blocks|key|937061|text|每一个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937062|对于纯粹主义者来说什么都不是，但是它非常有用！|937063|+public+static+void+Each<T>(this+IEnumerable<T>+items,+Action<T>+action)
+{
+++foreach+(var+i+in+items)
++++++action(i);
+}|code-block|syntax|javascript|937064|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>Each</h2>

<p>Nothing for the purists, but darn it's useful!</p>

<pre><code> public static void Each&lt;T&gt;(this IEnumerable&lt;T&gt; items, Action&lt;T&gt; action)
 {
   foreach (var i in items)
      action(i);
 }
</code></pre>


blocks|key|937091|text|订单|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937092|///+<summary>Sorts+the+elements+of+a+sequence+in+ascending+order.</summary>
public+static+IEnumerable<T>+Order<T>(this+IEnumerable<T>+source)
{
++++return+source.OrderBy(x+=>+x);
}|code-block|syntax|javascript|937093|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>Order</h2>

<pre><code>/// &lt;summary&gt;Sorts the elements of a sequence in ascending order.&lt;/summary&gt;
public static IEnumerable&lt;T&gt; Order&lt;T&gt;(this IEnumerable&lt;T&gt; source)
{
    return source.OrderBy(x =&gt; x);
}
</code></pre>


blocks|key|1151436|text|附加和准备|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151437|(自编写此答案以来，这些内容已添加到.NET中。)|1151438|///+<summary>Adds+a+single+element+to+the+end+of+an+IEnumerable.</summary>
///+<typeparam+name="T">Type+of+enumerable+to+return.</typeparam>
///+<returns>IEnumerable+containing+all+the+input+elements,+followed+by+the
///+specified+additional+element.</returns>
public+static+IEnumerable<T>+Append<T>(this+IEnumerable<T>+source,+T+element)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++return+concatIterator(element,+source,+false);
}

///+<summary>Adds+a+single+element+to+the+start+of+an+IEnumerable.</summary>
///+<typeparam+name="T">Type+of+enumerable+to+return.</typeparam>
///+<returns>IEnumerable+containing+the+specified+additional+element,+followed+by
///+all+the+input+elements.</returns>
public+static+IEnumerable<T>+Prepend<T>(this+IEnumerable<T>+tail,+T+head)
{
++++if+(tail+==+null)
++++++++throw+new+ArgumentNullException("tail");
++++return+concatIterator(head,+tail,+true);
}

private+static+IEnumerable<T>+concatIterator<T>(T+extraElement,
++++IEnumerable<T>+source,+bool+insertAtStart)
{
++++if+(insertAtStart)
++++++++yield+return+extraElement;
++++foreach+(var+e+in+source)
++++++++yield+return+e;
++++if+(!insertAtStart)
++++++++yield+return+extraElement;
}|code-block|syntax|javascript|1151439|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>Append &amp; Prepend</h2>

<p>(These have been added to .NET since this answer was written.)</p>

<pre><code>/// &lt;summary&gt;Adds a single element to the end of an IEnumerable.&lt;/summary&gt;
/// &lt;typeparam name="T"&gt;Type of enumerable to return.&lt;/typeparam&gt;
/// &lt;returns&gt;IEnumerable containing all the input elements, followed by the
/// specified additional element.&lt;/returns&gt;
public static IEnumerable&lt;T&gt; Append&lt;T&gt;(this IEnumerable&lt;T&gt; source, T element)
{
    if (source == null)
        throw new ArgumentNullException("source");
    return concatIterator(element, source, false);
}

/// &lt;summary&gt;Adds a single element to the start of an IEnumerable.&lt;/summary&gt;
/// &lt;typeparam name="T"&gt;Type of enumerable to return.&lt;/typeparam&gt;
/// &lt;returns&gt;IEnumerable containing the specified additional element, followed by
/// all the input elements.&lt;/returns&gt;
public static IEnumerable&lt;T&gt; Prepend&lt;T&gt;(this IEnumerable&lt;T&gt; tail, T head)
{
    if (tail == null)
        throw new ArgumentNullException("tail");
    return concatIterator(head, tail, true);
}

private static IEnumerable&lt;T&gt; concatIterator&lt;T&gt;(T extraElement,
    IEnumerable&lt;T&gt; source, bool insertAtStart)
{
    if (insertAtStart)
        yield return extraElement;
    foreach (var e in source)
        yield return e;
    if (!insertAtStart)
        yield return extraElement;
}
</code></pre>


blocks|key|937167|text|指定了默认值的FirstOrDefault|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937168|///+<summary>
///+Returns+the+first+element+of+a+sequence,+or+a+default+value+if+the
///+sequence+contains+no+elements.
///+</summary>
///+<typeparam+name="T">The+type+of+the+elements+of
///+<paramref+name="source"/>.</typeparam>
///+<param+name="source">The+<see+cref="IEnumerable&lt;T&gt;"/>+to+return
///+the+first+element+of.</param>
///+<param+name="default">The+default+value+to+return+if+the+sequence+contains
///+no+elements.</param>
///+<returns><paramref+name="default"/>+if+<paramref+name="source"/>+is+empty;
///+otherwise,+the+first+element+in+<paramref+name="source"/>.</returns>
public+static+T+FirstOrDefault<T>(this+IEnumerable<T>+source,+T+@default)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++using+(var+e+=+source.GetEnumerator())
++++{
++++++++if+(!e.MoveNext())
++++++++++++return+@default;
++++++++return+e.Current;
++++}
}

///+<summary>
///+Returns+the+first+element+of+a+sequence,+or+a+default+value+if+the+sequence
///+contains+no+elements.
///+</summary>
///+<typeparam+name="T">The+type+of+the+elements+of
///+<paramref+name="source"/>.</typeparam>
///+<param+name="source">The+<see+cref="IEnumerable&lt;T&gt;"/>+to+return
///+the+first+element+of.</param>
///+<param+name="predicate">A+function+to+test+each+element+for+a
///+condition.</param>
///+<param+name="default">The+default+value+to+return+if+the+sequence+contains
///+no+elements.</param>
///+<returns><paramref+name="default"/>+if+<paramref+name="source"/>+is+empty
///+or+if+no+element+passes+the+test+specified+by+<paramref+name="predicate"/>;
///+otherwise,+the+first+element+in+<paramref+name="source"/>+that+passes
///+the+test+specified+by+<paramref+name="predicate"/>.</returns>
public+static+T+FirstOrDefault<T>(this+IEnumerable<T>+source,
++++Func<T,+bool>+predicate,+T+@default)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++if+(predicate+==+null)
++++++++throw+new+ArgumentNullException("predicate");
++++using+(var+e+=+source.GetEnumerator())
++++{
++++++++while+(true)
++++++++{
++++++++++++if+(!e.MoveNext())
++++++++++++++++return+@default;
++++++++++++if+(predicate(e.Current))
++++++++++++++++return+e.Current;
++++++++}
++++}
}|code-block|syntax|javascript|937169|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>FirstOrDefault with a default value specified</h2>

<pre><code>/// &lt;summary&gt;
/// Returns the first element of a sequence, or a default value if the
/// sequence contains no elements.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the elements of
/// &lt;paramref name="source"/&gt;.&lt;/typeparam&gt;
/// &lt;param name="source"&gt;The &lt;see cref="IEnumerable&amp;lt;T&amp;gt;"/&gt; to return
/// the first element of.&lt;/param&gt;
/// &lt;param name="default"&gt;The default value to return if the sequence contains
/// no elements.&lt;/param&gt;
/// &lt;returns&gt;&lt;paramref name="default"/&gt; if &lt;paramref name="source"/&gt; is empty;
/// otherwise, the first element in &lt;paramref name="source"/&gt;.&lt;/returns&gt;
public static T FirstOrDefault&lt;T&gt;(this IEnumerable&lt;T&gt; source, T @default)
{
    if (source == null)
        throw new ArgumentNullException("source");
    using (var e = source.GetEnumerator())
    {
        if (!e.MoveNext())
            return @default;
        return e.Current;
    }
}

/// &lt;summary&gt;
/// Returns the first element of a sequence, or a default value if the sequence
/// contains no elements.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the elements of
/// &lt;paramref name="source"/&gt;.&lt;/typeparam&gt;
/// &lt;param name="source"&gt;The &lt;see cref="IEnumerable&amp;lt;T&amp;gt;"/&gt; to return
/// the first element of.&lt;/param&gt;
/// &lt;param name="predicate"&gt;A function to test each element for a
/// condition.&lt;/param&gt;
/// &lt;param name="default"&gt;The default value to return if the sequence contains
/// no elements.&lt;/param&gt;
/// &lt;returns&gt;&lt;paramref name="default"/&gt; if &lt;paramref name="source"/&gt; is empty
/// or if no element passes the test specified by &lt;paramref name="predicate"/&gt;;
/// otherwise, the first element in &lt;paramref name="source"/&gt; that passes
/// the test specified by &lt;paramref name="predicate"/&gt;.&lt;/returns&gt;
public static T FirstOrDefault&lt;T&gt;(this IEnumerable&lt;T&gt; source,
    Func&lt;T, bool&gt; predicate, T @default)
{
    if (source == null)
        throw new ArgumentNullException("source");
    if (predicate == null)
        throw new ArgumentNullException("predicate");
    using (var e = source.GetEnumerator())
    {
        while (true)
        {
            if (!e.MoveNext())
                return @default;
            if (predicate(e.Current))
                return e.Current;
        }
    }
}
</code></pre>


