非静态类中的C＃静态属性作为此类主要对象的指示符

Question

I have class Important and some objects of this class created. I want allow user to choose main object of this class. Have a look at code below:

public class Program
{
    public static void Main(string[] args)
    {
       Important imp1 = new Important("Important 1");
       Important imp2 = new Important("Important 2");
       Important imp3 = new Important("Important 3");

       imp2.SetMostImportant();

       Console.Write(Important.MostImportant.Name);
    }

    public class Important
    {
        public Important(string name)
        {
            Name = name;
            if(MostImportant == null)
                SetMostImportant();
        }

        public string Name { get; private set; }
        public static Important MostImportant { get; private set; }

        public void SetMostImportant()
        {
            MostImportant = this;
        }
    }
 }

Is it good solution? If not, please tell me why not.

Before, to achieve this kind of things I just created boolean field named eg IsMainObject and, when I wanted to change main object, I iterated through all objects (or group of object) of specific class except element that I want to be main, and changed boolean to false, in my new candidate I simply set flag to true. Example below:

public class Program
{
    public static void Main(string[] args)
    {
       Important imp1 = new Important("Important 1");
       Important imp2 = new Important("Important 2");
       Important imp3 = new Important("Important 3");
       List<Important> list = new List<Important> { imp1, imp2, imp3 };

       foreach(var item in list.Where(x => x.Name != "Important 2"))
       {
           item.SetMostImportant(false);
       }

       imp2.SetMostImportant(true);
       Console.Write(list.FirstOrDefault(x => x.MostImportant == true).Name);
    }

    public class Important
    {
        public Important(string name)
        {
            Name = name;
        }

        public string Name { get; private set; }
        public bool MostImportant { get; private set; }

        public void SetMostImportant(bool val)
        {
            MostImportant = val;
        }
    }
}

I don't like this solution because:

1. I don't know if MostImportant is true for more than one objects without iterating.
2. I need to write extra-code to handle much more cases.
3. I don't have possibility to always iterate through all instances of specific class (groups not always are enough).

... and much more, but you got the idea.

Answer 1

public static Important MostImportant { get; private set; }

is a fine solution, and much better than

public bool MostImportant { get; private set; }

It's not uncommon to have a static property of the type that it's inside of when implementing "singleton" classes. I've written code that resembles this:

class MyClass
{
    public static MyClass Instance { get; private set; }
    public MyClass()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            throw new Exception("MyClass already instantiated.");
        }
    }
}