logo标签列表

你最喜欢的C#扩展方法是什么？（codeplex.com/extensionoverflow）

c#.netopen-sourceextension-methods
478

让我们列出一份答案，其中您可以发布您卓越且最喜欢的扩展方法。

要求是必须发布完整代码，并提供示例以及如何使用它的解释。

基于对此主题的高度关注，我在Codeplex上建立了一个名为extensionoverflow的开源项目。

请标记您的答案以接受将代码放入Codeplex项目中。

请发布完整的源代码而不是链接。

Codeplex新闻:

2010年08月24日 Codeplex页面现在在这里：http://extensionoverflow.codeplex.com/

2008年11月11日 XmlSerialize / XmlDeserialize已经实现并通过单元测试。

2008年11月11日 还有更多开发人员的空间。;-) 现在加入吧！

2008年11月11日 第三个贡献者加入ExtensionOverflow，欢迎BKristensen

2008年11月11日，FormatWith现已实现并通过单元测试。

2008年11月09日，第二位贡献者加入了ExtensionOverflow。欢迎chakrit。

2008年11月09日，我们需要更多的开发人员。;-)

2008年11月09日，ThrowIfArgumentIsNull现已实现并通过单元测试在Codeplex上。

现在第一段代码已经提交到 Codeplex 网站。 - bovium
Erik，不幸的是，现在所有的事情都已经在CodePlex上开始了。请无论如何加入。 - bovium
3
看起来还不错。我对静态类的命名有一点评论。将它们命名为<type>Extensions并不是很具指示性。例如，StringExtensions 既包含格式化内容又包含 XML 内容。我认为更好的做法是根据你扩展的类型来命名类。例如，在 UnixDateTimeConversions 中命名。你可以合理地猜测它包含将时间转换为 Unix 时间及从 Unix 时间转换的方法。这只是一个想法！ - ecoffey
请查看以下网址了解有关C#扩展方法的更多信息：http://planetofcoders.com/c-extension-methods/ - Gaurav Agrawal
150个回答
11

我最喜欢的之一是String的IsLike()扩展。 IsLike()与VB的Like运算符匹配，当您不想编写完整的正则表达式来解决问题时非常方便。 用法应该像这样：

"abc".IsLike("a*"); // true
"Abc".IsLike("[A-Z][a-z][a-z]"); // true
"abc123".IsLike("*###"); // true
"hat".IsLike("?at"); // true
"joe".IsLike("[!aeiou]*"); // true

"joe".IsLike("?at"); // false
"joe".IsLike("[A-Z][a-z][a-z]"); // false

这是代码：

public static class StringEntentions {
    /// <summary>
    /// Indicates whether the current string matches the supplied wildcard pattern.  Behaves the same
    /// as VB's "Like" Operator.
    /// </summary>
    /// <param name="s">The string instance where the extension method is called</param>
    /// <param name="wildcardPattern">The wildcard pattern to match.  Syntax matches VB's Like operator.</param>
    /// <returns>true if the string matches the supplied pattern, false otherwise.</returns>
    /// <remarks>See http://msdn.microsoft.com/en-us/library/swf8kaxw(v=VS.100).aspx</remarks>
    public static bool IsLike(this string s, string wildcardPattern) {
        if (s == null || String.IsNullOrEmpty(wildcardPattern)) return false;
        // turn into regex pattern, and match the whole string with ^$
        var regexPattern = "^" + Regex.Escape(wildcardPattern) + "$";

        // add support for ?, #, *, [], and [!]
        regexPattern = regexPattern.Replace(@"\[!", "[^")
                                   .Replace(@"\[", "[")
                                   .Replace(@"\]", "]")
                                   .Replace(@"\?", ".")
                                   .Replace(@"\*", ".*")
                                   .Replace(@"\#", @"\d");

        var result = false;
        try {
            result = Regex.IsMatch(s, regexPattern);
        }
        catch (ArgumentException ex) {
            throw new ArgumentException(String.Format("Invalid pattern: {0}", wildcardPattern), ex);
        }
        return result;
    }
}
1
非常类似于我在这里发布的方法（https://dev59.com/G3VC5IYBdhLWcg3whBaj#3527407）。您的实现允许更灵活的模式，但我的可能更快;) - Thomas Levesque
10
与上面的字符串As和Is类似，但对所有对象全局有效。
这很简单，但我经常使用它们来减少括号爆炸与装箱。
public static class ExtensionMethods_Object
{
    [DebuggerStepThrough()]
    public static bool Is<T>(this object item) where T : class
    {
        return item is T;
    }

