if (User.IsInRole("Admin"))
{
    //Give Access to Secrets
}

The problem with this is you need to know the name of the group ahead of time. And what if you are on a network where the full name of a group is not always clear. The actual group name may be “MyDomain\Admin”. So I wrote up a quick way to just get a list of all the groups a user is a member of. It isn’t super straight forward (as far as which types you need to cast to) so I thought I would list it out here:

public static List<string> GetGroups(RolePrincipal user)
{
    List<string> groups = new List<string>();

    WindowsIdentity identity = p.Identity as WindowsIdentity;
    foreach (IdentityReference group in identity.Groups)
    {
        NTAccount account = (NTAccount)group.Translate(typeof(NTAccount));

        groups.Add(account.Value);
    }

    return groups;
}

the user of it on a web page would be something like:

List<string> groups = GetGroups(User as RolePrincipal);

Keep in mind that this is assuming you are using Windows Authentication. So the weird part of the code above is:

NTAccount account = (NTAccount)group.Translate(typeof(NTAccount));

if you do not get this step, you will just get a bunch of Active Directory IDs that won’t do you much good.

Also, sorry about the long title. I just can’t think of a clever title today. Maybe I should add something like “Ultimate Edition for Developers” on the end to make it extra clear.

• In N Out
• Lolita’s Taco Shop
• Phil’s Barbeque

Hopefully it is just a matter of having to learn about the local spots up here for good food. I am not all that hopeful that I will find mexican food up here like they have in San Diego.

In this series of posts, I will show how I converted a small website from just standard .aspx pages into a site where all pages are editable by Windows Live Writer and via an online interface. In Part I of this series I will just set some background on how I am approaching the creation of this lightweight CMS.

If The Shoe Fits…

When I first thought of a lightweight CMS, I thought of graffiti. It sounds like exactly what I need. So I downloaded the express edition and started evaluating it. It seemed like a nice product and all is not free for commercial use ($399 is the cheapest commercial licence) and I can’t afford that price tag when building small websites.

Enter BlogEngine.net. My favorite blogging platform. There, I said it. I host my blog on wordpress but I like BlogEngine.net better. In fact, I will probably be migrating to BlogEngine.net in the near future. How do I know I like it so much? Well, I use it to run my wife’s blog and I am constantly tinkering around with her site all of the time because I enjoy using BlogEngine.net so much.

I thought that BlogEngine.net has all of the key pieces I needed for my lightweight CMS:

1. A WYSIWYG Editor
2. A Metaweblog interface
3. Tons of extensibility

Basic Idea

I decided to base my CMS implementation on the concept of pages. Most blog engines have two distinct types of content: pages and posts. Posts are the typical type of content that becomes part of your blogs feed whereas pages are usually static content which can be anything outside of a blog post (for example an ‘About Me’ page). BlogEngine.net already has everything I need to get the content of page created and persisted in a data store (it supports xml and sql server out of the box). I decided to write a web control which I can place on any webpage and include the contents of a given page from the data store.

I made a control called PageViewer which you can place on the page like this:

<blog:PageViewer ID="view" runat="server" DisplayTitle="false"
    PageId="167eb7f3-135b-4f90-9756-be25ec10f14c" />

This control basically just looks up the page using the given id (this functionality is all provided by the existing BlogEngine.Core library) and displays its content. Here is the rendering logic

BlogEngine.Core.Page page = null;
if (PageId != Guid.Empty)
    page = BlogEngine.Core.Page.GetPage(PageId);

if (page != null)
{
    ServingEventArgs arg = new ServingEventArgs(page.Content, ServingLocation.SinglePage);
    BlogEngine.Core.Page.OnServing(page, arg);

    if (arg.Cancel)
        Page.Response.Redirect("error404.aspx", true);

    if (DisplayTitle)
    {
        writer.Write("<h1>");
        writer.Write(page.Title);
        writer.Write("</h1>");
    }

    writer.Write("<div>");
    writer.Write(arg.Body);
    writer.Write("</div>");
}

This code is pretty straight forward – all it does is get an instance of the page and then display its title in <h1> a tag and its body in <div> tag. This logic is actually straight from the existing page retrieval code that already exists in BlogEngine.net. This web control is pretty much the only new code I had to write. The rest of the project mostly involves moving files around and removing parts of the BlogEngine.net framework that I don’t need.

Armed with this control, we are ready to start converting the static pages from the old version of the website to be BlogEngine.net pages which can be stored and retrieved using the BlogEngine.Core classes.

In part II of this series, I will cover what changes I made to the website project used for BlogEngine.net blogs to make it function like a straight up website, not a blog. Any feedback is welcome.

The YUI Team just released version 2.5.0 of the library. We’ve added six new components — Layout Manager, Uploader (multi-file upload engine combining Flash and JavaScript), Resize Utility, ImageCropper, Cookie Utility and a ProfilerViewer Control that works in tandem with the YUI Profiler. This release also contains major improvements to the DataTable Control and new Dual-Thumb Slider functionality in the Slider Control.

Six new components?!? Man, I just can’t keep up with learning all this new stuff let alone keep YUI.Net up to date.

Roadmap Gone Off Track

I was working on a roadmap for YUI.Net but now I have some serious consideration to do about what next steps to take. Although there has been plenty of interest in the YUI.Net project, nobody has really come forward to help out. I am not complaining. I really enjoy working on YUI.Net. I just don’t have the time to dedicate to it right now. I am going to continue to follow the development of the YUI, but I don’t think I will continue development on the YUI.Net library for the foreseeable future.

I am currently working on a project roadmap so please let me know if you are interested in participating. One feature I have already begun work on is giving the control support for data binding.

Here is some example data binding code I have got working:

protected void Page_Load(object sender, EventArgs e)
{
    chart.DataSource = GetDataSource();
    chart.DataBind();
}

private DataTable GetDataSource()
{
    DataTable table = new DataTable();

    table.Columns.Add("Type", typeof(string));
    table.Columns.Add("Jan", typeof(float));
    table.Columns.Add("Feb", typeof(float));
    table.Columns.Add("Mar", typeof(float));

    table.Rows.Add("Men", 68, 78, 88);
    table.Rows.Add("Women", 68, 58, 78);
    table.Rows.Add("Both", 88, 48, 98);
    return table;
}

I am just binding to a simple DataTable which has one column containing the labels for the chart and multiple other columns which contain the data for the chart. The code above produces the following chart:

I look forward to seeing this project improve.

• Generics
• Iterators
• Anonymous Methods
• Partial Classes
• Nullable Types
• Static Classes
• Property and Indexer Accesability Changes

C# 3.0 brought us:

• LINQ
• Automatic Properties
• Object and Collection Initializers
• Lambda Expressions
• Extension Methods
• Anonymous Types
• Local Variable Type Inference

And that is just the new language features in the last 3 years! This does not include all of the new classes added to the BCL over the same time period.

Know the Cost

I am as excited about these new changes as the next guy. I have used various combinations of these improvements in my projects with great success. But is there a cost to new features?

Recently I read a couple of articles that reminded me that you not only have to understand how a feature is used, you also have to understand the cost of using it. Sometimes that cost is performance, other times it could be something like readability or portability. I’ll take one example from the 2.0 framework and then one from the 3.5 framework to show that you need to understand the implications of using new features.

Yield Return

First, there is Fritz Onion’s recent post on the amount of code generated by the yield return syntax introduced in C# 2.0:

The array allocation function generated a total of 20 lines of IL, but the yield return function, if you included all of the IL instructions for the IEnumerable class generation as well was over 100! That’s a 5x penalty in code generation to save 18 characters of typing

So is the 5x penalty ever worth it? Yes, of course it is. There are things you can do with yield that you couldn’t do previously. In most cases, the use of yield improves readability dramatically. It also makes the task of creating a custom enumerator much easier.

In his article The power of yield return, Joshua Flanagan points to an example where using the yield return improved performance dramatically:

With the improved implementation that took advantage of the yield keyword, the program was able to finish its job in less than half the time! It also used much less memory, as it never had to store all 9 strings in a collection. Now imagine the potential impact if GetCombinations returned a collection with thousands of entries!

The point here is that you have to know the costs and how they fit in with the requirements of the project you are working on. If you are building something that must support thousands of concurrent users and must be very performant, you will most likely choose to use the yield return despite the extra code generated by the compiler.

LINQ is Dead, Long Live LINQ

Most of the time when I show somebody the new language enhancements in C# 3.0, the thing that interests them the most (and rightly so) is LINQ. It is just so different to see query syntax built right into the language. The next question they usually ask is how the performance of something written using LINQ would compare the same procedure written using just C# 2.0 control structures.

Steve Hebert recently wrote a post about LINQ performance where he concludes:

Despite my best efforts I just couldn’t make my hand-written code perform as poorly as Linq

What? Seriously? Wow. Then I guess we should stay away from LINQ then right? Well, if you look closer at his post, you will notice that he has optimized his non LINQ version of the code a little bit for the underlying data structure where LINQ has to be able to operate regardless of the underlying data structure. I am not so much interested in the particulars so much as I am the idea that you should understand these things before you start replacing all of your for loops with LINQ queries.

Shifting Sands

One more recent post that fits in here. Rob Conery wrote about his recent experience where his 5 year old code has come back to haunt him:

I spose the moral of the story is to always view the concept of maintenance with an eye towards shifting toolsets and platforms. In 4 years you will need to support the ASP.NET 2.0 site you’re on now, using Visual Studio 2012 and it’s Silverlight-generated Scaffolds .

This is a great reminder of how tough it can be to deal with changes in technology. I mean, come on, he couldn’t find a machine to compile his 5 year old code?!? I know we can all relate. With the technology learning curve growing at a semi exponential way, just imagine where that same code will be in another 5 years.

Back to Machine Code

Obviously I am not advocating that we just give up on new features because they might not be as fast or resource efficient as our hand coded machine code. In fact, I think we need to embrace abstractions wherever possible. They make our jobs as software developers much easier. Just be smart about it. Have some idea what is going on behind the covers. It is important to realize that yield return eventually becomes a bunch of compiler generated code and that LINQ queries are general case and they may not always be as great as manually doing the coding yourself.

Maybe the documentation on these new language features could do a better job at explaining what sorts of considerations we need to take into account when using them in our applications.

• I work at Microsoft
• I love the Yahoo User Interface Library

So today’s big news that Microsoft has offered to buy Yahoo! for 44.6 billion dollars speaks to both of these facts about me. This is obviously big news for both Yahoo! and Microsoft and many people have their different takes on whether or not it is a good idea or not. I just want to say that I am feeling like my secret love affair with YUI is somehow more justified after hearing this news.

Now if I build sites using the YUI CSS library, or work on YUI.Net, I can be comforted by the fact that I wasn’t the first one to think of Microsoft + Yahoo! being a happy combination.

By the way, I realize that I haven’t added any new code to the YUI.Net controls in a long time. I am working on a roadmap of how to move forward and would love any feedback from people who have used the controls.

public enum Action
{
    Run = 2,
    Walk = 4,
    Crawl = 8
}

and then some code to do something with that enum:

static void Main(string[] args)
{
    Console.WriteLine((Action)2);
    Console.WriteLine((Action)4);
    Console.WriteLine((Action)8);
    Console.WriteLine((Action)10);
}

