Non-generic ExportProvider.GetExports(Type) method missing

Given a Type variable, how can I get its export?

public object Resolve<T>() => exportProvider.GetExportedValue<T>();          // OK
public object Resolve(Type type) => exportProvider.GetExportedValue(type);   // ??

[weltkante]

If you can elaborate on why this is important for you

I cannot speak for the OP, but I had the same requirement a few years ago when I had to implement IServiceProvider through a composition container. I don’t remember how I solved it back then, but I did get it to work via vs-mef at some point. These days I don’t see much usage of IServiceProvider so unfortunately I don’t have this trick in my codebase anymore.

I think if you expose GetContractName publically that should be enough, I think you can just pass object into the generic parameter of e.g. GetExportedValue together with the contract name, something like that already seems to work (unless there is a hidden edge case where it fails?):

public static class ContainerExtensions
{
    private abstract class PartDiscoveryHelper : PartDiscovery
    {
        private PartDiscoveryHelper(Resolver resolver) : base(resolver) { }
        public static string GetContractNameHelper(Type type) => GetContractName(type);
    }

    public static object GetExportedValue(this ExportProvider container, Type type)
    {
        return container.GetExportedValue<object>(PartDiscoveryHelper.GetContractNameHelper(type));
    }
}

[znakeeye]

I managed to create an extension method for the following method:

IEnumerable<object> GetExportedValues(Type type, string contractName) 

Getting it done for the very much needed GetExported() method is way harder due to the complex conversion needed for the return value. 😢

IEnumerable<Lazy<object, object>> GetExports(Type type, Type metadataViewType, string contractName); 

Source code

public static class ExportProviderExtensions
{
    private static readonly Func<Type, CompiledMethods> createCompiledMethods;
    private static readonly ConcurrentDictionary<Type, CompiledMethods> compiledMethods = new ConcurrentDictionary<Type, CompiledMethods>();

    static ExportProviderExtensions()
    {
        createCompiledMethods = t => new CompiledMethods(t);
    }

    public static IEnumerable<object> GetExportedValues(this ExportProvider exportProvider, Type type, string contractName)
    {
        return GetOrAdd(type).GetExports(exportProvider, contractName);
    }

    private static CompiledMethods GetOrAdd(Type type) => compiledMethods.GetOrAdd(type, createCompiledMethods);

    private class CompiledMethods
    {
        public readonly Func<ExportProvider, string, IEnumerable<object>> GetExports;

        public CompiledMethods(Type type)
        {
            var method = GetMethod(type, typeof(string));

            var instance = Expression.Parameter(typeof(ExportProvider));
            var arguments = method.GetParameters().Select(p => Expression.Parameter(p.ParameterType)).ToArray();
            var parameters = Enumerable.Repeat(instance, 1).Concat(arguments);
            
            var body = Expression.Call(instance, method, arguments.ToArray<Expression>());
            var convert = Expression.Convert(body, typeof(IEnumerable<object>));

            var delegateType = typeof(Func<,,>).MakeGenericType(typeof(ExportProvider), typeof(string), typeof(IEnumerable<object>));
            var lambda = Expression.Lambda(delegateType, convert, parameters).Compile();
            
            GetExports = (Func<ExportProvider, string, IEnumerable<object>>) lambda;
        }

        private static MethodInfo GetMethod(Type type, params Type[] parameters)
        {
            return typeof(ExportProvider)
                .GetMethods()
                .Where(m => m.Name == nameof(ExportProvider.GetExportedValues))
                .Where(m => m.GetGenericArguments().Length == 1)
                .Single(m => ParametersMatch(m, parameters))
                .MakeGenericMethod(type);
        }

        private static bool ParametersMatch(MethodInfo method, Type[] parameters)
        {
            var ps = method.GetParameters();
            if (ps.Length != parameters.Length)
            {
                return false;
            }

            for (int i = 0; i < ps.Length; i++)
            {
                if (parameters[i] == null && ps[i].ParameterType.IsGenericParameter)
                {
                    continue;
                }

                if (ps[i].ParameterType != parameters[i])
                {
                    return false;
                }
            }
            return true;
        }
    }
}