Interface with generic parameter vs Interface with generic methods
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?
}
Because your interface declares a generic method T My<T>()
, but you implementation does not implement a function with that specific signature.
To achieve what you want, you need to provide the T generic parameter to the interface instead, in your first example:
public interface IMyInterface2<T>
{
T My();
}
public class MyConcrete2 : IMyInterface2<string>
{
public string My()
{
throw new NotImplementedException();
}
}