标签: ienumerable

这是在C#中,我有一个类,我从其他人的DLL使用.它没有实现IEnumerable,但有两个传递IEnumerator的方法.有没有办法可以在这些上使用foreach循环.我正在使用的课程是密封的.

我创建了一个自定义通用队列,它实现了一个通用的IQueue接口,该接口使用System.Collections.Generic命名空间中的通用Qu​​eue作为私有内部队列.示例已清除不相关的代码.

public interface IQueue<TQueueItem>
{
    void Enqueue(TQueueItem queueItem);
    TQueueItem Dequeue();
}

public class CustomQueue<TQueueItem> : IQueue<TQueueItem>
{
    private readonly Queue<TQueueItem> queue = new Queue<TQueueItem>();
    ...
    public void Enqueue(TQueueItem queueItem)
    {
        ...
        queue.Enqueue( queueItem );
        ...
    }

    public TQueueItem Dequeue()
    {
        ...
        return queue.Dequeue();
        ...
    }
}

我希望保持与核心实现的一致性,并注意到核心Queue实现了IEnumerable,所以我将通过在类上显式实现IEnumerable或使用IQueue接口继承它来做同样的事情.

我想知道的是,当列举队列时,每个移动接下来要将下一个项目出列？我已经使用反射器来了解微软是如何做到的,他们所做的只是逐步通过队列私有阵列,但微软远非绝对不可靠,所以我想得到一般意见.

public class CustomQueue<TQueueItem> : IQueue<TQueueItem>, IEnumerable<TQueueItem>
{
    ...

    public IEnumerator<TQueueItem> GetEnumerator()
    {
        while (queue.Count > 0)
        {
            yield return Dequeue();
        }
    }

    //Or

    public IEnumerator<TQueueItem> GetEnumerator()
    {
        return queue.GetEnumerator();
    }

    ...
} …

想象一个类,让我们说可以与一个IList<T>或一个一起使用的分页IQueryable<T>.

该类将具有一个int TotalItems属性,该属性(不是那么令人惊讶)获取/设置可查询或可枚举参数的计数.

如果我IEnumerable<T>用作参数,

//simplified
public Pagination(IEnumerable<T> query)
    {
        TotalItems = query.Count();
    }

该Count()方法将是(如果我没看错,这就是问题所在)Enumerable.Count().因此,即使查询是IQueryable<T>(继承自IEnumerable<T>),它也将被枚举(使用"db query"显然不需要).

那么有什么方法可以Queryable.Count()在我IEnumerable<T>实际使用时使用方法IQueryable<T>,或者我必须改变我的设计,例如在这种情况下,2 ctor

//simplified
public Pagination(IEnumerable<T> query)
    {
         TotalItems = query.Count();
    }
public Pagination(IQueryable<T> query)
    {
         TotalItems = query.Count();
    }

编辑 我也明白,IQueryable<T>沿用IEnumerable<T>无关的事实,IEnumerable<T>并IQueryable<T>具有相同的扩展名的方法,而且它的好,有延期的方法相同的名字,"看起来他们做同样的",但我认为它仍然有时令人困惑......

好奇心的一般问题

它们是框架中的其他示例,具有相同的"体系结构":继承+扩展方法的通用名称？

我创建了两个名为X&Y的列表.这两个列表的类型不同.(即List<class_A> X&List<class_B> Y).

这两个列表中的值都不同.但是这DateTime两个列表中都有一个字段.

我需要根据date字段对这些列表进行排序.

我有单独的函数来打印列表A和列表B的详细信息.

假设排序列表看起来像

• 列表A中的元组,
• 列表B中的元组,
• 列表A中的元组,
• 列表B中的元组,

我的目的是遍历此列表并调用相应的函数来显示详细信息.即,如果元组来自列表A,则调用函数打印列表A的详细信息,反之亦然.

我正在使用Stream将流式传输IEnumerable<T>到流中的自定义实现.我正在使用此EnumerableStream实现来执行转换.

我正在使用它在流模式下通过WCF执行流式传输.我能够IEnumerable毫无问题地将其转换为流.有一次,我在客户端,我可以反序列化并获取所有数据,但是我无法找到停止循环流的条件.我越来越:

