From 6ac9ceec759c23c209e19b30ed81c68e02292667 Mon Sep 17 00:00:00 2001
From: CursedLand <cursedland@protonmail.com>
Date: Sat, 6 Aug 2022 23:52:02 +0200
Subject: [PATCH 1/5] Added Callbacks implementation for MemberCloner.

---
 .../Cloning/CallbackCloneListener.cs          | 22 ++++++++++
 .../Cloning/IMemberClonerListener.cs          | 15 +++++++
 .../Cloning/MemberCloner.Fields.cs            |  6 +++
 .../Cloning/MemberCloner.Methods.cs           |  6 +++
 .../Cloning/MemberCloner.Semantics.cs         |  8 ++++
 .../Cloning/MemberCloner.cs                   | 21 +++++++++-
 .../Cloning/MemberClonerListener.cs           | 41 +++++++++++++++++++
 .../Cloning/MetadataClonerTest.cs             | 30 +++++++++++++-
 8 files changed, 146 insertions(+), 3 deletions(-)
 create mode 100644 src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs
 create mode 100644 src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
 create mode 100644 src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs

diff --git a/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs b/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs
new file mode 100644
index 000000000..be7e1d945
--- /dev/null
+++ b/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace AsmResolver.DotNet.Cloning
+{
+    /// <inheritdoc/>
+    public class CallbackCloneListener : IMemberClonerListener
+    {
+
+        private readonly Action<IMetadataMember, IMetadataMember> _callback;
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="CallbackCloneListener"/> class.
+        /// </summary>
+        /// <param name="callback">The Callback used.</param>
+        public CallbackCloneListener(Action<IMetadataMember, IMetadataMember> callback) =>
+            _callback = callback;
+
+        /// <inheritdoc/>
+        public void OnClonedMember(IMetadataMember original, IMetadataMember cloned) =>
+            _callback(original, cloned);
+    }
+}
diff --git a/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs b/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
new file mode 100644
index 000000000..932723b41
--- /dev/null
+++ b/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
@@ -0,0 +1,15 @@
+namespace AsmResolver.DotNet.Cloning
+{
+    /// <summary>
+    /// <see cref="MemberCloner"/> Callback Listener.
+    /// </summary>
+    public interface IMemberClonerListener
+    {
+        /// <summary>
+        /// This function is called for every member got cloned.
+        /// </summary>
+        /// <param name="original">original member.</param>
+        /// <param name="cloned">cloned member.</param>
+        public void OnClonedMember(IMetadataMember original, IMetadataMember cloned);
+    }
+}
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs
index b68ab9c81..c797dfb48 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs
@@ -39,7 +39,13 @@ private static FieldDefinition CreateFieldStub(MemberCloneContext context, Field
         private void DeepCopyFields(MemberCloneContext context)
         {
             foreach (var field in _fieldsToClone)
+            {
                 DeepCopyField(context, field);
+                var clonedMember = (FieldDefinition)context.ClonedMembers[field];
+                _clonerListener.OnClonedMember(field, clonedMember);
+                if (_clonerListener is MemberClonerListener listener)
+                    listener.OnClonedField(field, clonedMember);
+            }
         }
 
         private void DeepCopyField(MemberCloneContext context, FieldDefinition field)
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs
index a7c2dc227..12c1f635f 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs
@@ -54,7 +54,13 @@ private static ParameterDefinition CloneParameterDefinition(MemberCloneContext c
         private void DeepCopyMethods(MemberCloneContext context)
         {
             foreach (var method in _methodsToClone)
+            {
                 DeepCopyMethod(context, method);
+                var clonedMember = (MethodDefinition)context.ClonedMembers[method];
+                _clonerListener.OnClonedMember(method, clonedMember);
+                if (_clonerListener is MemberClonerListener listener)
+                    listener.OnClonedMethod(method, clonedMember);
+            }
         }
 
         private void DeepCopyMethod(MemberCloneContext context, MethodDefinition method)
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs
index 10f3f30c4..c89fa9a4a 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs
@@ -17,6 +17,10 @@ private void DeepCopyProperties(MemberCloneContext context)
                 {
                     declaringType.Properties.Add(clonedProperty);
                 }
+                var clonedMember = clonedProperty;
+                _clonerListener.OnClonedMember(property, clonedMember);
+                if (_clonerListener is MemberClonerListener listener)
+                    listener.OnClonedProperty(property, clonedMember);
             }
         }
 
@@ -51,6 +55,10 @@ private void DeepCopyEvents(MemberCloneContext context)
                 {
                     declaringType.Events.Add(clonedEvent);
                 }
+                var clonedMember = clonedEvent;
+                _clonerListener.OnClonedMember(@event, clonedMember);
+                if (_clonerListener is MemberClonerListener listener)
+                    listener.OnClonedEvent(@event, clonedMember);
             }
         }
 
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
index 1580d1efa..7a7ee0da1 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
@@ -17,6 +17,7 @@ namespace AsmResolver.DotNet.Cloning
     /// </remarks>
     public partial class MemberCloner
     {
+        private readonly IMemberClonerListener _clonerListener;
         private readonly Func<MemberCloneContext, CloneContextAwareReferenceImporter>? _importerFactory;
         private readonly ModuleDefinition _targetModule;
 
@@ -30,7 +31,15 @@ public partial class MemberCloner
         /// Creates a new instance of the <see cref="MemberCloner"/> class.
         /// </summary>
         /// <param name="targetModule">The target module to copy the members into.</param>
-        public MemberCloner(ModuleDefinition targetModule) : this(targetModule, null) { }
+        /// <param name="callback">The callback used in the cloner listener.</param>
+        public MemberCloner(ModuleDefinition targetModule, Action<IMetadataMember, IMetadataMember>? callback = null) : this(targetModule, null, new CallbackCloneListener(callback ?? new Action<IMetadataMember, IMetadataMember>((orginal, cloned) => { }))) { }
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="MemberCloner"/> class.
+        /// </summary>
+        /// <param name="targetModule">The target module to copy the members into.</param>
+        /// <param name="listener">The callback listener used in the cloner.</param>
+        public MemberCloner(ModuleDefinition targetModule, IMemberClonerListener listener) : this(targetModule, null, listener) { }
 
         /// <summary>
         /// Creates a new instance of the <see cref="MemberCloner"/> class.
@@ -38,10 +47,12 @@ public MemberCloner(ModuleDefinition targetModule) : this(targetModule, null) {
         /// <param name="targetModule">The target module to copy the members into.</param>
         /// <param name="importerFactory">The factory for creating the reference importer</param>
         public MemberCloner(ModuleDefinition targetModule,
-            Func<MemberCloneContext, CloneContextAwareReferenceImporter>? importerFactory)
+            Func<MemberCloneContext, CloneContextAwareReferenceImporter>? importerFactory,
+            IMemberClonerListener clonerListener)
         {
             _targetModule = targetModule ?? throw new ArgumentNullException(nameof(targetModule));
             _importerFactory = importerFactory;
+            _clonerListener = clonerListener;
         }
 
         /// <summary>
@@ -272,7 +283,13 @@ private void DeepCopyMembers(MemberCloneContext context)
         private void DeepCopyTypes(MemberCloneContext context)
         {
             foreach (var type in _typesToClone)
+            {
                 DeepCopyType(context, type);
+                var clonedMember = (TypeDefinition)context.ClonedMembers[type];
+                _clonerListener.OnClonedMember(type, clonedMember);
+                if (_clonerListener is MemberClonerListener listener)
+                    listener.OnClonedType(type, clonedMember);
+            }
         }
 
         private void DeepCopyType(MemberCloneContext context, TypeDefinition type)
diff --git a/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs b/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
new file mode 100644
index 000000000..84c5b522d
--- /dev/null
+++ b/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
@@ -0,0 +1,41 @@
+namespace AsmResolver.DotNet.Cloning
+{
+    /// <summary>
+    /// <see cref="MemberCloner"/> Callback Listener.
+    /// </summary>
+    public abstract class MemberClonerListener : IMemberClonerListener
+    {
+        /// <inheritdoc/>
+        public abstract void OnClonedMember(IMetadataMember original, IMetadataMember cloned);
+        /// <summary>
+        /// This function is called for every type got cloned.
+        /// </summary>
+        /// <param name="original">original type.</param>
+        /// <param name="cloned">cloned type.</param>
+        public abstract void OnClonedType(TypeDefinition original, TypeDefinition cloned);
+        /// <summary>
+        /// This function is called for every method got cloned.
+        /// </summary>
+        /// <param name="original">original method.</param>
+        /// <param name="cloned">cloned method.</param>
+        public abstract void OnClonedMethod(MethodDefinition original, MethodDefinition cloned);
+        /// <summary>
+        /// This function is called for every field got cloned.
+        /// </summary>
+        /// <param name="original">original field.</param>
+        /// <param name="cloned">cloned field.</param>
+        public abstract void OnClonedField(FieldDefinition original, FieldDefinition cloned);
+        /// <summary>
+        /// This function is called for every property got cloned.
+        /// </summary>
+        /// <param name="original">original property.</param>
+        /// <param name="cloned">cloned property.</param>
+        public abstract void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned);
+        /// <summary>
+        /// This function is called for every event got cloned.
+        /// </summary>
+        /// <param name="original">original event.</param>
+        /// <param name="cloned">cloned event.</param>
+        public abstract void OnClonedEvent(EventDefinition original, EventDefinition cloned);
+    }
+}
diff --git a/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs b/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
index fadcc2b51..41441e4f9 100644
--- a/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
+++ b/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
@@ -329,5 +329,33 @@ public void CloneInterfaceImplementations()
                 originalTypeDef.Interfaces.Select(t => t.Interface.FullName),
                 clonedType.Interfaces.Select(t => t.Interface.FullName));
         }
+
+        [Fact]
+        public void CloneCallbackResult()
+        {
+            var sourceModule = ModuleDefinition.FromFile(typeof(Miscellaneous).Assembly.Location);
+            var type = sourceModule.TopLevelTypes.First(t => t.Name == nameof(Miscellaneous));
+
+            var targetModule = PrepareTempModule();
+
+            var reverseMethodsNames = (IMetadataMember original, IMetadataMember cloned) => {
+
+                if (cloned is MethodDefinition clonedDescriptor && original is MethodDefinition originalDescriptor)
+                    clonedDescriptor.Name = new string(originalDescriptor.Name.Reverse().ToArray());
+                
+            };
+
+            var result = new MemberCloner(targetModule, reverseMethodsNames)
+                .Include(type)
+                .Clone();
+
+            var clonedType = result.GetClonedMember(type);
+
+            Assert.Equal(
+                type.Methods.Select(m => m.Name.Reverse().ToArray()),
+                clonedType.Methods.Select(m => m.Name.ToArray()));
+
+        }
+
     }
-}
\ No newline at end of file
+}

From 4422b63c4814c69d6cf5c9335c35c76910edecd1 Mon Sep 17 00:00:00 2001
From: CursedLand <cursedland@protonmail.com>
Date: Sun, 7 Aug 2022 00:06:42 +0200
Subject: [PATCH 2/5] Add missing xmldocs.

---
 src/AsmResolver.DotNet/Cloning/MemberCloner.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
index 7a7ee0da1..208f6c273 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
@@ -46,6 +46,7 @@ public MemberCloner(ModuleDefinition targetModule, IMemberClonerListener listene
         /// </summary>
         /// <param name="targetModule">The target module to copy the members into.</param>
         /// <param name="importerFactory">The factory for creating the reference importer</param>
+        /// <param name="clonerListener">The listener used in the cloner.</param>
         public MemberCloner(ModuleDefinition targetModule,
             Func<MemberCloneContext, CloneContextAwareReferenceImporter>? importerFactory,
             IMemberClonerListener clonerListener)

From c1e163946c9735b7a319576b1e4952ab402d5332 Mon Sep 17 00:00:00 2001
From: CursedLand <cursedland@protonmail.com>
Date: Sun, 7 Aug 2022 14:32:19 +0200
Subject: [PATCH 3/5] Add CustomMemberClonerListener tests.

---
 .../Cloning/MetadataClonerTest.cs             | 20 ++++++++++++++
 .../AsmResolver.Tests.csproj                  |  1 +
 .../Listeners/CustomMemberClonerListener.cs   | 26 +++++++++++++++++++
 3 files changed, 47 insertions(+)
 create mode 100644 test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs

diff --git a/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs b/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
index 41441e4f9..6f96ea9b1 100644
--- a/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
+++ b/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
@@ -10,6 +10,7 @@
 using AsmResolver.DotNet.TestCases.Methods;
 using AsmResolver.DotNet.TestCases.Types;
 using AsmResolver.PE.DotNet.Cil;
+using AsmResolver.Tests.Listeners;
 using AsmResolver.Tests.Runners;
 using Xunit;
 
@@ -357,5 +358,24 @@ public void CloneCallbackResult()
 
         }
 
+        [Fact]
+        public void CloneCustomListenerResult() {
+            var sourceModule = ModuleDefinition.FromFile(typeof(Miscellaneous).Assembly.Location);
+            var type = sourceModule.TopLevelTypes.First(t => t.Name == nameof(Miscellaneous));
+
+            var targetModule = PrepareTempModule();
+
+            var result = new MemberCloner(targetModule, new CustomMemberClonerListener())
+                .Include(type)
+                .Clone();
+
+            var clonedType = result.GetClonedMember(type);
+
+            Assert.Equal(
+                type.Methods.Select(m => $"Method_{m.Name}"),
+                clonedType.Methods.Select(m => m.Name.ToString()));
+
+        }
+
     }
 }
diff --git a/test/AsmResolver.Tests/AsmResolver.Tests.csproj b/test/AsmResolver.Tests/AsmResolver.Tests.csproj
index 82f9cb9c6..122b6f398 100644
--- a/test/AsmResolver.Tests/AsmResolver.Tests.csproj
+++ b/test/AsmResolver.Tests/AsmResolver.Tests.csproj
@@ -17,6 +17,7 @@
     </ItemGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\..\src\AsmResolver.DotNet\AsmResolver.DotNet.csproj" />
       <ProjectReference Include="..\..\src\AsmResolver.PE.File\AsmResolver.PE.File.csproj" />
       <ProjectReference Include="..\..\src\AsmResolver\AsmResolver.csproj" />
     </ItemGroup>
diff --git a/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs b/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs
new file mode 100644
index 000000000..bcb386929
--- /dev/null
+++ b/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs
@@ -0,0 +1,26 @@
+using AsmResolver.DotNet;
+using AsmResolver.DotNet.Cloning;
+using System;
+
+namespace AsmResolver.Tests.Listeners {
+    public class CustomMemberClonerListener : MemberClonerListener {
+        public override void OnClonedEvent(EventDefinition original, EventDefinition cloned) =>
+            cloned.Name = $"Event_{original.Name}";
+
+        public override void OnClonedField(FieldDefinition original, FieldDefinition cloned) =>
+            cloned.Name = $"Field_{original.Name}";
+
+        public override void OnClonedMember(IMetadataMember original, IMetadataMember cloned) {
+
+        }
+
+        public override void OnClonedMethod(MethodDefinition original, MethodDefinition cloned) =>
+            cloned.Name = $"Method_{original.Name}";
+
+        public override void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned) =>
+            cloned.Name = $"Property_{original.Name}";
+
+        public override void OnClonedType(TypeDefinition original, TypeDefinition cloned) =>
+            cloned.Name = $"Type_{original.Name}";
+    }
+}

From 17e14ba10639c0c39bffa35e6e94ea9bfc180f99 Mon Sep 17 00:00:00 2001
From: CursedLand <cursedland@protonmail.com>
Date: Sun, 7 Aug 2022 22:49:16 +0200
Subject: [PATCH 4/5] Changes Request Applied.

---
 .../Cloning/CallbackCloneListener.cs          |  8 +--
 .../Cloning/IMemberClonerListener.cs          | 38 ++++++++++++--
 .../Cloning/MemberCloner.Fields.cs            |  3 +-
 .../Cloning/MemberCloner.Methods.cs           |  3 +-
 .../Cloning/MemberCloner.Semantics.cs         |  6 +--
 .../Cloning/MemberCloner.cs                   | 11 +++--
 .../Cloning/MemberClonerListener.cs           | 49 +++++--------------
 .../Cloning/MetadataClonerTest.cs             |  4 +-
 .../Listeners/CustomMemberClonerListener.cs   | 22 ++-------
 9 files changed, 71 insertions(+), 73 deletions(-)

diff --git a/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs b/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs
index be7e1d945..efa0063fd 100644
--- a/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs
+++ b/src/AsmResolver.DotNet/Cloning/CallbackCloneListener.cs
@@ -2,8 +2,10 @@
 
 namespace AsmResolver.DotNet.Cloning
 {
-    /// <inheritdoc/>
-    public class CallbackCloneListener : IMemberClonerListener
+    /// <summary>
+    /// This implementation that calls the <see cref="MemberClonerListener.OnClonedMember"/> to a callback action.
+    /// </summary>
+    public class CallbackCloneListener : MemberClonerListener
     {
 
         private readonly Action<IMetadataMember, IMetadataMember> _callback;
@@ -16,7 +18,7 @@ public CallbackCloneListener(Action<IMetadataMember, IMetadataMember> callback)
             _callback = callback;
 
         /// <inheritdoc/>
-        public void OnClonedMember(IMetadataMember original, IMetadataMember cloned) =>
+        public override void OnClonedMember(IMetadataMember original, IMetadataMember cloned) =>
             _callback(original, cloned);
     }
 }
diff --git a/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs b/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
index 932723b41..421839b9a 100644
--- a/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
+++ b/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
@@ -1,15 +1,45 @@
 namespace AsmResolver.DotNet.Cloning
 {
     /// <summary>
-    /// <see cref="MemberCloner"/> Callback Listener.
+    /// <see cref="MemberCloner"/> Callback listener that receives calls after cloning process.
     /// </summary>
     public interface IMemberClonerListener
     {
         /// <summary>
-        /// This function is called for every member got cloned.
+        /// This function is called for every member that got cloned.
         /// </summary>
-        /// <param name="original">original member.</param>
-        /// <param name="cloned">cloned member.</param>
+        /// <param name="original">The original member.</param>
+        /// <param name="cloned">The cloned member.</param>
         public void OnClonedMember(IMetadataMember original, IMetadataMember cloned);
+        /// <summary>
+        /// This function is called for every type got cloned.
+        /// </summary>
+        /// <param name="original">The original type.</param>
+        /// <param name="cloned">The cloned type.</param>
+        public void OnClonedType(TypeDefinition original, TypeDefinition cloned);
+        /// <summary>
+        /// This function is called for every method got cloned.
+        /// </summary>
+        /// <param name="original">The original method.</param>
+        /// <param name="cloned">The cloned method.</param>
+        public void OnClonedMethod(MethodDefinition original, MethodDefinition cloned);
+        /// <summary>
+        /// This function is called for every field got cloned.
+        /// </summary>
+        /// <param name="original">The original field.</param>
+        /// <param name="cloned">The cloned field.</param>
+        public void OnClonedField(FieldDefinition original, FieldDefinition cloned);
+        /// <summary>
+        /// This function is called for every property got cloned.
+        /// </summary>
+        /// <param name="original">The original property.</param>
+        /// <param name="cloned">The cloned property.</param>
+        public void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned);
+        /// <summary>
+        /// This function is called for every event got cloned.
+        /// </summary>
+        /// <param name="original">The original event.</param>
+        /// <param name="cloned">The cloned event.</param>
+        public void OnClonedEvent(EventDefinition original, EventDefinition cloned);
     }
 }
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs
index c797dfb48..78df400d3 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.Fields.cs
@@ -43,8 +43,7 @@ private void DeepCopyFields(MemberCloneContext context)
                 DeepCopyField(context, field);
                 var clonedMember = (FieldDefinition)context.ClonedMembers[field];
                 _clonerListener.OnClonedMember(field, clonedMember);
-                if (_clonerListener is MemberClonerListener listener)
-                    listener.OnClonedField(field, clonedMember);
+                _clonerListener.OnClonedField(field, clonedMember);
             }
         }
 
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs
index 12c1f635f..af6085a14 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.Methods.cs
@@ -58,8 +58,7 @@ private void DeepCopyMethods(MemberCloneContext context)
                 DeepCopyMethod(context, method);
                 var clonedMember = (MethodDefinition)context.ClonedMembers[method];
                 _clonerListener.OnClonedMember(method, clonedMember);
-                if (_clonerListener is MemberClonerListener listener)
-                    listener.OnClonedMethod(method, clonedMember);
+                _clonerListener.OnClonedMethod(method, clonedMember);
             }
         }
 
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs
index c89fa9a4a..7d3e5ea6b 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.Semantics.cs
@@ -19,8 +19,7 @@ private void DeepCopyProperties(MemberCloneContext context)
                 }
                 var clonedMember = clonedProperty;
                 _clonerListener.OnClonedMember(property, clonedMember);
-                if (_clonerListener is MemberClonerListener listener)
-                    listener.OnClonedProperty(property, clonedMember);
+                _clonerListener.OnClonedProperty(property, clonedMember);
             }
         }
 
@@ -57,8 +56,7 @@ private void DeepCopyEvents(MemberCloneContext context)
                 }
                 var clonedMember = clonedEvent;
                 _clonerListener.OnClonedMember(@event, clonedMember);
-                if (_clonerListener is MemberClonerListener listener)
-                    listener.OnClonedEvent(@event, clonedMember);
+                _clonerListener.OnClonedEvent(@event, clonedMember);
             }
         }
 
diff --git a/src/AsmResolver.DotNet/Cloning/MemberCloner.cs b/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
index 208f6c273..af5d27abd 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberCloner.cs
@@ -27,12 +27,18 @@ public partial class MemberCloner
         private readonly HashSet<PropertyDefinition> _propertiesToClone = new();
         private readonly HashSet<EventDefinition> _eventsToClone = new();
 
+        /// <summary>
+        /// Creates a new instance of the <see cref="MemberCloner"/> class.
+        /// </summary>
+        /// <param name="targetModule">The target module to copy the members into.</param>
+        public MemberCloner(ModuleDefinition targetModule) : this(targetModule, (original, cloned) => { }) { }
+
         /// <summary>
         /// Creates a new instance of the <see cref="MemberCloner"/> class.
         /// </summary>
         /// <param name="targetModule">The target module to copy the members into.</param>
         /// <param name="callback">The callback used in the cloner listener.</param>
-        public MemberCloner(ModuleDefinition targetModule, Action<IMetadataMember, IMetadataMember>? callback = null) : this(targetModule, null, new CallbackCloneListener(callback ?? new Action<IMetadataMember, IMetadataMember>((orginal, cloned) => { }))) { }
+        public MemberCloner(ModuleDefinition targetModule, Action<IMetadataMember, IMetadataMember> callback) : this(targetModule, new CallbackCloneListener(callback)) { }
 
         /// <summary>
         /// Creates a new instance of the <see cref="MemberCloner"/> class.
@@ -288,8 +294,7 @@ private void DeepCopyTypes(MemberCloneContext context)
                 DeepCopyType(context, type);
                 var clonedMember = (TypeDefinition)context.ClonedMembers[type];
                 _clonerListener.OnClonedMember(type, clonedMember);
-                if (_clonerListener is MemberClonerListener listener)
-                    listener.OnClonedType(type, clonedMember);
+                _clonerListener.OnClonedType(type, clonedMember);
             }
         }
 
diff --git a/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs b/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
index 84c5b522d..6f5531fed 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
@@ -1,41 +1,18 @@
 namespace AsmResolver.DotNet.Cloning
 {
-    /// <summary>
-    /// <see cref="MemberCloner"/> Callback Listener.
-    /// </summary>
-    public abstract class MemberClonerListener : IMemberClonerListener
-    {
+    /// <inheritdoc/>
+    public abstract class MemberClonerListener : IMemberClonerListener {
         /// <inheritdoc/>
-        public abstract void OnClonedMember(IMetadataMember original, IMetadataMember cloned);
-        /// <summary>
-        /// This function is called for every type got cloned.
-        /// </summary>
-        /// <param name="original">original type.</param>
-        /// <param name="cloned">cloned type.</param>
-        public abstract void OnClonedType(TypeDefinition original, TypeDefinition cloned);
-        /// <summary>
-        /// This function is called for every method got cloned.
-        /// </summary>
-        /// <param name="original">original method.</param>
-        /// <param name="cloned">cloned method.</param>
-        public abstract void OnClonedMethod(MethodDefinition original, MethodDefinition cloned);
-        /// <summary>
-        /// This function is called for every field got cloned.
-        /// </summary>
-        /// <param name="original">original field.</param>
-        /// <param name="cloned">cloned field.</param>
-        public abstract void OnClonedField(FieldDefinition original, FieldDefinition cloned);
-        /// <summary>
-        /// This function is called for every property got cloned.
-        /// </summary>
-        /// <param name="original">original property.</param>
-        /// <param name="cloned">cloned property.</param>
-        public abstract void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned);
-        /// <summary>
-        /// This function is called for every event got cloned.
-        /// </summary>
-        /// <param name="original">original event.</param>
-        /// <param name="cloned">cloned event.</param>
-        public abstract void OnClonedEvent(EventDefinition original, EventDefinition cloned);
+        public virtual void OnClonedMember(IMetadataMember original, IMetadataMember cloned) { }
+        /// <inheritdoc/>
+        public virtual void OnClonedEvent(EventDefinition original, EventDefinition cloned) { }
+        /// <inheritdoc/>
+        public virtual void OnClonedField(FieldDefinition original, FieldDefinition cloned) { }
+        /// <inheritdoc/>
+        public virtual void OnClonedMethod(MethodDefinition original, MethodDefinition cloned) { }
+        /// <inheritdoc/>
+        public virtual void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned) { }
+        /// <inheritdoc/>
+        public virtual void OnClonedType(TypeDefinition original, TypeDefinition cloned) { }
     }
 }
diff --git a/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs b/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
index 6f96ea9b1..9a8e72d2e 100644
--- a/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
+++ b/test/AsmResolver.DotNet.Tests/Cloning/MetadataClonerTest.cs
@@ -359,7 +359,9 @@ public void CloneCallbackResult()
         }
 
         [Fact]
