MyViewState.NET

Telerik Q2 2009 Release News

Kevin Babcock — Sat, 11 Jul 2009 01:19:07 -0400

The Telerik Q2 2009 “Release Week” came to a close today, and I’m sure the brilliant developers there are already hard at work on the Q3 2009 stuff. But I’m just getting started with the goodies they released this week and wanted to share the excitement. In case you missed it, Telerik updated our accounts with shiny new bits for 7 product lines (Sitefinity is on its own release cycle). If you aren’t already a Telerik user, go test out the trials and let them (and me!) know what you think.

Q2 2009 was hands-down the most exciting release I’ve seen yet. Not only did they surprise folks with the release of the FREE automated web UI testing framework for ASP.NET AJAX and Silverlight, but they added a ton of new features to existing tools. The RadControls for ASP.NET AJAX got 4 new controls, an expanded set of extensions for Visual Studio, and plenty of upgrades to the other controls. Let’s also not forget the new Visual Style Builder, which lets you quickly and easily create custom skins for the ASP.NET AJAX controls. The RadControls for Silverlight suite now features 3D charts – the first of its kind in the Silverlight space – and a new scheduler control. Telerik Reporting has a Crosstab Wizard. And there were plenty of upgrades to go around for those of you using their WinForms, WPF, and OpenAccess ORM product lines as well. You can read the full details here, here, or watch the video here. If you want to play around with the new release, they have an upgraded set of demos available online. Notice the new navigation bar at the top that lets you move from product to product – a nice touch!

And as if releasing a huge set of product enhancements wasn’t enough, Telerik generated a lot of excitement with daily webinars to showcase the new product features and contests in which they gave away thousands of dollars worth of prizes. I’ve never seen my Twitter feed so full of Telerik updates! If you missed the webinars they’re already posted to Telerik TV. They’re quick like that.

And if THAT wasn’t enough, Telerik also snuck in some new Oslo projects as well. Head over to Telerik Labs to check out the Oslo Comparison and Migration Tool and a new LINQ to M implementation.

Telerik is really moving at warp speed and continues to impress with the high quality products they put out. They really delivered this round and I can’t wait to see what’s next. The buzz I hear from the Telerik camp is that Q3 2009 is going to be even better.

Gig ‘em!

Moderating Comments…

Kevin Babcock — Sat, 11 Jul 2009 00:19:23 -0400

I am definitely not a fan of comment moderation. But unfortunately I’ve had to turn comment moderation on for now to stop the recent deluge of spam. Once I have the time to add CAPTCHA functionality to the site I’ll turn off comment moderation (what a great opportunity to test out Telerik’s new control!).

For those of you doing the manual spam thing: get a life and stop putting your links on my site.

To the rest of you posting great discussions and feedback: thanks! I appreciate your input.

Gig ‘em!

Visual Studio Tip: Navigate Your Code

Kevin Babcock — Fri, 10 Jul 2009 23:38:58 -0400

When working in big projects one of my favorite ways to get around is to right-click on a variable, class name, or method call in code and select Go To Definition from the context menu.

This quickly opens the file where the object you clicked on is defined and navigates to its definition. Very handy when trying to sort through and figure out code you didn’t write. If you’re like me, you often find yourself wandering into the depths of someone else’s code and eventually you’re going to want to back out and get back to where you started. In Visual Studio there are two navigation buttons on the Standard toolbar menu which allow you to move forward and backwards through your navigation history.

If you select the dropdown menu on the Backward button you can also view and navigate to code you visited in your navigation history. It is organized by filename so you can easily locate the code you want.

You can also use the keyboard shortcuts to navigate forward and backward more quickly:

Navigate Forward: Ctrl + Shift + -
Navigate Backward: Ctrl + -

The shortcuts aren’t as intuitive as I like, so I changed them. You change the keyboard shortcuts bound to the navigation commands as well in Tools | Options | Environment | Keyboard.

Enjoy!

SQL Server: 'Saving changes is not permitted.'

Kevin Babcock — Sun, 05 Jul 2009 23:38:49 -0400

