The Graphics Network

Introducing C# and .Net

Layout and white space. Blocks, braces and semicolons. Classes, methods and the use of '.'. The Main method. Basic input and output. Compiling and running programs.

Using Variables

Variable types and sizes. Integer versus floating point. Local variables and scope. Declaring and initializing variables. Implicitly-typed variables. Operators. Pre and post increment operators. Strings and characters. Special characters and escape sequences. Verbatim and formatted literal strings.

Control Flow

if and else. The for loop. while and do while. The switch statement. Conditional expressions. Writing and calling methods. Passing arguments by value, ref and out. Returning values. Method overloading.

Exception Handling

How exception handling works. try...catch and throw. Handling multiple exception types. try...finally and 'using'. Deriving exception classes.

Input-output and networking

The stream architecture. Readers, writers and text. TCP/IP and sockets. Clients, servers and listeners. Supporting many clients.

Advanced Language Features

Lambda expressions. Multiple return values using tuples. Extension methods. Structs. Delegates. Anonymous methods and lambda expressions. Memory management and the workings of the garbage collector. Calling legacy and unmanaged code. Using unsafe code. Operator overloading and indexers.

Classes and objects

Data types and nullable types. Value and reference types. Implicit types. Classes, objects and the use of 'new'. Encapsulation. The heap and the stack. Strings and StringBuilders. Collections, generics and concurrency. Arrays, jagged arrays and Indexers. Namespaces, 'using' and assemblies. Attributes.

Inheritance

Inheritance and the use of 'virtual' and 'override'. Benefits of inheritance. Hiding and the other use of 'new'. Abstract classes. Constructors and initialization. Casting, 'as' and 'is'.

Interfaces

The benefits of interfaces. Interfaces vs classes. Defining and implementing an interface. Common interfaces and the ubiquitous IEnumerable. Sorting and finding.

Threads and Processes

Creating processes. Using simple threads. Controlling and synchronizing threads. .Net and the operating system. Cross-thread calls and the user interface. Background workers. Using callbacks.

Tasks and the TPL

async and await. Parallel execution. Parallel For and ForEach. Tasks, threads and the thread pool. Controlling and synchronizing tasks. Promises and futures. .Net 4 synchronization mechanisms. Asynchronous methods in .Net.

Databases and ADO.Net

The ADO.Net architecture. Connections, Commands and Readers. Writing and retrieving data. Using parameters. Object relational modelling and using POCOs. Stored procedures and transactions. Designing and implementing multi-tier applications.

LINQ and Entity Framework

How LINQ works. Implicitly-typed variables and Lambda expressions. The LINQ syntaxes, query and method (fluent). Using LINQ with collections, databases and XML. Parallel LINQ (PLINQ).

Entity Framework

The Entity Framework Architecture. Code first and data (schema) first. Joins, relationships and navigation properties. EF and stored procedures. Making changes to the schema.

This outline covers WPF but I can also deliver training in other environments which use XAML.

Introduction to WPF

What WPF is for. XAML. The technologies. The tools. Patterns and Model-View-ViewModel (MVVM). WPF vs WinUI.

Designing a user interface with XAML

What XAML is. XAML details. Designing a window. Basic controls. Properties and attached properties. Panels and layouts. Code-behind and simple events.

Events and commands

The event architecture. Event bubbling and routed events. Tunnelling and preview events. Commands.

Containers and layouts

Panels. Canvas and absolute positioning. Wrap and Stack Panels. Margins, sizes and alignment. DockPanel. Grid and UniformGrid. Splitting and scrolling. Viewbox. Controls as containers.

WPF styles and controls

User controls. How WPF controls work. Drawing and presentation. Resources and resource dictionaries. Defining and using styles. Dynamic resources. Control templates. Triggers and animation.

Data binding

Connecting controls. Binding to objects. Binding modes. Syntax alternatives. Using data contexts. Events and updating. Property change notifications. Observable and binding collections. Data templates. Formatting. Using Prism and BindableBase.

Commands

'Built-in' commands. Binding to commands. Application defined commands. Using Prism and DelegateCommand. Using MVVM Light and RelayCommand.

Binding techniques

Data grids and column design. Items controls and lists. Enhancing data templates. Value converters. XAML namespaces and object creation. Binding multiple properties. Validation and error handling. Custom validation rules.

Model View View-Model (MVVM)

The architecture. Separating the View and the View Model. Creating the ViewModel from XAML. View first and View Model first. Views and data templates. Selection controls and enums. Dialogs. Using Multiple View/ViewModels. Building flexible user interfaces using user controls and regions. Application controllers and singletons.

LINQ and databases

Binding to data. Databases and POCOs. Using Entity Framework. Using LINQ in general programming. LINQ, binding and data. Hierarchy and relationships. Hierarchical data templates.

Using Windows Forms

Using Windows Forms from WPF. Using WPF from Windows Forms. Compatibility considerations. Integrating existing application code.

Graphics

Shapes and colours. Designing a visually interesting user interface. Creating graphics dynamically. Bitmaps and images.

Optional - Introducing the 3rd dimension

Coordinate systems and geometry. The ubiquitous triangle. Cameras and lighting. Models, meshes and materials. Building shapes. Practical examples.

Introduction

History and benefits of MVC. Models, Views and Controllers. Classic ASP and ASP.Net Web Forms. Comparing MVC 5 and .Net Core. Test driven development. Razor.

Getting Started With MVC

Creating a project. Project structure. Controllers and actions. Adding a view and using Razor. ViewBags. Adding a model. Strongly typed views.

Enhancing the Project

Using forms. Parameters. HTML helpers and tag helpers. Basic validation. Extending validation. JavaScript and jQuery. Error and exception handling. Partial and 'master' views. Routing and attributes.

Models and Data

Using attributes. Interacting with databases. Using Entity Framework. Schema first and code first. LINQ. Scaffolding. Keys and navigation. Session state and other options.

Razor Pages (Core)

How razor pages work. Page Models and code-behind. Forms, OnGet and OnPost. Routing to razor pages. Razor pages and MVC together.

Blazor (Core)

Blazor and razor. Client side vs server side. WebAssembly. Single Page Applications. Client-server together.

Partial Views and View Components

How partial views differ. Using partial views. View component options. Creating and including a view component.

AJAX (MVC5)

How AJAX works. JSON - JavaScript Object Notation. Using AJAX with jQuery. AJAX helpers and tags. Asynchronous requests. Putting together an interactive application.

Membership and Security

The ASP.Net membership model. Built-in and external databases. Security options.

Test Driven Development

How an MVC model enhances testability. A test project. Writing and running tests.

The Web API

What the Web API is for. HTTP and verbs. The ApiController. Tasks and asynchronicity. Returning data and errors.

Getting Started

Building a graphical user interface. Event handling. Control types and dialogs. Validation. Dynamic control creation. User interface methodologies. Holding objects in lists. Graphics and drawing.

UI Inheritance

Form and control inheritance. Custom controls. Distributing controls.

Forms and Databases

DataSets and adapters. Typed DataSets. DataSource controls. Data-aware controls and grids. Separating the data layer.