introduce CloneBehavior

Author: lofcz

README.md

@@ -108,18 +108,26 @@ TreeNode clone = child.DeepClone();
 
 This differs from `[FastClonerIgnore]` which leaves the member as `null`/default. With `[FastClonerShallow]`, the original reference is preserved.
 
-You might also need to exclude certain types from ever being cloned. To do that, put offending types on a blacklist:
-```cs
-FastCloner.FastCloner.IgnoreType(typeof(PropertyChangedEventHandler)); // or FastCloner.FastCloner.IgnoreTypes([ .. ])
+You might also need to customize how certain types are handled globally. Use `FastCloner.FastCloner.SetTypeBehavior<T>` to configure specific behaviors.
+
+```csharp
+FastCloner.FastCloner.SetTypeBehavior<MySingletonService>(CloneBehavior.Skip);
 ```
 
-If needed, the types can be removed from the blacklist later:
-```cs
-// note: doing this invalidates precompiled expressions and clears the cache,
-// performance will be negatively affected until the cache is repopulated
-FastCloner.FastCloner.ClearIgnoredTypes();
+Available behaviors:
+*   `Clone`: Deep recursive copy.
+*   `Reference`: Return the original instance.
+*   `Shallow`: Top-level `MemberwiseClone`.
+*   `Skip`: Return `default`, skip cloning.
+
+To reset behavior:
+```csharp
+FastCloner.FastCloner.ClearTypeBehavior<MySingletonService>();
+FastCloner.FastCloner.ClearAllTypeBehaviors();
 ```
 
