处理扩展非泛型基础的泛型类型

Question

For PLC (Programmable Logic Controller) communication I have an abstract class PlcValueAbstract and extending generic class PlcValue<T> . I have these classes so I can specify what to read (T) but to leave the read implementation up to the class doing PLC communication / interop. I need the ability to read multiple of these at the same time, that's where the PlcValueAbstract comes in.

Right now I have a method ReadMultiple(IDictionary<string, PlcValueAbstract> values) which will read values from registers (PLC) into the paired PlcValueAbstract . To achieve this, I check if the PlcValueAbstract is either PlcValue<int> or PlcValue<short> (will be extended to more types) and handle byte[] to PlcValue<> conversion ( IPAddress.NetworkToHostOrder(BitConverver.ToInt32(bytesFromLibrary)) ). However, now my code becomes cluttered with type checks (and exceptions) for every (different) method invocation which uses type T on PlcValue<T> .

Unfortunately I can't rely on conversion from byte[] to T either, because we use different brands of PLC's with different register sizes (or API types) and different endianness, so I can't constrain any of my PlcValue<T> code to support byte[] only.

I have a gut feeling that I'm overcomplicating the issue and thus having to do split type implementations for every supported generic type, which is really cumbersome. Is there a solution where I can move all the type mumbo-jumbo to just a few methods?

On request here's part of the implementation:

PlcValueAbstract:

public abstract class PlcValueAbstract
{
    internal PlcValueAbstract()
    {
    }

    public abstract Type GetUnderlyingType();
}

PlcValue:

public class PlcValue<T> : PlcValueAbstract
{
    public PlcValue(T value)
    {
        this.Value = value;
    }

    public T Value
    {
        get;
        set;
    }

    public override Type GetUnderlyingType()
    {
        return typeof(T);
    }
}

SiemensPlc:

public class SiemensPlc
{
    public void WriteMultiple(IDictionary<string, PlcValueAbstract> data)
    {
        IDictionary<string, byte[]> plcData = data.Select(e => BuildWrite(e.Key, e.Value))
            .ToDictionary(x => x.Key, x => x.Value);
        return library.Write(plcData);
    }

    public void Read(IDictionary<string, PlcValueAbstract> data)
    {
        byte[][] response = library.Read(data.Keys);
        PlcValueAbstract[] values = data.Values.ToArray();

        for (int i = 0; i < response.Length; i++)
        {
            byte[] res = response[i];
            PlcValueAbstract pv = values[i];

            if (pv is PlcValue<int>)
            {
                PlcValue<int> v = (PlcValue<int>)pv;
                v.Value = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(res, 0));
            }
            else if (pv is PlcValue<short>)
            {
                PlcValue<short> v = (PlcValue<short>)pv;
                v.Value = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(res, 0));
            }
            else
            {
                throw new Exception("Invalid type");
            }
        }
    }

    private KeyValuePair<string, byte[]> BuildWrite(string address, PlcValueAbstract value)
    {
        byte[] data;
        if (value is PlcValue<int>)
        {
            data = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(((PlcValue<int>)value).Value));
        }
        else if (value is PlcValue<short>)
        {
            data = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(((PlcValue<short>)value).Value));
        }
        else
        {
            throw new ArgumentException("Value type is not supported", "value");
        }

        return new KeyValuePair<string, byte[]>(address, data);
    }

The above code is a bit of a simplification, the actual code also handles address specification for the different data types.

Answer 1

My thinking is that something like this should work:

public abstract class PlcValueAbstract
{
    internal PlcValueAbstract()
    {
    }

    public abstract Type GetUnderlyingType();
    public abstract SetValue(byte[] bytes);
}


public class PlcValueInt : PlcValue<int>
{
    public override SetValue(byte[] bytes)
    {
        Value = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(bytes, 0));
    }
}

I've made the generic class abstract (not shown) and then there is a setValue method on the base abstract class that takes a byte array and its job is to set the value.

You then derive your concrete classes from this, one for each type you need, and that just needs to implement the one method to parse your result into the value.

