blocks|key|343167|text|我喜欢this+one。它是String.Split方法的变体，允许在拆分字符位于实际字符串中时使用转义字符来取消拆分。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|343168|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/634777/c-extension-method-string-split-that-also-accepts-an-escape-character^0|3|8|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I like <a href="https://stackoverflow.com/questions/634777/c-extension-method-string-split-that-also-accepts-an-escape-character">this one</a>. It is a variation on the String.Split method that allows the use of an escape character to suppress splitting when the split character is intended to be in the actual string.

blocks|key|3322194|text|完整的解决方案太大了，不能放在这里，但我写了一系列扩展方法，可以让您轻松地将DataTable转换为CSV。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322195|public+static+String+ToCSV(this+DataTable+dataTable)
{
++++return+dataTable.ToCSV(null,+COMMA,+true);
}++

public+static+String+ToCSV(this+DataTable+dataTable,+String+qualifier)
{
++++return+dataTable.ToCSV(qualifier,+COMMA,+true);
}

private+static+String+ToCSV(this+DataTable+dataTable,+String+qualifier,+String+delimiter,+Boolean+includeColumnNames)
{
++++if+(dataTable+==+null)+return+null;

++++if+(qualifier+==+delimiter)
++++{
++++++++throw+new+InvalidOperationException(
++++++++++++"The+qualifier+and+the+delimiter+are+identical.+This+will+cause+the+CSV+to+have+collisions+that+might+result+in+data+being+parsed+incorrectly+by+another+program.");
++++}

++++var+sbCSV+=+new+StringBuilder();

++++var+delimiterToUse+=+delimiter+??+COMMA;

++++if+(includeColumnNames)+
++++++++sbCSV.AppendLine(dataTable.Columns.GetHeaderLine(qualifier,+delimiterToUse));

++++foreach+(DataRow+row+in+dataTable.Rows)
++++{
++++++++sbCSV.AppendLine(row.ToCSVLine(qualifier,+delimiterToUse));
++++}

++++return+sbCSV.Length+>+0+?+sbCSV.ToString()+:+null;
}

private+static+String+ToCSVLine(this+DataRow+dataRow,+String+qualifier,+String+delimiter)
{
++++var+colCount+=+dataRow.Table.Columns.Count;
++++var+rowValues+=+new+String[colCount];

++++for+(var+i+=+0;+i+<+colCount;+i%2B%2B)
++++{
++++++++rowValues[i]+=+dataRow[i].Qualify(qualifier);
++++}

++++return+String.Join(delimiter,+rowValues);
}

private+static+String+GetHeaderLine(this+DataColumnCollection+columns,+String+qualifier,+String+delimiter)
{
++++var+colCount+=+columns.Count;
++++var+colNames+=+new+String[colCount];

++++for+(var+i+=+0;+i+<+colCount;+i%2B%2B)
++++{
++++++++colNames[i]+=+columns[i].ColumnName.Qualify(qualifier);
++++}

++++return+String.Join(delimiter,+colNames);
}

private+static+String+Qualify(this+Object+target,+String+qualifier)
{
++++return+qualifier+%2B+target+%2B+qualifier;
}|code-block|syntax|javascript|3322196|在一天结束时，你可以这样称呼它：|3322197|someDataTable.ToCSV();+//Plain+old+CSV
someDataTable.ToCSV("\"");+//Double+quote+qualifier
someDataTable.ToCSV("\"",+"\t");+//Tab+delimited|3322198|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|$]]

The full solution is too large to put here, but I wrote a series of extension methods that would allow you to easily convert a DataTable into a CSV.

<pre><code>public static String ToCSV(this DataTable dataTable)
{
 return dataTable.ToCSV(null, COMMA, true);
} 

public static String ToCSV(this DataTable dataTable, String qualifier)
{
 return dataTable.ToCSV(qualifier, COMMA, true);
}

private static String ToCSV(this DataTable dataTable, String qualifier, String delimiter, Boolean includeColumnNames)
{
 if (dataTable == null) return null;

 if (qualifier == delimiter)
 {
 throw new InvalidOperationException(
 "The qualifier and the delimiter are identical. This will cause the CSV to have collisions that might result in data being parsed incorrectly by another program.");
 }

 var sbCSV = new StringBuilder();

 var delimiterToUse = delimiter ?? COMMA;

 if (includeColumnNames) 
 sbCSV.AppendLine(dataTable.Columns.GetHeaderLine(qualifier, delimiterToUse));

 foreach (DataRow row in dataTable.Rows)
 {
 sbCSV.AppendLine(row.ToCSVLine(qualifier, delimiterToUse));
 }

 return sbCSV.Length &gt; 0 ? sbCSV.ToString() : null;
}

private static String ToCSVLine(this DataRow dataRow, String qualifier, String delimiter)
{
 var colCount = dataRow.Table.Columns.Count;
 var rowValues = new String[colCount];

 for (var i = 0; i &lt; colCount; i++)
 {
 rowValues[i] = dataRow[i].Qualify(qualifier);
 }

 return String.Join(delimiter, rowValues);
}

private static String GetHeaderLine(this DataColumnCollection columns, String qualifier, String delimiter)
{
 var colCount = columns.Count;
 var colNames = new String[colCount];

 for (var i = 0; i &lt; colCount; i++)
 {
 colNames[i] = columns[i].ColumnName.Qualify(qualifier);
 }

 return String.Join(delimiter, colNames);
}

private static String Qualify(this Object target, String qualifier)
{
 return qualifier + target + qualifier;
}
</code></pre>

At the end of the day, you could call it like this:

<pre><code>someDataTable.ToCSV(); //Plain old CSV
someDataTable.ToCSV("\""); //Double quote qualifier
someDataTable.ToCSV("\"", "\t"); //Tab delimited
</code></pre>

blocks|key|3322233|text|好吧，这并不是很聪明，但是我已经修改了-OrDefault方法，这样你就可以指定一个默认的内联项目，而不是稍后在你的代码中检查null：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322234|++++public+static+T+SingleOrDefault<T>+(+this+IEnumerable<T>+source,+
++++++++++++++++++++++++++++++++++++Func<T,+bool>+action,+T+theDefault+)
++++{
++++++++T+item+=+source.SingleOrDefault<T>(action);

++++++++if+(item+!=+null)
++++++++++++return+item;

++++++++return+theDefault;
++++}|code-block|syntax|javascript|3322235|它令人难以置信地简单，但确实有助于清理这些空检查。当你的UI需要一个包含X个项目的列表时，比如锦标赛系统，或者游戏玩家的位置，并且你想要显示“空座位”时，最好使用它。|3322236|用法：|3322237|++++return+jediList.SingleOrDefault(+
+++++++++++++++++j+=>+j.LightsaberColor+==+"Orange",+
+++++++++++++++new+Jedi()+{+LightsaberColor+=+"Orange",+Name+=+"DarthNobody");|3322238|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Well this isn't exactly clever but I've modified the ----OrDefault methods so you could specify a default item inline instead of checking for null later in your code:

<pre><code> public static T SingleOrDefault&lt;T&gt; ( this IEnumerable&lt;T&gt; source, 
 Func&lt;T, bool&gt; action, T theDefault )
 {
 T item = source.SingleOrDefault&lt;T&gt;(action);

 if (item != null)
 return item;

 return theDefault;
 }
</code></pre>

Its incredible simple but really helps clean up those null checks. Best used when your UI is expecting a list of X items, like a tournament system, or game player slots and you want to display "empty seats". 

Usage:

<pre><code> return jediList.SingleOrDefault( 
 j =&gt; j.LightsaberColor == "Orange", 
 new Jedi() { LightsaberColor = "Orange", Name = "DarthNobody");
</code></pre>

blocks|key|340850|text|这里有一个我一起黑出来的，所以你可以在上面挑个洞。它接受一个(有序的)整数列表，并返回一个连续范围的字符串列表。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340851|1,2,3,7,10,11,12++-->++"1-3","7","10-12"|code-block|syntax|javascript|340852|函数(在静态类中)：|340853|public+static+IEnumerable<string>+IntRanges(this+IEnumerable<int>+numbers)
{
++++int+rangeStart+=+0;
++++int+previous+=+0;

++++if+(!numbers.Any())
++++++++yield+break;

++++rangeStart+=+previous+=+numbers.FirstOrDefault();

++++foreach+(int+n+in+numbers.Skip(1))
++++{
++++++++if+(n+-+previous+>+1)+//+sequence+break+-+yield+a+sequence
++++++++{
++++++++++++if+(previous+>+rangeStart)
++++++++++++{
++++++++++++++++yield+return+string.Format("{0}-{1}",+rangeStart,+previous);
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++yield+return+rangeStart.ToString();
++++++++++++}
++++++++++++rangeStart+=+n;
++++++++}
++++++++previous+=+n;
++++}

++++if+(previous+>+rangeStart)
++++{
++++++++yield+return+string.Format("{0}-{1}",+rangeStart,+previous);
++++}
++++else
++++{
++++++++yield+return+rangeStart.ToString();
++++}
}|340854|使用示例：|340855|this.WeekDescription+=+string.Join(",",+from.WeekPattern.WeekPatternToInts().IntRanges().ToArray());|340856|此代码用于转换来自DailyWTF的时刻表应用程序的数据。WeekPattern是存储在字符串"0011011100...“中的位掩码。WeekPatternToInts()将其转换为IEnumerable，在本例中为3,4,6,7,8，它变为"3-4,6-8“。它为用户提供了发生讲座的学术周范围的紧凑描述。|340857|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Here's one I hacked together, so feel free to pick holes in it. It takes an (ordered) list of integers and returns a list of strings of contiguous ranges. eg:

<pre><code>1,2,3,7,10,11,12 --&gt; "1-3","7","10-12"
</code></pre>

The function (within a static class):

<pre><code>public static IEnumerable&lt;string&gt; IntRanges(this IEnumerable&lt;int&gt; numbers)
{
 int rangeStart = 0;
 int previous = 0;

 if (!numbers.Any())
 yield break;

 rangeStart = previous = numbers.FirstOrDefault();

 foreach (int n in numbers.Skip(1))
 {
 if (n - previous &gt; 1) // sequence break - yield a sequence
 {
 if (previous &gt; rangeStart)
 {
 yield return string.Format("{0}-{1}", rangeStart, previous);
 }
 else
 {
 yield return rangeStart.ToString();
 }
 rangeStart = n;
 }
 previous = n;
 }

 if (previous &gt; rangeStart)
 {
 yield return string.Format("{0}-{1}", rangeStart, previous);
 }
 else
 {
 yield return rangeStart.ToString();
 }
}
</code></pre>

Usage example:

<pre><code>this.WeekDescription = string.Join(",", from.WeekPattern.WeekPatternToInts().IntRanges().ToArray());
</code></pre>

This code is used to convert data from a DailyWTF-worthy timetabling application. WeekPattern is a bitmask stored in a string "0011011100...". WeekPatternToInts() converts that to an IEnumerable&lt;int&gt;, in this case [3,4,6,7,8], which becomes "3-4,6-8". It provides the user with a compact description of the academic week ranges that a lecture occurs on.

blocks|key|343229|text|我喜欢使用的两个方法是我编写的InsertWhere<T>和RemoveWhere<T>扩展方法。在WPF和Silverlight中使用ObservableCollections时，我经常需要修改有序列表，而不是重新创建它们。这些方法允许我根据提供的Func进行插入和删除，因此不需要重新调用.OrderBy()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|343230|++++///+<summary>
++++///+Removes+all+items+from+the+provided+<paramref+name="list"/>+that+match+the<paramref+name="predicate"/>+expression.
++++///+</summary>
++++///+<typeparam+name="T">The+class+type+of+the+list+items.</typeparam>
++++///+<param+name="list">The+list+to+remove+items+from.</param>
++++///+<param+name="predicate">The+predicate+expression+to+test+against.</param>
++++public+static+void+RemoveWhere<T>(this+IList<T>+list,+Func<T,+bool>+predicate)
++++{
++++++++T[]+copy+=+new+T[]+{+};
++++++++Array.Resize(ref+copy,+list.Count);
++++++++list.CopyTo(copy,+0);

++++++++for+(int+i+=+copy.Length+-+1;+i+>=+0;+i--)
++++++++{
++++++++++++if+(predicate(copy[i]))
++++++++++++{
++++++++++++++++list.RemoveAt(i);
++++++++++++}
++++++++}
++++}

++++///+<summary>
++++///+Inserts+an+Item+into+a+list+at+the+first+place+that+the+<paramref+name="predicate"/>+expression+fails.++If+it+is+true+in+all+cases,+then+the+item+is+appended+to+the+end+of+the+list.
++++///+</summary>
++++///+<typeparam+name="T"></typeparam>
++++///+<param+name="list"></param>
++++///+<param+name="obj"></param>
++++///+<param+name="predicate">The+sepcified+function+that+determines+when+the+<paramref+name="obj"/>+should+be+added.+</param>
++++public+static+void+InsertWhere<T>(this+IList<T>+list,+T+obj,+Func<T,+bool>+predicate)
++++{
++++++++for+(int+i+=+0;+i+<+list.Count;+i%2B%2B)
++++++++{+
++++++++++++//+When+the+function+first+fails+it+inserts+the+obj+paramiter.+
++++++++++++//+For+example,+in+a+list+myList+of+ordered+Int32's+{1,2,3,4,5,10,12}
++++++++++++//+Calling+myList.InsertWhere(+8,+x+=>+8+>+x)+inserts+8+once+the+list+item+becomes+greater+then+or+equal+to+it.
++++++++++++if(!predicate(list[i]))
++++++++++++{
++++++++++++++++list.Insert(i,+obj);
++++++++++++++++return;
++++++++++++}
++++++++}

++++++++list.Add(obj);
++++}|code-block|syntax|javascript|343231|编辑：|BOLD|343232|Talljoe对我匆忙构建的RemoveWhere/RemoveAll做了一些重大改进。新版本每隔三个项目就会删除一次，只需要大约50毫秒(如果可以调用List.RemoveAll，则不到10毫秒!)与之相对的是RemoveWhere的几秒钟(我已经厌倦了等待)。|343233|这是他的大大改进的版本，再次感谢！|343234|++++public+static+void+RemoveAll<T>(this+IList<T>+instance,+Predicate<T>+predicate)
++++{
++++++++if+(instance+==+null)
++++++++++++throw+new+ArgumentNullException("instance");
++++++++if+(predicate+==+null)
++++++++++++throw+new+ArgumentNullException("predicate");
++++++++if+(instance+is+T[])
++++++++++++throw+new+NotSupportedException();

++++++++var+list+=+instance+as+List<T>;
++++++++if+(list+!=+null)
++++++++{
++++++++++++list.RemoveAll(predicate);
++++++++++++return;
++++++++}

++++++++int+writeIndex+=+0;
++++++++for+(int+readIndex+=+0;+readIndex+<+instance.Count;+readIndex%2B%2B)
++++++++{
++++++++++++var+item+=+instance[readIndex];
++++++++++++if+(predicate(item))+continue;

++++++++++++if+(readIndex+!=+writeIndex)
++++++++++++{
++++++++++++++++instance[writeIndex]+=+item;
++++++++++++}
++++++++++++%2B%2BwriteIndex;
++++++++}

++++++++if+(writeIndex+!=+instance.Count)
++++++++{
++++++++++++for+(int+deleteIndex+=+instance.Count+-+1;+deleteIndex+>=+writeIndex;+--deleteIndex)
++++++++++++{
++++++++++++++++instance.RemoveAt(deleteIndex);
++++++++++++}
++++++++}
++++}|343235|entityMap^0|Q|2|15|2|0|0|0|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|M]]|D|@]|E|$]]|$1|N|3|O|5|6|7|14|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|15|8|@]|D|@]|E|$]]|$1|R|3|S|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|T|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|U|$]]

