Welcome to the Lounge

ZurdoDev wrote:

I agree. But I find it interesting how many experienced developers love using var. I feel like I must be missing something.

RugbyLeague wrote:

it removes a lot of unnecessary noise

var frobables = new List<Frobable>();
var frobables2 = GetFrobables(/*params*/);

var temp = db.tableName
             .Where(x => /*filter*/)
             .Select(x => new 
             {
                 x.Property1,
                 x.Property2,
                 x.Property3,
                 x.Property4
             });

var x = 6;
foreach (var x in y.GetAll())
...

rjmoses wrote:

I had forgotten some languages don't come with a debugger.

myCollection.Where(x => x.IsActive).ToList();

// vs.

myCollection.Where(IsActive).ToList();
// Elsewhere in the code.
private bool IsActive(Something x)
{
   return x.IsActive;
}

// If you'd write an actual function on a single line:
myCollection.Where(bool IsActive(MyObject x) { return x.IsActive; });

// Replace the {} with =>, the ; can then also be removed:
myCollection.Where(bool IsActive(MyObject x) => return x.IsActive);

// The return statement isn't necessary:
myCollection.Where(bool IsActive(MyObject x) => x.IsActive);

// Neither is a function name:
myCollection.Where(bool (MyObject x) => x.IsActive);

// Types can usually be inferred:
myCollection.Where((x) => x.IsActive);

// Remove redundant parenthesis:
myCollection.Where(x => x.IsActive);

// Example with multiple arguments, here you need parenthesis again:
myCollection.Where((x, y) => x.IsActive && y > 10);

// Sometimes the type can't be inferred:
myCollection.Where((MyObject x, int y) => x.IsActive && y > 10);

// You can (always) use full argument names if you like, although a single letter is common:
myCollection.Where((collectionItem, index) => collectionItem.IsActive && index > 10);