C# 无法隐式转换类型customB customC

谁能解释一下这个错误吗？我不熟悉编码。我想检查隐藏和重写方法的属性。非常感谢您的努力

您正试图将

B

分配给

C

，但并非所有情况下都正确。尝试重命名对象以使其更容易：

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            C c = new C();
            c = new B();

        }
    }

    class B
    {

    }
    class C : B
    {

    }

}

一只

狗

总是一只

动物

，但每只

动物

不一定是

狗

但以下几点是正确的：

class Animal
{
}

class Dog : Animal
{
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog ();
        dog = new Animal(); // Oops ! Not possible
    }
}

---

虽然在这种情况下，

Animal

可能应该是

abstract

（因此，您首先无法创建一个，您必须创建一个具体的类）。

您试图将

B

分配给

C

，但并非所有情况都是这样。尝试重命名对象以使其更容易：

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            C c = new C();
            c = new B();

        }
    }

    class B
    {

    }
    class C : B
    {

    }

}

一只

狗

总是一只

动物

，但每只

动物

不一定是

狗

但以下几点是正确的：

class Animal
{
}

class Dog : Animal
{
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog ();
        dog = new Animal(); // Oops ! Not possible
    }
}

---

虽然在这种情况下，

Animal

可能应该是

abstract

（因此，您首先无法创建一个，您必须创建一个具体的类）。

您试图将

B

分配给

C

，但并非所有情况都是这样。尝试重命名对象以使其更容易：

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            C c = new C();
            c = new B();

        }
    }

    class B
    {

    }
    class C : B
    {

    }

}

一只

狗

总是一只

动物

，但每只

动物

不一定是

狗

但以下几点是正确的：

class Animal
{
}

class Dog : Animal
{
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog ();
        dog = new Animal(); // Oops ! Not possible
    }
}

---

虽然在这种情况下，

Animal

可能应该是

abstract

（因此，您首先无法创建一个，您必须创建一个具体的类）。

您试图将

B

分配给

C

，但并非所有情况都是这样。尝试重命名对象以使其更容易：

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            C c = new C();
            c = new B();

        }
    }

    class B
    {

    }
    class C : B
    {

    }

}

一只

狗

总是一只

动物

，但每只

动物

不一定是

狗

但以下几点是正确的：

class Animal
{
}

class Dog : Animal
{
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog ();
        dog = new Animal(); // Oops ! Not possible
    }
}

---

虽然在这种情况下，

Animal

可能应该是

abstract

（因此您首先无法创建一个类-您必须创建一个具体的类）。

问题是C属于类型B，但B不是类型C

如果你这样写的话，它会起作用：

Animal animal = new Dog(); // Possible
animal = new Animal(); // Possible too

---

问题是C是B型的，但B不是C型的

如果你这样写的话，它会起作用：

Animal animal = new Dog(); // Possible
animal = new Animal(); // Possible too

---

问题是C是B型的，但B不是C型的

如果你这样写的话，它会起作用：

Animal animal = new Dog(); // Possible
animal = new Animal(); // Possible too

---

问题是C是B型的，但B不是C型的

如果你这样写的话，它会起作用：

Animal animal = new Dog(); // Possible
animal = new Animal(); // Possible too

---

如果你是新的编码，我不想把技术的东西扔给你。所以我会这样解释

您始终可以在两种情况下转换。 1.要从和转换到的对象已创建并调用预定义的转换器 2.您尝试从中转换的对象由您尝试转换为的较小对象组成

比如

在生活中，我们可以假设

 B b = new C();
 b = new B();

所以我们可以说

 Orange : Fruit

因为橘子是由低级水果制成的

然而，要把一个水果转换成橘子，你不能这样做，因为橘子比水果更复杂，谁又能说这个水果不是香蕉呢，这是两个完全不同的东西，尽管仍然是水果

---

正如评论中所说的“所有的橙子都是水果，但不是所有的水果都是橙子”

如果你对编码还不熟悉，我不想向你扔技术上的东西。所以我会这样解释

您始终可以在两种情况下转换。 1.要从和转换到的对象已创建并调用预定义的转换器 2.您尝试从中转换的对象由您尝试转换为的较小对象组成

比如

在生活中，我们可以假设

 B b = new C();
 b = new B();

所以我们可以说

 Orange : Fruit

因为橘子是由低级水果制成的

然而，要把一个水果转换成橘子，你不能这样做，因为橘子比水果更复杂，谁又能说这个水果不是香蕉呢，这是两个完全不同的东西，尽管仍然是水果

---

正如评论中所说的“所有的橙子都是水果，但不是所有的水果都是橙子”

如果你对编码还不熟悉，我不想向你扔技术上的东西。所以我会这样解释

您始终可以在两种情况下转换。 1.要从和转换到的对象已创建并调用预定义的转换器 2.您尝试从中转换的对象由您尝试转换为的较小对象组成

比如

在生活中，我们可以假设

 B b = new C();
 b = new B();

所以我们可以说

 Orange : Fruit

因为橘子是由低级水果制成的

然而，要把一个水果转换成橘子，你不能这样做，因为橘子比水果更复杂，谁又能说这个水果不是香蕉呢，这是两个完全不同的东西，尽管仍然是水果

---

正如评论中所说的“所有的橙子都是水果，但不是所有的水果都是橙子”

如果你对编码还不熟悉，我不想向你扔技术上的东西。所以我会这样解释

您始终可以在两种情况下转换。 1.要从和转换到的对象已创建并调用预定义的转换器 2.您尝试从中转换的对象由您尝试转换为的较小对象组成

比如

在生活中，我们可以假设

 B b = new C();
 b = new B();

所以我们可以说

 Orange : Fruit

因为橘子是由低级水果制成的

然而，要把一个水果转换成橘子，你不能这样做，因为橘子比水果更复杂，谁又能说这个水果不是香蕉呢，这是两个完全不同的东西，尽管仍然是水果

---

正如评论所说，“所有的橙子都是水果，但并非所有的水果都是橙子”

可能想将其改写为“所有的橙子都是水果，但并非所有的水果都是橙子”，可能想将其改写为“所有的橙子都是水果，