We Keep Coding

How to understand expressions as method parameters in C# [duplicate]

This question already has answers here:
Why would you use Expression<Func<T>> rather than Func<T>?
(12 answers)
Closed 3 years ago.
I am starting to see methods like the one below used more and more, but it's a concept that I don't fully understand.
public virtual Task<List<T>> GetAsync(Expression<Func<T, bool>> exp)
{
using (var conn = _factory.OpenDbConnection())
{
return conn.SelectAsync(exp);
}
}
Can someone help me translate the method parameter there that is an Expression? Like explain it as how it differs from a standard instance parameter?

These are called Expression Trees (https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/expression-trees/).
Basically it's a lamdba that can be translated to another platform, from the looks of it some kind of database in your case. This function would be translated (by a library) to SQL and then executed in the database.
Within the code of your program you would generally only need lambdas (Func<>), but in some cases you need an Expression Tree. Besides your example, sometimes you need a dynamically constructed function which can be done using these.
General information on lambdas can be found here: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions

c# confused with lambda expression in set property [duplicate]

This question already has answers here:
Lambda for getter and setter of property
(3 answers)
Closed 5 years ago.
I've read some code in setting property for a class like below
private int id;
public int ID {
get=>id;
set=>id=value;
}
and it works. But I'm totally confused by the lambda syntax.
I know that lambda expression would be (input-parameters) => expression.
how could it drop brackets in the left.
I've search the answer in google but not found. the likely answer would be that get&set should be equal to delegate, but I've no idea about this. Does someone has document about this?

You could find the usage of lambda of C# here
Quoted here:
To create a lambda expression, you specify input parameters (if any)
on the left side of the lambda operator =>, and you put the expression
or statement block on the other side.
Note the (if any)

As Furmek mentioned, these are called expression bodied members. These are similar, but different than lambda functions.
Another way of writing this is:
public int ID { get; set; }

Lambda function in C# context and OOP [closed]

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 5 years ago.
Improve this question
I am a beginner in c# and really interested in learning the language by going deeper. Recently used Lambda function to make a piece of my code but no idea how it worked.
I was mapping values from a list by writing hard code. See below:
var validRatings = new List<int> { 1, 2, 3, 4, 5 };
Used Lambda and it worked:
var validRatings = settings.grossAlphas.Select(ga => ga.fundRating).ToList();
I understand Lambda functions are anonymous but how are they different than regular functions and how do they fit in OOP context within C#?

Lambda functions are anonymous but how are they different than regular functions?
"How are X and Y different?" is in general not a good question for StackOverflow. Here, here's an apple tree and an oak tree; how are they different? Hard to say.
Briefly though:
Lambdas can be converted to delegates or expression trees. Regular functions can only be converted to delegates.
Lambdas can be expression bodied or statement bodied. Before C# 6, regular functions could only be statement bodied.
Lambdas can have their formal parameter types inferred from context; regular functions cannot.
how do they fit in OOP context within C#?
They don't. Lambdas are an idea from functional programming, not from object oriented programming. The fundamental idea of OOP is that functionality is logically connected to data; lambdas are the exact opposite of that. Lambdas are about the decoupling of functions from data objects.
If that doesn't answer your question, then ask a more clear question. What do you mean by "the oop context"?

A normal method can be called by name anytime in the code, but there are cases when we need some block of code that would be executed just once or the caller is only one, so if you see in the above code.
The main purpose of lambda expressions is to give calling code flexibility to pass it's own implementation, for example in the above case, you can have specified your own implementation and project my original collection to a new collection which contains one property named fundRating, chances are you only need this block of code for this use case, so lambda expression creates anonymous method which can only be called by the Select() method implementation.
Hope it helps!

You could create a function and name it, like so:
private string getFundRating(GrossAlpha ga)
{
return ga.fundRating;
}
And then you could pass that function in your Select. like so:
var validRatings = settings.grossAlphas.Select(getFundRating).ToList();
This would be an example of not using a lambda. In that case you are using a named function. You could use the same function somewhere else in your code or in another linq statement.
In the example you provided, you create a function on the fly, don't even name it and pass it in the Select.
Note: I assumed you had an object named GrossAlpha, and that settings.grossAlphas returns a list of those.
Regarding the other part of your question. How do they fit in the context of OOP, I can't explain it much better than Eric Lippert did.

A simple way to think of an anonymous method, albeit not a pure definition, is a method that you want to use once and move on. They're called anonymous because the aren't named methods. Lambdas, in C#, are an extremely powerful way of linking commonly used methods based on your individual objects.
What your code is doing, in one line would take many lines to write out unique methods based on every one of your classes.
To break down what your code is doing dot-by-dot:
var validRatings = settings.grossAlphas.Select(ga => ga.fundRating).ToList();
grossAlphas.Select(...): is walking through your enumeration (List, Array, etc...) object by object and aggregating them according to the parameters you supply inside the .Select(...).
ga => ga.fundRating: you are saying that you want to aggrigate ONLY the fundRating attribute from each object.
.ToList(): is making your enumeration into a List<int>().
This saves you from writing a List<int> GetFundRatings() for a single time you need to use a list of FundRatings.
Also see:
What is a lambda (function)?
C# Lambda expressions: Why should I use them?

Implicit delegate allocation when assigning to events? [duplicate]

This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
C#: Difference between ' += anEvent' and ' += new EventHandler(anEvent)'
In C# .NET 3.5, the compiler doesn't care if I do this (assume ButtonClickHandler is a function):
button.OnButtonClicked += ButtonClickHandler;
or:
button.OnButtonClicked += new ButtonClickHandlerDelegate( ButtonClickHandler );
Are these functionally the same? I read the stackoverflow question below, but I'm not sure if it applies to this scenario as well:
The difference between implicit and explicit delegate creation (with and without generics)

Yes, the first is simply syntactic sugar for the latter. The compiler simply infers the type of the delegate and constructs it for you. The exact same IL will be emitted by the compiler.
The first, shorter and cleaner syntax (delegate inference - which I recommend you use for readability), was added in C#2 - that is why some designers (also Microsoft's) tend to use the long and more verbose syntax of newing the delegate.
Actually, I think this is a duplicate of this prior question.

In C# 4 this will produce identical code, so yes they are functionally the same.
In the first (shorter) form the compiler infers the delegate type from the method signature, which saves you the work having to do it explicitly.

The name of the => operator in C# [duplicate]

This question already has answers here:
Closed 12 years ago.
Possible Duplicate:
What is the => token called?
Hey,
In LINQ what is the name of the => operator e.g:
list.Where(a => a.value == 5);

It's called the lambda operator and is pronounced "goes to".
From here.

It's the lambda operator. Or at least, an expression of the form
x => y
(or any of the longer forms involving =>) is a lambda expression. (I don't personally tend to think of it as an operator as such, even though the linked page refers to the lambda operator. The C# 4 spec doesn't contain the phrase "lambda operator" anywhere.)

The lambda operator.

You read it as "such that". So your example reads as "list where a such that a dot value equals 5"

its called ... lambda

Its used to create delegates or expression tree types, and yes the new term for it is lambda expression