Laden...

Gibt es eine Art fluent Interface für die Container Typen?

Erstellt von Seikilos vor 13 Jahren Letzter Beitrag vor 13 Jahren 951 Views
S
Seikilos Themenstarter:in
753 Beiträge seit 2006
vor 13 Jahren
Gibt es eine Art fluent Interface für die Container Typen?

Ich habe aus einer XSD eine cs Klasse generiert, die eine Liste vom Typ T[] beinhaltet. Sprich ein Array.
Wenn ich die Liste fülle so muss ich diese ja mittels new T[meine Größe] initialisieren.
Da feste Größen aber lame sind, würde man ja dafür ein List<T> nehmen, das befüllen und dann ein ToArray() aufrufen.

Meine Frage aber, gibt es einen Weg, so etwas zu machen:


Obj.meinArrayOfT = new List<T>().Add(einT).ToArray();

Mir ist klar, dass ich hier den Umweg über ToArray sparen kann. Worauf ich aber hinaus will, ist die Frage, ob irgendwo über einen Wrapper oder so das Konzept von Fluent Interfaces bereits realisiert wurde. Sprich alles was normalerweise void zurück gibt, return anstelle von void immer this.

Nettes beispiel:


var liste = new List<T>().Add(t1).Add(new T(..)).Add(t2);

Das wäre wirklich ab und zu recht hilfreich

Life is a short

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo Seikilos,

Gibt es eine Art fluent Interface für die Container Typen?

nein, gibt es nicht und kann es bei Collections, die IList<> implementieren, auch nicht geben, weil die Add-Methode dort als void definiert sind und man den Rückgabetyp weder ändern kann noch Überladungen erlaubt sind, die sich nur im Rückgabetyp unterscheidet.

Du hast zwar Recht, dass das manchmal praktische wäre, aber so wurde das Design eben nicht gemacht und nun ist es zu spät. Frei wäre man nur bei Collections, die IList<> nicht implementieren, was aber wiederum (zumindest für listenartige Collections) nicht sinnvoll ist.

herbivore

2.891 Beiträge seit 2004
vor 13 Jahren

Hallo Seikilos,

speziell für deinen Anwendungsfall kannst du auch folgendes machen:


new List<T>() { t1, new T(..), t2 };

Siehe auch Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch)

Gruß,
dN!3L

2.187 Beiträge seit 2005
vor 13 Jahren

Hallo @All,

Hier noch ein paar Varianten:


T[] array = new T[]{new T(), new T(), new T()};


List<T> zwi = new List<T>(new T[]{new T(), new T(), new T()});
// hier ginge dann zwi.Add(...)
T[] array = zwi.ToArray();

Gruß
Juy Juka

1.361 Beiträge seit 2007
vor 13 Jahren

Hey,

und wie wärs mit einer ExtensionsMethod? (Auch wenn diese die eigentliche Collection nicht verändert) Aber wenn du eh ganz am Ende "ToArray" aufrufst, sollte dir das egal sein.


public static IEnumerable<T> Append<T>(this IEnumerable<T> list, T x)
{
  return list.Concat(new[]{x});
}

beste Grüße
zommi

4.207 Beiträge seit 2003
vor 13 Jahren

Geht auch mit einer Extension-Method, die die zu Grunde liegende Liste verändert und ohne ToArray o.ä. auskommt:

using System;
using System.Collections.Generic;

namespace ListAdd
{
    public class Program
    {
        public static void Main()
        {
            var list = new List<int>().AddItem(23).AddItem(42);

            foreach(var item in list)
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
    }

    public static class ExtensionMethods
    {
        public static IList<T> AddItem<T>(this IList<T> source, T item)
        {
            source.Add(item);
            return source;
        }
    }
}

Einziger Haken: Sie kann nicht Add heißen, weil der Compiler sie dann findet (IntelliSense interessanterweise allerdings schon 😉).

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de