Superwebdesign Software Trainers are Microsoft Certified Application Specialists
Superwebdesign Software Trainers are Adobe Certified Experts
nl | en

Cours en programmation C#

Cours en programmation C# en Français, Anglais et Néerlandais

 

Crash Course C# (3 jours)

Le cours est basé sur C# 5.0 .Net 4.5 avec Visual Studio 2012.

Résumé.
L'objectif est de fournir les compétences de base en 2 jours. Si tel est le cas, les compétences avancées seront abordées durant le troisième jour. Sinon, le troisième jour servira à finaliser les objectifs de base.

Programmation de base :

DAY 1:
1. The Philisophy of .NET
2. Building C# Applications
3. Core C# Programming Construct, Part 1
4. Core C# Programming Construct, Part 2
5. Understanding Encapsulation
6. Understanding Inheritance and Polymorphism
7. Understanding Structured Exception Handling

DAY 2:
8. Working with Interfaces
9. Collection and Generics
10. Delegates, Events, and Lambda Expression
11. Advanced C# Language Features
12. LINQ to Object
13. File I/O and Object Serialization

Programmation avancée :

DAY 3:
14. Introduction LINQ to XML
15. ADO.NET, a survey
16. Building and Configuring Class Libraries
17. Multithreaded, Parallel, and Async Programming

Détail du cours

1. The Philosophy of .NET
1.1. An Initial Look at the .NET Platform
1.2. Introducing the building blocks of the .NET Platform (the CLR, CTS and CLS)
1.3. Additional .NET-Aware Programming Languages
1.4. An overview of .NET assemblies
1.5. Understanding the Common Type System
1.6. Understanding the Common Language Specification
1.7. Understanding the Common Language Specification
1.8. The Assembly/Namespace/Type Distinction
1.9. Exploring an Assembly using ildasm.exe
1.10. The Platform-Independent nature of .NET
1.11. A brief word regarding Windows 8 applications

2. Building C# Applications
2.1. The role of the .NET Framework 4.5 SDK
2.2. Building C# applications using csc.exe
2.3. Building .NET applications using Notepad++
2.4. Building .NET applications ussing SharpDevelop
2.5. Building .NET applications using Visual C# Expres
2.6. Building .NET applications using Visual Studio

3. Core C# Programming Construct, Part I.
3.1. The anatomy of a simple C# program
3.2. An interesting aside : some additional members of the System.Environment Class
3.3. The System.Console Class
3.4. System data types and corresponding C# keywords
3.5. Working with String data
3.6. Narrowing and widening data type conversions
3.7. Understanding implicitly typed local variables
3.8. C# iteration constructs
3.9. Decision constructs and the relational/equality operators

4. Core C# Programming Constructs, Part II.
4.1. Methods and Parameter Modifiers
4.2. Understanding C# arrays
4.3. Understanding the enum type
4.4. Understanding the structure type
4.5. Understanding value types and reference types
4.6. Understanding C# Nullable types

5. Understanding Encapsulation
5.1. Introducing the C# Class type
5.2. Understanding constructors
5.3. The role of « this » keyword
5.4. Understanding the « static » keyword
5.5. Defining the pillars of OOP
5.6. C# access modifiers
5.7. The first pillar : C#'s encapsulation services
5.8. Understanding automatic properties
5.9. Understanding object initialization syntax
5.10. Working with constant field data
5.11. Understanding partial types

6. Understanding Inheritance and Polymorphism
6.1. The basic mechanics of inheritance
6.2. Revising Visual Studio Class diagrams
6.3. The second pillar of OOP : the details of inheritance
6.4. Programming for Containment/Delegation
6.5. The third pillar of OOP : C#'s polymorphic support
6.6. Understanding base Class/derived Class casting rules
6.7. The master parent Class : System.Object

7. Understanding Structure Exception Handling
7.1. The role of .Net exception handling
7.2. The simplest possible example
7.3. Configuring the state of an exception
7.4. System-Level exceptions
7.5. Application-Level exceptions
7.6. Processing multiple exceptions
7.7. Who is throwing what ?
7.8. The result of unhandled exceptions
7.9. Debugging unhandled exception using visual studio

