属性 c# 的固定值

Question

我有一个Movement 类作为我的对象的属性。

我想要做的只是能够为此属性设置确定的值，例如：

class Movement
{
    public Direction Moving;
    public Direction Facing;
}

Movement movement = new Movement():

movement.Moving = Direction.Up;
movement.Facing = Direction.Down;

我可以将Direction.Up/Down/Left/Right 设为常量字符串，但我不想为属性设置任何不是Direction.Up/Down/Left/Right' 的东西。

但我不知道如何制作 Direction 类。

Answer 1

一种方法是使用Enum

public enum Direction 
{
    Up,
    Down,
    Left,
    Right
}

那么，如果您需要确保存储的 int 值是您的枚举的有效值：Is there a way to check if int is legal enum in C#?

Answer 2

您可以使用枚举并像这样使用它：

public enum Direction {
    1 = Up,
    2 = Right,
    3 = Down,
    4 = Left
}

public class UseDirection {
    public Direction Dir { public get; private set; }

    public void SetDirection(Direction dir) {
         Dir = dir;
    }
}

但是，现在如果你想对 Directions 做一些操作，或者做一些计算，你不能在 Direction 中实现它，因为它是一个枚举。

你也可以创建一个抽象类Direction，并让实际的方向派生自Direction，像这样：

public abstract class Direction {


    private class DirectionUp : Direction { }
    private class DirectionDown : Direction { }
    private class DirectionLeft : Direction { }
    private class DirectionRight : Direction { }

    public static Direction Up => new DirectionUp();
    public static Direction Down => new DirectionDown();
    public static Direction Left => new DirectionLeft();
    public static Direction Right => new DirectionRight();
}

现在你可以像这样使用Direction：

public class AggregatesDirection {
     public Direction Dir { public get; private set; }

    public AggregatesDirection() {
         Dir = Direction.Up; //uses the static property in Direction that will use the private constructor of the private class in Direction.
    }
}

这种模式很好，因为您现在可以只使用Direction 接口来完成与方向相关的所有事情，并且仍然有不同的实现，例如，当您将某个给定方向的某些东西重新定位到不同的方向时类。

您也可以只将类公开并在抽象 Direction 类之外，但是您会将类型公开给命名空间，这可能没有必要。

Answer 3

我想通了，这就是我的诀窍：

public class Direction
    {
        private string value;

        private Direction(string value)
        {
            switch (value)
            {
                case "left":
                    {
                        this.value = value;
                        break;
                    }
                case "right":
                    {
                        this.value = value;
                        break;
                    }
                case "up":
                    {
                        this.value = value;
                        break;
                    }
                case "down":
                    {
                        this.value = value;
                        break;
                    }
                default:
                    throw new Exception("Valor invalido");
            }
        }

        public static class Directions
        {
            public static Direction Up = new Direction("up");
            public static Direction Down = new Direction("down");
            public static Direction Left = new Direction("left");
            public static Direction Right = new Direction("right");
        }
    }  

我将'Direction'类设为public，但它的构造函数设为私有，所以它只能在自身及其子类中实例化，然后在其中创建静态类'Directions'。

所以我可以轻松：

this.directionMoving = Direction.Directions.Down;
this.directionLooking = Direction.Directions.Down;

在我的代码中的任何地方，但不能：

Direction move = new Direction();

因为它的构造函数只能在其内部访问。