Question

我从某处获得了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个属性。

Answer 1

不能做你要求的但是我建议为课程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");
        }
    }
}

Answer 2

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

Answer 3

嗯...它有点不清楚，让你感到困惑，但看看这个：

也许它与您的需求无关，但至少它可能会给您一个想法。

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

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;
}

可能会帮助你。如果没有让我知道删除这个问题。

Answer 4

您在此处实施的内容与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类实例进行更改。这是一项要求吗？

Answer 5

定义一个数组。然后将数组中的项目转换为单个属性

在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;
    }

扩展类的初始化？

5 个答案: