Question

我一直在研究一些电网模拟软件（ElecNetKit）。在电气网络中，有时使用单相模型很方便，有时使用三相模型。

因此，我希望能够代表其中一个电气网络元素：

class Bus
{
    public Complex Voltage {set; get;} //single phase property
}

但同时也是一种方式，以便用户可以拨打Bus.Voltage.Phases[x]，并期望Complex获得任何有效的整数x。

Bus.Voltage属性在被视为Bus.Voltage.Phases[1]时应映射到Complex。

我在这里有两个问题：

这违反了任何OOP原则吗？我有一种感觉可能会这样。
有没有方便的方法在C＃中表示？

就代表而言，我尝试过：

类Phased<T> : T，但这与输入系统不兼容，
类Phased<T>，其中包含用于键入T的通用转换器，但仍需要调用转换器。

我知道我可以简单地使用类似的东西：

public Dictionary<int,Complex> VoltagePhases {private set; get;}
public Complex Voltage {
    set {VoltagePhases[1] = value;} 
    get {return VoltagePhases[1];}
}

但是，一旦你开始在多个类中为多个属性执行此操作，就会有很多重复。

Answer 1

你能做这样的事吗？这将类似于您在底部的解决方案，但由于泛型类，您不会重复每个属性的代码。

class Program
{
    static void Main(string[] args)
    {
        Collection<Complex> complex = new Collection<Complex>();
        //TODO: Populate the collection with data

        Complex first = complex.First;
        Complex another = complex.Items[2];
    }
}

public class Complex
{
    // implementation
}


public class Collection<T> where T : class
{
    public List<T> Items { get; set; }

    public T First
    {
        get
        {
            return (Items.Count > 0) ? Items[1] : null;
        }
        set
        {
            if(Items.Count > 0) 
                Items[1] = value;
        }
    }
}

Answer 2

我会提出这样的建议：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Numerics;

namespace Test
{
    class PhaseList
    {
        private Dictionary<int, Complex> mPhases = new Dictionary<int, Complex>();

        public Complex this[int pIndex]
        {
            get
            {
                Complex lRet;
                mPhases.TryGetValue(pIndex, out lRet);
                return lRet;
            }
            set
            {
                mPhases.Remove(pIndex);
                mPhases.Add(pIndex, value);
            }
        }
    }

    class PhasedType
    {
        private PhaseList mPhases = new PhaseList();
        public PhaseList Phases { get { return mPhases; } }
        public static implicit operator Complex(PhasedType pSelf)
        {
            return pSelf.Phases[1];
        }

        public static implicit operator PhasedType(Complex pValue)
        {
            PhasedType lRet = new PhasedType();
            lRet.Phases[1] = pValue;
            return lRet;
        }
    }

    class Bus
    {
        public PhasedType Voltage { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Bus lBus = new Bus();

            lBus.Voltage = new Complex(1.0, 1.0);
            Complex c = lBus.Voltage;
            lBus.Voltage.Phases[1] = c;
            c = lBus.Voltage.Phases[1];
        }
    }
}

在一个类成员中表示多个值

2 个答案: