1. class Program
  2. {
  3. ///
  5. <summary>
  6. /// Delegate handler that's used to compile the IL to.
  7. /// (This delegate is standard in .net 3.5)
  8. /// </summary>
  11. /// <typeparam name="T1">Parameter Type</typeparam>
  12. /// <typeparam name="TResult">Return Type</typeparam>
  13. /// <param name="arg1">Argument</param>
  14. /// <returns>Result</returns>
  15. public delegate TResult Func<T1, TResult>(T1 arg1);
  16. ///
  18. <summary>
  19. /// This dictionary caches the delegates for each 'to-clone' type.
  20. /// </summary>
  23. static Dictionary<Type, Delegate> _cachedIL = new Dictionary<Type, Delegate>();
  25. ///
  27. <summary>
  28. /// The Main method that's executed for the test.
  29. /// </summary>
  32. /// <param name="args"></param>
  33. static void Main(string[] args)
  34. {
  35. DoCloningTest(1000);
  36. DoCloningTest(10000);
  37. DoCloningTest(100000);
  38. //Commented because the test takes long <img class="emoji" draggable="false" alt="??" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/1f609.svg">
  39. //DoCloningTest(1000000);
  41. Console.ReadKey();
  42. }
  44. ///
  46. <summary>
  47. /// Do the cloning test and printout the results.
  48. /// </summary>
  51. /// <param name="count">Number of items to clone</param>
  52. private static void DoCloningTest(int count)
  53. {
  54. // Create timer class.
  55. HiPerfTimer timer = new HiPerfTimer();
  56. double timeElapsedN = 0, timeElapsedR = 0, timeElapsedIL = 0;
  58. Console.WriteLine("--> Creating {0} objects...", count);
  59. timer.StartNew();
  60. List<Person> personsToClone = CreatePersonsList(count);
  61. timer.Stop();
  62. Person temp = CloneObjectWithIL(personsToClone[0]);
  63. temp = null;
  64. Console.WriteLine("\tCreated objects in {0} seconds", timer.Duration);
  66. Console.WriteLine("- Cloning Normal...");
  67. List<Person> clonedPersons = new List<Person>(count);
  68. timer.StartNew();
  69. foreach (Person p in personsToClone)
  70. {
  71. clonedPersons.Add(CloneNormal(p));
  72. }
  73. timer.Stop();
  74. timeElapsedN = timer.Duration;
  76. Console.WriteLine("- Cloning IL...");
  77. clonedPersons = new List<Person>(count);
  78. timer.StartNew();
  79. foreach (Person p in personsToClone)
  80. {
  81. clonedPersons.Add(CloneObjectWithIL<Person>(p));
  82. }
  83. timer.Stop();
  84. timeElapsedIL = timer.Duration;
  86. Console.WriteLine("- Cloning Reflection...");
  87. clonedPersons = new List<Person>(count);
  88. timer.StartNew();
  89. foreach (Person p in personsToClone)
  90. {
  91. clonedPersons.Add(CloneObjectWithReflection(p));
  92. }
  93. timer.Stop();
  94. timeElapsedR = timer.Duration;
  96. Console.WriteLine();
  97. Console.ForegroundColor = ConsoleColor.Green;
  98. Console.WriteLine("----------------------------------------");
  99. Console.WriteLine("Object count:\t\t{0}", count);
  100. Console.WriteLine("Cloning Normal:\t\t{0:00.0000} s", timeElapsedN);
  101. Console.WriteLine("Cloning IL:\t\t{0:00.0000} s", timeElapsedIL);
  102. Console.WriteLine("Cloning Reflection:\t{0:00.0000} s", timeElapsedR);
  103. Console.WriteLine("----------------------------------------");
  104. Console.ResetColor();
  105. }
  107. ///
  109. <summary>
  110. /// Create a list of persons with random data and a given number of items.
  111. /// </summary>
  114. /// <param name="count">Number of persons to generate</param>
  115. /// <returns>List of generated persons</returns>
  116. private static List<Person> CreatePersonsList(int count)
  117. {
  118. Random r = new Random(Environment.TickCount);
  119. List<Person> persons = new List<Person>(count);
  120. for (int i = 0; i < count; i++)
  121. {
  122. Person p = new Person();
  123. p.ID = r.Next();
  124. p.Name = string.Concat("Slaets_", r.Next());
  125. p.FirstName = string.Concat("Filip_", r.Next());
  126. persons.Add(p);
  127. }
  128. return persons;
  129. }
  131. ///
  133. <summary>
  134. /// Clone one person object with reflection
  135. /// </summary>
  138. /// <param name="p">Person to clone</param>
  139. /// <returns>Cloned person</returns>
  140. private static Person CloneObjectWithReflection(Person p)
  141. {
  142. // Get all the fields of the type, also the privates.
  143. FieldInfo[] fis = p.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
  144. // Create a new person object
  145. Person newPerson = new Person();
  146. // Loop through all the fields and copy the information from the parameter class
  147. // to the newPerson class.
  148. foreach (FieldInfo fi in fis)
  149. {
  150. fi.SetValue(newPerson, fi.GetValue(p));
  151. }
  152. // Return the cloned object.
  153. return newPerson;
  154. }
  156. ///
  158. <summary>
  159. /// Generic cloning method that clones an object using IL.
  160. /// Only the first call of a certain type will hold back performance.
  161. /// After the first call, the compiled IL is executed.
  162. /// </summary>
  165. /// <typeparam name="T">Type of object to clone</typeparam>
  166. /// <param name="myObject">Object to clone</param>
  167. /// <returns>Cloned object</returns>
  168. private static T CloneObjectWithIL<T>(T myObject)
  169. {
  170. Delegate myExec = null;
  171. if (!_cachedIL.TryGetValue(typeof(T), out myExec))
  172. {
  173. // Create ILGenerator
  174. DynamicMethod dymMethod = new DynamicMethod("DoClone", typeof(T), new Type[] { typeof(T) }, true);
  175. ConstructorInfo cInfo = myObject.GetType().GetConstructor(new Type[] { });
  177. ILGenerator generator = dymMethod.GetILGenerator();
  179. LocalBuilder lbf = generator.DeclareLocal(typeof(T));
  180. //lbf.SetLocalSymInfo("_temp");
  182. generator.Emit(OpCodes.Newobj, cInfo);
  183. generator.Emit(OpCodes.Stloc_0);
  184. foreach (FieldInfo field in myObject.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic))
  185. {
  186. // Load the new object on the eval stack... (currently 1 item on eval stack)
  187. generator.Emit(OpCodes.Ldloc_0);
  188. // Load initial object (parameter) (currently 2 items on eval stack)
  189. generator.Emit(OpCodes.Ldarg_0);
  190. // Replace value by field value (still currently 2 items on eval stack)
  191. generator.Emit(OpCodes.Ldfld, field);
  192. // Store the value of the top on the eval stack into the object underneath that value on the value stack.
  193. // (0 items on eval stack)
  194. generator.Emit(OpCodes.Stfld, field);
  195. }
  197. // Load new constructed obj on eval stack -> 1 item on stack
  198. generator.Emit(OpCodes.Ldloc_0);
  199. // Return constructed object. --> 0 items on stack
  200. generator.Emit(OpCodes.Ret);
  202. myExec = dymMethod.CreateDelegate(typeof(Func<T, T>));
  203. _cachedIL.Add(typeof(T), myExec);
  204. }
  205. return ((Func<T, T>)myExec)(myObject);
  206. }
  208. ///
  210. <summary>
  211. /// Clone a person object by manually typing the copy statements.
  212. /// </summary>
  215. /// <param name="p">Object to clone</param>
  216. /// <returns>Cloned object</returns>
  217. private static Person CloneNormal(Person p)
  218. {
  219. Person newPerson = new Person();
  220. newPerson.ID = p.ID;
  221. newPerson.Name = p.Name;
  222. newPerson.FirstName = p.FirstName;
  223. return newPerson;
  224. }
  225. }