Add WithConstant factory methods for single constant Setter creation

csharp/Platform.Setters.Tests/SetterTests.cs

@@ -45,5 +45,31 @@ public void MethodsWithIntegerReturnTypeTest()
             Assert.Equal(0, setter.SetFirstAndReturnFalse(new int[] { 4 }));
             Assert.Equal(4, setter.Result);
         }
+
+        [Fact]
+        public void WithConstantFactoryMethodTest()
+        {
+            Setter<int, int> setter = Setter<int, int>.WithConstant(42);
+            Assert.Equal(42, setter.TrueValue);
+            Assert.Equal(42, setter.FalseValue);
+            Assert.Equal(default, setter.Result);
+            Assert.Equal(42, setter.SetAndReturnTrue(1));
+            Assert.Equal(1, setter.Result);
+            Assert.Equal(42, setter.SetAndReturnFalse(2));
+            Assert.Equal(2, setter.Result);
+        }
+
+        [Fact]
+        public void WithConstantAndDefaultValueFactoryMethodTest()
+        {
+            Setter<int, int> setter = Setter<int, int>.WithConstant(42, 99);
+            Assert.Equal(42, setter.TrueValue);
+            Assert.Equal(42, setter.FalseValue);
+            Assert.Equal(99, setter.Result);
+            Assert.Equal(42, setter.SetAndReturnTrue(1));
+            Assert.Equal(1, setter.Result);
+            Assert.Equal(42, setter.SetAndReturnFalse(2));
+            Assert.Equal(2, setter.Result);
+        }
     }
 }

csharp/Platform.Setters/Setter[TResult, TDecision].cs

@@ -87,6 +87,40 @@ public Setter(TResult defaultValue) : base(defaultValue) { }
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Setter() { }
 
+        /// <summary>
+        /// <para>Creates a new instance of the <see cref="Setter{TResult, TDecision}"/> class using passed-in <paramref name="constantValue"/> as both true and false values.</para>
+        /// <para>Создает новый экземпляр класса <see cref="Setter{TResult, TDecision}"/>, используя переданное значение <paramref name="constantValue"/> в качестве значения для истины и лжи.</para>
+        /// </summary>
+        /// <param name="constantValue">
+        /// <para>A constant value that will be used for both true and false cases.</para>
+        /// <para>Константное значение, которое будет использоваться для случаев истины и лжи.</para>
+        /// </param>
+        /// <returns>
+        /// <para>A new instance of the <see cref="Setter{TResult, TDecision}"/> class with the same constant for both true and false values.</para>
+        /// <para>Новый экземпляр класса <see cref="Setter{TResult, TDecision}"/> с одинаковой константой для значений истины и лжи.</para>
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Setter<TResult, TDecision> WithConstant(TDecision constantValue) => new(constantValue, constantValue);
+
+        /// <summary>
+        /// <para>Creates a new instance of the <see cref="Setter{TResult, TDecision}"/> class using passed-in <paramref name="constantValue"/> as both true and false values with the <paramref name="defaultValue"/> as a result.</para>
+        /// <para>Создает новый экземпляр класса <see cref="Setter{TResult, TDecision}"/>, используя переданное значение <paramref name="constantValue"/> в качестве значения для истины и лжи с <paramref name="defaultValue"/> в качестве результата.</para>
+        /// </summary>
+        /// <param name="constantValue">
+        /// <para>A constant value that will be used for both true and false cases.</para>
+        /// <para>Константное значение, которое будет использоваться для случаев истины и лжи.</para>
+        /// </param>
+        /// <param name="defaultValue">
+        /// <para>A default result value.</para>
+        /// <para>Результирующее значение по умолчанию.</para>
+        /// </param>
+        /// <returns>
+        /// <para>A new instance of the <see cref="Setter{TResult, TDecision}"/> class with the same constant for both true and false values and the specified default result value.</para>
+        /// <para>Новый экземпляр класса <see cref="Setter{TResult, TDecision}"/> с одинаковой константой для значений истины и лжи и указанным значением результата по умолчанию.</para>
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Setter<TResult, TDecision> WithConstant(TDecision constantValue, TResult defaultValue) => new(constantValue, constantValue, defaultValue);
+
         /// <summary>
         /// <para>Sets the <paramref name="value"/> to the <see cref="Result"/> and returns the value indicating true.</para>
         /// <para>Устанавливает <paramref name="value"/> в <see cref="Result"/> и возвращает значение обозначающее истину.</para>

experiments/SingleConstantSetterDemo.cs

@@ -0,0 +1,41 @@
+using System;
+using Platform.Setters;
+
+namespace Platform.Setters.Experiments
+{
+    /// <summary>
+    /// Demo showing the usage of Setter with single constant as requested in issue #7.
+    /// This addresses the case where "in real life usage only one constant is actually used".
+    /// </summary>
+    class SingleConstantSetterDemo
+    {
+        static void Main()
+        {
+            // Example usage as requested in the issue: 
+            // "var setter = new Setter<uint, uint>(links.Constants.Break);"
+
+            // Before: Required specifying both true/false values
+            Console.WriteLine("=== Before (traditional approach) ===");
+            var traditionalSetter = new Setter<uint, uint>(1, 0); // trueValue=1, falseValue=0
+            Console.WriteLine($"TrueValue: {traditionalSetter.TrueValue}, FalseValue: {traditionalSetter.FalseValue}");
+
+            // After: Can use single constant for both true/false cases
+            Console.WriteLine("\n=== After (single constant approach) ===");
+            uint constantBreak = 42; // Simulating links.Constants.Break
+            var singleConstantSetter = Setter<uint, uint>.WithConstant(constantBreak);
+            Console.WriteLine($"TrueValue: {singleConstantSetter.TrueValue}, FalseValue: {singleConstantSetter.FalseValue}");
+
+            // Both methods return the same constant value
+            Console.WriteLine("\n=== Testing functionality ===");
+            Console.WriteLine($"SetAndReturnTrue result: {singleConstantSetter.SetAndReturnTrue(100)}"); // Should return 42
+            Console.WriteLine($"SetAndReturnFalse result: {singleConstantSetter.SetAndReturnFalse(200)}"); // Should return 42
+            Console.WriteLine($"Final result value: {singleConstantSetter.Result}"); // Should be 200
+
+            // Can also specify default value
+            Console.WriteLine("\n=== With default value ===");
+            var setterWithDefault = Setter<uint, uint>.WithConstant(constantBreak, 999);
+            Console.WriteLine($"TrueValue: {setterWithDefault.TrueValue}, FalseValue: {setterWithDefault.FalseValue}");
+            Console.WriteLine($"Initial result: {setterWithDefault.Result}"); // Should be 999
+        }
+    }
+}