C# 将子类转换为父类

我怎样才能解决这个问题？

---

谢谢

你不能那样做；列表包含A的实例，不能将A强制转换为B。只能在继承链中“向上”强制转换，不能向下。因此，如果您在代码中更改A和B的位置，它会起作用：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List list = new List();
            list.Add(new A());

            var list2 =
                from p in list
                select p as B;

            Console.WriteLine(list2.First().myString);
            Console.ReadLine();
        }
    }

    class A
    {
        public string myString = "abc";
    }

    class B : A
    {

    }
}

类程序
{
静态void Main（字符串[]参数）
{
列表=新列表（）；
添加（新的B（））；
变量列表2=
从列表中的p开始
选择p作为A；
Console.WriteLine（list2.First（）.myString）；
Console.ReadLine（）；
}
}
甲级
{
公共字符串myString=“abc”；
}
B类：A{}

如果要向另一个方向转换，则需要为转换编写代码：

class Program
{
    static void Main(string[] args)
    {
        List<B> list = new List<B>();
        list.Add(new B());

        var list2 =
            from p in list
            select p as A;

        Console.WriteLine(list2.First().myString);
        Console.ReadLine();
    }
}

class A
{
    public string myString = "abc";
}
class B : A { }

类程序
{
静态void Main（字符串[]参数）
{
列表=新列表（）；
添加（新的B（））；
var list2=list.ConvertAll（a=>B.FromA（a））；
Console.WriteLine（list2.First（）.myString）；
Console.ReadLine（）；
}
}
甲级
{
公共字符串myString=“abc”；
}
B类：A
{
公共B（）{}
公共静态B FromA（A fromInstance）
{
B结果=新的B（）；
result.myString=fromInstance.myString；
返回结果；
}
}

你不能那样做；列表包含A的实例，不能将A强制转换为B。只能在继承链中“向上”强制转换，不能向下。因此，如果您在代码中更改A和B的位置，它会起作用：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List list = new List();
            list.Add(new A());

            var list2 =
                from p in list
                select p as B;

            Console.WriteLine(list2.First().myString);
            Console.ReadLine();
        }
    }

    class A
    {
        public string myString = "abc";
    }

    class B : A
    {

    }
}

类程序
{
静态void Main（字符串[]参数）
{
列表=新列表（）；
添加（新的B（））；
变量列表2=
从列表中的p开始
选择p作为A；
Console.WriteLine（list2.First（）.myString）；
Console.ReadLine（）；
}
}
甲级
{
公共字符串myString=“abc”；
}
B类：A{}

如果要向另一个方向转换，则需要为转换编写代码：

class Program
{
    static void Main(string[] args)
    {
        List<B> list = new List<B>();
        list.Add(new B());

        var list2 =
            from p in list
            select p as A;

        Console.WriteLine(list2.First().myString);
        Console.ReadLine();
    }
}

class A
{
    public string myString = "abc";
}
class B : A { }

类程序
{
静态void Main（字符串[]参数）
{
列表=新列表（）；
添加（新的B（））；
var list2=list.ConvertAll（a=>B.FromA（a））；
Console.WriteLine（list2.First（）.myString）；
Console.ReadLine（）；
}
}
甲级
{
公共字符串myString=“abc”；
}
B类：A
{
公共B（）{}
公共静态B FromA（A fromInstance）
{
B结果=新的B（）；
result.myString=fromInstance.myString；
返回结果；
}
}

list2.First（）。myString

将尝试在

null

引用上访问

myString

。如果不能强制转换，

as

操作符将返回

null

。面向对象的设计原则告诉我们，在任何地方都可以使用子类，也可以使用其超类，但不能反过来使用。因此，您正在用

A

的实例填充列表，并尝试将它们转换为

B

。但是它们并不是

B

的实例，所以cast总是会失败（而且，因为您使用

as

，所以返回

null

）。

list2.First（）。myString

将尝试访问

null

引用上的

myString

。如果不能强制转换，

as

操作符将返回

null

。面向对象的设计原则告诉我们，在任何地方都可以使用子类，也可以使用其超类，但不能反过来使用。因此，您正在用

A

的实例填充列表，并尝试将它们转换为

B

。但是它们并不是

B

的实例，所以cast总是会失败（而且，因为您使用

as

，所以返回

null

）。

您的程序会“将父类转换为子类”，与您的问题标题相反。无论如何，那是不可能的

为了澄清这一点：

尝试将B类更改为以下内容：

class Program
{
    static void Main(string[] args)
    {
        List<A> list = new List<A>();
        list.Add(new B());

        var list2 = list.ConvertAll<B>(a => B.FromA(a));

        Console.WriteLine(list2.First().myString);
        Console.ReadLine();
    }
}

class A
{
    public string myString = "abc";
}

class B : A
{
    public B() { }

    public static B FromA(A fromInstance)
    {
        B result = new B();
        result.myString = fromInstance.myString;
        return result;
    }
}

如果您能够将A转换为B，那么myStringB值会是什么，因为它从未在A上定义过？

您的程序会“将父类转换为子类”，这与您的问题标题相反。无论如何，那是不可能的

为了澄清这一点：

尝试将B类更改为以下内容：

class Program
{
    static void Main(string[] args)
    {
        List<A> list = new List<A>();
        list.Add(new B());

        var list2 = list.ConvertAll<B>(a => B.FromA(a));

        Console.WriteLine(list2.First().myString);
        Console.ReadLine();
    }
}

class A
{
    public string myString = "abc";
}

class B : A
{
    public B() { }

    public static B FromA(A fromInstance)
    {
        B result = new B();
        result.myString = fromInstance.myString;
        return result;
    }
}

---

如果您能够将A强制转换为B，那么myStringB值会是什么，因为它从未在A上定义过？

在B类中创建一个构造函数，该构造函数接受一个类的实例。

在B类中创建一个构造函数，该构造函数接受一个类的实例。

您可以创建一个复制构造函数，该构造函数接受类型为

A

的对象：

class B : A
{
    public string MyStringB { get; set; }
}

---

但是，我对LINQ不太熟悉，所以我不确定如何让它自动使用它。

您可以创建一个复制构造函数，它接受类型为

a

的对象：

class B : A
{
    public string MyStringB { get; set; }
}

---

但是，我对LINQ不太熟悉，所以我不确定如何让它自动使用它。

对象引用未设置为对象的实例。您能运行它吗？@Alon:这就是错误所在——“as”构造在不成功的强制转换中返回null。他不能把A转换成B，所以他犯了那个错误。如果他使用直接强制转换（即，“（B）theA”），他将得到一个未设置为对象实例的InvalidCastException.Object引用。您能运行它吗？@Alon:这就是错误所在——“as”构造在不成功的强制转换中返回null。他不能把A转换成B，所以他犯了那个错误。如果他使用直接演员（即，“（B）theA”），他会得到一个无效的演员例外。我已经理解了，那么我该如何解决它呢？我的意思是，我应该为手动转换创建一个方法吗？@Alon:是的，如果你真的想要转换，你需要手动进行。我已经理解了，那么我该如何解决它呢？我的意思是，我应该为手动转换创建一个方法吗？@Alon:是的，如果你真的想进行转换，你就需要手动进行转换。明确地使用该构造函数，并明确地使用该构造函数。你必须显式地调用它。这是否意味着选择类型为a的对象，然后在以后循环使用它们，或者有没有办法将lambda传递给LINQ，让它转换它们？如果有