Question

The example I am giving is not exactly what I’m working on, but its is an approximate representation and greatly simplified to the exact problem. I am willing to investigate all options.

I have an abstract class with a data value I want to override in a subsequent class.

The base abstract class

public abstract class Variable
{
    public abstract long data;
}

I have a subclass

public class FloatVariable : Variable
{
    public override float data;
}

However when using late dynamic binding I have trouble

Variable var = new FloatVariable();
var.data = 0.33f;

Causes an error that it “Cannot implicitly convert type ‘float’ to ‘long'”

Obviously I’m not doing it right, however if there is a way to override variables (and types) so that late dynamic binding will still allow it to compile, it would make my life infinity easier.

Answer 1

I found a solution that solves my problem that I could not resolve with generics/templates.

Create a new scalar class

Class Scalar
{
    private byte dataByte = 0;
    private short dataShort = 0;
    // ... int, long, float, double
    private string dataString = 0;
    private List<Variable> dataList = null;

    //constructors for "later" type casting (see below)
    public Scalar(byte data)
    {
        this.dataByte = data;
    }

    //* repeat this for short, int, long, float, double, string, List<>

    //implicit conversions for getting data out
    public static implicit operator byte(Scalar scalar)
    {
        return scalar.dataByte;
    }

    //* repeat this for short, int, long, float, double, string, List<>

    //implicit conversions for getting data in (invokes a constructor)
    public static implicit operator Scalar(byte data)
    {
        return new Scalar(data);
    }

    //* repeat this for short, int, long, float, double, string, List<>
}

Then create my base variable class

abstract class Variable
{
    public Scalar Data
    {
        get { return data; }
        set { data = value; }
    }

    protected Scalar data = new Scalar(0);

    /* other meta information etc */
}

Then create your sub classes of your meta variables

class MetaByte : Variable
{
    public byte Data
    {
        get { return data; }
        set { data = value; }
    }

    /* byte specific features */
}

Then using it works just fine with dynamic binding

Variable scalar = new MetaByte();
scalar.Data = 33;
scalar = new MetaList();
scalar.Data = new List<Variable>();

Its not perfect with the lists, but it seems to work for how I intend to use it.