Почему я не могу определить как неявные, так и явные операторы?

Почему я не могу определить как неявные, так и явные операторы так?

    public class C
    {
        public static implicit operator string(C c)
        {
            return "implicit";
        }

        public static explicit operator string(C c)
        {
            return "explicit";
        }
    }

Вы можете сделать этот взлом, хотя:)

    class Program
    {
        public class A
        {

        }

        public class B
        {
            public static implicit operator A(B b)
            {
                Console.WriteLine("implicit");
                return new A();
            }
        }

        public class C : B
        {
            public static explicit operator A(C c)
            {
                Console.WriteLine("explicit");
                return new A();
            }
        }

        static void Main(string[] args)
        {
            C c = new C();

            A a = c;
            A b = (A) c;
        }
    }

Отпечатки:

implicit
explicit

Ответ 1

Проверьте это: Почему не может сосуществовать неявный и явный оператор одного и того же типа в С#?

Если вы определяете явный оператор, вы сможете сделать что-то вроде этого:

Thing thing = (Thing)"value";

Если вы определяете неявный оператор, вы все равно можете сделать выше, но вы также можете воспользоваться неявным преобразованием:

Thing thing = "value";

Короче говоря, явное допускает только явное преобразование, в то время как неявное позволяет как явное, так и неявное... следовательно, причина, по которой вы можете определить только один.

Ответ 2

Я не знаю технических ограничений, которые мешают этому, но я думаю, что они сделали бы это, чтобы люди не стреляли своими собственными ногами.

string imp = new C(); // = "implicit"
string exp = (string)new C(); // = "explicit"

Это будет приводить меня в бешенство и не имеет смысла, C следует применять только к строке 1, а не по-разному.