feat(source-generators): extend RelayCommand with InvertCanExecute

davidkallesen · davidkallesen · commit e2254e14a031 · 2025-03-16T01:50:21.000+01:00
diff --git a/docs/SourceGenerators/ViewModel.md b/docs/SourceGenerators/ViewModel.md
@@ -134,6 +134,7 @@ The `RelayCommand` attribute generates `IRelayCommand` properties, eliminating m
 
 - `CommandName` for customization.
 - `CanExecute` a property or method that return `bool` to specified to control when the command is executable.
+- `InvertCanExecute` if the property `CanExecute` is defined, this property will invert the outcome from the property or method `CanExecute` relays on.
 - `ParameterValue` or `ParameterValues` for 1 or many parameter values.
 
 ### 🛠 Quick Start Tips for RelayCommands
@@ -158,6 +159,10 @@ public void Save(string text);
 // Generates a RelayCommand with CanExecute function
 [RelayCommand(CanExecute = nameof(CanSave))]
 public void Save();
+
+// Generates a RelayCommand with CanExecute function
+[RelayCommand(CanExecute = nameof(IsConnected), InvertCanExecute = true)]
+public void Connect();
 ```
 
 **Note:**
@@ -199,6 +204,10 @@ public Task Save();
 // Generates an asynchronous RelayCommand with async keyword and CanExecute function
 [RelayCommand(CanExecute = nameof(CanSave))]
 public async Task Save();
+
+// Generates an asynchronous RelayCommand async keyword and CanExecute function
+[RelayCommand(CanExecute = nameof(IsConnected), InvertCanExecute = true)]
+public async Task Connect();
 ```
 
 ### 🔁 Multi-Parameter Commands
@@ -375,7 +384,7 @@ public partial class TestViewModel
 ```csharp
 public partial class PersonViewModel : ViewModelBase
 {
-    [ObservableProperty]
+    [ObservableProperty(BroadcastOnChange = true)]
     [NotifyPropertyChangedFor(nameof(FullName))]
     [Required]
     [MinLength(2)]
@@ -398,7 +407,11 @@ public partial class PersonViewModel : ViewModelBase
 
     public string FullName => $"{FirstName} {LastName}";
 
-    [RelayCommand]
+    public bool IsConnected { get; set; }
+
+    [RelayCommand(
+        CanExecute = nameof(IsConnected),
+        InvertCanExecute = true)]
     public void ShowData()
     {
         // TODO: Implement ShowData - it could be a dialog box
@@ -428,7 +441,7 @@ public partial class PersonViewModel : ViewModelBase
 ```csharp
 public partial class PersonViewModel
 {
-    public IRelayCommand ShowDataCommand => new RelayCommand(ShowData);
+    public IRelayCommand ShowDataCommand => new RelayCommand(ShowData, () => !IsConnected);
 
     public IRelayCommand SaveHandlerCommand => new RelayCommand(SaveHandler, CanSaveHandler);
 
@@ -442,9 +455,11 @@ public partial class PersonViewModel
                 return;
             }
 
+            var oldValue = firstName;
             firstName = value;
             RaisePropertyChanged(nameof(FirstName));
             RaisePropertyChanged(nameof(FullName));
+            Broadcast(nameof(FirstName), oldValue, value);
         }
     }
 
diff --git a/sample/Atc.Wpf.Sample/SamplesWpfSourceGenerators/PersonViewModel.cs b/sample/Atc.Wpf.Sample/SamplesWpfSourceGenerators/PersonViewModel.cs
@@ -25,7 +25,11 @@ public partial class PersonViewModel : ViewModelBase
 
     public string FullName => $"{FirstName} {LastName}";
 
-    [RelayCommand]
+    public bool IsConnected { get; set; }
+
+    [RelayCommand(
+        CanExecute = nameof(IsConnected),
+        InvertCanExecute = true)]
     public void ShowData()
     {
         var dialogBox = new InfoDialogBox(
diff --git a/src/Atc.Wpf.SourceGenerators/Builders/CommandBuilderBase.cs b/src/Atc.Wpf.SourceGenerators/Builders/CommandBuilderBase.cs
@@ -49,6 +49,7 @@ private static void GenerateRelayCommandWithOutParameterValues(
                 rc.CommandName,
                 rc.MethodName,
                 rc.CanExecuteName,
+                rc.InvertCanExecute,
                 rc.UsePropertyForCanExecute);
             builder.AppendLine(cmd);
         }
@@ -64,6 +65,7 @@ private static void GenerateRelayCommandWithOutParameterValues(
                     rc.CommandName,
                     $"{rc.MethodName}(CancellationToken.None)",
                     rc.CanExecuteName,
+                    rc.InvertCanExecute,
                     isLambda: true);
                 builder.AppendLine(cmd);
             }
