Toughest Developer Puzzle Ever

Filed Under (.NET, Development, Web Development) by Robert Green on 02-07-2009

Tagged Under :

Jeff Blankenburg has put together an incredible puzzle over at http://www.toughestdeveloperpuzzleever.com/tdpe/. Absolutely a ton of fun. It took me a few hours to get through it myself!

Left Joins in LINQ

Filed Under (.NET, Development) by Robert Green on 19-06-2009

Tagged Under : ,

For some reason it seems that I often need to perform a left join in LINQ. Every time I need to do this I find myself scouring the web one more time in order to remember how a left join works in LINQ. So how does it work? The best example that I’ve found is here. The example looks something like this:


1
2
3
4
5
6
7
8
9
10
var list = from r in dc.tblRooms
             join ui in dc.tblUserInfos
             on r.UserName equals ui.UserName into userrooms
             where r.CourseID == 1848
             from ur in userrooms.DefaultIfEmpty()
             select new{
                 FirstName = (ur.FirstName == null) ? "N/A" : ur.FirstName,
                 LastName = (ur.LastName == null) ? "N/A" : ur.LastName,
                 RoomName = r.Name
              };

I like this example a lot because it is very straight forward. Personally I would like to make the statement a bit more generic. In order to do that all we need to remember is that every Left Join has a left table A and a right table B. All the results from the A will be returned regardless of the join with B. In my example I will call table A the LEFT_TABLE and table B the RIGHT_TABLE.


1
2
3
4
5
6
var list =  from LT in LEFT_TABLE
	      join RT in RIGHT_TABLE
	      on LT.key equals RT.KEY into NEW_TABLE
              where <CONDITIONS>
              from NT in NEW_TABLE.DefaultIfEmpty()
              <SELECT_STATEMENT>;

The only problem that may occur with this left join occurs with the DefaultIfEmpty() operator. A better practice would be to pass in a default value so that we can know what to expect in return.

The Future of Web Pages

Filed Under (.NET, Development, PHP, Web Development) by Robert Green on 11-06-2009

Tagged Under : ,

This morning I came across this jQuery library and it got me to thinking a little bit. All of the web sites that I currently have coded ( I don’t really do the design) tend to use .NET or PHP that is mashed up with some Javascript here and there.


I’m wondering why we tend to still use PHP and .NET except for things that are absolutely on the back end. Why would I use .NET or PHP to manipulate elements in a page when I can just use JavaScript?


Maybe the web community should start developing pages that are JavaScript run and call PHP/.NET WebServices. That puts all the processing for display on the JS and all the data manipulation and retrieval where it should be – on the server.


Any thoughts?

Capitalize A String in C#

Filed Under (.NET, Development) by Robert Green on 27-05-2009

Tagged Under :

Capitalizing a string is a rather trivial task in C#. There are 2 ways to approach single word capitalization where each method includes 3 steps. Method 1 uses only strings and string methods while method 2 treats the letter to be capitalized as a char.

Method 1:

  1. Get the first character as a string ( stringToCapitalize.Substring(0,1) )
  2. Transform the first character to uppercase ( stringToCapitalize.Substring(0,1).ToUpper() )
  3. Append the rest of the string ( stringToCapitalize.Substring(0,1).ToUpper() + stringToCapitalize.Substring(1) )


1
2
3
4
5
6
7
8
9
10
public static string Capitalize(string toCapitalize) {
    try {
        if(toCapitalize.Length > 1) {
            toCapitalize = toCapitalize.Substring(0, 1).ToUpper() + toCapitalize.Substring(1);
        }
    } catch(Exception ex) {
        ExceptionHandling.ExceptionLogging(ex, "Error:Capitalize.");
    }
    return toCapitalize;
}


Method 2:

  1. Get the first character as a char ( stringToCapitalize[0] )
  2. Transform the first character to uppercase using the char.toUpper method ( char.toUpper(stringToCapitalize[0]) )
  3. Append the rest of the string ( char.toUpper(stringToCapitalize.Substring[0]) + stringToCapitalize.Substring(1) )


1
2
3
4
5
6
7
8
9
10
public static string Capitalize(string toCapitalize) {
    try {
        if(toCapitalize.Length > 1) {
            toCapitalize = char.ToUpper(toCapitalize[0]) + toCapitalize.Substring(1);
        }
    } catch(Exception ex) {
        ExceptionHandling.ExceptionLogging(ex, "Error:Capitalize.");
    }
    return toCapitalize;
}

Using either of these methods you could create an extension method as well. Something like this:

1
2
3
4
5
6
7
8
9
10
public static class MyExtensions
{
    public static string Capitalize(this String toCapitalize)
    {
        if(toCapitalize.Length > 1) {
            toCapitalize = toCapitalize.Substring(0, 1).ToUpper() + toCapitalize.Substring(1);
        }
        return toCapitalize;
    }
}

Replace HTML Text without Regular Expressions

Filed Under (.NET, Development, Web Development) by manatarms on 21-05-2009