Two that I like to use are the InsertWhere<code>&lt;T</code>> and RemoveWhere<code>&lt;T</code>> Extension Methods that I've written. Working with ObservableCollections in WPF and Silverlight I often need to modify ordered lists without recreating them. These methods allow me to insert and remove according to a supplied Func, so .OrderBy() doesn't need to be re-called.

<pre><code> /// &lt;summary&gt;
 /// Removes all items from the provided &lt;paramref name="list"/&gt; that match the&lt;paramref name="predicate"/&gt; expression.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;The class type of the list items.&lt;/typeparam&gt;
 /// &lt;param name="list"&gt;The list to remove items from.&lt;/param&gt;
 /// &lt;param name="predicate"&gt;The predicate expression to test against.&lt;/param&gt;
 public static void RemoveWhere&lt;T&gt;(this IList&lt;T&gt; list, Func&lt;T, bool&gt; predicate)
 {
 T[] copy = new T[] { };
 Array.Resize(ref copy, list.Count);
 list.CopyTo(copy, 0);

 for (int i = copy.Length - 1; i &gt;= 0; i--)
 {
 if (predicate(copy[i]))
 {
 list.RemoveAt(i);
 }
 }
 }

 /// &lt;summary&gt;
 /// Inserts an Item into a list at the first place that the &lt;paramref name="predicate"/&gt; expression fails. If it is true in all cases, then the item is appended to the end of the list.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
 /// &lt;param name="list"&gt;&lt;/param&gt;
 /// &lt;param name="obj"&gt;&lt;/param&gt;
 /// &lt;param name="predicate"&gt;The sepcified function that determines when the &lt;paramref name="obj"/&gt; should be added. &lt;/param&gt;
 public static void InsertWhere&lt;T&gt;(this IList&lt;T&gt; list, T obj, Func&lt;T, bool&gt; predicate)
 {
 for (int i = 0; i &lt; list.Count; i++)
 { 
 // When the function first fails it inserts the obj paramiter. 
 // For example, in a list myList of ordered Int32's {1,2,3,4,5,10,12}
 // Calling myList.InsertWhere( 8, x =&gt; 8 &gt; x) inserts 8 once the list item becomes greater then or equal to it.
 if(!predicate(list[i]))
 {
 list.Insert(i, obj);
 return;
 }
 }

 list.Add(obj);
 }
</code></pre>

Edit: 
Talljoe made some significant improvements to the RemoveWhere/RemoveAll, that I had hastily constructed. With ~3mill items removing every third one the new version takes only ~50 milliseconds (less then 10 if it can call List.RemoveAll !) as opposed to the RemoveWhere 's multiple seconds (I got tired of waiting for it.)

Here is his greatly improved version, thanks again!

<pre><code> public static void RemoveAll&lt;T&gt;(this IList&lt;T&gt; instance, Predicate&lt;T&gt; predicate)
 {
 if (instance == null)
 throw new ArgumentNullException("instance");
 if (predicate == null)
 throw new ArgumentNullException("predicate");
 if (instance is T[])
 throw new NotSupportedException();

 var list = instance as List&lt;T&gt;;
 if (list != null)
 {
 list.RemoveAll(predicate);
 return;
 }

 int writeIndex = 0;
 for (int readIndex = 0; readIndex &lt; instance.Count; readIndex++)
 {
 var item = instance[readIndex];
 if (predicate(item)) continue;

 if (readIndex != writeIndex)
 {
 instance[writeIndex] = item;
 }
 ++writeIndex;
 }

 if (writeIndex != instance.Count)
 {
 for (int deleteIndex = instance.Count - 1; deleteIndex &gt;= writeIndex; --deleteIndex)
 {
 instance.RemoveAt(deleteIndex);
 }
 }
 }
</code></pre>

blocks|key|3322315|text|这是我最近在工作中写的一篇文章，并在博客上写道：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322316|http://crazorsharp.blogspot.com/2009/03/cool-ienumberable-extension-method_25.html|offset|length|3322317|它基本上是IEnumerable.ToHtmlTable()；|3322318|entityMap|0|LINK|mutability|MUTABLE|url|http://tinyurl.com/cv2j8e^0|0|0|2A|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Here's one I wrote recently at work and blogged about:

<a href="http://tinyurl.com/cv2j8e" rel="nofollow noreferrer">http://crazorsharp.blogspot.com/2009/03/cool-ienumberable-extension-method_25.html</a>

It's basically IEnumerable.ToHtmlTable();

blocks|key|3322335|text|int上的扩展方法将指定天的位掩码(在本例中，一周的第一天是星期一)解码为DayOfWeek枚举的枚举：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322336|public+static+IEnumerable<DayOfWeek>+Days(this+int+dayMask)
{
++++if+((dayMask+&+1)+>+0)+yield+return+DayOfWeek.Monday;
++++if+((dayMask+&+2)+>+0)+yield+return+DayOfWeek.Tuesday;
++++if+((dayMask+&+4)+>+0)+yield+return+DayOfWeek.Wednesday;
++++if+((dayMask+&+8)+>+0)+yield+return+DayOfWeek.Thursday;
++++if+((dayMask+&+16)+>+0)+yield+return+DayOfWeek.Friday;
++++if+((dayMask+&+32)+>+0)+yield+return+DayOfWeek.Saturday;
++++if+((dayMask+&+64)+>+0)+yield+return+DayOfWeek.Sunday;
}|code-block|syntax|javascript|3322337|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|$]]

Extension method on int to decode a bitmask specifying days (with first day of week being Monday in this case) to an enumeration of DayOfWeek enums:

<pre><code>public static IEnumerable&lt;DayOfWeek&gt; Days(this int dayMask)
{
 if ((dayMask &amp; 1) &gt; 0) yield return DayOfWeek.Monday;
 if ((dayMask &amp; 2) &gt; 0) yield return DayOfWeek.Tuesday;
 if ((dayMask &amp; 4) &gt; 0) yield return DayOfWeek.Wednesday;
 if ((dayMask &amp; 8) &gt; 0) yield return DayOfWeek.Thursday;
 if ((dayMask &amp; 16) &gt; 0) yield return DayOfWeek.Friday;
 if ((dayMask &amp; 32) &gt; 0) yield return DayOfWeek.Saturday;
 if ((dayMask &amp; 64) &gt; 0) yield return DayOfWeek.Sunday;
}
</code></pre>

blocks|key|3322368|text|一对用于转换base-36字符串的扩展方法(！)对于整数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322369|public+static+int+ToBase10(this+string+base36)
{
++++if+(string.IsNullOrEmpty(base36))
++++++++return+0;
++++int+value+=+0;
++++foreach+(var+c+in+base36.Trim())
++++{
++++++++value+=+value+*+36+%2B+c.ToBase10();
++++}
++++return+value;
}

public+static+int+ToBase10(this+char+c)
{
++++if+(c+>=+'0'+&&+c+<=+'9')
++++++++return+c+-+'0';
++++c+=+char.ToUpper(c);
++++if+(c+>=+'A'+&&+c+<=+'Z')
++++++++return+c+-+'A'+%2B+10;
++++return+0;
}|code-block|syntax|javascript|3322370|(一些天才认为，在数据库中存储数字的最好方法是将它们编码为字符串。小数占用了太多的空间。十六进制更好，但不使用字符G-Z。显然，您将基数16扩展到了基数36！)|3322371|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A pair of extension methods to convert base-36 strings(!) to integers:

<pre><code>public static int ToBase10(this string base36)
{
 if (string.IsNullOrEmpty(base36))
 return 0;
 int value = 0;
 foreach (var c in base36.Trim())
 {
 value = value * 36 + c.ToBase10();
 }
 return value;
}

public static int ToBase10(this char c)
{
 if (c &gt;= '0' &amp;&amp; c &lt;= '9')
 return c - '0';
 c = char.ToUpper(c);
 if (c &gt;= 'A' &amp;&amp; c &lt;= 'Z')
 return c - 'A' + 10;
 return 0;
}
</code></pre>

(Some genius decided that the best way to store numbers in the database was to encode them to strings. Decimals take too much space. Hex is better, but doesnt use the characters G-Z. So obviously you extend base-16 to base-36!)

blocks|key|338507|text|我有各种.Debugify扩展方法，它们对将对象转储到日志文件很有用。例如，下面是我的Dictionary+debugify+(我有列表、数据表、参数数组等)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|338508|public+static+string+Debugify<TKey,+TValue>(this+Dictionary<TKey,+TValue>+dictionary)+{
++++string+Result+=+"";

++++if+(dictionary.Count+>+0)+{
++++++++StringBuilder+ResultBuilder+=+new+StringBuilder();

++++++++int+Counter+=+0;
++++++++foreach+(KeyValuePair<TKey,+TValue>+Entry+in+dictionary)+{
++++++++++++Counter%2B%2B;
++++++++++++ResultBuilder.AppendFormat("{0}:+{1},+",+Entry.Key,+Entry.Value);
++++++++++++if+(Counter+%25+10+==+0)+ResultBuilder.AppendLine();
++++++++}
++++++++Result+=+ResultBuilder.ToString();
++++}
++++return+Result;
}|code-block|syntax|javascript|338509|下面是一个DbParameterCollection+(用于将数据库调用转储到日志文件)：|338510|public+static+string+Debugify(this+DbParameterCollection+parameters)+{
++++List<string>+ParameterValuesList+=+new+List<string>();

++++foreach+(DbParameter+Parameter+in+parameters)+{
++++++++string+ParameterName,+ParameterValue;
++++++++ParameterName+=+Parameter.ParameterName;

++++++++if+(Parameter.Direction+==+ParameterDirection.ReturnValue)
++++++++++++continue;

++++++++if+(Parameter.Value+==+null+%7C%7C+Parameter.Value.Equals(DBNull.Value))
++++++++++++ParameterValue+=+"NULL";
++++++++else
++++++++{
++++++++++++switch+(Parameter.DbType)
++++++++++++{
++++++++++++++++case+DbType.String:
++++++++++++++++case+DbType.Date:
++++++++++++++++case+DbType.DateTime:
++++++++++++++++case+DbType.Guid:
++++++++++++++++case+DbType.Xml:
++++++++++++++++++++ParameterValue
++++++++++++++++++++++++=+"'"+%2B+Parameter
++++++++++++++++++++++++++++++++.Value
++++++++++++++++++++++++++++++++.ToString()
++++++++++++++++++++++++++++++++.Replace(Environment.NewLine,+"")
++++++++++++++++++++++++++++++++.Left(80,+"...")+%2B+"'";+//+Left...+is+another+nice+one
++++++++++++++++++++break;

++++++++++++++++default:
++++++++++++++++++++ParameterValue+=+Parameter.Value.ToString();
++++++++++++++++++++break;
++++++++++++}

++++++++++++if+(Parameter.Direction+!=+ParameterDirection.Input)
++++++++++++++++ParameterValue+%2B=+"+"+%2B+Parameter.Direction.ToString();
++++++++}

++++++++ParameterValuesList.Add(string.Format("{0}={1}",+ParameterName,+ParameterValue));
++++}

++++return+string.Join(",+",+ParameterValuesList.ToArray());
}|338511|示例结果：|BOLD|338512|Log.DebugFormat("EXEC+{0}+{1}",+procName,+params.Debugify);
//+EXEC+spProcedure+@intID=5,+@nvName='Michael+Haren',+@intRefID=11+OUTPUT|338513|请注意，如果您在DB调用之后调用此函数，您也将获得填充的输出参数。我在包含SP名称的行上调用它，这样我就可以将调用复制/粘贴到SSMS中进行调试。|338514|338515|这些让我的日志文件看起来很漂亮，很容易生成，而不会中断我的代码。|338516|entityMap^0|4|9|0|0|0|0|0|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|Q]]|D|@]|E|$]]|$1|R|3|S|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1A|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1C|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|Z|$]]

I have various <code>.Debugify</code> extension methods that are useful for dumping objects to a log file. For example, here's my Dictionary debugify (I have these for List, Datatable, param array, etc.):

<pre><code>public static string Debugify&lt;TKey, TValue&gt;(this Dictionary&lt;TKey, TValue&gt; dictionary) {
 string Result = "";

 if (dictionary.Count &gt; 0) {
 StringBuilder ResultBuilder = new StringBuilder();

 int Counter = 0;
 foreach (KeyValuePair&lt;TKey, TValue&gt; Entry in dictionary) {
 Counter++;
 ResultBuilder.AppendFormat("{0}: {1}, ", Entry.Key, Entry.Value);
 if (Counter % 10 == 0) ResultBuilder.AppendLine();
 }
 Result = ResultBuilder.ToString();
 }
 return Result;
}
</code></pre>

