¿Puedo agregar métodos de extensión a una clase estática existente?

Question

Soy un fan de los métodos de extensión en C#, pero no he tenido éxito al agregar un método de extensión a una clase estática, como la consola.

Por ejemplo, si quiero agregar una extensión a la consola, llamada 'WriteBlueLine', por lo que puedo ir:

Console.WriteBlueLine("This text is blue"); 

yo probamos este mediante la adición de un método estático locales, públicos, con la consola como un "este" parámetro ... ¡pero no dados!

public static class Helpers { 
    public static void WriteBlueLine(this Console c, string text) 
    { 
     Console.ForegroundColor = ConsoleColor.Blue; 
     Console.WriteLine(text); 
     Console.ResetColor(); 
    } 
} 

Esto no agregó un método 'WriteBlueLine' a la consola ... ¿Lo estoy haciendo mal? ¿O preguntando por lo imposible?

Answer 1

No. Los métodos de extensión requieren una variable de instancia (valor) para un objeto. Sin embargo, puede escribir un contenedor estático alrededor de la interfaz ConfigurationManager. Si implementa el contenedor, no necesita un método de extensión ya que solo puede agregar el método directamente.

public static class ConfigurationManagerWrapper 
{ 
     public static ConfigurationSection GetSection(string name) 
     { 
     return ConfigurationManager.GetSection(name); 
     } 

     ..... 

     public static ConfigurationSection GetWidgetSection() 
     { 
      return GetSection("widgets"); 
     } 
} 

Answer 2

No puede agregar métodos estáticos a un tipo. Solo puede agregar métodos de instancia (pseudo-) a una instancia de un tipo.

El objetivo del modificador this es indicar al compilador de C# que pase la instancia en el lado izquierdo de . como el primer parámetro del método estático/de extensión.

En el caso de agregar métodos estáticos a un tipo, no hay ninguna instancia para pasar para el primer parámetro.

Answer 3

Intenté hacer esto con System.Environment cuando estaba aprendiendo métodos de extensión y no tuve éxito. La razón es, como otros mencionan, porque los métodos de extensión requieren una instancia de la clase.

Answer 4

No. Las definiciones de métodos de extensión requieren una instancia del tipo que está extendiendo. Es desafortunado; No estoy seguro de por qué es necesario ...

Answer 5

No es posible.

Y sí, creo que MS cometió un error aquí.

Su decisión no tiene sentido y obliga a los programadores a escribir (como se describió anteriormente) una clase contenedora inútil.

He aquí un buen ejemplo: intentar extender la clase de prueba estática de MS Unit Afirmar: Quiero 1 más Método de aserción AreEqual(x1,x2).

La única forma de hacerlo es apuntar a diferentes clases o escribir un contenedor alrededor de cientos de diferentes métodos de Assert. ¿Por qué?

Si se tomó la decisión de permitir extensiones de instancias, no veo ninguna razón lógica para no permitir las extensiones estáticas. Los argumentos sobre bibliotecas de seccionamiento no se sostienen una vez que las instancias se pueden extender.

Answer 6

Tal vez usted podría agregar una clase estática con su espacio de nombres personalizado y el mismo nombre de la clase:

using CLRConsole = System.Console; 

namespace ExtensionMethodsDemo 
{ 
    public static class Console 
    { 
     public static void WriteLine(string value) 
     { 
      CLRConsole.WriteLine(value); 
     } 

     public static void WriteBlueLine(string value) 
     { 
      System.ConsoleColor currentColor = CLRConsole.ForegroundColor; 

      CLRConsole.ForegroundColor = System.ConsoleColor.Blue; 
      CLRConsole.WriteLine(value); 

      CLRConsole.ForegroundColor = currentColor; 
     } 

     public static System.ConsoleKeyInfo ReadKey(bool intercept) 
     { 
      return CLRConsole.ReadKey(intercept); 
     } 
    } 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      try 
      { 
       Console.WriteBlueLine("This text is blue"); 
      } 
      catch (System.Exception ex) 
      { 
       Console.WriteLine(ex.Message); 
       Console.WriteLine(ex.StackTrace); 
      } 

      Console.WriteLine("Press any key to continue..."); 
      Console.ReadKey(true); 
     } 
    } 
} 

Answer 7

Usted puede hacer esto si usted está dispuesto a "frigorífico" un poco haciendo una variable de la estática clase y asignarlo a nulo. Sin embargo, este método no estaría disponible para llamadas estáticas en la clase, por lo que no está seguro de cuánto uso sería:

Console myConsole = null; 
myConsole.WriteBlueLine("my blue line"); 

public static class Helpers { 
    public static void WriteBlueLine(this Console c, string text) 
    { 
     Console.ForegroundColor = ConsoleColor.Blue; 
     Console.WriteLine(text); 
     Console.ResetColor(); 
    } 
} 

