डब्ल्यूसीएफ - सामान्य तरीकों को साझा करने वाले कई अनुबंधों के दौरान सर्वोत्तम अभ्यास की तलाश में

Question

मेरा इरादा एक कोर मॉड्यूल इंटरफेस को उजागर करना है ताकि अन्य बड़े मॉड्यूल (विभिन्न क्लाइंट) संवाद कर सकें।

void Method_A(); 
void Method_B(); 
void Method_X2(); 

ग्राहकों के अन्य प्रकार (मॉड्यूल "X2 को बेनकाब करने के लिए:

void Method_A(); 
void Method_B(); 
void Method_X1(); 

ग्राहकों का एक प्रकार (मॉड्यूल" एक्स 1 ") और को बेनकाब करने के लिए: हैं, कहते हैं, वहाँ तरीकों में से समूह रहे हैं ") और यह जानकर कि Method_A और Method_B में सटीक कार्यान्वयन होना चाहिए ... तो मैं सेवा (ओं) आर्किटेक्चर (सेवाओं और अनुबंधों के संदर्भ में) को सर्वश्रेष्ठ तरीके से कैसे डिजाइन कर सकता हूं?

क्या विधि_ए और विधि_B को केवल एक बार लागू करने का कोई मौका है (अलग-अलग अनुबंध कार्यान्वयन में 2 बार नहीं)?

डब्ल्यूसीएफ का उपयोग करते समय मुझे इंटरफ़ेस विरासत का लाभ कैसे मिलेगा?

अग्रिम धन्यवाद और कृपया मुझे बताएं कि मुझे इसे और स्पष्ट करने की आवश्यकता है!

@marc_s ... मैं वास्तव में अपने दृष्टिकोण की सराहना करेंगे ...

Answer 1

क्लासेस, तरीकों कि एक इंटरफेस को संतुष्ट वारिस कर सकते हैं ताकि आप एक IServiceBase इंटरफेस और ServiceBase वर्ग कि सिर्फ Method_A और Method_B लागू करता है हो सकता था , फिर अनन्य तरीकों को अलग-अलग इंटरफेस में सिंगल आउट करें, अंततः उन वर्गों में उन्हें एक साथ जोड़ दें जो ServiceBase का उत्तराधिकारी हैं और इंटरफ़ेस 1 या इंटरफ़ेस 2 को लागू करते हैं। उदाहरण:

[ServiceContract] 
public interface IServiceBase 
{ 
    [OperationContract] 
    void Method_A(); 

    [OperationContract] 
    void Method_B(); 
} 

[ServiceContract] 
public interface IService1 : IServiceBase 
{ 
    [OperationContract] 
    void Method_X1(); 
} 

[ServiceContract] 
public interface IService2 : IServiceBase 
{ 
    [OperationContract] 
    void Method_X2(); 
} 

public abstract class ServiceBase : IServiceBase 
{ 
    void Method_A() 
    { 
     ... implementation here ... 
    } 

    void Method_B() 
    { 
     ... implementation here ... 
    } 
} 

public class Service1 : ServiceBase, IService1 
{ 
    void Method_X1() 
    { 
     ... implementation here ... 
    } 
} 

public class Service2 : ServiceBase, IService2 
{ 
    void Method_X2() 
    { 
     ... implementation here ... 
    } 
} 

Answer 2

मुझे कॉल किया गया है!?!? :-)

यदि आपके पास एक ही इंटरफ़ेस

public interface IServiceA 
{ 
    void Method_A(); 
    void Method_B(); 
    void Method_X1(); 
} 

और एक दूसरे से एक

public interface IServiceB 
{ 
    void Method_A(); 
    void Method_B(); 
    void Method_X2(); 
} 

आप पूरी तरह सर्वर साइड पर दो सामान्य तरीके के लिए कार्यान्वयन कोड साझा कर सकते हैं।

आप एक आम वर्ग पुस्तकालय में दो वर्गों MethodAHandler और MethodBHandler अपने सर्वर पर, बना सकते हैं (या दो अलग-अलग, आम विधानसभाओं में), और फिर आप की तरह कुछ इस्तेमाल कर सकते हैं:

using MethodHandlers; // contains the two method handlers 

public class ServiceA : IServiceA 
{ 
    public void Method_A() 
    { 
     MethodAHandler hnd = new MethodAHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_B() 
    { 
     MethodBHandler hnd = new MethodBHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_X1() 
    { 
     // handle method X1 call here or delegate to another handler class 
    } 
} 

और के लिए दूसरी सेवा:

using MethodHandlers; // contains the two method handlers 

public class ServiceB : IServiceB 
{ 
    public void Method_A() 
    { 
     MethodAHandler hnd = new MethodAHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_B() 
    { 
     MethodBHandler hnd = new MethodBHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_X2() 
    { 
     // handle method X2 call here or delegate to another handler class 
    } 
} 

सर्वर साइड पर, आप नेट वर्गों है और आप पूरी तरह से एक आम वर्ग पुस्तकालय के माध्यम से दो अलग-अलग सेवा कार्यान्वयन के बीच कोड साझा कर सकते हैं या जो भी आप के लिए सबसे अच्छा तरीका खोजने के आप।