通用运算符的有效方法

Question

我有一个班级Gen<T>，我希望能够比较它们。以下代码无法编译，因为 == 不能应用于 Parent 和 Child。有没有办法使这种比较成为可能，或者这种做法通常是不好的做法？

public class Parent{
    public int x;
}

public class Child:Parent{}

public class Gen<T> 
    where T : Parent 
{
    public T variable;
}

public static class Gen
{
    public static bool operator ==(Gen<Parent> left, Gen<Parent> right){
        if (left.variable.x == right.variable.x)
            return true;
        else
            return false;
    }
}

public void Test()
{
    Gen<Parent> foo = new Gen<Parent>();
    Gen<Child> bar = new Gen<Child>();

    if (foo == bar)
    {
        ...
    }
}

完整的上下文如下：

1. Gen<T> 等于 ColorSet<T> 其中 T:Color
2. 父级等于颜色
3. Child 是一个存储颜色附加信息的类，并非每个 Color 对象都需要这些信息。

我想通过ColorSet<T> 类访问每个Color，如下所示：

public class ColorSet<T> where T : Color
{
     private T blue;
     private T red;
     private T green;

     public ColorSet()
     {
         Red = (T)Activator.CreateInstance(typeof(T), new object[] { });
         Red.Name = Values.Res.get("red");
         Blue = (T)Activator.CreateInstance(typeof(T), new object[] { });
         Blue.Name = Values.Res.get("blue");
         Green = (T)Activator.CreateInstance(typeof(T), new object[] { });
         Green.Name = Values.Res.get("green");
     }
}

但有时我需要ColorSet<Color> 有时需要ColorSet<Child> 以获取更多信息。并且应该可以将ColorSet<Color> 与ColorSet<Child> 进行比较，因为它们具有最相关的共同信息。

Answer 1

（从 cmets 扩展）似乎不需要泛型类。让运算符为泛型类型工作的一种有效方法是重新设计类型，使它们不再是泛型的。

ColorSet 可以定义为

public class ColorSet {
  private Color red;
  private Color green;
  private Color blue;

  protected ColorSet(Type type) {
    red = (Color)Activator.CreateType(type);
    red.Name = Values.Res.get("red");
    green = (Color)Activator.CreateType(type);
    green.Name = Values.Res.get("red");
    blue = (Color)Activator.CreateType(type);
    blue.Name = Values.Res.get("red");
  }

  public static ColorSet FromType<T>() where T : Color {
    return new ColorSet(typeof(T));
  }
}

您现在可以调用ColorSet.FromType<ExtendedColor>()，而不是new ColorSet<ExtendedColor>()。

只要您实际上不需要在构造函数之外使用您的T，此方法就可以工作。

例如，如果你有一个

public T Red { get { return red; } }

属性，您需要将其更改为

public Color Red { get { return red; } }

财产。

但是，如果您有类似的东西，并且确实想保留泛型类型，则可以将其放入派生的泛型类中：

public class ColorSet<T> : ColorSet where T : Color {
  public ColorSet<T>() : base(typeof(T)) { }
  public new T Red { get { return (T)base.Red; } }
}

它仍然只需要基本非泛型 ColorSet 类的运算符。

Answer 2

回到您最初的问题/示例：这并不漂亮，但它有效（对于您的示例 - 我只测试了两个） 虽然它使用反射，所以我对它不太满意：

public class Parent
{
    public int x;

    public Parent (int x)
    {
        this.x = x;
    }

    public override bool Equals(object o)
    {
        var p = o as Parent;
        if (object.Equals(p, null))
            return false;

        return this.x == p.x;
    }

    public override int GetHashCode()
    {
        return x;
    }

    public static bool operator ==(Parent a, Parent b)
    {
        return a.Equals (b);
    }

    public static bool operator !=(Parent a, Parent b)
    {
        return !(a == b);
    }

}

public class Child : Parent
{
    public Child (int x)
        : base(x)
    {

    }
}

public class Gen<T> 
    where T : Parent 
{
    public T variable;

    public Gen (T x)
    {
        this.variable = x;
    }

    public override bool Equals(object o)
    {
        if (object.Equal(o, null)) return false;

        // CAUTION: VERY DIRTY - just a quick reply to hvd - should check/remove this with test cases!
        try
        {
           var oT = o.GetType ().GetGenericTypeDefinition ();
           var tT = this.GetType ().GetGenericTypeDefinition ();
           if (tT != oT)
               return false;

           // for example this:
           // var oVar = o.GetType().GetField ("variable").GetValue (o);
           // should really be
           var varField = o.GetType().GetField("variable");
           if (varField == null) return;
           var oVar = varField.GetValue(o);

           if (object.Equals(oVar, null)) 
              return object.Equals(this.variable, null);

           return this.variable.Equals (oVar);
         } catch { return false; }
    }

    public override int GetHashCode()
    {
        return variable.GetHashCode();
    }

    public static bool operator ==(Gen<T> a, object b)
    {
        return a.Equals (b);
    }

    public static bool operator !=(Gen<T> a, object b)
    {
        return !(a == b);
    }

}

这是你的另一个例子：

public static void Test()
{
    Gen<Parent> foo = new Gen<Parent>(new Parent(5));
    Gen<Child> bar = new Gen<Child>(new Child(5));
    Gen<Child> bas = new Gen<Child>(new Child(6));

    if (foo == bar)
        Console.WriteLine ("equal");
    else
        Console.WriteLine ("not-equal");

    if (foo == bas)
        Console.WriteLine ("equal");
    else
        Console.WriteLine ("not-equal");
}

顺便说一句：你真的不需要 Parent 类上的 (==) 和 (!=) - 但它并没有什么坏处

Answer 3

public class IGen<out T> 
    where T : Parent 
{
    T Variable{ get; }
}

public class Gen<T>
    : IGen<T>
    where T : Parent 
{
    public T Variable {get;set;}

    private static Func<T, T, bool> _equal;

    static Gen()
    {
        var left = Expression.Parameter(typeof(T));
        var right = Expression.Parameter(typeof(T));
        var body = Expression.Equal(left, right);
        var lambda = Expression.Lambda<Func<T, T, bool>>(body, left, right);
        _equal = lambda.Compile();
    }

    public static bool operator ==(Gen<T> left, Gen<T> right)
    {
        return _equal(left.Variable, right.Variable);
    }


    public static bool operator ==(Gen<T> left, IGen<T> right)
    {
        return _equal(left.Variable, right.Variable);
    }


    public static bool operator ==(IGen<T> left, Gen<T> right)
    {
        return _equal(left.Variable, right.Variable);
    }
}