Quels sont vos préférés des méthodes d'extension pour C#? (codeplex.com/extensionoverflow)

J'ai plusieurs méthodes d'extension dans mon MiscUtil projet (source complet est disponible là - je ne vais pas répéter ici). Mes favoris, dont certains concernent d'autres classes (comme les plages):

Date et l'heure de trucs surtout pour les tests unitaires. Pas sûr que j'avais utiliser en production 🙂

var birthday = 19.June(1976);
var workingDay = 7.Hours() + 30.Minutes();

Plages et pas à pas - un énorme merci à Marc Gravel pour son opérateur de trucs rendre cela possible:

var evenNaturals = 2.To(int.MaxValue).Step(2);
var daysSinceBirth = birthday.To(DateTime.Today).Step(1.Days());

Comparaisons:

var myComparer = ProjectionComparer.Create(Person p => p.Name);
var next = myComparer.ThenBy(p => p.Age);
var reversed = myComparer.Reverse();

Vérification Argument:

x.ThrowIfNull("x");

LINQ to XML appliqué à des types anonymes (ou d'autres types avec des propriétés appropriées):

//<Name>Jon</Name><Age>32</Age>
new { Name="Jon", Age=32}.ToXElements();
//Name="Jon" Age="32" (as XAttributes, obviously)
new { Name="Jon", Age=32}.ToXAttributes()

Pousser LINQ - serait trop long à expliquer ici, mais qu'il recherche.

OriginalL'auteur

Sont ces toute utilisation?

public static bool CoinToss(this Random rng)
{
    return rng.Next(2) == 0;
}

public static T OneOf<T>(this Random rng, params T[] things)
{
    return things[rng.Next(things.Length)];
}

Random rand;
bool luckyDay = rand.CoinToss();
string babyName = rand.OneOf("John", "George", "Radio XBR74 ROCKS!");

OriginalL'auteur

La méthode d'extension:

public static void AddRange<T, S>(this ICollection<T> list, params S[] values)
    where S : T
{
    foreach (S value in values)
        list.Add(value);
}

La méthode s'applique pour tous les types et vous permet d'ajouter des éléments à une liste de paramètres.

Exemple:

var list = new List<Int32>();
list.AddRange(5, 4, 8, 4, 2);

OriginalL'auteur

ForEach pour IEnumerables

public static class FrameworkExtensions
{
    //a map function
    public static void ForEach<T>(this IEnumerable<T> @enum, Action<T> mapFunction)
    {
        foreach (var item in @enum) mapFunction(item);
    }
}

Naïf exemple:

var buttons = GetListOfButtons() as IEnumerable<Button>;

//click all buttons
buttons.ForEach(b => b.Click());

Cool exemple:

//no need to type the same assignment 3 times, just
//new[] up an array and use foreach + lambda
//everything is properly inferred by csc :-)
new { itemA, itemB, itemC }
    .ForEach(item => {
        item.Number = 1;
        item.Str = "Hello World!";
    });

Remarque:

Ce n'est pas comme Select parce que Select attend votre fonction pour retourner quelque chose comme pour les transformer en une autre liste.

ForEach permet simplement de vous exécuter quelque chose pour chacun des items sans transformation/de manipulation de données.

J'ai fait ce que je puisse le programme en plus de style fonctionnel et j'ai été surpris de voir que la Liste a un ForEach tout IEnumerable ne pas.

Mettre cela dans le projet codeplex

OriginalL'auteur

J'ai une méthode d'extension pour l'enregistrement des exceptions:

public static void Log(this Exception obj)
{
//your logging logic here
}

Et il est utilisé comme ceci:

try
{
//Your stuff here
}
catch(Exception ex)
{
ex.Log();
}

[désolé de poster deux fois; la 2ème est mieux conçu :-)]

OriginalL'auteur

Je la trouve assez utile:

public static class PaulaBean
{
private static String paula = "Brillant";
public static String GetPaula<T>(this T obj) {
return paula;
}
}

Vous pouvez l'utiliser sur CodePlex.

OriginalL'auteur

gitorious.org/cadenza est une bibliothèque complète de certains des plus utiles à l'extension des méthodes que j'ai vu.

OriginalL'auteur

Voici un va-et-à partir de chiffres Romains. Pas souvent utilisé, mais qui pourrait être à portée de main. Utilisation:

