Suggestion to improve code and performance

Why does the BindingFactoryHelpers class uses reflection to build the CustomTriggerArgumentBinding? There are no advantages in this approach, only disadvantages:

• It makes the code very difficult to understand.
• Worsens performance.

Solution option

Reflection is not needed to build the SimpleTriggerArgumentBinding, it is enough to take the following steps:

1. To get the FuncAsyncConverter you need to use the FuncAsyncConverter GetConverter<TAttribute>(Type typeSource, Type typeDest) method in the IConverterManager instance.
2. Create CustomTriggerArgumentBinding<TMessage, TTriggerValue> class in which “UserType” can be passed through the constructor.

Code examples

The GetDirectTriggerBindingWorker method in the BindingFactoryHelpers class should be rewritten as follows.

private static SimpleTriggerArgumentBinding<TMessage, TTriggerValue>
    GetDirectTriggerBindingWorker<TMessage, TTriggerValue>(
        ITriggerBindingStrategy<TMessage, TTriggerValue> bindingStrategy,
        IConverterManager converterManager,
        Type userType)
{
    var directConvert = converterManager.GetConverter<Attribute>(typeof(TMessage), userType);
    if (directConvert != null)
    {
        var argumentBinding = new CustomTriggerArgumentBinding<TMessage, TTriggerValue>(
            bindingStrategy, converterManager, directConvert, userType);
        return argumentBinding;
    }
    return null;
}

The GetDirectTriggerBinding method in the BindingFactoryHelpers class should be rewritten as follows.

private static SimpleTriggerArgumentBinding<TMessage, TTriggerValue>
    GetDirectTriggerBinding<TMessage, TTriggerValue>(
        Type exactType,
        ITriggerBindingStrategy<TMessage, TTriggerValue> bindingStrategy,
        IConverterManager converterManager)
{
    return GetDirectTriggerBindingWorker(bindingStrategy, converterManager, exactType);
}

An example of the implementation of the class CustomTriggerArgumentBinding<TMessage, TTriggerValue>.

internal class CustomTriggerArgumentBinding<TMessage, TTriggerValue> :
    SimpleTriggerArgumentBinding<TMessage, TTriggerValue>
{
    private IBindingDataProvider _bindingDataProvider;
    private readonly FuncAsyncConverter _converter;
    private readonly Type _userType;

    public CustomTriggerArgumentBinding(
        ITriggerBindingStrategy<TMessage, TTriggerValue> bindingStrategy,
        IConverterManager converterManager,
        FuncAsyncConverter converter,
        Type userType) : base(bindingStrategy, converterManager)
    {
        if (converter == null)
        {
            throw new ArgumentNullException(nameof(converter));
        }

        this._converter = converter;
        _userType = userType;
        this.ElementType = _userType;

        _bindingDataProvider = BindingDataProvider.FromType(ElementType);
        AddToBindingContract(_bindingDataProvider);
    }

    internal override async Task<object> ConvertAsync(
        TMessage value,
        Dictionary<string, object> bindingData,
        ValueBindingContext context)
    {
        var obj = await _converter(value, null, context);

        AddToBindingData(_bindingDataProvider, bindingData, obj);

        return obj;
    }
}

Result

The above code examples allow you to get the same behavior, but with more readable code and without sacrificing performance.

[Shazhko-Artem]

Hi @v-anvari , I raised a new pull request for this case. The solution was successfully built, but I can’t figure out what the problem is with vstest.console. Looks like it’s a pipeline setup problem. Let me know if the problem is with my pull request.

[v-anvari]

Hi @Shazhko-Artem , I am following up with the team and the PR will be assigned to anyone from the team for further look up.