C# Training Course - Learn .NET

Who should attend

Our intro to C# .NET training course is aimed at anyone who needs to understand the fundamental principles of .NET programming with C#, in order to be able to then go on to develop commercial Windows, Web (ASP.NET Core MVC, Blazor), server-side or other Microsoft-based solutions. The course is well suited to experienced developers coming from backgrounds such as JavaScript, PHP, or Java.

Bring your own device (public scheduled .NET courses in London)

Our C# .NET training features lots of hands-on practical exercises using Visual Studio 2022 so to save time you can install it on your laptop before your course - it's easy to obtain and free to use. That means you can take away all the code you've worked on for further study or even to kick-start your next .NET project.

Prerequisites

Delegates should be comfortable with programming essentials, but no previous Object Oriented Programming experience is assumed (although some OOP experience would certainly be helpful).

Live, instructor-led online and on-site training

We appreciate that you need flexibility to fit in with new working situations - whether you're an individual, part of a distributed team, or simply have projects and deadlines to meet. 

Our remote training can take place online in a virtual classroom, with content split into modules to accommodate your scheduling challenges and meet your learning goals. Get in touch today to find out how we can help design a cost-effective, flexible training solution.

C# Development Environments

• Visual Studio
• Visual Studio Code

Executable Programs & ILDASM

• The .NET Framework
• .NET Core
• C#
• Assemblies

Variables & Data Types

• Data types
• Identifier names
• Keywords
• Initialisation
• Type Inference

Console Input & Output

Operators

• Assignment
• Arithmetic
• Increment / Decrement
• Relational
• Boolean
• Bitwise
• Ternary
• Conditional
• Operator precedence
• Type conversion

Complex data types

• Enums
• Bit flag Enums
• Arrays
• Tuples

C# statements

• Branching
• Jumping
• Looping

Object Oriented Programming

Reference & Value Types

• Nullable types
• Elvis operator
• Null coalescing operator
• Boxing & unboxing

Classes

• Declaration
• Access modifiers
• Data
• Methods
• Method parameters
• Objects
• Constructors
• Method overloading
• Properties
• Expression bodied members
• Local methods
• Static classes & members
• Indexers
• Deconstruct
• Partial types & methods

Structs & Records 

Inheritance

• Base & derived classes
• Constructors
• Code re-use
• Abstract classes
• Record inheritance
• Extension methods

Polymorphism

• Virtual methods
• Vtables & RTTI
• Abstract methods
• Sealed types

Collections

• Generic collections
• Concurrent collections
• Specialized collections
• Performance considerations

Interfaces

• Defining & implementing
• Default interface methods
• Interface inheritance
• .NET interfaces

Resource Management

• Finalizers
• Garbage Collection
• IDisposable
• The using statement

Files

• .NET I/O classes
• Streams
• Asynchronous I/O
• XML

Serialization

• Attributes
• JSON serialization
• Binary serialization
• XML serialization

Delegates

• Multicast delegates
• generic delegates
• Action<T>
• Predicate<T>
• Func<T>

Lambdas

• Expression & statement lambdas
• Parameters
• Return type
• Captures

Events

• Defining
• Raising
• Standard & custom events

Generics

• Methods
• Classes
• Constraints

LINQ

• Enabling features
• LINQ expression
• LINQ pattern
• Joins
• Aggregations

Optional Modules

These modules are available for custom / private / in-house training – as an additional workshop or for large training programmes (which may also incorporate coverage of further related / advanced topics). 

Operator Overloading (e.g.)

• Arithmetic
• Implicit & explicit conversion
• Boolean

WET, DRY & S.O.L.I.D.

• Good program design principles

Automated Testing

• Stubs
• Fakes
• Mocks
• Spies
• Test automation
• Xunit
• Microsoft test framework
• Data driven testing
• Parallel tests
• Test driven development
• Mocking frameworks

Databases

• ADO.NET
• Entity Framework 6,
• Entity Framework Core 7
• Entity Framework Core 8

GIT

• Source Management
• Collaborative Development

Frequently Asked Questions about .NET Programming and C#

1. What is C# and what is it used for in .NET programming?

C# is a modern, object-oriented programming language developed by Microsoft. It was first released in 2000 and since then has become one of the most popular programming languages. Like all .NET languages it uses the .NET framework which is a library of types and classes used by C# programmers for developing desktop applications, web applications, games, and mobile apps. C# code is fast and efficient, making it well-suited for building complex commercial applications.

