Difference between lambda and LINQ? [duplicate]

Answer 1

Language-Integrated Query (LINQ) is a set of features introduced in Visual Studio 2008 that extends powerful query capabilities to the language syntax of C# and Visual Basic

A lambda expression is an anonymous function that you can use to create delegates or expression tree types. By using lambda expressions, you can write local functions that can be passed as arguments or returned as the value of function calls.

Linq uses Lambda expression in order to execute some of its functionalities.

Example:

new [] { "Dan", "Yossi", "Ben" }.Where(item => item.Length == 3);

Lambda expression: item => item.Length == 3
Linq: (from item in (new [] { "Dan", "Yossi", "Ben" }) where item.Length == 3)

Answer 2

LINQ is a library that contains a set of extension methods (mostly to IEnumerable) that makes heavy uses of lambdas. The lambda is itself an anonymous delegate and is just simple syntax sugar. It gives you an easy way to define a function "in line" and pass that function to some method.

for example you can write the above code like this:

var result = object.Where(delegate(e) { 
     return e.objectParameter > 5; 
}).Any()

Answer 3

Linq (Language Integrated Query) can use Lambdas (Lambda Expressions) but doesn't have to.

This is Linq:

var a = from b in someList
        where b.Value == something
        select b;

But can be written with a Lambda:

var a = someList.Where(b => b.Value == something);

The Lambda is b => b.Value == something.

---

Where as mock.Setup(m => m.SomeOp()).Returns(new Thing()); uses a Lambda (the m => m.SomeOp()), but has nothing to do with Linq.

Answer 4

Lambdas are simply a syntax for expressing anonymous methods, which have existed in the language since .NET 2.0.

There isn't much difference between e => e.objectParameter > 5, a lambda which takes an object e and returns a boolean, and the older syntax, delegate(MyObj e) { return e.objectParameter > 5;}. If you're using Resharper, you can use it to translate any lambda to an anonymous method and vice versa.

As such, lambdas aren't equivalent to LINQ, they're a shorthand syntax for anonymous functions. However, they're a stepping stone towards LINQ.

LINQ is, in its essence, a way to filter, transform and manipulate collections using techniques borrowed from functional programming. These techniques rely on the concept of Functions as First Class Objects, meaning you call a method (say, your Where above) and pass it a function which determines how the Where filters. Using C# before lambdas, this would have been very cumbersome, with the coder forced to use the verbose anonymous delegate syntax, or create a named method for each Where call. (To see how clunky this can look, check out Java 7's anonymous types). So lambdas were added to the language to allow LINQ queries to be succinct, readable and (frankly) usable.