在C#3.0中，是否存在仅当foreach不'；没有迭代？

意思是

foreach(blah b in blahblahs)
{
    writeOnMoon(b.name);
}
default
{
    writeOnMoon("No Blahs!");
}

---

默认值或者，否则，或者类似的东西，如果这不存在。。。你认为应该吗？

你能不能先检查blahblahs.length？

你能不能先检查blahblahs.length？

怎么样：

    bool run = false;
    foreach (var item in collection)
    {
        run = true;
        // Do stuff
    }
    if (!run)
    {
        // Other Stuff
    }

那么：

    bool run = false;
    foreach (var item in collection)
    {
        run = true;
        // Do stuff
    }
    if (!run)
    {
        // Other Stuff
    }

---

不，没有。

不，没有。

不，C语言中没有特定的语法可以满足您的需要

---

您必须设计自己的方法（如JDunkerley的示例所示）。

不，C中没有特定的语法可以满足您的需要

---

您必须设计自己的方法（如JDunkerley的示例所示）。

没有关键字可以做到这一点

你可以做：

if (blahblahs.Any())
{
    foreach(blah b in blahblahs)
    {
        writeOnMoon(b.name);
    }
}
else
{
    writeOnMoon("No Blahs!");
}

---

没有关键字可以执行此操作

你可以做：

if (blahblahs.Any())
{
    foreach(blah b in blahblahs)
    {
        writeOnMoon(b.name);
    }
}
else
{
    writeOnMoon("No Blahs!");
}

这是不存在的

我认为这不应该出现在语言中，因为它确实不允许你做任何新的事情，也不会使当前任何复杂的任务变得更简单。

这是不存在的

---

我认为这不应该出现在语言中，因为它确实不允许您做任何新的事情，也不会使当前任何复杂的任务变得更简单。

不，但是您可以编写一个扩展方法，这样您就可以编写：

collection.ForEachOrDefault(b =>
{
    WriteOnMoon(b.name);
}, () =>
{
    WriteOnMoon("No Blahs!");
});

诚然，我不认为我会推荐它。。。但代码如下：

public static void ForEachOrDefault<T>(this IEnumerable<T> source,
    Action<T> forEachAction, Action defaultAction)
{
    // Nullity checking omitted for brevity
    bool gotAny = false;
    foreach (T t in source)
    {
        gotAny = true;
        forEachAction(t);
    }
    if (!gotAny)
    {
        defaultAction();
    }
}

publicstaticvoidforeachordefault（此IEnumerable源代码，
操作forEachAction、操作defaultAction）
{
//为简洁起见，省略了空值检查
bool-gotAny=false；
foreach（源中的T）
{
gotAny=true；
前驱作用（t）；
}
如果（！gotAny）
{
defaultAction（）；
}
}

否，但您可以编写一个扩展方法，以便编写：

collection.ForEachOrDefault(b =>
{
    WriteOnMoon(b.name);
}, () =>
{
    WriteOnMoon("No Blahs!");
});

诚然，我不认为我会推荐它。。。但代码如下：

public static void ForEachOrDefault<T>(this IEnumerable<T> source,
    Action<T> forEachAction, Action defaultAction)
{
    // Nullity checking omitted for brevity
    bool gotAny = false;
    foreach (T t in source)
    {
        gotAny = true;
        forEachAction(t);
    }
    if (!gotAny)
    {
        defaultAction();
    }
}

publicstaticvoidforeachordefault（此IEnumerable源代码，
操作forEachAction、操作defaultAction）
{
//为简洁起见，省略了空值检查
bool-gotAny=false；
foreach（源中的T）
{
gotAny=true；
前驱作用（t）；
}
如果（！gotAny）
{
defaultAction（）；
}
}

没有。但是你可以尝试发明一种简单的扩展方法——对于简单的情况，它可以

public static class EnumerableExtension
{
   public static void IfEmpty<T>(this IEnumerable<T> list, Action<IEnumerable<T>> action)
   {
       if (list.Count() == 0)
         action(list);
   }
}

foreach (var v in blabla)
{
}
blabla.IfEmpty(x => log("List is empty"));

公共静态类EnumerableExtension
{
公共静态void IfEmpty（此IEnumerable列表，操作）
{
if（list.Count（）==0）
行动（清单）；
}
}
foreach（blabla中的v变量）
{
}
IfEmpty（x=>log（“列表为空”）；

