C# 基于状态枚举设置子状态枚举

背景：

让我们以一个在电子商务网站上列出的项目为例来解释这个问题。也许你有一辆自行车要出售，你试图在销售网站上列出它，同时选择一个类别和子类别。也许你可以选择：

（类别>子类别） 车辆>自行车

作为类别和子类别。可以理解，车辆类别有自己独特的子类别集

问题：

我有一个类的以下代码：

public class Listing 
{
    public Category ListingCategory { get; set; }
    public Subcategory ListingSubcategory { get; set; }

    public enum Category {
        Vehicles,
        Guitars,
        ExoticAnimals
    }
}

---

如何允许子类别选择取决于所选类别，例如在背景示例中如果解决方案有效，我很高兴不使用枚举

我推荐以下结构：

  public class Category {
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }

    public Category Parent { get; set; }
    public IList<Category> Children { get; set; }
  }

---

我建议采用以下结构：

  public class Category {
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }

    public Category Parent { get; set; }
    public IList<Category> Children { get; set; }
  }

---

我建议采用以下结构：

  public class Category {
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }

    public Category Parent { get; set; }
    public IList<Category> Children { get; set; }
  }

---

我建议采用以下结构：

  public class Category {
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }

    public Category Parent { get; set; }
    public IList<Category> Children { get; set; }
  }

---

可以使用表示子类别的抽象类。它将在其Ctor中获取类别，并在类别和子类别项列表之间维护静态映射

子类别项可以包含任何单个子类别项所需的所有功能（如果有）

public class SubcategoryItem
{
    public string Name { get; set; }
    public Action WhatItDoes { get; set; }

    public SubcategoryItem(string name, Action trick)
    {
        Name = name;
        WhatItDoes = trick;
    }
}

public abstract class AbsSubcategory
{
    private static readonly IDictionary<Category, IList<SubcategoryItem>> mCategoriesMap = new Dictionary<Category, IList<SubcategoryItem>>();

    public abstract IList<SubcategoryItem> Subcategories { get; }

    protected AbsSubcategory(Category cat)
    {
        if (Subcategories != null) mCategoriesMap[cat] = Subcategories;
    }
}

public class VehiclesSubcategory : AbsSubcategory
{
    private static readonly IList<SubcategoryItem> mSubcategories;
    public override IList<SubcategoryItem> Subcategories
    {
        get { return mSubcategories; }
    }

    static VehiclesSubcategory()
    {
        mSubcategories = new List<SubcategoryItem>()
        {
            new SubcategoryItem("Bikes", () => { /* Do something */ } ),
            new SubcategoryItem("Cars", () => { /* Do something */ } ),
        };
    }

    public VehiclesSubcategory()
        : base(Category.Vehicles)
    {
    }
}

公共类子类别项
{
公共字符串名称{get；set；}
公共行动{get；set；}是什么
公共子类别项（字符串名称、操作技巧）
{
名称=名称；
做什么=欺骗；
}
}
公共抽象类子类别
{
私有静态只读IDictionary mCategoriesMap=new Dictionary（）；
公共抽象IList子类别{get；}
受保护的子类别（类别cat）
{
如果（子类别！=null）mCategoriesMap[cat]=子类别；
}
}
公共类车辆子类别：abs子类别
{
私有静态只读IList mSubcategories；
公共覆盖IList子类别
{
获取{return mSubcategories；}
}
静态车辆子类别（）
{
mSubcategories=新列表（）
{
新的子类别项（“自行车”，（）=>{/*做点什么*/}），
新的子类别项（“汽车”，（）=>{/*做点什么*/}），
};
}
公共车辆子类别（）
：基本（车辆类别）
{
}
}

您可以使用表示子类别的抽象类。它将在其Ctor中获取类别，并在类别和子类别项列表之间维护静态映射

子类别项可以包含任何单个子类别项所需的所有功能（如果有）

public class SubcategoryItem
{
    public string Name { get; set; }
    public Action WhatItDoes { get; set; }

    public SubcategoryItem(string name, Action trick)
    {
        Name = name;
        WhatItDoes = trick;
    }
}

public abstract class AbsSubcategory
{
    private static readonly IDictionary<Category, IList<SubcategoryItem>> mCategoriesMap = new Dictionary<Category, IList<SubcategoryItem>>();

    public abstract IList<SubcategoryItem> Subcategories { get; }

    protected AbsSubcategory(Category cat)
    {
        if (Subcategories != null) mCategoriesMap[cat] = Subcategories;
    }
}

public class VehiclesSubcategory : AbsSubcategory
{
    private static readonly IList<SubcategoryItem> mSubcategories;
    public override IList<SubcategoryItem> Subcategories
    {
        get { return mSubcategories; }
    }

    static VehiclesSubcategory()
    {
        mSubcategories = new List<SubcategoryItem>()
        {
            new SubcategoryItem("Bikes", () => { /* Do something */ } ),
            new SubcategoryItem("Cars", () => { /* Do something */ } ),
        };
    }

    public VehiclesSubcategory()
        : base(Category.Vehicles)
    {
    }
}

