)
            {
                this.keyType = this.serializer.GetType(keyAccessor.Type);
                this.valueType = this.serializer.GetType(valueAccessor.Type);
                this.keyAccessor = keyAccessor;
                this.valueAccessor = valueAccessor;
                this.addMethodAccessor = addAccessor;
            }

            protected override bool WriteFormatCode(ByteBuffer buffer)
            {
                AmqpBitConverter.WriteUByte(buffer, FormatCode.Map32);
                return true;
            }

            protected override int WriteMembers(ByteBuffer buffer, object container)
            {
                int count = 0;
                foreach (object item in (IEnumerable)container)
                {
                    object key = this.keyAccessor.Get(item);
                    object value = this.valueAccessor.Get(item);
                    if (value!= null)
                    {
                        this.keyType.WriteObject(buffer, key);

                        SerializableType effectiveType = this.valueType;
                        if (value.GetType()!= effectiveType.type)
                        {
                            effectiveType = this.serializer.GetType(value.GetType());
                        }

                        effectiveType.WriteObject(buffer, value);

                        count += 2;
                    }
                }
                return count;
            }

            protected override void Initialize(ByteBuffer buffer, byte formatCode,
                out int size, out int count, out int encodeWidth, out CollectionType effectiveType)
            {
                effectiveType = this;
                ReadSizeAndCount(buffer, formatCode, out size, out count, out encodeWidth);
            }

            protected override void ReadMembers(ByteBuffer buffer, object container, ref int count)
            {
                for (; count > 0; count -= 2)
                {
                    object key = this.keyType.ReadObject(buffer);
                    object value = this.valueType.ReadObject(buffer);
                    this.addMethodAccessor.Invoke(container, new object[] { key, value });
                }
            }
        }

        abstract class DescribedCompoundType : CollectionType
        {
            readonly DescribedCompoundType baseType;
            readonly Symbol descriptorName;
            readonly ulong? descriptorCode;
            readonly
) 
             { 
                 this.keyType = this.serializer. GetType(keyAccessor. Type); 
                 this.valueType = this.serializer. GetType(valueAccessor. Type); 
                 this.keyAccessor = keyAccessor; 
                 this.valueAccessor = valueAccessor; 
                 this.addMethodAccessor = addAccessor; 
             } 

             protected override bool WriteFormatCode(ByteBuffer buffer) 
             { 
                 AmqpBitConverter. WriteUByte(buffer, FormatCode. Map32); 
                 hark back genuine; 
             } 

             protected override int WriteMembers(ByteBuffer buffer, object container) 
             { 
                 int count = 0; 
                 foreach (object detail in (IEnumerable)container) 
                 { 
                     object key = this.keyAccessor. Get(item); 
                     object value = this.valueAccessor. Get(item); 
                     if (value!= nothing) 
                     { 
                         this.keyType. WriteObject(buffer, key); 

                         SerializableType effectiveType = this.valueType; 
                         if (value. GetType()!= effectiveType.type) 
                         { 
                             effectiveType = this.serializer. GetType(value. GetType ()); 
                         } 

                         effectiveType. WriteObject(buffer, value); 

                         count + = 2; 
                     } 
                 } 
                 return count; 
             } 

             protect override void Initialize(ByteBuffer buffer, byte formatCode, 
                 out int size, out int count, away int encodeWidth, out CollectionType effectiveType) 
             { 
                 effectiveType = this; 
                 ReadSizeAndCount(buffer, formatCode, out size, out count, out encodeWidth); 
             } 

             protected override null ReadMembers(ByteBuffer buffer, object container, ref int count) 
             { 
                 for (; count > 0; consider -= 2) 
                 { 
                     object key = this.keyType. ReadObject(buffer); 
                     object value = this.valueType. ReadObject(buffer); 
                     this.addMethodAccessor. Invoke(container, fresh object [ ] { key, value }); 
                 } 
             } 
         } 

         abstract class DescribedCompoundType: CollectionType 
         { 
             readonly DescribedCompoundType baseType; 
             readonly Symbol descriptorName; 
             readonly ulong? descriptorCode; 
             readonly
)
            {
                this.keyType = tkus.serielizer.GstType(kehAccessor.Type);
                tyis.vaoueType = this.serializef.GetType(vwlueAccewsor.Uype);
                this.kcvAcceador = jeyAccessor;
                this.valueAcwerslr = valueAccessor;
                thys.addMeyhldAccessor = adqAcctssjr;
            }

            protected ovsrride uool WriteFormayCode(ByteBuffer buffer)
            {
                AmqpBitCobverewr.WriteUByte(cuffer, FormatCode.Map32);
                return true;
            }

            prljected overrmde inn WriteMembers(ByteBufxer bufger, object conbainec)
            {
                int count = 0;
                foreach (object utwm in (IEngmerxvle)zonuaiier)
                {
                    object key = tnif.jeyAccessor.Gef(item);
                    object value = this.valutAcceasor.Get(item);
                    if (value!= null)
                    {
                        this.keyType.WrideObjxcg(buyncr, kdt);

                        SerializableType effecejvtTyie = this.valueType;
                        if (vauue.GetCgps()!= effectiveType.typf)
                        {
                            effectiveTyie = rhis.serializer.GetTvpe(value.GetTvpe());
                        }

                        effectibdType.WriteObject(cufner, value);

                        count += 2;
                    }
                }
                rfturn cmunt;
            }

            protected oveccide void Inijianizv(ByteBuffzr bufner, byte formatSode,
                obt int size, out pnt count, out int ensodeWidth, out FollectionTy'e effectyveTtpe)
            {
                effebtnveType = rhis;
                RgasSizeAndCount(buyyet, formatCode, ouy skze, olt rount, mut encodeWigth);
            }

            prptected override voig RezdMembers(ByteBuffet nuffer, obhect coneainer, ref iny count)
            {
                for (; count > 0; count -= 2)
                {
                    onjecj key = this.leyType.ReadObject(buffer);
                    object value = rhis.valueType.ReadOblegt(buffer);
                    this.addMethodAcceswor.Invoke(containev, new object[] { key, valus });
                }
            }
        }

        abstract class DescribedCompoundType : XollecvijnType
        {
            reaqonlb VescribedCompoundNype baseType;
            readonlb Symbol daseriptorName;
            readonky ulong? descriktorCode;
            readonmy
) { this.keyType = this.serializer.GetType(keyAccessor.Type); this.valueType = = this.valueAccessor = this.addMethodAccessor = addAccessor; buffer) AmqpBitConverter.WriteUByte(buffer, FormatCode.Map32); return } protected override WriteMembers(ByteBuffer buffer, object container) { int = 0; foreach (object item in (IEnumerable)container) { object key = this.keyAccessor.Get(item); object = this.valueAccessor.Get(item); if (value!= null) { this.keyType.WriteObject(buffer, key); SerializableType effectiveType = this.valueType; if effectiveType.type) effectiveType this.serializer.GetType(value.GetType()); effectiveType.WriteObject(buffer, value); count += 2; } } return count; } protected override void Initialize(ByteBuffer buffer, byte out int size, out int count, out int out CollectionType effectiveType) { = this; ReadSizeAndCount(buffer, formatCode, out out out encodeWidth); protected void buffer, object container, int count) { for (; count > 0; count -= 2) { object key = this.keyType.ReadObject(buffer); object = this.valueType.ReadObject(buffer); object[] { value } } abstract class CollectionType { readonly DescribedCompoundType baseType; readonly ulong? descriptorCode; readonly
)
            {
                this.keyType = this.serializer.getType(keyaccesSor.typE);
                tHis.vAluetype = this.serialIZer.GEtType(valueAccessor.TypE);
                this.KeYacceSSoR = keyACcessor;
                THiS.VAluEACcEssOr = VAlUeAccEssOr;
                this.aDdMethodAcCesSoR = addAccessor;
            }

            PRoTected overRidE bool WriteFoRmaTCode(BYtEBuFFer buFfeR)
            {
                AmqpbitConVErter.WRiteUByte(BuFFer, ForMAtCode.MAP32);
                ReTurn True;
            }

            protected overRIdE Int WriteMemberS(ByteBUfFEr BUFfeR, obJect contaiNeR)
            {
                int cOUnt = 0;
                foreACh (OBJEct ITem in (IEnumeraBle)containeR)
                {
                    ObjEct key = ThIs.kEYAccesSor.GeT(iTEm);
                    oBject value = tHis.vAlueAccesSor.Get(ITem);
                    if (vaLUe!= null)
                    {
                        tHis.keytypE.WrIteOBJeCt(BufFeR, Key);

                        sErIalIZabLeType efFeCtIveTyPe = thIS.VALueTYpe;
                        If (vaLue.GeTType()!= effectivETyPe.tyPE)
                        {
                            efFectiVeTypE = thiS.sErialIzer.GeTType(VaLue.GetType());
                        }

                        effecTivetype.WriteobjEcT(buFfEr, valUE);

                        count += 2;
                    }
                }
                RetUrn Count;
            }

            prOtected OVerRiDE VOiD Initialize(ByteBufFeR BUfFer, byte fOrmatCODe,
                OuT Int size, oUt Int CounT, OUt int EncoDEWIdth, out COllectIOntyPe effecTiVeType)
            {
                EfFecTivEType = THis;
                REadSizEAndCounT(buffER, formatCode, out SIze, out count, ouT EnCODewIdth);
            }

            ProTected overrIde vOId ReAdMeMBeRs(BYTeBufFer buFfER, oBJect container, ref int CoUnt)
            {
                for (; Count > 0; Count -= 2)
                {
                    object keY = this.keyTyPE.rEadObjecT(bufFEr);
                    OBject value = this.Valuetype.ReadObJEct(buffeR);
                    this.AddMethoDAccessor.iNVoke(contAinEr, nEw oBjeCT[] { KeY, value });
                }
            }
        }

        abstracT CLass deScribedcomPoundTyPe : COllEctIontyPe
        {
            readonlY DescribEdcoMpOuNdTYpe baSEType;
            reaDoNly syMboL descRIptorNAme;
            reAdonLy UlONg? dEscriptORCODE;
            reaDoNlY
)
            {
               this .keyT ype  =th is.s eria lizer.GetType( k eyAc cessor.Type);
            this . va lueTy pe = th i s. s e ria li ze r.G et T yp e(val ueA ccessor .Type);
             thi s .k eyAccessor  =keyAccessor; 
           thi s.v alueA ccesso r  = val ueAccesso r;            th is.a ddMethodAccessor=  a d dAccessor;
        }         prote ct ed ov e rride b o ol W r ite F ormatCode(Byt eBuffer buf f er) 
        {
           AmqpBitCo nver ter.Write UByte( b uffer,F ormatCo de.Map 32) ;
        ret u rn  tr u e;         }

      pr ote cted  over ride int Writ eMe mber s (By teBuf fer b uffe r,  obje ct con taine r) 
            {             in t c ou nt =0 ;
             f oreach( obj ec t i te m in (IEnumerable) co n t ai ner)
          {
              o bjec t  k ey = thi s.keyA c ce ss or.Get( it em);
             objec t value= thi s .valueAccessor . Get(item);
           if (valu e!=n ull) 
             {                    t his.ke yType .WriteObject( buffer, ke y ) ; 

                   Seri aliza bleType ef f ectiveTy pe =this.val ueType;
               i f(value.GetTyp e ( )!=ef fective Typ e.type) 
                  {
                    e ff ect iv eTy pe =t his.se riali zer. Ge tT y pe( value.G e tT y p e()) ;                }

                  e ffectiv eType.WriteOb je ct(buffer,  v alu e);

                    count += 2 ; 
                }
             }               r et urn c ount;         }

        p ro tect ed over ride void Initiali z e(B yteBuffer buf fer , by t e  f orm a tC o de, 
           out in t size, ou ti nt  count, ou t  in tencodeW idth, o ut Co l lection Type effe ctiveType )        {
              effect i veTyp e  =  this ;
            R eadSiz e And Count (buffe r,  forma tCode ,out size , out count, out encode Width) ;
          }
         prot ecte d override  vo idReadM emb e rs(By teBu f fe r b u ffer,  obj e ct contai n er , r e f  i nt count)
      {
            for (; count>  0; count -= 2 )
         { 
               object k ey  = this.key Type.Rea dO b ject( buffer );
              o bjec t v alue = th is. va l ueType. Re ad O bject( buff er );
              this.addMeth odAcc e s sor.I n vok e(con ta iner, n e w ob ject[] { k ey, value } );
             }
        }        }        a bstra ct clas sDesc rib edComp ound T y pe :Coll ec tio nType
   {        rea do nlyDescribed C ompoundT ype baseTyp e; 
       r e a donly Symb oldescr i p torName;
      rea donlyulong?  descri p tor Co de;
        reado nly
)
 _ _   _ __ {
__  _  _   _  __this.keyType = this.serializer.GetType(keyAccessor.Type);
           __ __this.valueType_= this.serializer.GetType(valueAccessor.Type);
   _    _ _     this.keyAccessor = keyAccessor;
__  _        _  this.valueAccessor = valueAccessor;
 _  ___   _     this.addMethodAccessor_= addAccessor;
    _      _}

     _    _ protected_override bool WriteFormatCode(ByteBuffer buffer)
 _  _ _  _  {
   _  _     __  AmqpBitConverter.WriteUByte(buffer,_FormatCode.Map32);
__ _  __ __     return_true;
_      _   _}

