在c#枚举中使用不同的类型

public enum EnumWeapons
{
    Fists = new WeaponFists(),
    Sword = new WeaponSword(),
    Bow = new WeaponBow(),
    Staff = new WeaponStaff()
}

public Weapon weapon = (Weapon)EnumWeapons.Fists;

这是不可能的，enum的底层类型是各种整型。来自文档:

允许的enum类型为:byte、sbyte、short、ushort、int、uint、long、ulong。

而且，我甚至不认为你想做的是有意义的。当你想要一件武器时，你真的想每次都使用相同的实例吗?我很怀疑。

我认为你真正想要的是一个工厂。在最朴素的形式中，你可以说:

public enum WeaponType {
    Fists,
    Sword,
    Bow, 
    Staff
}
public class WeaponFactory {
    public Weapon Create(WeaponType weaponType) {
        switch(weaponType) {
            case WeaponType.Fists:
                return new WeaponFists();
            case WeaponType.Sword:
                return new WeaponSword();
            case WeaponType.Bow:
                return new WeaponBow();
            case WeaponType.Staff:
                return new WeaponStaff();
            default:
                throw new ArgumentOutOfRangeException("weaponType");
        }
    }
}

现在你可以说:

var weapon = weaponFactory.Create(WeaponType.Fists);

不，枚举必须是整型(byte、short、int、long)。

你想做的事情可以这样做:

public static class EnumWeapons
{
    public static readonly Weapon Fists = new WeaponFists();
    public static readonly Weapon Sword = new WeaponSword();
    public static readonly Weapon Bow = new WeaponBow();
    public static readonly Weapon Staff = new WeaponStaff();
}

这不能直接用于枚举。然而，你可以使用"常规"枚举和Dictionary<EnumWeapons, Weapon>来代替通过枚举值检索你的武器实例。

不能这样使用enum。但是，您可以通过创建一个静态类来实现类似的目的:

public static class AllWeapons
{
    public static readonly Weapon Fists = new WeaponFists();
    // etc
}
Weapon weapon = AllWeapons.Fists;

根据这个源积分常数(它在两个级别上使代码无效)

你可以使用语法糖，使它看起来像一个枚举:

public static class Weapons
{
    Weapon Fists = new WeaponFists(),
    Weapon Sword = new WeaponSword(),
    Weapon Bow = new WeaponBow(),
    Weapon Staff = new WeaponStaff()
}

您键入的代码包含对象，这不再是枚举，这是枚举构造的目的。我不想只是重复别人说过的话，所以这里有一个建议:您可以保留枚举，但创建一个辅助方法来生成武器对象，如下所示:

public enum EnumWeapons
{
    Fists,
    Sword,
    Bow,
    Staff
}
public Weapon EnumWeaponsToWeaponObject(EnumWeapons weapon)
{
        switch (weapon)
        {
            case EnumWeapons.Fists:
                return new FistWeapon();
                break;
            case EnumWeapons.Sword:
                return new SwordWeapon();
                break;
            case EnumWeapons.Bow:
                return new BowWeapon();
                break;
            case EnumWeapons.Staff:
                return new StaffWeapon();
                break;
            default:
                throw new ArgumentException("Not a supported weapon type!");
                break;
        }
}

你可以把这个方法作为一个扩展，这样你就可以像下面这样使用它:EnumWeapons.Sword.EnumWeaponsToWeaponObject ();

我不认为c#枚举是这样工作的。在c#中，所有枚举值基本上都是整型。但是你可以使用你的方法:

public class Weapon 
{
    public static readonly Weapon Fists = new WeaponFists();
    public static readonly Weapon Sword = new WeaponSword();
   ...
}

然后

var myWeapon = Weapon.Fists;

根据MSDN， "批准的enum类型为byte、sbyte、short、ushort、int、uint、long或ulong ."

可以使用索引器按顺序位置和字符串引用Array或List。不像枚举那样干净，但Array或List可以包含对象。这就是它成为索引器的原因。

    namespace Indexer
    {
        class Program
        {
            static void Main(string[] args)
            {
                Persons MyPeople = new Persons();
                Console.WriteLine("MyPeople[0] " + MyPeople[0].Name);
                Console.WriteLine("MyPeople[0] " + MyPeople[1].Name);
                Console.WriteLine("MyPeople[Jim] " + MyPeople["Jim"].Name);
                Console.ReadLine();
            }
        }
        public class Persons
        {
            private List<Person> persons = new List<Person>();
            public int Count { get { return persons.Count; } }
            public Person this[int index]
            {
                get
                {
                    return persons[index];
                }
                set
                {
                    persons[index] = value;
                }
            }
            public Person this[string name]
            {
                get
                {
                    foreach (Person p in persons)
                    {
                        if (p.Name == name) return p;
                    }
                    return null;
                }
            }
            public Persons()
            { 
                persons.Add(new Person("Jim"));
                persons.Add(new Person("Harry"));
            }
            public class Person
            {
                private string name;
                public string Name { get { return name; } }
                public Person(string Name) { name = Name; }
            }
        }
    }