Posso adicionar métodos de extensão a uma classe estática existente?

Sou fã de métodos de extensão em C #, mas não tive sucesso ao adicionar um método de extensão a uma classe estática, como o Console.

Por exemplo, se eu quiser adicionar uma extensão ao console, chamada 'WriteBlueLine', para que eu possa:

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

Eu tentei isso adicionando um método estático público local, com o Console como um parâmetro 'this' ... mas não há dados!

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

Isso não adicionou um método 'WriteBlueLine' ao Console ... estou fazendo errado? Ou pedindo o impossível?

Não. Os métodos de extensão requerem uma variável de instância (valor) para um objeto. No entanto, você pode escrever um invólucro estático em torno da ConfigurationManagerinterface. Se você implementar o wrapper, não precisará de um método de extensão, pois você pode simplesmente adicionar o método diretamente.

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

      .....

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

Você pode adicionar extensões estáticas às classes em c #? Não, mas você pode fazer isso:

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

Aqui está como isso funciona. Embora você não possa tecnicamente escrever métodos de extensão estáticos, esse código explora uma brecha nos métodos de extensão. Essa brecha é que você pode chamar métodos de extensão em objetos nulos sem obter a exceção nula (a menos que você acesse algo via @this).

Então, aqui está como você usaria isso:

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

Agora, por que escolhi chamar o construtor padrão como exemplo e AND por que não retornei o novo T () no primeiro trecho de código sem fazer todo esse lixo de expressão? Bem, hoje é seu dia de sorte, porque você recebe um 2fer. Como qualquer desenvolvedor .NET avançado sabe, o novo T () é lento porque gera uma chamada para System.Activator que usa reflexão para obter o construtor padrão antes de chamá-lo. Maldito seja, Microsoft! No entanto, meu código chama o construtor padrão do objeto diretamente.

Extensões estáticas seriam melhores do que isso, mas tempos desesperados exigem medidas desesperadas.

Não é possível.

E sim, acho que a MS cometeu um erro aqui.

Sua decisão não faz sentido e força os programadores a escrever (como descrito acima) uma classe de invólucro sem sentido.

Aqui está um bom exemplo: Tentando estender a classe estática de teste de Unidade MS Assert: Quero mais 1 método Assert AreEqual(x1,x2).

A única maneira de fazer isso é apontar para diferentes classes ou escrever um wrapper em torno de centenas de diferentes métodos Assert. Por quê!?

Se a decisão foi tomada para permitir extensões de instâncias, não vejo razão lógica para não permitir extensões estáticas. Os argumentos sobre o seccionamento de bibliotecas não se sustentam quando as instâncias podem ser estendidas.

Eu me deparei com esse tópico enquanto tentava encontrar uma resposta para a mesma pergunta que o OP tinha. Não encontrei a resposta que queria, mas acabei fazendo isso.

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

E eu uso assim:

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

Talvez você possa adicionar uma classe estática com seu namespace personalizado e o mesmo nome de classe:

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

A partir do C # 7, isso não é suportado. No entanto, há discussões sobre a integração de algo assim no C # 8 e propostas que valem a pena apoiar .

Não. As definições de método de extensão exigem uma instância do tipo que você está estendendo. É lamentável; Não sei por que é necessário ...

Quanto aos métodos de extensão, os próprios métodos de extensão são estáticos; mas eles são chamados como se fossem métodos de instância. Como uma classe estática não é instanciada, você nunca teria uma instância da classe para invocar um método de extensão. Por esse motivo, o compilador não permite que métodos de extensão sejam definidos para classes estáticas.

Obnoxious escreveu: "Como qualquer desenvolvedor .NET avançado sabe, o novo T () é lento porque gera uma chamada para System.Activator que usa reflexão para obter o construtor padrão antes de chamá-lo".

New () é compilado na instrução IL "newobj" se o tipo for conhecido no momento da compilação. Newobj usa um construtor para invocação direta. Chamadas para System.Activator.CreateInstance () compilam a instrução "call" de IL para chamar System.Activator.CreateInstance (). New () quando usado em tipos genéricos resultará em uma chamada para System.Activator.CreateInstance (). O post do Sr. Obnóxio não era claro sobre este ponto ... e bem, detestável.

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

produz este 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

Você não pode adicionar estática métodos a um tipo. Você só pode adicionar métodos (pseudo-) de instância a uma instância de um tipo.

O objetivo do thismodificador é dizer ao compilador C # para passar a instância no lado esquerdo do .como o primeiro parâmetro do método static / extension.

No caso de adicionar métodos estáticos a um tipo, não há instância a ser transmitida para o primeiro parâmetro.

Tentei fazer isso com o System.Environment quando estava aprendendo métodos de extensão e não obtive sucesso. O motivo é, como outros mencionam, porque os métodos de extensão requerem uma instância da classe.

Não é possível escrever um método de extensão, no entanto, é possível imitar o comportamento que você está solicitando.

using FooConsole = System.Console;

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

Isso permitirá que você chame Console.WriteBlueLine (fooText) em outras classes. Se as outras classes quiserem acessar as outras funções estáticas do Console, elas deverão ser explicitamente referenciadas através de seu espaço para nome.

Você sempre pode adicionar todos os métodos à classe de substituição se desejar tê-los em um só lugar.

Então você teria algo como

using FooConsole = System.Console;

public static class Console
{
    public static void WriteBlueLine(string text)
    {
        FooConsole.ForegroundColor = ConsoleColor.Blue;
        FooConsole.WriteLine(text);
        FooConsole.ResetColor();
    }
    public static void WriteLine(string text)
    {
        FooConsole.WriteLine(text);
    }
...etc.
}

Isso forneceria o tipo de comportamento que você está procurando.

* Nota O console precisará ser adicionado através do espaço para nome em que você o colocou.

sim, em um sentido limitado.

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

Isso funciona, mas o console não, porque é 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);           
    }
}

Isso funciona porque contanto que não esteja no mesmo espaço para nome. O problema é que você precisa escrever um método estático de proxy para cada método que o System.Console possui. Não é necessariamente uma coisa ruim, pois você pode adicionar algo como isto:

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

ou

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

O modo como funciona é que você conecta algo ao WriteLine padrão. Pode ser uma contagem de linhas ou um filtro de palavras incorretas ou qualquer outra coisa. Sempre que você especificar o Console no seu espaço para nome, diga WebProject1 e importe o espaço para nome System, WebProject1.Console será escolhido sobre System.Console como padrão para as classes no espaço para nome WebProject1. Portanto, esse código transformará todas as chamadas Console.WriteLine em azul, na medida em que você nunca especificou System.Console.WriteLine.

O seguinte foi rejeitado como uma edição da resposta de tvanfosson. Fui convidado a contribuir como minha própria resposta. Usei sua sugestão e finalizei a implementação de um ConfigurationManagerwrapper. Em princípio, simplesmente preenchi a ...resposta de tvanfosson.

Não. Os métodos de extensão requerem uma instância de um objeto. No entanto, você pode escrever um invólucro estático na interface ConfigurationManager. Se você implementar o wrapper, não precisará de um método de extensão, pois você pode adicionar o método diretamente.

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

Você pode usar uma conversão em null para fazê-lo funcionar.

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

A extensão:

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

Seu tipo:

public class YourType { }

Você pode fazer isso se estiver disposto a "frig" um pouco, criando uma variável da classe estática e atribuindo-a a null. No entanto, esse método não estaria disponível para chamadas estáticas na classe, portanto, não tenho certeza de quanto uso seria:

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