Tôi có thể thêm các phương pháp mở rộng cho một lớp tĩnh hiện hành?

Tôi là người hâm mộ các phương thức mở rộng trong C #, nhưng chưa có thành công nào khi thêm phương thức mở rộng vào lớp tĩnh, chẳng hạn như Bảng điều khiển.

Ví dụ: nếu tôi muốn thêm tiện ích mở rộng vào Bảng điều khiển, được gọi là 'WriteBlueLine', để tôi có thể đi:

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

Tôi đã thử điều này bằng cách thêm một phương thức tĩnh cục bộ, công khai, với Console là tham số 'this' ... nhưng không có xúc xắc!

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

Điều này đã không thêm phương thức 'WriteBlueLine' vào Bảng điều khiển ... tôi có đang làm sai không? Hoặc yêu cầu những điều không thể?

Không. Các phương thức mở rộng yêu cầu một biến đối tượng (giá trị) cho một đối tượng. Tuy nhiên, bạn có thể viết một trình bao bọc tĩnh xung quanh ConfigurationManagergiao diện. Nếu bạn triển khai trình bao bọc, bạn không cần một phương thức mở rộng vì bạn chỉ có thể thêm phương thức trực tiếp.

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

      .....

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

Bạn có thể thêm các phần mở rộng tĩnh cho các lớp trong C # không? Không nhưng bạn có thể làm điều này:

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

Đây là cách nó hoạt động. Mặc dù về mặt kỹ thuật, bạn không thể viết các phương thức mở rộng tĩnh, thay vào đó, mã này khai thác lỗ hổng trong các phương thức mở rộng. Lỗ hổng đó là bạn có thể gọi các phương thức mở rộng trên các đối tượng null mà không nhận được ngoại lệ null (trừ khi bạn truy cập bất cứ thứ gì qua @this).

Vì vậy, đây là cách bạn sẽ sử dụng này:

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

Bây giờ TẠI SAO tôi đã chọn gọi hàm tạo mặc định làm ví dụ và VÀ tại sao tôi không trả lại T () mới trong đoạn mã đầu tiên mà không thực hiện tất cả rác biểu thức đó? Vâng, ngày hôm nay là ngày may mắn của bạn vì bạn nhận được 2fer. Như bất kỳ nhà phát triển .NET nâng cao nào cũng biết, T () mới chậm vì nó tạo ra một cuộc gọi đến System.Activator sử dụng sự phản chiếu để có được hàm tạo mặc định trước khi gọi nó. Chết tiệt bạn Microsoft! Tuy nhiên, mã của tôi gọi hàm tạo mặc định của đối tượng trực tiếp.

mở rộng tĩnh sẽ tốt hơn thế này nhưng thời gian tuyệt vọng kêu gọi các biện pháp tuyệt vọng.

Điều đó là không thể.

Và vâng tôi nghĩ MS đã phạm sai lầm ở đây.

Quyết định của họ không có ý nghĩa và buộc các lập trình viên phải viết (như được mô tả ở trên) một lớp bao bọc vô nghĩa.

Đây là một ví dụ điển hình: Cố gắng mở rộng lớp thử nghiệm Đơn vị MS tĩnh Khẳng định: Tôi muốn thêm 1 phương thức Khẳng định AreEqual(x1,x2).

Cách duy nhất để làm điều này là trỏ đến các lớp khác nhau hoặc viết một trình bao bọc khoảng 100 phương thức Khẳng định khác nhau. Tại sao!?

Nếu quyết định được đưa ra để cho phép các phần mở rộng của phiên bản, tôi thấy không có lý do hợp lý nào để không cho phép các phần mở rộng tĩnh. Các đối số về các thư viện phân đoạn không đứng lên một khi các thể hiện có thể được mở rộng.

Tôi tình cờ tìm thấy chủ đề này trong khi cố gắng tìm câu trả lời cho cùng một câu hỏi mà OP có. Tôi đã không tìm thấy câu trả lời mình muốn nhưng cuối cùng tôi đã làm điều này.

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

Và tôi sử dụng nó như thế này:

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

Có lẽ bạn có thể thêm một lớp tĩnh với không gian tên tùy chỉnh và cùng tên lớp:

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

Kể từ C # 7, điều này không được hỗ trợ. Tuy nhiên, có các cuộc thảo luận về việc tích hợp một cái gì đó tương tự như vậy trong C # 8 và các đề xuất đáng được hỗ trợ .

Không. Mở rộng định nghĩa phương pháp đòi hỏi một thể hiện của kiểu bạn đang mở rộng. Nó không may; Tôi không chắc tại sao lại cần ...

Đối với phương pháp khuyến nông, phương pháp khuyến nông chính họ là tĩnh; nhưng chúng được gọi như thể chúng là các phương thức thể hiện. Vì một lớp tĩnh là không thể thực hiện được, nên bạn sẽ không bao giờ có một thể hiện của lớp để gọi một phương thức mở rộng từ đó. Vì lý do này, trình biên dịch không cho phép các phương thức mở rộng được định nghĩa cho các lớp tĩnh.