Saving changes is not permitted. The changes you have made require the following tables to be dropped and re-created. You have either made changes to a table that can't be re-created or enabled the option Prevent saving changes that require the table to be re-created.

I ran into this fun little error message again tonight. It’s an annoying warning that pops up in SQL Server 2008 when performing certain changes to an existing schema. Apparently SQL Server 2008 drops and re-creates your tables when you make certain changes, so it keeps you from accidentally screwing up your database by providing this error. There is a setting which you can change to get around this “feature” but I highly recommend you think it through before just turning the warning off. After all, you wouldn’t want to inadvertently drop an important table would you?

To turn the warning off, go to Tools | Options | Designers | Table and Database Designers in SQL Server Management Studio and de-select the "Prevent saving changes that require table re-creation" checkbox.

You can also turn the setting off from Visual Studio by de-selecting the same checkbox in Tools |Options | Database Tools | Table and Database Designers | Table and Database Options.

Enjoy!

Performing Set Operations with LINQ

Kevin Babcock — Wed, 01 Jul 2009 23:59:44 -0400

LINQ’s set operations provide an easy (and fast!) way to filter or combine collections of objects in .NET. The four extension methods that perform set operations – Distinct, Except, Intersect, and Union – are available through the IEnumerable<T> and IQueryable<T> interfaces and use an instance of IEqualityComparer<T> to produce a result based on the presence or absence of equivalent elements.

IEqualityComparer<T>

When performing set operations against collections of built-in types you don’t need to use your own IEqualityComparer<T> implementation; using the default, EqualityComparer<T>, is sufficient. However, if you are performing these operations against collections of your own complex types you will need to create your own and pass it in to the method call. The details of how IEqualityComparer<T> works is probably the single most important thing to understand when using set operations.

The IEqualityComparer<T> interface requires implementation of two methods, Equals() and GetHashCode(). The first is an obvious requirement: you need to check the members of the set against each other for equality. The second has been a source of much confusion. If you take a look at the implementation of set operations in .NET Reflector, you’ll see that when iterating through collections to perform equality checks, it uses both Equals() and GetHashCode() to check for equality.

int hashCode = this.InternalGetHashCode(value);
for (int i = this.buckets[hashCode % this.buckets.Length] - 1; 
     i >= 0; 
     i = this.slots[i].next)
{
    if ((this.slots[i].hashCode == hashCode) 
        && this.comparer.Equals(this.slots[i].value, value))
    {
        return true;
    }
}

Here we see that the hash code is retrieved from a method called InternalGetHashCode(), which in turn calls the IEqualityComparer<T>’s GetHashCode() method. The actual values are stored in a private member array called slots and then another private array, buckets, is used to map values to an index based on the hash code. This is a hash table implementation, making value lookups very fast. It makes sense that we’d need two values considered to be equal to also return an identical hash code. Otherwise, the hash table would not work correctly and we’d have to iterate through the entire list of values to check each one for equality, which would seriously degrade performance. The use of hash tables is what makes the set operations so fast.

So with this newfound understanding of how IEqualityComparer<T> is used with set operations, we can design custom implementations correctly. Let’s create two simple implementations to cover the general cases that I have run into: one in which the equality of an object is based on the value of a single member, and another in which equality is based on two or more members.

For the first case, implementing IEqualityComparer<T> is simple:

public class SimpleData
{
    public string Value { get; set; }
}

public class SimpleDataComparer : IEqualityComparer<SimpleData>
{
    public bool Equals(SimpleData x, SimpleData y)
    {
        return x.Value == y.Value;
    }

    public int GetHashCode(SimpleData obj)
    {
        return obj.Value.GetHashCode();
    }
}

I have a class, SimpleData, that has a single member I want to use to test my class for equality. Notice in the implementation of SimpleDataComparer that I don’t call the object’s GetHashCode() method, but instead call GetHashCode() on the member being used to compare the data. This is an important distinction. Consider the following code snippet in which I use two SimpleData objects, each of which contains identical values. Calling GetHashCode() on these identical objects returns different values, whereas calling Value.GetHashCode() returns identical values.

