C＃方法使用动态参数重载

Question

I'm trying to write a tool for serialization of values. And I was hoping to get some nice syntax working.....

            float f = 9999.0f;
            ByteSerializer s = new ByteSerializer ();
            s.Write(f);

Where the params of Write() could be anything and any number:

    public void Write (params dynamic[] objects)
    {

        for (int i =0;i<objects.Length;i++) {

            byteList.AddRange (GetBytes (objects[i]));

        }
    }

GetBytes() should now be called according to the type of the object that was passed:

    public  byte[] GetBytes ( object v)
    {
    //Shouldn't actually do anything since it's a dummy
        return new byte[0];
    }


    public  byte[] GetBytes ( System.Single v)
    {
    //Why is this not called?

        return BitConverter.GetBytes (v);

    }

But it will always go straight for the method that takes an object as parameter. I initially tried (params object[]) as method parameters and found this behaviour to be rather obvious. But why does dynamic[] behave the same?

objects[i].GetType() reports a System.Single so what's going on here? Is what I am trying to do just not possible?

Answer 1

There is no reason this shouldn't work with dynamic exactly as you described. One of the primary features of the DLR is to do at runtime what would have been done at compile time if the types had been known then. For example, the following program:

public class Program
{
    public static void Main(string[] args)
    {
        WriteItems("a string", (byte)1, 3f, new object());
    }

    private static void WriteItems(params dynamic[] items)
    {
        foreach(dynamic item in items)
        {
            Write(item);
        }
    }

    private static void Write(byte b)
    {
        Console.WriteLine("Write byte: {0}", b);
    }

    private static void Write(float f)
    {
        Console.WriteLine("Write Single: {0}", f);
    }

    private static void Write(string s)
    {
        Console.WriteLine("Write string: {0}", s);
    }        

    private static void Write(object o)
    {
        Console.WriteLine("Write object: {0}", o);
    }
}

Produces the output:

Write string: a string
Write byte: 1
Write Single: 3
Write object: System.Object

Answer 2

Method overloading relies on knowing at compile time the types of all the arguments. Here, you can't know the argument types at compile time - because it's dynamic - so the compiler uses the lowest common type - which is object . The difference between object and dynamic is that dynamic allows late binding syntax - but that doesn't help you here.

If you want to call GetBytes for the correct types, you need to use reflection . Specifically, you want to use GetMethod to find an overload of GetBytes that matches the type of each argument, and then call it. with Invoke . Something like this(not tested):

byteList.AddRange (GetType()
        .GetMethod("GetBytes", new Type[objects[i].GetType()])
        .Invoke(null, new object[objects[i]]));

Answer 3

The dynamic type behaves like the object type. The only difference is that for dynamic the compiler does no type checking (so you can avoid compiler errors when working eg with COM).

What you intend, can be done anyway. But you must take the long road and do an explicit typechecking/cast in your for loop (a long but simple switch / case construct).

HTH Thomas