blocks|key|937178|text|IndexOf|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937179|///+<summary>
///+Returns+the+index+of+the+first+element+in+this+<paramref+name="source"/>
///+satisfying+the+specified+<paramref+name="condition"/>.+If+no+such+elements
///+are+found,+returns+-1.
///+</summary>
public+static+int+IndexOf<T>(this+IEnumerable<T>+source,+Func<T,+bool>+condition)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++if+(condition+==+null)
++++++++throw+new+ArgumentNullException("condition");
++++int+index+=+0;
++++foreach+(var+v+in+source)
++++{
++++++++if+(condition(v))
++++++++++++return+index;
++++++++index%2B%2B;
++++}
++++return+-1;
}|code-block|syntax|javascript|937180|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>IndexOf</h2>

<pre><code>/// &lt;summary&gt;
/// Returns the index of the first element in this &lt;paramref name="source"/&gt;
/// satisfying the specified &lt;paramref name="condition"/&gt;. If no such elements
/// are found, returns -1.
/// &lt;/summary&gt;
public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; source, Func&lt;T, bool&gt; condition)
{
    if (source == null)
        throw new ArgumentNullException("source");
    if (condition == null)
        throw new ArgumentNullException("condition");
    int index = 0;
    foreach (var v in source)
    {
        if (condition(v))
            return index;
        index++;
    }
    return -1;
}
</code></pre>


blocks|key|937231|text|MinElement|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937232|Min仅返回指定表达式返回的最小值，而不返回提供此最小元素的原始元素。|offset|length|style|CODE|937233|///+<summary>Returns+the+first+element+from+the+input+sequence+for+which+the
///+value+selector+returns+the+smallest+value.</summary>
public+static+T+MinElement<T,+TValue>(this+IEnumerable<T>+source,
++++++++Func<T,+TValue>+valueSelector)+where+TValue+:+IComparable<TValue>
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++if+(valueSelector+==+null)
++++++++throw+new+ArgumentNullException("valueSelector");
++++using+(var+enumerator+=+source.GetEnumerator())
++++{
++++++++if+(!enumerator.MoveNext())
++++++++++++throw+new+InvalidOperationException("source+contains+no+elements.");
++++++++T+minElem+=+enumerator.Current;
++++++++TValue+minValue+=+valueSelector(minElem);
++++++++while+(enumerator.MoveNext())
++++++++{
++++++++++++TValue+value+=+valueSelector(enumerator.Current);
++++++++++++if+(value.CompareTo(minValue)+<+0)
++++++++++++{
++++++++++++++++minValue+=+value;
++++++++++++++++minElem+=+enumerator.Current;
++++++++++++}
++++++++}
++++++++return+minElem;
++++}
}|code-block|syntax|javascript|937234|entityMap^0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<h2>MinElement</h2>

<p><code>Min</code> only returns the minimum value returned by the specified expression, but not the original element that gave this minimum element.</p>

<pre><code>/// &lt;summary&gt;Returns the first element from the input sequence for which the
/// value selector returns the smallest value.&lt;/summary&gt;
public static T MinElement&lt;T, TValue&gt;(this IEnumerable&lt;T&gt; source,
        Func&lt;T, TValue&gt; valueSelector) where TValue : IComparable&lt;TValue&gt;
{
    if (source == null)
        throw new ArgumentNullException("source");
    if (valueSelector == null)
        throw new ArgumentNullException("valueSelector");
    using (var enumerator = source.GetEnumerator())
    {
        if (!enumerator.MoveNext())
            throw new InvalidOperationException("source contains no elements.");
        T minElem = enumerator.Current;
        TValue minValue = valueSelector(minElem);
        while (enumerator.MoveNext())
        {
            TValue value = valueSelector(enumerator.Current);
            if (value.CompareTo(minValue) &lt; 0)
            {
                minValue = value;
                minElem = enumerator.Current;
            }
        }
        return minElem;
    }
}
</code></pre>


blocks|key|937247|text|ToQueue和ToStack|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937248|///+<summary>Creates+a+<see+cref="Queue&lt;T&gt;"/>+from+an+enumerable
///+collection.</summary>
public+static+Queue<T>+ToQueue<T>(this+IEnumerable<T>+source)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++return+new+Queue<T>(source);
}

///+<summary>Creates+a+<see+cref="Stack&lt;T&gt;"/>+from+an+enumerable
///+collection.</summary>
public+static+Stack<T>+ToStack<T>(this+IEnumerable<T>+source)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++return+new+Stack<T>(source);
}|code-block|syntax|javascript|937249|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>ToQueue &amp; ToStack</h2>

<pre><code>/// &lt;summary&gt;Creates a &lt;see cref="Queue&amp;lt;T&amp;gt;"/&gt; from an enumerable
/// collection.&lt;/summary&gt;
public static Queue&lt;T&gt; ToQueue&lt;T&gt;(this IEnumerable&lt;T&gt; source)
{
    if (source == null)
        throw new ArgumentNullException("source");
    return new Queue&lt;T&gt;(source);
}

/// &lt;summary&gt;Creates a &lt;see cref="Stack&amp;lt;T&amp;gt;"/&gt; from an enumerable
/// collection.&lt;/summary&gt;
public static Stack&lt;T&gt; ToStack&lt;T&gt;(this IEnumerable&lt;T&gt; source)
{
    if (source == null)
        throw new ArgumentNullException("source");
    return new Stack&lt;T&gt;(source);
}
</code></pre>


blocks|key|937278|text|Chunks|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937279|返回特定大小的块。1,2,3,4,5的x.Chunks(2)将返回两个带有1,2和3,4的数组。x.Chunks(2,true)将返回1,2、3,4和5。|offset|length|style|CODE|937280|public+static+IEnumerable<T[]>+Chunks<T>(this+IEnumerable<T>+xs,+int+size,+bool+returnRest+=+false)
{
++++var+curr+=+new+T[size];

++++int+i+=+0;

++++foreach+(var+x+in+xs)
++++{
++++++++if+(i+==+size)
++++++++{
++++++++++++yield+return+curr;
++++++++++++i+=+0;
++++++++++++curr+=+new+T[size];
++++++++}

++++++++curr[i%2B%2B]+=+x;
++++}

++++if+(returnRest)
++++++++yield+return+curr.Take(i).ToArray();
}|code-block|syntax|javascript|937281|entityMap^0|0|9|9|J|B|11|3|15|3|1C|G|1V|3|1Z|3|23|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|N|$]]

<h2>Chunks</h2>

<p>Returns chunks of a specific size. <code>x.Chunks(2)</code> of <code>1,2,3,4,5</code> will return two arrays with <code>1,2</code> and <code>3,4</code>. <code>x.Chunks(2,true)</code> will return <code>1,2</code>, <code>3,4</code> and <code>5</code>.</p>

<pre><code>public static IEnumerable&lt;T[]&gt; Chunks&lt;T&gt;(this IEnumerable&lt;T&gt; xs, int size, bool returnRest = false)
{
    var curr = new T[size];

    int i = 0;

    foreach (var x in xs)
    {
        if (i == size)
        {
            yield return curr;
            i = 0;
            curr = new T[size];
        }

        curr[i++] = x;
    }

    if (returnRest)
        yield return curr.Take(i).ToArray();
}
</code></pre>


blocks|key|937308|text|SkipLast和TakeLast|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937309|///+<summary>
///+Enumerates+the+items+of+this+collection,+skipping+the+last
///+<paramref+name="count"/>+items.+Note+that+the+memory+usage+of+this+method
///+is+proportional+to+<paramref+name="count"/>,+but+the+source+collection+is
///+only+enumerated+once,+and+in+a+lazy+fashion.+Also,+enumerating+the+first
///+item+will+take+longer+than+enumerating+subsequent+items.
///+</summary>
public+static+IEnumerable<T>+SkipLast<T>(this+IEnumerable<T>+source,+int+count)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++if+(count+<+0)
++++++++throw+new+ArgumentOutOfRangeException("count",
++++++++++++"count+cannot+be+negative.");
++++if+(count+==+0)
++++++++return+source;
++++return+skipLastIterator(source,+count);
}
private+static+IEnumerable<T>+skipLastIterator<T>(IEnumerable<T>+source,
++++int+count)
{
++++var+queue+=+new+T[count];
++++int+headtail+=+0;+//+tail+while+we're+still+collecting,+both+head+&+tail
++++++++++++++++++++++//+afterwards+because+the+queue+becomes+completely+full
++++int+collected+=+0;

++++foreach+(var+item+in+source)
++++{
++++++++if+(collected+<+count)
++++++++{
++++++++++++queue[headtail]+=+item;
++++++++++++headtail%2B%2B;
++++++++++++collected%2B%2B;
++++++++}
++++++++else
++++++++{
++++++++++++if+(headtail+==+count)+headtail+=+0;
++++++++++++yield+return+queue[headtail];
++++++++++++queue[headtail]+=+item;
++++++++++++headtail%2B%2B;
++++++++}
++++}
}

