WriteByte() private method

private WriteByte ( Byte value ) : void
value Byte
return void
 // Token: 0x0600529B RID: 21147 RVA: 0x0012227C File Offset: 0x0012047C
 internal static void WriteStringWithCode(string value, __BinaryWriter sout)
 {
     if (value == null)
     {
         sout.WriteByte(17);
         return;
     }
     sout.WriteByte(18);
     sout.WriteString(value);
 }
 internal static void WriteStringWithCode(string value, __BinaryWriter sout)
 {
     if (value == null)
     {
         sout.WriteByte(0x11);
     }
     else
     {
         sout.WriteByte(0x12);
         sout.WriteString(value);
     }
 }
 internal static void WriteStringWithCode(string value, __BinaryWriter sout)
 {
     if (value == null)
     {
         sout.WriteByte(0x11);
     }
     else
     {
         sout.WriteByte(0x12);
         sout.WriteString(value);
     }
 }
 // Token: 0x06005303 RID: 21251 RVA: 0x00123C0C File Offset: 0x00121E0C
 public void Write(__BinaryWriter sout)
 {
     if (this.nullCount == 1)
     {
         sout.WriteByte(10);
         return;
     }
     if (this.nullCount < 256)
     {
         sout.WriteByte(13);
         sout.WriteByte((byte)this.nullCount);
         return;
     }
     sout.WriteByte(14);
     sout.WriteInt32(this.nullCount);
 }
        internal static void WriteTypeInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, int assemId, __BinaryWriter sout)
        {
            switch (binaryTypeEnum)
            {
            case BinaryTypeEnum.Primitive:
            case BinaryTypeEnum.PrimitiveArray:
                sout.WriteByte((byte)(InternalPrimitiveTypeE)typeInformation);
                break;

            case BinaryTypeEnum.String:
                break;

            case BinaryTypeEnum.Object:
                break;

            case BinaryTypeEnum.ObjectUrt:
                sout.WriteString(typeInformation.ToString());
                break;

            case BinaryTypeEnum.ObjectUser:
                sout.WriteString(typeInformation.ToString());
                sout.WriteInt32(assemId);
                break;

            case BinaryTypeEnum.ObjectArray:
                break;

            case BinaryTypeEnum.StringArray:
                break;

            default:
                throw new SerializationException(Environment.GetResourceString("Serialization_TypeWrite", (object)binaryTypeEnum.ToString()));
            }
        }
 public void Write(__BinaryWriter sout)
 {
     if (this.nullCount == 1)
     {
         sout.WriteByte((byte)10);
     }
     else if (this.nullCount < 256)
     {
         sout.WriteByte((byte)13);
         sout.WriteByte((byte)this.nullCount);
     }
     else
     {
         sout.WriteByte((byte)14);
         sout.WriteInt32(this.nullCount);
     }
 }
 internal static void WriteWithCode(Type type, object value, __BinaryWriter sout)
 {
     if (type == null)
     {
         sout.WriteByte(0x11);
     }
     else if (object.ReferenceEquals(type, Converter.typeofString))
     {
         WriteStringWithCode((string) value, sout);
     }
     else
     {
         InternalPrimitiveTypeE code = Converter.ToCode(type);
         sout.WriteByte((byte) code);
         sout.WriteValue(code, value);
     }
 }
        // Token: 0x0600529C RID: 21148 RVA: 0x0012229C File Offset: 0x0012049C
        internal static void WriteWithCode(Type type, object value, __BinaryWriter sout)
        {
            if (type == null)
            {
                sout.WriteByte(17);
                return;
            }
            if (type == Converter.typeofString)
            {
                IOUtil.WriteStringWithCode((string)value, sout);
                return;
            }
            InternalPrimitiveTypeE internalPrimitiveTypeE = Converter.ToCode(type);

            sout.WriteByte((byte)internalPrimitiveTypeE);
            sout.WriteValue(internalPrimitiveTypeE, value);
        }
 public void Write(__BinaryWriter sout)
 {
     if (this.nullCount == 1)
     {
         sout.WriteByte(10);
     }
     else if (this.nullCount < 0x100)
     {
         sout.WriteByte(13);
         sout.WriteByte((byte) this.nullCount);
     }
     else
     {
         sout.WriteByte(14);
         sout.WriteInt32(this.nullCount);
     }
 }
 internal static void WriteWithCode(Type type, object value, __BinaryWriter sout)
 {
     if (type == null)
     {
         sout.WriteByte(0x11);
     }
     else if (object.ReferenceEquals(type, Converter.typeofString))
     {
         WriteStringWithCode((string)value, sout);
     }
     else
     {
         InternalPrimitiveTypeE code = Converter.ToCode(type);
         sout.WriteByte((byte)code);
         sout.WriteValue(code, value);
     }
 }
 // Token: 0x060052A8 RID: 21160 RVA: 0x00122428 File Offset: 0x00120628
 public void Write(__BinaryWriter sout)
 {
     this.majorVersion = this.binaryFormatterMajorVersion;
     this.minorVersion = this.binaryFormatterMinorVersion;
     sout.WriteByte((byte)this.binaryHeaderEnum);
     sout.WriteInt32(this.topId);
     sout.WriteInt32(this.headerId);
     sout.WriteInt32(this.binaryFormatterMajorVersion);
     sout.WriteInt32(this.binaryFormatterMinorVersion);
 }
 public void Write(__BinaryWriter sout)
 {
     this.majorVersion = this.binaryFormatterMajorVersion;
     this.minorVersion = this.binaryFormatterMinorVersion;
     sout.WriteByte((byte) this.binaryHeaderEnum);
     sout.WriteInt32(this.topId);
     sout.WriteInt32(this.headerId);
     sout.WriteInt32(this.binaryFormatterMajorVersion);
     sout.WriteInt32(this.binaryFormatterMinorVersion);
 }
 // Token: 0x060052ED RID: 21229 RVA: 0x00123558 File Offset: 0x00121758
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)this.binaryHeaderEnum);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.name);
     sout.WriteInt32(this.numMembers);
     for (int i = 0; i < this.numMembers; i++)
     {
         sout.WriteString(this.memberNames[i]);
     }
     for (int j = 0; j < this.numMembers; j++)
     {
         sout.WriteByte((byte)this.binaryTypeEnumA[j]);
     }
     for (int k = 0; k < this.numMembers; k++)
     {
         BinaryConverter.WriteTypeInfo(this.binaryTypeEnumA[k], this.typeInformationA[k], this.memberAssemIds[k], sout);
     }
     if (this.assemId > 0)
     {
         sout.WriteInt32(this.assemId);
     }
 }
