Могу ли я добавить методы расширения к существующему статическому классу?

Вы не можете добавить к типу методы статический. Вы можете добавлять только (псевдо) методы экземпляра к экземпляру типа.

Смысл модификатора this - указать компилятору C# передать экземпляр слева от . в качестве первого параметра статического метода / метода расширения.

В случае добавления статических методов к типу для первого параметра нет экземпляра.

Я пытался сделать это с помощью System.Environment, когда изучал методы расширения, и безуспешно. Причина в том, как упоминают другие, потому что методы расширения требуют экземпляра класса.

Неа. Для определений методов расширения требуется экземпляр расширяемого типа. Это прискорбно; Не знаю, зачем это нужно ...

Нет. Методы расширения требуют наличия переменной экземпляра (значения) для объекта. Однако вы можете написать статическую оболочку для интерфейса ConfigurationManager. Если вы реализуете оболочку, вам не нужен метод расширения, поскольку вы можете просто добавить метод напрямую.

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

      .....

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

Это невозможно.

И да, я думаю, что М.С. здесь ошибся.

Их решение не имеет смысла и заставляет программистов писать (как описано выше) бессмысленный класс-оболочку.

Вот хороший пример: Попытка расширить класс статического тестирования MS Unit Assert: мне нужен еще 1 метод Assert AreEqual(x1,x2).

Единственный способ сделать это - указать на разные классы или написать оболочку для сотен различных методов Assert. Почему!?

Если было принято решение разрешить расширения экземпляров, я не вижу логической причины не разрешать статические расширения. Аргументы о секционировании библиотек не выдерживают критики, если экземпляры могут быть расширены.

Возможно, вы могли бы добавить статический класс с вашим пользовательским пространством имен и тем же именем класса:

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

Вы МОЖЕТЕ сделать это, если хотите немного «поиграть», создав переменную статического класса и присвоив ей значение null. Однако этот метод не будет доступен для статических вызовов класса, поэтому не уверен, насколько он будет полезен:

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

Можете ли вы добавить статические расширения к классам на C#? Нет, но вы можете это сделать:

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

Вот как это работает. Хотя технически вы не можете написать статические методы расширения, вместо этого этот код использует лазейку в методах расширения. Эта лазейка заключается в том, что вы можете вызывать методы расширения для нулевых объектов без получения нулевого исключения (если вы не обращаетесь к чему-либо через @this).

Вот как это можно использовать:

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

Теперь ПОЧЕМУ я выбрал вызов конструктора по умолчанию в качестве примера, и почему бы мне просто не вернуть new T () в первом фрагменте кода, не выполняя весь этот мусор Expression? Что ж, сегодня твой счастливый день, потому что ты получишь 2-е место. Как известно любому опытному разработчику .NET, new T () работает медленно, потому что он генерирует вызов System.Activator, который использует отражение для получения конструктора по умолчанию перед его вызовом. Черт побери, Microsoft! Однако мой код напрямую вызывает конструктор объекта по умолчанию.

Статические расширения были бы лучше, чем это, но отчаянные времена требуют отчаянных мер.

Что касается методов расширения, сами методы расширения являются статическими; но они вызываются, как если бы они были методами экземпляра. Поскольку статический класс не может быть создан, у вас никогда не будет экземпляра класса для вызова метода расширения. По этой причине компилятор не позволяет определять методы расширения для статических классов.

Г-н Obnoxious писал: «Как знает любой продвинутый .NET-разработчик, new T () работает медленно, потому что он генерирует вызов System.Activator, который использует отражение для получения конструктора по умолчанию перед его вызовом».

New () компилируется в инструкцию IL "newobj", если тип известен во время компиляции. Newobj принимает конструктор для прямого вызова. Вызовы System.Activator.CreateInstance () компилируются с инструкцией «call» IL для вызова System.Activator.CreateInstance (). New () при использовании с универсальными типами приведет к вызову System.Activator.CreateInstance (). Сообщение г. Obnoxious было неясным по этому поводу ... и, в общем, неприятным.

Этот код:

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

производит этот 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

да, в ограниченном смысле.

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

Это работает, но консоль - нет, потому что она статична.

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

Это работает, потому что до тех пор, пока он не находится в том же пространстве имен. Проблема в том, что вам нужно написать статический метод прокси для каждого метода, который есть в System.Console. Это не обязательно плохо, так как вы можете добавить что-то вроде этого:

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

или же

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

Это работает так: вы подключаете что-то к стандартной WriteLine. Это может быть счетчик строк, фильтр плохих слов или что-то еще. Всякий раз, когда вы просто указываете Console в своем пространстве имен, скажите WebProject1 и импортируете пространство имен System, WebProject1.Console будет выбираться вместо System.Console по умолчанию для этих классов в пространстве имен WebProject1. Таким образом, этот код превратит все вызовы Console.WriteLine в синий цвет, поскольку вы никогда не указали System.Console.WriteLine.

Следующее было отклонено как редактировать на ответ tvanfosson. Меня попросили внести это как мой собственный ответ. Я воспользовался его предложением и закончил реализацию оболочки ConfigurationManager. В принципе я просто заполнил ... в ответе tvanfosson.

No. Extension methods require an instance of an object. You can however, write a static wrapper around the ConfigurationManager interface. If you implement the wrapper, you don't need an extension method since you can just add the method directly.

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

Вы можете использовать приведение к нулю, чтобы заставить его работать.

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

Расширение:

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

Твой тип:

public class YourType { }

Я наткнулся на эту ветку, пытаясь найти ответ на тот же вопрос, который был у OP. Я не нашел ответа, который хотел, но в итоге сделал это.

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

А я использую это так:

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

В C# 7 это не поддерживается. Однако есть обсуждение интеграции чего-то подобного в C# 8 и предложения заслуживают поддержки.

Невозможно написать метод расширения, однако можно имитировать запрашиваемое поведение.

using FooConsole = System.Console;

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

Это позволит вам вызывать Console.WriteBlueLine (fooText) в других классах. Если другие классы хотят получить доступ к другим статическим функциям консоли, на них нужно будет явно ссылаться через их пространство имен.

Вы всегда можете добавить все методы в замещающий класс, если хотите, чтобы все они были в одном месте.

Итак, у вас будет что-то вроде

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

Это обеспечит то поведение, которое вы ищете.

* Примечание. Консоль должна быть добавлена ​​через пространство имен, в которое вы ее поместили.