Jeff Garoutte

Older posts are broken for the moment

jeff — Sun, 04 Oct 2009 21:37:05 -0400

Recently, we did an upgrade to a new version of the .net blog engine. This update changed how the URLs work and relate back to posts, images, and attachments. While I am kicking myself for not testing the upgrade before deploying it; I am also a bit surprised that the new code was released without maintaining backwards compatibility of posts that were already published.

This brings me to a cross roads of choice. Do I...

dig in the code, find the issue and and the backwards compatibility and have to do this each time a new release is issued.
leave the old posts as is and ignore the problem/issue (which, honestly, is irking me)
Fix each post individually.
Write my own blog engine and use it instead.
hope the development team fixes the problem and releases an update.

Given the options, 1 is too much repeated work, 2 will slowly drive me nuts over time, 3 is a bit of work but doable, 4 has a host of issues... and 5.... well...that might happen before 3 or 4 was finished anyway. Who knows.

#4 Write my own blog engine and use it instead... while the idea is entertaining, the reality is I like the .net blog engine. I am not a fan of reinventing the wheel.

Now I don't believe I could write a better blog engine nor do I want to spend the time trying. But everyone should have a personal project to work on to push their skills and try new things. A project like a blog engine is an excellent system to do exactly that. But it is not really what I want to do for a project. So I am going to look at my options and see what I can do. The real problem here however is the external links, from places like dotnetkicks.com are now broken to the old posts and writing a new engine, or updating the old articles wont address that issue. So it looks like I have no choice but to sit down and add in the backwards compatibility for the old URL rewriting system. The kick here is finding the time to do it.

Ill look into it and see what I can do. In the mean time, my apologies to anyone looking for old posts, they are still here, just hiding.

The Hidden Requirement

jeff — Sun, 04 Oct 2009 21:15:29 -0400

Every developer runs into a hidden requirement leaving them feeling like a bird who discovered a closed window. Hidden requirements are not new, nor are they exclusive to software development. The first time I recall learning about hidden requirements was many years ago when I was in high school.

My Father owned a couple duplexes which he took good care of. My brother and I spent what seemed like an eternity doing yard work, small repairs, and shoveling the deep Minnesota snow from the sidewalks there. In reality it was was not that much time and when I was old enough to use the snow blower it was even faster; but I digress. Dad did not like paying someone else to do something that he could do himself. So it comes as no surprise that when the branch of a tree in the backyard of one of the duplexes had grown over the power line that he scoffed at what NSP (Northern States Power Company) wanted to charge to remove the offending limb.

The problem- The tree was old, the branch was heavy and when winter came it was possible the weight of the snow and ice on the branch could break branch off and take down the power line. Dad tried to be proactive and fix a problem before it was a problem.

He looked at the branch, the line and the yard before hatching a simple plan. What he needed to do was get the branch off the tree, to the ground, without taking out the power line or wounding himself in the process. Higher up in the tree there was a "Y" formed by the trunk and a heavy branch.

The Plan- Tie a rope around the branch and run it through the "Y" higher up in the tree and down to the his Ford Ranger pickup truck. He could cut the branch off the tree and it would swing around away from the power line. After that, he could simply backup his truck to lower the branch safely to the ground.

So, that is exactly what he did. Now, before I go on allow me to say, no one was in the truck and no one was injured in the process.

He attached and ran the rope securely, got in the tree and cut the branch free. For those of you thinking at this point, "He was standing on the branch and fell.... No, but plenty of people miss that safety tip as shown on youtube.

The branch, as planned, swung safely away from the power line... Now enter the hidden requirement

The Hidden Requirement- The nature of the the plan caused an additional requirement that was hidden. The Ford Ranger was a "half ton" pickup truck. The branch was more than a "half ton" branch. Gravity, which had been accounted for by planning to back the truck up to lower the branch had an equation of it's own to introduce.

The branch, out weighing the truck, begin a slow but steady decent to the ground. This means the unmanned truck was sliding back along the ground and began it's ascent up the tree. The truck came to rest with the front bumper balancing on the ground and the branch sitting not far from it.

The Problem- How to safely get a truck out of a tree?*

A hidden requirement and a missing requirement are not the same thing. Hidden requirements are specific to the solution that may have been over looked, for example: the weight of the truck must be greater than the weight of the branch. Had Dad used a crane (or NSP) the weight of his truck would not have been an issue. A missing requirement is something that is part of the problem in the first place that was overlooked or missed like "Don't break the power line".

A hidden requirement is only a problem if it becomes a "missed requirement". Avoiding the feeling of being the bird hitting the glass with hidden requirements is, in theory, fairly straight forward. When you find a solution step through the use case(s) with the solution and reconsider each step of the solution. If you change the solution slightly, repeat the process.

Hidden requirements will always pop up unexpectedly. Everyone will overlook something at some point. When it happens I cant help but laugh and say,

Well, that looks like a truck in a tree.

*No trucks were harmed in the making of this post. In fact, aside from having a really clean cab, the truck was in the same condition as it was before it went up the tree.

Using an Object for an Id

jeff — Fri, 19 Jun 2009 18:00:07 -0400

It's not that uncommon to use an ID for a data object. However, sometimes more information is needed to uniquely identify an object than a number. In these cases is useful to use another object. It can contain an integer, guid, date created, created by, or even the date and time and object was modified.

A good example of this would be a content management system. A given piece of content could have a content object ID, which would contain an ID, the day and time of the modification, who modified the content and a revision number. This would allow content to be retrieved not only by an ID but by revision allowing the content management system to save a history of the edits made to the content as well as draft's of pending revisions.

Another example would be in a customer records management system. An address, an e-mail, a phone number, or instant messenger ID are all types of a contact information. An abstract contact information base class could use an integer as an identifier for the object; however, if we used a contact information identifier object we would be able to inherit the identifier object to determine the type of relationship or parent object with contact information belong to. For example, a phone number can belong to a person or a company. We could use a person contact information identifier object or a company contact information identifier object inherited from an abstract contact information identifier object to determine what the type of parent object is in code.

The abstract contact information identifier object (that's a mouthful isn't it? ) could contain an int32 or int64 as an ID field. It would also have a parent ID field.

The hard part of using an object for an id is giving up the easy "Id=5;" syntax. But who says that needs to be given up?

We all have overloaded a method or two at some point. But what about overloading an operator?

public class ContactInformationId
    {
        public ContactInformationId(Int32 id)
        {
            Id = id;
        }
        public Int32 Id { get; set; }

        public static implicit operator ContactInformationId(Int32 id)
        {
            return new ContactInformationId(id);
        }

        public static implicit operator Int32(ContactInformationId id)
        {
            return id.Id;
        }
    }

Ah ha! So if we took the following code not only would it compile but at the end id.Id would equal 12.

ContactInformationId id = 5;
id = 10;
if (id < 7) id = 13;
if (id > 7) id = 2;
if (id == 5) id = 6;
if (6 != id) id = 12;

But it is not all roses. If you add another property...

    public class ContactInformationId
    {
        public ContactInformationId(Int32 id)
        {
            Id = id;
        }
        public Int32 Id { get; set; }
        public Int32 version { get; set; }

        public static implicit operator ContactInformationId(Int32 id)
        {
            return new ContactInformationId(id);
        }

        public static implicit operator Int32(ContactInformationId id)
        {
            return id.Id;
        }
    }

and you run the following code

            ContactInformationId id = 5;
            id.version = 2;
            id = 10;

            if (id < 7) id = 13;
            if (id > 7) id = 2;
            if (id == 5) id = 6;
            if (6 != id) id = 12;

id.Id will still be 12; but id.Version will be 0.

Every time the ContactInformationId object uses the operator overload it return a new object "crushing" any other properties. In the case of an id this might not be so bad. In a Content Management System (CMS) a version number of 0 could be used to call the "Head" version. But in cases where, "I don't need that, I only need an Int32," there is a greater "hidden" value.

Lets say I have a Person object with a PersonId object in it for an Id property. I use lazy loading to get back a list of contact information. I call ContactInformationDataService.GetByParentId(somePerson.Id);

Now lets say I have a Company object with a CompanyId in it for an Id property. Again I call ContactInformationDataService.GetByParentId(someCompany.Id);

if the Id properties were just Int32 there would be no way to know what return; after all company id 5 and person id 5 look the same as an Int32. But when they are a PersonId and CompanyId object we can use standard method overloading to know what we are returning.

Take this another step and inherit the id objects from a common base class like...BaseId. Now you can have a method in your data layer like GetByParentId(BaseId id) and, in the case of SQL server, set the stored procedure name based on the type of id object.

if(id is PersonId) sprocName="usp_ContactInformation_GetByPersonId";
else if(id is CompanyId) sprocName="usp_ContactInformation_GetByCompanyId";

If you are a big xml fan, you can set the file name or top node based on the id type.

More importantly you can use overloads on the methods to take action based on the type*.

protected override ContactInformationList GetContactInformationByParentId(SomeBaseId id)
{
     if(id is PersonId) GetContactInformationByParentId((PeronsId)id);
     if(id is CompanyId) GetContactInformationByParentId((CompanyId)id);
}

private ContactInformationList GetContactInformationByParentId(PersonId id)
{
     ...
}

private ContactInformationList GetContactInformationByParentId(CompanyId id)
{
     ...
}

*Note: the Microsoft .Net Framework maps methods at compile time not run time. So if a variable is boxed into a base type it will go to the method that uses the "boxed" type in the signature, not the type of object stored in the box at run time. Always pay attention to how your variables are boxed when you pass them. This is why logic like if(id is PersonId) in the GetContactInformationByParentId(BaseId id) method is needed.

I normally just declare my overloads in the abstract provider and avoid the type checking.

protected abstract ContactInformationList GetContactInformationByParentId(PersonId id);
protected abstract ContactInformationList GetContactInformationByParentId(CompanyId id);

In the end, it makes for somewhat cleaner code (it would be even cleaner if .net supported runtime type checking). While the Id object does have an issue with crushing itself when assigned to...that is the expected behavior of an object that it is overwritten when we assign to it instead of a property.

Below is an example of an abstract base class and subclass. Something like GetByParentId(GenericId<Int32> id) would be extremely useful. Notice the operator overloads are on the ContactInformation and not the abstract class. This has to do with operator overloads needing to be "contained" within the type they are converting to or from. In other words, they have to be there to prevent errors at compile time.

    public abstract class GenericId<BaseIdType> 
    {
        public GenericId(BaseIdType id)
        {
            Id = id;
        }
        public BaseIdType Id { get; set; }
    }

    public class ContactInformationId : GenericId<Int32>
    {
        public ContactInformationId(Int32 id) : base(id)
        {
            
        }
        public static implicit operator ContactInformationId(Int32 id)
        {
            return new ContactInformationId(id);
        }

        public static implicit operator Int32(ContactInformationId id)
        {
            return id.Id;
        }
    }

This solves a few issues for me when I am going back and forth between an object model and a relational data source like SQL Server.

While the operator overloads make things a bit easier, they are not really required.

You could get fancy and create an IIdentifier interface that defines an Id property

public interface IIdentifier
{
    object Id { get; set; }
}

Now if you explicitly implement the IIdentifier interface or your base GenericId<BaseIdType> class like...

        object IIdentifier.Id
        {
            get
            {
                return this.Id;
            }
            set
            {
                if (value is BaseIdType)
                    this.Id = (BaseIdType)value;
                else
                    throw new InvalidCastException(value.GetType().ToString() + " can not be cast as a " + typeof(BaseIdType).ToString());
            }
        }

You can use the IIdentifier in your method signatures and not worry about the type of the internal Id....That means PersonId could be a Guid and CompanyId remains an Int32 and nothing explodes.

There is one little trick, you will want to implement the IEquatable<IIdentifier> on the GenericId<BaseIdType> class.

        public bool Equals(IIdentifier other)
        {
            bool result = false;
            if (this.GetType()==other.GetType())            {
                result = Id.Equals(other.Id);
            }
            return result;
        }

We start off saying they are not equal. We check the types to see if they are the same type and we call the equals method of the Id property and pass in the other identifiers Id property. Because other is boxed as an IIdentifier this.Id==other.Id will always be false.

Well not "always", the Id property is boxed as an object and the default Equals method on an object checks to see if the two objects are both references to the same instance of an object (and while it is possible that they might be; they very rarely will be because of the nature of Int32, Guid, decimals and structs in general). See my blog about variable boxing and == vs. Equals for more information.

Calling the equals method instead of using the == operator invokes the correct Equals method on the GenericId<BaseIdType> instead of the default object equals method...it has to do with compile time mapping of methods.

