Sanjay Uttam

Closing a jQuery UI Dialog...

Sanjay Uttam — Thu, 08 Apr 2010 22:32:11 GMT

Why do I always forget this?

$('#someId).dialog('close');

Create IEnumerable<T> with one line in LINQ

Sanjay Uttam — Fri, 05 Feb 2010 21:45:45 GMT

Pretty straight-forward, but a useful snippet of code nonetheless.

Given this class:

    public class AggregateContent
    {
 
        public string Title { get; set; }
        public string Description  { get; set; }
      

        public AggregateContent(string Header, string Content)
        {
            Title = Header;
            Description = Content;
        }
    }

You can use line to create an IEnumerable<AggregateContent> like this:

            IEnumerable<AggregateContent> a = 
                LastNNewsItems.Select(p => new AggregateContent(p.NewsTitle, p.HtmlContent));

Technorati Tags: quick-tip

jQuery: Get value of checked checkboxes by name | className

Sanjay Uttam — Wed, 03 Feb 2010 16:50:15 GMT

Think this one speaks for itself :)

    //Get via name attribute.  Would be better if you added form ID to selector

    var checkBoxes = $("input[name=" + checkBoxName + "]");
        //Need to use each or you'll only get the first match

    $.each(checkBoxes, function() {
                if ($(this).attr('checked')){
            //do stuff
        }

        });

    //Get via class name. Would be better if you added form ID to selector

    var checkBoxes = $('.' + checkBoxClass);
        $.each(checkBoxes, function() {
            if ($(this).attr('checked')){
            //do stuff
        }
        });

jQuery AJAX call working in IE but not FF?

Sanjay Uttam — Thu, 21 Jan 2010 20:43:31 GMT

Just ran into this one. The following is the code I was working with:

$.ajax({
            type: "GET",
            url: 'http://services.somewhere.com/MethodName',
            data: { 'param1':'something', 'param2': 'somethingElse' },
            cache: false,
            dataType: 'json',
            success: function(view) {
                alert('success');
            },
            error: function(xhr, ajaxOptions, thrownError) {
                alert(xhr.status);
                alert(xhr.responseText);
                alert(xhr.statusText);
            }
        });

This worked in IE 8, but not FF 3.5. The strange part, though, was that the xhr object in my error function didn't even contain anything in FF, whereas when I intentionally made the service fail in my IE testing my error object contained the server response. Turns out the fix was changing dataType to 'jsonp' instead of 'json'. I also added the contentType based on this post. More on jsonp...

$.ajax({
            type: "GET",
            url: 'http://services.somewhere.com/MethodName',
            data: { 'param1':'something', 'param2': 'somethingElse' },
            cache: false,
            dataType: 'jsonp',
            contentType: "application/json; charset=utf-8",
            success: function(view) {
                alert('success');
            },
            error: function(xhr, ajaxOptions, thrownError) {
                alert(xhr.status);
                alert(xhr.responseText);
                alert(xhr.statusText);
            }
        });

Searching TFS for code changes

Sanjay Uttam — Tue, 19 Jan 2010 23:14:58 GMT

Eventually you're going to need to search their source-control for latest changes given some parameters. I recently came across a couple of handy ways to do this, using TFS Powertools (and Powershell).

First, ensure you have the latest version of TFS Powertools installed.