And here's one for a DbParameterCollection (useful for dumping database calls to the log file):

<pre><code>public static string Debugify(this DbParameterCollection parameters) {
 List&lt;string&gt; ParameterValuesList = new List&lt;string&gt;();

 foreach (DbParameter Parameter in parameters) {
 string ParameterName, ParameterValue;
 ParameterName = Parameter.ParameterName;

 if (Parameter.Direction == ParameterDirection.ReturnValue)
 continue;

 if (Parameter.Value == null || Parameter.Value.Equals(DBNull.Value))
 ParameterValue = "NULL";
 else
 {
 switch (Parameter.DbType)
 {
 case DbType.String:
 case DbType.Date:
 case DbType.DateTime:
 case DbType.Guid:
 case DbType.Xml:
 ParameterValue
 = "'" + Parameter
 .Value
 .ToString()
 .Replace(Environment.NewLine, "")
 .Left(80, "...") + "'"; // Left... is another nice one
 break;

 default:
 ParameterValue = Parameter.Value.ToString();
 break;
 }

 if (Parameter.Direction != ParameterDirection.Input)
 ParameterValue += " " + Parameter.Direction.ToString();
 }

 ParameterValuesList.Add(string.Format("{0}={1}", ParameterName, ParameterValue));
 }

 return string.Join(", ", ParameterValuesList.ToArray());
}
</code></pre>

Example result:

<pre><code>Log.DebugFormat("EXEC {0} {1}", procName, params.Debugify);
// EXEC spProcedure @intID=5, @nvName='Michael Haren', @intRefID=11 OUTPUT
</code></pre>

Note that if you call this after your DB calls, you'll get the output parameters filled in, too. I call this on a line that includes the SP name so I can copy/paste the call into SSMS for debugging.

<hr>

These make my log files pretty and easy to generate without interrupting my code.

blocks|key|339843|text|这个创建的数组在最开始的时候添加了一个元素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339844|public+static+T[]+Prepend<T>(this+T[]+array,+T+item)
{
++++T[]+result+=+new+T[array.Length+%2B+1];
++++result[0]+=+item;
++++Array.Copy(array,+0,+result,+1,+array.Length);
++++return+result;
}

string[]+some+=+new+string[]+{+"foo",+"bar"+};
...
some+=+some.Prepend("baz");+|code-block|syntax|javascript|339845|当我需要将一些表达式转换成它的正方形时，这个方法可以帮助我：|339846|public+static+double+Sq(this+double+arg)
{
++++return+arg+*+arg;
}

(x+-+x0).Sq()+%2B+(y+-+y0).Sq()+%2B+(z+-+z0).Sq()|339847|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|$]]

This one creates array with single element added at the very beginning:

<pre><code>public static T[] Prepend&lt;T&gt;(this T[] array, T item)
{
 T[] result = new T[array.Length + 1];
 result[0] = item;
 Array.Copy(array, 0, result, 1, array.Length);
 return result;
}

string[] some = new string[] { "foo", "bar" };
...
some = some.Prepend("baz"); 
</code></pre>

And this one helps me when I need to convert some expression to it's square:

<pre><code>public static double Sq(this double arg)
{
 return arg * arg;
}

(x - x0).Sq() + (y - y0).Sq() + (z - z0).Sq()
</code></pre>

blocks|key|338558|text|这是我写的另一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338559|++++public+static+class+StringExtensions
++++{
++++++++///+<summary>
++++++++///+Returns+a+Subset+string+starting+at+the+specified+start+index+and+ending+and+the+specified+end
++++++++///+index.
++++++++///+</summary>
++++++++///+<param+name="s">The+string+to+retrieve+the+subset+from.</param>
++++++++///+<param+name="startIndex">The+specified+start+index+for+the+subset.</param>
++++++++///+<param+name="endIndex">The+specified+end+index+for+the+subset.</param>
++++++++///+<returns>A+Subset+string+starting+at+the+specified+start+index+and+ending+and+the+specified+end
++++++++///+index.</returns>
++++++++public+static+string+Subsetstring(this+string+s,+int+startIndex,+int+endIndex)
++++++++{
++++++++++++if+(startIndex+<+0)+throw+new+ArgumentOutOfRangeException("startIndex",+"Must+be+positive.");
++++++++++++if+(endIndex+<+0)+throw+new+ArgumentOutOfRangeException("endIndex",+"Must+be+positive.");
++++++++++++if+(startIndex+>+endIndex)+throw+new+ArgumentOutOfRangeException("endIndex",+"Must+be+>=+startIndex.");
++++++++++++return+s.Substring(startIndex,+(endIndex+-+startIndex));
++++++++}

++++++++///+<summary>
++++++++///+Finds+the+specified+Start+Text+and+the+End+Text+in+this+string+instance,+and+returns+a+string
++++++++///+containing+all+the+text+starting+from+startText,+to+the+begining+of+endText.+(endText+is+not
++++++++///+included.)
++++++++///+</summary>
++++++++///+<param+name="s">The+string+to+retrieve+the+subset+from.</param>
++++++++///+<param+name="startText">The+Start+Text+to+begin+the+Subset+from.</param>
++++++++///+<param+name="endText">The+End+Text+to+where+the+Subset+goes+to.</param>
++++++++///+<param+name="ignoreCase">Whether+or+not+to+ignore+case+when+comparing+startText/endText+to+the+string.</param>
++++++++///+<returns>A+string+containing+all+the+text+starting+from+startText,+to+the+begining+of+endText.</returns>
++++++++public+static+string+Subsetstring(this+string+s,+string+startText,+string+endText,+bool+ignoreCase)
++++++++{
++++++++++++if+(string.IsNullOrEmpty(startText))+throw+new+ArgumentNullException("startText",+"Must+be+filled.");
++++++++++++if+(string.IsNullOrEmpty(endText))+throw+new+ArgumentNullException("endText",+"Must+be+filled.");
++++++++++++string+temp+=+s;
++++++++++++if+(ignoreCase)
++++++++++++{
++++++++++++++++temp+=+s.ToUpperInvariant();
++++++++++++++++startText+=+startText.ToUpperInvariant();
++++++++++++++++endText+=+endText.ToUpperInvariant();
++++++++++++}
++++++++++++int+start+=+temp.IndexOf(startText);
++++++++++++int+end+=+temp.IndexOf(endText,+start);
++++++++++++return+Subsetstring(s,+start,+end);
++++++++}
++++}|code-block|syntax|javascript|338560|这背后的动机很简单。内置的Substring方法是如何将startindex和length作为它的参数的，这一直困扰着我。做startindex和endindex总是更有帮助的。所以，我写了我自己的：|338561|用法：|338562|++++++++string+s+=+"This+is+a+tester+for+my+cool+extension+method!!";
++++++++s+=+s.Subsetstring("tester",+"cool",true);|338563|我必须使用Subsetstring的原因是因为Substring的重载已经接受了两个整数。如果有人有更好的名字，请让我知道！|338564|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's another one I wrote:

<pre><code> public static class StringExtensions
 {
 /// &lt;summary&gt;
 /// Returns a Subset string starting at the specified start index and ending and the specified end
 /// index.
 /// &lt;/summary&gt;
 /// &lt;param name="s"&gt;The string to retrieve the subset from.&lt;/param&gt;
 /// &lt;param name="startIndex"&gt;The specified start index for the subset.&lt;/param&gt;
 /// &lt;param name="endIndex"&gt;The specified end index for the subset.&lt;/param&gt;
 /// &lt;returns&gt;A Subset string starting at the specified start index and ending and the specified end
 /// index.&lt;/returns&gt;
 public static string Subsetstring(this string s, int startIndex, int endIndex)
 {
 if (startIndex &lt; 0) throw new ArgumentOutOfRangeException("startIndex", "Must be positive.");
 if (endIndex &lt; 0) throw new ArgumentOutOfRangeException("endIndex", "Must be positive.");
 if (startIndex &gt; endIndex) throw new ArgumentOutOfRangeException("endIndex", "Must be &gt;= startIndex.");
 return s.Substring(startIndex, (endIndex - startIndex));
 }

 /// &lt;summary&gt;
 /// Finds the specified Start Text and the End Text in this string instance, and returns a string
 /// containing all the text starting from startText, to the begining of endText. (endText is not
 /// included.)
 /// &lt;/summary&gt;
 /// &lt;param name="s"&gt;The string to retrieve the subset from.&lt;/param&gt;
 /// &lt;param name="startText"&gt;The Start Text to begin the Subset from.&lt;/param&gt;
 /// &lt;param name="endText"&gt;The End Text to where the Subset goes to.&lt;/param&gt;
 /// &lt;param name="ignoreCase"&gt;Whether or not to ignore case when comparing startText/endText to the string.&lt;/param&gt;
 /// &lt;returns&gt;A string containing all the text starting from startText, to the begining of endText.&lt;/returns&gt;
 public static string Subsetstring(this string s, string startText, string endText, bool ignoreCase)
 {
 if (string.IsNullOrEmpty(startText)) throw new ArgumentNullException("startText", "Must be filled.");
 if (string.IsNullOrEmpty(endText)) throw new ArgumentNullException("endText", "Must be filled.");
 string temp = s;
 if (ignoreCase)
 {
 temp = s.ToUpperInvariant();
 startText = startText.ToUpperInvariant();
 endText = endText.ToUpperInvariant();
 }
 int start = temp.IndexOf(startText);
 int end = temp.IndexOf(endText, start);
 return Subsetstring(s, start, end);
 }
 }
</code></pre>

The motivation behind this one was simple. It always bugged me how the built in Substring method took startindex and length as it's parameters. It's ALWAYS much more helpful to do startindex and endindex. So, I rolled my own:

Usage:

<pre><code> string s = "This is a tester for my cool extension method!!";
 s = s.Subsetstring("tester", "cool",true);
</code></pre>

The reason I had to use Subsetstring was because Substring's overload already takes two ints. If anyone has a better name, please, let me know!!

blocks|key|3109572|text|String.format不应该是静态的。所以我使用了一个名为frmt的扩展方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3109573|<Extension()>+Public+Function+frmt(ByVal+format+As+String,
+++++++++++++++++++++++++++++++++++ByVal+ParamArray+args()+As+Object)+As+String
++++If+format+Is+Nothing+Then+Throw+New+ArgumentNullException("format")
++++Return+String.Format(format,+args)
End+Function|code-block|syntax|javascript|3109574|当我想在不构造二进制写入器的情况下读写字节流时(从技术上讲，你不应该在用写入器包装原始流之后对其进行修改)：|3109575|<Extension()>+Public+Function+Bytes(ByVal+n+As+ULong,
++++++++++++++++++++++++++++++++++++ByVal+byteOrder+As+ByteOrder,
++++++++++++++++++++++++++++++++++++Optional+ByVal+size+As+Integer+=+8)+As+Byte()
++++Dim+data+As+New+List(Of+Byte)
++++Do+Until+data.Count+>=+size
++++++++data.Add(CByte(n+And+CULng(&HFF)))
++++++++n+>>=+8
++++Loop
++++Select+Case+byteOrder
++++++++Case+ByteOrder.BigEndian
++++++++++++Return+data.ToArray.reversed
++++++++Case+ByteOrder.LittleEndian
++++++++++++Return+data.ToArray
++++++++Case+Else
++++++++++++Throw+New+ArgumentException("Unrecognized+byte+order.")
++++End+Select
End+Function
<Extension()>+Public+Function+ToULong(ByVal+data+As+IEnumerable(Of+Byte),
++++++++++++++++++++++++++++++++++++++ByVal+byteOrder+As+ByteOrder)+As+ULong
++++If+data+Is+Nothing+Then+Throw+New+ArgumentNullException("data")
++++Dim+val+As+ULong
++++Select+Case+byteOrder
++++++++Case+ByteOrder.LittleEndian
++++++++++++data+=+data.Reverse
++++++++Case+ByteOrder.BigEndian
++++++++++++'no+change+required
++++++++Case+Else
++++++++++++Throw+New+ArgumentException("Unrecognized+byte+order.")
++++End+Select
++++For+Each+b+In+data
++++++++val+<<=+8
++++++++val+=+val+Or+b
++++Next+b
++++Return+val
End+Function|3109576|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|$]]

String.format should not have been static. So I use an extension method called frmt:

<pre><code>&lt;Extension()&gt; Public Function frmt(ByVal format As String,
 ByVal ParamArray args() As Object) As String
 If format Is Nothing Then Throw New ArgumentNullException("format")
 Return String.Format(format, args)
End Function
</code></pre>

When I want to read or write a number to a byte stream without constructing a binary writer (technically you aren't supposed to modify the raw stream after you've wrapped it with a writer):

<pre><code>&lt;Extension()&gt; Public Function Bytes(ByVal n As ULong,
 ByVal byteOrder As ByteOrder,
 Optional ByVal size As Integer = 8) As Byte()
 Dim data As New List(Of Byte)
 Do Until data.Count &gt;= size
 data.Add(CByte(n And CULng(&amp;HFF)))
 n &gt;&gt;= 8
 Loop
 Select Case byteOrder
 Case ByteOrder.BigEndian
 Return data.ToArray.reversed
 Case ByteOrder.LittleEndian
 Return data.ToArray
 Case Else
 Throw New ArgumentException("Unrecognized byte order.")
 End Select
End Function
&lt;Extension()&gt; Public Function ToULong(ByVal data As IEnumerable(Of Byte),
 ByVal byteOrder As ByteOrder) As ULong
 If data Is Nothing Then Throw New ArgumentNullException("data")
 Dim val As ULong
 Select Case byteOrder
 Case ByteOrder.LittleEndian
 data = data.Reverse
 Case ByteOrder.BigEndian
 'no change required
 Case Else
 Throw New ArgumentException("Unrecognized byte order.")
 End Select
 For Each b In data
 val &lt;&lt;= 8
 val = val Or b
 Next b
 Return val
End Function
</code></pre>

