Delegates are a way to declare accepted properties and returntype of methods, without having to write the actual code for the method. This can be handy when the method of an object depends upon the actual object itself.

When writing methods you define returntype, parameters and the actual code to be performed, the function body.

But in some cases when the method should depend on the instance of the class, it can be a problem to specify the actual function body.

Imagine we have a class Person with the string properties FirstName, LastName, and a List<string> property NameHistory for which we instantiate two objects: NoBody and SomeBody. We would like to be able to change the name of the people so we write a method ChangeName for this, but can’t decide how to write the code to save the history of names. Datastorage is precious and there are lots of nobodies in the world, so we can’t keep track of their names in a NameHistory. But we should keep a detailed record of this for a person that’s a somebody.

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public List<String> NameHistory { get; set; }

    public void ChangeName(string NewFirstName, string NewLastName)
    {
        ...?
    }
}

Person Nobody = new Person { FirstName = "No", LastName = "Body" };
Person SomeBody = new Person { FirstName = "Some", LastName = "Body" };

Of course an easy way would be to implement a property bool IsSomebody and use an if-statement in the ChangeName function. But what if we end up having lots of different rules for different instances of person? A delegate would solve this problem.

Create a delegate

A delegate is created with the keyword delegate followed by it’s returntype and parameters. You can then create an instance of this delegate, load it up with a method and invoke the method by calling the instance of the delegate.

class Person
{
    ...
    //Defenition of a delegate that returns nothing and takes a Person object as a parameter
    delegate void StoreHistoryDelegate(Person p);
    //A default method is given that takes itself as a parameter and does nothing. Using a lambda-expression to define the 
    //method.
    public StoreHistoryDelegate StoreHistory = p => {};

    public void ChangeName(string NewFirstName, string NewLastName)
    {
        //The delegate is used in the method to store history of name
        StoreHistory(this);
        //The names are changed
        this.FirstName = NewFirstName;
        this.LastName = NewLastName;
    }
    ...
}

We can then override the method contained in the instance of the object if we want to, and define a new function to handle the history storing.

Person Somebody = new Person { FirstName = "Some", LastName = "Body" }
Somebody.StoreHistory = (Person p) => 
{
    //Add datetime and previous name to the history list
    p.NameHistory.Add($"{DateTime.Now}: previous name is {FirstName} {LastName}");
}

String interpolation – $

Definition of interpolate: transitive verb

• 1a: to alter or corrupt (something, such as a text) by inserting new or foreign matter
• b: to insert (words) into a text or into a conversation

Source: Merriam-webster

When you want to insert code expressions in a string, using a string interpolation with the $ character in front of the string is the easiest and most readable way.

Console.WriteLine($"Car with ID {Car.CarID} costs {Car.Price}.")

Verbatim identifier – @

Definition of verbatim:

In the exact words : word for wordquoted the speech verbatim

Source: Merriam-webster

The C# compiler translates some special characters in a string. For example, when writing a filepath:

//Will not compile
Console.WriteLine("C:\Program Files\Documents\");

//Compiles
Console.WriteLine("C:\\Program Files\\Documents\\");

The \ is interpreted as an escape character, for the character after it, instead of just a \ character. Especially for filepaths it’s very handy to just be able to write the path, so here you can use the verbatim identifier @ and the compiler will interpret the string verbatim, “literally”.

Console.WriteLine(@"C:\Program Files\Documents\");

foreach loops are used to loop through collections of objects. C# has many standard type of loop functions, but the foreach loop is a special case. It can however be broken down to basic components to understand how it works. Imagine you have an array of cars that you iterate with a foreach loop:

//The car class
class Car{
  public int CarID {get;set;}
  public string Model {get;set;}
}

//Create an array of cars
public Car[] Cars = new Car[] {
  new Car { CarID = 1, Model = "Volvo"},
  new Car { CarID = 2, Model = "Mercedes"}
}

//Loop through the array
foreach(var Car in Cars)
{
  Console.WriteLine($"Car with ID {Car.CarID} is a {Car.Model}.");
}

// Car with ID 1 is a Volvo
// Car with ID 2 is a Mercedes

You get the Car objects one at a time, but under the hood more things are happening. The code invokes the method GetEnumerator() on the array which returns an object designed to iterate collections, let’s call it enum. This object must have a property named Current indicating the current object, and a method bool MoveNext(). The foreach loop could instead be written like this:

var enum = Cars.GetEnumerator();

while(enum.MoveNext())
{
  Var Car = enum.Current();

  // Start of code inside foreach block
  Console.WriteLine($"Car with ID {Car.CarID} is a {Car.Model}.");
}

Implementation

You can implement this functionality in your own class as well. Although the foreach loop doesn’t require any special function of the method MoveNext() and property Current of the object returned by GetEnumerator(), the most common case is to loop through each item and return false when the end is reached, keeping track of items with an index.

class CarEnumerator
{
  //MoveNext is invoked at the start of the loop, so begin the index at -1 to start at 0
  private int index = -1;
  private readonly Car[] Cars;

  //The Cars array is given during construction
  public CarEnumerator(Car[] Cars)
  {
    this.Cars = Cars;
  }

  //Move next advances the index by one and returns true if the end of the collection is not reached
  //When index >= Cars.Length it will return false, and the while-loop will not continue
  public bool MoveNext()
  {
    index ++;
    return (index < Cars.Length)
  }

  //The get method of the Current property returns the object at the current index position
  public Car Current
  {
    get{
      return Cars[index]
    }
  }
}

The actual method GetEnumerator() resides in a separate class, which also holds the collection.

class CarList
{
  Car[] Cars;

  public CarList(Car[] Cars)
  {
    this.Cars = Cars;
  }

  public CarEnumerator GetEnumerator()
  {
    return new CarEnumerator(Cars);
  }
}

In practice

This was a brief overview of how the foreach loop works. In practice you should implement the interface IEnumerable and IEnumerator when creating custom implementations for your class.