var data1 = new SimpleData { Value = "SomeValue" };
var data2 = new SimpleData { Value = "SomeValue2" };
var hashCode1 = data1.GetHashCode();        // returns 37121646
var hashCode2 = data2.GetHashCode();        // returns 45592480
var hashCode3 = data1.Value.GetHashCode();  // returns -840951029 
var hashCode4 = data2.Value.GetHashCode();  // returns -840951029

As you can see, calling the object’s GetHashCode() method returns different values, whereas calling it on the specific member we are comparing returns the same value. Of course, we could call SimpleData.GetHashCode() if we provided an overloaded implementation that returned identical values for equal objects. As an aside, don’t get too hung up on the negative hash code value that was returned. Internally the leftmost bit in the value is actually flipped, making it a positive value, before it is used.

The second case I want to bring up is one in which you might want to use more than one member to determine equality. Consider the following example, in which I use a custom class, ComplexData.

var data1 = new ComplexData 
    { FirstValue = 0.12, SecondValue = 1.45m, ThirdValue = "MyValue" };
var data2 = new ComplexData 
    { FirstValue = 0.12, SecondValue = 1.45m, ThirdValue = "MyValue" };
var hashCode1 = data1.GetHashCode();                // returns 22008501
var hashCode2 = data2.GetHashCode();                // returns 9008175
var hashCode3 = data1.FirstValue.GetHashCode()  ^   // returns -228796266 
                data1.SecondValue.GetHashCode() ^
                data1.ThirdValue.GetHashCode();     
var hashCode4 = data2.FirstValue.GetHashCode()  ^   // returns -228796266
                data2.SecondValue.GetHashCode() ^
                data2.ThirdValue.GetHashCode();

If I want to test for equality using multiple members of my custom class I must ensure that GetHashCode() returns a unique value based on these each unique set of values for my objects. As you’ve seen in the example above, this can be accomplished very easily by calling GetHashCode() on each value used in the comparison and then combining the results with an exclusive OR operator (^). Consider the following implementation:

public class ComplexDataDataComparer : IEqualityComparer<ComplexData>
{
    public bool Equals(ComplexData x, ComplexData y)
    {
        return x.FirstValue  == y.FirstValue  && 
               x.SecondValue == y.SecondValue && 
               x.ThirdValue  == y.ThirdValue;
    }

    public int GetHashCode(ComplexData obj)
    {
        return obj.FirstValue.GetHashCode()  ^
               obj.SecondValue.GetHashCode() ^
               obj.ThirdValue.GetHashCode();
    }
}

So there you have it. It’s been a somewhat length explanation, but I’ve seen quite a few questions in forums and on blogs regarding how to properly implement IEqualityComparer<T> (and why). And since this is a crucial element when performing set operations on complex types, it must be understood. So let’s move on to set operations and how we can use what we’ve learned so far to take advantage of this great LINQ functionality.

Distinct

The Distinct() method returns all objects that are unique in the set.

var numbers = new List<int> { 1, 2, 3, 2, 4, 1 };
// returns { 1, 2, 3, 4 }
var distinctNumbers = numbers.Distinct();

You can also pass in an instance of your own class to compare for equality:

var set = new List<ComplexData>
{
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" }
};
var comparer = new ComplexDataDataComparer();
var distinctSet = set.Distinct<ComplexData>(comparer);

Except

The Except() method returns the unique set of objects from one set that do not appear in a second set.

var numbers = new List<int> { 1, 2, 3, 2, 4, 1 };
var otherNumbers = new List<int> { 3, 4, 1, 9, 4, 7 };
// returns { 2 }
var filteredNumbers = numbers.Except(otherNumbers);

You can also pass in an instance of your own class to compare for equality:

var set = new List<ComplexData>
{
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" }
};
var secondSet = new List<ComplexData>
{
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" },
    new ComplexData { FirstValue = 7.1, SecondValue = 4.5m, ThirdValue = "Ef" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 0.4, SecondValue = 3.9m, ThirdValue = "Rs" }
};
var comparer = new ComplexDataDataComparer();
var filteredSet = set.Except(secondSet, comparer);

