委托示例有什么意义

Question

Like many other posts I've found on SO, I'm trying to get my head around delegates. Hopefully this example is not classed a duplicate because I am asking a specific question about a particular example.

 public delegate void HelloFunctionDelegate(string message);

    public class Delegate
    {
        static void Main()
        {
            HelloFunctionDelegate del = new HelloFunctionDelegate(GoodNight); // delegate will point to the GoodNight method

            del("Hello"); // invoke the delegate
        }

        public static void GoodMorning(string strMessage)
        {
            Console.WriteLine(strMessage + " and good morning!");
            Console.ReadKey();
        }

        public static void GoodNight(string strMessage)
        {
            Console.WriteLine(strMessage + " and good night!");
            Console.ReadKey();
        }
    }

So in my example I understand that my delegate is a reference to any function that matches its signature and if I pass in GoodMorning I will see: Hello and good morning!

and if I pass in GoodNight I will see: Hello and good night!

So its kind of like going through a middle man...

I don't understand is what's the point, why wouldn't I just directly call my GoodMorning / GoodNight methods as and when I need to use them?

Maybe there are better examples for when a delegate is useful, but in this example, why don't I just bypass the middle man?

Answer 1

Since you are asking concretely about this example and not in general: There is no point to doing that in this particular piece of code. It teaches you the mechanics of delegates but it does not teach you the point of using them.

In short, the point is that some piece of code can take a reference to a method without knowing what method it will actually receive. It can later call that delegate at will. That enables more abstractions than otherwise possible.

Answer 2

Consider you have the following delegate:

public delegate void CarEvent(Car car);

And then you have an implementation like the following:

public class Car : DataRecord
{
    // An event to execute when the record is deleted
    public CarEvent OnDelete { get; set; }

    public void Delete()
    {
        this.DeleteRecord(); // Deletes this record from ex. the database

        if (OnDelete)
        {
            OnDelete(this); // Executes the event
        }
    }
}

By using a delegate you can subscribe different methods to the OnDelete allowing you to do different things when the record is deleted.

Ex. you can make it so when the record is deleted it's deleted from a "ListView" that holds it.

public class CarList : ListView
{
    public CarList()
        : base()
    {
        foreach (var car in CarRecords.LoadCars())
        {
            var listViewItem = new ListViewItem(car);
            car.OnDelete = this.DeleteCarFromList;

            this.Items.Add(listViewItem);
        }
    }

    private void DeleteCarFromList(Car deletedCar)
    {
        this.Items.Remove(deletedCar);
    }
}

Of course the above is a rough example and there is a lot more things and different kind of situations where you can use delegates and most notably if you want to use them for events you should consider implementing them using the event keyword. - https://msdn.microsoft.com/en-us/library/awbftdfh.aspx

All in all you want to use delegates when the behavior may differ depending on the overall implementation of something. Like you might want to do one thing in one situation and something else in another situation, but they should both over-all do the same thing.

If you do not need different behaviors based on implementation then there's no need to use delegates. You'd always want to call a method directly if possible.

I hope this explained it okay.