Ich schaue mir gerade die Neuerungen in C# an und habe eine Frage zum deconstruct:
using System;
namespace deconstruct
{
class Program
{
class Wert
{
public int W1 { get; }
public int W2 { get; }
public float F { get; }
public Wert(int w1, int w2, float f)
{
W1 = w1;
W2 = w2;
F = f;
}
public void Deconstruct(out int w1, out int w2)
{
w1 = W1;
w2 = W2;
}
public void Deconstruct(out int w1, out float f)
{
w1 = W1;
f = F;
}
}
static void Main(string[] args)
{
Wert wert = new Wert(1, 2, 3f);
(int A_w1, int A_w2) = wert;
// CS0121
// Der Aufruf unterscheidet nicht eindeutig zwischen den folgenden Methoden oder Eigenschaften:
// "Program.Wert.Deconstruct(out int, out int)" und "Program.Wert.Deconstruct(out int, out float)"
(int B_w1, float B_f) = wert;
// CS0121
// Der Aufruf unterscheidet nicht eindeutig zwischen den folgenden Methoden oder Eigenschaften:
// "Program.Wert.Deconstruct(out int, out int)" und "Program.Wert.Deconstruct(out int, out float)"
// Fehlerfrei ist allerdings der direkte Aufruf:
wert.Deconstruct(out A_w1, out A_w2);
wert.Deconstruct(out B_w1, out B_f);
}
}
}
Das ich Deconstruct mit unterschiedlicher Parameteranzahl überladen kann ist mit bekannt. Und rein funktional kann ich auch mit gleicher Anzahl aber unterschiedlichen Typen überladen.
Leider klappt dann allerdings die Zuweisung über Tupel nicht (siehe CS0121):
(int B_w1, float B_f) = wert;
Der direkte Aufruf funktioniert allerdings:
wert.Deconstruct(out B_w1, out B_f);
Ist das logisch, dass das nicht geht? Gibt es dafür eine Erklärung*?
Gruß
Ralf
* Außer, das man in C# nicht durch unterschiedliche Rückgabewerte überladen kann. Nur Deconstruct ist als void definiert und hat auch keinen return-Befehl.
PS: Man muss übrigens immer noch System.ValueTuple laden. Eigentlich sollte das doch zu c# 7 dazugehören, oder?
Edit:
Noch eine kleine Ergänzung:
(int a, int b) = wert;
ist etwas anderes als
(int a, int b) ci = wert;
Der erste, anonyme Tupel-Fall löst ein deconstruct-Aufruf aus.
Der zweite, benannte Tupel-Fall löst eine Zuweisung aus und benötig somit einen operator in der Klassendefinition:
static public implicit operator (int x, int y) (Wert w)
{
return (w.W1, w.W2);
}
static public implicit operator (int x, float y) (Wert w)
{
return (w.W1, w.F);
}
Dieser kann allerdings sehr wohl zwischen den verschiedenen Typen unterscheiden und somit funktioniert auch:
(int a, int b) ci = wert;
(int a, float b) cf = wert;
ci hat anschließend die Werte (1, 2) und
cf die Werte (1,3).