blocks|key|3322544|text|这是我最近一直在玩的一个游戏：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322545|public+static+IDisposable+Tag(this+HtmlHelper+html,+string+tagName)
{
++++if+(html+==+null)
++++++++throw+new+ArgumentNullException("html");

++++Action<string>+a+=+tag+=>+html.Write(String.Format(tag,+tagName));
++++a("<{0}>");
++++return+new+Memento(()+=>+a("</{0}>"));
}|code-block|syntax|javascript|3322546|用法如下：|3322547|using+(Html.Tag("ul"))
{
++++this.Model.ForEach(item+=>+using(Html.Tag("li"))+Html.Write(item));
++++using(Html.Tag("li"))+Html.Write("new");
}|3322548|Memento是一个很方便的类：|3322549|public+sealed+class+Memento+:+IDisposable
{
++++private+bool+Disposed+{+get;+set;+}
++++private+Action+Action+{+get;+set;+}

++++public+Memento(Action+action)
++++{
++++++++if+(action+==+null)
++++++++++++throw+new+ArgumentNullException("action");

++++++++Action+=+action;
++++}

++++void+IDisposable.Dispose()
++++{
++++++++if+(Disposed)
++++++++++++throw+new+ObjectDisposedException("Memento");

++++++++Disposed+=+true;
++++++++Action();
++++}
}|3322550|并完成依赖关系：|3322551|public+static+void+Write(this+HtmlHelper+html,+string+content)
{
++++if+(html+==+null)
++++++++throw+new+ArgumentNullException("html");

++++html.ViewContext.HttpContext.Response.Write(content);
}|3322552|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

This is one that's been getting some play from me lately:

<pre><code>public static IDisposable Tag(this HtmlHelper html, string tagName)
{
 if (html == null)
 throw new ArgumentNullException("html");

 Action&lt;string&gt; a = tag =&gt; html.Write(String.Format(tag, tagName));
 a("&lt;{0}&gt;");
 return new Memento(() =&gt; a("&lt;/{0}&gt;"));
}
</code></pre>

Used like:

<pre><code>using (Html.Tag("ul"))
{
 this.Model.ForEach(item =&gt; using(Html.Tag("li")) Html.Write(item));
 using(Html.Tag("li")) Html.Write("new");
}
</code></pre>

Memento is a handy class:

<pre><code>public sealed class Memento : IDisposable
{
 private bool Disposed { get; set; }
 private Action Action { get; set; }

 public Memento(Action action)
 {
 if (action == null)
 throw new ArgumentNullException("action");

 Action = action;
 }

 void IDisposable.Dispose()
 {
 if (Disposed)
 throw new ObjectDisposedException("Memento");

 Disposed = true;
 Action();
 }
}
</code></pre>

And to complete the dependencies:

<pre><code>public static void Write(this HtmlHelper html, string content)
{
 if (html == null)
 throw new ArgumentNullException("html");

 html.ViewContext.HttpContext.Response.Write(content);
}
</code></pre>

blocks|key|341023|text|很酷，也喜欢扩展！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341024|这里有几个。|341025|这一个将获得一个月的最后一个日期：|341026|<System.Runtime.CompilerServices.Extension()>+_
++++Public+Function+GetLastMonthDay(ByVal+Source+As+DateTime)+As+DateTime
++++++++Dim+CurrentMonth+As+Integer+=+Source.Month
++++++++Dim+MonthCounter+As+Integer+=+Source.Month
++++++++Dim+LastDay+As+DateTime
++++++++Dim+DateCounter+As+DateTime+=+Source

++++++++LastDay+=+Source

++++++++Do+While+MonthCounter+=+CurrentMonth
++++++++++++DateCounter+=+DateCounter.AddDays(1)
++++++++++++MonthCounter+=+DateCounter.Month

++++++++++++If+MonthCounter+=+CurrentMonth+Then
++++++++++++++++LastDay+=+DateCounter
++++++++++++End+If
++++++++Loop

++++++++Return+LastDay
++++End+Function|code-block|syntax|javascript|341027|这两个让反射变得更容易了：|341028|+<System.Runtime.CompilerServices.Extension()>+_
++++Public+Function+GetPropertyValue(Of+ValueType)(ByVal+Source+As+Object,+ByVal+PropertyName+As+String)+As+ValueType
++++++++Dim+pInfo+As+System.Reflection.PropertyInfo

++++++++pInfo+=+Source.GetType.GetProperty(PropertyName)

++++++++If+pInfo+Is+Nothing+Then
++++++++++++Throw+New+Exception("Property+"+&+PropertyName+&+"+does+not+exists+for+object+of+type+"+&+Source.GetType.Name)
++++++++Else
++++++++++++Return+pInfo.GetValue(Source,+Nothing)
++++++++End+If
++++End+Function

++++<System.Runtime.CompilerServices.Extension()>+_
++++Public+Function+GetPropertyType(ByVal+Source+As+Object,+ByVal+PropertyName+As+String)+As+Type
++++++++Dim+pInfo+As+System.Reflection.PropertyInfo

++++++++pInfo+=+Source.GetType.GetProperty(PropertyName)

++++++++If+pInfo+Is+Nothing+Then
++++++++++++Throw+New+Exception("Property+"+&+PropertyName+&+"+does+not+exists+for+object+of+type+"+&+Source.GetType.Name)
++++++++Else
++++++++++++Return+pInfo.PropertyType
++++++++End+If
++++End+Function|341029|entityMap^0|0|0|0|0|0|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|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

cool, also loving Extensions!

here's a few.

This one will get the last Date of a Month:

<pre><code>&lt;System.Runtime.CompilerServices.Extension()&gt; _
 Public Function GetLastMonthDay(ByVal Source As DateTime) As DateTime
 Dim CurrentMonth As Integer = Source.Month
 Dim MonthCounter As Integer = Source.Month
 Dim LastDay As DateTime
 Dim DateCounter As DateTime = Source

 LastDay = Source

 Do While MonthCounter = CurrentMonth
 DateCounter = DateCounter.AddDays(1)
 MonthCounter = DateCounter.Month

 If MonthCounter = CurrentMonth Then
 LastDay = DateCounter
 End If
 Loop

 Return LastDay
 End Function
</code></pre>

these two make reflection a bit easier:

<pre><code> &lt;System.Runtime.CompilerServices.Extension()&gt; _
 Public Function GetPropertyValue(Of ValueType)(ByVal Source As Object, ByVal PropertyName As String) As ValueType
 Dim pInfo As System.Reflection.PropertyInfo

 pInfo = Source.GetType.GetProperty(PropertyName)

 If pInfo Is Nothing Then
 Throw New Exception("Property " &amp; PropertyName &amp; " does not exists for object of type " &amp; Source.GetType.Name)
 Else
 Return pInfo.GetValue(Source, Nothing)
 End If
 End Function

 &lt;System.Runtime.CompilerServices.Extension()&gt; _
 Public Function GetPropertyType(ByVal Source As Object, ByVal PropertyName As String) As Type
 Dim pInfo As System.Reflection.PropertyInfo

 pInfo = Source.GetType.GetProperty(PropertyName)

 If pInfo Is Nothing Then
 Throw New Exception("Property " &amp; PropertyName &amp; " does not exists for object of type " &amp; Source.GetType.Name)
 Else
 Return pInfo.PropertyType
 End If
 End Function
</code></pre>

blocks|key|3109640|text|这个函数会移位一个序列，这样您就可以先得到给定的项。例如，我使用它来获取周的日期并将其移位，以便序列中的第一天是当前文化的一周的第一天。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3109641|++++///+<summary>
++++///+Shifts+a+sequence+so+that+the+given+<paramref+name="item"/>+becomes+the+first.+
++++///+Uses+the+specified+equality+<paramref+name="comparer"/>+to+find+the+item.
++++///+</summary>
++++///+<typeparam+name="TSource">Type+of+elements+in+<paramref+name="source"/>.</typeparam>
++++///+<param+name="source">Sequence+of+elements.</param>
++++///+<param+name="item">Item+which+will+become+the+first.</param>
++++///+<param+name="comparer">Used+to+find+the+first+item.</param>
++++///+<returns>A+shifted+sequence.+For+example+Shift({1,2,3,4,5,6},+3)+would+become+{3,4,5,6,1,2}.+</returns>
++++public+static+IEnumerable<TSource>+Shift<TSource>(this+IEnumerable<TSource>+source,+TSource+item,+IEqualityComparer<TSource>+comparer)
++++{
++++++++var+queue+=+new+Queue<TSource>();
++++++++bool+found+=+false;

++++++++foreach+(TSource+e+in+source)
++++++++{
++++++++++++if+(!found+&&+comparer.Equals(item,+e))
++++++++++++++++found+=+true;

++++++++++++if+(found)
++++++++++++++++yield+return+e;
++++++++++++else
++++++++++++++++queue.Enqueue(e);
++++++++}

++++++++while+(queue.Count+>+0)
++++++++++++yield+return+queue.Dequeue();
++++}


++++///+<summary>
++++///+Shifts+a+sequence+so+that+the+given+item+becomes+the+first.+
++++///+Uses+the+default+equality+comparer+to+find+the+item.
++++///+</summary>
++++///+<typeparam+name="TSource">Type+of+elements+in+<paramref+name="source"/>.</typeparam>
++++///+<param+name="source">Sequence+of+elements.</param>
++++///+<param+name="element">Element+which+will+become+the+first.</param>
++++///+<returns>A+shifted+sequence.+For+example+Shift({1,2,3,4,5,6},+3)+would+become+{3,4,5,6,1,2}.+</returns>
++++public+static+IEnumerable<TSource>+Shift<TSource>(this+IEnumerable<TSource>+source,+TSource+element)
++++{
++++++++return+Shift(source,+element,+EqualityComparer<TSource>.Default);
++++}|code-block|syntax|javascript|3109642|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|$]]

This one shifts a sequence so that you get the given item first. I used it for example to take the day of weeks and shift it so that the first day in the sequence is the first day of the week for the current culture.

<pre><code> /// &lt;summary&gt;
 /// Shifts a sequence so that the given &lt;paramref name="item"/&gt; becomes the first. 
 /// Uses the specified equality &lt;paramref name="comparer"/&gt; to find the item.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="TSource"&gt;Type of elements in &lt;paramref name="source"/&gt;.&lt;/typeparam&gt;
 /// &lt;param name="source"&gt;Sequence of elements.&lt;/param&gt;
 /// &lt;param name="item"&gt;Item which will become the first.&lt;/param&gt;
 /// &lt;param name="comparer"&gt;Used to find the first item.&lt;/param&gt;
 /// &lt;returns&gt;A shifted sequence. For example Shift({1,2,3,4,5,6}, 3) would become {3,4,5,6,1,2}. &lt;/returns&gt;
 public static IEnumerable&lt;TSource&gt; Shift&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, TSource item, IEqualityComparer&lt;TSource&gt; comparer)
 {
 var queue = new Queue&lt;TSource&gt;();
 bool found = false;

 foreach (TSource e in source)
 {
 if (!found &amp;&amp; comparer.Equals(item, e))
 found = true;

 if (found)
 yield return e;
 else
 queue.Enqueue(e);
 }

 while (queue.Count &gt; 0)
 yield return queue.Dequeue();
 }


 /// &lt;summary&gt;
 /// Shifts a sequence so that the given item becomes the first. 
 /// Uses the default equality comparer to find the item.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="TSource"&gt;Type of elements in &lt;paramref name="source"/&gt;.&lt;/typeparam&gt;
 /// &lt;param name="source"&gt;Sequence of elements.&lt;/param&gt;
 /// &lt;param name="element"&gt;Element which will become the first.&lt;/param&gt;
 /// &lt;returns&gt;A shifted sequence. For example Shift({1,2,3,4,5,6}, 3) would become {3,4,5,6,1,2}. &lt;/returns&gt;
 public static IEnumerable&lt;TSource&gt; Shift&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, TSource element)
 {
 return Shift(source, element, EqualityComparer&lt;TSource&gt;.Default);
 }
</code></pre>

blocks|key|338619|text|我最常使用的扩展方法必须是System.Linq.Enumerable类中的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|338620|您可以在MoreLinq中找到该列表的一个很好且有用的扩展。|338621|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.linq.enumerable_methods.aspx|1|http://code.google.com/p/morelinq/wiki/OperatorsOverview^0|D|M|D|M|0|0|4|8|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

The extension methods I use the most would have to be the ones in the <a href="http://msdn.microsoft.com/en-us/library/system.linq.enumerable_methods.aspx" rel="nofollow noreferrer"><code>System.Linq.Enumerable</code></a> class.

And a good and useful extension to that list you can find in <a href="http://code.google.com/p/morelinq/wiki/OperatorsOverview" rel="nofollow noreferrer">MoreLinq</a>.

blocks|key|3322655|text|我在这里看到的大多数扩展方法的示例都与最佳实践背道而驰。扩展方法很强大，但应该谨慎使用。根据我的经验，使用老式语法的静态帮助器/实用程序类通常更适合其中的大多数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322656|Enums的扩展方法是有道理的，因为它们不可能有方法。如果在与Enum相同的命名空间中定义它们，并且在相同的程序集中定义它们，则它们的工作方式是透明的。|3322657|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Most examples for extension methods that I see here go against best practises.
Extension methods are powerful, but should be used sparingly. In my experience, a static helper/utility class with old-school syntax would generally be preferrable for most of these.

There is something to say for extension methods for Enums, as it's not possible for them to have methods. If you define them in the same namespace as your Enum and in the same assembly, they work transparently.

blocks|key|3322685|text|我编写了一系列扩展方法，使操作ADO.NET对象和方法变得更容易：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322686|只需一条指令即可从DbConnection创建DbCommand：|3322687|++++public+static+DbCommand+CreateCommand(this+DbConnection+connection,+string+commandText)
++++{
++++++++DbCommand+command+=+connection.CreateCommand();
++++++++command.CommandText+=+commandText;
++++++++return+command;
++++}|code-block|syntax|javascript|3322688|向DbCommand添加参数：|3322689|++++public+static+DbParameter+AddParameter(this+DbCommand+command,+string+name,+DbType+dbType)
++++{
++++++++DbParameter+p+=+AddParameter(command,+name,+dbType,+0,+ParameterDirection.Input);
++++++++return+p;
++++}

++++public+static+DbParameter+AddParameter(this+DbCommand+command,+string+name,+DbType+dbType,+object+value)
++++{
++++++++DbParameter+p+=+AddParameter(command,+name,+dbType,+0,+ParameterDirection.Input);
++++++++p.Value+=+value;
++++++++return+p;
++++}