    [DebuggerStepThrough()]
    public static bool IsNot<T>(this object item) where T : class
    {
        return !(item.Is<T>());
    }

    [DebuggerStepThrough()]
    public static T As<T>(this object item) where T : class
    {
        return item as T;
    }
}

我很高兴这段代码被用在了CodePlex上，实际上它已经被使用了。
所有这些的目的是什么？为什么不直接写成"item as Type"，而要像你现在这样写成"item.As<Type>()"呢？ - Kamarey
2
@Kamarey 这是一种主观偏好，但它可以减少在存在多个转换时可能会产生的混淆括号。item as Type 可以变成 (item as Type) 或者 ((Type)item) 如果你需要将 item 作为转换类型使用。此外，item.As<Type>() 的从左到右扫描... 在某些混乱的情况中比装箱更易读。我确实说过这很简单，而且我同意这是一个主观的问题，但我认为它能够提高代码的可读性。 - johnc
1
@Kamarey 一些人称之为“流畅编程”——总是从左到右进行编程，永远不需要倒退去添加括号。使用箭头键会减慢速度。这也与可枚举和可观察操作符的风格保持一致。@johnc 我建议在列表中增加一个 To<T> 方法，用于执行 (T)item 操作。 - scobi
10
9

从Random类中，您可以获得很多功能。

以下是我偶尔使用的一些扩展方法。除了Next和NextDouble之外，Random类还提供了NextBool、NextChar、NextDateTime、NextTimeSpan、NextDouble（接受minValue和maxValue参数），以及我个人最喜欢的NextString。还有更多（例如NextByte、NextShort、NextLong等），但这些大多数是为了完整性而存在，并没有被广泛使用。因此，我在这里没有包含它们（这段代码已经够长了！）。

// todo: implement additional CharType values (e.g., AsciiAny)
public enum CharType {
    AlphabeticLower,
    AlphabeticUpper,
    AlphabeticAny,
    AlphanumericLower,
    AlphanumericUpper,
    AlphanumericAny,
    Numeric
}

public static class RandomExtensions {
    // 10 digits vs. 52 alphabetic characters (upper & lower);
    // probability of being numeric: 10 / 62 = 0.1612903225806452
    private const double AlphanumericProbabilityNumericAny = 10.0 / 62.0;

    // 10 digits vs. 26 alphabetic characters (upper OR lower);
    // probability of being numeric: 10 / 36 = 0.2777777777777778
    private const double AlphanumericProbabilityNumericCased = 10.0 / 36.0;

    public static bool NextBool(this Random random, double probability) {
        return random.NextDouble() <= probability;
    }

    public static bool NextBool(this Random random) {
        return random.NextDouble() <= 0.5;
    }

    public static char NextChar(this Random random, CharType mode) {
        switch (mode) {
            case CharType.AlphabeticAny:
                return random.NextAlphabeticChar();
            case CharType.AlphabeticLower:
                return random.NextAlphabeticChar(false);
            case CharType.AlphabeticUpper:
                return random.NextAlphabeticChar(true);
            case CharType.AlphanumericAny:
                return random.NextAlphanumericChar();
            case CharType.AlphanumericLower:
                return random.NextAlphanumericChar(false);
            case CharType.AlphanumericUpper:
                return random.NextAlphanumericChar(true);
            case CharType.Numeric:
                return random.NextNumericChar();
            default:
                return random.NextAlphanumericChar();
        }
    }

