List mit 3 möglichen Werten

21/05/2010 - 20:21 von Günni | Report spam
Hallo zusammen,

ich weiß nicht ob sowas möglich ist aber hier meine Idee die sehr nützlich
für mich wàre :

Eine Liste mit 3 Werten also
sowas wie

TripleList<T,X,F>

Nur wie stelle ich sowas am dümmsten an ?

Icrgendwie muss ich dem ding ja weiß machen es soll 3 Werte speichern

Einfach eine Innerclass mit dem CustomType ?

internal class TripleList<T,F,X>:IEnumerator
{
internal class Container
{
public T value1;
public F Value2;
public X Value3;
}
List<Container> con = new List<Container>();
public void Add(T item1, F item2, X item3)
{
con.Add(new Container(){value1 = item1,Value2 = item2,Value3 =
item3});
}
}

Und danach nur noch einen Enumerator.
Ratsam ? Umsetzbar ? performant ?`

Meinungen dazu ?

Grüße
 

Lesen sie die antworten

#1 Frank Dzaebel
22/05/2010 - 09:49 | Warnen spam
Hallo,

Eine Liste mit 3 Werten



Kommt u.a. darauf an. in welchem Szenario diese
Klassen benutzt werden soll. Die Klasse bildest Du
Dir ja normal eher nach Deinen Bedürfnissen.
Solche Klasse, mit so wenig Werten, werden oft
eher über struct realisiert.
Wenn Du es halt oft benötigst oder möchtest, dass
ein foreach (oder MoveNext) auf die Klassen-Instanz
angewandt werden kann/soll, implementierst Du eben
noch einen IEnumerator.

Ganz allgemein hàtte ich im ersten Gedanken - wenn es denn
allgemein sein muss - "vielleicht" einen struct mit drei object
Typen genommen, weil das leichter im Handling ist. Da sieht
Du, der Aspekt Handling wàre zum Beispiel eine mögliche
Anforderung.
Performance ist dann durch das Boxing geringer, was
aber im Normalfall vielleicht in meinem Szenario keine
Rolle spielt.

struct TripleList
{
public TripleList(object wert1, object wert2,
object wert3)
{
Wert1 = wert1; Wert2 = wert2; Wert3 = wert3;
}
public object Wert1;
public object Wert2;
public object Wert3;
}

oder auch mit einer "class", weil man dann sehr
schon den parameterlosen Konstruktor private setzen
kann und die drei Werte Instanziierung explizit erzwingen
kann. alles halt subjektive Sichten.
Um einen guten Entwurf für Deine Klassen zu
erzeugen, solltest Du Dir Deine Anforderungen
und Haupt-Nutzungs-Szenarien klar machen.


internal class TripleList<T,F,X>:IEnumerator



Finde ich für so eine Minimalklasse etwas unhandlich
bei der Instanzierung, wenn ich an:
new TripleList<string, int, double>("eins",2,3);
denke.



Ratsam ? Umsetzbar ? performant ?`
Meinungen dazu ?



wie gesagt - ein wenig Anforderungen wàren
IMHO schon wichtig, wenn es eine allgemeine
best practice dafür gàbe, wàre sie im Framework schon
vorhanden. Es gibt dort ein paar Ansàtze bei der
Action und Func Klasse.

Ich würde die meisten Klassen dieser Art eher dezidiert
erstellen, also explizit benennen - möglichst mit expliziten
Typ und Benennung. Oder wenn generischer, dann vielleicht
über Interfaces (->OCP-Prinzip) :

http://de.wikipedia.org/wiki/Open-Closed_Prinzip
http://clean-code-developer.de/wiki...dPrinciple

Meistens versucht man die Klassen wirklich relativ eng
an der gewünschten Semantik zu halten, und dann ~"etwas"
erweiterbarer/generischer zu machen. Die Erweiterbarkeit kann auch
durch Frameworks (MEF, Unity, ...) gefördert werden.


ciao Frank
Dipl.Inf. Frank Dzaebel [MCP/MVP C#]
http://Dzaebel.NET

Ähnliche fragen