IEnumerable<char> query = "Not what you might expect";
string vowels = "aeiou";
for (int i = 0; i < vowels.Length; i++)
query = query.Where (c => c != vowels[i]);
foreach (char c in query) Console.Write (c);
发生异常IndexOutOfRangeException。为什么会发生这个异常，一切看起来都很好。
提前致谢。
解决方案
for (int i = 0; i < vowels.Length; i++)
{
char vowel = vowels[i];
query = query.Where (c => c != vowel);
}
这工作正常，这些代码有什么区别。请分享详细信息。
我正在尝试在Concat每个循环中使用IEnumerable 的方法,但我无法使其正常工作.
IEnumerable<Geo> geos = null;
foreach (string a in values)
{
if (geos == null)
geos = entities.Geos.Where(g => (g.ACode == Convert.ToInt16(a)));
else
geos = geos.Concat(entities.Geos.Where(g => (g.ACode == Convert.ToInt16(a))));
}
它返回的只是值中最终"a"的值,对于值中存在的记录计数也是如此.
因此,如果我有1,2,3作为值,它只返回3.我也需要1,2和3的值.
我哪里错了？
用户.我遇到了一个我无法找到答案的问题.我是Threading的新手(在C#中),遇到了这个问题.我有这个带有效果的图像编辑器,但由于它运行得太慢,我试图将其拆分为线程.问题是他总是使用效果列表中的最后一项运行"CreatePreview"命令.因此,如果我激活了效果:"黑/白","Sature"和"GreenFilter",它将尝试使用greenfilter创建3个预览.
任何人都可以帮我解决这个问题吗？
private void CreatePreviews(string fileName, List<IEffect> effects)
{
List<Task> tasks = new List<Task>();
foreach (var effect in effects)
{
//previews.Add(effect, CreatePreview(fileName, effect));
Task task = new Task(delegate()
{
string result = CreatePreview(fileName, effect);
Dispatcher.BeginInvoke(new Action(
delegate()
{
ShowPreview(result, effect.DisplayName);
}));
});
task.Start();
}
}
这是示例代码.
var values = new List<string>() { "Stack", "Over", "Go" };
var funcs = new List<Func<string>>();
foreach(var v in values)
funcs.Add( ()=>v );
foreach(var f in funcs)
Console.WriteLine(f());
当我使用visual studio 2010运行此代码时,我得到的输出为:
Go Go Go
但是当我在visual studio 2012中尝试相同的代码时,输出是:
Stack Over Go
为什么表现不一样？
可能重复:
C#在foreach中重用变量是否有原因？
循环操作列表
今天我遇到了关于C#foreach函数的问题,它并没有像我预期的那样给我正确的结果.这是代码:
using System;
using System.Collections.Generic;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int[] data = new int[] { 1, 2, 3, 4, 5 };
List<Func<int>> actions = new List<Func<int>>();
foreach (int x in data)
{
actions.Add(delegate() { return x; });
}
foreach (var foo in actions)
{
Console.WriteLine(foo());
}
Console.ReadKey();
}
}
}
当我在控制台应用程序中运行它并且它在屏幕上打印了5个5.为什么？我只是无法理解.曾经问过一些人,他们只是说这个代码中有封闭,但我对此并不十分清楚,我记得在javascript中,我经常遇到封闭,但在上面的代码中,为什么会有封闭？谢谢.
考虑以下lua代码:
f = {}
for i = 1, 10 do
f[i] = function()
print(i .. " ")
end
end
for k = 1, 10 do
f[k]()
end
这将打印从1到10的数字.在这种情况下,i将关闭外部循环的每次迭代的值.这就是我一直都懂得闭合的方式,我很开心......
...直到我将一些lua代码移植到c#中,我试图做同样的事情:
var f = new Action[10];
for (int i = 0; i < 10; i++)
{
f[i] = (new Action(delegate()
{
Console.Write(i + " ");
}));
}
for (int k = 0; k < 10; k++)
{
f[k]();
}
现在我将10号打印10次(让我们忘记了lua数组是基于1的).实际上,在这种情况下,闭包对变量起作用,而不是它的值,这很有意义,因为我只是在第一个循环结束后调用函数.
JavaScript似乎具有相同的语义(接近变量):
var f = []
for (var i = 0; …我试图使用dict中的值副本为每个循环生成线程.
我最初的理解是,这foreach将创造一个新的范围,并导致:
Dictionary<string, string> Dict = new Dictionary<string, string>() { { "sr1", "1" }, { "sr2", "2" } };
foreach (KeyValuePair<string, string> record in Dict) {
new System.Threading.Timer(_ =>
{
Console.WriteLine(record.Value);
}, null, TimeSpan.Zero, new TimeSpan(0, 0, 5));
}
写道
1
2
2
2
而不是(预期):
1
2
1
2
所以我尝试在foreach中克隆kvp:
KeyValuePair<string, string> tmp = new KeyValuePair<string, string>(record.Key, record.Value);
但这会产生相同的结果.
我也试过了,System.Parallel.ForEach但似乎需要非动态的价值,这对我的字典来说有点火车粉碎.
如何用线程迭代我的字典？
下面的代码片段将输出数字“10”十次：
\n\ndelegate void Printer();\n\nstatic void Main()\n{\n List<Printer> printers = new List<Printer>();\n for (int i = 0; i < 10; i++)\n {\n printers.Add(delegate { Console.WriteLine(i); });\n }\n\n foreach (var printer in printers)\n {\n printer();\n }\n}\n这是因为（取自https://www.toptal.com/c-sharp/interview-questions#iquestion-90455）：
\n\n\n\n\n“委托被添加到 for 循环中，\xe2\x80\x9creference\xe2\x80\x9d 到 i 被存储，\n 而不是值本身。因此，在我们退出循环后，\n 变量 i 已被存储设置为 10，因此当每个委托被调用时，传递给所有委托的值都是 10。”
\n
我的问题是：为什么存储对 i 的“引用”？
\n我阅读了有关此主题的不同文章Eric Lippert 的博客和其他文章，并知道为什么这两个代码的工作方式不同
int[] values = { 7, 9, 13 };
List<Action> f = new List<Action>();
foreach (var value in values)
f.Add( () => Console.WriteLine("foreach value: " + value));
foreach (var item in f)
item();
f = new List<Action>();
for (int i = 0; i < values.Length; i++)
f.Add(() => Console.WriteLine("for value: " + ((i < values.Length) ? values[i] : i)));
foreach (var item in f)
item();
但我没有找到明确的解释，为什么最终（从编译器 c# 版本 5 开始）决定“foreach 循环变量在逻辑上将位于循环体内部，因此闭包每次都会获得一个新的副本”。因为旧的实现提供了使用闭包 Lambda 的更多自由（“按值或按引用”），但要求程序员小心使用它，如果您需要 foreach …
好吧,所以我在这里遇到了一些问题.这是循环.
lock (ClientLocker)
{
Trace.WriteLine("#WriteAll: " + sm.Header);
foreach (Client c in Clients)
{
if (c.LoggedIn)
{
Trace.WriteLine("#TryWriteTo[" + c.Id + "](" + sm.Header + ")");
LazyAsync.Invoke(() => c.WriteMessage(sm));
}
}
}
这是LazyAsync
public static class LazyAsync
{
public static void Invoke(Action a)
{
a.BeginInvoke(a.EndInvoke, null);
}
}
每个Client包含一个socket,所以我不能Clone这么做.问题是,当我执行Invoketo时c.WriteMessage,由于执行被延迟,它通常不会触发列表中的第一对,并且有时实际上只会在最后一项上触发一大堆.
我知道这与c是一个在Invoke实际被调用之前发生变化的引用有关,但有没有办法避免这种情况？
执行一般for(int i=0 etc循环似乎无法解决此问题.
任何人对我如何解决这个问题都有任何想法？
记住,不能Clone Client.