Comment configurer une DataContract personnalisée sérialiseur ou XMLSerializer

Question

Im haveing ​​certains xml qui ont cette structure

<Person Id="*****" Name="*****"> 
    <AccessControlEntries> 
    <AccessControlEntry Id="*****" Name="****"/> 
    </AccessControlEntries> 
    <AccessControls /> 
    <IdentityGroups> 
    <IdentityGroup Id="****" Name="*****" /> 
    </IdentityGroups></Person> 

et j'ai aussi ces entités

[DataContract(IsReference = true)] 
public abstract class EntityBase 
{ 
    protected bool serializing; 

    [DataMember(Order = 1)] 
    [XmlAttribute()] 
    public string Id { get; set; } 

    [DataMember(Order = 2)] 
    [XmlAttribute()] 
    public string Name { get; set; } 

    [OnDeserializing()] 
    public void OnDeserializing(StreamingContext context) 
    { 
     this.Initialize(); 
    } 

    [OnSerializing()] 
    public void OnSerializing(StreamingContext context) 
    { 
     this.serializing = true; 
    } 

    [OnSerialized()] 
    public void OnSerialized(StreamingContext context) 
    { 
     this.serializing = false; 
    } 

    public abstract void Initialize(); 

    public string ToXml() 
    { 
     var settings = new System.Xml.XmlWriterSettings(); 
     settings.Indent = true; 
     settings.OmitXmlDeclaration = true; 

     var sb = new System.Text.StringBuilder(); 
     using (var writer = System.Xml.XmlWriter.Create(sb, settings)) 
     { 
      var serializer = new XmlSerializer(this.GetType()); 
      serializer.Serialize(writer, this); 
     } 

     return sb.ToString(); 
    } 
} 

[DataContract()] 
public abstract class Identity : EntityBase 
{ 
    private EntitySet<AccessControlEntry> accessControlEntries; 
    private EntitySet<IdentityGroup> identityGroups; 

    public Identity() 
    { 
     Initialize(); 
    } 

    [DataMember(Order = 3, EmitDefaultValue = false)] 
    [Association(Name = "AccessControlEntries")] 
    public EntitySet<AccessControlEntry> AccessControlEntries 
    { 
     get 
     { 
      if ((this.serializing && (this.accessControlEntries==null || this.accessControlEntries.HasLoadedOrAssignedValues == false))) 
      { 
       return null; 
      } 
      return accessControlEntries; 
     } 
     set 
     { 
      accessControlEntries.Assign(value); 
     } 
    } 

    [DataMember(Order = 4, EmitDefaultValue = false)] 
    [Association(Name = "IdentityGroups")] 
    public EntitySet<IdentityGroup> IdentityGroups 
    { 
     get 
     { 
      if ((this.serializing && (this.identityGroups == null || this.identityGroups.HasLoadedOrAssignedValues == false))) 
      { 
       return null; 
      } 
      return identityGroups; 
     } 

     set 
     { 
      identityGroups.Assign(value); 
     } 
    } 

    private void attach_accessControlEntry(AccessControlEntry entity) 
    { 
     entity.Identities.Add(this); 
    } 

    private void dettach_accessControlEntry(AccessControlEntry entity) 
    { 
     entity.Identities.Remove(this); 
    } 

    private void attach_IdentityGroup(IdentityGroup entity) 
    { 
     entity.MemberIdentites.Add(this); 
    } 

    private void dettach_IdentityGroup(IdentityGroup entity) 
    { 
     entity.MemberIdentites.Add(this); 
    } 

    public override void Initialize() 
    { 
     this.accessControlEntries = new EntitySet<AccessControlEntry>(
      new Action<AccessControlEntry>(this.attach_accessControlEntry), 
      new Action<AccessControlEntry>(this.dettach_accessControlEntry)); 
     this.identityGroups = new EntitySet<IdentityGroup>(
      new Action<IdentityGroup>(this.attach_IdentityGroup), 
      new Action<IdentityGroup>(this.dettach_IdentityGroup)); 
    } 
} 

[XmlType(TypeName = "AccessControlEntry")] 
public class AccessControlEntry : EntityBase, INotifyPropertyChanged 
{ 
    private EntitySet<Service> services; 
    private EntitySet<Identity> identities; 
    private EntitySet<Permission> permissions; 

    public AccessControlEntry() 
    { 
     services = new EntitySet<Service>(new Action<Service>(attach_Service), new Action<Service>(dettach_Service)); 
     identities = new EntitySet<Identity>(new Action<Identity>(attach_Identity), new Action<Identity>(dettach_Identity)); 
     permissions = new EntitySet<Permission>(new Action<Permission>(attach_Permission), new Action<Permission>(dettach_Permission)); 
    } 

    [DataMember(Order = 3, EmitDefaultValue = false)] 
    public EntitySet<Permission> Permissions 
    { 
     get { 
      if ((this.serializing && (this.permissions.HasLoadedOrAssignedValues == false))) 
      { 
       return null; 
      } 
      return permissions; 
     } 
     set 
     { 
      permissions.Assign(value); 
     } 
    } 

    [DataMember(Order = 4, EmitDefaultValue = false)] 
    public EntitySet<Identity> Identities 
    { 
     get 
     { 
      if ((this.serializing && (this.identities.HasLoadedOrAssignedValues == false))) 
      { 
       return null; 
      } 
      return identities; 
     } 
     set 
     { 
      identities.Assign(identities); 
     } 
    } 

    [DataMember(Order = 5, EmitDefaultValue = false)] 
    public EntitySet<Service> Services 
    { 
     get 
     { 
      if ((this.serializing && (this.services.HasLoadedOrAssignedValues == false))) 
      { 
       return null; 
      } 
      return services; 
     } 
     set 
     { 
      services.Assign(value); 
     } 
    } 

    private void attach_Permission(Permission entity) 
    { 
     entity.AccessControlEntires.Add(this); 
    } 
    private void dettach_Permission(Permission entity) 
    { 
     entity.AccessControlEntires.Remove(this); 
    } 

    private void attach_Identity(Identity entity) 
    { 
     entity.AccessControlEntries.Add(this); 
    } 
    private void dettach_Identity(Identity entity) 
    { 
     entity.AccessControlEntries.Remove(this); 
    } 

    private void attach_Service(Service entity) 
    { 
     entity.AccessControlEntries.Add(this); 
    } 
    private void dettach_Service(Service entity) 
    { 
     entity.AccessControlEntries.Remove(this); 
    } 

    #region INotifyPropertyChanged Members 

    public event PropertyChangedEventHandler PropertyChanged; 

    protected void OnPropertyChanged(string name) 
    { 
     PropertyChangedEventHandler handler = PropertyChanged; 
     if (handler != null) 
      handler(this, new PropertyChangedEventArgs(name)); 
    } 

    #endregion 

    public override void Initialize() 
    { 
     throw new NotImplementedException(); 
    } 
} 

[DataContract()] 
[XmlType(TypeName = "Person")] 
public class Person : Identity 
{ 
    private EntityRef<Login> login; 

    [DataMember(Order = 3)] 
    [XmlAttribute()] 
    public string Nombre { get; set; } 

    [DataMember(Order = 4)] 
    [XmlAttribute()] 
    public string Apellidos { get; set; } 

    [DataMember(Order = 5)] 
    public Login Login { 
     get 
     { 
      return login.Entity; 
     } 
     set 
     { 
      var previousValue = this.login.Entity; 
      if (((previousValue != value) || (this.login.HasLoadedOrAssignedValue == false))) 
      { 
       if ((previousValue != null)) 
       { 
        this.login.Entity = null; 
        previousValue.Person = null; 
       } 
       this.login.Entity = value; 

       if ((value != null)) 
        value.Person = this; 
      } 
     } 
    } 

    public override void Initialize() 
    { 
     base.Initialize(); 
    } 
} 

[DataContract()] 
[XmlType(TypeName = "Login")] 
public class Login : EntityBase 
{ 
    private EntityRef<Person> person; 

    [DataMember(Order = 3)] 
    public string UserID { get; set; } 

    [DataMember(Order = 4)] 
    public string Contrasena { get; set; } 

    [DataMember(Order = 5)] 
    public Domain Dominio 
    { 
     get; 
     set; 
    } 

    public Person Person 
    { 
     get 
     { 
      return person.Entity; 
     } 
     set 
     { 
      var previousValue = this.person.Entity; 
      if (((previousValue != value) || (this.person.HasLoadedOrAssignedValue == false))) 
      { 
       if ((previousValue != null)) 
       { 
        this.person.Entity = null; 
        previousValue.Login = null; 
       } 
       this.person.Entity = value; 

       if ((value != null)) 
        value.Login = this; 
      } 
     } 
    } 

    public override void Initialize() 
    { 
     throw new NotImplementedException(); 
    } 
} 

[DataContract()] 
[XmlType(TypeName = "IdentityGroup")] 
public class IdentityGroup : Identity 
{ 
    private EntitySet<Identity> memberIdentities; 

    public IdentityGroup() 
    { 
     Initialize(); 
    } 

    public override void Initialize() 
    { 
     this.memberIdentities = new EntitySet<Identity>(new Action<Identity>(this.attach_Identity), new Action<Identity>(this.dettach_Identity)); 
    } 

    [DataMember(Order = 3, EmitDefaultValue = false)] 
    [Association(Name = "MemberIdentities")] 
    public EntitySet<Identity> MemberIdentites 
    { 
     get 
     { 
      if ((this.serializing && (this.memberIdentities.HasLoadedOrAssignedValues == false))) 
      { 
       return null; 
      } 
      return memberIdentities; 
     } 
     set 
     { 
      memberIdentities.Assign(value); 
     } 
    } 

    private void attach_Identity(Identity entity) 
    { 
     entity.IdentityGroups.Add(this); 
    } 

    private void dettach_Identity(Identity entity) 
    { 
     entity.IdentityGroups.Remove(this); 
    } 
} 

[DataContract()] 
[XmlType(TypeName = "Group")] 
public class Group : Identity 
{ 
    public override void Initialize() 
    { 
     throw new NotImplementedException(); 
    } 
} 

mais quelque chose comme réponse ToXml() ce

<Person xmlns:xsi="************" xmlns:xsd="******" ID="******" Name="*****"/><AccessControlEntries/></Person> 

mais ce que je veux, c'est quelque chose comme ça

<Person Id="****" Name="***" Nombre="****"> 
    <AccessControlEntries/> 
    <IdentityGroups/> 
</Person> 

Answer 1

Essayez d'utiliser la méthode Serialize suivante:

var ns = new XmlSerializerNamespaces(); 
ns.Add("", ""); 
serializer.Serialize(writer, this, ns);