-        public void CloneCustomListenerResult() {
+        public void CloneCustomListenerResult()
+        {
+
             var sourceModule = ModuleDefinition.FromFile(typeof(Miscellaneous).Assembly.Location);
             var type = sourceModule.TopLevelTypes.First(t => t.Name == nameof(Miscellaneous));
 
diff --git a/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs b/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs
index bcb386929..0afb61f6d 100644
--- a/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs
+++ b/test/AsmResolver.Tests/Listeners/CustomMemberClonerListener.cs
@@ -2,25 +2,11 @@
 using AsmResolver.DotNet.Cloning;
 using System;
 
-namespace AsmResolver.Tests.Listeners {
-    public class CustomMemberClonerListener : MemberClonerListener {
-        public override void OnClonedEvent(EventDefinition original, EventDefinition cloned) =>
-            cloned.Name = $"Event_{original.Name}";
-
-        public override void OnClonedField(FieldDefinition original, FieldDefinition cloned) =>
-            cloned.Name = $"Field_{original.Name}";
-
-        public override void OnClonedMember(IMetadataMember original, IMetadataMember cloned) {
-
-        }
-
+namespace AsmResolver.Tests.Listeners
+{
+    public class CustomMemberClonerListener : MemberClonerListener
+    {
         public override void OnClonedMethod(MethodDefinition original, MethodDefinition cloned) =>
             cloned.Name = $"Method_{original.Name}";
-
-        public override void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned) =>
-            cloned.Name = $"Property_{original.Name}";
-
-        public override void OnClonedType(TypeDefinition original, TypeDefinition cloned) =>
-            cloned.Name = $"Type_{original.Name}";
     }
 }

From 80d5d8bf21dbe2cb66b2059404929f2c00c254cb Mon Sep 17 00:00:00 2001
From: CursedLand <cursedland@protonmail.com>
Date: Mon, 8 Aug 2022 23:09:18 +0200
Subject: [PATCH 5/5] Syntax & Grammer fixs.

---
 .../Cloning/IMemberClonerListener.cs                   | 10 +++++-----
 src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs |  3 ++-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs b/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
index 421839b9a..1a6ecaada 100644
--- a/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
+++ b/src/AsmResolver.DotNet/Cloning/IMemberClonerListener.cs
@@ -12,31 +12,31 @@ public interface IMemberClonerListener
         /// <param name="cloned">The cloned member.</param>
         public void OnClonedMember(IMetadataMember original, IMetadataMember cloned);
         /// <summary>
-        /// This function is called for every type got cloned.
+        /// This function is called for every type that got cloned.
         /// </summary>
         /// <param name="original">The original type.</param>
         /// <param name="cloned">The cloned type.</param>
         public void OnClonedType(TypeDefinition original, TypeDefinition cloned);
         /// <summary>
-        /// This function is called for every method got cloned.
+        /// This function is called for every method that got cloned.
         /// </summary>
         /// <param name="original">The original method.</param>
         /// <param name="cloned">The cloned method.</param>
         public void OnClonedMethod(MethodDefinition original, MethodDefinition cloned);
         /// <summary>
-        /// This function is called for every field got cloned.
+        /// This function is called for every field that got cloned.
         /// </summary>
         /// <param name="original">The original field.</param>
         /// <param name="cloned">The cloned field.</param>
         public void OnClonedField(FieldDefinition original, FieldDefinition cloned);
         /// <summary>
-        /// This function is called for every property got cloned.
+        /// This function is called for every property that got cloned.
         /// </summary>
         /// <param name="original">The original property.</param>
         /// <param name="cloned">The cloned property.</param>
         public void OnClonedProperty(PropertyDefinition original, PropertyDefinition cloned);
         /// <summary>
-        /// This function is called for every event got cloned.
+        /// This function is called for every event that got cloned.
         /// </summary>
         /// <param name="original">The original event.</param>
         /// <param name="cloned">The cloned event.</param>
diff --git a/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs b/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
index 6f5531fed..49bea854a 100644
--- a/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
+++ b/src/AsmResolver.DotNet/Cloning/MemberClonerListener.cs
@@ -1,7 +1,8 @@
 namespace AsmResolver.DotNet.Cloning
 {
     /// <inheritdoc/>
-    public abstract class MemberClonerListener : IMemberClonerListener {
+    public abstract class MemberClonerListener : IMemberClonerListener
+    {
         /// <inheritdoc/>
         public virtual void OnClonedMember(IMetadataMember original, IMetadataMember cloned) { }
         /// <inheritdoc/>