Usage of interfaces is always the recommended way to enforce a method’s signature – there are no doubts in that. But there are some occasions where you cannot use an interface to achieve this.
I had a scenario this week, in which I had to use some methods dynamically by reflecting them in run time. Basically these assemblies are created by others and I just consume the methods in run time. To add more problem, there can be any number of these methods. Even though there is an agreed signature for these methods, often times people can forget those ‘trivial’ details, resulting in run time exceptions, which may not be a nice thing to happen in a production system J.
So I wrote a little validation method which will validate a specified method against my signature. First define a delegate which matches your requirement.
delegate bool MyDesiredSignature(string param1, string param2);
Now extract the method info from the user’s assembly and attempt to create a delegate which matches my delegate (in this case it will be MyDesiredSignature).
bool ValidateSignature(string methodName, object typeInstance, Type delegateType)
MethodInfo methodInfo = this.GetType().GetMethod(
methodName, // The method's name.
BindingFlags.Instance | BindingFlags.NonPublic); // Change this accordingly for static/public methods.
// Attempt to create a delegate of my delegate type from the method info.
Delegate methodDelegate = Delegate.CreateDelegate(delegateType, typeInstance, methodInfo, false);
// If we have 'methodDelegate' as null, then that means the delegate does not match our signature
// or else we have a match.
return (methodDelegate != null);
Now we can just call this method for method verification like this.
bool isValidSignature = ValidateSignature("UsersMethodName", this, typeof(MyDesiredSignature));