Yapıcıyı Clone () ile kopyala

C # 'da, bir sınıfa (derin) kopyalama işlevi eklemenin tercih edilen yolu nedir? Kopya oluşturucusunu uygulamak mı yoksa daha doğrusu yöntemi türetmek ICloneableve uygulamak Clone()mı gerekir?

Not : Parantez içine "derin" yazdım çünkü alakasız olduğunu düşündüm. Görünüşe göre diğerleri aynı fikirde değil, bu yüzden bir kopya oluşturucu / işleç / işlevin hangi kopya varyantını uyguladığını netleştirmesi gerekip gerekmediğini sordum .

Bundan türetmemelisin ICloneable.

Bunun nedeni, Microsoft .net çerçevesini tasarladığında, Clone()yöntemin ICloneablederin veya sığ bir klon olup olmayacağını asla belirtmemiş olmasıdır , bu nedenle arayanlar, aramanın nesneyi derin mi yoksa sığ klonlayacağını bilemeyecekleri için arayüz anlamsal olarak bozuktur.

Bunun yerine, kendi IDeepCloneable(ve IShallowCloneable) arayüzlerinizi DeepClone()(ve ShallowClone()) yöntemleriyle tanımlamalısınız .

İki arabirim tanımlayabilirsiniz; biri güçlü biçimde yazılmış klonlamayı desteklemek için genel bir parametreye sahipken, diğeri farklı türden klonlanabilir nesnelerin koleksiyonlarıyla çalışırken zayıf yazılan klonlama yeteneğini korumaksızın:

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

Bunu daha sonra şu şekilde uygularsınız:

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

Genel olarak, bir kopya oluşturucunun aksine açıklanan arayüzleri kullanmayı tercih ederim, bu da amacı çok net tutar. Bir kopya oluşturucunun muhtemelen derin bir klon olduğu varsayılır, ancak kesinlikle bir IDeepClonable arayüzü kullanmak kadar net bir amaç değildir.

Bu, .net Çerçeve Tasarım Kılavuzunda ve Brad Abrams'ın blogunda tartışılmaktadır.

_{(Sanırım bir uygulama yazıyorsanız (bir çerçeve / kitaplığın aksine) ekibinizin dışından hiç kimsenin kodunuzu çağırmayacağından emin olabilirsiniz, bu çok da önemli değil ve anlamsal bir anlam atayabilirsiniz. .net ICloneable arayüzüne "deepclone", ancak bunun iyi belgelendiğinden ve ekibiniz içinde iyi anlaşıldığından emin olmalısınız. Şahsen ben çerçeve kurallarına bağlı kalırım.)}

C # 'da, bir sınıfa (derin) kopyalama işlevi eklemenin tercih edilen yolu nedir? Kopya yapıcısı mı uygulanmalı, yoksa ICloneable'dan türetilmeli ve Clone () yöntemi uygulanmalı mı?

Bununla ilgili sorun ICloneable, diğerlerinin de belirttiği gibi, derin veya sığ bir kopya olup olmadığını belirtmemesi, bu da onu pratikte kullanılamaz hale getirmesi ve pratikte nadiren kullanmasıdır. Aynı zamanda objectçok fazla döküm gerektirdiği için acı veren geri dönüyor . (Ve soruda özellikle sınıflardan bahsetmiş olsanız da ICloneable, bir üzerine uygulamak structkutulama gerektirir.)

Bir kopya oluşturucu da ICloneable ile ilgili sorunlardan birinden muzdariptir. Bir kopya oluşturucunun derin veya sığ bir kopya mı yaptığı açık değildir.

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

Bir DeepClone () yöntemi oluşturmak en iyisidir. Bu şekilde niyet tamamen açıktır.

Bu, statik mi yoksa örnek yöntem mi olması gerektiği sorusunu gündeme getirir.

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

veya

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

Bazen statik versiyonu biraz tercih ederim, çünkü klonlama, nesnenin yaptığı bir şeyden ziyade bir nesneye yapılan bir şey gibi görünüyor. Her iki durumda da, bir kalıtım hiyerarşisinin parçası olan nesneleri klonlarken ilgilenilmesi gereken sorunlar olacaktır ve bu sorunların nasıl çözüleceği nihayetinde tasarımı yönlendirebilir.

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();
    }
}

Öncelikle bir klon yöntemi üzerinde bir kopya oluşturucu kullanmanızı öneririm çünkü bir klon yöntemi, readonlybunun yerine bir yapıcı kullanmış olsaydınız olabilecek alanları oluşturmanızı önleyecektir .

Polimorfik klonlamaya ihtiyaç duyuyorsanız , temel sınıfınıza copy yapıcısına yapılan bir çağrı ile uyguladığınız bir abstractveya virtual Clone()yöntemi ekleyebilirsiniz .

Birden fazla tür kopyaya ihtiyacınız varsa (örn: derin / sığ), bunu kopya oluşturucudaki bir parametre ile belirtebilirsiniz, ancak deneyimlerime göre genellikle derin ve yüzeysel kopyalamanın bir karışımına ihtiyacım olduğunu görüyorum.

Ör:

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);
}

Korumalı bir kopya oluşturucu kullanarak clone () uygulamanız gerektiğine dair harika bir argüman var

Korumalı (genel olmayan) bir kopya oluşturucu sağlamak ve bunu klon yönteminden çağırmak daha iyidir. Bu bize, bir sınıfın kendi örneğine bir nesne yaratma görevini devretme, böylece genişletilebilirlik sağlama ve ayrıca korumalı kopya yapıcısını kullanarak nesneleri güvenli bir şekilde oluşturma yeteneği verir.

Yani bu bir "karşı" soru değil. Bunu doğru yapmak için hem kopya yapıcılara hem de bir klon arayüzüne ihtiyacınız olabilir.