8. Working with Interfaces
8.1. Understanding Interfaces types
8.2. Defining custom Interfaces
8.3. Implementing an Interface
8.4. Invoking Interface members at the Object level
8.5. Interfaces as parameters
8.6. Interfaces as return values
8.7. Arrays of Interface types
8.8. Implementing Interfaces using Visual Studio
8.9. Explicit Interface hierarchies
8.10. The IEnumerable and IEnumerator Interface
8.11. The ICloneable Interface
8.12. The IComparable Interface

9. Collections and Generics
9.1. The motivation for Collection classes
9.2. The problems of nongeneric Collections
9.3. The role of Generic type parameters
9.4. The System.Collections.Generic namespace
9.5. The System.Collections.ObjectModel namespace
9.6. Creating custom Generic methods

10. Delegates, Events, and Lambda Expressions
10.1. Understanding the .NET Delegate type
10.2. The simplest possible Delegate example
10.3. Sending object state notifications using Delegates
10.4. Understanding Generic Delegates
10.5. Understanding C# Events
10.6. Understanding C# Anonymous methods
10.7. Understanding Lambda expression

11. Advanced C# Language Features
11.1. Understanding Indexer methods
11.2. Understanding Operator overloading
11.3. Understanding custom type conversions
11.4. Understanding extension methods
11.5. Understanding anonymous types
11.6. Working with pointer types

12. LINQ to Objects
12.1. LINQ-Specific programming constructs
12.2. Understanding the role of LINQ
12.3. Applying LINQ queries to primitive arrays
12.4. Returning the result of a LINQ query
12.5. Applying LINQ queries to Collection Objects
12.6. Investigating the C# LINQ query operators
12.7. The internal representation of LINQ query statements

13. File I/O and Object Serialization
13.1. Exploring the System.IO Namespace
13.2. The Directory(Info) and File(Info) types
13.3. Working with the DirectoryInfo type
13.4. Working with the Directory type
13.5. Working with the DriveInfo Class
13.6. Working with the FileInfo Class
13.7. Working with the File Type
13.8. The abstract stream class
13.9. Working with StreamWriters and StreamReaders
13.10. Working with StringWriters and StringReaders
13.11. Working with BinaryWriters and BinaryReaders
13.12. Watching files programmatically
13.13. Understanding Object serialization
13.14. Configuring Object serialization
13.15. Choosing a Serialization Formatter
13.16. Serializing Objects using the BinaryFormatter
13.17. Serializing Objects using the SoapFormatter
13.18. Serializing Objects using the XmlSerializer
13.19. Serializing Collections of Objects
13.20. Customizing the Soap/Binary serialization process

14. Introduction LINQ to XML
14.1. A tale of two XML APIs
14.2. Members of the System.Xml.Linq Namespace
14.3. Working with XElement and EDocument
14.4. Manipulating an In-Memory XML Document
14.5. Converting an CSV to an XML
14.6. XDR Schemas
14.7. XSD Schemas
14.8. Selecting Nodes
14.9. Xpath

15. ADO.NET, a survey.
15.1. TO BE DONE

16. Building and Configuring Class Librairies
16.1. Defining custom Namespaces
16.2. The role of .NET Assemblies
16.3. Understanding the format of a .NET Assembly
16.4. Building and Consuming Custom Class Library
16.5. Understanding private Assemblies
16.6. Understanding shared Assemblies
16.7. Consuming a shared Assembly
16.8. Configuring shared Assemblies
16.9. Understanding publisher policy Assemblies
16.10. Understanding the <codeBase> element
16.11. The System.Configuration namespace
16.12. The configuration file schema documentation

17. Multithreaded, Parallel, and Async Programming
17.1. The Process/AppDomain/Context/Thread relationship
17.2. A brief review of the .NET Delegate
17.3. The Asynchronous nature of Delegates
17.4. Invoking a method asynchronously
17.5. The System.Threading namespace
17.6. The System.Threading.Thread Class
17.7. Manually creating secondary threads
17.8. The issue of concurrency
17.9. Programming with Timer callbacks
17.10. Understanding the CLR ThreadPool
17.11. Parallel programming using the Task Parallel Library
17.12. Parallel LINQ queries (PLINQ)
17.13. Asynchronous calls under .NET 4.5

 

C# 5.0 - Basic to Advanced programmation (5 jours)

