int x = 0;

you declare it as:

int? x = 0;

Now in coding examples all over the web I’m seeing the same logic and its driving me nuts!

if(x == null){
    x = -1;
}

There is a much shorter route and that is:

x = x ?? -1;

The “??” operator works exactly the same way an ISNULL function call works in SQL. It evaluates the variable on the left of the operator to ensure its not null (or undefined as some people call it), and if it is, it uses the value on the right of the ?? operator. Quick and easy.

Assume we have a basic class that contains a Name, ID and AwesomeScore for Users.

public class Users
{
public int ID {get; set;}
public string Name {get; set;}
public int AwesomeScore {get; set;}
}

So as you can see there’s nothing difficult about that. Its a basic class definition. So lets create a basic console application and fill a List of Users so we can work with that:

public static void Main(string[] args)
{
// Create and populate new list of Users
List<Users> failBoyUsers = new List<Users>();
failBoyUsers.Add(new Users { AwesomeScore = 7, Name = "FailBoy", ID = 1 });
failBoyUsers.Add(new Users { AwesomeScore = 10, Name = "Rathlan", ID = 2 });
failBoyUsers.Add(new Users { AwesomeScore = 9, Name = "Joe", ID = 3 });
failBoyUsers.Add(new Users { AwesomeScore = 1, Name = "newbie", ID = 4 });
}

So here we create a Generic List Collection of Users. So our failBoyUsers collection now contains 4 users with varying scores. Now, originally before the wonders of learning how to use Lambda’s, I would’ve done the following to return the users with an AwesomeScore of 8 or over:

public static List GetAwesomestPeople(List<Users> usersToSort)
{
List<Users> returnList = new List<Users>();

foreach (Users userItem in usersToSort)
{
if (userItem.AwesomeScore >= 8 )
{
returnList.Add(userItem);
}
}

return returnList;
}

So yeah, that was me, FailBoy being very intelligent. Now, that same functionality using Lambda’s.

public static IQueryable GetAwesomestPeopleLAMBDA(IQueryable usersToSort)
{
return usersToSort.Where(user => user.AwesomeScore >= 8).AsQueryable();
}

Thats right! Using Lambda’s its a single line. So lets look at that line, I pass in the usersToSort as IQueryable instead of the List. Converting from the List to IQueryable is as easy as passing the List parameter in and simply adding .AsQueryable() to the end of the parameter name! So it would be called as :

IQueryable awesomeOkes = GetAwesomestPeopleLAMBDA(failBoyUsers.AsQueryable());

Then I use the .Where() method which is an extension method on the IQueryable collection class and as such on the List<> class since List<> inherits from IEnumerable and IEnumerable inherits from IQueryable. The fun comes in where I pass the argument into the .Where() method.

user => user.AwesomeScore >= 8

Here I am declaring a new variable called user. The variable is an instance of the Collection we want to sort, in this case usersToSort. the “=>” is what is referred to as the Lambda operator. After the Lambda operator we specify our condition. In this as we only want the users with an AwesomeScore of 8 or higher. I then append the

.AsQueryable()

because we want to return the resultset as an IQueryable Collection of Users.

Using Lambda’s I’m condensed 9 lines of code into 1 line of code. And the less you need to code, the more time you save! I hope this is helpful to you! I’ve included the full code below.

FailBoy

It seems that .Net’s garbage collection retains a reference to the SqlParameter used in the first SqlCommand. This reference seems to survive the closing and even disposing of the connection in use. As long as the SqlCommand object is in use, .Net seems to remember that it has already been used. To bypass this, simply call the sqlCommand.Parameters.Clear() method. You’ll need to readd the SqlParameter or SqlParameter[] to the SqlCommand and it’ll work.