What do you think will happen here? Will it even compile?

When I saw this code snippet I said to myself, “the first three lines look ok but the last line won’t work because 10 isn’t a valid value for this enum. Well, I was wrong. This program actually outputs:

Run
Walk
Crawl
10

Huh?!? How could this be? 10 isn’t a valid value according to my enum definition!

This Should Never Happen…Right?

Ok, lets try something different. How about a method?

public static void Execute(Action action)
{
    switch (action)
    {
        case Action.Run:
            Console.WriteLine("Running");
            break;
        case Action.Walk:
            Console.WriteLine("Walking");
            break;
        case Action.Crawl:
            Console.WriteLine("Crawling");
            break;
        default:
            Console.WriteLine("This will never happen! {0}", action);
            break;
    }
}

Surely you can’t pass anything into this method other than one of the 3 values defined in my enum. So lets run some code:

static void Main(string[] args)
{
    Execute(Action.Run);
    Execute(Action.Walk);
    Execute((Action)55);
}

What do you think this does? Well, it outputs:

Running
Walking
This will never happen! 55

Just about this time you must be thinking: “This has to be a bug!”. Well, it is not. It is by design. here is the excerpt from the C# design spec:

14.5 Enum values and operations

Each enum type defines a distinct type; an explicit enumeration conversion (Section 6.2.2) is required to convert between an enum type and an integral type, or between two enum types. The set of values that an enum type can take on is not limited by its enum members. In particular, any value of the underlying type of an enum can be cast to the enum type, and is a distinct valid value of that enum type.

Wow, that is not at all what I expected when it comes to limiting the possible values of enums. So what are enums good for then? Are they just for code readability? Between this little revelation and my previous hack to associate string values to enums, I am loosing faith in enums.

Can You Handle it?

So what is the best way to check for this in your methods? Should you throw an exception if you receive an enum value you were not expecting? Should you just ignore it? Well, lets see what the .Net base class libraries do.

First, lets start with the System.IO.File class. What happens if I run the following code?

File.Open(@"C:\temp\test.txt", (FileMode)500);

Well, it throws a System.ArgumentOutOfRangeException with the message “Enum value was out of legal range.”. Ok, makes sense – I did pass in something out of range.

Lets try reflection. What does the following code snippet output?

PropertyInfo[] info = typeof(StringBuilder).GetProperties((BindingFlags)303);
Console.WriteLine(info.Length);

Well, it just outputs ’0′ which means in this case it is just being ignored and an empty array is returned.

What about System.String? Lets try this code snippet:

"TestString".Equals("TESTSTRING", (StringComparison)245);

Well, it turns out this throws an exception but instead of being a System.ArgumentOutOfRangeException like System.IO did, it throws a System.ArgumentException with the message “The string comparison type passed in is currently not supported.” Ok, so this is kind of the same but still a little inconsistent if you ask me.

Is Anything Safe These Days?

So what is a developer to do? Obviously you need to be aware of this when you are receiving enum types from publicly facing code. It seems there is no clear guidance on this that I can find. The C# design spec explains the behavior but doesn’t really give any guidance on why or how this should be handled. So the only other place to turn for guidance is one of my favorite .Net books Framework Design Guidelines by Brad Abrams and Krzysztof Cwalina. On their section on enums, I can’t find any guidance on how to handle out of range enum values. I do, however, find guidance that we should be using enums:

DO use an enum to strongly type parameters, properties, and return values that represent sets of values

They also suggest that enums should be favored over static constants:

DO favor using an enum over static constants

