यह असुरक्षित

Question

साथ वर्ग क्षेत्रों कॉपी करने के लिए संभव है मैं दो वर्गों

[StructLayout(LayoutKind.Explicit, Size = 12, CharSet = CharSet.Ansi)] 
unsafe class Dto 
{ 
    [FieldOffset(0)] 
    public int B; 
    [FieldOffset(4)] 
    public int C; 
    [FieldOffset(8)] 
    public int D; 
} 
[StructLayout(LayoutKind.Explicit, Size = 12, CharSet = CharSet.Ansi)] 
unsafe class Model 
{ 
    [FieldOffset(0)] 
    public int B; 
    [FieldOffset(4)] 
    public int C; 
    [FieldOffset(8)] 
    public int D; 
} 

वहाँ रास्ता ओ मॉडल का उदाहरण डीटीओ के कहने से क्षेत्रों से डेटा की प्रतिलिपि है है? एक भी क्षेत्र के लिए मैं कोड निम्नलिखित है

var a1 = new Dto { B = 10, C = 20, D = 30 }; 
var a2 = new Model(); 

unsafe 
{ 
    fixed (int* pa1 = &(a1.B)) 
    { 
      fixed (int* pa2 = &(a2.B)) 
      { 
       *pa2 = *pa1; 
      } 
    } 
} 

करता है सी # पूरी वस्तु को कॉपी करने के समान विधि प्रदान करते हैं? उच्च प्रदर्शन वातावरण के कारण फ़ील्ड-बाय-फील्ड कॉपी करना वांछनीय नहीं है।

Answer 1

आपकी मुख्य चिंता प्रदर्शन है। यदि आप फील्ड-दर-फ़ील्ड की प्रतिलिपि बनाते हैं, तो यह 6 mov निर्देशों का अनुवाद करेगा। इसके बाद इसे तेज बनाना बहुत मुश्किल है।

पॉइंटर्स का उपयोग करने से आवश्यक निर्देशों की संख्या कम नहीं होती है। यह क्यों होगा आपको अभी भी एक ही असाइनमेंट की आवश्यकता है।

कॉलिंग memcpy में अधिक ओवरहेड शामिल है तो मामूली 6 mov निर्देश।

तो आपको इष्टतम प्रदर्शन प्राप्त करने के लिए सुरक्षित प्रबंधित कोड का उपयोग करके "बेवकूफ" तीन असाइनमेंट लिखना चाहिए। वास्तव में, इस 12-बाइट ऑब्जेक्ट को कॉपी करना इतना सस्ता है कि मुझे संदेह है कि आपकी प्रदर्शन चिंताओं को मान्य है। मुझे संदेह है कि यह किसी भी प्रोफाइल पर दिखाई देगा।

प्रतिलिपि प्रदर्शन के लिए इससे कोई फ़र्क नहीं पड़ता कि आप class या struct का उपयोग करते हैं या नहीं। लेकिन struct में अन्य मतभेदों के कारण कुछ प्रदर्शन लाभ हैं। आप उनकी जांच करना चाहेंगे।

Answer 2

सी # में memcpy के सबसे नज़दीकी चीज Buffer.BlockCopy है, हालांकि यह सरणी के लिए डिज़ाइन किया गया है।

यह विषय पर interesting article है।

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

कुछ ऐसा;

public struct Model 
    { 
     public int B; 
     public int C; 
     public int D; 

     public Model(Dto dto) 
     { 
     B = dto.B; 
     C = dto.C; 
     D = dto.D; 
     } 

     static public implicit operator Model(Dto dto) 
     { 
     return new Model(dto); 
     } 
    } 

आप सिर्फ इतना कहना है की अनुमति होगी ...

 Dto a1 = new Dto { B = 10, C = 20, D = 30 }; 

    Model m = a1;