
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

# Custom exception types

Although there are many built-in exception types in .NET, we might need to create our own based on our application requirements.

> **Note:** The only thing we need to create a custom exception type is a class that inherits from `Exception`.

Imagine we’re building an application with a login feature. We need to check if the user provides the correct username and password. In the case that their credentials are invalid, we need to generate an exception that informs the user that they’ve provided invalid credentials.

We have a method that logs a user in:


```C#
public void LogIn(string username, string password)
{
}
```

We also have to define a custom exception that’s thrown in the case that their credentials are invalid:

```C#
public class InvalidCredentialsException : Exception
{
	public InvalidCredentialsException(string message)
		: base(message)
	{
	}
}
```

Our custom exception class does nothing specific. It inherits everything from `Exception` and uses its constructor to set the `Message` property. Instead of inheriting from the base `Exception` class, we could inherit from a class that would be more appropriate in this context. Invalid credentials are essentially invalid arguments. Therefore, we can inherit from the `ArgumentException` class:


```C#
public class InvalidCredentialsException : ArgumentException
{
	public InvalidCredentialsException(string message)
		: base(message)
	{
	}
}
```

Now, our class has all members of `ArgumentException`. 

Custom exception classes, like any other type, can define their own properties and methods. For our `InvalidCredentialsException` class, we can create two properties that hold the username and password that caused the exception to be generated:

```C#
public class InvalidCredentialsException : ArgumentException
{
	public string Username { get; private set; }
	public string Password { get; private set; }

	public InvalidCredentialsException(string message, string username, string password)
		: base(message)
	{
		Username = username;
		Password = password;
	}
}
```

Learn to create custom exception types and use them inside programs.

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

Creating and Throwing Exceptions

Custom exception types