扩展类的初始化

本文关键字：初始化 扩展 | 更新日期: 2023-09-27 18:36:34

我正在从某个地方获取AAA类的对象，我想在该对象中添加更多信息。因此，我正在创建一个从 AAA 派生的新类 BBB。类 BBB 具有额外的字段字典。我正在派生类构造函数中填充此字典，该构造函数采用 AAA 类对象和项目数组，我想将其用作字典的键，并且该字典的值是 AAA 类对象字段的元素。我试图在吹气示例代码中创建类似的场景：

void Main(){    
     A obj = new A () ;
     obj.prop1 =  new int [] {5 ,10, 15}   ;
     obj.prop2 =  "Hello" ;
     obj.prop3 = "World" ;
//   obj.Dump () ;
     B obj2 = new B (new int [] {1,2,3}, obj)  ;     
//   obj2.Dump () ;
}
// Define other methods and classes here
public class A {
    public int [] prop1 ;
    public string prop2 ;
    public string prop3 ;
}
public class B : A {
    public Dictionary <int, int> prop4 ;
    public B (int [] keys, A a) {
    prop4 = new Dictionary <int, int> () ;
        if (keys.Length == a.prop1.Length ) {
            for (int i = 0 ; i < keys.Length ; i++ ) {
                prop4.Add (keys[i], a.prop1[i]) ;
            }
            // is there a way to obsolete below lines of code???
            this.prop1 = a.prop1 ; 
            this.prop2 = a.prop2 ;
            this.prop3 = a.prop3 ;
        }
        else {
            throw new Exception ("something wrong") ;
        }           
    }
}

在派生类构造函数中，我正在手动填充属性，我不想这样做。有没有其他方法可以做到这一点。我的实际班级中有 20 多个属性。

扩展类的初始化

无法按照您的要求进行操作，但我建议为类 A 创建一个复制构造函数并将其与您的类B构造函数一起使用：

// Define other methods and classes here
public class A
{
    public int[] prop1;
    public string prop2;
    public string prop3;
    public A()
    {
    }
    public A(A orig)
    {
        prop1 = orig.prop1;
        prop2 = orig.prop2;
        prop3 = orig.prop3;
    }
}
public class B : A
{
    public Dictionary<int, int> prop4;
    public B(int[] keys, A a) : base( a )
    {
        prop4 = new Dictionary<int, int>();
        if (keys.Length == prop1.Length)
        {
            for (int i = 0; i < keys.Length; i++)
            {
                prop4.Add(keys[i], prop1[i]);
            }
        }
        else
        {
            throw new Exception("something wrong");
        }
    }
}

您在这里实现的内容与copy constructor非常相似。恐怕只有用手做

！

我的建议是在 A 类定义中使用 Properties 并覆盖 B 类实现的属性：

// Define other methods and classes here
public class A
{
    public virtual int[] prop1 { get; set; }
    public virtual string prop2 { get; set; }
    public virtual string prop3 { get; set; }
}
public class B : A
{
    public Dictionary<int, int> prop4;
    public override int[] prop1
    {
        get
        {
            return m_WrappedAInstance.prop1;
        }
        set
        {
            m_WrappedAInstance.prop1 = value;
        }
    }
    public override string prop2
    {
        get
        {
            return m_WrappedAInstance.prop2;
        }
        set
        {
            m_WrappedAInstance.prop2 = value;
        }
    }
    public override string prop3
    {
        get
        {
            return m_WrappedAInstance.prop3;
        }
        set
        {
            m_WrappedAInstance.prop3 = value;
        }
    }
    A m_WrappedAInstance = null;
    public B(int[] keys, A a)
    {
        m_WrappedAInstance = a;
        prop4 = new Dictionary<int, int>();
        if (keys.Length == a.prop1.Length)
        {
            for (int i = 0; i < keys.Length; i++)
            {
                prop4.Add(keys[i], a.prop1[i]);
            }
        }
        else
        {
            throw new Exception("something wrong");
        }
    }
}

从功能上讲，这将起到类似的作用。唯一的缺点是包装的 A 类实例不能再独立于 B 类实例进行更改。这是要求吗？

B 的实例（您正在构造）和A的实例（您正在传递给 B 的构造函数）是不相关的 - 它们保存不同的数据，它们位于不同的内存地址上。从传递A的值更新实例的属性/字段B的唯一方法是复制。

嗯嗯...它有点不清楚和困惑你在做什么，但看看这个：

也许它与你需要什么无关，但至少它可能会给你一个想法。

这就是从类型的所有属性创建字典的方法。

public static Dictionary<string, object> DictionaryFromType(object atype)
{
    if (atype == null) return new Dictionary<string, object>();
    Type t = atype.GetType();
    PropertyInfo[] props = t.GetProperties();
    Dictionary<string, object> dict = new Dictionary<string, object>();
    foreach (PropertyInfo prp in props)
    {
        object value = prp.GetValue(atype, new object[]{});
        dict.Add(prp.Name, value);
    }
    return dict;
}

可能会帮助你。如果没有，请告诉我删除此问题。

定义一个数组。 然后将数组中的项强制转换为各个属性

在A类

public object[] properties;
public int[] prop1 {
  get { return (int[]) properties[0]; }
  set { properties[0] = value; } }
public string prop2 {
  get { return (string)properties[1];  }
  set { properties[1] = value ; } }

B 的构造函数

public B (int[] keys, A obj)
    {
        properties = A.properties;
    }
相关文章：