C#入门经典 问题二，泛型中的类型问题

我：

有一个类这样约束它所继承的的基类型T为Animal

public class Farm<T> : IEnumerable<T>
        where T : 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;
        }

上面是这个自定义隐式转换符

那么这段函数的声明中

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

标为红色的Farm<T>，这个T类型是指什么？

你这个T，没有什么所谓的类型把，这个是模版参数。

猪头三老师回复：

你看看这个代码里面的T 应该明白了

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;
}

我：

但是类声明里不是限定了吗

where T : Animal

大概明白了，foreach (T animal in farm)

因为T在这个类里已经被约束为Animal,所以通过上面这个foreach (T animal in farm) 搜索farm里面所有的Animal的类型，以及继承自Animal的类型，

在程序的主函数里，是这样的

            Farm farm = new Farm();
farm.Animals.Add(new Cow(“Jack”));
farm.Animals.Add(new Chicken(“Vera”));
farm.Animals.Add(new Chicken(“Sally”));
farm.Animals.Add(new SuperCow(“Kevin”));
farm.MakeNoises();

Farm dairyFarm = farm.GetCows();
dairyFarm.FeedTheAnimals();

Farm newFarm = farm + dairyFarm;

Farm类里的，自定义的+双目运算符为

 public static Farm operator +(Farm farm1, Farm farm2)
{
… …

        }

其中Cow类为继承自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;
}

这个隐式转换运算符自然能够，解决运行失败的问题

 

我：


但是类声明里不是限定了吗


where T : Animal


大概明白了，foreach (T animal in farm)


因为T在这个类里已经被约束为Animal,所以通过上面这个foreach (T animal in farm) 搜索farm里面所有的Animal的类型，以及继承自Animal的类型，


在程序的主函数里，是这样的


            Farm farm = new Farm();
farm.Animals.Add(new Cow(“Jack”));
farm.Animals.Add(new Chicken(“Vera”));
farm.Animals.Add(new Chicken(“Sally”));
farm.Animals.Add(new SuperCow(“Kevin”));
farm.MakeNoises();


Farm dairyFarm = farm.GetCows();
dairyFarm.FeedTheAnimals();


Farm newFarm = farm + dairyFarm;


Farm类里的，自定义的+双目运算符为


 public static Farm operator +(Farm farm1, Farm farm2)
{
… …


        }


其中Cow类为继承自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;
}


这个隐式转换运算符自然能够，解决运行失败的问题