Intersect

The Intersect() method returns all objects that two sets share in common.

var numbers = new List<int> { 1, 2, 3, 2, 4, 1 };
var otherNumbers = new List<int> { 3, 4, 1, 9, 4, 7 };
// returns { 1, 3, 4 }
var commonNumbers = numbers.Intersect(otherNumbers);

You can also pass in an instance of your own class to compare for equality:

var set = new List<ComplexData>
{
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" }
};
var secondSet = new List<ComplexData>
{
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" },
    new ComplexData { FirstValue = 7.1, SecondValue = 4.5m, ThirdValue = "Ef" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 0.4, SecondValue = 3.9m, ThirdValue = "Rs" }
};
var comparer = new ComplexDataDataComparer();
var commonSet = set.Intersect(secondSet, comparer);

Union

The Union() method returns the combined set of unique objects from two sets.

var numbers = new List<int> { 1, 2, 3, 2, 4, 1 };
var otherNumbers = new List<int> { 3, 4, 1, 9, 4, 7 };
// returns { 1, 2, 3, 4, 9, 7 }
var combinedUniqueNumbers = numbers.Union(otherNumbers);

You can also pass in an instance of your own class to compare for equality:

var set = new List<ComplexData>
{
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 1.2, SecondValue = 0.1m, ThirdValue = "Ab" },
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" }
};
var secondSet = new List<ComplexData>
{
    new ComplexData { FirstValue = 2.1, SecondValue = 3.4m, ThirdValue = "Xy" },
    new ComplexData { FirstValue = 7.1, SecondValue = 4.5m, ThirdValue = "Ef" },
    new ComplexData { FirstValue = 3.1, SecondValue = 9.7m, ThirdValue = "Cd" },
    new ComplexData { FirstValue = 0.4, SecondValue = 3.9m, ThirdValue = "Rs" }
};
var comparer = new ComplexDataDataComparer();
var combinedUniqueValues = set.Union(secondSet, comparer);

Wrap Up

Using set operations is very easy and can be used to perform fast set operations on your collections. When performing set operations on collections of complex types, it is important to understand how to properly implement IEqualityComparer<T>. I used LINQ to Objects in the examples of this blog post, but you can just as easily take this concepts to LINQ to SQL, LINQ to Entities, or other LINQ implementations.

Have fun!

Hey jQuery lovers, ASP.NET AJAX can do Ajax too!

Kevin Babcock — Fri, 26 Jun 2009 00:21:53 -0400

I’m a big fan of jQuery. I’m no expert, but with a copy of jQuery in Action on my desk and ~~Google~~ Bing at my fingertips I can do a lot of cool things with it. One of the ways I often see people using jQuery is to make Ajax requests. jQuery provides a great library which should take care of just about all your Ajax needs, if you are an UpdatePanel-free web developer. I’ve blogged about it to a small degree, but for more in-depth details you can read about it here. For a quick example, here’s how you might make an Ajax call using jQuery:

$.ajax({
    url: "Services/Customers.svc",
    type: "GET",
    cache: false,
    success: getCustomersCompleteHandler
});

What amazes me is when I see folks using jQuery when all they need is Ajax functionality. If you’re using ASP.NET, you shouldn’t be surprised to know that it’s already provided for you in the client-side library. When you add service references to your ScriptManager, the JavaScript proxies it generates aren’t magic code; they make explicit calls into the ASP.NET AJAX library to perform service calls. You can too!

Using the WebRequest class, making Ajax calls is just as easy with ASP.NET AJAX:

function getCustomers(startIndex, rowCount) {
    var request = new Sys.Net.WebRequest();
    var url = String.format("Services/Customers.svc/?i={0}&c={1}", startIndex, rowCount);
    request.set_url(url);
    request.set_httpVerb("GET");
    request.add_completed(getCustomersCompleted);
    request.invoke();
}

