
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

## Introduction

We’ve seen how to perform some actions asynchronously using the `Task` class. Asynchronous execution allows us to delegate some parts of our program to background pool threads. If we have a method that has some asynchronous code inside, how can we inform its users that it’s asynchronous? How can others call this method asynchronously without encapsulating it inside a `Task` instance? Consider the following example:

```C#
public void Print()
{
	string message = "Asynchronous code inside!";
	
	// This part of the method runs asynchronously 
	Task.Run(() => Console.WriteLine(message));
}
```

The `Print()` method includes a part that runs asynchronously in the background. If we were to call the `Print()` method, however, the current thread will be blocked until the method is done executing. We can’t call it asynchronously unless we encapsulate the method inside another `Task` instance**: 

```C#
Task.Run(() => Print());
```

Also, without looking at the method’s source code, we don’t know if there’s asynchronous code inside. Fortunately, there’s a much cleaner approach to creating and calling asynchronous methods in .NET apps using the `async` and `await` operators.

## Create async methods

An asynchronous method is a method that can be called without blocking the current thread. In terms of syntax, an asynchronous method is the one that

1. Has the `async` modifier.
2. Has one or several `await` statements inside its body.
3. Returns either `void`, `Task`, or its derivatives.

Asynchronous methods also can’t have parameters modified with `ref` or `out` keywords**. 

It’s good practice to name asynchronous methods with `Async` at the end (`PrintAsync()`).

Having the `async` modifier doesn’t make a method asynchronous by itself, however. It’s the developer’s responsibility to write asynchronous code inside the method. Let’s make our `Print()` method asynchronous:

# Introduction

We’ve seen how to perform some actions asynchronously using the `Task` class. Asynchronous execution allows us to delegate some parts of our program to background pool threads. If we have a method that has some asynchronous code inside, how can we inform its users that it’s asynchronous? How can others call this method asynchronously without encapsulating it inside a `Task` instance? Consider the following example:

```C#
public void Print()
{
	string message = "Asynchronous code inside!";
	
	// This part of the method runs asynchronously 
	Task.Run(() => Console.WriteLine(message));
}
```

The `Print()` method includes a part that runs asynchronously in the background. If we were to call the `Print()` method, however, the current thread will be blocked until the method is done executing. We can’t call it asynchronously unless we encapsulate the method inside another `Task` instance**: 

```C#
Task.Run(() => Print());
```

Also, without looking at the method’s source code, we don’t know if there’s asynchronous code inside. Fortunately, there’s a much cleaner approach to creating and calling asynchronous methods in .NET apps using the `async` and `await` operators.

# Create async methods

An asynchronous method is a method that can be called without blocking the current thread. In terms of syntax, an asynchronous method is the one that

1. Has the `async` modifier.
2. Has one or several `await` statements inside its body.
3. Returns either `void`, `Task`, or its derivatives.

Asynchronous methods also can’t have parameters modified with `ref` or `out` keywords**. 

It’s good practice to name asynchronous methods with `Async` at the end (`PrintAsync()`).

Having the `async` modifier doesn’t make a method asynchronous by itself, however. It’s the developer’s responsibility to write asynchronous code inside the method. Let’s make our `Print()` method asynchronous:

Create methods that can run asynchronously.

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

Asynchronous Methods

Introduction