Initially C# & .NET were intended just for Windows platform development. In 2016 there was a big upheaval in .NET & it can now be used to develop fast, scalable , cross platform, web and mobile applications.

2. What are the basic syntax and data types in C#?

Like most modern programming languages, C# uses variables to store values. For the most part, C# is a strongly typed language meaning that variables must be declared before they can be used using a data type and a name and can be assigned values using the assignment operator "=". For example, int num = 10;

Data types in C# include:

• Int & long: used for integers
• float & double : used for floating-point numbers
• decimal: used for high precision decimal numbers
• bool: used for boolean values (true or false)
• char: & string used for a single characters & strings

There are also thousands of more complex types defined in the .NET Framework such as containers (Array, List, Dictionary etc), delegate, events, buttons, textboxes and more.

C# has various operators including arithmetic operators (+, -, *, /, %), comparison operators (==, !=, <, >, <=, >=), logical operators (&&, ||, !), and assignment operators (=, +=, -=, *=, /=, %=) among others.

Control Structures: C# has various control structures including branching statements (if, switch) and loops (for, foreach, while, do-while)

Methods: Methods are functions used to group a set of statements together to perform a specific task. They are declared with a return type, a name, and optional parameters. 

For example, 

int sum(int a, int b) { return a + b; }

Classes: Classes are used to define objects in C#. They usually contain fields and methods and can be used to create instances of the class. For example, class MyClass { int num; void PrintNum() { Console.WriteLine(num); } }

These are some of the basic syntax and data types in C#, which provide a foundation for building more complex applications.

3. How can I create a new C# project in Visual Studio?

It depends on what version of Visual Studio you are using, however, the general process is as follows:

1. Open Visual Studio. You will be shown an initial start window with options for opening existing or creating new projects.
2. Click on "Create a new project" in the start window. If you already have a project open you can use the “File” > “New” > “Project” menu.
3. In the "Create a new project" window, choose a template for your project. There are templates for many types of project in various .NET languages. Typically you might, for example choose a C# Console App
4. You will then be asked to Configure your new project (name & location).
5. Finally, you will be asked which version of .NET you wish to use. The default is usually the latest version installed on your machine.
6. Click "Create" to create the project.

Once you have created a new C# project, Visual Studio will generate some default files and folders based on the project template you selected. For example, a console app will include a Program.cs file containing a default "Hello World" program, while a Windows Forms app will include a Form1.cs file containing a default blank form.

From here, you can start writing your C# code and building your application.

4. How do I use object-oriented programming concepts in C#?

Object-oriented programming is a key feature of C#. Here are some basic concepts of OOP that can be used in C#:

1. Classes and Objects: In C#, you can create classes to define objects that contain both data (fields) and methods. To create an instance of a class (object), you can use the "new" keyword followed by the name of the class. For example, MyClass obj = new MyClass();
2. Encapsulation: C# supports encapsulation, which allows you to hide the implementation details of a class from other code. This is done by marking fields and methods as public, private, or protected which helps to protect the integrity of the data by ensuring that it can only be accessed in a predictable way.
3. Abstraction: C# supports abstraction, which allows you to define interfaces that specify a set of methods that must be implemented by any class that implements the interface. This helps to decouple the implementation details of a class from the code that uses it, making the code more flexible and extensible.
4. Inheritance: C# supports single inheritance, which allows you to create a new class based on an existing class. The new class (the subclass) inherits the data and methods of the existing class (the superclass). You can use the "class" keyword followed by the name of the subclass, followed by a colon and the name of the superclass. For example, class MySubclass : MyBaseClass { }
5. Polymorphism: C# supports polymorphism, which allows you to create methods with the same name in different classes. These methods can have different implementations, but they all share the same name. This allows you to write code that can work with different types of objects in a flexible and extensible way.

By correctly using these concepts, you can create complex and flexible applications that are easier to understand, maintain, and extend over time.

5. What are the differences between value types and reference types in C#?

In C#, there are three categories of data types: value types, reference type and pointer types. Pointers are considered unsafe and can only be used in an unsafe context. Here are the differences between the first two:

1. Value Types: Value types are data types that hold the actual value of the data they represent. When a value type variable is assigned to another variable, the value is copied from one variable to the other. The original value is not affected by any changes made to the copy. Examples of value types include integers, floating-point numbers, characters, and boolean values.
2. Reference Types: Reference types are data types that store a reference to the memory location where the data is stored. This is not the same as an unsafe pointer. When a reference type variable is assigned to another variable, both variables refer to the same object in memory. Any changes made to the object through one variable are reflected in the other variable as well. Examples of reference types include classes, arrays, and delegates.

