Mappage des valeurs XML au type enum

J'ai besoin de parser un fichier XML que je reçois de tiers à des objets C#.
Certains des XML-je recevoir ont des valeurs d'une énumération qui je veux stocker dans un type enum.

Par exemple, j'ai le xsd suivant du fichier xml:

<xsd:simpleType name="brandstof">
  <xsd:restriction base="xsd:string">
    <!--  Benzine --> 
    <xsd:enumeration value="B" /> 
    <!--  Diesel --> 
    <xsd:enumeration value="D" /> 
    <!--  LPG/Gas --> 
    <xsd:enumeration value="L" /> 
    <!--  LPG G3 --> 
    <xsd:enumeration value="3" /> 
    <!--  Elektrisch --> 
    <xsd:enumeration value="E" /> 
    <!--  Hybride --> 
    <xsd:enumeration value="H" /> 
    <!--  Cryogeen --> 
    <xsd:enumeration value="C" /> 
    <!--  Overig --> 
    <xsd:enumeration value="O" /> 
  </xsd:restriction>
</xsd:simpleType>

Je veux cette carte à un enum, et j'ai reçu ce jour:

public enum Fuel
{
    B,
    D,
    L,
    E,
    H,
    C,
    O
}

Le problème que j'ai, c'est que le xml peut contenir une valeur de 3 qui je ne peux pas me mettre dans le type enum. Est-il une solution pour mettre cette valeur de l'enum.

Je peux aussi obtenir d'autres valeurs avec un - ou un / en eux et que je veux mettre dans un type enum.
Anu suggestions sont les bienvenues!

source d'informationauteur Gerard

  1. 15

    Vous pouvez analyser l'attribut xml valeur d'un type enum avec:

    var value = Enum.Parse(typeof(Fuel), "B");

    Mais je ne pense pas que vous aurez vraiment loin avec votre "spécial" des valeurs (3a/ etc.).
    Pourquoi ne pas vous définir votre énumération que

    enum Fuel
{
    Benzine,
    Diesel,
    //...
    Three,
    ASlash,
    //...
}

    Et écrire une méthode statique pour convertir une chaîne de caractères à un membre enum?

    Une chose que vous pouvez regarder dans pour la mise en œuvre d'une telle méthode serait d'ajouter des attributs personnalisés pour l'enum membres contenant leur représentation sous forme de chaîne - si une valeur n'a pas d'équivalent exact dans l'énumération, pour un look membre de l'attribut.

    La création d'un tel attribut est facile:

    ///<summary>
///Simple attribute class for storing String Values
///</summary>
public class StringValueAttribute : Attribute
{
    public string Value { get; private set; }

    public StringValueAttribute(string value)
    {
        Value = value;
    }
}

    Et puis vous pouvez les utiliser dans votre enum:

    enum Fuel
{
    [StringValue("B")]        
    Benzine,
    [StringValue("D")]
    Diesel,
    //...
    [StringValue("3")]
    Three,
    [StringValue("/")]
    Slash,
    //...
}

    Ces deux méthodes vont vous aider à analyser une chaîne de caractères dans un enum membre de votre choix:

        ///<summary>
    ///Parses the supplied enum and string value to find an associated enum value (case sensitive).
    ///</summary>
    public static object Parse(Type type, string stringValue)
    {
        return Parse(type, stringValue, false);
    }

    ///<summary>
    ///Parses the supplied enum and string value to find an associated enum value.
    ///</summary>
    public static object Parse(Type type, string stringValue, bool ignoreCase)
    {
        object output = null;
        string enumStringValue = null;

        if (!type.IsEnum)
        {
            throw new ArgumentException(String.Format("Supplied type must be an Enum.  Type was {0}", type));
        }

        //Look for our string value associated with fields in this enum
        foreach (FieldInfo fi in type.GetFields())
        {
            //Check for our custom attribute
            var attrs = fi.GetCustomAttributes(typeof (StringValueAttribute), false) as StringValueAttribute[];
            if (attrs != null && attrs.Length > 0)
            {
                enumStringValue = attrs[0].Value;
            }                       

            //Check for equality then select actual enum value.
            if (string.Compare(enumStringValue, stringValue, ignoreCase) == 0)
            {
                output = Enum.Parse(type, fi.Name);
                break;
            }
        }

        return output;
    }

    Et pendant que j'y suis: c'est l'inverse 😉

        ///<summary>
    ///Gets a string value for a particular enum value.
    ///</summary>
    public static string GetStringValue(Enum value)
    {
        string output = null;
        Type type = value.GetType();

        if (StringValues.ContainsKey(value))
        {
            output = ((StringValueAttribute) StringValues[value]).Value;
        }
        else
        {
            //Look for our 'StringValueAttribute' in the field's custom attributes
            FieldInfo fi = type.GetField(value.ToString());
            var attributes = fi.GetCustomAttributes(typeof(StringValueAttribute), false);
            if (attributes.Length > 0)
            {
                var attribute = (StringValueAttribute) attributes[0];
                StringValues.Add(value, attribute);
                output = attribute.Value;
            }

        }
        return output;

    }
  2. 13

    Décorer avec le XmlEnum attribut: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlenumattribute.aspx

    public enum Fuel
{
    [XmlEnum("B")]
    Benzine,
    [XmlEnum("D")]
    Diesel,
    [XmlEnum("L")]
    LpgGas,
    [XmlEnum("3")]
    LpgG3,
    [XmlEnum("E")]
    Elektrisch,
    [XmlEnum("H")]
    Hybride,
    [XmlEnum("C")]
    Cryogeen,
    [XmlEnum("O")]
    Overig
}
  3. 3

    Pourquoi ne pouvez-vous pas analyser la chaîne

    [XmlAttribute("brandstof")]
public string FuelTypeString
{
    get { return fuel.ToString(); }
    set
    {
        fuel = (Fuel)System.Enum.Parse(typeof(Fuel), value);
    }
}
[XmlIgnore()]
public Fuel FuelType
{
    get { return fuel; }
    set { fuel = value; }
}

    Si vous avez vraiment sérialiser comme une chaîne de caractères.

  4. 0

    J'ai créé une classe qui gère ce:

        class EnumCreator
    {
        public static Type CreateEnum(List<string> AValues)
        {
            //Get the current application domain for the current thread.
            AppDomain currentDomain = AppDomain.CurrentDomain;

            //Create a dynamic assembly in the current application domain, 
            //and allow it to be executed and saved to disk.
            AssemblyName aName = new AssemblyName("TempAssembly");
            AssemblyBuilder ab = currentDomain.DefineDynamicAssembly(
                aName, AssemblyBuilderAccess.RunAndSave);

            //Define a dynamic module in "TempAssembly" assembly. For a single-
            //module assembly, the module has the same name as the assembly.
            ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");      

            //Define a public enumeration with the name "Elevation" and an 
            //underlying type of Integer.
            EnumBuilder eb = mb.DefineEnum("EnumValues", TypeAttributes.Public, typeof(int));

            //Define two members, "High" and "Low".
            foreach (string v in AValues)
            {
                eb.DefineLiteral(v, AValues.IndexOf(v));
            }

            //Create the type and save the assembly.
            Type finished = eb.CreateType();

            return finished;
        }
    }

    Vous n'avez qu'à lire le fichier xml de la première et de mettre les valeurs dans une liste, vous pouvez le faire avec l'objet XElement par exemple.

    //Edit:
    Comme ceci:

    XElement xml = XElement.parse("file.xml");
List<string> enumItems = new List<string>();

foreach(XElement row in   xml.Element("xsd:simpleType").Element("xsd:restriction").Elements())
{
  enumItems.Add(row.Attribute("value").Value);
}

Type Fuel = EnumCreator.CreatEnum(enumItems);