If you add the ICloneable interface to the object as well you have a very nice little object that you can clone, pass around and do anything you need to do with it.

I have seen people put methods in their identity object to get or delete an object with that id or return a list of child/parent objects.

What does all of this do? It gives us a non generic type to use in our method signatures, a strongly typed generic base class and strongly typed sub classes to use in our methods.

Finally, it does one more thing. When someone changes the requirement from the Id being an Int32 to a Guid the the logic of the Id is separated from your code making it a little easier to change.

Variable boxing and == vs. Equals

jeff — Thu, 18 Jun 2009 10:04:08 -0400

Let's take a moment and think about exactly how boxed variables work when checking to see if they are equal.

Here is a little Console application to do a quick comparison of how the Equals function and == operator work.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace VariableBoxEqualityTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 1;
            int y = 1;

            test(x, y);
           
            x = 2;
            y = 3;
            test(x, y);

            x = 5;
            test(x);
            Console.ReadKey();
        }

        private static void test(int x)
        {
            Console.WriteLine();
            Console.WriteLine("Testing with x=y={0}", x);
            DoTests(x, x);
            object ox = x;
            ObjectRefIsEquals(ref ox, ref ox);
            ObjectRefIsEqual(ref ox, ref ox);

            Console.WriteLine();
            ObjectIsEqual(ox, ox);
        }

        private static void test(int x, int y)
        {
            Console.WriteLine();
            Console.WriteLine("Testing with x={0} and y={1}", x, y);
            DoTests(x, y);
            object ox = x;
            object oy = y;
            ObjectRefIsEquals(ref ox, ref oy);
            ObjectRefIsEqual(ref ox, ref oy);
        }

        private static void DoTests(int x, int y)
        {
            object ox = x;
            object oy = y;
            ObjectIsEqual(ox, oy);
            ObjectIsEquals(ox, oy);
            intIsEqual(x, y);
            intIsEquals(x, y);
        }

        public static void intIsEqual(int x, int y)
        {
            Console.WriteLine("(int)x==(int)y : {0}", x == y);
        }

        public static void intIsEquals(int x, int y)
        {
            Console.WriteLine("((int)x).Equals((int)y) : {0}", x.Equals(y));
        }

        public static void ObjectIsEqual(object x, object y)
        {
            Console.WriteLine("(object)x==(object)y : {0}", x == y);
        }

        public static void ObjectIsEquals(object x, object y)
        {
            Console.WriteLine("((object)x).Equals((object)y) : {0}", x.Equals(y));
        }

        public static void ObjectRefIsEquals(ref object x, ref object y)
        {
            Console.WriteLine("((ref object)x).Equals((ref object)y) : {0}", x.Equals(y));
        }

        public static void ObjectRefIsEqual(ref object x, ref object y)
        {
            Console.WriteLine("((ref object)x)==((ref object)y) : {0}", x==y);
        }
    }
}

Now here are the results....

There are four groups of results above, let us about the first result in each set (and the only one in the last set).

(object)x==(object)y : False. With the exception of the last result this test was always False. Why? Because == was checking to see if the object was the same object, not if the values were the same. In the first 3 sets x and y were boxed into the ox and oy objects before the call to ObjectIsEqual. The forth set passed ox in twice ObjectIsEqual(ox, ox); .

Even when the values of x and y are the same the act of boxing them makes the objects different, and therefore not equal using the == operator.

If you box the same variable a second time the two objects will not be equal even though they are the same variable.

Here's a code change you can use to easily test that if you like...

 private static void test(int x)
        {
            Console.WriteLine();
            Console.WriteLine("Testing with x=y={0}", x);
            DoTests(x, x);
            object ox = x;
            ObjectRefIsEquals(ref ox, ref ox);
            ObjectRefIsEqual(ref ox, ref ox);

            Console.WriteLine();
            ObjectIsEqual(ox, ox);

            Console.WriteLine();
            object oy = x;
            ObjectIsEqual(ox, oy);
        }

the 2nd test in in set is the ((object)x).Equals((object)y) test. It passed in the 1st and 3rd set while failing in the 2nd. Which is what we would expect since 1=1, 2!=3 and 5=5. So the Equals function on a boxed (or unboxed) int works.

The 3rd and 4thtests in each set are the same functions from the first two tests except on unboxed ints. Both the == operator and the Equals method were correct in little tests. (If they were Id be worried).

the 5th and 6th test in each set are the same as the first two expect we are passing the objects in by reference. We would expect the same results...but no, the in the 3rd set (object)x==(object y) was false and ref object x==ref object y was true.... what happened?

The 1st test boxes x twice and passes it into the test. So the objects are not the same and it fails.

The 6th test boxes x once and pass in the same object twice so they match. It has nothing to do with them being passed as a ref. Here's another code snip you can use to test it.

private static void test(int x)
        {
            Console.WriteLine();
            Console.WriteLine("Testing with x=y={0}", x);
            DoTests(x, x);
            object ox = x;
            ObjectRefIsEquals(ref ox, ref ox);
            ObjectRefIsEqual(ref ox, ref ox);

            Console.WriteLine();
            ObjectIsEqual(ox, ox);

            Console.WriteLine();
            object oy = x;
            ObjectIsEqual(ox, oy);

            Console.WriteLine();
            ObjectRefIsEqual(ref ox, ref oy);
        }

My point is, when you box a variable you have to pay attention to how you work with it while it is boxed. I have seen code where it was assumed that x==y is true when x and y both equal 1 and they are boxed as an object.

Extending the ASP.Net Security model to use rights: Cassini

jeff — Thu, 18 Jun 2009 09:49:55 -0400

I get a few messages about how the rights system fires many times per request and it is a lot of SQL traffic. Allow me to address this issue and introduce to your silent partner Cassini.

Most developers, myself included, love being able to click the "play" icon (press F5 or select start debugging from the menu) and be able to debug their WebForms or MVC application on their local box.

The catch here is this- the site you are debugging is not running on/being served by IIS. It's Cassini.

Ok now do not jump up and say yes served by IIS... I am talking about the default configuration that unless you have changed, it is running on Cassini. That little web page down in the icon tray that says ASP.NET Development Server - Port #### when you mouse over it...that is Cassini.

I know, "big deal it just serves the application." What is often over looked is Cassini is not IIS and it behaves very differently. I am going to talk in some generalities here and gloss over certain details but my good friend Google is more than happy to help fill in the gaps. IIS handles all web requests through ISAPI filters, one of these filters is the asp.net filter. The filters sort out who gets to handle each file request. So by default on IIS; only apsx, .config, ascx etc etc files are handled by the asp.net framework.

Cassini is IIS's dog who ate a cracker with a mound of peanut butter on top of it. Every request that Cassini gets is handled by the asp.net framework and Cassini just keeps chomping away at it.

Here is where this difference comes into play. Lets say your site's home page has a 3 js files, 2 style sheets (one of general media and one for print), a logo image, a background image, an image used as li bullets, 4 images that are part of the navigation and another 4 images that are part of the sites design/layout. Not an unreasonable page makeup right?

IIS and Cassini both get the request for the aspx page, sends it to asp.net to get the html and sends it back to the client. The client browser see's all of the images, scripts and css files and issues requests to get each file.

IIS gets each request and sends the requests to filters based on the file type requested, in the example we talked about none of them are the asp.net filter. So you get 1 request to asp.net for the page itself (you may get more because of webresources.axd but we will ignore those....glossing over)

Cassini, still trying to get the peanut butter off the roof of it's mouth, gets every request and, not having filters, passes all of them to asp.net for processing...all of them. 3 js + 2 css + logo + background +li image + 4 navigation + other 4 images....16 additional files for a total of 17 requests that generate an IPrincipal and rights. Oh, and yes, you still get those other webresource.axd requests.

If you really want a shock open SQL Profiler and watch the asp.net membership and roles system at work in Cassini.

How do you fix this? Well, strictly speaking you can not "fix" it. By design an HttpModule gets called for every request so it will always get called. But, you can try to cut down on the sql overhead by modifying your HttpModule to look at the file extension and not do anything for certain file types. The downside to this is if someone changes the IIS configuration to pass jpg files to asp.net and tries to secure a directory of images in the web.config the Principle may not be correct for it work until you edit the code (you could but the file extensions in an appsetting so it would require modifying the web.config instead of a code change.)

