.NET Course

Course description

This fast-paced five-day course covers application development for the .NET framework.

Web and desktop applications are assembled, using Entity Framework Core to implement the data layer with ASP.NET Core MVC, Web API, React and WPF MVVM for the presentation layers. Other topics include the collections classes, SQL, LINQ, test driven development, dependency injection, concurrent programming and design patterns. View Course Outline or view a 3 minute video

We have been training Developers Since 1999. Call us today to discuss how we can train your staff to build and maintain .NET applications.

Telephone 0118 966 4994 or email mailbox@javaconsult.co.uk

Customised Training

We can provide customised training at your offices. To configure a custom course, click the "Select" button for modules in the course outline or start by adding all modules and then remove any not required.

Scheduled Dates

12 - 16 October, £1600 +VAT

Venue
Course hours are 9:00 to 5:00 at serviced offices in Reading.

To enable social distancing, the seats next to you will be unoccupied and there will be a maximum of four attendees. The course will therefore be more tutorial than lecture, encouraging discussion and questions.

View map
Related courses

Our Introduction to .NET Programming course is intended for developers who are new to programming.

What you will learn
Course instructor

Originally a Civil Engineer with a BSc from London University the course instructor, Simon Dineen, has 20 years' experience in .NET training and development.

Feedback

  • Absolutely excellent, fast-paced but that’s what I was hoping for. Good selection of topics.

  • Trainer was approachable and very knowledgeable. I appreciated the time and patience given to me as I was the slowest on the course.

  • I enjoyed the fast pace of the course. It’s given me the concepts which I now need to improve through practice.

  • Really enjoyable. Would recommend. Thanks

  • Fantastic introduction; so much information covered in one week.

  • It was highly intensive but easy to follow

  • Just wanted to say thanks for the course last week. I got a huge amount out of it. I really liked the way you built up the different components/apps over the week.

More feedback
Course outline

1. Programming in C#

Review of C# fundamentals. This is intended as a recap for developers who are already familiar with object-oriented programming but may not be up to date with best practices and new additions to the language.
  • Overview of the .NET Core Framework including the CLR, CTS and CLS
  • Syntax including data types, operators and statements
  • Class design including UML, encapsulation, expression-bodied members, auto-implemented properties, overloaded constructors, inheritance and overriding, abstract classes, structs
  • Handling and throwing exceptions; recursive methods
  • Passing parameters by reference with the in, out and ref keywords
  • Unit testing with xUnit, including parameterised tests and substituting dependencies for mock objects with the Moq library.
2 units

2. Collections

Comparing classes and interfaces in the collections framework
  • The collections interface hierarchy with IList and IDictionary implementations. Polymorphism and numeric formatting.
  • Using FIFO and LIFO collections including Stack, Queue and LinkedList
  • ISet implementations including HashSet and SortedSet. Overriding Equals and GetHashCode, implementing IComparer
  • Relative speeds of collection methods and Big O notation
  • Writing a generic class that implements ICollection<T>, using the Array class. Using the yield keyword to get an Enumerator
1 unit

3. LINQ

Using Language-Integrated Query to interrogate collections
  • Using LINQ Query syntax
  • Understanding LINQ method syntax, including extension methods, generic delegates, lambda expressions, covariance and contravariance
  • Filtering, selecting and aggregation operations
  • Building a repository class, using a HashSet persisted to a file with JsonSerializer. Unit testing the repository with XUnit and Moq.
1 unit

4. SQL

Communicating with a SQL Server database
  • Transact-SQL types. Creating tables, insert, update, delete and select statements. Primary and foreign keys, table joins
  • Getting a connection, IDisposable types and using statements. Transactions; pessimistic and optimistic concurrency control
  • Building repository classes and writing integration tests
1 unit

5. Entity Framework

Object-relational mapping with Entity Framework Core
  • Configuring a DbContext, data seeding. Test-driven development
  • Entity classes, generated values, foreign key properties, data annotations, optimistic concurrency control
  • Managing database schemas, using migrations to sync the data model with the database; reverse engineering
  • Querying with LINQ, eager and lazy loading of related data
  • Saving data; entity state; adding, modifying and removing tracked entities
  • Asynchronous methods, the Task class, using the await keyword, starting a background thread with Task.Run
  • Building a Service Layer for separation of business logic (services) and data-access logic (repositories)
2 units

6. Web API

Creating RESTful services with ASP.NET Core
  • Controller classes; HTTP methods and status codes; route mapping and constraints
  • Configuring dependency injection; CORS; debugging with Postman
  • Unit testing the controller with xUnit and Moq
  • Generating a SHA256 hashed password
  • Claims-based authentication, symmetric encryption, generating a JSON Web Token (JWT), authenticating the JWT on the server
  • Writing controller methods that call the service layer, including the JWT in the HTTP header
  • Creating a release build and deploying the service
3 units

7. React

A JavaScript library for building user interfaces
  • Understanding toolchains, packages and modules. Using Visual Studio Code with Node Package Manager to create a single page app
  • Javascript syntax review including data types, operators, variable declaration and scope, control structures, objects, constructors, arrays, inline and arrow functions
  • JSX. Components and props. Handling events
  • State and lifecycle with state and effect hooks; the virtual DOM; debugging with React developer tools
  • Conditional rendering, extracting components into a hierarchy, lifting shared state; HTML forms and controlled components
  • Generating HTML lists and tables; array functions including map and filter; for loops
  • Connecting to a REST service; promise objects and async functions
  • Authentication; obtaining a JSON Web Token and including the token in HTTP requests
  • Creating a production build and deploying the application
4 units

8. ASP.NET Core MVC

A cross-platform open-source framework for building cloud-based applications
  • Using the MVC design pattern to decouple the user-interface, data and application logic
  • Controllers, views and Razor syntax. HTTP methods and status codes
  • Configuring dependency injection and routing
  • Scaffolding views; tag helpers; layout pages; Bootstrap
  • Razor pages and model binding
  • Claims-based authentication with ASP.NET Core Identity. Scaffolding Register and Login pages
  • Writing controller methods that call the service layer. Data annotations and model state. client-side validation with jQuery. Preventing CSRF attacks
  • Unit testing the controller with xUnit and Moq
  • Creating a release build and deploying the application
3 units

9. WPF

Windows Presentation Foundation is a framework for building desktop applications on Windows
  • XAML controls and layout panels; delegates and events; styles and resources
  • Data binding; dependency properties; type converters; the DataGrid control
  • Using the Model-View-ViewModel (MVVM) pattern to separate presentation and business logic from the user interface. Configuring dependency injection
  • Calling the Web API asynchronously; serializing and deserializing JSON
  • Binding control properties to the ViewModel and sending PropertyChanged events
  • Authentication; obtaining a JSON Web Token and including the token in HTTP requests to the Web API
  • Unit testing the controller with xUnit and Moq
2 units

10. Design Principles and patterns

Design principles are intended to make software more understandable, flexible and maintainable. Design patterns are reusable solutions to commonly occurring problems. The following are discussed in the context of the applications built in the previous modules
  • SOLID principles (Single responsibility principle; open-closed, Liskov Substitution Principle; Interface Segregation principle; Dependency inversion)
  • Don't repeat yourself; encapsulate what changes; favour composition over inheritance; program to an interface, not to an implementation
  • Creational design patterns: abstract factory; builder; factory method; singleton
  • Structural design patterns: adapter, decorator, façade
  • Behavioural design patterns: observer; strategy; template method
1 unit