在线急等，重载泛型转换运算符的错误

Question

下面这个编译报错：
class Farm<T>
    {
        public static implicit operator ArrayList(Farm<bool> farm)
        {
            ArrayList al = new ArrayList();
            return al;
        }
    }
下面这么写编译就正确：
class Farm<T>
    {
        public static implicit operator ArrayList(Farm<T> farm)
        {
            ArrayList al = new ArrayList();
            return al;
        }
    }
为什么，急等高手。。

Answer 1

class   Farm <bool> 
        { 
                public   static   implicit   operator   ArrayList(Farm <bool>   farm) 
                { 
                        ArrayList   al   =   new   ArrayList(); 
                        return   al; 
                } 
        } 就ok了,泛型使用的基本概念呀

Answer 2

楼上搞笑了哈，如果一个类写出class       Farm   <bool>  还有什么意义啊 ^_^

Answer 3

晕倒,bool是使用类的时候传入的吧，不知道你写成那样想要实现什么~

Answer 4

class   Farm <T> 
        { 
                public   static   implicit   operator   ArrayList(Farm <bool>   farm) 
                { 
                        ArrayList   al   =   new   ArrayList(); 
                        return   al; 
                } 
        } 不论我想实现什么，从逻辑从语法或从什么方面来说，这么写都讲的通，就是道理上讲得通但是编译错误提示错误消息 
用户定义的转换必须是转换成封闭类型，或者从封闭类型转换
用户定义的转换例程必须转换成包含该例程的类，或者从包含该例程的类进行转换。用微软的例子解释是// CS0556.cs
namespace x
{
   public class ii
   {
      public class iii
      {
         public static implicit operator int(byte aa)   // CS0556
         // try the following line instead
         // public static implicit operator int(iii aa)
         {
            return 0;
         }
      }      public static void Main()
      {
      }
   }
}我只是疑惑为什么要有这个规定而已放在这里晾分吧，估计也没人回答

Answer 5

using System;
using System.Collections;public class ii
{
    class Farm<T>
    {
        public static implicit operator ArrayList(Farm<bool> farm)
        {
            ArrayList al = new ArrayList();
            return al;
        }
    }    public static void Main()
    {
        // 假设你有自定义类型 Class A , Class B , Class C
        // 你绝不可能把类 A 转类 B 的重载操作符定义在类 C 里
        
        // 同样，当声明为如下形式时，
        Farm<char> farm = new Farm<char>();
        // Farm<bool> 类相当于类 A 
        // 而 ArrayList 相当于类 B
        // Farm<char> 类相当于类 C 
        // 编译器考虑到这种出错的可能，所以不允许你这么写
        // Farm<T> 虽然看起来很像是个类，但 Farm<T> 其实是个模版
        // JIT 在编译的时候利用这个模版来生成 Farm<char> Farm<bool> 这些真正叫作类的东西。        // 所以你在模版里的重载操作符
        public static implicit operator ArrayList(Farm<bool> farm);
        // 实际上也它是一个模版
        // JIT 编译时会根据这个模版动态生成真正的重载操作符
        // 且重载操作符绝对合法
        // 所以编译器通过
    }
}

Answer 6

        // 所以你在模版里的重载操作符
        public static implicit operator ArrayList(Farm<T> farm);
        // 实际上它也是一个模版
        // JIT 编译时会根据这个模版动态生成真正的重载操作符
        // 且重载操作符绝对合法
        // 所以编译器通过

Answer 7

楼上的精神让我感动，不管你说的对不对我都会给你加分的。可惜我这人就是一根筋加脑袋笨我问
class   Farm <T> 
        { 
                public   static   implicit   operator   ArrayList(Farm <bool>   farm) 
                { 
                        ArrayList   al   =   new   ArrayList(); 
                        return   al; 
                } 
        } 
为什么编译报错，好像阁下并没有回答阁下只是回答了那个 编译正确的为什么正确而已
// 所以你在模版里的重载操作符
        public static implicit operator ArrayList(Farm<T> farm);
        // 实际上它也是一个模版
        // JIT 编译时会根据这个模版动态生成真正的重载操作符
        // 且重载操作符绝对合法
        // 所以编译器通过

Answer 8

讲的很好，尤其是这个比喻
之前我没认真看，对不起了
你让我明白了
Farm<char> 
Farm<bool>
是不同的类谢谢了！！！