++++public+static+DbParameter+AddParameter(this+DbCommand+command,+string+name,+DbType+dbType,+int+size)
++++{
++++++++return+AddParameter(command,+name,+dbType,+size,+ParameterDirection.Input);
++++}

++++public+static+DbParameter+AddParameter(this+DbCommand+command,+string+name,+DbType+dbType,+int+size,+ParameterDirection+direction)
++++{
++++++++DbParameter+parameter+=+command.CreateParameter();
++++++++parameter.ParameterName+=+name;
++++++++parameter.DbType+=+dbType;
++++++++parameter.Direction+=+direction;
++++++++parameter.Size+=+size;
++++++++command.Parameters.Add(parameter);
++++++++return+parameter;
++++}|3322690|按名称而不是按索引访问DbDataReader字段：|3322691|++++public+static+DateTime+GetDateTime(this+DbDataReader+reader,+string+name)
++++{
++++++++int+i+=+reader.GetOrdinal(name);
++++++++return+reader.GetDateTime(i);
++++}

++++public+static+decimal+GetDecimal(this+DbDataReader+reader,+string+name)
++++{
++++++++int+i+=+reader.GetOrdinal(name);
++++++++return+reader.GetDecimal(i);
++++}

++++public+static+double+GetDouble(this+DbDataReader+reader,+string+name)
++++{
++++++++int+i+=+reader.GetOrdinal(name);
++++++++return+reader.GetDouble(i);
++++}

++++public+static+string+GetString(this+DbDataReader+reader,+string+name)
++++{
++++++++int+i+=+reader.GetOrdinal(name);
++++++++return+reader.GetString(i);
++++}

++++...|3322692|另一个(无关的)扩展方法允许我对WinForms窗体和控件see+here执行DragMove操作(就像在WPF中一样)。|offset|length|3322693|entityMap|0|LINK|mutability|MUTABLE|url|http://www.thomaslevesque.com/2009/05/06/windows-forms-automatically-drag-and-drop-controls-dragmove/^0|0|0|0|0|0|0|0|T|8|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$S|1A|T|1B|1|1C]]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

I wrote a series of extension methods to make it easier to manipulate ADO.NET objects and methods :

Create a DbCommand from a DbConnection in one instruction :

<pre><code> public static DbCommand CreateCommand(this DbConnection connection, string commandText)
 {
 DbCommand command = connection.CreateCommand();
 command.CommandText = commandText;
 return command;
 }
</code></pre>

Add a parameter to a DbCommand :

<pre><code> public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType)
 {
 DbParameter p = AddParameter(command, name, dbType, 0, ParameterDirection.Input);
 return p;
 }

 public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, object value)
 {
 DbParameter p = AddParameter(command, name, dbType, 0, ParameterDirection.Input);
 p.Value = value;
 return p;
 }

 public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, int size)
 {
 return AddParameter(command, name, dbType, size, ParameterDirection.Input);
 }

 public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, int size, ParameterDirection direction)
 {
 DbParameter parameter = command.CreateParameter();
 parameter.ParameterName = name;
 parameter.DbType = dbType;
 parameter.Direction = direction;
 parameter.Size = size;
 command.Parameters.Add(parameter);
 return parameter;
 }
</code></pre>

Access DbDataReader fields by name rather than index :

<pre><code> public static DateTime GetDateTime(this DbDataReader reader, string name)
 {
 int i = reader.GetOrdinal(name);
 return reader.GetDateTime(i);
 }

 public static decimal GetDecimal(this DbDataReader reader, string name)
 {
 int i = reader.GetOrdinal(name);
 return reader.GetDecimal(i);
 }

 public static double GetDouble(this DbDataReader reader, string name)
 {
 int i = reader.GetOrdinal(name);
 return reader.GetDouble(i);
 }

 public static string GetString(this DbDataReader reader, string name)
 {
 int i = reader.GetOrdinal(name);
 return reader.GetString(i);
 }

 ...
</code></pre>

Another (unrelated) extension method allows me to perform the DragMove operation (like in WPF) on WinForms forms and controls, <a href="http://www.thomaslevesque.com/2009/05/06/windows-forms-automatically-drag-and-drop-controls-dragmove/" rel="nofollow noreferrer">see here</a>.

blocks|key|3322725|text|我在这里提到了几个我用到的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322726|3322727|Easier+checking+on+flags+enums|unordered-list-item|offset|length|3322728|3322729|if(+enumVar.IsSet(+MyEnum.PossibleFlag+)+)+//..then|style|CODE|3322730|Inline+checking+of+nulls|3322731|3322732|myObject.IfNotNull(+x+=>+x.Property+);|3322733|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/7244|1|https://stackoverflow.com/questions/123088^0|0|0|0|U|0|0|0|0|1F|0|0|O|1|0|0|0|12|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@$F|14|G|15|1|16]]|A|$]]|$1|H|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|18|8|@$F|19|G|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|E|7|1B|8|@]|9|@$F|1C|G|1D|1|1E]]|A|$]]|$1|O|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1G|8|@$F|1H|G|1I|K|L]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]|Z|$5|U|V|W|A|$X|10]]]]

There are a couple that I've mentioned here that I use:

<ul>
<li><a href="https://stackoverflow.com/questions/7244">Easier checking on flags enums</a>

<code>if( enumVar.IsSet( MyEnum.PossibleFlag ) ) //..then</code></li>
<li><a href="https://stackoverflow.com/questions/123088">Inline checking of nulls</a>

<code>myObject.IfNotNull( x =&gt; x.Property );</code></li>
</ul>

blocks|key|3322772|text|我自动引导以下代码来解决MVC项目中类名到大写字母的url问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322773|public+static+class+RouteCollectionExt
{
++++public+static+Route+MapRouteLowercase(this+RouteCollection+routes,+string+name,+string+url,+object+defaults)
++++{
++++++++var+route+=+new+LowercaseRoute(url,+new+RouteValueDictionary(defaults),+new+MvcRouteHandler());

++++++++routes.Add(name,+route);

++++++++return+route;
++++}

++++private+class+LowercaseRoute+:+Route
++++{
++++++++public+LowercaseRoute(string+url,+IRouteHandler+routeHandler)
++++++++++++:+base(url,+routeHandler)+{+}

++++++++public+LowercaseRoute(string+url,+RouteValueDictionary+defaults,+IRouteHandler+routeHandler)
++++++++++++:+base(url,+defaults,+routeHandler)+{+}

++++++++public+LowercaseRoute(string+url,+RouteValueDictionary+defaults,+RouteValueDictionary+constraints,+IRouteHandler+routeHandler)
++++++++++++:+base(url,+defaults,+constraints,+routeHandler)+{+}

++++++++public+LowercaseRoute(string+url,+RouteValueDictionary+defaults,+RouteValueDictionary+constraints,+RouteValueDictionary+dataTokens,+IRouteHandler+routeHandler)
++++++++++++:+base(url,+defaults,+constraints,+dataTokens,+routeHandler)+{+}

++++++++public+override+VirtualPathData+GetVirtualPath(RequestContext+requestContext,+RouteValueDictionary+values)
++++++++{
++++++++++++var+path+=+base.GetVirtualPath(requestContext,+values);

++++++++++++if+(path+!=+null)
++++++++++++{
++++++++++++++++path.VirtualPath+=+path.VirtualPath.ToLowerInvariant();
++++++++++++}

++++++++++++return+path;
++++++++}
++++}++
}|code-block|syntax|javascript|3322774|用法：|3322775|routes.MapRouteLowercase(
++"Default",
++"{controller}/{action}/{id}",
++new+{+controller+=+"Home",+action+=+"Index",+id+=+""+}+
);|3322776|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|$]]

I autopilot the following to solve the class-name-to-upper-case-url problem in MVC projects:

<pre><code>public static class RouteCollectionExt
{
 public static Route MapRouteLowercase(this RouteCollection routes, string name, string url, object defaults)
 {
 var route = new LowercaseRoute(url, new RouteValueDictionary(defaults), new MvcRouteHandler());

 routes.Add(name, route);

 return route;
 }

 private class LowercaseRoute : Route
 {
 public LowercaseRoute(string url, IRouteHandler routeHandler)
 : base(url, routeHandler) { }

 public LowercaseRoute(string url, RouteValueDictionary defaults, IRouteHandler routeHandler)
 : base(url, defaults, routeHandler) { }

 public LowercaseRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, IRouteHandler routeHandler)
 : base(url, defaults, constraints, routeHandler) { }

 public LowercaseRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler)
 : base(url, defaults, constraints, dataTokens, routeHandler) { }

 public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
 {
 var path = base.GetVirtualPath(requestContext, values);

 if (path != null)
 {
 path.VirtualPath = path.VirtualPath.ToLowerInvariant();
 }

 return path;
 }
 } 
}
</code></pre>

Usage:

<pre><code>routes.MapRouteLowercase(
 "Default",
 "{controller}/{action}/{id}",
 new { controller = "Home", action = "Index", id = "" } 
);
</code></pre>

blocks|key|3322824|text|虽然很简单，但我发现这一点特别有用，因为我从一个完整的结果集中得到了一个页面，这个结果集是一个项目的100亿次：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322825|public+static+class+QueryableExtensions
{
++++public+static+IQueryable<T>+Page(this+IQueryable<T>+query,+int+pageNumber,+int+pageSize)
++++{
++++++++int+skipCount+=+(pageNumber-1)+*+pageSize;
++++++++query+=+query.Skip(skipCount);
++++++++query+=+query.Take(pageSize);

++++++++return+query;
++++}
}|code-block|syntax|javascript|3322826|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|$]]

While very simple, I find this one to be particularly useful since I get a page out of a full result set ten billion times a project:

<pre><code>public static class QueryableExtensions
{
 public static IQueryable&lt;T&gt; Page(this IQueryable&lt;T&gt; query, int pageNumber, int pageSize)
 {
 int skipCount = (pageNumber-1) * pageSize;
 query = query.Skip(skipCount);
 query = query.Take(pageSize);

 return query;
 }
}
</code></pre>

blocks|key|3109811|text|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Text;
using+System.Text.RegularExpressions;

namespace+ConsoleApplication1
{
++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++string+guid1+=+"936DA01F-9ABD-4d9d-80C7-02AF85C822A8";
++++++++++++string+guid2+=+"936DA01F-9ABD-4d9d-80C7-02AF85C822A";
++++++++++++Console.WriteLine("guid1:+{0}",+guid1.IsGuid());
++++++++++++Console.WriteLine("guid2:+{0}",+guid2.IsGuid());
++++++++++++Console.ReadLine();
++++++++}
++++}

++++public+static+class+GuidUtility
++++{
++++++++///+<summary>
++++++++///+Determines+if+string+is+legitimate+GUID
++++++++///+</summary>+++++++
++++++++public+static+Boolean+IsGuid(this+String+s)
++++++++{
++++++++++++string+pattern+=+@"%5E[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$";
++++++++++++Regex+regex+=+new+Regex(pattern);
++++++++++++return+regex.IsMatch(s);
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3109812|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>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 string guid1 = "936DA01F-9ABD-4d9d-80C7-02AF85C822A8";
 string guid2 = "936DA01F-9ABD-4d9d-80C7-02AF85C822A";
 Console.WriteLine("guid1: {0}", guid1.IsGuid());
 Console.WriteLine("guid2: {0}", guid2.IsGuid());
 Console.ReadLine();
 }
 }

 public static class GuidUtility
 {
 /// &lt;summary&gt;
 /// Determines if string is legitimate GUID
 /// &lt;/summary&gt; 
 public static Boolean IsGuid(this String s)
 {
 string pattern = @"^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$";
 Regex regex = new Regex(pattern);
 return regex.IsMatch(s);
 }
 }
}
</code></pre>

blocks|key|3322860|text|我最常使用的几个扩展。第一组是对象扩展，实际上只用于转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3322861|public+static+class+ObjectExtension
{
++++public+static+T+As<T>(this+object+value)
++++{
++++++++return+(value+!=+null+&&+value+is+T)+?+(T)value+:+default(T);
++++}

++++public+static+int+AsInt(this+string+value)
++++{
++++++++if+(value.HasValue())
++++++++{
++++++++++++int+result;

++++++++++++var+success+=+int.TryParse(value,+NumberStyles.Integer,+CultureInfo.InvariantCulture,+out+result);

++++++++++++if+(success)
++++++++++++{
++++++++++++++++return+result;
++++++++++++}
++++++++}

++++++++return+0;
++++}

++++public+static+Guid+AsGuid(this+string+value)
++++{
++++++++return+value.HasValue()+?+new+Guid(value)+:+Guid.Empty;
++++}
}|code-block|syntax|javascript|3322862|字符串扩展|3322863|public+static+class+StringExtension
{
++++public+static+bool+HasValue(this+string+value)
++++{
++++++++return+string.IsNullOrEmpty(value)+==+false;
++++}

++++public+static+string+Slug(this+string+value)
++++{
++++++++if+(value.HasValue())
++++++++{
++++++++++++var+builder+=+new+StringBuilder();
++++++++++++var+slug+=+value.Trim().ToLower();

++++++++++++foreach+(var+c+in+slug)
++++++++++++{
++++++++++++++++switch+(c)
++++++++++++++++{
++++++++++++++++++++case+'+':
++++++++++++++++++++++++builder.Append("-");
++++++++++++++++++++++++break;
++++++++++++++++++++case+'&':
++++++++++++++++++++++++builder.Append("and");
++++++++++++++++++++++++break;
++++++++++++++++++++default:

++++++++++++++++++++++++if+((c+>=+'0'+&&+c+<=+'9')+%7C%7C+(c+>=+'a'+&&+c+<=+'z')+&&+c+!=+'-')
++++++++++++++++++++++++{
++++++++++++++++++++++++++++builder.Append(c);
++++++++++++++++++++++++}

++++++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}

++++++++++++return+builder.ToString();
++++++++}

++++++++return+string.Empty;
++++}

++++public+static+string+Truncate(this+string+value,+int+limit)
++++{
++++++++return+(value.Length+>+limit)+?+string.Concat(value.Substring(0,+Math.Min(value.Length,+limit)),+"...")+:+value;
++++}
}|3322864|最后是一些枚举扩展|3322865|public+static+class+EnumExtensions
{
++++public+static+bool+Has<T>(this+Enum+source,+params+T[]+values)
++++{
++++++++var+value+=+Convert.ToInt32(source,+CultureInfo.InvariantCulture);

++++++++foreach+(var+i+in+values)
++++++++{
++++++++++++var+mask+=+Convert.ToInt32(i,+CultureInfo.InvariantCulture);

++++++++++++if+((value+&+mask)+==+0)
++++++++++++{
++++++++++++++++return+false;
++++++++++++}
++++++++}

++++++++return+true;
++++}

++++public+static+bool+Has<T>(this+Enum+source,+T+values)
++++{
++++++++var+value+=+Convert.ToInt32(source,+CultureInfo.InvariantCulture);
++++++++var+mask+=+Convert.ToInt32(values,+CultureInfo.InvariantCulture);

++++++++return+(value+&+mask)+!=+0;
++++}

++++public+static+T+Add<T>(this+Enum+source,+T+v)
++++{
++++++++var+value+=+Convert.ToInt32(source,+CultureInfo.InvariantCulture);
++++++++var+mask+=+Convert.ToInt32(v,+CultureInfo.InvariantCulture);

++++++++return+Enum.ToObject(typeof(T),+value+%7C+mask).As<T>();
++++}

++++public+static+T+Remove<T>(this+Enum+source,+T+v)
++++{
++++++++var+value+=+Convert.ToInt32(source,+CultureInfo.InvariantCulture);
++++++++var+mask+=+Convert.ToInt32(v,+CultureInfo.InvariantCulture);

++++++++return+Enum.ToObject(typeof(T),+value+&+~mask).As<T>();
++++}

++++public+static+T+AsEnum<T>(this+string+value)
++++{
++++++++try
++++++++{
++++++++++++return+Enum.Parse(typeof(T),+value,+true).As<T>();
++++++++}
++++++++catch
++++++++{
++++++++++++return+default(T);
++++++++}
++++}
}|3322866|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

few extensions I use mostly. first set is object extensions, really only for converting.

<pre><code>public static class ObjectExtension
{
 public static T As&lt;T&gt;(this object value)
 {
 return (value != null &amp;&amp; value is T) ? (T)value : default(T);
 }

 public static int AsInt(this string value)
 {
 if (value.HasValue())
 {
 int result;

 var success = int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);

 if (success)
 {
 return result;
 }
 }

 return 0;
 }

 public static Guid AsGuid(this string value)
 {
 return value.HasValue() ? new Guid(value) : Guid.Empty;
 }
}
</code></pre>

