Có phương pháp Linq nào để thêm một mục đơn lẻ vào một tài khoản số <T> không?

Question

Về cơ bản tôi đang cố gắng để làm một cái gì đó như thế này:

image.Layers 

mà trả về một IEnumerable cho tất cả các lớp trừ lớp Parent, nhưng trong một số trường hợp, tôi chỉ muốn làm:

image.Layers.With(image.ParentLayer); 

vì nó chỉ được sử dụng ở một vài nơi so với 100s của việc sử dụng thông thường được thỏa mãn bởi image.Layers. Đó là lý do tại sao tôi không muốn tạo một tài sản khác cũng trả về lớp Parent.

Answer 1

Một cách sẽ được để tạo ra một singleton-chuỗi ra của sản phẩm (ví dụ như một mảng), và sau đó Concat nó lên bản gốc:

image.Layers.Concat(new[] { image.ParentLayer }) 

Nếu bạn đang làm điều này thực sự thường xuyên, xem xét viết một phần mở rộng-method Append (hoặc tương tự), chẳng hạn như một listed here, mà sẽ cho phép bạn làm:

image.Layers.Append(image.ParentLayer) 

Answer 2

Bạn có thể sử dụng Enumerable.Concat:

var allLayers = image.Layers.Concat(new[] {image.ParentLayer}); 

Answer 3

Có phương pháp Concat mà tham gia hai chuỗi.

Answer 4

bạn có thể làm một cái gì đó như:

image.Layers.Concat(new[] { image.ParentLayer }); 

phù hợp với enum với một mảng phần tử đơn chứa nội dung bạn muốn thêm

Answer 5

Nếu bạn thích cú pháp của .Với, hãy viết nó làm phương pháp mở rộng. IEnumerable sẽ không nhận thấy một số khác.

Answer 6

Không có phương pháp đơn nào thực hiện việc này. Cách gần nhất là phương pháp Enumerable.Concat nhưng cố gắng kết hợp một số IEnumerable<T> với IEnumerable<T> khác. Bạn có thể sử dụng sau đây để làm cho nó làm việc với một yếu tố duy nhất

image.Layers.Concat(new [] { image.ParentLayer }); 

Hoặc chỉ cần thêm một phương pháp khuyến nông mới

public static IEnumerable<T> ConcatSingle<T>(this IEnumerable<T> enumerable, T value) { 
    return enumerable.Concat(new [] { value }); 
} 

Answer 7

Tôi đã từng làm một hàm chút thoải mái cho việc này:

public static class CoreUtil 
{  
    public static IEnumerable<T> AsEnumerable<T>(params T[] items) 
    { 
     return items; 
    } 
} 

Hiện tại, điều này có thể:

image.Layers.Append(CoreUtil.AsEnumerable(image.ParentLayer, image.AnotherLayer)) 

Answer 8

Nhiều triển khai đã được đưa ra. Mỏ trông hơi khác một chút (nhưng cũng chỉ hoạt động)

Ngoài ra, tôi thấy nó thực tế cũng có quyền kiểm soát đối với ORDER. do đó, thông thường, tôi cũng có một phương thức ConcatTo, đặt phần tử mới op phía trước.

public static class Utility 
{ 
    /// <summary> 
    /// Adds the specified element at the end of the IEnummerable. 
    /// </summary> 
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam> 
    /// <param name="target">The target.</param> 
    /// <param name="item">The item to be concatenated.</param> 
    /// <returns>An IEnumerable, enumerating first the items in the existing enumerable</returns> 
    public static IEnumerable<T> ConcatItem<T>(this IEnumerable<T> target, T item) 
    { 
     if (null == target) throw new ArgumentException(nameof(target)); 
     foreach (T t in target) yield return t; 
     yield return item; 
    } 

    /// <summary> 
    /// Inserts the specified element at the start of the IEnumerable. 
    /// </summary> 
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam> 
    /// <param name="target">The IEnummerable.</param> 
    /// <param name="item">The item to be concatenated.</param> 
    /// <returns>An IEnumerable, enumerating first the target elements, and then the new element.</returns> 
    public static IEnumerable<T> ConcatTo<T>(this IEnumerable<T> target, T item) 
    { 
     if (null == target) throw new ArgumentException(nameof(target)); 
     yield return item; 
     foreach (T t in target) yield return t; 
    } 
} 

Hoặc cách khác, sử dụng mảng được tạo ngầm.(Sử dụng params từ khóa) để bạn có thể gọi phương thức để thêm một hoặc nhiều mục tại một thời điểm:

public static class Utility 
{ 
    /// <summary> 
    /// Adds the specified element at the end of the IEnummerable. 
    /// </summary> 
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam> 
    /// <param name="target">The target.</param> 
    /// <param name="items">The items to be concatenated.</param> 
    /// <returns>An IEnumerable, enumerating first the items in the existing enumerable</returns> 
    public static IEnumerable<T> ConcatItems<T>(this IEnumerable<T> target, params T[] items) => 
     (target ?? throw new ArgumentException(nameof(target))).Concat(items); 

    /// <summary> 
    /// Inserts the specified element at the start of the IEnumerable. 
    /// </summary> 
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam> 
    /// <param name="target">The IEnummerable.</param> 
    /// <param name="items">The items to be concatenated.</param> 
    /// <returns>An IEnumerable, enumerating first the target elements, and then the new elements.</returns> 
    public static IEnumerable<T> ConcatTo<T>(this IEnumerable<T> target, params T[] items) => 
     items.Concat(target ?? throw new ArgumentException(nameof(target))); 

Answer 9

tôi sử dụng phương pháp mở rộng sau đây để tránh tạo ra một vô dụng Array:

public static IEnumerable<T> ConcatSingle<T>(this IEnumerable<T> enumerable, T value) { 
    return enumerable.Concat(value.Yield()); 
} 

public static IEnumerable<T> Yield<T>(this T item) { 
    yield return item; 
} 

Answer 10

/// <summary>Concatenates elements to a sequence.</summary> 
/// <typeparam name="T">The type of the elements of the input sequences.</typeparam> 
/// <param name="target">The sequence to concatenate.</param> 
/// <param name="items">The items to concatenate to the sequence.</param> 
public static IEnumerable<T> ConcatItems<T>(this IEnumerable<T> target, params T[] items) 
{ 
    if (items == null) 
     items = new [] { default(T) }; 
    return target.Concat(items); 
} 

Giải pháp này dựa trên realbart's answer. Tôi điều chỉnh nó để cho phép việc sử dụng một giá trị duy nhất null như một tham số:

var newCollection = collection.ConcatItems(null) 

Answer 11

Append và Prepend hiện nay đã được bổ sung vào khuôn khổ NET tiêu chuẩn, vì vậy bạn không còn cần phải viết riêng bạn. Chỉ cần thực hiện việc này:

image.Layers.Append(image.ParentLayer) 

Xem What are the 43 APIs that are in .Net Standard 2.0 but not in .Net Framework 4.6.1? để biết danh sách lớn các chức năng mới.