C#中的IEnumerable

最新推荐文章于 2024-03-13 17:32:20 发布
最新推荐文章于 2024-03-13 17:32:20 发布
阅读量1.6w 收藏 23
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenweicode/article/details/90762523
版权

在MSDN上，是这么说的，它是一个公开枚举数，该枚举数支持在非范型集合上进行简单的迭代。

参考资料（非常好）：

https://www.cnblogs.com/fangyz/p/5721269.html

https://blog.csdn.net/weixin_42339460/article/details/80733758

以下为本人的调试代码：

代码1：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace 学习IEnumerable
{
    class Program
    {
        static void Main(string[] args)
        {
            FruitShop fruitShop = new FruitShop();
            Fruit fruitApple = new Fruit("Apple","10");
            Fruit fruitPear = new Fruit("Pear","12");
            Fruit fruitGrape = new Fruit("Grape","15");
            fruitShop.Add(fruitApple);
            fruitShop.Add(fruitPear);
            fruitShop.Add(fruitGrape);

            //调用自己实现的迭代器
            foreach (Fruit f in fruitShop)
            {
                Console.WriteLine(f.fruitName + ":" + f.fruitPrice);
            }

            Console.WriteLine("=============================================");

            CastAndOfType();

            Console.ReadLine();
        }

        //学习IEnumerable接口的两个扩展方法Cast<>(),OfType<>()
        static void CastAndOfType()
        {
            ArrayList fruits = new ArrayList(4);
            fruits.Add("Apple");
            fruits.Add("Pear");
            fruits.Add(2);
            fruits.Add(5);

            //下面的语句会报错，因为ArrayList没有实现IEnumerable<T>接口，故无法使用标准查询运算
            //IEnumerable<string> s = fruits.Select(str => str);

            IEnumerable<string> s1 = fruits.Cast<string>();
            IEnumerable<string> s2 = fruits.OfType<string>();
            //虽然Cast<T>和OfType<T>都可以用来进行转换，但是OfType<T>比Cast<T>更加强大，
            //它可以对结果进行筛选，而Cast<T>遇到无法强制转换的则会报错

            try
            {
                foreach (string fruit in s1)
                {
                    Console.WriteLine(fruit);
                }
            }
            catch (InvalidCastException invalid)
            {
                Console.WriteLine(invalid.Message);
            }

            foreach (string fruit in s2)
            {
                Console.WriteLine(fruit);
            }
        }
    }

    public class Fruit
    {
        public string fruitName;
        public string fruitPrice;

        public Fruit(string fruitName, string fruitPrice)
        {
            this.fruitName = fruitName;
            this.fruitPrice = fruitPrice;
        }
    }

    public class FruitShop : IEnumerable
    {
        Fruit[] fruits = new Fruit[3];
        int current = 0;

        public void Add(Fruit fruit)
        {
            fruits[current] = fruit;
            current++;
        }

        public IEnumerator GetEnumerator()
        {
            return new FruitEnumerator(fruits);
        }
    }

    //实现接口定义的方法
    public class FruitEnumerator : IEnumerator
    {
        Fruit[] fruits;
        int current = -1;

        public FruitEnumerator(Fruit[] fruits)
        {
            this.fruits = fruits;
        }

        public object Current
        {
            get
            {
                return CurrentFruit();
            }
        }

        object CurrentFruit()
        {
            if (current < 0 || current > fruits.Length)//此处是不是应该减1
                return null;
            else
                return fruits[current];
        }

        public bool MoveNext()
        {
            current++;
            if (current < fruits.Length && fruits[current] != null)
                return true;
            else
                return false;
        }

        public void Reset()
        {
            current = 0;
        }
    }
}

