Werte zuweisen von Array zu trennen Variablen in einer Zeile

Question

Kann ich jeden Wert in einem Array zuweisen, um Variablen in einer Zeile in C # zu trennen? Hier ist ein Beispiel in Ruby-Code von dem, was ich will:

irb(main):001:0> str1, str2 = ["hey", "now"]
=> ["hey", "now"]
irb(main):002:0> str1
=> "hey"
irb(main):003:0> str2
=> "now"

Ich bin nicht sicher, ob das, was ich will in C # möglich.

Edit: für das, was darauf hindeutet, ich zuweisen nur die Saiten „hey“ und „jetzt“ zu Variablen, das ist nicht das, was ich will. Stellen Sie sich vor wie folgt vor:

irb(main):004:0> val1, val2 = get_two_values()
=> ["hey", "now"]
irb(main):005:0> val1
=> "hey"
irb(main):006:0> val2
=> "now"

Nun ist die Tatsache, dass die Methode get_two_values Strings zurückgegeben „hey“ und „jetzt“ ist willkürlich. In der Tat könnte es zwei beliebige Werte zurückgeben, sie haben nicht einmal Strings sein.

Answer 1

Dies ist in C # nicht möglich.

Das nächste, was ich denken kann, ist die Initialisierung in der gleichen Zeile mit indexs zu verwenden

strArr = new string[]{"foo","bar"};
string str1 = strArr[0], str2 = strArr[1];

Answer 2

Update: In C # 7 Sie können leicht mehrere Variablen auf einmal mit Tupeln zuzuordnen. Um Array-Elemente Variablen zuweisen, müssen Sie eine geeigneten Deconstruct() Erweiterungsmethoden schreiben:

  

Eine andere Möglichkeit Tupeln zu konsumieren ist, sie zu dekonstruieren. Eine Dekonstruktion   Erklärung ist eine Syntax zum Spalten eines Tupels (oder einem anderen Wert) in   seine Teile und die Teile einzeln an den frischen Variablen zuweisen:

(string first, string middle, string last) = LookupName(id1); // deconstructing declaration
WriteLine($"found {first} {last}.");

     

In einer Dekonstruktion Erklärung Sie var für den einzelnen verwenden können   Variablen deklariert:

(var first, var middle, var last) = LookupName(id1); // var inside

     

oder legen auch nur einen einzigen var außerhalb der Klammern als   Abkürzung:

var (first, middle, last) = LookupName(id1); // var outside

     

Sie können auch dekonstruieren in bestehende Variablen mit einer Dekonstruktion   Zuordnung:

(first, middle, last) = LookupName(id2); // deconstructing assignment

     

Dekonstruktion ist nicht nur für Tupel. Jede Art kann dekonstruiert,   solange es ein (instance oder Erweiterung) hat Dekonstruktor Verfahren   die Form:

public void Deconstruct(out T1 x1, ..., out Tn xn) { ... }

     

Die out-Parameter bilden die Werte, die aus dem Ergebnis   Dekonstruktion.

     

(Warum verwenden Sie es Parameter, anstatt ein Tupel von der Rückkehr? Das ist   so dass können Sie mehrere Überlastungen für unterschiedliche Zahlen von   Werte).

class Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y) { X = x; Y = y; }
    public void Deconstruct(out int x, out int y) { x = X; y = Y; }
}

(var myX, var myY) = GetPoint(); // calls Deconstruct(out myX, out myY);

     

Es wird ein gemeinsames Muster seines Konstrukteuren und deconstructors zu haben sein   „Symmetrisch“ auf diese Weise.    https: // blogs. msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/

---

Alt Antwort:

In der Tat können Sie eine ähnliche Funktionalität in C # erreichen durch die Verwendung Erweiterungsmethoden wie diese (Anmerkung: Ich habe nicht enthalten zu überprüfen, ob Argumente gültig sind):

public static void Match<T>(this IList<T> collection, Action<T,T> block)
{
    block(collection[0], collection[1]);
}
public static void Match<T>(this IList<T> collection, Action<T,T,T> block)
{
    block(collection[0], collection[1], collection[2]);
}
//...

Und man kann sie wie folgt verwendet werden:

new[] { "hey", "now" }.Match((str1, str2) =>
{
    Console.WriteLine(str1);
    Console.WriteLine(str2);
});

Wenn ein Rückgabewert einer Funktion benötigt wird, würde die folgende Überlast arbeiten:

public static R Match<T,R>(this IList<T> collection, Func<T, T, R> block)
{
    return block(collection[0], collection[1]);
}

private string NewMethod1()
{   
    return new[] { "hey", "now" }.Match((str1, str2) =>
    {
        return str1 + str2;
    });
}

Auf diese Weise:

• Sie vermeiden, dass Array-Namen zu wiederholen, wie in Lösung von JaredPar und anderen vorgeschlagen; die Liste der "Variablen" ist leicht zu lesen.

• Sie vermeiden, explizit auf Variablen-Typen wie in Daniel Earwicker Lösung zu erklären.

Der Nachteil ist, dass Du mit zusätzlichem Codeblock am Ende, aber ich denke, es lohnt sich. Sie können Code-Schnipsel verwenden, um zu vermeiden Eingabe Klammern usw. manuell.

Ich weiß, es ist ein 7 Jahre alte Frage, aber nicht so lange her, brauchte ich eine solche Lösung - einfache Namen zu Array-Elementen bestanden in den Verfahren geben (nein, mit Klassen / Strukturen anstelle von Arrays war nicht praktikabel, weil für gleiche Arrays konnte ich verschiedene Elementnamen in verschiedenen Methoden) benötigen, und leider hatte ich am Ende Code wie folgt auf:

var A = points[0];
var A2 = points[1];
var B = points[2];
var C2 = points[3];
var C = points[4];

Jetzt kann ich schreiben (in der Tat, ich habe jetzt eine dieser Methoden Refactoring!):

points.Match((A, A2, B, C2, C) => {...});

---

Meine Lösung ist ähnlich Mustervergleich in F # und ich war von dieser Antwort inspiriert: https://stackoverflow.com / a / 2321922/6659843

Answer 3

Der reale Anwendungsfall dafür bietet eine bequeme Möglichkeit, mehrere Werte aus einer Funktion zurückzukehren. So ist es eine Ruby-Funktion, die eine feste Anzahl von Werten in dem Array zurückgibt, und der Anrufer will, dass sie in zwei separate Variablen. Hier wird die Funktion am meisten Sinn macht:

first_name, last_name = get_info() // always returns an array of length 2

Um auszudrücken, dies in C # würden Sie die beiden Parameter mit out in der Methodendefinition markieren, und das Rück void:

public static void GetInfo(out string firstName, out string lastName)
{
    // assign to firstName and lastName, instead of trying to return them.
}

Und so ist es zu nennen:

string firstName, lastName;
SomeClass.GetInfo(out firstName, out lastName);

Es ist nicht so schön. Hoffentlich einige zukünftige Version von C # ermöglicht dies:

var firstName, lastName = SomeClass.GetInfo();

Um dies zu ermöglichen, würde die GetInfo Methode ein Tuple<string, string> zurückzukehren. Dies wäre eine nicht-unterbrechende Änderung der Sprache sein, wie die aktuellen rechtlichen Verwendungen von var sehr restriktiv sind, so gibt es keine gültige Verwendung noch für die oben genannte „multiple Deklaration“ Syntax ist.

Answer 4

Sie können es in einer Zeile, aber nicht als eine Erklärung.

Zum Beispiel:

int str1 = "hey"; int str2 = "now";

Python und Ruby unterstützt die Zuordnung, die Sie zu tun versuchen; C # nicht.

Answer 5

  

Ich bin nicht sicher, ob das, was ich will ist   möglich in C #.

Es ist nicht.

Answer 6

Sie können dies tun, in C #

string str1 = "hey", str2 = "now";

oder Sie können wie folgt sein Phantasie

        int x, y;
        int[] arr = new int[] { x = 1, y = 2 };

Answer 7

Nein, aber Sie können ein Array von Strings initialisiert werden:

string[] strings = new string[] {"hey", "now"};

Obwohl das ist wahrscheinlich nicht zu nützlich für Sie. Ehrlich gesagt ist es nicht schwer, sie auf zwei Linien zu setzen:

string str1 = "hey";
string str2 = "now";

Answer 8

Sie Tupel mit C # 7 jetzt.

{
  (string part1, string part2) = Deconstruct(new string[]{"hey","now"});
}

public (string, string) Deconstruct(string[] parts)
{
   return (parts[0], parts[1]);
}