2005 2006 2007 2008 2009 2010 2011 2015 2016 2017 2018 aspnet azure csharp debugging docker elasticsearch exceptions firefox javascriptajax linux llblgen mongodb powershell projects python security services silverlight training videos wcf wpf xag xhtmlcss

Introducing the XML Assembly Generator



OK, so I'm back… with a gift to the world. For the last month or so I've been working on a project in my spare time that has already been a great help in my architecture and development work. About a month ago I got COMPLETELY fed up with writing code manually and I've always despised UML and graphical code generation systems (like Visio for Enterprise Architects-- I hate Visio anyhow!), but I'm completely addicted to XML and have been for years. What I wanted (demanded!) was a declarative (NON GUI!!!!!) programming tool that allows brainstorms/architectures/projects to be written in pure XML, so that I can think in concepts without having to work directly with code. So, I decided that it was about time that I create a system that will compile a XAML-like structure to a complete VS2005/C# project.

The system has already been a tremendous help to me. In fact, when I got the initial features of the system setup, I used it to create the rest of the system. This helped speed up development because I think in terms of trees, branches organization, and XML. When I was architecting the internal components of the compiler, I was doing all my work in XML using my XAML-like format. Then, when I got a design I kinda liked, I would run it through my compiler (at the time just a console application) and VOOM I got my C# project.

So, as of today, I'm releasing to the public in alpha form under the project-name "XAG" or "XML Assembly Generator". I considered the project-name "XAC" for "XML Assembly Compiler" as it's more of a compiler than anything else... but "XAC"? That's a real name and I found that beyond lame.

