C# alternatywa do wyliczenia dla relacji n: m

Question

Istnieje kilka wątków na zakresach wartości w wyliczeniach (nie jest to możliwe). Ale mam następujący problem i szukam najlepszego rozwiązania, w którym żaden z podanych mi produktów naprawdę mnie nie zadowalał.

Specyfikacja protokółu mówi, że bajt [x] z komunikatu, typu komunikatu, posiada następujące możliwe wartości (wartości Fantasy):

0x00 = get 
0x01 = set 
0x02 to 0xFF = identify 

więc istnieje tylko 3 Warianty logicznych, co najlepiej radzić sobie w wyliczaniu. Ale jedna z n opcji logicznych ma m różne odpowiedniki numeryczne, których nie można rozpatrywać w wyliczeniu.

Jakie jest najlepsze (najczystsze) rozwiązanie tego problemu? mógłbym zbudować klasę

class MessageType { 
    public enum MessageTypeEnum { 
     get = 0x00, 
     set = 0x01, 
     identify = 0x02 
    } 

    public static MessageTypeEnum getLogicalValue (byte numericalValue) 
    { 
     if (numericalValue < 0x02) 
      return (MessageTypeEnum(numericalValue)); 
     else 
      return MessageTypeEnum.identify; 
    } 
} 

mogę również utworzyć klasę bez wyliczenia, ale z członków statycznych.

czy inaczej jest jeden problem: Jeśli ktoś próbuje wysyła pakiet, może on wykorzystać

if (messageBytes[x] == (byte)MessageTypeEnum.identify) { 
    // do stuff 
} 

Ale messageByte [x] może być coś między 0x02 a 0xFF, więc „trafienia” wartość podaną w enum byłoby czystym szczęściem. Z drugiej strony chcę, aby enum (lub statyczny członek) był jawny dla łatwego budowania wiadomości.

Czy mogę w jakiś sposób wymusić użycie mojej funkcji getLogicalValue()? Czy istnieje bardziej eleganckie rozwiązanie?

Wszystko, czego chcę, to łatwy i dobrze zorganizowany sposób łączenia wartości logicznych z wartościami liczbowymi w relacji n: m. Szczególnie, że dany protokół ma wiele takich przypadków i chciałabym zachować porządek w swoim kodzie.

Dzięki za pomoc i czasu :)

Janis

Answer 1

Polecam, aby zrezygnować z używania wyliczeń i utworzyć niestandardowy typ dla tego.

Może to być zarówno struct, jak i class; to nie ma znaczenia. Można rozwiązać problem równości przez przeciążenie operatora == i zapewnienie niestandardowej implementacji.

coś takiego:

public class MessageType 
{ 
    private readonly byte value; 
    private MessageType(byte value) 
    { 
     this.value = value; 
    } 

    public static readonly MessageType Get = new MessageType(0); 
    public static readonly MessageType Set = new MessageType(1); 
    public static readonly MessageType Identify = new MessageType(2); 


    public static bool operator ==(MessageType m, byte b) 
    { 
     if (object.ReferenceEquals(m, null)) 
      return false; 

     if (m.value == 2 && b >= 2 && b <= 0xff)//I think <= check is redundant 
      return true; 
     return m.value == b; 
    } 

    public static bool operator !=(MessageType m, byte b) 
    { 
     return !(m == b); 
    } 
    //Need to implement Equals, GetHashCode etc 
} 

Nie zapomnij wdrożyć Equals i GetHashCode dla spójności w realizację równa.

Answer 2

Właściwie chciałbym użyć wartości enum jako identyfikatory, a nie tylko jako rzeczywiste wartości. Coś takiego:

class MessageType { 
    public enum MessageTypeEnum { 
     get, 
     set, 
     identify 
    } 

    public static MessageTypeEnum getLogicalValue (byte numericalValue) 
    { 
     if (numericalValue == 0x00) 
      return MessageTypeEnum.get; 
     else if (numericalValue == 0x01) 
      return MessageTypeEnum.set; 
     else 
      return MessageTypeEnum.identify; 
    } 
} 

i używać go w ten sposób:

if (MessageType.getLogicalValue(messageBytes[x]) == MessageTypeEnum.identify) { 
    // do stuff 
} 

Można oczywiście użyć switch zamiast if... else if..., to zależy od osobistych preferencji i potrzeb.

Jak stwierdzono w innej odpowiedzi, jeśli chcesz użyć bezpośredniego porównania, musisz utworzyć niestandardową klasę i zaimplementować porównanie równości z potrzebnymi.

Answer 3

można byłaby podpis metody i wykonaj następujące czynności i powie to, które enum wg nazwy to faktycznie przekazując w wyglądzie wartości w sposób po prostu refactored dla ciebie i jak nazywają go poniżej

public static string getLogicalValue(byte numericalValue) 
{ 
    Type type = numericalValue.GetType(); 
    var name = Enum.GetName(typeof(MessageTypeEnum), numericalValue); 
    if (numericalValue < 0x02) 
     return name; 
    else 
     return MessageTypeEnum.identify.ToString(); 
} 

Wywołanie metody statycznej jak ten

var enumValue = getLogicalValue(0x02); 

ciąg powrót będzie identify lub jeśli chcesz zrobić oświadczenie switch/case można wykonać następujące czynności oraz

public static string getLogicalValue(byte numericalValue) 
    { 
     Type type = numericalValue.GetType(); 
     var name = Enum.GetName(typeof(MessageTypeEnum), numericalValue); 
     switch(numericalValue) 
     { 
      case 0x00: 
       { 
        name= (MessageTypeEnum.get.ToString()); 
        break; 
       } 
      case 0x01: 
       { 
        name= (MessageTypeEnum.set.ToString()); 
        break; 
       } 

      default: 
       { 
        name= (MessageTypeEnum.identify.ToString()); 
        break; 
       } 
     } 
     return name; 
    }