คัดลอกตัวสร้างเทียบกับ Clone ()

ใน C # วิธีใดที่ต้องการเพิ่มฟังก์ชันการคัดลอก (ลึก) ลงในคลาส ควรใช้ตัวสร้างการคัดลอกหรือได้มาจากICloneableและใช้Clone()วิธีการนี้หรือไม่?

หมายเหตุ : ฉันเขียน "ลึก" ไว้ในวงเล็บเพราะคิดว่าไม่เกี่ยวข้อง เห็นได้ชัดว่าคนอื่นไม่เห็นด้วยดังนั้นฉันจึงถามว่าตัวสร้างการคัดลอก / ตัวดำเนินการ / ฟังก์ชั่นจำเป็นต้องทำให้ชัดเจนหรือไม่ว่าจะใช้ตัวแปรการคัดลอกใด

ICloneableคุณไม่ควรมาจาก

เหตุผลก็คือเมื่อ Microsoft ออกแบบ. net framework พวกเขาไม่เคยระบุว่าClone()เมธอดบนICloneableควรเป็นโคลนลึกหรือตื้นดังนั้นอินเทอร์เฟซจึงเสียความหมายเนื่องจากผู้โทรของคุณไม่ทราบว่าการโทรจะโคลนวัตถุลึกหรือตื้น

แต่คุณควรกำหนดเองของคุณIDeepCloneable(และIShallowCloneable) การเชื่อมต่อกับDeepClone()(และShallowClone()) วิธีการ

คุณสามารถกำหนดอินเทอร์เฟซได้สองอินเทอร์เฟซโดยหนึ่งมีพารามิเตอร์ทั่วไปเพื่อรองรับการโคลนนิ่งที่พิมพ์มากและอีกอันหนึ่งโดยไม่ต้องรักษาความสามารถในการโคลนที่พิมพ์ผิดไว้เมื่อคุณทำงานกับคอลเลกชันของอ็อบเจ็กต์ที่สามารถโคลนประเภทต่างๆได้:

public interface IDeepCloneable
{
    object DeepClone();
}
public interface IDeepCloneable<T> : IDeepCloneable
{
    T DeepClone();
}

ซึ่งคุณจะดำเนินการดังนี้:

public class SampleClass : IDeepCloneable<SampleClass>
{
    public SampleClass DeepClone()
    {
        // Deep clone your object
        return ...;
    }
    object IDeepCloneable.DeepClone()   
    {
        return this.DeepClone();
    }
}

โดยทั่วไปฉันชอบที่จะใช้อินเทอร์เฟซที่อธิบายซึ่งตรงข้ามกับตัวสร้างการคัดลอกซึ่งทำให้เจตนาชัดเจนมาก ตัวสร้างการคัดลอกอาจถือว่าเป็นโคลนลึก แต่ก็ไม่ได้มีเจตนาที่ชัดเจนเท่ากับการใช้อินเทอร์เฟซ IDeepClonable

สิ่งนี้จะกล่าวถึงในแนวทางการออกแบบ . net Frameworkและในบล็อกของ Brad Abrams

_{(ฉันคิดว่าถ้าคุณกำลังเขียนแอปพลิเคชัน (ตรงข้ามกับเฟรมเวิร์ก / ไลบรารี) ดังนั้นคุณสามารถมั่นใจได้ว่าจะไม่มีใครนอกทีมของคุณเรียกรหัสของคุณมันไม่สำคัญมากนักและคุณสามารถกำหนดความหมายเชิงความหมายของ "deepclone" ไปยังอินเทอร์เฟซ. net ICloneable แต่คุณควรตรวจสอบให้แน่ใจว่าสิ่งนี้ได้รับการบันทึกไว้เป็นอย่างดีและเป็นที่เข้าใจกันดีภายในทีมของคุณโดยส่วนตัวแล้วฉันจะยึดตามแนวทางของกรอบงาน)}

ใน C # วิธีใดที่ต้องการเพิ่มฟังก์ชันการคัดลอก (ลึก) ลงในคลาส ควรใช้ตัวสร้างการคัดลอกหรือค่อนข้างมาจาก ICloneable และใช้วิธี Clone ()?

ปัญหาICloneableคือตามที่คนอื่น ๆ กล่าวถึงว่าไม่ได้ระบุว่าเป็นสำเนาลึกหรือตื้นซึ่งทำให้ไม่สามารถใช้งานได้จริงและในทางปฏิบัติแทบไม่ได้ใช้ นอกจากนี้ยังส่งกลับobjectซึ่งเป็นความเจ็บปวดเนื่องจากต้องใช้การหล่อมาก (และแม้ว่าคุณกล่าวถึงเฉพาะการเรียนในคำถามที่ดำเนินการICloneableบนstructต้องมวย.)

ตัวสร้างสำเนายังประสบปัญหาอย่างใดอย่างหนึ่งกับ ICloneable ไม่ชัดเจนว่าตัวสร้างสำเนากำลังทำสำเนาลึกหรือตื้น

Account clonedAccount = new Account(currentAccount); // Deep or shallow?

การสร้างเมธอด DeepClone () จะเป็นการดีที่สุด วิธีนี้เจตนาชัดเจนอย่างสมบูรณ์

สิ่งนี้ทำให้เกิดคำถามว่าควรเป็นวิธีแบบคงที่หรืออินสแตนซ์

Account clonedAccount = currentAccount.DeepClone();  // instance method

หรือ

Account clonedAccount = Account.DeepClone(currentAccount); // static method

ฉันชอบเวอร์ชันคงที่เล็กน้อยในบางครั้งเพียงเพราะการโคลนดูเหมือนเป็นสิ่งที่กำลังทำกับวัตถุมากกว่าสิ่งที่วัตถุกำลังทำ ไม่ว่าในกรณีใดจะมีปัญหาที่ต้องจัดการเมื่อทำการโคลนนิ่งวัตถุที่เป็นส่วนหนึ่งของลำดับชั้นการสืบทอดและวิธีที่ปัญหาเหล่านั้นเกิดขึ้นในท้ายที่สุดอาจผลักดันการออกแบบ

class CheckingAccount : Account
{
    CheckAuthorizationScheme checkAuthorizationScheme;

    public override Account DeepClone()
    {
        CheckingAccount clone = new CheckingAccount();
        DeepCloneFields(clone);
        return clone;
    }

    protected override void DeepCloneFields(Account clone)
    {
        base.DeepCloneFields(clone);

        ((CheckingAccount)clone).checkAuthorizationScheme = this.checkAuthorizationScheme.DeepClone();
    }
}

ฉันขอแนะนำให้ใช้ตัวสร้างการคัดลอกบนวิธีการโคลนเป็นหลักเนื่องจากวิธีการโคลนจะป้องกันไม่ให้คุณสร้างฟิลด์readonlyที่อาจเกิดขึ้นได้หากคุณใช้ตัวสร้างแทน

หากคุณต้องการการโคลนแบบโพลีมอร์ฟิคคุณสามารถเพิ่มabstractหรือvirtual Clone()วิธีการลงในคลาสพื้นฐานของคุณที่คุณนำไปใช้ด้วยการเรียกไปยังตัวสร้างการคัดลอก

หากคุณต้องการสำเนามากกว่าหนึ่งประเภท (เช่นลึก / ตื้น) คุณสามารถระบุด้วยพารามิเตอร์ในตัวสร้างการคัดลอกแม้ว่าจากประสบการณ์ของฉันฉันพบว่าโดยปกติแล้วการคัดลอกแบบลึกและตื้นเป็นสิ่งที่ฉันต้องการ

Ex:

public class BaseType {
   readonly int mBaseField;

   public BaseType(BaseType pSource) =>
      mBaseField = pSource.mBaseField;

   public virtual BaseType Clone() =>
      new BaseType(this);
}

public class SubType : BaseType {
   readonly int mSubField;

   public SubType(SubType pSource)
   : base(pSource) =>
      mSubField = pSource.mSubField;

   public override BaseType Clone() =>
      new SubType(this);
}

มีข้อโต้แย้งที่ดีว่าคุณควรใช้ clone () โดยใช้ตัวสร้างสำเนาที่มีการป้องกัน

จะดีกว่าที่จะจัดเตรียมตัวสร้างการคัดลอกที่ได้รับการป้องกัน (ไม่ใช่สาธารณะ) และเรียกใช้จากวิธีการโคลน สิ่งนี้ทำให้เราสามารถมอบหมายงานในการสร้างอ็อบเจกต์ไปยังอินสแตนซ์ของคลาสได้เองดังนั้นจึงให้ความสามารถในการขยายและการสร้างอ็อบเจกต์อย่างปลอดภัยโดยใช้ตัวสร้างสำเนาที่มีการป้องกัน

ดังนั้นนี่จึงไม่ใช่คำถาม "กับ" คุณอาจต้องใช้ทั้งตัวสร้างการคัดลอกและอินเทอร์เฟซการโคลนเพื่อให้ถูกต้อง

(แม้ว่าอินเทอร์เฟซสาธารณะที่แนะนำคืออินเทอร์เฟซ Clone () แทนที่จะใช้ Constructor-based)

อย่าจมอยู่กับข้อโต้แย้งที่ชัดเจนหรือตื้น ๆ ในคำตอบอื่น ๆ ในโลกแห่งความเป็นจริงมักจะเป็นสิ่งที่อยู่ระหว่างกัน - และไม่ควรเป็นเรื่องที่ผู้โทรกังวล

สัญญา Clone () เป็นเพียง "จะไม่เปลี่ยนแปลงเมื่อฉันเปลี่ยนข้อแรก" คุณต้องคัดลอกกราฟมากแค่ไหนหรือหลีกเลี่ยงการเรียกซ้ำแบบไม่มีที่สิ้นสุดเพื่อให้สิ่งนั้นเกิดขึ้นไม่ควรเกี่ยวข้องกับผู้โทร

ไม่แนะนำให้ใช้ ICloneableเนื่องจากไม่ได้ระบุว่าเป็นสำเนาลึกหรือตื้นดังนั้นฉันจะไปหาผู้สร้างหรือเพียงแค่ใช้บางอย่างด้วยตัวเอง อาจจะเรียกมันว่า DeepCopy () เพื่อให้ชัดเจนจริงๆ!

คุณจะพบปัญหาเกี่ยวกับตัวสร้างการคัดลอกและคลาสนามธรรม ลองนึกภาพว่าคุณต้องการทำสิ่งต่อไปนี้:

abstract class A
{
    public A()
    {
    }

    public A(A ToCopy)
    {
        X = ToCopy.X;
    }
    public int X;
}

class B : A
{
    public B()
    {
    }

    public B(B ToCopy) : base(ToCopy)
    {
        Y = ToCopy.Y;
    }
    public int Y;
}

class C : A
{
    public C()
    {
    }

    public C(C ToCopy)
        : base(ToCopy)
    {
        Z = ToCopy.Z;
    }
    public int Z;
}

class Program
{
    static void Main(string[] args)
    {
        List<A> list = new List<A>();

        B b = new B();
        b.X = 1;
        b.Y = 2;
        list.Add(b);

        C c = new C();
        c.X = 3;
        c.Z = 4;
        list.Add(c);

        List<A> cloneList = new List<A>();

        //Won't work
        //foreach (A a in list)
        //    cloneList.Add(new A(a)); //Not this time batman!

        //Works, but is nasty for anything less contrived than this example.
        foreach (A a in list)
        {
            if(a is B)
                cloneList.Add(new B((B)a));
            if (a is C)
                cloneList.Add(new C((C)a));
        }
    }
}

หลังจากทำตามข้างต้นแล้วคุณจะเริ่มคิดว่าจะใช้อินเทอร์เฟซหรือตกลงสำหรับการใช้งาน DeepCopy () / ICloneable.Clone ()

ปัญหาเกี่ยวกับ ICloneable มีทั้งเจตนาและความสม่ำเสมอ ไม่เคยชัดเจนว่าเป็นสำเนาลึกหรือตื้น ด้วยเหตุนี้จึงอาจไม่เคยใช้ในลักษณะใดลักษณะหนึ่งเท่านั้น

ฉันไม่พบตัวสร้างสำเนาสาธารณะที่ชัดเจนในเรื่องนั้น

ที่กล่าวว่าฉันจะแนะนำระบบวิธีการที่เหมาะกับคุณและถ่ายทอดเจตนา (a'la ค่อนข้างจัดทำเอกสารด้วยตัวเอง)

หากออบเจ็กต์ที่คุณพยายามคัดลอกนั้นสามารถต่ออนุกรมได้คุณสามารถโคลนได้โดยการทำให้เป็นอนุกรมและแยกส่วนออก จากนั้นคุณไม่จำเป็นต้องเขียนตัวสร้างการคัดลอกสำหรับแต่ละคลาส

ตอนนี้ฉันไม่สามารถเข้าถึงรหัสได้ แต่เป็นแบบนี้

public object DeepCopy(object source)
{
   // Copy with Binary Serialization if the object supports it
   // If not try copying with XML Serialization
   // If not try copying with Data contract Serailizer, etc
}

ขึ้นอยู่กับการคัดลอกความหมายของคลาสที่เป็นปัญหาซึ่งคุณควรกำหนดตัวเองเป็นผู้พัฒนา วิธีการที่เลือกมักจะขึ้นอยู่กับกรณีการใช้งานที่ตั้งใจไว้ของคลาส บางทีมันอาจจะสมเหตุสมผลที่จะใช้ทั้งสองวิธี แต่ทั้งสองมีข้อเสียที่คล้ายกัน - ไม่ชัดเจนว่าพวกเขาใช้วิธีการคัดลอกแบบใด ควรระบุไว้อย่างชัดเจนในเอกสารสำหรับชั้นเรียนของคุณ

สำหรับฉันมี:

// myobj is some transparent proxy object
var state = new ObjectState(myobj.State);

// do something

myobject = GetInstance();
var newState = new ObjectState(myobject.State);

if (!newState.Equals(state))
    throw new Exception();

แทน:

// myobj is some transparent proxy object
var state = myobj.State.Clone();

// do something

myobject = GetInstance();
var newState = myobject.State.Clone();

if (!newState.Equals(state))
    throw new Exception();

ดูเป็นการแสดงเจตนาที่ชัดเจนขึ้น

ฉันคิดว่าควรมีรูปแบบมาตรฐานสำหรับวัตถุที่สามารถโคลนได้แม้ว่าฉันจะไม่แน่ใจว่ารูปแบบควรเป็นอย่างไร เกี่ยวกับการโคลนดูเหมือนว่าจะมีคลาสสามประเภท:

1. สิ่งที่สนับสนุนอย่างชัดเจนสำหรับการโคลนลึก
2. สิ่งที่การโคลนนิ่งแบบสมาชิกจะทำงานได้เหมือนกับการโคลนนิ่งแบบลึก แต่ไม่จำเป็นต้องมีการสนับสนุนอย่างชัดเจน
3. สิ่งที่ไม่สามารถโคลนนิ่งได้อย่างมีประโยชน์และการโคลนแบบสมาชิกจะให้ผลลัพธ์ที่ไม่ดี

เท่าที่ฉันสามารถบอกได้วิธีเดียว (อย่างน้อยใน. net 2.0) ในการรับวัตถุใหม่ของคลาสเดียวกันกับวัตถุที่มีอยู่คือการใช้ MemberwiseClone รูปแบบที่ดีดูเหมือนว่าจะมีฟังก์ชัน Clone "new" / "Shadows" ซึ่งจะส่งคืนชนิดปัจจุบันเสมอซึ่งคำจำกัดความคือการเรียก MemberwiseClone เสมอจากนั้นจึงเรียกรูทีนย่อยเสมือนที่มีการป้องกัน CleanupClone (originalObject) รูทีน CleanupCode ควรเรียก base.Cleanupcode เพื่อจัดการกับความต้องการการโคลนของประเภทพื้นฐานจากนั้นเพิ่มการล้างข้อมูลของตัวเอง หากรูทีนการโคลนนิ่งต้องใช้ออบเจ็กต์ดั้งเดิมก็จะต้องเป็นแบบไทคาสต์ แต่มิฉะนั้นการพิมพ์ดีดเพียงอย่างเดียวจะอยู่ในการเรียก MemberwiseClone

น่าเสียดายที่ระดับต่ำสุดของคลาสที่เป็นประเภท (1) ด้านบนแทนที่จะเป็นประเภท (2) จะต้องถูกเข้ารหัสเพื่อให้ถือว่าประเภทที่ต่ำกว่านั้นไม่จำเป็นต้องมีการสนับสนุนอย่างชัดเจนสำหรับการโคลนนิ่ง ฉันไม่เห็นทางนั้นจริงๆ

ถึงกระนั้นฉันคิดว่าการมีรูปแบบที่กำหนดไว้จะดีกว่าไม่มีอะไรเลย

อนึ่งหากรู้ว่าประเภทฐานรองรับ iCloneable แต่ไม่ทราบชื่อของฟังก์ชันที่ใช้มีวิธีใดบ้างในการอ้างอิงฟังก์ชัน iCloneable.Clone ของประเภทฐาน

หากคุณอ่านคำตอบและการอภิปรายที่น่าสนใจทั้งหมดคุณอาจยังคงถามตัวเองว่าคุณคัดลอกคุณสมบัติอย่างไร - ทั้งหมดอย่างชัดเจนหรือมีวิธีที่หรูหรากว่านี้หรือไม่? หากนั่นเป็นคำถามที่เหลืออยู่ของคุณลองดูสิ่งนี้ (ที่ StackOverflow):

ฉันจะโคลนคุณสมบัติของคลาสของบุคคลที่สามโดยใช้วิธีการขยายทั่วไปได้อย่างไร

อธิบายวิธีการใช้วิธีการขยายCreateCopy()ซึ่งสร้างสำเนา "ลึก" ของวัตถุรวมถึงคุณสมบัติทั้งหมด (โดยไม่ต้องคัดลอกคุณสมบัติตามคุณสมบัติด้วยตนเอง)