
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

The `FileStream` instance implements the `IDisposable` interface, so we must release the unmanaged resources after we’re done using the instance. In this lesson, we’ll look at how to write data to a file and read it back.

# Encode and decode

If we want to write something to a file, we must convert it to an array of bytes. The specific means of converting a data type to a `byte[]` object varies depending on the nature of what we’ll store. Each file type has a specific format. For instance, we can encode text (`string` objects) using UTF8 encoding, ASCII, and so on. Depending on the encoding type, the array of bytes and the contents of the file are both different.

If we want to write some text to a file, we can use the `Encoding` class. It converts a .NET data type into an array of bytes:

```csharp
string text = "Hello World!";
byte[] bytes = Encoding.UTF8.GetBytes(text);
``` 

> **Note:** The `Encoding` class only works with text formats and text objects.

# Write text

After we have a text encoded into a byte array, we can start writing it to a file stream (`FileStream` object). As when we read from a file, we first create an instance of the `FileStream` class:

```C#
using (var fileStream = new FileStream(fileName, FileMode.Create))
{
}
```

The `FileMode.Create` ensures that we create a new file. If the file already exists, then it is overwritten. 

Next, we use the `Write()` method of the `FileStream` object to write our byte array to the file:

```csharp
fileStream.Write(bytes, 0, bytes.Length);
```

The `bytes`, in our case, is the `byte[]` object we want to write, `0` is the offset (from which position we should start writing), and `bytes.Length` is the number of bytes we write. In this case, we write the whole byte array.

We can reverse the process to ensure that our text was written successfully:

Write to files without causing memory leaks.

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

Writing Files

Introduction

Encode and decode