blocks|key|1475203|text|我会质疑这是否明智，但也许：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475204|source.TakeWhile(x+=>+x+!=+value).Count();|code-block|syntax|javascript|1475205|(如果需要，使用EqualityComparer<T>.Default模拟!=+)-但如果找不到，则需要观察返回...所以也许只需要走很长一段路|offset|length|style|CODE|1475206|public+static+int+IndexOf<T>(this+IEnumerable<T>+source,+T+value)
{
++++int+index+=+0;
++++var+comparer+=+EqualityComparer<T>.Default;+//+or+pass+in+as+a+parameter
++++foreach+(T+item+in+source)
++++{
++++++++if+(comparer.Equals(item,+value))+return+index;
++++++++index%2B%2B;
++++}
++++return+-1;
}|1475207|entityMap^0|0|0|8|R|11|2|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|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

I'd question the wisdom, but perhaps:

<pre><code>source.TakeWhile(x =&gt; x != value).Count();
</code></pre>

(using <code>EqualityComparer&lt;T&gt;.Default</code> to emulate <code>!=</code> if needed) - but you need to watch to return -1 if not found... so perhaps just do it the long way

<pre><code>public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; source, T value)
{
 int index = 0;
 var comparer = EqualityComparer&lt;T&gt;.Default; // or pass in as a parameter
 foreach (T item in source)
 {
 if (comparer.Equals(item, value)) return index;
 index++;
 }
 return -1;
}
</code></pre>

blocks|key|1475244|text|我会像这样实现它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475245|public+static+class+EnumerableExtensions
{
++++public+static+int+IndexOf<T>(this+IEnumerable<T>+obj,+T+value)
++++{
++++++++return+obj.IndexOf(value,+null);
++++}

++++public+static+int+IndexOf<T>(this+IEnumerable<T>+obj,+T+value,+IEqualityComparer<T>+comparer)
++++{
++++++++comparer+=+comparer+??+EqualityComparer<T>.Default;
++++++++var+found+=+obj
++++++++++++.Select((a,+i)+=>+new+{+a,+i+})
++++++++++++.FirstOrDefault(x+=>+comparer.Equals(x.a,+value));
++++++++return+found+==+null+?+-1+:+found.i;
++++}
}|code-block|syntax|javascript|1475246|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|$]]

I would implement it like this:

<pre><code>public static class EnumerableExtensions
{
 public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; obj, T value)
 {
 return obj.IndexOf(value, null);
 }

 public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; obj, T value, IEqualityComparer&lt;T&gt; comparer)
 {
 comparer = comparer ?? EqualityComparer&lt;T&gt;.Default;
 var found = obj
 .Select((a, i) =&gt; new { a, i })
 .FirstOrDefault(x =&gt; comparer.Equals(x.a, value));
 return found == null ? -1 : found.i;
 }
}
</code></pre>

blocks|key|1260697|text|我认为最好的选择是这样实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1260698|public+static+int+IndexOf<T>(this+IEnumerable<T>+enumerable,+T+element,+IEqualityComparer<T>+comparer+=+null)
{
++++int+i+=+0;
++++comparer+=+comparer+??+EqualityComparer<T>.Default;
++++foreach+(var+currentElement+in+enumerable)
++++{
++++++++if+(comparer.Equals(currentElement,+element))
++++++++{
++++++++++++return+i;
++++++++}

++++++++i%2B%2B;
++++}

++++return+-1;
}|code-block|syntax|javascript|1260699|它也不会创建匿名对象|1260700|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|$]]

I think the best option is to implement like this:

<pre><code>public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, T element, IEqualityComparer&lt;T&gt; comparer = null)
{
 int i = 0;
 comparer = comparer ?? EqualityComparer&lt;T&gt;.Default;
 foreach (var currentElement in enumerable)
 {
 if (comparer.Equals(currentElement, element))
 {
 return i;
 }

 i++;
 }

 return -1;
}
</code></pre>

It will also not create the anonymous object

blocks|key|1260746|text|事后查找索引的另一种方法是包装Enumerable，这有点类似于使用Linq+GroupBy()方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1260747|public+static+class+IndexedEnumerable
{
++++public+static+IndexedEnumerable<T>+ToIndexed<T>(this+IEnumerable<T>+items)
++++{
++++++++return+IndexedEnumerable<T>.Create(items);
++++}
}

public+class+IndexedEnumerable<T>+:+IEnumerable<IndexedEnumerable<T>.IndexedItem>
{
++++private+readonly+IEnumerable<IndexedItem>+_items;

++++public+IndexedEnumerable(IEnumerable<IndexedItem>+items)
++++{
++++++++_items+=+items;
++++}

++++public+class+IndexedItem
++++{
++++++++public+IndexedItem(int+index,+T+value)
++++++++{
++++++++++++Index+=+index;
++++++++++++Value+=+value;
++++++++}

++++++++public+T+Value+{+get;+private+set;+}
++++++++public+int+Index+{+get;+private+set;+}
++++}

++++public+static+IndexedEnumerable<T>+Create(IEnumerable<T>+items)
++++{
++++++++return+new+IndexedEnumerable<T>(items.Select((item,+index)+=>+new+IndexedItem(index,+item)));
++++}

++++public+IEnumerator<IndexedItem>+GetEnumerator()
++++{
++++++++return+_items.GetEnumerator();
++++}

++++IEnumerator+IEnumerable.GetEnumerator()
++++{
++++++++return+GetEnumerator();
++++}
}|code-block|syntax|javascript|1260748|它给出了一个用例：|1260749|var+items+=+new[]+{1,+2,+3};
var+indexedItems+=+items.ToIndexed();
foreach+(var+item+in+indexedItems)
{
++++Console.WriteLine("items[{0}]+=+{1}",+item.Index,+item.Value);
}|1260750|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

An alternative to finding the index after the fact is to wrap the Enumerable, somewhat similar to using the Linq GroupBy() method.

<pre><code>public static class IndexedEnumerable
{
 public static IndexedEnumerable&lt;T&gt; ToIndexed&lt;T&gt;(this IEnumerable&lt;T&gt; items)
 {
 return IndexedEnumerable&lt;T&gt;.Create(items);
 }
}

public class IndexedEnumerable&lt;T&gt; : IEnumerable&lt;IndexedEnumerable&lt;T&gt;.IndexedItem&gt;
{
 private readonly IEnumerable&lt;IndexedItem&gt; _items;

 public IndexedEnumerable(IEnumerable&lt;IndexedItem&gt; items)
 {
 _items = items;
 }

 public class IndexedItem
 {
 public IndexedItem(int index, T value)
 {
 Index = index;
 Value = value;
 }

 public T Value { get; private set; }
 public int Index { get; private set; }
 }

 public static IndexedEnumerable&lt;T&gt; Create(IEnumerable&lt;T&gt; items)
 {
 return new IndexedEnumerable&lt;T&gt;(items.Select((item, index) =&gt; new IndexedItem(index, item)));
 }

 public IEnumerator&lt;IndexedItem&gt; GetEnumerator()
 {
 return _items.GetEnumerator();
 }

 IEnumerator IEnumerable.GetEnumerator()
 {
 return GetEnumerator();
 }
}
</code></pre>

Which gives a use case of:

<pre><code>var items = new[] {1, 2, 3};
var indexedItems = items.ToIndexed();
foreach (var item in indexedItems)
{
 Console.WriteLine("items[{0}] = {1}", item.Index, item.Value);
}
</code></pre>

blocks|key|1475463|text|我目前使用的方法比已经建议的方法要短一些，据我所知，它给出了预期的结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475464|+var+index+=+haystack.ToList().IndexOf(needle);|code-block|syntax|javascript|1475465|它有点笨拙，但它能做这件事，而且相当简洁。|1475466|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|$]]

The way I'm currently doing this is a bit shorter than those already suggested and as far as I can tell gives the desired result:

<pre><code> var index = haystack.ToList().IndexOf(needle);
</code></pre>

It's a bit clunky, but it does the job and is fairly concise.

