Interface with generic parameter vs Interface with generic methods

.net, c#, clr

Solution

Your generic method implementation has to be generic as well, so it has to be:

public class MyConcrete2 : IMyInterface2
{
    public T My<T>()
    {
        throw new NotImplementedException();
    }
}

Why you can't do `My<string>()` here? Because interface contract needs a method, that could be called with any type parameter `T` and you have to fulfill that contract.

Why you can't stop genericness in this point? Because it would cause situations like following:

Class declarations:

public interface IMyInterface2
{
    T My<T>(T value);
}

public class MyClass21 : IMyInterface2
{
    public string My<string>(string value) { return value; }
}

public class MyClass22 : IMyInterface2
{
    public int My<int>(int value) { return value; }
}

Usage:

var item1 = new MyClass21();
var item2 = new MyClass22();

// they both implement IMyInterface2, so we can put them into list
var list = new List<IMyInterface2>();
list.Add(item1);
list.Add(item2);

// iterate the list and call My method
foreach(IMyInterface2 item in list)
{
    // item is IMyInterface2, so we have My<T>() method. Choose T to be int and call with value 2:
    item.My<int>(2);

    // how would it work with item1, which has My<string> implemented?
}

Problem

Let's say I have such interface and concrete implementation ``` public interface IMyInterface<T> { T My(); } public class MyConcrete : IMyInterface<string> { public string My() { return string.Empty; } } ``` So I create MyConcrete implementation for `strings`, I can have one more concrete implementation for `int`. And that's ok. But let's say, that I want to do the same thing, but with generic methods, so I have ``` public interface IMyInterface2 { T My<T>(); } public class MyConcrete2 : IMyInterface2 { public string My<string>() { throw new NotImplementedException(); } } ``` So I have the same `IMyInterface2`, but which defines generic behavior by means of `T My<T>()`. In my concrete class I want to implement `My` behavior, but for concrete data type - `string`. But C# doesn't allow me to do that. My question is why I cannot do that? In other words, if i can create concrete implementation of `MyInterface<T>` as `MyClass : MyInterface<string>` and stop genericness at this point, why I can't do that with generic method - `T My<T>()`?

Original source