Blazor: Typecasting issue with Eventcallback<T> and it's argument

[gurunathancs1991]

Issue details.

Am using Eventcallback<T> type for events in my custom component . I need to do some action like type casting for argument before call to user component functional handler. hence it's need to be done in intermediate.

First, Trigger is a method which is JSinvokable one. Getting the data from JS end, arguments are serialized to string. now we need to convert it to proper type and invokeAsync to user component function handler.

Here, we cannot use the type directly. but having type details in a variable.

Here am facing some type casting issue. please find the code snippets.

    public class EventData
    {

       // Holding the function handler
        public object Handler { get; set; }
        // type of function handler, argument 
        public Type ArgumentType { get; set; }
        // set the event data details in a collection 
        public EventData Set<T>(EventCallback<T> action, Type type)
        {
            this.Handler = action;
            this.ArgumentType = type;
            return this;
        }
    }
// collection variable to hold this details. 
 protected Dictionary<string, EventData> DelegateList = new Dictionary<string, EventData>();

In above image, you can error. how can i resolve and do proper casting ?

I have already tried the Generic invoke method.

 public object InvokeGenericMethod(string name, Type type, Type parentType, params 
           object[] arguments)
           {
            MethodInfo method = parentType.GetMethod(name, BindingFlags.Instance | 
            BindingFlags.NonPublic);
            return method.MakeGenericMethod(type).Invoke(this, arguments);
            }

But this is sync action. so we are getting issues to return the data to JS end

[mkArtakMSFT]

Thanks for contacting us, @gurunathancs1991.

What are you trying to do here? There may be some other / better way to achieve what you're trying to do, so would be great to understand it first.

[gurunathancs1991]

Hi @mkArtakMSFT ,

Thanks for reply.

Actually, we are trying to return a value from Blazor end to JS end using `EventCallback as a callback method. but when calling another async method in callback method. the updated value is not return since async request is already succeed.

Base File

 [JSInvokable]
        public object Trigger(string eventName, string arg)
        {
            // getting the event data based on event event name.
            EventData data = this.DelegateList[eventName];
            // invoke the generic method as synchronous action. so eventcallback doesn't wait.
            // since here, sync action is happening henceforth, data returning back to js end before action done in sample event handler
            return this.InvokeGenericMethod("TriggerHandler", data.ArgumentType, this.GetType(), eventName, arg) as string;
        }
        public object InvokeGenericMethod(string name, Type type, Type parentType, params object[] arguments)
        {
            //collecting the method details.
            MethodInfo method = parentType.GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
            // invoke the generic method.
            return method.MakeGenericMethod(type).Invoke(this, arguments);
        }


        internal string TriggerHandler<T>(string eventName, string arg)
        {
            // cast the event method handler function to proper T type
            EventCallback<T> fn = (EventCallback<T>)this.DelegateList[eventName].Handler;

            // Deserialize the event arguments with generic type T
            var Settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };
            T eventArgs = JsonConvert.DeserializeObject<T>(arg, Settings);

            // Invoke the event handler method
            fn.InvokeAsync(eventArgs);

            // Return the event argument changes to client side
            return JsonConvert.SerializeObject(eventArgs);
        }

Sample component:

@page "/"

<comp @ref="instance" ValueChange="changeEvent"></comp>


@code {

    comp instance;

    public async void changeEvent(ChangeEventArgs args)
    {
        // setting this value in argument is worked properly 
        args.value = "this is before async method call";
        string data = await instance.DummyCall();
        // setting this value after an callback is not working properly. this is not reflected in textbox.
        args.value = "this is after async method call";
    }

}

Comp component

@using Typecasting
@using System.Threading.Tasks;

@inherits Base;

<input id="gencomp" type="text" />



@code {

    [Parameter]
    public EventCallback<ChangeEventArgs> ValueChange {
        get { return (EventCallback<ChangeEventArgs>)this.GetEvent("change"); }
        set { this.SetEvent<ChangeEventArgs>("change", value); }
    }

    public async Task<string> DummyCall()
    {
        // dummy async action method to show case the issue
        return  await Task.Run(() => { return "data"; } );
    }

}

I have prepared a sample to reproduce in this link:

https://github.com/gurunathancs1991/Typecasting

Kindly give me the suggestion to resolve this issue.

Thank you for contacting us. Due to no activity on this issue we're closing it in an effort to keep our backlog clean. If you believe there is a concern related to the ASP.NET Core framework, which hasn't been addressed yet, please file a new issue.