blocks|key|3296946|text|好吧，如果这个方法需要一个IEnumerable，那么你必须传递一个列表，即使它只包含一个元素。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3296947|传球|3296948|new[]+{+item+}|code-block|syntax|javascript|3296949|因为争论应该足够了，我想|3296950|entityMap^0|D|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Well, if the method expects an <code>IEnumerable</code> you've got to pass something that is a list, even if it contains one element only.

passing 

<pre><code>new[] { item }
</code></pre>

as the argument should be enough I think

blocks|key|325663|text|我认为最简单的方法是new+T[]{item};；没有语法可以做到这一点。我能想到的最接近的对等物是params关键字，但当然，这需要您有权访问方法定义，并且只能用于数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|325664|entityMap^0|A|E|1E|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

The easiest way I'd say would be <code>new T[]{item};</code>; there's no syntax to do this. The closest equivalent that I can think of is the <code>params</code> keyword, but of course that requires you to have access to the method definition and is only usable with arrays.

blocks|key|3297003|text|你的helper方法是最干净的方式，IMO。如果您传入一个列表或数组，那么一段不择手段的代码可能会强制转换它并更改内容，从而在某些情况下导致奇怪的行为。您可以使用只读集合，但这可能涉及更多的包装。我认为你的解决方案是最简洁的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3297004|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Your helper method is the cleanest way to do it, IMO. If you pass in a list or an array, then an unscrupulous piece of code could cast it and change the contents, leading to odd behaviour in some situations. You could use a read-only collection, but that's likely to involve even more wrapping. I think your solution is as neat as it gets.

blocks|key|327388|text|在C#+3中(我知道你说过2)，你可以写一个通用的扩展方法，这可能会使语法更容易被接受：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327389|static+class+IEnumerableExtensions
{
++++public+static+IEnumerable<T>+ToEnumerable<T>(this+T+item)
++++{
++++++++yield+return+item;
++++}
}|code-block|syntax|javascript|327390|然后，客户端代码为item.ToEnumerable()。|offset|length|style|CODE|327391|entityMap^0|0|0|9|J|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In C# 3 (I know you said 2), you can write a generic extension method which might make the syntax a little more acceptable:

<pre><code>static class IEnumerableExtensions
{
 public static IEnumerable&lt;T&gt; ToEnumerable&lt;T&gt;(this T item)
 {
 yield return item;
 }
}
</code></pre>

client code is then <code>item.ToEnumerable()</code>.

blocks|key|325709|text|令我有点惊讶的是，没有人建议使用T类型的参数重载该方法来简化客户端API。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|325710|public+void+DoSomething<T>(IEnumerable<T>+list)
{
++++//+Do+Something
}

public+void+DoSomething<T>(T+item)
{
++++DoSomething(new+T[]+{+item+});
}|code-block|syntax|javascript|325711|现在你的客户端代码就可以这样做了：|325712|MyItem+item+=+new+MyItem();
Obj.DoSomething(item);|325713|或者列出一个列表：|325714|List<MyItem>+itemList+=+new+List<MyItem>();
Obj.DoSomething(itemList);|325715|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I'm kind of surprised that no one suggested a new overload of the method with an argument of type T to simplify the client API.

<pre><code>public void DoSomething&lt;T&gt;(IEnumerable&lt;T&gt; list)
{
 // Do Something
}

public void DoSomething&lt;T&gt;(T item)
{
 DoSomething(new T[] { item });
}
</code></pre>

Now your client code can just do this:

<pre><code>MyItem item = new MyItem();
Obj.DoSomething(item);
</code></pre>

or with a list:

<pre><code>List&lt;MyItem&gt; itemList = new List&lt;MyItem&gt;();
Obj.DoSomething(itemList);
</code></pre>

blocks|key|3083687|text|任一(如前所述)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3083688|MyMethodThatExpectsAnIEnumerable(new[]+{+myObject+});|code-block|syntax|javascript|3083689|或|3083690|MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject,+1));|3083691|顺便说一句，如果你想要一个空的匿名对象列表，最后一个版本也是不错的，例如|3083692|var+x+=+MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new+{+a+=+0,+b+=+"x"+},+0));|3083693|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Either (as has previously been said)

<pre><code>MyMethodThatExpectsAnIEnumerable(new[] { myObject });
</code></pre>

or

<pre><code>MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject, 1));
</code></pre>

As a side note, the last version can also be nice if you want an empty list of an anonymous object, e.g.

