强制一个类实现没有值约束的枚举

Question

I've different classes (eg: Player, Enemy, Asteroids...) - that are supposed to have one of different statuses (eg: ok, teleporting...).

enum Status
{
    Ok,
    Teleporting,
    ...
};

Using an interface , I'd like to force those classes to declare only the existance of a enum status variable inside them. However, I want no constraints on values . That is, a Player and an Enemy can have different values inside status (eg: one can teleport, the other one can't).

How can I do that?

Update1

public enum Status
{
    Ok,
    Teleporting
};

public interface IHaveStatus
{
    Status Status { get; set; }
}

Update 2

public enum Status
{
    Ok,
    Teleporting
};

public interface IHaveStatus
{
    Status status;
}

Answer 1

You could declare the interface as follows:

public interface IHaveStatus {
    Status Status { get; set; }
}

and let the specific classes implement that interface:

class Player: IHaveStatus {
    public Status Status { get; set; }
}

This will not limit the usage of the status field, it can have any value that is legal for the Status enum.

If (however) you would like to apply some logic (enemy can't teleport), than this may not be the right design.

If you want to specify that players have certain capabillities (ie: teleporting) you could use an attribute or an interface to identify those classes.

Using interfaces:

public interface ICanTeleport { }

public class Player : ICanTeleport { ... }

you can determine capabillities using a cast:

if(somePlayer is ICanTeleport) { .. }

or when using attributes :

[System.AttributeUsage(System.AttributeTargets.Class)]  
public class Teleporter : System.Attribute  
{ }

[Teleporter()]
public class Player { ... }

Then you will have to use reflection to determine the attributes, see this question .

• Using interfaces makes the behavior bound to the class inheritance. It also gives you the abillity to add methods to the interface (ie a Teleport(coordinates) method).

• Using attributes gives more possibillites to mix and match capabillities on the fly, as there is no class hierarchy forcing the capabillities.

Answer 2

Unless I'm missing something obvious, a simple interface like this will do it:

 public interface IHaveStatus
 {
      Status Status {get;}
 }

Values constraints I would put in the concrete classes. For instance, if a player can't teleport, a good place to constraint that would be in the property setter:

public class Player : IHaveStatus
{
    private Status _status;

    public Status Status 
    {
        get {return _status;}
        set
        {
            // a player can't teleport...
            if(value != Status.Teleport)
            {
                _status = value;
            }
        }
    }
}

Answer 3

You can't, at least not with the same enum type. You would have to declare different enums for every set of allowed values. Pro: you get compile time checking (as long as you explicitly assign values as is usually the case with Enums values). Con: You have to declare a new Enum for every allowable range.

Alternatively you check the incoming value at run time at the type level in the setter (method or property) and enforce any constraint there. Pro: you only need one enum for the complete range. Con: The downside of this solution is you could have bugs that you will not catch until runtime.

Solution enum per accepted range

enum EnemyStatus
{
    Ok
}

enum UserStatus
{
    Ok,
    Teleporting
}

Solution constraint at the type level

class Enemy : IStatusable {

  public Status CurrentStatus {
    get {return _status;}
    set {if(value == Status.Teleporting) throw new NotSupportedException();
         this._status = value;
    }}
}

interface IStatusable {
   Status CurrentStatus {get;set;}
}

Answer 4

it is possible to combine multiple values in a single enum field if enum is marked with [Flags] attribute:

[Flags]
enum Status
{
    Ok = 0,
    Teleporting = 1,
    Flying = 2,
    Dancing = 4
}

then declare interface with one enum property:

interface Base
{
    Status Abilities { get; }
}

class Player : Base
{
    public Status Abilities { get; set; }
}

and test objects for different values like this:

var p = new Player();
p.Abilities = Status.Ok | Status.Teleporting;

bool canTeleport = p.Abilities.HasFlag(Status.Teleporting);
bool canFly = p.Abilities.HasFlag(Status.Flying);