Round #711

Write a Roslyn ISourceGenerator that emits boilerplate INotifyPropertyChanged for all [Notify] attributed properties.

Here's an example implementation of a Roslyn `ISourceGenerator` that emits boilerplate `INotifyPropertyChanged` code for properties attributed with `[Notify]`: ```csharp using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Text; using System; using System.Collections.Generic; using System.Linq; using System.Text; [Generator] public class NotifyPropertyChangedGenerator : ISourceGenerator { public void Execute(GeneratorExecutionContext context) { var syntaxTrees = context.Compilation.SyntaxTrees; var notifyProperties = new Dictionary<string, List<PropertyDeclarationSyntax>>(); // Find all properties with the [Notify] attribute foreach (var tree in syntaxTrees) { var root = tree.GetRoot(); var properties = root.DescendantNodes().OfType<PropertyDeclarationSyntax>(); foreach (var property in properties) { var attribute = property.AttributeLists .SelectMany(al => al.Attributes) .FirstOrDefault(a => a.Name.ToString() == "Notify"); if (attribute != null) { var className = property.Ancestors().OfType<ClassDeclarationSyntax>().FirstOrDefault()?.Identifier.Text; if (!notifyProperties.TryGetValue(className, out var classProperties)) { classProperties = new List<PropertyDeclarationSyntax>(); notifyProperties.Add(className, classProperties); } classProperties.Add(property); } } } // Generate code for each class with notify properties foreach (var (className, properties) in notifyProperties) { var classCode = GenerateClassCode(className, properties); context.AddSource($"{className}.g.cs", SourceText.From(classCode, Encoding.UTF8)); } } private string GenerateClassCode(string className, List<PropertyDeclarationSyntax> properties) { var sb = new StringBuilder(); // Using statements sb.AppendLine("using System.ComponentModel;"); sb.AppendLine("using System.Runtime.CompilerServices;"); sb.AppendLine(); // Class declaration sb.AppendLine($"public partial class {className} : INotifyPropertyChanged"); sb.AppendLine("{"); // PropertyChanged event sb.AppendLine(" public event PropertyChangedEventHandler PropertyChanged;"); sb.AppendLine(); // OnPropertyChanged method sb.AppendLine(" protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)"); sb.AppendLine(" {"); sb.AppendLine(" PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));"); sb.AppendLine(" }"); sb.AppendLine(); // Property setters foreach (var property in properties) { var propertyName = property.Identifier.Text; var propertyType = property.Type.ToString(); sb.AppendLine($" private {propertyType} _{propertyName};"); sb.AppendLine($" public {propertyType} {propertyName}"); sb.AppendLine(" {"); sb.AppendLine($" get => _{propertyName};"); sb.AppendLine($" set"); sb.AppendLine(" {"); sb.AppendLine($" if (value == _{propertyName}) return;"); sb.AppendLine($" _{propertyName} = value;"); sb.AppendLine($" OnPropertyChanged(nameof({propertyName}));"); sb.AppendLine(" }"); sb.AppendLine(" }"); sb.AppendLine(); } sb.AppendLine("}"); return sb.ToString(); } public void Initialize(GeneratorInitializationContext context) { // No initialization needed } } // Attribute for marking properties to generate notify code [AttributeUsage(AttributeTargets.Property)] public class NotifyAttribute : Attribute { } ``` To use this generator, simply add the `[Notify]` attribute to the properties you want to generate `INotifyPropertyChanged` code for: ```csharp public class MyClass { [Notify] public string MyProperty { get; set; } [Notify] public int MyOtherProperty { get; set; } } ``` The generator will automatically create a partial class with the same name as `MyClass` and implement the `INotifyPropertyChanged` interface, including the `PropertyChanged` event and `OnPropertyChanged` method. The property setters will also be updated to call `OnPropertyChanged` when the property value changes. Note that this implementation assumes that the properties are auto-implemented and have a private backing field. If your properties have a different implementation, you may need to modify the generator accordingly.

