Les références à des variables en C#?

En C++, je peux faire quelque chose comme ceci:

int i[10] = new int[10];
int *p = &i[5];

Puis, je peux toujours savoir que p pointe vers le 5ème élément de tableau int i, quelle que soit j'ai du contenu.

Est-il possible de faire la même chose en C#?

Je réalise que c'est probablement l'une des façons dont C# "protège" nous de nous-mêmes, donc je ne suis pas à la recherche d'une exacte equivelent, mais plutôt un concept similaire... c'est à dire être capable de se référer au contenu d'une autre variable, plutôt que de l'instance de la variable elle-même.

Voici mon cas d'utilisation je suis en train de penser. J'ai un tableau de chaînes de caractères. Je voudrais avoir un autre tableau de références à ces éléments du tableau. Quelque chose comme ceci (évidemment pas de code valide):

string[] s = new string[] { "one", "two", "three", "four", "five", "six" };
stringref[] sr = new stringref[] { &s[0], &s[1], &s[2], &s[3], &s[4], &s[5] };

Console.WriteLine(sr[1]); //== "two"
s[1] = "two point zero";
Console.WriteLine(sr[1]); //== "two point zero"

Certainement, ref paramets ce faire, et les paramètres de sortie vous permettent d'écrire à une variable spécifique. Mais qu'en non-paramètres? Pouvez-vous garder une ref? Pouvez-vous garder un tableau de références ou d'un dictionnaire?

Il semble comme si la capacité à le faire avec des paramètres est présent, il doit être un moyen de le faire sans eux.

Votre question semble confondre les références avec les pointeurs, et utilise plutôt la confusion des termes tels que "le contenu" d'une variable et la variable "lui-même". int *p = &i[5] attribue le adresse de la cinquième élément du tableau i à la variable p, qui est déclaré comme un pointeur vers un int. Les références ne sont pas les mêmes que les pointeurs. Je ne suis pas sûr au sujet de C#, mais à partir d'un C++ perspective, il n'est pas clair ce que vous demandez.
Je pense que c'est assez clair, car tout le monde a compris de quoi je parlais. Les références en C++ sont plus ou moins la même chose que les pointeurs, sauf que vous ne pouvez pas faire des maths ou de la ré-assigner. Peu importe, c# références ne sont pas les mêmes qu'en C++ références, et C# n'a pas de notion de pointeurs (lorsque vous n'utilisez pas le code unsafe), de sorte que les références sont ce que vous pouvez utiliser en C# depuis il n'y a rien d'autre. Aussi, j'ai dit "l'instance de la variable elle-même".

OriginalL'auteur Erik Funkenbusch | 2009-09-14

  1. 18

    Pas. Mettre unsafe code de côté, qui ne permet pas la tenue de pointeurs vers des emplacements de mémoire, il n'y a aucun moyen de stocker une référence à une variable en C#.

    ref et out arguments sont le seul moyen de prendre une référence, mais vous ne pouvez pas enregistrer de n'importe où.

    Vous pouvez contourner cette limitation en enveloppant les champs dans un class et à l'aide de sa référence à la place. C'est ce que le compilateur ne à la capture de variables dans les bouchons:

    Par exemple, lorsque vous écrivez:

    int integer = 0;
Action<int> method = i => Console.WriteLine(i + integer);
integer = 42;
method(100); //prints 142, not 100

    Dans la deuxième ligne, le compilateur va devoir prendre la méthode anonyme et de le stocker en tant que distincte de la méthode dans la classe. Évidemment, cette méthode n'ont pas accès à integer variable. De toute façon il faut passer une "référence" à integer variable pour que la méthode anonyme. Puisqu'il n'est pas possible, il va générer un class avec un champ de tenir un entier et utilise une instance de cette classe pour stocker la variable. Fondamentalement, la variable locale est promu à un champ dans une classe et est stocké dans le tas.

    C'est très intéressant et me donne quelques idées. Merci.

    OriginalL'auteur Mehrdad Afshari

  2. 6

    Lecture seule référence de tableau:

    class ArrayRef<T>
{
   private T[] array;
   private int index;

   public ArrayRef(T[] array, int index)
   {
      this.array = array;
      this.index = index;
   }

   public static implicit operator T(ArrayRef self)
   {
      return self.array[self.index];
   }
}

var s = new string[] { "one", "two", "three", "four", "five", "six" };
var sr = new ArrayRef<string>[] { new ArrayRef<string>(s, 0), new ArrayRef<string>(s, 1), new ArrayRef<string>(s, 2), new ArrayRef<string>(s, 3), new ArrayRef<string>(s, 4), new ArrayRef<string>(s, 5) };

