C# 泛型运算符

在C#中，可以像其他方法一样进行运算符的重写，也可以在泛型类中实现此类重写。例如，可在Fami<T>中定义如下隐式的转换运算符：

public static implicit operator List<Animal>(Farm<T> farm)

{

    List<Animal> result = new List<Animal>();

    foreach (T animal in farm)

    {

        result,Add(animal);

    }

    return result;

}

这样，如有必要，就可以在Farm<T>中把Animal对象直接作为List<Animal>来访问。例如，使用下面的运算符添加两个Farm<T>实例，这是很方便的：

public static Farm<T> operator +(Farm<T> farml, List<T> farm2)

{

    Farm<T> result = new Farm<T>(); 

    foreach (T animal in farml)

    {

        result.Animals.Add(animal);

    }

    foreach (T animal in farm2)

    {

        if {!result.Animals.Contains(animal))

        {

            result.Animals.Add(animal);

        }

    }

    return result;

}

public static Farm<T> operator + (List<T> farml, Farm<T> farm2) => farm2 + farml;

接着可以添加Farm<Animal>和Farm<Cow>^实例，如下所示：

    Farm<Animal> newFarm = farm + dairyFarm;

在这行代码中，dairyFarm(Farm<Cow>的实例)隐式转换为List<Animal>, List<Animal>可在Fann<T>中由重载运算符+使用。

读者可能认为，使用下面的代码也可以做到这一点：

    public static Farm<T> operator +(Farm<T> farml, Farm<T> farm2){ ... }

但是，Farm<Cow>不能转换为Farm<Animal>，所以汇总会失败。为了更进一步，可以使用下面的转换运算符来解决这个问题：

public static implicit operator Farm<Animal>(Farm<T> farm)

{

    Farm <Animal> result = new Farm <Animal>(); 

    foreach (T animal in farm)

    {

        result.Animals.Add(animal);

    }

    return result;

}

使用这个运算符，Farm<T>的实例(如Farm<Cow>)就可以转换为Farm<Animal>的实例，这解决了上面的问题。所以，可以使用上面列出的两种方法中的一种，但是后者更适合，因为它比较简单。