@@ -76,6 +78,7 @@ private static void GenerateRelayCommandWithOutParameterValues(
                     rc.CommandName,
                     rc.MethodName,
                     rc.CanExecuteName,
+                    rc.InvertCanExecute,
                     rc.UsePropertyForCanExecute);
                 builder.AppendLine(cmd);
             }
@@ -90,7 +93,7 @@ private static void GenerateRelayCommandWithOutParameterValues(
                     $"{implementationType}{tupleGeneric}",
                     rc.CommandName,
                     $"x => {rc.MethodName}({constructorParametersMulti})",
-                    rc.CanExecuteName is null ? null : $"x => {rc.CanExecuteName}");
+                    rc.CanExecuteName is null ? null : rc.InvertCanExecute ? $"x => !{rc.CanExecuteName}" : $"x => {rc.CanExecuteName}");
                 builder.AppendLine(cmd);
             }
             else
@@ -100,7 +103,7 @@ private static void GenerateRelayCommandWithOutParameterValues(
                     $"{implementationType}{tupleGeneric}",
                     rc.CommandName,
                     $"x => {rc.MethodName}({constructorParametersMulti})",
-                    rc.CanExecuteName is null ? null : $"x => {rc.CanExecuteName}({filteredConstructorParameters})");
+                    rc.CanExecuteName is null ? null : rc.InvertCanExecute ? $"x => !{rc.CanExecuteName}({filteredConstructorParameters})" : $"x => {rc.CanExecuteName}({filteredConstructorParameters})");
                 builder.AppendLine(cmd);
             }
         }
@@ -143,7 +146,7 @@ private static void GenerateRelayCommandWithParameterValues(
                         implementationType,
                         rc.CommandName,
                         $"() => {rc.MethodName}({constructorParameters})",
-                        $"{rc.CanExecuteName}");
+                        rc.InvertCanExecute ? $"!{rc.CanExecuteName}" : $"{rc.CanExecuteName}");
                     builder.AppendLine(cmd);
                 }
                 else
@@ -153,7 +156,7 @@ private static void GenerateRelayCommandWithParameterValues(
                         implementationType,
                         rc.CommandName,
                         $"() => {rc.MethodName}({constructorParameters})",
-                        $"{rc.CanExecuteName}({constructorParameters})");
+                        rc.InvertCanExecute ? $"!{rc.CanExecuteName}({constructorParameters})" : $"{rc.CanExecuteName}({constructorParameters})");
                     builder.AppendLine(cmd);
                 }
             }
@@ -197,6 +200,7 @@ private static string GenerateCommandLine(
         string commandName,
         string constructorParameters,
         string? canExecuteName = null,
+        bool invertCanExecute = false,
         bool usePropertyForCanExecute = false,
         bool isLambda = false)
     {
@@ -209,16 +213,22 @@ private static string GenerateCommandLine(
             {
                 if (interfaceType.Contains('<'))
                 {
-                    commandInstance += $", _ => {canExecuteName}";
+                    commandInstance += invertCanExecute
+                        ? $", _ => !{canExecuteName}"
+                        : $", _ => {canExecuteName}";
                 }
                 else
                 {
-                    commandInstance += $", () => {canExecuteName}";
+                    commandInstance += invertCanExecute
+                        ? $", () => !{canExecuteName}"
+                        : $", () => {canExecuteName}";
                 }
             }
             else
             {
-                commandInstance += $", {canExecuteName}";
+                commandInstance += invertCanExecute
+                    ? $", !{canExecuteName}"
+                    : $", {canExecuteName}";
             }
         }
 
diff --git a/src/Atc.Wpf.SourceGenerators/Inspectors/Attributes/RelayCommandInspector.cs b/src/Atc.Wpf.SourceGenerators/Inspectors/Attributes/RelayCommandInspector.cs
@@ -75,6 +75,9 @@ private static void AppendRelayCommandToGenerate(
             canExecuteName = canExecuteNameValue!.ExtractInnerContent();
         }
 
+        var invertCanExecute = relayCommandArgumentValues.TryGetValue(NameConstants.InvertCanExecute, out var invertCanExecuteValue) &&
+                               "true".Equals(invertCanExecuteValue, StringComparison.OrdinalIgnoreCase);
+
         var usePropertyForCanExecute = false;
         if (canExecuteName is not null)
         {
@@ -111,6 +114,7 @@ is NameConstants.Task
                 parameterTypes?.ToArray(),
                 parameterValues.Count == 0 ? null : parameterValues.ToArray(),
                 canExecuteName,
+                invertCanExecute,
                 usePropertyForCanExecute,
                 isAsync));
     }