You can suffer with (or ignore) it in Cassini and test performance on a real IIS server...(which we all do anyway's right?)

Or you can use a SqlDependency object or caching in the provider layer or serve back recently cached objects. Even if you do this, the default asp.net membership and roles is going to kick your SQL Servers butt (Really try SQL Profiler on your database and watch it...)

This is a spot where you need to figure out where you want to eat the cycles of doing it. If SQL is local to the the web server the memory hit with caching may out weigh the SQL processing costs. If the SQL Server is over a WAN cache it! If the SQL Server is on the same switch/network there are lots of factors you will want to look at....bandwidth, throughput, cost of development...etc etc.

However this difference between IIS and Cassini raises it's ugly head in other areas of development as well. For example, I wrote a HttpModule to stop bandwidth leeching once. It worked fine on my local PC but failed to work when deployed in the production environment. Because Cassini passed image requests to ASP.net it worked fine in development; but IIS does not pass them to asp.net so the module never had any requests come in to process. After altering the IIS configuration to pass images files to the asp.net dll it worked wonderfully.

One other place I have seen Cassini/IIS differences break things was with a large/bulk file uploader that provided a status bar in the browser. It hooked into a "worker process" class for the web server to pull/write some information. The problem was Cassini and IIS used different worker process classes and the method being used did not work with Cassini. For the same reason it did not work on a newer version IIS. Which means, not all version of IIS behave exactly the same under the hood and if you "hack" something in to get things to work, well....yeah. It might not work after some random update/SP.

I do development/testing with Cassini, I deploy to my local IIS where I test again; and finally I publish to the production server. When I need to debug HttpModules I set a conditional break that checks the file information so I am not stopping when I do not need to be.

The short of it is, Cassini is not as smart as IIS and it processes files as asp.net request causing extra traffic in your code when you are debugging. It is too busy with peanut butter to learn about filtering what requests are for ASP.net and which are not.

Cassini on Wikipedia: http://en.wikipedia.org/wiki/UltiDev_Cassini_Web_Server

Special thanks to JB for reminding me to post this article that has been on my flash drive for a long time.

Ajax Popup Tooltips

jeff — Mon, 23 Feb 2009 01:13:00 -0400

I was sent a link to Caleb's blog about an ajax tooltip popup script. It's a great article but the script was a little to specific for my uses. As I played with the script I found some things I wanted to change a bit.

One issue is I needed to add it to a site with jQuery 1.2.6 (and for reasons I cant begin to understand) upgrading to a newer version of jQuery was not an option. the other issue was I needed several different tooltips on the same page. So I rewrote parts of the script.

; (function($)
{
    $.popup = {
        defaults: {
            hideDelay: 500,
            currentID: null,
            hideTimer: null,
            popupAjaxRequest: null,
            requestUrl: '',
            containerHtml: '<div class="PopupContainer">'
            + '<table width="" border="0" cellspacing="0" cellpadding="0" align="center" class="PopupPopup">'
            + '<tr>'
            + '   <td class="corner topLeft"></td>'
            + '   <td class="top"></td>'
            + '   <td class="corner topRight"></td>'
            + '</tr>'
            + '<tr>'
            + '   <td class="left">&nbsp;</td>'
            + '   <td class="center"><div class="PopupContent"></div></td>'
            + '   <td class="right">&nbsp;</td>'
            + '</tr>'
            + '<tr>'
            + '   <td class="corner bottomLeft">&nbsp;</td>'
            + '   <td class="bottom">&nbsp;</td>'
            + '   <td class="corner bottomRight"></td>'
            + '</tr>'
            + '</table>'
            + '</div>',
            emptyContent: '&nbsp;',
            errorMessage: {
                idReplacementRegEx: '\{0\}',
                errorText: '<span style="color:red" class="smallText">We did not return a valid result for Id {0}.  Please have your administrator check the error log.</span>'
            },
            cssClasses: {
                PopupContentDiv: '.PopupContent',
                PopupTrigger: '.PopupTrigger',
                RequestDiv: '.PopupResult'
            }
        }
    };

    $.fn.extend({
        popup: function(settings)
        {

            settings = $.extend({}, $.popup.defaults, settings);
            //var hideDelay = 500;
            //var currentID;
            //var hideTimer = null;
            //var popupAjaxrequest = null;

            var container = $(settings.containerHtml).mouseout(function()
            {
                if (settings.hideTimer)
                    clearTimeout(settings.hideTimer);
                settings.hideTimer = setTimeout(function()
                {
                    container.find(settings.cssClasses.PopupContentDiv).html(settings.emptyContent);
                    container.css('display', 'none');
                    settings.currentID = '';
                }, settings.hideDelay);
            }).mouseover(function()
            {
                if (settings.hideTimer)
                    clearTimeout(settings.hideTimer);
            });

            $('body').append(container);

            $(this).find(settings.cssClasses.PopupTrigger).mouseover(function()
            {
                // format of 'rel' tag: pageid,guid
                var newId = $(this).attr('rel');


                // If no guid in url rel tag, don't popup blank
                if (newId == '')
                {
                    container.css('display', 'none');
                    settings.currentID = '';
                    return;
                }
                if (settings.hideTimer)
                    clearTimeout(settings.hideTimer);
                if (settings.currentID == newId)
                    return;
                settings.currentID = newId;

                var pos = $(this).offset();
                var width = $(this).width();


                if (settings.popupAjaxrequest)
                {
                    settings.popupAjaxrequest.abort();
                    settings.popupAjaxrequest = null;
                }
                popupAjaxrequest = $.ajax({
                    type: 'GET',
                    url: settings.requestUrl,
                    data: 'id=' + settings.currentID,
                    success: function(data)
                    {
                        if ($(data).find(settings.cssClasses.RequestDiv).length != 0)
                        {
                            var text = $(data).find(settings.cssClasses.RequestDiv).html();
                            // Verify that we're pointed to a page that returned the expected results.
                            if (text != '')
                            {
                                container.find(settings.cssClasses.PopupContentDiv).html(settings.errorMessage.errorText.replace(settings.errorMessage.idReplacementRegEx, settings.currentID));
                            }
                            // Verify requested id is this id since we could have multiple ajax
                            // requests out if the server is taking a while.
                            if (data.indexOf(settings.currentID) > 0)
                            {
                                container.find(settings.cssClasses.PopupContentDiv).html(text);
                            }
                            container.css({
                                left: (pos.left + width) + 'px',
                                top: pos.top - 5 + 'px'
                            });
                            container.css('display', 'block');
                        }
                        else
                        {
                            container.find(settings.cssClasses.PopupContentDiv).html(settings.emptyContent);
                            container.css('display', 'none');
                        }
                        settings.popupAjaxrequest = null;
                    },
                    error: function(data)
                    {
                        container.find(settings.cssClasses.PopupContentDiv).html(settings.errorMessage.errorText.replace(settings.errorMessage.idReplacementRegEx, settings.currentID));
                        container.css({
                            left: (pos.left + width) + 'px',
                            top: pos.top - 5 + 'px'
                        });
                        container.css('display', 'block');
                        settings.popupAjaxrequest = null;
                    }
                });
            }).mouseout(function()
            {
                if (settings.hideTimer)
                    clearTimeout(settings.hideTimer);
                settings.hideTimer = setTimeout(function()
                {
                    container.find(settings.cssClasses.PopupContentDiv).html(settings.emptyContent);
                    container.css('display', 'none');
                    settings.currentID = '';
                }, settings.hideDelay);
            });
        }
    }); //fnextend end

})(jQuery);

Using the script is fairly simple

$("#container").popup({requestUrl:"/someurl.aspx"});

When I have more time, I will try to make it work using the 1.3.x jquery live function.

If you have not already, check out Caleb's post about it. I understand he has posted a newer version that tries to avoid excessive ajax requests.

The Dummy Provider: Testing membership and roles

jeff — Tue, 04 Nov 2008 23:32:13 -0400

Asp.net has a wonderful system built in for handling user accounts and roles. The administration interface is encapsulated in a separate web site that can be accessed from within Visual Studio but it is difficult to integrate into the site. This often leads to building a new user administration area in each site. The problem I have with this is going into the data store and deleting the incomplete test data and not having "known good" data for testing.

In the past, I have talked about provider pattern and the built is membership and roles systems both use providers. This offers a wonderful framework for unit testing and more importantly for have a data store that reverts to a known good state every time the application is run.

Enter the "dummy provider". A dummy provider contains the data store in the code. It is nothing more than a list of objects that is modified by the providers methods. Because of this the data will revert to its initial state when it is run, it can be used without a SQL server (or some other data store) and the user interface can be tested by adding, deleting and modifying the data until your hearts content. This makes testing and changing the user interface for membership and roles faster and easier; but the dummy provider is not limited to membership and roles.

Lets look at the some code, the dummy role provider

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Security;

namespace CS.Data.Providers.Dummies
{
    public class DummyRoleProvider : RoleProvider
    {
        internal static List<string> _roles;
        internal static List<PersonToRole> _userToRole;
        internal class PersonToRole : IEqualityComparer<PersonToRole>
        {
            public PersonToRole(string user, string role)
            {
                _userName = user;
                _roleName = role;
            }
            private String _userName;

            public String UserName
            {
                get { return _userName; }
                set { _userName = value; }
            }
            private String _roleName;

            public String RoleName
            {
                get { return _roleName; }
                set { _roleName = value; }
            }

            #region IEqualityComparer<PersonToRole> Members

            public bool Equals(PersonToRole x, PersonToRole y)
            {
                return ((x._userName == y._userName) && (x._roleName == y._roleName));
            }

            public int GetHashCode(PersonToRole obj)
            {
                return base.GetHashCode();
            }

            #endregion
        }
        static DummyRoleProvider()
        {
            _roles = new List<string>();
            _roles.Add("Administrator");
            _roles.Add("Cat");
            _roles.Add("Customer");
            _roles.Add("User");

            _userToRole = new List<PersonToRole>();
            _userToRole.Add(new PersonToRole("Admin", "Cat"));
            _userToRole.Add(new PersonToRole("Admin", "User"));
            _userToRole.Add(new PersonToRole("Admin", "Administrator"));
            _userToRole.Add(new PersonToRole("Admin", "Customer"));

            _userToRole.Add(new PersonToRole("SomeCustomer", "Customer"));
            _userToRole.Add(new PersonToRole("SomeCustomer1", "Customer"));
            _userToRole.Add(new PersonToRole("SomeCustomer2", "Customer"));
            _userToRole.Add(new PersonToRole("Admin2", "Customer"));
            _userToRole.Add(new PersonToRole("Admin3", "Customer"));

            _userToRole.Add(new PersonToRole("SomeCustomer2", "User"));
            _userToRole.Add(new PersonToRole("Admin3", "User"));

            _userToRole.Add(new PersonToRole("SomeCustomer", "User"));
            _userToRole.Add(new PersonToRole("SomeCustomer1", "User"));

            _userToRole.Add(new PersonToRole("Admin2", "Administrator"));
            _userToRole.Add(new PersonToRole("Admin3", "Administrator"));

        }
        public override void AddUsersToRoles(string[] usernames, string[] roleNames)
        {
            foreach (string user in usernames)
            {
                foreach (string role in roleNames)
                {
                    PersonToRole ptr = new PersonToRole(user, role);
                    if (!_userToRole.Contains(ptr)) _userToRole.Add(ptr);
                }
            }
        }

        public override string ApplicationName { get; set; }

        public override void CreateRole(string roleName)
        {
            if (!_roles.Contains(roleName)) _roles.Add(roleName);
        }

        public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
        {
            if (_roles.Contains(roleName))
            {
                _userToRole = _userToRole.Where(p => p.RoleName != roleName).ToList();
                _roles.Remove(roleName);
                return true;
            }
            else
            {
                return false;
            }
        }

        public override string[] FindUsersInRole(string roleName, string usernameToMatch)
        {
            return _userToRole.Where(p => p.RoleName == roleName).Select(u => u.UserName).ToArray();
        }

        public override string[] GetAllRoles()
        {
            return _roles.ToArray();
        }

        public override string[] GetRolesForUser(string username)
        {
            return _userToRole.Where(p => p.UserName == username).Select(r => r.RoleName).ToArray();
        }

        public override string[] GetUsersInRole(string roleName)
        {
            return _userToRole.Where(p => p.RoleName == roleName).Select(u => u.UserName).ToArray();
        }

        public override bool IsUserInRole(string username, string roleName)
        {
            return _userToRole.Contains(new PersonToRole(username,roleName));
        }

        public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
        {
            foreach (string user in usernames)
            {
                foreach (string role in roleNames)
                {
                    PersonToRole p = new PersonToRole(user, role);
                    if (_userToRole.Contains(p)) _userToRole.Remove(p);
                }
            }
        }

        public override bool RoleExists(string roleName)
        {
            return _roles.Contains(roleName);
        }
    }
}

First you may notice there are 2 lists inside the provider. One is just a list of strings. because the asp.net role system treats roles as nothing more than a string the dummy provider does not need to hang onto any extra data. The second list is holds onto a PersonToRole object. The PersonToRole object just holds the username and role.

Using the provider is as easy as configuring the web.config...

The user membership provider has a bit more too it. Again there is a private class that defines the user that is stored in the list. The providers constructor creates several users and stores them in an internal list.

In the constructor there is a list of names that is used to create the user accounts. To add the account to a specific role simply add the user name and role to the role providers constructor.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Security;
using CS.People;
using CS.Identifiers;

namespace CS.Data.Providers.Dummies
{
    public class DummyMembershipProvider : MembershipProvider
    {
        private class myUser
        {
            #region security fields for asp.net member and roles

            private string _email = String.Empty;

            public string Email
            {
                get { return _email; }
                set { _email = value; }
            }
            private String _comments = String.Empty;

            public String Comments
            {
                get { return _comments; }
                set { _comments = value; }
            }

            private bool _isApproved=true;

            public bool IsApproved
            {
                get { return _isApproved; }
                set { _isApproved = value; }
            }

            private bool _isLocked=false;

            public bool IsLocked
            {
                get { return _isLocked; }
                set { _isLocked = value; }
            }

            private DateTime _created = DateTime.Now;

            public DateTime CreatedDate
            {
                get { return _created; }
                set { _created = value; }
            }
            private DateTime _login = DateTime.Now;

            public DateTime LastLoginDate
            {
                get { return _login; }
                set { _login = value; }
            }

            private DateTime _lastActivity = DateTime.Now;

            public DateTime LastActivityDate
            {
                get { return _lastActivity; }
                set { _lastActivity = value; }
            }
            private DateTime _lastPasswordChange = DateTime.Now;

            public DateTime LastPasswordChangeDate
            {
                get { return _lastPasswordChange; }
                set { _lastPasswordChange = value; }
            }

            private DateTime _lastLock=DateTime.Now;

            public DateTime LastLockDate
            {
                get { return _lastLock; }
                set { _lastLock = value; }
            }
            private string _passwordQuestion = String.Empty;

            public string PasswordQuestion
            {
                get { return _passwordQuestion; }
                set { _passwordQuestion = value; }
            }

            private string _passwordAnswer=String.Empty;
            /// <summary>
            /// Used only by the dummy provider for testing
            /// </summary>
            public string PasswordAnswer
            {
                get { return _passwordAnswer; }
                set { _passwordAnswer = value; }
            }
            private string _password = String.Empty;
            /// <summary>
            /// Used only by the dummy provider for testing
            /// </summary>
            public string Password
            {
                get { return _password; }
                set { _password = value; }
            }

            private string _userName = String.Empty;
            public string UserName
            {
                get { return _userName; }
                set { _userName = value; }
            }

            private Guid _id=Guid.Empty;

            public Guid Id
            {
                get { return _id; }
                set { _id = value; }
            }

            private bool _isOnline;

            public bool IsOnline
            {
                get { return _isOnline; }
                set { _isOnline = value; }
            }

            #endregion


        }
        private static Dictionary<string, myUser> _users;
        static DummyMembershipProvider()
        {
            _users = new Dictionary<string, myUser>();

            List<string> names = new List<string>{"Administrator","User", "Bob", "Ed","George", "Frank",
                "Admin", "SomeCustomer1", "SomeCustomer"};
            int i = 0;
            foreach (string name in names)
            {
                i++;
                CreateUser(name, "password", name + "@someplace.com", "What is my name?", name, (i % 2) == 0, Guid.NewGuid());
            }
        }
        public override string ApplicationName { get; set; }

        private MembershipUser GetMembershipUser(myUser p)
        {
            return new MembershipUser(this.Name, p.UserName, p.Id, p.Email, p.PasswordQuestion, p.Comments
                , p.IsApproved, p.IsLocked, p.CreatedDate, p.LastLoginDate, p.LastActivityDate, p.LastPasswordChangeDate
                , p.LastLockDate);
        }

        public override bool ChangePassword(string username, string oldPassword, string newPassword)
        {
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if (u == null) return false;
            if (u.Password == oldPassword)
            {
                u.Password = newPassword;
            }
            else
            {
                return false;
            }
            return true;
        }

        public override bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer)
        {
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if (u == null) return false;
            if (u.Password != password)
            {
                return false;
            }
            else
            {
                u.PasswordAnswer = newPasswordAnswer;
                u.PasswordQuestion = newPasswordQuestion;
            }
            return true;
        }

        private static myUser CreateUser(string username, string password, string email
            , string passwordQuestion, string passwordAnswer, bool isApproved
            , object providerUserKey)
        {
            myUser m = new myUser();
            m.UserName = username;
            m.Password = password;
            m.Email = email;
            m.PasswordQuestion = passwordQuestion;
            m.PasswordAnswer = passwordAnswer;
            m.IsApproved = isApproved;
            if (providerUserKey != null && providerUserKey is Guid)
                m.Id = (Guid)providerUserKey;
            else
                m.Id = Guid.NewGuid();

            _users.Add(m.UserName, m);
            return m;

        }
        public override MembershipUser CreateUser(string username, string password, string email
            , string passwordQuestion, string passwordAnswer, bool isApproved
            , object providerUserKey, out MembershipCreateStatus status)
        {
            status = MembershipCreateStatus.Success;
            myUser m = CreateUser(username, password, email, passwordQuestion, passwordAnswer, isApproved, providerUserKey);

            if (_users.Values.FirstOrDefault(u => u.UserName == m.UserName) != null) status = MembershipCreateStatus.DuplicateUserName;
            if (_users.Values.Count(u => u.Email == email) > 0) status = MembershipCreateStatus.DuplicateEmail;
            if (_users.Values.Count(u => u.Id == m.Id) > 0) status = MembershipCreateStatus.DuplicateProviderUserKey;
            if (status == MembershipCreateStatus.Success) _users.Add(m.UserName, m);
            return GetMembershipUser(m);
        }

        public override bool DeleteUser(string username, bool deleteAllRelatedData)
        {
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if (u == null) return false;
            u.IsApproved = false;
            u.Comments += "/r/nDeleted";
            return true;
        }

        public override bool EnablePasswordReset
        {
            get { return true; }
        }

        public override bool EnablePasswordRetrieval
        {
            get { return true; }
        }

        public override MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords)
        {
            MembershipUserCollection c = new MembershipUserCollection();
            totalRecords = _users.Count;
            List<myUser> usersFound = _users.Values.Where(u => u.Email.ToLower().Contains(emailToMatch.ToLower())).ToList();
            foreach (MembershipUser m in usersFound.Skip((pageIndex - 1) * pageSize).Take(pageSize).Select(u => GetMembershipUser(u)))
            {
                c.Add(m);
            }
            return c;
        }

        public override MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords)
        {
            MembershipUserCollection c = new MembershipUserCollection();
            totalRecords = _users.Count;
            List<myUser> usersFound = _users.Values.Where(u => u.UserName.ToLower().Contains(usernameToMatch.ToLower())).ToList();
            foreach (MembershipUser m in usersFound.Skip((pageIndex - 1) * pageSize).Take(pageSize).Select(u => GetMembershipUser(u)))
            {
                c.Add(m);
            }
            return c;
        }

        public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords)
        {
            MembershipUserCollection c = new MembershipUserCollection();
            totalRecords = _users.Count;
            foreach (MembershipUser m in _users.Skip((pageIndex - 1) * pageSize).Take(pageSize).Select(u => GetMembershipUser(u.Value)))
            {
                c.Add(m);
            }
            return c;
        }

        public override int GetNumberOfUsersOnline()
        {
            return _users.Values.Where(u => u.IsOnline).Count();
        }

        public override string GetPassword(string username, string answer)
        {
            string result = "";
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if (u != null)
            {
                if (u.PasswordAnswer == answer) result = u.PasswordAnswer;
            }
            return result;
        }

        public override MembershipUser GetUser(string username, bool userIsOnline)
        {
            MembershipUser result = null;
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if (u != null)
            {
                u.IsOnline = userIsOnline;
                result = GetMembershipUser(u);
            }
            return result;
        }

        public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
        {
            MembershipUser result = null;
            myUser m = _users.Values.FirstOrDefault(u => u.Id == (Guid)providerUserKey);
            if (m != null)
            {
                m.IsOnline = userIsOnline;
                result = GetMembershipUser(m);
            }
            return result;
        }

        public override string GetUserNameByEmail(string email)
        {
            string result = "";
            myUser u = _users.Values.FirstOrDefault(m => m.Email == email);
            if (u != null) result = u.UserName;
            return result;
        }

        public override int MaxInvalidPasswordAttempts
        {
            get { return 3; }
        }

        public override int MinRequiredNonAlphanumericCharacters
        {
            get { return 0; }
        }

        public override int MinRequiredPasswordLength
        {
            get { return 4; }
        }

        public override int PasswordAttemptWindow
        {
            get { return 5; }
        }

        public override MembershipPasswordFormat PasswordFormat
        {
            get { return MembershipPasswordFormat.Clear; }
        }

        public override string PasswordStrengthRegularExpression
        {
            get { return ""; }
        }

        public override bool RequiresQuestionAndAnswer
        {
            get { return true; }
        }

        public override bool RequiresUniqueEmail
        {
            get { return false; }
        }

        public override string ResetPassword(string username, string answer)
        {
            string result = "";
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if ((u != null) && (u.PasswordAnswer == answer))
            {
                result = "password1";
                u.Password = result;
            }
            return result;
        }

        public override bool UnlockUser(string userName)
        {
            bool result = false;
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == userName);
            if (u != null)
            {
                u.IsLocked = false;
            }
            return result;
        }

        public override void UpdateUser(MembershipUser user)
        {
            myUser m = _users.Values.FirstOrDefault(u => u.UserName == user.UserName);
            m.Comments = user.Comment;
            m.Email = user.Email;
            m.IsApproved = user.IsApproved;
            m.IsLocked = user.IsLockedOut;
            m.LastActivityDate = user.LastActivityDate;
            m.LastLockDate = user.LastLockoutDate;
            m.LastLoginDate = user.LastLoginDate;
            m.LastPasswordChangeDate = user.LastPasswordChangedDate;
            m.PasswordQuestion = user.PasswordQuestion;
        }

        public override bool ValidateUser(string username, string password)
        {
            bool result = false;
            myUser u = _users.Values.FirstOrDefault(m => m.UserName == username);
            if ((u != null) && (u.Password == password))
                result = true;
            return result;

        }
    }
}

