Emil's Wicked Cool Blog

EduSpring Part 6: Crazy Error Messages and What to do about them

2011-06-14T09:36:00.000-07:00

Because Spring will create most of your objects up front, a simple error in the configuration Xml can have disastrous effects. This, in my opinion, is the #1 reason people fear Spring.

Here are a few error messages I've seen, and their corresponding solutions:

The virtual path '/currentcontext.dummy' maps to another application, which is not allowed: This error message usually means you've deployed the application to a server, but forgotten to make the virtual directory an application in IIS. Spring performs a server.Transfer() call to "~/currentcontext.dummy" to get all the dependency wiring done correctly before another server.Transfer() brings the request back to the right place.
no application context for virtual path: This error message tells you that there's no spring configuration setup at all.
Resource handler for the 'web' protocol is not defined: This message tells you that the httpModule is not active. Add the spring.net HttpModule into the appropriate section of web.config (system.web for IIS6, system.webserver for IIS7).
Could not load type from assembly: This may or may not have anything to do with Spring, so take a look a the stack trace. If you see Spring.Core (specifically Spring.Core.TypeResolution.TypeResolver.Resolve) in the trace, you can be fairly certain you misspelled a type name in the configuration.
node cannot be resolved for the specified context: Spring tried to assign an object or value to a property, but the property doesn't exist on the object. It's likely you misspelled the property name, or maybe you refactored, removed the property, but forgot to update the spring configuration.

Things to check if your dependency is showing up as null:

Is your configuration binding the right type? For example, if your property is a string, and you're assigning a stringbuilder to it, Spring will just ignore the assignment.
You're missing the object definition in the spring configuration.
You're missing the property definition in the spring configuration.
Did you commit the cardinal sin of DI? Do not use new MyType()!

Take a look through web.config and spring.config of the Debugging Web Applications project in the eduSpring project on GitHub for troubleshooting examples. There are several errors scattered throughout the two configuration files, and the errors are fully documented.

Also note that the best way to work through the troubleshooting procedure is to correct each issue in turn, shut down the integrated web server and F5 to view the next error.

Setting up Spring.Net's verbose logging is also shown in the web.config. You might notice that the actual project references do not include anything except standard ASP.NET DLLs. Spring, Common Logging, and Log4Net must exist in the bin directory at run time, but no project references are actually required. With VS 2010 SP1 or higher, we can put these semi-dependent DLLs in a special folder called _bin_deployableAssemblies and the build procedure will copy them in place.

EduSpring Part 5: Spring.Net in an ASP.NET environment (including MVC)

2011-06-14T07:49:00.000-07:00

This post is part of a series on Spring.NET. I recommend starting at the beginning if you haven't already. Also, I am walking through code in the accompanying GitHub project.

By now, you should have the basics of DI, IoC, and the benefits and drawbacks of the approach. Now, I'll introduce you to the architecture of Spring.NET in an ASP.NET environment. I'm sure a lot of other IoC frameworks operate in a similar manner. If not, you can add code to make them work that way. ;-)

If you look at the IocWithoutSpring project, you'll see this Main function:

static void Main(string[] args)
        {
            //These two lines are handled by the Spring.NET HttpModule
            var container = new IoCContainer();
            container.Initialize();

            // These two lines are also handled by the HttpModule by a special 
            // syntax in the spring configuration
            var service = new DoSomeWork();
            service.Worker = container.GetObject("myObject");

            // This is what the ASP.NET Framework would do
            Console.WriteLine("The output is: " + service.DoTheWork());
        }

Most of the time, creation of the IoC container itself is a single dependency that's particularly hard to get rid of without writing some reflection-style glue code. Ideally, we want our objects to be completely ignorant of this container, though. In ASP.NET, the web.config provides us with the concept of an HttpModule, which will look at every request coming from into the web server and have an opportunity to do something with it. Taking advantage of this feature, the Spring.Net team wrote an ASP.NET HttpModule that will do just that, so the first two lines of main (instantiation and initialization of the container) are handled by the ASP.NET framework. Awesome!

Now our Spring.Net dictionary is populated, assuming we have a valid configuration. I'll address more about the pain points of Spring configuration later, but this very early creation of lots of objects is one of the main frustrations of people who want to use Spring.Net. The next question is, what about setting up dependencies in ASPX pages?

Technically speaking, the ASP.NET framework parses an ASPX file (or MVC view) and code-generates a class. On each request, it creates an instance of this class and allows it to process the request, before destroying the object. Very stateless, but this creation and destruction of classes rubs against IoC's Dictionary<string,object> heart.

If you read this contract from the other side (a.k.a. how would I solve this problem if I were writing Spring.Net), you can imagine yourself writing a PageHandlerFactory that can deliver the aspx page class with dependencies already injected. There are two problems you have to solve, however:

What name do you use to look up the object?
How do you deal with request-specific data?

The answer to #1 is relatively obvious if you look at the problem from the perspective of Spring. The object doesn't really have a name, so we leave that blank, and the virtual path (~/page.aspx) is used as the type of the object since someone configuring the object will not know the type ASP.NET generates. The actual type name needs to be figured out by Spring. The answer to the second question runs a bit contrary to what I've been discussing so far.

In the examples so far, the initialization method of the IoC container has created all the objects in configuration and put them in its internal dictionary. However, there's no reason that the objects need to be created right away, nor do they have to be held in the dictionary. In the case of this PageHandlerFactory, objects are created and configured at the time of the request, not at initialization. However, dependencies follow the normal rules.

EduSpring Part 4: What is so terribly broken with Dependency Injection?

2011-06-13T22:23:00.001-07:00

Move all the CS BS to the side. This stuff doesn't work in the real world. And it's because of things that could have (and probably should have) been fixed by uber-geeks 10+ years ago with fancy CompSci PhDs. And I'm talking about .Net specifically here, although I can throw the same stones at Java. Most (but not all) other languages have the same problems I'll get on my soapbox about here.

To do DI correctly, you have one of two options:

Your class has dependencies on properties/internal fields that implement Interfaces
Your class has dependencies on properties/internal fields that implement base classes

In both cases, the contracts are relatively weak. If you depend on a method that requires an object and returns an object, there are lots of things that can go wrong. And you have no way of knowing whether it will go wrong unless an until you run it - compile time checks don't help. Here's a short list of Murphy's law for a single method that takes an object parameter and returns an object:

