
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

## Constants

A **constant** is an immutable field with a value assigned during compilation. Constants can’t be reassigned and their value can’t be modified.

Constants are declared using the `const` keyword:

```C#
public const int PI = 3.14;
```

Only the primitive types, except for the `Object` `class`, can be declared as constants. Any other classes, including user-defined types, can’t be modified with the `const` keyword.

Access modifiers can be used to control access to constants. The `static` keyword, however, isn’t allowed, because `const` fields are `static` members.

The difference between normal static fields and constants is that constants are assigned a value during compilation, and this value doesn’t change during runtime. In contrast, the initial assignment for regular static fields happens during program launch.

Consider the following code snippet:


```C#
public class SomeClass 
{
    public const int number = 5;
    public static int number1 = 7;
}
```

Using a special tool (ILDasm), we can see the resulting IL code (in this case, some part of it):

```C#
.class public auto ansi beforefieldinit SomeClass
    extends [System.Private.CoreLib]System.Object
{
    // Fields
    .field public static literal int32 number = int32(5)
    .field public static int32 number1

.method private hidebysig specialname rtspecialname static 
        void .cctor () cil managed 
    {
        // Method begins at RVA 0x2058
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldc.i4.7
        IL_0001: stsfld int32 SomeClass::number1
        IL_0006: ret
    } // end of method SomeClass::.cctor

} // end of class SomeClass
```

The only thing that we need to understand from the code above is that the value of the `number` constant is assigned during compilation, while `number1` receives its value when the static constructor is called. Here’s the explanation:


# Constants

A **constant** is an immutable field with a value assigned during compilation. Constants can’t be reassigned and their value can’t be modified.

Constants are declared using the `const` keyword:

```C#
public const int PI = 3.14;
```

Only the primitive types, except for the `Object` `class`, can be declared as constants. Any other classes, including user-defined types, can’t be modified with the `const` keyword.

Access modifiers can be used to control access to constants. The `static` keyword, however, isn’t allowed, because `const` fields are `static` members.

The difference between normal static fields and constants is that constants are assigned a value during compilation, and this value doesn’t change during runtime. In contrast, the initial assignment for regular static fields happens during program launch.

Consider the following code snippet:


```C#
public class SomeClass 
{
    public const int number = 5;
    public static int number1 = 7;
}
```

Using a special tool (ILDasm), we can see the resulting IL code (in this case, some part of it):

```C#
.class public auto ansi beforefieldinit SomeClass
    extends [System.Private.CoreLib]System.Object
{
    // Fields
    .field public static literal int32 number = int32(5)
    .field public static int32 number1

.method private hidebysig specialname rtspecialname static 
        void .cctor () cil managed 
    {
        // Method begins at RVA 0x2058
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldc.i4.7
        IL_0001: stsfld int32 SomeClass::number1
        IL_0006: ret
    } // end of method SomeClass::.cctor

} // end of class SomeClass
```

The only thing that we need to understand from the code above is that the value of the `number` constant is assigned during compilation, while `number1` receives its value when the static constructor is called. Here’s the explanation:


Learn to create fields that are read-only.

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

Constants and Read-Only Fields

Constants