Question

我有一个通用接口，有几个类实现它。然后从一个全球的地方，我想使用该界面的方法，但是，我不知道他们编译的泛型类型，因此引用只是它们的对象的类，如在运行时所示。（所以我无法访问界面方法）

几个问题：

是否可以使用它们？
我应该在没有泛型的情况下进行设计吗？
如果我不能在运行时使用通用接口的目的是什么？
可以在那种情况下进行通用或动态帮助吗？

编辑：一些示例代码

  public interface IMyInterface<T> 
        where T: class, new()
    {
        void Delete (T obj);
    }

public class trigger {}
public class triggervm : IMyInterface<trigger>
{

List<trigger> _trigList = new List<trigger>()
    public void Delete (trigger obj)
    {
        _trigList.Remove (obj);
    }
}

现在，说我要检查，然后从“全局”地方使用删除方法：

if (chosenItem is IMyInterface<???>)
{
     var item = chosenItem as      IMyInterface<???>;
     item.Delete(someObj);
}

Answer 1

这是一个如何使用泛型接口函数的示例，而不必在编写代码时知道泛型类型。

基本思想是调用自己的泛型函数（在本例中为CompareValuesInternal）并使用反射来提取相应的类型信息以与调用一起传递。

 sm_compare_values_info = typeof(YourType).GetMethod("CompareValuesInternal", BindingFlags.NonPublic | BindingFlags.Static);

static public bool CompareValues(object x, object y)
{
  bool result = true;

  if ((x == null && y != null) || (x != null && y == null))
  {
    result = false;
  }
  else if (x == null && y == null)
  {
    result = true;
  }
  else if (x is IComparer)
  {
    result = ((x as IComparer).Compare(x, y) == 0);
  }
  else if (x is IComparable)
  {
    result = ((x as IComparable).CompareTo(y) == 0);
  }
  else if (x is IEqualityComparer)
  {
    result = (x as IEqualityComparer).Equals(x, y);
  }
  else if (x.GetType() != y.GetType())
  {
    result = false;
  }
  else
  {
    //----IMPORTANT PART----
    MethodInfo info = sm_compare_values_info.MakeGenericMethod(x.GetType());
    result = (bool)info.Invoke(null, new object[] { x, y });
  }

  return result;
}

static protected bool CompareValuesInternal<T>(T x, T y)
{
  bool result = false;

  if (x is IEqualityComparer<T>)
  {
    result = (x as IEqualityComparer<T>).Equals(x, y);
  }
  else if (x is IEquatable<T>)
  {
    result = (x as IEquatable<T>).Equals(y);
  }
  else if (x is IComparable<T>)
  {
    result = ((x as IComparable<T>).CompareTo(y) == 0);
  }
  else if (x is IComparer<T>)
  {
    result = ((x as IComparer<T>).Compare(x, y) == 0);
  }

  return result;
}

Answer 2

是的，使用动态可以是解决此问题的最简单，最好的方法。 Jon Skeet的C＃在动作中也提到了这一点。

正如其他人所说，更多的代码更少英语，我们都可以在这里缩小范围。

Answer 3

像托马斯建议的那样，我使用动态，

和“RedHat”建议一样，我的封闭类继承自我的接口（IClipboard<T>）和父接口（IClippable），它只是一个“分组”接口。

myinterface继承自分组接口，因此任何实现myinterface的类也与分组接口匹配。所以我可以检查所选项目是否为IClippable。

凭借我目前对该语言的了解，我能获得最清晰的知识。

在C＃中提供更好的支持会很好。

Answer 4

interface IInterface<T>
{
    Type GetMyType();
}
class MyClass1 : IInterface<int>
{
    public Type GetMyType()
    {
        return typeof(int);//each subclass must be return own generic type
    }
}

static void Main()
{
    new MyClass1().GetMyType()==typeof(int);//Is True
}

接口<t>来自实现类的方法，没有引用</t>

4 个答案: