मैं इंटरफ़ेस पर स्थिर तरीके कैसे लागू कर सकता हूं?

Question 1

मेरे पास 3rd पार्टी 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();
}

Question 2

आप C # में इंटरफ़ेस पर स्थिर सदस्यों को परिभाषित नहीं कर सकते। एक इंटरफ़ेस उदाहरणों के लिए एक अनुबंध है ।

जैसा कि आप वर्तमान में हैं, मैं इंटरफ़ेस बनाने की सलाह दूंगा, लेकिन स्थिर कीवर्ड के बिना। फिर एक वर्ग बनाएं StaticIInterfaceजो इंटरफ़ेस को लागू करता है और स्थिर C ++ विधियों को कॉल करता है। यूनिट टेस्टिंग करने के लिए, एक अन्य क्लास बनाएं FakeIInterface, जो कि इंटरफ़ेस को लागू करता है, लेकिन आपको अपने यूनिट टेस्ट को संभालने की आवश्यकता है।

एक बार जब आपके पास इन 2 वर्गों को परिभाषित कर दिया जाता है, तो आप अपने पर्यावरण के लिए आवश्यक एक बना सकते हैं, और इसे पास करने वाले के पास भेज सकते हैं MyClass।

Question 3

इंटरफेस में स्थिर सदस्य नहीं हो सकते हैं और इंटरफ़ेस विधियों के कार्यान्वयन के रूप में स्थिर तरीकों का उपयोग नहीं किया जा सकता है।

आप क्या कर सकते हैं एक स्पष्ट इंटरफ़ेस कार्यान्वयन का उपयोग करें:

public interface IMyInterface
{
    void MyMethod();
}

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

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

वैकल्पिक रूप से, आप केवल गैर-स्थैतिक तरीकों का उपयोग कर सकते हैं, भले ही वे किसी भी उदाहरण के विशिष्ट सदस्यों तक न पहुंचें।

Question 4

CLR में स्टेटिक सदस्य पूरी तरह से कानूनी हैं, सिर्फ C # नहीं।

आप कार्यान्वयन विवरण को लिंक करने के लिए IL में कुछ गोंद लागू कर सकते हैं।

निश्चित नहीं है कि क्या C # कंपाइलर उन्हें कॉल करने की अनुमति देगा?

देखें: 8.9.4 इंटरफ़ेस प्रकार की परिभाषा ECMA-335।

इंटरफ़ेस प्रकार आवश्यक रूप से अपूर्ण हैं क्योंकि वे इंटरफ़ेस प्रकार के मूल्यों के प्रतिनिधित्व के बारे में कुछ नहीं कहते हैं। इस कारण से, एक इंटरफ़ेस प्रकार की परिभाषा इंटरफ़ेस प्रकार (यानी, उदाहरण फ़ील्ड) के मानों के लिए फ़ील्ड परिभाषा प्रदान नहीं करेगी, हालांकि यह स्थिर फ़ील्ड घोषित कर सकती है (देखें .48.4.3)।

इसी प्रकार, एक इंटरफ़ेस प्रकार की परिभाषा अपने प्रकार के मूल्यों पर किसी भी तरीके के लिए कार्यान्वयन प्रदान नहीं करेगी। हालाँकि, एक इंटरफ़ेस प्रकार की परिभाषा हो सकती है - और आमतौर पर विधि अनुबंधों (विधि नाम और विधि हस्ताक्षर) को परिभाषित करती है जिन्हें समर्थन प्रकारों द्वारा लागू किया जाएगा। एक इंटरफ़ेस प्रकार की परिभाषा स्थिर तरीकों को परिभाषित और कार्यान्वित कर सकती है (देखें .38.4.3) क्योंकि स्थिर तरीके इंटरफ़ेस के प्रकार से जुड़े होते हैं बजाय किसी प्रकार के मूल्य के।

Question 5

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

Question 6

आप इसे प्रतिबिंब के साथ आमंत्रित कर सकते हैं:

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

Question 7

सी # "दस" भूमिकाओं के साथ-साथ इंटरफेस पर स्थिर सदस्यों को अनुमति देने जा रहा है । यह एक बहुत बड़ा कदम है, यह सामान्य ऑपरेटर को ओवरलोडिंग की अनुमति देगा, बिना किसी प्रतिबिंब के उपयोग के। यहां एक उदाहरण स्निपेट है कि यह कैसे काम करता है, क्लासिक मोनोइड उदाहरण का उपयोग करते हुए, जो "कुछ ऐसा जोड़ा जा सकता है" कहने के लिए सिर्फ शब्दजाल है। मैड्स टॉर्गर्सन से सीधे लिया गया : भविष्य में सी # :

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 # 8 इंटरफ़ेस स्थिर सदस्य

संपादित करें

यह पोस्ट मूल रूप से इंटरफ़ेस में स्थिर सदस्यों को C # 8.0 में जोड़ा जाएगा , जो कि सच नहीं है, मैंने वीडियो में Mads Torgersen के शब्दों की गलत व्याख्या की है। आधिकारिक C # 8.0 गाइड अभी तक स्थिर इंटरफ़ेस सदस्यों के बारे में बात नहीं करता है, लेकिन यह स्पष्ट है कि वे इस पर काफी लंबे समय से काम कर रहे हैं।

Question 8

के रूप में क्यों आप एक अंतरफलक पर एक स्थिर विधि नहीं हो सकता है: क्यों नहीं # सी इंटरफ़ेस को लागू करने के लिए स्टेटिक तरीकों की अनुमति दें?

हालांकि, मैं उदाहरण के तरीकों के पक्ष में स्थिर तरीकों को हटाने का सुझाव दूंगा। यदि यह संभव नहीं है, तो आप इंस्टेंस मेथड कॉल्स को इंस्टेंस मेथड के अंदर लपेट सकते हैं, और फिर आप उसके लिए एक इंटरफ़ेस बना सकते हैं और उसी से अपना यूनिट टेस्ट चला सकते हैं।

अर्थात

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

Question 9

C # 8 अंतरंग पर स्थैतिक सदस्यों को अनुमति देता है

C # 8.0 के साथ शुरुआत, एक इंटरफ़ेस सदस्यों के लिए एक डिफ़ॉल्ट कार्यान्वयन को परिभाषित कर सकता है। यह सामान्य कार्यक्षमता के लिए एकल कार्यान्वयन प्रदान करने के लिए स्थैतिक सदस्यों को भी परिभाषित कर सकता है।

इंटरफ़ेस (C # संदर्भ)

उदाहरण के लिए

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

var something = IGetSomething.Something;