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

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>

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

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.

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...

1 2 3 4 5 6

Powered by
Python / Django / Elasticsearch / Azure / Nginx / CentOS 7

Mini-icons are part of the Silk Icons set of icons at famfamfam.com