Summary.
In five days, you will learn in details the bases and advanced features of C# programming & .NET framework for backoffice applications : types, OO, generics, file, XML, LINQ, ADO, threads,
Microsoft Communication Foundation and Microsoft Workflow Foundation. Content and duration can be adapted to fit your request, for exemple, a cursus of 2 days focusing on C# syntaxe & LINQ.

Prerequises :
Experience of 2 years in OO programming language.
The course can be adapted for beginners or programmers who have already an experience in C#.
Student should have installed Visual Studio, version 2010 and .NET 4.5 minimim , Visual Studio Express is enough.

Organisation

DAY 1 :
Chapter 1: The Philosophy of .NET3
Chapter 2: Building C# Applications
Chapter 3: Core C# Programming Constructs, Part I
Chapter 4: Core C# Programming Constructs, Part II
Chapter 5: Understanding Encapsulation

DAY 2 :
Chapter 6: Understanding Inheritance and Polymorphism
Chapter 7: Understanding Structured Exception Handling
Chapter 8: Working with Interfaces
Chapter 9: Collections and Generics
Chapter 10: Delegates, Events, and Lambda Expressions

DAY 3 :
Chapter 11: Advanced C# Language Features
Chapter 12: LINQ to Objects
Chapter 13: Understanding Object Lifetime
Chapter 14: Building and Configuring Class Libraries
Chapter 15: Type Reflection, Late Binding, and Attribute-Based Programming
Chapter 16: Dynamic Types and the Dynamic Language Runtime

DAY 4 :
Chapter 17: Processes, AppDomains, and Object Contexts
Chapter 18: Understanding CIL and the Role of Dynamic Assemblies
Chapter 19: Multithreaded, Parallel, and Async Programming
Chapter 20: File I/O and Object Serialization
Chapter 21: ADO.NET Part I: The Connected Layer

DAY 5 :
Chapter 22: ADO.NET Part II: The Disconnected Layer
Chapter 23: ADO.NET Part III: The Entity Framework
Chapter 24: Introducing LINQ to XML
Chapter 25: Introducing Windows Communication Foundation
Chapter 26: Introducing Windows Workflow Foundation

Content.

1. The Philosophy of .NET
1.1. An Initial Look at the .NET Platform
1.2. Introducing the building blocks of the .NET Platform (the CLR, CTS and CLS)
1.3. Additional .NET-Aware Programming Languages
1.4. An overview of .NET assemblies
1.5. Understanding the Common Type System
1.6. Understanding the Common Language Specification
1.7. Understanding the Common Language Specification
1.8. The Assembly/Namespace/Type Distinction
1.9. Exploring an Assembly using ildasm.exe
1.10. The Platform-Independent nature of .NET
1.11. A brief word regarding Windows 8 applications

2. Building C# Applications
2.1. The role of the .NET Framework 4.5 SDK
2.2. Building C# applications using csc.exe
2.3. Building .NET applications using Notepad++
2.4. Building .NET applications ussing SharpDevelop
2.5. Building .NET applications using Visual C# Expres
2.6. Building .NET applications using Visual Studio

3. Core C# Programming Construct, Part I.
3.1. The anatomy of a simple C# program
3.2. An interesting aside : some additional members of the System.Environment Class
3.3. The System.Console Class
3.4. System data types and corresponding C# keywords
3.5. Working with String data
3.6. Narrowing and widening data type conversions
3.7. Understanding implicitly typed local variables
3.8. C# iteration constructs
3.9. Decision constructs and the relational/equality operators

4. Core C# Programming Constructs, Part II.
4.1. Methods and Parameter Modifiers
4.2. Understanding C# arrays
4.3. Understanding the enum type
4.4. Understanding the structure type
4.5. Understanding value types and reference types
4.6. Understanding C# Nullable types

5. Understanding Encapsulation
5.1. Introducing the C# Class type
5.2. Understanding constructors
5.3. The role of « this » keyword
5.4. Understanding the « static » keyword
5.5. Defining the pillars of OOP
5.6. C# access modifiers
5.7. The first pillar : C#'s encapsulation services
5.8. Understanding automatic properties
5.9. Understanding object initialization syntax
5.10. Working with constant field data
5.11. Understanding partial types

