Supporting calling non-generic instance methods on generic types

[julienGrd]

Describe the bug

I have a generic component wich need some Js interaction. My component is an autocomplete wich listen on the keypress event to launch research. Whe i try invoke c# method from Js, I have this following Js error
"Error: System.InvalidOperationException: Late bound operations cannot be performed on types or methods for which ContainsGenericParameters is true.
"

To Reproduce

create a generic component, which contain an input type text

@typeparam TItem 
@inherits AutoCompleteViewModel<TItem>
<input type="text" id="@Id" class="form-control" value="@Value"> `

register js on render

 protected override async Task OnAfterRenderAsync()
        {
            this.JsRuntime.InvokeAsync<object>("listenAutoComplete", this.Id, new DotNetObjectRef(this));
            await base.OnAfterRenderAsync();
        }

[JSInvokable]
        public void SynchroniseValue(string value)
        {
            if(this.Value != value)
            {
                this.Value = value;
                this.LaunchResearch();
            }
        }

function listenAutoComplete(id, control) {
    $("#" + id).keyup(function () {
        var value = $(this).val();
        control.invokeMethodAsync('SynchroniseValue', value);
    });
}

Expected behavior

Have a way to call C# method without error

Additional context

My first idea was to use the key-* event of razor, but i was unable to have a satisfaying behavior with ths events (unable to retrieve the current value of my input, binding seem only fire when control lost focus), so i decided to switch on js.
If you have another solution, i take it ;-)

[mkArtakMSFT]

Thanks for contacting us, @julienGrd.
You're facing this issue because we currently don't support JSInterop from a generic type.

[mrpmorris]

@mkArtakMSFT This PR on the old repo would have fixed it. If I can get approval then I will reimplement it on this repo instead - but I don't want to do that if there is no chance of it being merged in...

dotnet/jsinterop#6

[SteveSandersonMS]

@mrpmorris I'd recommend holding off on reimplementing the PR. The reason is that, if we're only supporting calling methods on generic types if it's an instance method and the method itself has no generic args [1], then my gut sense is that it should be an extremely small change, on the order of a few lines of code. The previous PR involved some extensive refactoring which I would hope we can avoid.

[1] I do agree this is probably the right restriction, since you probably don't want to let client-side code pass arbitrary type args. There would be security implications if it can force the server to load types (and execute static constructors, etc.) that you never expected it to load.

[mrpmorris]

@SteveSandersonMS Hi Steve.
The code was mostly refactored (500 lines). I extracted out your code for holding lookups so we could have one for static methods and one for instance methods. The lookup method was different because static must have unique names per DLL, but for instance we couldn't do this because we need to allow duplicate names in the DLL that are unique based on hierarchy.

Most of the code is actually test classes (probably 2/3 or 3/4 of the remaining 500 lines).

[SQL-MisterMagoo]

FYI - for a workaround, I have found that using a child component to handle the JS Interop works, then I just wired up some Action parameters so the child can notify the Generic parent when something happens.