using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using System.Threading;

​

[assembly: Foo.Bar.AsyncEnumerableWrapperFactory<Foo.Bar.Test1Factory>]

​

namespace Foo.Bar;

​

public class Program

{

    public static void Main()

    {

        var domain = AppDomain.CurrentDomain;

        var files = new List<string>();

        files.AddRange(Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll"));

        files.AddRange(Directory.GetFiles(domain.BaseDirectory, "*.dll"));

        files.AddRange(Directory.GetFiles(Path.Combine(domain.BaseDirectory, domain.RelativeSearchPath ?? string.Empty), "*.dll"));

        Console.WriteLine(typeof(MetadataLoadContext).Assembly.Location);

        using var context = new MetadataLoadContext(new PathAssemblyResolver(files));

        context.LoadFromAssemblyPath(Assembly.GetEntryAssembly().Location);

        context.LoadFromAssemblyPath(Assembly.GetCallingAssembly().Location);

        context.LoadFromAssemblyPath(Assembly.GetExecutingAssembly().Location);

        var allAssemblies = new HashSet<Assembly>();

        foreach (var assembly in context.GetAssemblies())

        {

            Console.WriteLine(assembly.FullName);

            var asm = context.LoadFromAssemblyPath(assembly.Location);

            foreach (var referencedAssembly in asm.GetReferencedAssemblies())

            {

                try

                {

                    allAssemblies.Add(context.LoadFromAssemblyName(referencedAssembly));

                    Console.WriteLine($"\t{referencedAssembly.FullName}");

                }

                catch

                {

                    Console.WriteLine($"failed referenced assembly: {referencedAssembly.FullName}");

                }

            }

            allAssemblies.Add(asm);

        }

        // allAssemblies contains reflection-only assemblies; we can't get the attribute directly.

        var targetAssemblyName = allAssemblies

            .First(x => x.GetCustomAttributesData().Any(x => x.AttributeType.FullName.StartsWith(typeof(AsyncEnumerableWrapperFactoryAttribute<>).FullName)))

            .GetName();

        var factory = Assembly

            .Load(targetAssemblyName)

            .GetCustomAttribute(typeof(AsyncEnumerableWrapperFactoryAttribute<>))

            as IAsyncEnumerableWrapperFactory;

        var foo = new[] { "a", "b", "c" }.AsQueryable();

        factory.Create(foo);

        Console.WriteLine(nameof(Main));

    }

    public static void A()

    {

        var a = new StackTrace(false).GetFrames().Select(Foo).ToArray();

    }

    public static bool Foo(StackFrame frame)

    {

        var method = frame.GetMethod();

        var name = method.Name;

        var assembly = method.DeclaringType.Assembly.FullName;

        Console.WriteLine($"{name} : {assembly}");

        return true;

    }

}

​

[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]

public sealed class AsyncEnumerableWrapperFactoryAttribute<TFactory> : Attribute, IAsyncEnumerableWrapperFactory

    where TFactory : IAsyncEnumerableWrapperFactory, new()

{

    public TFactory Factory { get; } = new();   

    public IAsyncEnumerable<TSource> Create<TSource>(

        IQueryable<TSource> source)

        where TSource : class

        => Factory.Create(source);

}

​

public interface IAsyncEnumerableWrapperFactory

{

    public IAsyncEnumerable<TSource> Create<TSource>(IQueryable<TSource> source) where TSource : class;

}

​

public sealed class Test1Factory : IAsyncEnumerableWrapperFactory

{

    public IAsyncEnumerable<TSource> Create<TSource>(IQueryable<TSource> source) where TSource : class

    {

        Console.WriteLine(nameof(Test1Factory));

        return null;

    }

}