Research ~ A ~ holic

Older Web applications and the challenge of IE 10+

chadit — Thu, 02 May 2013 17:30:00 +0000

As the market share of Internet Explorer 10 increases along with the looming release of Internet Explorer 11 a growing number of web developers are realizing that Microsoft in their great wisdom (I am not against it, just wish there was an option) removed the ability to use conditional comments.

In a sense breaking every legacy application that a company might be using. For those that do not know or need a refresh, conditional comments where a way to do something like this:

Conditional comments were commonly used by developers to load a CSS files specificly for the quirks of that browser. Why? Because the rules would change for how features where handled (joys of lack of feature standardization). So one could say with conditional comments being removed in IE10 developers must now pay for the past faults. An businesses have to enforce stupid lock out rules like all PC’s can only have IE 8 or 9, or shoot me now IE6.

So what do we do about it?

The purist out there say “oh just make the changes and only support IE 10, DEATH to all other browsers!!!” To them I must ask if they have ever worked in an enterprise setting.

Firstly this is not always possible, project time lines, size of the application, and resources sometimes does not allow this to be an option. Secondly on most teams I have been on new features are more important then fixing past issues. Most of the time a legacy feature was probably written by someone else so teams avoid changing what is working for fear of breaking that code. So in essence of ROI of upgrading an application to a newer browser does not out way the ROI of implementing new features. Perfect example of why there is still market share for IE6.

I am sure this hack will probably get some angry feedback from the purist and those that think it is so easy to just waist time and money on older applications or complex ones that are slowly being refactored (large applications can not be upgraded over night, sometimes it takes YEARS).

Option 1: (Restore conditionals through changing the document mode)

Internet Explorer 10 might have some great new features; however if you have an application that must support all the flavors of IE still more then likely HTML5 is not on the radar you can set the browser document mode in a way that it only affects IE 10. This will in turn allow IE 10 to see conditional comments, it will be treated as if the browser is Internet Explorer 9.

public "-//W3C//DTD HTML 4.0 Strict//en">
"X-UA-Compatible" content="IE=9" />

Option 2: (Feature detection to determine which browser)

Feature detection is where we check (usually through JavaScript) if the browser supports a specific HTML/CSS feature. This is a growing tread with HTML5 and browsers implementing those features differently. Well we can do the same thing to attempt to figure out what browser a client is currently using. You might ask “Why not just use browser detection and look at the agent?” Simple answer browser detection is considered evil, very unreliable, and easy to lie to.

I found two references to two charts

Tanalin.com

IE Versions	Supported Standard Object
10+	window.atob
9+	document.addEventListener
8+	document.querySelector
7+	window.XMLHttpRequest
6+	document.compatMode

snippets.webaware.com.au

IE Versions	Find Version
10+	“history” in window && “pushState” in window.history
9+	“performance” in window
8+	“documentMode” in document
7	“maxHeight” in document.documentElement.style && !(“documentMode” in document)
6	!(“maxHeight” in document.documentElement.style)

With these two tables we can now do something like this:

// Check if this is Internet explorer
if ("documentElement" in document && ("filters" in document.documentElement || "documentMode" in document)) {
       // IE 6
       if (!("maxHeight" in document.documentElement.style)) {
               document.documentElement.className += ' ie6';

                // can load js file or css if needed
       }

       // IE 7
       if ((document.documentMode === 7) || ("maxHeight" in document.documentElement.style && !("documentMode" in document))) {
                document.documentElement.className += ' ie7';

                // can load js file or css if needed
       }

       // IE 8
       if ((document.documentMode === 8) || (document.all && document.querySelector && !document.addEventListener)) {
                document.documentElement.className += ' ie8';

               // can load js file or css if needed
       }

      // IE 9
      if (document.documentMode === 9) {
                document.documentElement.className += ' ie9';
      }
}

With this code snippet I am looking to see if the browser first is IE. If it is IE, I then start to check for browser features to determine which one I am most likely talking to. If you notice I am checking the documentMode first for IE 7,8, and 9. This is because as we saw in option one we can force the documentMode for IE. (Example: Telling IE 10 to run documentMode of IE 8).