(Önerilen ortak arabirim, Oluşturucu tabanlı değil Clone () arabirimi olsa da.)

Diğer yanıtlardaki açık derin veya sığ tartışmaya kapılmayın. Gerçek dünyada bu neredeyse her zaman arada bir şeydir ve her iki durumda da arayanın endişesi olmamalıdır.

Clone () sözleşmesi basitçe "ilkini değiştirdiğimde değişmeyecek" dir. Grafiğin ne kadarını kopyalamanız gerektiği veya bunun gerçekleşmesi için sonsuz yinelemeden nasıl kaçındığınız arayan kişiyi ilgilendirmemelidir.

ICloneable'ın uygulanması , derin veya sığ bir kopya olup olmadığı belirtilmediği için tavsiye edilmez , bu yüzden kurucuya gidebilir veya sadece bir şeyi kendim uygularım. Belki bunu gerçekten açık hale getirmek için DeepCopy () olarak adlandırın!

Kopyalama yapıcıları ve soyut sınıflarla ilgili sorunlarla karşılaşacaksınız. Aşağıdakileri yapmak istediğinizi hayal edin:

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));
        }
    }
}

Yukarıdakileri yaptıktan hemen sonra, bir arayüz kullanacağınızı veya bir DeepCopy () / ICloneable.Clone () uygulamasına karar vereceğinizi dilemeye başlıyorsunuz.

ICloneable ile ilgili sorun hem niyet hem de tutarlılıktır. Derin veya sığ bir kopya olup olmadığı asla net değildir. Bu nedenle, muhtemelen hiçbir zaman yalnızca bir şekilde kullanılmaz.

Bu konuda daha açık bir halka açık kopya kurucu bulmuyorum.

Bununla birlikte, sizin için çalışan ve amacı aktaran bir yöntem sistemi sunacağım (a'la bir şekilde kendi kendini belgeleyen)

Kopyalamaya çalıştığınız nesne Seri hale getirilebilir ise, onu seri hale getirip serisini kaldırarak klonlayabilirsiniz. O zaman her sınıf için bir kopya oluşturucu yazmanıza gerek kalmaz.

Şu anda koda erişimim yok ama bunun gibi bir şey

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
}

Kendinizi geliştirici olarak tanımlamanız gereken söz konusu sınıfın kopyalama anlamlarına bağlıdır. Seçilen yöntem genellikle sınıfın amaçlanan kullanım durumlarına dayanmaktadır. Belki her iki yöntemi de uygulamak mantıklı olacaktır. Ancak her ikisi de benzer dezavantajları paylaşıyor - hangi kopyalama yöntemini uyguladıkları tam olarak belli değil. Bu, sınıfınızın belgelerinde açıkça belirtilmelidir.

Benim için sahip olunan:

// 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();

onun yerine:

// 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();

daha net bir niyet beyanı olarak görünüyordu.

Klonlanabilir nesneler için standart bir model olması gerektiğini düşünüyorum, ancak desenin tam olarak ne olması gerektiğinden emin değilim. Klonlama ile ilgili olarak, üç tür sınıf var gibi görünüyor:

1. Derin klonlamayı açıkça destekleyenler
2. Üye bazında klonlamanın derin klonlama olarak çalışacağı, ancak açık desteğe sahip olmayan veya buna ihtiyaç duymayanlar.
3. Yararlı bir şekilde derin klonlanamayanlar ve üyelere göre klonlamanın kötü sonuçlar vereceği yerler.

Anlayabildiğim kadarıyla, mevcut bir nesneyle aynı sınıftan yeni bir nesne almanın tek yolu (en azından .net 2.0'da) MemberwiseClone kullanmaktır. Hoş bir model, "yeni" / "Gölgeler" işlevine sahip gibi görünebilir ve her zaman mevcut türü döndürür, tanımı her zaman MemberwiseClone'u çağırır ve ardından korumalı bir sanal alt yordamı CleanupClone (originalObject) çağırır. CleanupCode rutini, temel türün klonlama ihtiyaçlarını karşılamak için base.Cleanupcode'u çağırmalı ve ardından kendi temizleme işlemini eklemelidir. Klonlama rutininin orijinal nesneyi kullanması gerekiyorsa, typecast olmalıdır, ancak aksi takdirde tek tip yayınlama MemberwiseClone çağrısında olacaktır.

Ne yazık ki, tip (2) yerine yukarıda tip (1) olan en düşük sınıf seviyesinin, daha düşük türlerinin klonlama için herhangi bir açık desteğe ihtiyaç duymayacağını varsaymak için kodlanması gerekecektir. Ben bunun etrafında gerçekten bir yol göremiyorum.

Yine de, belirli bir modele sahip olmanın hiç yoktan daha iyi olacağını düşünüyorum.

Bu arada, birinin temel türünün iCloneable'ı desteklediğini bilir, ancak kullandığı işlevin adını bilmiyorsa, kişinin temel türünün iCloneable.Clone işlevine başvurmanın herhangi bir yolu var mı?

Tüm ilginç cevapları ve tartışmaları okursanız, yine de kendinize mülkleri tam olarak nasıl kopyaladığınızı sorabilirsiniz - hepsini açık bir şekilde veya bunu yapmanın daha zarif bir yolu var mı? Geri kalan sorunuz buysa, şuna bir göz atın (StackOverflow'da):

Genel bir uzantı yöntemi kullanarak 3. taraf sınıfların özelliklerini nasıl "derinlemesine" klonlayabilirim?

CreateCopy()Nesnenin tüm özellikleri içeren "derin" bir kopyasını oluşturan bir uzantı yönteminin nasıl uygulanacağını açıklar (özelliği manuel olarak özelliğe göre kopyalamak zorunda kalmadan).