Answer 8

se puede añadir extensiones estáticas de clases en C#? No, pero puede hacer esto:

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

Así es como funciona. Aunque técnicamente no se pueden escribir métodos de extensión estáticos, este código explota una laguna en los métodos de extensión. Esa laguna es que puede llamar a los métodos de extensión en objetos nulos sin obtener la excepción nula (a menos que acceda a algo mediante @this).

Así que aquí es cómo utilizaría la siguiente:

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(...) 

Ahora ¿por qué tomo una llamada al constructor por defecto como un ejemplo, y Y por qué no me acaba de regresar nueva T() en el primer fragmento de código sin hacer toda esa basura Expression? Bueno, hoy es tu día de suerte porque obtienes un 2fer. Como cualquier desarrollador de .NET avanzado sabe, la nueva T() es lenta porque genera una llamada a System.Activator que usa la reflexión para obtener el constructor predeterminado antes de llamarlo. ¡Maldito seas Microsoft! Sin embargo, mi código llama directamente al constructor predeterminado del objeto.

Las extensiones estáticas serían mejores que esto, pero los tiempos desesperados exigen medidas desesperadas.

Answer 9

En cuanto a los métodos de extensión, los métodos de extensión en sí mismos son estáticos; pero se invocan como si fueran métodos de instancia. Como una clase estática no es instanciable, nunca tendría una instancia de la clase para invocar un método de extensión. Por esta razón, el compilador no permite que se definan métodos de extensión para clases estáticas.

El Sr. Obnoxious escribió: "Como cualquier desarrollador .NET avanzado sabe, la nueva T() es lenta porque genera una llamada a System.Activator que utiliza la reflexión para obtener el constructor predeterminado antes de llamarlo".

New() se compila a la instrucción IL "newobj" si el tipo se conoce en tiempo de compilación. Newobj toma un constructor para la invocación directa. Las llamadas a System.Activator.CreateInstance() compilan a la instrucción IL "call" para invocar System.Activator.CreateInstance(). New() cuando se usa contra tipos genéricos dará como resultado una llamada a System.Activator.CreateInstance(). La publicación del Sr. Obnoxious no estaba clara en este punto ... y bueno, desagradable.

este código:

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

produce esta 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 

Answer 10

sí, en un sentido limitado.

public class DataSet : System.Data.DataSet 
{ 
    public static void SpecialMethod() { } 
} 

Esto funciona pero la consola no lo hace porque es estático.

public static class Console 
{  
    public static void WriteLine(String x) 
    { System.Console.WriteLine(x); } 

    public static void WriteBlueLine(String x) 
    { 
     System.Console.ForegroundColor = ConsoleColor.Blue; 
     System.Console.Write(.x);   
    } 
} 

Esto funciona porque siempre y cuando no esté en el mismo espacio de nombres. El problema es que debe escribir un método proxy estático para cada método que tenga System.Console. No es necesariamente algo malo, como se puede añadir algo como esto:

public static void WriteLine(String x) 
    { System.Console.WriteLine(x.Replace("Fck","****")); } 

o

public static void WriteLine(String x) 
    { 
     System.Console.ForegroundColor = ConsoleColor.Blue; 
     System.Console.WriteLine(x); 
    } 

La forma en que funciona es que usted engancha algo en el WriteLine estándar. Podría ser un conteo de líneas o filtro de palabras malas o lo que sea. Siempre que especifique Console en su espacio de nombres, diga WebProject1 e importe el espacio de nombres System, WebProject1.Console se elegirá sobre System.Console como predeterminado para esas clases en el espacio de nombres WebProject1. Por lo tanto, este código convertirá todas las llamadas de Console.WriteLine en azules en la medida en que nunca especificó System.Console.WriteLine.

Answer 11

Lo siguiente fue rechazado como edit a la respuesta de tvanfosson. Me pidieron que lo contribuyera como mi propia respuesta. Utilicé su sugerencia y terminé la implementación de un contenedor ConfigurationManager. En principio, simplemente llené el ... en la respuesta de tvanfosson.

No. Los métodos de extensión requieren una instancia de un objeto. Sin embargo, puede , escribir un contenedor estático en la interfaz ConfigurationManager . Si implementa el contenedor, no necesita una extensión ya que puede agregar el método directamente.

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

Answer 12

Puede usar un yeso en nula para hacer que funcione.

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

La extensión:

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

YourType:

public class YourType { } 

Answer 13

Me encontré sobre este tema al tratar de encontrar una respuesta a la misma pregunta del PO tenía. No encontré la respuesta que quería pero terminé haciendo esto.

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

y lo uso como esto:

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

Answer 14

A partir de C# 7 no es compatible. Sin embargo, hay discussions about integrating something like that in C#8 y proposals worth supporting.