Method parameter: Interface VS Generic type

Question

What are the arguments to use one or another of those two method implementations (in Example class)?

public interface IInterface
{
    void DoIt();
}

public class Example
{
    public void MethodInterface(IInterface arg)
    {
        arg.DoIt();
    }

    public void MethodGeneric<T>(T arg) where T: IInterface
    {
        arg.DoIt();
    }
}

PS: If method returns an IInterface or T I would choose the "generic" way to avoid further casting in type T if needed.

Answer 1

Both appears to be same, but really not.

Generic version will not box the ValueType when passed where as non generic version requires "boxing"

Here is a small sample program and relevant IL which demonstrates the situation

void Main()
{
    Example ex = new Example();
    TestStruct tex = new TestStruct();
    ex.MethodGeneric(tex);
    ex.MethodInterface(tex);
}
public interface IInterface
{
   void DoIt();
}

public class Example
{
   public void MethodInterface(IInterface arg)
   {
       arg.DoIt();
   }

   public void MethodGeneric<T>(T arg) where T : IInterface
   {
       arg.DoIt();
   }
}

internal struct TestStruct : IInterface
{
   public void DoIt()
   {

   }
}

Below is the relevant part of IL generated

IL_0001:  newobj      UserQuery+Example..ctor
IL_0006:  stloc.0     // ex
IL_0007:  ldloca.s    01 // tex
IL_0009:  initobj     UserQuery.TestStruct
IL_000F:  ldloc.0     // ex
IL_0010:  ldloc.1     // tex
IL_0011:  callvirt    UserQuery+Example.MethodGeneric
IL_0016:  nop         
IL_0017:  ldloc.0     // ex
IL_0018:  ldloc.1     // tex
IL_0019:  box         UserQuery.TestStruct //<--Box opcode
IL_001E:  callvirt    UserQuery+Example.MethodInterface

Though it is a matter of preference, While MethodGeneric is the one which will perform better in case of "ValueTypes"

Answer 2

I suggest passing Interface as a simple parameter, instead of using generic approach, for these reasons:

1. Simpler design, which results in better maintainability
2. More readable code, lesser professional knowledge
3. Better support for Dependency Injection and IoC
4. No reflection (I'm not sure about this, I'm going to provide proof, because generics use reflection to understand the type)