System.Runtime.Serialization.SerializationException:解析完成之前遇到的Stream of Stream.

这是我想要实现的示例:

class Program
{
    public static void Main()
    {
        var ListToSend = new List<List<string>>();
        var ListToReceive = new List<List<string>>();
        ListToSend = SimulateData().ToList();
        using (Stream stream = GetStream(ListToSend))
        {
            var formatter = new BinaryFormatter();
            while (stream.CanRead || 1 == 1 || true...) // What should I put in here to stop once I read everything???
            {
                List<string> row = formatter.Deserialize(stream) as List<string>;
                ListToReceive.Add(row);
            }
            Printer(ListToReceive);
            Console.WriteLine("Done");
        }
    } …

使用反射器我注意到该System.Linq.Enumerable.Count方法有一个条件来优化它,因为IEnumerable<T>传递实际上是一个ICollection<T>.如果转换成功,则Count方法不需要迭代每个元素,但可以调用ICollection的Count方法.

基于此,我开始认为IEnumerable<T>可以像集合的只读视图一样使用,而不会出现我最初基于API的性能损失.IEnumerable<T>

我感兴趣的是,Count当IEnumerable<T>a是一个Select语句的结果时,仍然保持优化ICollection,但是基于反映的代码,这种情况没有被优化,并且需要遍历所有元素.

你从反射器得出相同的结论吗？缺少这种优化背后的原因是什么？我似乎在这个常见的操作中浪费了很多时间.即使可以在不这样做的情况下确定Count ,规范是否要求评估每个元素？

如何启用我的BLL的自动排序,返回列表,CustomerList:GridView中的列表？

Customer是我自己的强类型类,CustomerList是客户列表.

我知道一种方法是在GridView中将AllowSorting属性设置为true并处理OnSorting事件并调用在CustomerList类中定义的排序方法.

但是我想要一个自动解决方案,我不需要处理OnSorting事件,它应该像GridView如何处理DataView,DataTable和DataSet的自动排序.

我需要在CustomerList或Customer类上实现一个能够实现该功能的接口吗？

alt text http://img260.imageshack.us/img260/3373/aa479347gridviewfg21enu.gif

我有一个简单的值类型:

    [Serializable]
    private struct TimerInstance
    {
        public TimerInstance(string str, long nTicks)
        {
            _name = str;
            _ticks = nTicks;
        }

        private readonly string _name;
        private readonly long _ticks;

        public string Name { get { return _name; } }
        public long Ticks { get { return _ticks; } }

        public override string ToString()
        {
            return string.Format("{0,20}: {1,10:N}", Name, Ticks);
        }
    }

你会注意到它是可序列化的.然后我列出了这些:

static private List<TimerInstance> _Timers = new List<TimerInstance>();

和一个LINQ方法,从列表中消除最低5%和前5%的计时器:

// Return items that should be persisted.  By convention, we are eliminating …

可能重复:
使用LINQ 获取序列的奇数/偶数部分
如何从List <T>中获取每个第n项？

我正在使用HtmlAgilityPack和C#来解析一些HTML.

<div id="post-8266">
<div class="ruler"> </div>
<div id="post-8266">
<div class="ruler"> </div>
<div id="post-8266">
<div class="ruler"> </div>
<div id="post-8266">
<div class="ruler"> </div>

基本上,我有这些元素,每个元素都在自己的对象中,在IEnumerable中.

是否有一种优雅的方式来获取集合中的每个N/2元素.意思是,用课跳过每个div .ruler？

我需要遍历生成的集合,因此要么将每个找到的对象复制到新的IEnumerable中,要么在foreach函数中使用它内联.

例如:

//Copying resulting set to new IEnumerable<T>:
var odds = elements.SelectOdds();

//Using it inline for my usage:
foreach (var x in elements.SelectOdds())
{   
}

哪种选择最好,我怎样才能做到这一点？

你如何确定方法是否应该返回IEnumerable<T>或IObservable<T>？

为什么我会选择一种范式而不是另一种？