There is always room for improvement; for example some settings could be taken from the web.config instead of code. The dummy provider allows direct control of test data at the start of the application which allows unit tests to be created that are not dependant on a database.

Windows 2008 and SQL 2000

jeff — Mon, 03 Nov 2008 00:37:26 -0400

Ok we all know SQL2K has lost support from Microsoft. We all know it is marked with "compatibility" issues with Win2k8. But will it run? Microsoft dropped the ball on us here. They shipped Win2K8 before SQL2000. leaving those of us with giant budgets in a pickle... The option from Microsoft "upgrade to SQL2k5 and buy software assurance".

I assure you, their bottom line will thank you.

But if you are a smaller shop with limited resources and getting Win2k8 approved was nearly impossible you may be in a jam about SQL.

Or if you, like me, do not want to spend thousands on Sql2k8 just because MS is slow in sending you the "heroes happen here" copy of sql2k8 so you can start playing...err working... with win2k8 and you have limited hardware resources in your home lab... than running sql2000 on win2k8 seems reasonable as a short term solution.

When you try to install sql2k you get a scary message that it is not compatible. Nice message, but it does not really say it will not work, nor does it stop you. Just click continue; now I always setup a domain service account for SQL and set all services to run under that account (there are articles out there about securing SQL in a domain environment that explain the reasons for this so I will leave that to them). After setting my configuration and letting the files copy I noticed the service did not start. Taking a page from install Sql2k on win2k3 I choose to install SQL sp4. After a few errors I tracked down the only issue I really ran into....security. After giving the service account modify rights to the Microsoft SQL server directory in the program files directory the service started and sp4 installed like a champ.

So my server rebooted, came back up and SQL was running.

And that's it. SQL runs in an unsupported and "not compatible" but working manner. Would I do this in a production environment? Not if I could help it. Do I trust it? Not really. Would I recommend it? No way. When SQL2k8 arrives Ill be upgrading to that and removing SQL2K.

I see lots of people asking if it will work and the responses all seem to be the same "It is not supported, upgrade to SQL2k5 or get SQL2k8". No one seems to be willing to answer the question that was asked.

Yes, it will run. No it is not supported. Will every single feature work? I do not know, I do not use every feature of SQL. But SQL itself will run.

Of course one can drive their car off a cliff too... that does not make it a good idea nor recommend.

WebService Documentation: Using a custom Site Map

jeff — Mon, 18 Aug 2008 00:32:17 -0400

Not long ago I started working on changing the look and feel of the default WebService documentation that is generated by asp.net. While I demonstrated how to replace the default page template with a custom one I "glossed" over the details of what you can do with it.

By using a custom Sitemap Provider you can create a dynamic Map of all of your WebServices methods. Please note I am not out to explain SiteMaps in this article. They list the pages in a site for use by some asp.net controls, like the menu control. That over simplified short description of a SiteMap is about as deep as I will be getting into the the general topic of SiteMaps.

Here is a quick peek at my sample web.config. The first SiteMap, "Help", is a simple "out of the box" XmlSiteMapProvider. We will take a look at the associated Help.sitemap file a little later on.

<siteMap>
      <providers>
        <add name="Help" type="System.Web.XmlSiteMapProvider"
                siteMapFile="help.sitemap"/>
        <add name="ObjectHelpDesk.WebServices.help_desk"
                 type="SiteMapProviders.WebServiceSiteMapProvider,SiteMapProviders"
                 webServiceType="ObjectHelpDesk.WebServices.help_desk,ObjectHelpDesk"
                 path="~/help/help-desk.asmx"/>
      </providers>
    </siteMap>

The second SiteMap is a little more interesting. The type is our custom SiteMapProvider class. We give it 2 pieces of information, one is the path to the asmx file; the other is the class type of the WebService. I am using the same WebService I used in the pervious "WebService Documentation: Using a Custom Template" post. I moved the WebService code behind into an assembly; this makes locating the class from the web.config easy. Speaking of the code...

using System.Text;
using System.Web;
using System.Configuration;
using System.Collections.Specialized;
using System.Web.Services;
using System.IO;
using System.Web.Services.Description;
using System.Collections;
using System.Reflection;

namespace SiteMapProviders
{
    public class WebServiceSiteMapProvider : StaticSiteMapProvider
    {
        Type _webServiceType = null;
        SiteMapNode _root = null;
        String[] roles = { "" };
        NameValueCollection _attributes = null;
        string path = "";

        public override void Initialize(string name, NameValueCollection attributes)
        {
            base.Initialize(name, attributes);
            string typeName = attributes["webServiceType"];
            if (String.IsNullOrEmpty(typeName))
                throw new ConfigurationErrorsException("webServiceType is not configured for " + name);

            path = attributes["path"];
            if (String.IsNullOrEmpty(path))
                throw new ConfigurationErrorsException("path is not configured for " + name);
            
            attributes.Remove("path");
            attributes.Remove("webServiceType");

            if (attributes["roles"] != null)
            {
                roles = attributes["roles"].Split(',');
                attributes.Remove("roles");
            }
            _attributes = attributes;

            _webServiceType = Type.GetType(typeName, false);
            if (_webServiceType == null)
            {
                throw new ConfigurationErrorsException(string.Format("webServiceType '{0}' was not found for {1}", typeName, name));
            }
        }

        protected override SiteMapNode GetRootNodeCore()
        {
            if (_root == null) BuildSiteMap();
            return _root;
        }

