C# Func委托给声明的方法

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

    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 TypeResolverResult tryretrievefrom可重用（TypeResolverConfiguration TypeResolverConfiguration），其中T:class
{
返回null；
}
私有类型ResolverResult BuildNew（类型ResolverConfiguration类型ResolverConfiguration），其中T:class
{
返回null；
}

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

我似乎不明白，我试过：

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

private Func\u 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、IManager
{
私人Neeeddelgate；
公共管理器（运行时配置运行时配置，IList存储库）
{
if（runtimeConfiguration.WhatEver）
{
neeedDelegate=tryretrievefromReusables；
}
其他的
{
neeeddelgate=BuildNew；
}
}
公共重写类型ResolverResult Resolve（），其中T:class
{
//要避免这样做：
if（runtimeConfiguration.WhatEver）
{
TryRetrieveFromReusables（新类型ResolverConfiguration（））；
}
其他的
{
BuildNew（新类型ResolverConfiguration（））；
}
//就这个
neeedDelegate（新类型解析配置（））；
}
私有类型ResolveResult TryRetrieveFromReusables（类型ResolverConfiguration类型ResolverConfiguration），其中T:class
{
返回null；
}
私有类型ResolverResult BuildNew（类型ResolverConfiguration类型ResolverConfiguration），其中T:class
{
返回null；
}
}

更新在我看来，这样的方法应该是可行的，只要

atypesolver

在

解析

上有

其中T:class

：

---

如果愿意，您可以将

var typeResolver=…

行移动到它自己的方法中，以分离逻辑并允许您使用它，而不仅仅是

Resolve

。如果这样做，解析可能会非常简单：

return GetTypeResolver（）（new-TypeResolverConfiguration（））
您似乎不太清楚泛型是如何工作的。我将给出一个快速概述，但请阅读

当你有一个泛型类

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

它将把
Foo
的所有用法替换为
FooInt
，
Foo
替换为
FooString

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

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

它将用
GetBarInt
替换
GetBar
，用
GetBarString
替换
GetBar

但田地不是这样的。如果你有一个这样的班级

public class Foo
{
    public T Bar;
}

你不能这样做

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

Foo-Foo=new-Foo（）；
foo.Bar=1；
foo.Bar=“测试”；

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

但我想说的是这一点。泛型并不是什么神奇的“我不需要指定类型”特性。它们是对编译的提示，提示“我将多次执行相同的操作，我希望您为我生成代码。”
您仍然不能这样做，因为包含的类不是泛型的。
T
来自哪里？@cadrell0来自“Where T:class；”@TimS。我希望使用Func委托，但你是对的，我必须创建自己的委托，我只是觉得我遗漏了一些东西。Thanks@Marco这与您最初的尝试有相同的问题。这只是代码多一点，外观更干净一点；使用
Func
或
TypeResolver
可以。不好的是在没有定义
T
的上下文中使用
T
，例如非泛型类的字段。您试图在什么上下文中使用它？如果没有泛型，则很难拥有泛型类型参数。方法可以是泛型的，即使类型不是泛型的，因为调用方定义了该类型。但是，除非包含的类型是泛型的，否则字段和属性不能是泛型的。@cadrell0方法是泛型的，但类不是泛型的，并且它们具有定义的约束：class@cadrell0是的，你说得对，回到起点。@Marco你希望如何使用这个领域？也许使用局部变量可以更好地满足您的需要？另一种选择，虽然不是很好，但将其存储为非泛型
对象
，并在运行时强制转换（例如，在非泛型类的泛型方法中）。@TimS。基本上，我有一个配置对象，根据该对象中的设置，我需要创建两个不同的代码路径。另一种选择是在类中的某些代码运行时使用条件句，但我想避免这种情况。我确实知道它们是如何工作的，但我不知道的是，是否可以在委托用法的定义中设置约束，因此我的问题是。回到我的java时代，大约在2004年，当强大的Sun java论坛还没有建立时，我对泛型有了最好的答案，我记不起确切的名字，我相信他的昵称是Jonathan。不过还是要谢谢你：）
public class FooInt
{
    public int Bar { get; set; }
}

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

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() { ..... }
}

public class Foo
{
    public T Bar;
}

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