6. Understanding Inheritance and Polymorphism
6.1. The basic mechanics of inheritance
6.2. Revising Visual Studio Class diagrams
6.3. The second pillar of OOP : the details of inheritance
6.4. Programming for Containment/Delegation
6.5. The third pillar of OOP : C#'s polymorphic support
6.6. Understanding base Class/derived Class casting rules
6.7. The master parent Class : System.Object

7. Understanding Structure Exception Handling
7.1. The role of .Net exception handling
7.2. The simplest possible example
7.3. Configuring the state of an exception
7.4. System-Level exceptions
7.5. Application-Level exceptions
7.6. Processing multiple exceptions
7.7. Who is throwing what ?
7.8. The result of unhandled exceptions
7.9. Debugging unhandled exception using visual studio

8. Working with Interfaces
8.1. Understanding Interfaces types
8.2. Defining custom Interfaces
8.3. Implementing an Interface
8.4. Invoking Interface members at the Object level
8.5. Interfaces as parameters
8.6. Interfaces as return values
8.7. Arrays of Interface types
8.8. Implementing Interfaces using Visual Studio
8.9. Explicit Interface hierarchies
8.10. The IEnumerable and IEnumerator Interface
8.11. The ICloneable Interface
8.12. The IComparable Interface

9. Collections and Generics
9.1. The motivation for Collection classes
9.2. The problems of nongeneric Collections
9.3. The role of Generic type parameters
9.4. The System.Collections.Generic namespace
9.5. The System.Collections.ObjectModel namespace
9.6. Creating custom Generic methods

10. Delegates, Events, and Lambda Expressions
10.1. Understanding the .NET Delegate type
10.2. The simplest possible Delegate example
10.3. Sending object state notifications using Delegates
10.4. Understanding Generic Delegates
10.5. Understanding C# Events
10.6. Understanding C# Anonymous methods
10.7. Understanding Lambda expression

11. Advanced C# Language Features
11.1. Understanding Indexer methods
11.2. Understanding Operator overloading
11.3. Understanding custom type conversions
11.4. Understanding extension methods
11.5. Understanding anonymous types
11.6. Working with pointer types

12. LINQ to Objects
12.1. LINQ-Specific programming constructs
12.2. Understanding the role of LINQ
12.3. Applying LINQ queries to primitive arrays
12.4. Returning the result of a LINQ query
12.5. Applying LINQ queries to Collection Objects
12.6. Investigating the C# LINQ query operators
12.7. The internal representation of LINQ query statements

13. Understanding Object Lifetime
13.1. Classes, Objects, and References
13.2. The Basics of Object Lifetime
13.3. The Role of Application Roots
13.4. Understanding Object Generations
13.5. Concurrent Garbage Collection Under .NET 1.0-3.5
13.6. Background Garbage Collection Under .NET 4.0 and Greater
13.7. The System.GC Type
13.8. Building Finalizable Objects
13.9. Building Disposable Objects
13.10. Building Finalizable and Disposible Types
13.11. Understanding Lazy Object Instantiation

14. Building and Configuring Class Librairies
14.1. Defining custom Namespaces
14.2. The role of .NET Assemblies
14.3. Understanding the format of a .NET Assembly
14.4. Building and Consuming Custom Class Library
14.5. Understanding private Assemblies
14.6. Understanding shared Assemblies
14.7. Consuming a shared Assembly
14.8. Configuring shared Assemblies
14.9. Understanding publisher policy Assemblies
14.10. Understanding the <codeBase> element
14.11. The System.Configuration namespace
14.12. The configuration file schema documentation

15. Type Reflection, Late Binding, and Attribute-Based Programming
15.1. The Necessity of Type Metadata
15.2. Understanding Reflection
15.3. Building Custom Metadata Viewer
15.4. Dynamically Loading Assemblies
15.5. Reflectinf on Shared Assemblies
15.6. Understanding Late Binding
15.7. Understanding the Role of .NET Attributes
15.8. Building Custome Attributes
15.9. Assembly-Level Attributes
15.10. Reflecting on Attributes Using Early Binding
15.11. Reflecting on Attributes Using Late Binding
15.12. Putting Reflection, Late Binding, and Custom Attributes in Perspective
15.13. Buiding Extendable Application

16. Dynamic Types and the Dynamic Language Runtime
16.1. The Role of the C# dynamic Keyword
16.2. The Role of the Dynamic Language Runtime
16.3. Simplifiying Late-Bound Calls Using Dynamic Types
16.4. Symplifiying COM interoperability Using Dynamic Data
16.5. COM interop Using C# Dynamic Data

