कोड अनुबंध: विरासत वाले इंटरफेस से कैसे निपटें?

Question

मैं एमएस कोड अनुबंध का उपयोग कर रहा हूं और इंटरफेस विरासत और ContractClassFor विशेषताओं का उपयोग कर एक झटके में भाग गया है।

इन इंटरफेस और अनुबंध वर्गों को देखते हुए:

[ContractClass(typeof(IOneContract))] 
interface IOne { } 
[ContractClass(typeof(ITwoContract))] 
interface ITwo : IOne { } 

[ContractClassFor(typeof(IOne))] 
abstract class IOneContract : IOne { } 
[ContractClassFor(typeof(ITwo))] 
abstract class ITwoContract : IOneContract, ITwo { } 

मान लें कि Ione और ITwo पर्याप्त इंटरफ़ेस हैं करते हैं। तो आवश्यक जांच के लिए IOneContract में इसमें पर्याप्त मात्रा में कोड होगा।

मैं आईओएन इंटरफेस के लिए ITwoContract में उन सभी को डुप्लिकेट नहीं करना चाहता हूं। मैं केवल आईटीवो इंटरफेस के लिए नए अनुबंध जोड़ना चाहता हूं। एक अनुबंध वर्ग को दूसरे से लेना उस कोड का पुन: उपयोग करने का संभावित तरीका लगता है। फिर भी मुझे निम्न त्रुटि मिलती है:

EXEC : warning CC1066: Class 'ITwoContract' is annotated as being the contract for the interface 'ITwo' and cannot have an explicit base class other than System.Object. 

क्या यह कोड अनुबंधों में एक सीमा है या क्या मैं इसे गलत कर रहा हूं? हमारे पास हमारे प्रोजेक्ट में बहुत अधिक इंटरफ़ेस विरासत है और यह कोड अनुबंधों के लिए एक सौदा ब्रेकर जैसा लगता है अगर मैं इस मुद्दे के आसपास काम करने का तरीका नहीं समझ सकता।

Answer 1

बजाय:

[ContractClassFor(typeof(ITwo))] 
abstract class ITwoContract : ITwo { } 

आप केवल तरीकों जो ITwo में नए हैं पर ठेके देने की आवश्यकता:

[ContractClassFor(typeof(ITwo))] 
abstract class ITwoContract : IOneContract, ITwo { } 

बस अनुबंध प्राप्त करती हैं। IOneContract से अनुबंध स्वचालित रूप से विरासत में मिला दिया जाएगा, और आप सार — तथ्य, आप ITwoContract पर IOne के लिए अनुबंध प्रदान नहीं कर सकते में के रूप में सभी विरासत में मिला IOne तरीकों घोषणा कर सकते हैं, या सीसी शिकायत :)

उदाहरण के लिए, आप अगर इस राशि:

[ContractClass(typeof (IOneContract))] 
interface IOne 
{ 
    int Thing { get; } 
} 

[ContractClass(typeof (ITwoContract))] 
interface ITwo : IOne 
{ 
    int Thing2 { get; } 
} 

[ContractClassFor(typeof (IOne))] 
abstract class IOneContract : IOne 
{ 
    public int Thing 
    { 
     get 
     { 
      Contract.Ensures(Contract.Result<int>() > 0); 
      return 0; 
     } 
    } 
} 

[ContractClassFor(typeof (ITwo))] 
abstract class ITwoContract : ITwo 
{ 
    public int Thing2 
    { 
     get 
     { 
      Contract.Ensures(Contract.Result<int>() > 0); 
      return 0; 
     } 
    } 

    public abstract int Thing { get; } 
} 

फिर इस कार्यान्वयन की उम्मीद के रूप में दोनों तरीकों पर कहेंगे "अप्रमाणित अनुबंध",:

class Two : ITwo 
{ 
    public int Thing 
    { 
     get { return 0; } 
    } 

    public int Thing2 
    { 
     get { return 0; } 
    } 
}