Here are some key differences between value types and reference types in C#:

• Value types are stored on the stack, while reference types are stored on the heap.
• Value types are allocated and deallocated automatically, while reference types are allocated on the heap and their memory is deallocated using automatic garbage collection.
• Value types have a default value (e.g. 0 for integers, false for boolean), while reference types have a default value of null.

Understanding the differences between value types and reference types is important when working with C#, as it affects how variables are stored, passed as arguments to methods, and manipulated in memory.

6. How do I work with arrays and collections in C#?

Arrays and collections are synonymous in C# and are both used to store multiple values. Here's how you can work with them:

1. Arrays: An array is a fixed-size collection of elements of the same data type. Arrays are accessed using a subscript. You can create an array in C# by declaring the array type and size, and then initializing the elements. Here's an example:
   
   int[] numbers = new int[5]; // create an integer array of size 5
   numbers[0] = 1; // set the first element to 1
   numbers[1] = 2; // set the second element to 2
   // ...
   
   You can also use array initializer syntax to create and initialize an array in a single line:
   
   

   int[] numbers = { 1, 2, 3, 4, 5 };

   
   To access elements of an array, you can use the square bracket notation followed by the index of the element (starting from 0):
   
   

   numbers[2] = 999; // array now contains 1, 2, 999, 4, 5

1. Collections: Collections are a more flexible way to store and manipulate groups of elements in C#. There are many types of collections available in C#, such as lists, dictionaries, and queues. To use a collection, you typically need to create an instance of the collection type and then add or remove elements from it. Here's an example using a list:
   
   

   List<string> names = new List<string>(); // create a new list 
   
           names.Add("Alice"); // add a string to the list
   
           names.Add("Bob");
   
           // ...

   
   
   You can access elements of a list using the square bracket notation followed by the index of the element (starting from 0). You can also use other methods provided by the collection type to manipulate the elements, such as Remove(), Clear(), and Count().

Arrays and collections are both useful tools for working with groups of data in C#. Depending on your needs, you may find that one is more appropriate than the other for a given task.

7. How do I handle exceptions and errors in my C# code?

Handling exceptions and errors is an important part of writing robust and reliable code in C#. There are 4 exception statements in C#, try, catch, finally & throw. Here's how you can handle exceptions and errors in your C# code to prevent unexpected crashes or failures:

1. Try-Catch Blocks: One way to handle exceptions in C# is to use a try-catch block. A try block contains the code that might throw an exception, while a catch block handles the exception if one is thrown. Here's an example:
   

           try
   
           {
   
           // code that might throw an exception
   
           }
   
           catch (Exception ex)
   
           {
   
           // code to handle the exception
   
           Console.WriteLine("An exception occurred: " + ex.Message);
   
           }
   
           

   In this example, any exceptions that occur within the try block will be caught by the catch block, which will print an error message to the console.

1. Finally Blocks: You can also use a finally block to ensure that some code is always executed, regardless of whether an exception is thrown or not. For example:
   

           try
   
           {
   
           // code that might throw an exception
   
           }
   
           catch (Exception ex)
   
           {
   
           // code to handle the exception
   
           Console.WriteLine("An exception occurred: " + ex.Message);
   
           }
   
           finally
   
           {
   
           // code that is always executed
   
           Console.WriteLine("Finished handling exception.");
   
           }
   
           

   
   In this example, the finally block will always execute, even if an exception is thrown and caught by the catch block.

1. Throwing Exceptions: You can also manually throw an exception in your code using the throw keyword. For example:
   
   

           if (someCondition)
   
           {
   
           throw new Exception("An error occurred.");
   
           }
           

   
   
   In this example, an exception will be thrown if the condition is true.

The .NET framework contains many pre-defined exceptions that it uses to inform you of exceptional conditions, and that you can also reuse in your code.

8. How do I use LINQ to query data in C#?

LINQ (Language-Integrated Query) is a powerful feature in C# that allows you to query and manipulate data from different data sources using a unified SQL-like syntax. Here's how you can use LINQ to query data in C#:

1. Importing the Required Namespaces: To use LINQ in your C# code, you need to import the System.Linq namespace. N.B. most project templates will already contain this statement.
   
   

    using System.Linq;