    public static char NextChar(this Random random) {
        return random.NextChar(CharType.AlphanumericAny);
    }

    private static char NextAlphanumericChar(this Random random, bool uppercase) {
        bool numeric = random.NextBool(AlphanumericProbabilityNumericCased);

        if (numeric)
            return random.NextNumericChar();
        else
            return random.NextAlphabeticChar(uppercase);
    }

    private static char NextAlphanumericChar(this Random random) {
        bool numeric = random.NextBool(AlphanumericProbabilityNumericAny);

        if (numeric)
            return random.NextNumericChar();
        else
            return random.NextAlphabeticChar(random.NextBool());
    }

    private static char NextAlphabeticChar(this Random random, bool uppercase) {
        if (uppercase)
            return (char)random.Next(65, 91);
        else
            return (char)random.Next(97, 123);
    }

    private static char NextAlphabeticChar(this Random random) {
        return random.NextAlphabeticChar(random.NextBool());
    }

    private static char NextNumericChar(this Random random) {
        return (char)random.Next(48, 58);
    }

    public static DateTime NextDateTime(this Random random, DateTime minValue, DateTime maxValue) {
        return DateTime.FromOADate(
            random.NextDouble(minValue.ToOADate(), maxValue.ToOADate())
        );
    }

    public static DateTime NextDateTime(this Random random) {
        return random.NextDateTime(DateTime.MinValue, DateTime.MaxValue);
    }

    public static double NextDouble(this Random random, double minValue, double maxValue) {
        if (maxValue < minValue)
            throw new ArgumentException("Minimum value must be less than maximum value.");

        double difference = maxValue - minValue;
        if (!double.IsInfinity(difference))
            return minValue + (random.NextDouble() * difference);

        else {
            // to avoid evaluating to Double.Infinity, we split the range into two halves:
            double halfDifference = (maxValue * 0.5) - (minValue * 0.5);

            // 50/50 chance of returning a value from the first or second half of the range
            if (random.NextBool())
                return minValue + (random.NextDouble() * halfDifference);
            else
                return (minValue + halfDifference) + (random.NextDouble() * halfDifference);
        }
    }

    public static string NextString(this Random random, int numChars, CharType mode) {
        char[] chars = new char[numChars];

        for (int i = 0; i < numChars; ++i)
            chars[i] = random.NextChar(mode);

        return new string(chars);
    }

    public static string NextString(this Random random, int numChars) {
        return random.NextString(numChars, CharType.AlphanumericAny);
    }

    public static TimeSpan NextTimeSpan(this Random random, TimeSpan minValue, TimeSpan maxValue) {
        return TimeSpan.FromMilliseconds(
            random.NextDouble(minValue.TotalMilliseconds, maxValue.TotalMilliseconds)
        );
    }

    public static TimeSpan NextTimeSpan(this Random random) {
        return random.NextTimeSpan(TimeSpan.MinValue, TimeSpan.MaxValue);
    }
}
9

IEnumerable<> 随机排序

我使用了 Fisher-Yates 算法来实现一个随机排序函数。

通过使用 yield return 并将代码分为两个函数，它实现了适当的 参数验证 和 延迟执行。（感谢 Dan 指出我第一版中的缺陷）

static public IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
{
    if (source == null) throw new ArgumentNullException("source");

    return ShuffleIterator(source);
}