Though there is a complete documentation page linked from the XAG start page, here are some of the features that XAG provides.

  • Creation of classes
  • Creation of structs
  • Creation of enumerations
  • Creation of delegates
  • Creation of interfaces
  • Creation of physical folders
  • Creation of custom attributes
  • Creation of type aliases ("using A = B;")
  • Automatic Interface Implementation
  • Usage of Polymorphism
  • Strongly-linked objects (the resource "x:Key" subsystem)
  • Inclusion of properties
  • Inclusion of fields
  • Inclusion of constructors
  • Inclusion of methods
  • Inclusion of events
  • Auto generated constructors for properties
  • Static members
  • ref and out parameters
  • Inline instantiation of properties and fields
  • Inclusion of app.config data
    • I would like to point out a few special features of the system besides what should be obvious. First, I tried to make the syntax as close to XAML as possible, including the concept of resources. So, not only can you create types, but you can strongly-link types together just like you can do in XAML with resources. For example, you can create a class called "Item" and give it a key of "MyItem01" then you can create another class and declare a property using the type referring to the key "MyItem01". XAG will do all the magic for you in finding the real name of the type. This same concept is used for many things including inheritance, interface implementation, and aliasing generics. This helps you keep your structures strongly-linked, so you can ensure that when you want to inherit from a specific class named "MyClass" you get the specific one you want, not another one with the same name, but in a different name space. This also decouples the name of the type from the key. So you can rename the class all day long and not have to update any references. As a side note, just like with WPF/XAML, in order to access a resource, you have to first declare it. I don't think that's too much to ask.

      Second, have you ever created a type with multiple properties and then had to create a constructor to set all the properties? I hate doing that. I appreciate it when it's done (who isn't frustrated at the WPF guys forgetting to do that on their UIElements!?), but still... it just seems like work that should be done for you. C# 3.0 makes this work easier... but XAG simplifies this for you today. So, when you want to create a class with properties that has a constructor to set the properties, simply create the class and the properties and set AutoGenerateConstructorsByProperties to true and BAM, your type will magically have a constructor (in addition to the parameterless one) that maps parameters to properties.

      Third, when compiling the XML to C# (or VB2005 or IL or whatever the destination is--given I add those abilities), XAG looks for compliance to many coding practices. For example, if you try to set a class field to public, the compiler will give a warning and tell you it's changing it to private. I personally hate it when people write code that doesn't obey the .NET coding laws. So, I'm not allowing some of the most common things that lead to screw ups. Also, structs have many rules that are enforced. In fact, structs have more rules enforced than all other types combined. This is not so much for compliance to the .NET coding laws, but, rather, because structs just have more rules than classes. For example, say you have a struct with three instance Int32 fields and you want a constructor. Well, first off, you can't have a parameterless constructor and secondly, if you have a constructor at all, you have to initialize all the fields before control leaves that constructor. When creating constructors, XAG knows about your fields and initializes them for you.

      Here are some sample XML documents that will compile to VS2005 projects:

      The simplest ever:

      <assembly />

      Something a bit more interesting:

      <Assembly xmlns:x=" http://www.jampadtechnology.com/xag/2006/11/ ">
        <MyClass x:Key="MyClass" Type="Class" Namespace="ClassNamespace" />
      </Assembly>

      OK, that wasn't interesting at all... So, here's one that should explain things a bit better:

      <Assembly xmlns:x=" http://www.jampadtechnology.com/xag/2006/11/">
        <MyClass x:Key="MyClass"
                   Type="Class"
                   AutoGenerateConstructorsByProperties="True"
                   Namespace="ClassNamespace">
          <Properties>
            <Id Type="Int32" />
            <Name Type="String" />
          </Properties>
        </MyClass>
      
      
        <MyOtherClass Type="Class" AccessModifier="Public" Inherits="{Type MyClass}" Namespace="ClassNamespace" />
      
      
      </Assembly>

      This last one creates a project with two classes, one inheriting from the other. The first class has two properties and two constructors, one which is parameterless (as you should always have!) and one which takes two parameters and sets them to their respective properties.

      Looking at that, you may think it's too much overhead. Well, this isn't a sissy C# file creator. This thing actually creates the entire project and returns it to you as a single zip file. So, even if you wanted to start a new project, this system will help you tremendously. Simply open the XAG screen, select a template (optional), type in your code, hit Create Project, and you'll immediately get a ZIP file containing all folders, all files, an AssemblyInfo.cs file, and the project file. You will have everything you need to start your solution or to continue your solution by simply adding the XAG project to your existence solution.

      The XAG website also currently has a few tools you may find useful. Not only can you use the initial screen to create your XAG projects, but you can also use it to check for well-formed XML and also to format your XML. The entire website is Ajax based, so responsiveness is unsurpassed. As a side note, in case anyone is wondering, I did all the Ajax code manually as I find it much more efficient than using Atlas, however... I am using Atlas for web service calls to the main compilation server.

      As a warning, I'm still cleaning up the website (it's alpha!) so there may be problems in selling all compilation errors. I'm also redoing major parts of how compiler warnings are displayed, so, for now, there might not be any compiler warnings (it depends on when you look at the site!) Ideally, I would like the system to give a list of compiler errors and warnings to the end user (you!) It does in the console version, but I've yet to completely add that to the website.

      In the future I'll probably be modifying the syntax a bit (and therefore adding a release notes/change log here) and adding a few features and simplifications that I've been meaning to add for a while. For example, I wrote a much more powerful subsystem for generics, but decided that I should hold off on a public release of that to version 2.0. I will also be monitoring the exception logs and fixing bugs as they come up. I'm sure I'll be adding a ton of "if(v != null)" in this initial release.

      You can access this application at http://www.jampadtechnology.com/xag/. You can hit the intro link to see how it works, but it's fairly obvious. Most importantly, PLEASE SKIM THE DOCUMENTATION. I didn't say read it. Only super-geeks with no lives READ documentation. Just skim it and take in the overall idea and syntax. Lastly, please feel free to use any examples in the documentation, documents in the samples section (which I will be expanding upon), or provided templates to start or assist in your usage of the system.

      Links

Firefox 2.0 Officially Released!



Firefox 2.0 Officially Released!

The world's most powerful web access system has now been released in a new version: 2.0.

