fixed values for property c#

Question

I have an Movement class as a property for my objects.

What I want to do is only be able to set determined values for this property, ex:

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

Movement movement = new Movement():

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

I could make Direction.Up/Down/Left/Right constant strings, but i dont want to be able to set anything that's not Direction.Up/Down/Left/Right' to the property.

but i don't know how to make the Direction class.

Answer 1

One way is to use an Enum

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

Then if you need to make sure the stored int value is a valid value for your enum: Is there a way to check if int is legal enum in C#?

Answer 2

You can use an enum and use it like this:

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;
    }
}

However, now if you want to do some manipulations on Directions, or do some calculation, you cannot implement it in Direction since it is an enum.

You could also make an abstract class Direction, and make the actual directions derive from Direction, like this:

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();
}

Now you can use Direction like this:

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.
    }
}

This pattern is nice, because you can now just use the Direction interface to do all the stuff relevant to direction, and still have different implementations for when you would, say, relocate something for a given direction in the different direction classes.

You could also just make the classes public and outside of the abstract Direction class, but you would expose the types to the namespace then, which is probably not necessary.

Answer 3

i figured it out, here's what did the trick for me:

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");
        }
    }  

i put the class 'Direction' as public, but it constructor as private, so it can only be instantiated inside itself and its child's, and then made the static class 'Directions' inside it.

so i can easily:

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

anywhere in my code, but can't:

Direction move = new Direction();

because it's constructor is only accessible inside itself.