<pre><code>var x = MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new { a = 0, b = "x" }, 0));
</code></pre>

blocks|key|325744|text|在C#+3.0中，您可以使用System.Linq.Enumerable类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|325745|//+using+System.Linq

Enumerable.Repeat(item,+1);|code-block|syntax|javascript|325746|这将创建一个仅包含您的项目的新IEnumerable。|325747|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In C# 3.0 you can utilize the System.Linq.Enumerable class:

<pre><code>// using System.Linq

Enumerable.Repeat(item, 1);
</code></pre>

This will create a new IEnumerable that only contains your item.

blocks|key|3297118|text|正如我刚刚发现的，并看到用户LukeH也提出了一个很好的简单方法，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3297119|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
++++}
}|code-block|syntax|javascript|3297120|此模式将允许您以多种方式调用相同的功能:单个项；多个项(以逗号分隔)；数组；列表；枚举等。|3297121|虽然我不能100%25确定使用AsEnumerable方法的效率，但它确实很管用。|3297122|更新:+AsEnumerable函数看起来非常高效！(reference)|offset|length|3297123|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1763894/c-asenumerable-example/1763960#1763960^0|0|0|0|0|R|9|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

As I have just found, and seen that user LukeH suggested too, a nice simple way of doing this is as follows:

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

public static void PerformAction(IEnumerable&lt;YourType&gt; items)
{
 foreach (YourType item in items)
 {
 // Do stuff
 }
}
</code></pre>

This pattern will allow you to call the same functionality in a multitude of ways: a single item; multiple items (comma-separated); an array; a list; an enumeration, etc.

I'm not 100% sure on the efficiency of using the AsEnumerable method though, but it does work a treat.

Update: The AsEnumerable function looks pretty efficient! (<a href="https://stackoverflow.com/questions/1763894/c-asenumerable-example/1763960#1763960">reference</a>)

blocks|key|330778|text|这可能不会好到哪里去，但它还是很酷的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330779|Enumerable.Range(0,+1).Select(i+=>+item);|code-block|syntax|javascript|330780|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This may not be any better but it's kind of cool:

<pre><code>Enumerable.Range(0, 1).Select(i =&gt; item);
</code></pre>

blocks|key|3297151|text|虽然这对于一种方法来说有点夸张，但我相信有些人可能会发现交互式扩展很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3297152|Microsoft的交互式扩展(Ix)包括以下方法。|3297153|public+static+IEnumerable<TResult>+Return<TResult>(TResult+value)
{
++++yield+return+value;
}|code-block|syntax|javascript|3297154|它可以像这样使用：|3297155|var+result+=+EnumerableEx.Return(0);|3297156|Ix添加了原始Linq扩展方法中没有的新功能，并且是创建反应式扩展(Rx)的直接结果。|3297157|想象一下，对于IEnumerable，Linq+Extension+Methods+%2B+Ix+=+Rx。|offset|length|style|CODE|3297158|您可以找到这两个Rx+and+Ix+on+CodePlex。|3297159|entityMap|0|LINK|mutability|MUTABLE|url|http://rx.codeplex.com/^0|0|0|0|0|0|0|7|B|J|M|18|2|1D|2|0|8|L|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$Q|1B|R|1C|S|T]|$Q|1D|R|1E|S|T]|$Q|1F|R|1G|S|T]|$Q|1H|R|1I|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1J|8|@]|9|@$Q|1K|R|1L|1|1M]]|A|$]]|$1|W|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

Although it's overkill for one method, I believe some people may find the Interactive Extensions useful.

The Interactive Extensions (Ix) from Microsoft includes the following method.

<pre><code>public static IEnumerable&lt;TResult&gt; Return&lt;TResult&gt;(TResult value)
{
 yield return value;
}
</code></pre>

Which can be utilized like so:

<pre><code>var result = EnumerableEx.Return(0);
</code></pre>

Ix adds new functionality not found in the original Linq extension methods, and is a direct result of creating the Reactive Extensions (Rx).

Think, <code>Linq Extension Methods</code> + <code>Ix</code> = <code>Rx</code> for <code>IEnumerable</code>.

You can find both <a href="http://rx.codeplex.com/" rel="noreferrer">Rx and Ix on CodePlex</a>.

blocks|key|3297161|text|此帮助器方法适用于item或many。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3297162|public+static+IEnumerable<T>+ToEnumerable<T>(params+T[]+items)
{
++++return+items;
}++++|code-block|syntax|javascript|3297163|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This helper method works for item or many.

