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: AsyncEnumerableWrapperFactory<Test1Factory>]

​

public class Program

{

    public static void Main()

    {

        var files = new List<string>(Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll"));

        files.Add(typeof(Program).Assembly.Location);

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

        foreach (var assembly in context.GetAssemblies())

        {

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

            var asm = context.LoadFromAssemblyName(assembly.GetName());

            foreach (var referencedAssembly in asm.GetReferencedAssemblies())

            {

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

            }

        }

        Console.WriteLine("---------------");

        foreach (var assemblyName in Assembly.GetExecutingAssembly().GetReferencedAssemblies()) {

            Console.WriteLine(assemblyName);

        }

        Console.WriteLine("---------------");

        var factory = typeof(Program).Assembly

            .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;

    }

}