I have an enum that looks like the following:
public enum EnumWeapons
{
Fists = new WeaponFists(),
Sword = new WeaponSword(),
Bow = new WeaponBow(),
Staff = new WeaponStaff()
}
Which are derived from the base class Weapon.
Is it possible to use an enum in this way?
If so, will I be able to do something like the following? :
public Weapon weapon = (Weapon)EnumWeapons.Fists;
My attempts haven't worked as intended, and any help or guidance is appreciated :). Thank you!
This is not possible, the underlying type of an enum are various integral types. From the documentation:
The approved types for an enum are
byte,sbyte,short,ushort,int,uint,long, orulong.
Also, I don't even think what you are trying to do makes sense. When you want a weapon, do you really want the same instance every time? I doubt it.
What you really want, I think, is a factory. In it's most naive form, you can say:
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");
}
}
}
Now you can say:
var weapon = weaponFactory.Create(WeaponType.Fists);
No, enums must be an integral type (byte, short, int, long).
What you are trying to do may be achieved like this:
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();
}
Fists every time he asks for EnumWeapons.Fists. I doubt that is what he really wants.
This won't work with enums directly. You could however use a "regular" enum and a Dictionary<EnumWeapons, Weapon> instead to retrieve your Weapon instances by enum value.
You cannot use an enum that way. You can, however, achieve something similar by creating a static class:
public static class AllWeapons
{
public static readonly Weapon Fists = new WeaponFists();
// etc
}
Weapon weapon = AllWeapons.Fists;
According to this source integral constants (which invalidates that code on two levels)
You could use syntactic sugar and make it look like an enum using this:
public static class Weapons
{
Weapon Fists = new WeaponFists(),
Weapon Sword = new WeaponSword(),
Weapon Bow = new WeaponBow(),
Weapon Staff = new WeaponStaff()
}
The code you typed contains objects and that's no longer an enumeration, which is the purpose of the enum construct. I don't want to only repeat what others said so here's a suggestion: You could keep the enum but create a helper method to generate Weapon objects like this:
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;
}
}
You can make this method an extension so that you can use it as follows: EnumWeapons.Sword.EnumWeaponsToWeaponObject();
I don't think C# enums works this way. in C# all enum values are basically ints. However you may use your approach:
public class Weapon
{
public static readonly Weapon Fists = new WeaponFists();
public static readonly Weapon Sword = new WeaponSword();
...
}
and then
var myWeapon = Weapon.Fists;
As per MSDN, "The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong."
Please see This Reference.
You can use an indexer to refer to an Array or List both by ordinal position and string. Not as clean as enumeration but the Array or List can contain objects. The this is what makes it an indexer.
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; }
}
}
}