Do you assume anything about the return value? It might return what you expect, or might return null. Or, it could throw an exception. Generally, experience with DI will teach you good defensive coding, but it does take work...
Can the method handle null input values? If it errors, is it going to return null or throw an exception? If it throws, what kind of exception will it generate?
Is the method you're calling going to muck with the object you pass in? If it does alter properties, is that a problem? What if you're not in control of the object, and the property this dependency decides it's OK to muck with throws an exception during the set operation?

Without some type of design by contract construct built into your language of choice, these questions become just the tip of the iceberg. Glancing through the Common Language Specification for .NET, it appears that there is no built-in construct available in the platform. C# provides a MS Research Code Contract construct in .NET 4, but they feel hacky without being part of the language, and even more hacky when implemented with IoC.

Feel free to run through the Main method for FallaciesOfInterfaces for concrete examples of how Murphy can strike. This project will compile, but will fail at almost every step. Read through the comments and fix the code one-by-one to get a sense of how, even with an IoC container and good DI practices, everything must be tested.

EduSpring Part 3: What do we need an IoC for?

2011-06-13T22:05:00.000-07:00

This post is part of a series on Spring.NET. I recommend starting at the beginning if you haven't already. Also, I am walking through code in the accompanying GitHub project.

Last time, I walked through why we might want to use dependency integration. Outside the authentication example, here are a few other examples:

Authentication
Authorization
SMTP settings
Payment gateways
Business rules (rule engine style)
Branding

This time, I'd like to explore how an IoC container actually does its job. By understanding how the IoC does its job, we can understand the value that it adds to our solutions. In the project "2 - IocWithoutSpring" on GitHub, you'll see a quick, hand-coded IoC container. It's amazingly brilliant (insert sarcasm here) and also relatively close to what a real IoC container does (really). Here is the IocContainer class in all it's glory:

class IoCContainer
    {
        private readonly IDictionary _allObjects = new Dictionary();

        public T GetObject(string objectName)
        {
            return (T)_allObjects[objectName];
        }

        public void Initialize()
        {
            // Wouldn't it be nice if we could configure this through 
            // app.config or web.config?  Spring does that!
            _allObjects.Add("myObject", new ClassA());
        }
    }

Most IoC containers work in a similar manner. There's some sort of initialization function, and there's some sort of GetObject method. Internally, all it does is "new up" all the classes you've defined and shoves them in a global dictionary object. The rest, as they say, is window dressing. As you see in the comment, once you've built an IoC container, you can think of all kinds of cool things to do. It would be really nice if you could configure from web.config/app.config, or maybe a separate XML file, or maybe the database, or maybe all of them? What if you added the ability to set properties on the objects, not just create them? How about the ability to create an object based on the state of another object (Spring calls this a factory method). How about defining objects in one place, and values for properties in another? IoC containers have all this stuff, and it's built for you...there's no reason to reinvent the wheel.

But at the end of the day, remember: An IoC container, at its heart, is a Dictionary<string, object>. And that's all, folks. Another key thing to remember, especially in a stateless ASP.NET scenario, is that those objects exist during the lifetime of the application. This is a performance gain (no GC stepping in, no creation of multiple objects), and a bug factory if you assume your objects are going to be created, used once, and destroyed.

More goodies are in the main file if you read the comments, but I'll explore them more in depth in later posts.

EduSpring Part 2: Simplifying dependencies

2011-06-13T17:25:00.000-07:00

Last time, I introduced you to Spring, IoC, and Dependency Injection. If you haven't read that post, please do. This time, I'll start walking through some of the code in the accompanying GitHub project. The code is organized by project in order of these posts. Some conventions (specifically 1 class/file) have been ignored specifically to let the reader go through in a linear manner. All projects are setup as console applications.

This time, I'll tackle the first project, "0 - Advantages of DI". This is one of the few projects I that will have more than one file to peruse. The first file is a baseline...how we would solve a particular problem in a "traditional" procedural manner. I've simulated a program that calls a service (MyClass) that needs to authenticate the user prior to performing some work on behalf of the caller. If authentication fails, it will throw an exception. Here is the class:

/// 
    /// Simulates a typical class
    /// 
    public class MyClass
    {
        /// 
        /// Authentication provider.  We can't change this out for the production version 
        /// without changing source code and recompiling
        /// 
        private readonly MyAuthenticationProvider authenticationProvider = new MyAuthenticationProvider();

        // Comment the line above, uncomment and recompile for production.  
        // 
        // By recompiling, you won't know if you're testing the same
        // code that exists in production (did you just change this line, or something else too?)  Versions might 
        // be different, etc.
        //private readonly MyProductionAuthenticationProvider authenticationProvider = new MyProductionAuthenticationProvider();

        public void DoWork(string user, SecureString password)
        {
            if(!authenticationProvider.Authenticate(user,password).Identity.IsAuthenticated)
                throw new SecurityException("Not authorized to perform this action");
            Thread.Sleep(3000);// Simulate some work
        }
    }

You'll notice that when we move this class into production, we have to remember to swap out our authentication provider. In reality, the new authentication provider might now call a central authentication single-sign-on service through a web/rest service, might redirect the user in order to change password, or any number of crazy things. For these purposes, I just check that the password is "bar".