公共类子类别项
{
公共字符串名称{get；set；}
公共行动{get；set；}是什么
公共子类别项（字符串名称、操作技巧）
{
名称=名称；
做什么=欺骗；
}
}
公共抽象类子类别
{
私有静态只读IDictionary mCategoriesMap=new Dictionary（）；
公共抽象IList子类别{get；}
受保护的子类别（类别cat）
{
如果（子类别！=null）mCategoriesMap[cat]=子类别；
}
}
公共类车辆子类别：abs子类别
{
私有静态只读IList mSubcategories；
公共覆盖IList子类别
{
获取{return mSubcategories；}
}
静态车辆子类别（）
{
mSubcategories=新列表（）
{
新的子类别项（“自行车”，（）=>{/*做点什么*/}），
新的子类别项（“汽车”，（）=>{/*做点什么*/}），
};
}
公共车辆子类别（）
：基本（车辆类别）
{
}
}

您可以使用表示子类别的抽象类。它将在其Ctor中获取类别，并在类别和子类别项列表之间维护静态映射

子类别项可以包含任何单个子类别项所需的所有功能（如果有）

public class SubcategoryItem
{
    public string Name { get; set; }
    public Action WhatItDoes { get; set; }

    public SubcategoryItem(string name, Action trick)
    {
        Name = name;
        WhatItDoes = trick;
    }
}

public abstract class AbsSubcategory
{
    private static readonly IDictionary<Category, IList<SubcategoryItem>> mCategoriesMap = new Dictionary<Category, IList<SubcategoryItem>>();

    public abstract IList<SubcategoryItem> Subcategories { get; }

    protected AbsSubcategory(Category cat)
    {
        if (Subcategories != null) mCategoriesMap[cat] = Subcategories;
    }
}

public class VehiclesSubcategory : AbsSubcategory
{
    private static readonly IList<SubcategoryItem> mSubcategories;
    public override IList<SubcategoryItem> Subcategories
    {
        get { return mSubcategories; }
    }

    static VehiclesSubcategory()
    {
        mSubcategories = new List<SubcategoryItem>()
        {
            new SubcategoryItem("Bikes", () => { /* Do something */ } ),
            new SubcategoryItem("Cars", () => { /* Do something */ } ),
        };
    }

    public VehiclesSubcategory()
        : base(Category.Vehicles)
    {
    }
}

公共类子类别项
{
公共字符串名称{get；set；}
公共行动{get；set；}是什么
公共子类别项（字符串名称、操作技巧）
{
名称=名称；
做什么=欺骗；
}
}
公共抽象类子类别
{
私有静态只读IDictionary mCategoriesMap=new Dictionary（）；
公共抽象IList子类别{get；}
受保护的子类别（类别cat）
{
如果（子类别！=null）mCategoriesMap[cat]=子类别；
}
}
公共类车辆子类别：abs子类别
{
私有静态只读IList mSubcategories；
公共覆盖IList子类别
{
获取{return mSubcategories；}
}
静态车辆子类别（）
{
mSubcategories=新列表（）
{
新的子类别项（“自行车”，（）=>{/*做点什么*/}），
新的子类别项（“汽车”，（）=>{/*做点什么*/}），
};
}
公共车辆子类别（）
：基本（车辆类别）
{
}
}

您可以使用表示子类别的抽象类。它将在其Ctor中获取类别，并在类别和子类别项列表之间维护静态映射

子类别项可以包含任何单个子类别项所需的所有功能（如果有）

public class SubcategoryItem
{
    public string Name { get; set; }
    public Action WhatItDoes { get; set; }

    public SubcategoryItem(string name, Action trick)
    {
        Name = name;
        WhatItDoes = trick;
    }
}

public abstract class AbsSubcategory
{
    private static readonly IDictionary<Category, IList<SubcategoryItem>> mCategoriesMap = new Dictionary<Category, IList<SubcategoryItem>>();

    public abstract IList<SubcategoryItem> Subcategories { get; }

    protected AbsSubcategory(Category cat)
    {
        if (Subcategories != null) mCategoriesMap[cat] = Subcategories;
    }
}

public class VehiclesSubcategory : AbsSubcategory
{
    private static readonly IList<SubcategoryItem> mSubcategories;
    public override IList<SubcategoryItem> Subcategories
    {
        get { return mSubcategories; }
    }

    static VehiclesSubcategory()
    {
        mSubcategories = new List<SubcategoryItem>()
        {
            new SubcategoryItem("Bikes", () => { /* Do something */ } ),
            new SubcategoryItem("Cars", () => { /* Do something */ } ),
        };
    }

    public VehiclesSubcategory()
        : base(Category.Vehicles)
    {
    }
}

公共类子类别项
{
公共字符串名称{get；set；}
公共行动{get；set；}是什么
公共子类别项（字符串名称、操作技巧）
{
名称=名称；
做什么=欺骗；
}
}
公共抽象类子类别
{
私有静态只读IDictionary mCategoriesMap=new Dictionary（）；
公共抽象IList子类别{get；}
受保护的子类别（类别cat）
{
如果（子类别！=null）mCategoriesMap[cat]=子类别；
}
}
公共类车辆子类别：abs子类别
{
私有静态只读IList mSubcategories；
公共覆盖IList子类别
{
获取{return mSubcateg