Today I was faced with an issue. I had an interface based implementation of a specific functionality. All classes that implemented this interface had different implementation of course. What I had to add is ability to run certain checks on each implementation that would need to analyze the data defined in the interface and return a Boolean result of this check.
The problem was that the checks were all the same and I hated to add this check to the interface and write identical code in all implementations. As everyone knows interfaces cannot contain implementation code though. So, what should I do?
So, a particular .NET 3.5 feature came to my rescue. I am referring to extension methods. As you may or may not know extension methods are tied to a type. Well, interface is a type too. Here is some code to look at.
Here is the interface definition:
public interface ISupportCustomAction
{
Action CustomAction { get; set; }
void Execute();
}
Here is my class definition that implements this interface
public class CustomActionOne : ISupportCustomAction
{
#region ISupportCustomAction Members
private Action action;
public Action CustomAction
{
get
{
return action;
}
set
{
action = value;
}
}
public void Execute()
{
// fill in the method
}
#endregion
}
Finally, here is my extension method
public static class ISupportCustomActionExtensions
{
public static bool Check(this ISupportCustomAction action)
{
if (action.CustomAction == null)
{
return false;
}
else
{
return true;
}
}
}
Here is my test code to confirm that everything works
class Program
{
static void Main(string[] args)
{
CustomActionOne action = new CustomActionOne();
action.CustomAction = () => { Debug.WriteLine("Exectuted Action."); };
Analize(action);
action = new CustomActionOne();
Analize(action);
Console.ReadKey();
}
private static void Analize(ISupportCustomAction action)
{
if (action.Check())
{
Console.WriteLine("Can execute action");
}
else
{
Console.WriteLine("Cannot execute action");
}
}
}
How useful this is? Pretty useful in my case. Saved me some typing and resulted in consistent coding. My point is that is good to know what features .NET has and use them as a need arises. As you can see I have a hybrid here of a base (abstract) class and an interface. As a result, I am able to use features that belong to both concepts.
What does this code remind you of? Can you say “Multiple Inheritance in C#?” Well, not exactly, but pretty close.
Thanks.