Union C++ en C#

Question

Je suis en train de traduire une bibliothèque écrite en C++ en C#, et le mot clé "union" n'existe qu'une fois. Dans un struct.

Quelle est la manière correcte de le traduire en C# ? Et que fait-il ? Cela ressemble à quelque chose comme ceci ;

struct Foo {
    float bar;

    union {
        int killroy;
        float fubar;
    } as;
}

Answer 1

Vous pouvez utiliser des modèles de champs explicites pour cela :

[StructLayout(LayoutKind.Explicit)] 
public struct SampleUnion
{
    [FieldOffset(0)] public float bar;
    [FieldOffset(4)] public int killroy;
    [FieldOffset(4)] public float fubar;
}

Non testé. L'idée est que deux variables ont la même position dans votre structure. Vous ne pouvez bien sûr utiliser qu'une seule d'entre elles.

Plus d'informations sur les syndicats en Tutoriel sur les structures

Answer 2

Vous ne pouvez pas vraiment décider de la manière de traiter cette question sans savoir comment elle est utilisée. S'il est simplement utilisé pour gagner de l'espace, vous pouvez l'ignorer et vous contenter d'utiliser un struct.

Toutefois, ce n'est généralement pas la raison pour laquelle les syndicats sont utilisés. Il existe deux raisons courantes de les utiliser. La première est de fournir deux ou plusieurs façons d'accéder aux mêmes données. Par exemple, l'union d'un int et d'un tableau de 4 octets est l'une des nombreuses façons de séparer les octets d'un entier de 32 bits.

L'autre cas est celui où les données de la structure proviennent d'une source externe, comme un paquet de données réseau. En général, l'un des éléments de la structure qui contient l'union est un ID qui vous indique quel type d'union est en vigueur.

Dans aucun de ces cas, vous ne pouvez ignorer aveuglément l'union et la convertir en une structure où les deux champs (ou plus) ne coïncident pas.

Answer 3

En C/C++, l'union est utilisée pour superposer différents membres dans le même emplacement mémoire. Ainsi, si vous avez une union d'un int et d'un float, ils utilisent tous deux les mêmes 4 octets de mémoire pour être stockés, et il est évident que l'écriture dans l'un corrompt l'autre (puisque int et float ont une disposition de bits différente).

Dans .Net, Microsoft a opté pour le choix le plus sûr et n'a pas inclus cette fonctionnalité.

EDIT : sauf pour l'interop

Answer 4

Personnellement, je ne tiendrais pas compte de l'UNION et j'implémenterais Killroy et Fubar comme des champs séparés.

public struct Foo
{
    float bar;
    int Kilroy;
    float Fubar;
}

L'utilisation d'une UNION permet d'économiser 32 bits de mémoire allouée par l'adresse int...., ce qui ne va pas faire ou défaire une application de nos jours.

Answer 5

Voici une tentative pour contenir plusieurs messages complexes (simplifiés ici) dans une Union. Les messages sont mutuellement exclusifs, nous n'en avons qu'un seul disponible à la fois, voire aucun. J'aborde ici la forme conceptuelle de l'union, pas la forme technique (binaire) qui est abordée par d'autres messages dans cette page.

   public class Msg1 {
      public int v;
   }

   public class Msg2 {
      public double v;
   }

   public class Msg3 {
      public string v;
   }

   public class Union {

      public enum selector_t {
         NONE,
         MSG1,
         MSG2,
         MSG3,
      }

      private selector_t _selector;
      private Object     _value;

      public Union() {
         reset();
      }

      public Union( Msg1 value ) {
         set( value );
      }

      public Union( Msg2 value ) {
         set( value );
      }

      public Union( Msg3 value ) {
         set( value );
      }

      private void set( selector_t selector, Object value ) {
         _selector = selector;
         _value    = value;
      }

      public selector_t getSelector() {
         return _selector;
      }

      public bool isNone() {
         return _selector == selector_t.NONE;
      }

      public bool isMsg1() {
         return _selector == selector_t.MSG1;
      }

      public bool isMsg2() {
         return _selector == selector_t.MSG2;
      }

      public bool isMsg3() {
         return _selector == selector_t.MSG3;
      }

      public void reset() {
         set( selector_t.NONE, null );
      }

      public void set( Msg1 value ) {
         set( selector_t.MSG1, value );
      }

      public void set( Msg2 value ) {
         set( selector_t.MSG2, value );
      }

      public void set( Msg3 value ) {
         set( selector_t.MSG3, value );
      }

      public Msg1 getMsg1() {
         return (Msg1)_value;
      }

      public Msg2 getMsg2() {
         return (Msg2)_value;
      }

      public Msg3 getMsg3() {
         return (Msg3)_value;
      }
   }

   class Program {
      static void Main(string[] args) {
         Union u = new Union( new Msg2());
         Console.WriteLine( "isMsg1: " + u.isMsg1());
         Console.WriteLine( "isMsg2: " + u.isMsg2());
         Console.WriteLine( "isMsg3: " + u.isMsg3());
         Console.WriteLine( "getMsg2: " + u.getMsg2());
         try {
            Console.WriteLine( "getMsg3: " + u.getMsg3());
         }
         catch( InvalidCastException x ) {
            Console.WriteLine(x);
         }
         u.set( new Msg3());
         try {
            Console.WriteLine( "getMsg3: " + u.getMsg3());
         }
         catch( InvalidCastException x ) {
            Console.WriteLine(x);
         }
      }
   }

Journal d'exécution :

isMsg1: False
isMsg2: True
isMsg3: False
getMsg2: Union.Msg2
System.InvalidCastException: Impossible d'effectuer un cast d'un objet de type 'Union.Msg2' en type 'Union.Msg3'.
   à Union.Union.getMsg3() dans f:\dev\C#\2014\Union\Program.cs:ligne 99
   à Union.Program.Main(String[] args) dans f:\dev\C#\2014\Union\Program.cs:ligne 111
getMsg3: Union.Msg3

El System.InvalidCastException est attendu, car nous tentons d'utiliser un Msg2 como Msg3 .