linq和lambda

Kzu and friends have a new pet project called Moq, which may be the coolest derivative open source project name ever. But, before I get into that...

Kzu和朋友有一个名为Moq的新宠物项目，这可能是有史以来最酷的衍生开源项目名称。 但是，在我开始之前...

There's lots of interesting Mock Object Frameworks out there. The ones that you'll always hear about (because they are awesome) are Rhino.Mocks and TypeMock (Full Disclosure: we used TypeMock at Corillian, my last job. Here's a Case Study that was done.)

有很多有趣的Mock对象框架。 您会经常听到的(因为它们很棒)是Rhino.Mocks和TypeMock (完整披露：我们在上次工作的Corillian使用TypeMock。这是完成的一个案例研究。 )

Both frameworks are very powerful. Here's Phil Haack's post on mocking IHttpRequest and IHttpReponse in the new MVC Framework using Rhino Mocks. Here's Travis Illig using TypeMock to mock the actual HttpContext (not the MVC interface) earlier this year.

这两个框架都非常强大。 这是Phil Haack在使用Rhino Mocks的新MVC框架中模拟IHttpRequest和IHttpReponse的文章。 这是Travis Illig在今年早些时候使用TypeMock模拟实际的HttpContext(不是MVC接口)的情况。

One of the things that often comes up when comparing Mock Frameworks, after their core capabilities, is their syntax.

在比较Mock框架的核心功能之后，经常会想到的一件事就是它们的语法。

Early Mocking frameworks like NMock (which isn't really used much anymore) mock interfaces and use a quasi-fluent interface that breaks down when you start referring to methods and properties using strings. Why is this bad? Well, for one it means when you refactor using tools like CodeRush or Resharper the system doesn't realize that a string referring to "Foo" means the method x.Foo(). For example, here's a snippet from NMock:

早期的Mocking框架(例如NMock) (不再使用了)模拟了接口，并使用了准流利的接口，当您开始使用字符串引用方法和属性时，该接口会崩溃。 为什么这样不好？ 好吧，对于这意味着，当您使用诸如CodeRush或Resharper之类的工具进行重构时，系统不会意识到引用“ Foo”的字符串表示方法x.Foo()。 例如，这是NMock的片段：

   mocks = new Mockery();ITransferFundsView mockView = mocks.NewMock<ITransferFundsView>();Expect.Once.On(mockView).GetProperty("Amount").Will(Return.Value(200.00));

You get the idea. We're referring to a property "FromAccount" via a string passed into GetProperty, rather than in a strongly typed way.

你明白了。 我们通过传递给GetProperty的字符串而不是强类型方式来引用属性“ FromAccount”。

RhinoMock is smarter, and might look like this snippet:

RhinoMock更加智能，可能看起来像以下片段：

     mockView = (ITransferFundsView)mocks.CreateType(typeof(ITransferFundsView)); 

     SetupResult.For(mockView.Amount).Return(200.00);

See how much clearer it is to just call the property?

看到仅调用该属性要清楚多少？

TypeMock is implemented as a profiler under the covers so it can do some pretty powerful stuff like "recording" your expectations do you can Tivo them back. So with TypeMock you'd do this using their "Natural TypeMock" syntax.:

TypeMock是作为幕后分析器实现的，因此它可以执行一些非常强大的工作，例如“记录”您的期望，也可以将其翻转。 因此，使用TypeMock，您可以使用其“ Natural TypeMock”语法进行此操作。

 using (RecordExpectations recorder = RecorderManager.StartRecording()) {    double foo = mockView.Ammount;    recorder.Return(200.00); } //the next time you call mockView.Ammount, it will return 200.00.

Either way, you can see why both RhinoMocks and TypeMock's syntaxs would be refactoring tool friendly. They compile against the real method signatures and properties so they can been "seen" by the tool. As for which one you like, that's a religious argument I won't get into, but depending on what you need, both are fine choices and they each have a very friendly syntax.

无论哪种方式，您都可以看到为什么RhinoMocks和TypeMock的语法都将重构工具友好。 它们根据实际的方法签名和属性进行编译，因此可以通过工具“看到”它们。 至于您喜欢哪一种，我不会讲这是一种宗教论据，但是根据您的需要，两者都是不错的选择，并且每种语法都非常友好。

Why all this background? There's a new Mocking Framework in town, and it's C# 3.0 specific using LINQ Expression Trees and Lambda Expressions.

为什么所有这些背景？ 镇上有一个新的Mocking框架，它使用LINQ表达式树和Lambda表达式特定于C＃3.0。

The same snippet in Moq might look like this:

Moq中的相同代码段可能如下所示：

var mockView = new Mock<ITransferFundsView>;mockView.Expect(x => x.Amount).Returns(200.00);

Note the use of Generics for the Type ITransferFundsView and the interesting use of a Lambda expression to indicate a mocked call to the Amount property. Check out the Moq QuickStart for more interesting examples.

注意类型ITransferFundsView使用泛型，以及有趣的使用Lambda表达式来指示对Amount属性的模拟调用。 请查看Moq快速入门，以获取更多有趣的示例。

Here's another deeper, more interesting example that shows how lambdas might really be a great feature for any .NET Mock Framework. It's the "It" class combined with the power of predicates.

这是另一个更深入，更有趣的示例，该示例说明了lambda如何真正成为任何.NET Mock Framework的强大功能。 这是“ It”类，结合谓词的功能。

The It class provides for a kind of wildcard support. There's an IsAny, IsInRange and IsRegex. The coolest one though is the plain It.Is method that receives a predicate!

It类提供了一种通配符支持。 有一个IsAny ， IsInRange和IsRegex 。 不过，最酷的是接收谓词的普通It.Is方法！

mock.Expect(x => x.DoInt(It.Is<int>(i => i % 2 == 0))).Returns(1);

 mock.Expect(x => x.DoInt(It.Is<int>(i => i % 2 == 0))).Returns(1);

Here the mocked object will return the value 1 only if the integer passed to the DoInt method is an even number.

在此，仅当传递给DoInt方法的整数为偶数时，模拟对象才会返回值1。

The cool thing about this approach is that you don't need the mocking library to provide all the filters you need, as you can simply pass a predicate for any condition you can dream of.

这种方法的妙处在于，您不需要模拟库来提供所需的所有过滤器，因为您可以简单地为您可以梦想的任何条件传递谓词。

Slick. Moq is definitely a project to watch.

光滑最小起订量绝对是一个值得关注的项目。

翻译自: https://www.hanselman.com/blog/moq-linq-lambdas-and-predicates-applied-to-mock-objects

linq和lambda