C＃泛型无法识别类型

Question

I can't figure out why the following code returns a Cannot resolve method Write(T) - it seems unambiguous to me:

  private static void WriteToDisk<T>(string fileName, T[] vector) { using (var stream = new FileStream(fileName, FileMode.Create)) { using (var writer = new BinaryWriter(stream)) { foreach(T v in vector) writer.Write(v); writer.Close(); } } } 

I would like to define a generic binary write method that can deal with vectors of, eg, int[] , long[] or double[] .

Answer 1

Which overload of Write() to call will be determined at compile time, not at runtime. BinaryWriter would need a Write(object) overload (or a Write<T>(T) generic overload) to allow calling the method this way. This error (correctly) indicates that it has neither.

You will need to write your own wrapper method that accepts an object (or a generically-typed argument) and inspects its type to determine which BinaryWriter.Write() overload to call.

Answer 2

cdhowie has the correct explanation. Overload resolution happens at compile-time, and in this case nothing is known about T , so no overload is applicable.

With dynamic , overload resolution happens runtime. Maybe you can use:

writer.Write((dynamic)v)

It will be a bit slow because of boxing and repeated overload resolution taking place runtime.

Edit: If for some reason you don't have access to dynamic , you can get a similar behavior with explicit reflection:

private static void WriteToDisk<T>(string fileName, T[] vector)
{
    var correctMethod = typeof(BinaryWriter).GetMethod("Write", new[] { typeof(T), });
    if (correctMethod == null)
        throw new ArgumentException("No suitable overload found for type " + typeof(T), "T");
    using (var stream = new FileStream(fileName, FileMode.Create))
    {
        using (var writer = new BinaryWriter(stream))
        {
           foreach(var v in vector)
               correctMethod.Invoke(writer, new object[] { v, });
        }
    }
}

I don't know if this is faster or slower than dynamic .

In either case, if you accidentally use a type T (such as DateTime ) which is not supported by BinaryWriter , everything will compile fine, and you will only discover your mistake at runtime (when the code runs). See jam40jeff's answer for a more type-safe solution where you specify the overload yourself by passing in a delegate instance to the method.

Answer 3

I disagree that dynamic is the best way to go. The problem here is that you need to guarantee that callers pass a type T that BinaryWriter.Write() can handle. Since there is no common class or interface that can guarantee this by constraining T , the best way to do that is to "pass the buck" to the caller as follows:

private static void WriteToDisk<T>(string fileName, T[] vector, Action<BinaryWriter, T> callWrite)
{
    using (var stream = new FileStream(fileName, FileMode.Create))
    {
        using (var writer = new BinaryWriter(stream))
        {
            foreach (T v in vector)
                callWrite(writer, v);
            writer.Close();
        }
    }
}

This is called as follows:

WriteToDisk("filename", new int[0], (w, o) => w.Write(o)); // compiles
WriteToDisk("filename", new string[0], (w, o) => w.Write(o)); // compiles
WriteToDisk("filename", new DateTime[0], (w, o) => w.Write(o)); // doesn't compile (as desired)

Of course, if there's only a small set of known types, you can create "convenience methods" as such:

private static void WriteToDisk(string fileName, int[] vector)
{
    WriteToDisk(fileName, vector, (w, o) => w.Write(o));
}

private static void WriteToDisk(string fileName, string[] vector)
{
    WriteToDisk(fileName, vector, (w, o) => w.Write(o));
}

and now your calls are simply:

WriteToDisk("filename", new int[0]);
WriteToDisk("filename", new string[0]);

A little more code, but a lot more compile-time type safety and speed.

Answer 4

You can change it to:

private static void WriteToDisk<T>(string fileName, T[] vector) where T : struct, IComparable,IComparable<T>

if you want to keep type of array as number value type.