示例#14
0
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)this.binaryHeaderEnum);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.name);
     sout.WriteInt32(this.numMembers);
     for (int index = 0; index < this.numMembers; ++index)
     {
         sout.WriteString(this.memberNames[index]);
     }
     for (int index = 0; index < this.numMembers; ++index)
     {
         sout.WriteByte((byte)this.binaryTypeEnumA[index]);
     }
     for (int index = 0; index < this.numMembers; ++index)
     {
         BinaryConverter.WriteTypeInfo(this.binaryTypeEnumA[index], this.typeInformationA[index], this.memberAssemIds[index], sout);
     }
     if (this.assemId <= 0)
     {
         return;
     }
     sout.WriteInt32(this.assemId);
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte) this.binaryHeaderEnum);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.name);
     sout.WriteInt32(this.numMembers);
     for (int i = 0; i < this.numMembers; i++)
     {
         sout.WriteString(this.memberNames[i]);
     }
     if (this.assemId > 0)
     {
         sout.WriteInt32(this.assemId);
     }
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)this.binaryHeaderEnum);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.name);
     sout.WriteInt32(this.numMembers);
     for (int i = 0; i < this.numMembers; i++)
     {
         sout.WriteString(this.memberNames[i]);
     }
     if (this.assemId > 0)
     {
         sout.WriteInt32(this.assemId);
     }
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)this.binaryHeaderEnum);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.name);
     sout.WriteInt32(this.numMembers);
     for (int index = 0; index < this.numMembers; ++index)
     {
         sout.WriteString(this.memberNames[index]);
     }
     if (this.assemId <= 0)
     {
         return;
     }
     sout.WriteInt32(this.assemId);
 }