代码2：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace 深入学习IEnumerable
{
    class Program
    {
        static void Main(string[] args)
        {
            FruitShop fruitShop = new FruitShop();
            Fruit fruitApple = new Fruit("Apple");
            Fruit fruitPear = new Fruit("Pear");
            Fruit fruitGrape = new Fruit("Grape");
            fruitShop.Add(fruitApple);
            fruitShop.Add(fruitPear);
            fruitShop.Add(fruitGrape);

            IEnumerable<Fruit> s1 = fruitShop as IEnumerable<Fruit>;
            IEnumerable<Fruit> s2 = MyCast(fruitShop);

            Console.WriteLine("s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2s2");
            foreach (Fruit str in s2)
            {
                Console.WriteLine(str.fruitName);
            }

            //Console.WriteLine("s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1");
            //foreach (Fruit str in s1)
            //{
            //    Console.WriteLine(str.fruitName);
            //}

            Console.ReadLine();
        }

        static IEnumerable<Fruit> MyCast(FruitShop fruitShop)
        {
            IEnumerable<Fruit> typedSource = fruitShop as IEnumerable<Fruit>;
            if (typedSource != null)
                return typedSource;

            if (fruitShop == null)
                throw new Exception("fruitShop == null");

            return CastIterator<Fruit>(fruitShop);
        }

        static IEnumerable<TResult> CastIterator<TResult>(IEnumerable source)
        {
            foreach (object obj in source)
            {
                yield return (TResult)obj;
            }
        }
    }

    public class Fruit
    {
        public string fruitName;
        public string fruitPrice;

        public Fruit(string fruitName, string fruitPrice = "10")
        {
            this.fruitName = fruitName;
            this.fruitPrice = fruitPrice;
        }
    }

    public class FruitShop : IEnumerable
    {
        Fruit[] fruits = new Fruit[3];
        int current = 0;

        public void Add(Fruit fruit)
        {
            fruits[current] = fruit;
            current++;
        }

        public IEnumerator GetEnumerator()
        {
            return new FruitEnumerator(fruits);
        }
    }

    //实现接口定义的方法
    public class FruitEnumerator : IEnumerator
    {
        Fruit[] fruits;
        int current = -1;

        public FruitEnumerator(Fruit[] fruits)
        {
            this.fruits = fruits;
        }

        public object Current
        {
            get
            {
                return CurrentFruit();
            }
        }

        object CurrentFruit()
        {
            if (current < 0 || current > fruits.Length)//此处是不是应该减1
                return null;
            else
                return fruits[current];
        }

        public bool MoveNext()
        {
            current++;
            if (current < fruits.Length && fruits[current] != null)
                return true;
            else
                return false;
        }

        public void Reset()
        {
            current = 0;
        }
    }
}

代码3：

using System;
using System.Collections;

namespace 再次深入学习IEnumerable
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] strList = new string[] { "chenwei","male","15601598187"};
            MyIEnumerable my = new MyIEnumerable(strList);

            Console.WriteLine("==========开始调用自己实现的迭代器==========");
            //第一步：获取IEnunerator接口实例
            var tst = my.GetEnumerator();

            //第二步：判断是否可以继续循环
            while (tst.MoveNext())
            {
                //第三步：取值
                Console.WriteLine(tst.Current);
            }

            Console.WriteLine("通过foreach来取值（效果同上，因为IL代码是一样的）");
            foreach (var item in my)
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
    }

    //为什么都用数组做容器？可以用List吗？？？
    //可以

    //.net中迭代器是通过IEnumerable和IEnumerator接口来实现的。
    //可以照葫芦画瓢，实现自己的迭代器。
    //IEnumerable只有一个返回IEnumerator的GetEnumerator方法。
    //而IEnumerator中有两个方法加一个属性。
    public class MyIEnumerable : IEnumerable
    {
        private string[] strList;

        public MyIEnumerable(string[] _strList)
        {
            strList = _strList;
        }

        public IEnumerator GetEnumerator()
        {
            return new MyIEnumerator(strList);
        }
    }

    public class MyIEnumerator:IEnumerator
    {
        private string[] strList;
        private int position;

        public MyIEnumerator(string[] _strList)
        {
            strList = _strList;
            position = -1;
        }

        //因为只有get没有set，所以foreach中不能修改item的值
        public object Current
        {
            get{return strList[position];}
        }

        public bool MoveNext()
        {
            position++;
            if(position < strList.Length)
                return true;
            else
                return false;
        }

        public void Reset()
        {
            position = -1;
        }
    }
}

代码4：

using System;
using System.Collections;

