C# – How can I “overload” a delegate?

by

Imagine for a moment this was possible. Suppose I could have an overloaded delegate:

public delegate void OneDelegate(int i);
public delegate void OneDelegate(string s);

Now imagine I declare a variable of this type and then assign a function to it, for example:

OneDelegate myDelegate = StringMethod;

where StringMethod is declared thusly:

public void StringMethod(string s) { Console.WriteLine(s); }

Now you pass myDelegate to some other code, and that code does this:

myDelegate(47);

What do you expect to happen in this case? How can the runtime call StringMethod() with an integer argument?

If you really want a delegate that can take any set of parameters at all, then the only option is to have one with a params object[] array:

public delegate void OneDelegate(params object[] parameters);

But then you will have to assign to it a function that can actually handle any object array, for example:

public void MyMethod(params object[] parameters)
{
    if (parameters == null || parameters.Length == 0)
        throw new ArgumentException("No parameters specified.");
    if (parameters.Length > 1)
        throw new ArgumentException("Too many parameters specified.");

    if (parameters[0] is int)
        IntMethod((int) parameters[0]);
    else if (parameters[0] is string)
        StringMethod((string) parameters[0]);
    else
        throw new ArgumentException("Unsupported parameter type.");
}

As you can see, this gets messy real quick. Therefore, I submit to you that if you need such a delegate, you have probably made a mistake somewhere in your architectural design. Identify this flaw and fix the design before you proceed with the implementation, as otherwise the maintainability of your code will suffer.

More Related Contents:

  1. Pass Method as Parameter using C#
  2. Unsubscribe anonymous method in C#
  3. Invoke(Delegate)
  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. C#: Passing null to overloaded method – which method is called?
  10. Delegates: Predicate vs. Action vs. Func
  11. Super-simple example of C# observer/observable with delegates
  12. Performance of calling delegates vs methods
  13. Creating delegates manually vs using Action/Func delegates
  14. Assigning events in object initializer
  15. Wrapping StopWatch timing with a delegate or lambda?
  16. C# pattern to prevent an event handler hooked twice [duplicate]
  17. C# 3.0 generic type inference – passing a delegate as a function parameter
  18. Are C# events synchronous?
  19. Why method overloading is not allowed in WCF?
  20. What’s the point of a lambda expression?
  21. Why does asynchronous delegate method require calling EndInvoke?
  22. Func delegate with ref variable
  23. How can I clear event subscriptions in C#?
  24. What are the advantages of delegates? [duplicate]
  25. C#: Triggering an Event when an object is added to a Queue
  26. What does “a field initializer cannot reference non static fields” mean in C#?
  27. Events – naming convention and style
  28. Discrete Anonymous methods sharing a class?
  29. Passing Data Between 3 Separate WinForms [duplicate]
  30. Passing a variable between Windows Forms forms

Leave a Comment