Erik Porter's Blog

ASP.NET Web Pages Templates for VB

2011-02-09T01:09:30.457

Today, (well…yesterday, but I didn’t have time to blog about it yesterday) our team added the Visual Basic versions of the templates you can get inside of WebMatrix for ASP.NET Web Pages. These are available as NuGet packages on the NuGet Gallery site.

Along with the above 4 templates we’ve also shipped the original 4 C# templates that are included in WebMatrix as packages for those of you who might use ASP.NET Web Pages without WebMatrix.

In this release, we’ve also included a new template that doesn’t ship (yet) in WebMatrix.

WishList Template (C# only)

To run these templates, simply open an existing or create a new ASP.NET Web Pages app and navigate to (or click the “ASP.NET Web Pages Administration” link on your dashboard in WebMatrix), login to the admin, search for “template”, pick which package you want and install it. This will put the contents of the template into a folder called “Microsoft Templates” in your app root. Inside will be instructions to tell you to take the contents of that folder and move them to the root of your site. This step is unfortunate, but required since NuGet or the ASP.NET Web Pages Administration app doesn’t currently allow you to override existing files. Now run your site and you should see the template you installed.

Jim Wang, who works on our team (and built the WishList Template), made a video on how to get WishList installed in less than a minute.

We hope these are helpful to get you started with ASP.NET Web Pages! For those of you working with VB, we want to hear from you. Are these templates helpful? Anyone running ASP.NET Web Pages WITHOUT WebMatrix (or Visual Studio)?

IE 9 Windows Jump List ASP.NET Web Pages Helper

2010-09-15T20:40:15

I’m sure you’ve all heard today about the beta release of IE 9. It’s looking pretty good! Did you see that you can integrate with the Windows Jump List now? Neato! Neowin has a write up on the meta tags you need to have to integrate with Windows. Over lunch I wrote a quick helper in ASP.NET Web Pages (install WebMatrix via WebPI here) that you can just drop into your App_Code folder…

Code Snippet
using System;
 using System.Web;
 using System.Web.Mvc;
 using Microsoft.WebPages.Helpers;
 
 public static class Windows {
     public static IHtmlString JumpListTask(string name, string actionUrl, string iconUrl) {
         HttpContext httpContext = HttpContext.Current;
         
         if (httpContext.Request.Browser.Browser == "IE" && httpContext.Request.Browser.Version.StartsWith("9")) {
             if (string.IsNullOrWhiteSpace(name)) {
                 throw new ArgumentNullException("name");
             }
             if (string.IsNullOrWhiteSpace(actionUrl)) {
                 throw new ArgumentNullException("actionUrl");
             }
 
             if (string.IsNullOrWhiteSpace(iconUrl)) {
                 throw new ArgumentNullException("iconUrl");
             }
 
             if (!(actionUrl.StartsWith("http://") || actionUrl.StartsWith("https://"))) {
                 string hostUrl = httpContext.Request.Url.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped);
                 actionUrl = hostUrl + VirtualPathUtility.ToAbsolute(actionUrl);
             }
 
             TagBuilder html = new TagBuilder("meta");
             html.MergeAttribute("name", "msapplication-task");
             html.MergeAttribute("content", string.Format("name={0}; action-uri={1}; icon-uri={2}", name, actionUrl, iconUrl));
 
             return new HtmlString(html.ToString(TagRenderMode.SelfClosing));
         }
         return new HtmlString("");
     }
 }

And then call it in your page…

<!DOCTYPE html>
<html>
 <head>
 <title></title>
 @Windows.JumpListTask("Test", "~/", "fav.ico")
 </head>
 <body>
 </body>
</html>

Not much to it, but hopefully some of you will find it handy. Note: it does not render anything in browsers other than IE 9. Maybe we can clean this up and put it in the next release of ASP.NET Web Pages. :) What do you think? Do you have other ideas for helpers in ASP.NET Web Pages?

Writing Helpers in ASP.NET Web Pages (Beta)

2010-07-20T19:10:40.653

I’ve been seeing some people asking about how to write their own helpers in ASP.NET Web Pages. If you’re not familiar with ASP.NET Web Pages or Razor be sure to check out Scott Guthrie’s post announcing them. I’m the PM for them. :) You can use WebMatrix (or Notepad or any text editor of your choice) to build web apps using ASP.NET Web Pages.

First, let me overview how writing your own helper will be in the next version of ASP.NET Web Pages, then I’ll go over how you would go about writing them as of when this blog post went up.

Future @helper Usage (not in Beta)

In the next release of ASP.NET Web Pages you will be able to use our new @helper syntax to easily build new helpers. The main scenario we’re trying to cover with this is simple. Say you have a page with a little code/markup that you would like to reuse on other pages.

<!DOCTYPE html>
 <html>
   <head>
        <title>Gravatar</title>
    </head>
    <body>
        <img src="@Gravatar.GetUrl("someone@somewhere.com")" alt="Gravatar" />
    </body>
 </html>

In the next version you will be able to simply do the following:

Create a new file under App_Code in your app named Utilities.cshtml (this can be named anything)
Cut the code/markup you’d like to reuse and place it into a method in the new file and replace any hard-coded values with any incoming parameters you have in your method.
Call the new helper by the name of the file (Utilities in this example) and the name of the method

Here is what the Utilities.cshtml file would look like:

@helper GetGravatarImage(string email) {
    <img src="@Gravatar.GetUrl(email)" alt="Gravatar" />
 }

And here is what the original page would now look like using the new helper:

<!DOCTYPE html>
 <html>
   <head>
        <title>Gravatar</title>
    </head>
    <body>
        @Utilities.GetGravatarImage("someone@somewhere.com")
    </body>
 </html>

Pretty straightforward and simple. Unfortunately, we’re still working on this feature. It will be in the next release.

Writing a Helper Today in Beta

For the time being you can convert your code/markup into a static class, which is how we currently build helpers internally. Here is an example:

using System.Web;
 using Microsoft.WebPages.Helpers;
 
 public static class Utilities {
     public static IHtmlString GetGravatarImage(string email) {
         return new HtmlString("<img src=\"" + @Gravatar.GetUrl(email) + "\" alt=\"Gravatar\" />");
     }
 }

The most important thing to note here is that your method should return IHtmlString for things to get rendered properly. How you build it internally doesn’t really matter. In my simple example I just build a string and then wrap it up into a new instance of HtmlString (which is an implementation of HtmlString). One other thing to note here is that I’m importing the Microsoft.WebPages.Helpers namespace because that’s where the Gravatar helper that I’m using exists.

One other important thing to note is that while I’m building a string here because it’s such a simple solution, the better/safer way to do this is to build it using the TagBuilder, which is in MVC (and available in the Beta).

The usage for this helper would be exactly the same as the new way stated above:

<!DOCTYPE html>
 <html>
   <head>
        <title>Gravatar</title>
    </head>
    <body>
        @Utilities.GetGravatarImage("someone@somewhere.com")
    </body>
 </html>

So it’s still pretty easy to build your own, but unfortunately today you have to start learning some OOP concepts, which goes against our goal of simplicity and staying relatively procedural. Can you see why we’re working on a newer syntax to help simplify this? :)

Summary

Writing helpers isn’t too difficult but can be a lot of work if you’re trying to compartmentalize a lot of code/markup and requires you to understand more advanced concepts. In the next release of ASP.NET Web Pages you will be able to simply cut and paste your code/markup that you want to reuse into a new file and use it.

Do you like the new syntax? What sorts of helpers are you building?

Same Team, New Role at Microsoft

2010-04-19T18:19:34.817

Today is my first day as a PM (Program Manager) on the ASP.NET team. If you’ve been following any of the projects I’ve worked on at Microsoft like Oxite or Orchard, you may remember that I just joined the Orchard team as an SDE in November. Why the fast move? I’ve actually been interested in switching to the PM role for a couple years now, and the right opportunity happened to come up last week. The fun part is, I’m still on the ASP.NET team, just in a completely different role. It happened pretty fast. On my birthday (April 9th) I started talking with the team about an open position. Thursday of the next week they told me the job was mine. On Friday, I was told “you start Monday”. I am very excited to get started and ‘thrown into the fire’. I can’t say what exactly I’ll be working on just yet, but it will be fun, no doubt.

Does this mean I’m done with Orchard? Absolutely not. I love open source software at Microsoft and I think Orchard is a great project. I will continue to give feedback and contribute in any way I can and have time for.

I expect to finally get back to more blogging too. Since joining Microsoft as a developer the amount I’ve blogged has steadily declined into nothingness. Now that blogging will be one way to gather community feedback, it will definitely happen more often.

My wife and I are expecting a baby girl in June (our second child). The life changes just keep coming! Exciting times. :)

Planning for the Next Oxite Release

2009-06-22T06:46:42.77

As many of you have been pointing out, it’s been a long time since the last Oxite release. To be exact, it’s been 4 months today. :| For a piece of software, that isn’t much time at all. For a web application, that can be pretty big. We’re usually fast movers, but we made a decision a while back that we want to “go Beta” for the next release. This means that the next release should be at least halfway comparable to the feature set of other blog engines out there and that non-developers should be able to run Oxite without much work. Here are the 3 high level goals for the next release of Oxite:

Improve the admin (add missing features and improve the user experience)
Build a great plug-in model (works well for non-devs and devs alike to build small new features on top of Oxite)
Make installation easier (include Oxite in the Web App Gallery)

With those goals in mind, here’s what we’re working on and how far along we are with each so you can get an idea how much more we have to go…

Required to ship

The following are items we will not ship without and how far along we are in their development.

Plug-in Model – 90%

There’s really too much to talk about with plug-ins here, but the gist of it is that anyone can use their favorite text editor to write a few lines of code, FTP up the file to their web server and run. You can also use Oxite to edit the code file if your hoster will let you edit files through ASP.NET. We will be including a few plug-ins out of the box so you can see how to build them and we’ll also have documentation when we ship (you can see the work in progress docs here). We have already demo’d plug-ins internally to a few teams and so far the response has been great. We’re just in the process of finishing up a couple things and fixing last minute bugs.

Spam Filtering – 95%

We built a plug-in that will be included in the next release that calls out to a spam filtering service (like Akismet or TypePad AntiSpam) when new comments are added and verifies whether or not they are spam and removes any comments that are spam.

Site Setup Wizard – 15%

This feature has been designed and we’ve gone over the design with one of our new contributors who is going to handle the implementation. We want to make setting up a new Oxite instance as simple as possible so walking through the wizard, you will be asked as little as possible to get Oxite running. Afterwards, you can tweak Oxite’s settings to make it work the way you want it to.

User/Blog Management – 50%

We already have pages for adding, editing and removing users and blogs, however, we’re been doing a major overhaul to the admin area and we don’t expect these to be working at the moment. As we overhaul the admin UX we are going to make some changes to the flow of these pages anyway.

Authorization Management – 50%

We have a permission API in place already for the new release, but we don’t have any UI in the admin for it yet. Permissions are done by associating 3 things together: User, Role and Entity. To make a person an owner of a blog to do whatever they want with it, you would associate the user with the admin role to a particular blog.

MetaWeblog API Improvements – 85%

In the new release, we’ve moved the MetaWeblog implementation from WCF to using MVC controller actions. This makes future work simpler to implement and errors easier to bubble up. This work is complete, but not fully test. We will also be adding file support so you don’t have to use FTP for blog post images anymore.

Rich Text Editor – Complete (sort of)

So far, we’ve been unable to find a rich text editor that is compatible with the license of Oxite (Ms-PL) and built on jQuery. In the meantime, we’ve implemented markItUp! This will allow you to do simple formatting that most people will need. In the near future, we will also be demonstrating how you can write your own plug-in to use your favorite rich text editor instead.

Contact Page – 0%

This is sort of a no brainer that we’ve somehow overlooked in past versions of Oxite. All blogs have a contact page. Oxite will join those ranks in the new version. You know, the standard “enter your name and email and a message and I’ll send it to the site/blog owner” type of page.

Scale – 75%

Dumb caching has been implemented at the service level of Oxite. What this means is that the results of calls to the repositories are now cached after the first time they’re called. We invalidate cache by entity or entity type or sliding expiration. The current cache service is implemented using ASP.NET Web Cache. In the future, we will more than likely implement a Velocity cache service too for those who choose to use Velocity. We will also probably make the caching a bit more smart and cache entities and query results instead of just straight query results.

Random Bugs and Admin UX Enhancements – 40%

We have a gazillion bugs we’ve fixed since the last release and are continuing to fix bugs (be sure to start a discussion on CodePlex and report them when you find them). In this bucket, I am also including all of the admin work we’re doing. We’ve added some cool things like dialogs (that work both service side and client side so they’ll work on phones and modern browsers alike), lots of new management pages, new UX around adding and editing posts and pages, etc. The list goes on and on, but you’ll have to wait and see exactly what features get in the next release.

More Cleanup – 95%

We’ve done some more cleanup in this version of Oxite:

Database – Some tables have been cleaned up and reorganized to make the schema better match the data we store.
Model – All of our model classes immutable so objects can never be in an incorrect state.
Services – All add/edit/remove services have been modified to return generic result instances that include validation/model results to help keep validation in a single place.
Controllers – All controller action parameters have been converted to ENTITYInput or ENTITYAddress classes with ModelBinders to map the values appropriately, all validation has been pushed into the services and we now return ViewModels directly and have filters that convert them into the appropriate ViewResults.
Views – Many views have been cleaned up and separated better. The admin is now completely separate from the rest of the site and now renders HTML 5 instead of XHTML. Skinning the site is now simpler since the admin is not included in skinning anymore.

Optional to ship

The following are items we would like to make time for, but if they take too long, we will ship the next release without them and put them in the next release. These are ordered by priority.

Modules – 10%

We have a lot of the infrastructure in place, but have yet to fully design how modules will work in Oxite. Basically, we want to break Oxite up into pieces (like IIS 7) so it’s easy to replace and build your own major chunks of Oxite. Modules will be similar to plug-ins, but much more powerful and for those who are very familiar with .NET. If you want to build forums on top of Oxite, a module would help you accomplish that. Modules will be how you can get into the Oxite/MVC pipeline. We’re really set on getting this into this release of Oxite, but if it ends up taking too long, we will cut it for this release.

Blog Management – 60%

While Oxite does support having more than one blog running in it, we haven’t yet optimized it when you go from one to two blogs. To do this, there’s quite a bit of work involved like getting the dashboard to be aware of all blogs a user has access to, the menu needs to change in the admin, plug-ins need to have a way for site admins to specify which plug-ins are allowed to run and then blog owners need to be able to set their own settings on each plug-in that’s installed, etc. This work is high priority on the optional list, but if it doesn’t make it in, it will in the next version.

Skin Engine Enhancements – 0%

While skinning is pretty great in Oxite, we have some ideas on how to improve it further to make scenarios like building an iPhone skin or optimizing Oxite for MSNBot or Google to index your site or making your site work in IE 6 even easier and better organized than it is today. We will more than likely not get to this one for this version.

Threaded Commenting – 75%

Before we went off and implemented plug-ins we started down the path of adding threaded commenting so it’s easier to understand who is replying to who. We got the server side implementation done, but not the client side implementation and it still needs to be properly tested. Hopefully this one will make it in this release, but not making any promises.

AJAX Enhancements – 25%

We’ve done some work in the admin to make things work well client side, but still have some more we’d like to do as well as getting paging and commenting to work client side. Nice to have, but not needed to ship.

Authorization Provider Model – 0%

Our authorization in Oxite is mostly separated out into its own thing, but there is still work to be done to enable anyone to build a module for their own authentication scheme (like OpenID, Live ID, Facebook Connect, etc). This is another nice to have, but if it doesn’t make it in this version, it will be very high priority for the next version.

Exception Logging – 0%

This will make it much easier to debug problems when they come up for people, but is a nice to have and will not hold up shipping the next version if we don’t have time.

Unit Tests – 25%

For the most part, the Oxite team isn’t a TDD bunch, but we do see the importance of unit testing and will try to get more tests in there.

Post ship

After we ship the next release to CodePlex, we will be nearly immediately submitting Oxite to the Web App Gallery. This will make it so those who want to just use Oxite and not go through the code can get Oxite up and running can get Oxite in a few clicks with the Web Platform Installer. This is exciting stuff and will get Oxite out there much more than it is today.

Future

Even though we haven’t even started any development for these, I believe it’s important to understand where we’re going so we build the right things in the right priority. These are items we’re beginning to plan, but would definitely love to hear feedback and eventually get help coding.

Oxite.net

This currently redirects to http://visitmix.com/lab/oxite (our home base). http://oxite.codeplex.com is the other place most people go to. As we grow and need more features it will more than likely make sense to move the project to our own domain (oxite.net) and consolidate it all to one place (other than the source code). Luckily, this will just be a DNS change since we already point to that domain for all our stuff. This is not set in stone yet, but is our current intent. We want oxite.net to be the page everybody goes to for information about features, documentation on how Oxite works, galleries for skins and plug-ins, etc.

Forums

This one comes up often and we think it’s a good idea. Once Oxite modules are done, this becomes easier, but forums usually have a lot of features that blogs don’t (even though it’s still the same idea…post and then comment on the post).

Social

We don’t have user profile pages at all yet, nor anything like being able to add friends, etc. That’s ok for now because there isn’t much of a reason for anybody to register on an Oxite site yet. Anonymous users can comment and do just about anything an authenticated user could. In the future we’d like there to be profiles and friends and some modules I can’t talk about yet. :)

None of this really even hints at a date for the next release. That’s because we really never know when we’re going to work on Oxite. Seems to be random as we have time. We’re building momentum with Oxite. In the last few weeks we’ve added more contributors to Oxite (5 to be exact and we have 2 more joining soon). Some work for Microsoft, some don’t. We need your help to continue building a great platform. Go build something cool with Oxite and show it off. We’re listening closely for individuals who know what they’re doing, build the right things and are very interested in our “little” project. Show us your code! :)

So how do you think the next Oxite release is shaping up? Useful? Awesome? Horrible? Am I forgetting any other major features? What will you build on top of Oxite? Does it seem like something you’ll want to use?

Oxite Plugin Extensibility Points Discussion

2009-04-23T06:38:04.677

Lately, I’ve been integrating some code built by another team at Microsoft, who will for now remain unidentified until they’re ready to make themselves known. It’s a pretty cool plugins architecture that makes it super simple to build plugins. It’s not fully baked yet so I’ve been filling in some pieces as I go, but the concepts are solid. I’m still in the process of refactoring some things, but if you’d like to follow along at home, feel free to grab the latest checkin. I make no promises that everything works perfectly and the UI for installing/uninstalling/editing plugins isn’t done yet. You can actually run plugins with the latest code though.

Today, I got our team together to brainstorm about plugins in Oxite. I thought it might be handy to talk about some of the plugins we’d like to build, as well as some of the more popular plugins that have already been built for other blog engines. We came up with a nice little list of some initial extensibility points we could have in Oxite. Since I like to be pretty transparent with what we’re doing with Oxite (follow @HumanCompiler to keep up on Oxite) I tweeted about it:

Javier tweeted back pretty quickly:

That’s a great idea, Javier! Even better, I’ll share the list we’ve come up with so far AND get the community involved. I’d like to get your feedback! So here’s the list we have so far:

Events

These provide a way for plugins to be notified when something happens. One might write a plugin so when a new comment is added to a blog post, it sends a txt msg to the post author (using the CommentAdded event). Another example might be a plugin displays a “How to Use Your New Blog” page to a user who just signed up for a blog on your site (using the AreaAdded event).

AreaAdded
AreaEdited
AreaRemoved
PostAdded
PostEdited
PostRemoved
PostPublished
PostUnpublished
PostViewed
CommentAdded
CommentApproved
CommentRemoved
CommentSpamCheck
PageAdded
PageEdited
PageRemoved
PagePublished
PageUnpublished
TrackbackReceived
PingbackReceived
UserLoggedIn
UserLoggedOut
UserSearched

Processing Methods

I wasn’t sure what to call these actually. WordPress calls them Filters, but that didn’t seem totally appropriate. I’m open to names if you have any. Basically, these are methods that plugins can hook into to do processing on an Oxite entity like a Post, Comment, User, etc. One example might be a plugin that takes code blocks in all post bodies and properly formats them before being rendered by the view. Maybe a plugin that applies a time of day mod to the currently selected skin.

ProcessPostInput
ProcessPostDisplay
ProcessCommentInput
ProcessCommentDisplay
ProcessNewTag
ProcessMarkup
SelectSkin

So what do you think? Is this list a good start? Are any of these completely pointless? What others would you use in writing your own plugins? Is the naming easy to understand? What plugins would you develop if the sky was the limit? Share your thoughts. We’re listening. :)

Channel 9 Turns 5!

2009-04-06T18:13:47.777

Channel 9 turns 5 today. We've got a new skin and videos to celebrate.

Oxite.2009.2.15 Released

2009-02-20T04:30:41.477

We’ve been hard at work over the last month working to refactor Oxite. We received a lot of community feedback about how we organized the code in Oxite. I don't want to go into too much detail, but want to be completely transparent (I’m from the Channel 9 team, would you expect anything less?) about how Oxite came to be. Oxite was a side project by a couple of us that just thought it would be cool to release some of our code that was reusable, showed off the ability to control your markup 100% and was more than a sample (something people could actually ship on if they wanted to). It obviously got expanded into more than that, but just wanted to share a little behind the “how, when, who and why” of Oxite. For a more in-depth explanation, check out Duncan’s post.

Back to the community feedback, although some of it was taken a bit too far, overall the community was right and we decided it was necessary to begin a large refactor to get our code more inline with ASP.NET MVC. Sampy has a post (Part 1 and Part 2) about the architectural changes we’ve made in this release of Oxite. You should check out. He also started an Oxite Architecture page on CodePlex. I don’t think there’s a single line in Oxite that hasn’t been touched. As with all projects, we will continue to evolve it moving forward. We’ve discovered a few places where our current architecture has a few things that don’t work out perfectly. In the next release we will address some of this, but they will be much smaller changes than in this release.

What We Refactored

Besides "everything", well, we added dependency injection (much needed). We already had things like our Controllers setup for this, we just hadn't taken the final step to add it. Now that we are using it in lots of places, and things are much simpler and easier to setup now. We get the added benefit of being able to replace anything that is loaded through DI with a web.config (or code) change. You can replace everything from our Routes to Controllers to ActionFilters to Repositories. Be sure to read Sampy's post. He has a section on DI.

The model has also been cleaned up to make more sense. Before, we were using interfaces for everything to get around LINQ to SQL building it's own concrete types, but this was problematic. Now we just have our own concrete types. Unfortunately, because we can't easily manipulate LINQ to SQL with different query options before the statement is executed and still get our types back, we have to project them to our types. A little painful, but not too bad.

Another big complaint we addressed was that our Controller Actions were being used like the Page Load method in WebForms. We were brand new to MVC when we started Oxite and it was an honest mistake that I think those new to MVC will make. With the model and repositories cleaned up it and the addition of ActionFilters, we were able to get almost all of our Controller Actions shrunk down so they follow SRP.

We've also added quite a few ActionFilters that help us build up the ViewModel and fill things out for the Controller Actions for us. These are where all our code to do additional things on the page have gone like filling in the sidebar data. We also created an ActionFilter registry class that Sampy will probably explain more soon, for specifying when ActionFilters are executed.

The last major thing I can think of that we cleaned up were the Views. To be clear, what the Views produced was always very clean. What I mean is we cleaned up the code and markup in the Views to use more HtmlHelpers when appropriate. At the same time we also split more views apart and rearranged where they live to make more sense and to ensure we don't have repeated markup/code anywhere. This helps make skinning easier.

With all this refactoring, we still managed to stabilize current features, add new features and simplify deployment. The refactor was our only goal for this release, but some of us really care what features Oxite has and want to improve on it with every release. Lot’s of late nights, but well worth it. Now that we’re all also running Oxite as our blogs we will continue to find/fix bugs and add new features. Let’s go over old and new features.

Oxite Features

So we’ve got all the basics you’d expect in a blog:

Posts
Commenting
Tagging
Content pages
RSS and ATOM feeds everywhere (All up, Blog, Tag, Comment, etc)
Trackbacks (sending/receiving) and Pingbacks (receiving)
Email subscriptions
Sitemaps
Search
Metaweblog API support (use Windows Live Writer, etc to post to Oxite)
Web admin
- All up dashboard
- Manage site
- Manage areas (blogs)
- Add/Edit Posts/Pages
- Manage comments
- BlogML import

No need to go over those in detail since they're very standard these days. We also have some other features that are either unique to Oxite or are just nice to have and not necessarily in every blog engine. I'll let you be the judge which are which.

Background Services

Background services are basically classes that are wrapped by an executor that calls a Run method in a timer so it's run on a separate thread. You might be asking why a web app would need this. Most other blog engines don't do this, why Oxite? Personal preference around user experience is the short answer. The slightly longer answer is that we think it's a bad idea to hold up a page request to go off and do something intensive or dependent on a potentially long running task (like post to another website). I'll use the two background services we ship with as examples of what I mean by that: SendTrackbacks and SendMessages. SendTrackbacks is a service that simply takes any outbound trackbacks that were generated from creating or editing a post and sends them. You say, "This seems like a really simple task. Why not just have that happen when you add/edit a post?" Good question. It IS a really simple task. There's not much code in the service. However, the work done in that service can take a while and is dependent on the sites that you linked to. Submitting a new post could be infinitely held up by all those requests and only gets worse the more sites you link to (to get a response back from them). SendMessages exists for the same reasons. It's purpose is to take a generated list of emails and send them through SMTP. Again, super simple and barely any code at all, but if you have a lot of people with email subscriptions set up or your SMTP server goes down or is slow this could take a really long time. Background services move the load to the background so the user's request isn't held up.

Multiple Site Storage in Single Database

This is mostly a feature that we've found important over the years to what we do, but thought it would be helpful to others. In the web.config <appSettings> you can specify a "SiteName" that is a unique string in the database for the current application's instance name. Since all posts, content pages, blogs, etc are all scoped by that name, you can store many sites in the same database. This may or may not be useful depending on your hosting situations.

Skinning

ASP.NET MVC is perfect for skinning. We built our own little skin engine that basically just helps the view engine decide where to look for WebForms, Styles and Scripts. If you just want to create a skin just with CSS that's super simple. If you want to create a skin with CSS and override some of the default Views, that is also really simple. Check out Nathan's page on CodePlex about How to Skin Oxite.

Web Standards Compliant

From day 1 when we started building the MIX Online site we found that ASP.NET MVC was great for controlling your markup and have taken advantage of that in Oxite to ensure we are XHTML 1.0 Strict compliant as well as having our CSS, RSS and ATOM validate. Go out and compare Oxite to other blog engines and see how well or not well they validate. Take it a step further and compare Oxite to major websites out there. Fun! Beyond being compliant with web standards our markup is semantic. This is just a good thing to be overall, but can also make skinning much easier as the classes properly describe the content they are attributed to. Hats off to Nathan! Be sure to check out Web Standards: Where the ROI is by Molly Holzschlag and Web Design from the Gut by Nishant Kothary.

What's Next

Now that we've got most of the refactoring done and are more solid across the board, what's next? Lots! Our team can't devote time to working on Oxite unless it is related to one of our projects (like it was for MIX Online). It just so happens this month's work relates to Oxite for our next project so we will be making improvements. We will be creating the new Session Browser for MIX and it will be running Oxite. Out of this, the new feature we'll be adding is files. This was one of the few features we had in the first version of Oxite, but had to cut. It's coming back in the next release because we need it for the session browser. This includes being able to upload new files and associate them (or existing files at any URL) with a post. We think that's valuable in a blogging platform (and of course for us) so we'll be adding it for the next release. We will also be refactoring a few more things as we go. On a personal level here are the things we will be working on in our spare time:

Plugins

Plugins will allow a developer to build new functionality on top of Oxite and allow someone running Oxite to drag-drop-run this new functionality. Some of you may have noticed there are some plugin classes in Oxite today. These were just the start and we ran out of time to finish that feature. We will finish them off in the next release to make it super simple to tack on little pieces of functionality (everything from adding Routes, ActionFilters and Controllers to keeping track of settings for the plugin and making them installable) to Oxite.

Skin Variations

We will be adding the ability to create subfolders under a skin with addition Styles and Scripts (and potentially other subfolders for other sub-variations) to create variations of skins. These variations will "inherit" all the Styles and Scripts from its parent skin. We've found lots of skins that would look great with tweaked colors, fonts, etc. At the same time, we will also be modifying the site settings page to make selecting a skin and optionally a variation strongly typed (ex. dropdown lists).

Rich Text Editor (RTE)

Without a RTE in the web admin, it can be a bit difficult to craft your own HTML by hand. For now, we suggest you use something like Windows Live Writer to post to Oxite. Eventually we'd like to add RTE to the plugin side of things so you can decide which RTE you'd like to use. We'd also like to find an RTE that we can ship out of the box with Oxite, but it's difficult to find one with a license that agrees with MS-PL.

Trackback validation service and trackbacks display

We're currently keeping track of inbound and outbound trackbacks, but we don't currently validate that received trackbacks are valid (ex. did the site actually link to you or is this just spam), nor do we show trackbacks anywhere in the default skin. This is what we'll be implementing.

User/Role Management

This is an area we dropped the ball on with this version of Oxite. Our "authorization" model right now is basically "can you log into Oxite? Ok, then you can do whatever you want." For most this is fine since you're usually just using Oxite for a single blog. In the cases where you'd like to have more than one blogger on your site (family website, company website, etc) this is crucial to be able to set permissions to blogs and other stuff and we will be adding it back.

Content Page Management

There is currently no UI for displaying what content pages are available on your site (other than the dropdown list for picking which page is the parent of the current page you're adding/editing) so you can move/remove them. We haven't figured out if we're going to use a tree view or something else for this, but it is needed and has already been brought up in the community.

Other View Engines

We are investigating other view engines. WebForms in MVC is great, but sometimes it isn't a great fit, especially when you want a designer to work on the views. Spark is one of them that we're investigating. If anything, we will at least get back to following MVC and allowing other view engines to be registered and used.

Mobile Views

Because of our good markup that we render, viewing an Oxite site from a phone is a decent experience. It is readable. We want to do more. You should be able to control your markup without a lot of work that gets sent to phones and this is what we'll enable.

This list will take us a bit. If I had to guess I'd say 2 or 3 months to finish off that list (there will be many release in between). Keep in mind this is just as we have time (an evening here and there) and it's possible and likely that this list will change over time. I'd love to hear what features you all think are important.

Where to Get Oxite

If you’ve read this far and want to checkout Oxite, please visit Oxite on CodePlex. The latest release can be found here. Be sure to go through the Setting up Oxite page as there are dependencies to run Oxite. If you end up running it publicly somewhere, let us know and we'll add your site to our list of sites running Oxite. If you create a skin you want to share it, let us know and we'll post it up for others to find. If you have feedback for us or just want to discuss Oxite, start a discussion on CodePlex. If you think it's lame that I use the default skin for Oxite (I do and it's lame), make a hot looking skin and I'll use it for my site and give you credit!

How to Keep Up on Oxite

Many of us are on Twitter and we talk about Oxite. You can follow me on Twitter here. My blog will also be a good thing to follow as I'll be talking about Oxite as we progress. Oxite on CodePlex will also be a great place to watch since they have discussions, an issue tracker and RSS for Releases.

What Now?

I have some other "hidden" features I'm going to blog about soon, but what do you want to see blogged about next? What isn't clear in Oxite? What's hard to use? What things do you want to learn how to customize? Any other questions you have, please leave a comment and I'll address them.

My Blog Moved (to ErikPorter.com Running Oxite)

2009-02-16T19:58:27.603

Alrighty, so now that I'm dogfooding my own code it's time to get back to blogging and talking about Oxite and other stuff our team works on. Unfortunately, first I need to finish off my site. As of this writing it is running plain old vanilla Oxite with nothing changed (other than my data). I still need to add a few things like analytics, tweets to my sidebar, about page text, etc.

Once I get all of that I'll be putting up a blog post about the new version of Oxite we released last night. After that, I'll blog about some of the features we currently have that are not really documented.

My blog has moved from there to here (if you happen to be looking for my old content).

Bill Gates: Transitioning into the Future

2009-02-14T05:45:47.733

Bill Gates is leaving and Charles from Channel 9 has a great interview with Bill.

Bill Gates: Transitioning into the Future

Life at Microsoft

2009-02-14T05:45:47.263

I had the pleasure of "acting" with some fellow 'softies to create this fun video about the misconceptions that people have with Microsoft.

Life At Microsoft - The Truth Revealed

It was a lot of fun to run around with nerf guns, kick people, yell and scream. Tina, can we do it again? :)

ASP.NET AJAX BUG: $addHandler Can't Attach to Element Inside an IFrame in Internet Explorer

2009-02-14T05:45:45.673

I have an iframe on my page and an html page that's loaded in it (from the same domain) and an anchor tag is clicked in the iframe I want to execute some code on my page on the client. In the Initialize method in my client object I call $addHandler and pass in the anchor tag from inside the iframe, 'click' (to attach to the onclick of the anchor tag) and my delegate. I run the code in Firefox. Everything works great. I go to Internet Explorer and run it and when I click on the anchor tag inside of the iframe I get an error of "Sys.ArgumentNullException: Value cannot be null. Parameter name: eventObject". A quick search turned up this gem of a workaround:

Bug with $addHandler applied to element in an iFrame

I hope the ASP.NET team fixes this in future versions of ASP.NET AJAX, but for now this will work.

CES: Bill Gates Leaving Microsoft Video

2009-02-14T05:45:45.33

This is a great video that was shown at CES

Bill's Last Day: The CES Keynote video

PDC 2008

2009-02-14T05:45:45.127

http://msdn.microsoft.com/pdc2008

It's official now. See you there?!?!

Accompanying Channel 9 thread discussing it.

IE 8 Exists

2009-02-14T05:45:44.753

Yipee!

http://blogs.msdn.com/ie/archive/2007/12/05/internet-explorer-8.aspx

Ok, we all knew it existed and was being worked on, but this is the first time the IE team has talked about anything (even if there's no actual info here).

Accompanying Channel 9 thread discussing the "announcement".

Yahoo Messenger for Windows Vista (using WPF) Preview Released

2009-02-14T05:45:44.377

http://on10.net/Blogs/larry/yahoo-messenger-with-wpf-goes-live/

Just installed it and while it's not feature complete yet and there are some performance issues, overall I really like it!

It kind of makes the Windows Live Messenger team look a little stupid for letting their competition use our technology to make a better looking IM client, doesn't it? ;)

Definitely check it out!

Facebook Beacon Now Lets You Completely Opt-Out

2009-02-14T05:45:44.003

This is great to see.

http://blog.facebook.com/blog.php?post=7584397130

Nothing better in this world than a company who admits mistakes, listens to customers and makes changes when needed.

Facebook Beacon

2009-02-14T05:45:43.77

Ever wanted something more powerful than just a "Share on Facebook" link on your site, but didn't want to write an entire Facebook app? Enter Facebook Beacon. With it, you can add a few lines of code to your site and your users can share actions they did on your site like (bought a product/service, changed their profile, posted a comment, etc) to Facebook so it shows up in their news feed and then travels down the viral highway that is Facebook.

We're considering integrating Beacon into our community web platform that runs (Channel 9, Channel 10, MIX Online, Channel 8 and TechNet Edge). Do you think this would get annoying? Would you like to share what you're doing on our sites with your friends on Facebook?

FYI, we're building a Facebook app as well for our sites (and all sites involved in Microsoft Communities), but we think this also adds value too. Thoughts?

.NET Web Roadmap for 3.5 (ASP.NET, Silverlight, IIS 7)

2009-02-14T05:45:43.443

Scott Guthrie posted some fantastic info on ASP.NET Extensions 3.5 to match up with Visual Studio 2008 and .NET Framework 3.5.

http://weblogs.asp.net/scottgu/archive/2007/11/29/net-web-product-roadmap-asp-net-silverlight-iis7.aspx

Highlights:

Silverlight 1.1 is now Silverlight 2.0
Silverlight 2.0 will start to get some of the great features that WPF has
Some of the ASP.NET AJAX Futures (like the browser history control) will be moved into ASP.NET AJAX
IIS 7 will ship early next year
There will be new ways to deploy to IIS 7 and do things like versioning and rolling back on single servers and web farms

Great stuff...check it out!

Rich Text Editor on CodePlex

2009-02-14T05:45:43.147

This is really great to see. RTEs are a pain to write yourself.

http://ledgards.com/blogs/josh/archive/2007/11/12/rich-text-editor-control-on-codeplex.aspx

My only requests are that they add Opera and Safari support, XHTML support, undo and better flexibility for customizing it (like hiding the view tabs and ASP.NET Themes).

Definitely worth checking out!

Popfly - Building Mash-ups, Blocks, Pages in a Fun Community

2009-02-14T05:45:42.647

I've been following Popfly for a long time. It's come a long way (and 2 code names) to where it is today and it's good stuff! They have a cool editor in Silverlight for connecting blocks to create mash-ups, a web page editor, social networking to share your creations. If you're into the nitty gritty you can even go in and edit all the Javascript yourself. Check out the intro video on Channel 9.

Building a Silverlight 1.1 DLL with Visual Studio 2005

2009-02-14T05:45:42.21

Hotness!

http://blogs.sqlxml.org/bryantlikes/archive/2007/05/02/silverlight-hello-world-in-c-from-vs-2005.aspx

Silverlight (WAS: WPF/E) is Official

2009-02-14T05:45:41.647

The official name as well as site is now out for Silverlight, which used to be called WPF/E. Lookin' good!

SQL WHERE List Matches Any or All

2009-02-14T05:45:41.15

I saw a cool post recently from Jon Galloway called "Passing lists to SQL Server 2005 with XML Parameters". This is a pattern I've used several times while building the new version of Channel 9. If you'd like to learn how to pass in lists to stored procedures, check out Jon's post.

One of the times I've used it is to search our database for all entries from two of our forums. For this example, we'll say Techoff and Sandbox. Once you have a temp table with the two forum ids (actually forums in our system are just tags too) you can just do a where in statement like the following:

SELECT e.* FROM Entry e INNER JOIN EntryForum ef ON e.EntryID = ef.EntryID WHERE ef.ForumID IN (SELECT ForumID FROM ForumList)

Note: This is all pseudo code to represent the basics of how we do this. This is not the exact code.

This selects all the entries (or posts) from our database that are from the list of forums I passed into the ForumList temp table. WHERE IN specificies that all rows be returned that match ANY of the records in my temp table. The following statement would be equivalent and work exactly the same.

SELECT e.* FROM Entry e INNER JOIN EntryForum ef ON e.EntryID = ef.EntryID WHERE ef.ForumID = @ForumID1 OR ef.ForumID = @ForumID2

Note: In the above example, @ForumID1 and @ForumID2 have the values that were stored in the ForumList temp table in the example above that one.

This works pretty well. The other thing we do with passing in lists though is selecting only the entries that match ALL (not ANY) of the list we pass in to the stored procedure. The example of this is when searching by multiple tags. So for instance, you want to search on our site for all content that contains information on WPF AND WCF. The previous example won't work. It would instead need to be something like this...

SELECT e.* FROM Entry e INNER JOIN EntryTag et ON e.EntryID = et.EntryID WHERE et.TagID = @TagIDWPF AND et.TagID = @TagIDWCF

Using WHERE IN, we can't do this (at least I couldn't find anything in the docs or internet searching to say otherwise). Duncan helped figure out the idea on how to do this and here is the implentation I came up with:

