Delegates, Why? [duplicate]

by

Changing functionality at runtime is not what delegates accomplish.

Basically, delegates save you a crapload of typing.

For instance:

class Person
{
    public string Name { get; }
    public int Age { get; }
    public double Height { get; }
    public double Weight { get; }
}

IEnumerable<Person> people = GetPeople();

var orderedByName = people.OrderBy(p => p.Name);
var orderedByAge = people.OrderBy(p => p.Age);
var orderedByHeight = people.OrderBy(p => p.Height);
var orderedByWeight = people.OrderBy(p => p.Weight);

In the above code, the p => p.Name, p => p.Age, etc. are all lambda expressions that evaluate to Func<Person, T> delegates (where T is string, int, double, and double, respectively).

Now let’s consider how we could’ve achieved the above without delegates. Instead of having the OrderBy method take a delegate parameter, we would have to forsake genericity and define these methods:

public static IEnumerable<Person> OrderByName(this IEnumerable<Person> people);
public static IEnumerable<Person> OrderByAge(this IEnumerable<Person> people);
public static IEnumerable<Person> OrderByHeight(this IEnumerable<Person> people);
public static IEnumerable<Person> OrderByWeight(this IEnumerable<Person> people);

This would totally suck. I mean, firstly, the code has become infinitely less reusable as it only applies to collections of the Person type. Additionally, we need to copy and paste the very same code four times, changing only 1 or 2 lines in each copy (where the relevant property of Person is referenced — otherwise it would all look the same)! This would quickly become an unmaintainable mess.

So delegates allow you to make your code more reusable and more maintainable by abstracting away certain behaviors within code that can be switched in and out.

More Related Contents:

  1. Pass Method as Parameter using C#
  2. Invoke(Delegate)
  3. Compiler Ambiguous invocation error – anonymous method and method group with Func or Action
  4. When & why to use delegates? [duplicate]
  5. C#: Difference between ‘ += anEvent’ and ‘ += new EventHandler(anEvent)’
  6. Why can’t an anonymous method be assigned to var?
  7. Func vs. Action vs. Predicate [duplicate]
  8. How do I Unregister ‘anonymous’ event handler [duplicate]
  9. Super-simple example of C# observer/observable with delegates
  10. Performance of calling delegates vs methods
  11. Creating delegates manually vs using Action/Func delegates
  12. Assigning events in object initializer
  13. Wrapping StopWatch timing with a delegate or lambda?
  14. C# pattern to prevent an event handler hooked twice [duplicate]
  15. Are C# events synchronous?
  16. What’s the point of a lambda expression?
  17. How to correctly unregister an event handler
  18. Why does asynchronous delegate method require calling EndInvoke?
  19. Func delegate with ref variable
  20. What are the advantages of delegates? [duplicate]
  21. C#: Triggering an Event when an object is added to a Queue
  22. How do I create a delegate for a .NET property?
  23. Discrete Anonymous methods sharing a class?
  24. Passing Data Between 3 Separate WinForms [duplicate]
  25. Return a value from an Event — is there a Good Practice for this?
  26. Does Func.BeginInvoke use the ThreadPool?
  27. Is it good idea to use “Control.CheckForIllegalCrossThreadCalls = false” [duplicate]
  28. Is it possible to have a delegate as attribute parameter?
  29. Creating a property setter delegate
  30. C# Dynamic Event Subscription

Leave a Comment