17. Processes, AppDomains, and Object Contexts
17.1. The Role of a Windows Process
17.2. Interacting with Processes Under the .NET Platform
17.3. Understanding .NET Application Domains
17.4. Interacting with the Default Application Domain
17.5. Creating New Application Domains
17.6. Understanding Object Context Boundaries
17.7. Summarizing Processes, AppDomains, and Context

18. Understanding CIL and the Role of Dynamic Assemblies
18.1. Reasons for Learning the Grammar of CIL
18.2. Examining CIL Directives, Attributes, and Opcodes
18.3. Pushing and Popping : The Stack-Based Nature of CIL
18.4. Understanding Round-Trip Engineering
18.5. Understanding CIL Directives and Attributes
18.6. .NET Base Class Library, C#, and CIL Data Type Mappings
18.7. Defining Type Members in CIL
18.8. Examining CIL Opcodes
18.9. Building a .NET Assembly with CIL
18.10. Understanding Dynamic Assemblies

19. Multithreaded, Parallel, and Async Programming
19.1. The Process/AppDomain/Context/Thread relationship
19.2. A brief review of the .NET Delegate
19.3. The Asynchronous nature of Delegates
19.4. Invoking a method asynchronously
19.5. The System.Threading namespace
19.6. The System.Threading.Thread Class
19.7. Manually creating secondary threads
19.8. The issue of concurrency
19.9. Programming with Timer callbacks
19.10. Understanding the CLR ThreadPool
19.11. Parallel programming using the Task Parallel Library
19.12. Parallel LINQ queries (PLINQ)
19.13. Asynchronous calls under .NET 4.5

20. File I/O and Object Serialization
20.1. Exploring the System.IO Namespace
20.2. The Directory(Info) and File(Info) types
20.3. Working with the DirectoryInfo type
20.4. Working with the Directory type
20.5. Working with the DriveInfo Class
20.6. Working with the FileInfo Class
20.7. Working with the File Type
20.8. The abstract stream class
20.9. Working with StreamWriters and StreamReaders
20.10. Working with StringWriters and StringReaders
20.11. Working with BinaryWriters and BinaryReaders
20.12. Watching files programmatically
20.13. Understanding Object serialization
20.14. Configuring Object serialization
20.15. Choosing a Serialization Formatter
20.16. Serializing Objects using the BinaryFormatter
20.17. Serializing Objects using the SoapFormatter
20.18. Serializing Objects using the XmlSerializer
20.19. Serializing Collections of Objects
20.20. Customizing the Soap/Binary serialization process

21. ADO.NET Part I : The Connected Layer
21.1. A High-Level Definition of ADO.NET
21.2. Understanding ADO.NET Data Providers
21.3. Additional ADO.NET Namespaces
21.4. Abstracting Data Providers Using Interfaces
21.5. Creating the AutoLot Database
21.6. The ADO.NET Data Provider Factory Model
21.7. Understanding the Connected Layer of ADO.NET
21.8. Working with Data Readers
21.9. Building a Reusable Data Access Library
21.10. Creating a Console UI-Based Front End
21.11. Understanding Database Transactions

22. ADO.NET Part II : The Disconnected Layer
22.1. Understanding the Disconnected Layer of ADO.NET
22.2. Understanding the Role of the DataSet
22.3. Working with DataColumns
22.4. Working with DataRows
22.5. Working with DataTables
22.6. Binding DataTable Objects to Windows Form GUIs
22.7. Working with Data Adaptaers
22.8. Adding Disconnection Functionality
22.9. Multitabled DataSet Objects and Data Relationships
22.10. The Windows Forms Database Designer Tools
22.11. Isolating Strongly Typed Database Code into a Class Library
22.12. Programming with LINQ to DataSet

23. ADO.NET Part III : The Entity Framework
23.1. Understanding the Role of Entity Framework
23.2. Buiding and Analyzing Your First EDM
23.3. Programming Against the Conceptual Model
23.4. Data Binding Entities to Windows Forms GUIs
23.5. Going Forward with .NET Data-Access APIs

24. Introduction LINQ to XML
24.1. A tale of two XML APIs
24.2. Members of the System.Xml.Linq Namespace
24.3. Working with XElement and EDocument
24.4. Manipulating an In-Memory XML Document