<pre><code>public static IEnumerable&lt;T&gt; ToEnumerable&lt;T&gt;(params T[] items)
{
 return items;
} 
</code></pre>

blocks|key|3083813|text|我同意@EarthEngine对原文的评论，即'AsSingleton‘是一个更好的名字。See+this+wikipedia+entry。然后，根据单例的定义，如果将空值作为参数传递，则“AsSingleton”应返回具有单个空值的IEnumerable，而不是空的IEnumerable，这将解决if+(item+==+null)+yield+break;的争论。我认为最好的解决方案是使用两个方法：'AsSingleton‘和'AsSingletonOrEmpty'；其中，如果将null作为参数传递，则'AsSingleton’将返回单个null值，而'AsSingletonOrEmpty‘将返回空IEnumerable。如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3083814|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;
}|code-block|syntax|javascript|3083815|然后，这些将或多或少类似于IEnumerable上的“First”和“FirstOrDefault”扩展方法，这感觉就是正确的。|3083816|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Singleton_%2528mathematics%2529^0|46|U|19|O|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I agree with @EarthEngine's comments to the original post, which is that 'AsSingleton' is a better name. <a href="http://en.wikipedia.org/wiki/Singleton_%28mathematics%29" rel="noreferrer">See this wikipedia entry</a>. Then it follows from the definition of singleton that if a null value is passed as an argument that 'AsSingleton' should return an IEnumerable with a single null value instead of an empty IEnumerable which would settle the <code>if (item == null) yield break;</code> debate. I think the best solution is to have two methods: 'AsSingleton' and 'AsSingletonOrEmpty'; where, in the event that a null is passed as an argument, 'AsSingleton' will return a single null value and 'AsSingletonOrEmpty' will return an empty IEnumerable. Like this:

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

public static IEnumerable&lt;T&gt; AsSingleton&lt;T&gt;(this T source)
{
 yield return source;
}
</code></pre>

Then, these would, more or less, be analogous to the 'First' and 'FirstOrDefault' extension methods on IEnumerable which just feels right.

blocks|key|3083841|text|在foreach中使用this+C#+compiler+optimization时，这比yield或Enumerable.Repeat快30%25，而在其他情况下性能相同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3083842|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);
++++}
}|code-block|syntax|javascript|3083843|在此测试中：|3083844|++++//+Fastest+among+seqs,+but+still+30x+times+slower+than+direct+sum
++++//+49+mops+vs+37+mops+for+yield,+or+c.30%25+faster
++++[Test]
++++public+void+SingleSequenceStructForEach()+{
++++++++var+sw+=+new+Stopwatch();
++++++++sw.Start();
++++++++long+sum+=+0;
++++++++for+(var+i+=+0;+i+<+100000000;+i%2B%2B)+{
++++++++++++foreach+(var+single+in+new+SingleSequence<int>(i))+{
++++++++++++++++sum+%2B=+single;
++++++++++++}
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine($"Elapsed+{sw.ElapsedMilliseconds}");
++++++++Console.WriteLine($"Mops+{100000.0+/+sw.ElapsedMilliseconds+*+1.0}");
++++}|3083845|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/3168435/801189^0|1|7|18|5|1E|H|B|T|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

This is 30% faster than <code>yield</code> or <code>Enumerable.Repeat</code> when used in <code>foreach</code> due to <a href="https://stackoverflow.com/a/3168435/801189">this C# compiler optimization</a>, and of the same performance in other cases.

<pre><code>public struct SingleSequence&lt;T&gt; : IEnumerable&lt;T&gt; {
 public struct SingleEnumerator : IEnumerator&lt;T&gt; {
 private readonly SingleSequence&lt;T&gt; _parent;
 private bool _couldMove;
 public SingleEnumerator(ref SingleSequence&lt;T&gt; parent) {
 _parent = parent;
 _couldMove = true;
 }
 public T Current =&gt; _parent._value;
 object IEnumerator.Current =&gt; 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&lt;T&gt; GetEnumerator() {
 return new SingleEnumerator(ref this);
 }
 IEnumerator IEnumerable.GetEnumerator() {
 return new SingleEnumerator(ref this);
 }
}
</code></pre>

in this test:

<pre><code> // 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 &lt; 100000000; i++) {
 foreach (var single in new SingleSequence&lt;int&gt;(i)) {
 sum += single;
 }
 }
 sw.Stop();
 Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}");
 Console.WriteLine($"Mops {100000.0 / sw.ElapsedMilliseconds * 1.0}");
 }