A few of the new features in Firefox 2.0 are:

  • In any text box you now have a SPELL CHECKER! So, if you are typing a comment in a form... you have little red underlines for misspelled words (goodness, I'm seeing them all over this e-mail. I just have to right click and fix it).
  • It's prettier for Mac and Vista people.
  • When you type in the search bar it starts to give you suggestions as to what you may be looking for.
  • Phishing protection -- Phishing is when you go to a website that says "Welcome to eBay! Give us your credit card number to continue service!". Firefox (and well most web browsers now these days) helps protect against that.
  • It handles even MORE powerful websites and intranets (Internet Explorer is finally caught up to 2003).
  • You ever want to restart your computer or just for (some odd reason and hopefully very rare reason) shut your down your computer and want to remember what you were doing? Well, now you can close Firefox and when you reopen it you have the option of continuing right when you left off (thank you Firefox 2.0 spell checker-- I could NOT spell continuing!). So, if you have 9 or so tabs open then you can have them all back when you restart your Firefox 2.0. Opera people have had this for a long time and many Firefox users had an extension that gave them this ability, but now it's finally native.

For those of you who are in a corporate environment (which is just about everyone in my target audience I suppose), to deploy Firefox in your corporate environment you won't want to install Mozilla Firefox directly, but rather, you will probably want to use FrontMotion Firefox. You can get this from FrontMotion's website. As of the time of this writing they haven't released the new 2.0 MSI (how could they... it was JUST officially released!), but in a few days they should have it posted. This Firefox is an MSI version that allows deployment via Active Directory ("AD"), which if very cool and REALLY needs to be native to Firefox anyhow. FrontMotion also provided administrative templates for your Firefox AD deployment. Their mozilla.adm template is a very powerful template allow customization of many aspects of the Firefox internal registry.

As a reminder, you can extend Firefox in any which way you want. I don't mean by using "add ons" in general, but I mean extensions. Don't like something? Fix it... Here are some extensions that I have installed everywhere.

  • All-in-One Sidebar
  • IETab
  • Download Statusbar

FrontMotion will also customize your corporate Firefox to have to extensions that you want in your MSI. What if you want to install Firefox extensions AFTER the MSI install? Well, the way to do that is simple and it does not involve a sissy GUI. Most people think that when you install a Firefox extension it's installed in the entire system. That's not true. Firefox extensions are per profile, not per operating system login nor per system. If you want to install an extension on a system use the following command.

firefox.exe --install-global-extension MyExtensionName.xpi

That will install the Firefox extension globally on the machine. This command is something you can definately package in an MSI yourself and if you know anything about MSI and AD deployment, then you know that you can set prerequisites, which will allow you to deploy the extensions after Firefox 2.0 is installed. Now, as with all properly designed software, Firefox extensions are versioned. Extension are versioned not only to have their own version, but they are versioned to work with specificially tested versions of Firefox (thats actually a Firefox extension development best practice). So, version your Firefox extension MSI packages so that you can tell AD to deploy the new versions as needed.

Given my audience, I think it would be a good idea to make a few statements about about the architecture of Firefox. This week I was at the HDC06 convention and one of the keynote speakers said something to the effect of "COM was never really implemented anywhere else other than in Microsoft operating systems" (that's a super paraphrase). Obviously that's not true... but one place it is definately not true is with Firefox. Internally Firefox has a technology called XPCOM (Cross Platform COM) that looks and feels much like Microsoft's implementation of COM (though a lot cleaner). You have interfaces and you query interfaces... blah blah blah. If you know COM, you know know what I mean.

Firefox also has it's own internal registry kinda like the Windows registry, except it's actually intuitive and it's not yet bloated to the point of complete uselessness. To access the Firefox registry, simply put "about:config" (with out the quotes) in the address bar. This allows you to customize just about anything about Firefox. As with anything, some of the really awesome stuff isn't directly seen in there (i.e. there aren't entries or "keys" for them by default), but the many Mozilla-specific websites have great documentation on how to customize and tweak your web system to your own likings. There's not really any limit to what you can do with the Firefox registry, so any documentation you see will by in some sense be incomplete, though MozillaZine's documenation is great for much of the Firefox registry defaults. You can tweak anything form the lowest geekiest component to something web developer-ish like toggling strict JavaScript mode on (... remember the Option Strict in VB? Same type of thing...) So, you may wanna dive into that depending on your needs (btw, if you see bold entries... that means they have been changed from their defaults or they have been added -- by an extension, by you, or by something else; they just aren't at their default state.) With regard to AD deployment, this Firefox registry type of stuff is what the mozilla.adm AD template will allow you to control in your AD group policy.

Lastly, for those of you have haven't seen my Firefox Web Developer videos, you can view them at the below links. Even though the videos were created using Firefox 1.0, everything in them is still true in Firefox 2.0. In the future I may released more videos, but for now what's posted is all I have prepared. I had one last video in the series , but "something" happened and it got cut in half.

So, if you haven't done so already GetFirefox.com today and help spread the goodness around the world and into your corporation

Links in this Entry

My Firefox Web Developer Video Series Link

XHTML 1.1 Escaping (Chapter Excerpt 3)



One thing you will inevitably notice when working with the ultra strict XHTML 1.1 is how the ampersand (&) works. In HTML you never had to worry much about the ampersand, though you could use it to implant an HTML space (&nbsp;). Now given that XHTML is XML, you simply can't get by with the rules of HTML. In the XML world, if you want to save an XML document with an ampersand, then you have to escape it. If you are familiar with C-based programming languages, then you know all about special characters like this. In those languages you have to "escape" certain characters such as the backslash (), with another backslash.

In fact, in Altova's XMLSpy application you will get a stopping warning if you have XML that looks something like <b>&</b>. The appropriate way to have an ampersand in XML is to write it as &amp;. This is very similar to what you could do with the   space in HTML and it's not that far off from what we already do. For instance, if you wanted to write &nbsp;. In fact if you want to write &amp;nbsp; you have to write &amp;amp;nbsp. So, if you know HTML, you already know the fundamentals of this rule. It's just that in the strict world of XHTML 1.1, you can no longer let little mistakes enter your code.

Now this rule about dealing with ampersands doesn't end with standalone ampersands, but also applies to ampersands in links. For instance, you can't just have a link like default.aspx?id=3&category=5. Your link has to transform to default.aspx?id=3&category=5.

Fortunately ASP.NET 2.0 is smart enough to deal with things like this in your databinding. For instance, look at the following code…

ASP.NET 2.0 Code

<asp:GridView ID="gvLinks" runat="server"></asp:GridView>

Code Behind

C#

String[] links = new String[] { "http://jampad.net/default.aspx?id=1&name=2", "http://jampad.net/default.aspx?id=1&name=2&frog=3", "Amburgers & Wootbeer" };
gvLinks.DataSource = links;
gvLinks.DataBind( );

Believe it or not, ASP.NET will output produce the following...

<table cellspacing="0" rules="all" border="1" id="gvLinks" style="border-collapse: collapse;">
    <tr>
        <th scope="col">Item</th>
    </tr>
    <tr>
        <td>http://jampad.net/default.aspx?id=1&amp;name=2</td>
    </tr>
    <tr>
        <td>http://jampad.net/default.aspx?id=1&amp;name=2&amp;frog=3</td>
    </tr>
    <tr>
        <td>A&W</td>
    </tr>
</table>

While I'm not a big fan of looking at table code, I am however a huge fan of automation. As you can see here, you don't have to fight with manually escaping data binding ampersands. Thus, you can give ampersands in XHTML data binding a vote towards deterministic.

XHTML 1.1 and DataBinding (Chapter Excerpt #2)



When doing serious data binding in ASP.NET you may want to reconsider using XHTML 1.1 or XHTML 1.0 Strict at all. The rule is simple: use the document type that can be deterministicly proven to be proper in your situation. Put another way, unless you have deterministicly proven that there will never be any invalid markup in the data, you should always use XHTML 1.0 Transitional.

If the binding data has some odd markup, then you will end up sending invalid XHTML 1.0 sent to IE breaking validation or sending invalid XHTML 1.1 markup to browsers such as Firefox, halting the rendering.

But what does it mean to be deterministicly proper? To put it simply it means to absolutely garuntee that the data will always be proper, that is, to be able to always predict the properness of data. This does not mean "well, it worked for 100,000 tests, so it's good enough", but rather it means that it absolutely will always work 100% of the time. You can get this level of determinism by looking at the symantics of what is going to be bound. For example, if you are binding a table with numbers, which will always be numbers, then you should have a level of determinism here. However, if you are binding a table with unvalidated under input, then you do not have determinism as you have no idea what a user will input. The user could input <b><i></b></i>, which will break the page. You have no idea. Having a proven, not demonstrated, view of data is what this is all about.

Here are a few guidelines that should help you with determining what is and not deterministic.

These things are never deterministic...

  • Unvalidated user input
  • Unvalidated external data
  • HTML
  • Anything else with angle brackets (<, >), except wellformed XML

Given symantical care, these things should be deterministic...

  • Wellformed XML
  • Alphanumeric strings
  • Base64 encoded data
  • Alphanumeric strings

To reiterate: only use the document type that is deterministicly proven to always be proper.

The Uncatchable Exception



There's once aspect of exception handling that I've found that many seasoned .NET veterans know about. Take a look at the following code…

class Node {
    private Node node;

<span style="color: rgb(0,0,255)">public</span> <span style="color: rgb(43,145,175)">Node</span> ChildNode {
    <span style="color: rgb(0,0,255)">get</span> {
        <span style="color: rgb(0,0,255)">if</span> (node == <span style="color: rgb(0,0,255)">null</span>) {
            node = <span style="color: rgb(0,0,255)">new</span> <span style="color: rgb(43,145,175)">Node</span>( );
        }
        <span style="color: rgb(0,0,255)">return</span> node;
    }
    <span style="color: rgb(0,0,255)">set</span> { node = <span style="color: rgb(0,0,255)">value</span>; }
}

}

class Program { static void ProcessNode(Node node) { ProcessNode(node.ChildNode); }

<span style="color: rgb(0,0,255)">static</span> <span style="color: rgb(0,0,255)">void</span> Main(<span style="color: rgb(0,0,255)">string</span>[] args) {
    <span style="color: rgb(0,0,255)">try</span> {
        ProcessNode(<span style="color: rgb(0,0,255)">new</span> <span style="color: rgb(43,145,175)">Node</span>( ));
    }
    <span style="color: rgb(0,0,255)">catch</span> (<span style="color: rgb(43,145,175)">StackOverflowException</span> ex) {
        <span style="color: rgb(43,145,175)">Console</span>.WriteLine(ex.Message);
    }
    <span style="color: rgb(0,0,255)">catch</span> (<span style="color: rgb(43,145,175)">Exception</span> ex) {
        <span style="color: rgb(43,145,175)">Console</span>.WriteLine(ex.Message);
    }
}

}

Code Segment 1

What do you figure the output will be? Well, most people say the output is something like "Operation caused a stack overflow." That's a nice guess, but this exception thrown from the CLR is actually not catchable. This is the uncatchable exception. It actually jumps directly outside of your try block and shuts your application down. What you actually see is what's in the below figure.

StackOverFlowException

Figure 1

The CLR does not allow you to have infinite loops in your applications at all. So much so in fact that it will literally kill your entire application to make sure you follow the rules.

Now, if you're thinking about it... you may be think "CLR threw it? Hmm... I wonder... I read something about the ability to throw things that aren't exceptions". So, you may be tempted to try this...

try {
    ProcessNode(new Node( ));
}
catch {
    Console.WriteLine("Unknown exception");
}

Code Segment 2

This actually doesn't help the situation at all. Actually, if you've read my previous blog entry on the RuntimeWrappedException, then you would know about the .NET wrapping plan. Under .NET's default rules, thrown objects which do not inherit from System.Exception are wrapped in an instance of RuntimeWrappedException. So, even if the exception thrown was one of those, it would have been caught by the original code anyhow.

This StackOverFlowException application failure is actually a very helpful rule the CLR enforces. It forces you to go back and make sure you don't have a recursion bug in your code, because this is not really a user-specific exception it's literally a bug in your application. So, before you throw a fit when you see this, just go back and find the bug in your recursion code.

It's important to note however, that there's nothing inherently special about the StackOverFlowException itself. Take a look at this code...

static void ThrowStackOverFlowException( ) {
    throw new StackOverflowException( );
}


static void Main(string[] args) {
    try {
        ThrowStackOverFlowException( );
    }
    catch (StackOverflowException ex) {
        Console.WriteLine(ex.Message);
    }
}

Code Segment 3

This time your output really is "Operation caused a stack overflow.". So, if you throw it yourself you can catch it. The uncatchable exception isn't really StackOverflowException, but rather the CLR's throwing of the StackOverflowException.

There are other ways to completely kill an application. One of the more subtle of ways is via use of System.Environment.FastFail(String message). This static method will immediately kill and application and will not be caught by any catch blocks anywhere. So, if you really want to screw up an application simply do the following...

[Serializable]
public class SalesOrderException : Exception
{
    public SalesOrderException( ) {
        Environment.FailFast(String.Empty);
    }
<span style="color: rgb(0,128,0)">// More constructors go here...
}

Code Segment 4

Now every time your application has a SalesOrderException, it will explode into pieces. There's absolutely no way to recover from this. The above code is something that a disguntled employee would love to check in.

That said, looking at it in another light, Environment.FastFail(String) can actually be a great debugging tool. For example, say you have an application that is just downright giving you some weird output. You have no idea why. You know it's wrong, but there are just no exceptions bubbling to the surface to help you out. Well, if you have access to Visual Studio 2005's Debug->Exceptions... menu item, you can actually tell Visual Studio to allow you to see those first chance exceptions. If you don't have that, however you can put Environment.FastFail(String) in an exception, and use deductive reasoning and process of elimination to find out where your problem in.

You may actually be wondering "What is the point of Environment.FastFail(String)?" It's actually quite useful for anyone severely uptight about security or someone withing really low level in a system. If you're absolutely sure there's an unrecoverable corruption in your system, then you can call this method to kill this application. Basically what you're doing is "blue screening your application". The operating system is untouched, but you application is gone. Another situation someone can use Environment.FastFail in in security situations. If you absolutely need to verify some piece of security for the application to continue at all (i.e. you don't want anyone to catch an exception you throw and continue insecure), then you can use this method to "bluescreen" the app.

Troelsen's COM and .NET Interoperability Book



Now this is cool… Andrew Troelsen's book "COM and .NET Interoperability" is FREE in e-book format at apress.com (click on Free E-Books under one of the headings). I highly recommend this book to anyone who wants to either continue to use their current COM components in the .NET world or for people who want to use their .NET abilities in COM-based technologies.

Many times I hear people say they would have to need for this. Well, let me give you some ideas of what I do at the office. Every now and again the web developer at the office will get overloaded with work and it will bubble up to the architect (me!) Well... the older websites are all in classic ASP and while I spend my share of time in the trenches with classic web application development, there is NO way I'm going to do any VBScript development. (heck, even back then I did most of my work in PerlScript!)

My solution is simple: .NET to COM interop. Most of my work is done in .NET and I just expose the interfaces to COM. You really think I'm going to consume a web service with manual XML structures in VBScript? Uh... think again.

By the way, for those web services I consume and expose to COM I wrote my own web service consuming framework (because so many people expose COMPLETELY INVALID services to the world in pseudo-"SOAP" that .NET won't get near it). I then expose these new "services" to the COM world via component services. Oh yes, the book has an entire chapter just on serviced components (COM+ Interop).

Brad Abram's Presentation



Anyone who knows me knows I'm an architect and designer at heart… every time I see construction work I just stare at it and study how everything is being planned. Heck, I learned much of software architecture from watching Discovery Channel's Extreme Engineering. I love the stuff… ergo, Brad Abrams is my hero. His work is astonishing. As far as I'm concerned he is the glue that kept the BCL together.

Everyone NEEDS to check out his latest presentation on design guidelines. This is some good stuff. Usually I think PowerPoint is a mind numbing waste of time, but this presentation is great. By the way, if you don't OWN the design guidelines book by Krzysztof Cwalina and Brad Abrams, YOU NEED TO. If you never looked at it, please stop writing code today.

Check it out...

C# 3.0 Features at MSDN Nuggets



The MSDN Nuggets website has just released a TON of awesome videos about new C# 3.0 features. Personally I love the stuff they are doing with the LINQ project. It's going to make the awesome C# 2.0 language even more powerful and flexible.

The site also released a cool video about how to get Vista's glass to work in your apps. By the way, if you're interested in the workflow foundation, there are a ton of videos on that as well.

Here are the videos...

New Blog Engine



The other day I got sick and tired of the fact that I didn't have labels on my entires… sure Blogger Beta allows for that, but you have to be on their server to use it (and understandably so). So last weekend I wrote my own blog engine in .NET 2.0. Sure I could have used a pre-built one (like DasBlog), but I kinda like the level of control I get from using things with my architecture and my coding style. Yes, I know that's a ridiculous and somewhat arrogant excuse, but I really do like to have it in my own architecture and design even if own as a training tool I can use in the future.

Anyhow... the new system has been up for a few days and if you see any weird behavior on it (like a blog entry link taking you to the homepage or whatever), please be assured that I get a notification e-mail about the problem and will quickly look into it. I'm still considering it in "beta".

With the new blog engine you can access labels to view various entires at once as well as see articles by month by going to http://www.netfxharmonics.com/year/month/ like http://www.netfxharmonics.com/2006/10/.

There are various other nice internal features too, like the ability for each entry to have more than one URL. Some of my blog entries are actually linked via different links, so that's something that is definitely important to me.

Oh, how did I do that you ask? HttpHandlers! These ASP.NET pieces of goodness are great. My entire blog is really just one public page: default.aspx (plus the internal supporting user controls, masterpage and clientside JavaScript and CSS pages). There isn't really a link called http://www.netfxharmonics.com/2005/12/video-1-fwd-setting-up-your-firefox.aspx. When ASP.NET sees that URL being requested, the HttpHandler parses it and sends the information off to the default.aspx page which then looks up the blog entry data (via an adapter which then accesses LLBLGen) and sends that data back to the client who thinks that's a real page (even Google indexes it as a real page).

Another cool thing is something I mentioned before: each page can have more than one url. So, for example, the following two URLs show the same data (via a simple lookup in a table which contains the URL names).

As far as tracking, I did throw in a simple tracking system so I can log all traffic via IP address, session, and many other things. I really only did that so I can watch myself go through the site for debugging purposes. My REAL tracking is done via the awesome Google Analytics service which I have been using since it's release. I even have it on all the e-commerce sites we host at the office (replacing WebTrends!). Google Analytics is awesome. Google is awesome!

This weekend I'm going to be builtng in a Atom/RSS creation system that will give a feed to FeedBurner for the RSS subscribers to see (if you aren't using FeedBurner to serve your feeds, you really should--it abstracts the URL from your site so you can change your REAL feed location all you want and it gives you great stats as well). I'm actually going to implement my IAP (doesn't really stand for anything) engine which allows developers to dynamically create report templates and RSS feeds declaratively. We also use this at the office... it's actually really cool. It's not only an RSS server, but also an RSS aggregator. So, at the office, we use my IAP engine in the company portal to show blocks of information (they are simply RSS feeds shown via a custom ASP.NET control like ). So... implementing the new RSS system should be really simple.

As far as a client... I think that the web is kind of a hassle for client work. Personally I've grown to hate it. Back in the day I was all about web applications. I thought they were so cool, but I'm all about smart clients now. So, I wrote my blog editing application in WPF which, naturally, communicates with the server via WCF. The interface was rather simple to build in WPF as WPF it has the the advantages of WinForms with regard to simplicity and the power and awesome control tree model of ASP.NET. Great stuff...

The internal database is SQL Server 2005 Express. I swear... that thing is so cool. I've been using it for some time now and I have to say that I SO don't see myself ever needing the standard edition. Even at the office we don't need the standard edition for most of our databases (our CRM system needs standard for it's 60GB database, but other than that... Express works great). Oh... and YES, LLBLGen Pro 2.0 is the data access layer. That thing is so awesome.

As far as hosting. I love abstraction and delegation, so I don't see myself ever doing self-hosting. That said, I'm always looking for the best deal. That doesn't mean LOWEST price. "Best deal" in my situation is a metric of many factors. So, I use CrystalTech's dedicated web hosting for hosting the site (as well as MANY others) and I use the same box for my development work as well. It may just be a Celeron, but I have 1GB of RAM it in with everything I need. I can do anything from WPF to WF to WCF to Atlas on this thing. Granted I have to work with my own DNS and IIS configuration... but, serious, if you can't do that, you shouldn't even be in the biz.

I think that covers most everything. So, if you see something weird in the system, I can almost guarantee that there was an internal exception thrown and that I was notified of it with detailed in information of the failure.

Using XAG to Create a WCF Service



Here's a good example of what you could use XAG for. Using XAG, the below XML document compiles to a WCF Service Project. It contains an interface, a class implementing the interface, a few data contracts, and all appropriate references.

As you can see, you can include a literal configuration in the XML structure. This will be included as an app.config in your project.

What is XAG? XAG is a new FREE .NET 2.0/3.0 architecture and development tool allowing the creation of entire VS2005 projects in a single XML structure. You can access XAG at http://www.jampadtechnology.com/xag/

<Assembly xmlns:x="http://www.jampadtechnology.com/xag/2006/11/">
  <References>
    <Reference Name="System.Runtime.Serialization " />
    <Reference Name="System.ServiceModel" />
  </References>
  <Folder Header="Data Contracts">
    <Person x:Key="Person" Type="Class" AutoGenerateConstructorsByProperties="True" AccessModifier="Public" Namespace="AcmeCorp.Sales ">
      <Attributes>
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
      </Attributes>
      <Properties>
        <FirstName Type="String" />
        <LastName Type="String" />
        <Address1 Type="String" />
        <Address2 Type="String" />
        <City Type="String" />
        <State Type="String" />
        <PostalCode Type="String" />
      </Properties>
    </Person>
    <CreditCard x:Key="CreditCard" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales">
      <Attributes>
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
      </Attributes>
      <Properties>
        <Number Type="String" />
        <Cvv2 Type="String" />
        <Name Type="String" />
        <ExpDate Type="String" />
      </Properties>
    </CreditCard>
    <Item x:Key="Item" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales">
      <Attributes>
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
      </Attributes>
      <Properties>
        <ItemCode Type="String" />
        <Name Type="String" />
        <Price Type="Decimal" />
      </Properties>
    </Item>
    <Cart x:Key="Cart" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales ">
      <Attributes>
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization" />
      </Attributes>
      <Aliases>
        <Alias x:Key="LineItemsCollection" Name="LineItemsCollection" Type="System.Collections.ObjectModel.Collection [{Type Item}]" />
      </Aliases>
      <Properties>
        <LineItems Type="{Type LineItemsCollection}" />
      </Properties>
    </Cart>
    <Sale x:Key="Sale" Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Sales">
      <Attributes>
        <Attribute Type="DataContract" Namespace="System.Runtime.Serialization " />
      </Attributes>
      <Properties>
        <Person AccessModifier="Public" Type="{Type Person}" InstantiateObject="True" />
        <CreditCard AccessModifier="Public" Type="{Type CreditCard}" />
        <Cart AccessModifier="Public" Type="{Type Cart}" />
      </Properties>
    </Sale>
  </Folder>
  <Folder Header="Services">
    <IProcessorService x:Key="IProcessorService" Type="Interface" AccessModifier="Public" Namespace="AcmeCorp.ServiceContracts">
      <Attributes>
        <Attribute Type="ServiceContract" Namespace="System.ServiceModel" Reference="System.ServiceModel" />
      </Attributes>
      <Methods>
        <ProcessSale ReturnType="Void">
          <Attributes>
            <Attribute Type="OperationContract" Namespace="System.ServiceModel" />
          </Attributes>
          <Parameters>
            <Parameter Name="sale" Type="{Type Sale}" />
          </Parameters>
        </ProcessSale>
      </Methods>
    </IProcessorService>
    <ProcessorService Type="Class" AccessModifier="Public" Namespace="AcmeCorp.Service">
      <Implements>
        <Interface Name="{Type IProcessorService}" Namespace="System" />
      </Implements>
    </ProcessorService>
  </Folder>
  <Configuration>
    <!--
// Sample Console Application


using System;
using System.ServiceModel;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args) {
            using (ServiceHost service = new ServiceHost(typeof(AcmeCorp.Service.ProcessorService))) {
                service.Open( );
                Console.WriteLine("Listening...");
                Console.ReadLine( );
            }
        }
    }
}
-->
    <system.serviceModel>
      <services>
        <service name="AcmeCorp.Service.ProcessorService" behaviorConfiguration="Service1Behavior">
          <host>
            <baseAddresses>
              <add baseAddress="http://localhost:3827/"/>
              <add baseAddress="net.pipe://localhost/"/>
            </baseAddresses>
          </host>
          <endpoint address="" contract="AcmeCorp.ServiceContracts.IProcessorService" binding="netNamedPipeBinding"/>
          <endpoint address="mex" contract="IMetadataExchange" binding="mexHttpBinding"/>
        </service>
      </services>
      <behaviors>
        <serviceBehaviors>
          <behavior name="Service1Behavior">
            <serviceMetadata httpGetEnabled="true"/>
            <serviceDebug includeExceptionDetailInFaults="true"/>
          </behavior>
        </serviceBehaviors>
      </behaviors>
    </system.serviceModel>
  </Configuration>
</Assembly>