Was sind Ihre bevorzugten Erweiterungsmethoden für C#? (codeplex.com/extensionoverflow)

Question

Lassen Sie uns eine Liste mit Antworten erstellen, in der Sie Ihre ausgezeichneten und bevorzugten Erweiterungsmethoden .

Die Anforderung ist, dass der vollständige Code mit einem Beispiel und einer Erklärung, wie er zu verwenden ist, veröffentlicht werden muss.

Aufgrund des großen Interesses an diesem Thema habe ich ein Open Source Projekt namens extensionoverflow auf Codeplex .

Bitte markieren Sie Ihre Antworten mit der Zustimmung, den Code in das Codeplex-Projekt zu stellen.

Bitte posten Sie den vollständigen Quellcode und nicht nur einen Link.

Codeplex Nachrichten:

24.08.2010 Die Codeplex-Seite ist jetzt hier: http://extensionoverflow.codeplex.com/

11.11.2008 XmlSerialize / XmlDeserialize ist jetzt Implementiert y Einheit getestet .

11.11.2008 Es gibt noch Platz für weitere Entwickler ;-) JETZT anmelden!

11.11.2008 Dritter Beitragszahler beigetreten ExtensionOverflow , willkommen bei BKristensen

11.11.2008 FormatWith ist jetzt Implementiert y Einheit getestet .

09.11.2008 Zweiter Beitragszahler beigetreten ExtensionOverflow . willkommen bei chakrit .

09.11.2008 Wir brauchen mehr Entwickler ;-)

09.11.2008 ThrowIfArgumentIsNull in jetzt Implementiert y Einheit getestet auf Codeplex.

Answer 1

Einer meiner Favoriten ist eine IsLike()-Erweiterung für String. IsLike() entspricht VBs Like-Operator und ist praktisch, wenn Sie nicht eine komplette Regex schreiben wollen, um Ihr Problem zu lösen. Die Verwendung würde etwa so aussehen:

"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

Hier ist der Code

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

Answer 2

Ähnlich wie die obigen Zeichenfolgen As und Is, aber global für alle Objekte.

Es ist recht einfach, aber ich verwende sie oft, um die Explosion von Parens beim Boxen zu verringern.

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

Ich freue mich, wenn dieser Code bei Codeplex verwendet wird, das ist er ja bereits.

Answer 3

Weitere Beispiele finden Sie hier: www.extensionmethod.net

Answer 4

IEnumerable<> Mischen

Ich habe die Fisher-Yates den Algorithmus zur Implementierung einer Shuffle-Funktion.

Durch die Verwendung von yield return und die Aufteilung des Codes in zwei Funktionen, erreicht sie eine ordnungsgemäße Argumentüberprüfung y verzögerte Ausführung . (Dank, Dan für den Hinweis auf diesen Fehler in meiner ersten Version)

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

Answer 5

Eine weitere nützliche Information für mich:

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

Beispiel:

int number = "123".ToInt32();

ou :

int badNumber = "a".ToInt32(100); // Returns 100 since a is nan