IEnumerable <T> koleksiyonuna nasıl öğe ekleyebilirim?

Yukarıdaki başlık olarak sorum. Örneğin,

IEnumerable<T> items = new T[]{new T("msg")};
items.ToList().Add(new T("msg2"));

ama sonuçta içinde sadece 1 öğe var.

Gibi bir yöntem alabilir miyiz items.Add(item)?

gibi List<T>

Yapamazsınız, çünkü IEnumerable<T>öğelerin eklenebileceği bir koleksiyonu temsil etmez. Aslında, mutlaka bir koleksiyonu temsil etmez! Örneğin:

IEnumerable<string> ReadLines()
{
     string s;
     do
     {
          s = Console.ReadLine();
          yield return s;
     } while (!string.IsNullOrEmpty(s));
}

IEnumerable<string> lines = ReadLines();
lines.Add("foo") // so what is this supposed to do??

Bununla birlikte, yapabileceğiniz şey, numaralandırıldığında, eskisinin tüm öğelerini artı kendi öğelerinizi sağlayacak yeni bir IEnumerable nesne (belirtilmemiş türde) oluşturmaktır . Bunun için kullanın Enumerable.Concat:

 items = items.Concat(new[] { "foo" });

Bu , dizi nesnesini değiştirmez (yine de dizilere öğe ekleyemezsiniz). Ancak, dizideki tüm öğeleri listeleyen yeni bir nesne oluşturacak ve sonra "Foo" oluşturacaktır. Ayrıca, bu yeni nesne dizideki değişiklikleri izler (yani numaralandırdığınızda öğelerin geçerli değerlerini görürsünüz).

Tür IEnumerable<T>, bu tür işlemleri desteklemez. IEnumerable<T>Arayüzün amacı, tüketicinin bir koleksiyonun içeriğini görmesine izin vermektir. Değerleri değiştirmemek.

.ToList (). Add () gibi işlemler yaptığınızda yeni List<T>bir liste oluşturursunuz ve bu listeye bir değer eklersiniz . Orijinal listeyle bağlantısı yoktur.

Yapabileceğiniz şey, IEnumerable<T>katma değerle yeni bir tane oluşturmak için Uzantı ekle yöntemini kullanmaktır .

items = items.Add("msg2");

Bu durumda bile orijinal IEnumerable<T>nesneyi değiştirmez . Bu, bir referans tutarak doğrulanabilir. Örneğin

var items = new string[]{"foo"};
var temp = items;
items = items.Add("bar");

Bu işlem kümesinden sonra değişken temp hala değerler kümesinde sadece tek bir eleman "foo" ile numaralandırılabilir bir değere referans verirken, öğeler "foo" ve "bar" değerleri ile farklı bir numaralandırılabilir referans olacak.

DÜZENLE

İçeriğin, tipik bir uzantı yöntemi olmadığını, IEnumerable<T>çünkü tanımladığım ilk yöntemlerden biri olduğunu unutuyorum . İşte burada

public static IEnumerable<T> Add<T>(this IEnumerable<T> e, T value) {
  foreach ( var cur in e) {
    yield return cur;
  }
  yield return value;
}

Kullanmayı ICollection<T>veya IList<T>arayüzleri kullanmayı düşündünüz mü , bir Addyöntemde olmasını istediğiniz nedenden dolayı var olurlar IEnumerable<T>.

IEnumerable<T>bir türü, gerçek temeldeki nesnenin öğelerin eklenmesini / kaldırılmasını destekleyip desteklemediğine dair herhangi bir garanti vermeden ... iyi, numaralandırılabilir veya sadece bir dizi öğeyi 'işaretlemek' için kullanılır. Ayrıca, bu arayüzlerin uygulandığını unutmayın, IEnumerable<T>böylece aldığınız tüm uzantı yöntemlerini elde edersiniz IEnumerable<T>.

Birkaç kısa, tatlı uzatma yöntemi IEnumerableve IEnumerable<T>benim için yap:

public static IEnumerable Append(this IEnumerable first, params object[] second)
{
    return first.OfType<object>().Concat(second);
}
public static IEnumerable<T> Append<T>(this IEnumerable<T> first, params T[] second)
{
    return first.Concat(second);
}   
public static IEnumerable Prepend(this IEnumerable first, params object[] second)
{
    return second.Concat(first.OfType<object>());
}
public static IEnumerable<T> Prepend<T>(this IEnumerable<T> first, params T[] second)
{
    return second.Concat(first);
}

Zarif (jenerik olmayan versiyonlar hariç). Bu yöntemler BCL'de çok kötü değil.

.Net Core'da Enumerable.Appendtam olarak bunu yapan bir yöntem var.

Yöntemin kaynak kodu GitHub'da bulunur. .... Uygulama (diğer cevaplardaki önerilerden daha karmaşık) bir göz atmaya değer :).

Hayır, IEnumerable buna öğe eklemeyi desteklemez.

'Alternatif' sizsiniz:

var List = new List(items);
List.Add(otherItem);

İkinci mesaj eklemek için -

IEnumerable<T> items = new T[]{new T("msg")};
items = items.Concat(new[] {new T("msg2")})

Yalnızca sizin belirttiğiniz gibi öğeler eklemekle kalmaz, aynı List<T>zamanda mevcut bir numaralandırıcınız olan bir öğeye (veya hemen hemen salt okunur olmayan herhangi bir koleksiyona) bir öğe eklerseniz , numaralandırıcı geçersiz kılınır ( InvalidOperationExceptiono andan itibaren atar ).

Bazı veri sorgusu türlerinden sonuçları topluyorsanız, Concatuzantı yöntemini kullanabilirsiniz :

Düzenleme: Aslında Unionaslında doğru değil, örnekte uzantısını kullandım . Uygulamam, çakışan sorguların sonuçları yinelemediğinden emin olmak için yoğun bir şekilde kullanıyor.

IEnumerable<T> itemsA = ...;
IEnumerable<T> itemsB = ...;
IEnumerable<T> itemsC = ...;
return itemsA.Concat(itemsB).Concat(itemsC);

Ben sadece burada Enumerable.Concatuzantısı yöntemi dışında, Enumerable.Append.NET Core 1.1.1 adlı başka bir yöntem var gibi görünüyor . İkincisi, tek bir öğeyi mevcut bir diziye birleştirmenizi sağlar. Böylece Aamol'un yanıtı şu şekilde de yazılabilir:

IEnumerable<T> items = new T[]{new T("msg")};
items = items.Append(new T("msg2"));

Yine de, bu işlevin giriş sırasını değiştirmeyeceğini lütfen unutmayın, verilen sırayı ve ekteki öğeyi bir araya getiren bir sarıcı döndürür.

Diğerleri, bir öğeye neden ekleyemediğiniz (ve yapmamanız gerektiği!) Hakkında zaten büyük açıklamalar yapmışlardır IEnumerable. Sadece bir koleksiyonu temsil eden ve bir ekleme yöntemi isteyen bir arabirime kodlamaya devam etmek istiyorsanız, ICollectionya da kodlamanız gerektiğini ekleyeceğim IList. Ek bir bonanza olarak, bu arayüzler uygulanır IEnumerable.

Bunu yapabilirsiniz.

//Create IEnumerable    
IEnumerable<T> items = new T[]{new T("msg")};

//Convert to list.
List<T> list = items.ToList();

//Add new item to list.
list.add(new T("msg2"));

//Cast list to IEnumerable
items = (IEnumerable<T>)items;

Bunu yapmanın en kolay yolu basitçe

IEnumerable<T> items = new T[]{new T("msg")};
List<string> itemsList = new List<string>();
itemsList.AddRange(items.Select(y => y.ToString()));
itemsList.Add("msg2");

Sonra listeyi IEnumerable olarak döndürebilirsiniz çünkü IEnumerable arabirimini uygular

Eğer gibi nesne oluşturursanız IEnumerable<int> Ones = new List<int>(); Sonra yapabilirsiniz((List<int>)Ones).Add(1);

Elbette, (T işinizi bir kenara bırakıyorum):

public IEnumerable<string> tryAdd(IEnumerable<string> items)
{
    List<string> list = items.ToList();
    string obj = "";
    list.Add(obj);

    return list.Select(i => i);
}