C# 4.0 使用基类引用对象初始化派生类成员变量

初始化命令的正确方法是什么？拥有基类引用并使用对象派生类作为_ref的优点是什么？只是使用基类引用可以保存多个派生类对象这一事实？如果是这种情况，派生类的所有成员变量是否应该在构造过程中初始化（如：_ref=new-derived（a，b，c，d））。如果我想稍后在方法中初始化_ref.der_e怎么办？我知道我可以这样做（var cast\u ref=\u ref as Derived；cast\u ref.der\u e=444），但这种外观似乎不是最佳实践。拥有这样一个结构的想法是什么？在派生类对象的成员被构造之后初始化它的正确性是什么？

这些问题太多了

初始化命令的正确方法是什么

对于初始化

der_e

，必须有

派生的
类的引用，因为它知道der_e属性，而不是
Base
类

有基类引用和使用
_ref的对象派生类

是的，这就是所谓的面向对象编程的本质。它允许我们在不知道实际实现的情况下持有各种具体实现

如果是这样，派生类的所有成员变量
在构造过程中进行初始化（如下所示：_ref=new
派生（a，b，c，d））

没有这样的规则。这取决于你的情况。如果在创建对象后不打算更改这些值，并且在构建对象期间这些值是已知的，则应在构建期间对其进行初始化

同样，如果存在各种场景，比如有时值已知，有时值未知，那么可能会有重载构造函数，它们采用不同的参数

如果我想稍后在方法中初始化_ref.der_e怎么办

这很好，这取决于你想要实现什么。这个问题不是一个具体的问题，而是一个抽象的问题，在这个问题上，很难对你试图实现的目标做出评论

我知道我可以做到这一点（var cast\u ref=\u ref as Derived；cast\u ref.der\u e=
但这种外观似乎不是最佳做法

我正在分享一些类似于C的Java代码，因为我来自Java背景

I came across a lot of code in our company codebase with the following structure



   class Base
    {
     public Base (var a, var b)
     {
      base_a = a;
      base_b = b;
     }

     var base_a;
     var base_b;
    }

    class Derived:Base
    {
     publc Derived (var a,b,c,d): base (a,d)
     {
       der_c = c;
       der_d = d;  
     }
     var der_c;
     var der_d;
     var der_e;
    }


    class  Ref
    {
     Base _ref;
     public Ref( var a,b,c,d)
     {
      _ref = new Derived (a,b,c,d)
     }

     public void method( )
     {
       _ref.der_e = 444; // won't compile
     }
    }

我分享一些参考资料，这将有助于你这一点，因为我认为答案可能是很长的解释






您可以在派生类中创建构造函数并映射对象，或者创建如下扩展方法：

//This class knows about Base and nothing about the Derived class
class UserOfBase{

   Base ref; 

   //Constructor of UserOfBase gets passed an instance of Base
   public UserOfBase(Base bInstance){
      this.ref = bInstance;
   }

   //Now this class should not cast it into Derived class as that would not be a polymorphic behavior. In that case you have got your design wrong.

   public void someMethod(){
        Derived derivedRef = (Derived)ref; //This should not happen here
   }

}

  public static class Extensions 
  {            
        public static void FillPropertiesFromBaseClass<T1, T2>(this T2 drivedClass, T1 baseClass) where T2 : T1
        {
            //Get the list of properties available in base class
            System.Reflection.PropertyInfo[] properties = typeof(T1).GetProperties();

            properties.ToList().ForEach(property =>
            {
                //Check whether that property is present in derived class
                System.Reflection.PropertyInfo isPresent = drivedClass.GetType().GetProperty(property.Name);
                if (isPresent != null && property.CanWrite)
                {
                    //If present get the value and map it
                    object value = baseClass.GetType().GetProperty(property.Name).GetValue(baseClass, null);
                    drivedClass.GetType().GetProperty(property.Name).SetValue(drivedClass, value, null);
                }
            });
        }
  }

您可以通过以下代码初始化派生类：

public class Fruit {
    public float Sugar { get; set; }
    public int Size { get; set; }
}
public class Apple : Fruit {
    public int NumberOfWorms { get; set; }
}

您给出的代码根本不会编译-您不能对参数或字段使用
var
（除非您实际拥有一个名为
var
的类）。请给出一个现实的例子-理想情况下更短，遵循.NET命名约定，格式更好。这是否回答了您的问题？public void someMethod（）{Derived derivedRef=（Derived）ref；//这不应该在这里发生}你会说这与构造函数public UserOfBase（int a）中的情况相同吗{This.ref=new deriver（a）；}@cyrux是的，这与
UserOfBase
不应该实例化具体的派生类实例相同。它只需要知道基地的情况，而不是其他任何事情。请参阅依赖项注入-即将依赖项注入到
UserOfBase
。
//constructor 
public Apple(Fruit fruit)
{            
   this.FillPropertiesFromBaseClass(fruit);
}