---

也许你甚至可以创建可重用的动作。虽然它没有多大意义。

没有。但是你可以尝试发明一种简单的扩展方法——对于简单的情况，它可以

public static class EnumerableExtension
{
   public static void IfEmpty<T>(this IEnumerable<T> list, Action<IEnumerable<T>> action)
   {
       if (list.Count() == 0)
         action(list);
   }
}

foreach (var v in blabla)
{
}
blabla.IfEmpty(x => log("List is empty"));

公共静态类EnumerableExtension
{
公共静态void IfEmpty（此IEnumerable列表，操作）
{
if（list.Count（）==0）
行动（清单）；
}
}
foreach（blabla中的v变量）
{
}
IfEmpty（x=>log（“列表为空”）；

也许你甚至可以创建可重用的动作。虽然它没有太多意义。

Python有这个（对于…其他…），我真的很怀念C#中的它

使用LINQ，您可以执行以下操作：

public static IEnumerable<T> IfEmpty<T>(this IEnumerable<T> source, Action action)
{
    var enumerator = source.GetEnumerator();
    if (enumerator.MoveNext())
        do yield return enumerator.Current; while (enumerator.MoveNext());
    else
        action();
}

mylistofobjects.Each(...).IfEmpty(() => { /* empty list */ });

公共静态IEnumerable IfEmpty（此IEnumerable源，操作）
{
var枚举器=source.GetEnumerator（）；
if（枚举数.MoveNext（））
不返回枚举数.Current；while（枚举数.MoveNext（））；
其他的
动作（）；
}
mylistofobjects.Each（…）.IfEmpty（（）=>{/*empty list*/}）；

Python有这个（用于…其他…），我真的很怀念C#中的它

使用LINQ，您可以执行以下操作：

public static IEnumerable<T> IfEmpty<T>(this IEnumerable<T> source, Action action)
{
    var enumerator = source.GetEnumerator();
    if (enumerator.MoveNext())
        do yield return enumerator.Current; while (enumerator.MoveNext());
    else
        action();
}

mylistofobjects.Each(...).IfEmpty(() => { /* empty list */ });

公共静态IEnumerable IfEmpty（此IEnumerable源，操作）
{
var枚举器=source.GetEnumerator（）；
if（枚举数.MoveNext（））
不返回枚举数.Current；while（枚举数.MoveNext（））；
其他的
动作（）；
}
mylistofobjects.Each（…）.IfEmpty（（）=>{/*empty list*/}）；

是的，但我只是检查一下，因为这样的东西会/会更方便、更干净looking@lod3n：不总是，因为枚举不总是有长度。foreach只需要IEnumerable，所以不总是一个选项您可以始终使用LINQ Enumerable.Length（），但是对于大的枚举，这也可能非常慢。@Reed:不是“Any”（你自己的建议！）比“Length”（长度）好得多？是的，但我只是检查一下，因为像这样的东西会/可能更方便、更干净looking@lod3n：不总是，因为枚举不总是有长度。foreach只需要IEnumerable，所以不总是选项您可以始终使用LINQ Enumerable.Length（），但对于大的可枚举项，这也可能非常慢。@Reed:“Any”（您自己的建议！）不是比“Length”好得多的选择吗？它的缺点是调用

GetEnumerator（）

两次。这通常不是问题，但偶尔也会有问题。不过，它比其他建议的解决方案更干净、更易于阅读。这确实有调用

GetEnumerator（）的缺点

两次。这通常不是问题，但偶尔也会有问题。但与其他建议的解决方案相比，它更干净、更易于阅读。您将收到一个未初始化的变量错误。他的代码应为：

bool run=false；

显式初始化它是一个更好的做法。实际上，初始化更好，已更新以反映这一点s、 （我前面没有visual studio，所以忘了！）好吧，至少ReSharper会抱怨如果你执行bool run=false的话会有冗余的初始化；所以是的，它看起来是这样的^^@Oskar：是的，ReSharper的功能很烦人，Visual Studio想要一个，重塑另一个你会收到一个未初始化的变量错误。他的代码应该是：

bool run=false；

更好的做法是解释初始化它。实际上，初始化更好，已经更新以反映这一点。（没有visual studio。）