blocks|key|1260936|text|有点晚了，我知道...但这就是我最近所做的。它与您的略有不同，但允许程序员指定相等操作需要是什么(谓词)。我发现这在处理不同类型时非常有用，因为这样我就有了一种通用的方法来做这件事，而不管对象类型和相等运算符中内置的<T>。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1260937|它还具有非常非常小的内存占用，并且非常、非常快/高效……如果你关心这个的话。|1260938|更糟糕的是，您只需将其添加到您的扩展列表中。|1260939|不管怎样..。这就是了。|1260940|+public+static+int+IndexOf<T>(this+IEnumerable<T>+source,+Func<T,+bool>+predicate)
+{
+++++int+retval+=+-1;
+++++var+enumerator+=+source.GetEnumerator();

+++++while+(enumerator.MoveNext())
+++++{
+++++++++retval+%2B=+1;
+++++++++if+(predicate(enumerator.Current))
+++++++++{
+++++++++++++IDisposable+disposable+=+enumerator+as+System.IDisposable;
+++++++++++++if+(disposable+!=+null)+disposable.Dispose();
+++++++++++++return+retval;
+++++++++}
+++++}
+++++IDisposable+disposable+=+enumerator+as+System.IDisposable;
+++++if+(disposable+!=+null)+disposable.Dispose();
+++++return+-1;
+}|code-block|syntax|javascript|1260941|希望这能帮助到一些人。|1260942|entityMap^0|30|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|Z|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|10|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|11|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

A bit late in the game, i know... but this is what i recently did. It is slightly different than yours, but allows the programmer to dictate what the equality operation needs to be (predicate). Which i find very useful when dealing with different types, since i then have a generic way of doing it regardless of object type and <code>&lt;T&gt;</code> built in equality operator.

It also has a very very small memory footprint, and is very, very fast/efficient... if you care about that.

At worse, you'll just add this to your list of extensions.

Anyway... here it is.

<pre><code> public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; source, Func&lt;T, bool&gt; predicate)
 {
 int retval = -1;
 var enumerator = source.GetEnumerator();

 while (enumerator.MoveNext())
 {
 retval += 1;
 if (predicate(enumerator.Current))
 {
 IDisposable disposable = enumerator as System.IDisposable;
 if (disposable != null) disposable.Dispose();
 return retval;
 }
 }
 IDisposable disposable = enumerator as System.IDisposable;
 if (disposable != null) disposable.Dispose();
 return -1;
 }
</code></pre>

Hopefully this helps someone.

blocks|key|1475646|text|获取位置的最佳方法是使用FindIndex。此函数仅适用于List<>|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1475647|示例|1475648|int+id+=+listMyObject.FindIndex(x+=>+x.Id+==+15);+|code-block|syntax|javascript|1475649|如果您有枚举器或数组，请使用此方法|1475650|int+id+=+myEnumerator.ToList().FindIndex(x+=>+x.Id+==+15);+|1475651|或|1475652|+int+id+=+myArray.ToList().FindIndex(x+=>+x.Id+==+15);+|1475653|entityMap^0|C|9|T|6|0|0|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]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|15|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

The best way to catch the position is by <code>FindIndex</code> This function is available only for <code>List&lt;&gt;</code>

Example

<pre><code>int id = listMyObject.FindIndex(x =&gt; x.Id == 15); 
</code></pre>

If you have enumerator or array use this way

<pre><code>int id = myEnumerator.ToList().FindIndex(x =&gt; x.Id == 15); 
</code></pre>

or

<pre><code> int id = myArray.ToList().FindIndex(x =&gt; x.Id == 15); 
</code></pre>

blocks|key|1261100|text|这可以通过一个扩展(作为代理)变得非常酷，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261101|collection.SelectWithIndex();+
//+vs.+
collection.Select((item,+index)+=>+item);|code-block|syntax|javascript|1261102|它将自动将索引分配给可通过此Index属性访问的集合。|offset|length|style|CODE|1261103|接口：|1261104|public+interface+IIndexable
{
++++int+Index+{+get;+set;+}
}|1261105|自定义扩展(可能对使用EF和DbContext最有用)：|1261106|public+static+class+EnumerableXtensions
{
++++public+static+IEnumerable<TModel>+SelectWithIndex<TModel>(
++++++++this+IEnumerable<TModel>+collection)+where+TModel+:+class,+IIndexable
++++{
++++++++return+collection.Select((item,+index)+=>
++++++++{
++++++++++++item.Index+=+index;
++++++++++++return+item;
++++++++});
++++}
}

public+class+SomeModelDTO+:+IIndexable
{
++++public+Guid+Id+{+get;+set;+}
++++public+string+Name+{+get;+set;+}
++++public+decimal+Price+{+get;+set;+}

++++public+int+Index+{+get;+set;+}
}

//+In+a+method
var+items+=+from+a+in+db.SomeTable
++++++++++++where+a.Id+==+someValue
++++++++++++select+new+SomeModelDTO
++++++++++++{
++++++++++++++++Id+=+a.Id,
++++++++++++++++Name+=+a.Name,
++++++++++++++++Price+=+a.Price
++++++++++++};

return+items.SelectWithIndex()
++++++++++++.OrderBy(m+=>+m.Name)
++++++++++++.Skip(pageStart)
++++++++++++.Take(pageSize)
++++++++++++.ToList();|1261107|entityMap^0|0|0|E|5|0|0|0|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|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

This can get really cool with an extension (functioning as a proxy), for example:

<pre><code>collection.SelectWithIndex(); 
// vs. 
collection.Select((item, index) =&gt; item);
</code></pre>

Which will automagically assign indexes to the collection accessible via this <code>Index</code> property.

Interface:

<pre><code>public interface IIndexable
{
 int Index { get; set; }
}
</code></pre>

Custom extension (probably most useful for working with EF and DbContext):

<pre><code>public static class EnumerableXtensions
{
 public static IEnumerable&lt;TModel&gt; SelectWithIndex&lt;TModel&gt;(
 this IEnumerable&lt;TModel&gt; collection) where TModel : class, IIndexable
 {
 return collection.Select((item, index) =&gt;
 {
 item.Index = index;
 return item;
 });
 }
}

public class SomeModelDTO : IIndexable
{
 public Guid Id { get; set; }
 public string Name { get; set; }
 public decimal Price { get; set; }

 public int Index { get; set; }
}

// In a method
var items = from a in db.SomeTable
 where a.Id == someValue
 select new SomeModelDTO
 {
 Id = a.Id,
 Name = a.Name,
 Price = a.Price
 };

return items.SelectWithIndex()
 .OrderBy(m =&gt; m.Name)
 .Skip(pageStart)
 .Take(pageSize)
 .ToList();
</code></pre>

blocks|key|1261174|text|使用@Marc+Gravell的答案，我找到了使用以下方法的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261175|source.TakeWhile(x+=>+x+!=+value).Count();|code-block|syntax|javascript|1261176|为了在找不到项目时获取-1：|1261177|internal+static+class+Utils
{

++++public+static+int+IndexOf<T>(this+IEnumerable<T>+enumerable,+T+item)+=>+enumerable.IndexOf(item,+EqualityComparer<T>.Default);

++++public+static+int+IndexOf<T>(this+IEnumerable<T>+enumerable,+T+item,+EqualityComparer<T>+comparer)
++++{
++++++++int+index+=+enumerable.TakeWhile(x+=>+comparer.Equals(x,+item)).Count();
++++++++return+index+==+enumerable.Count()+?+-1+:+index;
++++}
}|1261178|我想这种方式既快又简单。然而，我还没有测试过性能。|1261179|entityMap^0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Using @Marc Gravell 's answer, I found a way to use the following method:

<pre><code>source.TakeWhile(x =&gt; x != value).Count();
</code></pre>

in order to get -1 when the item cannot be found:

<pre><code>internal static class Utils
{

 public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, T item) =&gt; enumerable.IndexOf(item, EqualityComparer&lt;T&gt;.Default);

 public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, T item, EqualityComparer&lt;T&gt; comparer)
 {
 int index = enumerable.TakeWhile(x =&gt; comparer.Equals(x, item)).Count();
 return index == enumerable.Count() ? -1 : index;
 }
}
</code></pre>

I guess this way could be both the fastest and the simpler. However, I've not tested performances yet.

I wrote this:

<pre><code>public static class EnumerableExtensions
{
 public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; obj, T value)
 {
 return obj
 .Select((a, i) =&gt; (a.Equals(value)) ? i : -1)
 .Max();
 }

 public static int IndexOf&lt;T&gt;(this IEnumerable&lt;T&gt; obj, T value
 , IEqualityComparer&lt;T&gt; comparer)
 {
 return obj
 .Select((a, i) =&gt; (comparer.Equals(a, value)) ? i : -1)
 .Max();
 }
}
</code></pre>

But I don't know if it already exists, does it?

How to get the index of an element in an IEnumerable?

我写了以下内容：public static class EnumerableExtensions{ public static int IndexOf<T>(this IEnumerable<T> obj, T value) { return obj .Select((a...

问如何在IEnumerable中获取元素的索引？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在IEnumerable中获取元素的索引？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在IEnumerable中获取元素的索引？
EN