namespace 实现foreach需要满足什么条件
{
    //继“再次深入学习IEnumerable”之后，有如下疑问：
    //实现foreach需要什么条件？
    //必须实现IEnumerable接口？NO！
    //我们把自己写的MyIEnumerable删掉后面的IEnumerable接口一样可以foreach。
    //所以要可以foreach只需要对象定义了GetEnumerator无参方法，并且返回值是IEnumerator或其对应的范型。
    //也就是说，只要三步就可以了，不一定要继承与IEnumerable。
    //第一步：“获取IEnumerator实例”
    //第二步：“判断是否可以继续循环”
    //第三步：“取值”
    class Program
    {
        static void Main(string[] args)
        {
            string[] strList = new string[] { "chenwei", "male", "15601598187" };
            MyIEnumerable my = new MyIEnumerable(strList);

            Console.WriteLine("==========开始调用自己实现的迭代器==========");
            //第一步：获取IEnunerator接口实例
            var tst = my.GetEnumerator();

            //第二步：判断是否可以继续循环
            while (tst.MoveNext())
            {
                //第三步：取值
                Console.WriteLine(tst.Current);
            }

            Console.WriteLine("通过foreach来取值（效果同上，因为IL代码是一样的）");
            foreach (var item in my)
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
    }

    public class MyIEnumerable
    {
        private string[] strList;

        public MyIEnumerable(string[] _strList)
        {
            strList = _strList;
        }

        public IEnumerator GetEnumerator()
        {
            return new MyIEnumerator(strList);

            //实际连MyIEnumerator都可以不要，yield就可以了。
            //for (int i = 0; i < strList.Length; i++)
            //{
            //    yield return strList[i];
            //}
        }
    }

    public class MyIEnumerator : IEnumerator
    {
        private string[] strList;
        private int position;

        public MyIEnumerator(string[] _strList)
        {
            strList = _strList;
            position = -1;
        }

        //因为只有get没有set，所以foreach中不能修改item的值
        public object Current
        {
            get { return strList[position]; }
        }

        public bool MoveNext()
        {
            position++;
            if (position < strList.Length)
                return true;
            else
                return false;
        }