Then your problem code will just look like:

for (int i = 0; i < response.Length; i++) { byte[] res = response[i]; PlcValueAbstract pv = values[i];

    pv.SetValue(res);

}

This code has not been tested or compiled but the principles should be sound, even if it needs a bit of tweaking to get it working.

You are essentially shuffling your type check code around, removing the need for checking what the type is in favour of having a class declaration for each of your datatypes.

The main reason this works is because the method signature for SetValue doesn't need to know what the underlying type is, it just needs to take a certain input and then does whatever it wants internally so it can easily be called without knowing anything more.

Answer 2

It looks as though what you need may be to define an IPlcValue interface which contains members to find an item's underlying type, as well as to convert that type to or from a series of bytes [the routine to convert from a series of bytes could be written to use a stream, or could accept an array of bytes along the length of the valid portion of the array and a nextOffset value, the latter being passed as a ref int ]. In addition to that, one should define an IPlcValue<T> interface which contains a Value member of type T . Once one has done those things, one could define class(es) PlcIntegerMsbFirst and/or PlcIntegerLsbFirst which would implement IPlcValue<int> , a PlcString which implements IPlcValue<String> [if any PLCs use strings], etc. Code which has a collection of IPlcValue items could convert them all to or from a sequence of bytes without having to know about their underlying types; code which knows that something should be a number could access it as IPlcValue<int> without having to know whether it was stored MSB-first or LSB-first, etc.

Answer 3

I finally spent some time and thought on this issue and came up with a solution. I added an IntermediateReadResult abstract class that is passed on to the PlcValueContainerBase ( PlcValueAbstract in the original question), which in turn will pass it to PlcValueContainer<T> ( PlcValue<T> in the original question), which will tell the IntermediateReadResult that it wants to perform an Action with a value of type T . The IntermediateReadResult in turn passes this on to some implementation in the implementation class ( MitsubishiIntermediateReadResult in the example below) that will actually do the value conversion. A similar approach is taking for performing the writes. There is some small discrepancy between reads and writes in that for a read of multiple data objects I build one IntermediateReadResult for every data container, while for writes I have only one IntermediateWriteData . This is not clearly visible from the small example below, but can be figured because only the type is passed (as generic argument) onto the Apply<TValue> method.

The effect of the explained structure is that now I can have the following set of implementation classes for a PLC type to implement data reading and writing using PlcValueContainer s:

• BrandDataConverter
• BrandIntermediateReadResult
• BrandIntermediateWriteData
• BrandPlc

There might be additional classes necessary depending on the PLC supplier's API, but those are always required of course. All the Brand classes live in their own BrandPlc assembly so I don't create dependencies on all PLC brands if I need only one (or two). I also have some wrapping code and an abstract PLC class to hide internal API from consumer classes (I don't want the consumers to apply some CustomIntermediateReadResult by accident), but other than that the following code example covers most of what is required:

public abstract class PlcValueContainerBase
{
    ...

    internal abstract void ApplyReadResult(IntermediateReadResult intermediateReadResult);

    internal abstract void ContributeWrite(IntermediateWriteData intermediateWriteData);

    ...
}

public class PlcValueContainer<TValue> : PlcValueContainerBase
{
    public TValue Value { get; set; }

    internal override void ApplyReadResult(IntermediateReadResult intermediateReadResult)
    {
        intermediateReadResult.Apply<TValue>(value => Value = value);
    }

    internal override void ContributeWrite(IntermediateWriteData intermediateWriteData)
    {
        intermediateWriteData.Append(Address, Value, Length);
    }
}

public abstract class IntermediateReadResult
{
    protected internal abstract void Apply<TValue>(Action<TValue> valueAction);
}

class MitsubishiIntermediateReadResult : IntermediateReadResult
{
    private readonly short[] data;

    public MitsubishiIntermediateReadResult(short[] data)
    {
        this.data = data;
    }

    protected override void Apply<TValue>(Action<TValue> valueAction)
    {
        valueAction(MitsubishiDataConverter.ConvertFromPlc<TValue>(data));
    }
}