Vượt qua một mục duy nhất dưới dạng IEn Countable <T>

Có một cách phổ biến để truyền một mục loại duy nhất Tcho một phương thức mong đợi một IEnumerable<T>tham số không? Ngôn ngữ là C #, phiên bản khung 2.0.

Hiện tại tôi đang sử dụng một phương thức của trình trợ giúp (đó là .Net 2.0, vì vậy tôi có cả đống phương thức trợ giúp truyền / chiếu tương tự như LINQ), nhưng điều này có vẻ ngớ ngẩn:

public static class IEnumerableExt
{
    // usage: IEnumerableExt.FromSingleItem(someObject);
    public static IEnumerable<T> FromSingleItem<T>(T item)
    {
        yield return item; 
    }
}

Cách khác tất nhiên sẽ là tạo và điền vào một List<T>hoặc một Arrayvà vượt qua nó thay vì IEnumerable<T>.

[Chỉnh sửa] Là một phương thức mở rộng, nó có thể được đặt tên:

public static class IEnumerableExt
{
    // usage: someObject.SingleItemAsEnumerable();
    public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
    {
        yield return item; 
    }
}

Am i thiếu cái gì ở đây?

[Edit2] Chúng tôi thấy someObject.Yield()(như @Peter đã đề xuất trong các bình luận bên dưới) là tên tốt nhất cho phương thức mở rộng này, chủ yếu là cho ngắn gọn, do đó, đây là cùng với nhận xét XML nếu có ai muốn lấy nó:

public static class IEnumerableExt
{
    /// <summary>
    /// Wraps this object instance into an IEnumerable&lt;T&gt;
    /// consisting of a single item.
    /// </summary>
    /// <typeparam name="T"> Type of the object. </typeparam>
    /// <param name="item"> The instance that will be wrapped. </param>
    /// <returns> An IEnumerable&lt;T&gt; consisting of a single item. </returns>
    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }
}

Phương pháp trợ giúp của bạn là cách sạch nhất để làm điều đó, IMO. Nếu bạn chuyển vào một danh sách hoặc một mảng, thì một đoạn mã vô đạo đức có thể bỏ nó và thay đổi nội dung, dẫn đến hành vi kỳ quặc trong một số tình huống. Bạn có thể sử dụng một bộ sưu tập chỉ đọc, nhưng điều đó có khả năng liên quan đến nhiều gói hơn. Tôi nghĩ rằng giải pháp của bạn là gọn gàng như nó được.

Chà, nếu phương thức mong muốn IEnumerablebạn phải vượt qua một cái gì đó là một danh sách, ngay cả khi nó chỉ chứa một yếu tố.

đi qua

new[] { item }

như tôi tranh luận là đủ

Trong C # 3.0, bạn có thể sử dụng lớp System.Linq.Enumerable:

// using System.Linq

Enumerable.Repeat(item, 1);

Điều này sẽ tạo ra một IEnumerable mới chỉ chứa mục của bạn.

Trong C # 3 (tôi biết bạn đã nói 2), bạn có thể viết một phương thức mở rộng chung có thể khiến cú pháp dễ chấp nhận hơn một chút:

static class IEnumerableExtensions
{
    public static IEnumerable<T> ToEnumerable<T>(this T item)
    {
        yield return item;
    }
}

mã khách hàng là sau đó item.ToEnumerable().

Phương pháp trợ giúp này hoạt động cho mục hoặc nhiều.

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

Tôi hơi ngạc nhiên khi không ai đề xuất một phương thức quá tải mới với đối số loại T để đơn giản hóa API khách.

public void DoSomething<T>(IEnumerable<T> list)
{
    // Do Something
}

public void DoSomething<T>(T item)
{
    DoSomething(new T[] { item });
}

Bây giờ mã khách hàng của bạn chỉ có thể làm điều này:

MyItem item = new MyItem();
Obj.DoSomething(item);

hoặc với một danh sách:

List<MyItem> itemList = new List<MyItem>();
Obj.DoSomething(itemList);

Hoặc (như đã nói trước đây)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

hoặc là

MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject, 1));

Là một lưu ý phụ, phiên bản cuối cùng cũng có thể tốt nếu bạn muốn một danh sách trống của một đối tượng ẩn danh, ví dụ:

var x = MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new { a = 0, b = "x" }, 0));

Như tôi vừa tìm thấy và thấy rằng người dùng LukeH cũng đề xuất, một cách đơn giản để thực hiện việc này như sau:

public static void PerformAction(params YourType[] items)
{
    // Forward call to IEnumerable overload
    PerformAction(items.AsEnumerable());
}

public static void PerformAction(IEnumerable<YourType> items)
{
    foreach (YourType item in items)
    {
        // Do stuff
    }
}

Mẫu này sẽ cho phép bạn gọi cùng một chức năng theo nhiều cách: một mục duy nhất; nhiều mục (được phân tách bằng dấu phẩy); một mảng; một danh sách; một bảng liệt kê, vv

Tôi không chắc chắn 100% về hiệu quả của việc sử dụng phương pháp AsEnumerable, nhưng nó thực sự hiệu quả.

Cập nhật: Chức năng AsEnumerable trông khá hiệu quả! ( tham khảo )

Mặc dù nó quá mức cho một phương pháp, tôi tin rằng một số người có thể thấy Tiện ích mở rộng tương tác hữu ích.

Phần mở rộng tương tác (Ix) từ Microsoft bao gồm phương pháp sau.

public static IEnumerable<TResult> Return<TResult>(TResult value)
{
    yield return value;
}

Mà có thể được sử dụng như vậy:

var result = EnumerableEx.Return(0);

Ix thêm chức năng mới không được tìm thấy trong các phương thức mở rộng Linq ban đầu và là kết quả trực tiếp của việc tạo Tiện ích mở rộng phản ứng (Rx).

Hãy suy nghĩ, Linq Extension Methods+ Ix= Rxcho IEnumerable.

Bạn có thể tìm thấy cả Rx và Ix trên CodePlex .

Tốc độ này nhanh hơn 30% so với yieldhoặc Enumerable.Repeatkhi được sử dụng foreachdo tối ưu hóa trình biên dịch C # này và có cùng hiệu suất trong các trường hợp khác.

public struct SingleSequence<T> : IEnumerable<T> {
    public struct SingleEnumerator : IEnumerator<T> {
        private readonly SingleSequence<T> _parent;
        private bool _couldMove;
        public SingleEnumerator(ref SingleSequence<T> parent) {
            _parent = parent;
            _couldMove = true;
        }
        public T Current => _parent._value;
        object IEnumerator.Current => Current;
        public void Dispose() { }

        public bool MoveNext() {
            if (!_couldMove) return false;
            _couldMove = false;
            return true;
        }
        public void Reset() {
            _couldMove = true;
        }
    }
    private readonly T _value;
    public SingleSequence(T value) {
        _value = value;
    }
    public IEnumerator<T> GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
    IEnumerator IEnumerable.GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
}

trong bài kiểm tra này:

    // Fastest among seqs, but still 30x times slower than direct sum
    // 49 mops vs 37 mops for yield, or c.30% faster
    [Test]
    public void SingleSequenceStructForEach() {
        var sw = new Stopwatch();
        sw.Start();
        long sum = 0;
        for (var i = 0; i < 100000000; i++) {
            foreach (var single in new SingleSequence<int>(i)) {
                sum += single;
            }
        }
        sw.Stop();
        Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}");
        Console.WriteLine($"Mops {100000.0 / sw.ElapsedMilliseconds * 1.0}");
    }

IanG có một bài viết hay về chủ đề này , gợi ý EnumerableFrom()như tên (và đề cập rằng Haskell và Rx gọi nó Return). IIRC F # gọi nó là Trả lại quá . F # 's Seqgọi tổng đàisingleton<'T> .

Hấp dẫn nếu bạn chuẩn bị trở thành C # -centric là gọi nó Yield[ám chỉ những người yield returnliên quan đến việc nhận ra nó].

Nếu bạn quan tâm đến các khía cạnh hoàn hảo của nó, James Michael Hare có số 0 hoặc một mục được gửi lại cũng rất đáng để quét.

Điều này có thể không tốt hơn nhưng nó khá tuyệt:

Enumerable.Range(0, 1).Select(i => item);

Tôi đồng ý với ý kiến ​​của @ EarthEngine cho bài viết gốc, đó là 'AsSingleton' là một cái tên hay hơn. Xem mục wikipedia này . Sau đó, nó xuất phát từ định nghĩa của singleton rằng nếu một giá trị null được thông qua dưới dạng đối số 'AsSingleton' sẽ trả về một IEnumerable với một giá trị null thay vì một IEnumerable trống sẽ giải quyết if (item == null) yield break;cuộc tranh luận. Tôi nghĩ giải pháp tốt nhất là có hai phương pháp: 'AsSingleton' và 'AsSingletonOrEmpty'; trong đó, trong trường hợp null được truyền dưới dạng đối số, 'AsSingleton' sẽ trả về một giá trị null duy nhất và 'AsSingletonOrEmpty' sẽ trả về một IEnumerable trống. Như thế này:

public static IEnumerable<T> AsSingletonOrEmpty<T>(this T source)
{
    if (source == null)
    {
        yield break;
    }
    else
    {
        yield return source;
    }
}

public static IEnumerable<T> AsSingleton<T>(this T source)
{
    yield return source;
}

Sau đó, những cái này, ít nhiều sẽ tương tự như các phương thức mở rộng 'First' và 'FirstOrDefault' trên IEnumerable mà cảm thấy đúng.

Cách dễ nhất tôi muốn nói là new T[]{item};; không có cú pháp để làm điều này. Tương đương gần nhất mà tôi có thể nghĩ đến là paramstừ khóa, nhưng tất nhiên điều đó đòi hỏi bạn phải có quyền truy cập vào định nghĩa phương thức và chỉ có thể sử dụng được với các mảng.

Enumerable.Range(1,1).Select(_ => {
    //Do some stuff... side effects...
    return item;
});

Đoạn mã trên rất hữu ích khi sử dụng like

var existingOrNewObject = MyData.Where(myCondition)
       .Concat(Enumerable.Range(1,1).Select(_ => {
           //Create my object...
           return item;
       })).Take(1).First();

Trong đoạn mã trên không có kiểm tra trống / null và được đảm bảo chỉ có một đối tượng được trả về mà không sợ ngoại lệ. Hơn nữa, vì nó lười biếng, việc đóng sẽ không được thực thi cho đến khi được chứng minh là không có dữ liệu hiện có phù hợp với tiêu chí.

Tôi đến bữa tiệc muộn một chút nhưng dù sao tôi cũng sẽ chia sẻ. Vấn đề của tôi là tôi muốn liên kết ItemSource hoặc WPF TreeView với một đối tượng. Hệ thống phân cấp trông như thế này:

Dự án> Lô đất> Phòng (s)

Luôn luôn chỉ có một Dự án nhưng tôi vẫn muốn Hiển thị dự án trong Cây, mà không phải thông qua Bộ sưu tập chỉ có một đối tượng trong đó như một số đề xuất.
Vì bạn chỉ có thể vượt qua các đối tượng IEnumerable dưới dạng ItemSource, tôi đã quyết định tạo lớp IEnumerable của mình:

public class ProjectClass : IEnumerable<ProjectClass>
{
    private readonly SingleItemEnumerator<AufmassProjekt> enumerator;

    ... 

    public IEnumerator<ProjectClass > GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Và tạo En Enatorator của riêng tôi theo đó:

public class SingleItemEnumerator : IEnumerator
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(object current)
    {
        this.Current = current;
    }

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public object Current { get; }
}

public class SingleItemEnumerator<T> : IEnumerator<T>
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(T current)
    {
        this.Current = current;
    }

    public void Dispose() => (this.Current as IDisposable).Dispose();

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public T Current { get; }

    object IEnumerator.Current => this.Current;
}

Đây có lẽ không phải là giải pháp "sạch nhất" nhưng nó hiệu quả với tôi.

EDIT
Để duy trì nguyên tắc trách nhiệm duy nhất như @Groo đã chỉ ra tôi đã tạo một lớp bao bọc mới:

public class SingleItemWrapper : IEnumerable
{
    private readonly SingleItemEnumerator enumerator;

    public SingleItemWrapper(object item)
    {
        this.enumerator = new SingleItemEnumerator(item);
    }

    public object Item => this.enumerator.Current;

    public IEnumerator GetEnumerator() => this.enumerator;
}

public class SingleItemWrapper<T> : IEnumerable<T>
{
    private readonly SingleItemEnumerator<T> enumerator;

    public SingleItemWrapper(T item)
    {
        this.enumerator = new SingleItemEnumerator<T>(item);
    }

    public T Item => this.enumerator.Current;

    public IEnumerator<T> GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Mà tôi đã sử dụng như thế này

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

EDIT 2
Tôi đã sửa một lỗi với MoveNext()phương pháp.

Để được nộp theo "Không nhất thiết là một giải pháp tốt , nhưng vẫn ... một giải pháp" hoặc "Thủ thuật LINQ ngu ngốc", bạn có thể kết hợp Enumerable.Empty<>()với Enumerable.Append<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Append("Hello, World!");

... hoặc Enumerable.Prepend<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Prepend("Hello, World!");

Hai phương thức sau có sẵn kể từ .NET Framework 4.7.1 và .NET Core 1.0.

Đây là một giải pháp khả thi nếu ai đó thực sự có ý định sử dụng phương pháp hiện có thay vì viết riêng của họ, mặc dù tôi chưa quyết định nếu điều này là nhiều hơn hoặc ít rõ ràng hơn các Enumerable.Repeat<>()giải pháp . Đây chắc chắn là mã dài hơn (một phần do suy luận tham số loại không thể thực hiện đượcEmpty<>() ) và tuy nhiên, tạo ra gấp đôi số đối tượng liệt kê.

Làm tròn điều này "Bạn có biết những phương pháp này tồn tại?" câu trả lời, Array.Empty<>()có thể được thay thế Enumerable.Empty<>(), nhưng thật khó để tranh luận rằng làm cho tình hình ... tốt hơn.

Gần đây tôi đã hỏi điều tương tự trên một bài đăng khác ( Có cách nào để gọi phương thức C # yêu cầu <T> IEn đếm được với một giá trị không? ... với điểm chuẩn ).

Tôi muốn mọi người dừng lại ở đây để xem so sánh điểm chuẩn ngắn gọn được hiển thị tại bài đăng mới hơn cho 4 trong số các cách tiếp cận được trình bày trong các câu trả lời này.

Có vẻ như chỉ cần viết new[] { x }trong các đối số cho phương thức là giải pháp ngắn nhất và nhanh nhất.