Question

I’ve been working on some electrical network simulation software (ElecNetKit). In electrical networks, sometimes it’s convenient to work with single-phase models, sometimes in three-phase models.

As such, I would like to be able to represent one of the electrical network elements as:

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

but simultaneously in a fashion so that the user can call Bus.Voltage.Phases[x], and expect a Complex for any valid integer x.

The Bus.Voltage property should map to Bus.Voltage.Phases[1] when treated as a Complex.

I’ve got two questions here:

1. Is this in violation of any OOP principles? I’ve got a feeling that it might be.
2. Is there a convenient way to represent this in C#?

In terms of representation, I’ve tried:

• a class Phased<T> : T, but this is incompatible with the typing system, and
• a class Phased<T> with a generic converter to type T, but the converter still needs to be invoked.

I’m aware that I can simply use something like:

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

but there’s a lot of repetition once you start to do this for multiple properties, across multiple classes.

Answer 1

I would propose something like this:

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