static private IEnumerable<T> ShuffleIterator<T>(this IEnumerable<T> source)
{
    T[] array = source.ToArray();
    Random rnd = new Random();          
    for (int n = array.Length; n > 1;)
    {
        int k = rnd.Next(n--); // 0 <= k < n

        //Swap items
        if (n != k)
        {
            T tmp = array[k];
            array[k] = array[n];
            array[n] = tmp;
        }
    }

    foreach (var item in array) yield return item;
}
1
如果您打算在LINQ查询中使用此方法，那么您可能希望考虑实现一个ShuffledEnumerable类，该类仅在GetEnumerator时执行此工作（并且可能会将其缓存），以提供惰性评估，也就是延迟执行。否则，如果某人调用例如var shuffledNames = myObjects.Select(x => x.Name).Distinct().Shuffle();操作将立即执行，这可能不是他/她所期望的。不过，回答得真好！ - Dan Tao
1
@Dan：这是一个很好的观点。有一种优雅的方法可以在没有显式声明类的情况下使用延迟执行，yield return可以解决这个问题。我会编辑我的答案。 - jpbochi
1
不错。现在它基本上是“OrderBy”的逻辑相反。干得好！ - Dan Tao
刚刚在这里找到了一个稍微更灵活的版本：https://dev59.com/R2025IYBdhLWcg3wwo-m#5807238 - jpbochi
你应该移除 foreach 循环，并将 if 语句的主体替换为 yield return array[k] = array[n];。 - leviathanbadger
9

对我来说另一个有用的技能是：

/// <summary>
/// Converts any type in to an Int32
/// </summary>
/// <typeparam name="T">Any Object</typeparam>
/// <param name="value">Value to convert</param>
/// <returns>The integer, 0 if unsuccessful</returns>
public static int ToInt32<T>(this T value)
{
  int result;
  if (int.TryParse(value.ToString(), out result))
  {
    return result;
  }
  return 0;
}

/// <summary>
/// Converts any type in to an Int32 but if null then returns the default
/// </summary>
/// <param name="value">Value to convert</param>
/// <typeparam name="T">Any Object</typeparam>
/// <param name="defaultValue">Default to use</param>
/// <returns>The defaultValue if unsuccessful</returns>
public static int ToInt32<T>(this T value, int defaultValue)
{
  int result;
  if (int.TryParse(value.ToString(), out result))
  {
    return result;
  }
  return defaultValue;
}

例子：

int number = "123".ToInt32();

或者：

int badNumber = "a".ToInt32(100); // Returns 100 since a is nan
没错，同样的ToInt64、ToFloat等。如果你愿意，可以消除if语句，并将其简化为一个return。 - cfeduke
啊哈，我以前也有很多这样的东西。但是当你需要string.ToInt32 double.ToInt32 float.ToInt32时它有点太大了，嘿嘿，我想我有点滥用它了 :-) - chakrit
Pablo Marambio - 我还有其他的执行方法吗？ - TWith2Sugars
2
如果我记得正确的话，convert.ToIt32可能会抛出一个异常。 - TWith2Sugars
我有一个类似的方法叫做Parse<T>，我用它处理各种类型，不仅限于int32。 - John
8

我在Silverlight项目中使用以下内容：

public static void Show(this UIElement element)
{
    element.Visibility = Visibility.Visible;
}

public static void Hide(this UIElement element)
{
    element.Visibility = Visibility.Collapsed;
}
8

我对.NET Framework更喜欢将文件和目录表示为字符串而不是对象感到失望，FileInfo和DirectoryInfo类型也没有我希望的那么强大。因此，我开始编写流畅的扩展方法，例如：

public static FileInfo SetExtension(this FileInfo fileInfo, string extension)
{
    return new FileInfo(Path.ChangeExtension(fileInfo.FullName, extension));
}

public static FileInfo SetDirectory(this FileInfo fileInfo, string directory)
{
    return new FileInfo(Path.Combine(directory, fileInfo.Name));
}

是的，你可以把它放在CodePlex上。

1
FileInfo和DirectoryInfo与它们的字符串File和Directory相比速度较慢。您可能需要对它们进行分析。 - chakrit
8

我最好的一些方法扩展（我有很多！）：

public static T ToEnum<T>(this string str) where T : struct
{
    return (T)Enum.Parse(typeof(T), str);
}

//DayOfWeek sunday =  "Sunday".ToEnum<DayOfWeek>();

public static string ToString<T>(this IEnumerable<T> collection, string separator)
{
    return ToString(collection, t => t.ToString(), separator);
}

public static string ToString<T>(this IEnumerable<T> collection, Func<T, string> stringElement, string separator)
{
    StringBuilder sb = new StringBuilder();
    foreach (var item in collection)
    {
        sb.Append(stringElement(item));
        sb.Append(separator);
    }
    return sb.ToString(0, Math.Max(0, sb.Length - separator.Length));  // quita el ultimo separador
}

//new []{1,2,3}.ToString(i=>i*2, ", ")  --> "2, 4, 6"

此外，下一个目标是在几乎任何情况下都能够继续在同一行中进行，而不是声明新变量然后删除状态。
public static R Map<T, R>(this T t, Func<T, R> func)
{
    return func(t);
}

ExpensiveFindWally().Map(wally=>wally.FirstName + " " + wally.LastName)

public static R TryCC<T, R>(this T t, Func<T, R> func)
    where T : class
    where R : class
{
    if (t == null) return null;
    return func(t);
}

public static R? TryCS<T, R>(this T t, Func<T, R> func)
    where T : class
    where R : struct
{
    if (t == null) return null;
    return func(t);
}

public static R? TryCS<T, R>(this T t, Func<T, R?> func)
    where T : class
    where R : struct
{
    if (t == null) return null;
    return func(t);
}

public static R TrySC<T, R>(this T? t, Func<T, R> func)
    where T : struct
    where R : class
{
    if (t == null) return null;
    return func(t.Value);
}

public static R? TrySS<T, R>(this T? t, Func<T, R> func)
    where T : struct
    where R : struct
{
    if (t == null) return null;
    return func(t.Value);
}

public static R? TrySS<T, R>(this T? t, Func<T, R?> func)
    where T : struct
    where R : struct
{
    if (t == null) return null;
    return func(t.Value);
}

//int? bossNameLength =  Departament.Boss.TryCC(b=>b.Name).TryCS(s=>s.Length);


public static T ThrowIfNullS<T>(this T? t, string mensaje)
    where T : struct
{
    if (t == null)
        throw new NullReferenceException(mensaje);
    return t.Value;
}

public static T ThrowIfNullC<T>(this T t, string mensaje)
    where T : class
{
    if (t == null)
        throw new NullReferenceException(mensaje);
    return t;
}

public static T Do<T>(this T t, Action<T> action)
{
    action(t);
    return t;
}

//Button b = new Button{Content = "Click"}.Do(b=>Canvas.SetColumn(b,2));

public static T TryDo<T>(this T t, Action<T> action) where T : class
{
    if (t != null)
        action(t);
    return t;
}

public static T? TryDoS<T>(this T? t, Action<T> action) where T : struct
{
    if (t != null)
        action(t.Value);
    return t;
}

希望这不会像来自火星一样 :)


涉及 IT 技术的翻译内容如下：

8

与时间跨度相关的扩展，例如：

public static TimeSpan Seconds(this int seconds)
{
  return TimeSpan.FromSeconds(seconds);
}

public static TimeSpan Minutes(this int minutes)
{
  return TimeSpan.FromMinutes(minutes);
}

这使得可以使用：

1.Seconds()
20.Minutes()

锁定扩展名：

public static IDisposable GetReadLock(this ReaderWriterLockSlim slimLock)
{
  slimLock.EnterReadLock();
  return new DisposableAction(slimLock.ExitReadLock);
}

public static IDisposable GetWriteLock(this ReaderWriterLockSlim slimLock)
{
  slimLock.EnterWriteLock();
  return new DisposableAction(slimLock.ExitWriteLock);
}

public static IDisposable GetUpgradeableReadLock(this ReaderWriterLockSlim slimLock)
{
  slimLock.EnterUpgradeableReadLock();
  return new DisposableAction(slimLock.ExitUpgradeableReadLock);
}

这允许使用锁，例如：

using (lock.GetUpgradeableReadLock())
{
  // try read
  using (lock.GetWriteLock())
  {
    //do write
  }
}

还有很多来自Lokad共享库的内容

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接