C# 列表<&燃气轮机；获取下一个元素或获取第一个元素

我想要得到列表中的下一个元素，如果列表在它的末尾，我想要第一个元素。 所以我只想让它转一圈，换句话说

   List<int> agents = taskdal.GetOfficeAgents(Branches.aarhusBranch);
    if (lastAgentIDAarhus != -1)
    {
        int index = agents.IndexOf(lastAgentIDAarhus);
        if (agents.Count > index + 1)
        {
            lastAgentIDAarhus = agents[index + 1];
        }
        else
        {
            lastAgentIDAarhus = agents[0];
        }
    }
    else
    {
        lastAgentIDAarhus = agents[0];
    }

List-agents=taskdal.GetOfficeAgents（branchs.aarhusBranch）；
如果（lastAgentIDAarhus！=-1）
{
int index=agents.IndexOf（lastAgentIDAarhus）；
如果（agents.Count>index+1）
{
lastAgentIDAarhus=代理人[指数+1]；
}
其他的
{
lastAgentIDAarhus=代理[0]；
}
}
其他的
{
lastAgentIDAarhus=代理[0]；
}

---

我对上面显示的我自己的解决方案相当不满意，如果您有更好的解决方案，请告诉我：）

差别不大，但至少少了一些代码（至少在编辑器中）；o）

List-agents=taskdal.GetOfficeAgents（branchs.aarhusBranch）；
如果（lastAgentIDAarhus！=-1）
{
int index=agents.IndexOf（lastAgentIDAarhus）；
lastAgentIDAarhus=（agents.Count>index+1？agents[index+1]：agents[0]）；
}
其他的
{
lastAgentIDAarhus=代理[0]；
}

使用MOD运算符%可以自动将索引剪切到可能的索引范围内

---

模运算符是对DIV（/）运算符的补充，返回两个整数除法的余数。例如，如果将9除以6，结果是1，余数为3。MOD操作符要求使用3。

作为对这一点的一种稍微不同的理解，这里有一种扩展方法，您可以用来使任何IEnumerable“循环”

  public static IEnumerable<T> AsCircularEnumerable<T>(this IEnumerable<T> enumerable)
  {
    var enumerator = enumerable.GetEnumerator();
    if(!enumerator.MoveNext())
      yield break;

    while (true)
    {
      yield return enumerator.Current;
      if(!enumerator.MoveNext())
        enumerator = enumerable.GetEnumerator();
    }
  }

公共静态IEnumerable AsCircularEnumerable（此IEnumerable enumerable）
{
var enumerator=enumerable.GetEnumerator（）；
如果（！enumerator.MoveNext（））
屈服断裂；
while（true）
{
产生返回枚举数。当前；
如果（！enumerator.MoveNext（））
enumerator=enumerable.GetEnumerator（）；
}
}

所以你可以这样使用它

  var agents = new List<int> {1, 2, 3, 4, 123, 234, 345, 546};

  foreach(var i in agents.AsCircularEnumerable())
  {
    Console.WriteLine(i);
  }

var-agents=新列表{1,2,3,4,123,234,345,546}；
foreach（agent.AsCircularEnumerable（）中的变量i）
{
控制台写入线（i）；
}

这将继续下去……：）

或者简单地说：

public static T NextOf<T>(this IList<T> list, T item)
{
    var indexOf = list.IndexOf(item);
    return list[indexOf == list.Count - 1 ? 0 : indexOf + 1];
}

public static T NextOf（此IList列表，T项）
{
var indexOf=list.indexOf（项目）；
返回列表[indexOf==list.Count-1？0:indexOf+1]；
}

例如：

List<string> names = new List<string>();

names.Add("jonh");
names.Add("mary");

string name = String.Empty;    

name = names.NextOf(null);   //name == jonh

name = names.NextOf("jonh"); //name == mary

name = names.NextOf("mary"); //name == jonh

列表名称=新列表（）；
姓名。添加（“jonh”）；
姓名。添加（“玛丽”）；
string name=string.Empty；
name=names.NextOf（空）//name==john
name=names.NextOf（“john”）//姓名=玛丽
name=names.NextOf（“玛丽”）//name==john

我喜欢使用扩展方法。不幸的是，他发布的代码将抛出异常。这是基于his的，但不会引发异常，而且非常简单易读（IMHO）：

public static T Next（此IList列表，T项）
{
var nextIndex=list.IndexOf（item）+1；
if（nextIndex==list.Count）
{
返回列表[0]；
}
返回列表[nextIndex]；
}

---

如果传入的项目不在列表中，它将返回列表中的第一个项目，因为

list。在这种情况下，IndexOf（item）

将返回

-1

如果我们添加一些检查以避免常见错误，您认为如何

public static class ListExtensions
{
    public static TType Next<TType>(this IList<TType> list, TType item)
    {
        if (list == null) return default(TType);

        var itemIndex = list.IndexOf(item);
        if (itemIndex < 0) return list.FirstOrDefault();

        var nextIndex = itemIndex + 1;

        return nextIndex >= list.Count 
            ? list.FirstOrDefault() 
            : list[nextIndex];
    }
}

公共静态类ListExtensions
{
公共静态TType Next（此IList列表，TType项）
{
if（list==null）返回默认值（TType）；
var itemIndex=list.IndexOf（项目）；
if（itemIndex<0）返回list.FirstOrDefault（）；
var nextIndex=itemIndex+1；
return nextIndex>=list.Count
？list.FirstOrDefault（）
：list[nextIndex]；
}
}
字符串行=行[lines.FindIndex（x=>x.Contains（item））+1]
 哇，这是一个非常好的解决方案，如果它起作用的话：）介意解释一下吗？mod运算符做一个模运算，这正是你想要的。如果您可以将索引初始化为0而不是-1，那么可以使用：lastAgentIDAarhus=agents[index%（agents.Count-1）]我认为应该是
index%（agents.Count）
@EricYin:您的计数将始终比您拥有的最高索引高1。这是因为（通常）索引从0开始，而Count属性从1开始。@EricYin是正确的。假设您有一个包含10个项目的列表，并且您尝试访问索引10处的项目（它不存在）。10%10=0是您想要的，而不是10%9=1.Koveras，在哪里会引发异常？请记住该列表。如果找不到项，IndexOf（项）将返回-1。这对于扩展来说确实是个好主意。我对它做了一点修改并实现了：）如果列表中有3个元素，如果我使用4或5的索引值-来访问列表中的一个项目-我会得到列表的第一个和第二个元素吗？我不确定你的意思。如果您想使用我上面概述的解决方案建立索引，因为这不是一个列表，它是一个IEnumerable，您不能在IEnumerable上使用索引器，那么不，您不会。您可以改用agents.AsCircularEnumerable（）.Skip（10）.First（）之类的内容。
List<string> names = new List<string>();

names.Add("jonh");
names.Add("mary");

string name = String.Empty;    

name = names.NextOf(null);   //name == jonh

name = names.NextOf("jonh"); //name == mary

name = names.NextOf("mary"); //name == jonh

public static T Next<T>(this IList<T> list, T item)
{
    var nextIndex = list.IndexOf(item) + 1;

    if (nextIndex == list.Count)
    {
        return list[0];
    }

    return list[nextIndex];
}

public static class ListExtensions
{
    public static TType Next<TType>(this IList<TType> list, TType item)
    {
        if (list == null) return default(TType);

        var itemIndex = list.IndexOf(item);
        if (itemIndex < 0) return list.FirstOrDefault();

        var nextIndex = itemIndex + 1;

        return nextIndex >= list.Count 
            ? list.FirstOrDefault() 
            : list[nextIndex];
    }
}