Console.WriteLine(sr[1]); //== "two"
s[1] = "two point zero";
Console.WriteLine(sr[1]); //== "two point zero"
    J'avais pensé à quelque chose le long de ces lignes, mais c'est jamais assez gélifié dans mon esprit. Cela me donne quelques idées, avec Mehrdad de réponse.

    OriginalL'auteur dalle

  3. 2

    En code managé références sont utilisées à la place des pointeurs, comme le garbage collector peut déplacer des objets en mémoire à tout moment.

    Une référence à quelque chose qu'il a à être l'objet, de sorte que vous ne pouvez pas avoir des références pour les éléments individuels d'un tableau d'entiers. Comme des chaînes de caractères sont des objets, vous pouvez avoir des références pour les différentes cordes en copiant simplement les références dans le tableau:

    string[] s = new string[] { "one", "two", "three", "four", "five", "six" };
string[] sr = new string[] { s[0], s[1], s[2], s[3], s[4], s[5] };

    Cependant, comme les chaînes de caractères sont des objets immuables vous pouvez uniquement utiliser les références pour lire les articles. Si vous affectez une chaîne de référence dans le rp tableau, vous permettra de remplacer la référence au lieu de changer l'objet vers lequel il pointe.

    Si vous souhaitez modifier les objets, vous devrez avoir mutable objets. Par exemple:

    StringBuilder[] s = new StringBuilder[] {
   new StringBuilder("one"),
   new StringBuilder("two"),
   new StringBuilder("three"),
};
StringBuilder[] sr = new StringBuilder[] { s[0], s[1], s[2] };

Console.WriteLine(s[1]); //== "two"
sr[1].Append(" point zero");
Console.WriteLine(s[1]); //== "two point zero"
    Oui, c'est une façon intéressante de le résoudre. Pas tout à fait ce que j'avais à l'esprit, mais une solution possible.
    "Pour avoir une référence à quelque chose qu'il a à être l'objet, de sorte que vous ne pouvez pas avoir des références pour les éléments individuels d'un tableau d'entiers'. Qui n'est tout simplement pas vrai sur deux niveaux.
    De quelle manière pensez-vous que ce n'est pas vrai?
    ref var x = ref arr[3]; // c'est tout bon, même dans l'ancienne syntaxe, vous étiez en mesure de passer 'arr[3]" de la fonction par la réf.

    OriginalL'auteur Guffa

  4. 0

    Si quelqu'un est à la recherche de solution possible.
    En jouant un peu avec les génériques, il est possible si vous enveloppez chaque tableau en classe de sorte qu'il peut être affecté à une autre instance de la même envelopper par la classe de référencement de tableau.

    Mais cela doit être utilisé uniquement comme une preuve de concept qu'il est possible de le faire.
    En général, je ne recommandons pas l'utilisation de cette, mais il propose la refonte du code de manière plus efficace. Aussi, sa vaut la peine de mentionner que vous simplement pouvez affecter tableau à un autre tableau comme référence pour l'un de ses éléments (DOH).

    Cela étant dit, voici l'exemple de code de référence générique de tableau de tableau de données:

    using System;
using System.Diagnostics;
public class RefArray<TElem>
{
TElem[] data;
///<summary>Initializes RefArray by creating Ref&lt;T>[]data from values.</summary>
public RefArray(TElem[] values)
{
data = values;
}
///<summary>Creates reference RefArray pointing to same RefArray&lt;T> data.</summary>
public RefArray(RefArray<TElem> references)
{
this.data = references.data;
}
public int Length
{
get { return data.Length; }
}
public TElem this[int index]
{
get
{
return data[index];
}
set
{
data[index] = value;
}
}
}
public static class RefArrayTest
{
public static void Usage()
{
//test ints (struct type)
RefArray<int> c = new RefArray<int>(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
RefArray<int> d = new RefArray<int>(c);
Debug.Print(string.Format("c[3]: {0,-30}, d[3]: {1}", c[3], d[3]));
c[3] = 1111;
Debug.Print(string.Format("c[3]: {0,-30}, d[3]: {1}", c[3], d[3]));
d[3] = 2222;
Debug.Print(string.Format("c[3]: {0,-30}, d[3]: {1}", c[3], d[3]));
d[3] = c[3] + 3333;
Debug.Print(string.Format("c[3]: {0,-30}, d[3]: {1}", c[3], d[3]));
//test strings (class type)
RefArray<string> a = new RefArray<string>(new string[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
RefArray<string> b = new RefArray<string>(a);
Debug.Print(string.Format("a[3]: {0,-30}, b[3]: {1}", a[3], b[3]));
a[3] = "set a";
Debug.Print(string.Format("a[3]: {0,-30}, b[3]: {1}", a[3], b[3]));
b[3] = "set b";
Debug.Print(string.Format("a[3]: {0,-30}, b[3]: {1}", a[3], b[3]));
a[3] = b[3] + " + take b set a";
Debug.Print(string.Format("a[3]: {0,-30}, b[3]: {1}", a[3], b[3]));
//proof of no point since
string[] n1 = new string[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
string[] n2 = n1;
Debug.Print(string.Format("n1[3]: {0,-30}, n2[3]: {1}", n1[3], n2[3]));
n1[3] = "set n1";
Debug.Print(string.Format("n1[3]: {0,-30}, n2[3]: {1}", n1[3], n2[3]));
n2[3] = "set n2";
Debug.Print(string.Format("n1[3]: {0,-30}, n2[3]: {1}", n1[3], n2[3]));
n1[3] = n2[3] + " + take n2 set n1";
Debug.Print(string.Format("n1[3]: {0,-30}, n2[3]: {1}", n1[3], n2[3]));
}
}

    Aussi si référencé éléments doivent être hors de vue vous pouvez ajouter générique Ref_T classe à enrouler chaque valeur de référence:

    using System;
using System.Text;
using System.Diagnostics;
public class Ref_T<TValue>
{  
public TValue data;
public Ref_T(TValue value)
{
this.data = value;
}
}
public class RefArray<TElem>
{
public readonly Ref_T<TElem>[] data;
///<summary>Initializes RefArray by creating Ref&lt;T>[]data from values.</summary>
public RefArray(TElem[] values)
{
data = new Ref_T<TElem>[values.Length];
for (int i = 0; i < values.Length; i++)
{
//creates reference members
data[i] = new Ref_T<TElem>(values[i]); 
}
}
///<summary>Creates reference RefArray pointing to same RefArray&lt;T> data.</summary>
public RefArray(RefArray<TElem> references)
{
data = references.data;
}
///<summary>Creates reference RefArray pointing to same Ref&lt;T>[] references.</summary>
public RefArray(Ref_T<TElem>[] references)
{
data = references;
}
public int Length
{
get { return data.Length; }
}
public TElem this[int index]
{
get { return data[index].data; }
set { data[index].data = value; }
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
int count = data.Length;
for (int i = 0; i < count; i++ )
sb.Append(string.Format("[{0}]:{1,-4}, ", i, data[i].data));
return sb.ToString();
}
public static implicit operator Array(RefArray<TElem> a)
{
return a.data;
}
}
public static class RefArrayTest
{
public static void Usage()
{    
//test ints (struct type) out of order
//initialize 
RefArray<int> e = new RefArray<int>(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
//reference e out of order
RefArray<int> f = new RefArray<int>(new Ref_T<int>[] 
{ e.data[8], e.data[6], e.data[4], e.data[2], e.data[0], 
e.data[9], e.data[7], e.data[5], e.data[3], e.data[1] 
});
Debug.WriteLine("Initial: ");
Debug.WriteLine("e: [" + e + "]");
Debug.WriteLine("f: [" + f + "]\r\n");
e[3] = 1111;
Debug.WriteLine("e[3] = 1111;");
Debug.WriteLine("e: [" + e + "]");
Debug.WriteLine("f: [" + f + "]\r\n");
f[3] = 2222;
Debug.WriteLine("f[3] = 2222;");
Debug.WriteLine("e: [" + e + "]");
Debug.WriteLine("f: [" + f + "]\r\n");
f[3] = e[3] + 3333;
Debug.WriteLine("f[3] = e[3] + 3333;");
Debug.WriteLine("e: [" + e + "]");
Debug.WriteLine("f: [" + f + "]\r\n");
Array.Reverse(f);
Debug.WriteLine("Array.Reverse(f);");
Debug.WriteLine("e: [" + e + "]");
Debug.WriteLine("f: [" + f + "]\r\n");
}
}

    sorties:

    Initial: 
e: [[0]:0   , [1]:1   , [2]:2   , [3]:3   , [4]:4   , [5]:5   , [6]:6   , [7]:7   , [8]:8   , [9]:9   , ]
f: [[0]:8   , [1]:6   , [2]:4   , [3]:2   , [4]:0   , [5]:9   , [6]:7   , [7]:5   , [8]:3   , [9]:1   , ]
e[3] = 1111;
e: [[0]:0   , [1]:1   , [2]:2   , [3]:1111, [4]:4   , [5]:5   , [6]:6   , [7]:7   , [8]:8   , [9]:9   , ]
f: [[0]:8   , [1]:6   , [2]:4   , [3]:2   , [4]:0   , [5]:9   , [6]:7   , [7]:5   , [8]:1111, [9]:1   , ]
f[3] = 2222;
e: [[0]:0   , [1]:1   , [2]:2222, [3]:1111, [4]:4   , [5]:5   , [6]:6   , [7]:7   , [8]:8   , [9]:9   , ]
f: [[0]:8   , [1]:6   , [2]:4   , [3]:2222, [4]:0   , [5]:9   , [6]:7   , [7]:5   , [8]:1111, [9]:1   , ]
f[3] = e[3] + 3333;
e: [[0]:0   , [1]:1   , [2]:4444, [3]:1111, [4]:4   , [5]:5   , [6]:6   , [7]:7   , [8]:8   , [9]:9   , ]
f: [[0]:8   , [1]:6   , [2]:4   , [3]:4444, [4]:0   , [5]:9   , [6]:7   , [7]:5   , [8]:1111, [9]:1   , ]
Array.Reverse(f);
e: [[0]:0   , [1]:1   , [2]:4444, [3]:1111, [4]:4   , [5]:5   , [6]:6   , [7]:7   , [8]:8   , [9]:9   , ]
f: [[0]:1   , [1]:1111, [2]:5   , [3]:7   , [4]:9   , [5]:0   , [6]:4444, [7]:4   , [8]:6   , [9]:8   , ]

    Espère que cela aide quelqu'un.

    OriginalL'auteur SoLaR

  5. 0

    Il est possible de réaliser cela à l'aide de délégués. Aujourd'hui, il ne nécessite même pas beaucoup de code:

    int i[10] = new int[10];
int *p = &i[5];

    devient:

    int[] i = new int[10];
Func<int> p = () => i[5];

    effectuer p() renvoie toujours le 6ème élément d'indice (5, 0).

    Nous pouvons également ajouter un peu de sucre:

    public class Reference<T>
{
private readonly Func<T> referenceFunc;
public Reference(Func<T> referenceFunc)
{
this.referenceFunc = referenceFunc;
}
public T Value => this.referenceFunc();
public static implicit operator T(Reference<T> reference)
{
return reference.Value;
}
public static implicit operator Reference<T>(Func<T> referenceFunc)
{
return new Reference<T>(referenceFunc);
}
public override string ToString()
{
return this.Value?.ToString();
}
}
public static class ReferenceExtensions
{
public static void Add<T>(
this ICollection<Reference<T>> collection,
Func<T> referenceFunc)
{
collection.Add(referenceFunc);
}
}

    Appliqué à votre exemple:

    string[] s = new string[] { "one", "two", "three", "four", "five", "six" };
IReadOnlyList<Reference<string>> sr = new List<Reference<string>>
{
() => s[0],   
() => s[1],
() => s[2],
() => s[3],
() => s[4],
() => s[5],
};
Console.WriteLine(sr[1]); //== "two"
s[1] = "two point zero";
Console.WriteLine(sr[1]); //== "two point zero"

    .Net Violon

    Remarque: bien sûr, dans l'exemple où vous avez une sauvegarde de tableau/liste/de la collection, il serait juste assez pour stocker l'index au lieu d'un Func<T>. Peut-être plus rapide. Aussi certains de la liste des implémentations, comme LinkedList<T>, permettent d'accéder à la structure de la liste.
    (Coupant les cheveux en quatre: Puis de nouveau le tableau lui-même est une "liste" de références et donc s[1] et sr[1] devrait être équivalente, sr donc totalement superflu dans l'exemple).

    OriginalL'auteur BatteryBackupUnit

  6. -1

    Je soupçonne que vous vous posez la mauvaise question...

    Considérer le code C# suivant:

    MyClass[] arr = new MyClass[] { MyClass(1), MyClass(2) .... };
MyClass obj = arr[5];

    Dans ce cas, obj est référence au même objet que arr[5], puisque les deux arr[5] et obj sont des références.

    La question avec l'exemple de code que vous avez fourni a été que quand vous écrivez "s[1] = "deux point zéro"", vous n'êtes pas en train de changer la chaîne de caractères en mémoire, vous faites référence, dans le tableau, pointez sur une autre chaîne. Fondamentalement, votre code C# est équivalent à celui-ci dans C:

    char **s = malloc( ... );
... set s's members
char *sr = malloc( ... );
sr[1] = s1;
s[1] = "two point zero";
//now, s[1] is "two point zero" while sr[1] is still "one"
    Non, je pose la question correcte. Votre point est exactement ce que je cherche à éviter. Un objet de points de référence à une instance de données, pas l'emplacement des données.
    Mais c'EST l'emplacement des données. Le tableau de chaîne est juste l'emplacement de la référence...
    Non, vous n'êtes toujours pas la compréhension. Je vous suggère de relire ma question, et les réponses qui leur ont été donnés. Vous me dites quelque chose que je connais déjà. Je sais obj fait référence au même objet. Je suis à la recherche d'un moyen de PAS se référer à l'instance réelle de l'objet, mais de la référence elle-même, de la même manière que les paramètres de ref de travail.

    OriginalL'auteur Tal Pressman