        public override SiteMapNode BuildSiteMap()
        {
            if (_root == null) //verify it is null
            {
                lock (new object())//create a lock
                {
                    if (_root == null)//make sure no one else has already started it
                    {
                        //build the map here
                        _root = new SiteMapNode(this, _webServiceType.ToString(), path, _webServiceType.Name, _webServiceType.Name + " documentation");
                        _root.Roles = roles;

                        foreach (MethodInfo method in _webServiceType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
                        {
                            if (method.DeclaringType!=_webServiceType) continue;
                            string url = "";
                            string title = "";
                            string desc = "";
                            
                            object[] customAttributes = method.GetCustomAttributes(typeof(WebMethodAttribute), true);
                            if (customAttributes.Count() > 0)
                            {
                                foreach (WebMethodAttribute attribute in customAttributes)
                                {
                                    if (!String.IsNullOrEmpty(attribute.Description))
                                        desc = attribute.Description;
                                    if (!String.IsNullOrEmpty(attribute.MessageName))
                                        title = attribute.MessageName;
                                    title = method.Name;
                                }//foreach (WebMethodAttribute attribute in customAttributes)
                                url = string.Format("{0}?op={1}", path, title);
                                CreateNode(_root, title, desc, url, roles, _attributes, null, "");
                            }//if (customAttributes.Count() > 0)
                        }//foreach (MethodInfo method 
                    }// if (_root == null)
                }//lock (new object())
            }// if (_root == null)
            return _root;
        }

        private SiteMapNode CreateNode(SiteMapNode parent, string title, string desc, string url, string[] roles, NameValueCollection attributes, NameValueCollection explicitResourceKeys, string implicitResourceKey)
        {
            SiteMapNode node = new SiteMapNode(this, url, url, title, desc, roles, attributes, explicitResourceKeys, implicitResourceKey);
            AddNode(node, parent);
            return node;
        }

    }
}

The Initialize method sets up the basics of the SiteMap. It grabs the path to the asmx and gets the Type of the WebService. It also grabs a comma separated list of role names and populates a roles variable for use later. This can be used with security trimming depending on your sites configuration (It is a SiteMap thing and outside of the scope of this post).

The next method is GetRootNodeCore. All it does is check to see if the _root variable is set and call BuildSiteMap if it is null.

I am going to skip BuildSiteMap for a moment; down at the bottom we have a simple private method CreateNode. CreateNode takes all of the information about a SiteMapNode, creates it and adds it to it's parent node.

And that brings us back to the BuildSiteMap method. If we check if the _root node has been created. If it has we do not need to do anything. Next we create a lock and check the _root again. Why 3 checks? A web application (or site) is multi threaded. Seven, One hundred, or a thousand people might all hit it at once. Because providers, including SiteMapProviders, are created once and last the lifetime of the application having several people create the _root node and build the entire site is bad voodoo. So by checking before we call BuildSiteMap we avoid hoping around code. By checking before the lock we are basically making sure that we still need to do it and the check after the lock ensures we did not already start building the SiteMap on a different thread while we were trying to lock people out.

So now that we have locked everyone out and are building the site map we need to create a Root Node (_root). We create the node setting the path to the asmx file path and the title to the WebService type name. We also slap out roles collection into the roles property of the node.

Next we do a little reflection. Why does everyone cringe when I say reflection? We loop through all the methods in the class type we got from the web.config. Next we check to see if it has a WebMethodAttribute set on it. Keep in mind [WebMethodAttribute()] and [WebMethod()] are the same thing. We grab the description from the attribute and the title from the method name. Notice there is a check setting the title to the "MessageName" of the WebMethodAttribute that is completely unused. In fact we step on it when we set the title to the method name. If you set the message name, you might want to put an "else" in between the two title sets. I have not had to use a message name yet and therefore have not tested if it is needed in the title or not. Next I create the SiteMapNodes URL from the path of the asmx and the method name (or title). Finally, I call CreateNode passing all of the important information.

Now if you have 15 different WebServices, you could add 15 SiteMap data sources to your page with a bunch of Menus; but there is an easier way. Let's look at the help.sitemap file from our XmlSiteMapProvider.

<?xml version="1.0" encoding="utf-8" ?>
<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" >
  <siteMapNode url="~/help/default.aspx" title="Help"  description="">
    <siteMapNode url="" title="Web Services"  description="">
      <siteMapNode provider="ObjectHelpDesk.WebServices.help_desk"/>
    </siteMapNode>
  </siteMapNode>
</siteMap>

The only node in this SiteMap that is relevant to us is in the middle; in fact it is missing a URL and title attribute. The only thing it has is a provider attribute. The provider attribute is the name of the provider to include at that position in the SiteMap. Now you can include all 15 different WebService SiteMap's by adding them to the web.config and creating a node in the help.sitemap.

Create a page with a menu control bound to the "help" SiteMap provider. Open the page.

Add 5 new WebMethods to a WebService, recompile and refresh the page. The new methods are already in the menu without any extra work.

Now you can add a nice menu to a custom template or, even better, a master page that you've set the template to use.

Happy coding

WebService Documentation: Using a custom template

jeff — Sun, 10 Aug 2008 04:00:29 -0400

Web Services: they are an easy way to make information accessible or use information from some other site. For example, weather.gov's wsdl. The beauty of web services is that not all web services are .net and we don't have to care. Any web service that adheres to the w3's standards and that provides a wsdl we can easily use in asp.net. In order to help people understand how to consume the service; asp.net even gives us a nice page of generated documentation when someone opens the asmx in their browser.

I, for one, hate that page. If I have gone to all the trouble of building a WebService for someone to submit data or request information, why would I want to send them to a page that looks nothing like the rest of my site to learn how to use it? At the very least brand it in a way that identifies my company. But no, the sad state is such that the generate page is fixed and only by adding a theme to the page section in a web.config can you get it to use a custom style sheet or theme.

So what are we to do? Replace it! That's right, we can replace it. The first thing we need is, a web service of course.

I've cracked open the ObjectHelpDesk solution and added a new folder, "help". I have added a new WebService "help-desk" in the help folder. I moved the code-behind into a dll and edited the asmx accordingly.

I left HelloWorld in place and added EchoHelloWorld. Do not forget to but the WebMethod tag on EchoHelloWorld; otherwise the method will not be available in the web service.

Now we can browse out to the site and see how it looks. If you added comments to the code you might be thinking, "It would be a vast improvement if my comments listed under the methods."

I agree, and we can come close; by editing the WebMethod attribute tag, above the methods, we can add a basic description to the default documentation page. We are going to replace the default page; but we are also going to be using its "guts" as the base of our new page. Because turning off the custom WebService documentation page is as easy as editing one line in the web.config it is important to make sure everything is in order. There is also a description property on the WebService tag that can be set as well.

[WebMethod(Description="Echos back the passed in string")]
public string EchoHelloWorld(string echoMessage)
{
    return "Hello World " + echoMessage;
}

(don't forget to set a description for the WebService)

[WebService(Namespace = http://www.JeffGaroutte.net/, 
    Description="This web service is currently used for testing.")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[ToolboxItem(false)]
public class help_desk : System.Web.Services.WebService

Browse out to C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG and look for DefaultWsdlHelpGenerator.aspx. Copy the file into your project and rename it. I renamed mine to WsdlTemplate.aspx and placed it in the "help" folder with the asmx. Tip: Do not delete, remove, edit or rename the original DefaultWsdlHelpGenerator.aspx file. Sites that do not have a custom template specified in the web.config will need the file. If for some reason you need to turn off the custom template will will still need the file.

Edit the web.config and add a webServices section.

Notice the href; it looks like a relative path. If the href starts with ~/ or / asp.net will throw a 404 error. You can also add a protocols section to the webServices to remove the "documentation" feature entirely. This is an excellent idea if the WebService is not meant to be open to general public use. For "security reasons" the HttpPost and HttpGet protocols methods are disabled for any request that is not from the localhost.

Now you can edit your WsdlTemplate.aspx page and change to your hearts content. However, the page must be dymancily complied. I tried moving the huge code block out into a code behind and found that asp.net did not like it. I believe this is due to the way the rendered page is generated from the template inside of the framework.

Happy Coding!

The returning event delegate

jeff — Mon, 04 Aug 2008 02:42:28 -0400

Delegates have been a great help to developers everywhere; coupled with Events they form the basis of every asp.net web application. Check out the page event life cycle, events are firing long before the code written by the sites developer. But what happens when events and delegates are used with a return value?

I've heard people say that it depends on the return type, it varies by how many functions have been added to the delegate, etc etc...

Poppycock. Never thought I would use that word, however I have no idea the age of everyone who visits here.

It is all about the order. Users have dealt with this same issue for years; If two users open the same file from the network, edit and save it whose changes are kept or lost? Last save wins. So the last delegate to "save" the result wins. So which Delegate is last?

Delegates, like good fast food, follow fifo (First In First Out). Before anyone picks on that statement and points out how many times they placed an order only to get it after the guy who order after them, I said "good fast food". You'll find that hanging out with Santa and the Easter bunny.

The order that method are added to the delegate is the order they will fire in. So the last one added is the last one to run and, therefore, controls the result.

But do not take my word for it, let the code do the talking. Here is the contents for a Program.cs file from a C# console application project.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Delegates
{
    public delegate ReturnType LessonEventHandler<ReturnType>(object sender, EventArgs e);

    class Program
    {
        static void Main(string[] args)
        {
            int order = 1;
            RunTestByOrder(order);
            order++;
            RunTestByOrder(order);
            Console.WriteLine("Press any key to exit.");
            Console.ReadLine();

        }
        
        static void RunTestByOrder(int order)
        {
            Console.WriteLine("Order " + order.ToString() + ":Start");
            EventMaster master = new EventMaster();
            RunBooleanTests(master, order);
            RunInt32Tests(master, order);
            Console.WriteLine("Order " + order.ToString() + ":End");
        }

        static void RunBooleanTests(EventMaster master, int order)
        {
            Console.WriteLine("BooleanTest:Start");
            switch (order)
            {
                case 2:
                    master.BooleanTest += new LessonEventHandler<bool>(master_BooleanTest2);
                    master.BooleanTest += new LessonEventHandler<bool>(master_BooleanTest1);
                    break;
                case 1:
                default:
                    master.BooleanTest += new LessonEventHandler<bool>(master_BooleanTest1);
                    master.BooleanTest += new LessonEventHandler<bool>(master_BooleanTest2);
                    break;
            }
            Console.WriteLine("BooleanTest result: " + master.DoBooleanTest().ToString());
            Console.WriteLine("BooleanTest:End");
        }

        static void RunInt32Tests(EventMaster master, int order)
        {
            Console.WriteLine("Int32Test:Start");
            switch (order)
            {
                case 2:
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test4);
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test3);
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test2);
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test1);
                    break;
                case 1:
                default:
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test1);
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test2);
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test3);
                    master.Int32Test += new LessonEventHandler<int>(master_Int32Test4);
                    break;
            }
            Console.WriteLine("Int32Test result: " + master.DoInt32Test().ToString());
            Console.WriteLine("Int32Test:End");
        }

        static int master_Int32Test1(object sender, EventArgs e)
        {
            Int32 i = 10;
            Console.WriteLine("Int32Test:" + i.ToString());
            return i;
        }

        static int master_Int32Test2(object sender, EventArgs e)
        {
            Int32 i = 20;
            Console.WriteLine("Int32Test:" + i.ToString());
            return i;
        }

        static int master_Int32Test3(object sender, EventArgs e)
        {
            Int32 i = 30;
            Console.WriteLine("Int32Test:" + i.ToString());
            return i;
        }

        static int master_Int32Test4(object sender, EventArgs e)
        {
            Int32 i = 40;
            Console.WriteLine("Int32Test:" + i.ToString());
            return i;
        }

        static bool master_BooleanTest1(object sender, EventArgs e)
        {
            Console.WriteLine("BooleanTest:True");
            return true;
        }
        static bool master_BooleanTest2(object sender, EventArgs e)
        {
            Console.WriteLine("BooleanTest:False");
            return false;
        }
    }

    public class EventMaster
    {
        public event LessonEventHandler<Boolean> BooleanTest;
        public event LessonEventHandler<Int32> Int32Test;

        public Boolean DoBooleanTest()
        {
            return BooleanTest(this, EventArgs.Empty);
        }

        public Int32 DoInt32Test()
        {
            return Int32Test(this, EventArgs.Empty);
        }
    }
}

And here is a screen capture of the output...

If you need to do something like a "IsCanceled" for an event do not use the return from the delegate, use a property in a custom EventArgs object.
There is no way to see the result of the method that fired before you in the delegate.
If there could be more than one method wired into a delegate the result is fairly worthless. If there is only on method wired in, how has it been secured so no one else can hook into it? Private/protected? why not just use a virtual method?

When is a delegate with a return useful? Like everything, it has its place and use; for example: Threading! They can be used to ensure thread safety. But that is topic for another day.

Happy Coding!

The woes of SourceForge.net and SVN

jeff — Tue, 29 Jul 2008 01:32:30 -0400

It's no secret, I use SourceForge.net to work on an open source project ObjectHelpDesk.net and most of the code, patterns and nick nacks that I write about come from that project. I also use TortoiseSVN coupled with VisualSVN to manage my source code. Recently, as part of the Generics, Interfaces, Providers and You series I choose to branch from the trunk and rewrite the projects provider model. When I was finished I attempted to merge them back together.

Recently, I updated Tortoise and VisualSVN so I now have version 1.5.1. SO I switched my working copy back to the trunk, and attempted to reintegrate a branch into the trunk.

"Retrieval of mergeinfo unsupported by 'https://objecthelpdeskn.svn.sourceforge.net/...'" errr what? So I did a little digging with my good friend Google. What I found was a whole bunch of people having the same basic issue. Turns out that SVN made a change around version 1.5 and added a mergeinfo command to make it so you do not have to remember what the last version you merged was so you do not double merge files by accident. Great idea, except...

SourceForge.net is not running the 1.5 SVN server. No problem, find the option to use an older merge method and away we go... So I searched, I looked, hunted and pondered. For the life of me I could not find an option to "reintegrate" the branch into the trunk. Back to Google for an answer.

I found one common suggestion, or fix, download an older client from before 1.5 and use that to do the merge.

Ok first, I hate downgrading. Second, I just got everything installed on a new development machine and I am not about to go mucking about uninstalling tortoise so I can reinstall an older version just to do a merge because Sourceforge.net does not have the latest version of a SVN server. So there had to be another option, one that seemed sane.

Let me explain, I refused to believe that the folks over at SourceForge.net would leave something like source control merges broken for any length of time. On the other hand It seemed that SVN/TortoiseSVN would not go as far as to break their software with a "hub" of the open source community like SourceForge.net. And there was another option right under my nose...

Merge two Different Tress. Really, that is all we are doing, the trunk and branch are two different tress. This merge method asks you which tree/revision you want to start with and which tree/revision you want to end up at and it makes in happen in your working copy. Run the merge, compile the code and commit the changes.

What surprised me was not the fix for the issue, but it was the number of posts about this message and people saying "Oh downgrade your client or upgrade the server" and that number of replies that said "thanks downgrading the client fixed it". In the case of many open source projects, we depend on free tools and systems, like SourceForge.net to host our projects and we have no control over what version of source control repository software they gave installed (However, I do thank them for giving us a choice of source control repositories and being there). I use VisualSVN heavily in Visual Studio and I cant just downgrade tortoise without affecting it and my development environment. So using this "manual" fix seems like the sane method to me.

So if you run into a problem merging with an unsupported mergeinfo message do not just downgrade your client, try merging the two trees instead of reintegrating the branch into the trunk.

Beyond Generics, Interfaces, Providers and You : IReadByParentId

jeff — Sun, 27 Jul 2008 23:06:47 -0400

Ok so in the Generics, Interfaces, Providers and You series, Part 1, Part 2, Part 3 & Part 4, we made a flexible system of interfaces to make working with a data access provider model easier. In Part 4, I listed some ideas where there was room for improvement in the interfaces/class that we made. If you have not read the series yet, go ahead and take a few minutes to read them; this post will not make much sense without it. So here it is, the IReadByParentId interface(s).

Of course we need something to return the collection of items back as and this means we have a new interface in this set, IReadByParentIdDataObjectCollection.

public interface IReadByParentIdDataObjectCollection<DataObject, IdType> : IList<DataObject>
        where DataObject : IReadByParentIdDataObject<DataObject, IdType>
    {
    }

The interface requires that the class inherits an IList<DataObject>. Next we need the IReadByParentIdDataObject interface.

public interface IReadByParentIdDataObject<DataObject, IdType> where DataObject : IReadByParentIdDataObject<DataObject, IdType>
    {
        IdType ParentId { get; }
    }

This does not look that different from the IReadDataObject interface. At this point I should point out that both interfaces can be put on the same onject and the IdType between IReadDataObject and IReadByParentIdDataObject do not need to match. Next we need a provider interface...

public interface IReadByParentIdProvider<ProviderType, DataObjectTypeCollection, DataObject, IdType>
        where ProviderType : IReadByParentIdProvider<ProviderType, DataObjectTypeCollection, DataObject, IdType>
        where DataObject : IReadByParentIdDataObject<DataObject, IdType>
        where DataObjectTypeCollection : IReadByParentIdDataObjectCollection<DataObject, IdType>
    {
        DataObjectTypeCollection GetByParentId(IdType id, IPrincipal user);
    }

Aside from one more generic type in the signature for the interface and the method returning a DataObjectTypeCollection this is not that different from the IReadProvider. Now that we have the provider we need a new collection for them,

public interface IReadByParentIdProviderCollection<ProviderType, DataObjectTypeCollection, DataObject, IdType>
        where ProviderType : IReadByParentIdProvider<ProviderType,DataObjectTypeCollection, DataObject, IdType>
        where DataObject : IReadByParentIdDataObject<DataObject, IdType>
        where DataObjectTypeCollection : IReadByParentIdDataObjectCollection<DataObject, IdType>
    {
        ProviderType this[string name] { get; }
        ProviderType this[int index] { get; }
        void Add(ProviderBase provider);
    }

The changes here only involve the new generic collection type. Finally we have a new repository interface...

public interface IReadByParentIdProviderRepository<ProviderCollectionType, ProviderType, DataObjectTypeCollection, DataObject, IdType>
        where ProviderCollectionType : ProviderCollection, IReadByParentIdProviderCollection<ProviderType, DataObjectTypeCollection,DataObject, IdType>, new()
        where ProviderType : ProviderBase, IReadByParentIdProvider<ProviderType,DataObjectTypeCollection, DataObject, IdType>
        where DataObject : IReadByParentIdDataObject<DataObject, IdType>
        where DataObjectTypeCollection : IReadByParentIdDataObjectCollection<DataObject, IdType>
    {
        ProvidersRepositoryGeneric<ProviderCollectionType,ProviderType> LoadedProviders{get;}

        DataObjectTypeCollection GetByParentId(IdType id, IPrincipal user);
        DataObjectTypeCollection GetByParentId(IdType id, String providerName, IPrincipal user);
        DataObjectTypeCollection GetByParentId(IdType id, Int32 providerIndex, IPrincipal user);
        DataObjectTypeCollection GetByParentId(IdType id, ProviderType provider, IPrincipal user);
    }

At this point I will introduce a new object to the example tree... a Person

    public class Person
    {
        public Int32 Id { get; set; }
        public string FirstName { get; set; }

        public String LastName { get; set; }

        private ContactInformationList _contactInformation = null;
        public ContactInformationList ContactInformation
        {
            get
            {
                return _contactInformation;
            }
            set
            {
                _contactInformation = value;
            }
        }
    }

We will also need a collection of ContactInformation so we will make one,

    public class ContactInformationList : List<ContactInformation>,
        IReadByParentIdDataObjectCollection<ContactInformation, Int32>
    {
    }

Now lets start editing the ContactInformation objects to use our new interfaces.

First we will change the ContactInformation Object

    public abstract class ContactInformation : IReadDataObject<ContactInformation, Int32>, 
        IUpdateDataObject<ContactInformationProvider,ContactInformation>,
        IReadByParentIdDataObject<ContactInformation, Int32>
    {
        public static ContactInformation GetById(Int32 id, IPrincipal user)
        {
           return new ContactInformationProviderRepository().GetById(id, user);
        }
        //public event EventHandler onValidate;
        

        private String _name;
        public String Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }

        #region IReadableDataObject<ContactInformation,int> Members

        private Int32 _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        #endregion

        #region IUpdateDataObject<ContactInformationProvider,ContactInformation> Members

        public void Save(IPrincipal user)
        {
            new ContactInformationProviderRepository().Update(this, user);
        }

        public virtual void Save(ContactInformationProvider provider, IPrincipal user)
        {
            provider.Update(this, user);
        }

        #endregion

        #region IReadByParentIdDataObject<ContactInformation,int> Members

        public int ParentId { get; set; }

        #endregion
    }

The only changes here are the class declaration and the addition of the ParentId property; seems simple enough; Now we will update the Provider...

    public abstract class ContactInformationProvider : ProviderBase,
        IReadProvider<ContactInformationProvider,ContactInformation, Int32>,
        IUpdateProvider<ContactInformationProvider,ContactInformation>,
        IReadByParentIdProvider<ContactInformationProvider, 
            ContactInformationList, ContactInformation, Int32>
    {
        #region IReadProvider<ContactInformation,int> Members

        public abstract ContactInformation GetById(int id, System.Security.Principal.IPrincipal user);

        #endregion

        #region IUpdateProvider<ContactInformationProvider,ContactInformation> Members

        public virtual void Update(ContactInformation item, System.Security.Principal.IPrincipal user)
        {
            throw new NotSupportedException("The abstract ContactInformation can not be updated.");
        }

        #endregion
        public abstract void Update(EmailAddress item, System.Security.Principal.IPrincipal user);
        public abstract void Update(PhoneNumber item, System.Security.Principal.IPrincipal user);

        #region IReadByParentIdProvider<ContactInformationProvider,ContactInformationList,ContactInformation,int> Members

        public abstract ContactInformationList GetByParentId(int id, System.Security.Principal.IPrincipal user);

        #endregion
    }

Again the only changes here are adding the interface and the new abstract method. Breaking change by adding a new abstract method we break any providers that were built before this new version. To maintain backwards compatibility you could mark the method virtual and throw a NotSupportedException, NotImplementedException, or even do something like return new ContactInformationList();.

Next we will modify the provider collection...

public class ContactInformationProviderCollection : ProviderCollection, 
        IReadProviderCollection<ContactInformationProvider,ContactInformation, Int32>,
        IUpdateProviderCollection<ContactInformationProvider,ContactInformation>,
        IReadByParentIdProviderCollection<ContactInformationProvider, ContactInformationList, ContactInformation, Int32>
    {
        #region IReadProviderCollection<ContactInformation,int> Members

        public new ContactInformationProvider this[string name]
        {
            get
            {
                if (String.IsNullOrEmpty(name)) throw new ArgumentNullException();
                ContactInformationProvider result = (ContactInformationProvider)base[name];
                if (result == null) throw new ArgumentOutOfRangeException();

                return result;
            }
        }

        public ContactInformationProvider this[int index]
        {
            get
            {
                if ((index < 0) || (index >= this.Count)) throw new ArgumentOutOfRangeException();
                int currentIndex = 0;
                foreach (ContactInformationProvider item in this)
                {
                    if (currentIndex == index) return item;
                    currentIndex++;
                }
                //if we reach this point something really odd happened
                //in theory since we already verdified the index is 0 or greater
                //and is less than the total provider count this should never be hit.
                //it would be possible if a provider was removed during run time...
                //so it should blow up.
                throw new ArgumentOutOfRangeException();
            }
        }

        public new void Add(ProviderBase provider)
        {
            //cant add a null so die if we try
            if (provider == null) throw new ArgumentNullException();

            //check the type of the provider
            if (provider is ContactInformationProvider)
            {
                //all good so add the provider to the collection
                base.Add(provider);
            }
            else
            {
                //Invalid type so blow up.
                throw new ArgumentException();
            }
        }

        #endregion
    }

