Désérialiser Xml avec des éléments vides en C #

Essayer de désérialisation xml snippits à partir d'un fournisseur en objets. Le problème c'est que je reçois un format non valide sur chaque balise d'élément vide. Je peux désérialiser l'objet d'aucun problème lorsque tous les éléments ont des valeurs. Ou les éléments vides sont omises.

Xml Snippit:

<foo>
<propOne>1</propOne>
<propTwo />
</foo>

De Classe C#:

[Serialilbe()]     
public class foo
{ 
   public foo(){}
   [XmlElementAttribute(IsNullable = true)]
   public int? propOne {get;set;} 
   [XmlElementAttribute(IsNullable = true)]
   public int? propTwo {get;set;}   
 }

Est-il un paramètre sur la classe que je peux faire pour régler l'analyse?
ou
Est-il un moyen facile je peux appliquer de xsl pour supprimer ces éléments?
ou
Dois-je utiliser des regEx pour supprimer les éléments vides avant desrializing?
ou
une meilleure façon de le faire?

source d'informationauteur Ryan Mrachek

  1. 11

    La plus uniforme de la façon de nettoyer ces nœuds semble être d'ajouter une RegEx filtre à l'deserializer. 

        public static T Deserialize<T>(string xml){
        XmlSerializer xs = new XmlSerializer(typeof(T));
        string cleanXml = Regex.Replace(xml, @"<[a-zA-Z].[^(><.)]+/>",
                                        new MatchEvaluator(RemoveText));
        MemoryStream memoryStream = new MemoryStream((new UTF8Encoding()).GetBytes(cleanXml));
        XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
        return (T)xs.Deserialize(memoryStream);
    }
      static string RemoveText(Match m) { return "";}
  2. 9

    Voir cet article: Peut XmlSerializer désérialiser dans un Nullable?

    En un mot votre Xml devrait ressembler à ceci si vous souhaitez utiliser les types Nullables:

    <foo xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
<propOne>1</propOne>
<propTwo xsi:nil='true'/>
</foo>

    Les deux modifications sont l'ajout de l'espace de noms, et de définir explicitement xsi:nil à vrai dans l'élément de valeur null.

    Si vous n'avez pas de contrôle sur votre Xml, il est plus avancé de la technique décrite ici: À l'aide de XmlSerializer pour désérialiser dans un Nullable

  3. 9

    Une autre option si vous n'avez pas eu de contrôle sur les entrées XML est de contourner ce problème en ayant la deserializer prétendre que la variable est une chaîne de caractères:

    [Serializable()]     
public class foo
{ 
  public foo(){}

  [XmlElement("propOne")]
  [EditorBrowsable(EditorBrowsableState.Never)]
  public string propOneString {get;set;}

  [XmlIgnore]
  private int? propOneInternal = null;
  [XmlIgnore]
  private bool propOneSet = false;

  [XmlIgnore]
  public int? propOne
  {
    get
    {
      if (!propOneSet)
      {
        if(!string.IsNullOrEmpty(propOneString)
        {
          propOneInternal = int.Parse(propOneString);
        }
        //else leave as pre-set default: null
        propOneSet = true;
      }
      return propOneInternal;
    }
    set { propOneInternal = value; }
  }
}

    La Deserialiser est heureux pour analyser un élément de chaîne quand elle est vide, donc vous l'utiliser.

    Il n'est pas particulièrement beau, mais il va faire si vous avez seulement un ou 2 balises pour couvrir

  4. 0

    Pour des raisons de simplicité, pourquoi ne pas vous parse le xml explicitement à l'aide de XmlDocument et XPath? Utiliser XPath pour explicitement l'accès de chaque nœud xml par exemple

    XmlNode node = xml.SelectSingleNode ("foo/PropOne");
if (node != null)
{
     propOneValue = node.innerText;
}