如何在vim中翻转窗口？(How to flip windows in vim? [duplicate])

 那么，它们在“构造函数”这个词的任何正常用法中都不是真正的“构造函数”。 
 
 它们是可以转换为委托类型或表达式树类型的表达式 - 后者在处理进程外的LINQ时非常重要。 
 
 如果你真的问是否期望使用两个“等价”lambda表达式可以创建不平等的委托实例：是的，它是。 IIRC，C＃语言规范甚至还声明这种情况。 
 
 但是，多次使用相同的lambda表达式不会总是创建不同的实例： 
 
using System;

class Test
{
    static void Main(string[] args)
    {
        Action[] actions = new Action[2];
        for (int i = 0; i < 2; i++)
        {
            actions[i] = () => Console.WriteLine("Hello");
        }
        Console.WriteLine(actions[0] == actions[1]);
    }
}
 
 在我的盒子上，它实际上打印了True - actions[0]和actions[1]具有完全相同的值 - 它们指向相同的实例。 事实上，我们可以走得更远： 
 
using System;

class Test
{
    static void Main(string[] args)
    {
        object x = CreateAction();
        object y = CreateAction();
        Console.WriteLine(x == y);
    }

    static Action CreateAction()
    {
        return () => Console.WriteLine("Hello");
    }
}
 
 再次，这打印True 。 不能保证，但在这里编译器实际上已经创建了一个静态字段来缓存第一次需要的委托 - 因为它没有捕获任何变量等。 
 
 基本上这是一个你不应该依赖的编译器实现细节。 

Well, they're not really "constructors" in any of the normal uses of the word "constructor".
 
They're expressions which can be converted to delegate types or expression tree types - the latter being essential when it comes to out-of-process LINQ.
 
If you're really asking whether it's expected that using two "equivalent" lambda expressions can create unequal delegate instances: yes, it is. IIRC, the C# language specification even calls out that that's the case.
 
However, using the same lambda expression more than once won't always create different instances:
 
using System;

class Test
{
    static void Main(string[] args)
    {
        Action[] actions = new Action[2];
        for (int i = 0; i < 2; i++)
        {
            actions[i] = () => Console.WriteLine("Hello");
        }
        Console.WriteLine(actions[0] == actions[1]);
    }
}
 
On my box, that actually prints True - actions[0] and actions[1] have the exact same value - they refer to the same instance. Indeed, we can go further:
 
using System;

class Test
{
    static void Main(string[] args)
    {
        object x = CreateAction();
        object y = CreateAction();
        Console.WriteLine(x == y);
    }

    static Action CreateAction()
    {
        return () => Console.WriteLine("Hello");
    }
}
 
Again, this prints True. It's not guaranteed to, but here the compiler has actually created a static field to cache the delegate the first time it's required - because it doesn't capture any variables etc.
 
Basically this is a compiler implementation detail which you should not rely on.