C# 类似工厂的模式，无需手动将鉴别器写入工厂

我有以下资料：

public abstract class FooBase
{
    public virtual int Id { get; set; }
}

public class Foo1 : FooBase { /* could be stuff here */ }

public class Foo2 : FooBase { /* could be stuff here */ }

public class Bar
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual SOMETHING WhichFoo { get; set } 
}

…其中

WhichFoo

处理要使用的

FooBase

（可能是

“Foo1”

的

string

，但这看起来相当混乱）

使用映射：

public class FooBaseMap : ClassMap<FooBase>
{
    public FooBaseMap()
    {
        this.Id(x => x.Id);
        this.DiscriminateSubClassesOnColumn("Type");
    }
}

public class Foo1Map : SubclassMap<Foo1>
{
    public Foo1Map() { this.DiscriminatorValue("Foo1"); }
}

public class Foo2Map : SubclassMap<Foo2>
{
    public Foo2Map() { this.DiscriminatorValue("Foo2"); }
}

public class BarMap : ClassMap<Bar>
{
    this.Id(x => x.Id);
    this.Map(x => x.Name);
    this.References(x => x.FooFactory);
}

public class FooFactoryBaseMap : ClassMap<FooFactoryBase>
{
    this.Id(x => x.Id);
    this.HasMany(x => x.Bars).Inverse();
    this.DiscriminateSubClassesOnColumn("Id");
}

public class Foo1FactoryMap : SubClassMap<Foo1Factory>
{
    this.DiscriminatorValue(Foo1Factory.Guid);
}

其中

GetANewFoo（）

可以是一个方法，一个返回

Foo1

或

Foo2

的空实例的属性

实际上，我想做的是将

GetANewFoo

创建的

FooBase

类型存储在

Bar

中

---

当我创建一个

条形图时，如果不显式地手动将
“Foo1”
或
“Foo2”
写入
条形图，最好的方法是什么？
您可以在条形图表中创建一个列，该列将保存它是什么类型的Foo。因此，如果这个
属性的类型是
枚举
，或者
字符串
，或者
int
（无论什么），您可以使用
开关大小写语句
来识别Foo的类型，创建您需要的并返回

就这样,

    public FooBase GetANewFoo()
    {
        switch (WhichFoo)
        {
            case "Foo1": return new Foo1();
            case "Foo2": return new Foo2();
            default: return null;
        }
    }

好吧，我想我明白了——事实上

和映射：

public class FooBaseMap : ClassMap<FooBase>
{
    public FooBaseMap()
    {
        this.Id(x => x.Id);
        this.DiscriminateSubClassesOnColumn("Type");
    }
}

public class Foo1Map : SubclassMap<Foo1>
{
    public Foo1Map() { this.DiscriminatorValue("Foo1"); }
}

public class Foo2Map : SubclassMap<Foo2>
{
    public Foo2Map() { this.DiscriminatorValue("Foo2"); }
}

public class BarMap : ClassMap<Bar>
{
    this.Id(x => x.Id);
    this.Map(x => x.Name);
    this.References(x => x.FooFactory);
}

public class FooFactoryBaseMap : ClassMap<FooFactoryBase>
{
    this.Id(x => x.Id);
    this.HasMany(x => x.Bars).Inverse();
    this.DiscriminateSubClassesOnColumn("Id");
}

public class Foo1FactoryMap : SubClassMap<Foo1Factory>
{
    this.DiscriminatorValue(Foo1Factory.Guid);
}

并将创建相应的
FooBase

有时候你只需要问一个问题就可以解决：）
你如何知道是创建foo1还是foo2？@lucasabiledebob很好，在
栏中添加了一个属性来处理这个问题。
public class BarMap : ClassMap<Bar>
{
    this.Id(x => x.Id);
    this.Map(x => x.Name);
    this.References(x => x.FooFactory);
}

public class FooFactoryBaseMap : ClassMap<FooFactoryBase>
{
    this.Id(x => x.Id);
    this.HasMany(x => x.Bars).Inverse();
    this.DiscriminateSubClassesOnColumn("Id");
}

public class Foo1FactoryMap : SubClassMap<Foo1Factory>
{
    this.DiscriminatorValue(Foo1Factory.Guid);
}

Bar bar = this.Session.Get<Bar>(10);

FooBase foo = bar.FooFactory.CreateFoo();