अमूर्त प्रकारों में स्थैतिक तरीकों को परिभाषित नहीं कर सकता। कैसे काम करने के लिए?

Question

मैं वर्तमान में एक बाइनरी अनुप्रयोग प्रोटोकॉल के लिए एक पुस्तकालय विकसित कर रहा हूँ। निम्नलिखित कोड नमूना संकलन नहीं है (स्थिर तरीकों परिभाषा सार प्रकार की अनुमति नहीं दी बहुत खराब :(।), लेकिन मेरा इरादा पता चलता है:

public abstract class CmdBody<T> 
{ 
    public static abstract byte[] ToBytes(T cmdBody); 
    public abstract int GetLength(); 
} 

public class CmdBodyA : CmdBody<CmdBodyA> 
{ 
    static override byte[] ToBytes(CmdBodyA cmdBody) 
    { // Implementation } 
} 

public class CmdBodyB : CmdBody<CmdBodyB> 
{ 
    static override byte[] ToBytes(CmdBodyB cmdBody) 
    { // Implementation } 
} 

[...] 

public class Cmd<T> 
{ 
    public CmdHeader Header { get; set; } 
    public CmdBody<T> Body { get; set; } 

    public byte[] ToBytes() 
    { 
     byte[] cmdBytes = new byte[Header.GetLength() + Body.GetLength()]; 
     Header.ToBytes().CopyTo(cmdBytes, 0); 
     Body.ToBytes().CoptyTo(cmdBytes, Header.GetLength()); 

     return cmdBytes; 
    } 
} 

तो बहुत बुनियादी सामान, एक Cmd एक शीर्ष लेख और एक शरीर के होते हैं , सीएमडी प्रकार के आधार पर सभी सीएमडी (बॉडी) और बॉडी के पास विभिन्न पैरामीटर (गुण) होते हैं, और मैं सीएमडी ऑब्जेक्ट्स के साथ काम करना चाहता हूं, और उन्हें भेजने के लिए उन पर ToBytes() को कॉल करने में सक्षम होना नेटवर्क

मेरे वास्तविक कार्यान्वयन में मैं ToBytes() विधि के बजाय रूपांतरण ऑपरेटर का उपयोग कर रहा हूं, लेकिन मैं कोड नमूना सरल रखना चाहता हूं, अंत में यह वही काम करता है।

मेरे पास कई अलग-अलग कमांड प्रकार हैं, और मैं इसे सरल रखने और केवल एक सामान्य जेएमएम प्रकार के साथ प्राप्त करने के लिए समाधान को हल नहीं कर सकता। एकमात्र समाधान जिसे मैं सोच सकता हूं, बेस सीएमडीबीडी कक्षा में स्थैतिक विधि से छुटकारा पाने के लिए, सामान्य पहलू से छुटकारा पाएं और प्रत्येक सीएमडीबीडी प्रकार के लिए एक संबद्ध सीएमडी कक्षा (कक्षा सीएमडीए, कक्षा सीएमडीबी ...) बनाएं लेकिन इस दिन के अंत में बहुत सारे कोड डुप्लिकेशन होंगे।

इस पर काम करने में मेरी मदद करने के लिए एक अच्छा desing के लिए कोई विचार?

Answer 1

आपके पास वर्चुअल/अमूर्त/ओवरराइड के रूप में "वर्चुअल" स्थिर विधियां नहीं हो सकती हैं, क्योंकि इंस्टेंस रनटाइम पर ओवरराइड किया गया है।

आप कुछ इस तरह कर सकता है, हालांकि:

public abstract class CmdBody 
{ 
    public static byte[] ToBytes<T>(T cmdBody) where T : CmdBody 
    { 
     return cmdBody.ToBytes(); 
    } 

    protected abstract byte[] ToBytes(); 

    public abstract int GetLength(); 
} 

public class CmdBodyA : CmdBody 
{ 
    protected override byte[] ToBytes() 
    { // Implementation } 
} 

public class CmdBodyB : CmdBody 
{ 
    protected override byte[] ToBytes() 
    { // Implementation } 
} 

यह है कि यह कैसे अपने आप धारावाहिक है परिभाषित करने के लिए प्रत्येक "CmdBody" प्रकार की अनुमति देता है, लेकिन आधार वर्ग स्थिर विधि इसे उपयोग करने में केवल सार्वजनिक रूप से दिखाई रास्ता ।

कहा जा रहा है कि, आपके उपयोग के मामले में, इस स्थिर को बिल्कुल बनाने का कोई कारण नहीं है। आप बस कर सकते हैं:

public abstract class CmdBody 
{ 
    public abstract byte[] ToBytes(); 

    public abstract int GetLength(); 
} 

public class CmdBodyA : CmdBody 
{ 
    public override byte[] ToBytes() 
    { // Implementation } 
} 

public class CmdBodyB : CmdBody 
{ 
    public override byte[] ToBytes() 
    { // Implementation } 
} 


public class Cmd<T> where T : CmdBody 
{ 
    public CmdHeader Header { get; set; } 
    public T Body { get; set; } 

    public byte[] ToBytes() 
    { 
     byte[] cmdBytes = new byte[Header.GetLength() + Body.GetLength()]; 
     Header.ToBytes().CopyTo(cmdBytes, 0); 
     Body.ToBytes().CopyTo(cmdBytes, Header.GetLength()); 

     return cmdBytes; 
    } 
}