Also ensure you have included Powershell CmdLets when you install (or make sure this option was enabled if you've already got TFS Powertools installed)

To search TFS via the command line, fire up the Powershell window and execute the following command:

PS C:\SanjayU\> Get-TfsitemHistory "$/SomeProject/SomeBranch/1.0/" -Version "D1/1/10~D1/15/10" -Re
curse -server http://YourTfsServer:8080

This would get all changes from January 1st, 2010 to January 15th, 2010 in the SomeProject/SomeBranch/1.0 directory on our TFS server.

Alternatively, you can execute the following command which will provide you a GUI to conduct similar searches..

PS C:\SanjayU\> tfpt searchcs

Definitely handy.

___

Sources & further reading

http://blog.hackedbrain.com/archive/2009/04/01/6166.aspx

http://msdn.microsoft.com/en-us/library/z51z7zy0.aspx

http://msdn.microsoft.com/en-us/library/bb385992.aspx

Installation of TFS PowerTools:

http://dotnet.org.za/willy/archive/2008/11/09/visual-studio-team-system-2008-team-foundation-server-power-tools-october-2008-release.aspx

Technorati Tags: Quick-tip

Making your code instantly readable...

Sanjay Uttam — Fri, 08 Jan 2010 22:20:22 GMT

I'm currently reading the second edition of _Code Complete_ from cover-to-cover. More on that later, I'm sure - but for now I'll just say that you should read this right now if you haven't read it already. This is one of those books that you should really just leave by your dev machine.

In any case, Steve McConnell mentions the importance of making code readable throughout the book. This is far from profound, yet in practice I don't see it done very much. Frankly, if you examine your coding practices from a cost-benefit perspective, you'd be hard-pressed to find an instance where this doesn't make sense. It takes so little effort to make your code readable. It could even reduce the likelihood of creating bugs in your code.

The below is a less-than-ideal, contrived example - I think it communicates the point, though. What looks better, this...

protected override void OnLoad(EventArgs e)
{
    int NumberOfVacationDays = 0;

    if(Employee.Type == EmployeeType.FullTime)
    {
        if (Employee.Level == EmployeeLevel.Professional)
        {
            NumberOfVacationDays = 10;
        }
        if (Employee.Level == EmployeeLevel.Executive)
        {
            NumberOfVacationDays = 20;
        }
    }
    
    if(Employee.Type == Employee.PartTime)
    {
        if(Employee.ExemptStatus == ExemptStatus.Exempt)
        {        
            NumberOfVacationDays = 0;
        }
        if(Employee.ExemptStatus == ExemptStatus.NonExempt)
        {        
            NumberOfVacationDays = 0;
        }
    }
}

or...

protected override void OnLoad(EventArgs e)
{
    EmployeeType employeeType = New EmployeeType();
    int NumberOfVacationDays = GetVacationByEmployeeType(employeeType);
}

//This method doesn't need to be in the same class...only for demo purposes
private int GetVacationByEmployeeType(employeeType)
{...}

Okay. You're either thinking one or more of the following right now:

Q. So what? You didn't reduce any of the code. What does this accomplish?

A. You're right. We haven't reduced code. In fact, we have done the exact opposite. We have reduced the perceived complexity though, because when Sam from down the hall needs to add some functionality in 4 months he'll know exactly what is being done without having to _mentally parse_ any code. Yes, of course he can read a few simple if blocks and deduce what's happening - there just isn't a reason to do this.

Q. You're adding more code and this could make the program perform worse.

A. In the most performance critical application (Hello NASA employees), maybe. For 99.9999% of us, you are not going to see improvements by reducing method calls. We're doing the logic somewhere and adding a method to the stack really won't change your life. I can prove it on an abacus.

Q. Okay, that's more readable...do I gain any other benefits?
A. Yes. You gain the gratification of knowing you've done something correctly. You really shouldn't have business rules/logic embedded in your event. What happens when you want to use the same logic in some other class/method/file/spacecraft? You're out of luck. It's easy to never think about this...or assume you'll never need to use this logic anywhere else. If that's the case, you should part out the logic into its own private, local method. That way if you ever need to reuse the method you can change the access modifier and move it to a class where it makes a little more sense.

As a additional side note, you should never ever have the business rule evaluation logic [as shown in the first example] in more than one location. If that's the case, you'll need to make changes all over place when the business rules change. And trust me, they're going to change.

Annoying Error + Semi-Annoying Hunt for Resolution = Pleasant Surprise

Sanjay Uttam — Wed, 02 Dec 2009 15:23:09 GMT

I received the following error yesterday:

"Unable to start debugging on the web server. An authentication error occurred while communicating with the web server. Please see Help for assistance."

I tried a fair amount stuff (technical term) including items outlined on Ryan Farley's post regarding the message. What ended up working [for me] was posted by Boaz in the comments of Ryan's blog. Here is the link to the MSDN fix:

http://support.microsoft.com/?kbid=896861#fixitforme

Warning: If you go the "Fix it For Me" route, you'll need to reboot.

If the above fix doesn't work, take a look at this.

Web Application Performance: CSS Data URIs

Sanjay — Tue, 01 Dec 2009 21:04:10 GMT

Was doing my daily research today and learned a couple of new and interesting things. A while back, I wrote a post about rendering options using .NET 3.5 SP1's charting component. I outlined a few of the more conventional/out-of-the-box methods (temporary directory, binary streaming). I also outlined a lesser-known technique in which you stream binary data to the src attribute of your <img> tag. That ends up looking like this...

<img src='data:image/png;base64, iVBORw0KGgoAAAA[snip]; />

The full post can be found here.

In any case, it turns out you can apply a similar/identical technique to your CSS for a performance gain (by way of reducing HTTP requests)....It's really the same exact technique as above. So, for example, a CSS class may look like this:

#some-css-class{background-image:url(data:image/png;base64,iVBORw0KGgoAAAA [snip] )}

This can be very useful for sites that have a large number of image paths embedded in CSS. But "How do I convert my existing images?" you ask? There are a few ways. In the previous post I mentioned how convert a memory stream to its base64 representation.

A quick-and-dirty sample of how to do this from a file that exists on a server/HD would look like this (Update: Per Petar's comment below, disposing of the FileStream object completely eluded me in my original version of the code sample below. Updated to use using instead.)

protected void getBase64Image()
{
    using (FileStream imageStream = File.OpenRead("C:\\temp\\testImage.png"))
    {
    byte[] data = new byte[imageStream.Length];
    imageStream.Read(data, 0, data.Length);
    string binaryRepresenatation = string.Concat("data:image/png;base64,", Convert.ToBase64String(data.ToArray()));
    //htmlImgTag looks like this: <img runat="server" id="htmlImgTag" />
    htmlImgTag.Src = binaryRepresenatation;
    }
}

Additionally, you can do do one-off conversions of images from your HD or a URL using Hixie's Data URI Kitchen: http://software.hixie.ch/utilities/cgi/data/data

Lastly, Nicholas Zakas created the Java based CSSEmbed tool that will do this conversion for you from your CSS files on-the-fly. I haven't tried it, but have heard good things: http://github.com/nzakas/cssembed

As always, there are some things to watch out for using this technique.

Firstly, data URI are not supported in all browsers...the wiki on Data URIs has some good info: http://en.wikipedia.org/wiki/Data_URI_scheme

Second, as described by Rob Flaherty, there are some gotchas to watch out for. The long and short of it is if you have a data URI that results in an image larger than 32k, it could negate this performance boost to some extent. It's best to check out Rob's post on this for more detailed information: http://www.ravelrumba.com/blog/css-images-and-data-uris/

Technorati Tags: performance,quick-tip

Sources:

http://en.wikipedia.org/wiki/Data_URI_scheme

http://www.ravelrumba.com/blog/css-images-and-data-uris/

http://geekswithblogs.net/SanjayU/archive/2009/06/18/asp.net-charting-rendering-options.aspx :)

http://www.slideshare.net/stoyan/high-performance-kick-ass-web-apps-javascript-edition

Error Handling in ASP.NET MVC 1 [Part 2 of 2]

Sanjay — Mon, 09 Nov 2009 23:38:07 GMT

In the first post in this series, I provided a little info on the HandleError attribute in MVC 1. In case you don’t want to flip back, the HandleError attribute can decorate a method or a class and will push your users to a generic errors view provided customErrors is “On” or “RemoteOnly”. There’s a little more to it, but that’s all the background we need for this post.

The out-of-the-box HandleError attribute works well, until you’re in a scenario where you need to do more than hide your errors. Typically, you may want to do some logging or fire-off some alerts. Now, as luck should have it, I did some searching before writing this up and Danny Tuppeny already has a great post on this very subject…I encourage you to take a peak at his post, as I’ve provided a very high-level, yet functional summary below.

The facts are these…

- System.Web.Mvc.Controller contains an OnException method that gets fired when an exception occurs [provided custom errors are On/RemoteOnly in the web.config]

- The OnException method can easily be overridden, allowing you to either completely change behavior or add behavior (by calling base.OnException)

- This method will fire regardless of whether your class or method is decorated with HandleError

This means that your could will look like this:

        1: using System;

       2: using System.Collections.Generic;

       3: using System.Linq;

       4: using System.Web;

       5: using System.Web.Mvc;

       6:  

       7: namespace MvcErrorHandling.Controllers

       8: {

       9:     public class ControllerBase : System.Web.Mvc.Controller

      10:     {

      11:         protected override void OnException(ExceptionContext filterContext)

      12:         {

      13:             //Do whatever stuff you'd like

      14:             DoSomeOtherStuff();

      15:             

      16:             //Displays a friendly error, doesn't require HandleError

      17:             filterContext.ExceptionHandled = true;

      18:             this.View("Error").ExecuteResult(this.ControllerContext);

      19:             

      20:             //Displays a friendly error, *requires* HandlError

      21:             //base.OnException(filterContext);

      22:         }

      23:  

      24:         protected void DoSomeOtherStuff() { /* brevity */ }

      25:     }

      26: }

To get the above code to work you’d simply make your controller inherit from ControllerBase. Of course, you’d likely have additional utility-methods in this class that you’d need in multiple controllers.

Lines 17 and 18 can be used to push the user to your error view after you execute the DoSomeOtherStuff() method – this would not require the HandleError attribute. Alternatively, you can execute System.Web.Mvc.Controller’s OnException by calling it explicitly as it’s done on line 21. In this case, the HandleError would be required to push your use down the custom-error path you’ve got configured.

And that’s pretty much all there is to centralizing & customizing your error-handling in MVC 1.

Share this post :

Technorati Tags: MVC,c#

Error Handling in ASP.NET MVC 1 [Part 1 of 2]

Sanjay — Fri, 06 Nov 2009 22:08:54 GMT

I’ve been using ASP.NET MVC Release 1 for a bit now, and while it’s definitely not for every application, I happen to like it quite a bit. There has been a lot of activity on MS-centric blogs regarding MVC, but there are still some really mundane tasks that there could be more information on. So, this series of posts isn’t going to be anything crazy; it will, however, illustrate what options you have to do centralized error-handling using MVC 1.

We’ll start at the beginning…

The System.Web.Mvc.dll comes with the HandleErrorAttribute class, which contains..wait for it…the HandleError attribute. This information won’t be important until later in this series, but the HandleErrorAttribute class inherits from the FilterAttribute class, and implements the IExceptionFilter interface – the interface requires a method with the following signature.

     public virtual void OnException(ExceptionContext filterContext);

This method is really where the brunt of the work is done when you use the provided [HandleError] attribute. In case you’ve never taken a look using Reflector, this HandleErrorAttribute’s implementation of OnException looks like this:

    public virtual void OnException(ExceptionContext filterContext)

      {

          if (filterContext == null)

          {

              throw new ArgumentNullException("filterContext");

          }

          if (!filterContext.ExceptionHandled && filterContext.HttpContext.IsCustomErrorEnabled)

          {

              Exception innerException = filterContext.Exception;

              if ((new HttpException(null, innerException).GetHttpCode() == 500) && this.ExceptionType.IsInstanceOfType(innerException))

              {

                  string controllerName = (string) filterContext.RouteData.Values["controller"];

                  string actionName = (string) filterContext.RouteData.Values["action"];

                  HandleErrorInfo model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);

                  ViewResult result = new ViewResult();

                  result.ViewName = this.View;

                  result.MasterName = this.Master;

                  result.ViewData = new ViewDataDictionary<HandleErrorInfo>(model);

                  result.TempData = filterContext.Controller.TempData;

                  filterContext.Result = result;

                  filterContext.ExceptionHandled = true;

                  filterContext.HttpContext.Response.Clear();

                  filterContext.HttpContext.Response.StatusCode = 500;

                  filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;

              }

          }

      }

Essentially, you’re grabbing some information from the ExceptionContext, and you’re using the HandleErrorInfo class to pass this information back to your view.

Using [HandleError] is really as easy as using any other attribute. You simply decorate your method or class with the attribute and your errors will be pushed to the default view for errors (Views/Shared/Error.aspx)

Sample usage of [HandleError]:

    namespace MvcErrorHandling.Controllers

    {

        [HandleError]

        public class HomeController : Controller

        {

            public ActionResult Index()

            {

                if (true)

                { 

                    throw new ApplicationException("Some error...");

                }

                return View();

            }

            //removed...

Alternatively, you can provide the HandleError attribute with some arguments to specify a view other than the default error-view, or specify a specific view based on the exception type. Here’s an example of the usage for that…

    [HandleError(ExceptionType = typeof(ApplicationException), View = "AppErrorPage")]

    public class HomeController : Controller

    {

        public ActionResult Index()

        {

            if (true)

            { 

                throw new ApplicationException("Some error...");

            }

            return View();

        }

        //removed...

The only other thing you’ll want to make sure you do is ensure your web.config <customErrors> section is configured appropriately. That is, you’ll want to make sure customErrors mode=”On” to test this out.

Hope this helps somebody; the next part in this series will demonstrate how to add functionality to the existing OnException method that the HandleErrorAttribute class implements, such as logging.

Share this post :

Technorati Tags: mvc,c#

Adventures in WF 3.0/3.5

Sanjay — Thu, 22 Oct 2009 21:18:59 GMT

Until redesign of WF 4.0 is completed & released, I’m going to have to put up with this. I’ve been working some WF stuff the past few days. One of the very annoying things about working with the VS designer environment is, well, frankly – the designer. It’s entirely inconsistent. Sometimes, when I need to add a normal property (not a dependency property) – doing things the normal way gets me there. In other words, I add this code to the activity code:

     public int MyProperty { get; set; }

and in the designer (right click activity > properties > under “Misc”), I see what I’m supposed to see (umm..right? I’m supposed to see this??)

…and everything is right in the world. Then, 10 minutes you take the identical steps, only with a new property and to your amazement, absolutely nothing happens and you’re left wondering if someone killed a butterfly in a rainforest or something. Well, I have no idea what happened…but I can tell you that a restart of the IDE is what works for me. Yep, that’s right…it’s the old Windows 98 solution to things. Try it.

Now, the above scenario was with a “normal” property – not a dependency property. Well, turns out the same thing can happen with dependency properties – which I was fortunate enough to have experienced yesterday. I would assume the above restart-the-ide “solution” would work for that, as well. In case it doesn’t, though, it turns out you can actually access dependency properties by doing this…It’s not that pretty – but it definitely works.

    someLocalVarFoo = ((SourceNamespace.SourceClassName)this.GetActivityByName("ActivityName")).PropertyName;

Get the index of a given item using LINQ [quick-tip]

Sanjay Uttam — Thu, 15 Oct 2009 21:06:35 GMT

UPDATE: Please see first comment to do this the "safe" way...

It took a bit for me to get comfortable enough with LINQ-to-objects to write ‘queries’ off the top of my head…but once you’re used to it you realize it’s much more concise, easier to interpret/read, and well..it’s less code. Here are some real quick examples…

This first example selects the string array value as well as its position from the someItems array. Note, the user of new{} creates a new generic type that has the properties ItemName and Position. I could have called these two properties whatever I pleased, because I’m creating them at query-time.

string[] someItems = { "cat", "dog", "purple elephant", "unicorn" };

var selectedItems = someItems.Select((item, index) => new

{

    ItemName = item,

    Position = index

});

After you run this, selectedItems will look like this….

And if you needed to just get the position as an int to use that for some other logic, your code may look like this..

int firstItem = someItems.Select((item, index) => new

{

    ItemName = item,

    Position = index

}).Where(i => i.ItemName == "purple elephant")

  .First()

  .Position;

In which case, firstItem would equal 2. Naturally, this is only the beginning of what LINQ to objects can do for you – but it definitely illustrates how LINQ can ease your daily coding.

Technorati Tags: C#,LINQ,.NET,quick-tip

Returning values from your LINQ queries [quick tip]

Sanjay — Fri, 11 Sep 2009 21:09:45 GMT

Just a quick tip that I found handy while doing some writing yesterday; chances are if you’ve played with LINQ you probably wrote something like this…

     var outputString = from s

                       in inputString

                       where s.Length > 1

                       select s;

    //Do some stuff with outputString in your method...

Code like the above will work perfectly well if what you’re going to work with your implicit variable, outputString, within the body of the same method. But, as it stands, you can’t return outputString, or any implicit variable from your method. Try it, I dare you. At this point, you’re probably thinking “Wait, can’t I just do a outputString.ToList() or .ToArray() and return that? Yes – you can. The catch with doing that, though, is that your LINQ expression is going to be evaluated right there and then. This might be fine for you, or it might not – but you should be aware of the deferred query execution model that LINQ embraces.

In any case, the easy way out of this assuming you’d prefer to defer execution until you enumerate is actually very straightforward….You can simply return an IEnumerable<T>. So, something like…

    static IEnumerable<string> DoLinqStuff(string[] inputString)

    {

        //You can do this and return an IEnumerable<string>

        IEnumerable<string> outputString =  from s

                                            in inputString

                                            where s.Length > 1

                                            select s;

        return outputString;

    }

That way, you can do the following to leverage your LINQ expression in an external method while leaving the deferred execution model in-tact…

    //Remember this isn't evaluated yet...

    IEnumerable<string> myReturnedStuff = DoLinqStuff(myStrings);

    //It's getting evaluated now...

    foreach (string s in myReturnedStuff) {

        Console.WriteLine(s);

    }

Or if you want to be a bit more concise about it…

    //Same thing but slightly less code...

    foreach (string s in DoLinqStuff(myStrings)){

        Console.WriteLine(s);

    }

Okay, so it wasn’t exactly rocket-science but I figure it may be helpful.

Share this post :

Technorati Tags: C#,LINQ,.NET,quick-tip

If you are thinking about using Windows Work-Flow…you should know…

Sanjay — Fri, 21 Aug 2009 17:54:14 GMT

That MS decided to totally blow it up in .NET 4.0. (weblogs.asp.net link, S/O link). Yes, that’s right, they are totally re-writing WF 4.0 from the ground-up. As the first link states, this could be for any number of reasons including lack of adoption and the perception that WF is just too complex – which I happen to agree with. 3.0/3.5 workflows will still work, but only on the 3.0 runtime.

On the one hand, I have to give some credit to MS for basically saying “Hey guys, we effed up and we’re gonna scrap this…”, and yet, on the other I have to assume it’s a little embarrassing to have to do something like this.

BTW, Is this old news? How did I totally miss the memo on this?

Share this post :

Technorati Tags: Workflow,.NET

Surprising jQuery Performance Tip

Sanjay — Fri, 21 Aug 2009 16:28:15 GMT

Was doing some research this morning, as usual, and came across a post from Giulio Bai on jQuery performance tips. A lot of his tips are things I’ve heard elsewhere (no offense!), but one that I haven’t seen anywhere and for some reason surprised me is that using a the JavaScript provided for() loop is considerably faster than using jQuery’s each() function. In fact, it can be several orders of magnitude faster depending on what you’re doing. Interesting.

Link to his post

Technorati Tags: jQuery,performance