Gewusst wie: Auflisten von einer generischen List<T>, ohne zu wissen, die Art

Leite ich eine generische Liste an eine Funktion , ich möchte aufzählen der Objekte in der Liste. Wenn ich in der Lage, aufzählen von Elementen in der Liste, die ich verwenden wird, die Reflexion auf den rest.

 var Items= new List<String>(){"s1","s2"};
  Enumerate(Items);
  void Enumerate(object items)
  {
        //i know the type so i  can cast and enumerate
        foreach(var item in (List<String>) items)
        {

        }
        //i don't know the type of object in the list
        //Following won't work , can't cast to List<object> 
        foreach (var item in (List<object>) items)
        {

        }
    }

sollten Sie nicht vorbei und werden ein IEnumerable<T> statt Objekt?
wie kann ich den parameter als Typ " IEnumerable<T> , Das Objekt an die Funktion übergeben wird immer ein List<T> , aber der Typ des Objekts in der Liste anders sein wird
die größere Frage ist, warum haben Sie andere Objekte in der Liste? Der übliche Weg, dies zu erreichen ist mit dem Composite-design-pattern...
Sie brauchen nicht zu wissen, geben Sie nur für die Aufzählung. Wenn Sie zu manipulieren, dann sind Sie definitiv brauchen. Wenn Sie haben, um zu überprüfen, einige verschiedene Typen von Objekten mit ähnlichen Eigenschaften sind, dann würde ich dir empfehlen, um Schnittstelle zu verwenden, und Listen Sie auf, dass. wie `foreach(var i in (Liste<IYourInterface>) - items)...
Auch die Verwendung einer Schnittstelle wie dieser kann schwierig sein pre-C# 4.0, wenn Sie nicht über eine List<IYourInterface> in den ersten Platz.

InformationsquelleAutor Priyan R | 2009-09-10

9

Ich bin mir nicht sicher, was Ihre end-game Ziele. Wenn Sie erwarten, dass eine Liste, die speziell eine generische Liste, warum gehen Sie nicht mit einer generischen Methode, in:
```
void Enumerate<T>(List<T> items)
{
  for(var item in items) 
  {
    //...
  }
}
```
Dies ist näher beschrieben http://msdn.microsoft.com/en-us/library/twcad0zb(VS.80).aspx.

Ich möchte nur hinzufügen, dass die oben genannte Methode, auf seine eigene, Niederlagen der Zweck der ein einfaches für in-Schleife. Wieder, ich weiß nicht was ich Aufzählen soll jenseits der Iteration über die Elemente.

InformationsquelleAutor David Andres

Können Sie machen Sie Ihre Funktion generische

public void Enum<T>(List<T> list)
        {
            foreach (T t in list)
            {

            }
        }

InformationsquelleAutor Adriaan Stander

Die version der Funktion, die funktioniert, ist:

var Items= new List<String>(){"s1","s2"};
Enumerate(Items);
void Enumerate<T>(List<T> items)
{
    if (typeof(T) == typeof(string))
    {
        //i know the type so i  can cast and enumerate
        foreach(string item in (List<String>) items)
        {

        }
    }
    else
    {
        //i don't know the type of object in the list
        //Following won't work , can't cast to List<object> 
        foreach (T item in items)
        {

        }
    }
}

Aber dies kann geschrieben werden, besser als:

void Enumerate<T>(List<T> items)
{
    foreach (T item in items)
    {
        if (typeof(T) == typeof(string))
        { /* Do something */ }
        else
        { /* Do something else */ }
    }
}

InformationsquelleAutor Matthew Scharley

Ich habe eine statische Klasse, wo ich einige utils Funktionen wie ein string-enumerator aus einer Liste:

public static string EnumerateStrings<T>(this List<T> items, string separator = "; ")
{
    var result = "";

    if(typeof(T) == typeof(string) && items.SafeAny())
    {
        items.ForEach(str => {
            try
            {
                if (!String.IsNullOrEmpty(str as string))
                {
                    if (!String.IsNullOrEmpty(result))
                        result += separator;
                    result += str;
                }
            }
            catch { }
        });
    }

    return result;
}

Und mit dieser Funktion werden Sie nur benötigen, um zu verwenden, wie diese:

string myCarsEnumeration = Cars.Select(ob => ob.Name).ToList().EnumerateStrings();
//output-> Porsche; Lexus; Peugeot

//or

string myCarsEnumeration2 = Cars.Select(ob => ob.Name).ToList().EnumerateStrings(", ");
//output-> Porsche, Lexus, Peugeot

Können Sie sich an die Arbeit mit mehr Objekt-Typen.

Den code von SafeAny():

public static bool SafeAny<T>(this IEnumerable<T> list, Func<T, bool> predicate)
{
    return list != null && list.Any(predicate);
}

InformationsquelleAutor Ninita

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.