你所见过的最好或最有趣的扩展方法使用是什么？

经常需要根据枚举值显示用户友好的值，但是不想使用自定义属性路线，因为这似乎不太优雅。

有了这个方便的扩展方法：

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!!";
}

我可以做到这一点：

Console.WriteLine(MyEnum.First.EnumValue());

太棒了！

虽然非常简单，但我发现这个解决方案在每个项目中都可以生成满足完整结果集的页面。

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;
    }
}

我在这里看到的大多数扩展方法示例都违反了最佳实践。扩展方法很强大，但应该谨慎使用。根据我的经验，对于大多数情况来说，具有老式语法的静态帮助程序/工具类通常更可取。

有些情况下，枚举类型可以使用扩展方法，因为它们无法具有方法。如果您将其定义在与枚举相同的命名空间和程序集中，则它们可以透明地工作。

这个很简单，但我经常检查它，所以最终做了一个扩展方法。我最喜欢的扩展方法通常是非常简单、直接的，比如像Taylor L的用于触发事件的扩展方法。

public static bool IsNullOrEmpty(this ICollection e)
{
    return e == null || e.Count == 0;
}

我正在将很多Java代码转换为C#。其中许多方法只有大小写或其他小语法差异。因此，Java代码如下：

myString.toLowerCase();

如果不添加扩展方法，代码将无法编译

public static void toLowerCase(this string s)
{
    s.ToLower();
}

我可以捕获所有方法（我认为一个好的编译器会内联这个方法？）。

这无疑使工作变得更加容易和可靠。 （我感谢@Yuriy-请参见：Java和C#中StringBuilder的区别），提供了这个建议。

为了让组合代码更加功能强大：

    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);
    }

那么我可以这样写：

接下来我可以写出类似于这样的内容：

    public static int ParseInt(this string str, int coalesce)
    {
        return TryCoalesce(int.Parse, str, coalesce);
    }

我经常使用另一组用于合并IDictionary方法的集合：

    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);
    }

对于一般集合的操作：

    public static IEnumerable<T> AsCollection<T>(this T item)
    {
        yield return item;
    }

那么对于树形结构：

    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;
    }

所以我可以轻松地遍历和操作类似的类：

class Category
{
    public string Name { get; set; }
    public Category Parent { get; set; }
}

下一步，为了方便函数组合和更加类似F#的C#编程方式：

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));
}

我个人收藏的字符串工具中最喜欢的是一种可以从字符串解析出强类型值的工具，适用于任何具有 TryParse 方法的类型：

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));
    }
}

它非常适合从查询字符串中获取强类型信息：

var value = Request.QueryString["value"].To<int>();

我讨厌在每个地方都要这样做：

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
        }
    }
}

相反，我通常使用以下的扩展方法：

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;
            }
        }
    }
}

那么第一个例子就变成了：

foreach(DataRow row in ds.DataRows()){
    //Do some processing
}

太棒了，扩展方法！

在使用 StringBuilder 的时候，你可能会发现需要同时使用 AppendFormat() 和 AppendLine()。

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

另外，由于我正在将一个VB6应用程序转换为C#，以下内容对我非常有用：

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.");
}