Ông Obnoxious đã viết: "Như bất kỳ nhà phát triển .NET nâng cao nào cũng biết, T () mới chậm vì nó tạo ra một cuộc gọi đến System.Activator sử dụng sự phản chiếu để có được hàm tạo mặc định trước khi gọi nó".

New () được biên dịch theo hướng dẫn "newobj" của IL nếu loại được biết tại thời điểm biên dịch. Newobj có một hàm tạo để gọi trực tiếp. Các lệnh gọi tới System.Activator.CreateInstance () biên dịch theo lệnh "gọi" IL để gọi System.Activator.CreateInstance (). Mới () khi được sử dụng đối với các loại chung sẽ dẫn đến lệnh gọi System.Activator.CreateInstance (). Bài đăng của ông Obnoxious không rõ ràng về điểm này ... và tốt, đáng ghét.

Mã này:

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

sản xuất IL này:

  .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

Bạn không thể thêm tĩnh phương thức vào một loại. Bạn chỉ có thể thêm các phương thức cá thể (giả cho) vào một thể hiện của một loại.

Điểm của công cụ thissửa đổi là yêu cầu trình biên dịch C # vượt qua thể hiện ở phía bên trái của. tham số đầu tiên làm phương thức tĩnh / mở rộng.

Trong trường hợp thêm các phương thức tĩnh vào một kiểu, không có trường hợp nào chuyển cho tham số đầu tiên.

Tôi đã thử làm điều này với System.EnFE trở lại khi tôi đang học các phương pháp mở rộng và không thành công. Lý do là, như những người khác đề cập, bởi vì các phương thức mở rộng yêu cầu một thể hiện của lớp.

Không thể viết một phương thức mở rộng, tuy nhiên có thể bắt chước hành vi mà bạn đang yêu cầu.

using FooConsole = System.Console;

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

Điều này sẽ cho phép bạn gọi Console.WriteBlueLine (fooText) trong các lớp khác. Nếu các lớp khác muốn truy cập vào các hàm tĩnh khác của Console, chúng sẽ phải được tham chiếu rõ ràng thông qua không gian tên của chúng.

Bạn luôn có thể thêm tất cả các phương thức vào lớp thay thế nếu bạn muốn có tất cả chúng ở một nơi.

Vì vậy, bạn sẽ có một cái gì đó như

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

Điều này sẽ cung cấp loại hành vi bạn đang tìm kiếm.

* Note Console sẽ phải được thêm vào thông qua không gian tên mà bạn đặt nó vào.

vâng, trong một ý nghĩa hạn chế.

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

Điều này hoạt động nhưng Console không vì nó tĩnh.

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

Điều này hoạt động vì miễn là nó không nằm trên cùng một không gian tên. Vấn đề là bạn phải viết một phương thức tĩnh proxy cho mọi phương thức mà System.Console có. Nó không hẳn là một điều xấu vì bạn có thể thêm một cái gì đó như thế này:

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

hoặc là

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

Cách thức hoạt động là bạn móc thứ gì đó vào WriteLine tiêu chuẩn. Nó có thể là một dòng đếm hoặc bộ lọc từ xấu hoặc bất cứ điều gì. Bất cứ khi nào bạn chỉ định Bảng điều khiển trong không gian tên của bạn nói WebProject1 và nhập Hệ thống không gian tên, WebProject1.Console sẽ được chọn trên System.Console làm mặc định cho các lớp đó trong không gian tên WebProject1. Vì vậy, mã này sẽ biến tất cả các cuộc gọi Console.WriteLine thành màu xanh trong khi bạn chưa bao giờ chỉ định System.Console.WriteLine.

Sau đây đã bị từ chối như là một chỉnh sửa cho câu trả lời của tvanfosson. Tôi đã được yêu cầu đóng góp nó như là câu trả lời của riêng tôi. Tôi đã sử dụng đề nghị của anh ấy và hoàn thành việc thực hiện một ConfigurationManagertrình bao bọc. Về nguyên tắc, tôi chỉ cần điền ...vào câu trả lời của tvanfosson.

Không. Các phương thức mở rộng yêu cầu một thể hiện của một đối tượng. Tuy nhiên, bạn có thể viết một trình bao bọc tĩnh xung quanh giao diện Trình quản lý cấu hình. Nếu bạn triển khai trình bao bọc, bạn không cần một phương thức mở rộng vì bạn chỉ có thể thêm phương thức trực tiếp.

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

Bạn có thể sử dụng cast trên null để làm cho nó hoạt động.

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

Phần mở rộng:

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

Kiểu của bạn:

public class YourType { }

Bạn CÓ THỂ làm điều này nếu bạn sẵn sàng "frig" nó một chút bằng cách tạo một biến của lớp tĩnh và gán nó thành null. Tuy nhiên, phương thức này sẽ không có sẵn cho các cuộc gọi tĩnh trên lớp, vì vậy không chắc nó sẽ sử dụng bao nhiêu:

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