And Jeffrey Richter (and while I am pointing out my favorite .Net books, I have to add Mr. Richter’s book CLR via C# which contains priceless information on the CLR that you can’t find anywhere else) adds the following commentary:

An enum is a structure with a set of static constants. The reason to follow this guideline is because you will get some additional compiler and reflection support if you define an enum versus manually defining a structure with static constants.

So I guess we do continue to use enums and just know that we can’t always trust their values to be valid. Do you think the C# design spec should be amended to include a recommended behavior for out of range enum values? Perhaps Brad and Krzysztof can include something in their second edition of Framework Design Guidelines.

One thing that I don’t see emphasized much is trying to associated string values with enums. For example, what if you want to have a Drop Down list that you can choose from a list of values (which are backed by an enum)? Lets start with a test enum:

public enum States
{
    California,
    NewMexico,
    NewYork,
    SouthCarolina,
    Tennessee,
    Washington
}

So if you made a drop down list out of this enum, using the ToString() method, you would get a drop down that looks like this:

While most people will understand this, it should really be displayed like this:

“But enums can’t have spaces in C#!” you say. Well, I like to use the System.ComponentModel.DescriptionAttribute to add a more friendly description to the enum values. The example enum can be rewritten like this:

public enum States
{
    California,
    [Description("New Mexico")]
    NewMexico,
    [Description("New York")]
    NewYork,
    [Description("South Carolina")]
    SouthCarolina,
    Tennessee,
    Washington
}

Notice that I do not put descriptions on items where the ToString() version of that item displays just fine.

How Do We Get To the Description?

Good question! Well, using reflection of course! Here is what the code looks like:

public static string GetEnumDescription(Enum value)
{
    FieldInfo fi = value.GetType().GetField(value.ToString());

    DescriptionAttribute[] attributes =
        (DescriptionAttribute[])fi.GetCustomAttributes(
        typeof(DescriptionAttribute),
        false);

    if (attributes != null &&
        attributes.Length > 0)
        return attributes[0].Description;
    else
        return value.ToString();
}

This method first looks for the presence of a DescriptionAttribute and if it doesn’t find one, it just returns the ToString() of the value passed in. So

GetEnumDescription(States.NewMexico);

returns the string “New Mexico”.

A Free Bonus: How to Enumerate Enums

Ok, so now we know how to get the string value of an enum. But as a free bonus, I also have a helper method that allows you to enumerate all the values of a given enum. This will allow you to easily create a drop down list based on an enum. Here is the code for that method:

public static IEnumerable<T> EnumToList<T>()
{
    Type enumType = typeof(T);

    // Can't use generic type constraints on value types,
    // so have to do check like this
    if (enumType.BaseType != typeof(Enum))
        throw new ArgumentException("T must be of type System.Enum");

    Array enumValArray = Enum.GetValues(enumType);
    List<T> enumValList = new List<T>(enumValArray.Length);

    foreach (int val in enumValArray)
    {
        enumValList.Add((T)Enum.Parse(enumType, val.ToString()));
    }

    return enumValList;
}

As you can see, the code for either of these methods isn’t too complicated. But used in conjunction, they can be really useful. Here is an example of how we would create the drop down list pictured above based on our enum:

DropDownList stateDropDown = new DropDownList();
foreach (States state in EnumToList<States>())
{
    stateDropDown.Items.Add(GetEnumDescription(state));
}

Pretty simple huh? I hope you find this as useful as I do.

One More Example

There is one more scenario that I often find myself needing to associate string values with enums – when dealing with legacy constant string based system. Lets say you have a library that has the following method:

public void ExecuteAction(int value, string actionType)
{
    if (actionType == "DELETE")
        Delete();
    else if (actionType == "UPDATE")
        Update();
}

(I tried to make this look as legacy as I could for a contrived example). What happens if somebody passes in “MyEvilAction” as a value for actionType? Well, whenever I see hard coded strings, that is a code smell that could possibly point to the use of enums instead. But sometimes you don’t have control over legacy code and you have to deal with it. So you could make an enum which looks like this:

public enum ActionType
{
    [Description("DELETE")]
    Delete,
    [Description("UPDATE")]
    Update
}

(I know, I know, this is a very contrived example) Then you could call the ExecuteAction Method like this:

ExecuteAction(5, GetEnumDescription(ActionType.Delete));

This at least makes the code more readable and may also make it more consistent and secure.

public string Name
{
    get
    {
        object o = ViewState["Name"];
        return o == null ? String.Empty : (string)o;
    }
    set { ViewState["Name"] = value; }
}

Basically, you just want a property (in this case a string named “Name”) and you want to store it in ViewState. And when the value is being retrieved, if it is not in ViewState, you want to retrieve some default value. This is a pattern that I repeat over and over in my controls. So I made a code snippet to make it easier.

I use the shortcut ‘webprop’

and it expands like this:

To install, you just need to place the .snippet file (link to download below) in your ‘My Snippets’ folder which in windows vista is located at:

C:\Users\<UserName>\Documents\Visual Studio 2005\Code Snippets\Visual C#\My Code Snippets

or if you use Visual Studio 2008:

C:\Users\<UserName>\Documents\Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets

I hope this is helpful. It saves me a bunch of time.

You can download the .snipped file here

http://www.istartedsomething.com/20080109/ultimate-extras-inactive-reminder/

I really respect the way that he states the facts and doesn’t resort to anger. I also love how he has suggestions for possible extras that are very realistic. It is a good practice to always suggest a solution whenever you point out a problem.

The Man Himself

If you look at the comments for my previous post, you will notice the first comment is from none other than the founder, CEO and Chief Geek at SmugMug – Don MacAskill. I love it when leaders of companies care enough about their company that they are willing to step up and participate in the conversation about their company on the Internet. There are a couple of things Don said in his comment that I think explain exactly why I even wrote the first post in the first place:

I’m so glad you spoke up about it rather than just shrugging and going somewhere else

It is usually way easier to just shrug something off. In fact, I was ready to do that and just buy my friend a Flickr account as a gift. But, my wife was persistent about at least seeing the Smugmug thing through and I figured I wasn’t the only one who had experienced this problem. This is a key point for users of any software: If you are confused about something or are experiencing any type of difficulty, chances are you are not alone. It is too easy for users to blame themselves.

without feedback like this, we’d never improve, so I’m glad to hear it.

Smugmug is obviously a company that wants to improve their product any way they can. One reason why I love Don’s stance on this issue so much, is that I now how hard it is to accept feedback on something you feel so passionate about. Smugmug is a family owned business that Don MacAskill started with his father and he could have just have easily been defensive or taken feedback personally. You’d be surprised how many CEOs react like that. And don’t get me started on developers being defensive about their code. Feedback is good. Wouldn’t your rather hear what your actual users think rather than just guessing what they must think?

Above and Beyond

Well, in the end I was able to give the gift of Smugmug as well as receive a gift because the folks at Smugmug decided to give me and my friend free accounts as a way to show how much they care about any difficulty I have experienced. That is more then I would have ever wanted to come out of this situation. They didn’t have to do that. But they did. And that is why they have renewed my faith in how much they care about their customers.

On Trial

So I signed up for a trial account with Smugmug and just browsed around to get a general feel for the site. I really like the site and they have a done a wonderful job of making it easy to perform most of the common tasks that a photo sharing site should enable you to do.

I talked it over with my wife and we both agreed that Flickr is more techy while Smugmug is more family friendly. Since we wanted a site which would allow our friends to share baby photos with their family, Smugmug seemed like a really good choice.

A Snafu

So I searched around the Smugmug site and finally found a page where you can “give the gift of Smugmug” so I decided I would go ahead with that. One problem though, when I reached the gifting page, I was greeted with a blank page. Hmmm. That’s strange. Maybe it is my browser. So I tried it in Firefox. Same thing. Try it for yourself, here is the Url:

https://www.smugmug.com/gift.mg

Then, I remembered that Smugmug is a family owned business and they boast that they have really personal and friendly support. So I wrote those wonderful humans at help@smugmug.com.

Warm, but not very helpful

I wrote support and explained that I was getting a blank page in both browsers when trying to give the gift of Smugmug. I received a response a couple of days* later that basically consisted of the usual support response: Clear your browser cache, delete all of your cookies, and restart your computer. Ok, that is to be expected. It seems that in technical support you have to start with the most basic things first. I knew it wouldn’t help but I decided to try it anyway. Well, it didn’t help. I was still getting a blank page.

*Update: After going back and checking the timestamps on the emails with Smugmug support, the response actually came the next day and from then on out they responded to all of my emails within a couple of hours except for my very last message to them which was never responded to.

Next, I tried it at a different computer (from work) and again, in both browsers. Same results. So I replied to support and told them this and asked if they had any other ideas. The response I received really puzzled me:

Thanks for contacting SmugMug. To give the ‘Gift of SmugMug’ you must
have a current / active account with us and have credit card information
in the control panel of your account. Check to make sure you have
updates your account billing information.

Well, I guess I don’t mind giving them my credit card information since I will need to be paying for this gift. So I went to my user settings on Smugmug and went to update my credit card information. Well, in order to enter credit card information, I must sign up for my own Smugmug account and pay for it. Ok, so let me get this straight. To give somebody else a gift, I must fist purchase an account for myself? But I am perfectly happy with my Flickr account and I don’t need to pay another fee for a site I may or may not use.

In A Tight Spot

So now here I am, three days after Christmas and I still have not been able to purchase a Christmas gift for my friends. My first reaction was to just back out and give them a Flickr account. But my wife insisted we get them a Smugmug account – it is prettier. So what do I do? At this point I don’t feel like I am getting much help from Smugmug. I am trying to give them money and they won’t take it.

Why Blank?

Ok, so maybe they haven’t really set up a way for non-members to give others gifts. Maybe this is even a business rule they decided to enforce on their web site. But why not explain this on the page rather than just giving me nothing? Here is what the code for that page must look like:

if(User.IsPayingCustomer)
{
     DisplayGiftForm();
}
else
{
     DisplayBlankPage();
}

Makes no sense to me. I must be missing something.

Jeff Atwood published his post Sorting for Humans : Natural Sort Order

Ian Griffiths responds with post entitled Natural Sorting in C#

Charles Petzold responds with Sorting Without Spaces

Dare Obasanjo responds with his post Natural Sort in IronPython vs. C# 2.0

Now these are some pretty big names to have both reading your blog and responding on their own blog. And according to technorati, there are 9 blog reactions to Jeff’s post. That is pretty impressive. That makes Jeff Atwood a very influential blogger in my book.

If this were my timeline, it would look more like this:

Luke published his post on Asp.Net Control For Google Charts

Luke’s Mom emails him and says, "I read your new blog post and I didn’t understand a word you said but great job!"

Luke’s Wife calls him and says, "Your Mom really likes your new blog post."

Trackback spam responds to Luke’s post: "Want to buy some ViAGra?"

This will copy the full path of the file you select to the clipboard. This is very handy for pasting file paths into a command prompt window. Why this option is so hidden, I don’t know.

I hope this saves you some time.

ASP.NET 3.5 Extensions preview

For those of you who haven’t been following the development of this framework:

ASP.NET MVC is an architecture that enables you to easily maintain separation of concerns in your applications, as well as facilitate clean testing and test driven development.

You can read some great articles on Scott Guthrie’s blog and Rob Conery’s blog.

I definitely plan on checking it out and posting my thoughts and feedback.

Here is the official description:

The Google Chart API is an extremely simple tool that lets you easily create a chart from some data and embed it in a webpage. You embed the data and formatting parameters in an HTTP request, and Google returns a PNG image of the chart. Many types of chart are supported, and by making the request into an image tag you can simply include the chart in a webpage.

A Weekend Coding Project

I really enjoy building custom Asp.Net web controls so I decided to try my hand at creating a control to wrap the Google chart functionality. Now, this is really just a first pass so it is definitely not bug free or feature complete. I just figure I can put it out there and get some feedback to see if I should continue in the same direction or to see if I am way off. Also, I can use this as an opportunity to share a little about how I approach web control design.

Note: I realize that I am not the first or only one to get the idea to create a Google chart Asp.Net control, but since my approach is so different, I figured I would go ahead and submit my own.

So Many Classes

Maybe I am a little too obsessive or just set in my ways, but it always seems like when I set out to tackle a problem like this, there is a set of helper/utility classes that I prefer to use. Over time this creates a sticky situation because I have so many copies of the same or similar classes laying around it becomes a maintenance nightmare. I have considered just creating my own utility assembly but then people would have to deploy that with any solution that they use my code in. I prefer to release my code as a self contained assembly whenever possible so I guess I will just put up with it for now.

Here is a quick list of the classes I used on this project:

I use ColorHelper to translate System.Drawing.Color objects to and from their hexadecimal string counterparts. EnumHelper contains methods for getting Description attributes associated to enums as well as some parsing methods similar to these. I have written about DelimitedList and the state managed classes before. I make heavy use of QueryStringHelper to build the query string which represents the chart data.

Heavy on the Declarative Syntax

I have approached this problem by trying to represent the entire chart declaratively right in the aspx code. Here is an example of a line chart:

<web:Chart ID="chart" runat="server" Width="300px" Height="150px"
    Title="Transportation" Type="Line" EnableLegend="true">
    <DataSets>
        <web:DataSet Color="ForestGreen" Label="Cars">
            <web:DataPoint Value="5" />
            <web:DataPoint Value="9" />
            <web:DataPoint Value="21" />
            <web:DataPoint Value="30" Marker="Arrow" />
            <web:DataPoint Value="25" />
            <web:DataPoint Value="36" />
        </web:DataSet>
        <web:DataSet Color="Red" Label="Trucks">
            <web:DataPoint Value="7" />
            <web:DataPoint Value="3" />
            <web:DataPoint Value="13" />
            <web:DataPoint Value="13" />
            <web:DataPoint Value="16" />
            <web:DataPoint Value="25" />
        </web:DataSet>
        <web:DataSet Color="Orange" Label="Motorcycles">
            <web:DataPoint Value="18" />
            <web:DataPoint Value="25" />
            <web:DataPoint Value="18" />
            <web:DataPoint Value="13" />
            <web:DataPoint Value="25" />
            <web:DataPoint Value="23" />
        </web:DataSet>
    </DataSets>
</web:Chart>

As you can see, a chart with any sizable amount of data can become very cumbersome. The output of this chart looks like this:

The url used to generate this chart looks like this:

http://chart.apis.google.com/chart?chd=t:5,9,21,30,25,36|7,3,13,13,16,25|18,25,18,13,25,23

&cht=lc&chs=300×150&chco=228b22,ff0000,ffa500
&chm=a,000000,0,3,10&chtt=Transportation&chdl=Cars|Trucks|Motorcycles

You can change the type of chart being generated through the Type property. Here is an example of a bar chart:

A Venn Diagram:

Pie Chart:

Feedback Please

What I really need right now is some feedback. Do you find this helpful at all? Is my design way off? What would be the ideal way to build charts using the Google Api?

Please – download the library, try it out. Download the source and check it out. Post comments letting me know what you think.

Also, let me know if you would like me to write more about the details of the code or the usage of the control.

Source: Google Chart Source Assembly: Google Chart Assembly

When you first type the word (which is case sensitive)

Then you put your mouse over the little blip and you get:

Then you click and you get the menu:

My point is that this is all a very disruptive if you just want to quickly add the using tag and keep moving. I should mention, that there is a default keyboard binding to show the smart tag menu which is Alt+Shift+F10. Personally I can never remember this short cut.

So what is the tip already?

What I like to do is to bind this shortcut to a more intuitive Alt+Down Arrow. This way I just hold down the alt button and pressing down makes sense that the menu would show.

To set this binding you must open up the Tools->Options menu in Visual Studio and go to the ‘Keyboard’ tab. In the commands box, type in ‘View.ShowSmartTag’ and you will see the command show up in the list:

Then, put your cursor in the Shortcut key box and press Alt+The Down Arrow. Click assign and OK and you are all good to go.

Now to add a using statement, you just have to type the class name, type Alt+Down Arrow, and press enter. Not very disruptive at all. This may seem small but I find this to be extremely useful in my day to day development.

I am very excited about this opportunity to grow and work in an area that is outside of my usual expertise. Just in case you are not clear about exactly what and SDET does or if you had some of the same misconceptions I did, here are a couple of posts from jobsblog to clear things up:

• SDET/Testers – Behind the Myths
• Are you a good enough developer to be a Microsoft SDET?

I am not sure what this move will mean for the future content of this blog. I plan on keeping up with all things .Net even though I will be taking a new journey into the land of unmanaged code.

I know I am late to the party when it comes to checking out ruby. I just don’t really have alot of opportunity to use it outside of my free time. I finally decided to answer the call of Scott Hanselman and try it out. Just like Perl made working with text files and regular expressions really simple, ruby (and more specifically, rails), seems to do that for web development. I plan on spending alot more time looking into ruby/rails but I just wanted to share my initial thoughts.

I can remember doing things like:

open(FILE) or die "cant open file";

in perl and when I see:

Time.now - 2.weeks

in ruby it takes me back to those days.

I was just recently talking to a recruiter who was looking for Perl developers. I was really surprised that new startups are actually choosing technologies like Perl when things like ruby on rails exist.

Some Background

Here is a situation I ran into recently: I have an Asp.Net Ajax service (.asmx) which has a method used to create rows in a database similiar to:

[WebMethod]
public int CreateItem(string description, double value)

This method basically created a row in the database and returns the id of the item created. It is called from javascript like this:

function MyButtonClicked() {
    MyNamespace.Service.CreateItem("My Item", 5.3, OnSucceeded, OnFailed);
}

function OnSucceeded(result, userContext, methodName) {
}

function OnFailed(error, userContext, methodName) {
}

If you are not familiar with calling Ajax web services from javascript, you can read more from the Calling Web Services from Client Script in ASP.NET AJAX article on asp.net. Basically, I am just calling my CreateItem method (which is part of a .asmx service) from javascript – how this magic happens isn’t really too important to understand the problem I was facing.

Notice that the last two parameters I passed into my CreateItem call in javascript are references to callback methods that should be called in the event that my call succeeded or failed. A successful call will end up calling back my OnSucceeded method which has 3 parameters:

• result – this contains any values returned from my method. In this case it will be the id of the item that was inserted.
• userContext – this is an optional item that can be passed into the original call to the method and will just be passed on to the callback method. I am not using this parameter in this situation
• methodName – this is the name of the method that was called which resulted in the OnSucceeded method being called. In my case, this will be the string “CreateItem”

Now for the Problem

Ok, now with all that background I can actually spell out the problem I had to solve. In many cases, I make calls to the CreateItem method many times in a row. So if I need to create three items in the database, I may do something like this in javascript:

MyNamespace.Service.CreateItem("My first Item", 1, OnSucceeded, OnFailed);
MyNamespace.Service.CreateItem("My second Item", 2, OnSucceeded, OnFailed);
MyNamespace.Service.CreateItem("My third Item", 3, OnSucceeded, OnFailed);

Notice that all three calls have the same callback on success. Now lets say I want to create these three items and then as soon as all three calls are completed successfully I want to forward the user to another page. At first you may think I can just do something like this:

function OnSucceeded(result, userContext, methodName) {
    if (methodName == "CreateItem") {
        window.location = "NextPage.aspx";
    }
}

This would forward the user to a new page as soon as our call to CreateItem has completed successfully. There is one huge problem though: how do we know which call to CreateItem succeeded? The first one? The Second one? The third one?

Obviously we only want to forward the user in the case that our final call has succeeded. As you can see, this problem only gets worse if we have other calls on the same page that could be pending at the time we want to forward the user to the next page.

My Solution – Count Your Calls

So here is how I solved the problem: I made a variable which I would use to keep track of how many pending calls there were at any given time. At the top of my javascript page I first declare:

var pendingCalls = 0;

Then, each time I make a call, I increment the counter:

++pendingCalls;
MyNamespace.Service.CreateItem("My first Item", 1, OnSucceeded, OnFailed);
++pendingCalls;
MyNamespace.Service.CreateItem("My second Item", 2, OnSucceeded, OnFailed);
++pendingCalls;
MyNamespace.Service.CreateItem("My third Item", 3, OnSucceeded, OnFailed);

Then I need to make sure I decrement the counter each time a call succeeds or fails:

function OnSucceeded(result, userContext, methodName) {
    --pendingCalls;
}

function OnFailed(error, userContext, methodName) {
    --pendingCalls;
}

This way, we know how many pending calls we have at any given time. Then to forward the user to a new page once all calls are completed, I did the following:

function OnSucceeded(result, userContext, methodName) {
    --pendingCalls;
    if (methodName == "CreateItem" && pendingCalls == 0) {
        window.location = "NextPage.aspx";
    }
}

As you can see, asynchronous programming can be very difficult. Has anybody else had to solve this problem? If so, how did you do it?

<asp:TextBox ID="myTextBox" runat="server" />

can cause the TextBox to be rendered as:

<input name="ctl00$ContentPlaceHolder1$myTextBox"
    type="text" id="ctl00_ContentPlaceHolder1_myTextBox" />

if the page uses a MasterPage or any moderately complex control hierarchy. Asp.Net does this to minimize naming conflicts. This is the whole concept of a Naming Container. Asp.Net uses the interface INamingContainer to mark controls that can be rendered inside of a naming container. The end result is a really long id that can change based on the items place in the control hierarchy. This is a problem if you want to use the elements rendered by server controls in your client side javascript code.

First, the Hack

One technique for getting around this I have seen, has a definite bad code smell to it. You basically have Asp.Net render the itemsID inside your javascript code using the <% %> syntax like so:

<script type="text/javascript">
    var myValue = document.getElementById('<%= myTextBox.ClientID %>');
</script>

this will render as

<script type="text/javascript">
    var myValue = document.getElementById('ctl00_ContentPlaceHolder1_myTextBox');
</script>

This technique has a couple of huge short commings:

• It is really hard to maintain
• It doesn’t support having your javascript in a library or a separte .js file

JQuery to the Rescue…sort of

There are many javascript client libraries out there that help ease the headache of writing javascript code that works across browsers. I am currently working on a project where we have decided to use JQuery which I am very impressed with.

One of the main features of using the JQuery library, is its use of selectors to find elements on the page. I will not get that deeply into this rich DOM querying language here, but you can read all about it from the JQuery Documentation.

JQuery selectors allow me to find items in the page many different ways. For example, I can find the textbox in my example above using the following code:

var myTextBox = $("input:text");

This will actually find every textbox on the page but since we have only on textbox on our page, it works. Alternatively, you can use something like the Css class of the item. Suppose we gave the textbox a css class of ‘textInput’:

<asp:TextBox ID="myTextBox" runat="server" CssClass="textInput" />

Now, the control renders as

<input name="ctl00$ContentPlaceHolder1$myTextBox"
    type="text" id="ctl00_ContentPlaceHolder1_myTextBox"
    class="textInput" />

so we can use JQuery to select just this item using the following javascript

var myTextBox = $("input:text[@class=textInput]");

or

var myTextBox = $("input.textInput");

or even simpler

var myTextBox = $(".textInput");

There are many ways to select the same item, but you get the idea.

So does this solve our problem with long IDs? No, not really, we would still have to use the following javascript to select this item by id:

var myTextBox = $("#ctl00_ContentPlaceHolder1_myTextBox");

The Solution

As I was working through this problem in my head, I remembered somethign about javascript: it is more than just the attributes that already exist in DOM elements. You are not restricted to just using ID or Class. So why not just come up with your own attribute to use just for the purpose of selecting DOM elements? So here is a pretty workable solution I came up with:

<asp:TextBox ID="myTextBox" runat="server" ClientSelector="myTextBox" />

I just use a made up attribute called ‘ClientSelector’ (you can use whatever you fancy and it renders like this:

<input name="ctl00$ContentPlaceHolder1$myTextBox" type="text"
    id="ctl00_ContentPlaceHolder1_myTextBox"
    ClientSelector="myTextBox" />

so now we can use JQuery to select the item with this statement

var myTextBox = $("input[@ClientSelector=myTextBox]");

So now we can use the same selector for just this one textbox no matter if it is in a MasterPage or not. We don’t have to care how the id renders anymore. I have found this technique very useful. What do you think? Is this also too much of a hack?

Lately I have been writing a lot of code utilizing the Microsoft Ajax framework. This means that I am writing “Ajax Services” to handle my asynchronous callbacks. Ajax Services is a term I heard from Rob Bagby which emphasizes the fact that while these services are generally in a .asmx file and the methods are decorated with the [WebMethod] attribute, they are not really web services. They are a special form of service made just for Ajax callbacks. This additional file has got me thinking lately about how I can organize the files in my web site so that it doesn’t get too cluttered.

Let me start off by saying that this post is just a diary of my thoughts and I don’t really think I have found the best solution yet. That is why I am putting this out there to see how others are approaching this situation.

Too Many Files

In extreme cases, I can have four different separate files (6 if you count the code behind file) for just one page. Typically, you have one javascript file and one css file per website but I have found this to just be too cumbersome lately. I find that my css and js files just become too cluttered and hard to maintain. So I end up with:

• .asmx – Contains the WebMethods for my ajax callbacks
• .aspx – Contains the layout for my page in typically Asp.Net fasion
• .css – Contains the style definitions for the page layout
• .js – Contains the javascript methods which typically respond to events on my page and make callbacks to my ajax services.

So now lets look at a folder on the website which has 3 different pages – a very typical scenario.

This layout quickly becomes unwieldy in its own way. All of the sudden your solution explorer view of your site becomes very hard to navigate and it becomes difficult to maintain the references to all those files. Now if I have a very simple page which has no need for any ajax callbacks or custom css mixed in there, It sort of gets lost in the shuffle

See how your eye can easily miss the ‘MyPage2-Simple.aspx’ page?

A Better Way?

Another idea I had was to have one folder per page which would look like:

This is a little better but it is still cluttered. Just for completeness, lets look at our site with only one js, css, and asmx file.

While this definitely looks a lot cleaner, it also has a code smell of it’s own. Imagine what our common files (js, css, asmx) must look like. They have the code from 3 separate pages all thrown in together.

The last idea I will throw out there is to put each file type in its own folder.

I also like this better than most but it breaks down pretty quickly when you have your web site organized into many folders. Do you keep the script, service, and style files in the root folders or do you have a Script, Services, and Style folder for each sub folder?

Like I said earlier, I haven’t really found a solution that I think is best. Currently, I am trying to organize my project by having each action in its own folder and within these folders I put all the extra files (style, script, or callbacks).

How do you organize your web sites? How do you non Asp.Net people organize yours?

So go ahead. Do it. Click on the link. And then come back in an hour or so and read the rest of this post if you can stop trying to remember your uncles third cousins middle name.

I have shared this site with several people and they all have the same reaction – they immediately start adding all of the family members they can think of and they usually get 20 or 30 people deep before they stop. What is it about Geni that is so addictive? Well I think there are several things:

• It is extremely easy to start
• The main interface is graphical and immediately makes sense.
• Collaboration is encouraged
• Users are encouraged to contribute
• It is applicable to a wide array of users

Easy to Start

When you first visit Geni, the interface is just inviting you to start inputting information just to see what happens. I don’t want to repeat too much of what Jeff said in his post, but when it is this easy to start (and you aren’t asked for tons of irrelevent information up front) I think users are much more likely to sign up. In addition to being easy, the initialy start page is does not force you to do something that you don’t want to do. It is not saying, “you must enter all of the data we are asking you for or you may not enter!”

Graphical Interface

Just the fact that Geni is a family tree application who’s main interface is actually a tree, makes it much more comfortable to use. Contrast this with another recent family tree application Family.Show which displays the information in a tree, but you have to edit and view most information in a pane on the right side of the window.

Collaboration Is Key

The killer feature of Geni is the fact that it is family tree meets social networking. Anybody in your family can log on and add/edit information. This allows people to work on part of the tree that they are most familiar with. Also, there are other fun myspace like features like friends lists (people not in your family), picture sharing, and leaving messages. It is also extremely easy to invite somebody. Anytime you enter somebody’s email address, it allows you to invite them. This will send them an automated email inviting them to join Geni. While this feature is not totally new and innovative, it is usually a one click operation which makes you just that more likely to invite people.

Don’t Underestimate the Power of Competition

Do you have a little rivalry in your family? Geni allows you to use that competitive streak for good. The most obvious way it does this is by posting tree awards. Once my family members see this screen, they immediately want to be #1. This is such a great way to get people to participate. If they just add a couple of more people or upload some more pictures they can move up in the rankings. Not only is there competition between people in the same tree, I have found that there is a little game between me and friends to see who can get the most people in their tree. Just so you know, I think I am currently in the lead in this department.

I guess this also just proves my addiction since I have added the vast majority of the 207 people currently in my tree.

Even my Grandma can use it

Do you ever get tired of people using your mom or your grandma as the typical uninitiated computer user? Me too. I hear the phrase “This is so easy that my Grandma can use it!” Well, with Geni this is true from a UI perspective but I am talking about something better than than. Not only can Grandma use it, but she would really want to! Since family is such a unifying theme, having an application that taps into that is just brilliant. I have yet to have showed Geni to a family member who didn’t have an immediate interest.

Is Your Application Addictive?

The crazy thing about collaboration on the web today is that so many factors can contribute to the success or addictiveness of your application. It is not just a nice interface (see myspace), and it is not just purely usefulness. Users have to connect with your application and feel welcomed. They don’t want to have to think too hard and to conform to the restrictions of the apps they are using.

I mainly worked on boring enterprise business applications, does this apply to me? Absolutely. Just because somebody is using an app on the intranet and they have no choice on whether or not to use your app or not, it does not mean you should not think about how to make their experience with that app the best it can possibly be. Can you make data entry or running reports fun? I think so.

What other addictive applications / user interfaces can you think of?

I just recently finished the book Smart and Gets Things Done: Joel Spolsky’s Concise Guide to Finding the Best Technical Talent. Joel Spolsky is the author of the very popular blog Joel On Software and owner of Fog Creek Software. This is another one of those books that is very unique when it comes to technical writing. It is both entertaining and informative. I don’t really think there is any other book like this out there. It is a fresh perspective on hiring technical talent written from the perspective of a developer who has been through the process of finding great talent.

The thesis of the book is that if you want to be successful in software, you have to hire the best developers and they will in turn develop the best software. The problem is, hiring the best developers is not an easy task as they never really tend to be looking for a job. The title comes from the basic description of what makes a great developer: Someone show is smart and gets things done.

Joel makes many assertions in this book that many companies don’t want to hear. Treat your software developers right. Buy them nice equipment. Give them private offices (gasp!). Apparently Joel practices what he preaches because nobody has ever quit their job from his company Fog Creak Software! That is amazing. That is the kind of company I want to work for.

Even if you are not a recruiter or heavily involved in hiring technical workers, this book still has plenty of value to you. If you are a developer, you can get a very good feeling for how good you are (are you smart and get things done?) and how to measure a company’s commitment to getting the best developers and making the best software.

There are a couple of points made in this book that I found very interesting and had never thought about before. First, the fact that the best developers are not really in it for the money – they just want to be taken care of by the company they work for. This is not really obvious to most companies who are hiring developers. Just look at how most startups try to attract talent.

The other interesting point was that what a company actually does makes a big difference to most developers. They want to work on something fun that they believe in. I wonder what effect this has on the quality of software that is not fun? How do you convince somebody to come write software for your cow manure processing plant?

This book is definitely worth the hour or two that it takes to read through it. Joel has a great writing style that is both engaging and informative.

I know I am probably late to the game but I have just completed reading through Don’t Make Me Think by Steve Krug. I have recently become very interested in learning more about what I can do as a developer to improve the user experience of the apps I write. The thing is, I am not and will never be much of a graphic designer or even a pro interaction designer. I do, however, think it is very important that I at least understand what it takes to be part of these disciplines.

Practice What You Preach

I would have written a shorter letter, but I did not have the time.

There are so many things that I loved about this book but the main one is the fact that it really tries to follow its own advice. It is a book about good design and making things simple and it does exactly that with a simple layout and clear narrative. This may seem like a small thing but it most definitely is not. Making things very clear and concise is much more difficult than just writing and rambling. This book was designed to be read in a single airplane ride so it is fairly light weight. But this does not mean that the content is not deep.

It sounds like writing the second edition of this book was an exercise in usability testing and paring down to the bare minimum. Mr. Krug took his readers suggestions and comments about the first edition and took them to heart. As a result, there were chapters that were taken out in the transition for the good of the book. This is really a remarkable move by the author. Usually authors are trying to add more and more content to their books to sell more copies. Don’t feel left out if you don’t buy the first edition because the missing chapters are available online.

Worth Its Weight In Gold

To me, the chapter on how to do usability testing for cheap is worth more than the price of the entire book. Krug spells out a very simple and clear way in which you can do usability testing on your own for about $600 or less. I have already brought this up in my company and received approval to go forward with some testing. I am really excited about getting real fresh input on some of our web sites.

One thing I Didn’t Like

I felt that the numerous footnotes in this book really distracted from the message of the book. I found myself constantly looking at the bottom of a page to read a footnote and losing my train of thought. Or, sometime I would reach the end of a page and see that there were footnotes on that page so I would go back and find the reference that I had missed. Again, this just distracted from the flow of the book. In many cases, the footnotes were just little jokes that could have been interjected into the text. I understand that the book is meant to be witty and easy to read, but many of the “jokes” just got in the way.

So go out now and buy this book. And let me know what you think and how you plan to apply it to your work.

For me, this was a weekend of just trying new things and just hoping for the best. And I must say that it was a success. What do I mean by new things? Well, those of you who know me realize that I don’t usually put myself in social situations where I have to meet new people or make small talk on purpose. This means at the last code camp I attended, I just went to sessions and enjoyed the content – but I didn’t really bother to talk to anybody really. Well, this time I decided to try my hand at stepping out so I decided to volunteer to help out. This gave me opportunity to meet tons of cool people.

Here is a list of my favorite sessions:

• Ask a Recruiter - Chuck Middendorf and Marie Watkins – This was just a casual time of question and answer. Chuck and Marie had very useful advice to share when it comes to resumes and recruiting.
• Calling Web Services with ASP.NET AJAX - Rob Bagby - You can really tell that Rob knows his stuff when it comes to asp.net ajax. I really like the new term he coined – Ajax Service. It captures perfectly that the fact that an .asmx file in Asp.Net ajax doesn’t have to speak soap, it defaults to the lighter weight JSON/Restful type service.
• Building a Claims-Based Security Model with WCF - Michele Leroux Bustamante - I make sure I attend Michele’s talks when I can because they are guaranteed to be extremely informative and helpful.
• SQL Querying Tips & Tricks - Richard Campbell - This was my first time seeing Richard speak and I was really amazed at what a great speaker he is. You can just tell that Richard is extremely knowledgeable about so many topics that you can’t help be in awe.
• The Scaling Habits of ASP.NET Applications - Richard Campbell - Again, an amazing session which I can immediately apply at my job.

My personal goal is to be a presenter at next years code camp. Now I just have to find a topic and the right T shirt to wear.

User Interface Enhancements

I am not going to gush about all the cool little “flashy” things that were added to the Vista UI. In fact, I find most of them pretty useless. But there are a couple of small things which I really like and find that they add value. An obvious one is the ability to search the start menu. I love being able to open up programs without having to ever use my mouse. I do not, however, include the entire searching feature that is built into Vista in my list of good features. In fact, the search seems to be pretty much useless every time I use it so I am slowly learning to avoid it.

I also really like how the file path displayed at the top of Windows Explorer can be used as a clickable bread crumb for navigation. I use this feature all of the time.

The last small UI enhancement that I find a lot of value in is the new menu that pops up when you use Alt+Tab. I was a big fan of TaskSwitchXp as a replacement for the Alt+Tab menu in Xp and I find it even better when useful features like this are just built into the operating system.

IIS7 – Finally Multiple Web Sites

As a web developer using Windows XP, I found it very limiting to be able to only have one web site under IIS. I know that there were ways around this limitation, but I found them to be very cumbersome. So then I moved to Windows Server 2003 as my development machines OS, but this always felt like a step backwards. I was giving up many things I liked in XP just to have multiple web site. Well, this problem is fixed with the inclusion of IIS7 in Windows Vista. Multiple web sites is not the only feature I love about IIS7 – I also love the new management interface and the integration with .Net.

I am sure there are other small things that I have grown used to in Vista that I just can’t recall, but I think I have covered the major ones (kind of small list huh?)

Do I Feel More Secure?

I know there is a lot of discussion about how users (even developers) should never run as Administrator just to do every day tasks. I even agree with a lot of the arguments. Developers running as administrators just seems to propagate the problem because they develop software which requires admin access. So am I just a lazy developer who doesn’t want to go through the trouble of dealing with less than administrator access? I don’t think I am.

Rather than tackle this whole subject at once, I think I will just focus on my development experience using Visual Studio 2005 to develop web applications on Vista. So you want to access we web site in a Visual Studio project via IIS? Well then you better remember to right click on the visual studio short cut when you launch it and choose ‘Run as Administrator’. Otherwise, you get this:

So I guess if I want to work with websites I have to remember to always remember to run VS as administrator? This is just one more thing to make my life harder.

Here is another problem I run into all of the time - Drag and drop. For some reason, somebody decided that it would not be secure to drag something from a program that is not running as administrator to one that is. So I remember to open visual studio as Administrator so I can work with web sites but then I want to drag some files onto it to open them, I get this:

I can’t even take a bunch of items and drag them onto solution explorer to add them to my project. I have to use the “Add existing item” dialog to add each folder of items separately. So basically I have sacrificed usability for security. But is it more secure? How was dragging and dropping a security hazard for me in the past? It wasn’t.

I was going to include a discussion about problems I have debugging web sites using visual studio due to even more security constraints, but then I noticed that Scott Guthrie announced a hot fix for this problem. Hopefully this fixes my problem

Can I please Move Files?

There is one last usability thing that I want to discuss – the process of moving or copying files. I know many people have already expressed outrage about the speed of copying and moving files. I have more of a problem with the dialog boxes used in copying. Scott Hanselman has expressed grief about the Network Diagnostics dialog box. My problems with the move files dialogs are very much the same. Omar Shahine has also talked about the file dialogs in the past. So here is the scenario – I want to take a bunch of files and folders and move them over to a server while replacing what is there. In Xp, this was just a matter of doing a copy and paste (or a drag drop) and then clicking a “Yes to All” button when you were prompted to replace. In Vista you get two different dialog boxes. First one for folders:

So since I want to replace everything, I have to click the checkbox at the bottom and then click ’Yes’. But then I am prompted with another dialog for files:  

Now I have to again, click the checkbox at the bottom, but now the UI is different from the last dialog. Instead of clicking yes, I must choose one of the three huge button choices: “Move and replace”, “Don’t Move”, or “Move, but keep both files”. This confuses my brain because it is different than the last dialog. And why does there have to be two separate dialogs? Can’t they just warn me once?

I also like Jan Miksovsky’s thoughts on the replace file dialog.

Just let me do what I want

So my overall feeling as a developer using vista is I am trapped. I have to walk around with shackles. Am I just a walking security hazard? I think that if the powers that be want me to be running as a regular user, the tools need to support it much better than they do. UAC is not the answer. More warnings and dialogs is never the answer. More restrictions do not really improve security in my opinion – it just alienates users.

The solution that I am currently considering is to have the users just edit Xml directly. The users in this case are very capable and can adapt pretty well to new ideas. Here are is my current list of pros and cons:

Pros

• Easily Validated
• Fairly easy to read, understand and write
• Possible intellisense with the right editor
• Easy to program against
• Lends itself well to heirarichal data

Cons

• Very verbose
• Another language for users to learn
• No consumer level editor

So with the above lists, Xml is not looking like too bad of a choice. Did I miss any pros or cons?

I have also been looking for a good Xml editor that the people can use to author the documents with. My first idea was the Microsoft Xml Notepad. Maybe I am missing something but that tool seems very awkward and hard to use, not to mention the fact that you have to edit an xml file as if it were a tree. Then, I thought of SharpDevelop - a free, open source, .Net IDE that has a pretty decent Xml editor (I still think visual studio 2005 is the best I have used). I downloaded it and tried out SharpDevelop and it seems to work very well. It would fit the bill for this project because it is free and lightweight.

So what do you think – Is hand writing Xml too much to ask of the average user?

As part of my ongoing series covering the Yui.Net library (an asp.net wrapper for the Yahoo User Interface Library), today I will cover a fairly simple but useful component – the ToolTip. This component is exactly what you would expect it to be – a ToolTip which you can associate with any element on the page. The nice thing about the YUI ToolTip is that it can contain html code, can be styled via css and it can have animations applied to it.

Lets start with a simple example – a div with a basic tool tip. As with all Yui.Net controls, you must first include the YahooScriptManager on your page:

<yui:YahooScriptManager ID="manager" runat="server" />

Next, we’ll just place a simple div:

<div id="content">Just a simple div</div>

then we can place our ToolTip control on the page:

<yui:Tooltip ID="toolTip" runat="server" ContextID="content" Text="This is a simple tooltip!" />

this will cause a simle tooltip popup when you place your mouse over the div. Lets take a look at the code that is generated by these controls. First, there are the necessary script tags managed by the YahooScriptManager:

<script src="http://yui.yahooapis.com/2.2.2/build/yahoo-dom-event/yahoo-dom-event.js" type="text/javascript"></script>

then there is the javascript initialization of the tooltip object:

var toolTip = new  YAHOO.widget.Tooltip("toolTip", {
    visible: false, constraintoviewport: true, iframe : false,
    context: "content", text: "This is a simple tooltip!"} );

That is all that is really needed for a basic tooltip. Now, lets add a fade animation so that the ToolTip will fade in an out nicely:

<yui:Tooltip ID="toolTip" runat="server" ContextID="content" Text="This is a simple tooltip!">
    <Animations>
        <yui:Animation Type="Fade" Duration="3" />
    </Animations>
</yui:Tooltip>

This will cause an extra script reference to be generated by the YahooScriptManager:

<script src="http://yui.yahooapis.com/2.2.2/build/animation/animation-min.js" type="text/javascript"></script>

Whenever possible the YahooScriptManager will only include the references needed for the needed functionality so the animation library is only included if a control on the current page will need animation. Actually, it is not the YahooScriptManager that makes this decision but it is the controls themselves. Now the generated javascript looks like:

var toolTip = new  YAHOO.widget.Tooltip("toolTip",
    { visible: false, effect:
    {effect:YAHOO.widget.ContainerEffect.FADE,duration:0.3},
    constraintoviewport: true, iframe : false, context: "content",
    text: "This is a simple tooltip!"} );

That is about all you really need to know about the ToolTip control to get started. Pretty standard really. Next up I will cover the FloatPanel control and some new features I am building into the YUI.Net library for dealing with javascript events.

All of this talk about Asp.Net being a leaky abstraction and having an overly complicated page lifecycle, I have been considering looking at some alternatives to see what all the fuss is about. I am one of those developers who has taken the time to learn a lot about the page lifecycle and am fairly comfortable with it. I don’t think this means that I should get too comfortable. I have to agree that the current model doesn’t really promote good design and separation of concerns like it should. So here is my “alternative to Asp.net” list:

• MonoRail
• StructureMap
• ActiveRecord
• NHibernate (I know this doesn’t really have to go along with the above)

Language Of The Year

I am also very interested in the trend to learn a new programming language every year. Many people have decided to choose one of the new cool languages like Ruby or Boo.  I was considering following suite until I watched this video over at YUI Theater. I realized that I have been using javascript on and off for over 8 years and I have never really stopped to learn it. So I have decided to make javascript my language for the year. Like many server side, compiled language programmers, I have never like javascript. Now that the tools for developing and debugging in javascript are improving I have decided to give it a fair shake. Visual Studio 2008 will even have intellisense for javascript! (how did this feature take this long to come about?) I think I will start my javascript journey by focusing in on javascript librarires – starting with Asp.Net Ajax and the Yahoo User Interface Library.

.Net 3.5

Lastly, there are is the huge learning opportunity that is .Net 3.5 which will become more mainstream with the release of Visual Studio 2008. I have already ready a couple of books on WPF and WCF but I also want to add:

• Linq
• Workflow
• Cardspace
• Silverlight

That should keep me busy for a while. The hard part for me is not so much in the learning but in finding ways which I can apply new things to my work while still fitting in with the applications/frameworks we currently have deployed.

Well, the other day I received a free licence for Codesmith 4.0 professional so I decided to use it on a project I am working on. After spending a couple of days with the product there are many features which I feel are missing or need some improvement. Some of them seem so glaring that I plan on following up with support to make sure I understand the functionality and the documentation correctly. It is also possible that the scenarios that Codesmith is meant to target are just not what I am trying to use it for. It seems that Codesmith is very well suited for walking through database structures and generating stored procedures or some sort of custom data layer, but that is not really what I want to use it for.

Background

First I want to explain what I am attempting to use code generation for. Basically, I am generating an asp.net website based on configuration in a database. I already have a separate app that is used to input the configuration parameters and now I am trying to use Codesmith templates to generate the website. So here is the basic structure of my project:

I have created a base class for all the templates which includes some properties and functionality that will be common to all the code templates in this project. I created this class in Visual Studio and so it is in a re-usable dll. I also have other classes in this assembly which are used to hold common configuration parameters and such.

I plan on making three template files (.cst) for each aspx page I am generating. One for the code behind(.cs), one for the markup (.aspx), and one “master” template that will call the other two templates.

In the end, I will be writing my own client which will use the Codesmith API to run the templates and generate the website.

Visual Studio Integration

With visual studio integration being a feature, I assumed that this would allow you to view, edit, and run your code templates inside of Visual Studio. I was expecting an experience where I can open Visual Studio, choose “New Codesmith Project” or “Add Codesmith template” to an existing project and then begin editing both the .cst file as well as the .cs code behind file. Well, the only visual studio template that is provided is a “Add Codesmith project” which simply adds a Codesmith project (.csp) to your project. This features helps you manage code generation as part of your build process. And when it comes to editing and running your code templates, they still open up in Codesmith Studio which is external to Visual Studio. This wouldn’t be so bad except the development experience in Codesmith Studio is nowhere near as nice as Visual Studio. The intellisense only seems to work part of the time, the code formatting is not very configurable, and it just feels a lot more like editing in notepad than it does a development IDE.

Reading through the feature request at the Codesmith forums lead me to believe that I am not alone in my frustrations with the Visual Studio integration. I have seen other products do a much better job of leveraging the fact that I am comfortable and much more productive in Visual Studio. Codesmith Studio should only be for developers who do not have Visual Studio.

Assembly References

As I mentioned earlier, I want to use a common assembly to hold some base and utility classes for my templates. There is one problem though, if you want to use any external assemblies, they must be in one of three places:

• The GAC
• The Visual Studio PublicAssemblies Folder
• The Codesmith Addins folder

So this basically means that I have to finish developing my external assemblies BEFORE I begin developing my code templates or I can just copy my assembly manually over to one of the folders above every time I make a new build of it. Well, that may not be so bad except for the fact that the Codesmith Studio holds on to the assembly once you use it in a template so I can’t replace it in the file system until I completely close Codesmith Studio. This is annoying to say the least.

I do not know how the Codesmith engine works under the hood, but I assume it is doing some sort of build which results in a .Net assembly or something very similar. I think it would be ideal if you could just have a Codesmith visual studio project type which would result in an assembly which could be referenced in other visual studio projects. This would really open up tons of new scenarios for sharing templates across applications as well as with the community. Having the templates in a assembly package would also make using the Codesmith API much easier. Instead of having to point the CodeTemplateCompiler to a .cst file, I would like to be able pass it an instance of a CodeTemplate class which it can then operate on.

Code Behind

I realize intellisense is probably a very hard feature to implement but whenever I use a product has it implemented but it only works sometimes, this almost makes me wish it weren’t there at all. If you can’t count on a feature, then it is more of an annoyance than a help. The code behind model seems like it is something that was just tacked on to Codesmith and is not really supported all that well. For starters, I can’t figure out how to add a .cs code behind file to the Codesmith Explorer window. If I right click, there is not “new C# file” option and if I try to rename another file to a .cs extension it complains that it is not a valid extension. The only way I have been able to add my own code behind files into the Codesmith explorer is to create a blank cs file and move it into the same folder as my template using windows explorer. Then it shows up in the Codesmith explorer. Maybe my experience as an Asp.Net developer pushes me towards the code behind model because it seems that Codesmith templates are more geared towards the inline classic asp type model of coding.

Conclusion

I hope all of this ranting makes you think I hate Codesmith. On the contrary, I think it is a pretty cool product that has a very wide variety of applications. I guess I am just spoiled by Visual Studio. I am a big believer that when you create tools for a development platform like .Net or Visual Studio, you should make things work just like they were always part of the platform. For example, if you are writing APIs, they should conform as closely as possible to the BCL standards as far as naming etc. Codesmith essentially introduces a new file type into my development arsenal: the .cst template file. Having to use these files outside of Visual studio when I am trying to integrate them with a project that is being developed inside of the Visual Studio IDE just feels wrong. I would love to hear from the Codesmith team as to what their plans are beyond version 4.0

<asp:GridView ID="grid" runat="server">
    <Columns>
        <asp:BoundField />
        <asp:ButtonField />
    </Columns>
</asp:GridView>

There is so many things going on it a control like this that just seem like magic. How are the child items persisted in ViewState? How does the control know how to parse the child items? What if the whole world were a power ranger?

StateManagedItem

I have created a couple of classes that really simplify the process of creating lists of child items. The first of which is the class StateManagedItem. This class is the base class for all the objects which you wish to use as "Child Items" (like grid view columns or list items).

In order to manage state in Asp.Net, you have to implement the IStateManager interface. This interface allows objects to participate in the process of saving and retrieving things from ViewState. In order to generalize the whole process, I needed on other method to set an item as "Dirty" so I created the following interface:

public interface IStateManagedItem : IStateManager
{
    void SetDirty();
}

So now we have the base interface for all state managed items. So here is the what the base class definition looks like:

public abstract class StateManagedItem : IStateManagedItem

This class provides it’s own ViewState for items to save their state in which essentially allows "Child Items" to save their state just like custom web controls do. To illustrate this concept, lets create an example class called Appointment which will hold information about a calendar appointment.

public class Appointment : StateManagedItem

The definition for this class is very simple. Here is how the properties are implemented:

public DateTime? Start
{
    get
    {
        object o = ViewState["Start"];
        return o == null ? null : (DateTime?)o;
    }
    set { ViewState["Start"] = value; }
}

If you are familiar with using ViewState to store web control properties, this syntax should look fairly familiar. That that is all there is to our child item.

StateManagedCollection

The next helper class is a base class for the collection of items. In our example, we need a collection of Appointments. For this purpose, I have created a StateManagedCollection<T> class which can be used to hold the child items.

public abstract class StateManagedCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IStateManager,
    IList, ICollection
    where T : class, IStateManagedItem, new()

If you are not familiar with generics and generic constraints, this is basically a list class which requires the child items to be a class (not a struct), derive from IStateManagedItem, and to have a default constructor.

So to create our list of Appointments, all we need to do is the following:

public class AppointmentCollection : StateManagedCollection<Appointment>
{
}

That is it as far as the AppointmentCollection class goes. It doesn’t require any more code.

Sample Control

So lets finish the example by creating a custom control which displays a list of Appointments. First we will derive from Composite Control:

[ParseChildren(true), PersistChildren(false)]
public class AppointmentControl : CompositeControl

Note the ParseChildren and PersistChildren attributes, these are required to tell Asp.Net how to parse the markup inbetween the start and end tags of your control. This is part of the "Magic" I mentioned earlier.

Next, make a member of the class which is an AppointmentCollection:

private AppointmentCollection appointments = null;

And a public property to access that collection:

[
    Mergable(false),
    PersistenceMode(PersistenceMode.InnerProperty),
]
public AppointmentCollection Appointments
{
    get
    {
        if (appointments == null)
        {
            appointments = new AppointmentCollection();
            if (base.IsTrackingViewState)
            {
                appointments.TrackViewState();
            }
        }
        return appointments;
    }
}

This property also must have a couple of attributes – Mergable and PersistenceMode. These basically tell Asp.Net and Visual Studio how to handle and persist this property.

To use this control, first place the proper includ directive on your page:

<%@ Register TagPrefix="web" Namespace="Web.Example.Appointment" %>

Now we can declare our control markup as:

<web:AppointmentControl id="appointmentList" runat="server">
    <Appointments>
        <web:Appointment Start="1/6/2007 8:00 AM" End="1/6/2007 11:30 AM" Description="Breakfast" />
        <web:Appointment Start="5/12/2007 9:30 AM" End="5/12/2007 9:45 AM" Description="Meeting" />
        <web:Appointment Start="5/12/2007 10:00 AM" End="5/12/2007 10:30 AM" Description="Break" />
    </Appointments>
</web:AppointmentControl>

I won’t go into the render code (you can download the source code to see all the gory details) but here is how the control renders:

You have 3 appointment(s)

• Breakfast – (01/06/2007 08:00:00 – 01/06/2007 11:30:00)
• Meeting – (05/12/2007 09:30:00 – 05/12/2007 09:45:00)
• Break – (05/12/2007 10:00:00 – 05/12/2007 10:30:00)

You can download the full source code here. Hope this helps dispell some of the "Magic" of Asp.Net controls.

Background

Here is the situation I kept finding myself in – I will use the case of a comma delimited list of items since it is the most common scenario:

I want to loop through a list of strings and build a comma delimited list. The code begins something like this:

string[] items = new string[]
{
    "Apples",
    "Oranges",
    "Pears",
    "Bannanas"
};    

StringBuilder list = new StringBuilder();       

foreach (string item in items)
{
    list.AppendFormat("{0},", item);
}       

Console.WriteLine(list.ToString());

The problem with this is it will produce the following string:

Apples,Oranges,Pears,Bannanas,

Notice that there is a trailing comma on the end. So then I end up having to explicitly remove that last comma by either not adding it on the last iteration through the loop or by removing it after the loop has completed.

DelimitedList

So I wrote a class which will help me produce such lists but without the pain of remembering if there is a comma at the end or not. Although the DelimitedList class defaults to just having a single comma as its delimited, it can actually have any string as a delimited. I have used it in the past to delimited things by pipes ‘|’ and even line breaks which can be useful when you want one item per line.

Rewriting the same code above with the delimited list would look like this:

DelimitedList<string> list = new DelimitedList<string>();       

foreach (string item in items)
{
    list.Add(item);
}     

Console.WriteLine(list.ToString());

Now this will produce the expected string:

Apples,Oranges,Pears,Bannanas

The DelimitedList can also work on any type of object (thus the use of Generics) so you can use it with types other than strings: (just for varieties sake, I will use a delimiter other than a comma)

DelimitedList<int> list = new DelimitedList<int>("+");       

for (int i = 0; i < 10; i++)
{
    list.Add(i);
}       

Console.WriteLine(list);

This will produce the following string:

0+1+2+3+4+5+6+7+8+9

You can download the complete code for the DelimitedList class here

The Basics

In order to just get a basic calendar displayed on your page, you need to include two things:

1. The YahooScriptManager

<yui:YahooScriptManager ID="manager" runat="server" />

2. The Calendar Control

<yui:Calendar id="cal" runat="server" />

On the server site, the Script manager generates the following code:

<script src="http://yui.yahooapis.com/2.2.2/build/yahoo-dom-event/yahoo-dom-event.js" type="text/javascript"></script>
<script src="http://yui.yahooapis.com/2.2.2/build/calendar/calendar-min.js" type="text/javascript"></script> 

<script type="text/javascript" media="Screen">
function SetHiddenSelectedDates(type, args, obj) {
    var txtDate1 = document.getElementById(obj.id + "_selectedDates");
    var selected = "";
    var dates = obj.getSelectedDates();
    for(var i = 0; i < dates.length; i++)
    {
        var month = dates[i].getMonth() + 1;
        var day = dates[i].getDate();
        var year = dates[i].getFullYear();
        selected = selected + month + "/" + day + "/" + year + ",";
    }
    txtDate1.value = selected.substring(0, selected.length - 1);
}
</script> 

<link href="http://yui.yahooapis.com/2.2.2/build/calendar/assets/calendar.css" rel="stylesheet" type="text/css" media="Screen" /> 

<script type="text/javascript" media="Screen">
    var cal;
    function init() {
        cal = new  YAHOO.widget.Calendar("cal", "cal_container", { pagedate: "05/2007"} ); cal.render();cal.selectEvent.subscribe(SetHiddenSelectedDates, cal, true);
    }
    YAHOO.util.Event.addListener(window, "load", init);
</script>

There are 3 things I would like to point out in this code (not necessarily in the order they appear):

First, there are the includes of the yahoo-dom-event.js and the calendar-min.js files which are hosted on the yahoo servers. YUI.Net also allows you to host the files yourself if you need access to the debug scripts or if you just prefer to store the files locally. the calendar.css file is also included which contains the default styles for the calendar control.

Second, there is the javascript initialization code in the last script block. This initializes the calendar with the default values and hooks up the event handler for the selectEvent event. This allows the calendar to store the selected dates in a hidden html field for use on the server side.

Lastly, there is the SetHiddenSelectedDates method which is responsible for taking the selected dates and storing them as a comma delimited string in a hidden html field.

The calendar control renders the following html markup:

<div id="cal_container"></div><input type="hidden" name="cal_selectedDates"></input>

This is basically just the div which will contain the calendar and the hiddent field to hold the selected dates. Notice that the name of the div is the same that is passed in to the YAHOO.widget.Calendar constructor.

Server Side Properties

public DateTime[] SelectedDates

This returns a list of dates currently selected. It achieves this by parsing through the hidden html field mentioned earlier which stores all of the selected dates in a comma delimited list. This property is read only.

public string SelectedDateString

This string maps to the ‘selected’ property of the YUI calendar configuration property. (Side note: this can get a little confusing because there is a while javascript object model which does not always map directly to the sever side .Net object model). Here is an excerpt from the YUI documentation for this property:

Sets the calendar’s selected dates. The built-in default date format is MM/DD/YYYY. Ranges are defined using MM/DD/YYYY-MM/DD/YYYY. Month/day combinations are defined using MM/DD. Any combination of these can be combined by delimiting the string with commas. For example: “12/24/2005,12/25/2005,1/18/2006-1/21/2006″

public DateTime? SelectedDate

Allows for a quick way to access the selected date for calendars which are limited to just one selection. A nullable date is used so a null can be returned if no date is selected.

public int Pages

This allows support for multiple calendars in one control which appears like:

This causes the calendar to be rendered as a YAHOO.widget.CalendarGroup rather than a YAHOO.widget.Calendar. This is an example of where I have tried to make such functionality transperant to the user.

Here is how the rest of the properties map to the YUI javascript properties:

In some cases I have renamed some properties to make them more Asp.Net like and changed thier types from numbers to enums to provide a better user experience.

As you can see, most of the power of this control comes from the javascript provided by Yahoo – which is why the YUI.Net is mostly a wrapper with some funcationlity added.

Technorati tags: YUI, Asp.Net

Not only do I like the library itself, but I really like the community around it. (althought they could use a better forum than Yahoo! groups.) Like I mentioned earlier, the documentation is top notch. There is also a blog and and a series of screencasts about the YUI.  And if that isn’t enough, will now host the files on their servers.

Recently, I was working on an Asp.Net project where we needed some of the functionality provided by the YUI container controls. Being the web control guy I am, I decided to make a control to make working with the panel controls easier.

Next, I realized I needed the calendar control as well so I wrote a web control for that as well.  The next thing I knew I started writing controls to wrap the basic functionalities in many of the YUI controls and I had a class library on my hands. I have recently cleaned the code up a little bit and decided to share it with the world.

Keep in mind that I am not really much of a javacript expert so the client side functionality of the controls is just the bare minimum. In fact, if anybody else out there has any feedback on how I implemented the javascript, please let me know.

Here is the basic class diagram for what I have so far.

The inheritence heirarchy for the panels, mostly mirrors that of the YUI. The Module and Overlay classes contain functionality used by the Menu, FloatPanel, and the Tooltip controls.

Architecture

The basic architecture is that each control implements an interface called IYahooControl. This interface is used by the YahooScriptManager to generate the javascript needed to initialize the controls.

interface IYahooControl
{
    string LoadScript { get;}
    YahooScript[] ScriptScriptDependancies { get;}
    YahooStyleSheet[] StyleScriptDependancies { get;}
}

The script manager is a non visual control that must be placed on any page which uses any of the Yahoo controls. It bascially manages all of the script references and initilization of the client side controls.

In most cases, I have tried to match the object model of the YUI javacript classes as closely as possible.  There are however, some exceptions. I decided to make some of the properties function more like most Asp.Net controls when it made sense. For example, the YUI Button control has a property called ‘diabled’ which defaults to false but Asp.Net tends to use ‘Enabled’ and defaults it to true. Most of these changes should be fairly small.

I have tried to wrap most of the panel controls into one class called FloatPanel. This control can be set to draggable and resizable which will change the actual YUI class which implements this functionality automatically.

Helper Classes

There are several classes which I consider just general utility classes which I included in the project just so I can use them in the control. I will do a seperate post in the future going through some of those classes and why I feel they are essential.

Server Side Functionality

Since the YUI controls are client side controls, they don’t really have any inherant server side functionality. I have not yet made much effort to add this functionality yet. The only exceptio is the calendar control. I added a SelectedDates property which you can use on the server side to see which dates are selected. I implemented this by added a hidden field to the form and storing the selected dates in it on the client side.  This allows me to access that on the server side when the form is posted.

Future Plans

The biggest weakness of the controls I have build so far is they don’t really provide an easy way to plug into the rich YUI eventing model. I have not yet decided how I am going to approach this so any feedback is definitely welcome. I have put the code up on CodePlex so hopefully I can generate some interest and get some other developers to contribute to the project. There is another project on CodePlex related to the YUI controls which included both the Grid and the TreeView (which I have not yet implemented). I plan on taking a look at how are two libraries can possibly work together

Documentation

I would really like to follow in the tradition of the YUI and provide good documentation but that will have to wait until a future release.

        public static Point GetMousePosition(Visual relativeTo)
        {
            Win32Point mouse = new Win32Point();
            GetCursorPos(ref mouse);

            System.Windows.Interop.HwndSource presentationSource =
                (System.Windows.Interop.HwndSource)PresentationSource.FromVisual(relativeTo);

            ScreenToClient(presentationSource.Handle, ref mouse);

            GeneralTransform transform = relativeTo.TransformToAncestor(presentationSource.RootVisual);

            Point offset = transform.Transform(new Point(0, 0));

            return new Point(mouse.X - offset.X, mouse.Y - offset.Y);
        }

        public static int GetIndexUnderDragCursor(ItemsControl control)
        {
            int index = -1;
            for (int i = 0; i < control.Items.Count; ++i)
            {
                if (control.ItemContainerGenerator.Status == GeneratorStatus.ContainersGenerated)
                {
                    DependencyObject item = control.ItemContainerGenerator.ContainerFromIndex(i);
                    if (IsMouseOver(item as Visual))
                    {
                        index = i;
                        break;
                    }
                }
            }
            return index;
        }

        public static bool IsMouseOver(Visual target)
        {
            if (target == null)
                return false;
            Rect bounds = VisualTreeHelper.GetDescendantBounds(target);
            Point mousePos = GetMousePosition(target);
            return bounds.Contains(mousePos);
        }

I didn’t change the GetMousePosition method at all from what I found on Lester’s blog.  Then I slightly modified some of Josh’s code so that it is a little more general.  I hope this helps.  Suggestions welcome.

http://acephalous.typepad.com/acephalous/2006/11/measuring_the_s.html

I was relieved to find that the main feed at codebetter.com is different. Since I subscribed to their main feed, I find almost all of the posts to be at least interesting if not very helpful and applicable. Why is this?  I really don’t know.  Maybe they are focused on a smaller number of good authors.  The posts range from jmiller’s short, quick, and entertaining posts (CodingLaw! and There are two types of developers in the world) to longer, more involved posts (A Wrapper Class for Spring .NET’s Inversion of Control-Dependency Injection and Creating-an-Ad-Publishing-Application).

Browse the topics covered on this site and let me know what you think!

I read through the first part of the book pretty quickly.  I would read 2 or 3 chapters while not in front of a computer and then I would find a computer and type in and run most of the samples. I thought it was important to type in the samples myself instead of just using the sample code you download from the Microsoft Press companion website so I could get used to coding in the Visual Studio Cider environment. I found this technique to be very effective in recognizing common mistakes and errors and learning how to fix them.

The pace of my reading slowed down significantly somewhere around Chapter 11: Single Child Elements or Chapter 12: Custom Panels.  Not that the subject matter wasn’t interesting, I just found it very difficult to visualize without being around a computer to try out the samples. I just kept pressing though anyway with the intention of reading those chapters slower on my second pass through of the book (yes, I intend to read the entire book twice).

Chapter 18: The Notepad Clone was also very difficult to read.  This sort of “Tying it all together” chapter is required in most programming books so I don’t blame the author for the excess of code in this chapter.

The Xaml portion of the book starts in Chapter 19. Once I reached this point, the book became a page turner. There are so many WPF mysteries that are being revealed I can’t even keep track of all of them. I found the information on Resources, Data Binding, Styles, and Templates to be fascinating.  This, in my opinion, is where the real power of WPF is revealed. I have so many things I want to try using the techniques found in these sections that I am not sure when I will find the time. After I finish this book for the first time, I am going to write down all of my ideas so I can keep them in mind during my second reading. Stay tuned.

Well, after 5 days with no email I did finally gain access to my email.  So how did my email get fixed? Did the people at Netidentity find the problem and fix it system wide? no. Did one of my emails or calls to support get my problem escalated to a priority and they fixed it? no.  Did I spend days and days reading though the blog of one of their employees and all of the angry comments only to discover that I could post my email address there to get it fixed?  Yup.

I am pretty sure that if I had not found the blog and read through it to figure out that netidentity was paying more attention to users problems if they post their information directly on the blog, I would still be without email. I can’t even imagine how this must be for the typical customer who does not read blogs or search alternative means for reaching customer service but instead just sits and waits for netidentity to fix their email.

So everything is fine now right?  Wrong.  My email worked for a couple of days and now I am getting an error message “An error occurred while reading your settings. Please contact your system administrator.” when I try to access my web mail.

This is ridiculous. I guess it is time to abandon this service and search for a new one. I really wish they didn’t own the domain name of my last name.  I guess I will change my last name to zlkdjfaowiejfadsjf and purchase the domain name right away.

Mailbank was sold and the company became Netidenty.  Their prices have continued to increase (I now pay like $50/year) but I stuck with the service.  I think in the back of my mind I always hoped they would give up on the business model of mass buying tons of domain names and give up the less profitable ones.  Since there have never been more than 2 users that I know of on the Foust.com domain, I figured there may be a chance that one day I could buy the domain.

In any event, the company was recently sold to Tuscows and they decided to upgrade their web mail interface.  This is a fairly popular action for email services to make so I didn’t think much of it.  Well, my mailbox got corrupted during the migration and now I have been without my personal email for 3 days.  This has been a migration gone bad to say the least.  I have placed an email and a call into support with no response.  The only real message I get is that there are thousands of people with the same problem as me.  Not really much of a consolation for any single person left without email for days on end when they could have settled with another email service for free.

The closest thing to customer service I have seen, are a couple of blog posts by a senior product manager.  This has helped as far as information goes, but it doesn’t really make me, a loyal customer, very satisfied.  It makes me especially angry when I read the following:

Mailbox index corruption. I have been informed that this problem has been solved. We were able to ascertain that the indexes of roughly 2500 accounts had been corrupted. Once all of the accounts were identified, it was relatively easy to fix the issue. This means that no one should be stuck on the pending migration page.

This is absolutely not true for me and for many others according to the comments of Ross’ blog post. You can tell a lot about a company by how they respond to crisis and I have to say that Netidentity has failed in almost every way.  It will be interesting to see how this whole thing shakes out.

Here is my advice to Tuscows (the new owner of Netidenty), stop raising prices and keep the service simple and reliable.

Petzold’s book is not the first book I have read on the Windows Presentation Foundation - I have also read Chris Sells’ Programming Windows Presentation Foundation which I would say was OK but not great.

Since it will probably take me a couple of weeks to work my way through Petzold’s book, I will just blog about my thoughts along the way.

First off, I love the idea of using just code and no XAML during the first half of the book.  This really drives home the idea that you should understand what XAML eventually translates to in code. In order to truly understand a technology like WPF, you have to start from the very basics and work your way up. It is such a new programming paradigm in so many ways that somebody who has experience with Asp.Net or Windows Forms programming will not necessarily be able to transfer all of their UI knowledge to WPF that easily.

I do, however, have some immediate gripes with the book (albeit small ones).  I definitely echo the sentiments found on some of the Amazon.com reviews regarding screenshots. I immediately noticed this books lack of any screenshots or diagrams.  On one hand, this goes with the whole learning from scratch thing and I can see how the author may be using this as a way to encourage the readers to try out the examples for themselves. I just think that a book on a presentation technology could really benefit from pictures to really drive home the point.

Another very small gripe I have is also echoed on amazon.com: the fact that every code example in the book has 3 lines of code that are not necessary – The copyright notice.

//-------------------------------------------
// ProgramName.cs (c) 2006 by Charles Petzold
//-------------------------------------------

I could see including these in the downloaded example code, but to print them in the book is just redundant and really adds up as far as space.  Hundreds of examples * 3 lines of code = many extra pages in the book.

I am sure I will have many more good to say about this book in the long run than bad as I really enjoy Petzold’s writing style and he is definitely very knowledgeable.

public static void RecurseControls(ControlCollection controls, FindControlDelegate callback)
{
    foreach (Control c in controls)
    {
        callback(c);
        if (c.Controls.Count > 0)
        {
            RecurseControls(c.Controls, callback);
        }
    }
}

This basically recurses through the control tree and calls a given delegate for each control found.  Here is the delegate:

public delegate void FindControlDelegate(Control control);

To top it all off, here is the method I wrote to find all of the controls of a given type on a page:

public static List<T> FindAllControls<T>(Page page)
    where T : Control
{
    List<T> controls = new List<T>();
    RecurseControls(page.Controls, delegate(Control c)
    {
        if(c is T)
            controls.Add(c as T);
    });
    return controls;
}

I am usually not one to use cryptic programming techniques such as inline delegates, but in this case it just made sense.  Otherwise, I would have had to somehow share the object containing the list of found controls between two different methods.

So here is the thing, since the blogs are generally sorted by their alpha numeric name, I get to the ones which are named starting with A-D much sooner than the ones that start with letters later in the alphabet.

So why does this matter? Well, let me give you an example: There are at least 3 different feeds which I read which basically aggregate various stories from a round the web and report the ones they find interesting. The first one is the one and only Digg. I subscribe to the front page feed as a way to keep up with what the Digg community deems as interesting or important. The content of this feed can be both interesting and very annoying (but that is a different top altogether). The next feed is Gizmodo’s main feed. This feed consists of anything and everything having to do with gadgets. The third “catch all” feed is the main feed on Techmeme. This site just basically aggregates what is currently popular in the blogosphere. These topics tend to be mostly techy and geeky in content.

The thing is, the content of these three feeds sometimes overlaps.

So if the same story is in all three feeds, I tend to see it in Digg first and Techmeme last. Does this mean that Tecmeme is somehow delivering me old information? No, but it tends to appear that way. I have noticed that when I am looking through my blog feeds I read Digg items more closely but by the time I get to the end and I am on the Techmeme feed, I am less interested and I tend to skim more than read. Over time, this makes Digg seem more “cool” and up to date than Techmeme in my mind. Does anybody else run into this problem? I guess I should rename my blog “Aardvark’s Antics”.

So now, when I see somebody walking down the street talking on their cell phone like they would in their own living room, I can’t help but with there were an over hear in San Diego. It turns out there are a couple of other sites related to the New York one: Overheard in the Office and Overheard at the Beach. According to Wikipedia, there are other sites like this out there. Since all this data is available via rss, it can be aggregated. This idea is demonstrated on the Google Maps mashup which combines the Over Heard In New York data with Google Maps.

So I guess this is the end of me talking about my penchant for naked mole rats and Cock-a-hoop in public lest I be made fun of.

(digg)

I used to go to pretty much every Shillglen show I could make it to. I remember thinking, “Why wouldn’t I jump at any chance I get to go see great music? Who Wouldn’t?” Over time, I sort of got to know the guys in the band. I was the weird guy who came to all their shows. We would even record some of them. It didn’t seem too weird at the time – we were just having fun. In retrospect, it probably was.

Well, now Greg Laswell is out on his own and big things are starting to happen for him. He signed a record deal with Vanguard Records, he has a video on VH1, and he is even producing an album for Minnie Driver. His solo shows are very heartfelt and his songwriting is better than ever. You can check him out at his official website http://www.greglaswell.com or on myspace.

One of these days I am going to take all those Shillglen recordings I have and digitize them.

I can tell from the Xml examples I have found, that data binding is more powerful than ever. It just looks a little complicated when you have multiple ways of writing declarative data binding (verbose and shortcut).

I have just now started my journey of learning the WinFX world. I have a Windows Communication Foundation (WCF) app started but have run into troubles there as well. (I will explain that in a future blog post) So far, I am very excited about the next generation of Windows and .Net development. It will be very interesting to see what types of applications come out of these new technologies after the dust settles.

One of the big changes from Asp.Net 1.1 to 2.0 was the format of their web projects. I actually really like the new format alot. There was, however, one problem that I could not get past. I have written various “plug-in” type frameworks where you specify classes in an xml file which are loaded at runtime. The xml usually looks something like this:

Item assembly=“myAssembly“ class=“myClass“ />

so at runtime I just have to load the given assembly and then I can create an instance of the given class. The problem with the new web project format is that you don’t really have control over your web project assembly name like you used to in Asp .net 1.1. So, here ist he trick I learned:

Assembly assembly = Assembly.Load(“App_Code”);

• http://www.stuffonmycat.com
• http://www.chucknorrisfacts.com