2

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

    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;
        }
    }
4

2 回答 2

1

更新从我所看到的，只要ATypeResolver有一个这样的方法应该可以where T : class工作Resolve<T>：

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

于 2013-07-15T19:31:07.283 回答
0

您似乎不完全了解泛型是如何工作的。我将简要介绍一下，但请阅读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; }
}

它将取代Foo<int>withFooInt和Foo<string>with的所有用法FooString

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

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

它将替换GetBar<T>为GetBarInt和GetBar<string>GetBarString

但田野不是那样的。如果你有一个看起来像这样的课程

public class Foo
{
    public T Bar;
}

你不能做这个

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

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

但我想说的是这个。泛型并不是什么神奇的“我不需要指定类型”的特性。它们是编译的提示，说“我将多次做同样的事情，我希望你为我生成代码。”

于 2013-07-15T20:00:04.443 回答