
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

# Overview

**Dictionaries** are key-value stores. These are mappings between keys and associated values. We can imagine a dictionary as a book where we have words and associated translations. Words are keys and translations are values:

Keys in .NET dictionaries must be unique. It’s impossible to have two identical keys. Values aren’t unique, though.

# Syntax

Dictionaries in .NET are created by instantiating the `Dictionary<K, V>` class. We can use any type as a key and any type as a value:

```C#
// Keys are of string type, values are of string type
var countryCapitalMapping = new Dictionary<string, string>();
```

Keys and values can be of different types:

```C#
// Keys are of string type, values are int type
var countryPopulationMapping = new Dictionary<string, int>();
```

There are several `Dictionary<K, V>` methods that constitute its primary functionality:


 - `Add()` This method adds a key and value pair to the dictionary:

	```C#
	countryCapitalMapping.Add("United States", "Washington");
	```

 - `TryAdd()`: This method tries to add a key and value and returns a boolean as a result, indicating whether the operation was successful. We can use this method when we’re not sure if the key we add already exists in the dictionary:

	```C#
	bool added = countryCapitalMapping.TryAdd("United States", "Washington");
	
	if (!added)
	{
		Console.WriteLine("The key already exists!");
	}
	```

 - `TryGet()`: This method tries to read a key and write the associated value to some variable that was passed with the `out` modifier. It returns a boolean that indicates whether the operation was successful:
	```C#
	int USPopulation;
	bool retrieved = countryPopulationMapping.TryGet("United States", out USPopulation);
	
	if (!retrieved)
	{
		Console.WriteLine("The key does not exist!");
	}
	```	

 - `[]`: This indexer is used to read a value associated with the key. In arrays, we provide an integer index to the indexer. In dictionaries, however, we provide a key:

	```C#
	countryCapitalMapping["United States"] = "Washington, DC";
	```

# Example

Let’s create a program that counts a letter’s occurrences in a given text. We could use characters as keys and the count as values:

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

Dictionary

Overview