një konstruktor si delegat - a është e mundur në C#?

Jo, CLR nuk lejon delegatët e detyrueshëm për ConstructorInfo.

Sidoqoftë, thjesht mund të krijoni tuajën:

static T Make<T>(Action<T> init) where T : new()
{
  var t = new T();
  init(t);
  return t;
}

Përdorimi

var t = Make<Foo>( x => { x.Bar = "bar"; x.Baz = 1; });

Unë supozoj se normalisht do të bënit diçka të tillë si pjesë e një zbatimi në fabrikë, ku llojet aktuale nuk njihen në kohën e përpilimit...

Së pari, vini re se një qasje më e lehtë mund të jetë një hap fillestar pas krijimit, atëherë mund të përdorni gjenerikët:

static T Create<T>({args}) where T : class, ISomeInitInterface, new() {
    T t = new T();
    t.Init(args);
    return t;
}

Më pas mund të përdorni MakeGenericMethod dhe/ose CreateDelegate.

Përndryshe; ju mund ta bëni këtë me në fluturim me Expression (3.5) ose DynamicMethod (2.0).

Qasja Expression është më e lehtë për tu koduar:

    var param = Expression.Parameter(typeof(int), "val");
    var ctor = typeof(Foo).GetConstructor(new[] { typeof(int) });
    var lambda = Expression.Lambda<Func<int, Foo>>(
        Expression.New(ctor, param), param);
    var func = lambda.Compile();
    Foo foo = func(123);
    string s = foo.ToString(); // proof

ose (duke përdorur DynamicMethod):

    ConstructorInfo ctor = typeof(Foo).GetConstructor(new[] { typeof(int) });
    DynamicMethod dm = new DynamicMethod("Create", typeof(Foo),
            new Type[] { typeof(int) }, typeof(Foo), true);
    ILGenerator il = dm.GetILGenerator();
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Newobj, ctor);
    il.Emit(OpCodes.Ret);
    Converter<int, Foo> func = (Converter<int, Foo>)
        dm.CreateDelegate(typeof(Converter<int, Foo>));        
    Foo foo = func(123);
    string s = foo.ToString(); // proof

Unë mendoj se aq koncize sa do të arrini (pa kaluar në një model fabrike) do të ishte diçka me metoda anonime, si kjo:

delegate Foo FooGenerator(int x);

...    

void DoStuff()
{
    YourDelegateConsumer(x => new Foo(x));
}

Kjo nuk është duke bërë në mënyrë strikte atë që keni kërkuar (pasi ju po kaloni një delegat në një metodë anonime që kthen një shembull të ri, në vend që një delegat i drejtpërdrejtë te konstruktori), por nuk mendoj se çfarë po kërkoni është rreptësisht e mundur.

Kjo, natyrisht, është duke supozuar se po përdorni 3.5+

Duket sikur ndoshta dëshironi të përdorni modelin e fabrikës së klasës.

Modeli i metodës së fabrikës

Fatkeqësisht jo, konstruktorët nuk janë të njëjtat gjëra si metodat dhe si të tillë nuk mund të krijosh një delegat që i drejton ata. Megjithatë, kjo është një ide interesante, ndoshta me më shumë informacion mund të krijojmë një lloj zgjidhjeje që do të ishte sintaksisht e ngjashme.

Përgjigja e Marc Gravell më frymëzoi për zgjidhjen e mëposhtme shumë të thjeshtë:

static void Main()
{
    Pet a = _MakeObject(typeof(Dog));
    Pet b = _MakeObject(typeof(Cat));
}

private static Pet _MakeObject(Type type)
{
    ConstructorInfo info = type.GetConstructor(new Type[0]);
    return (Pet)info?.Invoke(null);
}

Pothuajse e njëjta gjë nëse konstruktori juaj ka parametra (në këtë shembull: 1 param i llojit int):

static void Main()
{
    Pet a = _MakeObject(typeof(Dog), 5);
    Pet b = _MakeObject(typeof(Cat), 7);
}

private static Pet _MakeObject(Type type, int age)
{
    ConstructorInfo info = type.GetConstructor(new [] { typeof(int) });
    return (Pet)info?.Invoke(new object[] { age });
}

Një tjetër opsion do të ishte përdorimi i klasës Activator, si kjo:

Përdorimi i llojeve të përgjithshme

public delegate Foo FooGeneratorDelegate<T>(int x);

public T FooGeneratorFunction<T>(int x)
{
    return (T)Activator.CreateInstance(typeof(T), x);
}

// implementation example
FooGeneratorDelegate<Foo> del = FooGeneratorFunction<Foo>;
Foo foo = del(someIntValue);

Të kalosh Type Foo si parametër

public delegate object FooGeneratorDelegate(Type t, int x);

public object FooGeneratorFunction(Type t, int x)
{
    return Activator.CreateInstance(t, x);
}

// implementation example
FooGeneratorDelegate del = FooGeneratorFunction;
Foo foo = (Foo)del(typeof(Foo), someIntValue);

Nëse lloji do të jetë gjithmonë i llojit Foo

public delegate Foo FooGeneratorDelegate(int x);

public Foo FooGeneratorFunction(int x)
{
    return (Foo)Activator.CreateInstance(typeof(Foo), x);
}

// implementation example
FooGeneratorDelegate del = FooGeneratorFunction;
Foo foo = del(someIntValue);

Supozimi im është se nuk është e mundur pasi do të kaloni një metodë të një objekti që nuk është krijuar ende.

Ndërsa përgjigjet e tjera mbështesin vetëm konstruktorin pa parametra. Këtu janë parametrat e mbështetjes së versionit. Shpresoj se mund të ndihmojë dikë që dëshiron të kthejë me parametrat ConsturctorInfo në Delegate.

public Delegate CreateDelegate(ConstructorInfo constructorInfo)
{
    var ctorParameters = constructorInfo.GetParameters();
    var lambdaParameters =
        ctorParameters.Select(x => Expression.Parameter(x.ParameterType, x.Name)).ToArray();
    var argsExp =
        ctorParameters.Select((p, i) => Expression.Convert(lambdaParameters[i], p.ParameterType));
    var newExp = Expression.New(constructorInfo, argsExp);
    var lambda = Expression.Lambda(newExp, lambdaParameters);
    return lambda.Compile();
}

Përdorimi:

CreateDelegate(/* ConstructorInfo */).DynamicInvoke(args);