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!
Filed Under (.NET, Development) by Robert Green on 19-06-2009
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.
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?
Filed Under (.NET, Development) by Robert Green on 27-05-2009
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:
- Get the first character as a string ( stringToCapitalize.Substring(0,1) )
- Transform the first character to uppercase ( stringToCapitalize.Substring(0,1).ToUpper() )
- 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:
- Get the first character as a char ( stringToCapitalize[0] )
- Transform the first character to uppercase using the char.toUpper method ( char.toUpper(stringToCapitalize[0]) )
- 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;
}
} |
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.