The main point here is that we have to remember to swap, and we'll have to recompile the application when we do that. If we forget, anyone can log in with anything and we'll happily give up the goods. Since everything has been "tested", it's likely we won't thoroughly check the service (indeed, if we're on a production system, and this service's purpose was to delete a bunch of accounts, we probably wouldn't test it). After deployment have two versions of the binary - one for production, and one outside production. Who is to say there aren't any other changes in this code. Now we have a maintenance problem too - we can't assume the code is identical, and every time we deploy we run the risk of missing this step. But, it's simpler when we're coding it, isn't it?

If we could just pass this dependency into MyClass, we'll be in much better shape. At the minimum we can centralize the changes, and in the best case we can move these changes out into a configuration file or some other mechanism that doesn't require code changes for this simple switch. Enter the next file in this project - "1 - WithDependencyInjection.cs". Here are the contents:

/// 
    /// Simulates a typical class
    /// 
    public class MyClassWithDependencyInjection
    {
        /// 
        /// Authentication provider.  Because we use an interface, we no longer 
        /// need to change this code after it's been tested
        /// 
        private readonly IAuthenticate _authenticationProvider;

        /// 
        /// Constructor to establish this class' dependencies.  Since the 
        /// class is not "complete" (can't operate) without an authentication
        /// provider, we require an object up front.
        /// 
        /// public MyClassWithDependencyInjection(IAuthenticate authProvider)
        {
            if (authProvider == null)
                throw new ArgumentNullException("authProvider");
            _authenticationProvider = authProvider;
        }

        public void DoWork(string user, SecureString password)
        {
            if (!_authenticationProvider.Authenticate(user, password).Identity.IsAuthenticated)
                throw new SecurityException("Not authorized to perform this action");
            Thread.Sleep(3000);// Simulate some work
        }
    }

    /// 
    /// New Interface introduced.  Our two classes don't have a real-world inheritance relationship,
    /// but the authentication process is identical, so we build a contract
    /// 
    public interface IAuthenticate
    {
        IPrincipal Authenticate(string user, SecureString password);
    }

    class TestingAuthenticationProvider : IAuthenticate
    {
        public IPrincipal Authenticate(string user, SecureString password)
        {
            // Implementation for development
            return new GenericPrincipal(new GenericIdentity(user), new string[] { });
        }
    }

    class ProductionAuthenticationProvider : IAuthenticate
    {
        public IPrincipal Authenticate(string user, SecureString password)
        {
            if (user == "foo" && password.StringEquals("bar"))
                return new GenericPrincipal(new GenericIdentity(user), new string[] { });
            return new GenericPrincipal(new GenericIdentity(""), new string[] { }); ;
        }
    }

Here, we've done the following things:

Introduced an interface for authentication and marked both providers as implementing the interface. We could just as well have introduced a base class (concrete or abstract), but we have no default implementation, so an interface is probably best.
Introduced a parameterized constructor for the main class. Now this class lets the world know that it can't do it's job without a way to authenticate. And it doesn't care how the authentication gets done, just that it can authenticate.

Back in the main program, we can now (sort of) demonstrate what we've done. Obviously without changing the code we can't demonstrate changing the provider for MyClass, but we can demonstrate the DI approach to the problem:

static void Main(string[] args)
        {
            // Without DI
            new MyClass().DoWork("foo", new SecureString().Append("bar"));
            
            // With DI
            var testSystemProvider = new TestingAuthenticationProvider();
            var productionSystemProvider = new ProductionAuthenticationProvider();
            // The choice of test/production is now made here, outside of the class.  
            // The class shouldn't "care" who does the authentication work, it's job is to do other work
            // The new statement in the next line would be done through an IoC container (e.g. Spring) in a 
            // real environment.
            new MyClassWithDependencyInjection(testSystemProvider).DoWork("foo", new SecureString().Append("bar"));

            // Switch the constructor (in Spring.NET, done through a config file change) and now we're running against 
            // "production".  No recompile necessary
            new MyClassWithDependencyInjection(productionSystemProvider).DoWork("foo", new SecureString().Append("bar"));

            // We can also do this without a container.  Here, we'll get type information from the command line.
            // Change the provider type via project properties to see how this works.
            // The next line is basically what an IoC container would do
            var myAuthProvider = (IAuthenticate)Activator.CreateInstance(Type.GetType(args[0]));
            new MyClassWithDependencyInjection(myAuthProvider).DoWork("foo", new SecureString().Append("bar"));
        }

With dependency injection techniques, the caller can decide the authentication mechanism. Given a proper IoC container, this configuration will be centralized, but for now, we can do it manually by creating two objects, one of type TestingAuthenticationProvider and one of type ProductionAuthenticationProvider. These are passed into the constructor for the DI class, and voilà, we can change the way authentication works. In the last two lines, I show how we can even pass in the type name via the command line. Now, for the first time, we have the ability to change the way we authenticate without changing code.

...and that, folks, is all an IoC container is about.

EduSpring Part 1: Introduction

2011-06-13T16:46:00.000-07:00

I get quite a few questions about Spring.Net, so I thought I'd put together a VS Solution, presentation, and set of blog posts to provide some background and details about what it is, why/when to consider using it, and how to configure and debug the framework.

A lot of this material will not be specific to Spring.Net, but rather Dependency Injection generally. To understand Spring.Net, you must be familiar with Inversion of Control and Dependency Injection. You can read about them on Wikipedia, but here's a short summary:

Inversion of Control: Flow of control of a system is inverted in comparison to procedural programming
Dependency Injection: A specific technique to achieve inversion of control with respect to dependencies

What this means in layman's terms is that instead of a program:

Starts up
Creating new services for whatever needs to be done
Using the services/doing the work
Disposing of the services and returning the results

The program now does only what it's responsible. Namely:

Starts up
Uses services that have been configured for its use/does the work
Returns the results

This makes the program itself easier to test, simpler to code/maintain, and separates infrastructural responsibilities (determine location of services and creating them) from the business logic the program was created to deliver.

The devil in these particular details are in #2. How does one create and configure services for a program? We can code this by hand, but it's a lot of boring glue code, and doing it right is incredibly difficult. Enter the IoC container - a piece of pre-built code that will do this work for us. Depending on the application, we don't even need to use the container explicitly. In a system like ASP.NET, we can use HttpModules to intercept requests and wire dependencies automatically.

One significant problem with this approach are the complexity of configuration. Using Spring.net, I can have a dependency-injected factory method to deliver an instance of an object used to populate a property that will be injected into another object that will have additional advice applied through Spring.Net's AOP module. When that fails, I might get a "node cannot be resolved for the specified context" without any additional information pointing me to the cause of the problem. With flexibility comes complexity.

Another issue is a fundamental problem with .NET (C# and VB and I believe all .NET classes adhering to the CLI). Interfaces are incomplete contracts.

Finally, with regards to Spring.Net in particular, the framework can be slow to move (IIS7 Integrated mode, introduced with Windows Server 2008 on Feb 27, 2008, gained support in Spring.Net 1.3.1 released December 10, 2010). Also, no Mono support exists as of this writing.

Next up - some walkthrough code.

Total application design: circa 2011

2011-06-05T23:01:00.000-07:00

Working with a few recent projects I'm getting pretty close to a nice boilerplate for a "standard" web application built with the latest technologies. Subject to client restraints, here's the stack:

UI and middle tier: ASP.NET MVC3 (using VS2010 SP1). Note that this requires .NET 4, which has some nice features (I love Tuples) but I don't think is completely necessary otherwise. SP1 is important, which I'll mention later. For smaller-ish applications I've been moving away from multiple projects in a solution, mainly because I haven't been seeing a ton of real business logic besides authorization, and I've been able to productize many ancillary functions into separate DLLs. Razor view engine is used, and templates are updated to mirror Html5Boilerplate.com's templates. jQuery is applied unobtrusively.
Data access: Fluent NHibernate. This is integrated in such a way that depending on your needs, you don't need to add a direct reference to it, though. References are needed for access to NHibernate advanced queries and the Linq provider.
URL Rewriting: UrlRewriter.Net. This is used for css/js versioning. A URLHelper extension method appends the current version number (derived at build time from source control) for the application to the script or CSS filename, and the rewriter strips it back off. We probably could use MVC3 routes here, but it seems overkill for something that could be handled by simple Url rewriting.
Dependency Injection: Spring.net. Any DI/IOC container would work here. Again, the integration with spring is very lightweight and easily replaceable. One strike against Spring.Net is the lack of support for Mono, but this hasn't been an issue in the environments with which I've been working.
Other tools: Dotless is used in a development-time capacity to generate CSS, with Chirpy (customized) to keep the development experience smooth. A handful of other custom DLLs and build tools keep the project structure relatively vanilla. Hudson is used for continuous integration.

I'm putting together a NuGet package with this build. When this is complete, I'll post an update.

Other technologies/tools on the radar are Entity Framework (NHibernate replacement) and Castle Windsor (IoC container that supports Mono). DotNetOpenAuth is under consideration as a standard way to pull in authentication and authorization functions.

Supporting Multiple Databases in Applications

2011-03-29T08:48:00.001-07:00

In general, having a persistence-ignorant application provides a lot of flexibility. Allowing us to easily port between various RDBMS’s, NoSQL data stores, text files, the cloud, or simply storing our data on papyrus managed and maintain by a group of beer-making monks provides us with tangible opportunities to cross-sell our (non-hosted) application to multiple clients.

As any write once, run anywhere scheme, support for multiple databases can be notoriously difficult. Consider the following SQL Server T-SQL code:

Wait…what? I just created FOO, yet SQL Server is telling me that the table foo doesn’t exist. What’s going on? In this case, the database default collation has been changed to Latin1_General_Bin, a binary collation, so FOO != ‘foo’. As a result, the following query also provides no results:

To get any data back from this table, we need to match exactly:

Great, so I’ve jacked the default installation collation in SQL Server. Not a lot of people or organizations do this? But…is this an academic exercise? If you want to support multiple databases and clients, the answer is a resounding NO. Consider:

Some organizations may want the application to work on a database with binary collation. Rare, but it could happen.
Organizations might be using another database, and not all databases are case insensitive, even by default.

If you want a portable application, #2 is your much more concerning issue. Recently I verified default installations on a number of popular database systems to determine what behavior they produced. Here are my findings (in alphabetical order):

	Table/Column Names	Data
Oracle	Insensitive	Sensitive
Postgres	Insensitive	Sensitive
MySQL	Sensitive	Insensitive
SQLLite	Insensitive	Sensitive
SQL Server	Insensitive	Insensitive

The most curious finding is MySQL. I’d love to know what reasoning was used to come to the conclusion that Table and Column names should be case sensitive, but data should be considered insensitive. In any case, programming for the least common denominator requires handling these situations.

Ideally you’d leave the SQL to an ORM. If your application is unlikely to switch database platforms and an ORM is out of the question, I’d recommend a RDBMS-specific data access layer. If you’re application absolutely must have a generic data layer, though, you must keep this in mind as part of design.

Batch uploading RDL files to SQL Server Reporting Services 2005

2010-03-22T07:10:00.000-07:00

There doesn't seem to be a tool to mass-upload all RDL files in a directory, so I created one. It's available on BitBucket here: http://bitbucket.org/emil/bulk-rdl-uploader-for-ssrs-reports/overview/

The executable is available here: http://bitbucket.org/emil/bulk-rdl-uploader-for-ssrs-reports/downloads/ReportingServicesBatchUpload.exe

This is a console application with no dependencies (it calls a web service). Call without parameters for usage information. One known bug is that the "create a folder if it doesn't already exist" logic seems to be broken for some servers, so for best results create the reporting services folder prior to running the program.

Working with a feature branch in Subversion (TortoiseSVN on Windows)

2010-03-09T08:51:00.000-08:00

Branching and merging is one of the most nerve-racking activities for people working with Subversion. Unlike Mercurial and other DVCS where branching and merging is commonplace, typical workflows in Subversion do not include this activity. As a result, the terminology is typically confusing, the massive number of changes can be scary, and a lot of people are so concerned about "getting it right" that they typically just avoid the practice altogether and work completely outside of source control. That, of course, is the exact opposite of what we need when working on an important design spike or critical new feature.

Conceptually, what we want with a design spike or large new feature is to:

Create a new branch for the change
Work in the new branch, committing early and often
Periodically pull in (merge) the changes from the project trunk
When complete, reintegrate the branch into the trunk

For these instructions, I assume that you have a subversion repository checked out and you're actively working on the trunk.

Creating a new branch:

Right-click on the directory you want to branch. Pick the Branch/Tag operation.
On the branch/tag screen, enter a new branch (typically the repository has a /branches folder as well as a /trunk folder). The new branch is typically /branches/mynewbranch, where the branch name itself is a folder that does not exist in the repository.
In this scenario, you will also want to choose "switch working copy to new branch/tag". We'll be doing work on the new feature or design change immediately, so this tells subversion that any new commits will be on that other branch.

At this point you'll want to take note of the revision number that had the last changes.

Work in the new branch, committing early and often

This is standard subversion behavior.

Periodically pull in (merge) the changes from the project trunk

You'll want to keep track of the last revision you've pulled changes from. In the beginning, this revision number is the revision that represented the branch itself.

Pick the Merge tool off the TortoiseSVN menu.
Choose the "Merge a range of revisions" from the first screen of the wizard.
In the "URL to merge from", choose the trunk.
In the Revision range to merge, the best approach is to be precise. Put in the last revision number that was merged (e.g. if you branched when the repository was at revision 10, put in 11-HEAD). You can leave this blank, but we want to avoid merging a change twice. You may need to look at the log to help find the right revisions.

Hit next and do a test merge just to be sure before performing the actual merge. All other settings can be left at their defaults. Note that the merge is done in your working directory, so you'll have a bunch of local changes to test and commit on your branch.

Reintegrate the branch into the trunk

Commit all branch changes
Switch the working directory back to the trunk. This is done via the TortoiseSVN switch command.
Pick the Merge command off the TortoiseSVN menu as before. This time, however, we'll pick the "Reintegrate a branch" option.
In the "From URL" field, put the URL to the branch you've finished working on.
Test the merge and if happy, perform the merge, test the changes, and commit to the trunk.

Spring.Net-enabled WCF Services available from Microsoft Ajax

2010-02-25T17:39:00.000-08:00

Implementing Spring.NET WCF services is fairly straightforward.

Implementing MS Ajax WCF services is also straightforward, if you pick the right New Item to add from Visual Studio.

The complication comes in when you want a Spring.NET WCF service that handles calls from Microsoft Ajax controls. This method will let you add them.

Step 1. Add new "Ajax-Enabled WCF Service"

Step 2. Create your methods, test and make sure all base functionality is working. This sample is for a CascadingDropDown control from the Ajax Control Toolkit, but any control will work.

Step 3. Introduce an interface to use for the methods. Spring.Net requires an interface, and this is the crux of the problem. Here I've created IMyAjaxService.

Step 4. Move the [ServiceContract(Namespace = "")] from the class to the interface

Step 5. Move the [OperationContract] tags from the methods on the class to the interface method definitions

Step 6. Change web.config endpoint contract (xpath = /configuration/system.serviceModel/services/service/endpoint) to reference the interface

Step 7: Test. The test should work, without dependency injection from Spring.Net. Now we have a WCF service that responds to Ajax, but has the interface definitions just the way Spring likes them.

Wiring in Spring

For Spring.NET to handle WCF, you need .NET 3.0 or higher, and you need Spring.Net 1.3.0 or higher. You'll need the following DLLs available for binding (either your bin directory or the GAC):

Spring.Core.dll from the 2.0 folder
Spring.Web.dll from the 2.0 folder
Spring.Services.dll from the 3.0 folder

In the Service you've created, edit the markup and add Factory="Spring.ServiceModel.Activation.ServiceHostFactory" onto the end, like so:

This will get Spring.Net into the activation pipeline for the service.

Lastly, you'll add the new object to spring configuration. It is CRITICAL that the OBJECT ID MATCH THE SERVICE NAME FROM WEB.CONFIG. The Spring.Net documentation mentions this, but I don't think they mention it very loudly. The type information is exactly as you'd expect: the type for the WCF service class.

Also CRITICAL: Add singleton="false" to the object definition for Spring for your new object

Intermittent Operation Aborted Errors in IE when using MS Ajax

2009-07-08T22:50:00.001-07:00

This issue has been plaguing our project: operation aborted errors, intermittent in nature, occurring sometimes as little as once/week. Even in IE 8 there were issues, although thankfully not the crazy dialog box we see in IE 6 and 7.

It turns out that the problem is due to a bug in Ajax itself. I won't go into all the details, since they're covered very well in these two blog posts:

First post with background: http://seejoelprogram.wordpress.com/2008/06/08/when-sysapplicationinitialize-causes-operation-aborted-in-ie/
Second post with bug fixes to the original bug fix: http://seejoelprogram.wordpress.com/2008/10/03/fixing-sysapplicationinitialize-again/

I didn't particularly care for the recommended way of packaging the fix, so instead I've used built-in ASP.NET Ajax functionality to override the default script delivery. I also updated the fixed functions to work for all versions of Ajax (at the time of this writing - currently Ajax bundled with .NET 3.5 SP1 and below). First, here are the updated functions:

Sys$_Application$initialize:


 function Sys$_Application$initialize() {
     if(!this._initialized && !this._initializing) {
         this._initializing = true;
         var u = window.navigator.userAgent.toLowerCase(),
             v = parseFloat(u.match(/.+(?:rv|it|ml|ra|ie)[\/: ]([\d.]+)/)[1]);

         var initializeDelegate = Function.createDelegate(this, this._doInitialize);

         if (/WebKit/i.test(u) && v < 525.13)
         {
             this._load_timer = window.setInterval(function()
             {
                 if (/loaded|complete/.test(document.readyState))
                 {
                     initializeDelegate();
                 }
             }, 10);
         }
         else if (/msie/.test(u) && !window.opera)
         {
             document.attachEvent('onreadystatechange',
                 function (e) {
                     if (e && arguments.callee && document.readyState == 'complete') {
                         document.detachEvent('on'+e.type, arguments.callee);
                         initializeDelegate();
                     }
                 }
             );
             if (window == top) {
                 (function () {
                     try {
                         document.documentElement.doScroll('left');
                     } catch (e) {
                         setTimeout(arguments.callee, 10);
                         return;
                     }
                     initializeDelegate();
                 })();
             }

         }
         else if (document.addEventListener
             &&  ((/opera\//.test(u) && v > 9) ||
                 (/gecko\//.test(u) && v >= 1.8) ||
                 (/khtml\//.test(u) && v >= 4.0) ||
                 (/webkit\//.test(u) && v >= 525.13))) {
             document.addEventListener("DOMContentLoaded", initializeDelegate, false);
         }
         else
         {
             $addHandler(window, "load", initializeDelegate);
         }
     }
 }

Sys$_Application$_doInitialize():


 function Sys$_Application$_doInitialize() {
   if (this._initialized) {
    return;
   }
   Sys._Application.callBaseMethod(this, 'initialize');
   if (this._load_timer !== null)
   {
    clearInterval(this._load_timer);
    this._load_timer = null;
   }
   var handler = this.get_events().getHandler("init");
   if (handler) {
    this.beginCreateComponents();
    handler(this, Sys.EventArgs.Empty);
    this.endCreateComponents();
   }
   if (Sys.WebForms) {
    if (this._onPageRequestManagerBeginRequest) this._beginRequestHandler = Function.createDelegate(this, this._onPageRequestManagerBeginRequest);
    if (this._beginRequestHandler) Sys.WebForms.PageRequestManager.getInstance().add_beginRequest(this._beginRequestHandler);
    if (this._onPageRequestManagerEndRequest) this._endRequestHandler = Function.createDelegate(this, this._onPageRequestManagerEndRequest);
    if (this._endRequestHandler) Sys.WebForms.PageRequestManager.getInstance().add_endRequest(this._endRequestHandler);
   }

   if (this.get_stateString){
    var loadedEntry = this.get_stateString();
    if (loadedEntry !== this._currentEntry) {
     this._navigate(loadedEntry);
    }
   }
   this.raiseLoad();
   this._initializing = false;
  }

Sys$_Application$_loadHandler():


 function Sys$_Application$_loadHandler() {
  if(this._loadHandlerDelegate) {
   Sys.UI.DomEvent.removeHandler(window, "load", this._loadHandlerDelegate);
   this._loadHandlerDelegate = null;
  }
  this._initializing = true;
  this._doInitialize();
 }

Next, here is how I overrode how the framework delivers the script:


  <ajaxtoolkit:toolkitscriptmanager runat="server" enablepartialrendering="true" id="ScriptManager">
       <scripts>
           <asp:scriptreference name="MicrosoftAjax.js" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" path="~/js/MicrosoftAjax-withFix.js">
       </scripts>
  </ajaxToolkit:ToolkitScriptManager>

You do not need to use the ToolKitScriptManager - you can also do it this way:


   <asp:scriptmanager runat="server" enablepartialrendering="true" id="ScriptManager">
       <scripts>
<asp:scriptreference name="MicrosoftAjax.js" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" path="~/js/MicrosoftAjax-withFix.js">
       </scripts>
   </asp:ScriptManager>

Note that you can replace ~/js with the directory of your choosing.

Be aware that when the framework loads the file, it automatically adds .debug or .release onto the end of the file name, so the final file reference provided will be either MicrosoftAjax-withFix.debug.js or MicrosoftAjax-withFix.release.js.

If you don't want to bother incorporating these fixes into .NET 3.5 SP1 Ajax files, feel free to download them from here:

Debug version: http://lerch.org/js/MicrosoftAjax-WithFix.debug.js
Release version (simply a minified version of the debug js - run through YUI Compresssor): http://lerch.org/js/MicrosoftAjax-WithFix.release.js

Javascript Hacks: Using XHR to load binary data

2009-07-07T10:56:00.001-07:00

I recently needed to get image data from a server using Javascript, base64 encode it, and post that data back to an application. While the details of why I needed to do this are a bit complex, I believe that getting image data through an XMLHttpRequest object and base 64 enconding it will become more valuable in terms of client-side image manipulation using the data URI scheme for image tags.

This would allow a Javascript developer, for instance, to load an existing image (say, a photo), without base64 encoding it on the server, load it into an image tag with a data URI, and make direct manipulations on that image.

Unfortunately, this area is relatively new and browsers have a lot of differences. Data URI support is still very new, inconsistent, and limited. In the meantime, here is how you get that base64 encoded image in the first place:

Internet Explorer:

IE has a property of XMLHttpRequest object for binary data ResponseBody. This contains exactly what we need, but unfortunately the property is not visible to Javascript. Since the string returned to Javascript by ResponseText will be terminated at the first null value, we must use ResponseBody. This requires a bit of VBScript, which can do one of the following things:

Get the numeric value of each unsigned byte and turn that into a number in a string of comma delimited numbers. This is less efficient, but gets you in and out of VBScript as quickly as possible, allowing a generic base64 encoding routine. This is the route I followed (it may be less efficient, but it pales in comparison with the XHR request just made):
```
Function BinaryArrayToAscCSV( aBytes )
 Dim j, sOutput
        sOutput = "BinaryArrayToAscCSV"
 For j = 1 to LenB(aBytes)
  sOutput= sOutput & AscB( MidB(aBytes,j,1) )
  sOutput= sOutput & ","
 Next
 BinaryArrayToAscCSV = sOutput
End Function
```
Base 64 encode it directly in VBScript.

Once this is done, we can then base64 encode it using a fairly generic function in Javascript:


Base64 = {
 
 // private property
 _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",

 encodeBinaryArrayAsString : function(input){
  var ascArr;
  var output = "";
  var bytebuffer;
  var encodedCharIndexes = new Array(4);
  
  var inx = 0;
  ascArr = input.substring("BinaryArrayToAscCSV".length, input.length - 1).split(',');
  while(inx < ascArr.length){
   // Fill byte buffer array
   bytebuffer = new Array(3);
   for(jnx = 0; jnx < bytebuffer.length; jnx++)
    if(inx < ascArr.length)
     bytebuffer[jnx] = parseInt(ascArr[inx++]); 
    else
     bytebuffer[jnx] = 0;
     
   // Get each encoded character, 6 bits at a time
   // index 1: first 6 bits
   encodedCharIndexes[0] = bytebuffer[0] >> 2;  
   // index 2: second 6 bits (2 least significant bits from input byte 1 + 4 most significant bits from byte 2)
   encodedCharIndexes[1] = ((bytebuffer[0] & 0x3) << 4) | (bytebuffer[1] >> 4);  
   // index 3: third 6 bits (4 least significant bits from input byte 2 + 2 most significant bits from byte 3)
   encodedCharIndexes[2] = ((bytebuffer[1] & 0x0f) << 2) | (bytebuffer[2] >> 6);  
   // index 3: forth 6 bits (6 least significant bits from input byte 3)
   encodedCharIndexes[3] = bytebuffer[2] & 0x3f;  
   
   // Determine whether padding happened, and adjust accordingly
   paddingBytes = inx - (ascArr.length - 1);
   switch(paddingBytes){
    case 2:
     // Set last 2 characters to padding char
     encodedCharIndexes[3] = 64; 
     encodedCharIndexes[2] = 64; 
     break;
    case 1:
     // Set last character to padding char
     encodedCharIndexes[3] = 64; 
     break;
    default:
     break; // No padding - proceed
   }
   // Now we will grab each appropriate character out of our keystring
   // based on our index array and append it to the output string
   for(jnx = 0; jnx < encodedCharIndexes.length; jnx++)
    output += this._keyStr.charAt(encodedCharIndexes[jnx]);     
  }
  return output;
 }
};

Firefox:

Firefox works a little differently, as there is no RequestBody property. In this case, RequestText is not truncated as long as you override the mime type coming from the server, forcing Firefox to pass the data unaltered. All we need to do is compensate for binary data coming back and being placed in a Unicode Javascript string. To compensate, we can AND each character with 0xFF to throw away the high-order byte (see https://developer.mozilla.org/En/Using_XMLHttpRequest#Handling_binary_data). The resulting encoding function looks like this:


Base64 = {
 
 // private property
 _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",

 encodeBinary : function(input){
  var output = "";
  var bytebuffer;
  var encodedCharIndexes = new Array(4);
  var inx = 0;
  var paddingBytes = 0;
   
  while(inx < input.length){
   // Fill byte buffer array
   bytebuffer = new Array(3);
   for(jnx = 0; jnx < bytebuffer.length; jnx++)
    if(inx < input.length)
     bytebuffer[jnx] = input.charCodeAt(inx++) & 0xff; // throw away high-order byte, as documented at: https://developer.mozilla.org/En/Using_XMLHttpRequest#Handling_binary_data
    else
     bytebuffer[jnx] = 0;
   
   // Get each encoded character, 6 bits at a time
   // index 1: first 6 bits
   encodedCharIndexes[0] = bytebuffer[0] >> 2;  
   // index 2: second 6 bits (2 least significant bits from input byte 1 + 4 most significant bits from byte 2)
   encodedCharIndexes[1] = ((bytebuffer[0] & 0x3) << 4) | (bytebuffer[1] >> 4);  
   // index 3: third 6 bits (4 least significant bits from input byte 2 + 2 most significant bits from byte 3)
   encodedCharIndexes[2] = ((bytebuffer[1] & 0x0f) << 2) | (bytebuffer[2] >> 6);  
   // index 3: forth 6 bits (6 least significant bits from input byte 3)
   encodedCharIndexes[3] = bytebuffer[2] & 0x3f;  
   
   // Determine whether padding happened, and adjust accordingly
   paddingBytes = inx - (input.length - 1);
   switch(paddingBytes){
    case 2:
     // Set last 2 characters to padding char
     encodedCharIndexes[3] = 64; 
     encodedCharIndexes[2] = 64; 
     break;
    case 1:
     // Set last character to padding char
     encodedCharIndexes[3] = 64; 
     break;
    default:
     break; // No padding - proceed
   }
   // Now we will grab each appropriate character out of our keystring
   // based on our index array and append it to the output string
   for(jnx = 0; jnx < encodedCharIndexes.length; jnx++)
    output += this._keyStr.charAt(encodedCharIndexes[jnx]);
  }
  return output;
 };

Ideally we'd combine these two functions into a single encoding function, but I've left them separate for clarity. Note also that these techniques do not appear to work for Safari, Chrome or Opera. It should work for IE6 if using the correct ActiveX XHR object, but I was not supporting IE6. I did a spot check on Safari/Chrome/Opera and they were not working, but I did not investigate as they were not supported browsers for my implementation. The actual XHR function I used was:


LoadBinaryResource = function(url) { 
  var req = new XMLHttpRequest();  
  req.open('GET', url, false);  

  if (req.overrideMimeType)
    req.overrideMimeType('text/plain; charset=x-user-defined');  
  req.send(null);  
  if (req.status != 200) return '';  
  if (typeof(req.responseBody) !== 'undefined') return BinaryArrayToAscCSV(req.responseBody);
  return req.responseText;  
} 

LoadBinaryResourceAsBase64 = function(url) { 
  var data = LoadBinaryResource(url);
  
  if (data.indexOf("BinaryArrayToAscCSV") !== -1)
    return Base64.encodeBinaryArrayAsString(data);
  else
    return Base64.encodeBinary(data);  
}

A little surprised no one caught this

2008-10-28T23:42:00.001-07:00

So I just watched last week's SNL Weekend Update Thursdays on NBC.com, and decided to play around with their viewer. I haven't watched shows there before, but the Olympics were Silverlight and I wanted to know if they used Silverlight (no, they use Flash), and what features they had. I hit the info button (the thing with the arrow pointing to it), and was greeted with the interface you see below...the red box is mine (added for emphasis). Clearly they had some of the original mockup "Lorem Ipsum" in there and no one bothered to update it or correct it.

It doesn't get much better than this

2008-09-25T09:13:00.000-07:00

How's this for a setup message? Kinda hard to comply with...

One more technical analysis link

2008-05-27T08:56:00.000-07:00

I bumped across Stoxline during my recent foray into the technical analysis world. It provides a good quick summary of some key price points.

Excercising INTC stock options

2008-05-23T07:50:00.000-07:00

So I've excercised the remaining stock options from Intel that remain above water. There are still a large number of options that will die worthless (my original options were priced at $67 back in 2001, current stock price is $23.52, and there were no splits in between). The next set of options that even have a shot at becoming in the money are priced around $26, and with 3 weeks out, it would be surprising if they became valuable. Here's the quick story of how the excercise went down.

I excercised in three batches. The first batch I got totally lucky and sold at $27.98, exactly $0.01 off the 52 week high. Dumb luck. I sold only half because word on the street was that Q1 would be great, and the price would keep going up. In retrospect, I think selling half was a good move, but my big mistake here was not to have sold the most expensively priced options. Those options at $26 would have actually been worth something.

The stock tanked this year, but recently began to gain ground. Oddly, it picked up momentum based on almost no news (the overall market was also up). Intel did get an upgrade that did pretty well for the stock. Due to what seemed to be a short term movement and the imminent expiration of my options, I dug out some of my technical analysis knowledge and went to town:

I watched the following indicators:

MACD: I was looking pretty short-term (<1>
Bollinger Bands: I thought this would be a fairly useless indicator, but in fact, it was just when the stock crossed the upper band that it turned negative.
RSI: Fairly useful indicator in this scenario
Slow Stochastic Oscillator: Fast stoch always seems too touchy for me. Maybe if I were trading several times a day it would be different, but the slow stoch was useful
Parabolic SAR: My primary source of when the options should be sold.

When the stock hit 25 and retreated a bit to 24.60, I decided to sell my second batch, a fairly small set of options that were priced in the mid 23's. My primary thinking here was to lock in some of the options since going up over 5% in one day on no news was just crazy.

At 25, the MACD, Bollinger Bands and RSI indicators all went bearish, so I thought I'd sell when the price started to dip. The next day it opened pretty low and then dropped below 24.13, which was the Parabolic SAR trigger point, so now all the indicators I was tracking went bearish. I sold at 24.08, and so far, it's down another 0.85 from there.

Lessons learned? The indicators can work...don't rely on just one, and make sure that you use the right indicator for your goal.

Another couple links of use:

Scottrade chart: This chart is continuously updated, and summarizes what the indicators are saying (e.g. Parabolic Indicator is bearish/MACD is bullish). The conintuous updates made it more useful than Yahoo. It does, however, force you to re-add the indicators - no deep link is possible.
Yahoo chart: I was originally using this chart from Yahoo. Since the URL includes all the options, it looks exactly as I was using. However, it only updates at the end of each day.
TD Ameritrade Command Center 2.0: A Java app available for TD Ameritrade customers, it let me watch the stock in real-time during the day.

It could have been so much more effective with a little B&E

2008-05-21T07:13:00.000-07:00

A couple days ago I got a flyer on my door advertising a security system and monitoring package. I'm not sure how many people actually respond to a blanket flyer like that, but it got me thinking...wouldn't the flyer have been more effective had they managed to leave it somewhere inside the house while we weren't home? Illegal - yes. Effective: definitely.

Check for valid stored procedures

2008-05-02T09:23:00.000-07:00

I just posted a small utility on CodeProject to check for valid stored procedures, views, and functions (in SQL Server). It's actually a polish of some work someone else had done earlier, but if you have a large number of objects and are doing significant database refactoring, you may want to check it out.

Street signs

2008-05-01T08:10:00.000-07:00

When crossing the street and seeing one of the standard walk signs (such as the one to the left), I have a habit of imitating the sign and saying "white man walking".

Well, Sweden is now crossing the gender barrier with their new signs. Where this will lead, I'm not sure. Non-caucasians? Dogs? Cats? It does make me wonder, if the signs are specific, is Sweden now implying that where this sign is posted, only women are allowed to walk?

Google Maps update

2008-04-17T07:06:00.000-07:00

I just noticed that Google Maps introduced the ability to show historical "average traffic" for any given time on particular day of the week. I just used it to confirm my commuting schedule, and it seems to correlate well with my experiences and validate that the times I drive are pretty reasonable.

There are definitely some systemic traffic slowdowns in the Portland area. For example, 26 west bound between Murray and Bethany is nearly always a problem from 4PM-7PM, probably stemming from the fact that the road moves from 3 lanes down to 2 just after the Bethany exit. This is especially unfortunate since the third lane was just added...although I do admit that there are much more serious traffic concerns in the area to focus our resources on.

It would be nice to know that those that plan road improvements take a look at this type of data to prioritize their efforts.

Calendar sync bliss (finally)

2008-04-02T19:56:00.000-07:00

Finally, a calendar sync solution that works. After my experiment with gSyncIT, I just couldn't quite get past some of its limitations. Once multiple calendars get involved, things get a bit ugly.

A coworker recommended SyncMyCal as a way past those issues, and I'm pretty happy. You'll see my calendaring setup to the right.

Google Calendar is pretty much my primary calendar, and I have several calendars loaded. Some calendars, like US, UK, Indian Holidays and the Winterhawks game schedule are information only. However, I have my own calendar, a family calendar for events the whole family is attending, and two TripIt calendars (one for my wife, one for me) that do a great job representing any travel I'm doing.

I'd like to make sure that these calendars are available (at least in free/busy form) to other Exchange users at work, and that the calendars get posted to my cell phone using Windows Mobile. The Outlook 2007 Internet Calendars feature doesn't allow this, so I needed a solution that would allow my Google calendars to merge into my single Outlook calendar. I was also looking for my work calendar to post out to Google so I could have visibility there as well.

SyncMyCal had the answer through the use of category synchronization. Each Google calendar has their events assigned to a specific category, and only those events are sync'd with that calendar. Anything not assigned to a category (work stuff) gets sync'd to Google under a new "Work" calendar. I didn't need full synchronization here, but it's nice to know I have it if I need it.

What's missing? I can't find a way to have SyncMyCal make all Google-sourced events private on the Outlook side (although it does sync the private flag). I have to remember to mark anything truly private as such. Not a big deal, but it's worth mentioning.

There is definitely whitespace for an entrepreneur to simplify calendaring...I can't believe that my needs are *THAT* special...

C# Covariant Generics

2008-04-01T08:28:00.000-07:00

Sorry for the highly technical posts...lighter stuff to come!

This has really been bugging me on my current project. In an object oriented system, if one class inherits from another (e.g. "Cat" inherits from "Animal"), and a method expects to receive the base class as a parameter, it is safe to send in a subtype. In my example, a method operating on "Animal" can take "Cat" safely. This is sometimes called "downcasting".

This behavior should extend to generic types. Again, in my example, if a method expects a List of Animals, I should be able to pass in a List of Cats. However, C# does not allow this behavior (but the CLR does). Bah!

Here is some more background I've dug up on the issue:

Yet more SQL 2005 fun: Developing search procs

2008-03-27T08:47:00.001-07:00

A common pattern in applications is to have a search stored procedure work as the backend for a search screen. If a term has not been passed by the user, the intent is that there is no filter on the results for that parameter. Here's a great article discussing the ways that this can be acheived. I'm a personal fan of the COALESCE statement talked about in the static discussion.

One area that was not discussed in the article was the idea of having similar functionality with a list of filters (e.g. filter to these specific books in the library). I found a pretty good article talking about SQL 2005's use of Xml parameters to do this - Xml's main benefit being that it's more designed for this use case than a delimited string. However, the same problem now applies...what if I either have a list of books, or don't pass anything, meaning I want to search across all books?

My solution was to grab all the data from the reference table and build my own Xml string. Then I could use it in the main select statement:

IF @param is null
SET @param =
(SELECT 1 AS Tag,0 AS Parent,MyElementName AS [Root!1!string!element]
FROM sourcetable FOR XML EXPLICIT)

SELECT...
WHERE...
...AND
FieldName IN
(SELECT Field.value('.','VARCHAR(max)') FinalName
FROM @param.nodes('//string') AS Table(Field))

I'm sure this wouldn't perform well with large tables, but my reference tables are fairly small (<100 rows each), and it works great.

FYI: Here is an example COALESCE statement for the standard filters:

table LIKE '%' + COALESCE(@Name, fac.FacilityName ) + '%'

More SQL 2005: SqlDependency update

2008-03-27T08:24:00.000-07:00

While SQL Server data update notifications through the SqlDependency object seemed like a great idea, I now believe the architecture is fundamentally flawed...I'm looking forward to changes in this area to make the feature more robust in the next release(s) of SQL Server and/or the .NET Framework. Here are some of the problems I've run into:

Massive amounts of required permissions in the default run mode
Query types available are incredibly restrictive
Ineffective tear down of resources, again, in default run mode, with no programatic workaround. (The worst part? The problem is actually most acute while doing active development...)
Severe ramifications for any issue, whether caused by environment or poor coding
Complex (and maybe unusable) setup for custom service/queue implementation to alleviate the first two issues. I never really even figured out that setup when operating in a non-default schema in a restricted permission environment.

This feature is a great concept, but with an implementation that severely limits its use. My recommendation is to avoid this functionality in nearly all cases. In my current project, I've moved to a custom cache implementation that checks last modified date across all all lookup tables and clears the cache of all out of date lists. If something happens in between checks, we'll just have to deal with that.