///+<summary>
///+Returns+a+collection+containing+only+the+last+<paramref+name="count"/>
///+items+of+the+input+collection.+This+method+enumerates+the+entire
///+collection+to+the+end+once+before+returning.+Note+also+that+the+memory
///+usage+of+this+method+is+proportional+to+<paramref+name="count"/>.
///+</summary>
public+static+IEnumerable<T>+TakeLast<T>(this+IEnumerable<T>+source,+int+count)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");
++++if+(count+<+0)
++++++++throw+new+ArgumentOutOfRangeException("count",
++++++++++++"count+cannot+be+negative.");
++++if+(count+==+0)
++++++++return+new+T[0];

++++var+queue+=+new+Queue<T>(count+%2B+1);
++++foreach+(var+item+in+source)
++++{
++++++++if+(queue.Count+==+count)
++++++++++++queue.Dequeue();
++++++++queue.Enqueue(item);
++++}
++++return+queue.AsEnumerable();
}|code-block|syntax|javascript|937310|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>SkipLast &amp; TakeLast</h2>

<pre><code>/// &lt;summary&gt;
/// Enumerates the items of this collection, skipping the last
/// &lt;paramref name="count"/&gt; items. Note that the memory usage of this method
/// is proportional to &lt;paramref name="count"/&gt;, but the source collection is
/// only enumerated once, and in a lazy fashion. Also, enumerating the first
/// item will take longer than enumerating subsequent items.
/// &lt;/summary&gt;
public static IEnumerable&lt;T&gt; SkipLast&lt;T&gt;(this IEnumerable&lt;T&gt; source, int count)
{
    if (source == null)
        throw new ArgumentNullException("source");
    if (count &lt; 0)
        throw new ArgumentOutOfRangeException("count",
            "count cannot be negative.");
    if (count == 0)
        return source;
    return skipLastIterator(source, count);
}
private static IEnumerable&lt;T&gt; skipLastIterator&lt;T&gt;(IEnumerable&lt;T&gt; source,
    int count)
{
    var queue = new T[count];
    int headtail = 0; // tail while we're still collecting, both head &amp; tail
                      // afterwards because the queue becomes completely full
    int collected = 0;

    foreach (var item in source)
    {
        if (collected &lt; count)
        {
            queue[headtail] = item;
            headtail++;
            collected++;
        }
        else
        {
            if (headtail == count) headtail = 0;
            yield return queue[headtail];
            queue[headtail] = item;
            headtail++;
        }
    }
}

/// &lt;summary&gt;
/// Returns a collection containing only the last &lt;paramref name="count"/&gt;
/// items of the input collection. This method enumerates the entire
/// collection to the end once before returning. Note also that the memory
/// usage of this method is proportional to &lt;paramref name="count"/&gt;.
/// &lt;/summary&gt;
public static IEnumerable&lt;T&gt; TakeLast&lt;T&gt;(this IEnumerable&lt;T&gt; source, int count)
{
    if (source == null)
        throw new ArgumentNullException("source");
    if (count &lt; 0)
        throw new ArgumentOutOfRangeException("count",
            "count cannot be negative.");
    if (count == 0)
        return new T[0];

    var queue = new Queue&lt;T&gt;(count + 1);
    foreach (var item in source)
    {
        if (queue.Count == count)
            queue.Dequeue();
        queue.Enqueue(item);
    }
    return queue.AsEnumerable();
}
</code></pre>


blocks|key|1151672|text|InsertBetween|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151673|在每对连续元素之间插入一个元素。|1151674|///+<summary>Inserts+the+specified+item+in+between+each+element+in+the+input
///+collection.</summary>
///+<param+name="source">The+input+collection.</param>
///+<param+name="extraElement">The+element+to+insert+between+each+consecutive
///+pair+of+elements+in+the+input+collection.</param>
///+<returns>A+collection+containing+the+original+collection+with+the+extra
///+element+inserted.+For+example,+new[]+{+1,+2,+3+}.InsertBetween(0)+returns
///+{+1,+0,+2,+0,+3+}.</returns>
public+static+IEnumerable<T>+InsertBetween<T>(
++++this+IEnumerable<T>+source,+T+extraElement)
{
++++return+source.SelectMany(val+=>+new[]+{+extraElement,+val+}).Skip(1);
}|code-block|syntax|javascript|1151675|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>InsertBetween</h2>

<p>Inserts an element in between every pair of consecutive elements.</p>

<pre><code>/// &lt;summary&gt;Inserts the specified item in between each element in the input
/// collection.&lt;/summary&gt;
/// &lt;param name="source"&gt;The input collection.&lt;/param&gt;
/// &lt;param name="extraElement"&gt;The element to insert between each consecutive
/// pair of elements in the input collection.&lt;/param&gt;
/// &lt;returns&gt;A collection containing the original collection with the extra
/// element inserted. For example, new[] { 1, 2, 3 }.InsertBetween(0) returns
/// { 1, 0, 2, 0, 3 }.&lt;/returns&gt;
public static IEnumerable&lt;T&gt; InsertBetween&lt;T&gt;(
    this IEnumerable&lt;T&gt; source, T extraElement)
{
    return source.SelectMany(val =&gt; new[] { extraElement, val }).Skip(1);
}
</code></pre>


blocks|key|937471|text|ZipMerge|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937472|这是我的Zip版本，工作起来就像一个真正的拉链。它不会将两个值投影到一个值中，而是返回一个组合的IEnumerable。重载，跳过右尾和/或左尾是可能的。|offset|length|style|CODE|937473|public+static+IEnumerable<TSource>+ZipMerge<TSource>(
++++++++this+IEnumerable<TSource>+first,
++++++++IEnumerable<TSource>+second)
{
++++using+(var+secondEnumerator+=+second.GetEnumerator())
++++{
++++++++foreach+(var+item+in+first)
++++++++{
++++++++++++yield+return+item;

++++++++++++if+(secondEnumerator.MoveNext())
++++++++++++++++yield+return+secondEnumerator.Current;
++++++++}

++++++++while+(secondEnumerator.MoveNext())
++++++++++++yield+return+secondEnumerator.Current;
++++}
}|code-block|syntax|javascript|937474|entityMap^0|0|4|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<h2>ZipMerge</h2>

<p>This is my version of <code>Zip</code> which works like a real zipper. It does not project two values into one but returns a combined IEnumerable. Overloads, skipping the right and/or left tail are possible.</p>

<pre><code>public static IEnumerable&lt;TSource&gt; ZipMerge&lt;TSource&gt;(
        this IEnumerable&lt;TSource&gt; first,
        IEnumerable&lt;TSource&gt; second)
{
    using (var secondEnumerator = second.GetEnumerator())
    {
        foreach (var item in first)
        {
            yield return item;

            if (secondEnumerator.MoveNext())
                yield return secondEnumerator.Current;
        }

        while (secondEnumerator.MoveNext())
            yield return secondEnumerator.Current;
    }
}
</code></pre>


blocks|key|937482|text|用于IEnumerable的String.Join|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937483|++++public+static+string+Join<T>(this+IEnumerable<T>+items,+string+delimiter)
++++{
++++++++var+result+=+new+StringBuilder();
++++++++if+(items+!=+null+&&+items.Any())
++++++++{
++++++++++++delimiter+=+delimiter+??+String.Empty;
++++++++++++foreach+(var+item+in+items)
++++++++++++{
++++++++++++++++result.Append(item);
++++++++++++++++result.Append(delimiter);
++++++++++++}
++++++++++++result.Length+=+result.Length+-+delimiter.Length;
++++++++}
++++++++return+result.ToString();
++++}|code-block|syntax|javascript|937484|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>String.Join for IEnumerable&lt;T></h2>

<pre><code>    public static string Join&lt;T&gt;(this IEnumerable&lt;T&gt; items, string delimiter)
    {
        var result = new StringBuilder();
        if (items != null &amp;&amp; items.Any())
        {
            delimiter = delimiter ?? String.Empty;
            foreach (var item in items)
            {
                result.Append(item);
                result.Append(delimiter);
            }
            result.Length = result.Length - delimiter.Length;
        }
        return result.ToString();
    }
</code></pre>


blocks|key|937498|text|ToHashSet|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937499|public+static+HashSet<T>+ToHashSet<T>(this+IEnumerable<T>+items)
{
++++return+new+HashSet<T>(items);
}|code-block|syntax|javascript|937500|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>ToHashSet</h2>

<pre><code>public static HashSet&lt;T&gt; ToHashSet&lt;T&gt;(this IEnumerable&lt;T&gt; items)
{
    return new HashSet&lt;T&gt;(items);
}
</code></pre>


