The Graphics Network

Course Outline - C# and .Net

01285 713297 info@tgn.co.uk

I have modules on the C# language and its use in web applications (ASP.Net, MVC and Core), desktop XAML applications (WPF, WinUI and Uno) and Windows Forms) as well as object orientation, databases and multitasking. These can be given individually or in combination, and a popular choice is to split a 5 day course into separate weeks, for example 2 days on the basic language and OO followed by 3 days on using C# for web development.

The C# Language

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.
Advanced Language Features
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. The Marshal and IntPtr types. Operator overloading and indexers.
The Dynamic Language Runtime
Supporting dynamic languages. The dynamic keyword. Comparing dynamic and object. ExpandoObject. DynamicObject. Office support.

Object Orientation

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.

Multitasking

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

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.

XAML - WPF, WinUI and Uno

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.
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.

Web Development

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.

Windows Forms

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.