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.

The Boring Standard Method:

The Distinct method removes any duplicate entries in a collection without you needing to do much work, the same as the DISTINCT keyword inT-SQL. Here is the basic and standard use that is really not difficult to understand.

string[] names = new string[] { "Peter", "Paul", "Mary", "Peter", "Paul", "Mary", "Janet" };

foreach (string _name in names.Distinct())
{
Console.WriteLine(_name);
}

So like I said, easy enough, we have a string array with names and by using the .Distinct method we remove any duplicates from the resultset that is returned. Now comes the real fun!

Custom Distinct Implementation:

Since the advent of generics, most of us have been creating strongly typed lists of data. Plain example would be a list of our customer UserClass.

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

// 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 = 10, Name = "Rathlan", ID = 2 });
failBoyUsers.Add(new Users { AwesomeScore = 7, Name = "Joe", ID = 3 });
failBoyUsers.Add(new Users { AwesomeScore = 7, Name = "Joe", ID = 3 });
failBoyUsers.Add(new Users { AwesomeScore = 7, Name = "Joe", ID = 3 });
failBoyUsers.Add(new Users { AwesomeScore = 1, Name = "newbie", ID = 4 });

This would then give us a “strongly typed Array” of our User class. If we now had to call the .Distinct function on the collection it wouldn’t work! Thats because the CLR does not know what to evaluate to decide whether an entry is unique or a duplicate so it returns all the items including the duplicates. The Distinct method accepts an overload paramter, this object must implement the IEqualityComparer interface. So we declare a new class and implement IEqualityComparer as follows:

public class AwesomeComparer : IEqualityComparer<Users>
{
public bool Equals(Users x, Users y)
{
if (x == null || y == null)
return false;
else
return (x.Name.ToLower() == y.Name.ToLower() &&
x.AwesomeScore == y.AwesomeScore &&
x.ID == y.ID);
}

public int GetHashCode(Users obj)
{
return obj.Name.GetHashCode();
}
}

so what we do in the Equals Method is define what we feel a duplicate of our custom class looks like. We also implement the GetHashCode method to return the hash of the “primary field”. This will usually be the Primary Key that you class will be based on. Then we implement our Distinct method, we do so as follows:

AwesomeComparer awesomeComparer = new AwesomeComparer();

foreach (Users usr in failBoyUsers.Distinct(awesomeComparer))
{
Console.WriteLine(usr.ID.ToString() + " - " + usr.Name + " - " + usr.AwesomeScore.ToString());
}

And that will only return Distinct values from our custom class! I hope this helps someone at some stage as I never knew about this myself and stumbled onto it. Drop me a comment if you think I suck or if my some margain of luck I managed to produce some bug free code, I am after FailBoy for a reason

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

My stupidity lead me into trying to set the Path on each cookie. That, however,  wasn’t the problem. A Colleague of mine found the solution this morning though. After we log the user into the system we fire the following code:

FormsAuthentication.RedirectFromLoginPage(authToken, true);

However the RedirectFromLoginPage does take a 3rd parameter which will be the path that I’ve been trying to set. So now the code reads:

string applicationBasePath = Request.ApplicationPath;
FormsAuthentication.RedirectFromLoginPage(authToken, chkRememberMe.Checked, applicationBasePath);

So once that was done everything worked like a charm!

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.

<configuration>
   <runtime>
      <gcServer enabled="true"/>
   </runtime>
</configuration>

Why should you enable this though? How does it benefit your application? It comes down to the performance of your application on the server. Not how quick your page loads, but how well your application handles large volumes of traffic without your application falling over and dying. Here’s why! Server Garbage Collection creates one GC heap per processor, which are collected in parallel. This GC mode maximizes the number of requests per second. So imagine having a server with 4 gigs of RAM and a quad core CPU, your application would be able to withstand much larger amounts of traffic without the application running over of memory! Effectively, on a quad core CPU, you would have 4 Garbage Collectors working in unison!

It was really quick to implement and works really nicely.

protected string ToTinyURLS(string txt)
{
    Regex regx = new Regex("http://([\\w+?\\.\\w+])+([a-zA-Z0-9\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)_\\-\\=\\+\\\\\\/\\?\\.\\:\\;\\'\\,]*)?", RegexOptions.IgnoreCase);

    MatchCollection mactches = regx.Matches(txt);

    foreach (Match match in mactches)
    {
        string tURL = MakeTinyUrl(match.Value);
        txt = txt.Replace(match.Value, tURL);
    }

    return txt;
}

public static string MakeTinyUrl(string Url)
{
    try
    {
        if (Url.Length <= 12)
        {
            return Url;
        }
        if (!Url.ToLower().StartsWith("http") && !Url.ToLower().StartsWith("ftp"))
        {
            Url = "http://" + Url;
        }
        var request = WebRequest.Create("http://tinyurl.com/api-create.php?url=" + Url);
        var res = request.GetResponse();
        string text;
        using (var reader = new StreamReader(res.GetResponseStream()))
        {
            text = reader.ReadToEnd();
        }
        return text;
    }
    catch (Exception)
    {
        return Url;
    }
}

Hope this can as useful to you as it was for me!

Now I’m sure MS had their reasons for removing it but I don’t care and want it back So I’ve written a little extension method to convert the LiNQ resultset to a DataTable using a bit of Reflection. Here’s the code and enjoy! As always, I take no responsibility for its usage

/// <summary>
/// Converts an IEnumerable type collection into a DataTable
/// </summary>
/// <param name=”collection”>Collection type that implements IEnumberable</param>
/// <returns>Datatable representing IEnumerable collection</returns>
public static DataTable ToDataTable<T>(this IEnumerable<T>collection)
{
// Create DataTable to Fill
DataTable _newDataTable = new DataTable();

// Retrieve the Type passed into the Method
Type _impliedType = typeof(T);

//Get an array of the Type’s properties
PropertyInfo[] _propInfo = _impliedType.GetProperties();

//Create the columns in the DataTable
foreach (PropertyInfo pi in _propInfo)
{
_newDataTable.Columns.Add(pi.Name, pi.PropertyType);
}

//Populate the table
foreach (T item in collection)
{
DataRow _newDataRow = _newDataTable.NewRow();
_newDataRow.BeginEdit();

foreach (PropertyInfo pi in _propInfo)
{
_newDataRow[pi.Name] = pi.GetValue(item, null);
}

_newDataRow.EndEdit();
_newDataTable.Rows.Add(_newDataRow);
}

return _newDataTable;
}