So in the example above what ends up happening is if say IE 8 is found. It changes the html tag to look like this:

<html class="ie8">

Since CSS gradients can be a pain in IE 6, 7, and 8; we have the option now to add a change for our CSS class that looks like this:

.WorkListGrid tr.Row
{
    background: #dedede;
    background: -webkit-gradient(linear, 0 0, 0 bottom, from(#dedede), to(#ffffff));
    background: -webkit-linear-gradient(#dedede, #ffffff);
    background: -moz-linear-gradient(#dedede, #ffffff);
    background: -ms-linear-gradient(#dedede, #ffffff);
    background: -o-linear-gradient(#dedede, #ffffff);
    background: linear-gradient(#dedede, #ffffff);

}

/* Do not need to add the cross browser background sizes, this will only run for IE*/
.ie6 .WorkListGrid tr.Row,
.ie7 .WorkListGrid tr.Row,
.ie8 .WorkListGrid tr.Row {
    background: #dedede;
    background-image: url(../../img/gradientgrey.jpg);
    background-repeat: repeat-x;
    background-size: 100% 100%;
}

If the browser is IE 6, 7, or 8 it will use a gradient image file, and so we do not break any modern browser we can still implement the standard background gradient CSS parms.

In conclusion like I said in the intro this might not be best practice nor will the purist like this article, but in business there are times when developers have no choose but to do hacks and slashes to get a feature out the door. It is the way the world turns. In my opinion option two could be a good. If an application is being redesigned one feature at a time in order to modernizing it. You gain the flexibility of making changes without major features breaking.

Battle of the INotifyPropertyChanged techniques

chadit — Mon, 11 Mar 2013 14:00:00 +0000

Recently at a conference I was given the opportunity to talk about Aspect Orientated programming with PostSharp. In my demo I showed off the difference between creating an INotifyPropertyChanged class manually, using boilerplate code generated by Resharper, and using smart tags built into PostSharp 3. By the request of a few, here is what was covered.

What is INotifyPropertyChanged?

It is an interface provided by Microsoft .NET Framework that is used to let client application know when a property has changed. Typically this will then allow the client to refresh a field to display the changed value.

Initial Setup

In this example lets use this class for as our simple example:

public class Customer{
     public int CustomerId {get; set;}
     public string FirstName {get; set;}
     public string LastName {get; set;}
     public string FullName {get; set;}
     public string Address {get; set;}
}

—- Manually —-

In the beginning we coded stuff manually.

First thing that needs to be done is to add INotifyPropertyChanged to our class. Add the interface member along with a method to handle the OnPropertyChanged event. We will now have a class that looks like this:

public class Customer : INotifyPropertyChanged{
     public int CustomerId {get; set;}
     public string FirstName {get; set;}
     public string LastName {get; set;}
     public string FullName {get; set;}
     public string Address {get; set;}

     public event PropertyChangedEventHandler PropertyChanged;

     protected void OnPropertyChanged(string propertyName){
          if (this.PropertyChanged != null){
               this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
          }
     }
}

Now we can setup our properties to use the OnPropertyChanged method. Can you spot the error?

public class Customer : INotifyPropertyChanged{
        private string customerFirstName, customerLastName, address;

        public int CustomerId { get; set; }

        public string FirstName{
            get{
                return customerFirstName;
            }

            set{
                if (value != null){
                    customerFirstName = value;
                    this.OnPropertyChanged("FirstName");
                    this.OnPropertyChanged("FullName");
                }
            }
        }

        public string LastName{
            get{
                return customerLastName;
            }

            set{
                if (value != null){
                    customerLastName = value;
                    this.OnPropertyChanged("LastName");
                    this.OnPropertyChanged("FullName");
                }
            }
        }

        public string FullName{
            get{
                return string.Format("{0}  {1}", FirstName, LastName);
            }
        }

        public string Address{
            get{
                return address;
            }

            set{
                if (value != null){
                    company = value;
                    this.OnPropertyChanged("FirstName");
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName){
            if (this.PropertyChanged != null){
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }

I hope you spotted the error.

A big problem like this commonly occurs when a developer needs to add a slew of properties like this. Most of the time out of pure boredom they will eventually just start copy, pasting and modifying the code. In our example above, we copy pasted the FirstName property and modified that. When we got to address, we forgot to change the OnPropertyChanged string.

—- Boilerplate —-

Because of the bugs that can be generated by copy paste development, tools like Resharper 7.x+ have built in boilerplate generating functions. I am not going to go into a lot of detail on this, if you want to read more about this go here.

Through the use of boilerplate code generation and Resharpers smart tags; adding new properties is pretty simple. With a few clicks our end code looks similar to the end code of the manual process. So you might be wondering why I still have issues with this, why do I still consider this a mid tier solution.

—- PostSharp 3 —-

PostSharp is a framework that adds Aspect Oriented Programming or AOP to a solution. This allows developers to separate out boilerplate code (or referenced as cross cutting concerns) from business code. With PostSharp 3 they introduced the concept of design pattern automation. If you want to read a great article about this, please go here.

You can install PostSharp3 from the Visual Studio Extension Gallery. Once installed right click your solution and select to add PostSharp. After that go to your class file (notice in the image that it looks like our original code base), from the smart tag select ‘Implement INotifyPropertyChanged’ and watch the magic happen. The end code will look similar to this:

[NotifyPropertyChanged]
public class Customer{
     public int CustomerId {get; set;}
     public string FirstName {get; set;}
     public string LastName {get; set;}
     public string FullName {get; set;}
     public string Address {get; set;}
}

That is it, don’t believe me… try it and use something like Teleriks JustDecompile or Resharpers dotPeek (Reflector if you have the money for a license.) The code generated in the dll will look similar to our manually and boilerplate code. In the end which is easier to read, modify, and troubleshoot if a problem arises?

Presenting at Orlando Code Camp Sat March 16th

chadit — Fri, 08 Mar 2013 14:00:00 +0000

This year I am given the honor to talk to people at the Orlando Code Camp Saturday March 16th. This will be my first time there and I am really excited to get a presentation slot.

4:00 – 4:50 Room TBD – Test Frist Development/TDD

We are going to dive into what unit testing is, talk about some of the advantages of Unit testing and TDD along with walking through the process of using TDD to create a method.

NCrunch a Visual Studio Add-In for Unit Testing

chadit — Wed, 20 Feb 2013 15:00:00 +0000

I made it a goal late in 2012 that one of my personal task for 2013 was going to be diving deeper into unit testing and mocking. In my research I came across a unit testing tool for Visual Studio called NCrunch which is developed by Remco Mulder. I downloaded the trial and immediately fell in love with it. The rest of this article is a high overview, I highly recommend you check out there site and give it a try.

At first the price of NCrunch can put some folks back ($159 for user license and $289 for seat license), until you look at all the features it packs in, then it becomes a deal. If you are doing some form of Test Driven Development (TDD) it almost becomes the tool you can’t live without.

Automated concurrent testing

Normally a developer write code in this form: (if following TDD)

Write the test code
Run the test code (should fail by TDD rules)
Write the code
Run the test code
If the Test passes write another test, else repeat step 3 and 4 till passes.

In a perfect world at the most developers experience 5 steps when writing a test and method of code to go along with it. What if you could simplify this process even more to something like this:

Write the test code
Write the code
If test passes write another test else repeat step 2 till passes

You might be asking yourself “How the heck are you removing the steps to run the test”. Simply put you could have a display like below

Ncrunch will automatically run the test in the background on separate threads and as you change code the affected unit test are run. The results are returned pretty fast, speed can vary depending on your workstation environment and amount of test affected. In one test on an i7 with 8GB of ram and 15 unit test there was about a 20 second delay in total feedback. There are two modes for testing, run them side by side (if you have the memory for it) or one after the other. I choose one after the other when I reach about 10 test (personal preference).

In the bottom right of Visual Studio you will have a Ncrunch status icon that looks like this:

This will provide you with some rapid information about what NCrunch is doing in the background. In this instance it is showing I have one test that is failing. If it is blue with a number in it, that means there are test queued up and waiting to run, and a blue N means it is idle.

Code Coverage

As Ncrunch runs the test in the background it will identify the code coverage of your application. Below is an example of what it looks like from the test and source code text editors:

As the test are running the lines of code will show Red for failed test, green for passed test, and black for no code coverage. Each code coverage also has access to a context menu with additional options

Just like other code coverage tools you can see the metrics for your methods. NCrunch also allows you to ignore classes from the metrics; along with export them to a text file.

Performance Metrics

NCrunch also has performance metrics built in. As test are run, NCrunch will alert on hot spots by displaying the line dot in yellow. Hot spots are generally slowly running code, here is an example:

Inline Exception Details

NCrunch will display exceptions inline, this will make it easier to spot test failures

Intelligent Test Execution

As test are run there are metrics collected on system impact. There is a processing queue system that ranks test (the ranking varies by either test speed or memory this can be set in the settings section).

Included also is a Risk/Progress bar, it will display the metric as your test runs (see the NCrunch support site here for more information on this).

South Florida Code Camp 2013 my demo links #sflcc

chadit — Wed, 13 Feb 2013 15:00:00 +0000

This year was my second year presenting at the South Florida Code Camp. I am once again amazed at the amount of attendees, number of sessions, and of course the great folks you get to meet and learn from.

This year I was lucky and both my sessions were accepted. Great turn out for both of them. I loved the feedback and open discussion that occurred in both of them. As requested here are both of sessions slides and projects.

Session one: Unit Testing and TDD

Description: In this session we talked about the advantages that come from Unit Testing, and an overview of Test Driven Development. On top of that we talk about a great tool that makes TDD a breeze, nCrunch. If you haven’t used this tool before, I highly recommend you give the trial a try.

Presentation is located here.
Demo code is located here.

Session Two: AoP with PostSharp to the Rescue

Description: In this session I showed the power behind using Aspects in your development cycle. Included in this demo encapsulated how Aspects have many advantages over cut and copy code and boilerplate code.

Presentation is located here.

Entity Framework 5 easier way to update record

chadit — Wed, 06 Feb 2013 14:00:00 +0000

In the past with EF if you wanted to update a record you would need to do something like this:

 public HttpResponseMessage PutCustomer(Customer customer)
        {
            using (var context = new ChinookContext())
            {
                var request = context.Customers.Single(c => c.CustomerId == customer.CustomerId);

                // todo this has to have an easier way.  Customer.Attach throws an error
                request.FirstName = customer.FirstName;
                request.LastName = customer.LastName;
                request.Address = customer.Address;
                request.City = customer.City;
                request.PostalCode = customer.PostalCode;
                request.State = customer.State;
                request.Country = customer.Country;
                request.Fax = customer.Fax;
                request.Email = customer.Email;
                request.Company = customer.Company;

                context.SaveChanges();

                var response = Request.CreateResponse(HttpStatusCode.Accepted, customer);
                response.Headers.Location = new Uri(Request.RequestUri, string.Format("Customer/{0}", customer.CustomerId));
                return response;
            }
        }

As you may notice this can get tedious and rather large as more fields need updating. In Entity Framework 5 we get a wonderful new method ‘SetValues’. With this new method we can change the above code from that to this:

 public HttpResponseMessage PutCustomer(Customer customer)
        {
            using (var context = new ChinookContext())
            {
                var original = context.Customers.Find(customer.CustomerId);

                if (original != null)
                {
                    context.Entry(original).CurrentValues.SetValues(customer);
                    context.SaveChanges();
                }

                var response = Request.CreateResponse(HttpStatusCode.Accepted, customer);
                response.Headers.Location = new Uri(Request.RequestUri, string.Format("Customer/{0}", customer.CustomerId));
                return response;
            }
        }

Presenting at South Florida Code Camp Sat 9th

chadit — Mon, 04 Feb 2013 20:00:00 +0000

This coming weekend (Feb 9th) I will be giving two presentations.

1:20 – 2:30 Room 1052 – Test Frist Development/TDD

We are going to dive into what unit testing is, talk about some of the advantages of Unit testing and TDD along with walking through the creation of a project using TDD. I will also be demoing a fascinating new unit testing tool called NCrunch.

In honor of Separation of Concerns month (2013 Software Craftsmanship Calendar)

2:40-3:50 Room 1048 – AoP with PostSharp to the Rescue.

In this session we will dive into what Aspect Oriented programming is, how it can be an advantage to development teams, and show off some Aspects including new features coming in PostSharp 3

Call WCF Service Asynchronously

chadit — Wed, 16 Jan 2013 14:00:00 +0000

Why would we want to call a WCF Service asynchronously?

The biggest reason to move from synchronous to asynchronous is performance. When a synchronous call is made, the current thread locks till the call is completed. It varies by OS and programming language but most application will have a set number of threads they can pull out of a thread pool. If to many threads are being utilized to retrieve data synchronously it could cause the entire application to lock up while it waits for a thread to become available. This is bad when end user usability plays a large part in development decisions today.

Asynchronous calls will call the WCF service and release the thread back into the thread pool. When the async call is completed a callback method is raised, this will pull out a new thread to consume the returning data.

In order to setup Async calls do the following:

Right click on the service reference
Select ‘configure service reference’
Check ‘Allow generation of asynchronous operations’
Ensure ‘Generate asynchronous operations’ is selected
Click OK

Then to make the call in your code you just simple do this

C# version

private void AsyncTest()
{
    WcfClient someWcfClient = new WcfClient();
    //Setup a listener that can wait for the async call to complete
    someWcfClient.SimpleSearchCompleted += DocCallback;
    //call the async method and optionally pass in a parm
    someWcfClient.SimpleSearchAsync(someParm);
}

private void DocCallback(object sender, SinpleSearchEventArgs e)
{
    // do something
}

VB.NET version

Private Sub AsyncTest()
Dim someWcfClient As New WcfClient()
'Setup a listener that can wait for the async call to complete
AddHandler someWcfClient.SimpleSearchCompleted, AddressOf DocCallback
'call the async method and optionally pass in a parm
someWcfClient.SimpleSearchAsync(someParm)
End Sub

Private Sub DocCallback(ByVal sender As Object, ByVal e As SinpleSearchEventArgs)
' do something
End Sub

@media and IE8 and below

chadit — Thu, 10 Jan 2013 14:00:00 +0000

So this week I have been working on creating an adaptive UI for the various screen resolutions that our users operate on. Currently the page was static and looked horrible on high resolution screens.

Playing around with HTML/JS Windows 8 and MVC 4 applications I got the idea of just using @media with a min and max range. On IE 9, 10, Chrome, and Firefox everything looked super. Then I got the test case of ensuring it also worked on IE 7 and 8. I Cringed, adding support for older browsers can be troublesome at the very least.

IE 8 and below does not support a CSS setting for min and max on the width. Which completely blew my design out of the water.

Luckily I found a solution by Scott Jehl on github. The project is called respond. Its goal is to enable browsers to utilize CSS3 media queries that normally do not.

It is very easy to turn the feature on.

Download it from the link above
Add it to your project folder
Add a link to the file in the header of our page.
You can now freely use the @media query in your pages for IE 7 and 8.

Example:

@media screen and (min-width: 600px) and (max-width: 1024px) {
        .PanelsLeft {
            width: 40%;
        }

        .PanelsRight {
            width: 60%;
        }
}

Change the Computer Name for a TFS workspace

chadit — Wed, 19 Dec 2012 14:00:00 +0000

So today I had the enjoyment of the infrastructure team changing the workstation station naming conventions company wide. Which if you have been a developer for sometime this usually will make you cringe.

With Visual Studio Microsoft included a command line utility tf.exe which is usually located in *\Common7\IDE. This utility allows you to do more administrative style commands that are hidden from the UI side of visual studio.

To updated the computer name for all of your workspaces in a collection you would run something like this:

tf workspaces /updateComputerName:oldcomputername /collection:http://tfsServer:8080/tfs/DefaultCollection

If you are going across domain you might need to send the /login:NetworkName with it.