Question

我正在撰写一种特殊的System.IO.BinaryWriter。本作者应该能够处理整数类型，包括Enum和这些类型的集合。

abstract class MyBinaryWriter
{
    // ...

    #region Methods: Basic Types: Writing
    public abstract void Write(byte value);
    public abstract void Write(ushort value);
    public abstract void Write(uint value);
    public abstract void Write(ulong value);
    public abstract void Write(string value); 
    #endregion

    #region Methods: Complex Types: Writing
    public virtual void Write<T>(ICollection<T> collection)
    {
        // first write the 32-bit-unsigned-length prefix
        if (collection == null || collection.Count == 0)
        {
            Write((uint)0);
        }
        else
        {
            Write((uint)collection.Count);

            // then write the elements, if any
            foreach (var item in collection)
                ; // What here? Obviously Write(item) doesn't work...
        }
    }

    // ...
}

处理此问题的最佳方法是什么？使用泛型比使用每个整数类型和我希望处理的每个枚举类型编写重载更好的解决方案？可能的解决方案如下，但我不太喜欢并且存在潜在的性能问题。

    #region Methods: Complex Types: Writing
    public virtual void Write<T>(ICollection<T> collection) where T : IConvertible
    {
        // first write the 32-bit-unsigned-length prefix
        if (collection == null || collection.Count == 0)
        {
            Write((uint)0);
        }
        else
        {
            Write((uint)collection.Count);

            // get the method for writing an element
            Action<T> write = null;
            var type = typeof(T);
            if (type.IsEnum)
                type = Enum.GetUnderlyingType(type);

            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Byte:
                case TypeCode.SByte:
                    write = (x => Write((byte)(IConvertible)x.ToByte(null)));
                    break;

                case TypeCode.Int16:
                case TypeCode.UInt16:
                    write = (x => Write((ushort)(IConvertible)x.ToUInt16(null)));
                    break;

                case TypeCode.Int32:
                case TypeCode.UInt32:
                    write = (x => Write((uint)(IConvertible)x.ToUInt32(null)));
                    break;

                case TypeCode.Int64:
                case TypeCode.UInt64:
                    write = (x => Write((ulong)(IConvertible)x.ToUInt64(null)));
                    break;

                default:
                    Debug.Fail("Only supported for integral types.");
                    break;
            }

            // then write the elements, if any
            foreach (var item in collection)
                write(item);
        }
    }

Answer 1

执行此操作的一种方法是使用已编译的表达式：

// helper classes which compiles a fast, type-safe delegate for writing various types
static class MyBinaryWriterHelper<T> {
    public static readonly Action<MyBinaryWriter, T> WriteAction;

    // this initialization is a bit expensive, but it will occur only once
    // for each writable type T and will occur lazily
    static {
        // find the existing Write(T) on the MyBinaryWriter type
        var writeMethod = typeof(MyBinaryWriter).GetMethods()
            .FirstOrDefault(m => m.Name == "Write" 
                && m.GetArguments().Length == 1
                && m.GetArguments()[0](p => p.ParameterType == typeof(T)
        );

        // if there is no such method, fail
        if (writeMethod == null) { throw ... }

        // build up an expression (writer, t) => writer.Write(t)
        var writerParam = Expression.Parameter(typeof(MyBinaryWriter));
        var tParam = Expression.Parameter(typeof(T));
        var call = Expression.Call(writerParam, writeMethod, tParam);
        var lambda = Expression.Lambda<Action<MyBinaryWriter, T>>(call, new[] { writerParam, tParam });

        // compile the expression to a delegate, caching the result statically in the
        // readonly WriteAction field
        WriteAction = lambda.Compile();
    }
}

// then in your writer class
public void Write<T>(IEnumerable<T> collection) {
    // other collection writing logic (e. g. writing the count) ...

    // to write out the items, just use the static action field
    foreach (var t in collection) {
        MyBinaryWriterHelper<T>.WriteAction(this, t);
    }
}

虽然没有办法使用泛型强制类型为“数字”，但您可以使用IConvertible（如示例代码中）作为松散约束来增加额外的编译时安全性。

Answer 2

我能想到的最好的事情就是使用dynamic：

public void Write<T>(ICollection<T> collection) {
    dynamic self = this;
    foreach (var value in collection) {
        self.Write(value);
    }
}

动态调用has been discussed by Eric的性能。简而言之，它的性能与使用编译的表达式树有些相同。

实现泛型方法来处理不同整数类型集合的正确方法是什么？

2 个答案: