Overview of .NET 5
.NET is designed to be used for developing multiple types of applications. You'll get an overview of the applications you can build. You will also be introduced to the different flavors contained within
.NET Framework and .NET 5.
- What is a .NET Application?
- .NET Framework versus .NET 5
- .NET Applications: ASP.NET, Web API, WPF, Blazor, Xamarin,...
The .NET Application
When building applications in .NET, it needs to follow a couple of rules. We'll look at the structure of an application
and which parts are necessary during runtime.
- The Visual Studio solution and project
- What are namespaces and assemblies
Classes and Objects
One of the most basic parts of Object-Oriented (OO) programming is designing a blueprint (called class) and during runtime
creating an object out of that. In this module we will talk about the real fundamentals of .NET programming. We create
variables to store numbers, text and complex objects and try to use operators on them. We'll explore the ways in
which you create a class and add state and behavior to objects.
- What is a Class?
- Fields, Methods and Properties
- LAB: Work with classes, class members and instances
Whenever you instantiate an object from a class, it needs to be constructed. This module will discuss how .NET handles
- Instance Constructors
- Constructor Initializers
- Overloading Constructors
Types in .NET
Whether you're trying to store numbers, text or objects, you need to put them into variables. These variables will inevitably
end up somewhere in memory. By knowing where in memory each type of variable gets stored, we can predict what will
happen to them.
- Type Categories in .NET
- Value Types, Reference Types and Immutable Reference Types
- Custom Value Types: Structure and Enumeration
- Boxing and Unboxing
- Arguments of Functions. Pass by Value, by Reference; Passing Output
- LAB: Constructors, Enums and StringBuilder
Static Members and Static Classes
From time to time you need some functionality that is not part of one object, but instead part of a complete class. This
allows you to use methods without creating an object, or storing data that is reachable for every object. In .NET
we call this static members and classes.
- Static Members
- Static Constructors
- Static Classes
- LAB: Car Factory
A very important aspect of OO programming is being able to inherit functionality from a basic concept. We'll explore
how we can use Inheritance to extend a class and add functionality to it. To help you a bit with a practical example we'll create an ASP.NET MVC application to illustrate Inheritance.
- General Principle of Inheritance
- Accessibility Levels: Public, Private, Protected and Internal
- LAB: Creating a Web Shop in ASP.NET
On top of Inheritance in OO programming comes this marvel called polymorphism. It allows us to add a different implementation
for specific types, based on a generic definition of a function. With polymorphism this is an easy feat to accomplish.
- Inheritance & Polymorphism
- Overriding Methods & Properties
- Using the Base Class
- Sealed Classes, Methods and Properties
- The Object Class
- Overriding the ToString, Equals and GetHashCode Method
- LAB: Adding Polymorphism to an Employee Class
Abstract classes and Interfaces
Both concepts are incredibly important in .NET. We'll have a look at how to implement this with an ASP.NET MVC application.
- Abstract Classes
- Defining Interfaces
- Implementing Interfaces
- Interface Examples in .NET
- LAB: Implementing IComparable and Controlling Devices
Storing elements in a collection is crucial in programming languages. This chapter talks about one of the most basic collections in .NET.
- Arrays in .NET
- Multidimensional Arrays
- Indexer Properties
- The for, foreach and while Loops
In C#, you can consider two separate mechanisms when writing reusable code across different types: inheritance and generics.
Where inheritance provides reusability with the concept of base types, generics express reusability by providing
a template that contains type placeholders. Generics, in comparison to inheritance, can increase type safety and
reduce the need for casting and boxing within your applications. This module will illustrate how and when to use
generics in your .NET applications. We'll use a WPF application to illustrate Generics.
- How to use Generics
- Creating your own Generics
- Generic Constraints
- LAB: Sports Team or Movietheek
Whenever something unexpected happens, like the network going down, we want our programs to handle this behavior in a
user-friendly way. With Exceptions we can react fittingly when these problems occur.
- Exceptions in .NET
- The try-catch-when-finally Keywords
- Creating Custom Exceptions
Delegates and Events
One of the most difficult aspects of .NET programming is to be able to store functions in a variable. That is exactly
what delegates allow us to do. This concept is used with lots of .NET technologies, like asynchronous programming,
event handling, LINQ,.... Events are based on delegates, allowing your application to react to something happening,
like a button click.
- Creating Delegates
- Using Delegates
- Multicast Delegates
- Creating Events
- Using Events in a UI
- LAB: Calculator or Music Store
This module will introduce you to a couple of nifty features that are included in .NET.
- Type Inference
- Extension Methods
- Anonymous Methods
- Anonymous Types
- Lambda Expressions
- LAB: Type Inference, Extension Methods and Lambda Expressions
Accessing a Database with LINQ and Entity Framework
LINQ allows to use query-expressions that are very akin to SQL queries, but that can be applied to multiple types of
data. This makes certain operations like filtering and sorting data very easy. You will also be introduced to Entity
Framework for exposing your relational data.
- Enumerable Class
- Func Delegates
- Entity Framework
- Query Operations from, where, order, group and select
- Introducing Entity Framework
- Entity Framework Basics
- LAB: Creating a Shop in WPF