/// <summary>
        ///
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="entity"></param>
        /// <param name="rootElementName"></param>
        /// <param name="declareRootType">Indica si debe resgitrar el tipo del objeto como atributo del elemento Root. Si es true, lo registra si no hay un alias definido, sino, no lo registra.</param>
        public virtual void Serialize(XmlTextWriter writer, object entity, string rootElementName)
        {
            if (entity == null)
            {
                return;
            }

            Type type = entity.GetType();

            if (!type.IsSerializable)
            {
                throw new SerializationException("The entity " + type.Name + " is not marked as serializable.");
            }

            XmlSerializerContext context = this.CreateContext();
            object         holder        = this.CreateObjectHolder(type, entity);
            TypeDescriptor holderDesc    = new TypeDescriptor(holder.GetType());

            PropertyDescriptor   desc = holderDesc.Properties[0];
            RootPropertyMetadata metadata;

            if (string.IsNullOrEmpty(rootElementName))
            {
                rootElementName = this.GetElementName(type, context);
                metadata        = new RootPropertyMetadata(rootElementName, desc.Metadata.DefaultAttributeName, desc.Metadata);
            }
            else
            {
                context.RegisterAlias(rootElementName, entity.GetType());
                metadata = new RootPropertyMetadata(rootElementName, desc.Metadata.DefaultAttributeName, desc.Metadata);
            }

            desc.Metadata = metadata;
            desc.UseAlias = true;

            //podria agregar la instancia a serializa y tener un seguimiento de la secuencia.....pero para mas adelante
            this.Context = context;
            IXmlConverter converter = context.GetConverter(type);

            converter.ToXml(holder, desc, entity, writer, context);
        }
        public virtual object Deserialize(Type rootType, string rootElementName, XmlReader reader)
        {
            using (reader)
            {
                XmlNodeType typeNode = reader.MoveToContent();
                if (typeNode == XmlNodeType.Element || typeNode == XmlNodeType.EndElement)
                {
                    XmlSerializerContext context = this.CreateContext();

                    Type type = context.GetTypeFromAttribute(reader);
                    if (type == null)
                    {
                        type = context.GetTypeFromAlias(reader.LocalName);
                    }

                    if (type == null)
                    {
                        if (rootType != null)
                        {
                            type = rootType;
                        }
                        else
                        {
                            throw new Exception("No es posible obtener tipo del objeto a deserializar cuyo nombre de elemento raíz es " + reader.LocalName);
                        }
                    }

                    object         holder     = this.CreateObjectHolder(type, null);
                    TypeDescriptor holderDesc = new TypeDescriptor(holder.GetType());
                    if (holderDesc.Properties.Count == 0)
                    {
                        throw new SerializationException("The type is not marked as serializable.");
                    }

                    PropertyDescriptor desc = holderDesc.Properties[0];

                    RootPropertyMetadata metadata;

                    if (string.IsNullOrEmpty(rootElementName))
                    {
                        rootElementName = this.GetElementName(type, context);
                    }

                    metadata = new RootPropertyMetadata(rootElementName, desc.Metadata.DefaultAttributeName, desc.Metadata);

                    desc.Metadata = metadata;
                    desc.UseAlias = true;

                    this.Context = context;
                    IXmlConverter converter = context.GetConverter(type);

                    object output = converter.FromXml(holder, desc, type, reader, context);

                    return(output);
                }
                else
                {
                    return(null);
                }
            }
        }