blocks|key|937584|text|无序播放|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937585|public+static+IEnumerable<T>+Shuffle<T>(this+IEnumerable<T>+items)
{
++++var+random+=+new+Random();
++++return+items.OrderBy(x+=>+random.Next());
}|code-block|syntax|javascript|937586|编辑:上面的实现似乎有几个问题。以下是基于@LukeH的代码和@ck和@Strilanc.的注释的改进版本。|937587|private+static+Random+_rand+=+new+Random();
public+static+IEnumerable<T>+Shuffle<T>(this+IEnumerable<T>+source)
{
++++var+items+=+source+==+null+?+new+T[]+{+}+:+source.ToArray();
++++var+count+=+items.Length;
++++while(count+>+0)
++++{
++++++++int+toReturn+=+_rand.Next(0,+count);
++++++++yield+return+items[toReturn];
++++++++items[toReturn]+=+items[count+-+1];
++++++++count--;
++++}
}|937588|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<h2>Shuffle</h2>

<pre><code>public static IEnumerable&lt;T&gt; Shuffle&lt;T&gt;(this IEnumerable&lt;T&gt; items)
{
    var random = new Random();
    return items.OrderBy(x =&gt; random.Next());
}
</code></pre>

<p>EDIT: It seems there are several issues with the above implementation. Here is an improved version based @LukeH's code and comments from @ck and @Strilanc.</p>

<pre><code>private static Random _rand = new Random();
public static IEnumerable&lt;T&gt; Shuffle&lt;T&gt;(this IEnumerable&lt;T&gt; source)
{
    var items = source == null ? new T[] { } : source.ToArray();
    var count = items.Length;
    while(count &gt; 0)
    {
        int toReturn = _rand.Next(0, count);
        yield return items[toReturn];
        items[toReturn] = items[count - 1];
        count--;
    }
}
</code></pre>


blocks|key|937653|text|WhereIf|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937654|IEnumerable和IQueryable上的可选Where子句。避免在为查询构建谓词和lambda时使用if语句。在编译时不知道是否应该应用筛选器时非常有用。|offset|length|style|CODE|937655|public+static+IEnumerable<TSource>+WhereIf<TSource>(
++++++++++++this+IEnumerable<TSource>+source,+bool+condition,
++++++++++++Func<TSource,+bool>+predicate)
{
++++return+condition+?+source.Where(predicate)+:+source;
}|code-block|syntax|javascript|937656|使用情况：|937657|var+custs+=+Customers.WhereIf(someBool,+x=>x.EyeColor=="Green");|937658|从Andrew's+blog借来的LINQ+WhereIf+At+ExtensionMethod.NET。|937659|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.binaryocean.com/2008/03/07/LINQWhereIfExtensionMethod.aspx|1|http://extensionmethod.net/Details.aspx?ID=242^0|0|0|B|C|A|Q|5|0|0|0|0|1|D|0|H|Z|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]|$D|1H|E|1I|1|1J]]|A|$]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

<h2>WhereIf</h2>

<p>Optional <code>Where</code> clause on <code>IEnumerable</code> and <code>IQueryable</code>. Avoids if statements when building predicates &amp;  lambdas for a query. Useful when you don't know at compile time whether a filter should apply. </p>

<pre><code>public static IEnumerable&lt;TSource&gt; WhereIf&lt;TSource&gt;(
            this IEnumerable&lt;TSource&gt; source, bool condition,
            Func&lt;TSource, bool&gt; predicate)
{
    return condition ? source.Where(predicate) : source;
}
</code></pre>

<p>Useage:</p>

<pre><code>var custs = Customers.WhereIf(someBool, x=&gt;x.EyeColor=="Green");
</code></pre>

<p><a href="http://extensionmethod.net/Details.aspx?ID=242" rel="nofollow noreferrer">LINQ WhereIf At ExtensionMethod.NET</a> and borrowed from <a href="http://blog.binaryocean.com/2008/03/07/LINQWhereIfExtensionMethod.aspx" rel="nofollow noreferrer">Andrew's blog</a>.</p>


blocks|key|1152008|text|重复项|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152009|与Ani的AssertCount方法(我使用一个名为CountAtLeast的方法)等方法结合使用，可以非常容易地在一个序列中找到出现多次的元素：|offset|length|style|CODE|1152010|public+static+IEnumerable<T>+Duplicates<T,+TKey>(this+IEnumerable<T>+source,
++++Func<T,+TKey>+keySelector+=+null,+IEqualityComparer<TKey>+comparer+=+null)
{
++++source.ThrowIfNull("source");
++++keySelector+=+keySelector+??+new+Func<T,+TKey>(x+=>+x);
++++comparer+=+comparer+??+EqualityComparer<TKey>.Default;

++++return+source.GroupBy(keySelector,+comparer)
++++++++.Where(g+=>+g.CountAtLeast(2))
++++++++.SelectMany(g+=>+g);
}|code-block|syntax|javascript|1152011|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3645644/whats-your-favorite-linq-to-objects-operator-which-is-not-built-in/3645877#3645877^0|0|5|B|Q|C|5|B|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@$D|10|E|11|1|12]]|A|$]]|$1|H|3|I|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<h1>Duplicates</h1>

<p>Used in conjunction with a method like Ani's <a href="https://stackoverflow.com/questions/3645644/whats-your-favorite-linq-to-objects-operator-which-is-not-built-in/3645877#3645877"><code>AssertCount</code></a> method (I use one called <code>CountAtLeast</code>), it becomes very easy to find elements in a sequence that appear more than once:</p>

<pre><code>public static IEnumerable&lt;T&gt; Duplicates&lt;T, TKey&gt;(this IEnumerable&lt;T&gt; source,
    Func&lt;T, TKey&gt; keySelector = null, IEqualityComparer&lt;TKey&gt; comparer = null)
{
    source.ThrowIfNull("source");
    keySelector = keySelector ?? new Func&lt;T, TKey&gt;(x =&gt; x);
    comparer = comparer ?? EqualityComparer&lt;TKey&gt;.Default;

    return source.GroupBy(keySelector, comparer)
        .Where(g =&gt; g.CountAtLeast(2))
        .SelectMany(g =&gt; g);
}
</code></pre>


blocks|key|1152022|text|IsEmpty|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152023|public+static+bool+IsEmpty<T>(this+IEnumerable<T>+source)
{
++++return+!source.Any();
}|code-block|syntax|javascript|1152024|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>IsEmpty</h2>

<pre><code>public static bool IsEmpty&lt;T&gt;(this IEnumerable&lt;T&gt; source)
{
    return !source.Any();
}
</code></pre>


blocks|key|1152085|text|WhereLike|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152086|将Where与SQL+LIKE模式匹配结合使用。|offset|length|style|CODE|1152087|public+static+IEnumerable<TSource>+WhereLike<TSource>(this+IEnumerable<TSource>+source,+Func<TSource,+string>+selector,+string+match)
++++{
++++++++/*+Turn+"off"+all+regular+expression+related+syntax+in
++++++++++++*+the+pattern+string.+*/
++++++++string+pattern+=+Regex.Escape(match);

++++++++/*+Replace+the+SQL+LIKE+wildcard+metacharacters+with+the
++++++++*+equivalent+regular+expression+metacharacters.+*/
++++++++pattern+=+pattern.Replace("%25",+".*?").Replace("_",+".");

++++++++/*+The+previous+call+to+Regex.Escape+actually+turned+off
++++++++*+too+many+metacharacters,+i.e.+those+which+are+recognized+by
++++++++*+both+the+regular+expression+engine+and+the+SQL+LIKE
++++++++*+statement+([...]+and+[%5E...]).+Those+metacharacters+have
++++++++*+to+be+manually+unescaped+here.+*/
++++++++pattern+=+pattern.Replace(@"\[",+"[").Replace(@"\]",+"]").Replace(@"\%5E",+"%5E");
++++++++Regex+reg+=+new+Regex(pattern,+RegexOptions.IgnoreCase);

++++++++return+source.Where(t+=>+reg.IsMatch(selector(t)));
++++}|code-block|syntax|javascript|1152088|entityMap^0|0|1|5|B|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

<h2>WhereLike</h2>

<p>Combines <code>Where</code> with SQL <code>LIKE</code> pattern matching.</p>

<pre><code>public static IEnumerable&lt;TSource&gt; WhereLike&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, Func&lt;TSource, string&gt; selector, string match)
    {
        /* Turn "off" all regular expression related syntax in
            * the pattern string. */
        string pattern = Regex.Escape(match);

        /* Replace the SQL LIKE wildcard metacharacters with the
        * equivalent regular expression metacharacters. */
        pattern = pattern.Replace("%", ".*?").Replace("_", ".");

        /* The previous call to Regex.Escape actually turned off
        * too many metacharacters, i.e. those which are recognized by
        * both the regular expression engine and the SQL LIKE
        * statement ([...] and [^...]). Those metacharacters have
        * to be manually unescaped here. */
        pattern = pattern.Replace(@"\[", "[").Replace(@"\]", "]").Replace(@"\^", "^");
        Regex reg = new Regex(pattern, RegexOptions.IgnoreCase);

        return source.Where(t =&gt; reg.IsMatch(selector(t)));
    }
</code></pre>


blocks|key|937835|text|CountUpTo|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937836|static+int+CountUpTo<T>(this+IEnumerable<T>+source,+int+maxCount)
{
++++if+(maxCount+==+0)
++++++++return+0;

++++var+genericCollection+=+source+as+ICollection<T>;+
++++if+(genericCollection+!=+null)+
++++++++return+Math.Min(maxCount,+genericCollection.Count);

++++var+collection+=+source+as+ICollection;+
++++if+(collection+!=+null)
++++++++return+Math.Min(maxCount,+collection.Count);

++++int+count+=+0;
++++foreach+(T+item+in+source)
++++++++if+(%2B%2Bcount+>=+maxCount)
++++++++++++break;
++++return+count;
}|code-block|syntax|javascript|937837|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>CountUpTo</h2>

<pre><code>static int CountUpTo&lt;T&gt;(this IEnumerable&lt;T&gt; source, int maxCount)
{
    if (maxCount == 0)
        return 0;

    var genericCollection = source as ICollection&lt;T&gt;; 
    if (genericCollection != null) 
        return Math.Min(maxCount, genericCollection.Count);

    var collection = source as ICollection; 
    if (collection != null)
        return Math.Min(maxCount, collection.Count);

    int count = 0;
    foreach (T item in source)
        if (++count &gt;= maxCount)
            break;
    return count;
}
</code></pre>


blocks|key|1152135|text|合并|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152136|public+static+T+Coalesce<T>(this+IEnumerable<T>+items)+{
+++return+items.Where(x+=>+x+!=+null+&&+!x.Equals(default(T))).FirstOrDefault();
+++//+return+items.OfType<T>().FirstOrDefault();+//+Gabe's+take
}|code-block|syntax|javascript|1152137|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>Coalesce</h2>

<pre><code>public static T Coalesce&lt;T&gt;(this IEnumerable&lt;T&gt; items) {
   return items.Where(x =&gt; x != null &amp;&amp; !x.Equals(default(T))).FirstOrDefault();
   // return items.OfType&lt;T&gt;().FirstOrDefault(); // Gabe's take
}
</code></pre>


blocks|key|937909|text|具有初始容量的ToList和ToDictionary|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937910|公开基础集合类的初始容量的ToList和ToDictionary重载。在源长度已知或有界的情况下，有时会很有用。|937911|public+static+List<TSource>+ToList<TSource>(
++++this+IEnumerable<TSource>+source,+
++++int+capacity)
{
++++if+(source+==+null)
++++{
++++++++throw+new+ArgumentNullException("source");
++++}
++++var+list+=+new+List<TSource>(capacity);
++++list.AddRange(source);
++++return+list;
}+++++

public+static+Dictionary<TKey,+TSource>+ToDictionary<TSource,+TKey>(
++++this+IEnumerable<TSource>+source,+
++++Func<TSource,+TKey>+keySelector,+
++++int+capacity,
++++IEqualityComparer<TKey>+comparer+=+null)
{
++++return+source.ToDictionary<TSource,+TKey,+TSource>(
++++++++++++++++++keySelector,+x+=>+x,+capacity,+comparer);
}

public+static+Dictionary<TKey,+TElement>+ToDictionary<TSource,+TKey,+TElement>(
++++this+IEnumerable<TSource>+source,+
++++Func<TSource,+TKey>+keySelector,+
++++Func<TSource,+TElement>+elementSelector,
++++int+capacity,
++++IEqualityComparer<TKey>+comparer+=+null)
{
++++if+(source+==+null)
++++{
++++++++throw+new+ArgumentNullException("source");
++++}
++++if+(keySelector+==+null)
++++{
++++++++throw+new+ArgumentNullException("keySelector");
++++}
++++if+(elementSelector+==+null)
++++{
++++++++throw+new+ArgumentNullException("elementSelector");
++++}
++++var+dictionary+=+new+Dictionary<TKey,+TElement>(capacity,+comparer);
++++foreach+(TSource+local+in+source)
++++{
++++++++dictionary.Add(keySelector(local),+elementSelector(local));
++++}
++++return+dictionary;
}|code-block|syntax|javascript|937912|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h1>ToList and ToDictionary with Initial Capacity</h1>

<p>ToList and ToDictionary overloads that expose the underlying collection classes' initial capacity. Occasionally useful when source length is known or bounded. </p>

<pre><code>public static List&lt;TSource&gt; ToList&lt;TSource&gt;(
    this IEnumerable&lt;TSource&gt; source, 
    int capacity)
{
    if (source == null)
    {
        throw new ArgumentNullException("source");
    }
    var list = new List&lt;TSource&gt;(capacity);
    list.AddRange(source);
    return list;
}     

public static Dictionary&lt;TKey, TSource&gt; ToDictionary&lt;TSource, TKey&gt;(
    this IEnumerable&lt;TSource&gt; source, 
    Func&lt;TSource, TKey&gt; keySelector, 
    int capacity,
    IEqualityComparer&lt;TKey&gt; comparer = null)
{
    return source.ToDictionary&lt;TSource, TKey, TSource&gt;(
                  keySelector, x =&gt; x, capacity, comparer);
}

public static Dictionary&lt;TKey, TElement&gt; ToDictionary&lt;TSource, TKey, TElement&gt;(
    this IEnumerable&lt;TSource&gt; source, 
    Func&lt;TSource, TKey&gt; keySelector, 
    Func&lt;TSource, TElement&gt; elementSelector,
    int capacity,
    IEqualityComparer&lt;TKey&gt; comparer = null)
{
    if (source == null)
    {
        throw new ArgumentNullException("source");
    }
    if (keySelector == null)
    {
        throw new ArgumentNullException("keySelector");
    }
    if (elementSelector == null)
    {
        throw new ArgumentNullException("elementSelector");
    }
    var dictionary = new Dictionary&lt;TKey, TElement&gt;(capacity, comparer);
    foreach (TSource local in source)
    {
        dictionary.Add(keySelector(local), elementSelector(local));
    }
    return dictionary;
}
</code></pre>


blocks|key|1152269|text|在两者之间|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152270|与著名的SQL+"between“构造等效的C#|1152271|///+<summary>
///+Determines+if+the+current+value+is+included+in+the+range+of+specified+values.+Bounds+are+included.
///+</summary>
///+<typeparam+name="T">The+type+of+the+values</typeparam>
///+<param+name="val">The+value.</param>
///+<param+name="firstValue">The+lower+bound.</param>
///+<param+name="secondValue">The+upper+bound.</param>
///+<returns>
///+Return+<c>true</c>+if+the+<paramref+name="val">value</paramref>+is+between+the+<paramref+name="firstValue"/>+and+the+<paramref+name="secondValue"/>;+otherwise,+<c>false</c>
///+</returns>
public+static+bool+Between<T>(this+T+val,+T+firstValue,+T+secondValue)+where+T+:+IComparable<T>
{
++if+(val+==+null)
++++throw+new+ArgumentNullException();

++if+(firstValue+==+null+%7C%7C
++++++secondValue+==+null)
++++return+false;

++return+firstValue.CompareTo(val)+<=+0+&&+secondValue.CompareTo(val)+>=+0;
}|code-block|syntax|javascript|1152272|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>Between</h2>

<p>C# equivalent of the well-known SQL "between" construct</p>

<pre><code>/// &lt;summary&gt;
/// Determines if the current value is included in the range of specified values. Bounds are included.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the values&lt;/typeparam&gt;
/// &lt;param name="val"&gt;The value.&lt;/param&gt;
/// &lt;param name="firstValue"&gt;The lower bound.&lt;/param&gt;
/// &lt;param name="secondValue"&gt;The upper bound.&lt;/param&gt;
/// &lt;returns&gt;
/// Return &lt;c&gt;true&lt;/c&gt; if the &lt;paramref name="val"&gt;value&lt;/paramref&gt; is between the &lt;paramref name="firstValue"/&gt; and the &lt;paramref name="secondValue"/&gt;; otherwise, &lt;c&gt;false&lt;/c&gt;
/// &lt;/returns&gt;
public static bool Between&lt;T&gt;(this T val, T firstValue, T secondValue) where T : IComparable&lt;T&gt;
{
  if (val == null)
    throw new ArgumentNullException();

  if (firstValue == null ||
      secondValue == null)
    return false;

  return firstValue.CompareTo(val) &lt;= 0 &amp;&amp; secondValue.CompareTo(val) &gt;= 0;
}
</code></pre>


blocks|key|1152313|text|In和NotIn|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152314|其他两个众所周知的SQL构造的C#等价物|1152315|///+<summary>
///+Determines+if+the+source+value+is+contained+in+the+list+of+possible+values.
///+</summary>
///+<typeparam+name="T">The+type+of+the+objects</typeparam>
///+<param+name="value">The+source+value</param>
///+<param+name="values">The+list+of+possible+values</param>
///+<returns>
///+++++<c>true</c>+if+the+source+value+matches+at+least+one+of+the+possible+values;+otherwise,+<c>false</c>.
///+</returns>
public+static+bool+In<T>(this+T+value,+params+T[]+values)
{
++++if+(values+==+null)
++++++++return+false;

++++if+(values.Contains<T>(value))
++++++++return+true;

++++return+false;
}

///+<summary>
///+Determines+if+the+source+value+is+contained+in+the+list+of+possible+values.
///+</summary>
///+<typeparam+name="T">The+type+of+the+objects</typeparam>
///+<param+name="value">The+source+value</param>
///+<param+name="values">The+list+of+possible+values</param>
///+<returns>
///+++++<c>true</c>+if+the+source+value+matches+at+least+one+of+the+possible+values;+otherwise,+<c>false</c>.
///+</returns>
public+static+bool+In<T>(this+T+value,+IEnumerable<T>+values)
{
++++if+(values+==+null)
++++++++return+false;

++++if+(values.Contains<T>(value))
++++++++return+true;

++++return+false;
}

///+<summary>
///+Determines+if+the+source+value+is+not+contained+in+the+list+of+possible+values.
///+</summary>
///+<typeparam+name="T">The+type+of+the+objects</typeparam>
///+<param+name="value">The+source+value</param>
///+<param+name="values">The+list+of+possible+values</param>
///+<returns>
///+++++<c>false</c>+if+the+source+value+matches+at+least+one+of+the+possible+values;+otherwise,+<c>true</c>.
///+</returns>
public+static+bool+NotIn<T>(this+T+value,+params+T[]+values)
{
++++return+In(value,+values)+==+false;
}

///+<summary>
///+Determines+if+the+source+value+is+not+contained+in+the+list+of+possible+values.
///+</summary>
///+<typeparam+name="T">The+type+of+the+objects</typeparam>
///+<param+name="value">The+source+value</param>
///+<param+name="values">The+list+of+possible+values</param>
///+<returns>
///+++++<c>false</c>+if+the+source+value+matches+at+least+one+of+the+possible+values;+otherwise,+<c>true</c>.
///+</returns>
public+static+bool+NotIn<T>(this+T+value,+IEnumerable<T>+values)
{
++++return+In(value,+values)+==+false;
}|code-block|syntax|javascript|1152316|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>In and NotIn</h2>

<p>C# equivalents of two other well-known SQL constructs</p>

<pre><code>/// &lt;summary&gt;
/// Determines if the source value is contained in the list of possible values.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the objects&lt;/typeparam&gt;
/// &lt;param name="value"&gt;The source value&lt;/param&gt;
/// &lt;param name="values"&gt;The list of possible values&lt;/param&gt;
/// &lt;returns&gt;
///     &lt;c&gt;true&lt;/c&gt; if the source value matches at least one of the possible values; otherwise, &lt;c&gt;false&lt;/c&gt;.
/// &lt;/returns&gt;
public static bool In&lt;T&gt;(this T value, params T[] values)
{
    if (values == null)
        return false;

    if (values.Contains&lt;T&gt;(value))
        return true;

    return false;
}

/// &lt;summary&gt;
/// Determines if the source value is contained in the list of possible values.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the objects&lt;/typeparam&gt;
/// &lt;param name="value"&gt;The source value&lt;/param&gt;
/// &lt;param name="values"&gt;The list of possible values&lt;/param&gt;
/// &lt;returns&gt;
///     &lt;c&gt;true&lt;/c&gt; if the source value matches at least one of the possible values; otherwise, &lt;c&gt;false&lt;/c&gt;.
/// &lt;/returns&gt;
public static bool In&lt;T&gt;(this T value, IEnumerable&lt;T&gt; values)
{
    if (values == null)
        return false;

    if (values.Contains&lt;T&gt;(value))
        return true;

    return false;
}

/// &lt;summary&gt;
/// Determines if the source value is not contained in the list of possible values.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the objects&lt;/typeparam&gt;
/// &lt;param name="value"&gt;The source value&lt;/param&gt;
/// &lt;param name="values"&gt;The list of possible values&lt;/param&gt;
/// &lt;returns&gt;
///     &lt;c&gt;false&lt;/c&gt; if the source value matches at least one of the possible values; otherwise, &lt;c&gt;true&lt;/c&gt;.
/// &lt;/returns&gt;
public static bool NotIn&lt;T&gt;(this T value, params T[] values)
{
    return In(value, values) == false;
}

/// &lt;summary&gt;
/// Determines if the source value is not contained in the list of possible values.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;The type of the objects&lt;/typeparam&gt;
/// &lt;param name="value"&gt;The source value&lt;/param&gt;
/// &lt;param name="values"&gt;The list of possible values&lt;/param&gt;
/// &lt;returns&gt;
///     &lt;c&gt;false&lt;/c&gt; if the source value matches at least one of the possible values; otherwise, &lt;c&gt;true&lt;/c&gt;.
/// &lt;/returns&gt;
public static bool NotIn&lt;T&gt;(this T value, IEnumerable&lt;T&gt; values)
{
    return In(value, values) == false;
}
</code></pre>


blocks|key|1152318|text|public+static+IEnumerable<T>+Append<T>(this+IEnumerable<T>+enumerable,+T+item)
{
+return+enumerable.Concat(new[]+{+item+});
}

public+static+IEnumerable<T>+AppendIf<T>(this+IEnumerable<T>+enumerable,+T+item,+Func<bool>+predicate)
{
+return+predicate()+?+enumerable.Append(item)+:+enumerable;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1152319|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static IEnumerable&lt;T&gt; Append&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, T item)
{
 return enumerable.Concat(new[] { item });
}

public static IEnumerable&lt;T&gt; AppendIf&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, T item, Func&lt;bool&gt; predicate)
{
 return predicate() ? enumerable.Append(item) : enumerable;
}
</code></pre>


blocks|key|938037|text|一、二、MoreThanOne、AtLeast、AnyAtAll|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938038|public+static+bool+One<T>(this+IEnumerable<T>+enumerable)
{
++++using+(var+enumerator+=+enumerable.GetEnumerator())
++++++++return+enumerator.MoveNext()+&&+!enumerator.MoveNext();
}

public+static+bool+Two<T>(this+IEnumerable<T>+enumerable)
{
++++using+(var+enumerator+=+enumerable.GetEnumerator())
++++++++return+enumerator.MoveNext()+&&+enumerator.MoveNext()+&&+!enumerator.MoveNext();
}

public+static+bool+MoreThanOne<T>(this+IEnumerable<T>+enumerable)
{
++++return+enumerable.Skip(1).Any();
}

public+static+bool+AtLeast<T>(this+IEnumerable<T>+enumerable,+int+count)
{
++++using+(var+enumerator+=+enumerable.GetEnumerator())
++++++++for+(var+i+=+0;+i+<+count;+i%2B%2B)
++++++++++++if+(!enumerator.MoveNext())
++++++++++++++++return+false;
++++return+true;
}

public+static+bool+AnyAtAll<T>(this+IEnumerable<T>+enumerable)
{
++++return+enumerable+!=+null+&&+enumerable.Any();
}|code-block|syntax|javascript|938039|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>One, Two, MoreThanOne, AtLeast, AnyAtAll</h2>

<pre class="lang-cs prettyprint-override"><code>public static bool One&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable)
{
    using (var enumerator = enumerable.GetEnumerator())
        return enumerator.MoveNext() &amp;&amp; !enumerator.MoveNext();
}

public static bool Two&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable)
{
    using (var enumerator = enumerable.GetEnumerator())
        return enumerator.MoveNext() &amp;&amp; enumerator.MoveNext() &amp;&amp; !enumerator.MoveNext();
}

public static bool MoreThanOne&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable)
{
    return enumerable.Skip(1).Any();
}

public static bool AtLeast&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, int count)
{
    using (var enumerator = enumerable.GetEnumerator())
        for (var i = 0; i &lt; count; i++)
            if (!enumerator.MoveNext())
                return false;
    return true;
}

public static bool AnyAtAll&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable)
{
    return enumerable != null &amp;&amp; enumerable.Any();
}
</code></pre>


blocks|key|1152399|text|窗户|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152400|枚举长度为size的数组(“窗口”)，其中包含最新的值。|offset|length|style|CODE|1152401|{+0,+1,+2,+3+}变成了{+[0,+1],+[1,+2],+[2,+3]+}。|1152402|例如，我正在使用它来通过连接两个点来绘制折线图。|1152403|public+static+IEnumerable<TSource[]>+Window<TSource>(
++++this+IEnumerable<TSource>+source)
{
++++return+source.Window(2);
}

public+static+IEnumerable<TSource[]>+Window<TSource>(
++++this+IEnumerable<TSource>+source,+int+size)
{
++++if+(size+<=+0)
++++++++throw+new+ArgumentOutOfRangeException("size");

++++return+source.Skip(size).WindowHelper(size,+source.Take(size));
}

private+static+IEnumerable<TSource[]>+WindowHelper<TSource>(
++++this+IEnumerable<TSource>+source,+int+size,+IEnumerable<TSource>+init)
{
++++Queue<TSource>+q+=+new+Queue<TSource>(init);

++++yield+return+q.ToArray();

++++foreach+(var+value+in+source)
++++{
++++++++q.Dequeue();
++++++++q.Enqueue(value);
++++++++yield+return+q.ToArray();
++++}
}|code-block|syntax|javascript|1152404|entityMap^0|0|5|4|0|0|E|H|Q|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|12|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

<h2>Window</h2>

<p>Enumerates arrays ("windows") with the length of <code>size</code> containing the most current values.<br>
<code>{ 0, 1, 2, 3 }</code> becomes to <code>{ [0, 1], [1, 2], [2, 3] }</code>.</p>

<p>I am using this for example to draw a line graph by connecting two points.</p>

<pre><code>public static IEnumerable&lt;TSource[]&gt; Window&lt;TSource&gt;(
    this IEnumerable&lt;TSource&gt; source)
{
    return source.Window(2);
}

public static IEnumerable&lt;TSource[]&gt; Window&lt;TSource&gt;(
    this IEnumerable&lt;TSource&gt; source, int size)
{
    if (size &lt;= 0)
        throw new ArgumentOutOfRangeException("size");

    return source.Skip(size).WindowHelper(size, source.Take(size));
}

private static IEnumerable&lt;TSource[]&gt; WindowHelper&lt;TSource&gt;(
    this IEnumerable&lt;TSource&gt; source, int size, IEnumerable&lt;TSource&gt; init)
{
    Queue&lt;TSource&gt; q = new Queue&lt;TSource&gt;(init);

    yield return q.ToArray();

    foreach (var value in source)
    {
        q.Dequeue();
        q.Enqueue(value);
        yield return q.ToArray();
    }
}
</code></pre>


