反射 c#. 是否可以找出创建实例时使用的输入参数？

方法参数通过堆栈传递，即 在构造函数调用结束时，对传递给它的参数一无所知。有几种方法可以找出传递给构造函数的参数。

缓存

传递给构造函数的参数通常存储在新创建的对象的字段中。借助反射，我们可以删除这些字段。就个人而言，我不推荐这种方法，因为。你必须知道类型的内部结构，因为 由于这些字段通常是私有的，因此有关它们的元数据可能会因版本而异。

public sealed class Some
{
    readonly int x;

    public Some(int x)
    {
        this.x = x;
    }
}

static void Main()
{
    var some = new Some(5);

    // проверки опущены
    Console.WriteLine(some.GetField("x").GetValue(some)); // 5
}

在本地保存参数

您可以将参数本地存储在调用构造函数的方法的堆栈中。这是最简单和最安全的方法。

public sealed class Node
{
    readonly Node? next;

    public Node(Node? next = null)
    {
        this.next = next;
    }
}

static void Main()
{
    var next = new Node();
    var node = new Node(next);

    // `next` - это и есть аргумент 2-го конструктора
}

代理类

如果你真的想全局保存参数，而不是从内部打开类，那么你可以使用代理类。

public sealed class Some
{
    readonly int a, b, c;

    public Some(int a, int b, int c)
    {
        (this.a, this.b, this.c) = (a, b, c);
    }
}

public sealed class SomeProxy
{
    public Some Instance { get; }
    public int PassedA { get; }
    public int PassedB { get; }
    public int PassedC { get; }

    public SomeProxy(int a, int b, int c)
    {
        Instance = new Some(a, b, c);
        (PassedA, PassedB, PassedC) = (a, b, c);
    }
}

public interface ISomeOwner : IDisposable
{
    Some Instance { get; }

    void Remove();
}
public class SomeStorage
{
    readonly LinkedList<SomeProxy> proxies;

    ⋮

    public ISomeOwner Add(int a, int b, int c)
    {
        var proxy = new SomeProxy(a, b, c);
        var node = proxies.Add(proxy);

        ⋮

        return new SomeOwner(proxy.Instance, node);
    }

    ⋮

    seales class SomeOwner : ISomeOwner
    {
        internal SomeOwner(Some some, LinkedListNode<Some> node)
        {
            ⋮
        }

        ⋮
    }
}

^{重要的！这是伪代码。您不应将其复制到发布项目中。}

在创建类型对象并将其添加Some到我们预先创建的存储之后，我们可以通过从相应的SomeProxy.

因此，我们可以通过非常简单的方式在类本身、外部本地和全局存储中实现构造函数参数的存储。根据自己的情况选择适合自己的方法。

从已知类型的对象中获取构造函数非常容易，但是如果您想从泛型对象中获取构造函数，则必须努力工作。这是我关于第三种方法 - SomeProxy。可以用这样的类替换它：

public sealed class Proxy<out T>
{
    public T Instance { get; }
    public ConstructorInfo UsedConstructor { get; }
    public IReadOnlyList<object?> PassedArgs { get; }

    public Proxy(params object?[]? args)
    {
        if (!FindConstructor(out var ctor, args)) throw new ArgumentException("Suitable constructor not found", nameof(args));

        UsedConstructor = ctor;
        PassedArgs = new ReadOnlyCollection<object?>(args ?? Array.Empty<object?>);
        Instance = UsedConstructor.Invoke(PassedArgs);
    }
    
    static bool FindConstructorByArgs([MaybeNullWhen(false)] out ConstructorInfo constructor, params object?[]? args)
    {
        constructor = null!;

        var ctorArgTypes = args is null ? Array.Empty<Type?>() :
            args.Select(a => a is null ? null : a.GetType());
        var ctors = typeof(T).GetConstructors();
        ConstructorInfo? ctor = null;

        foreach (var _ctor in ctors)
        {
            var args = _ctor.GetParameters();

            if (args.Length != ctorArgTypes.Length) continue;

            for (var i = 0; i < args.Length; i++)
            {
                if (ctorArgTypes[i] is null &&
                    args[i].ParameterType != typeof(Nullable<>) &&
                    args[i].ParameterType.IsValueType)
                    continue;
                if (args[i].ParameterType != ctorArgTypes[i])
                    continue;
            }

            ctor = _ctor;

            break;
        }

        if (ctor is null) return false;

        constructor = ctor;

        return true;
    }
}