示例#18
0
 // Token: 0x060052BF RID: 21183 RVA: 0x001228C8 File Offset: 0x00120AC8
 internal void Write(__BinaryWriter sout)
 {
     sout.WriteByte(21);
     sout.WriteInt32((int)this.messageEnum);
     IOUtil.WriteStringWithCode(this.methodName, sout);
     IOUtil.WriteStringWithCode(this.typeName, sout);
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         IOUtil.WriteStringWithCode((string)this.callContext, sout);
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         sout.WriteInt32(this.args.Length);
         for (int i = 0; i < this.args.Length; i++)
         {
             IOUtil.WriteWithCode(this.argTypes[i], this.args[i], sout);
         }
     }
 }
        // Token: 0x060052F2 RID: 21234 RVA: 0x001237E4 File Offset: 0x001219E4
        public void Write(__BinaryWriter sout)
        {
            switch (this.binaryHeaderEnum)
            {
            case BinaryHeaderEnum.ArraySinglePrimitive:
                sout.WriteByte((byte)this.binaryHeaderEnum);
                sout.WriteInt32(this.objectId);
                sout.WriteInt32(this.lengthA[0]);
                sout.WriteByte((byte)((InternalPrimitiveTypeE)this.typeInformation));
                return;

            case BinaryHeaderEnum.ArraySingleObject:
                sout.WriteByte((byte)this.binaryHeaderEnum);
                sout.WriteInt32(this.objectId);
                sout.WriteInt32(this.lengthA[0]);
                return;

            case BinaryHeaderEnum.ArraySingleString:
                sout.WriteByte((byte)this.binaryHeaderEnum);
                sout.WriteInt32(this.objectId);
                sout.WriteInt32(this.lengthA[0]);
                return;

            default:
                sout.WriteByte((byte)this.binaryHeaderEnum);
                sout.WriteInt32(this.objectId);
                sout.WriteByte((byte)this.binaryArrayTypeEnum);
                sout.WriteInt32(this.rank);
                for (int i = 0; i < this.rank; i++)
                {
                    sout.WriteInt32(this.lengthA[i]);
                }
                if (this.binaryArrayTypeEnum == BinaryArrayTypeEnum.SingleOffset || this.binaryArrayTypeEnum == BinaryArrayTypeEnum.JaggedOffset || this.binaryArrayTypeEnum == BinaryArrayTypeEnum.RectangularOffset)
                {
                    for (int j = 0; j < this.rank; j++)
                    {
                        sout.WriteInt32(this.lowerBoundA[j]);
                    }
                }
                sout.WriteByte((byte)this.binaryTypeEnum);
                BinaryConverter.WriteTypeInfo(this.binaryTypeEnum, this.typeInformation, this.assemId, sout);
                return;
            }
        }