DECLARE @TagCount int
DECLARE @Tags TABLE (TagID bigint)
DECLARE @Entries TABLE (EntryID bigint)

SELECT @TagCount = COUNT(*) FROM @Tags
;
WITH Entries(EntryID, MatchCount) AS
(
    SELECT
        e.EntryID,
        COUNT(DISTINCT t.TagID) AS MatchCount
    FROM
        Entry e
            INNER JOIN
        EntryTag et
            ON
                e.EntryID = et.EntryID
            INNER JOIN
        @Tags t
            ON
                et.TagID = t.TagID
    GROUP BY
        e.EntryID
)
INSERT INTO @Entries (EntryID) SELECT EntryID FROM Entries WHERE MatchCount = @TagCount

What is this code doing? Well, first, it's doing a count on the tags that were passed in (again, from XML turned into a temp table) and storing it in a variable. Then, it creates a Common Table Expression or CTE around a query that returns all the entries that match the tag list and how many of those tags it matches up with. If you're not familiar with CTEs, they're basically a wrapper around a query so you can write a query against it. Kind of like a subquery, but much more organized. Recursive CTEs are particularly powerful and cool, but that's another blog post. So then after creating the CTE, fill another temp table with everything from the CTE where the MatchCount equals the count of how many tags were passed in originally. This means that the entry returned had ALL the tags passed in associated with it. So this will now only return entries that match ALL of the tags from the list that I passed in (stored in @Tags). I hope this helps someone. :)

UPDATE: Check out the first comment from Bryan. He points out a slightly better implementation. Thanks, Bryan!

Best Comment on Slashdot EVER!

2009-02-14T05:45:37.217

I'm a Slashdot browser. I've never commented on anything thing and never will. Slashdot is 90% crap (mostly because of the comments left there). That's my opinion and I'm sticking to it. That said, it's good to watch what goes on there, because every once and a while there is a gem of great insight.

This isn't the kind of gem I'm referring to, but it is still a gem and TOO GOOD and TOO TRUE to pass up. My buddy Tobin pointed me to this one...

http://apple.slashdot.org/comments.pl?sid=44091&cid=4592270

I'm not a big fan of bashing people...unless they deserve it. :)

TechFest with Microsoft Research on Channel 9

2009-02-14T05:45:36.967

Rory posted a great first video taking a look at a couple new apps out of MSR.

There's going to be lots more good stuff coming soon from TechFest. To follow the happenings on Channel 9 in regards to TechFest, check out the TechFest tag.

Btw, this has to be the best preview image on any of our videos ever! ;)

Scott Guthrie on Red vs. Blue on Channel 9

2009-02-14T05:45:36.75

Pretty funny. :)

http://weblogs.asp.net/scottgu/archive/2007/03/05/video-of-scott-guthrie-shooting-private-donut-and-some-good-asp-net-ajax-links.aspx

My boss, Adam Kinney made the WPF/E skin for the video.

Direct link here.

Robert Fripp on Channel 9 Again

2009-02-14T05:45:36.42

This is really great. The way they went about making the sounds for Windows Vista is really cool. There are some really great ideas in this video like having calm music (you have to listen to the video to hear them) in the background while installing Windows Vista. It's sad that it didn't make it into the final product. Maybe they'll come out with some music from this we can buy. Check it out...

Making Windows Vista Sing: Robert Fripp and the Vista Melody

Re: ASP.NET Custom Authentication Problems

2009-02-14T05:45:35.97

I just got a comment from an old post from over 2 years ago about some custom auth problems I had. It's funny looking back that far to see how you were. As with all typical developers, I look back and laugh at myself. :)

The question posted was if I could share my custom authentication code. The fact of the matter is, the way I was doing authentication at the time was kind of silly and I thought I'd post how we do it now. It's much simpler and uses everything that's already built into ASP.NET 2.0 already. When a user logs into your site (using whatever type of authentication you want), the Context.User (same User object that shows up on the Page class, etc) is set to an IPrincipal. Depending on what "username" you passed in for it to tack on to the cookie, you'll be ablel to access a key for looking up more detailsl about the user. Then the same applies from the rest of my 2 year old post. Create a BasePage class that inherits from Page and shadow the User property with your own. Here's the code from our platform in the BasePage class.

public bool IsAuthenticated
{

get { return Request.IsAuthenticated; }
}

private string username;
public string Username
{

get

{

if (username == null)

{

if (IsAuthenticated)

username = base.User.Identity.Name;

else

username = "";

}

return username;

}
}

private bool isUserSet;
private EvNetUser user;
public new EvNetUser User
{

get

{

if (!isUserSet)

{

if (IsAuthenticated)

user = Users.Retrieve(Username);

isUserSet = true;

}

return user;

}
}

Now anywhere in our site we can say Page.User and get back an object filled with everything we need to know about the current user. If the request is anonymous, Page.User will return null. Hope this helps Mohammed!

JavaScript Intellisense in Visual Studio Orcas

2009-02-14T05:45:35.767

This is really great to see!

http://blogs.msdn.com/webdevtools/archive/2007/03/02/jscript-intellisense-in-orcas.aspx

I've been developing a lot of client controls in ASP.NET AJAX lately and this would be so helpful.

How to Use Embedded JavaScript Files in ASP.NET AJAX

2009-02-14T05:45:35.097

I'm writing up a post about creating custom client controls at the moment (well, as of a few minutes ago anyway). It is getting pretty long and it's way past my bedtime. So I thought in the meantime I'd post a quick little blurb about how you can use JavaScript from an assembly for your ASP.NET AJAX code and why you would want to.

It's pretty easy to setup a .js file in your web project with some code in it. Sometimes though the code in said file is associated with say a custom client control (something that inherits from Sys.UI.Control) that is in its own assembly (not your web project). This is how our controls are setup for our platform. This is so we can use the same controls across Channel 9, Channel 10, etc. The problem is now that we have code in js files, they have to be replicated across all our web projects and that's just no fun. So instead we moved to having the js files embedded in our main class library. The server controls register these files and they are then pulled out of the assembly and sent down to the client and cached. Here's how to set this up yourself...

Add the following line as the last line in your js file:

if (Sys != undefined) Sys.Application.notifyScriptLoaded();

This tells ASP.NET AJAX that the file is done loading. This is needed because all embedded js files stream down in the same "file" so the end of the file isn't necessarily the end of what's streamed down to the client. Unlike when you just like to a js file regularly.

Now, in Visual Studio go to the properties window while your js file is selected. Change the Build Action to Embedded Resource. This will compile the file into the assembly as a resource. If you open up reflector and venture through, you'll find the js file. Now in your server control, add this line so ASP.NET knows about the resource (and what mime type to send it down as):

[assembly: WebResource("EvNet.Web.Templates.Scripts.Toolbar.js", "text/javascript")]

Now anytime you add a ScriptReference to a ScriptManager, your file will be streamed down to the client. Just specify the resource name (This is the physical file path down to the file starting at the root of your class library with slashes replaced by periods [see below]) and the assembly the resource is in and you're done. No need to worry about where the file is anymore. :) This of course works when implementing IScriptControl.GetScriptReferences in your server control too:

public IEnumerable<ScriptReference> GetScriptReferences()
{
return new ScriptReference[] { new ScriptReference("EvNet.Web.Templates.Scripts.Toolbar.js", "EvNet") };
}

Enjoy!

