C# 是否可以提取具有主类属性的对象？

我有a类，继承了B类。 假设类A具有以下属性：

• 物业A 1
• 财产2
• 财产A 3

比如：

public class ObjectA
{
    public int propertyA1 { get; set; }
    public int propertyA2 { get; set; }
    public int propertyA3 { get; set; }
}

public class ObjectB : ObjectA
{
    public int propertyB1 { get; set; }
    public int propertyB2 { get; set; }
}

ObjectA a = b.GetPropertiesFromMasterClass();

因此，我们的B类将具有以下属性：

• propertyA1-继承一个
• propertyA2-继承一个
• propertyA3-继承一个
• 物业B1-自有物业B
• 物业B2-自有物业B

比如：

public class ObjectA
{
    public int propertyA1 { get; set; }
    public int propertyA2 { get; set; }
    public int propertyA3 { get; set; }
}

public class ObjectB : ObjectA
{
    public int propertyB1 { get; set; }
    public int propertyB2 { get; set; }
}

ObjectA a = b.GetPropertiesFromMasterClass();

我们创建了一个B类的新对象，并设想我们有一个包含20个相同类型对象的列表。 假设类A的属性是200，类B 100也都对应于数据库中的一个表

因此，为了保留B类对象列表中的数据（使用EntityFramework），我们希望将A类的信息保存在表A中。 通常我们会做以下工作：

foreach(var item in ObjectsB)
{
    ObjectA a = new ();
    a.propertyA1 = item.propertyA1;
    ...
    // And so on to put all the corresponding properties.
    db.TableA.add(a);
    db.SaveChanges();
}

这就是我的问题所在： 是否可以从B类对象创建A类对象？也就是说，省略类B的所有属性。 比如：

public class ObjectA
{
    public int propertyA1 { get; set; }
    public int propertyA2 { get; set; }
    public int propertyA3 { get; set; }
}

public class ObjectB : ObjectA
{
    public int propertyB1 { get; set; }
    public int propertyB2 { get; set; }
}

ObjectA a = b.GetPropertiesFromMasterClass();

如果是这样的话，我们将避免分配200个字母 如果可能，前进的道路是什么？

也许是这样：

var b = new ObjectB();
var a = b as ObjectA;

更紧凑的版本：

ObjectA a = new ObjectB();

尝试自动映射：

Mapper.CreateMap（）

更多细节可以找到
 您是否考虑过在数据库中创建可更新视图？然后，您可以使用实体框架语法更新视图，然后就可以完成了
 使用继承，您可以针对A创建B的实例。以下示例显示了对象列表：

 class A
    {
        public string Property1 { get; set; }
        public string Property2 { get; set; }

        public string Property100 { get; set; }

        public string Property200 { get; set; }
    }

    class B : A
    {
        public string PropertyB_1 { get; set; }
        public string PropertyB_2 { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<A> list = new List<A>();
            for (int i = 0; i < 10; i++)
            {
                A a = new B()
                {
                    Property1 = "P1_" + i,
                    Property2 = "P2_" + i,
                    Property100 = "P100_" + i,
                    Property200 = "P200_" + i,
                    PropertyB_1 = "PB_1_" + i,
                    PropertyB_2 = "PB_2_" + i
                };
                list.Add(a);
            }
            //list only contains A data
            foreach (A a in list)
            {
                //save a to database
            }
        }
    }

A类
{
公共字符串属性1{get；set；}
公共字符串属性2{get；set；}
公共字符串属性100{get；set；}
公共字符串Property200{get；set；}
}
B类：A
{
公共字符串属性b_1{get；set；}
公共字符串属性b_2{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
列表=新列表（）；
对于（int i=0；i<10；i++）
{
A=新的B（）
{
Property1=“P1_”+i，
Property2=“P2_”+i，
不动产100=“P100”+i，
Property200=“P200_216;”+i，
属性b_1=“PB_1_”+i，
属性b_2=“PB_2_”+i
};
列表.添加（a）；
}
//列表仅包含一个数据
foreach（列表中的一个）
{
//将文件保存到数据库
}
}
}
使用反射在
foreach
循环中分配200个属性：

public class ObjectB : ObjectA
{
    public int propertyB1 { get; set; }
    public int propertyB2 { get; set; }
    // ...

    public ObjectA CreateA()
    {
        Type type = typeof(ObjectA);
        ObjectA result = new ObjectA();

        foreach (PropertyInfo propertyInfo in type.GetProperties())
        {
            if (propertyInfo.CanRead)
            {
                object value = propertyInfo.GetValue(this, null);
                propertyInfo.SetValue(result, value);
            }
        }
        return result;
    }
}

非常简单，非常实用！谢谢，很好用！这是选角，会让节目慢下来。我已经在下面发布了完整的示例。我严重怀疑像这样的微优化是否重要。尤其是在处理数据库时（它已经比这段代码慢了很多），在那里你有很多潜在的和真正的瓶颈需要担心。@Avneesh你的说法是荒谬的。首先，cast是一个简单的引用转换，所以它不能再便宜了；其次，您在这里处理的是DB延迟，再多几个纳秒又有什么关系？@Avneesh：没有cast，它是一个简单且明显有效的引用转换，相当于直接赋值
ObjectA a=b
。
as
在这里进行了优化，因为
b
始终可分配给
对象a
。编译器知道这将永远成功。在OO语言中，最糟糕的决定之一就是将完全不同的特性放在演员包中；类型转换、引用转换、装箱等。每种转换的成本和影响都截然不同。因此，您的解决方案包括不必要的反射（速度很慢）以及200次创建对象，我不明白你怎么能在我的答案中看到问题老实说，我想知道a-ve分配的答案有什么问题？？仅仅用-ve来证明关于内存的错误假设是没有意义的。在一个需要高效内存编码的好项目上工作。