示例#20
0
 // Token: 0x060052C8 RID: 21192 RVA: 0x00122EBC File Offset: 0x001210BC
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(22);
     sout.WriteInt32((int)this.messageEnum);
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueInline))
     {
         IOUtil.WriteWithCode(this.returnType, this.returnValue, sout);
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         IOUtil.WriteStringWithCode((string)this.callContext, sout);
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         sout.WriteInt32(this.args.Length);
         for (int i = 0; i < this.args.Length; i++)
         {
             IOUtil.WriteWithCode(this.argTypes[i], this.args[i], sout);
         }
     }
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte) this.binaryHeaderEnum);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.name);
     sout.WriteInt32(this.numMembers);
     for (int i = 0; i < this.numMembers; i++)
     {
         sout.WriteString(this.memberNames[i]);
     }
     for (int j = 0; j < this.numMembers; j++)
     {
         sout.WriteByte((byte) this.binaryTypeEnumA[j]);
     }
     for (int k = 0; k < this.numMembers; k++)
     {
         BinaryConverter.WriteTypeInfo(this.binaryTypeEnumA[k], this.typeInformationA[k], this.memberAssemIds[k], sout);
     }
     if (this.assemId > 0)
     {
         sout.WriteInt32(this.assemId);
     }
 }
 public  void Write(__BinaryWriter sout) 
 {
     if (nullCount == 1) 
     { 
         sout.WriteByte((Byte)BinaryHeaderEnum.ObjectNull);
     } 
     else if (nullCount < 256)
     {
         sout.WriteByte((Byte)BinaryHeaderEnum.ObjectNullMultiple256);
         sout.WriteByte((Byte)nullCount); 
         //Console.WriteLine("Write nullCount "+nullCount);
     } 
     else 
     {
         sout.WriteByte((Byte)BinaryHeaderEnum.ObjectNullMultiple); 
         sout.WriteInt32(nullCount);
         //Console.WriteLine("Write nullCount "+nullCount);
     }
 } 
 public  void Write(__BinaryWriter sout)
 { 
     sout.WriteByte((Byte)BinaryHeaderEnum.MemberReference); 
     sout.WriteInt32(idRef);
 } 
        public  void Write(__BinaryWriter sout) 
        {
            SerTrace.Log( this, "Write"); 
            switch (binaryHeaderEnum) 
            {
                case BinaryHeaderEnum.ArraySinglePrimitive: 
                    sout.WriteByte((Byte)binaryHeaderEnum);
                    sout.WriteInt32(objectId);
                    sout.WriteInt32(lengthA[0]);
                    sout.WriteByte((Byte)((InternalPrimitiveTypeE)typeInformation)); 
                    break;
                case BinaryHeaderEnum.ArraySingleString: 
                    sout.WriteByte((Byte)binaryHeaderEnum); 
                    sout.WriteInt32(objectId);
                    sout.WriteInt32(lengthA[0]); 
                    break;
                case BinaryHeaderEnum.ArraySingleObject:
                    sout.WriteByte((Byte)binaryHeaderEnum);
                    sout.WriteInt32(objectId); 
                    sout.WriteInt32(lengthA[0]);
                    break; 
                default: 
                    sout.WriteByte((Byte)binaryHeaderEnum);
                    sout.WriteInt32(objectId); 
                    sout.WriteByte((Byte)binaryArrayTypeEnum);
                    sout.WriteInt32(rank);
                    for (int i=0; i<rank; i++)
                        sout.WriteInt32(lengthA[i]); 
                    if ((binaryArrayTypeEnum == BinaryArrayTypeEnum.SingleOffset) ||
                        (binaryArrayTypeEnum == BinaryArrayTypeEnum.JaggedOffset) || 
                        (binaryArrayTypeEnum == BinaryArrayTypeEnum.RectangularOffset)) 
                    {
                        for (int i=0; i<rank; i++) 
                            sout.WriteInt32(lowerBoundA[i]);
                    }
                    sout.WriteByte((Byte)binaryTypeEnum);
                    BinaryConverter.WriteTypeInfo(binaryTypeEnum, typeInformation, assemId, sout); 
                    break;
            } 
 
        }
示例#25
0
 // Token: 0x060052FD RID: 21245 RVA: 0x00123BC6 File Offset: 0x00121DC6
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(9);
     sout.WriteInt32(this.idRef);
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(0x13);
     sout.WriteInt32(this.objectId);
     sout.WriteInt32(this.value);
 }
 public  void Write(__BinaryWriter sout)
 { 
     sout.WriteByte((Byte)BinaryHeaderEnum.Object);
     sout.WriteInt32(objectId); 
     sout.WriteInt32(mapId); 
 }
 public void Write(__BinaryWriter sout) 
 {
     sout.WriteByte((Byte)BinaryHeaderEnum.Assembly);
     sout.WriteInt32(assemId);
     sout.WriteString(assemblyString); 
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(12);
     sout.WriteInt32(this.assemId);
     sout.WriteString(this.assemblyString);
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(20);
     sout.WriteInt32(this.assemId);
     sout.WriteInt32(this.assemblyIndex);
 }
        public void Write(__BinaryWriter sout)
        {
            sout.WriteByte((Byte)BinaryHeaderEnum.MethodReturn); 
            sout.WriteInt32((Int32)messageEnum);
 
            if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInline)) 
            {
                IOUtil.WriteWithCode(returnType, returnValue, sout); 
            }

            if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline))
                IOUtil.WriteStringWithCode((String)callContext, sout); 

            if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline)) 
            { 
                sout.WriteInt32(args.Length);
                for (int i=0; i<args.Length; i++) 
                {
                    IOUtil.WriteWithCode(argTypes[i], args[i], sout);
                }
            } 
        }
 internal static void WriteWithCode(Type type, Object value, __BinaryWriter sout)
 {
     if ((object)type == null)
         sout.WriteByte((Byte)InternalPrimitiveTypeE.Null); 
     else if (Object.ReferenceEquals(type, Converter.typeofString))
         WriteStringWithCode((String)value, sout); 
     else 
     {
         InternalPrimitiveTypeE code = Converter.ToCode(type); 
         sout.WriteByte((Byte)code);
         sout.WriteValue(code, value);
     }
 } 
 internal static void WriteStringWithCode(String value, __BinaryWriter sout)
 { 
     if (value == null)
         sout.WriteByte((Byte)InternalPrimitiveTypeE.Null);
     else
     { 
         sout.WriteByte((Byte)InternalPrimitiveTypeE.String);
         sout.WriteString(value); 
     } 
 }
        // Writes the type information on the wire 
        internal static void WriteTypeInfo(BinaryTypeEnum binaryTypeEnum, Object typeInformation, int assemId, __BinaryWriter sout)
        {
            SerTrace.Log( "BinaryConverter", "WriteTypeInfo Entry  ",((Enum)binaryTypeEnum).ToString()," ",typeInformation," assemId ",assemId);
 
            switch (binaryTypeEnum)
            { 
                case BinaryTypeEnum.Primitive: 
                case BinaryTypeEnum.PrimitiveArray:
                    Contract.Assert(typeInformation!=null, "[BinaryConverter.WriteTypeInfo]typeInformation!=null"); 
                    sout.WriteByte((Byte)((InternalPrimitiveTypeE)typeInformation));
                    break;
                case BinaryTypeEnum.String:
                case BinaryTypeEnum.Object: 
                case BinaryTypeEnum.StringArray:
                case BinaryTypeEnum.ObjectArray: 
                    break; 
                case BinaryTypeEnum.ObjectUrt:
                    Contract.Assert(typeInformation!=null, "[BinaryConverter.WriteTypeInfo]typeInformation!=null"); 
                    sout.WriteString(typeInformation.ToString());
                    break;
                case BinaryTypeEnum.ObjectUser:
                    Contract.Assert(typeInformation!=null, "[BinaryConverter.WriteTypeInfo]typeInformation!=null"); 
                    sout.WriteString(typeInformation.ToString());
                    sout.WriteInt32(assemId); 
                    break; 
                default:
                    throw new SerializationException(Environment.GetResourceString("Serialization_TypeWrite",((Enum)binaryTypeEnum).ToString())); 
            }
            SerTrace.Log( "BinaryConverter", "WriteTypeInfo Exit");
        }
 public  void Write(__BinaryWriter sout)
 { 
     majorVersion = binaryFormatterMajorVersion; 
     minorVersion = binaryFormatterMinorVersion;
     sout.WriteByte((Byte)binaryHeaderEnum); 
     sout.WriteInt32(topId);
     sout.WriteInt32(headerId);
     sout.WriteInt32(binaryFormatterMajorVersion);
     sout.WriteInt32(binaryFormatterMinorVersion); 
 }
 public  void Write(__BinaryWriter sout) 
 {
     sout.WriteByte((Byte)BinaryHeaderEnum.MessageEnd); 
 }
        internal static void WriteTypeInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, int assemId, __BinaryWriter sout)
        {
            switch (binaryTypeEnum)
            {
                case BinaryTypeEnum.Primitive:
                case BinaryTypeEnum.PrimitiveArray:
                    sout.WriteByte((byte) ((InternalPrimitiveTypeE) typeInformation));
                    return;

                case BinaryTypeEnum.String:
                case BinaryTypeEnum.Object:
                case BinaryTypeEnum.ObjectArray:
                case BinaryTypeEnum.StringArray:
                    return;

                case BinaryTypeEnum.ObjectUrt:
                    sout.WriteString(typeInformation.ToString());
                    return;

                case BinaryTypeEnum.ObjectUser:
                    sout.WriteString(typeInformation.ToString());
                    sout.WriteInt32(assemId);
                    return;
            }
            throw new SerializationException(Environment.GetResourceString("Serialization_TypeWrite", new object[] { binaryTypeEnum.ToString() }));
        }
 public void Write(__BinaryWriter sout) 
 { 
     sout.WriteByte((Byte)BinaryHeaderEnum.CrossAppDomainAssembly);
     sout.WriteInt32(assemId); 
     sout.WriteInt32(assemblyIndex);
 }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)11);
 }
        internal void Write(__BinaryWriter sout)
        { 
            sout.WriteByte((Byte)BinaryHeaderEnum.MethodCall); 
            sout.WriteInt32((Int32)messageEnum);
            //IOUtil.WriteStringWithCode(uri, sout); 
            IOUtil.WriteStringWithCode(methodName, sout);
            IOUtil.WriteStringWithCode(typeName, sout);
            if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline))
                IOUtil.WriteStringWithCode((String)callContext, sout); 

            if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline)) 
            { 
                sout.WriteInt32(args.Length);
                for (int i=0; i<args.Length; i++) 
                {
                    IOUtil.WriteWithCode(argTypes[i], args[i], sout);
                }
 
            }
        } 
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(0x12);
     sout.WriteInt32(this.crossAppDomainArrayIndex);
 }
        public void Write(__BinaryWriter sout)
        {
            switch (this.binaryHeaderEnum)
            {
                case BinaryHeaderEnum.ArraySinglePrimitive:
                    sout.WriteByte((byte) this.binaryHeaderEnum);
                    sout.WriteInt32(this.objectId);
                    sout.WriteInt32(this.lengthA[0]);
                    sout.WriteByte((byte) ((InternalPrimitiveTypeE) this.typeInformation));
                    return;

                case BinaryHeaderEnum.ArraySingleObject:
                    sout.WriteByte((byte) this.binaryHeaderEnum);
                    sout.WriteInt32(this.objectId);
                    sout.WriteInt32(this.lengthA[0]);
                    return;

                case BinaryHeaderEnum.ArraySingleString:
                    sout.WriteByte((byte) this.binaryHeaderEnum);
                    sout.WriteInt32(this.objectId);
                    sout.WriteInt32(this.lengthA[0]);
                    return;
            }
            sout.WriteByte((byte) this.binaryHeaderEnum);
            sout.WriteInt32(this.objectId);
            sout.WriteByte((byte) this.binaryArrayTypeEnum);
            sout.WriteInt32(this.rank);
            for (int i = 0; i < this.rank; i++)
            {
                sout.WriteInt32(this.lengthA[i]);
            }
            if (((this.binaryArrayTypeEnum == BinaryArrayTypeEnum.SingleOffset) || (this.binaryArrayTypeEnum == BinaryArrayTypeEnum.JaggedOffset)) || (this.binaryArrayTypeEnum == BinaryArrayTypeEnum.RectangularOffset))
            {
                for (int j = 0; j < this.rank; j++)
                {
                    sout.WriteInt32(this.lowerBoundA[j]);
                }
            }
            sout.WriteByte((byte) this.binaryTypeEnum);
            BinaryConverter.WriteTypeInfo(this.binaryTypeEnum, this.typeInformation, this.assemId, sout);
        }
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)6);
     sout.WriteInt32(this.objectId);
     sout.WriteString(this.value);
 }
示例#44
0
 // Token: 0x060052B4 RID: 21172 RVA: 0x001225B4 File Offset: 0x001207B4
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(20);
     sout.WriteInt32(this.assemId);
     sout.WriteInt32(this.assemblyIndex);
 }
        public  void Write(__BinaryWriter sout)
        {

            sout.WriteByte((Byte)binaryHeaderEnum); 
            sout.WriteInt32(objectId);
            sout.WriteString(name); 
            sout.WriteInt32(numMembers); 
            for (int i=0; i<numMembers; i++)
                sout.WriteString(memberNames[i]); 
            if (assemId > 0)
                sout.WriteInt32(assemId);
        }
示例#46
0
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)1);
     sout.WriteInt32(this.objectId);
     sout.WriteInt32(this.mapId);
 }
        public  void Write(__BinaryWriter sout)
        { 
            sout.WriteByte((Byte)binaryHeaderEnum);
            sout.WriteInt32(objectId); 
            sout.WriteString(name); 
            sout.WriteInt32(numMembers);
            for (int i=0; i<numMembers; i++) 
                sout.WriteString(memberNames[i]);
            for (int i=0; i<numMembers; i++)
                sout.WriteByte((Byte)binaryTypeEnumA[i]);
            for (int i=0; i<numMembers; i++) 
                //if (binaryTypeEnumA[i] != BinaryTypeEnum.ObjectUrt && binaryTypeEnumA[i] != BinaryTypeEnum.ObjectUser)
                    BinaryConverter.WriteTypeInfo(binaryTypeEnumA[i], typeInformationA[i], memberAssemIds[i], sout); 
 
            if (assemId > 0)
                sout.WriteInt32(assemId); 

        }
 public  void Write(__BinaryWriter sout) 
 {
     sout.WriteByte((Byte)BinaryHeaderEnum.CrossAppDomainString); 
     sout.WriteInt32(objectId); 
     sout.WriteInt32(value);
 } 
示例#49
0
 // Token: 0x060052DF RID: 21215 RVA: 0x0012330E File Offset: 0x0012150E
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte(8);
     sout.WriteByte((byte)this.primitiveTypeEnum);
     sout.WriteValue(this.primitiveTypeEnum, this.value);
 }
示例#50
0
 public void Write(__BinaryWriter sout)
 {
     sout.WriteByte((byte)12);
     sout.WriteInt32(this.assemId);
     sout.WriteString(this.assemblyString);
 }
 public  void Write(__BinaryWriter sout) 
 {
     sout.WriteByte((Byte)BinaryHeaderEnum.CrossAppDomainMap);
     sout.WriteInt32(crossAppDomainArrayIndex);
 } 
 public  void Write(__BinaryWriter sout) 
 {
     sout.WriteByte((Byte)BinaryHeaderEnum.ObjectString); 
     sout.WriteInt32(objectId);
     sout.WriteString(value);
 }
 public  void Write(__BinaryWriter sout)
 { 
     sout.WriteByte((Byte)BinaryHeaderEnum.MemberPrimitiveTyped);
     sout.WriteByte((Byte)primitiveTypeEnum); //pdj 
     sout.WriteValue(primitiveTypeEnum, value); 
 }