Puis-je ajouter une extension des méthodes à une classe statique?

Pouvez-vous ajouter de la statique des extensions de classes en C#? Non, mais vous pouvez le faire:

public static class Extensions
{
    public static T Create<T>(this T @this)
        where T : class, new()
    {
        return Utility<T>.Create();
    }
}

public static class Utility<T>
    where T : class, new()
{
    static Utility()
    {
        Create = Expression.Lambda<Func<T>>(Expression.New(typeof(T).GetConstructor(Type.EmptyTypes))).Compile();
    }
    public static Func<T> Create { get; private set; }
}

Voici comment cela fonctionne. Si vous ne pouvez pas techniquement écrire statiques les méthodes d'extension, au lieu de ce code exploite une faille dans les méthodes d'extension. Cette échappatoire étant que l'on peut appeler des méthodes d'extension sur des objets nuls sans nulle exception (sauf si vous avez accès à quoi que ce soit via @ce).

Alors, voici comment vous pourriez utiliser ceci:

    var ds1 = (null as DataSet).Create(); //as oppose to DataSet.Create()
    //or
    DataSet ds2 = null;
    ds2 = ds2.Create();

    //using some of the techniques above you could have this:
    (null as Console).WriteBlueLine(...); //as oppose to Console.WriteBlueLine(...)

Maintenant, POURQUOI ai-je choisir d'appeler le constructeur par défaut comme un exemple, ET pourquoi n'ai-je pas juste de retour de new T() dans le premier extrait de code sans avoir à faire tout l'Expression de déchets?
Eh bien aujourd'hui votre jour de chance parce que vous obtenez un 2fer. Comme toute avancée .NET développeur sait, new T() est lent, car il génère un appel Système.Activator qui utilise la réflexion pour obtenir le constructeur par défaut avant de l'appeler. Putain vous Microsoft!
Cependant mon code appelle le constructeur par défaut de l'objet directement.

Statique extensions serait mieux que cela, mais les temps désespérés appellent des mesures désespérées.

Je suis tombé sur ce fil, tout en essayant de trouver une réponse à la même question de l'OP eu. Je n'ai pas trouvé la réponse que je voulais, mais j'ai fini par faire cette.

public static class MyConsole
{
    public static void WriteLine(this ConsoleColor Color, string Text)
    {
        Console.ForegroundColor = Color;
        Console.WriteLine(Text);   
    }
}

Et je l'utilise comme ceci:

ConsoleColor.Cyan.WriteLine("voilà");

Nope. Méthode d'Extension des définitions nécessitent une instance du type que vous êtes l'extension. Son malheureux; je ne sais pas pourquoi sa...

Comme pour les méthodes d'extension, les méthodes d'extension sont eux-mêmes statique; mais ils sont invoqués comme si ils sont des méthodes d'instance. Depuis une classe statique n'est pas instanciable, vous n'auriez jamais une instance de la classe pour appeler une méthode d'extension de. Pour cette raison, le compilateur ne pas permettre l'extension de définir des méthodes pour les classes statiques.

M. Odieux a écrit: "Comme toute avancée .NET développeur sait, new T() est lent, car il génère un appel Système.Activator qui utilise la réflexion pour obtenir le constructeur par défaut avant d'appeler ça".

New() est compilé à l'IL "newobj" instruction si le type est connu au moment de la compilation. Newobj prend un constructeur pour l'invocation directe. Les appels Système.Activateur.CreateInstance() à compiler le IL "appel" instruction à invoquer Système.Activateur.CreateInstance(). New() lorsqu'il est utilisé contre les types génériques sera la suite d'un appel Système.Activateur.CreateInstance(). Le post de M. Odieux était pas clair sur ce point... et bien, désagréable.

Ce code:

System.Collections.ArrayList _al = new System.Collections.ArrayList();
System.Collections.ArrayList _al2 = (System.Collections.ArrayList)System.Activator.CreateInstance(typeof(System.Collections.ArrayList));

produit ce IL:

  .locals init ([0] class [mscorlib]System.Collections.ArrayList _al,
           [1] class [mscorlib]System.Collections.ArrayList _al2)
  IL_0001:  newobj     instance void [mscorlib]System.Collections.ArrayList::.ctor()
  IL_0006:  stloc.0
  IL_0007:  ldtoken    [mscorlib]System.Collections.ArrayList
  IL_000c:  call       class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
  IL_0011:  call       object [mscorlib]System.Activator::CreateInstance(class [mscorlib]System.Type)
  IL_0016:  castclass  [mscorlib]System.Collections.ArrayList
  IL_001b:  stloc.1

J'ai essayé de le faire avec le Système.L'environnement de l'époque où j'étais à l'apprentissage des méthodes d'extension et n'a pas réussi. La raison en est, comme d'autres, mentionner, car les méthodes d'extension nécessitent une instance de la classe.

Ce qui suit a été rejetée comme une modifier à tvanfosson de réponse. J'ai été invité à participer comme ma propre réponse. J'ai utilisé sa suggestion et a terminé la mise en œuvre d'un ConfigurationManager wrapper. En principe, j'ai simplement rempli le ... dans tvanfosson de réponse.

Pas. Les méthodes d'Extension nécessitent une instance d'un objet. Vous pouvez
cependant, écrire un statique wrapper autour de la ConfigurationManager
de l'interface. Si vous mettez en œuvre le wrapper, vous n'avez pas besoin d'une extension
méthode, car vous pouvez simplement ajouter la méthode directement.

public static class ConfigurationManagerWrapper
{
    public static NameValueCollection AppSettings
    {
        get { return ConfigurationManager.AppSettings; }
    }

    public static ConnectionStringSettingsCollection ConnectionStrings
    {
        get { return ConfigurationManager.ConnectionStrings; }
    }

    public static object GetSection(string sectionName)
    {
        return ConfigurationManager.GetSection(sectionName);
    }

    public static Configuration OpenExeConfiguration(string exePath)
    {
        return ConfigurationManager.OpenExeConfiguration(exePath);
    }

    public static Configuration OpenMachineConfiguration()
    {
        return ConfigurationManager.OpenMachineConfiguration();
    }

    public static Configuration OpenMappedExeConfiguration(ExeConfigurationFileMap fileMap, ConfigurationUserLevel userLevel)
    {
        return ConfigurationManager.OpenMappedExeConfiguration(fileMap, userLevel);
    }

    public static Configuration OpenMappedMachineConfiguration(ConfigurationFileMap fileMap)
    {
        return ConfigurationManager.OpenMappedMachineConfiguration(fileMap);
    }

    public static void RefreshSection(string sectionName)
    {
        ConfigurationManager.RefreshSection(sectionName);
    }
}

Vous pouvez utiliser un cast sur null pour le faire fonctionner.

public static class YoutTypeExtensionExample
{
    public static void Example()
    {
        ((YourType)null).ExtensionMethod();
    }
}

L'extension:

public static class YourTypeExtension
{
    public static void ExtensionMethod(this YourType x) { }
}

YourType:

public class YourType { }