await operation in step causing thread switching(from a managed thread to thread pool thread) when using reqnroll while specflow continues to execute using same managed thread

[satishmarisetti123]

We are currently migrating from specflow to reqnroll. Specflow tests are configured to use "Nunit" as test execution framework and run in parallell(Parallelizable(ParallelScope.Fixtures).

Existing implementation:

BeforeTestRun hook: Registering CustomValueComparerRetriever(Implementation of IValueRetriever,IValueComparer) with reqnroll.assisst.Service.

BeforeFeature hook: creates an entry in dictionary object with threadId and objectcontainer for every execution of hook.

please see below for code samples.

[Binding]
internal class AssistRetrieverAndComparerRegistrationHooks
{
    private static readonly Dictionary<int, List<IObjectContainer>> ThreadFeatureContainers = new();

[BeforeFeature]
public static void BeforeFeature(IObjectContainer container,IContextManager manager)
{
    var threadId = Environment.CurrentManagedThreadId;

    lock (ThreadFeatureContainers)
    {
        if (!ThreadFeatureContainers.TryGetValue(threadId, out var list))
        {
            list = new List<IObjectContainer>();
            ThreadFeatureContainers.Add(threadId, list);
        }

        list.Add(container);
    }
}

[BeforeTestRun]
public static void BeforeTestRun(ILogger<AssistRetrieverAndComparerRegistrationHooks> logger)
{
       var valueRetrieverComparer = new StepArgumentTransformationValueRetrieverComparer(ThreadFeatureContainers);
    lock (Reqnroll.Assist.Service.Instance)
    {
        logger.LogDebug("Registering StepArgumentTransformation value Retriever/Comparer");
        if (!Reqnroll.Assist.Service.Instance.ValueRetrievers.OfType<StepArgumentTransformationValueRetrieverComparer>().Any())
        {
            Reqnroll.Assist.Service.Instance.ValueRetrievers.Register(valueRetrieverComparer);
        }

        if (!Reqnroll.Assist.Service.Instance.ValueComparers.OfType<StepArgumentTransformationValueRetrieverComparer>().Any())
        {
            Reqnroll.Assist.Service.Instance.ValueComparers.Register(valueRetrieverComparer);
            Reqnroll.Assist.Service.Instance.ValueComparers.Register(new EnumValueComparer());
        }
    }
}
}

CustomValueRetrieverComparer

internal class StepArgumentTransformationValueRetrieverComparer : IValueRetriever,
                                                                  IValueComparer
{
    private readonly IDictionary<int, List<IObjectContainer>> _containers;

    public StepArgumentTransformationValueRetrieverComparer(IDictionary<int, List<IObjectContainer>> containers)
    {
        _containers = containers;
    }

public bool CanRetrieve(KeyValuePair<string, string> keyValuePair, Type targetType, Type propertyType)
{
    if (GetContainer() is not IObjectContainer container)
    {
        return false;
    }

    propertyType = propertyType.GetSourceType();
    
    var converter = container.Resolve<IStepArgumentTypeConverter>();
    return converter.CanConvert(
        keyValuePair.Value,
        new RuntimeBindingType(propertyType),
        CultureInfo.InvariantCulture);
}
public object Retrieve(KeyValuePair<string, string> keyValuePair, Type targetType, Type propertyType)
{
    if (GetContainer() is not IObjectContainer container)
    {
        return false;
    }

    propertyType = propertyType.GetSourceType();

    var converter = container.Resolve<IStepArgumentTypeConverter>();
    return AsyncHelpers.RunSync(() => converter.ConvertAsync(
        keyValuePair.Value,
        new RuntimeBindingType(propertyType),
        CultureInfo.InvariantCulture),true);
}

private IObjectContainer GetContainer()
{
    lock (_containers)
    {
        return _containers.TryGetValue(Environment.CurrentManagedThreadId, out var result)
            ? result.LastOrDefault()
            : null;
    }
}

While invoking Table.CreateInstance() method from a step, assist.service is invoking canretrieve on the customvaluecomparerretriever which is fetching objectcontainer related to the current feature passing the currentmanagedThreadId to dictionary(created in beforeFeaturehook) it worked fine in specflow but after migrating to reqnroll thread executing the canretrieve of customValueComparerRetriever is different from thread executing the beforefeature hook.Hence we are not able to get objectcontainer of current feature hence not able to create instance from table.

Note:There is an await call in one of the steps which causing the switch from managed thread(that executed beforefeaturehook) to a threadpool thread to takeover the subsequent execution whereas same await operation when used with specflow did not cause switching to a threadpool thread. I am assuming this switching is internal to .NET asyn/await implementation but I am wondering why this is not happening any time while using specflow.

Can you please help me how to deal with this problem or change the implementation for reqnroll?

[304NotModified]

@satishmarisetti123 I've updated your post because of some code was unreadable. Could you please fix the indentation and maybe, post a smaller test case. Its not really a minimal example.

[304NotModified]

Maybe this could help

https://stackoverflow.com/help/minimal-reproducible-example

[DerAlbertCom]

this is the nature of async/await that there is no really a guarantee which thread executes the code after an await.

What is your goal with having Thread Specific Object Container?
Why are must they be shared for a Thread?
And why your are retrieving only the last one for a thread?

Why is this not stored in the FeatureContext or ScenarioContext?