Upon completion of the request you can access returned data or handle timeouts and aborted requests through the WebRequestExecutor object that is passed to the event handler.

function getCustomersCompleted(executor, args) {
    if (executor.get_responseAvailable()) {
        var data = executor.get_responseData();
        var jsonData = eval("(" + data + ")");
        loadContent(jsonData);
    }
    else if (executor.get_timedOut()) {
        // handle request timeout
    }
    else if (executor.get_aborted()) {
        // handle aborted request
    }
}

I built a very simple client-side “grid” that offers paging functionality and retrieves all its data from a web service. You can see that each request made from the ASP.NET AJAX library invokes the web service and returns only the minimum amount of data necessary to update the grid.

Check out the [LIVE DEMO], or download the [SOURCE CODE], to see it in action.

If you’re already using jQuery to add other rich functionality to your site then it makes sense to use it for your Ajax needs as well. But if all you need is Ajax, don’t forget that the ASP.NET AJAX library offers the same functionality without the need to manage yet another client-side library in your web app. It’s good to have options.

JavaScript Shortcuts

Kevin Babcock — Wed, 24 Jun 2009 21:26:26 -0400

JavaScript is definitely an interesting language. Unlike typical server-side code, we will often sacrifice readability for brevity in order to save a few bytes. Thanks to the many JavaScript compression apps out there, we don’t have to worry about this as much. But there are a few shortcuts I like to use from time to time which keep my client script terse, albeit a little less readable than using alternative means.

|| as a null coalescing operator

A null coalescing operator returns the value to its right only if the value to its left is null. Here is an example of a null coalescing operator (??) in C#:

public string GetWebAddress(protocol, url) 
{
    protocol = protocol ?? "http://";
    return protocol + url; 
}
string p = "https://";
string url = "www.mysite.com";
string address = getWebAddress(p, url);    // returns "https://www.mysite.com"
string address = getWebAddress(null, url); // returns "http://www.mysite.com"

There is no null coalescing operator in JavaScript. However, you can use the logical OR operator (||) in its place. Here is similar code in JavaScript:

function getWebAddress(protocol, url) {
    protocol = protocol || "http://";
    return protocol + url; 
}
var p = "https://", url = "www.mysite.com";
var address1 = getWebAddress(p, url);    // returns "http://www.mysite.com"
var address2 = getWebAddress(null, url); // returns "https://www.mysite.com"

This is logically equivalent to

function getWebAddress(protocol, url) {
    if (protocol === null) {
        protocol = "http://";
    }
    return protocol + url; 
}
var p = "https://", url = "www.mysite.com";
var address1 = getWebAddress(p, url);    // returns "http://www.mysite.com"
var address2 = getWebAddress(null, url); // returns "https://www.mysite.com"

But the first method, using the logical OR operator, is much more compact.

!! for quick boolean conversion

You can quickly cast JavaScript variables to boolean values using the double exclamation (!!). This operation will convert any non-null, non-zero value to true and all others to false.

var obj = { name: 'Kevin' };
var arr = [ '1', 0, '0' ];
var a = !!true;         // True
var b = !!false;        // False
var c = !!'true';       // True
var d = !!'false';      // True
var e = !!5;            // True
var f = !!0;            // False
var g = !!null;         // False
var h = !![];           // True
var i = !!{};           // True   
var j = !!'undefined';  // True
var k = !!obj.name;     // True
var l = !!obj.age;      // False
var m = !!arr[0];       // True
var n = !!arr[1];       // False
var o = !!arr[2];       // True
var p = !!arr[3];       // False

Enjoy!

RadControls for ASP.NET AJAX Q2 2009 Beta Available

Kevin Babcock — Tue, 23 Jun 2009 21:28:53 -0400

I’m a little late to the party, but I wanted to toss a quick plug to the folks at Telerik for the Beta release of their Q2 2009 RadControls for ASP.NET AJAX suite. If you’re like me and can’t wait another few weeks for the official release, you can download and start playing with the beta version today. It’s got some great new features, some of which I hope to cover right here.