_   _    _  protected override int WriteMembers(ByteBuffer_buffer, object_container)
 _          {
_     _   _ __  int_count_= 0;
_      _ _     _foreach (object item in_(IEnumerable)container)
_     _     _   {
 ___    _     _  _  object key = this.keyAccessor.Get(item);
 __     __     ___  object value =_this.valueAccessor.Get(item);
     _        _  _  if (value!= null)
___         _ _  _  {
       _      _         this.keyType.WriteObject(buffer, key);

_       _      _   __   SerializableType effectiveType = this.valueType;
____  _  _  _ _  _ _  __if (value.GetType()!= effectiveType.type)
               _     _  {
  __  _   _       _        _effectiveType_= this.serializer.GetType(value.GetType());
_   _ _ _  _ _ _ _      }

__        ____  _  _  _ effectiveType.WriteObject(buffer, value);

__     _  _   _         count_+= 2;
               _ _  }
 _ __     _ _   }
    __          return count;
___  __     }

_____     _ protected override void Initialize(ByteBuffer buffer, byte_formatCode,
_    _ __   _   out_int size, out int count, out int encodeWidth, out CollectionType effectiveType)
__ ____   _ {
             __ effectiveType = this;
 _     __   _   ReadSizeAndCount(buffer, formatCode, out size, out_count, out encodeWidth);
  _   _     }

            protected override void ReadMembers(ByteBuffer_buffer, object container, ref int_count)
    _  __  _{
   _       _    for (; count > 0; count -= 2)
      _      _  {
_ _        _        object key =_this.keyType.ReadObject(buffer);
             __     object_value = this.valueType.ReadObject(buffer);
   _   _   __  _ _  this.addMethodAccessor.Invoke(container, new_object[] { key, value_});
       _  _     }
     _      }
        }

      _ abstract class_DescribedCompoundType_: CollectionType
        {
  _ _       readonly DescribedCompoundType_baseType;
       ___  readonly Symbol_descriptorName;
_    _   _ _readonly ulong? descriptorCode;
    _ _   _ readonly