将函数委托给已声明的方法

本文关键字：声明 方法 函数 | 更新日期: 2023-09-27 18:22:21

在非泛型类中声明这两个方法，它们共享相同的签名：

    private TypeResolverResult<T> TryRetrieveFromReusable<T>(TypeResolverConfiguration<T> typeResolverConfiguration) where T : class 
    {
        return null;
    }
    private TypeResolverResult<T> BuildNew<T>(TypeResolverConfiguration<T> typeResolverConfiguration) where T : class
    {
        return null;
    }

如何创建代表这些方法签名的委托？

我似乎不明白，我试过了：

    private Func<TypeResolverConfiguration<T>, TypeResolverResult<T>> _typeResolveFunc;

但很明显，这不起作用，因为类是非泛型的，我无法改变这一点。

感谢

更新

这或多或少是我需要的：

    public class Manager : ATypeResolver, IManager
    {
        private neeedDelegate;

        public Manager(RuntimeConfiguration runtimeConfiguration, IList<RepositoryContainer> repositories)
        {
            if (runtimeConfiguration.WhatEver)
            {
                neeedDelegate = TryRetrieveFromReusable;
            }
            else
            {
                neeedDelegate = BuildNew;
            }
        }
        public override TypeResolverResult<T> Resolve<T>() where T : class
        {
            //Want to avoid doing this:
            if (runtimeConfiguration.WhatEver)
            {
                TryRetrieveFromReusable(new TypeResolverConfiguration<T>());
            }
            else
            {
                BuildNew(new TypeResolverConfiguration<T>());
            }
            //and have just this
            neeedDelegate<T>(new TypeResolverConfiguration<T>());
        }
        private TypeResolverResult<T> TryRetrieveFromReusable<T>(TypeResolverConfiguration<T> typeResolverConfiguration) where T : class 
        {
            return null;
        }
        private TypeResolverResult<T> BuildNew<T>(TypeResolverConfiguration<T> typeResolverConfiguration) where T : class
        {
            return null;
        }
    }

将函数委托给已声明的方法

更新根据我所见，只要ATypeResolver在Resolve<T>:上有where T : class，这样的方法就应该有效

public class Manager : ATypeResolver, IManager
{
    private bool tryRetrieveFromReusable;
    public Manager(RuntimeConfiguration runtimeConfiguration, IList<RepositoryContainer> repositories)
    {
        this.tryRetrieveFromReusable = runtimeConfiguration.WhatEver;
    }
    public override TypeResolverResult<T> Resolve<T>()
    {
        var typeResolver = tryRetrieveFromReusable ? (TypeResolver<T>)TryRetrieveFromReusable : BuildNew;
        return typeResolver(new TypeResolverConfiguration<T>());
    }
}

这使用了一种自定义的委托类型（类似于您的Func也应该工作）：

public delegate TypeResolverResult<T> TypeResolver<T>(
    TypeResolverConfiguration<T> typeResolverConfiguration) where T : class;

如果您愿意，您可以将var typeResolver = ...行移动到它自己的方法，以分离逻辑，并允许您使用它而不仅仅是Resolve。如果您这样做了，Resolve可能很简单：return GetTypeResolver<T>()(new TypeResolverConfiguration<T>());。

您似乎并不完全理解泛型是如何工作的。我将简要介绍一下，但请阅读MSDN。

当你有一个通用类

public class Foo<T>
{
    public T Bar {get; set;}
}

你用它就像这个

Foo<int> intFoo = new Foo<int>();
Foo<string> stringFoo = new Foo<string();

在编译时，编译器将检测泛型类型的两种用法。它将为每种用法创建一种类型。所以你的程序集会有类似这样的类型（不，不完全是，但让我们假装一下，这样我们人类就能理解）。

public class FooInt
{
    public int Bar { get; set; }
}
public class FooString
{
    public string Bar { get; set; }
}

它将用FooInt取代Foo<int>的所有用途，用FooString取代Foo<string>的所有用途

现在，如果我们有一个具有泛型方法的非泛型类

public class Foo
{
    public T GetBar<T>() { ..... }
}

你像这个一样使用它

Foo foo = new Foo();
int x = foo.GetBar<int>();
string s = foo.GetBar<string();

编译器将生成

public class Foo
{
    public int GetBarInt() { ..... }
    public string GetBarString() { ..... }
}

它将用GetBarInt取代GetBar<T>，用GetBarString 取代GetBar<string>

但田地不是那样的。如果你有一个看起来像的类

public class Foo
{
    public T Bar;
}

你不能做这个

Foo foo = new Foo();
foo.Bar<int> = 1;
foo.Bar<string> = "test";

编译器就是不明白。我不是内部结构方面的专家，但我的猜测是，因为这指向内存中的一个位置，所以编译无法在编译时生成通用用法。

但我想说的是。泛型并不是什么神奇的"我不需要指定类型"功能。它们是对编译的提示，说"我要多次做同样的事情，我希望你为我生成代码。"

相关文章：