1. Querying Data: To query data using LINQ, you typically start with a data source such as an array, list, or database table, and then use LINQ operators to filter, sort, group, and transform the data as needed. Here's an example:
   
   

           int[] numbers = { 1, 2, 3, 4, 5 };
   
           var evenNumbers = from num in numbers
   
           where num % 2 == 0
   
           select num;
           

   
   
   In this example, the LINQ query selects only the even numbers from the array of integers. The result is stored in the evenNumbers variable, which is of type IEnumerable<int> (a collection of integers).

1. Executing Queries: To execute a LINQ query and retrieve the results, you can use a foreach loop to iterate over the query results, or you can convert the query results to a collection type such as a list or array using the ToList() or ToArray() method:
   
   

           foreach (int num in evenNumbers)
   
           {
   
           Console.WriteLine(num);
   
           }
   
           

   
   In this example, the foreach loop prints each even number to the console.

LINQ provides a powerful and expressive way to query and manipulate data in C#. By learning the LINQ syntax and operators, you can write efficient and concise code for a wide range of data processing tasks.

9. How can I work with databases in C# using ADO.NET or Entity Framework?

To work with databases in C#, there are two common approaches: using ADO.NET or using Entity Framework. Here's a brief overview of both approaches:

1. ADO.NET: ADO.NET is a set of classes in .NET that allow you to access and manipulate data from various data sources, including relational databases. Here's how you can use ADO.NET to work with a database in C#:

• Establish a connection to the database using a connection string.
• Create a command object to execute SQL queries or stored procedures.
• Execute the command and retrieve the results using a data reader or a dataset.
• Close the connection when finished.

1. Entity Framework: Entity Framework (EF) is an Object-Relational Mapping (ORM) framework in .NET that allows you to work with databases using a high-level, object-oriented approach. In the background EF is using ADO.NET & SQL to perform actions on the underlying database. The complexities of this are hidden (abstracted) from you. Visual Studio contains a rich set of wizards to create entity models of your database & all the components necessary to manipulate them. Here's how you can use Entity Framework to work with a database in C#:

• Create a data context class that inherits from DbContext and represents your database.
• Define entity classes that represent your database tables.
• Define a connection string in your application configuration.
• Use LINQ queries to query and manipulate data in your database.

Both ADO.NET and Entity Framework provide powerful and flexible ways to work with databases in C#. By choosing the right approach for your needs and understanding the basic concepts, you can create efficient and scalable database applications in C#.

10. What are lambdas in C#?

Lambda expressions are anonymous (unnamed) methods. Lambda expressions allow you define the method implementation inline using a simple syntax. For example:

    // This is a method and call

41int Add2Numbers(int n1, int n2)

41{

41return n1 + n2;

41}

41int methodResult = Add2Numbers(10, 20);

41// this is a lambda and call

41Func<int, int, int> AddNumbers = (n1, n2) => n1 + n2;

    int lambdaResult = AddNumbers(10, 20);

11. How do I implement multi-threading and asynchronous programming in C#?

In C#, multi-threading and asynchronous programming can be implemented using the following features listed in order of complexity:

1. BackgroundWorker class: The BackgroundWorker class in C# provides a simple way to execute an operation on a separate thread and report progress to the user interface thread.
2. Thread pool: The thread pool is a predefined collection of thread objects that you can use to start work in the background by using the ThreadPool.QueueUserWorkItem method and specifying the work to be carried out. This work can be specified in a method or by using a C# Lambda expression.
3. Thread class: The Thread class in C# allows you to create and manage threads in a multi-threaded application. You can use the Thread class to create & start a new thread specifying the code that the thread should execute. Task Parallel Library (TPL): The TPL in C# is a set of high-level APIs that simplify the process of creating and managing multiple threads. It allows you to write asynchronous and parallel code with minimal effort.
4. asynchronous code that looks like synchronous code. The async keyword is used to define a method that performs an asynchronous operation, while the await keyword is used to wait for the completion of the operation.

Overall, multi-threading and asynchronous programming in C# can be complex, but these features provide powerful ways to improve the performance and responsiveness of your applications.

12. What is reflection & when should I use it?

Reflection provides objects in System.Reflection that describe assemblies (programs) and types. You can use reflection to query an existing object and invoke its methods or access its fields and properties. You can also use reflection to dynamically define a new type and create an instance of the type at runtime.

Reflection is useful in the following situations:

• When you have to access attributes in your program's metadata.
• For examining and instantiating types in an assembly.
• For building new types at run time. Use classes in System.Reflection.Emit.
• For performing late binding, accessing methods on types created at run time.

• Visual Studio 2022
• Microsoft .NET
• .NET Developer Community
• https://www.reddit.com/r/dotnet