Could the generated code also include a static implicit operator?

[morganski]

Steve,

First of all let me say how much I love using VoGen. I've been lusting after the capabilities of F# for a while, and now with VoGen I can indulge myself and rid the primitives from my code.

The one thing I feel is missing is a conversion operator to convert directly from (not to!) an integer to a VoGen generated type.

As an example, I have a strongly typed MemberId...

[ValueObject<int>(Conversions.Default | Conversions.DapperTypeHandler)]
public partial struct MemberId
{
}

I'm using Blazor (but the same would be true for ASP.NET), where I have a route constraint as follows...

@page "/members/{member:int}"

Now, because there is no implicit operator to convert from int to MemberId, I can't define my backing property for this field as anything other than an int...

[Parameter]
public int Member { get; set; }

So then when I want to use this parameter in code, I have to convert it to a MemberId using MemberId.From(this.Member).

If there were a static implicit operator that did something like this...

public static implicit operator MemberId(int value)
{
    return MemberId.From(value);
}

I'd then be able to define my property as a MemberId and it would "just work". Well, I reckon it would.

I'm sure there may be good reasons why you have not included this in the code, but from my perspective this would make VoGen easier to use in many places. What do you think?

Thanks again for VoGen, it's excellent. I started on a ZX80 so you can keep your 6502 based 'puters. :-)

[SteveDunn]

Hi @morganski - thanks for the kind words - I'm very pleased to hear that you're enjoying using Vogen! Nice to get feedback from another 80's fossil! :)

Vogen does actually generate implicit (and explicit) converters. These are controlled by the toPrimitiveCasting and fromPrimitiveCasting arguments in the attribute:

However, for ASP.NET Core web apps, you don't need this as the ASP.NET runtime should just use the type converter that is generated by default. This tutorial explains how it works. I'd be interested to see if it doesn't work for you so that I can update it accordingly.
It works correctly in the sample web app, so maybe there's a difference in Blazor.

[morganski]

Hi Steve, thanks for the reply. I've augmented my code with the appropriate cast operator...

[ValueObject<int>(Conversions.Default, fromPrimitiveCasting: CastOperator.Implicit, toPrimitiveCasting: CastOperator.Implicit)]
public partial struct MemberId
{
}

And my blazor page is as follows...

@page "/members/{memberId:int}"

<PageTitle>Member Details</PageTitle>

<p>This is a test page</p>

@code{
    [Parameter]
    public MemberId MemberId { get; set; }
}

I've tested using both Implicit and also Explicit casting operators, but continue to get the same exception from the bowels of .NET...

System.InvalidCastException: Unable to cast object of type 'System.Int32' to type 'BlazorApp1.MemberId'.
   at Microsoft.AspNetCore.Components.Reflection.PropertySetter.CallPropertySetter[TTarget,TValue](Action`2 setter, Object target, Object value)
   at Microsoft.AspNetCore.Components.Reflection.ComponentProperties.<SetProperties>g__SetProperty|3_0(Object target, PropertySetter writer, String parameterName, Object value)

I've checked the source code for the ComponentProperties class and also the PropertySetter class too and can't immediately spot anything that looks "off" with the implementation (I have a lot of .NET experience going back to pre .NET 1 days, and have more reflection/property info/class info knowledge under my belt than many). I've managed to extract enough of the source code to create a repro that can be called outside of Blazor in a Console app, should you wish.

So, the code boils down to the following...

public class TestMemberId
{
    public static void TestSettingProperty()
    {
        var targetType = typeof(Test);
        var property = targetType.GetProperty("MemberId")!;
        var setMethod = property.SetMethod!;

        var propertySetterAsAction =
            setMethod.CreateDelegate(typeof(Action<,>).MakeGenericType(targetType, property.PropertyType));
        var callPropertySetterClosedGenericMethod =
            CallPropertySetterOpenGenericMethod.MakeGenericMethod(targetType, property.PropertyType);
        var setterDelegate = (Action<object, object>)
            callPropertySetterClosedGenericMethod.CreateDelegate(typeof(Action<object, object>), propertySetterAsAction);

        // Now call the setter...
        var target = new Test();

        // Boom...
        setterDelegate(target, 123);
    }

    private static readonly MethodInfo CallPropertySetterOpenGenericMethod =
        typeof(TestMemberId).GetMethod(nameof(CallPropertySetter), BindingFlags.NonPublic | BindingFlags.Static)!;

    private static void CallPropertySetter<TTarget, TValue>(
        Action<TTarget, TValue> setter,
        object target,
        object value)
        where TTarget : notnull
    {
        if (value == null)
        {
            setter((TTarget)target, default!);
        }
        else
        {
            setter((TTarget)target, (TValue)value);
        }
    }
}

public class Test
{
    [Parameter]
    public MemberId MemberId { get; set; }
}

Sadly it looks like there's nothing to do here other than my workaround of using an int property on the component, as clearly the above isn't using the (most excellent, IMHO) TypeConverter stuff. As an aside, I've been using TypeConverter to do some whacky stuff for over 20 years now.

Anyway, feel free to mess about with the above - I have but to no avail!

[morganski]

As an aside though, now you have shown me that I can create an implicit operator to convert from an int to a Vogen struct, I can live with the fact that in my Razor page I define the value as an integer...

@page "/members/{memberId:int}"

@code {
    [Parameter]
    public int MemberId { get; set; }

    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthenticationStateProvider!.GetAuthenticationStateAsync();
        var user = authState.User;

        _details = await _mediator.Send(new GetMemberDetails.Query
        {
            TenantId = user!.GetTenantId(),
            MemberId = this.MemberId  // Implicit cast will do for me, MemberId on the LHS is a Vogen struct
        });
    }

    public GetMemberDetails.Response _details { get; set; } = new();
}

It's not quite as clean as I'd have liked, but will do all the same.

Thanks again for your assistance here, and once again for such an excellent library!

[SteveDunn]

Thanks for the repro. It looks like a real pain to use value objects as parameters! I looked into it as I wondered why the explicit/implicit operators weren't working, and it's because they're not considered if the type being converted is object, which it is in this part of Blazor.