
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

In addition to the `ThreadPool` class, there’s another way to use a pool’s threads. With the help of the Task Parallel Library (TPL), we can asynchronously execute methods that we want to run in the background. The TPL library is based on the concept of tasks, each of which describes a separate operation. Tasks are represented by the `Task` class that resides in the `System.Threading.Tasks` namespace. This class encapsulates a method that  executes asynchronously (without blocking the main thread) on a pool’s thread.


We create new threads using the `Thread` class for long-term jobs that keep the application running, even when other threads finish executing. Thread pool threads, on the other hand, are useful for jobs that run constantly but for shorter amounts of time. Because threads are reused and not destroyed, performance doesn’t deteriorate. TPL is an abstraction over thread pool threads, so performance notes apply here as well. However, TPL has one major feature that other multithreading approaches lack: tasks can return value. Therefore, if we need our methods to run on background threads and return value once they’re done, TPL is the best option. This lesson, however, focuses on methods that have the `void` return type.


## Create tasks

There are several ways to create instances of `Task` and run methods asynchronously. The first option is to instantiate using a constructor and provide it with an instance of the `Action` delegate (or any method that conforms to this delegate):

```C#
Task task = new Task(SomeMethod);
task.Start();

public void SomeMethod()
{
	Console.WriteLine("Executed inside a task");
}
```

We call the `Start()` method to begin execution. Anonymous methods that conform to the `Action` delegate can also be passed to the `Task` constructor:

# Introduction

In addition to the `ThreadPool` class, there’s another way to use a pool’s threads. With the help of the Task Parallel Library (TPL), we can asynchronously execute methods that we want to run in the background. The TPL library is based on the concept of tasks, each of which describes a separate operation. Tasks are represented by the `Task` class that resides in the `System.Threading.Tasks` namespace. This class encapsulates a method that  executes asynchronously (without blocking the main thread) on a pool’s thread.


We create new threads using the `Thread` class for long-term jobs that keep the application running, even when other threads finish executing. Thread pool threads, on the other hand, are useful for jobs that run constantly but for shorter amounts of time. Because threads are reused and not destroyed, performance doesn’t deteriorate. TPL is an abstraction over thread pool threads, so performance notes apply here as well. However, TPL has one major feature that other multithreading approaches lack: tasks can return value. Therefore, if we need our methods to run on background threads and return value once they’re done, TPL is the best option. This lesson, however, focuses on methods that have the `void` return type.


# Create tasks

There are several ways to create instances of `Task` and run methods asynchronously. The first option is to instantiate using a constructor and provide it with an instance of the `Action` delegate (or any method that conforms to this delegate):

```C#
Task task = new Task(SomeMethod);
task.Start();

public void SomeMethod()
{
	Console.WriteLine("Executed inside a task");
}
```

We call the `Start()` method to begin execution. Anonymous methods that conform to the `Action` delegate can also be passed to the `Task` constructor:

Learn to run background jobs with the help of tasks.

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

Tasks

Introduction