Question

我有这样的界面：

public interface IStuff
{
    bool DoSomethingWith<T>(T type);
}

这个实现它的类

    public class MyStuff<T> : IStuff
    {

        readonly ISomeClass<T> _cls;

        public MyStuff(ISystemCache cache)
        {
            _cls= cache.Get<T>();
        }

        public bool DoSomethingWith<T>(T type)
        {
            //dummy code here that returns a bool
            Type theType = typeof(T);
            return theType == typeof(T);
        }
     }

现在类型T在类MyStuff上的原因是因为我希望它在实现IStuff的类的构造函数中可用。 MyStuff将以某种类型传递，以便在其DoSomethingWith方法中使用。

现在DoSomethingWith也有T类型，因为我希望它可以在所有实现IStuff的类上使用。

IStuff最多只有一两个实现;目前只有一个，但一旦我完成设计，将会增加另一个。但是发送到ISomeClass类的MyStuff大约有5-6种不同的实现。对于MyStuff的每次实施，我都不想重复ISomeClass。稍后MyStuff_V2将执行将发送的ISomeClass的实现。

我如何设计这个以便我没有得到编译器警告＆＃34; Type参数T与外部类MyStuff<T>中的Type参数同名？

修改这是一个非常人为的例子，可能并不完美，但目标是能够在接口方法上创建一个通用类型，也可以为实现该接口的类的构造函数使用。

Answer 1

您必须IStuff通用：

public interface IStuff<T>
{
    bool DoSomethingWith(T type);
}

更改MyStuff<T>以实施IStuff<T>：

public class MyStuff<T> : IStuff<T>

并且您可以从DoSomething实现中删除泛型参数：

public bool DoSomethingWith(T type)
{
    //dummy code here that returns a bool
    Type theType = typeof(T);
    return theType == typeof(T);
}

Answer 2

你想要两种类型不同吗？只需更改类型：

public bool DoSomethingWith<T2>(T2 type)
{
   //dummy code here that returns a bool
   Type theType = typeof(T2);
   return theType == typeof(T);
}

否则你将不得不做@Marcin建议的事情。

更完整的例子：

void Main()
{
   IStuff s = new MyStuff<int>();
   Console.WriteLine(s.DoSomethingWith(2.34)); // compare will be false (double != int)
   Console.WriteLine(s.DoSomethingWith(5)); // compare will be true (int == int)
}

// Define other methods and classes here
public interface IStuff
{
    bool DoSomethingWith<T2>(T2 type);
}

public class MyStuff<T> : IStuff
{
   public MyStuff()
   {
      // Do whatever with type T
   }

   public bool DoSomethingWith<T2>(T2 type)
   {
      // dummy code here that returns a bool
      Type theType = typeof(T2);
      return theType == typeof(T);
   }
}

方法上的类型参数与其外部类型相同

2 个答案: