对于每个循环，确定哪个是循环的最后一次迭代

我有一个foreach循环，当从List中选择最后一项时，需要执行一些逻辑，例如:

 foreach (Item result in Model.Results)
{
//if current result is the last item in Model.Results
//then do something in the code
}

我可以知道哪个循环是最后没有使用循环和计数器吗?

329245 次浏览
小开
最佳答案

如果你只需要对最后一个元素做一些事情(而不是对最后一个元素做不同的)，那么在这里使用LINQ会有所帮助:

Item last = Model.Results.Last();
// do something with last

如果你需要对最后一个元素做一些不同的事情，那么你需要这样的东西:

Item last = Model.Results.Last();
foreach (Item result in Model.Results)
{
// do something with each item
if (result.Equals(last))
{
// do something different with the last item
}
else
{
// do something different with every item but the last
}
}

尽管你可能需要编写一个自定义比较器，以确保你能分辨出该项与Last()返回的项相同。

此方法应谨慎使用，因为Last很可能必须遍历集合。虽然这对于小型集合可能不是问题，但如果它变得很大，可能会对性能产生影响。如果列表包含重复的项，也会失败。在这种情况下，这样的语句可能更合适:

int totalCount = result.Count();
for (int count = 0; count < totalCount; count++)
{
Item result = Model.Results[count];


// do something with each item
if ((count + 1) == totalCount)
{
// do something different with the last item
}
else
{
// do something different with every item but the last
}
}
小开

最好的方法可能是在循环之后执行该步骤:

foreach(Item result in Model.Results)
{
//loop logic
}


//Post execution logic

或者如果你需要对最后的结果做些什么

foreach(Item result in Model.Results)
{
//loop logic
}


Item lastItem = Model.Results[Model.Results.Count - 1];


//Execute logic on lastItem here
小开

正如Chris所展示的，Linq可以工作;只需使用Last()来获得枚举对象中最后一个的引用，只要你没有使用该引用，那么就执行正常的代码，但如果你正在使用该引用，那么就执行额外的事情。它的缺点是它总是O(N)-复杂度。

你可以使用Count()(如果IEnumerable也是一个ICollection, Count()是O(1);这对于大多数常见的内置IEnumerables都是正确的)，并将foreach与计数器混合:

var i=0;
var count = Model.Results.Count();
foreach (Item result in Model.Results)
{
if (++i == count) //this is the last item
}
小开

迭代器实现没有提供这一点。您的集合可能是IList，可通过O(1)中的索引访问。在这种情况下，你可以使用普通的for-loop:

for(int i = 0; i < Model.Results.Count; i++)
{
if(i == Model.Results.Count - 1) doMagic();
}

如果你知道计数，但不能通过索引访问(因此，结果是ICollection)，你可以通过在foreach的主体中增加i并将其与长度进行比较来自己计数。

所有这些都不是完美的优雅。克里斯的解决方案可能是我迄今为止见过的最好的。

小开

一个老式的for循环怎么样?

for (int i = 0; i < Model.Results.Count; i++) {


if (i == Model.Results.Count - 1) {
// this is the last item
}
}

或者使用Linq和foreach:

foreach (Item result in Model.Results)
{
if (Model.Results.IndexOf(result) == Model.Results.Count - 1) {
// this is the last item
}
}
小开
在某些类型上使用Last()将遍历整个集合!
这意味着如果你创建一个foreach并调用Last()，你就循环了两次!，我相信你想在大的集合中避免这一点

那么解决方案是使用while循环:

using var enumerator = collection.GetEnumerator();


var last = !enumerator.MoveNext();
T current;


while (!last)
{
current = enumerator.Current;


//process item


last = !enumerator.MoveNext();
if(last)
{
//additional processing for last item
}
}

因此，除非集合类型为IList<T>类型，否则Last()函数将遍历所有集合元素。

Test

如果你的集合提供随机访问(例如实现IList<T>)，你也可以像下面这样检查你的项目。

if(collection is IList<T> list)
return collection[^1]; //replace with collection.Count -1 in pre-C#8 apps
小开

正如Shimmy所指出的，使用Last()可能会导致性能问题，例如，如果您的集合是LINQ表达式的实时结果。为了防止多次迭代，你可以使用“ForEach”扩展方法，如下所示:

var elements = new[] { "A", "B", "C" };
elements.ForEach((element, info) => {
if (!info.IsLast) {
Console.WriteLine(element);
} else {
Console.WriteLine("Last one: " + element);
}
});

扩展方法看起来像这样(作为额外的奖励，它还会告诉你索引，如果你在看第一个元素):

public static class EnumerableExtensions {
public delegate void ElementAction<in T>(T element, ElementInfo info);


public static void ForEach<T>(this IEnumerable<T> elements, ElementAction<T> action) {
using (IEnumerator<T> enumerator = elements.GetEnumerator())
{
bool isFirst = true;
bool hasNext = enumerator.MoveNext();
int index = 0;
while (hasNext)
{
T current = enumerator.Current;
hasNext = enumerator.MoveNext();
action(current, new ElementInfo(index, isFirst, !hasNext));
isFirst = false;
index++;
}
}
}


public struct ElementInfo {
public ElementInfo(int index, bool isFirst, bool isLast)
: this() {
Index = index;
IsFirst = isFirst;
IsLast = isLast;
}


public int Index { get; private set; }
public bool IsFirst { get; private set; }
public bool IsLast { get; private set; }
}
}
小开

还有更简单的方法吗?

Item last = null;
foreach (Item result in Model.Results)
{
// do something with each item


last = result;
}


//Here Item 'last' contains the last object that came in the last of foreach loop.
DoSomethingOnLastElement(last);
小开

".Last()"对我不起作用，所以我不得不这样做:

Dictionary<string, string> iterativeDictionary = someOtherDictionary;
var index = 0;
iterativeDictionary.ForEach(kvp =>
index++ == iterativeDictionary.Count ?
/*it's the last item */ :
/*it's not the last item */
);
小开

你可以这样做:

foreach (DataGridViewRow dgr in product_list.Rows)
{
if (dgr.Index == dgr.DataGridView.RowCount - 1)
{
//do something
}
}
小开

接受的答案将不适用于集合中的副本。如果你被设置在foreach上，你可以添加你自己的索引变量。

int last = Model.Results.Count - 1;
int index = 0;
foreach (Item result in Model.Results)
{
//Do Things


if (index == last)
//Do Things with the last result


index++;
}
小开

对Jon Skeet的优秀代码进行一些小的调整，您甚至可以通过允许访问前一个和下一个项目来使其更智能。当然，这意味着您必须在实现中提前阅读1项。出于性能原因，前一项和下一项仅为当前迭代项保留。它是这样的:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// Based on source: http://jonskeet.uk/csharp/miscutil/


namespace Generic.Utilities
{
/// <summary>
/// Static class to make creation easier. If possible though, use the extension
/// method in SmartEnumerableExt.
/// </summary>
public static class SmartEnumerable
{
/// <summary>
/// Extension method to make life easier.
/// </summary>
/// <typeparam name="T">Type of enumerable</typeparam>
/// <param name="source">Source enumerable</param>
/// <returns>A new SmartEnumerable of the appropriate type</returns>
public static SmartEnumerable<T> Create<T>(IEnumerable<T> source)
{
return new SmartEnumerable<T>(source);
}
}


/// <summary>
/// Type chaining an IEnumerable&lt;T&gt; to allow the iterating code
/// to detect the first and last entries simply.
/// </summary>
/// <typeparam name="T">Type to iterate over</typeparam>
public class SmartEnumerable<T> : IEnumerable<SmartEnumerable<T>.Entry>
{


/// <summary>
/// Enumerable we proxy to
/// </summary>
readonly IEnumerable<T> enumerable;


/// <summary>
/// Constructor.
/// </summary>
/// <param name="enumerable">Collection to enumerate. Must not be null.</param>
public SmartEnumerable(IEnumerable<T> enumerable)
{
if (enumerable == null)
{
throw new ArgumentNullException("enumerable");
}
this.enumerable = enumerable;
}


/// <summary>
/// Returns an enumeration of Entry objects, each of which knows
/// whether it is the first/last of the enumeration, as well as the
/// current value and next/previous values.
/// </summary>
public IEnumerator<Entry> GetEnumerator()
{
using (IEnumerator<T> enumerator = enumerable.GetEnumerator())
{
if (!enumerator.MoveNext())
{
yield break;
}
bool isFirst = true;
bool isLast = false;
int index = 0;
Entry previous = null;


T current = enumerator.Current;
isLast = !enumerator.MoveNext();
var entry = new Entry(isFirst, isLast, current, index++, previous);
isFirst = false;
previous = entry;


while (!isLast)
{
T next = enumerator.Current;
isLast = !enumerator.MoveNext();
var entry2 = new Entry(isFirst, isLast, next, index++, entry);
entry.SetNext(entry2);
yield return entry;


previous.UnsetLinks();
previous = entry;
entry = entry2;
}


yield return entry;
previous.UnsetLinks();
}
}


/// <summary>
/// Non-generic form of GetEnumerator.
/// </summary>
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}


/// <summary>
/// Represents each entry returned within a collection,
/// containing the value and whether it is the first and/or
/// the last entry in the collection's. enumeration
/// </summary>
public class Entry
{
#region Fields
private readonly bool isFirst;
private readonly bool isLast;
private readonly T value;
private readonly int index;
private Entry previous;
private Entry next = null;
#endregion


#region Properties
/// <summary>
/// The value of the entry.
/// </summary>
public T Value { get { return value; } }


/// <summary>
/// Whether or not this entry is first in the collection's enumeration.
/// </summary>
public bool IsFirst { get { return isFirst; } }


/// <summary>
/// Whether or not this entry is last in the collection's enumeration.
/// </summary>
public bool IsLast { get { return isLast; } }


/// <summary>
/// The 0-based index of this entry (i.e. how many entries have been returned before this one)
/// </summary>
public int Index { get { return index; } }


/// <summary>
/// Returns the previous entry.
/// Only available for the CURRENT entry!
/// </summary>
public Entry Previous { get { return previous; } }


/// <summary>
/// Returns the next entry for the current iterator.
/// Only available for the CURRENT entry!
/// </summary>
public Entry Next { get { return next; } }
#endregion


#region Constructors
internal Entry(bool isFirst, bool isLast, T value, int index, Entry previous)
{
this.isFirst = isFirst;
this.isLast = isLast;
this.value = value;
this.index = index;
this.previous = previous;
}
#endregion


#region Methods
/// <summary>
/// Fix the link to the next item of the IEnumerable
/// </summary>
/// <param name="entry"></param>
internal void SetNext(Entry entry)
{
next = entry;
}


/// <summary>
/// Allow previous and next Entry to be garbage collected by setting them to null
/// </summary>
internal void UnsetLinks()
{
previous = null;
next = null;
}


/// <summary>
/// Returns "(index)value"
/// </summary>
/// <returns></returns>
public override string ToString()
{
return String.Format("({0}){1}", Index, Value);
}
#endregion


}
}
}
小开

要对除最后一个元素之外的每个元素做一些额外的事情，可以使用基于函数的方法。

delegate void DInner ();


....
Dinner inner=delegate
{
inner=delegate
{
// do something additional
}
}
foreach (DataGridViewRow dgr in product_list.Rows)
{
inner()
//do something
}
}

这种方法有明显的缺点:对于更复杂的情况，代码更不清晰。调用委托可能不是很有效。排除故障可能不太容易。好的一面——编码很有趣!

话虽如此，如果你知道你的集合的计数不是特别慢，我建议在一些不重要的情况下使用plain for循环。

小开 
var last = objList.LastOrDefault();
foreach (var item in objList)
{
if (item.Equals(last))
{
  

}
}
小开 
foreach (DataRow drow in ds.Tables[0].Rows)
{
cnt_sl1 = "<div class='col-md-6'><div class='Slider-img'>" +
"<div class='row'><img src='" + drow["images_path"].ToString() + "' alt='' />" +
"</div></div></div>";
cnt_sl2 = "<div class='col-md-6'><div class='Slider-details'>" +
"<p>" + drow["situation_details"].ToString() + "</p>" +
"</div></div>";
if (i == 0)
{
lblSituationName.Text = drow["situation"].ToString();
}
if (drow["images_position"].ToString() == "0")
{
content += "<div class='item'>" + cnt_sl1 + cnt_sl2 + "</div>";
cnt_sl1 = "";
cnt_sl2 = "";
}
else if (drow["images_position"].ToString() == "1")
{
content += "<div class='item'>" + cnt_sl2 + cnt_sl1 + "</div>";
cnt_sl1 = "";
cnt_sl2 = "";
}
i++;
}
小开

另一种方法是使用Queue(队列)，我没有看到它被贴出来。这类似于实现SkipLast()方法而无需进行不必要的迭代。这种方法也可以让你在任何数量的最后一项上这样做。

public static void ForEachAndKnowIfLast<T>(
this IEnumerable<T> source,
Action<T, bool> a,
int numLastItems = 1)
{
int bufferMax = numLastItems + 1;
var buffer = new Queue<T>(bufferMax);
foreach (T x in source)
{
buffer.Enqueue(x);
if (buffer.Count < bufferMax)
continue; //Until the buffer is full, just add to it.
a(buffer.Dequeue(), false);
}
foreach (T item in buffer)
a(item, true);
}

要调用它，你需要执行以下操作:

Model.Results.ForEachAndKnowIfLast(
(result, isLast) =>
{
//your logic goes here, using isLast to do things differently for last item(s).
});
小开

如何将foreach转换为对最后一个元素做出反应:

List<int> myList = new List<int>() {1, 2, 3, 4, 5};
Console.WriteLine("foreach version");
{
foreach (var current in myList)
{
Console.WriteLine(current);
}
}
Console.WriteLine("equivalent that reacts to last element");
{
var enumerator = myList.GetEnumerator();
if (enumerator.MoveNext() == true) // Corner case: empty list.
{
while (true)
{
int current = enumerator.Current;


// Handle current element here.
Console.WriteLine(current);


bool ifLastElement = (enumerator.MoveNext() == false);
if (ifLastElement)
{
// Cleanup after last element
Console.WriteLine("[last element]");
break;
}
}
}
enumerator.Dispose();
}
小开

进一步改进丹尼尔·沃尔夫回答，你可以在另一个IEnumerable上进行堆栈，以避免多次迭代和lambda，例如:

var elements = new[] { "A", "B", "C" };
foreach (var e in elements.Detailed())
{
if (!e.IsLast) {
Console.WriteLine(e.Value);
} else {
Console.WriteLine("Last one: " + e.Value);
}
}

扩展方法实现:

public static class EnumerableExtensions {
public static IEnumerable<IterationElement<T>> Detailed<T>(this IEnumerable<T> source)
{
if (source == null)
throw new ArgumentNullException(nameof(source));


using (var enumerator = source.GetEnumerator())
{
bool isFirst = true;
bool hasNext = enumerator.MoveNext();
int index = 0;
while (hasNext)
{
T current = enumerator.Current;
hasNext = enumerator.MoveNext();
yield return new IterationElement<T>(index, current, isFirst, !hasNext);
isFirst = false;
index++;
}
}
}


public struct IterationElement<T>
{
public int Index { get; }
public bool IsFirst { get; }
public bool IsLast { get; }
public T Value { get; }


public IterationElement(int index, T value, bool isFirst, bool isLast)
{
Index = index;
IsFirst = isFirst;
IsLast = isLast;
Value = value;
}
}
}
小开

只需存储之前的值，并在循环中使用它。然后在最后，“previous”值将是最后一项，让您以不同的方式处理它。不需要计数或特殊库。

bool empty = true;
Item previousItem;


foreach (Item result in Model.Results)
{
// Alternatively, check if previousItem == null
// if your Enumerable can't contain nulls
if (!empty)
{
// We know this isn't the last item because
// it came from the previous iteration
handleRegularItem(previousItem);
}


previousItem = result;
empty = false;
}


if (!empty)
{
// We know this is the last item because the loop is finished
handleLastItem(previousItem);
}
小开 
     List<int> ListInt = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };




int count = ListInt.Count;
int index = 1;
foreach (var item in ListInt)
{
if (index != count)
{
Console.WriteLine("do something at index number  " + index);
}
else
{
Console.WriteLine("Foreach loop, this is the last iteration of the loop " + index);
}
index++;


}
//OR
int count = ListInt.Count;
int index = 1;
foreach (var item in ListInt)
{
if (index < count)
{
Console.WriteLine("do something at index number  " + index);
}
else
{
Console.WriteLine("Foreach loop, this is the last iteration of the loop " + index);
}
index++;


}
小开

你可以创建一个专门用于此的扩展方法:

public static class EnumerableExtensions {
public static bool IsLast<T>(this List<T> items, T item)
{
if (items.Count == 0)
return false;
T last = items[items.Count - 1];
return item.Equals(last);
}
}

你可以这样使用它:

foreach (Item result in Model.Results)
{
if(Model.Results.IsLast(result))
{
//do something in the code
}
}
小开

你可以只使用一个for循环，不需要在for主体中添加额外的if:

for (int i = 0; i < Model.Results.Count - 1; i++) {
var item = Model.Results[i];
}

for条件中的-1负责跳过最后一项。

小开

使用Linq和foreach:

foreach (Item result in Model.Results)
{
if (Model.Results.IndexOf(result) == Model.Results.Count - 1) {
// this is the last item
}
}

https://code.i-harness.com/en/q/7213ce

小开

根据@Shimmy的回复，我创建了一个扩展方法，这是每个人都想要的解决方案。它很简单，易于使用，并且只循环遍历集合一次。

internal static class EnumerableExtensions
{
public static void ForEachLast<T>(this IEnumerable<T> collection, Action<T>? actionExceptLast = null, Action<T>? actionOnLast = null)
{
using var enumerator = collection.GetEnumerator();
var isNotLast = enumerator.MoveNext();
while (isNotLast)
{
var current = enumerator.Current;
isNotLast = enumerator.MoveNext();
var action = isNotLast ? actionExceptLast : actionOnLast;
action?.Invoke(current);
}
}
}

这适用于任何IEnumerable<T>。用法如下:

var items = new[] {1, 2, 3, 4, 5};
items.ForEachLast(i => Console.WriteLine($"{i},"), i => Console.WriteLine(i));

输出如下:

1,
2,
3,
4,
5

此外，你可以把它变成Select风格的方法。然后，在ForEach中重用该扩展。代码是这样的:

internal static class EnumerableExtensions
{
public static void ForEachLast<T>(this IEnumerable<T> collection, Action<T>? actionExceptLast = null, Action<T>? actionOnLast = null) =>
// ReSharper disable once IteratorMethodResultIsIgnored
collection.SelectLast(i => { actionExceptLast?.Invoke(i); return true; }, i => { actionOnLast?.Invoke(i); return true; }).ToArray();


public static IEnumerable<TResult> SelectLast<T, TResult>(this IEnumerable<T> collection, Func<T, TResult>? selectorExceptLast = null, Func<T, TResult>? selectorOnLast = null)
{
using var enumerator = collection.GetEnumerator();
var isNotLast = enumerator.MoveNext();
while (isNotLast)
{
var current = enumerator.Current;
isNotLast = enumerator.MoveNext();
var selector = isNotLast ? selectorExceptLast : selectorOnLast;
//https://stackoverflow.com/a/32580613/294804
if (selector != null)
{
yield return selector.Invoke(current);
}
}
}
}

提交答案