En C #, comment cartographier facilement les drapeaux Enum d'un type à un autre?

Je ne sais pas pourquoi vous devez faire cela, car il semble que vous ayez vraiment besoin d'une énumération.

S'il est prudent de supposer que les valeurs numériques des valeurs "équivalentes" enum sont toujours identiques, alors la question réelle est "la valeur fournie a-t-elle des" drapeaux "qui ne font pas partie de l'énumération cible" . Une façon de le faire serait de boucler toutes les valeurs possibles pour l'énumération cible. Si la FLAS est définie, alors Xor de la valeur. Si la valeur! = 0 à la fin de la boucle, il ne peut pas être converti.

Si cela peut être converti, alors jetez la valeur sur un int, puis sur le nouveau type.

ps. Ai-je mentionné qu'il est étrange de faire cela en premier lieu?

Le dictionnaire générique est implémenté comme une haperttable, par conséquent, la complexité de l'algorithme est O (1). Donc, si Enum plutôt grand, c'est un moyen le plus rapide.

édité: strong> Pour clarifier ... suppose que vous avez plusieurs délégués qui déclare la règle de conversion, où l'un d'entre eux est par défaut (SA-> DA), Name: défaut_délégate. P>

class MyMapper
{
    delegate DestEnum singlemap(SourceEnum);
    static Dictionary<SourceEnum, singlemap> _source2dest = 
       new Dictionary<SourceEnum, singlemap>();
    static MyMapper()
    {
         //place there non-default conversion
         _source2dest[S_xxxx] = My_delegate_to_cast_S_xxxx;
         ......
    }
    static singlemap MapDelegate(SourceEnum se)
    {
        singlemap retval;
        //checking has complexity O(1)
        if(_source2dest.TryGetValue ( se, out retval) )
            return retval;
        return default_delegate;
    }

Si les valeurs de votre Enums sont logiquement équivalentes, vous pouvez simplement lancer une enum à l'autre, par exemple

public DestEnum Map(SourceEnum source) {
    return (DestEnum)SourceEnum;
}

  public ReturnEnum ConvertEnum<InEnum, ReturnEnum>(InEnum fromEnum)
  {
     ReturnEnum ret = (ReturnEnum)Enum.ToObject(typeof(ReturnEnum), fromEnum);
     if (Enum.IsDefined(typeof(ReturnEnum), ret))
     {
        return ret;
     }
     else
     {
        throw new Exception("Nope"); // TODO: Create more informative error here
     }
  }

Je pense que quelque chose le long de ces lignes fonctionnerait, en supposant que les noms des énums suivent un modèle similaire:

DestEnum de = DestEnum.DNone;
        SourceEnum se = SourceEnum.SA;
        Dictionary<int, int> maps = new Dictionary<int, int>();
        maps.Add((int)SourceEnum.SNone, (int)DestEnum.DNone);
        maps.Add((int)SourceEnum.SAB, (int)(DestEnum.DA | DestEnum.DB));
        maps.Add((int)SourceEnum.SA, (int)DestEnum.DA);
        de = (DestEnum)maps[(int)se];

Voici une solution qui prend simplement un dictionnaire de mappages et effectue une cartographie en balayant dessus. Malheureusement, System.Enum ne peut pas être utilisé comme contrainte générique, donc j'ai construit la solution à l'aide d'une classe dérivée spécifique qui gère la coulée.

Notez que le constructeur de Flagmapper prend des paires de drapeaux simples qui correspondent à l'autre. Il peut également cartographier plusieurs bits sur plusieurs bits aussi longtemps que vous vous assurez que les mappages sont tous cohérents. Si tous les bits du premier élément de la paire sont allumés dans la source Enum, les bits du deuxième élément de la paire seront définis dans l'énum de destination. P>

la cartographie pour SLLA Il ne fonctionne actuellement pas parce que dans mon constructeur, je n'ai pas cartographié les bits d'ordre supérieur. Je n'ai pas fait cette cartographie car il est un peu incompatible avec l'obligation que la cartographie de SD échoue. P>

using System;
using System.Collections.Generic;

namespace Flags
{
    [Flags]
    enum SourceEnum
    {
        SNone = 0x00,

        SA = 0x01,
        SB = 0x02,
        SC = 0x04,
        SD = 0x08,

        SAB = SA | SB,

        SALL = -1,
    }

    [Flags]
    enum DestEnum
    {
        DNone = 0x00,

        DA = 0x01,
        DB = 0x02,
        DC = 0x04,

        DALL = 0xFF,
    }

    class FlagMapper
    {
        protected Dictionary<int, int> mForwardMapping;

        protected FlagMapper(Dictionary<int, int> mappings)
        {
            this.mForwardMapping = mappings;
        }

        protected int Map(int a)
        {
            int result = 0;

            foreach (KeyValuePair<int, int> mapping in this.mForwardMapping)
            {
                if ((a & mapping.Key) == mapping.Key)
                {
                    if (mapping.Value < 0)
                    {
                        throw new Exception("Cannot map");
                    }

                    result |= mapping.Value;
                }
            }

            return result;
        }
    }

    class SourceDestMapper : FlagMapper
    {
        public SourceDestMapper()
            : base(new Dictionary<int, int>
            {
                { (int)SourceEnum.SA, (int)DestEnum.DA },
                { (int)SourceEnum.SB, (int)DestEnum.DB },
                { (int)SourceEnum.SC, (int)DestEnum.DC },
                { (int)SourceEnum.SD, -1 }
            })
        {
        }

        public DestEnum Map(SourceEnum source)
        {
            return (DestEnum)this.Map((int)source);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            SourceDestMapper mapper = new SourceDestMapper();

            Console.WriteLine(mapper.Map(SourceEnum.SA));
            Console.WriteLine(mapper.Map(SourceEnum.SA | SourceEnum.SB));
            Console.WriteLine(mapper.Map(SourceEnum.SAB));

            //Console.WriteLine(mapper.Map(SourceEnum.SALL));

            Console.WriteLine(mapper.Map(SourceEnum.SD));
        }
    }
}