More convenient usage of the generator

[Rekkonnect]

The current approach is to declare a field that is basically useless for StyledProperty. What I would prefer is having an attribute that is placed on the containing class, which declares the type and the name of the property and the StyledProperty field.

For example,

[AvaStyledProperty<double>(nameof(MinValue))]
[AvaStyledProperty<double>(nameof(MaxValue))]
[AvaStyledProperty<double>(nameof(CurrentValue))]
public partial class ExampleControl : UserControl
{
}

Generating:

partial class ExampleControl
{
    public static readonly StyledProperty<double> MinValueProperty =
        AvaloniaProperty.Register<ExampleControl, double>(nameof(MinValue));

    public double MinValue
    {
        get => GetValue(MinValueProperty);
        set
        {
            SetValue(MinValueProperty, value);
        }
    }

    public static readonly StyledProperty<double> MaxValueProperty =
        AvaloniaProperty.Register<ExampleControl, double>(nameof(MaxValue));

    public double MaxValue
    {
        get => GetValue(MaxValueProperty);
        set
        {
            SetValue(MaxValueProperty, value);
        }
    }

    public static readonly StyledProperty<double> CurrentValueProperty =
        AvaloniaProperty.Register<ExampleControl, double>(nameof(CurrentValue));

    public double CurrentValue
    {
        get => GetValue(CurrentValueProperty);
        set
        {
            SetValue(CurrentValueProperty, value);
        }
    }
}

[lucdem]

That would also be a valid approach, but personally I just don't like the idea of declaring properties on top of a class rather than inside it. Totally subjective opinion and I'm sure some would consider it completely silly, but that's how I feel about it.

Even though the added field is useless when it comes to styled properties, ultimately custom controls are not something you'll typically create by the millions, so a few extra bytes of ram are a completely negligible cost. Although I understand why others would be bothered by it purely from principle.

And in the very unlikely scenario someone decides to use this package, decides to create a crazy amount of controls in their app and finds the extra memory relevant, they can just fall back to writing the full boilerplate by hand for that specific control.

Anyway, that is all to say I might add this at some point if I feel like it but can't promise anything. If someone makes a pr implementing it I'd gladly take a look at it as well.

[shameleo]

With latest C# partial properties can be used. Community.Toolkit already added support for using [ObservableProperty] with partial properties while still maintaining using with fields (for previous C# versions).

[lucdem]

With latest C# partial properties can be used. Community.Toolkit already added support for using [ObservableProperty] with partial properties while still maintaining using with fields (for previous C# versions).

@shameleo When I created this repo I made a suggestion to the Avalonia team that it would be nice for them to add source generators to the project, as you can see here: AvaloniaUI/Avalonia#14731.

One of the maintainers answered that they were waiting for partial properties, so I assume that they have this on their roadmap already, and eventually this repo will no longer have a purpose as the framework itself will already have something similar.