相关疑难解决方法(0)

什么是关闭？我们在.NET中有它们吗？

如果它们确实存在于.NET中,您能否提供一个代码片段(最好用C#)来解释它？

编辑:我浏览了Jon Skeet的文章,了解什么是闭包以及如何在.NET中使用它们.

在这个答案中,https: //stackoverflow.com/a/8649429/1497 Eric Lippert说"我们很有可能在下一版本的C#中解决这个问题;对于开发人员而言,这是一个主要的痛点". foreach循环使用变量.

在下一个版本中,每次运行"foreach"循环时,我们将生成一个新的循环变量,而不是每次都关闭相同的变量.这是一个"突破"的变化,但在绝大多数情况下,"休息"将是修复而不是导致错误.

我无法找到任何表明此更改尚未完成的内容.有没有迹象表明这是foreach循环在C#5中的工作方式？

虽然F#和IronPython语言在技术上不同,但我认为它们的潜在用途之间存在很大的重叠.什么时候比另一个更适用？

到目前为止,我认为F#在计算上更有效率,而IronPython从Python继承了更好的库.我很高兴得到纠正.

有一个相关的问题是F#to IronPython/IronRuby,因为C#是VB.NET的？但大多数答案都是关于语言范式而不是它们的实际适用性.

编辑:我想我应该添加更多背景.我一般都对Python有很好的经验,并且刚刚在一些犹豫不决的函数编程步骤之后学习了F#,主要是在Erlang中.我目前觉得能够继续使用Python或F#.我想决定我应该使用哪一个以及在哪里.例如:

1. Python作为标准库的一部分具有非常好的数据结构.前几天我需要一个相当于Python的heap模块,它在标准的F#/ .net库中不可用.指向IronPython.
2. F#可用于构建更方便的库,更易于从其他.Net语言访问.所以对于.Net驻留库我更喜欢F#.
3. 跨平台开发.IronPython在这里更好.F#/ Mono可用是一个小得多的平台集,F#/ OCaml兼容性不易维护,特别是在库方面.
4. IronPython交互式shell在我看来比fsi更容易.因人而异.

因此,问题归结为:除了偏好一种范式而不是另一种或某些团队或公司偏好之外,还有什么理由可以让你选择F#而不是IronPython,反之亦然？假设你对两者都有同样的信心？或者它们是否完全等同于所有实际目的？

编辑:好的,看起来你认为这是一个愚蠢的问题,低估它和答案.但至少它是诚实的.所以请提示一下.是不是可以区分这两者,还是我通过提出这个问题进入一些秘密禁忌？如果它看起来像一个巨魔可以有人请通知我？

我正在使用jQuery,我有一个我不明白的奇怪的事情.我有一些代码:

for (i = 1; i <= some_number; i++) {
    $("#some_button" + i).click(function() {
        alert(i);
    });
}

正如名字所说的"#some_button" - 它们是一些按钮.点击它们时,应该弹出一个带有它号码的方框,对吗？但他们没有.如果有4个按钮,它们总是弹出"5"(按钮计数+ 1).为什么会这样？

这可以在for循环中完成吗？

        TickEventArgs targs1 = new TickEventArgs(lbl1_up_time, _elapsedTime_up1);
        timer_up1.Tick += (sender, e) => Tick(targs1);

        TickEventArgs targs2 = new TickEventArgs(lbl2_up_time, _elapsedTime_up2);
        timer_up2.Tick += (sender, e) => Tick(targs2);

        TickEventArgs targs3 = new TickEventArgs(lbl3_up_time, _elapsedTime_up3);
        timer_up3.Tick += (sender, e) => Tick(targs3);

        TickEventArgs targs4 = new TickEventArgs(lbl4_up_time, _elapsedTime_up4);
        timer_up4.Tick += (sender, e) => Tick(targs4);

        TickEventArgs targs5 = new TickEventArgs(lbl5_up_time, _elapsedTime_up5);
        timer_up5.Tick += (sender, e) => Tick(targs5);

这不起作用,因为我超出界限(5)

        targs[0] = new TickEventArgs(lbl1_up_time, _elapsedTime_up1);
        targs[1] = new TickEventArgs(lbl2_up_time, _elapsedTime_up2);
        targs[2] = new TickEventArgs(lbl3_up_time, _elapsedTime_up3);
        targs[3] = new …

我有一个非常简单的服务,

public class AzureService : IAzureService
{
    private readonly CloudBlobContainer _container;
    public AzureService(ISettings settings)
    {
        var storageAccount = CloudStorageAccount.Parse(settings.BlobConnectionString);            
        var blobClient = storageAccount.CreateCloudBlobClient();
        _container = blobClient.GetContainerReference(settings.BlobContainerName);
    }

    public Task UploadBlobAsync(string fileName, Stream stream)
    {
        var blob = _container.GetBlockBlobReference(fileName);
        return blob.UploadFromStreamAsync(stream);
    }

    public Task DeleteBlobAsync(string fileName)
    {
        var blob = _container.GetBlockBlobReference(fileName);
        return blob.DeleteAsync();
    }
}

这个方法叫做,

    public Task SaveAllAsync(Dictionary<string, Stream> images)
    {
        var tasks = new List<Task>();
        foreach (var image in images)
        {
            var fileName = image.Key;
            var stream = image.Value; …

我打算发一个问题,但提前想出来并决定发布问题和答案 - 或者至少我的意见.

当使用匿名委托作为WaitCallback时,在foreach循环中调用ThreadPool.QueueUserWorkItem时,似乎将相同的一个foreach-value传递到每个线程.

List< Thing > things = MyDb.GetTheThings();
foreach( Thing t in Things)
{
    localLogger.DebugFormat( "About to queue thing [{0}].", t.Id );
    ThreadPool.QueueUserWorkItem(
        delegate()
        {
            try
            {
                WorkWithOneThing( t );
            }
            finally
            {
                Cleanup();
                localLogger.DebugFormat("Thing [{0}] has been queued and run by the delegate.", t.Id ); 
            }
        });
 }

对于事物中的16个Thing实例的集合,我观察到传递给WorkWithOneThing的每个'Thing'对应于'things'列表中的最后一个项目.

我怀疑这是因为委托正在访问't'外部变量.请注意,我还尝试将Thing作为参数传递给匿名委托,但行为仍然不正确.

当我重新考虑代码以使用命名的WaitCallback方法并将Thing't'传递给方法时,瞧......事物的第一个实例被正确地传递给了WorkWithOneThing.

我想是平行学的一课.我还想象Parallel.For系列解决了这个问题,但是这个库不是我们的选择.

希望这能节省一些时间.

霍华德霍夫曼

我试图同时运行几个任务,我遇到了一个似乎无法理解或解决的问题.

我以前有这样的功能:

private void async DoThings(int index, bool b) {
    await SomeAsynchronousTasks();
    var item = items[index];
    item.DoSomeProcessing();
    if(b)
        AVolatileList[index] = item; //volatile or not, it does not work
    else
        AnotherVolatileList[index] = item;
}

我想用for循环调用Task.Run().但是我找不到向这个发送参数的方法,Action<int, bool>并且每个人都建议在类似的情况下使用lambdas:

for(int index = 0; index < MAX; index++) { //let's say that MAX equals 400 
    bool b = CheckSomething();
    Task.Run(async () => {
        await SomeAsynchronousTasks();
        var item = items[index]; //here, index is always evaluated at 400
        item.DoSomeProcessing();
        if(b)
            AVolatileList[index] …

我有一段代码,我认为因为封闭而可以工作; 但是,结果证明不是这样.这里发生了什么不能产生预期的输出(每个单词之一)？

码:

string[] source = new string[] {"this", "that", "other"};
List<Thread> testThreads = new List<Thread>();
foreach (string text in source)
{
    testThreads.Add(new Thread(() =>
    {
        Console.WriteLine(text);
    }));
}

testThreads.ForEach(t => t.Start())

输出:

other
other
other

由于以下问题,我正在撕掉我的头发.我有一些代码循环遍历对象列表并为每个对象创建一个处理任务.

        IList<TileInfo> tiles = tileSource.Schema.GetTilesInView(extent, level);
        List<Task> renderingTasks = new List<Task>();
        foreach (TileInfo info in tiles) {
            renderingTasks.Add(Task.Factory.StartNew(new Action(delegate {
                Console.WriteLine(Task.CurrentId +"Info object"+ info.GetHashCode());
                             }
                         })));
        }

此代码打印:

1Info object36963566
2Info object36963566
3Info object36963566
4Info object36963566
5Info object36963566
6Info object36963566
7Info object36963566
8Info object36963566
9Info object36963566
10Info object36963566
11Info object36963566
12Info object36963566
...

正如您所看到的,问题是任务似乎都引用了一个对象!

为什么这些任务都只使用列表中的一个对象？

谢谢你的帮助

我遇到这个简单代码的问题,我不明白为什么c#这样做.

问题似乎是c#在列表中使用列表时使用Linq表达式引用而不是值.

在数字循环中,我根据列表选择数字,它们都存在,所以所有数字都应该添加到列表{1,2,3}中.

当您在控制台中看到数字循环中显示{1,2,3}的输出时,行为正常.

问题在于列表的循环,在这里似乎Linq只将最后一个数字添加到列表中,因此它输出{3,3,3}.

我知道我不需要列表中的整数列表,但这只是为了证明这一点非常奇怪,这是一个已知的"错误"吗？

编辑:这似乎是它应该在5.0之前的c#中工作.在C#5.0(VS2012 +编译器)中,此行为已被修改为我所期望的

static void Main()
{
    var list = new List<IEnumerable<int>>();
    var numbers = new[] {1, 2, 3};
    var numbers2 = new[] {1, 2, 3};

    foreach (var number in numbers)
    {
        var result = from s in numbers2
                     where s == number
                     select s;

        Console.WriteLine(result.First()); // outputs {1,2,3}
        list.Add(result);
    }

    foreach (var num in list)
    {
        Console.WriteLine(num.First()); // outputs {3,3,3}
    }
}

产量

1 2 3 3 3 3

我的目标是从源可观察源创建一组observable,以便我可以单独订阅它们.

当我手动执行此操作(即手动创建每个子源)时,事情按预期工作:添加到原始源的值充分传播到子源.

但是当我在循环中创建它们,将它们添加到a时List<IObservable<T>>,从该列表中获取的元素的订阅似乎不起作用:

class Program
{
    static void Main(string[] args)
    {
        // using Subject for the sake of example
        var source = new Subject<int>(); 


        // manually creating each subSource
        var source0 = source.Where((t, i) => i % 3 == 0);
        var source1 = source.Where((t, i) => i % 3 == 1);
        var source2 = source.Where((t, i) => i % 3 == 2);


        // creating a List of subsources
        List<IObservable<int>> sources = new List<IObservable<int>>();

        int count = 3;

        for …

本程序应将.txt文件重命名为.txtok.在我的测试目录中,我创建了~10个文本文件.

在运行时,抛出了FileNotFoundException.丢失的文件是一个已经在之前的线程中重命名的文件.

似乎多个线程已经在一个Loop-Iteration中启动了!？

static void Main(string[] args)
    {
        foreach (String s in Directory.EnumerateFiles(@"C:\Test", "*.txt", SearchOption.TopDirectoryOnly))
        {
            new Thread(() =>
            {
                File.Move(s, s + "ok");
            }).Start();                
        }
        Console.ReadKey();
    }

有人有问题吗？

谢谢