In this case the only change was adding the interface to the class. Seems easy so far, now to edit the Repository...

    public class ContactInformationProviderRepository : 
        IReadProviderRepository<ContactInformationProviderCollection, 
            ContactInformationProvider, ContactInformation, Int32>,
        IUpdateProviderRepository<ContactInformationProviderCollection, 
            ContactInformationProvider, ContactInformation>,
        IReadByParentIdProviderRepository<ContactInformationProviderCollection,
            ContactInformationProvider, ContactInformationList, 
            ContactInformation, Int32>
    {

        #region IReadProviderRepository<ContactInformationProviderCollection,ContactInformationProvider,ContactInformation,int> Members
        private static ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider> _loadedProviders = null;
        public ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider> LoadedProviders
        {
            get
            {
                if (_loadedProviders == null)
                {
                    Object processLock = new Object();
                    lock (processLock)
                    {
                        if (_loadedProviders == null)
                        {
                            _loadedProviders = new ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider>();
                        }
                    }

                }
                return _loadedProviders;
            }
        }

        public ContactInformation GetById(int id, System.Security.Principal.IPrincipal user)
        {
            return GetById(id, LoadedProviders.Provider, user);
        }

        public ContactInformation GetById(int id, string providerName, System.Security.Principal.IPrincipal user)
        {
            return GetById(id, LoadedProviders.Providers[providerName], user);
        }

        public ContactInformation GetById(int id, int providerIndex, System.Security.Principal.IPrincipal user)
        {
            return GetById(id, LoadedProviders.Providers[providerIndex], user);
        }

        public ContactInformation GetById(int id, ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            return provider.GetById(id, user);

        }

        #endregion


        #region IUpdateProviderRepository<ContactInformationProviderCollection,ContactInformationProvider,ContactInformation> Members


        public void Update(ContactInformation item, System.Security.Principal.IPrincipal user)
        {
            Update(item, LoadedProviders.Provider, user);
        }

        public void Update(ContactInformation item, string providerName, System.Security.Principal.IPrincipal user)
        {
            Update(item, LoadedProviders.Providers[providerName], user);
        }

        public void Update(ContactInformation item, int providerIndex, System.Security.Principal.IPrincipal user)
        {
            Update(item, LoadedProviders.Providers[providerIndex], user);
        }

        public void Update(ContactInformation item, ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            item.Save(provider, user);
        }

        #endregion
        
        #region IReadByParentIdProviderRepository<ContactInformationProviderCollection,ContactInformationProvider,ContactInformationList,ContactInformation,int> Members


        public ContactInformationList GetByParentId(int id, System.Security.Principal.IPrincipal user)
        {
            return GetByParentId(id, LoadedProviders.Provider, user);
        }

        public ContactInformationList GetByParentId(int id, string providerName, System.Security.Principal.IPrincipal user)
        {
            return GetByParentId(id, LoadedProviders.Providers[providerName], user);
        }

        public ContactInformationList GetByParentId(int id, int providerIndex, System.Security.Principal.IPrincipal user)
        {
            return GetByParentId(id, LoadedProviders.Providers[providerIndex], user);
        }

        public ContactInformationList GetByParentId(int id, ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            return provider.GetByParentId(id, user);
        }

        #endregion
    }

Well we added the the new interface to the class and added code for the new methods to the class. The new code looks a lot like the code for the GetById methods. Of course now we need to populate the list in the person object. In this case we will use a little lazy loading to populate the list.

    public class Person
    {
        public Int32 Id { get; set; }
        public string FirstName { get; set; }

        public String LastName { get; set; }

        private ContactInformationList _contactInformation = null;
        public ContactInformationList ContactInformation
        {
            get
            {
                if (_contactInformation == null)
                    _contactInformation = new ContactInformationProviderRepository()
                        .GetByParentId(this.Id, Thread.CurrentPrincipal);
                return _contactInformation;
            }
            set
            {
                _contactInformation = value;
            }
        }
    }

the only thing that remains is to edit the dummyContactInformationProvider to handle the new method. In a real provider this would be, I think, the hardest part. You have to deal with the data store here and may, or may not, be easy (betrive anyone?).

 public class dummyContactInformationProvider : ContactInformationProvider
    {
        private ContactInformationList _memoryDataStore = null;

        private ContactInformationList MemoryDataStore
        {
            get
            {
                if (_memoryDataStore == null) _memoryDataStore=BuildMemoryDataStore();
                return _memoryDataStore;
            }
        }

        private ContactInformationList BuildMemoryDataStore()
        {
            ContactInformationList result = new ContactInformationList();
            HomePhoneNumber phone = new HomePhoneNumber();
            phone.Number = "555.555.1234";
            phone.ParentId = 1;
            result.Add(phone);

            phone = new HomePhoneNumber();
            phone.Number = "555.555.9999";
            phone.ParentId = 2;
            result.Add(phone);

            phone = new HomePhoneNumber();
            phone.Number = "555.555.1234";
            phone.ParentId = 3;
            result.Add(phone);

            EmailAddress email = new EmailAddress();
            email.Address = "bob@test.com";
            email.ParentId = 1;
            result.Add(email);

            email = new EmailAddress();
            email.Address = "dilbert@dilbert.com";
            email.ParentId = 2;
            result.Add(email);

            email = new EmailAddress();
            email.Address = "Jones@microsoft.com";
            email.ParentId = 3;
            result.Add(email);

            return result;
        }
        public override ContactInformation GetById(int id, System.Security.Principal.IPrincipal user)
        {
            ContactInformation result = MemoryDataStore.FirstOrDefault(ci => ci.Id == id);
            return result;
        }

        public override void Update(EmailAddress item, System.Security.Principal.IPrincipal user)
        {
            EmailAddress email = (EmailAddress)MemoryDataStore.FirstOrDefault(ci => ci is EmailAddress && ci.Id == item.Id);
            email.Address = item.Address;
            email.ParentId = item.ParentId;
        }

        public override void Update(PhoneNumber item, System.Security.Principal.IPrincipal user)
        {
            PhoneNumber phone = (PhoneNumber)MemoryDataStore.FirstOrDefault(ci => ci is PhoneNumber && ci.Id == item.Id);
            
            phone.Number = item.Number;
            phone.ParentId = item.ParentId;
        }

        public override ContactInformationList GetByParentId(int id, System.Security.Principal.IPrincipal user)
        {
            ContactInformationList result = new ContactInformationList();
            result.AddRange(MemoryDataStore.Where(ci => ci.ParentId == id));
            return result;
        }
    }

And there you have it. There is a reason it is named "dummy" but it does the basics and will mock a real data store fairly nicely. Why did I rewrite a "dummy" provider... I now have a data store that will reset to known values each time I start the application, I can make changes to the data in my application (or unit tests) pull the modified data and when the application ends my data store is back to it's known state.

If you're interested in seeing the code itself, check out the SVN Repository at SourceFroge.net. The code samples in my blog(s) come from the project at http://sourceforge.net/projects/objecthelpdeskn.

Enjoy.

Generics, Interfaces, Providers and You - Part 4: Building the Classes

jeff — Sun, 27 Jul 2008 20:53:03 -0400

Now that we have our interfaces we need to make some changes to our existing objects. Back in part 1 we defined an object tree for contact information. For this example, a 3rd parting marketing system is loading new contact information into our data store and management does not want anyone to delete data, but in a truely pointy hair boss fashion they want people to be able to update the data...

First we will create the ContactInformationProviderRepository. We make a static ProvidersRepositoryGeneric to hold the Providers we load based on the web.config. By looking at GetById and Update you can see they use the same logic to locate the correct provider. If the overload that takes the provider as a parameter has a null for the provider it simply throws an exception.

The LoadedProviders accessor is where the real trick happens. First we look to see if the static ProvidersRepositoryGeneric is populated. If it is null we create a lock to stop anyone from accessing it and we check it again to make sure someone else did not set it between our first check and the lock. This is important to do because we are running in a multi thread environment (multiple web requests at once) we need to be sure we are not stepping on our own feet. If it is still null we create it. The constructor goes out and gets the provider information from the web.config and populates the collection.

    public class ContactInformationProviderRepository : 
        IReadProviderRepository<ContactInformationProviderCollection, 
            ContactInformationProvider, ContactInformation, Int32>,
        IUpdateProviderRepository<ContactInformationProviderCollection, 
            ContactInformationProvider, ContactInformation>
    {

        #region IReadProviderRepository<ContactInformationProviderCollection,ContactInformationProvider,ContactInformation,int> Members
        private static ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider> _loadedProviders = null;
        public ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider> LoadedProviders
        {
            get
            {
                if (_loadedProviders == null)
                {
                    Object processLock = new Object();
                    lock (processLock)
                    {
                        if (_loadedProviders == null)
                        {
                            _loadedProviders = new ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider>();
                        }
                    }

                }
                return _loadedProviders;
            }
        }

        public ContactInformation GetById(int id, System.Security.Principal.IPrincipal user)
        {
            return GetById(id, LoadedProviders.Provider, user);
        }

        public ContactInformation GetById(int id, string providerName, System.Security.Principal.IPrincipal user)
        {
            return GetById(id, LoadedProviders.Providers[providerName], user);
        }

        public ContactInformation GetById(int id, int providerIndex, System.Security.Principal.IPrincipal user)
        {
            return GetById(id, LoadedProviders.Providers[providerIndex], user);
        }

        public ContactInformation GetById(int id, ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            return provider.GetById(id, user);

        }

        #endregion

        #region IUpdateProviderRepository<ContactInformationProviderCollection,ContactInformationProvider,ContactInformation> Members

        public void Update(ContactInformation item, System.Security.Principal.IPrincipal user)
        {
            Update(item, LoadedProviders.Provider, user);
        }

        public void Update(ContactInformation item, string providerName, System.Security.Principal.IPrincipal user)
        {
            Update(item, LoadedProviders.Providers[providerName], user);
        }

        public void Update(ContactInformation item, int providerIndex, System.Security.Principal.IPrincipal user)
        {
            Update(item, LoadedProviders.Providers[providerIndex], user);
        }

        public void Update(ContactInformation item, ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            if (provider == null) throw new ArgumentNullException("provider"); 
            item.Save(provider, user);
        }

        #endregion
    }

Even though ProvidersRepositoryGeneric<ContactInformationProviderCollection, ContactInformationProvider> LoadedProviders is defined in both the IReadProviderRepository and IUpdateProviderRepository interfaces it only appears once in the class. That is because the property signature matches between the two and they use the same one.

Now let us get the provider collection created.

 public class ContactInformationProviderCollection : ProviderCollection, 
        IReadProviderCollection<ContactInformationProvider,ContactInformation, Int32>,
        IUpdateProviderCollection<ContactInformationProvider,ContactInformation>
    {
        #region IReadProviderCollection<ContactInformation,int> Members

        public new ContactInformationProvider this[string name]
        {
            get
            {
                if (String.IsNullOrEmpty(name)) throw new ArgumentNullException();
                ContactInformationProvider result = (ContactInformationProvider)base[name];
                if (result == null) throw new ArgumentOutOfRangeException();

                return result;
            }
        }

        public ContactInformationProvider this[int index]
        {
            get
            {
                if ((index < 0) || (index >= this.Count)) throw new ArgumentOutOfRangeException();
                int currentIndex = 0;
                foreach (ContactInformationProvider item in this)
                {
                    if (currentIndex == index) return item;
                    currentIndex++;
                }
                //if we reach this point something really odd happened
                //in theory since we already verdified the index is 0 or greater
                //and is less than the total provider count this should never be hit.
                //it would be possible if a provider was removed during run time...
                //so it should blow up.
                throw new ArgumentOutOfRangeException();
            }
        }

        public new void Add(ProviderBase provider)
        {
            //cant add a null so die if we try
            if (provider == null) throw new ArgumentNullException();

            //check the type of the provider
            if (provider is ContactInformationProvider)
            {
                //all good so add the provider to the collection
                base.Add(provider);
            }
            else
            {
                //Invalid type so blow up.
                throw new ArgumentException();
            }
        }

        #endregion
    }
}

We are doing 3 things here, we are way to get the provider by the index. Next we are hiding the base class implementation of get by name "public new ContactInformationProvider this[string name] ". Finally we are hiding the the Add method on the base class. We hide it so we can check to make sure the provider being added is of the correct type.

Next we setup an abstract provider...

public abstract class ContactInformationProvider : ProviderBase,
        IReadProvider<ContactInformationProvider,ContactInformation, Int32>,
        IUpdateProvider<ContactInformationProvider,ContactInformation>
    {
        #region IReadProvider<ContactInformation,int> Members

        public abstract ContactInformation GetById(int id, System.Security.Principal.IPrincipal user);

        #endregion

        #region IUpdateProvider<ContactInformationProvider,ContactInformation> Members

        public virtual void Update(ContactInformation item, System.Security.Principal.IPrincipal user)
        {
            throw new NotSupportedException("The abstract ContactInformation can not be updated.");
        }

        #endregion
        public abstract void Update(EmailAddress item, System.Security.Principal.IPrincipal user);
        public abstract void Update(PhoneNumber item, System.Security.Principal.IPrincipal user);
    }

We will be able to inherit this class to make a working provider for contact information. We added two overloads to the update method to take the specific types of contact information we have in our model. Because ContactInforamtion is an abstract class and is the root of the object tree, or the branch we are interested in saving, we do not want to try to update it so we can throw a NotImplementedException or a NotSupportedException; I marked the method as virtual just incase a provider is created that can handle an unboxed ContactInformation; you could do a if else tree checking if (item is EmailAddress){ Update(((EmailAddress)item),user); } else if (item is PhoneNumber).....

Now we need to modify the ContactInofrmation base class.