Intro to ASP.NET AJAX Custom Client Controls

2009-02-14T05:45:34.8

So in my journey to explore our platform that runs Channel 9 and Channel 10 and soon a few more sites continues with a walkthrough of some basics on creating custom controls in ASP.NET AJAX. More than likely if you're reading this it's because you already know about ASP.NET AJAX 1.0 or have at least heard about it. You found this post through a search on your favorite search engine, saw it on the weblogs.asp.net home page, subscribe to my feed or someone linked to it (here's hoping). If you have no idea what it is, well...go check out the site and come back. :) That's probably the easiest way to explain it.

ASP.NET AJAX 1.0 Basics

ASP.NET AJAX has basically built on top of JavaScript to make it cross-browser compatible as a framework on top. This makes developing things like custom client controls very similar to building classes in .NET. There are namespaces, classes, enums, methods, fields, properties, inheritance, etc. There is also a server control architecture to allow you to build server controls to configure and instantiate custom client controls. I'll talk about this later. The best way to think of ASP.NET AJAX is to think of it as a client technology. Yes there are server aspects, but the server just acts as the middle man. It gets requests for pages and servers and returns the appropriate data. This is how it is today except now we can push more logic down to the client so the server doesn't have to render UI logic as much.

UpdatePanel

While this post isn't going to focus on the UpdatePanel, it's good to know about it and how it compares to custom controls. The UpdatePanel is gold. Plain and simple. Build some code on your ASP.NET page, say a GridView with some data bound to it. It works great and just does the usual postbacks. Page through some data, yippee. Now surround it with an UpdatePanel and watch the "magic". Paging now without postbacks? Glorious! Like all great things that make our lives easier, you can definitely overuse it. Working with ViewState just like a normal postback would, sending it back and forth between requests, is its greatest strength and weakness. You can still have the same problems of bloated ViewState that can make those monthly bandwidth bills for your site go up and up. The UpdatePanel is great for quick and dirty AJAX. If you have a simple form you want to make fancy, it is the right tool. A good example where the UpdatePanel probably isn't the best answer to solve your problem is showing and hiding lots of divs. Things that can easily be done through javascript should. This saves lots of server request and makes it so you don't really need any ViewState because the work will be done on the client.

Sys.UI.Control

Sys.UI.Control inherits from Sys.UI.Component. Just like any Windows application, a component in ASP.NET AJAX is a client side control that has no UI (like a timer) and a control has UI. As I mentioned above, ASP.NET AJAX helps us push UI logic off of the server and onto the client. Sys.UI.Control is a base type you can inherit from to build your control on. It takes care of all the basics like with DOM element it's associated with for its UI and has methods like initialize and dispose. Let's build a quick calculator control. Hey, it wouldn't be a typical example if it were anything else but a calculator. ;)

Have ASP.NET AJAX 1.0 installed and create a new website using the ASP.NET AJAX-Enabled Web Site template and call it Calculator.

Visual Representation

All we should need for this is two textboxes, a dropdownlist, a button and a label to display the answer in. Create a new Web User Control called Calculator.ascx.

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="Calculator.ascx.cs" Inherits="Calculator" EnableViewState="false" %>
Number 1: <asp:TextBox ID="Number1TextBox" runat="server"></asp:TextBox> 
Type: <asp:DropDownList ID="TypeDropDownList" runat="server"></asp:DropDownList> 
Number 2: <asp:TextBox ID="Number2TextBox" runat="server"></asp:TextBox> 
<asp:Button ID="CalculateButton" runat="server" Text="Calculate" />
Total: <asp:Label ID="TotalLabel" runat="server" Font-Bold="true"></asp:Label>

@ Control Language="C#" AutoEventWireup="true" CodeFile="Calculator.ascx.cs" Inherits="Calculator" EnableViewState="false" %>
Number 1: <asp:TextBox ID="Number1TextBox" runat="server"></asp:TextBox> 
Type: <asp:DropDownList ID="TypeDropDownList" runat="server"></asp:DropDownList> 
Number 2: <asp:TextBox ID="Number2TextBox" runat="server"></asp:TextBox> 
<asp:Button ID="CalculateButton" runat="server" Text="Calculate" />
Total: <asp:Label ID="TotalLabel" runat="server" Font-Bold="true"></asp:Label>

Definitely no prettying up there. Just the basics. The calculator example may not be the best use of a custom control, but it keeps it simple so you learn what should be learned.

Client Code

First things first, we should register a namespace for our class that's going to represent the definition of our client representation of the calculator. Create a new .js file called Calculator and add the following to it.

Type.registerNamespace("Porter.Erik");

"Porter.Erik");

Then we need to create and register the class itself.

blah

Web Service

blah

It's been a really interesting journey watching ASP.NET AJAX grow up. I got to see very early builds of it (this was a few weeks before the first CTP) before I joined Microsoft when I was an ASP Insider and while the potential was there, it was still in its infancy and had a long way to go. This was in October 2005. Now it's all grown up and turned into a comprehensive client library, awesome integration with ASP.NET server controls and a Control Toolkit. Things are only going to get better with full integration into Orcas. Good times!

So far we're just using custom controls in basic places on Channel 9 like the wiki edit control, reply editor and a couple others. We're currently using the UpdatePanel for our EntryList control because it was simple to get going. Between the beta of Channel 9 and RTW, I will probably switch it over to being a custom control. This will more than likely be a blog post on its own and will demonstrate some advanced techniques.

There's more code from our platform in the pipeline. I'm not sure what to talk about next, but it may be our Virtual Path Provider setup or Templating scheme.

Windows Vista Install Demo

2009-02-14T05:45:33.83

This is more for the technology enthusiast crowd than the developer crowd, but...

Channel 10 has a video up today to start off Windows Vista Week (even a pretty new banner just for the occassion ;)) about installing Windows Vista. I've installed Windows Vista 18 hundred million billion times since I've been running it for a long, long time, but I think this video is interesting in showing that it's easy to install (sorry for linking directly to the mov file, but Apple's site doesn't have permalinks for their videos).

ASP.NET FindControl Recursive with Generics

2009-02-14T05:45:32.007

While working on the new version of Channel 9, part of my job this time around was to "templatize" our entire community platform. The way everything is set up now, aspx files are read in through the Virtual Path Provider (VPP), additional settings in the Page directive are set based off of database settings and the page is rendered. All our controls are now ascx files with the CodeFileBaseClass set to a class that implements all the code. This allows us to easily setup new controls and templates for our different sites if new ones are needed. Right now, Channel 9 and Channel 10 are the only two sites that will be running this code. In the halfway near future, VisitMIX and a yet to be named Student focused site will run this code as well, so templating was very important. My other job for this sprint was to add ASP.NET AJAX functionality to the site. As we get closer to launching the beta you'll see more posts from me sampling some of our code and techniques especially around ASP.NET AJAX.

The new EntryList control that I created takes a List<Entry>. The control has a setting to let us set which ascx file we want to use to represent each Entry in the list. These are loaded using Page.LoadControl. The same thing goes for the Pager and Filters control in the header and footer of the EntryList. All of these controls implement different interfaces so we can throw in different ones and look them up generically. I don't necessarily know the names of these controls and needed a way to look them up by the interfaces they implement. So I thought, "hey, I'll bet generics could help me out here." I got the below code written, but unfortunately couldn't figure out how to properly cast the control by the type passed in. My next door neighbor, our resident Sampy, helped me figure out that I needed to force the type coming in to be a reference (hence the "where T : class" part). Here's the resulting code...

public static T FindControl<T>(System.Web.UI.ControlCollection Controls) where T : class
{
 T found = default(T);

 if (Controls != null && Controls.Count > 0)
 {
 for (int i = 0; i < Controls.Count; i++)
 {
 if (Controls[i] is T)
 {
 found = Controls[i] as T;
 break;
 }
 else
 found = FindControl<T>(Controls[i].Controls);
 }
 }

 return found;
}