</code></pre>

blocks|key|325838|text|我来参加聚会有点晚了，但不管怎样，我会分享我的方法的。我的问题是，我希望将ItemSource或WPF+TreeView绑定到单个对象。层次结构如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|325839|项目>绘图>房间|325840|总是只有一个项目，但我仍然想在树中显示项目，而不是像一些人建议的那样，传递一个只有一个对象的Collection。|325841|由于您只能将IEnumerable对象作为ItemSource传递，因此我决定将我的类设置为IEnumerable：|325842|public+class+ProjectClass+:+IEnumerable<ProjectClass>
{
++++private+readonly+SingleItemEnumerator<AufmassProjekt>+enumerator;

++++...+

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

++++IEnumerator+IEnumerable.GetEnumerator()+=>+this.GetEnumerator();
}|code-block|syntax|javascript|325843|并相应地创建自己的枚举器：|325844|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;
}|325845|这可能不是最“干净”的解决方案，但它对我很有效。|325846|编辑|offset|length|style|BOLD|325847|为了支持@Groo指出的single+responsibility+principle，我创建了一个新的包装器类：|325848|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();
}|325849|我就是这样使用的|325850|TreeView.ItemSource+=+new+SingleItemWrapper(itemToWrap);|325851|编辑2个|325852|我用MoveNext()方法纠正了一个错误。|CODE|325853|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Single_responsibility_principle^0|0|0|0|0|0|0|0|0|0|2|0|C|V|0|0|0|0|0|0|4|0|2|A|0^^$0|@$1|2|3|4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1M|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1N|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1P|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1R|8|@$U|1S|V|1T|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1U|8|@]|9|@$U|1V|V|1W|1|1X]]|A|$]]|$1|10|3|11|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|15|5|J|7|20|8|@]|9|@]|A|$K|L]]|$1|16|3|17|5|6|7|21|8|@$U|22|V|23|W|X]]|9|@]|A|$]]|$1|18|3|19|5|6|7|24|8|@$U|25|V|26|W|1A]]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|1C|$1D|$5|1E|1F|1G|A|$1H|1I]]]]

I'm a bit late to the party but I'll share my way anyway.
My problem was that I wanted to bind the ItemSource or a WPF TreeView to a single object. The hierarchy looks like this:

Project > Plot(s) > Room(s)

There was always going to be only one Project but I still wanted to Show the project in the Tree, without having to pass a Collection with only that one object in it like some suggested. 
Since you can only pass IEnumerable objects as ItemSource I decided to make my class IEnumerable:

<pre><code>public class ProjectClass : IEnumerable&lt;ProjectClass&gt;
{
 private readonly SingleItemEnumerator&lt;AufmassProjekt&gt; enumerator;

 ... 

 public IEnumerator&lt;ProjectClass &gt; GetEnumerator() =&gt; this.enumerator;

 IEnumerator IEnumerable.GetEnumerator() =&gt; this.GetEnumerator();
}
</code></pre>

And create my own Enumerator accordingly:

<pre><code>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&lt;T&gt; : IEnumerator&lt;T&gt;
{
 private bool hasMovedOnce;

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

 public void Dispose() =&gt; (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 =&gt; this.Current;
}
</code></pre>

This is probably not the "cleanest" solution but it worked for me.

EDIT 
To uphold the <a href="https://en.wikipedia.org/wiki/Single_responsibility_principle" rel="nofollow noreferrer">single responsibility principle</a> as @Groo pointed out I created a new wrapper class:

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

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

 public object Item =&gt; this.enumerator.Current;

 public IEnumerator GetEnumerator() =&gt; this.enumerator;
}

public class SingleItemWrapper&lt;T&gt; : IEnumerable&lt;T&gt;
{
 private readonly SingleItemEnumerator&lt;T&gt; enumerator;

 public SingleItemWrapper(T item)
 {
 this.enumerator = new SingleItemEnumerator&lt;T&gt;(item);
 }

 public T Item =&gt; this.enumerator.Current;

 public IEnumerator&lt;T&gt; GetEnumerator() =&gt; this.enumerator;

 IEnumerator IEnumerable.GetEnumerator() =&gt; this.GetEnumerator();
}
</code></pre>

Which I used like this 

<pre><code>TreeView.ItemSource = new SingleItemWrapper(itemToWrap);
</code></pre>

EDIT 2 
I corrected a mistake with the <code>MoveNext()</code> method.

blocks|key|3083937|text|Enumerable.Range(1,1).Select(_+=>+{
++++//Do+some+stuff...+side+effects...
++++return+item;
});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3083938|上面的代码在使用like时很有用|unstyled|3083939|var+existingOrNewObject+=+MyData.Where(myCondition)
+++++++.Concat(Enumerable.Range(1,1).Select(_+=>+{
+++++++++++//Create+my+object...
+++++++++++return+item;
+++++++})).Take(1).First();|3083940|在上面的代码片段中，没有空/null检查，并且保证只返回一个对象，而不用担心出现异常。此外，因为它是惰性的，所以在证明没有符合条件的现有数据之前，闭包将不会被执行。|3083941|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

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

The above code is useful when using like 

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

In the above code snippet there is no empty/null check, and it is guaranteed to have only one object returned without afraid of exceptions. Furthermore, because it is lazy, the closure will not be executed until it is proved there is no existing data fits the criteria.

blocks|key|327529|text|要被归入“不一定是一个好的解决方案，但仍然是……一个解决方案”或“愚蠢的LINQ技巧”，你可以将Enumerable.Empty<>()和Enumerable.Append<>()结合起来……|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|327530|IEnumerable<string>+singleElementEnumerable+=+Enumerable.Empty<string>().Append("Hello,+World!");|code-block|syntax|javascript|327531|...or+Enumerable.Prepend<>()...|327532|IEnumerable<string>+singleElementEnumerable+=+Enumerable.Empty<string>().Prepend("Hello,+World!");|327533|后两种方法从.NET框架4.7.1和.NET+Core1.0开始可用。|327534|如果一个人真的打算使用现有的方法而不是编写自己的方法，那么这是一个可行的解决方案，尽管我不确定这是比the+Enumerable.Repeat<>()+solution更清楚还是更不明确。然而，这绝对是更长的代码(部分原因是类型参数推断对于Empty<>()是不可能的)，并且创建了两倍多的枚举器对象。|327535|四舍五入：“你知道这些方法存在吗？”答案是，Array.Empty<>()可以取代Enumerable.Empty<>()，但很难说situation...better就是这样。|327536|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/dotnet/api/system.linq.enumerable.empty|1|https://docs.microsoft.com/dotnet/api/system.linq.enumerable.append|2|https://docs.microsoft.com/dotnet/api/system.linq.enumerable.prepend|3|https://stackoverflow.com/a/1948625/150605|4|https://docs.microsoft.com/dotnet/api/system.array.empty^0|1C|K|1X|L|1C|K|0|1X|L|1|0|0|6|M|6|M|2|0|0|0|1I|L|3C|9|1E|Y|3|0|M|F|15|K|M|F|4|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]|$9|1I|A|1J|1|1K]]|E|$]]|$1|F|3|G|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|M|3|N|5|H|7|1S|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1T|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@$9|1Z|A|20|1|21]]|E|$]]|$1|S|3|T|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]]|D|@$9|27|A|28|1|29]]|E|$]]|$1|U|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]|14|$5|X|Y|Z|E|$10|15]]|16|$5|X|Y|Z|E|$10|17]]|18|$5|X|Y|Z|E|$10|19]]]]

To be filed under "Not necessarily a good solution, but still...a solution" or "Stupid LINQ tricks", you could combine <a href="https://docs.microsoft.com/dotnet/api/system.linq.enumerable.empty" rel="nofollow noreferrer"><code>Enumerable.Empty&lt;&gt;()</code></a> with <a href="https://docs.microsoft.com/dotnet/api/system.linq.enumerable.append" rel="nofollow noreferrer"><code>Enumerable.Append&lt;&gt;()</code></a>...

<pre class="lang-cs prettyprint-override"><code>IEnumerable&lt;string&gt; singleElementEnumerable = Enumerable.Empty&lt;string&gt;().Append("Hello, World!");
</code></pre>

...or <a href="https://docs.microsoft.com/dotnet/api/system.linq.enumerable.prepend" rel="nofollow noreferrer"><code>Enumerable.Prepend&lt;&gt;()</code></a>...

<pre><code>IEnumerable&lt;string&gt; singleElementEnumerable = Enumerable.Empty&lt;string&gt;().Prepend("Hello, World!");
</code></pre>

The latter two methods are available since .NET Framework 4.7.1 and .NET Core 1.0.

This is a workable solution if one were really intent on using existing methods instead of writing their own, though I'm undecided if this is more or less clear than <a href="https://stackoverflow.com/a/1948625/150605">the <code>Enumerable.Repeat&lt;&gt;()</code> solution</a>. This is definitely longer code (partly due to type parameter inference not being possible for <code>Empty&lt;&gt;()</code>) and creates twice as many enumerator objects, however.

Rounding out this "Did you know these methods exist?" answer, <a href="https://docs.microsoft.com/dotnet/api/system.array.empty" rel="nofollow noreferrer"><code>Array.Empty&lt;&gt;()</code></a> could be substituted for <code>Enumerable.Empty&lt;&gt;()</code>, but it's hard to argue that makes the situation...better.

blocks|key|325911|text|我最近在另一个帖子(Is+there+a+way+to+call+a+C#+method+requiring+an+IEnumerable+with+a+single+value?+...with+benchmarking)上问了同样的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|325912|我想让人们在这里停下来看看在新的帖子中显示的关于这些答案中的4种方法的简要基准比较。|325913|似乎简单地在方法的参数中编写new[]+{+x+}是最短、最快的解决方案。|style|CODE|325914|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/62296111/is-there-a-way-to-call-a-c-sharp-method-requiring-an-ienumerablet-with-a-singl^0|A|2T|0|0|0|E|B|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@$A|X|B|Y|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

I recently asked the same thing on another post (<a href="https://stackoverflow.com/questions/62296111/is-there-a-way-to-call-a-c-sharp-method-requiring-an-ienumerablet-with-a-singl">Is there a way to call a C# method requiring an IEnumerable&lt;T&gt; with a single value? ...with benchmarking</a>). 

I wanted people stopping by here to see the brief benchmark comparison shown at that newer post for 4 of the approaches presented in these answers. 

It seems that simply writing <code>new[] { x }</code> in the arguments to the method is the shortest and fastest solution.

blocks|key|328531|text|我更喜欢|type|unstyled|depth|inlineStyleRanges|entityRanges|data|328532|public+static+IEnumerable<T>+Collect<T>(this+T+item,+params+T[]+otherItems)
{
++++yield+return+item;
++++foreach+(var+otherItem+in+otherItems)
++++{
++++++++yield+return+otherItem;
++++}
}|code-block|syntax|javascript|328533|这允许您在需要单例的情况下调用item.Collect()，但也允许您在需要时调用item.Collect(item2,+item3)|offset|length|style|CODE|328534|entityMap^0|0|0|F|E|15|Q|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

I prefer
<pre><code>public static IEnumerable&lt;T&gt; Collect&lt;T&gt;(this T item, params T[] otherItems)
{
 yield return item;
 foreach (var otherItem in otherItems)
 {
 yield return otherItem;
 }
}
</code></pre>
This lets you call <code>item.Collect()</code> if you want the singleton, but it also lets you call <code>item.Collect(item2, item3)</code> if you want

Is there a common way to pass a single item of type <code>T</code> to a method which expects an <code>IEnumerable&lt;T&gt;</code> parameter? Language is C#, framework version 2.0.

Currently I am using a helper method (it's .Net 2.0, so I have a whole bunch of casting/projecting helper methods similar to LINQ), but this just seems silly:

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

Other way would of course be to create and populate a <code>List&lt;T&gt;</code> or an <code>Array</code> and pass it instead of <code>IEnumerable&lt;T&gt;</code>.

[Edit] As an extension method it might be named:

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

Am I missing something here?

[Edit2] We found <code>someObject.Yield()</code> (as @Peter suggested in the comments below) to be the best name for this extension method, mainly for brevity, so here it is along with the XML comment if anyone wants to grab it:

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

Passing a single item as IEnumerable<T>

有没有一种常见的方法来将类型为T的单个项传递给需要IEnumerable<T>参数的方法？语言是C#，框架版本2.0。目前我使用的是一个辅助方法(它是LINQ2.0，所以我有一大堆类似于.Net的造型/投影辅助方法)，但这看起来很愚蠢：public static class IEnumerableExt{ // ...

问将单个项目作为IEnumerable<T>传递
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将单个项目作为IEnumerable<T>传递EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将单个项目作为IEnumerable<T>传递
EN