blocks|key|1152413|text|public+static+void+AddRangeWhere<T>(this+IEnumerable<T>+list,+IEnumerable<T>+sourceList,+Func<T,+bool>+predicate)
++{
+++if+(list+!=+null)
+++{
++++List<T>+newRange+=+new+List<T>();

++++foreach+(var+item+in+sourceList)
++++{
+++++if+(predicate(item))
++++++newRange.Add(item);
++++}

++++list.Concat(newRange);
+++}
++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1152414|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static void AddRangeWhere&lt;T&gt;(this IEnumerable&lt;T&gt; list, IEnumerable&lt;T&gt; sourceList, Func&lt;T, bool&gt; predicate)
  {
   if (list != null)
   {
    List&lt;T&gt; newRange = new List&lt;T&gt;();

    foreach (var item in sourceList)
    {
     if (predicate(item))
      newRange.Add(item);
    }

    list.Concat(newRange);
   }
  }
</code></pre>


blocks|key|938165|text|OneOrDefault|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938166|与SingleOrDefault类似，只有当列表中有多个元素时，它才返回null，而不是抛出异常。|offset|length|style|CODE|938167|public+static+T+OneOrDefault<T>(this+IEnumerable<T>+list)
{
++++using+(var+e+=+list.GetEnumerator())
++++{
++++++++if+(!e.MoveNext())
++++++++++++return+default(T);
++++++++T+val+=+e.Current;
++++++++if+(e.MoveNext())
++++++++++++return+default(T);
++++++++return+val;
++++}
}|code-block|syntax|javascript|938168|entityMap^0|0|1|F|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<h2>OneOrDefault</h2>

<p>Like <code>SingleOrDefault</code>, only it returns null instead of throwing an exception when there are multiple elements in the list.</p>

<pre><code>public static T OneOrDefault&lt;T&gt;(this IEnumerable&lt;T&gt; list)
{
    using (var e = list.GetEnumerator())
    {
        if (!e.MoveNext())
            return default(T);
        T val = e.Current;
        if (e.MoveNext())
            return default(T);
        return val;
    }
}
</code></pre>


blocks|key|938243|text|GetBreadthFirstEnumerable|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938244|这是我的最爱--广度优先搜索任何集合都很容易。在每次迭代中，该方法生成当前节点、它的父节点、它在图中的级别以及它的索引。这在某些情况下很有帮助，但如果你不需要它，方法可以大大简化，如果你想的话-你可以只生成节点本身。|938245|public+class+IteratedNode<T>
{
++++public+T+Node;
++++public+T+ParentNode;
++++public+int+Level;
++++public+int+Index;
}

///+<summary>
///+Iterates+over+a+tree/graph+via+In+Order+Breadth+First+search.
///+</summary>
///+<param+name="root">The+root+item.</param>
///+<param+name="childSelector">A+func+that+receives+a+node+in+the+tree+and+returns+its+children.</param>
public+static+IEnumerable<IteratedNode<T>>+GetBreadthFirstEnumerable<T>(this+T+root,+Func<T,+IEnumerable<T>>+childSelector)
{
++++var+rootNode+=+new+IteratedNode<T>+{+Node+=+root,+ParentNode+=+default(T),+Level+=+1,+Index+=+1};
++++var+nodesToProcess+=+new+Queue<IteratedNode<T>>(+new[]+{rootNode});

++++int+itemsIterated+=+0;
++++while+(nodesToProcess.Count+>+0)
++++{
++++++++IteratedNode<T>+currentItem+=+nodesToProcess.Dequeue();

++++++++yield+return+currentItem;+itemsIterated%2B%2B;

++++++++//+Iterate+over+the+children+of+this+node,+and+add+it+to+queue,+to+process+later.
++++++++foreach+(T+child+in+childSelector(currentItem.Node))
++++++++{
++++++++++++nodesToProcess.Enqueue(+
++++++++++++++++new+IteratedNode<T>+{
++++++++++++++++++++Node+=+child,
++++++++++++++++++++ParentNode+=+currentItem.Node,
++++++++++++++++++++Level+=+currentItem.Level+%2B+1,
++++++++++++++++++++Index+=+itemsIterated
++++++++++++++++});++++++++++++++++++++++
++++++++}
++++}
}|code-block|syntax|javascript|938246|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>GetBreadthFirstEnumerable</h2>

<p>This is my favorite - does Breadth First Search over any collection quite easily. At each iteration, the method yield the current node, its parent, the level it is in the graph, and its index in breadth-first-order. This is great help in some scenarios, but if you don't need it, the method can be greatly simplified, if you want - you can yield only the node itself.</p>

<pre><code>public class IteratedNode&lt;T&gt;
{
    public T Node;
    public T ParentNode;
    public int Level;
    public int Index;
}

/// &lt;summary&gt;
/// Iterates over a tree/graph via In Order Breadth First search.
/// &lt;/summary&gt;
/// &lt;param name="root"&gt;The root item.&lt;/param&gt;
/// &lt;param name="childSelector"&gt;A func that receives a node in the tree and returns its children.&lt;/param&gt;
public static IEnumerable&lt;IteratedNode&lt;T&gt;&gt; GetBreadthFirstEnumerable&lt;T&gt;(this T root, Func&lt;T, IEnumerable&lt;T&gt;&gt; childSelector)
{
    var rootNode = new IteratedNode&lt;T&gt; { Node = root, ParentNode = default(T), Level = 1, Index = 1};
    var nodesToProcess = new Queue&lt;IteratedNode&lt;T&gt;&gt;( new[] {rootNode});

    int itemsIterated = 0;
    while (nodesToProcess.Count &gt; 0)
    {
        IteratedNode&lt;T&gt; currentItem = nodesToProcess.Dequeue();

        yield return currentItem; itemsIterated++;

        // Iterate over the children of this node, and add it to queue, to process later.
        foreach (T child in childSelector(currentItem.Node))
        {
            nodesToProcess.Enqueue( 
                new IteratedNode&lt;T&gt; {
                    Node = child,
                    ParentNode = currentItem.Node,
                    Level = currentItem.Level + 1,
                    Index = itemsIterated
                });                      
        }
    }
}
</code></pre>


blocks|key|1152580|text|我的是RemoveConcurrent<T>()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1152581|public+static+IEnumerable<T>+RemoveConcurrent<T>(this+IEnumerable<T>+ts)+where+T+:+IEquatable<T>
{
++++bool+first+=+true;
++++T+lval+=+default(T);
++++foreach+(T+t+in+ts)
++++{
++++++++if+(first+%7C%7C+!t.Equals(lval))
++++++++{
++++++++++++first+=+false;
++++++++++++yield+return+t;
++++++++}
++++++++lval+=+t;
++++}
}|code-block|syntax|javascript|1152582|也许有一种方法可以用标准的LINQ查询做到这一点，但如果是这样的话，我不知道如何做到这一点。|1152583|entityMap^0|3|L|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

<p>Mine is <code>RemoveConcurrent&lt;T&gt;()</code>:</p>

<pre><code>public static IEnumerable&lt;T&gt; RemoveConcurrent&lt;T&gt;(this IEnumerable&lt;T&gt; ts) where T : IEquatable&lt;T&gt;
{
    bool first = true;
    T lval = default(T);
    foreach (T t in ts)
    {
        if (first || !t.Equals(lval))
        {
            first = false;
            yield return t;
        }
        lval = t;
    }
}
</code></pre>

<p>There may be a way to do this with the standard LINQ queries, but if so, I don't know how.</p>


blocks|key|938362|text|除了使用params列表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938363|这是一个非常简单的包装器，可以使某些查询变得更容易：|938364|public+static+IEnumerable<T>+Except<T>(this+IEnumerable<T>+elements,+params+T[]+exceptions)
{
++++return+elements.Except(exceptions);
}|code-block|syntax|javascript|938365|用法：|938366|//returns+a+list+of+"work+week"+DayOfWeek+values.
Enum.GetValues(typeof(DayOfWeek)).Except(DayOfWeek.Saturday,+DayOfWeek.Sunday);|938367|这就避免了必须创建自己的集合来传递Except，或者使用带有大布尔值的Where“不等于A和不等于B和...”构造，使代码更加整洁。|938368|除了with谓词(反转Where)|938369|我还看到，除了给定了一个谓词之外，它基本上是Where的倒数，最简单的实现就是：|938370|public+static+IEnumerable<T>+Except<T>(this+IEnumerable<T>+elements,+Predicate<T>+predicate)
{
+++return+elements.Where(x=>!predicate(x));
}|938371|938372|//best+use+is+as+a+"natural+language"+statement+already+containing+Where()
ListOfRecords.Where(r=>r.SomeValue+=+123).Except(r=>r.Id+=+2536);|938373|如果C#同时具有do-while和do-until结构，那么这就有了它的位置。|938374|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|18|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|U|3|J|5|6|7|1A|8|@]|9|@]|A|$]]|$1|V|3|W|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|X|3|Y|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|10|$]]

<h2>Except with params list</h2>

<p>This is a really simple wrapper that can make certain queries much easier:</p>

<pre><code>public static IEnumerable&lt;T&gt; Except&lt;T&gt;(this IEnumerable&lt;T&gt; elements, params T[] exceptions)
{
    return elements.Except(exceptions);
}
</code></pre>

<p>Usage:</p>

<pre><code>//returns a list of "work week" DayOfWeek values.
Enum.GetValues(typeof(DayOfWeek)).Except(DayOfWeek.Saturday, DayOfWeek.Sunday);
</code></pre>

<p>This prevents having to create your own collection to pass into Except, or using Where with a large Boolean "doesn't equal A and doesn't equal B and..." construct, making code a bit cleaner.</p>

<h2>Except with Predicate (Inverse Where)</h2>

<p>I have also seen Except given a predicate, basically making it an inverse of Where, and the easiest implementation is exactly that:</p>

<pre><code>public static IEnumerable&lt;T&gt; Except&lt;T&gt;(this IEnumerable&lt;T&gt; elements, Predicate&lt;T&gt; predicate)
{
   return elements.Where(x=&gt;!predicate(x));
}
</code></pre>

<p>Usage:</p>

<pre><code>//best use is as a "natural language" statement already containing Where()
ListOfRecords.Where(r=&gt;r.SomeValue = 123).Except(r=&gt;r.Id = 2536);
</code></pre>

<p>If C# has both do-while and do-until constructs, this has its place.</p>


blocks|key|1152676|text|ObjectWithMin/ObjectWithMax|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152677|类似于Timwi的MinElement，但是有一个更简洁的算法，它使用聚合扩展方法来遍历源枚举：|1152678|public+static+T+ObjectWithMax<T,+TResult>(this+IEnumerable<T>+elements,+Func<T,+TResult>+projection)
++++where+TResult+:+IComparable<TResult>
{
++++if+(elements+==+null)+throw+new+ArgumentNullException("elements",+"Sequence+is+null.");
++++if+(!elements.Any())+throw+new+ArgumentException("Sequence+contains+no+elements.");

++++//Set+up+the+"seed"+(current+known+maximum)+to+the+first+element
++++var+seed+=+elements.Select(t+=>+new+{Object+=+t,+Projection+=+projection(t)}).First();

++++//run+through+all+other+elements+of+the+source,+comparing+the+projection+of+each
++++//to+the+current+"seed"+and+replacing+the+seed+as+necessary.+Last+element+wins+ties.
++++return+elements.Skip(1).Aggregate(seed,
++++++++++++++++++++++++++++++(s,+x)+=>
++++++++++++++++++++++++++++++projection(x).CompareTo(s.Projection)+>=+0
++++++++++++++++++++++++++++++++++?+new+{Object+=+x,+Projection+=+projection(x)}
++++++++++++++++++++++++++++++++++:+s
++++++++).Object;
}

public+static+T+ObjectWithMin<T,+TResult>(this+IEnumerable<T>+elements,+Func<T,+TResult>+projection)
++++where+TResult+:+IComparable<TResult>
{
++++if+(elements+==+null)+throw+new+ArgumentNullException("elements",+"Sequence+is+null.");
++++if+(!elements.Any())+throw+new+ArgumentException("Sequence+contains+no+elements.");

++++var+seed+=+elements.Select(t+=>+new+{Object+=+t,+Projection+=+projection(t)}).First();

++++//ties+won+by+the+FIRST+element+in+the+Enumerable
++++return+elements.Aggregate(seed,
++++++++++++++++++++++++++++++(s,+x)+=>
++++++++++++++++++++++++++++++projection(x).CompareTo(s.Projection)+<+0
++++++++++++++++++++++++++++++++++?+new+{Object+=+x,+Projection+=+projection(x)}
++++++++++++++++++++++++++++++++++:+s
++++++++).Object;
}|code-block|syntax|javascript|1152679|我发现与OrderBy().First()或Where(x=>x.SomeField+==+source.Min(someField)).First()相比，这些方法是非常有价值的。它是线性的，只遍历可枚举数一次，并且稳定到列表的当前顺序。|offset|length|style|CODE|1152680|entityMap^0|0|0|0|4|H|M|1I|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<h2>ObjectWithMin/ObjectWithMax</h2>

<p>Similar to Timwi's MinElement, but there's a more concise algorithm using the Aggregate extension method to spin through the source Enumerable:</p>

<pre><code>public static T ObjectWithMax&lt;T, TResult&gt;(this IEnumerable&lt;T&gt; elements, Func&lt;T, TResult&gt; projection)
    where TResult : IComparable&lt;TResult&gt;
{
    if (elements == null) throw new ArgumentNullException("elements", "Sequence is null.");
    if (!elements.Any()) throw new ArgumentException("Sequence contains no elements.");

    //Set up the "seed" (current known maximum) to the first element
    var seed = elements.Select(t =&gt; new {Object = t, Projection = projection(t)}).First();

    //run through all other elements of the source, comparing the projection of each
    //to the current "seed" and replacing the seed as necessary. Last element wins ties.
    return elements.Skip(1).Aggregate(seed,
                              (s, x) =&gt;
                              projection(x).CompareTo(s.Projection) &gt;= 0
                                  ? new {Object = x, Projection = projection(x)}
                                  : s
        ).Object;
}

public static T ObjectWithMin&lt;T, TResult&gt;(this IEnumerable&lt;T&gt; elements, Func&lt;T, TResult&gt; projection)
    where TResult : IComparable&lt;TResult&gt;
{
    if (elements == null) throw new ArgumentNullException("elements", "Sequence is null.");
    if (!elements.Any()) throw new ArgumentException("Sequence contains no elements.");

    var seed = elements.Select(t =&gt; new {Object = t, Projection = projection(t)}).First();

    //ties won by the FIRST element in the Enumerable
    return elements.Aggregate(seed,
                              (s, x) =&gt;
                              projection(x).CompareTo(s.Projection) &lt; 0
                                  ? new {Object = x, Projection = projection(x)}
                                  : s
        ).Object;
}
</code></pre>

<p>I have found these methods invaluable compared to <code>OrderBy().First()</code> or <code>Where(x=&gt;x.SomeField == source.Min(someField)).First()</code>. It's linear, goes through the Enumerable only once, and is stable to the current order of the list.</p>


blocks|key|938441|text|///+<summary>
///+Performs+the+specified+action+on+each+element+of+the+IEnumerable.
///+</summary>
public+static+void+ForEachAction<T>(this+IEnumerable<T>+enumerable,+Action<T>+action)
{
++++if+(action+==+null+%7C%7C+enumerable+==+null)
++++{
++++++++throw+new+ArgumentNullException();
++++}

++++foreach+(var+item+in+enumerable)
++++{
++++++++action.Invoke(item);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|938442|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>/// &lt;summary&gt;
/// Performs the specified action on each element of the IEnumerable.
/// &lt;/summary&gt;
public static void ForEachAction&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, Action&lt;T&gt; action)
{
    if (action == null || enumerable == null)
    {
        throw new ArgumentNullException();
    }

    foreach (var item in enumerable)
    {
        action.Invoke(item);
    }
}
</code></pre>


<p>With extension methods, we can write handy LINQ operators which solve generic problems.</p>

<p>I want to hear which methods or overloads you are missing in the <code>System.Linq</code> namespace and how you implemented them.</p>

<p>Clean and elegant implementations, maybe using existing methods, are preferred.</p>


What's your favorite LINQ to Objects operator which is not built-in?

使用扩展方法，我们可以编写方便的LINQ运算符来解决一般问题。我想知道您在System.Linq名称空间中缺少哪些方法或重载，以及您是如何实现它们的。最好使用干净和优雅的实现，也许可以使用现有的方法。

问你最喜欢的没有内置的LINQ to Objects操作符是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你最喜欢的没有内置的LINQ to Objects操作符是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你最喜欢的没有内置的LINQ to Objects操作符是什么？
EN