25. Introduction Windows Communication Foundation
25.1. A Potpourri of Distributed Computing APIs
25.2. The Role of WCF
25.3. Investigating the Core WCF Assemblies
25.4. The Visual Studio WCF Project Templates
25.5. The Basic Composition of a WCF Application
25.6. The ABCs of WCF
25.7. Buiding a WCF Service
25.8. Hosting the WCF Service
25.9. Building the WCF Client Application
25.10. Simplifiying Configuration Settings
25.11. Using the WCF Service Library Project Template
25.12. Hosting the WCF Service Within a Windows Service
25.13. Invoking a Service Asynchronously from the Client
25.14. Designing WCF Data Contracts

26. Introduction Windows Workflow Foundation
26.1. Defining a Business Process
26.2. Buidling a Simple Workflow
26.3. The Workflow Runtime
26.4. Examining the Workflow Activities
26.5. Building a Flowchart Workflow
26.6. Building a Sequence Workflow
26.7. Consuming the Workflow Library

 

Testing with Visual Studio 2010 (3 jours)

Summary.
A three day advanced course on testing with Visual Studio. It can be customised and duration can be reduced to a one day training centered to your needs.

Prerequises :
Experience of 2 years with C#.
Local network with Team Foundation Server.

Organisation

DAY 1 :
1. Visual Studio 2010 Test Types
2. Test Plan, Test Suite, and Manual Testing
3. Automated Tests
4. Unit Testing

DAY 2 :
5. Web Performance Test editor
6. Advanced Web Testing
7. Load Testing
8. Ordered and Generic Tests

DAY 3 :
9. Managing and Configuring a Test
10. Command Line
11. Working with Test Results
12. Reporting
13. Test and Lab Center

Content.
1. Visual Studio 2010 Test Types
1.1. Software testing in Visual Studio 2010
1.2. Testing as part of the Software Development Life Cycle
1.3. Types of testing
1.4. Test management in VS 2010
1.5. Microsoft Test Manager

2. Test Plan, Test Suite, and Manual Testing
2.1. Test Plan
2.2. Test Suite and Test Suite Types
2.3. Run Manual Tests
2.4. Shared steps and action recording for shared steps

3. Automated Tests
3.1. Coded UI Test from Action Recording

4. Unit Testing
4.1. Creating Unit Tests
4.2. Assert Statements
4.3. Unit Tests and generics
4.4. Data-driven unit testing
4.5. Unit testing an ASP.NET application
4.6. Unit testing web services
4.7. Code coverage unit test

5. Web Performance Testing
5.1. Creating Web Performance Test
5.2. Recording a test
5.3. Web Performance Test editor
5.4. Debug/Running Web Performance Test

6. Advanced Web Testing
6.1. Dynamic parameters in Web Performance Testing
6.2. Coded Web Performance Test
6.3. Debugging the Coded Web Performance Test
6.4. Custom rules

7. Load Testing
7.1. Creating Load Test

8. Ordered and Generic Tests
8.1. Ordered Tests
8.2. Generic Tests

9. Managing and Configuring a Test
9.1. Managing Tests using Test Lists
9.2. Configuring Tests

10. Command Line
10.1. MSTest utility
10.2. Running a test from the command line
10.3. Publishing test results
10.4. Trace files
10.5. Publishing

11. Working with Test Results
11.1. Tests Results

12. Reporting
12.1. Team Foundation Server reports for Testing
12.2. SQL Server Business Intelligence Project

13. Test and Lab Center
13.1. Connect to Team Project
13.2. Testing Center
13.3. Lab Center

 

 

C# unit testing with NUnit (2 jours)

Summary.
This two day course will empowered you with tests, specially Unit Testing. The course is intended for C# developers who wants to improve the quality of their code and are ready to invest in Unit
Testing. They are right, unit testing has a very ROI.

Prerequises :
Experience of 2 years with C#.

Organisation

DAY 1 :
1. Introduction
2. Your First Unit Tests
3. Writing Tests in NUnit
4. What to Test : The Right-BICEP
5. Correct Boundary Conditions

DAY 2
6. Using Mock Objects
7. Properties of Good Tests
8. Testing on a Project
9. Design Issues
10. GUI Testing
11. Extending NUnit

