示例#1
0
        private Byte[] GetSignature(
            FieldReference fieldReference)
        {
            using (var buffer = new MemoryStream())
                using (var writer = new BinaryWriter(buffer)) // Only Write(Byte) will be used
                {
                    var binaryWriter = TinyBinaryWriter.CreateBigEndianBinaryWriter(writer);

                    binaryWriter.WriteByte(0x06); // Field reference calling convention
                    WriteTypeInfo(fieldReference.FieldType, binaryWriter);

                    return(buffer.ToArray());
                }
        }
示例#2
0
        private byte[] GetSignature(
            IEnumerable <VariableDefinition> variables)
        {
            using (var buffer = new MemoryStream())
                using (var writer = new BinaryWriter(buffer)) // Only Write(Byte) will be used
                {
                    var binaryWriter = TinyBinaryWriter.CreateBigEndianBinaryWriter(writer);
                    foreach (var variable in variables)
                    {
                        WriteTypeInfo(variable.VariableType, binaryWriter);
                    }

                    return(buffer.ToArray());
                }
        }
示例#3
0
        private Byte[] GetSignature(
            Collection <TypeReference> interfaces)
        {
            using (var buffer = new MemoryStream())
                using (var writer = new BinaryWriter(buffer)) // Only Write(Byte) will be used
                {
                    var binaryWriter = TinyBinaryWriter.CreateBigEndianBinaryWriter(writer);

                    binaryWriter.WriteByte((Byte)interfaces.Count);
                    foreach (var item in interfaces)
                    {
                        WriteSubTypeInfo(item, binaryWriter);
                    }

                    return(buffer.ToArray());
                }
        }
示例#4
0
        private Byte[] GetSignature(
            TypeReference typeReference,
            Boolean isFieldSignature)
        {
            using (var buffer = new MemoryStream())
                using (var writer = new BinaryWriter(buffer)) // Only Write(Byte) will be used
                {
                    var binaryWriter = TinyBinaryWriter.CreateBigEndianBinaryWriter(writer);

                    if (isFieldSignature)
                    {
                        writer.Write((Byte)0x06); // Field signature prefix
                    }
                    WriteTypeInfo(typeReference, binaryWriter);

                    return(buffer.ToArray());
                }
        }
        private Byte[] CreateByteCode(
            MethodDefinition method)
        {
            if (!method.HasBody)
            {
                return(new Byte[0]);
            }

            using (var stream = new MemoryStream())
                using (var writer = new BinaryWriter(stream))
                {
                    var codeWriter = new CodeWriter(
                        method, TinyBinaryWriter.CreateBigEndianBinaryWriter(writer),
                        _fakeStringTable, _context);
                    codeWriter.WriteMethodBody();
                    return(stream.ToArray());
                }
        }
示例#6
0
        private Byte[] GetSignature(
            IMethodSignature methodReference)
        {
            using (var buffer = new MemoryStream())
                using (var writer = new BinaryWriter(buffer)) // Only Write(Byte) will be used
                {
                    var binaryWriter = TinyBinaryWriter.CreateBigEndianBinaryWriter(writer);
                    writer.Write((Byte)(methodReference.HasThis ? 0x20 : 0x00));

                    writer.Write((Byte)(methodReference.Parameters.Count));

                    WriteTypeInfo(methodReference.ReturnType, binaryWriter);
                    foreach (var parameter in methodReference.Parameters)
                    {
                        WriteTypeInfo(parameter.ParameterType, binaryWriter);
                    }

                    return(buffer.ToArray());
                }
        }