From: 011netservice@gmail.com
Date: 2022-04-24
Subject: MemberwiseClone.txt

Summary:
1. MemberwiseClone() 是 protected method, 只能在 class 內部呼叫.
2. 建議搭配 ICloneable interface 使用, 統一以 Clone() 名稱提供 (預設複製物件的方法).
3. 使用 ICloneable 時, 建議同時實作可複寫的 protected virtual 方法, 提供子物件可自行決定預設的 Clone() 方法是 (ShallowCopy 淺層複製), 還是(DeepCopy 深層複製)  
4. 如需深層複製, 可經由 Reflection 取得執行時期的設定, 複製為新物件的設定. 參考 ZClone() 實作方式.

----------
20200807


https://www.c-sharpcorner.com/UploadFile/ff2f08/deep-copy-of-object-in-C-Sharp/
Reflection is used for obtaining Meta information of an object at runtime. The System.Reflection namespace has classes that allow us to obtain object information at runtime as well as we can create an instance of a type of object from the existing object and also accessing its properties and invoke its methods. To do a deep copy of an object, we can use reflection. Consider the following code. Here I have created one static method that accepts any object and it returns the same type of object with a new reference.

深層複製: 物件可經由 Reflection 取得執行時期的設定, 複製為新物件的設定.

 
        /// <summary>
        /// 深層複製(Deep Copy)物件.
        /// 包括(屬性、清單)都會複製.
        /// </summary>
        /// <param name="objSource"></param>
        /// <returns></returns>
        public static object ZClone(this object objSource)
        {
            // https://www.c-sharpcorner.com/UploadFile/ff2f08/deep-copy-of-object-in-C-Sharp/

            //Get the type of source object and create a new instance of that type
            Type typeSource = objSource.GetType();
            object objTarget = Activator.CreateInstance(typeSource);

            //Get all the properties of source object type
            PropertyInfo[] propertyInfo = typeSource.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            //Assign all source property to taget object 's properties
            foreach (PropertyInfo property in propertyInfo)
            {
                //Check whether property can be written to
                if (property.CanWrite)
                {
                    //check whether property type is value type, enum or string type
                    if (property.PropertyType.IsValueType || property.PropertyType.IsEnum || property.PropertyType.Equals(typeof(System.String)))
                    {
                        property.SetValue(objTarget, property.GetValue(objSource, null), null);
                    }
                    else
                    {
                        object objPropertyValue = property.GetValue(objSource, null);
                        if (objPropertyValue == null)
                        {
                            property.SetValue(objTarget, null, null);
                        }
                        else
                        {
                            //else property type is object/complex types, so need to recursively call this method until the end of the tree is reached
                            property.SetValue(objTarget, objPropertyValue.ZClone(), null);
                        }
                    }
                }
            }
            return objTarget;
        }



----------
20200804

ICloneable with MemberwiseClone

https://stackoverflow.com/questions/21116554/proper-way-to-implement-icloneable

You can easily create a superficial clone with object's protected method MemberwiseClone.

Example:

若只需要淺層複製, 則這樣寫就可以:
   public abstract class AbstractCloneable : ICloneable // 統一以 Clone() 名稱提供 (預設複製物件的方法)
   {
      public object Clone()
      {
         return this.MemberwiseClone(); // MemberwiseClone() 是(ShallowCopy 淺層複製)
		 ... 其他的欄位
		   例如 string, 可使用 String.Copy(StringTypeField) 複製新字串.
      }
   }
If you don't need anything like a deep copy, you will not have to do anything in the child classes.
The MemberwiseClone method creates a shallow copy by creating a new object, and then copying the nonstatic fields of the current object to the new object. If a field is a value type, a bit-by-bit copy of the field is performed. If a field is a reference type, the reference is copied but the referred object is not; therefore, the original object and its clone refer to the same object.


若子類別也需要自行決定 Clone() 的複製方法, 則可提供一個(可複寫的 protected virtual 方法)給子類別覆寫後, 改變 Clone() 的實作內容:
If you need more intelligence in the cloning logic, you can add a virtual method to handle references :

   public abstract class AbstractCloneable : ICloneable // 統一以 Clone() 名稱提供複製物件的方法
   {
      public object Clone()
      {
         var clone = (AbstractCloneable) this.MemberwiseClone(); // 預設只需執行 MemberwiseClone() 淺層複製就可回傳.
         HandleCloned(clone);  // 呼叫深層複製的加工.
         return clone; 
      }

      protected virtual HandleCloned(AbstractCloneable clone) // 子類別可覆寫為不同的內容
      {
		
         //Nothing particular in the base class, but maybe useful for children.
         //Not abstract so children may not implement this if they don't need to.
		 // 若需深層複製, 則在此複製其他欄位.
		 // ... 其他的欄位
		 //   例如 string, 可使用 String.Copy(StringTypeField) 複製新字串.
      }
   }

在子類別中, 可複寫 HandleCloned() 決定 Clone() 的複製方式如下:
   public class ConcreteCloneable : AbstractCloneable
   {
       protected override HandleCloned(AbstractCloneable clone)
       {
           //Get whathever magic a base class could have implemented.
           base.HandleCloned(clone);  // 照母類別的方式做

           //Clone is of the current type.
           ConcreteCloneable obj = (ConcreteCloneable) clone; // 轉型為子類別

           //Here you have a superficial copy of "this". You can do whathever 
           //specific task you need to do.
           //e.g.:
           obj.SomeReferencedProperty = this.SomeReferencedProperty.Clone();  // 子類別每一個屬性, 再執行(屬性本身的 )Clone()方法, 複製為新的屬性 Instance. 
       }
   }


----------
20200804

What is the best way to clone/deep copy a .NET generic Dictionary<string, T>?

https://stackoverflow.com/questions/139592/what-is-the-best-way-to-clone-deep-copy-a-net-generic-dictionarystring-t

Okay, the .NET 2.0 answers:

If you don't need to clone the values, you can use the constructor overload to Dictionary which takes an existing IDictionary. (You can specify the comparer as the existing dictionary's comparer, too.)

If you do need to clone the values, you can use something like this:

public static Dictionary<TKey, TValue> CloneDictionaryCloningValues<TKey, TValue>
   (Dictionary<TKey, TValue> original) where TValue : ICloneable
{
    Dictionary<TKey, TValue> ret = new Dictionary<TKey, TValue>(original.Count,
                                                            original.Comparer);
    foreach (KeyValuePair<TKey, TValue> entry in original)
    {
        ret.Add(entry.Key, (TValue) entry.Value.Clone());
    }
    return ret;
}
That relies on TValue.Clone() being a suitably deep clone as well, of course.


----------
20200804

How create a new deep copy (clone) of a List<T>?

https://stackoverflow.com/questions/14007405/how-create-a-new-deep-copy-clone-of-a-listt


The problem with cloning objects and, especially the ICloneable interface, is that the public interface doesn't communicate the intention well.

Namely - will such Clone function of the List<T> clone contained elements as well, or just clone the list and copy the references to contained elements? Shallow copy, which copies the references and only creates the new list would be equivalent to this:

通常只淺層複製 Shallow copy 如下:
  List<T> clone = new List<T>(originalList);

However, if you wanted to force all the contained elements to be cloned as well, then it would be equivalent to this:

若需逐項深層複製 Deep copy, 則需如下寫法:
  List<T> clone = originalList.Select(x => (T)x.Clone()).ToList();
但是這個寫法, 仍無法確認個別元素是否支援了 ICloneable 介面? 以及元素的 Clone() 是否為深層複製 ?  
  

This assumes that the type T is implementing ICloneable. However, even with this solution, exact effects of code execution cannot be told in advance. What does it mean for an element x to clone itself? Will it be a shallow copy (offered by the MemberwiseClone method it inherits form System.Object), or will it be a deep copy. And if deep, what will happen if two objects in the list are referencing the same third object? Will that third object be copied twice or only once? And so on... you can see where this is going.

For all the reasons listed above, cloning facilities are not incorporated in the framework. It is left to custom code to decide what it means to clone an object and then implement custom code for that.

You need to create new Book objects then put those in a new List:
  List<Book> books_2 = books_1.Select(book => new Book(book.title)).ToList();

Update: Slightly simpler... List<T> has a method called ConvertAll that returns a new list:
  List<Book> books_2 = books_1.ConvertAll(book => new Book(book.title));
  
  
  https://stackoverflow.com/questions/40953968/why-is-listt-not-clonable/40954103
  
To make a cloneable List type you would do:

public class CloneableList<T> : List<T>, ICloneable
{
    public object Clone() {
        var clone = new CloneableList<T>();
        clone.AddRange(this);
        return clone;
    }
}
Or this if you want it deeply cloned:

public class DeepCloneableList<T> : List<T>, ICloneable where T : ICloneable
{
    public object Clone() {
        var clone = new DeepCloneableList<T>();
        clone.AddRange(this.Select(x => (T)x.Clone()));
        return clone;
    }
}

Because List<T> does not inherit from IClonable. If you want to do a clone of a list you could do...

var t = new List<IClonable>();
var newList = t.Select(a=>a.Clone()).ToList();



----------
20200714

/*
ZItem.cs
萬用的項目物件.

20200730, Honda, Base on ZLib.

常用1: 作為臨時使用的List<T>, Dictionary<TKey, TValue>的項目存放物件.

常用2: 替代 Tuple 回傳多值.
  1. Tuple的用法, 容易混淆. 
  2. 可改用 ZTuple 以 Class 的方式包裝常用的欄位
public static Tuple<int, string, bool> TupleGetInfo()
{
    return new Tuple<int, string, bool>(1, "小明", true);
}
 
private static void Main(string[] args)
{
    Tuple<int, string, bool> Info = TupleGetInfo();
    int UserID = Info.Item1;
    string UserName = Info.Item2;
    bool UserSex = Info.Item3;
    Console.ReadLine();
}


*/


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ZLib
{
    public class ZItem
    {
        public string Type;
        public string Key;
        public string Value;
        public DateTime Time;
        public ZItem ZShallowCopy()
        {
            // The MemberwiseClone method creates a shallow copy by creating a new object, and then copying the nonstatic fields of the current object to the new object. 
            // If a field is a value type, a bit-by-bit copy of the field is performed. 
            // If a field is a reference type, the reference is copied but the referred object is not; 
            // therefore, the original object and its clone refer to the same object.
            return (ZItem)MemberwiseClone(); // CodeHelper MemberwiseClone ShallowCopy 淺層複製. 實質型別欄位的值 以及 (參考型別 及 string)的位址.
        }
        public ZItem ZDeepCopy() // CodeHelper DeepCopy 深層複製. 先執行(ShallowCopy 淺層複製實質型別欄位), 再逐一複製(參考型別及 String )欄位的值.
        {
            ZItem other = ZShallowCopy();
            other.Type = String.Copy(Type);
            other.Key = String.Copy(Key);
            other.Value = String.Copy(Value);
            return other;
        }
    }
}

----------
20200803

Nuget 上的 DeepCloner 套件(原始碼)

https://github.com/force-net/DeepCloner


----------
20200803

https://linmasaki09.blogspot.com/2018/07/c-shallow-clonecopydeep-clonecopy.html

C# 建立物件的淺層複製(Shallow Clone/Copy)及深層複製(Deep Clone/Copy)
這幾天在使用 Memory Cache 時，意外發現外部的修改會影響到 Memory Cache 原本的值，進而延伸出其它神奇的問題，追根究柢，主要是因為在存取 Memory Cache 值時，都是使用同一份參考(reference)，造成程式上某個地方改動該 Cache 值時，其它地方都會受到影響，所以我的解決方式就是深層複製出一份 Cache 的值供外部使用，防止外部操作去更動到原始 Cache 值 類似的問題其實以前就遇過了，但當時因為手上太多案子所以就只在網路上找ㄧ些快速解法複製貼上而不了了之(菸~~~)，這次趁休假空擋整理出ㄧ些覺得還不錯的實作方式及順便比較一下優缺點。


0. 一般使用狀況(無使用任何深層複製)

public class Item
{
    public string Name { get; set; }
    public int Number { get; set; }
    public List<string> Features { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        var clone = source;

        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine("Source" + Environment.NewLine + "Name: "+ source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));
    }
}

/* 輸出結果(原始資料被更動了) */
//Source Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 
1. 使用 BinaryFormatter 複製
優點: 幾乎可完美處理任何複雜的物件，網路上查到的大多也都是這個方式
缺點: 執行時間較其他方式長，複製對象 Class 必需標記 [Serializable] 標籤有點麻煩

先建立一個擴充方法如下

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

public static class CommonExtensions
{
    /// <summary>
    /// 深層複製(複製對象必需可序列化)
    /// </summary>
    /// <typeparam name="T">複製對象類別</typeparam>
    /// <param name="source">複製對象
    /// <returns>複製出的物件</returns>
    public static T DeepClone<T>(this T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", nameof(source));
        }

        if (source != null)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(stream, source);
                stream.Seek(0, SeekOrigin.Begin);
                return (T)formatter.Deserialize(stream);
            }
        }

        return default(T);
    }
}
使用方式如下

[Serializable]
public class Item
{
    public string Name { get; set; }
    public int Number { get; set; }
    public List<string> Features { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        var clone = source.DeepClone();

        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine("Source" + Environment.NewLine + "Name: "+ source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));
    }
}

/* 輸出結果(原始資料不變) */
//Source Object
//Name: The Lord of the Rings
//Number: 10
//Features: Love, Funny
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 
2. 使用 Newtonsoft.Json 套件
優點: 輕巧、簡單、速度比 BinaryFormatter 快上不少，基本上不知道要挑哪一個方式又想自己寫時，我會傾向建議使用此方式
缺點: Private 欄位無法被複製到，遇到循環參考會出錯(解決方式可參考這篇)

建立一個擴充方法如下

using System;
using Newtonsoft.Json;

public static class CommonExtensions
{  
    /// <summary>
    /// 深層複製
    /// </summary>
    /// <typeparam name="T">複製對象類別</typeparam>
    /// <param name="source">複製對象
    /// <returns>複製出的物件</returns>
    public static T DeepCloneByJson<T>(this T source)
    {
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }
        var deserializeSettings = new JsonSerializerSettings { ObjectCreationHandling = ObjectCreationHandling.Replace };
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source), deserializeSettings);
    }
}
使用方式如下

public class Item
{
    public string Name { get; set; }
    public int Number { get; set; }
    public List<string> Features { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        var clone = source.DeepCloneByJson();

        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine("Source" + Environment.NewLine + "Name: "+ source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));
    }
}

/* 輸出結果(原始資料不變) */
//Source Object
//Name: The Lord of the Rings
//Number: 10
//Features: Love, Funny
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 
3. 使用 Expression Trees 方式(參考來源)
優點: 速度又比第二種方式更快，也可處理 Private 欄位、循環參考的問題
缺點: Framework 需 .NET 4 以上，我有遇到當型態是 IEnumerable<T> 時，會跳出錯誤(目前我是先轉 List<T> 型態解決)，除此之外，還沒遇到其它問題

由於該擴充方法的程式碼有點冗長，所以這邊直接提供原始碼檔案下載，然後使用方式參考下面

public class Item
{
    public string Name { get; set; }
    public int Number { get; set; }
    public List<string> Features { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        var clone = source.DeepCopyByExpressionTree();

        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine("Source Object" + Environment.NewLine + "Name: "+ source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone Object" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));
    }
}

/* 輸出結果(原始資料不變) */
//Source Object
//Name: The Lord of the Rings
//Number: 10
//Features: Love, Funny
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 
4. 在 Class 裡手動撰寫 DeepCopy 和 ShallowCopy 方法
優點: 速度最快，假設有其他更快的方式，請告知我，感恩
缺點: 必須撰寫較多的程式碼，後續維護較麻煩且容易有人為上的疏失(假如你夠細心的話可無視)

ShallowCopy 微軟提供了內建方法Object.MemberwiseClone()供呼叫，和 DeepCopy 的差意主要是前者只複製實值(Value)型別的欄位，如果是參考(reference)型別的欄位，則只複製該物件欄位的參考位址，所以該欄位的值還是屬於和大家共用的狀態，至於什麼是參考型別還實值型別，由於不在本篇討論的範圍，有興趣的讀者可以自行參考這兩篇文章：一、Value Type(實值型別) vs Reference Type(參考型別)、二、實值型別與參考型別的記憶體配置

這邊分別比較使用這兩種方式的結果

public class Item
{
    public Item ShallowCopy()
    {
        return (Item)this.MemberwiseClone();
    }

    public Item DeepCopy()
    {
        var other = (Item)this.MemberwiseClone();
        other.Name = String.Copy(Name);
        other.Features = new List<string>();
        foreach (var m in Features)
        {
            other.Features.Add(m);
        }

        return other;
    }

    public string Name { get; set; }
    public int Number { get; set; }
    public List<string> Features { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        /* ShallowCopy */
        var source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        var clone = source.ShallowCopy();

        clone.Name = "Harry Potter";
        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine("*** ShallowCopy ***");
        Console.WriteLine("Source Object" + Environment.NewLine + "Name: "+ source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone Object" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));

        /* DeepCopy */
        source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        clone = source.DeepCopy();

        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine(Environment.NewLine + "*** DeepCopy ***");
        Console.WriteLine("Source Object" + Environment.NewLine + "Name: " + source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone Object" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));
    }
}

/* 輸出結果 */
//*** ShallowCopy(原物件的實值型別欄位沒有被更動,但欄位Features的值被更動了) ***
//Source Object
//Name: The Lord of the Rings
//Number: 10
//Features: Adventure, Magic
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 

//*** DeepCopy(原物件的欄位都沒有被更動) ***
//Source Object
//Name: The Lord of the Rings
//Number: 10
//Features: Love, Funny
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 
到這邊我猜有些讀者應該和我一樣，會有一個疑問就是string也是參考型別，但在執行 ShallowCopy 的時候，怎麼 source 物件的 Name 屬性確沒有被修改到，抱著該疑問查找了一下資料後，原因主要在於 CLR string 屬於不可變變數(Immutable)，一但宣告建立後就不可再改變或重組，所以當變更 clone 物件的 Name 值時，實際上是重新分配了一塊記憶體給 clone 的 Name 屬性使用，造成兩個物件的 Name 屬性已指向不同的記憶體區塊

5. Nuget 上的 DeepCloner 套件(原始碼)
優點: 速度比使用 Expression Trees 方式還快一些，懶得自己寫程式碼時，是一個還不錯的選擇，官方文件也有提供和各種方式的效能比較
缺點: 需另外安裝額外的套件，且需 .NET Framework 4 以上，不過它有支援 .Net Standard 算是一種優點吧!?

使用前需先從 Nuget 上安裝，使用方式如下

public class Item
{
    public string Name { get; set; }
    public int Number { get; set; }
    public List<string> Features { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var source = new Item { Name = "The Lord of the Rings", Number = 10, Features = new List<string> { "Love", "Funny" } };
        var clone = source.DeepClone();

        clone.Name = "Harry Potter";
        clone.Number = 30;
        clone.Features[0] = "Adventure";
        clone.Features[1] = "Magic";

        Console.WriteLine("Source Object" + Environment.NewLine + "Name: "+ source.Name + Environment.NewLine + "Number: " + source.Number + Environment.NewLine + "Features: " + string.Join(", ", source.Features));
        Console.WriteLine();
        Console.WriteLine("Clone Object" + Environment.NewLine + "Name: " + clone.Name + Environment.NewLine + "Number: " + clone.Number + Environment.NewLine + "Features: " + string.Join(", ", clone.Features));
    }
}

/* 輸出結果(原始資料不變) */
//Source Object
//Name: The Lord of the Rings
//Number: 10
//Features: Love, Funny
//
//Clone Object
//Name: Harry Potter
//Number: 30
//Features: Adventure, Magic 
總結
經我自己測試後，大概整理出以下的心得

效能(處理時間)： 4 > 5 > 3 > 2 > 1

實用性(之後我專案傾向採用的機率來排序)： 5 > 2 = 3 > 1 > 4

事實上，真的很難挑出一個十全十美的處理方式，我認為選擇出一種最適合目前手上專案的才是最重要的