Content.
1. Introduction
1.1. Coding with Confidence
1.2. What is Unit Testing ?
1.3. Why Should I Bother with Unit Testing
1.4. What Do I Want to Accomplish
1.5. How Do I Do Unit Testing ?
1.6. Excuses For Not Testing
1.7. Roadmap

2. Your First Unit Tests
2.1. Planning Tests
2.2. Testing a Simple Method
2.3. Running Tests with Nunit
2.4. Running the Example
2.5. More Tests

3. Writing Tests in NUnit
3.1. Writing Tests in Nunit
3.2. Classic Asserts
3.3. Constraint-based Asserts
3.4. NUnit Framework
3.5. NUnit Test Selection
3.6. More NUnit Asserts
3.7. NUnit Custom Asserts
3.8. NUnit and Exceptions
3.9. Temporarily Ignoring Tests

4. What to Test : The Right-BICEP
4.1. Are the Results Right ?
4.2. Boundary Conditions
4.3. Check Inverse Relationships
4.4. Cross-check Using Other Means
4.5. Force Error Conditions
4.6. Performance Characteristics

5. Correct Boundary Conditions
5.1. Conformance
5.2. Ordering
5.3. Range
5.4. Reference
5.5. Existence
5.6. Cardinality
5.7. Time
5.8. Try It Yourself

6. Using Mock Objects
6.1. Stubs
6.2. Fakes
6.3. Mock Objects
6.4. When Not To Mock

7. Properties of Good Tests
7.1. Automatic
7.2. Thorough
7.3. Repeatable
7.4. Independent
7.5. Professional
7.6. Testing the Tests

8. Testing on a Project
8.1. Where to Put Test Code
8.2. Where to Put Nunit
8.3. Test Courtesy
8.4. Test Frequency
8.5. Tests and Legacy Code
8.6. Tests and Code Reviews

9. Design Issues
9.1. Designing for Testability
9.2. Refactoring for Testing
9.3. Testing the Class Invariant
9.4. Test-Driven Design
9.5. Testing Invalid Parameters

10. GUI Testing
10.1. Unit testing WinForms
10.2. Unit testing beyond Windows Forms
10.3. Web UIs
10.4. Command Line UIs
10.5. GUI Testing Gotchas

11. Extenting Nunit
11.1. Writing NUnit Extensions
11.2. Using NUnit Core Addins

 

Continuous Integration in .NET (2 jours)

Summary.
A 2 day course to demonstrate the feasability of continuous integration by the exemple in .NET environment

Prerequises :
Experienced developpers of 2 years with .NET.

Organisation

DAY 1 :
1. Source Control
2. Automated Build
3. Unit testing

DAY 2 :
4. Integration, System, and Acceptance Testing
5. Documentation
6. Integration

Content.
1. Make It Happen
1.1. Understanding Continuous Integration
1.2. Setting up a Source Control System
1.3. Automating the Build Process
1.4. Choosing the Right CI Server
1.5. Continuous Feedback
1.6. Unit Testing Continuously Integrated Code

2. Extend It
2.1. Performing Integration, System, and Acceptance Testing
2.2. Analysing the Code
3. Smooth and Polish IT
3.1. Generating Documentation
3.2. Deployment and Delivery
3.3. Continuous Database Integration
3.4. Extending Continuous Integration

 

 

Toutes les formations en programmation:

Quelques clients: Cefora, IBM, Holcim, CBR, Total, Bpost, Cisco, Shape, Colruyt, Telelingua, Nestlé, CPAS Molenbeek, Fabricom, Club Med, OTAN, G4Securicor, Fonds de Participation, Roularta, Georg Fischer, SGC, STIB, Police Fédérale, KBC, Fortis, ING, Tetrapak, Starwood hotels, Royal Canin, GSK, ULB, Jetair, Belgacom, VRT, Banque National de Belgique, Hansgrohe, Regie des Batiments, General Electric, Hiscox, Prace, Toyota,...

Plus de Cours en programmation à Bruxelles

Formation en informatique Bruxelles

 

 

50% de réduction pour les indépendants et PME de la Region Bruxelles-Capitale

50% de réduction pour les indépendants
et PME par la Region Bruxelles-Capitale

 

Valid HTML 4.01 Transitional Valid CSS!