diff --git a/src/Atc.Wpf.SourceGenerators/Models/AttributeToGenerate/RelayCommandToGenerate.cs b/src/Atc.Wpf.SourceGenerators/Models/AttributeToGenerate/RelayCommandToGenerate.cs
@@ -7,6 +7,7 @@ internal sealed class RelayCommandToGenerate(
     string[]? parameterTypes,
     string[]? parameterValues,
     string? canExecuteName,
+    bool invertCanExecute,
     bool usePropertyForCanExecute,
     bool isAsync)
 {
@@ -20,10 +21,12 @@ internal sealed class RelayCommandToGenerate(
 
     public string? CanExecuteName { get; } = canExecuteName;
 
+    public bool InvertCanExecute { get; } = invertCanExecute;
+
     public bool UsePropertyForCanExecute { get; } = usePropertyForCanExecute;
 
     public bool IsAsync { get; } = isAsync;
 
     public override string ToString()
-        => $"{nameof(CommandName)}: {CommandName}, {nameof(MethodName)}: {MethodName}, {nameof(ParameterTypes)}.Count: {ParameterTypes?.Length}, {nameof(ParameterValues)}.Count: {ParameterValues?.Length}, {nameof(CanExecuteName)}: {CanExecuteName}, {nameof(UsePropertyForCanExecute)}: {UsePropertyForCanExecute}, {nameof(IsAsync)}: {IsAsync}";
+        => $"{nameof(CommandName)}: {CommandName}, {nameof(MethodName)}: {MethodName}, {nameof(ParameterTypes)}.Count: {ParameterTypes?.Length}, {nameof(ParameterValues)}.Count: {ParameterValues?.Length}, {nameof(CanExecuteName)}: {CanExecuteName}, {nameof(InvertCanExecute)}: {InvertCanExecute}, {nameof(UsePropertyForCanExecute)}: {UsePropertyForCanExecute}, {nameof(IsAsync)}: {IsAsync}";
 }
diff --git a/src/Atc.Wpf.SourceGenerators/NameConstants.cs b/src/Atc.Wpf.SourceGenerators/NameConstants.cs
@@ -25,6 +25,7 @@ internal static class NameConstants
     public const string FrameworkElement = nameof(FrameworkElement);
     public const string Handler = nameof(Handler);
     public const string IObservableObject = nameof(IObservableObject);
+    public const string InvertCanExecute = nameof(InvertCanExecute);
     public const string IRelayCommand = nameof(IRelayCommand);
     public const string IRelayCommandAsync = nameof(IRelayCommandAsync);
     public const string IsAnimationProhibited = nameof(IsAnimationProhibited);
diff --git a/src/Atc.Wpf/Mvvm/Attributes/RelayCommandAttribute.cs b/src/Atc.Wpf/Mvvm/Attributes/RelayCommandAttribute.cs
@@ -35,6 +35,22 @@ public RelayCommandAttribute(
     /// </summary>
     public string? CanExecute { get; set; }
 
+    /// <summary>
+    /// Gets or sets a value indicating whether the canExecute value should be inverted.
+    /// <para>
+    /// For example, if CanExecute is specified as "IsConnected" property and InvertCanExecute is true,
+    /// the generated lambda will be:
+    /// <code language="csharp">
+    /// () => !IsConnected
+    /// </code>
+    /// instead of:
+    /// <code language="csharp">
+    /// () => IsConnected
+    /// </code>
+    /// </para>
+    /// </summary>
+    public bool InvertCanExecute { get; set; }
+
     /// <summary>
     /// Gets or sets the parameter value.
     /// </summary>
diff --git a/test/Atc.Wpf.SourceGenerators.Tests/Generators/ViewModelGeneratorTests_AsyncRelayCommand.cs b/test/Atc.Wpf.SourceGenerators.Tests/Generators/ViewModelGeneratorTests_AsyncRelayCommand.cs
@@ -1014,4 +1014,46 @@ public partial class TestViewModel
 
         AssertGeneratorRunResultAsEqual(expectedCode, generatorResult);
     }
+
+    [Fact]
+    public void AsyncRelayCommand_NoParameter_CanExecute_Inverted()
+    {
+        const string inputCode =
+            """
+            namespace TestNamespace;
+
+            public partial class TestViewModel : ViewModelBase
+            {
+                [RelayCommand(CanExecute = nameof(CanSave), InvertCanExecute = true)]
+                public Task Save()
+                {
+                }
+                
+                public bool CanSave()
+                {
+                    return true;
+                }
+            }
+            """;
+
+        const string expectedCode =
+            """
+            // <auto-generated>
+            #nullable enable
+            using Atc.Wpf.Command;
+
+            namespace TestNamespace;
+
+            public partial class TestViewModel
+            {
+                public IRelayCommandAsync SaveCommand => new RelayCommandAsync(Save, !CanSave);
+            }
+
+            #nullable disable
+            """;
+
+        var generatorResult = RunGenerator<ViewModelGenerator>(inputCode);
+
+        AssertGeneratorRunResultAsEqual(expectedCode, generatorResult);
+    }
 }
diff --git a/test/Atc.Wpf.SourceGenerators.Tests/Generators/ViewModelGeneratorTests_RelayCommand.cs b/test/Atc.Wpf.SourceGenerators.Tests/Generators/ViewModelGeneratorTests_RelayCommand.cs
@@ -816,4 +816,46 @@ public bool MyCanSave
 
         AssertGeneratorRunResultAsEqual(expectedCode, generatorResult);
     }
+
+    [Fact]
+    public void RelayCommand_NoParameter_CanExecute_Inverted()
+    {
+        const string inputCode =
+            """
+            namespace TestNamespace;
+
+            public partial class TestViewModel : ViewModelBase
+            {
+                [RelayCommand(CanExecute = nameof(CanSave), InvertCanExecute = true)]
+                public void Save()
+                {
+                }
+                
+                public bool CanSave()
+                {
+                    return true;
+                }
+            }
+            """;
+
+        const string expectedCode =
+            """
+            // <auto-generated>
+            #nullable enable
+            using Atc.Wpf.Command;
+
+            namespace TestNamespace;
+
+            public partial class TestViewModel
+            {
+                public IRelayCommand SaveCommand => new RelayCommand(Save, !CanSave);
+            }
+
+            #nullable disable
+            """;
+
+        var generatorResult = RunGenerator<ViewModelGenerator>(inputCode);
+
+        AssertGeneratorRunResultAsEqual(expectedCode, generatorResult);
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@ private static void GenerateRelayCommandWithOutParameterValues(`
`49`	`49`	`rc.CommandName,`
`50`	`50`	`rc.MethodName,`
`51`	`51`	`rc.CanExecuteName,`
	`52`	`+ rc.InvertCanExecute,`
`52`	`53`	`rc.UsePropertyForCanExecute);`
`53`	`54`	`builder.AppendLine(cmd);`
`54`	`55`	`}`
`@@ -64,6 +65,7 @@ private static void GenerateRelayCommandWithOutParameterValues(`
`64`	`65`	`rc.CommandName,`
`65`	`66`	`$"{rc.MethodName}(CancellationToken.None)",`
`66`	`67`	`rc.CanExecuteName,`
	`68`	`+ rc.InvertCanExecute,`
`67`	`69`	`isLambda: true);`
`68`	`70`	`builder.AppendLine(cmd);`
`69`	`71`	`}`
`@@ -76,6 +78,7 @@ private static void GenerateRelayCommandWithOutParameterValues(`
`76`	`78`	`rc.CommandName,`
`77`	`79`	`rc.MethodName,`
`78`	`80`	`rc.CanExecuteName,`
	`81`	`+ rc.InvertCanExecute,`
`79`	`82`	`rc.UsePropertyForCanExecute);`
`80`	`83`	`builder.AppendLine(cmd);`
`81`	`84`	`}`
`@@ -90,7 +93,7 @@ private static void GenerateRelayCommandWithOutParameterValues(`
`90`	`93`	`$"{implementationType}{tupleGeneric}",`
`91`	`94`	`rc.CommandName,`
`92`	`95`	`$"x => {rc.MethodName}({constructorParametersMulti})",`
`93`		`- rc.CanExecuteName is null ? null : $"x => {rc.CanExecuteName}");`
	`96`	`+ rc.CanExecuteName is null ? null : rc.InvertCanExecute ? $"x => !{rc.CanExecuteName}" : $"x => {rc.CanExecuteName}");`
`94`	`97`	`builder.AppendLine(cmd);`
`95`	`98`	`}`
`96`	`99`	`else`
`@@ -100,7 +103,7 @@ private static void GenerateRelayCommandWithOutParameterValues(`
`100`	`103`	`$"{implementationType}{tupleGeneric}",`
`101`	`104`	`rc.CommandName,`
`102`	`105`	`$"x => {rc.MethodName}({constructorParametersMulti})",`
`103`		`- rc.CanExecuteName is null ? null : $"x => {rc.CanExecuteName}({filteredConstructorParameters})");`
	`106`	`+ rc.CanExecuteName is null ? null : rc.InvertCanExecute ? $"x => !{rc.CanExecuteName}({filteredConstructorParameters})" : $"x => {rc.CanExecuteName}({filteredConstructorParameters})");`
`104`	`107`	`builder.AppendLine(cmd);`
`105`	`108`	`}`
`106`	`109`	`}`
`@@ -143,7 +146,7 @@ private static void GenerateRelayCommandWithParameterValues(`
`143`	`146`	`implementationType,`
`144`	`147`	`rc.CommandName,`
`145`	`148`	`$"() => {rc.MethodName}({constructorParameters})",`
`146`		`- $"{rc.CanExecuteName}");`
	`149`	`+ rc.InvertCanExecute ? $"!{rc.CanExecuteName}" : $"{rc.CanExecuteName}");`
`147`	`150`	`builder.AppendLine(cmd);`
`148`	`151`	`}`
`149`	`152`	`else`
`@@ -153,7 +156,7 @@ private static void GenerateRelayCommandWithParameterValues(`
`153`	`156`	`implementationType,`
`154`	`157`	`rc.CommandName,`
`155`	`158`	`$"() => {rc.MethodName}({constructorParameters})",`
`156`		`- $"{rc.CanExecuteName}({constructorParameters})");`
	`159`	`+ rc.InvertCanExecute ? $"!{rc.CanExecuteName}({constructorParameters})" : $"{rc.CanExecuteName}({constructorParameters})");`
`157`	`160`	`builder.AppendLine(cmd);`
`158`	`161`	`}`
`159`	`162`	`}`
`@@ -197,6 +200,7 @@ private static string GenerateCommandLine(`
`197`	`200`	`string commandName,`
`198`	`201`	`string constructorParameters,`
`199`	`202`	`string? canExecuteName = null,`
	`203`	`+ bool invertCanExecute = false,`
`200`	`204`	`bool usePropertyForCanExecute = false,`
`201`	`205`	`bool isLambda = false)`
`202`	`206`	`{`
`@@ -209,16 +213,22 @@ private static string GenerateCommandLine(`
`209`	`213`	`{`
`210`	`214`	`if (interfaceType.Contains('<'))`
`211`	`215`	`{`
`212`		`- commandInstance += $", _ => {canExecuteName}";`
	`216`	`+ commandInstance += invertCanExecute`
	`217`	`+ ? $", _ => !{canExecuteName}"`
	`218`	`+ : $", _ => {canExecuteName}";`
`213`	`219`	`}`
`214`	`220`	`else`
`215`	`221`	`{`
`216`		`- commandInstance += $", () => {canExecuteName}";`
	`222`	`+ commandInstance += invertCanExecute`
	`223`	`+ ? $", () => !{canExecuteName}"`
	`224`	`+ : $", () => {canExecuteName}";`
`217`	`225`	`}`
`218`	`226`	`}`
`219`	`227`	`else`
`220`	`228`	`{`
`221`		`- commandInstance += $", {canExecuteName}";`
	`229`	`+ commandInstance += invertCanExecute`
	`230`	`+ ? $", !{canExecuteName}"`
	`231`	`+ : $", {canExecuteName}";`
`222`	`232`	`}`
`223`	`233`	`}`
`224`	`234`
Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,9 @@ private static void AppendRelayCommandToGenerate(`
`75`	`75`	`canExecuteName = canExecuteNameValue!.ExtractInnerContent();`
`76`	`76`	`}`
`77`	`77`
	`78`	`+ var invertCanExecute = relayCommandArgumentValues.TryGetValue(NameConstants.InvertCanExecute, out var invertCanExecuteValue) &&`
	`79`	`+ "true".Equals(invertCanExecuteValue, StringComparison.OrdinalIgnoreCase);`
	`80`	`+`
`78`	`81`	`var usePropertyForCanExecute = false;`
`79`	`82`	`if (canExecuteName is not null)`
`80`	`83`	`{`
`@@ -111,6 +114,7 @@ is NameConstants.Task`
`111`	`114`	`parameterTypes?.ToArray(),`
`112`	`115`	`parameterValues.Count == 0 ? null : parameterValues.ToArray(),`
`113`	`116`	`canExecuteName,`
	`117`	`+ invertCanExecute,`
`114`	`118`	`usePropertyForCanExecute,`
`115`	`119`	`isAsync));`
`116`	`120`	`}`