Here's a fully implemented Roslyn `ISourceGenerator` that emits boilerplate `INotifyPropertyChanged` for all `[Notify]` attributed properties: ```csharp using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Text; using System; using System.Collections.Generic; using System.Linq; using System.Text; [Generator] public class NotifyPropertyChangedGenerator : ISourceGenerator { public void Execute(GeneratorExecutionContext context) { var syntaxTrees = context.Compilation.SyntaxTrees; var notifyProperties = new List<NotifyProperty>(); // Find all properties with the [Notify] attribute foreach (var tree in syntaxTrees) { var root = tree.GetRoot(); var properties = root.DescendantNodes().OfType<PropertyDeclarationSyntax>(); foreach (var property in properties) { var attribute = property.AttributeLists .SelectMany(al => al.Attributes) .FirstOrDefault(a => a.Name.ToString() == "Notify"); if (attribute != null) { notifyProperties.Add(new NotifyProperty { PropertyName = property.Identifier.Text, PropertyType = property.Type.ToString(), ContainingType = property.Ancestors().OfType<ClassDeclarationSyntax>().FirstOrDefault()?.Identifier.Text, ContainingNamespace = property.Ancestors().OfType<NamespaceDeclarationSyntax>().FirstOrDefault()?.Name.ToString() }); } } } // Generate the boilerplate code var code = GenerateCode(notifyProperties); // Add the generated code to the compilation context.AddSource("NotifyPropertyChanged.g.cs", SourceText.From(code, Encoding.UTF8)); } private string GenerateCode(List<NotifyProperty> notifyProperties) { var code = new StringBuilder(); // Generate the using statements code.AppendLine("using System.ComponentModel;"); code.AppendLine(); // Generate the implementation for each property foreach (var property in notifyProperties) { code.AppendLine($"namespace {property.ContainingNamespace}"); code.AppendLine("{"); code.AppendLine($" public partial class {property.ContainingType} : INotifyPropertyChanged"); code.AppendLine(" {"); code.AppendLine($" private {property.PropertyType} _{property.PropertyName};"); code.AppendLine(); code.AppendLine($" public {property.PropertyType} {property.PropertyName}"); code.AppendLine(" {"); code.AppendLine($" get => _{property.PropertyName};"); code.AppendLine($" set"); code.AppendLine(" {"); code.AppendLine($" if (value == _{property.PropertyName}) return;"); code.AppendLine($" _{property.PropertyName} = value;"); code.AppendLine($" OnPropertyChanged(nameof({property.PropertyName}));"); code.AppendLine(" }"); code.AppendLine(" }"); code.AppendLine(); code.AppendLine(" public event PropertyChangedEventHandler PropertyChanged;"); code.AppendLine(); code.AppendLine(" protected virtual void OnPropertyChanged(string propertyName)"); code.AppendLine(" {"); code.AppendLine(" PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));"); code.AppendLine(" }"); code.AppendLine(" }"); code.AppendLine("}"); code.AppendLine(); } return code.ToString(); } public void Initialize(GeneratorInitializationContext context) { } private class NotifyProperty { public string PropertyName { get; set; } public string PropertyType { get; set; } public string ContainingType { get; set; } public string ContainingNamespace { get; set; } } } [AttributeUsage(AttributeTargets.Property)] public class NotifyAttribute : Attribute { } ``` This `ISourceGenerator` finds all properties with the `[Notify]` attribute and generates the boilerplate code for implementing `INotifyPropertyChanged`. The generated code includes the `OnPropertyChanged` method and the event handler for the `PropertyChanged` event. To use this generator, simply add the `[Notify]` attribute to the properties you want to generate the boilerplate code for: ```csharp public class MyClass { [Notify] public string MyProperty { get; set; } } ``` The generator will automatically generate the necessary code to implement `INotifyPropertyChanged` for the `MyProperty` property.