Comment stocker une référence à un entier en C#?

Question

Possible en double:
How do I assign by “reference” to a class field in c#?

Bonjour à tous - me dire comment faire ce travail? Fondamentalement, je besoin d'un type de référence entier (int * travaillerait en C++)

class Bar 
{ 
    private ref int m_ref;  // This doesn't exist 

    public A(ref int val) 
    { 
     m_ref = val; 
    } 

    public void AddOne() 
    { 
     m_ref++; 
    } 
} 

class Program 
{ 
    static void main() 
    { 
     int foo = 7; 
     Bar b = new Bar(ref foo); 
     b.AddOne(); 
     Console.WriteLine(foo); // This should print '8' 
    } 
} 

Dois-je utiliser la boxe?

Modifier: Peut-être que j'aurais dû être plus précis. J'écris une classe BitAccessor, qui permet simplement d'accéder à des bits individuels. Voici mon utilisation souhaitée:

class MyGlorifiedInt 
{ 
    private int m_val; 
    ... 
    public BitAccessor Bits { 
     return new BitAccessor(m_val); 
    } 
} 

Utilisation:

MyGlorifiedInt val = new MyGlorifiedInt(7); 
val.Bits[0] = false;  // Bits gets a new BitAccessor 
Console.WriteLine(val); // outputs 6 

Pour BitAccessor pour pouvoir modifier m_val, il a besoin d'une référence. Mais je veux utiliser ce BitAccessor de nombreux endroits, avec juste une référence à l'entier désiré.

Answer 1

Vous ne pouvez pas stocker une référence à un entier comme celui-ci directement, mais peut stocker une référence à l'objet GlorifiedInt le contenant. Dans votre cas, ce que je ferais probablement est de rendre la classe BitAccessor imbriquée à l'intérieur de GlorifiedInt (afin qu'elle ait accès aux champs privés), puis de lui passer une référence à this quand elle est créée, qu'elle peut alors utiliser pour accéder au m_val champ. Voici un exemple qui fait ce que vous cherchez:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var g = new GlorifiedInt(7); 
     g.Bits[0] = false; 
     Console.WriteLine(g.Value); // prints "6" 
    } 
} 

class GlorifiedInt 
{ 
    private int m_val; 

    public GlorifiedInt(int value) 
    { 
     m_val = value; 
    } 

    public int Value 
    { 
     get { return m_val; } 
    } 

    public BitAccessor Bits 
    { 
     get { return new BitAccessor(this); } 
    } 

    public class BitAccessor 
    { 
     private GlorifiedInt gi; 

     public BitAccessor(GlorifiedInt glorified) 
     { 
      gi = glorified; 
     } 

     public bool this[int index] 
     { 
      get 
      { 
       if (index < 0 || index > 31) 
        throw new IndexOutOfRangeException("BitAcessor"); 
       return (1 & (gi.m_val >> index)) == 1; 
      } 
      set 
      { 
       if (index < 0 || index > 31) 
        throw new IndexOutOfRangeException("BitAcessor"); 
       if (value) 
        gi.m_val |= 1 << index; 
       else 
        gi.m_val &= ~(1 << index); 
      } 
    } 
    } 
} 

Answer 2

Vous n'avez pas besoin d'avoir une référence à un entier - il suffit de mettre votre entier dans un type de référence - ce qui est presque ce que vous avez déjà fait. Il suffit de changer cette ligne:

Console.WriteLine(foo); 

à:

Console.WriteLine(bar.Value); 

Ensuite, ajoutez un accesseur correspondant à la classe Bar et supprimer les erreurs de compilation (supprimer les mots-clés ref).

Une approche alternative est de passer l'entier à une fonction par référence:

static void AddOne(ref int i) 
{ 
    i++; 
} 

static void Main() 
{ 
    int foo = 7; 
    AddOne(ref foo); 
    Console.WriteLine(foo); 
} 

Sortie:

8 

Answer 3

Vous ne précisaient pas que vous étiez contre le code dangereux, donc cela devrait fonctionner: Je n'ai jamais utilisé de pointeurs en C#, mais cela semble fonctionner. Je ne suis pas sûr de ce que les effets secondaires possibles sont.

Answer 4

Cela ne répond pas directement à votre question, mais pouvez-vous pas seulement utiliser la classe System.Collections.BitArray?

Vous vous demandez simplement si vous «réinventez la roue»?