if ("IV".IsValidRomanNumeral())
{
//Do useful stuff with the number 4.
}
Console.WriteLine("MMMDCCCLXXXVIII".ParseRomanNumeral());
Console.WriteLine(3888.ToRomanNumeralString());

La source:

    public static class RomanNumeralExtensions
{
private const int NumberOfRomanNumeralMaps = 13;
private static readonly Dictionary<string, int> romanNumerals =
new Dictionary<string, int>(NumberOfRomanNumeralMaps)
{
{ "M", 1000 }, 
{ "CM", 900 }, 
{ "D", 500 }, 
{ "CD", 400 }, 
{ "C", 100 }, 
{ "XC", 90 }, 
{ "L", 50 }, 
{ "XL", 40 }, 
{ "X", 10 }, 
{ "IX", 9 }, 
{ "V", 5 }, 
{ "IV", 4 }, 
{ "I", 1 }
};
private static readonly Regex validRomanNumeral = new Regex(
"^(?i:(?=[MDCLXVI])((M{0,3})((C[DM])|(D?C{0,3}))"
+ "?((X[LC])|(L?XX{0,2})|L)?((I[VX])|(V?(II{0,2}))|V)?))$", 
RegexOptions.Compiled);
public static bool IsValidRomanNumeral(this string value)
{
return validRomanNumeral.IsMatch(value);
}
public static int ParseRomanNumeral(this string value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
value = value.ToUpperInvariant().Trim();
var length = value.Length;
if ((length == 0) || !value.IsValidRomanNumeral())
{
throw new ArgumentException("Empty or invalid Roman numeral string.", "value");
}
var total = 0;
var i = length;
while (i > 0)
{
var digit = romanNumerals[value[--i].ToString()];
if (i > 0)
{
var previousDigit = romanNumerals[value[i - 1].ToString()];
if (previousDigit < digit)
{
digit -= previousDigit;
i--;
}
}
total += digit;
}
return total;
}
public static string ToRomanNumeralString(this int value)
{
const int MinValue = 1;
const int MaxValue = 3999;
if ((value < MinValue) || (value > MaxValue))
{
throw new ArgumentOutOfRangeException("value", value, "Argument out of Roman numeral range.");
}
const int MaxRomanNumeralLength = 15;
var sb = new StringBuilder(MaxRomanNumeralLength);
foreach (var pair in romanNumerals)
{
while (value / pair.Value > 0)
{
sb.Append(pair.Key);
value -= pair.Value;
}
}
return sb.ToString();
}
}

OriginalL'auteur

Pour Winform Contrôles:

///<summary>
///Returns whether the function is being executed during design time in Visual Studio.
///</summary>
public static bool IsDesignTime(this Control control)
{
if (LicenseManager.UsageMode == LicenseUsageMode.Designtime)
{
return true;
}
if (control.Site != null && control.Site.DesignMode)
{
return true;
}
var parent = control.Parent;
while (parent != null)
{
if (parent.Site != null && parent.Site.DesignMode)
{
return true;
}
parent = parent.Parent;
}
return false;
}
///<summary>
///Sets the DropDownWidth to ensure that no item's text is cut off.
///</summary>
public static void SetDropDownWidth(this ComboBox comboBox)
{
var g = comboBox.CreateGraphics();
var font = comboBox.Font;
float maxWidth = 0;
foreach (var item in comboBox.Items)
{
maxWidth = Math.Max(maxWidth, g.MeasureString(item.ToString(), font).Width);
}
if (comboBox.Items.Count > comboBox.MaxDropDownItems)
{
maxWidth += SystemInformation.VerticalScrollBarWidth;
}
comboBox.DropDownWidth = Math.Max(comboBox.Width, Convert.ToInt32(maxWidth));
}

IsDesignTime Utilisation:

public class SomeForm : Form
{
public SomeForm()
{
InitializeComponent();
if (this.IsDesignTime())
{
return;
}
//Do something that makes the visual studio crash or hang if we're in design time,
//but any other time executes just fine
}
}

SetDropdownWidth Utilisation:

ComboBox cbo = new ComboBox { Width = 50 };
cbo.Items.Add("Short");
cbo.Items.Add("A little longer");
cbo.Items.Add("Holy cow, this is a really, really long item. How in the world will it fit?");
cbo.SetDropDownWidth();

J'ai oublié de mentionner, n'hésitez pas à utiliser ces sur Codeplex...

OriginalL'auteur

Je m'ennuie de la Visual Basic Avec déclaration quand passer au C#, donc ici, il va:

public static void With<T>(this T obj, Action<T> act) { act(obj); }

Et voici comment l'utiliser en C#:

someVeryVeryLonggggVariableName.With(x => {
x.Int = 123;
x.Str = "Hello";
x.Str2 = " World!";
});

Permet d'économiser beaucoup de la saisie!

Comparer:

someVeryVeryLonggggVariableName.Int = 123;
someVeryVeryLonggggVariableName.Str = "Hello";
someVeryVeryLonggggVariableName.Str2 = " World!";

mis en codeplex projet

OriginalL'auteur

J'ai trouvé utile

public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> pSeq)
{
return pSeq ?? Enumerable.Empty<T>();
}

Il supprime la valeur null est à vérifier dans le code appelant. Vous pouvez maintenant faire

MyList.EmptyIfNull().Where(....)

OriginalL'auteur

Ci-dessous est un méthode d'extension qui s'adapte Rick Strahl du code (et les commentaires aussi) pour vous empêcher de vous avoir à deviner ou à lire la marque d'ordre des octets d'un tableau d'octets ou de fichier texte chaque fois que vous le convertir en chaîne.

Le bout de code vous permet de tout simplement faire:

byte[] buffer = File.ReadAllBytes(@"C:\file.txt");
string content = buffer.GetString();

Si vous trouvez des bugs s'il vous plaît ajouter aux commentaires. N'hésitez pas à inclure dans le projet Codeplex.

public static class Extensions
{
///<summary>
///Converts a byte array to a string, using its byte order mark to convert it to the right encoding.
///Original article: http://www.west-wind.com/WebLog/posts/197245.aspx
///</summary>
///<param name="buffer">An array of bytes to convert</param>
///<returns>The byte as a string.</returns>
public static string GetString(this byte[] buffer)
{
if (buffer == null || buffer.Length == 0)
return "";
//Ansi as default
Encoding encoding = Encoding.Default;       
/*
EF BB BF    UTF-8 
FF FE UTF-16    little endian 
FE FF UTF-16    big endian 
FF FE 00 00 UTF-32, little endian 
00 00 FE FF UTF-32, big-endian 
*/
if (buffer[0] == 0xef && buffer[1] == 0xbb && buffer[2] == 0xbf)
encoding = Encoding.UTF8;
else if (buffer[0] == 0xfe && buffer[1] == 0xff)
encoding = Encoding.Unicode;
else if (buffer[0] == 0xfe && buffer[1] == 0xff)
encoding = Encoding.BigEndianUnicode; //utf-16be
else if (buffer[0] == 0 && buffer[1] == 0 && buffer[2] == 0xfe && buffer[3] == 0xff)
encoding = Encoding.UTF32;
else if (buffer[0] == 0x2b && buffer[1] == 0x2f && buffer[2] == 0x76)
encoding = Encoding.UTF7;
using (MemoryStream stream = new MemoryStream())
{
stream.Write(buffer, 0, buffer.Length);
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream, encoding))
{
return reader.ReadToEnd();
}
}
}
}

OriginalL'auteur

"S'il vous plaît noter vos réponses avec une acceptation de mettre le code dans le projet Codeplex."

Pourquoi? Tous les Trucs sur ce site sous CC-by-sa-2.5, donc il suffit de mettre votre Extension de dépassement de Projet sous la même licence, et vous pouvez l'utiliser librement.

De toute façon, ici, est une Chaîne de caractères.Fonction Reverse, basé sur cette question.

///<summary>
///Reverse a String
///</summary>
///<param name="input">The string to Reverse</param>
///<returns>The reversed String</returns>
public static string Reverse(this string input)
{
char[] array = input.ToCharArray();
Array.Reverse(array);
return new string(array);
}

OriginalL'auteur

Il m'énervait que LINQ me donne une OrderBy qui prend une classe implémentant l'interface IComparer comme un argument, mais ne prend pas en charge le passage d'une simple anonyme comparer la fonction. J'ai rectifié.

Cette classe crée une IComparer de comparer votre fonction...

///<summary>
///    Creates an <see cref="IComparer{T}"/> instance for the given
///    delegate function.
///</summary>
internal class ComparerFactory<T> : IComparer<T>
{
public static IComparer<T> Create(Func<T, T, int> comparison)
{
return new ComparerFactory<T>(comparison);
}
private readonly Func<T, T, int> _comparison;
private ComparerFactory(Func<T, T, int> comparison)
{
_comparison = comparison;
}
#region IComparer<T> Members
public int Compare(T x, T y)
{
return _comparison(x, y);
}
#endregion
}

...et ces méthodes d'extension exposer mon nouveau OrderBy surcharges sur enumerables. Je doute que cela fonctionne pour LINQ to SQL, mais il est parfait pour LINQ to Objects.

public static class EnumerableExtensions
{
///<summary>
///Sorts the elements of a sequence in ascending order by using a specified comparison delegate.
///</summary>
public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
Func<TKey, TKey, int> comparison)
{
var comparer = ComparerFactory<TKey>.Create(comparison);
return source.OrderBy(keySelector, comparer);
}
///<summary>
///Sorts the elements of a sequence in descending order by using a specified comparison delegate.
///</summary>
public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
Func<TKey, TKey, int> comparison)
{
var comparer = ComparerFactory<TKey>.Create(comparison);
return source.OrderByDescending(keySelector, comparer);
}
}

Vous êtes les bienvenus pour mettre cela sur codeplex si vous le souhaitez.

OriginalL'auteur

De transformer ceci:

DbCommand command = connection.CreateCommand();
command.CommandText = "SELECT @param";
DbParameter param = command.CreateParameter();
param.ParameterName = "@param";
param.Value = "Hello World";
command.Parameters.Add(param);

... dans ce:

DbCommand command = connection.CreateCommand("SELECT {0}", "Hello World");

... à l'aide de cette méthode d'extension:

using System;
using System.Data.Common;
using System.Globalization;
using System.Reflection;
namespace DbExtensions {
public static class Db {
static readonly Func<DbConnection, DbProviderFactory> getDbProviderFactory;
static readonly Func<DbCommandBuilder, int, string> getParameterName;
static readonly Func<DbCommandBuilder, int, string> getParameterPlaceholder;
static Db() {
getDbProviderFactory = (Func<DbConnection, DbProviderFactory>)Delegate.CreateDelegate(typeof(Func<DbConnection, DbProviderFactory>), typeof(DbConnection).GetProperty("DbProviderFactory", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true));
getParameterName = (Func<DbCommandBuilder, int, string>)Delegate.CreateDelegate(typeof(Func<DbCommandBuilder, int, string>), typeof(DbCommandBuilder).GetMethod("GetParameterName", BindingFlags.Instance | BindingFlags.NonPublic, Type.DefaultBinder, new Type[] { typeof(Int32) }, null));
getParameterPlaceholder = (Func<DbCommandBuilder, int, string>)Delegate.CreateDelegate(typeof(Func<DbCommandBuilder, int, string>), typeof(DbCommandBuilder).GetMethod("GetParameterPlaceholder", BindingFlags.Instance | BindingFlags.NonPublic, Type.DefaultBinder, new Type[] { typeof(Int32) }, null));
}
public static DbProviderFactory GetProviderFactory(this DbConnection connection) {
return getDbProviderFactory(connection);
}
public static DbCommand CreateCommand(this DbConnection connection, string commandText, params object[] parameters) {
if (connection == null) throw new ArgumentNullException("connection");
return CreateCommandImpl(GetProviderFactory(connection).CreateCommandBuilder(), connection.CreateCommand(), commandText, parameters);
}
private static DbCommand CreateCommandImpl(DbCommandBuilder commandBuilder, DbCommand command, string commandText, params object[] parameters) {
if (commandBuilder == null) throw new ArgumentNullException("commandBuilder");
if (command == null) throw new ArgumentNullException("command");
if (commandText == null) throw new ArgumentNullException("commandText");
if (parameters == null || parameters.Length == 0) {
command.CommandText = commandText;
return command;
}
object[] paramPlaceholders = new object[parameters.Length];
for (int i = 0; i < paramPlaceholders.Length; i++) {
DbParameter dbParam = command.CreateParameter();
dbParam.ParameterName = getParameterName(commandBuilder, i);
dbParam.Value = parameters[i] ?? DBNull.Value;
command.Parameters.Add(dbParam);
paramPlaceholders[i] = getParameterPlaceholder(commandBuilder, i);
}
command.CommandText = String.Format(CultureInfo.InvariantCulture, commandText, paramPlaceholders);
return command;
}
}
}

Plus ADO.NET les méthodes d'extension: DbExtensions

OriginalL'auteur