
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

All `class` members have access modifiers. We already encountered them when we decorated our classes with the `public` keyword.

Access modifiers define a context in which a given `class` or its member can be used.


 - The `public` modifier makes a `class` or its member public to all external code. They can be accessed from any other part of the program and even from a different program or assembly.
 - The `private` modifier makes a `class` or its member closed to the external environment. A private `class` can only be accessed from the `class` where it’s defined. We can’t make a `class` private on the `namespace` level. Members that are `private` can only be accessed from within the `class` where they’re defined.
 - The `protected` modifier can only be used with `class` members. These members are only accessible from the same `class` or any derived `class`.
 - With the `internal` modifier, `classes` and members are only visible inside the assembly where they’re defined.

> **Note:** An **assembly** is a collection of types (classes, structs, and so on). It’s essentially a .dll or an .exe file that results from compiling our project. One .NET project equals one assembly.

 - The `protected internal` modifier indicates that classes and members are accessible from the current assembly and from any derived `class` (including those residing in other assemblies).
 - The `private protected` modifier indicates that members are visible inside the `class` where they’re defined and inside the derived classes in the current assembly.


Let’s explore each of the modifiers with the help of the code playground.

# The `public` modifier


Learn to control the visibility of methods and other class members.

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

Access Modifiers