One of my latest job requirements was replacing some basic American English words with some more British words ( color-colour, favor-favour, etc.). The original iteration of this project used JavaScript to scan the page content and the replace the words properly. The only problem with this version is that AJAX calls would make browsers complain about breaking the DOM. The script for this iteration was:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
function replaceTerms(){	
	var searchArray = new Array("favors","labors","colors","favor","labor","color");
	var replaceArray = new Array("favours","labours","colours","favour","labour","colour");
 
	if (!document.body || typeof(document.body.innerHTML) == "undefined") {
		//alert("Sorry, for some reason the text of this page is unavailable. Searching will not work.");
		return false;
	}
 
	var bodyText = document.body.innerHTML;
	for (var i = 0; i < searchArray.length; i++) {
		bodyText = doReplace(bodyText, searchArray[i], replaceArray[i]);
	}
 
	//document.body.innerHTML = bodyText;
	return true;
}
 
function doReplace(bodyText, searchTerm, replaceWith) {
 
	// find all occurences of the search term in the given text, and add some "highlight" tags to them (we're not using a
	// regular expression search, because we want to filter out matches that occur within HTML tags and script blocks, so
	// we have to do a little extra validation)
 
	var newText = "";
	var i = -1;
	var lcSearchTerm = searchTerm.toLowerCase();
	var lcBodyText = bodyText.toLowerCase();
 
	while (bodyText.length > 0) {
 
		//Get index of search term
		i = lcBodyText.indexOf(lcSearchTerm, i+1);
 
		//if we can't fine it, replace the newText with the BodyText and return
		if (i < 0) {
			newText += bodyText;
			bodyText = "";
		} else {
 
			// skip anything inside an HTML tag
			if (bodyText.lastIndexOf(">", i) >= bodyText.lastIndexOf("<", i)) {
				// skip anything inside a <script> block
				if (lcBodyText.lastIndexOf("/script>", i) >= lcBodyText.lastIndexOf("<script", i)) {
 
					//Get Ascii Representation
					var	charCode = bodyText.charAt(i).charCodeAt(0);
 
					//Is this uppercase
					var isUpper = (charCode >= 65 && charCode <= 90);
 
					//Do replacing
					if(isUpper){
						newText += bodyText.substring(0, i) +  replaceWith.charAt(0).toUpperCase() + replaceWith.substr(1) + " ";
					}else{
						newText += bodyText.substring(0, i) +  replaceWith + " ";
					}
					bodyText = bodyText.substr(i + searchTerm.length);
					lcBodyText = bodyText.toLowerCase();
					i = -1;
				}
			}
		}
	}
 
	return newText;
}

Since we could not have our site breaking the DOM, the filtering was moved into the Visual Basic code behind of the project. The trick to filtering content in .NET is to leverage the Response.Filter property along with a custom class. This class will intercept the content and re-write it to however you see fit. More details on this can be found here.

The first version of our filter used regular expressions in order to replace the appropriate words in the page. This also caused a severe problem: The RegEx was replacing properties of tags, css, and control names ( understand that the word ‘color’ was being replaced ). My first attempt at a solution was to find the proper RegEx to replace words only inside paragraph tags. It turns out that writing a RegEx to parse HTML is nearly impossible ;)

The solution? The original JavaScript code was migrated into the Visual Basic filter. This worked like a charm as it was using no RegExes and was also based upon the original code that worked. The final Visual Basic code is as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
Private Function doReplace(ByVal bodyText As String, ByVal searchTerm As String, ByVal replaceWith As String) As String
	Private Function doReplace(ByVal bodyText As String, ByVal searchTerm As String, ByVal replaceWith As String) As String
	Dim newText As String = ""
	Dim i As Integer = -1
	Dim lcSearchTerm As String = searchTerm.ToLower()
	Dim lcBodyText As String = bodyText.ToLower()
 
	While bodyText.Length > 0
		'Get the index of the search term
		i = lcBodyText.IndexOf(lcSearchTerm, i + 1)
 
		'If it isn't there, just return
		If i < 0 Then
			newText += bodyText
			bodyText = ""
		Else
			'Avoid tags
			If bodyText.LastIndexOf(">", i) >= bodyText.LastIndexOf("<", i) Then
				'Avoid scripts
				If lcBodyText.LastIndexOf("/script>", i) >= lcBodyText.LastIndexOf("<script", i) Then
					'Is the first character uppercase?
					Dim isUpper As Boolean = Char.IsUpper(bodyText.Chars(i))
 
					'If it is, then capitalize the replacement
					If isUpper Then
						newText += bodyText.Substring(0, i) + Char.ToUpper(replaceWith.Chars(0)) + replaceWith.Substring(1) + " "
					Else
						newText += bodyText.Substring(0, i) + replaceWith + " "
					End If
 
					'Truncate body text
					bodyText = bodyText.Substring(i + searchTerm.Length())
 
					'Reset current text
					lcBodyText = bodyText.ToLower()
					i = -1
				End If
			End If
		End If
	End While
 
	Return newText
End Function

The lesson learned here? Think before you code. If I would have simply migrated the JavaScript code I would have saved a lot of time.