C#为具有泛型方法的泛型类创建接口
假设我有一段代码
public interface IFoo
{
}
public abstract class FooBase<TModel> : IFoo
{
public T Create<T>() where T : TModel;
}
public class Foo : FooBase<ModelBase>
{
public TModel Create<TModel>()
{
return Activator.CreateInstance(typeof(TModel));
}
}
public abstract class ModelBase
{
}
public class ModelFoo : ModelBase
{
}
public class ModelBar : ModelBase
{
}现在，假设我有这样一个类
public static FooProvider
{
public IFoo Get<TModel>()
{
var provider = ...; // find which IFoo class has generic TModel
return provider;
}
}我可以用下面的命令调用它
IFoo provider = FooProvider.Get<ModelBar>(); // -> instance of Foo但是我得到了IFoo的一个实例，因此不能访问FooBase方法。是否可以实现IFoo (或中间抽象类)来提供一个方法声明，该方法声明可以在不(必然)强制转换返回值provider的情况下调用
理想情况下，我希望能够做到
ModelBar bar = FooProvider.Get<ModelBar>().Create<ModelBar>();有可能吗？
回答 2
Stack Overflow用户
发布于 2013-05-09 17:26:08
随着问题的发展，我发布了第二个答案。下面是一个示例类层次结构，其中：
- 允许对许多模型类型使用相同的提供程序
- 允许以一致的方式构造许多不同的提供程序和模型
- 在编译时检查提供程序/模型兼容性在使用
期间不需要强制转换
代码：
public interface IWhatever { }
public class Foo { }
public class Foo2 : Foo, IWhatever { }
public class Bar { }
public class Bar2 : Bar { }
public class Bar3 : Bar, IWhatever { }
public interface IModelProvider<T>
{
U Create<U>() where U : T;
}
public class FooProvider : IModelProvider<Foo>
{
public U Create<U>() where U : Foo
{
// create a proper "U" - for example Foo or Foo2
return Activator.CreateInstance<U>(); // simpliest
}
}
public class BarProvider : IModelProvider<Bar>
{
public U Create<U>() where U : Bar
{
// create a proper "U" - for example Bar, Bar2 or Bar3
// more verbose
if (typeof(U) == typeof(Bar)) return (U)new Bar();
if (typeof(U) == typeof(Bar2)) return (U)(object)new Bar2();
if (typeof(U) == typeof(Bar3)) return (U)(object)new Bar3();
throw new Exception();
}
}
public class WhateverProvider : IModelProvider<IWhatever>
{
public U Create<U>() where U : IWhatever, new()
{
// create a proper "U" - for example Foo2 or Bar3
return new U(); // really the simpliest
}
}返回公共类VeryGenericProvider : IModelProvider _ TModel { TModel _ public _TModel_ Create() where TModel: new() _TModel_TModel{TModel__ return new TModel()；*}**}
public class ProviderFactory
{
public static IModelProvider<T> Get<T>() where T : new()
{
// somehow choose a provider for T, dumb implementation just for example purposes
if (typeof(T) == typeof(Foo)) return (IModelProvider<T>)new FooProvider();
if (typeof(T) == typeof(Bar)) return (IModelProvider<T>)new BarProvider();
if (typeof(T) == typeof(IWhatever)) return (IModelProvider<T>)new WhateverProvider();
return VeryGenericProvider<T>();
}
}
public static class ProviderTest
{
public static void test()
{
Foo foo = ProviderFactory.Get<Foo>().Create<Foo>();
Foo2 foo2 = ProviderFactory.Get<Foo>().Create<Foo2>();
// Bar2 bar2 = ProviderFactory.Get<Foo>().Create<Bar2>(); - compile error
Bar2 bar2 = ProviderFactory.Get<Bar>().Create<Bar2>(); // - ok!
Bar3 bar3 = ProviderFactory.Get<IWhatever>().Create<Bar3>();
}
}这段代码可以编译，但我还没有运行它。请注意，“测试”中的最终用法确实执行类型检查，并且不需要任何强制转换--但是提供者的内部实现肯定需要强制转换一些东西--例如，请参阅手动构造对象的BarProvider。即使“我们知道”确定U是Bar2，也没有办法告诉语言将U上的约束从Bar升级到Bar2 -因此需要双重转换。
我的意思是：
return (U)new Bar(); // is ok because U is constrained to 'Bar'对比
return (U)new Bar2(); // will not compile, U:Bar is not related to Bar2:Bar
return (U)(object)new Bar2(); // is ok: temporary cast to object 'erases' type informationStack Overflow用户
发布于 2013-05-09 16:54:58
你的意思是
ModelBar bar = FooProvider.Get<ModelBar>().Create<ModelBar>();或者更确切地说
ModelBar bar = FooProvider.Get<ModelBar>().Create();我觉得前者有点奇怪，除非在某些情况下，第一个ModelBar实际上是ModelBarBase或IModelBar，而后者ModelBar实际上是最后一个可构造的类型。
无论如何，我也发现您的类布局有点奇怪，因为在您的代码示例中，Get()和Create()来自同一个类(Foo/FooBase)。我觉得你把SRP搞砸了。
我会推荐：
public class FooProvider
{
public static Provider<T> Get<T> { return new Provider<T>(); };
}
public class Provider<T>
{
public T CreateDirect()
{
return Activator.Create<T>();
}
public TDerived CreateDerived<TDerived>() where TDerived : T
{
return Activator.Create<TDerived>();
}
}在此设置中，您可以：
class IMyInterf {}
class MyType : IMyInterf {}
class MyChildType : MyType {}
MyType tmp1 = FooProvider.Get<MyType>().CreateDirect();
MyChildType tmp1 = FooProvider.Get<MyType>().CreateDerived<MyChildType>();
MyChildType tmp1 = FooProvider.Get<IMyInterf>().CreateDerived<MyChildType>();这只是一个草图，手写，没有编译，但它显示了一般的想法。
如果您删除"CreateDirect“并将"CreateDerived”重命名为just Create，您将得到类似于您的代码的内容，但更简单。当然，如果确实需要，您现在可以将这两个单独的类混合并压缩成一个类，但我看不出这有什么实际意义:)
编辑：
当然，您可以引入一个ProviderBase<T>和多个OrangeProvider:ProviderBase<Orange>，而不是Provider<T>，这只是为了更容易地构建/找到适当的提供者，但实际的Get<>仍然必须返回实际的ProviderBase<T>或IProvider<T>。
https://stackoverflow.com/questions/16457695
复制相似问题
腾讯云开发者
