Create a base class with an abstract field that is implemented by a child

Question

I am writing a wrapper around the driver of a rare database. Specifically, I am implementing raw query code, so I naturally need as much speed as possible. This is going to be implemented in a large eCommerce solution.

This has put me off dynamic types and casting. I want direct access to the actual data type.

The functionality I need is to have a base parameter class with general fields, and a series of child classes with one specifically typed field each (one for each database type, which are int, long, double, string, byte[], object, and list, plus list of each of these types). The C# type should match the database type.

This is not straightforward because in my implementation, the calling code needs to see the base type, but base types can't see a child's fields.

Here is the code I have so far:

private abstract class GlobalQueryParam
{
    public readonly string Low;
    // Val must be correctly typed
    public abstract object Val; // requires casting; don't want, but works
    protected string dbVal = "";        

    public string GetDBVal()
    {
        return this.dbVal;
    }

    public abstract bool SetDBVal(string value);

    public GlobalQueryParam(string low)
    {
        this.Low = low;
    }
}

public class GlobalQueryParamInt : GlobalQueryParam
{
    /// <summary>
    /// Represents the current literal value. Used in traversal actions.
    /// </summary>
    public override int Val;

    public int Parse(string dbVal)
    {
        return (this.Val = int.Parse(dbVal));
    }

    public override bool SetDBVal(string value)
    {
        if (value != "")
        {
            this.dbVal = value;
            return int.TryParse(value, out this.Val);
        }

        return false;
    }

    public GlobalQueryParamInt(string low = "") : base(low) { }
}

In my implementation, I have to declare an array of the base class, which is throwing a spanner in the works.

I am sure there is a better way to do this. I looked at interfaces, but they too need the type, and I couldn't get generics to work because of the array of base types sharing a common type.

If I change the aforementioned array, I introduce other complexities which are circular in nature.

What is the most efficient way to implement what I am looking for, or as close to it as possible?

EDIT Implementation (doesn't work with generics):

    GlobalQueryParam[] trail = new GlobalQueryParam[dataPos+1]; // DOESN'T WORK
    trail[0] = new GlobalQueryParamInt((this.TestParams[0].QueryLow - 1).ToString());
    trail[1] = new GlobalQueryParamInt((this.TestParams[1].QueryLow - 1).ToString());
    trail[2] = new GlobalQueryParamInt((this.TestParams[2].QueryLow - 1).ToString());
    trail[3] = new GlobalQueryParamInt((this.TestParams[3].QueryLow - 1).ToString());
    trail[4] = new GlobalQueryParamInt((this.TestParams[4].QueryLow - 1).ToString());
    trail[5] = new GlobalQueryParamInt((this.TestParams[5].QueryLow - 1).ToString());
    trail[6] = new GlobalQueryParamInt((this.TestParams[6].QueryLow - 1).ToString());
    trail[7] = new GlobalQueryParamInt((this.TestParams[7].QueryLow - 1).ToString());

Answer 1

You want to use Generics

public abstract GlobalQueryParam{}

public abstract class GlobalQueryParam<TValue>: GlobalQueryParam where TValue : struct
{
    public readonly TValue Low;
    public TValue Val; 
    protected TValue dbVal = default(TValue);

    public TValue GetDBVal()
    {
        return  dbVal;
    }

    public abstract bool SetDBVal(TValue value);

    public abstract TValue Parse(string dbVal);

    public GlobalQueryParam(TValue low)
    {
        this.Low = low;
    }
}

public class GlobalQueryParamInt : GlobalQueryParam<int>
{

    public int Parse(string dbVal)
    {
        return (this.Val = int.Parse(dbVal));
    }

    public override bool SetDBVal(int value)
    {

        return true;
    }

    public GlobalQueryParamInt(int low = 0) : base(low) { }
}

EDIT: Create a base class for this and a collection class based on this post Collection of generic types

Answer 2

Create an interface with the methods/properties you need:

public interface IGlobalQueryParam { 

  string ToString();

  . . . 

} 

Then use the generic classes as in damdum answer, implementing the interface:

private abstract class GlobalQueryParam<TValue> : IGlobalQueryParam where TValue : struct {   
  public readonly TValue Low;   
  public TValue Val;    
  protected TValue dbVal = default(TValue);   

  public TValue GetDBVal()   
  {   
    return  dbVal;   
  }   

  public override string ToString()
  {
    return Val.ToString();
  } // ToString

  . . . implement IGlobalQueryParam . . .

}  

public class GlobalQueryParamInt : GlobalQueryParam<int> {

  . . . 
}

and then create and use arrays (or lists etc) of the interface:

IGlobalQueryParam[] trail = new IGlobalQueryParam[dataPos+1];
trail[0] = new GlobalQueryParamInt((this.TestParams[0].QueryLow - 1).ToString());    
trail[1] = new GlobalQueryParamInt((this.TestParams[1].QueryLow - 1).ToString());    
trail[2] = new GlobalQueryParamInt((this.TestParams[2].QueryLow - 1).ToString());    
trail[3] = new GlobalQueryParamInt((this.TestParams[3].QueryLow - 1).ToString());    
trail[4] = new GlobalQueryParamInt((this.TestParams[4].QueryLow - 1).ToString());    
trail[5] = new GlobalQueryParamInt((this.TestParams[5].QueryLow - 1).ToString());    

It is still not possible to access the underlying value of each item without boxing it (i.e. with a IGlobalQueryParam property returning object), but it is possible to create methods and properties of the interface that do what's needed on the underlying values withut boxing - for example to convert the values to a string as in the example above.

Answer 3

In the end, I reverted to my original code, which casts and boxes the values to and from object. Generics added nothing because object inheritance implemented the desired type. And interface added nothing once generics were removed.