iteration

Author: KSemenenko

.gitignore

@@ -863,4 +863,6 @@ FodyWeavers.xsd
 ### VisualStudio Patch ###
 # Additional files built by Visual Studio
 
-# End of https://www.toptal.com/developers/gitignore/api/windows,linux,macos,visualstudio,visualstudiocode,intellij,intellij+all,rider,angular,dotnetcore,aspnetcore,xamarinstudio
+*.trx
+
+# End of https://www.toptal.com/developers/gitignore/api/windows,linux,macos,visualstudio,visualstudiocode,intellij,intellij+all,rider,angular,dotnetcore,aspnetcore,xamarinstudio

AGENTS.md

@@ -10,6 +10,7 @@ If I tell you to remember something, you do the same, update
 
 ## Rules to follow
 always check all test are passed.
+- Prefer static interface members for result/command factories to centralize shared overloads and avoid duplication across result-like types.
 
 # Repository Guidelines
 

Directory.Build.props

@@ -6,6 +6,7 @@
         <EnableNETAnalyzers>true</EnableNETAnalyzers>
         <Nullable>enable</Nullable>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <EnablePreviewFeatures>true</EnablePreviewFeatures>
     </PropertyGroup>
 
     <!--NuGet-->

ManagedCode.Communication.Tests/Commands/CommandTests.cs

@@ -25,4 +25,65 @@ public void FromIdValue()
         command.Value
             .ShouldBe(nameof(Command));
     }
-}
+
+    [Fact]
+    public void Create_WithEnumType_ShouldSetCommandType()
+    {
+        var command = Command.Create(TestCommandType.Delete);
+
+        command.CommandType
+            .ShouldBe(TestCommandType.Delete.ToString());
+        command.CommandId
+            .ShouldNotBe(Guid.Empty);
+    }
+
+    [Fact]
+    public void Create_WithEmptyCommandType_ShouldThrow()
+    {
+        Should.Throw<ArgumentException>(() => Command.Create(Guid.NewGuid(), string.Empty));
+    }
+
+    [Fact]
+    public void GenericCreate_WithValueFactory_ShouldInvokeFactoryOnce()
+    {
+        var callCount = 0;
+
+        var command = Command<string>.Create(() =>
+        {
+            callCount++;
+            return "payload";
+        });
+
+        callCount
+            .ShouldBe(1);
+        command.Value
+            .ShouldBe("payload");
+    }
+
+    [Fact]
+    public void GenericCreate_WithEmptyCommandType_ShouldThrow()
+    {
+        Should.Throw<ArgumentException>(() => Command<string>.Create(Guid.NewGuid(), string.Empty, "value"));
+    }
+
+    [Fact]
+    public void GenericFrom_WithCommandType_ShouldReturnCommand()
+    {
+        var id = Guid.NewGuid();
+        var command = Command<string>.From(id, "custom", "value");
+
+        command.CommandId
+            .ShouldBe(id);
+        command.CommandType
+            .ShouldBe("custom");
+        command.Value
+            .ShouldBe("value");
+    }
+
+    private enum TestCommandType
+    {
+        Create,
+        Update,
+        Delete
+    }
+}

ManagedCode.Communication.Tests/Commands/PaginationCommandTests.cs

@@ -0,0 +1,79 @@
+using System;
+using ManagedCode.Communication.Commands;
+using Shouldly;
+using Xunit;
+
+namespace ManagedCode.Communication.Tests.Commands;
+
+public class PaginationCommandTests
+{
+    [Fact]
+    public void Create_WithSkipAndTake_ShouldPopulateProperties()
+    {
+        var command = PaginationCommand.Create(10, 5);
+
+        command.CommandType
+            .ShouldBe("Pagination");
+        command.Skip
+            .ShouldBe(10);
+        command.Take
+            .ShouldBe(5);
+        command.PageNumber
+            .ShouldBe(3);
+        command.PageSize
+            .ShouldBe(5);
+        command.Value
+            .ShouldNotBeNull();
+        command.Value!.Skip
+            .ShouldBe(10);
+    }
+
+    [Fact]
+    public void Create_WithCommandId_ShouldRespectIdentifier()
+    {
+        var id = Guid.NewGuid();
+
+        var command = PaginationCommand.Create(id, 12, 6);
+
+        command.CommandId
+            .ShouldBe(id);
+        command.Skip
+            .ShouldBe(12);
+        command.Take
+            .ShouldBe(6);
+    }
+
+    [Fact]
+    public void Create_WithNegativeSkip_ShouldThrow()
+    {
+        Should.Throw<ArgumentOutOfRangeException>(() => PaginationCommand.Create(-1, 10));
+    }
+
+    [Fact]
+    public void Create_WithNegativeTake_ShouldThrow()
+    {
+        Should.Throw<ArgumentOutOfRangeException>(() => PaginationCommand.Create(0, -1));
+    }
+
+    [Fact]
+    public void FromPage_WithValidParameters_ShouldCalculateSkipAndTake()
+    {
+        var command = PaginationCommand.FromPage(3, 20);
+
+        command.Skip
+            .ShouldBe(40);
+        command.Take
+            .ShouldBe(20);
+        command.PageNumber
+            .ShouldBe(3);
+        command.PageSize
+            .ShouldBe(20);
+    }
+
+    [Fact]
+    public void PaginationRequest_FromPage_InvalidInput_ShouldThrow()
+    {
+        Should.Throw<ArgumentOutOfRangeException>(() => PaginationRequest.FromPage(0, 10));
+        Should.Throw<ArgumentOutOfRangeException>(() => PaginationRequest.FromPage(1, 0));
+    }
+}