        public void Reset()
        {
            position = -1;
        }
    }
}

 

coder_chenwei
关注
  • 4
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#中的IEnumerable简介及简单实现实例
09-03
主要介绍了C#中的IEnumerable简介及简单实现实例,本文讲解了IEnumerable一些知识并给出了一个简单的实现,需要的朋友可以参考下
C#实现IEnumerable接口
yasenRK的博客
03-08 1604
C#实现IEnumerable接口 public class Person { public Person(string f,string l) { this.FirstName = f; this.LastName = l; } public string LastNa...
详解C# 迭代器
weixin_33918357的博客
03-17 918
    迭代器模式是设计模式中行为模式(behavioral pattern)的一个例子，他是一种简化对象间通讯的模式，也是一种非常容易理解和使用的模式。简单来说，迭代器模式使得你能够获取到序列中的所有元素而不用关心是其类型是array，list，linked list或者是其他什么序列结构。这一点使得能够非常高效的构建数据处理通道(data pipeline)--即数据能够进入处理通道，进行一系...
C#中IEnumerable＜string＞和IList＜string＞的区别
最新发布
weixin_46407807的博客
03-13 539
总结：IList更加厉害，IEnumerable只能迭代不能改（跟枚举类型enum联系起来）是两种不同的接口，它们具有不同的特性和用途。
C# foreach详解 涉及迭代器的内容 IEnumerable与其泛型的实现
qq_14812585的博客
01-24 558
var lstStr = new List&lt;string&gt; { "a", "b" }; foreach (var str in lstStr) { Console.WriteLine(str); } //这是foreach的使用 //实际上内部是这样的 var lstStr = new List&lt;string&gt; {"a",...
C#学习笔记（七）—–集合--IEnumerable和IEnumerator接口
瓦力的博客
05-24 3005
IEnumerable IEnumerator foreach IEnumerable<T> IEnumerator<T>
IEnumerable（C#）
qq_64410237的博客
07-13 3328
foreach 循环会自动调用集合的 GetEnumerator() 方法，然后使用枚举器来逐个访问集合中的元素。在这个示例中，MyCollection 类实现了 IEnumerable 接口，并提供了一个 GetEnumerator() 方法用于返回一个枚举器。通过 foreach 循环，在 Main 方法中遍历 MyCollection 对象时，会自动调用其 GetEnumerator() 方法获取枚举器，并使用该枚举器的 MoveNext() 和 Current 属性来逐个访问集合中的元素。
转载-------C#基础之IEnumerable
chengquying3939的博客
08-10 1691
1.IEnumerable的作用 　　在使用Linq查询数据时经常以IEnumerable<T>来作为数据查询返回对象，在使用foreach进行遍历时需要该对象实现IEnumerable接口，这2个功能让我对IEnumerable充满了无穷的好奇。然而在VS中查看IEnumera...
C#中的IEnumerable、IEnumerator、Yield
m0_57527977的博客
03-21 4497
IEnumerable/IEnumerator/Yield
C# IEnumerable
lvxingzhe3的博客
03-10 6723
C# IEnumerable,自定义类添加迭代
C#中IEnumerable接口用法实例分析
09-03
主要介绍了C#中IEnumerable接口用法,实例分析了IEnumerable接口的功能与使用技巧,需要的朋友可以参考下
C#中IEnumerable、ICollection、IList、List之间的区别
09-03
主要介绍了C#中IEnumerable、ICollection、IList、List之间的区别,本文分别分析了它的实现源码,从而总结出了它们之间的关系和不同之处,需要的朋友可以参考下
C#中IEumerable的简单了解
qq_39806817的博客
03-22 2346
IEnumerable是可枚举类型，一般在迭代中应用广泛，如foreach中要循环访问的集合或数组都实现了IEnumerable接口。 现以一个实例遍历数组: IEnumerableTest enumerableTest = new IEnumerableTest(); enumerableTest.Show(); ------------------------------------------------------ public class IEnumerableTest
C#的IEnumerable可枚举的集合
ultramand的博客
01-11 1063
接口是 .NET 中集合类的基础接口之一，包括数组、列表、字典等常见的集合类都实现了该接口。它提供了一种标准的方式来遍历集合中的元素，使用迭代器模式实现了对集合的迭代访问。它提供了一种标准的方式来遍历集合中的元素，使用迭代器模式实现了对集合的迭代访问。这种方式可以提供一种统一的方法来处理不同类型的集合，并通过迭代器实现惰性加载，避免一次性加载整个集合的开销。这种方式可以提供一种统一的方法来处理不同类型的集合，并通过迭代器实现惰性加载，避免一次性加载整个集合的开销。接口的迭代器对象，用于遍历集合中的元素。
C#IEnumberable＜＞
ultramand的博客
08-04 1529
IEnumerable接口定义了一个名为GetEnumerator的方法，该方法返回一个实现了IEnumerator接口的枚举器。IEnumerator接口提供了对集合中元素的访问和操作，它包含了MoveNext、Current和Reset等方法，用于在集合上进行迭代。在C#中，IEnumerable是一个泛型接口，用于表示一个可枚举的集合。在Main方法中，我们创建了一个MyCollection实例，并使用foreach语句遍历集合中的元素并输出到控制台。方法中，我们创建了一个。
C# IEnumerable＜T＞介绍
琅嬛福地
11-18 1488
IEnumerable 只有一个方法，即 GetEnumerator，该方法返回一个 IEnumerator 对象。IEnumerator 对象用于迭代集合，它提供了 MoveNext 方法（用于移动到集合的下一个元素），Current 属性（获取当前元素）和 Reset 方法（将枚举器设置回其初始位置，但这个方法通常不会被实现或使用）。IEnumerable 是 C# 中的一个接口，它是 .NET Framework 中的集合类型的基础。接口的一部分，它返回一个。方法会被调用，然后返回的。
C# 常用接口学习 IEnumerable<T>
zls365365的博客
06-02 2930
我们先去看看公开的.Net4.0的源程序中IEnumerable<T>、IEnumerable、IEnumerator<T>和IEnumerator这四个接口是如何...
C#中的IQueryable vs IEnumerable
weixin_43263355的博客
12-02 7179
概要 我们在应用开发中经常用到IQueryable 和 IEnumerable两个接口。如果这两个接口搞混，往往会对程序性能造成很大的影响。 本文以一个实例来区分这两个接口，说明在实际开发过程中，这两个接口如何使用。 基本定义 IEnumerable IEnumerable 是一个接口，客户代码通过实现该接口的GetEnumerator方法，来返回一个具体的IEnumerator. 在实际应用中，IEnumerable 面向内存对象，它会将所有的数据载入到内存中，再进行各种操作。 **IQueryable
C#中IEnumerable的使用
05-27
在C#中，IEnumerable接口是用于支持枚举器（enumerator）的基本接口。枚举器用于循环访问集合中的元素。IEnumerable接口提供了一个方法GetEnumerator()，该方法返回一个实现IEnumerator接口的对象，该对象用于遍历...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值