+>*Note: Changing type behavior automatically invalidates the internal cache, which may temporarily impact performance. Configure this at application startup.*
+
 Cache can be invalidated to reduce the memory footprint, if needed:
 
 ```csharp

src/FastCloner.Tests/FailureHypothesisTests.cs

@@ -85,21 +85,22 @@ public void ConcurrentBag_Should_Be_Deep_Cloned_Correctly()
     }
 
     [Test]
-    public void CancellationTokenSource_Should_Be_Deep_Cloned_Independently()
+    public void CancellationTokenSource_Should_Be_Reference_Copied()
     {
         using var original = new CancellationTokenSource();
         var clone = original.DeepClone();
 
-        Assert.That(clone, Is.Not.SameAs(original));
+        Assert.That(clone, Is.SameAs(original));
         Assert.That(clone.IsCancellationRequested, Is.False);
 
         // Cancel original
         original.Cancel();
 
         Assert.That(original.IsCancellationRequested, Is.True);
-        Assert.That(clone.IsCancellationRequested, Is.False, "Clone should not be cancelled when original is cancelled");
+        // Since it is a reference copy, the clone (same object) MUST be cancelled too.
+        Assert.That(clone.IsCancellationRequested, Is.True, "Clone is the same object, so it should be cancelled");
 
-        // Cancel clone
+        // Cancel clone (safe to call again)
         clone.Cancel();
         Assert.That(clone.IsCancellationRequested, Is.True);
     }

src/FastCloner.Tests/SourceGeneratorSafetyTests.cs

@@ -0,0 +1,53 @@
+using FastCloner.SourceGenerator.Shared;
+using NUnit.Framework;
+using System;
+using System.Threading;
+
+namespace FastCloner.Tests.SourceGenerator
+{
+    // Define a class that uses the Source Generator
+    [FastClonerClonable]
+    public partial class SafetyTestClass
+    {
+        public CancellationTokenSource? Cts { get; set; }
+        public WeakReference<string>? WeakRef { get; set; }
+        public WeakReference? NonGenericWeakRef { get; set; }
+        public System.Threading.Tasks.Task? Task { get; set; }
+    }
+
+    [TestFixture]
+    public class SourceGeneratorSafetyTests
+    {
+        [Test]
+        public void Verify_SourceGenerator_Uses_ReferenceCopy_For_SpecialTypes()
+        {
+            // Arrange
+            var source = new SafetyTestClass
+            {
+                Cts = new CancellationTokenSource(),
+                WeakRef = new WeakReference<string>("test"),
+                NonGenericWeakRef = new WeakReference("test"),
+                Task = System.Threading.Tasks.Task.CompletedTask
+            };
+
+            // Act
+            // This calls the Source Generated FastDeepClone() method
+            var clone = source.FastDeepClone();
+
+            // Assert
+            Assert.That(clone, Is.Not.SameAs(source));
+            
+            // CancellationTokenSource should be Reference Copy
+            Assert.That(clone.Cts, Is.SameAs(source.Cts), "CTS should be reference copied by Source Generator");
+
+            // WeakReference<T> should be Reference Copy
+            Assert.That(clone.WeakRef, Is.SameAs(source.WeakRef), "WeakReference<T> should be reference copied by Source Generator");
+            
+            // WeakReference (non-generic) should be Reference Copy
+            Assert.That(clone.NonGenericWeakRef, Is.SameAs(source.NonGenericWeakRef), "WeakReference should be reference copied by Source Generator");
+
+            // Task should be Reference Copy
+            Assert.That(clone.Task, Is.SameAs(source.Task), "Task should be reference copied by Source Generator");
+        }
+    }
+}

src/FastCloner.Tests/SpecialCaseTests.cs

@@ -14,6 +14,7 @@
 using System.Net.Http.Headers;
 using System.Numerics;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.Json.Nodes;
@@ -795,6 +796,64 @@ public void Test_Action_Delegate_Clone()
         Assert.That(clonedResult, Is.EquivalentTo(originalResult), "Both delegates should produce the same result");
     }
 
+    [Test]
+    public void ConditionalWeakTable_DeepClone_VerifyBehavior()
+    {
+        ConditionalWeakTable<string, string> cwt = new ConditionalWeakTable<string, string>();
+        string key = "key";
+        string val = "value";
+        cwt.Add(key, val);
+        
+        var clone = cwt.DeepClone();
+        
+        Assert.That(clone, Is.Not.SameAs(cwt));
+        
+        if (clone.TryGetValue(key, out string? clonedVal))
+        {
+            Console.WriteLine("Clone found key: " + clonedVal);
+        }
+        else
+        {
+            Console.WriteLine("Clone did NOT find key");
+        }
+    }
+
+    [Test]
+    public void WeakReferenceGeneric_DeepClone_VerifyBehavior()
+    {
+        string target = "target";
+        WeakReference<string> weak = new WeakReference<string>(target);
+        
+        var clone = weak.DeepClone();
+        
+        Assert.That(clone, Is.SameAs(weak));
+        
+        bool hasTarget = clone.TryGetTarget(out string? clonedTarget);
+        
+        Console.WriteLine($"Original target alive: {weak.TryGetTarget(out _)}");
+        Console.WriteLine($"Clone target alive: {hasTarget}");
+    }
+
+    [Test]
+    public void CancellationTokenSource_DeepClone_VerifyBehavior()
+    {
+        CancellationTokenSource cts = new CancellationTokenSource();
+        var clone = cts.DeepClone();
+        Assert.That(clone, Is.SameAs(cts));
+    }
+
+    [Test]
+    public void CancellationTokenSource_DeepClone_VerifySafety()
+    {
+        // CancellationTokenSource manages native handles and cannot be safely deep cloned by value.
+        // It is now treated as a "Safe" type, meaning DeepClone returns the SAME instance.
+        
+        using var cts = new CancellationTokenSource();
+        var clone = cts.DeepClone();
+        
+        // Assert it is the SAME object (Reference Copy)
+        Assert.That(clone, Is.SameAs(cts));
+    }
     [Test]
     public void Test_Static_Action_Delegate_Clone()
     {
@@ -3286,4 +3345,22 @@ public void ValueTask_From_Task_Should_Be_Safe()
 
         Assert.That(clone.Result, Is.EqualTo(42));
     }
+
+
+    [Test]
+    public void WeakReferenceGeneric_DeepClone_VerifySafety()
+    {
+        string target = "target";
+        WeakReference<string> weak = new WeakReference<string>(target);
+        
+        var clone = weak.DeepClone();
+        
+        // Assert it is the SAME object (Reference Copy)
+        Assert.That(clone, Is.SameAs(weak));
+        
+        bool hasTarget = clone.TryGetTarget(out string? clonedTarget);
+        
+        Console.WriteLine($"Original target alive: {weak.TryGetTarget(out _)}");
+        Console.WriteLine($"Clone target alive: {hasTarget}");
+    }
 }