Tôi có một C ++ DLL của bên thứ ba mà tôi gọi từ C #.

Các phương thức là tĩnh.

Tôi muốn tóm tắt nó để thực hiện một số thử nghiệm đơn vị, vì vậy tôi đã tạo một giao diện với các phương thức tĩnh trong đó nhưng bây giờ chương trình của tôi bị lỗi với:

Công cụ sửa đổi 'tĩnh' không hợp lệ cho mục này

MyMethod cannot be accessed with an instance reference; qualify it with a type name instead

Làm thế nào tôi có thể đạt được sự trừu tượng này?

Mã của tôi trông như thế này

private IInterfaceWithStaticMethods MyInterface;

public MyClass(IInterfaceWithStaticMethods myInterface)
{
  this.MyInterface = myInterface;
}

public void MyMethod()
{
  MyInterface.StaticMethod();
}

Bạn không thể xác định các thành viên tĩnh trên giao diện trong C #. Giao diện là một hợp đồng cho các phiên bản .

Tôi khuyên bạn nên tạo giao diện như hiện tại nhưng không có từ khóa tĩnh. Sau đó, tạo một lớp StaticIInterfacethực thi giao diện và gọi các phương thức C ++ tĩnh. Để thực hiện kiểm thử đơn vị, hãy tạo một lớp khác FakeIInterface, lớp này cũng triển khai giao diện, nhưng thực hiện những gì bạn cần để xử lý các kiểm thử đơn vị của mình.

Khi bạn đã xác định 2 lớp này, bạn có thể tạo một lớp bạn cần cho môi trường của mình và chuyển nó cho hàm tạo MyClasscủa.

Các giao diện không thể có các thành viên tĩnh và các phương thức tĩnh không thể được sử dụng để triển khai các phương thức giao diện.

Những gì bạn có thể làm là sử dụng triển khai giao diện rõ ràng:

public interface IMyInterface
{
    void MyMethod();
}

public class MyClass : IMyInterface
{
    static void MyMethod()
    {
    }

    void IMyInterface.MyMethod()
    {
        MyClass.MyMethod();
    }
}

Ngoài ra, bạn có thể chỉ cần sử dụng các phương thức không tĩnh, ngay cả khi chúng không truy cập vào bất kỳ thành viên cụ thể nào.

Các thành viên tĩnh hoàn toàn hợp pháp trong CLR, chỉ không phải C #.

Bạn có thể triển khai một số keo trong IL để liên kết các chi tiết thực hiện.

Không chắc liệu trình biên dịch C # có cho phép gọi chúng hay không?

Xem: 8.9.4 Định nghĩa kiểu giao diện ECMA-335.

Các kiểu giao diện nhất thiết không hoàn chỉnh vì chúng không nói gì về việc biểu diễn các giá trị của kiểu giao diện. Vì lý do này, một định nghĩa kiểu giao diện sẽ không cung cấp định nghĩa trường cho các giá trị của kiểu giao diện (ví dụ, trường thể hiện), mặc dù nó có thể khai báo các trường tĩnh (xem §8.4.3).

Tương tự, một định nghĩa kiểu giao diện sẽ không cung cấp triển khai cho bất kỳ phương pháp nào trên các giá trị của kiểu của nó. Tuy nhiên, định nghĩa kiểu giao diện có thể — và thường là — xác định các hợp đồng phương thức (tên phương thức và chữ ký phương thức) sẽ được thực hiện bởi các kiểu hỗ trợ. Định nghĩa kiểu giao diện có thể xác định và triển khai các phương thức tĩnh (xem §8.4.3) vì các phương thức tĩnh được liên kết với chính kiểu giao diện chứ không phải với bất kỳ giá trị nào của kiểu.

Bạn có thể định nghĩa các phương thức tĩnh trong c # 8 nhưng bạn phải khai báo một phần thân mặc định cho nó.

    public interface IMyInterface
    {
          static string GetHello() =>  "Default Hello from interface" ;
          static void WriteWorld() => Console.WriteLine("Writing World from interface");
    }

hoặc nếu bạn không muốn có bất kỳ nội dung mặc định nào, chỉ cần đặt một ngoại lệ:

    public interface IMyInterface
    {
          static string GetHello() =>  throw new NotImplementedException() ;
          static void WriteWorld() => throw new NotImplementedException();
    }

Bạn có thể gọi nó với sự phản chiếu:

MyInterface.GetType().InvokeMember("StaticMethod", BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, null);

C # "Ten" sẽ cho phép các thành viên tĩnh trên các giao diện , cùng với các vai trò. Đây là một bước tiến vượt bậc, nó cũng sẽ cho phép nạp chồng toán tử chung mà không cần sử dụng phản xạ. Đây là một đoạn mã ví dụ về cách hoạt động của nó, sử dụng ví dụ monoid cổ điển, chỉ là biệt ngữ để nói "thứ gì đó có thể được thêm vào". Lấy trực tiếp từ Mads Torgersen: C # vào tương lai :

interface IMonoid<T>
{
    static T Zero { get; }
    static T operator +(T t1, T t2);
}

public static T AddAll<T>(T[] ts) where T : IMonoid<T>
{
    T result = T.Zero;
    foreach (T t in ts) { result += t; }
    return result;
}

role IntAddMonoid extends int : IMonoid<int>
{
    public static int Zero => 0;
}

IntAddMonoid[] values = new int[] {1, 2, 4, 8, 16, 32};
int sixtyThree = AddAll<IntAddMonoid>(values); // == 63

Các nguồn bổ sung:

Jeremy Bytes: Giao diện C # 8 thành viên tĩnh

BIÊN TẬP

Bài viết này ban đầu nói giao diện thành viên tĩnh sẽ được thêm vào trong C # 8.0 , điều này không đúng, tôi đã hiểu sai lời của Mads Torgersen trong video. Hướng dẫn C # 8.0 chính thức chưa nói về các thành viên giao diện tĩnh, nhưng rõ ràng là họ đã làm việc trên nó từ khá lâu rồi.

Về lý do tại sao bạn không thể có một phương thức tĩnh trên một giao diện: Tại sao C # không cho phép các phương thức tĩnh triển khai một giao diện?

Tuy nhiên, tôi khuyên bạn nên loại bỏ các phương thức tĩnh thay vì các phương thức instance. Nếu điều đó là không thể, thì bạn có thể bọc các lệnh gọi phương thức tĩnh bên trong một phương thức cá thể, sau đó bạn có thể tạo một giao diện cho điều đó và chạy các bài kiểm tra đơn vị của bạn từ đó.

I E

public static class MyStaticClass
{
    public static void MyStaticMethod()
    {...}
}

public interface IStaticWrapper
{
    void MyMethod();
}

public class MyClass : IStaticWrapper
{
    public void MyMethod()
    {
        MyStaticClass.MyStaticMethod();
    }
}

C # 8 cho phép các thành viên tĩnh trên giao diện

Bắt đầu với C # 8.0, một giao diện có thể xác định một cài đặt mặc định cho các thành viên. Nó cũng có thể xác định các thành viên tĩnh để cung cấp một triển khai duy nhất cho chức năng chung.

giao diện (Tham chiếu C #)

Ví dụ

public interface IGetSomething
{
    public static string Something = "something";
}

var something = IGetSomething.Something;