public interface IEnumerable
    {
        IEnumerator GetEnumerator();
    }

    public interface IEnumerator
    {//获取集合中的当前元素。
        object Current { get; }//将枚举数推进到集合的下一个元素。
        bool MoveNext();//将枚举数设置为其初始位置，该位置位于集合中第一个元素之前。
        void Reset();
    }

    class User
    {
        public User(string fName, string lName)
        {
            this.firstName = fName;
            this.lastName = lName;
        }
        public string firstName;
        public string lastName;
    }

        static void Main(string[] args)
        {
            User[] user = new User[] {
                new User("John", "Smith"),
                new User("Jim", "Johnson"),
                new User("Sue", "Rabon"),
            };
            foreach (User u in user)
            {
                Console.WriteLine(u.firstName);
            }

            Console.ReadKey();
        }
//此处之所以可以用foreach循环，是因为定义的类型其实是一个数组类型，因为数组类型已经实现了IEnumerable接口，并对其进行了实现.

MSDN中的例子，其实就是对数组重写了http://msdn.microsoft.com/zh-cn/library/vstudio/system.collections.ienumerable.aspx

        static void Main(string[] args)
        {
            User use = new User("dddd","ffff");
            foreach (string s in use)
            {
                Console.WriteLine(s);
            }
            Console.ReadKey();
        }
//这里会提示错误：User不包含GetEnumerator的公共定义，因此foreach语句不能作用与User类型的变量

       //调用1

ExtraGenericInterface(typeof(List<User>),typeof(IEnumerable<>))

//调用2

ExtraGenericInterface(typeof(IEnumerable<User>),typeof(IEnumerable<>))

　　　　public Type ExtraGenericInterface(Type queryType, Type interfaceType)
        {
            //当前类型queryType是否是泛型
            bool b = queryType.IsGenericType;
            //返回可以构造当前泛型类型的一个泛型类型，即：由IEnumerable<User>得到 IEnumerable<>
            Type tt = queryType.GetGenericTypeDefinition();

            bool ttt = tt == interfaceType ? true : false;

            Func<Type, bool> predicate = t => t.IsGenericType && (t.GetGenericTypeDefinition() == interfaceType);
            //Func<Type, bool> predicate = delegate(Type queryType2){return false;};
            //如果当前类型是泛型，并且该发行是由interfaceType类型构造的。
            if (predicate(queryType))
            {
                return queryType;
            }
            else
            {
                //获取当前类实现的所有类和接口
                Type[] types = queryType.GetInterfaces();
                //在数组中找，并返回满足 predicate 条件的第一个元素
                //也就是在所有父类或实现的接口中找到是泛型并且构造此泛型的类型是interfaceType类型的第一个元素

//FirstOrDefault<Type>中Type是后面委托predicate的参数类型　
                Type tttt = types.FirstOrDefault<Type>(predicate);

                return queryType.GetInterfaces().FirstOrDefault<Type>(predicate);
            }
            
        }