Four, count them, FOUR new controls: RadBinaryImage, RadCaptcha, RadListBox, and RadXmlHttpPanel. Wow! Check out the demos.
Visual Studio Extensions. Templates and wizards covering common application scenarios, among other things.
Control improvements & bug fixes. There are quite a few new features for many of the controls, and bug fixes all around. It looks like the RadScheduler and RadGrid got a great deal of attention, but they aren’t the only ones!
A sleek new installer. The installation itself still takes about the same amount of time, but the new installer is a welcome change from the old full-screen installer.

Go read more about the new features, or download the controls and discover the new features for yourself.

ASP.NET AJAX & Type-safe parameters

Kevin Babcock — Tue, 23 Jun 2009 01:49:52 -0400

The information in this post was written for the ASP.NET AJAX 4.0 Preview 4, and is subject to change with future releases.

A new feature in the ASP.NET AJAX 4.0 client library is the Function.validateParameters() method. I say “new,” but it has really been there all along as a the private member Function._validateParams(). We all know that there is no such thing as public and private in JavaScript, but the accepted practice is that all members starting with an underscore (“_”) should be considered private and left untouched. You are free to call private member functions and access private member variables if you like, but doing so is bad for a number of reasons. First, it violates industry standard. Second, and most importantly, doing so is not supported by Microsoft. So if in a future release Microsoft suddenly decides to change the behavior of the private member to something unexpected, you won’t have anyone to blame but yourself.

As of Preview 4 of the ASP.NET AJAX 4.0 client library, the functionality has been exposed through the Function.validateParameters() method. I’m glad the folks at Microsoft have realized the value in making this feature public. Here’s how you can start using it today…

Function.validateParameters(parameters, expectedParameters, validateParameterCount)

parameters

The first argument is the list of the parameters that were actually passed to the JavaScript function. This can be easily accessed by calling the arguments variable, which is local to every function.

function doSomething(aString, aNumber) {
    var e = Function.validateParameters(arguments, [
        { name: "aString", type: String },
        { name: "aNumber", type: Number }
    ], false);
    if (e) throw e;
    // do something...    
}

expectedParameters

The second parameter is an array containing information about each expected parameter. There are several options you can use to specify what type of parameter is expected:

var e = Function.validateParameters(arguments, [
    { 
        name:              "name",          // any string value
        type:              [expected type], // any native or custom JavaScript type
        integer:           [true|false],
        domElement:        [true|false],
        mayBeNull:         [true|false],
        optional:          [true|false],
        elementType:       [true|false],
        elementDomElement: [true|false],
        elementInteger:    [true|false],
        elementMayBeNull:  [true|false]
    }, ...]);

name: The name of the parameter. The name is not used in any validation, but is instead used for error reporting. If validation fails, the name value will be passed to the Error object returned from Function.validateParameters() to indicate which parameter was the culprit.

type: The data type of the parameter. This can be a native JavaScript type, an ASP.NET AJAX client library type, or your own custom type.

function sendMessage(message) {
    var e = Function.validateParameters(arguments, [
        { name: "message", type: String }
    ], true);
    if (e) throw e;
    // send message...    
}
sendMessage('This is a test message');

function saveCustomer(customer) {
    var e = Function.validateParameters(arguments, [
        { name: "customer", type: MyApp.Entities.Customer}
    ], true);
    if (e) throw e;
    // save customer...    
}
var customer = new MyApp.Entities.Customer();
saveCustomer(customer);

domElement: A boolean value indicating whether or not the parameter is a DOM element.

function updateContent(container) {
    var e = Function.validateParameters(arguments, [
        { name: "container", domElement: true }
    ], true);
    if (e) throw e;
    // update content...    
}
var divContainer = $get('container');
var nonExistingElement = $get('nothing');  // returns null
updateContent(divContainer);
updateContent(nonExistingElement);         // throws Sys.ArgumentException
updateContent('test');                     // throws Sys.ArgumentNullException

integer: A boolean value indicating whether or not the parameter is an integer. Only evaluated if the type option is set to Number.

function updateAge(age) {
    var e = Function.validateParameters(arguments, [
        { name: "age", type: Number }], 
    true);
    if (e) throw e;
    // update age...
}
updateAge(23.78);  // ok
updateAge(23);     // ok

function updateAge(age) {
    var e = Function.validateParameters(arguments, [
        { name: "age", type: Number, integer: true }], 
    true);
    if (e) throw e;
    // update age...
}
updateAge(23.78)   // throws Sys.ArgumentOutOfRangeException
updateAge(23);     // legal

mayBeNull: A boolean value indicating whether or not the parameter may be null.

function doSomething(aString) {
    var e = Function.validateParameters(arguments, [
        { name: "aString", type: String, mayBeNull: true }], 
    true);
    if (e) throw e;
    // do something...
}
doSomething('');   // ok
doSomething(null); // ok
doSomething();     // throws Sys.ParameterCountException

optional: A boolean value indicating whether or not the parameter is optional.

function doSomething(aString) {
    var e = Function.validateParameters(arguments, [
        { name: "aString", type: String, optional: true }], 
    true);
    if (e) throw e;
    // do something...
}
doSomething('');   // ok
doSomething(null); // throws Sys.ArgumentNullException
doSomething();     // ok

elementType: The data type expected for each element of an array parameter. This can be a native JavaScript type, an ASP.NET AJAX client library type, or your own custom type. Does not enforce any restriction on the array size.

function doSomething(anArray) {
    var e = Function.validateParameters(arguments, [
        { name: "anArray", type: Array, elementType: String }], 
    true);
    if (e) throw e;
    // do something...
}
doSomething([]);                // ok
doSomething(['test']);          // ok
doSomething(['one', 'two']);    // ok
doSomething(['one', 'two', 3]); // throws Sys.ArgumentTypeException
doSomething();                  // throws Sys.ParameterCountException

elementDomElement: A boolean value indicating whether or not each element in the array parameter is a DOM element. Does not enforce any restriction on the array size.

function doSomething(anArray) {
    var e = Function.validateParameters(arguments, [
        { name: "anArray", type: Array, elementDomElement: true }], 
    true);
    if (e) throw e;
    // do something...
}
doSomething([$get('container')]); // ok
doSomething(['test']);            // throws Sys.ArgumentException
doSomething();                    // throws Sys.ParameterCountException

elementInteger: A boolean value indicating whether or not each element in the array parameter is an integer. Only evaluated if the type option is set to Number. Does not enforce any restriction on the array size.

function doSomething(anArray) {
    var e = Function.validateParameters(arguments, [
        { name: "anArray", type: Array, elementType: Number, elementInteger: true }], 
    true);
    if (e) throw e;
    // do something...
}
doSomething([]);        // ok
doSomething([null]);    // throws ArgumentNullException
doSomething([1, 2, 3]); // ok
doSomething();          // throws ParameterCountException

elementMayBeNull: A boolean value indicating whether or not each element in the array parameter may be null. Does not enforce any restriction on the array size.

function doSomething(anArray) {
    var e = Function.validateParameters(arguments, [
        { name: "anArray", type: Array, elementMayBeNull: true }], 
    true);
    if (e) throw e;
    // do something...
}
doSomething([]);                      // ok
doSomething([null, '']);              // ok
doSomething(['test', null, 'test']);  // ok
doSomething();                        // throws Sys.ParameterCountException

parameterArray: A boolean value indicating whether or not the parameter is a variable-length array. This option is helpful when you want to define a function with a required set of parameters and a variable number of trailing parameters. A good example is the ASP.NET AJAX client library’s String.format():

String.format = function String$format(format, args) {
    var e = Function._validateParams(arguments, [
        {name: "format", type: String},
        {name: "args", mayBeNull: true, parameterArray: true}
    ]);
    if (e) throw e;
    return String._toFormattedString(false, arguments);
}

It expects a format parameter or type String, and then a variable number of arguments.

var name = "Kevin", age = 28;
var formattedValue = String.format("Name: {0}, Age: {1}", name, age);

