ฉันมี C ++ DLL ของบุคคลที่สามที่ฉันเรียกจาก C #

วิธีการเป็นแบบคงที่

ฉันต้องการสรุปเพื่อทำการทดสอบหน่วยดังนั้นฉันจึงสร้างอินเทอร์เฟซด้วยวิธีการแบบคงที่ แต่ตอนนี้ข้อผิดพลาดของโปรแกรมของฉันกับ:

ตัวปรับแต่ง 'คงที่' ไม่ถูกต้องสำหรับรายการนี้

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

ฉันจะบรรลุนามธรรมนี้ได้อย่างไร

รหัสของฉันมีลักษณะเช่นนี้

private IInterfaceWithStaticMethods MyInterface;

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

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

คุณไม่สามารถกำหนดสมาชิกแบบคงที่บนอินเทอร์เฟซใน C # อินเตอร์เฟซที่เป็นสัญญาสำหรับอินสแตนซ์

ฉันขอแนะนำให้สร้างอินเทอร์เฟซตามที่คุณเป็นอยู่ในขณะนี้ แต่ไม่มีคีย์เวิร์ดแบบคงที่ จากนั้นสร้างคลาสStaticIInterfaceที่ใช้อินเทอร์เฟซและเรียกใช้เมธอด C ++ แบบคงที่ ในการทดสอบหน่วยให้สร้างคลาสอื่นFakeIInterfaceที่ใช้อินเทอร์เฟซเช่นกัน แต่ทำในสิ่งที่คุณต้องการเพื่อจัดการกับการทดสอบหน่วยของคุณ

เมื่อคุณกำหนด 2 คลาสนี้แล้วคุณสามารถสร้างคลาสที่คุณต้องการสำหรับสภาพแวดล้อมของคุณและส่งต่อไปยังคอนMyClassสตรัคเตอร์ของ

อินเทอร์เฟซต้องไม่มีสมาชิกแบบคงที่และไม่สามารถใช้วิธีการแบบคงที่เป็นการใช้วิธีการอินเทอร์เฟซได้

สิ่งที่คุณทำได้คือใช้อินเทอร์เฟซที่ชัดเจน:

public interface IMyInterface
{
    void MyMethod();
}

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

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

หรือคุณสามารถใช้วิธีการไม่คงที่แม้ว่าพวกเขาจะไม่เข้าถึงสมาชิกเฉพาะอินสแตนซ์ก็ตาม

สมาชิกแบบคงที่ถูกต้องตามกฎหมายใน CLR ไม่ใช่ C #

คุณสามารถใช้กาวบางส่วนใน IL เพื่อเชื่อมโยงรายละเอียดการใช้งาน

ไม่แน่ใจว่าคอมไพเลอร์ C # จะอนุญาตให้เรียกมันได้หรือไม่?

ดู: 8.9.4 นิยามประเภทอินเทอร์เฟซ ECMA-335

ประเภทอินเทอร์เฟซจำเป็นต้องไม่สมบูรณ์เนื่องจากไม่ได้พูดอะไรเกี่ยวกับการแสดงค่าของประเภทอินเทอร์เฟซ ด้วยเหตุนี้ข้อกำหนดประเภทอินเทอร์เฟซจะไม่ให้คำจำกัดความฟิลด์สำหรับค่าของประเภทอินเทอร์เฟซ (เช่นฟิลด์อินสแตนซ์) แม้ว่าจะสามารถประกาศฟิลด์แบบคงที่ได้ (ดู§8.4.3)

ในทำนองเดียวกันนิยามประเภทอินเทอร์เฟซจะต้องไม่จัดเตรียมการใช้งานสำหรับวิธีการใด ๆ กับค่าของประเภท อย่างไรก็ตามคำจำกัดความประเภทอินเทอร์เฟซสามารถและโดยปกติจะกำหนดสัญญาวิธีการ (ชื่อวิธีการและลายเซ็นวิธีการ) ที่จะนำไปใช้โดยประเภทการสนับสนุน นิยามประเภทอินเทอร์เฟซสามารถกำหนดและใช้วิธีการแบบคงที่ (ดู see8.4.3) เนื่องจากวิธีการแบบคงที่เชื่อมโยงกับชนิดของอินเทอร์เฟซเองแทนที่จะเป็นค่าใด ๆ ของชนิด

คุณสามารถกำหนดวิธีการแบบคงที่ใน c # 8 แต่คุณต้องประกาศเนื้อความเริ่มต้นสำหรับมัน

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

หรือถ้าคุณไม่ต้องการมีเนื้อหาเริ่มต้นใด ๆ ก็ให้โยนข้อยกเว้น:

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

คุณสามารถเรียกมันด้วยการสะท้อน:

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

C # "Ten" จะอนุญาตให้สมาชิกคงที่บนอินเทอร์เฟซควบคู่ไปกับบทบาท นับเป็นก้าวที่ยิ่งใหญ่ซึ่งจะช่วยให้ตัวดำเนินการทั่วไปทำงานหนักเกินไปโดยไม่ต้องใช้การสะท้อนใด ๆ นี่คือตัวอย่างตัวอย่างวิธีการทำงานโดยใช้ตัวอย่าง monoid แบบคลาสสิกซึ่งเป็นเพียงศัพท์แสงสำหรับพูดว่า "สิ่งที่สามารถเพิ่มได้" นำมาโดยตรงจากMads Torgersen: C # สู่อนาคต :

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

แหล่งข้อมูลเพิ่มเติม:

Jeremy Bytes: C # 8 อินเทอร์เฟซสมาชิกแบบคงที่

แก้ไข

โพสต์นี้ระบุไว้เดิมสมาชิกคงที่ของอินเทอร์เฟซจะถูกเพิ่มในC # 8.0ซึ่งไม่เป็นความจริงฉันตีความคำพูดของ Mads Torgersen ในวิดีโอผิด คู่มือ C # 8.0 อย่างเป็นทางการยังไม่ได้พูดถึงสมาชิกอินเทอร์เฟซแบบคงที่ แต่เป็นที่ชัดเจนว่าพวกเขาได้ดำเนินการมานานแล้ว

สาเหตุที่คุณไม่สามารถใช้วิธีคงที่บนอินเทอร์เฟซได้: เหตุใด C # จึงไม่อนุญาตให้ใช้วิธีการแบบคงที่ในการใช้งานอินเทอร์เฟซ

อย่างไรก็ตามฉันขอแนะนำให้ลบวิธีการแบบคงที่เพื่อสนับสนุนวิธีการอินสแตนซ์ หากเป็นไปไม่ได้คุณสามารถรวมการเรียกเมธอดแบบคงที่ไว้ในเมธอดอินสแตนซ์จากนั้นคุณสามารถสร้างอินเทอร์เฟซสำหรับสิ่งนั้นและเรียกใช้การทดสอบหน่วยของคุณจากสิ่งนั้น

กล่าวคือ

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

C # 8 อนุญาตให้สมาชิกคงที่บนอินเทอร์เฟซ

เริ่มต้นด้วย C # 8.0 อินเทอร์เฟซอาจกำหนดการใช้งานเริ่มต้นสำหรับสมาชิก นอกจากนี้ยังอาจกำหนดสมาชิกแบบคงที่เพื่อจัดเตรียมการใช้งานเดียวสำหรับฟังก์ชันการทำงานทั่วไป

อินเทอร์เฟซ (อ้างอิง C #)

เช่น

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

var something = IGetSomething.Something;