Unlike a recursive method that's not generic, you would have to pass in the type as a parameter to the method, which would get passed down through every method call, and you'd have to cast the found control on every call you made to FindControl. That wouldn't be a huge deal, but there is something nice about simplicity. :)

IMyInterface myControl = FindControl<IMyInterface>(this.Controls);

Note: This only returns the first instance of a control. You could easily pass in a references List<IMyInterface> and add to it as you find them.

This isn't break through code or anything, but it's fun for us, the dev geeks. Expect to see more posts soon about coding techniques in our platform.

ASP.NET AJAX 1.0 Released

2009-02-14T05:45:31.803

I have to jump in with everyone else. Me too, me too! :D

http://ajax.asp.net/

In the coming months you will see our platform pushed to Channel 9 and 10 and we use ASP.NET AJAX heavily. Hopefully I'll have time to work up some samples from our code to share.

CES Content on Channel 10

2009-02-14T05:45:31.523

http://on10.net/tags/CES

Keep checking back for more. We've got a lot of great stuff lined up! :)

XNA Game Studio 1.0 Released

2009-02-14T05:45:31.32

I've been playing around with XNA a little bit in my free time. It's pretty darn easy to build a simple game with. You can debug it from your Windows machine while running on your Xbox 360, all good stuff!

http://learnxna.com/archive/2006/12/11/Its-official.aspx

Be sure to check out the XNA content on Channel 9 too.

P.S. Don't mind the typo on Learn XNA. "not" should be "now". ;)

WPF/E December CTP on Channel 9

2009-02-14T05:45:30.557

Awesome stuff. Check it out! :)

http://channel9.msdn.com/playground/wpfe/

Video Marketplace Launches on Xbox 360

2009-02-14T05:45:28.247

Major Nelson talks about it here: http://www.majornelson.com/archive/2006/11/22/video-marketplace-now-live.aspx

I turned on my 360 today to find all kinds of cool new ways for me to spend some points. ;) It's pretty fabulous. They've got shows for bunches of major networks, movies (old & new), etc.

I'm downloading THX 1138 (still haven't seen it and I feel ashamed as a George Lucas fan). I love that they have entire seasons of shows. What I'm disappointed in though is the fact that the only TV shows they have in HD are all the CBS shows. So if you wanted to watch the latest Studio 60 episode in HD you're out of luck. Hopefully this will change in the future. Overall I'm loving this though! I'm going to need a bigger hard drive soon. ;)

Win Visual Studio 2005 (Team System Suite) and MSDN license

2009-02-14T05:45:27.857

http://addressof.com/blog/archive/2006/11/09/What-would-you-do-for-a-Visual-Studio-2005-_2800_Team-System_2900_-and-MSDN-license_3F00_.aspx

Be creative!

How to Keep Developers at Your Company

2009-02-14T05:45:27.637

I think every company (software or not and even the good companies) should read this article. I'm definitely not in code for the money (although it's icing on the cake). Great article.

http://www.softwarebyrob.com/articles/Nine_Things_Developers_Want_More_Than_Money.aspx

(found this from the JobSyntax blog)

Windows Forms to Windows Service Process to Process Communication Using WCF

2009-02-14T05:45:27.42

I've been working on a side project for an application that will run on Windows Vista. It involves a Windows Service that does P2P and WCF Endpoint code to do some communication. I wanted to setup a WinForms app that could talk to it. I could just set up another http endpoint, but that would be slower and open up my security surface area. Instead I wanted my application to talk to the Windows Service in memory. The way to do this is through named pipes in WCF. It was fairly easy to figure out how to do, but currently WCF is a bit picky on the details so it took a while to get it going. I thought I'd share how to setup this up with some sample code. Note: I didn't use WPF for the UI because I don't know it well enough yet and know Windowns Forms pretty well. I imagine a WPF app would connect about the same.

Setting up the WCF Service and Contract

Setting up the Named Pipe

Setting up the Metadata Service

Connecting to the Service

Enjoy!

ROW_NUMBER() OVER Not Fast Enough With Large Result Set

2009-02-14T05:45:24.19

So I'm working on improving the performance of the next version of Channel 9. For those of you not familiar, our team created a new platform for our department to build community sites (blogs, forums, videos, tagging, etc). You can see an example of the platform running on 10. Currently, there's not a whole lot of data in the 10 database so we've been able to get away with murder from a performance standpoint. Now that I've imported all the data from Community Server (Channel 9) to 10 (EvNet Platform), we've been finding that 250,000 rows doesn't perform very well with our current code.

The architecture of our platform is pretty simple. There's an Entry table that houses Entries, Threads & Comments and the relationships between them. When you're viewing a blog, you're looking at this table. When you're looking at a forum, you're looking at this table. We differentiate everything in our system by tags. There's one for each forum, each blog, and content tags to describe what's in each entry.

Currently, to do paging we've been using the ROW_NUMBER OVER function. It's a new feature of SQL Server 2005 and is very simple and easy to use. Unfortunately, it doesn't work very well with a lot of rows (250,000 for example). I did some searching and came across this gem of an article. It uses an interesting trick to use SET ROWCOUNT to get the first record to start with in a paged result set, then you just run the query again and set the row count again to the number you want where the values are greater than the first row from the starting point of the paged result set and man is it snappy. Do check it out if you're having troubles with performance of ROW_NUMBER() OVER.

Oh yah, I forgot to mention how much of an improvement this change made. Before the change queries were taking about 8 seconds on average. After the change, the queries now take less than 1 second. Depending on if SQL has decided to cache the results or not, it's pretty much instantaneous.

Soapbox Video and Invites on 10

2009-02-14T05:45:23.567

Laura posted a video all about Soapbox on 10. If you're not familiar Soapbox...think...YouTube. ;) Want to know how it's different than YouTube? Watch the video, then get an invite (which have been hard to come by as of late), courtesy of 10! :)

See the Zune in Action!

2009-02-14T05:45:23.317

No words necessary...enjoy!

http://on10.net/Blogs/duncan/sharing-songs-and-pictures-with-the-zune/

Our Team on Channel 9 Again

2009-02-14T05:45:23.113

We recently launched a new version of 10. There were a few cosmetic changes, lots of bug fixes and a HUGE update to the guts of it. It is now much more generic on the inside. At its simplest, our platform is now just a bunch of Entries and Tags and associations between the two. When viewing a forum, you're just looking at tagged entries. When viewing someone's blog, you're just looking at tagged entries. The list continues...

This major re-organization/generalization of our platform lines us up to update Channel 9 soon to this new platform, enabling us to make very quick updates to all of our sites. There will be some new sites over the next year.

Anyway, we put up a video of us launching the new site on Channel 9. Check it out. It's good for a laugh and a little insight into our crazy team. :)

http://channel9.msdn.com/Showpost.aspx?postid=238667

Also, expect to see these videos turn into a regular thing (but in much shorter and more frequent chunks).

Web Application Project (Visual Studio 2005) on Windows Vista RC1

2009-02-14T05:45:22.613

If you've tried installing it already, you know it doesn't work. Rich Mercer posted the answer, which is to run the msi as an administrator. Unfortunately, you can't just right mouse click and run as Administrator. For details on the work around (a bat file) check out Rich's blog post about it.

UPDATE: The issue with this has been fixed in Windows Vista RC2 (5744) and you do not need the workaround anymore to get it installed.

Channel 9 and Microsoft 10 are Hiring

2009-02-14T05:45:22.46

Jeff spills the details...

http://www.jeffsandquist.com/WereHiringComeJoinTheChannel9And10Team.aspx

Windows Live Spaces Goes LIVE!

2009-02-14T05:45:22.27

The new Windows Live Spaces (formerly MSN Spaces) has just gone live. They have some really neat new features. Of course we have a video on 10 about the new release. :)

Microsoft Photosynth from Live Labs

2009-02-14T05:45:21.647

This thing is unbelieveable! It meshes still images together in 3D space and lets you fly around through them.

Check it out on 10 AND Channel 9 for different perspectives on the product.

Now what I really want to see is navigating images using Play Anywhere. ;)