Enumerated values compared to the left and right sides identified as inconsistent

Question

I am creating a windows application written in C#. I created a class Palette which defines an enumerated type of property: direction {up, down, right, left}. Inside another class of type Form1 I created an instance p of Palette.

Here is a simplified version:

namespace WindowsFormsApplication1
{
    public class Palette
    {
        public Direction _direction
        {
            set { this._direction = value; }
            get { return this._direction; }
        }
    }

    public partial class Form1 : Form
    {
        private Palette p;
        public enum Direction
        {
            Left, Right, Up, Down
        }
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            p = new Palette { _direction = Direction.Up };
        }
    }       

Then i think, p.direction should also be an enumerated type, is not it?

My software does not think that because I use it to compare p.direction! = Direction.up.

It thinks the type on the left is Palette._direction. The right type is enum.

How can i do it?

Answer 1

The reason your code does not compile as expected is that you have declared the enum Direction to be a nested type, nested inside the outer type Form1, while the referring type Palette is not so nested. A nested type is a type defined within a class or struct. When referred to by code within that outer type, its name can be used directly. I.e. inside Form1 you can refer to your enum by simply doing Direction.Up. But outside the containing type it is necessary to use the full name of the nested type, which is Form1.Direction.

Thus, to fix your problem, you could:

1. Move Direction outside of Form1, making it a top-level type in the WindowsFormsApplication1 namespace.

   This is recommended if you are going to use Palette in multiple different forms.

2. Make both Palette and Direction be nested types inside Form1.

   This is recommended if Palette is only used inside Form1 or needs access to access private or protected members of Form1.

3. In Palette use the full name for Direction:

   public Form1.Direction _direction { get; set; }
   

   While this will compile it is not recommended as it is awkward and inconsistent.

Incidentally, you have an unrelated problem in your code, namely that your _direction property has an infinite recursion. You should modify it to be an auto-implemented property or make the manually created backing field have a different name than the property.

Thus a fixed version of your code might look like:

public class Palette
{
    Direction _direction;

    public Direction Direction
    {
        set { this._direction = value; }
        get { return this._direction; }
    }
}

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

public partial class Form1 : Form
{
    private Palette p;

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        p = new Palette { Direction = Direction.Up };
    }
}

Since your full code apparently compiles, you may have some other type WindowsFormsApplication1.Direction whose name would conflict with that of your nested Direction type if you were to move it out of Form1. If so, and you want to keep Palette outside of Form, your options are:

1. In the event they are actually duplicates, simply eliminate the inner nested type.

2. If they are not duplicates, rename the Direction enum to something else, say DirectionType.