protected override XmlElement WriteChild (ObjectWriter writer, Widget wrapper)
		{
			if (writer.Format == FileFormat.Glade || Type == ButtonType.Custom)
				return base.WriteChild (writer, wrapper);
			else
				return null;
		}

		protected override XmlElement WriteChild (ObjectWriter writer, Widget wrapper)
		{
			XmlElement child_elem = base.WriteChild (writer, wrapper);
			if (tabs.Contains (wrapper.Wrapped))
				GladeUtils.SetChildProperty (child_elem, "type", "tab");
			return child_elem;
		}

            public override void WriteTo(Encoding encoding, ObjectWriter writer, CancellationToken cancellationToken)
            {
                if (encoding == null)
                {
                    base.WriteTo(encoding, writer, cancellationToken);
                    return;
                }

                cancellationToken.ThrowIfCancellationRequested();

                writer.WriteByte(EncodingSerialization);

                byte[] value;
                if (!s_encodingCache.TryGetValue(encoding, out value))
                {
                    // we don't have cache, cache it
                    var formatter = new BinaryFormatter();
                    using (var stream = SerializableBytes.CreateWritableStream())
                    {
                        // unfortunately, this is only way to properly clone encoding
                        formatter.Serialize(stream, encoding);
                        value = stream.ToArray();

                        // add if not already exist. otherwise, noop
                        s_encodingCache.TryAdd(encoding, value);
                    }
                }

                // write data out
                writer.WriteValue(value);
            }

		protected override XmlElement WriteChild (ObjectWriter writer, Widget wrapper)
		{
			XmlElement child_elem = base.WriteChild (writer, wrapper);
			if (wrapper.Wrapped == expander.LabelWidget)
				GladeUtils.SetChildProperty (child_elem, "type", "label_item");
			return child_elem;
		}

 /// <exception cref="System.Exception"></exception>
 public virtual void TestStringFragment()
 {
     string fragment = "01234567890";
     ObjectWriter mapper = new ObjectWriter();
     byte[] json = mapper.WriteValueAsBytes(fragment);
     JsonDocument jsdoc = new JsonDocument(json);
     NUnit.Framework.Assert.AreEqual(fragment, jsdoc.JsonObject());
 }

		protected override XmlElement WriteProperties (ObjectWriter writer)
		{
			XmlElement elem = base.WriteProperties (writer);
			string group = GroupManager.GladeGroupName (Wrapped);
			if (group != Wrapped.Name)
				GladeUtils.SetProperty (elem, "group", group);
			return elem;
		}

 public void Write(ObjectWriter writer)
 {
     writer.PrimitiveWriter.Write(Name);
     writer.PrimitiveWriter.Write(Version);
     writer.PrimitiveWriter.Write(CultureName);
     writer.PrimitiveWriter.Write((byte)Token.Length);
     writer.PrimitiveWriter.Write(Token);
 }

        static void Main(string[] args)
        {
            IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Loopback, 4040);
            Socket ss = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            var productos = new ObservableCollection<Producto>();
            for (int i = 0; i < 20; i++)
            {
                productos.Add(new Producto()
                {
                    ProductId = i,
                    Nombre = "Producto servidor" + i,
                    Precio = (decimal)i,
                    CantidadDisponible = i * 10,
                    Descripcion = "The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list. Usually it is best to"
                });
            }

            try
            {
                ss.Bind(localEndPoint);
                ss.Listen(10);
                while (true)
                {
                    Console.WriteLine("Servidor escuchando por conexiones");
                    Socket cliente = ss.Accept();
                    string descCliente = cliente.LocalEndPoint.ToString();
                    Console.WriteLine("Conexion aceptada " + descCliente);
                    ObjectWriter w = new ObjectWriter(cliente);
                    ObjectReader r = new ObjectReader(cliente);

                    Transacciones transaccion = (Transacciones)r.ReadInt32();
                    switch (transaccion)
                    {
                        case Transacciones.SolicitarCarrito:
                            Console.WriteLine("\tSolicitud de carrito por: " + descCliente);
                            w.WriteInt32(productos.Count);
                            for (int i = 0; i < productos.Count; i++)
                            {
                                w.WriteObject<Producto>(productos[i]);
                            }
                            break;
                        case Transacciones.RealizarCompra:
                            Console.WriteLine("\tOrden de compra de " + descCliente);
                            Orden o = r.ReadObject<Orden>();
                            productos[o.ProductId].CantidadDisponible -= o.Cantidad;
                            break;
                    }
                    Console.WriteLine("Conexion terminada " + descCliente);
                    cliente.Shutdown(SocketShutdown.Both);
                    cliente.Close();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

		protected override XmlElement WriteProperties (ObjectWriter writer)
		{
			XmlElement elem = base.WriteProperties (writer);
			if (menuInfo != null)
				elem.AppendChild (writer.XmlDocument.ImportNode (menuInfo, true));
			else
				elem.AppendChild (actionTree.Write (writer.XmlDocument, writer.Format));
			return elem;
		}

		public override XmlElement Write (ObjectWriter writer)
		{
			XmlElement group = writer.XmlDocument.CreateElement ("action-group");
			group.SetAttribute ("name", name);
			if (writer.CreateUndoInfo)
				group.SetAttribute ("undoId", UndoId);
			foreach (Action ac in actions) {
				if (ac.Name.Length > 0)
					group.AppendChild (writer.WriteObject (ac));
			}
			return group;
		}

 private object Load(XamlXmlReader reader)
 {
     XamlObjectWriter writer = new ObjectWriter();
     while (reader.Read())
     {
         writer.WriteNode(reader);
     }
     writer.Close();
     reader.Close();
     if (writer.Result is DependencyObject && !(writer is INameScope))
         ((DependencyObject)writer.Result).SetValue(NameScope.NameScopeProperty, writer.RootNameScope);
     return writer.Result;
 }

 /// <exception cref="System.Exception"></exception>
 public virtual void TestJsonArray()
 {
     IList<object> array = new AList<object>();
     array.AddItem("01234567890");
     array.AddItem("bar");
     array.AddItem(5);
     array.AddItem(3.5);
     array.AddItem(true);
     array.AddItem(new DateTime().ToString());
     ObjectWriter mapper = new ObjectWriter();
     byte[] json = mapper.WriteValueAsBytes(array);
     JsonDocument jsdoc = new JsonDocument(json);
     NUnit.Framework.Assert.AreEqual(array, jsdoc.JsonObject());
 }

 /// <exception cref="System.Exception"></exception>
 public virtual void TestJsonObject()
 {
     IDictionary<string, object> dict = new Dictionary<string, object>();
     dict.Put("id", "01234567890");
     dict.Put("foo", "bar");
     dict.Put("int", 5);
     dict.Put("double", 3.5);
     dict.Put("bool", true);
     dict.Put("date", new DateTime().ToString());
     ObjectWriter mapper = new ObjectWriter();
     byte[] json = mapper.WriteValueAsBytes(dict);
     JsonDocument jsdoc = new JsonDocument(json);
     NUnit.Framework.Assert.AreEqual(dict, jsdoc.JsonObject());
 }

 // create the same JSON encoding used by TouchDB
 // this lets us test comparisons as they would be encoded
 public virtual string Encode(object obj)
 {
     ObjectWriter mapper = new ObjectWriter();
     try
     {
         byte[] bytes = mapper.WriteValueAsBytes(obj);
         string result = Sharpen.Runtime.GetStringForBytes(bytes);
         return result;
     }
     catch (Exception e)
     {
         Log.E(Tag, "Error encoding JSON", e);
         return null;
     }
 }

        public int RealizaCompra(int productId, int cantidad)
        {
            IPEndPoint remotePoint = new IPEndPoint(IPAddress.Loopback, 4040);
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            s.Connect(remotePoint);
            ObjectReader r = new ObjectReader(s);
            ObjectWriter w = new ObjectWriter(s);

            w.WriteInt32((int)Transacciones.RealizarCompra);
            Orden o = new Orden { ProductId = productId, Cantidad = cantidad };
            w.WriteObject<Orden>(o);
            s.Shutdown(SocketShutdown.Both);
            s.Close();
            return 1;
        }

        public void ShouldHandleTwoWritesAndReads()
        {
            var strings = new [] { "One", "Two" };

            var stream = new MemoryStream();
            var writer = new ObjectWriter(stream);
            writer.WriteObject(strings[0]);
            writer.WriteObject(strings[1]);
            var position = stream.Position;

            stream.Seek(0, SeekOrigin.Begin);
            var reader = new ObjectReader(stream);
            Assert.AreEqual(strings[0], reader.ReadObject<string>());
            Assert.AreEqual(strings[1], reader.ReadObject<string>());
            Assert.AreEqual(position, stream.Position);
        }

        public void Write(ObjectWriter writer)
        {
            writer.TouchAndWriteTypeId(UnderlyingMethod.ReflectedType);

            var methodParameters = UnderlyingMethod.GetParameters();
            if(UnderlyingMethod.IsGenericMethod)
            {
                var genericDefinition = UnderlyingMethod.GetGenericMethodDefinition();
                var genericArguments = UnderlyingMethod.GetGenericArguments();
                var genericMethodParamters = genericDefinition.GetParameters();

                writer.PrimitiveWriter.Write(genericDefinition.Name);
                writer.PrimitiveWriter.Write(genericArguments.Length);
                for(int i = 0; i < genericArguments.Length; i++)
                {
                    writer.TouchAndWriteTypeId(genericArguments[i]);
                }

                writer.PrimitiveWriter.Write(genericMethodParamters.Length);
                for(int i = 0; i < genericMethodParamters.Length; i++)
                {
                    writer.PrimitiveWriter.Write(genericMethodParamters[i].ParameterType.IsGenericParameter);
                    if(genericMethodParamters[i].ParameterType.IsGenericParameter)
                    {
                        writer.PrimitiveWriter.Write(genericMethodParamters[i].ParameterType.GenericParameterPosition);
                    }
                    else
                    {
                        writer.TouchAndWriteTypeId(methodParameters[i].ParameterType);
                    }
                }
            }
            else
            {
                writer.PrimitiveWriter.Write(UnderlyingMethod.Name);
                writer.PrimitiveWriter.Write(0); // no generic arguments
                writer.PrimitiveWriter.Write(methodParameters.Length);

                foreach(var p in methodParameters)
                {
                    writer.TouchAndWriteTypeId(p.ParameterType);
                }
            }
        }

        public void ShouldHandleTwoWritesAndReads()
        {
            var strings = new [] { "One", "Two" };

            var stream = new MemoryStream();
            var writer = new ObjectWriter(stream, Serializer.GetReflectionBasedWriteMethods());
            writer.WriteObject(strings[0]);
            writer.WriteObject(strings[1]);
            writer.Flush();
            var position = stream.Position;

            stream.Seek(0, SeekOrigin.Begin);
            var reader = new ObjectReader(stream, Serializer.GetReflectionBasedReadMethods(false));
            Assert.AreEqual(strings[0], reader.ReadObject<string>());
            Assert.AreEqual(strings[1], reader.ReadObject<string>());
            reader.Flush();

            Assert.AreEqual(position, stream.Position);
        }

		protected override XmlElement WriteProperties (ObjectWriter writer)
		{
			XmlElement elem = base.WriteProperties (writer);
			if (type != ButtonType.StockItem && imageInfo != null) {
				if (writer.Format == FileFormat.Glade) {
					switch (imageInfo.Source) {
						case ImageSource.File:
							GladeUtils.SetProperty (elem, "icon", imageInfo.Name);
							break;
						case ImageSource.Theme:
							GladeUtils.SetProperty (elem, "stock_id", imageInfo.Name);
							break;
						default:
							throw new System.NotSupportedException ("Image source not supported by Glade.");
					}
				}
			}
			return elem;
		}

        public void ShouldHandleTwoWritesAndReads()
        {
            var strings = new [] { "One", "Two" };

            var typeIndices = new List<Type>
            {
                typeof(string)
            };
            var stream = new MemoryStream();
            var writer = new ObjectWriter(stream, typeIndices);
            writer.WriteObject(strings[0]);
            writer.WriteObject(strings[1]);
            var position = stream.Position;

            stream.Seek(0, SeekOrigin.Begin);
            var types = typeIndices.ToArray();
            var reader = new ObjectReader(stream, types, false);
            Assert.AreEqual(strings[0], reader.ReadObject<string>());
            Assert.AreEqual(strings[1], reader.ReadObject<string>());
            Assert.AreEqual(position, stream.Position);
        }