string extensions

<pre><code>public static class StringExtension
{
 public static bool HasValue(this string value)
 {
 return string.IsNullOrEmpty(value) == false;
 }

 public static string Slug(this string value)
 {
 if (value.HasValue())
 {
 var builder = new StringBuilder();
 var slug = value.Trim().ToLower();

 foreach (var c in slug)
 {
 switch (c)
 {
 case ' ':
 builder.Append("-");
 break;
 case '&amp;':
 builder.Append("and");
 break;
 default:

 if ((c &gt;= '0' &amp;&amp; c &lt;= '9') || (c &gt;= 'a' &amp;&amp; c &lt;= 'z') &amp;&amp; c != '-')
 {
 builder.Append(c);
 }

 break;
 }
 }

 return builder.ToString();
 }

 return string.Empty;
 }

 public static string Truncate(this string value, int limit)
 {
 return (value.Length &gt; limit) ? string.Concat(value.Substring(0, Math.Min(value.Length, limit)), "...") : value;
 }
}
</code></pre>

and last is some enum extensions

<pre><code>public static class EnumExtensions
{
 public static bool Has&lt;T&gt;(this Enum source, params T[] values)
 {
 var value = Convert.ToInt32(source, CultureInfo.InvariantCulture);

 foreach (var i in values)
 {
 var mask = Convert.ToInt32(i, CultureInfo.InvariantCulture);

 if ((value &amp; mask) == 0)
 {
 return false;
 }
 }

 return true;
 }

 public static bool Has&lt;T&gt;(this Enum source, T values)
 {
 var value = Convert.ToInt32(source, CultureInfo.InvariantCulture);
 var mask = Convert.ToInt32(values, CultureInfo.InvariantCulture);

 return (value &amp; mask) != 0;
 }

 public static T Add&lt;T&gt;(this Enum source, T v)
 {
 var value = Convert.ToInt32(source, CultureInfo.InvariantCulture);
 var mask = Convert.ToInt32(v, CultureInfo.InvariantCulture);

 return Enum.ToObject(typeof(T), value | mask).As&lt;T&gt;();
 }

 public static T Remove&lt;T&gt;(this Enum source, T v)
 {
 var value = Convert.ToInt32(source, CultureInfo.InvariantCulture);
 var mask = Convert.ToInt32(v, CultureInfo.InvariantCulture);

 return Enum.ToObject(typeof(T), value &amp; ~mask).As&lt;T&gt;();
 }

 public static T AsEnum&lt;T&gt;(this string value)
 {
 try
 {
 return Enum.Parse(typeof(T), value, true).As&lt;T&gt;();
 }
 catch
 {
 return default(T);
 }
 }
}
</code></pre>

blocks|key|3109861|text|要允许使用更多功能更强大的组合器代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3109862|++++public+static+Func<T,+R>+TryCoalesce<T,+R>(this+Func<T,+R>+f,+R+coalesce)
++++{
++++++++return+x+=>
++++++++++++{
++++++++++++++++try
++++++++++++++++{
++++++++++++++++++++return+f(x);
++++++++++++++++}
++++++++++++++++catch
++++++++++++++++{
++++++++++++++++++++return+coalesce;
++++++++++++++++}
++++++++++++};
++++}
++++public+static+TResult+TryCoalesce<T,+TResult>(this+Func<T,+TResult>+f,+T+p,+TResult+coalesce)
++++{
++++++++return+f.TryCoalesce(coalesce)(p);
++++}|code-block|syntax|javascript|3109863|然后我可以写下这样的代码：|3109864|++++public+static+int+ParseInt(this+string+str,+int+coalesce)
++++{
++++++++return+TryCoalesce(int.Parse,+str,+coalesce);
++++}|3109865|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|$]]

To allow more functional combinator code:

<pre><code> public static Func&lt;T, R&gt; TryCoalesce&lt;T, R&gt;(this Func&lt;T, R&gt; f, R coalesce)
 {
 return x =&gt;
 {
 try
 {
 return f(x);
 }
 catch
 {
 return coalesce;
 }
 };
 }
 public static TResult TryCoalesce&lt;T, TResult&gt;(this Func&lt;T, TResult&gt; f, T p, TResult coalesce)
 {
 return f.TryCoalesce(coalesce)(p);
 }
</code></pre>

Then I could write something like this:

<pre><code> public static int ParseInt(this string str, int coalesce)
 {
 return TryCoalesce(int.Parse, str, coalesce);
 }
</code></pre>

blocks|key|3109894|text|我经常使用的另一个集合是用于合并IDictionary方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3109895|++++public+static+TValue+Get<TKey,+TValue>(this+IDictionary<TKey,+TValue>+d,+TKey+key,+Func<TValue>+valueThunk)
++++{
++++++++TValue+v+=+d.Get(key);
++++++++if+(v+==+null)
++++++++{
++++++++++++v+=+valueThunk();
++++++++++++d.Add(key,+v);
++++++++}
++++++++return+v;
++++}
++++public+static+TValue+Get<TKey,+TValue>(this+IDictionary<TKey,+TValue>+d,+TKey+key,+TValue+coalesce)
++++{
++++++++return+Get(d,+key,+()+=>+coalesce);
++++}|code-block|syntax|javascript|3109896|并且一般用于处理集合：|3109897|++++public+static+IEnumerable<T>+AsCollection<T>(this+T+item)
++++{
++++++++yield+return+item;
++++}|3109898|然后对于树状结构：|3109899|++++public+static+LinkedList<T>+Up<T>(this+T+node,+Func<T,+T>+parent)
++++{
++++++++var+list+=+new+LinkedList<T>();
++++++++node.Up(parent,+n+=>+list.AddFirst(n));
++++++++return+list;
++++}|3109900|因此，我可以很容易地遍历和操作一个up类，如下所示：|3109901|class+Category
{
++++public+string+Name+{+get;+set;+}
++++public+Category+Parent+{+get;+set;+}
}|3109902|接下来，为了方便函数组合和C#中更像F#的编程方式：|3109903|public+static+Func<T,+T>+Func<T>(this+Func<T,+T>+f)
{
++++return+f;
}
public+static+Func<T1,+R>+Compose<T1,+T2,+R>(this+Func<T1,+T2>+f,+Func<T2,+R>+g)
{
++++return+x+=>+g(f(x));
}|3109904|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Another set I use quite often is for coalescing IDictionary methods:

<pre><code> public static TValue Get&lt;TKey, TValue&gt;(this IDictionary&lt;TKey, TValue&gt; d, TKey key, Func&lt;TValue&gt; valueThunk)
 {
 TValue v = d.Get(key);
 if (v == null)
 {
 v = valueThunk();
 d.Add(key, v);
 }
 return v;
 }
 public static TValue Get&lt;TKey, TValue&gt;(this IDictionary&lt;TKey, TValue&gt; d, TKey key, TValue coalesce)
 {
 return Get(d, key, () =&gt; coalesce);
 }
</code></pre>

And for working with collections in general:

<pre><code> public static IEnumerable&lt;T&gt; AsCollection&lt;T&gt;(this T item)
 {
 yield return item;
 }
</code></pre>

Then for tree-like structures:

<pre><code> public static LinkedList&lt;T&gt; Up&lt;T&gt;(this T node, Func&lt;T, T&gt; parent)
 {
 var list = new LinkedList&lt;T&gt;();
 node.Up(parent, n =&gt; list.AddFirst(n));
 return list;
 }
</code></pre>

So I can then easily traverse and operate upon a up a class like:

<pre><code>class Category
{
 public string Name { get; set; }
 public Category Parent { get; set; }
}
</code></pre>

Next, to facilitate function composition and a more F# like way of programming in C#:

<pre><code>public static Func&lt;T, T&gt; Func&lt;T&gt;(this Func&lt;T, T&gt; f)
{
 return f;
}
public static Func&lt;T1, R&gt; Compose&lt;T1, T2, R&gt;(this Func&lt;T1, T2&gt; f, Func&lt;T2, R&gt; g)
{
 return x =&gt; g(f(x));
}
</code></pre>

blocks|key|338752|text|如果经常使用StringBuilder，您可能会发现需要结合使用AppendFormat()和AppendLine()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338753|public+static+void+AppendFormatLine(this+StringBuilder+sb,+string+format,+params+object[]+args)
{
++++sb.AppendFormat(format,+args);
++++sb.AppendLine();
}|code-block|syntax|javascript|338754|此外，由于我要将应用程序从VB6转换为C#，因此以下内容对我非常有用：|338755|public+static+string+Left(this+string+s,+int+length)
{
++++if+(s.Length+>=+length)
++++++++return+s.Substring(0,+length);
++++throw+new+ArgumentException("Length+must+be+less+than+the+length+of+the+string.");
}
public+static+string+Right(this+string+s,+int+length)
{
++++if+(s.Length+>=+length)
++++++++return+s.Substring(s.Length+-+length,+length);
++++throw+new+ArgumentException("Length+must+be+less+than+the+length+of+the+string.");
}|338756|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|$]]

With regular use of StringBuilder, you may see the need to combine AppendFormat() and AppendLine().

<pre><code>public static void AppendFormatLine(this StringBuilder sb, string format, params object[] args)
{
 sb.AppendFormat(format, args);
 sb.AppendLine();
}
</code></pre>

Also, since I'm converting an application from VB6 to C#, the following are very useful to me:

<pre><code>public static string Left(this string s, int length)
{
 if (s.Length &gt;= length)
 return s.Substring(0, length);
 throw new ArgumentException("Length must be less than the length of the string.");
}
public static string Right(this string s, int length)
{
 if (s.Length &gt;= length)
 return s.Substring(s.Length - length, length);
 throw new ArgumentException("Length must be less than the length of the string.");
}
</code></pre>

blocks|key|338767|text|这是一种扩展方法，用于在引发事件之前集中null检查。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338768|public+static+class+EventExtension
{
++++public+static+void+RaiseEvent<T>(this+EventHandler<T>+handler,+object+obj,+T+args)+where+T+:+EventArgs
++++{
++++++++EventHandler<T>+theHandler+=+handler;

++++++++if+(theHandler+!=+null)
++++++++{
++++++++++++theHandler(obj,+args);
++++++++}
++++}
}|code-block|syntax|javascript|338769|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|$]]

This is an extension method to centralize null checks before raising events.

<pre><code>public static class EventExtension
{
 public static void RaiseEvent&lt;T&gt;(this EventHandler&lt;T&gt; handler, object obj, T args) where T : EventArgs
 {
 EventHandler&lt;T&gt; theHandler = handler;

 if (theHandler != null)
 {
 theHandler(obj, args);
 }
 }
}
</code></pre>

blocks|key|338773|text|很多时候，我需要根据Enum值显示一个用户友好的值，但我不想走自定义属性路线，因为它看起来不太优雅。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338774|使用这个方便的扩展方法：|338775|public+static+string+EnumValue(this+MyEnum+e)+{
++++switch+(e)+{
++++++++case+MyEnum.First:
++++++++++++return+"First+Friendly+Value";
++++++++case+MyEnum.Second:
++++++++++++return+"Second+Friendly+Value";
++++++++case+MyEnum.Third:
++++++++++++return+"Third+Friendly+Value";
++++}
++++return+"Horrible+Failure!!";
}|code-block|syntax|javascript|338776|我可以这样做：|338777|Console.WriteLine(MyEnum.First.EnumValue());|338778|耶！|338779|entityMap^0|0|0|0|0|0|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|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Often times, I've needed to display a user-friendly value based on an Enum value, but didn't want to go the custom Attribute route, as it didn't seem too elegant. 

With this handy extension method:

<pre><code>public static string EnumValue(this MyEnum e) {
 switch (e) {
 case MyEnum.First:
 return "First Friendly Value";
 case MyEnum.Second:
 return "Second Friendly Value";
 case MyEnum.Third:
 return "Third Friendly Value";
 }
 return "Horrible Failure!!";
}
</code></pre>

I can do this:

<pre><code>Console.WriteLine(MyEnum.First.EnumValue());
</code></pre>

Yay!

blocks|key|338794|text|这个非常简单，但这是一个我经常做的检查，所以我最终为它做了一个扩展方法。我最喜欢的扩展方法往往是像这样非常简单、直接的方法，或者像Taylor+L的用于引发事件的扩展方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338795|public+static+bool+IsNullOrEmpty(this+ICollection+e)
{
++++return+e+==+null+%7C%7C+e.Count+==+0;
}|code-block|syntax|javascript|338796|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|$]]

This one is incredibly simple, but it's a check I do a lot so I ended up making an extension method for it. My favorite extension methods tend to be the really simple, straightforward ones like this, or like Taylor L's extension method for raising events.

<pre><code>public static bool IsNullOrEmpty(this ICollection e)
{
 return e == null || e.Count == 0;
}
</code></pre>

blocks|key|3110063|text|我正在将大量的Java转换成C#。许多方法仅在大小写或其他小的语法差异方面有所不同。所以Java代码，比如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3110064|myString.toLowerCase();|code-block|syntax|javascript|3110065|将不会进行编译，而是通过添加扩展方法|3110066|public+static+void+toLowerCase(this+string+s)
{
++++s.ToLower();
}|3110067|我可以捕获所有的方法(我假设一个好的编译器会内联这些方法？)。|3110068|这无疑使这项工作变得更加容易和可靠。(我感谢@Yuriy+-请参阅答案：differences+between+StringBuilder+in+Java+and+C#)的建议。|offset|length|3110069|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1548296/differences-between-stringbuilder-in-java-and-c^0|0|0|0|0|0|10|1C|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

I am converting a lot of Java to C#. Many of the methods vary only in capitalization or other small syntax differences. So Java code such as

<pre><code>myString.toLowerCase();
</code></pre>

will not compile but by adding an extension method

<pre><code>public static void toLowerCase(this string s)
{
 s.ToLower();
}
</code></pre>

I can catch all the methods (and I assume a good compiler will inline this anyway?).

It's certainly made the job much easier and more reliable.
(I thank @Yuriy - see answer in: <a href="https://stackoverflow.com/questions/1548296/differences-between-stringbuilder-in-java-and-c">differences between StringBuilder in Java and C#</a>) for the suggestion.

blocks|key|338834|text|是否曾经使用过实体框架&一遍又一遍地使用类似于此的一行代码？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|338835|_context.EmployeeSet.Include("Department")
++++.Include("Manager").Include(+...+).Select();|code-block|syntax|javascript|338836|这样做不是更容易吗：|338837|_context.EmployeeSet.IncludeCommonReferenceses().Select();|338838|`|338839|internal+static+class+ObjectContextExtensions
{
++++internal+static+ObjectQuery<Employee>+IncludeCommonReferenceses(this+ObjectQuery<Employee>+employeeSet)
++++{
++++++++return+employeeSet.Include(GetPropertyName<Employee>(e+=>+e.Department))
+++++++++++.Include(GetPropertyName<Employee>(e+=>+e.Manager)).Include(+...+);
++++}

++++private+static+string+GetPropertyName<T>(Expression<Func<T,+object>>+subSelector)
++++{
++++++++return+((MemberExpression)subSelector.Body).Member.Name;
++++}
}|338840|我建议你将属性名保存在consts中，以避免使用反射。|338841|entityMap^0|7|4|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|14|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|V|$]]

Ever worked with Entity Framework &amp; used a line of code similar to this over and over?

<pre><code>_context.EmployeeSet.Include("Department")
 .Include("Manager").Include( ... ).Select();
</code></pre>

Isn't it easier to do this:

<pre><code>_context.EmployeeSet.IncludeCommonReferenceses().Select();
</code></pre>

`

<pre><code>internal static class ObjectContextExtensions
{
 internal static ObjectQuery&lt;Employee&gt; IncludeCommonReferenceses(this ObjectQuery&lt;Employee&gt; employeeSet)
 {
 return employeeSet.Include(GetPropertyName&lt;Employee&gt;(e =&gt; e.Department))
 .Include(GetPropertyName&lt;Employee&gt;(e =&gt; e.Manager)).Include( ... );
 }

 private static string GetPropertyName&lt;T&gt;(Expression&lt;Func&lt;T, object&gt;&gt; subSelector)
 {
 return ((MemberExpression)subSelector.Body).Member.Name;
 }
}
</code></pre>

I Recommend you save the property names in consts to avoid using reflection over &amp; over agasin.

blocks|key|3323213|text|在我个人的string+utils集合中，我最喜欢的一种方法是从字符串中解析具有TryParse方法的任何类型的强类型值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3323214|public+static+class+StringUtils
{
++++///+<summary>
++++///+This+method+will+parse+a+value+from+a+string.
++++///+If+the+string+is+null+or+not+the+right+format+to+parse+a+valid+value,
++++///+it+will+return+the+default+value+provided.
++++///+</summary>
++++public+static+T+To<t>(this+string+value,+T+defaultValue)
++++++++where+T:+struct
++++{
++++++++var+type+=+typeof(T);
++++++++if+(value+!=+null)
++++++++{
++++++++++++var+parse+=+type.GetMethod("TryParse",+new+Type[]+{+typeof(string),+type.MakeByRefType()+});
++++++++++++var+parameters+=+new+object[]+{+value,+default(T)+};
++++++++++++if((bool)parse.Invoke(null,+parameters))
++++++++++++++++return+(T)parameters[1];
++++++++}
++++++++return+defaultValue;
++++}

++++///+<summary>
++++///+This+method+will+parse+a+value+from+a+string.
++++///+If+the+string+is+null+or+not+the+right+format+to+parse+a+valid+value,
++++///+it+will+return+the+default+value+for+the+type.
++++///+</summary>
++++public+static+T+To<t>(this+string+value)
++++++++where+T+:+struct
++++{
++++++++return+value.To<t>(default(T));
++++}
}|code-block|syntax|javascript|3323215|它非常适合从查询字符串中获取强类型信息：|3323216|var+value+=+Request.QueryString["value"].To<int>();|3323217|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|$]]

My favourite from my own personal collection of string utils is one that will parse a strongly typed value from a string for any type that has a TryParse method:

<pre><code>public static class StringUtils
{
 /// &lt;summary&gt;
 /// This method will parse a value from a string.
 /// If the string is null or not the right format to parse a valid value,
 /// it will return the default value provided.
 /// &lt;/summary&gt;
 public static T To&lt;t&gt;(this string value, T defaultValue)
 where T: struct
 {
 var type = typeof(T);
 if (value != null)
 {
 var parse = type.GetMethod("TryParse", new Type[] { typeof(string), type.MakeByRefType() });
 var parameters = new object[] { value, default(T) };
 if((bool)parse.Invoke(null, parameters))
 return (T)parameters[1];
 }
 return defaultValue;
 }

 /// &lt;summary&gt;
 /// This method will parse a value from a string.
 /// If the string is null or not the right format to parse a valid value,
 /// it will return the default value for the type.
 /// &lt;/summary&gt;
 public static T To&lt;t&gt;(this string value)
 where T : struct
 {
 return value.To&lt;t&gt;(default(T));
 }
}
</code></pre>

It's great for getting strongly typed information from query strings:

<pre><code>var value = Request.QueryString["value"].To&lt;int&gt;();
</code></pre>

blocks|key|3110266|text|我讨厌在任何地方都要这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3110267|DataSet+ds+=+dataLayer.GetSomeData(1,+2,+3);
if(ds+!=+null){
++++if(ds.Tables.Count+>+0){
++++++++DataTable+dt+=+ds.Tables[0];
++++++++foreach(DataRow+dr+in+dt.Rows){
++++++++++++//Do+some+processing
++++++++}
++++}
}|code-block|syntax|javascript|3110268|相反，我通常使用以下扩展方法：|3110269|public+static+IEnumerable<DataRow>+DataRows(this+DataSet+current){
++++if(current+!=+null){
++++++++if(current.Tables.Count+>+0){
++++++++++++DataTable+dt+=+current.Tables[0];
++++++++++++foreach(DataRow+dr+in+dt.Rows){
++++++++++++++++yield+return+dr;
++++++++++++}
++++++++}
++++}
}|3110270|因此，第一个示例变成：|3110271|foreach(DataRow+row+in+ds.DataRows()){
++++//Do+some+processing
}|3110272|耶，扩展方法！|3110273|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I hate having to do this everywhere:

<pre><code>DataSet ds = dataLayer.GetSomeData(1, 2, 3);
if(ds != null){
 if(ds.Tables.Count &gt; 0){
 DataTable dt = ds.Tables[0];
 foreach(DataRow dr in dt.Rows){
 //Do some processing
 }
 }
}
</code></pre>

Instead I usually use the following Extension Method:

<pre><code>public static IEnumerable&lt;DataRow&gt; DataRows(this DataSet current){
 if(current != null){
 if(current.Tables.Count &gt; 0){
 DataTable dt = current.Tables[0];
 foreach(DataRow dr in dt.Rows){
 yield return dr;
 }
 }
 }
}
</code></pre>

So the first example then becomes:

<pre><code>foreach(DataRow row in ds.DataRows()){
 //Do some processing
}
</code></pre>

Yay, Extension Methods!

blocks|key|340219|text|我不喜欢INotifyPropertyChanged接口，该接口要求将属性名作为字符串传递。我想要一种强类型的方式来在编译时检查我是否只引发和处理已存在的属性的属性更改。我使用下面的代码来做这件事：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|340220|public+static+class+INotifyPropertyChangedExtensions
{
++++public+static+string+ToPropertyName<T>(this+Expression<Func<T>>+@this)
++++{
++++++++var+@return+=+string.Empty;
++++++++if+(@this+!=+null)
++++++++{
++++++++++++var+memberExpression+=+@this.Body+as+MemberExpression;
++++++++++++if+(memberExpression+!=+null)
++++++++++++{
++++++++++++++++@return+=+memberExpression.Member.Name;
++++++++++++}
++++++++}
++++++++return+@return;
++++}
}|code-block|syntax|javascript|340221|在实现INotifyPropertyChanged的类中，我包含了这个助手方法：|340222|protected+void+NotifySetProperty<T>(ref+T+field,+T+value,
++++Expression<Func<T>>+propertyExpression)
{
++++if+(field+==+null+?+value+!=+null+:+!field.Equals(value))
++++{
++++++++field+=+value;
++++++++this.NotifyPropertyChanged(propertyExpression.ToPropertyName());
++++}
}|340223|所以最终我可以做这样的事情：|340224|private+string+_name;
public+string+Name
{
++++get+{+return+_name;+}
++++set+{+this.NotifySetProperty(ref+_name,+value,+()+=>+this.Name);+}
}|340225|它是强类型的，我只为实际更改其值的属性引发事件。|340226|entityMap^0|4|M|0|0|3|M|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

I'm not a fan of the <code>INotifyPropertyChanged</code> interface requiring that property names are passed as strings. I want a strongly-typed way to check at compile time that I'm only raising and handling property changes for properties that exist. I use this code to do that:

<pre><code>public static class INotifyPropertyChangedExtensions
{
 public static string ToPropertyName&lt;T&gt;(this Expression&lt;Func&lt;T&gt;&gt; @this)
 {
 var @return = string.Empty;
 if (@this != null)
 {
 var memberExpression = @this.Body as MemberExpression;
 if (memberExpression != null)
 {
 @return = memberExpression.Member.Name;
 }
 }
 return @return;
 }
}
</code></pre>

In classes that implement <code>INotifyPropertyChanged</code> I include this helper method:

<pre><code>protected void NotifySetProperty&lt;T&gt;(ref T field, T value,
 Expression&lt;Func&lt;T&gt;&gt; propertyExpression)
{
 if (field == null ? value != null : !field.Equals(value))
 {
 field = value;
 this.NotifyPropertyChanged(propertyExpression.ToPropertyName());
 }
}
</code></pre>

So that finally I can do this kind of thing:

<pre><code>private string _name;
public string Name
{
 get { return _name; }
 set { this.NotifySetProperty(ref _name, value, () =&gt; this.Name); }
}
</code></pre>

It's strongly-typed and I only raise events for properties that actually change their value.

blocks|key|341381|text|将给定fileinfo类的任何给定属性与另一个属性进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341382|++++public+static+bool+compare(this+FileInfo+F1,FileInfo+F2,string+propertyName)
++++{
++++++++try
++++++++{
++++++++++++System.Reflection.PropertyInfo+p1+=+F1.GetType().GetProperty(propertyName);
++++++++++++System.Reflection.PropertyInfo+p2+=+F2.GetType().GetProperty(propertyName);

++++++++++++++++if+(p1.GetValue(F1,+null)+==+p2.GetValue(F1,+null))
++++++++++++++++{
++++++++++++++++++++return+true;
++++++++++++++++}

++++++++}
++++++++catch+(Exception+ex)
++++++++{
++++++++++++return+false;
++++++++}

++++++++return+false;
++++}|code-block|syntax|javascript|341383|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|$]]

Compare any given property of the given fileinfo class against another one..

<pre><code> public static bool compare(this FileInfo F1,FileInfo F2,string propertyName)
 {
 try
 {
 System.Reflection.PropertyInfo p1 = F1.GetType().GetProperty(propertyName);
 System.Reflection.PropertyInfo p2 = F2.GetType().GetProperty(propertyName);

 if (p1.GetValue(F1, null) == p2.GetValue(F1, null))
 {
 return true;
 }

 }
 catch (Exception ex)
 {
 return false;
 }

 return false;
 }
</code></pre>

blocks|key|343739|text|这是我经常用来从一个流复制到另一个流的东西，特别是在将内容复制到MemoryStream中时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|343740|public+static+void+CopyStream(this+Stream+destination,+Stream+source)
++++{
++++++++if+(source.CanSeek)
++++++++{
++++++++++++source.Position+=+0;
++++++++}
++++++++int+Length+=+64000;
++++++++Byte[]+buffer+=+new+Byte[Length];
++++++++int+bytesRead+=+source.Read(buffer,+0,+Length);
++++++++//+write+the+required+bytes
++++++++while+(bytesRead+>+0)
++++++++{
++++++++++++destination.Write(buffer,+0,+bytesRead);
++++++++++++bytesRead+=+source.Read(buffer,+0,+Length);
++++++++}
++++}|code-block|syntax|javascript|343741|实施：|343742|MemoryStream+result+=+new+MemoryStream();
Stream+s+=+new+FileStream(tempDocFile,+FileMode.Open);

