Create a variable of a type only known at runtime (C#)

Question

My question is very similar to : Cast to type known only at runtime , however that one was not really answered (it's also in C rather than C#).

I'm writing something to control some hardware, and depending on the given hardware configuration I have to do some bitwise arithmetic with a "byte" or "UInt32" type. The bit arithmetic code is long but identical in the 32bit and 8bit case, with the only difference being the length of certain loops (32 or 8).

My current solution is to use a switch, which means I have pretty much two copies of the same code in a giant if statement.

An alternative solution is to use an array or 0s and 1s rather than a UInt32 or byte to do the bitwise operations and then convert to UInt32 or byte at the end.

The last solution, which I'm most interested in here, is to dynamically pick which type I will use at runtime. Here is some pseudocode for what I would like:

System.Type MyType;    
if (something)
    MyType=type1;
else
    MyType=somethingElse;

myType someVariable; //Create a variable of type myType. This line will give an 
                     //error
someVariable=(myType) otherVariable //do an example typecast with the 
                                    //runtime-determined type

I've searched around to know that the answer may have something to do with generics and reflection, but I can't figure out how to do it exactly.

Once you have created the value, what are you going to do with it? How are you going to do artithmetic operations on it? — Martin Mulder, May 23 '13 at 20:18
What do you plan on doing with someVariable? Since it's not known what type it is until runtime, you're going to have a difficult time writing code against it. The specifics of what you need to do with it will determine how to get the type system to play along nicely.... — Mark Brackett, May 23 '13 at 20:18
If the only difference is the number of loops, why not just figure that out? for (int i = 0; i < (byteConfig ? 8 : 32); i++) ? — Mark Brackett, May 23 '13 at 20:59

score 1 · Answer 1 · answered May 23 '13 at 20:16

You might consider using a BitArray for this - you can initialise it from a byte or uint32, do the bitwise operations, and then convert it back at the end e.g.

    object value;
    bool isByte = value is byte;
    BitArray ba = isByte
        ? new BitArray(new byte[] { (byte)value })
        : new BitArray(BitConverter.GetBytes((unint32)value));
   ...

score 1 · Answer 2 · answered May 23 '13 at 20:21

I would probably create an abstract class, something like HardwareConfigBase which includes your looping code as well as the size of the loop. Then have 2 child classes that extend that base class.

public abstract class HardwareConfigBase
{
    protected int TimesToLoop;
    public byte[] Data = new byte[32 * 8]; //Size of UInt, but still works for 8bit byte

    public void MyLoopCode
    {
        for(int i = 0; i < TimesToLoop; i++)
        {
            //Do whatever
        }
    }
}

public class ByteHardwareConfig
{
    public ByteHardwareConfig
    {
        TimesToLoop = 8;
    }
}

public class UIntHardwareConfig
{
    public UIntHardwareConfig
    {
         TimesToLoop = 32;
    }
}

public void Main()
{
    var myHardwareConfig = new ByteHardwareConfig(); //Could also be UInt
    //Do some more initialization and fill the Data property.
    myHardwareConfig.MyLoopCode();
}

score 0 · Answer 3 · edited May 23 '17 at 10:25

You can create an instance of a type at runtime using Activator.CreateInstance() like so:

object myInstance = Activator.CreateInstance(MyType);

Then, see this question for how to do a type cast at runtime using only runtime-known types.

public static dynamic Convert(dynamic source, Type dest) {
    return Convert.ChangeType(source, dest);
}

myInstance = Convert(myInstance, MyType);
// will result in myInstance being of type MyType.

Mario Stopfer · Answer 4 · 2013-06-03T19:44:17.297

The answer is rather pretty simple. You will not need to cast or convert any variables at runtime in order to be able to modify uint or byte types at runtime. The following three definitions will suffice.

The first class definition is the Provider class which defines two methods, each one to modify either a variable of uint or byte type. Be sure to put your modifying logic inside the methods.

class Provider
{
    public uint GetResult(uint c)
    {
        return c;
    }

    public byte GetResult(byte c)
    {
        return c;
    }
}

The next class is the one that will invoke the appropriate method from the previous class definition, depending on the type of the parameter you provide.

class Execute
{
    public object GetResult(object source)
    {
        var provider = new Provider();

        return provider.GetType()
                       .GetMethods()
                       .Where(x => x.Name == "GetResult" && x.ReturnType == source.GetType())
                       .First()
                       .Invoke(provider, new object[] { source });
    }
}

The last definition is here to simply test how this setup works. You can see that we have both a byte and a uint type. Passing them both to the GetResult(object) method yields the expected results, and as you can see, the underlying system type is also as expected.

class Program
{
    static void Main()
    {
        uint u = 1;
        byte b = 2;

        var result1 = new Execute().GetResult(u);
        var result2 = new Execute().GetResult(b);

        sc.WriteLine(result1 + " " + result1.GetType().UnderlyingSystemType);
        sc.WriteLine(result2 + " " + result2.GetType().UnderlyingSystemType);

        sc.Read();
    }
}

score -1 · Answer 5 · answered May 23 '13 at 20:13

-1

Try using the dynamic keyword in C#.

dynamic myType;
if (a) {
    myType = new type1();
} else {
    myType = new type2();
}

answered May 23 '13 at 20:13

Porkbutts

924
7
12

-1: The type of `myType` is already known: it is `Type`. There is not the problem. – Martin Mulder May 23 '13 at 20:14

Create a variable of a type only known at runtime (C#)

5 Answers5