There are some peculiarities that you should be aware of when using several mutually exclusive parameter options (domElement, integer, etc) at the same time. Specifically, there is an order of precedence when evaluating the parameter rules and certain combinations of options may cause unexpected results. However, those details will have to wait for another post.

validateParameterCount

The third argument to Function.validateParameters() indicates whether or not to explicitly validate the parameter count. JavaScript allows you to pass in a different number of parameters than expected by a function.

function doSomething(aString, aNumber) {
    // do something...    
}

// both of the following function calls are legal
doSomething('test');          // aString = 'test', aNumber = undefined
doSomething('test', 1, 2, 3); // aString = 'test', aNumber = 1

Passing fewer parameters than expected by a JavaScript function results in the extra parameters being undefined. Passing more parameters than expected is also legal, but the extra parameter values are only accessible by referencing the proper index in the local arguments variable.

Using the validateParameterCount option, you can ensure that the correct number of parameters is present.

function doSomething(aString) {
    var e = Function.validateParameters(arguments, [{ name: "aString" }], true);
    if (e) throw e;
    // do something...    
}
doSomething('test'); // ok
doSomething(25);     // ok
doSomething();       // throws a Sys.ParameterCountException

The first two calls to doSomething() are perfectly legal. Since no parameter type was specified, the only validation that occurs is the parameter count. The third call will cause Function.validateParameters() to return an Error.parameterCount exception, which will be thrown by the calling function.

Since the ASP.NET AJAX client library validates the parameters passed in to Function.validateParameters(), you cannot omit the first two. However, the third is optional and will default to true if unspecified.

It is important to note that when using the validateParameterCount option in conjunction with the parameterArray option, the enforced minimum number of parameters will be the number of parameters preceding the one with the parameterArray option in the expectedParameters array.

// requires a minimum of 2 parameters, no maximum
function doSomething(aString, aNumber, params) {
    var e = Function.validateParameters(arguments, [
        { name: "aString", type: String },
        { name: "aNumber", type: Number },
        { name: "params", parameterArray: true  }
    ], true);
    if (e) throw e;
    // do something...    
}

// requires a minimum of 1 parameter, no maximum
function doSomethingElse(aString, params) {
    var e = Function.validateParameters(arguments, [
        { name: "aString", type: String },
        { name: "params", parameterArray: true  }
    ], true);
    if (e) throw e;
    // do something...    
}

doSomething('test');                       // throws a Sys.ParameterCountException
doSomething('test', 123);                  // ok
doSomething('test', 123, 'testing', 123);  // ok
doSomething();                             // throws a Sys.ParameterCountException
doSomethingElse('test');                   // ok
doSomethingElse('test', 123, 123);         // ok

Wrap up

Due to its dynamic nature and language-specific peculiarities, type-checking in JavaScript is usually a cumbersome task. Fortunately, the folks at Microsoft have abstracted those details away into a tidy little function call, making it easier than ever to enforce type safety on our functions. Since it is used to perform type-checking throughout the entire ASP.NETAJAX client library, I think it is safe to assume that Function.validateParameters() performs fairly well. However, I haven’t done any performance testing myself so I recommend testing it in your own applications before using it extensively.

Shhhh…You’ll wake the baby!

Kevin Babcock — Mon, 22 Jun 2009 19:26:19 -0400

The baby just fell asleep, the wife is on a plane to California, and I’ve got some free time. Never mind the big pile of laundry, the dirty dishes, the overgrown lawn, or the growing list of unwatched “Law & Order” episodes on the DVR. It’s time to do some writing!

I’ve been quiet lately. Not for lack of things to write about, but due to a flurry of long work days, a teething baby, and even a weekend vacation. The content is coming, I promise! I know, I know…another blog goes silent for several weeks, then the author pops in with an explanation and promises of posts to come. Well, I won’t promise anything except that I’ve got a huge backlog of topics I want to cover and not enough time to write about them all. There are already a few in the pipeline, but they’ll trickle out as time allows.

I hope you’ll stay tuned.