result.CopyStream(s);

s.Close();|343743|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|$]]

This is something which I often use to copy from a stream into another stream, especially for copying stuff into a MemoryStream.

<pre><code>public static void CopyStream(this Stream destination, Stream source)
 {
 if (source.CanSeek)
 {
 source.Position = 0;
 }
 int Length = 64000;
 Byte[] buffer = new Byte[Length];
 int bytesRead = source.Read(buffer, 0, Length);
 // write the required bytes
 while (bytesRead &gt; 0)
 {
 destination.Write(buffer, 0, bytesRead);
 bytesRead = source.Read(buffer, 0, Length);
 }
 }
</code></pre>

Implementation:

<pre><code>MemoryStream result = new MemoryStream();
Stream s = new FileStream(tempDocFile, FileMode.Open);

result.CopyStream(s);

s.Close();
</code></pre>

blocks|key|340268|text|在多线程WPF应用程序中(例如，当您使用套接字或计时器时)，我经常必须调用GUI线程来更改WPF元素属性。这是丑陋的、臃肿的代码，尤其是你需要为每个方法都这么做。这就是我做这个扩展方法的原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340269|++++///+<summary>
++++///+Invoke+the+element's+thread+using+a+dispatcher.+This+is+needed+for+changing+WPF+element+attributes.
++++///+</summary>
++++///+<param+name="dispatcherObject">The+element+of+which+to+use+the+thread.</param>
++++///+<param+name="action">The+action+to+do+with+the+invoked+thread.</param>
++++///+<param+name="dispatcherPriority">The+priority+of+this+action.</param>
++++public+static+void+DoInvoked(this+System.Windows.Threading.DispatcherObject+dispatcherObject,+Action+action,+System.Windows.Threading.DispatcherPriority+dispatcherPriority+=+System.Windows.Threading.DispatcherPriority.Render)
++++{
++++++++if+(System.Threading.Thread.CurrentThread+==+dispatcherObject.Dispatcher.Thread)
++++++++{
++++++++++++action();
++++++++}
++++++++else
++++++++{
++++++++++++dispatcherObject.Dispatcher.BeginInvoke(action,+dispatcherPriority,+null);
++++++++}
++++}|code-block|syntax|javascript|340270|实施：|340271|public+partial+class+MainWindow+:+Window
{
++++...+other+code+...
++++void+updateTime(object+sender,+ElapsedEventArgs+e)
++++{
++++++++this.DoInvoked(()+=>+textBoxStatus.Text+=+"Done.");
++++}
}|340272|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|$]]

In multi-threaded WPF applications (for example when you're using sockets or timers) I often have to invoke the GUI thread to change WPF Element attributes. This is ugly bloated code, especially since you need to do it for every method. That's why I made this extension method:

<pre><code> /// &lt;summary&gt;
 /// Invoke the element's thread using a dispatcher. This is needed for changing WPF element attributes.
 /// &lt;/summary&gt;
 /// &lt;param name="dispatcherObject"&gt;The element of which to use the thread.&lt;/param&gt;
 /// &lt;param name="action"&gt;The action to do with the invoked thread.&lt;/param&gt;
 /// &lt;param name="dispatcherPriority"&gt;The priority of this action.&lt;/param&gt;
 public static void DoInvoked(this System.Windows.Threading.DispatcherObject dispatcherObject, Action action, System.Windows.Threading.DispatcherPriority dispatcherPriority = System.Windows.Threading.DispatcherPriority.Render)
 {
 if (System.Threading.Thread.CurrentThread == dispatcherObject.Dispatcher.Thread)
 {
 action();
 }
 else
 {
 dispatcherObject.Dispatcher.BeginInvoke(action, dispatcherPriority, null);
 }
 }
</code></pre>

Implementation:

<pre><code>public partial class MainWindow : Window
{
 ... other code ...
 void updateTime(object sender, ElapsedEventArgs e)
 {
 this.DoInvoked(() =&gt; textBoxStatus.Text = "Done.");
 }
}
</code></pre>

blocks|key|340297|text|我可能最常将它们用于受约束的类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340298|类似于：|340299|public+class+Gallons
{
++++private+int+m_gallons;

++++public+Gallons(int+count)
++++{
++++++++if(count+<+0)
++++++++++++throw+new+ArgumentException("Cannot+have+negative+gallons");
++++++++m_gallons+=+count;
++++}

++++static+public+Gallons+operator+%2B+(Gallons+left,+Gallons+right)
++++{
++++++++return+new+Gallons(left.m_gallons+%2B+right.m_gallons);
++++}
++++public+override+string+ToString()
++++{
++++++++return+m_gallons.ToString();
++++}
}
public+class+Feet
{
++++private+int+m_feet;

++++public+Feet(int+count)
++++{
++++++++if(count+<+0)
++++++++++++throw+new+ArgumentException("Cannot+have+negative+feet");
++++++++m_feet+=+count;
++++}

++++static+public+Feet+operator+%2B(Feet+left,+Feet+right)
++++{
++++++++return+new+Feet(left.m_feet+%2B+right.m_feet);
++++}
++++public+override+string+ToString()
++++{
++++++++return+m_feet.ToString();
++++}
}

public+static+class+Conversions
{
++++static+public+Feet+Feet(this+int+i)
++++{
++++++++return+new+Feet(i);
++++}
++++static+public+Gallons+Gallons(this+int+i)
++++{
++++++++return+new+Gallons(i);
++++}
}

public+class+Test
{
++++static+public+int+Main(string[]+args)
++++{
++++++++System.Console.WriteLine(2.Feet()+%2B+3.Feet());+//+5
++++++++System.Console.WriteLine(3.Gallons()+%2B+4.Gallons());+//+7
++++++++System.Console.WriteLine(2.Feet()+%2B+3.Gallons());+//+doesn't+compile+-+can't+add+feet+to+gallons!
++++++++return+0;
++++}
}|code-block|syntax|javascript|340300|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|$]]

I'd probably use them most for constrained types.

Something like:

<pre><code>public class Gallons
{
 private int m_gallons;

 public Gallons(int count)
 {
 if(count &lt; 0)
 throw new ArgumentException("Cannot have negative gallons");
 m_gallons = count;
 }

 static public Gallons operator + (Gallons left, Gallons right)
 {
 return new Gallons(left.m_gallons + right.m_gallons);
 }
 public override string ToString()
 {
 return m_gallons.ToString();
 }
}
public class Feet
{
 private int m_feet;

 public Feet(int count)
 {
 if(count &lt; 0)
 throw new ArgumentException("Cannot have negative feet");
 m_feet = count;
 }

 static public Feet operator +(Feet left, Feet right)
 {
 return new Feet(left.m_feet + right.m_feet);
 }
 public override string ToString()
 {
 return m_feet.ToString();
 }
}

public static class Conversions
{
 static public Feet Feet(this int i)
 {
 return new Feet(i);
 }
 static public Gallons Gallons(this int i)
 {
 return new Gallons(i);
 }
}

public class Test
{
 static public int Main(string[] args)
 {
 System.Console.WriteLine(2.Feet() + 3.Feet()); // 5
 System.Console.WriteLine(3.Gallons() + 4.Gallons()); // 7
 System.Console.WriteLine(2.Feet() + 3.Gallons()); // doesn't compile - can't add feet to gallons!
 return 0;
 }
}
</code></pre>

blocks|key|3110482|text|其中一些已经发布了，但我只想说，我看到了许多这样的帖子，投票从来没有与什么是有用的现实相匹配。IMO，这是真正最有用的扩展方法列表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3110483|someCollection.ForEach(i+=>+i.DoSomething());|code-block|syntax|javascript|3110484|这是非常非常有用的，因为它取代了内置的foreach语句，我们都知道它被使用的频率。|3110485|7.CreateSequence();|3110486|这只会创建一个从0到6的序列。还可以有其他版本，例如指定起点和步长。这是第二个最有用的函数，因为它取代了for循环。有些人说这复制了Enumerable.Range函数，这是真的，但是我喜欢linq的一件事是从左到右的排序，所以你可以这样做。|3110487|myCollection.Where(i+=>+i.Something+==+somethingElse).Count().CreateSequence().+do+something+else|3110488|下一个最有用的是CastTo和As。同样，它们复制了内置的功能，但它们保留了从左到右的顺序。请注意，CastTo在单个对象上工作，因此CastTo与强制转换不同。|3110489|myObject.CastTo<Person>().DoSomething()
myObject.As<Person>()|3110490|然后是SplitAsEnumerable。这与split的工作原理相同，但不会一次将所有内容加载到内存中。这对于解析大文件非常有用。它在字符串或流上工作。|3110491|myFileStream.SplitAsEnumerable("\r\n").Select(line+=>+line.SplitAsEnumerable(","))|3110492|最后一个是将集合转换为字符串的方法。这对于在屏幕上显示内容或写入文件非常有用。例如：|3110493|myTextBox.Text+=+"Top+3+scorers+are+"+%2B+myCollection.OrderBy(i+=>+i.Score).Take(3).FlattenToString(i+=>+i.Score.ToString(),+",+");|3110494|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Some of these have already been posted but I just wanted to say that I have seen a number of these threads and the votes never match the reality of what is useful. IMO, this is the list of the truly most useful extension methods

<pre><code>someCollection.ForEach(i =&gt; i.DoSomething());
</code></pre>

This is very very useful because it replaces the built in foreach statement and we all know how often that gets used.

<pre><code>7.CreateSequence();
</code></pre>

This just creates a sequence from 0 to 6. There can be other versions such as specifying a starting point and step. This is the second most useful function because it replaces the for loop. Some people have said that this duplicates the Enumerable.Range function, which is true, but one of the things I like with linq is the left to right ordering, so you can do something like this

<pre><code>myCollection.Where(i =&gt; i.Something == somethingElse).Count().CreateSequence(). do something else
</code></pre>

The next most useful is the CastTo and As. Again they duplicate built in functionality but they preserve the left to right ordering. Note that CastTo is different to Cast in that CastTo works on a single object.

<pre><code>myObject.CastTo&lt;Person&gt;().DoSomething()
myObject.As&lt;Person&gt;()
</code></pre>

Then there is the SplitAsEnumerable. This works the same as split but doesn't load everything into memory at once. This is great for parsing large files. It works on a string or a stream.

<pre><code>myFileStream.SplitAsEnumerable("\r\n").Select(line =&gt; line.SplitAsEnumerable(","))
</code></pre>

The last one is a way to turn a collection into a string. This is great for displaying stuff on the screen or writing to files. eg:

<pre><code>myTextBox.Text = "Top 3 scorers are " + myCollection.OrderBy(i =&gt; i.Score).Take(3).FlattenToString(i =&gt; i.Score.ToString(), ", ");
</code></pre>

blocks|key|341467|text|虽然我没有写这两个--我希望我写了。在http://lostechies.com/jimmybogard/2009/10/16/more-missing-linq-operators/上找到|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|341468|追加|style|BOLD|341469|public+static+IEnumerable<TSource>+Append<TSource>(this+IEnumerable<TSource>+source,+TSource+element)
{
++++using+(IEnumerator<TSource>+e1+=+source.GetEnumerator())
++++++++while+(e1.MoveNext())
++++++++++++yield+return+e1.Current;

++++yield+return+element;
}|code-block|syntax|javascript|341470|预挂起|341471|public+static+IEnumerable<TSource>+Prepend<TSource>(this+IEnumerable<TSource>+source,+TSource+element)
{
++++yield+return+element;

++++using+(IEnumerator<TSource>+e1+=+source.GetEnumerator())
++++++++while+(e1.MoveNext())
++++++++++++yield+return+e1.Current;
}|341472|entityMap|0|LINK|mutability|MUTABLE|url|http://lostechies.com/jimmybogard/2009/10/16/more-missing-linq-operators/^0|J|21|0|0|0|2|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|16|8|@$A|17|B|18|F|G]]|9|@]|C|$]]|$1|O|3|P|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Whilst I did not write these two - I wish I had. Found on <a href="http://lostechies.com/jimmybogard/2009/10/16/more-missing-linq-operators/" rel="nofollow">http://lostechies.com/jimmybogard/2009/10/16/more-missing-linq-operators/</a>

Append

<pre><code>public static IEnumerable&lt;TSource&gt; Append&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, TSource element)
{
 using (IEnumerator&lt;TSource&gt; e1 = source.GetEnumerator())
 while (e1.MoveNext())
 yield return e1.Current;

 yield return element;
}
</code></pre>

Prepend

<pre><code>public static IEnumerable&lt;TSource&gt; Prepend&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, TSource element)
{
 yield return element;

 using (IEnumerator&lt;TSource&gt; e1 = source.GetEnumerator())
 while (e1.MoveNext())
 yield return e1.Current;
}
</code></pre>

I'm starting to really love extension methods... I was wondering if anyone her has stumbled upon one that really blew their mind, or just found clever. 

An example I wrote today:

Edited due to other users' comments:

<pre><code>public static IEnumerable&lt;int&gt; To(this int fromNumber, int toNumber) {
 while (fromNumber &lt; toNumber) {
 yield return fromNumber;
 fromNumber++;
 }
}
</code></pre>

This allows a for loop to be written as a foreach loop:

<pre><code>foreach (int x in 0.To(16)) {
 Console.WriteLine(Math.Pow(2, x).ToString());
}
</code></pre>

I can't wait to see other examples! Enjoy!

What is the best or most interesting use of Extension Methods you've seen?

日志文件

数据库

编译器

Windows

Java

我开始真的喜欢上扩展方法了。我想知道她是不是偶然发现了一个真正让他们大吃一惊的人，或者只是觉得聪明的人。我今天写了一个例子：由于其他用户的评论而编辑的：public static IEnumerable<int> To(this int fromNumber, int toNumber) { while (fro...

问您所见过的扩展方法的最佳或最有趣的用法是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问您所见过的扩展方法的最佳或最有趣的用法是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问您所见过的扩展方法的最佳或最有趣的用法是什么？
EN