Pass custom type as command parameter

Question

I have to migrate an old Delphi application to WPF with the MVVM Light framework, in my main screen I have about 50 MenuItems... (no comment).

Currently, each MenuItem has a RelayCommand that executes a generic method based on a precise model:

<MenuItem Command="{Binding ShowOrderCommand}"/>

and in ViewModel

ShowOrderCommand = new RelayCommand(ShowGridType<OrderModel>, CanShowGridType)

(where OrderModel interface is IBaseModel) calling this method definition:

ShowGridType<T>() where T : IBaseModel

(note: generic type must be kept because of DI resolution further in code).

I would like to remove these hundreds of lines of RelayCommand<OrderModel, PriceModel, ...> instantiations by a single command that can pass the type of model via a command parameter (or other) with a generic method like ShowCommand = RelayCommand<IBaseModel> or RelayCommand<TModel>.

I thought I had found the solution simply through this:

<MenuItem Command="{Binding ShowCommand}"  CommandParameter="{x:Type models:OrderModel}"/>
ShowCommand = RelayCommand<IBaseModel>(ShowGridType);
ShowGridType<Tmodel>(Tmodel model) where Tmodel : IBaseModel

But when I click on my MenuItem I have a conversion error:

Unable to cast object of type 'System.RuntimeType' to type 'XXXXXX.Models.IBaseModel'

I have also tried to receive an 'object' instead of a IBaseModel, but can't find how to use this with the generic definition ShowGridType<T> .

Any idea that will help?

Answer 1

I use Unity as container and I only need the type to resolve many things [...]

If it is only about resolution, you could expose the command with Type as parameter.

public RelayCommand<Type> ShowOrderCommand { get; }

Create methods for the execute and can execute delegates.

private bool CanShowOrder(Type type)
{
   // ...replace with your code.
   return true;
}

private void ShowOrder(Type type)
{
   // Resolve type using the your container here.
   var obj= _myUnityContainer.Resolve(type);

   // ...do something with the instance.
}

As you can see, Unity does not only provide the generic extension methods for resolving, there are others that work with Type, see below. That means you do not need a generic method in your view model.

• Documentation for Resolve

  object Resolve(Type type, string name, params ResolverOverride[] overrides)
  

• Documentation for UnityContainerExtensions

  public static object Resolve(this IUnityContainer container, Type t, params ResolverOverride[] overrides)
  

Initialize the ShowOrderCommand command using both methods.

ShowOrderCommand = new RelayCommand<Type>(ShowOrder, CanShowOrder);

In XAML, bind the model as you did in the question as command parameter for each MenuItem.

<MenuItem Command="{Binding ShowCommand}"  CommandParameter="{x:Type models:OrderModel}"/>

---

Now, if you really need to call your own generic method with a specific type, there are two options.

1. Check the type explicitly using an if or switch statement to call you generic ShowGridType<T> method.

   private void ShowOrder(Type type)
   {
      if (type == typeof(OrderModel))
         ShowGridType<OrderModel>();
   
      // ...check other derivatives.
   }
   

2. Reflect the method and type parameter and call it. Here, you get the method info using GetMethod and use the concrete Type that you have as type parameter for it. Then you invoke it on this, because the method is defined in the containing class, and without parameters (null).

   private void ShowOrder(Type type)
   {
      var method = GetType().GetMethod(nameof(ShowGridType), BindingFlags.Instance | BindingFlags.NonPublic);
      var genericMethod = method.MakeGenericMethod(type);
   
      genericMethod.Invoke(this, null);
   }
   

   Please be aware that you there are some pitfalls, so this is just a proof-of-concept.

Both methods involve reflection, as you need to check the runtime type. Passing an IBaseModel as a command parameter will not magically call a generic method with a concrete type at runtime. This also means that there is a certain overhead and errors can occur at runtime, while the code compiles just fine, so you need to be sure what you are doing and check the code carefully.