
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

Now’s a good time to explore how the `foreach` loop works. When we iterate using a `for` loop, we determine how that iteration works. How does the `foreach` loop know what the first and subsequent items are? How does it determine when there are no more items in the collection?

Know that `foreach` loops aren’t magic. Types that want to be iterated using a `foreach` loop must implement the `IEnumerable` interface:

# The `IEnumerable<T>` interface

> Non-generic collections can also be iterated with a `foreach` loop. Non-generic collections implement the `IEnumerable` interface, while generic collections utilize the generic collections use the generic version of this interface. We’ll mostly talk about `IEnumerable<T>` in this lesson.

The `IEnumerable<T>` is an interface derived from `IEnumerable`. Therefore, a class that wants to implement `IEnumerable<T>` must also implement `IEnumerable`.

There’s not much to implement, however:

```C#
public interface IEnumerable
{
	IEnumerator GetEnumerator();
}

public interface IEnumerable<out T> : IEnumerable
{
	new IEnumerator<T> GetEnumerator();
}
```
We need two `GetEnumerator` methods, and the one from `IEnumerable` must be implemented explicitly:

```C#
using System.Collections;
using System.Collections.Generic;

namespace Collections
{
    public class PositiveIntegerList : IEnumerable<int>
    {
        public IEnumerator<int> GetEnumerator()
        {
            // Implementation
        }

        // Explicit implementation
        IEnumerator IEnumerable.GetEnumerator()
        {
            // Implementation
        }
    }
}
```

So, to become iterable through a `foreach` loop, a type must have a `GetEnumerator` method that returns an `IEnumerator` type object. Let’s see what that object is.

# The `IEnumerator`

> Just like `IEnumerable`, `IEnumerator` has a generic version. We’ll focus on that.

The `IEnumerator<T>` is an interface that exposes three methods and one property:

```C#
public interface IEnumerator<T> : IEnumerator, IDisposable
{
	new T Current;
}

public interface IEnumerator
{
	object Current;
	bool MoveNext();
	void Reset();
}

public interface IDisposalbe
{
	void Dispose();
}
```

- The `new T Current`; property indicates that the `IEnumerator<T>` interface hides the `Current` property that comes from `IEnumerator`.
- The three methods are:
  - `MoveNext` from `IEnumerator`
  - `Reset` from `IEnumerator`
  - `Dispose` from IDisposable

## The `IEnumerator<T>` methods

 - The `MoveNext()` method sets the pointer to the next item in the collection and returns `true`. If the pointer reaches the end of the collection, it returns `false`.

 - The `Current` method returns the current item in the collection (the item to which the pointer is pointing).

 - The `Reset()` method resets the pointer.

 - The `Dispose()` method is used for clean-up purposes.

Armed with this knowledge, let’s look at a custom implementation for our custom collection.

# Putting everything together

We create a class called `PositiveIntegerList` that only stores positive integers. This class can be iterated using `foreach` because we implement the `IEnumerable<T>` interface:





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

IEnumerable Interface

Introduction