ManagedCode.Communication/CollectionResultT/CollectionResultT.Fail.cs

@@ -22,7 +22,7 @@ public static CollectionResult<T> Fail(IEnumerable<T> value)
 
     public static CollectionResult<T> Fail(Problem problem, T[] items)
     {
-        return CollectionResultFactoryBridge<CollectionResult<T>, T>.Fail(problem, items);
+        return CollectionResult<T>.CreateFailed(problem, items);
     }
 
     public static CollectionResult<T> Fail(string title) => ResultFactoryBridge<CollectionResult<T>>.Fail(title);

ManagedCode.Communication/Commands/Command.From.cs

@@ -6,11 +6,16 @@ public partial class Command
 {
     public static Command<T> From<T>(Guid id, T value)
     {
-        return Command<T>.Create(id, value);
+        return Command<T>.From(id, value);
     }
 
     public static Command<T> From<T>(T value)
     {
-        return Command<T>.Create(value);
+        return Command<T>.From(value);
     }
-}
+
+    public static Command<T> From<T>(Guid id, string commandType, T value)
+    {
+        return Command<T>.From(id, commandType, value);
+    }
+}

ManagedCode.Communication/Commands/Command.cs

@@ -6,7 +6,7 @@ namespace ManagedCode.Communication.Commands;
 
 [Serializable]
 [DebuggerDisplay("CommandId: {CommandId}")]
-public partial class Command : ICommand
+public partial class Command : ICommand, ICommandFactory<Command>
 {
     [JsonConstructor]
     protected Command()
@@ -73,17 +73,34 @@ protected Command(Guid commandId, string commandType)
     /// </summary>
     public static Command Create(string commandType)
     {
-        return new Command(Guid.CreateVersion7(), commandType);
+        return CommandFactoryBridge.Create<Command>(commandType);
+    }
+
+    public static Command Create<TEnum>(TEnum commandType)
+        where TEnum : Enum
+    {
+        return CommandFactoryBridge.Create<Command, TEnum>(commandType);
     }
 
     /// <summary>
     /// Creates a new command with specific ID and type
     /// </summary>
     public static Command Create(Guid commandId, string commandType)
     {
+        if (string.IsNullOrWhiteSpace(commandType))
+        {
+            throw new ArgumentException("Command type must be provided.", nameof(commandType));
+        }
+
         return new Command(commandId, commandType);
     }
 
+    public static Command Create<TEnum>(Guid commandId, TEnum commandType)
+        where TEnum : Enum
+    {
+        return CommandFactoryBridge.Create<Command, TEnum>(commandId, commandType);
+    }
+
     /// <summary>
     /// Try to convert CommandType string to an enum value
     /// </summary>
@@ -95,4 +112,4 @@ public Result<TEnum> GetCommandTypeAsEnum<TEnum>() where TEnum : struct, Enum
         }
         return Result<TEnum>.Fail("InvalidCommandType", $"Cannot convert '{CommandType}' to enum {typeof(TEnum).Name}");
     }
-}
+}

ManagedCode.Communication/Commands/CommandT.From.cs

@@ -6,27 +6,47 @@ public partial class Command<T>
 {
     public static Command<T> Create(T value)
     {
-        return new Command<T>(Guid.CreateVersion7(), value);
+        return CommandValueFactoryBridge.Create<Command<T>, T>(value);
     }
-    
+
     public static Command<T> Create(Guid id, T value)
     {
-        return new Command<T>(id, value);
+        return CommandValueFactoryBridge.Create<Command<T>, T>(id, value);
     }
-    
+
     public static Command<T> Create(Guid id, string commandType, T value)
     {
+        if (string.IsNullOrWhiteSpace(commandType))
+        {
+            throw new ArgumentException("Command type must be provided.", nameof(commandType));
+        }
+
         return new Command<T>(id, commandType, value);
     }
-    
+
+    public static Command<T> Create(Guid id, string commandType, Func<T> valueFactory)
+    {
+        return CommandValueFactoryBridge.Create<Command<T>, T>(id, commandType, valueFactory);
+    }
+
+    public static Command<T> Create(Func<T> valueFactory)
+    {
+        return CommandValueFactoryBridge.Create<Command<T>, T>(valueFactory);
+    }
+
     // Legacy From methods for backward compatibility
     public static Command<T> From(Guid id, T value)
     {
-        return Create(id, value);
+        return CommandValueFactoryBridge.From<Command<T>, T>(id, value);
     }
 
     public static Command<T> From(T value)
     {
-        return Create(value);
+        return CommandValueFactoryBridge.From<Command<T>, T>(value);
+    }
+
+    public static Command<T> From(Guid id, string commandType, T value)
+    {
+        return CommandValueFactoryBridge.From<Command<T>, T>(id, commandType, value);
     }
-}
+}

ManagedCode.Communication/Commands/CommandT.cs

@@ -7,7 +7,7 @@ namespace ManagedCode.Communication.Commands;
 
 [Serializable]
 [DebuggerDisplay("CommandId: {CommandId}; {Value?.ToString()}")]
-public partial class Command<T> : ICommand<T>
+public partial class Command<T> : ICommand<T>, ICommandValueFactory<Command<T>, T>
 {
     [JsonConstructor]
     protected Command()