public abstract class ContactInformation : IReadDataObject<ContactInformation, Int32>, 
        IUpdateDataObject<ContactInformationProvider,ContactInformation>
    {
        public static ContactInformation GetById(Int32 id, IPrincipal user)
        {
           return new ContactInformationProviderRepository().GetById(id, user);
        }        

        private String _name;
        public String Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }

        #region IReadableDataObject<ContactInformation,int> Members

        private Int32 _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        #endregion

        #region IUpdateDataObject<ContactInformationProvider,ContactInformation> Members

        public void Save(IPrincipal user)
        {
            new ContactInformationProviderRepository().Update(this, user);
        }

        public virtual void Save(ContactInformationProvider provider, IPrincipal user)
        {
            provider.Update(this, user);
        }

        #endregion
    }

First we added a static method, GetById that will return a contact information by id. It simply calls a new ContactInformationProviderRepository and calls the GetById method. Next we added an Id property. The set accessor was not required by the interface but we still added one.

The save method calls out to the repository to get back the provider. The repository finds the requested provider and calls the items save method passing the provider as a parameter (The delete method would do the same thing). The Save overload that accepts the provider is marked virtual so it can be overridden in subclasses.

Now let's update the PhoneNumber EmailAddress clasesses

    public abstract class PhoneNumber : ContactInformation
    {
        private string _number;
        public string Number
        {
            get
            {
                return _number;
            }
            set
            {
                _number = value;
            }
        }
        public override void Save(ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            provider.Update(this, user);
        }
    }

    public class EmailAddress : ContactInformation
    {
        public EmailAddress()
        {
            Name = "Email Address";
        }
        private string _address;
        public string Address
        {
            get
            {
                return _address;
            }
            set
            {
                _address = value;
            }
        }
        public override void Save(ContactInformationProvider provider, System.Security.Principal.IPrincipal user)
        {
            provider.Update(this, user);
        }
    }

Both classes have the same change; they both override the Save method. The code seems the same but it is important to be there. There is a type boxing issue, (I mentioned the boxing issue back in part 2 as well), that we want to get around. Let me explain...

The the method calls are mapped at compile time, not runtime. For example say you have a variable "contact" defined as ContactInformation contact=new EmailAddress(); and ContactInformationProvider provider=new DummyContactInformationProvider();

Now what happens if you call provider.Update(contact,Thread.CurrentPrincipal);?

the provider update method is passed an object of type ContactInformation
the NotSupportedException is thrown

The fact that contact is holding an object of type EmailAddress is not checked. This is because of the compile time mapping of method calls. Now let's look at what happens if you use the same objects and call Contact.Save(Thread.CurrentPrincipal);

The item is passed to the repository boxed as a ContactInformation object
The repository calls its own overload passing the item, provider, and user
The items save method is called with the provider and user as the parameters.
Because EmailAddress overrides the save method overload with that signature, it is used.
The Save method call provider.Update passing "this" and the user.
Because "this" from inside of the EmailAddress is strongly typed as an EmailAddress the provider's Update method that accepts an EmailAddress object is called and there is no exception.

provider.Update(contact,Thread.CurrentPrincipal); would work if .net used runtime mapping. However I suspect the overhead in doing that might be a performance killer. This is the same reason why we can not use a System.Type variable with generics to make runtime generic objects.

The only thing remaining is to build a provider...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ObjectHelpDesk.ContactInformations;
using ObjectHelpDesk.ContactInformations.PhoneNumbers;

namespace DummyProviders
{
    public class dummyContactInformationProvider : ContactInformationProvider
    {
        private string email = "bob@test.com";
        private string phone = "555.555.1234";
        public override ContactInformation GetById(int id, System.Security.Principal.IPrincipal user)
        {
            ContactInformation result = null; ;
            switch (id)
            {
                case 1:
                case 2:
                    result = new EmailAddress();
                    ((EmailAddress)result).Address = email;
                    break;
                case 3:
                default:
                    result = new HomePhoneNumber();
                    ((PhoneNumber)result).Number = phone;
                    break;
            }
            
            result.Id = id;
            return result;
        }

        public override void Update(EmailAddress item, System.Security.Principal.IPrincipal user)
        {
            email = item.Address;
        }

        public override void Update(PhoneNumber item, System.Security.Principal.IPrincipal user)
        {
            phone = item.Number;
        }
    }
}

This provider is really simple, and fairly useless, but it gets the point across of how this works. GetById returns an EmailAddress object for if the id is 1 or 2 and a phone number for anything else. The update methods update private strings that are used to generate those objects.

All of these interfaces make setting up a new provider fairly quick and easy. More importantly they give you a great deal of flexibility. There is room for expansion/improvement here; Off the top of my head...

you could add another set of interfaces for a function that would be common, IReadByParentId.
Make the update interfaces use an IsDirty property and the INotifiyPropertyChanged interface. It is part of the .net framework.
make the abstract providers have a public concrete implementation of the methods and call a protected version of the method internally... like public void Update(IUpdateDataObject item, IPrincipal user) { DoUpdate(item,user);} protected abstract void DoUpdate( IUpdateDataObject item, IPrincipal user);
add pre/post events for each data method (this ties into #3)
make the pre event able to cancel the call.

Happy Coding!

Generics, Interfaces, Providers and You - Part 3:IProviderCollection & IProviderRepository

jeff — Sun, 27 Jul 2008 05:43:57 -0400

In part 1 We talked about the web.config and the basic classes to get started with a provider model. Part 2 covered the interface for the data object and the Provider. Now in part 3 we will address the IProviderCollection and the IProviderRepository.

Back in part one we added a provider collection to the generic provider repository by taking the provider collection as a generic parameter. Now we are going to define the ProviderCollection interfaces. They are going to be ICreateProviderCollection, IReadProviderCollection, IUpdateProviderCollection, IDeleteProviderCollection and ICrudProviderCollection.

First ICreateProviderCollection

public interface ICreateProviderCollection<ProviderType, DataObject>
        where ProviderType : ICreateProvider<ProviderType, DataObject>
        where DataObject : ICreateDataObject<ProviderType,DataObject>
    {
        ProviderType this[string name] {get;}
        ProviderType this[int index] { get; }
        void Add(ProviderBase provider);
    }

We define to methods of getting back a provider, one by name and the other by it's index in the collection. We also define a way to add a provider to the collection.

Next IReadProviderCollection

    public interface IReadProviderCollection<ProviderType, DataObject, IdType>
        where ProviderType : IReadProvider<ProviderType,DataObject, IdType>
        where DataObject : IReadDataObject<DataObject, IdType>
    {
        ProviderType this[string name] { get; }
        ProviderType this[int index] { get; }
        void Add(ProviderBase provider);
    }

Except for the where clause, it is identical to the ICreateProviderCollection; In fact so are IUpdateProviderCollection and IDeleteProviderCollections

    public interface IUpdateProviderCollection<ProviderType, DataObject>
        where ProviderType : IUpdateProvider<ProviderType, DataObject>
        where DataObject : IUpdateDataObject<ProviderType, DataObject>
    {
        ProviderType this[string name] { get; }
        ProviderType this[int index] { get; }
        void Add(ProviderBase provider);
    }

    public interface IDeleteProviderCollection<ProviderType, DataObject>
        where ProviderType : IDeleteProvider<ProviderType, DataObject>
        where DataObject : IDeleteDataObject<ProviderType, DataObject>
    {
        ProviderType this[string name] { get; }
        ProviderType this[int index] { get; }
        void Add(ProviderBase provider);
    }

The ICrudProviderCollection on the other hand is empty...

    public interface ICrudProviderCollection<ProviderType, DataObject, IdType> : 
        ICreateProviderCollection<ProviderType, DataObject>,
        IReadProviderCollection<ProviderType, DataObject, IdType>,
        IUpdateProviderCollection<ProviderType, DataObject>,
        IDeleteProviderCollection<ProviderType, DataObject>
        where ProviderType : ICrudProvider<ProviderType, DataObject, IdType>
        where DataObject : ICrudDataObject<ProviderType, DataObject, IdType>
    {
    }

This is because the methods and properties are defined on the other interfaces already.

So, let's move on to the IProviderRepository.

First we have the ICrudProviderRepository

public interface ICrudProviderRepository<ProviderCollectionType,ProviderType, DataObject, IdType> :
        ICreateProviderRepository<ProviderCollectionType, ProviderType, DataObject>,
        IReadProviderRepository<ProviderCollectionType, ProviderType, DataObject, IdType>,
        IUpdateProviderRepository<ProviderCollectionType, ProviderType, DataObject>,
        IDeleteProviderRepository<ProviderCollectionType, ProviderType, DataObject>
        where ProviderCollectionType : ProviderCollection,
            ICrudProviderCollection<ProviderType, DataObject, IdType>, new()
        where ProviderType : ProviderBase, ICrudProvider<ProviderType, DataObject, IdType>
        where DataObject : ICrudDataObject<ProviderType, DataObject, IdType>
    {
    }

Again all of the methods and properties are defined on the other interfaces.

ICreateProviderRepository

    public interface ICreateProviderRepository<ProviderCollectionType,ProviderType,DataObject>
        where ProviderCollectionType : ProviderCollection, ICreateProviderCollection<ProviderType, DataObject>, new()
        where ProviderType : ProviderBase, ICreateProvider<ProviderType, DataObject>
        where DataObject : ICreateDataObject<ProviderType,DataObject>
    {
        ProvidersRepositoryGeneric<ProviderCollectionType, ProviderType> LoadedProviders { get; }

        void Create(DataObject item, IPrincipal user);
        void Create(DataObject item, String providerName, IPrincipal user);
        void Create(DataObject item, Int32 providerIndex, IPrincipal user);
        void Create(DataObject item, ProviderType provider, IPrincipal user);

    }

The interface defines 4 overloads of the create method. The first, in a concret class, would use the default provider. The second accepts the name of the provider and uses it to find the correct provider to use. The 3 overload takes the index of the provider in the collection to try and find the provider. And last but not least is the 4th overload which accepts the provider itself. The IReadProviderRepository, IUpdateProviderRepository and IDeleteProviderRepositorys all have these 4 overloads with similar signatures. In IReadProviderRepository the read methods return a DataObject instead of taking one as a parameter. Back in part one we defined the ProvidersRepositoryGeneric and this is where we use it.

IReadProviderRepository

    public interface IReadProviderRepository<ProviderCollectionType, ProviderType,DataObject,IdType>
        where ProviderCollectionType : ProviderCollection,IReadProviderCollection<ProviderType, DataObject, IdType>,new()
        where ProviderType : ProviderBase,IReadProvider<ProviderType, DataObject, IdType>
        where DataObject: IReadDataObject<DataObject,IdType>
    {
        ProvidersRepositoryGeneric<ProviderCollectionType,ProviderType> LoadedProviders{get;}

        DataObject GetById(IdType id, IPrincipal user);
        DataObject GetById(IdType id, String providerName, IPrincipal user);
        DataObject GetById(IdType id, Int32 providerIndex, IPrincipal user);
        DataObject GetById(IdType id, ProviderType provider, IPrincipal user);
    }

IUpdateProviderRepository

    public interface IUpdateProviderRepository<ProviderCollectionType,ProviderType,DataObject>
        where ProviderCollectionType : ProviderCollection, IUpdateProviderCollection<ProviderType, DataObject>, new()
        where ProviderType : ProviderBase, IUpdateProvider<ProviderType, DataObject>
        where DataObject : IUpdateDataObject<ProviderType,DataObject>
    {
        ProvidersRepositoryGeneric<ProviderCollectionType, ProviderType> LoadedProviders { get; }

        void Update(DataObject item, IPrincipal user);
        void Update(DataObject item, String providerName, IPrincipal user);
        void Update(DataObject item, Int32 providerIndex, IPrincipal user);
        void Update(DataObject item, ProviderType provider, IPrincipal user);
    }

IDeleteProviderRepository

    public interface IDeleteProviderRepository<ProviderCollectionType, ProviderType,DataObject>
        where DataObject : IDeleteDataObject<ProviderType, DataObject>
        where ProviderCollectionType : ProviderCollection, IDeleteProviderCollection<ProviderType, DataObject>, new()
        where ProviderType : ProviderBase, IDeleteProvider<ProviderType, DataObject>
    {
        ProvidersRepositoryGeneric<ProviderCollectionType, ProviderType> LoadedProviders { get; }

        void Delete(DataObject item, IPrincipal user);
        void Delete(DataObject item, String providerName, IPrincipal user);
        void Delete(DataObject item, int providerIndex, IPrincipal user);
        void Delete(DataObject item, ProviderType provider, IPrincipal user);
    }

Our basic interfaces are done, now we need to create classes that use them and build a provider

Next : Generics, Interfaces, Providers and You - Part 4: Building the Classes