
Delve into .NET development with C#, covering programming fundamentals, object-oriented principles, exception handling, and multithreading. Gain hands-on experience to build cross-platform applications effectively.

csharp.tar.gz

CSharp-Compile-Run-code

.NET is Microsoft’s free and open source framework for developing native software applications on Linux, macOS, and Windows. The power of cross-platform development allows developers to design, code, and run programs on a wide array of platforms.

This course is an introduction to developing .NET applications using C#. You’ll start start with a comprehensive review of C# and computer programming fundamentals: data types, conditionals, loops, methods, and more. You’ll then review the basics of object-oriented programming before diving into methods, exception handling, delegation, and events. With this foundation, you’ll continue building interfaces, collections, database operations, and multithreading. You’ll wrap up with process improvements using dynamic binding, garbage collection, and unmanaged resources.

By the end of this course, you’ll have hands-on experience with C# and .NET, and be ready to build applications using object-oriented programming principles on almost any platform.

Mastering C# and .NET

## The `null` and reference types

In C#, we have a special value called `null`. This value represents the absence of value and is the default for reference-type variables.

```C#
string name = null;
```

The `null` value means that a variable doesn’t point to anything in memory. Because we’re dealing with references, we can’t assign `null` to a value-type variable, such as `int`.

If we try to access a variable that doesn’t point to anything, we get a `NullReferenceException`:

using System;

namespace NullValue
{
    class Program
    {
        static void Main(string[] args)
        {
            string name = null;

            // name is null. Accessing its members and methods
            // will yield an error
            string nameInUpperCase = name.ToUpper();
            Console.WriteLine(nameInUpperCase);
        }
    }
}

## The `null` and value types

Unlike reference types, value-type variables can’t be assigned the `null` value directly. However, it’s quite common to potentially need a value-type to be `null`. For instance, if we’re fetching some number from the database, we must assume that nothing may be returned.

For a value-type variable to be able to hold `null`, it must be of type `Nullable`. To ensure this, simply add `?` after the type name:

```C#
int? age = null;
```

The `age` variable here is of type `int?`, which is actually an alias for `System.Nullable<T>`, where `T` is a value type. So, in the case above it’s of type `System.Nullable<int>` because we create an `int?` variable.

We can use a `nullable` value type just like a regular value type:


```C#
int? age = null; // We can assign null
int? someValue = 12; // We can also assign a value
```

The `System.Nullable<T>` has two interesting properties:

 - The `Value` contains the value of type `T` (`T` is a placeholder for an actual type). If we access this property while it’s` null`, we get the same `NullReferenceException`.
 - A `HasValue` returns `true` if the variable contains a value, or `false` if it’s `null`.

We can perform arithmetic and comparison operations with `nullable` types just like we would perform them with regular value types. Remember that adding a `nullable` type to a regular value type yields a `nullable` type:

```C#
int? number = 24;
int anotherNumber = 12;
int sum = number + anotherNumber; // Error, the result must be of type int?
```

If one of the operands is `null`, then the result is also `null`.

## Check for `null`

If our method accepts parameters that can potentially have a `null` value, then we must always perform a `null` check:

```C#
public void MyMethod(string parameter)
{
	if (parameter != null)
	{
		// Perform actions only if the parameter is not null
	}
}

```

## The `??` operator

The `??` operator is the `null` coalescing operator and its syntax is as follows:

```C#
string name = null;
string nameToSend  = name ?? "Tom";
```

The `??` operator checks if the left-hand operand is `null`. If it’s `null`, then it returns the value from the right-hand side. If it isn’t `null`, then it returns the value from the left.

In the example above, `nameToSend` is `"Tom"`, because the `name` variable is `null`.

What’s the result of the following code?


# The `null` and reference types

In C#, we have a special value called `null`. This value represents the absence of value and is the default for reference-type variables.

```C#
string name = null;
```

The `null` value means that a variable doesn’t point to anything in memory. Because we’re dealing with references, we can’t assign `null` to a value-type variable, such as `int`.

# The `null` and value types

Unlike reference types, value-type variables can’t be assigned the `null` value directly. However, it’s quite common to potentially need a value-type to be `null`. For instance, if we’re fetching some number from the database, we must assume that nothing may be returned.

For a value-type variable to be able to hold `null`, it must be of type `Nullable`. To ensure this, simply add `?` after the type name:

```C#
int? age = null;
```

The `age` variable here is of type `int?`, which is actually an alias for `System.Nullable<T>`, where `T` is a value type. So, in the case above it’s of type `System.Nullable<int>` because we create an `int?` variable.

We can use a `nullable` value type just like a regular value type:


```C#
int? age = null; // We can assign null
int? someValue = 12; // We can also assign a value
```

The `System.Nullable<T>` has two interesting properties:

 - The `Value` contains the value of type `T` (`T` is a placeholder for an actual type). If we access this property while it’s` null`, we get the same `NullReferenceException`.
 - A `HasValue` returns `true` if the variable contains a value, or `false` if it’s `null`.

We can perform arithmetic and comparison operations with `nullable` types just like we would perform them with regular value types. Remember that adding a `nullable` type to a regular value type yields a `nullable` type:

```C#
int? number = 24;
int anotherNumber = 12;
int sum = number + anotherNumber; // Error, the result must be of type int?
```

If one of the operands is `null`, then the result is also `null`.

# Check for `null`

If our method accepts parameters that can potentially have a `null` value, then we must always perform a `null` check:

```C#
public void MyMethod(string parameter)
{
	if (parameter != null)
	{
		// Perform actions only if the parameter is not null
	}
}

```

# The `??` operator

The `??` operator is the `null` coalescing operator and its syntax is as follows:

```C#
string name = null;
string nameToSend  = name ?? "Tom";
```

The `??` operator checks if the left-hand operand is `null`. If it’s `null`, then it returns the value from the right-hand side. If it isn’t `null`, then it returns the value from the left.

In the example above, `nameToSend` is `"Tom"`, because the `name` variable is `null`.

What’s the result of the following code?


Getting Started

C# Programming Basics

Classes and OOP

Classes and OOP II

Exception Handling

First Assessment

Delegates and Events

Interfaces

Additional Features

Collections

LINQ

Working with Strings

Working with Dates and Time

Multithreading and Asynchronous Programming

Reflection

Dynamic Binding

Garbage Collection and Unmanaged Resources

Final Assessment

Next Steps

Appendix

Null Value

The `null` and reference types

The `null` and value types

First Assessment

Final Assessment

Null Value

The null and reference types

The null and value types

The `null` and reference types

The `null` and value types