Jim O'Neil's Blog : A-to-Z

.NET from A to Z – The Index

joneil — Tue, 30 Jun 2009 14:45:00 GMT

As you might be aware, this week ended my A-Z series exploring various facets of Microsoft and .NET technologies. It was actually a lot of fun to explore a different topic each week, and I’m even happier to say I didn’t miss one Monday, making me something like 1 for10 in terms of fulfilling New Year’s resolutions. With 26 letters in the alphabet leading to 26 posts, that also means 2009 is half-over, yikes!

Just to pull it all together, here’s a complete listing of the posts in this series. I hope you got something out of one or more of the posts, and I’m always looking for new ideas, so let me know if there’s something you’d like to hear about on a more or less regular basis.

.NET from A-Z (introductory post)

A is for Azure	B is for BAML	C is for Color
D is for Dependency Property	E is for Extension Method	F is for F#
G is for Generation	H is for HierarchyID	I is for Isolated Storage
J is for JSON	K is for Key	L is for Lambda
M is for M	N is for Nullable<T>	O is for Oomph
P is for Partial Method	Q is for Quirks	R is for REST
S is for SQLMetal	T is for Tracepoint	U is for Unchecked
V is for Velocity	W is for WeakReference	X is for XML Literal
Y is for Yield	Z is for Zermatt

Z is for… Zermatt

joneil — Mon, 29 Jun 2009 07:01:00 GMT

Zermatt is, well actually was, the code name for Microsoft’s next generation identity and access management API. Zermatt is now known by its new code name of “Geneva” Framework, but short of z-index, I was coming up empty on something to cover for this final post of my A-Z series – so let’s just call it poetic license.

The “Geneva” Framework is just one part of this new claims-based identity platform, which also comprises “Geneva” Server and Windows CardSpace “Geneva”. Its two primary goals are to simplify the single sign-on process within the enterprise and to enable existing systems to interoperate with new hosted services and service-oriented architecture implementations.

Let’s take a brief look at the three components, and then I’ll offer a number of links for further reference.

“Geneva” Server

“Geneva” Server is a Security Token Service (STS) that transforms claims into tokens. Clear as mud? let’s take a step back to get a handle on what that means.

A claim is simply a piece of information about a specific identity (often a user), and it’s the assembly of one or more of these claims into a (security) token that drives the authentication model. A claim could be someone’s name, their age, a password, or really any other piece of information that’s relevant to identifying valid users to a given application or computing environment. Tokens are interpreted by the application to which the user is requesting access, and it’s up to that application (the “relying party” in the picture above) to decide whether it trusts the provider of the token and the claims it is making.

While the specific claims aren’t all that important, knowing those claims are accurate and valid is paramount, so the token (which contains the claims) is digitally signed by a trusted party to verify its source and guard against tampering. The issuer of a signed token is referred to as a Security Token Service (STS), and the organization hosting the STS (the “trusted party”) is termed the identity provider – they are the ones attesting that the claims in the tokens they issue are valid. In the Windows Live ID service, for instance, Microsoft is acting as the identity provider.

“Geneva” Server, which is the next generation of Microsoft’s Active Directory Federation Services (ADFS), implements just such a Security Token Service. An organization could then choose “Geneva” Server to implement their own claims-based identity provider, built on Active Directory Domain Services, and act as an identity provider to applications within their enterprise or elsewhere.

Windows CardSpace “Geneva”

Cardspace “Geneva” is the user-focused component of the “Geneva” platform. In the simplest of scenarios, a user would have one identity, managed by an STS like “Geneva” Server, and she’d request the STS to provide the claims associated with her identity to authenticate herself to every application.

That’s a rather myopic view though. Just as we have multiple identification facets in our physical lives (social security numbers, driver’s licenses, passports, etc.) that we use in different contexts, so do we have multiple digital identities that we use for different applications and services (think for instance of all of the various passwords you’re keeping track of now!) My Facebook account, for instance, doesn’t need to know what my Blue Cross number is, but my on-line pharmacy probably does.

This is where the concept of an identity selector comes in. When a user requests the services of an application, that application will forward a list of its needs – in terms of token types, claim requirements, and the identity providers it trusts. The identity selector, here “Geneva” Cardspace, can review the requirements and present the user a list of the available identities (presented as Information Cards) that meet the authentication needs of the application. The information card contains the information needed to locate the appropriate STS and obtain the requisite token; the card itself doesn’t store any claims or token information.

“Geneva” Cardspace also handles the user interface, so that there is a consistent experience across Windows applications relying on identity selection. The interface presented to the user looks something like the following, with a link (“What information will be sent”) to provide more information on exactly what specific pieces of information (claims) will be sent to the relying party application.

“Geneva” Framework (previously “Zermatt”)

The “Geneva” Framework (my “Z” for this post) provides the programmatic interface for .NET developers to validate and consume claims in client applications (the “relying party” in the figure presented at the beginning of this post). The .NET Framework 3.0 does include a few classes in System.IdentityModel.dll to do claims-based programming; however, the developer story wasn’t too compelling in terms of openness and ease of use.

At the forefront of the new framework (incorporated into Microsoft.IdentityModel.dll), is the Claim class, which contains several properties:

ClaimType

Typically a URI that indicates what the claim is. This URI could be anything that your application and issuer can agree on. In CardSpace, a user’s first name would have a ClaimType of http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname

Value and ValueType

Value indicates the value of the claim, such as “Jim” for a first name. This is always a string value. The ValueType property indicates the underlying XML schema type used to serialize and deserialize the value. There’s a number of predefined schema type strings you can use in the static class ClaimValueTypes; for instance, a date value would be serialized per http://www.w3.org/2001/XMLSchema#date

Properties

An IDictionary<string, string> of optional metadata related to the claim.

Issuer and OriginalIssuer

A name for the issuer (STS) of the claim. In a federated scenario, where two or more issuers are involved, the Issuer is the last in the chain, and OriginalIssuer is the first in the chain.

Subject

An object implementing IClaimsIdentity that provides additional information about the user’s identity. IClaimsIdentity extends the existing IIdentity interface, which provides only the name of the user. IClaimsIdentity exposes a ClaimsCollection as well as a way to specify which claim corresponds to the user’s name and roles.

The “Geneva” Framework also exposes a IClaimsPrincipal interface, with a default implementation in ClaimsPrincipal. IClaimsPrincipal extends the existing IPrincipal class to include a collection of IClaimsIdentities. In most, cases there will be one item in this collection, but it does make it possible to support scenarios where the relying application requests multiple tokens from different issuers.

The addition of the new interfaces and enhancement of the Claims class does add a little more complexity, but given the extension of existing interfaces, you can access the claims information using the same constructs you’ve used before to get the user information, by accessing the Thread.CurrentPrincipal or User.Identity in an ASP.NET page. For example,

IClaimsIdentity claimsIdentity = 
    Thread.CurrentPrincipal.Identity as IClaimsIdentity;

The Microsoft Code Name "Geneva" Framework Whitepaper for Developers is a great source of information for using these classes within your applications. In fact, it’s interesting (and not too surprising) to note that “Geneva” Server actually uses the “Geneva” Framework itself to implement its own security token service. If you’re concerned over all the infrastructure required to try all this out, you’ll be happy to know that if you download the Beta 2 release, there’s an option to get a pre-configured VPC to facilitate your evaluation.

One final point to note is that while these three components provide a solid infrastructure for claims-based identity, they do not form an all-or-nothing proposition. “Geneva” is Microsoft’s implementation of standards-based technologies like WS-Trust and SAML 2.0. You don’t have to use “Geneva” server to use CardSpace; in fact, you might not even need an identity selector for simple scenarios. Likewise, applications built using the “Geneva” Framework can process claims served from sources other than “Geneva” Server.

References

MSDN Security Developer Center

“Geneva” Claims Based Access Platform (whitepapers)

“Geneva” Framework Whitepaper for Developers

“Geneva” Beta 2 Download

Channel 9: The Id Element

“Geneva” Team Blog

Y is for… Yield

joneil — Mon, 22 Jun 2009 07:01:00 GMT

Before we talk specifically about the yield keyword, let’s review a few constructs you probably use everyday, namely collection classes like lists and arrays. We’re quite used to traversing these simply with a foreach loop, and what enables us to do so is that these types implement the System.Collections.IEnumerable interface.

IEnumerable is a rather simple interface that requires implementing a single method, GetEnumerator, which returns an object that implements another interface, IEnumerator. IEnumerator, in turn, encapsulates two methods and a property:

`MoveNext`	called when advancing to the next element in the sequence or collection; it returns false when at the end of the collection.
`Current`	obtains the `System.Object` at the current spot in the collection
`Reset`	reinitializes the list or sequence

Now, let’s say we wanted to build a implementation of a class that returns the first n triangular numbers. One way to do so would be the following:

   1: public class TriNumbers : IEnumerable

   2:      {

   3:          private Int32[] _nums;

   4:          public TriNumbers(Int32 n)

   5:          {

   6:              if (n <= 0)

   7:                  throw new System.ArgumentOutOfRangeException();

8:

   9:              _nums = new Int32[n];

  10:              _nums[0] = 1;

  11:              for (Int32 i = 1; i < n; i++)

  12:                  _nums[i] = _nums[i-1] + i + 1;

  13:          }

14:

  15:          public IEnumerator GetEnumerator()

  16:          {

  17:              return _nums.GetEnumerator();

  18:          }

  19:      }

and then iterate over it with code like this.

class Program
{
    static void Main(string[] args)
    {
        TriNumbers triNums = new TriNumbers(10);
        foreach (var val in triNums)
            Console.WriteLine(val);
        Console.ReadLine();
    }
}

In the implementation of TriNumbers, I sort of ‘cheated’ (line 17) by just deferring the iteration work to the iterator I get for free from the underlying integer array, which is really what’s storing my sequence.

Not that cheating is wrong in this case, but it does require my array to be populated from the get-go, in the constructor. Initializing an array of ten elements is no big deal, but what if the argument to the constructor were much larger? and there are many instances of this class in memory? and what if I only end up iterating over the first couple of values? Clearly I’m using up memory here that isn’t really needed, and I’m taking time to calculate each element of the sequence, when I’m not really even sure I need them all. If the calculation was CPU-intensive or required a series of database or services calls to build the list, there could be a lot of wasted cycles dedicated to populating data that might never be requested in the application.

To make the class a little less wasteful up front, I can implement the IEnumerator interface explicitly – something like this:

public class TriNumbers : IEnumerable
{
    private TriNumbersEnumerator _enum;
    public TriNumbers(Int32 n)
    {
        _enum = new TriNumbersEnumerator(n);
    }

    public IEnumerator GetEnumerator()
    {
        return _enum;
    }

    private class TriNumbersEnumerator : IEnumerator
    {
        private Int32 _limit = 0;
        private Int32 _index = 0;
        private Int32 _value = 0;
        public TriNumbersEnumerator(Int32 n)
        {
            if (n <= 0)
                throw new System.ArgumentOutOfRangeException();
            _limit = n;
        }

        public object Current
        {
            get
            {
                if (_index == 0)
                    throw new System.InvalidOperationException(
                            "Enumeration has not started. Call MoveNext.");
                else
                    return _value;
            }
        }

        public bool MoveNext()
        {
            _index++;
            if (_index <= _limit)
            {
                _value += _index;
                return true;
            }
            else
            {
                Reset();
                return false;
            }
        }

        public void Reset()
        {
            _index = 0;
            _value = 0;
        }
    }
}

That works, but there’s an easier way! Enter yield – not much longer than the original implementation, and certainly less wasteful of space and CPU cycles should the entire sequence not be enumerated.

   1: public class TriNumbers : IEnumerable

   2: {

   3:     private Int32 _limit = 0;

   4:     public TriNumbers(Int32 n)

   5:     {

   6:         if (n <= 0)

   7:             throw new System.ArgumentOutOfRangeException();

   8:         _limit = n;

   9:     }

10:

  11:     public IEnumerator GetEnumerator()

  12:     {

  13:         Int32 val = 0;

  14:         for (Int32 i = 0; i < _limit; i++)

  15:         {

  16:             val += i + 1;

  17:             yield return val;

  18:         }

  19:     }

The magic is on line 17, with the yield return statement. Each time this statement is reached, the current value of val is returned as the value of the IEnumerator reference (namely, what the foreach in the calling program will see). The current location and state of the GetEnumerator method is stored, and so the next time the iterator is called, we’ll get the next value from the for loop in line 14.

While reading IL is not something I do often, it’s interesting to look at what gets generated when using the yield return construct. Using IL DASM, you can see a newobj call to a class called d__0, essentially indicating that there is a new class being constructed under the covers.

IL DASM shows that that class is implementing the IEnumerator interface (the Current property and the Reset and MoveNext methods), so essentially the yield return provides some "syntactic sugar" (more or less) for code similar to the TriNumbersEnumerator class that I wrote above.

The real story is a tad deeper than that though, and Wes Dyer does a great job of looking more closely at the generated class in his blog post. And if you’d like to do all this in Visual Basic, which unfortunately doesn’t have iterators (yet?), take a look at Matthew Doig’s blog.

X is for… XML Literal

joneil — Mon, 15 Jun 2009 07:23:41 GMT

XML Literal(s) is a feature that Visual Basic developers can call their own! The XML Literal syntax facilitates creating XML documents and elements that support the vast majority of the XML 1.0 specification. Complementing the literals are axis properties that aid in navigating and accessing XML elements and attributes.

Let’s start with an example. Below is an XML literal representing a menu; as you can see it’s assigned directly to a variable – here relying on implicit typing.

Dim xml = <menu>
              <course name="appetizer">
                  <dish>Shrimp Cocktail</dish>
                  <dish>Escargot</dish>
              </course>
              <course name="main">
                  <dish>Filet Mignon</dish>
                  <dish>Garlic Potatoes</dish>
                  <dish>Broccoli</dish>
              </course>
              <course name="dessert">
                  <dish>Chocolate Cheesecake</dish>
              </course>
          </menu>

So what is the type of the xml variable? It’s a System.Xml.Linq.XElement, which certainly brings to the forefront the synergy with LINQ (Language Integrated Query). Underneath the covers, the Visual Basic compiler calls the relevant constructors (XElement, XAttribute, etc.) to create the LINQ to XML object.

Note though that xml in the following snippet is an XDocument, because of the inclusion of the xml version tag.

Dim xml = <?xml version="1.0"?>
                  <menu>
                      <course name="appetizer">
                          <dish>Shrimp Cocktail</dish>
                          <dish>Escargot</dish>
                      </course>
                  </menu>

LINQ within XML Literals

You can include LINQ expressions with your literals as well, using an embedded expression syntax reminiscent of ASP! The following code yields the same XML as the first example, but populates it using LINQ to Objects from a hard-coded list; of course, that data could just as easily come from a database or some other external source.

Dim menu As List(Of Dish) = New List(Of Dish)()

menu.Add(New Dish("appetizer", "Shrimp Cocktail"))
menu.Add(New Dish("appetizer", "Escargot"))
menu.Add(New Dish("main", "Filet Mignon"))
menu.Add(New Dish("main", "Garlic Potatoes"))
menu.Add(New Dish("main", "Broccoli"))
menu.Add(New Dish("dessert", "Chocolate Cheesecake"))

Dim xml = <?xml version="1.0"?>
          <menu>
              <course name="appetizer">
                  <%= From m In menu _
                      Where m.Course = "appetizer" _
                      Select <dish><%= m.Food %></dish> _
                  %>
              </course>
              <course name="main">
                  <%= From m In menu _
                      Where m.Course = "main" _
                      Select <dish><%= m.Food %></dish> _
                  %>
              </course>
              <course name="dessert">
                  <%= From m In menu _
                      Where m.Course = "dessert" _
                      Select <dish><%= m.Food %></dish> _
                  %>
              </course>
          </menu>

XML literals can also be traversed via LINQ to XML. For instance, the following snippet will result in a list of each of the dishes, without any XML markup.

Dim dishList = From d In xml.Descendants("dish") _
        Select d.Value
For Each item In dishList
    Console.WriteLine(item)
Next

Axis Properties

Axis properties are a series of syntax elements that enable you to access elements and attributes within the XML. There are three different properties that we’ll take a look at next.

Child axis

The child axis property returns all child elements of the source element. The property is denoted by placing angle brackets around the child elements desired. For example, this code
Dim childAxis = xml.<menu>.<course>
For Each item In childAxis
    Console.WriteLine(item)
Next

results in


  
    <course name="appetizer"> 
      
  <dish>Shrimp Cocktail</dish> 

      
  <dish>Escargot</dish> 

      
</course> 

      
<course name="main"> 

      
  <dish>Filet Mignon</dish> 

      
  <dish>Garlic Potatoes</dish> 

      
  <dish>Broccoli</dish> 

      
</course> 

      
<course name="dessert"> 

      
  <dish>Chocolate Cheesecake</dish> 

      
</course>

Descendant axis

The descendant axis property returns all elements under the source element, regardless of how deeply they are nested. This property is denoted by placing angle brackets around the element desired and separating it from the source element with three periods. For example, the following code produces the same XML as shown for the child axis example above.
Dim childAxis = xml...<course>
For Each item In childAxis
    Console.WriteLine(item)
Next

You can use indexing as well, for instance, to get only the last course, dessert, via the following line
Dim course3 = xml...<course>(2)

Attribute axis

The attribute axis returns the specified attribute (denoted by the @ symbol) of the element on which it operates. For instance, the following code will print out the three courses: appetizer, main, and dessert.
Dim childAxis = xml...<course>
For Each item In childAxis
    Console.WriteLine(item.@name)
Next

For more information on using XML Literals with Visual Basic, check out the MSDN topic, XML in Visual Basic. And for those of you using C#, there’s a neat little add-in that will paste the code necessary to create the XML document that you have stored on the clipboard. Here’s how:

Extract the LinqSamples\PasteXmlAsLinq directory from
C:\Program Files\Microsoft Visual Studio 9.0\Samples\1033\CSharpSamples.zip
Build the PasteXmlAsLinq solution
Copy the PasteXmlAsLinq.dll and PasteXmlAsLinq.Addin files into the Addins folder. This folder is located at My Documents/Visual Studio/Addins, but you may need to create it explicitly.
Restart Visual Studio.
If you have XML in the clipboard (perhaps copied from some other source), you’ll see a Paste XML as XElement menu option in the Edit menu:

Copying the XML literal syntax from the first Visual Basic example in this post into the clipboard and then pasting into a C# script using the menu item above yields the following:

XElement xml = new XElement("menu",
    new XElement("course",
        new XAttribute("name", "appetizer"),
        new XElement("dish", "Shrimp Cocktail"),
        new XElement("dish", "Escargot")
    ),
    new XElement("course",
        new XAttribute("name", "main"),
        new XElement("dish", "Filet Mignon"),
        new XElement("dish", "Garlic Potatoes"),
        new XElement("dish", "Broccoli")
    ),
    new XElement("course",
        new XAttribute("name", "dessert"),
        new XElement("dish", "Chocolate Cheesecake")
    )
);

It’s not exactly an XML literal, but certainly saves a lot of typing!

W is for… WeakReference

joneil — Mon, 08 Jun 2009 07:33:00 GMT

With most of the major development technologies from Microsoft beginning with a “W” – Windows Presentation Foundation, Windows Communication Foundation, Windows Workflow Foundation – there was no shortage of choices for today’s post. But somehow those just seemed too easy, and well, a bit large to tackle in one post.

So, from the depths of the .NET Framework, I settled on a class called WeakReference. A weak reference is essentially a reference to an object that you can access but that is also a candidate for garbage collection. It’s essentially a shade of grey between the absolutes of having an object in memory that has a strong reference (e.g., you’ve got a variable referencing the object) and an object that’s been marked for garbage collection but hasn’t yet been reclaimed.

By creating a weak reference to an object, you’re saying that you’d like to still be able to use it in the future, but it’s not *that* important that it can’t be reclaimed by the garbage collector – in which case, you’ll take the hit for recreating it.

Let’s take a look an example here. It’s a simplified version of the sample from the MSDN reference page, and dare I say, a bit more interesting, since it forces a garbage collection so that you can actually see the weak reference scenario kick in.

The context here is a cache, specifically a wrapper for a Dictionary<int, String>; of course, the String could be any object here. The strings are initialized to just the word “Item” followed by their index in the dictionary. The indexer (line 15) casts the weak reference to a strong one in line 19 to determine whether the object is still available. If the null test (line 22) fails, we know the object has been garbage collected, and we have to create a new one (line 24).

Note, there is an IsAlive property on WeakReference which will return true if the object reference has not yet been garbage collected; however, be aware that in the instant between the positive test for IsAlive and the actual reference of the object, that object could be garbage-collected. It’s recommended that you do the cast and then check for null as I did below.

   1: public class Cache

   2: {

   3:     Dictionary<int, WeakReference> Items;

   4:     public int Count { get { return Items.Count;} }

5:

   6:     String ItemFactory(int i) { return "Item " + i.ToString(); }

7:

   8:     public Cache(int count)

   9:     {

  10:         Items = new Dictionary<int, WeakReference>(count);

  11:         for (int i = 0; i < count; i++)

  12:             Items[i] = new WeakReference(ItemFactory(i), false);

  13:     }

14:

  15:     public String this[int index]

  16:     {

  17:         get

  18:         {

  19:             String d = (String) Items[index].Target;

  20:             Console.WriteLine("Object at {0,2}: {1}", index.ToString(),

  21:                 d == null ? "Regenerated" : "Original");

  22:             if (d == null)

  23:             {

  24:                 d = ItemFactory(index);

  25:                 Items[index] = new WeakReference(d, false);

  26:             }

  27:             return d;

  28:         }

  29:     }

  30: }

Now, let’s take a look at a simple console application to show the weak references in action. I create a Cache object with ten items, and then launch a loop that references items in the cache ‘randomly’ (using the random number generator reference created in line 3). The twist here is that on line 13, a garbage collection is forced on every fifth reference to the cache. That will result in all of the current weak references in the cache being garbage collected.

   1: public static void Main()

   2: {

   3:     Random r = new Random();

   4:     Cache c = new Cache(10);

5:

   6:     // Randomly access objects in the cache.

   7:     for (int i = 0; i < 100; i++)

   8:     {

   9:         Console.Write("{0,2}: ", i);

10:

  11:         String s = c[r.Next(c.Count)];

12:

  13:         if ((i + 1) % 5 == 0) GC.Collect();

  14:     }

  15:     Console.ReadLine();

  16: }

So, lets take a look at the output, below. The first five lines demonstrate accessing the weak references set up in the cache constructor; no garbage collection has yet occurred. The garbage collection occurs at the end of the fifth iteration, and all the weak references in the cache are reclaimed. As a result, when the 3rd item is referenced at iteration 5, the strongly cast reference to

Items[index].Target

(line 19 in the first code snippet above) results in null, and a new weak reference is subsequently re-created. On iteration 8, we get lucky, because the object at index 0 was just recreated in iteration 6.

One thing this example drives home is that the effectiveness of this approach in terms of implementing a cache pattern depends on the frequency of the garbage collection. Here, I forced garbage collection for the sake of example, but it could well be the case that the frequency and cost of re-creating objects outweigh the benefits that the cache was to provide. Jeffrey Richter in CLR via C# cautions:

The problem with this technique is the following: Garbage collections do not occur when memory is full or close to full. Instead, garbage collections occur whenever generation 0 is full, which occurs approximately after every 256 KB of memory is allocated. So objects are being tossed out of memory much more frequently than desired, and your application’s performance suffers greatly.

… Basically you want your cache to keep strong references to all of your objects and then, when you see that memory is getting tight, you start turning strong references into weak references…some people have had much success by periodically calling the Win32 GlobalMemoryStatusEx function and checking the returned MEMORYSTATUSEX structure’s dwMemoryLoad member. If this member reports a value above 80, memory is getting tight, and you can start converting strong references to weak references based on whether you want a least-recently used algorithm, a most-frequently used algorithm, a time-base algorithm, or whatever.

If you look closely at the documentation for WeakReference, you’ll note there is a property called TrackResurrection as well as an overloaded constructor to set this value when creating the weak reference. The default value, which I relied on above, is false, indicating a short weak reference. The alternative, a long weak reference, allows the object to be reclaimed even after finalization.

If your object has a finalizer (or destructor), the garbage collection process actually has to ‘resurrect’ the object to allow the finalizer to run. If you have a long weak reference, you’re allowed to reclaim the object at this stage; with a short weak reference, you can’t. Note that if you did reclaim a long reference at this point, the object has been finalized, so you may end up with an object that has an indeterminate state in terms of the unmanaged resources that the finalizer was cleaning up. To cut to the chase, safe use of long weak references is not for the meek!

V is for… Velocity

joneil — Mon, 01 Jun 2009 07:39:00 GMT

Velocity is the code name (and a cool code name at that) for a highly-scalable, in-memory cache currently in a Community Technology Preview (CTP) stage. The objective of Velocity is to increase performance by enabling your applications to grab data from the cache versus needing to make expensive calls back to the data source, whether that be a traditional relational database management system or an on-premises or cloud-hosted service.

Velocity Physical and Logical Models

The physical configuration of Velocity is as a service (the cache host service) running on one or more servers, known as cache servers. Multiple cache servers are arranged in a ring, the cache cluster, communicating among each other to handle requests for retrieving, storing, and distributing data. The cluster configuration itself may be stored in SQL Server or in a file share.

To the consumer of the cache, the cache cluster is the single entry point, and both the number of servers involved and the actual distribution of data among those servers is immaterial. The image below shows the relationship of the client to the cache cluster and servers; note there are also a PowerShell administration tool and cmdlets provided to configure the cluster.

The logical model of a cache cluster comprises three parts

named cache
region
cache item

A named cache is a logical grouping of data, somewhat like a database, and is defined by a name, expiration and eviction policy (defining when items expire and how are they removed from the cache). You can also enable high-availability, which automatically engages secondary copies of your objects. The secondary objects are kept in sync (strong consistency) and can assume a primary role if the cache host on which the primary object is located fails.

A region is a logical subset of a named cache, something like a table within a database. Regions, which are optional, enable richer retrieval functionality by allowing data to be tagged with one or more descriptive strings (in addition to the unique key for that data). Regions, however, are stored on a single node in the cluster and not load-balanced, so there is a tradeoff between functionality and scalability.

A cache item is any serializable descendant of System.Object. Associated with each cache item is a key and other metadata, including version, creation timestamp, time to live (TTL), etc.

Data Taxonomy

When considering caching technology, it’s important to understand the nature of the data that you are caching. One possible classification is three bins

Reference data
Activity data
Resource data

Reference data are things like tax tables or a product catalog. The data is shared among multiple clients, but it’s essentially immutable, and when it does change the change affects everyone – an updated product list, for instance. Such data lends itself quite well to partitioning, and in Velocity, you can use local cache as well (cache managed within the application process) to get even better performance for frequently accessed items.

Activity data are items that result from the processes that your application initiates. If you’re running an e-commerce site, for instance, the activity data would be things like a shopping cart or customer order. The data here is mutable, but it’s only accessible by a single user. The single access point still allows for partitioning of the data; however, here high-availability is generally required since you don’t want to risk losing information about an activity while that activity is in progress.

Resource data is data that is shared in both a read and write fashion by multiple clients. Inventory data is a classic example – you’re booking a flight via an on-line service, for instance. As you view the flight options, someone else may be booking the last seat on that flight, so in these scenarios options for resolving concurrency issues are paramount. Velocity does support both optimistic concurrency (via version metadata) and pessimistic concurrency (via a locking mechanism).

The nature of the data to be cached will lead you toward specific configuration options for your caches.

Client API

Using Velocity within your own applications is fairly straightforward. There are four assemblies that contain the various classes required by the Microsoft.Data.Caching namespace:

        CASBase.dll 
      FabricCommon.dll 
      CacheBaseLibrary.dll 
      ClientLibrary.dll

When building client applications, you’ll need to add references to the last two of these assemblies within your Visual Studio project. You also need to add some configuration information to the client config file (or programmatically) to specify the location of a cache host (any one in the cluster will do) as well as whether you want the client to act as a simple client or a routing client.

A routing client maintains a lookup table mapping data items to the specific cache host where the object is physically located, so the data is directly retrieved from that server.

A simple client connects to only a single cache host and makes all requests through that host. As a result, the host needs to make additional requests to get to the actual cache host physically storing the data. Simple clients should be use only if there are topology issues such that a client does not have visibility to all the cache hosts in the cluster – generally a rare scenario.

Within the client configuration file, you can also indicate whether a local cache should be maintained. The local cache is stored in the address space of the client application and should be used only to store rarely (if ever) changed data - to reduce the occurrence of stale data.

Within your client code, the access pattern looks something like this:

The code above does not use regions; however, there are overloads of Get and Put that address regions as well. There are also ‘locking’ versions of Get and Put to provide for pessimistic concurrency, where the object is locked from access by other clients.

Also available are callback actions to which a client can subscribe to be informed of additions, modifications, and deletions of items and regions as well as logging capabilities with levels of error, warning, information and verbose.

References

MSDN Data Platform Developer Center

Velocity Team Blog

Community Technology Preview (CTP) 3 download

Sample Code (CTP 2 – needs modification to work with CTP 3)

U is for… unchecked

joneil — Mon, 25 May 2009 07:01:00 GMT

Welcome to the Memorial Day edition of the A-Z series! As I flipped through the index of Pro C# 2008 and the .NET 3.5 Platform, I happened upon the unchecked keyword - one of those things I remember seeing once or twice, but couldn’t really recall what it did or how it worked. As you might expect, there’s a checked keyword too.

unchecked and its positive counterpart come into play when dealing with integer arithmetic and overflow conditions. Recall that the range for an Int16 variable is ‑32,768 to 32,767, so what do you suppose happens with the following code?

Here’s the result, courtesy of 2’s complement; essentially, we’ve ‘wrapped around’ and are now in negative number territory. There were no errors, reported though, and that’s because this is an unchecked operation by default.

The compiler is smart enough to catch a lot of cases of potential conversion issues, like the following:

Subtle difference, huh? It’s essentially the same statement; however, the type promotion rules for the binary operator + differ just enough from the rules for the compound assigment += to result in this behavior. The good news here is that it makes it harder to unwittingly introduce these types of errors: most of the time the compiler will warn you that an explicit cast is required, even if you try to do something to ‘trick’ it, like this:

You do have the option though to use an explicit cast (and take responsibility for the consequences), and so the following code results in the same erroneous output that I started the post off with:

If you’re really concerned about these types of errors impacting your application, you can use the checked keyword/method, in which case an OverflowException is thrown if there is numeric overflow (which, of course, you’d then be catching to handle a bit more gracefully than this):

By the way, another way to write the checked logic is as follows:

It should be clear by now that by default your code is executing in an unchecked mode. That may seem more dangerous, but given the warnings you get about casting when writing your code, there shouldn’t be too much of an opportunity for surprises. It’s also expensive to make these checks at runtime, so rather than make everyone pay a performance penalty, the default is to let the overflow go undetected at runtime.

But what if you’d still prefer to err on the side of caution, or perhaps you’re working with less-than-robust 3rd party code that you can’t fix at the moment? If you click the Advanced button on the Build tab of your project, you can turn on the automatic detection of overflow and underflow:

… and now the original example throws an exception too.

We’re now erring on the side of caution, but what if there’s now code that we know will cause an overflow/underflow, but we don’t care? Now that I’ve turned it on everywhere, how do I turn it off? As you might expect, that’s where unchecked comes in. To let my original code succeed in spite of the Build property being changed, I can change my code to the following, and it ‘works’ again.

It turns out you can nest the checked and unchecked sections too, which promises to add up to a maintenance nightmare, but it’s nice to know you can do it.

T is for… Tracepoint

joneil — Mon, 18 May 2009 07:01:00 GMT

I’ve presented various sessions on Debugging Tips and Tricks as part of the Northeast Roadshow and MSDN Events series, and one of the undiscovered gems in that presentation is that of tracepoints. Tracepoints have actually been around since Visual Studio 2005, but weren’t all that discoverable until Visual Studio 2008.

What exactly is a tracepoint? It’s essentially a breakpoint that doesn’t halt the execution of your application in the debugger. Instead, it provides the opportunity to write information to the output window, with much the same effect that Trace.WriteLine has, but without requiring code to do it. You can also use tracepoints to run macros for more advanced debugging scenarios.

To get an idea of how to employ tracepoints, here’s a YACE (yet-another-contrived-example) that builds a list of the prime numbers between two input numbers. There are far better algorithms than this for performing this task, so don’t focus too much on the logic, lack of bounds checking, coding style, performance issues, etc.

   1:  List<Int32> primeList = new List<Int32>();

   2:  Boolean isPrime;

3:

   4:  if ((startVal <= 2) && (endVal >= 2)) primeList.Add(2);

5:

   6:  for (int candidate = Math.Max(3, startVal); candidate <= endVal;

   7:           candidate++)

   8:  {

   9:      isPrime = true;

  10:      int maxTest = (int) Math.Sqrt(candidate) + 1;

11:

  12:      for (int testVal = 2; (testVal < maxTest) && isPrime; testVal++)

  13:          if (candidate % testVal == 0)

  14:              isPrime = false;

15:

  16:      if (isPrime) primeList.Add(candidate);

  17:  }

If I employ this logic in a simple console application, and set startVal to say 700 and endVal to 800, I’ll get output such as the following:

Now, lets say I’m looking at the output and really wondering why 703 and 713 didn’t make the list. They “look” prime – at least they don’t pass those handful of quick tests we learned in junior high – so I’m curious as to what factor kicked them out of the list. It’s the code at lines 13 and 14 where a divisor is detected for a candidate prime number, and that divisor is testVal.

I could put some code in there using System.Diagnostics.Trace to output testVal at that point, but it’s going to require me to introduce more code, as well as some logic, perhaps, to print out only when it’s dealing with the values 703 and 713. And, maybe it’s not even my code to be tinkering with.

One option here is to introduce a tracepoint on line 14 to capture just the information you want but without causing execution to stop as a breakpoint would. You can insert a tracepoint by right-clicking on a line of code and selecting the option from the context menu as you see here:

Alternatively, you can click on the gutter to add a breakpoint, and then use the When hit… menu item to convert it from a breakpoint into a tracepoint (note the diamond shape versus the circle in the gutter):

Both of these mechanisms bring up a dialog with two main options

Print a message, or
Run a macro

Regardless of which option you choose, you can elect to continue execution or break (as a normal breakpoint would). By default, when you select either the Print a message or Run a macro option, the Continue execution box will be checked.

Print a message

When you choose to Print a message, the verbiage no longer has the disabled look, and you can use the textbox to indicate what you want to display in the output window. The Function and Thread information are there as a default and demonstrate that you have access to a number of debugging environment values (which are described on the dialog). You can also include your own variables and expressions enclosed in curly braces. For our scenario here, I’ve set up the tracepoint as follows:

When I execute the application now, it runs to completion, but within the Output window, I get the information I was looking for, and I can see that 703 is divisible by 19 and 713 by 23.

Keep in mind it’s still a breakpoint too, so the other options on a breakpoint apply to activating the tracepoint as well. For instance, if I really want the trace information written for only 703 and 713, then I can set up a breakpoint condition such as the following:

The output will show as on the right, and execution will continue. In such a case, the tracepoint glyph will include a white cross

indicating that there are advanced options set.

Run a macro

The Run a macro option gives you even more power for handling a tracepoint, but presumes you’re willing to work for it by writing a bit of Visual Basic for Applications script to implement a macro. The dropdown list already provides a number of options; these are macros that come with Visual Studio, and the ones in the Macros.Samples.VSDebugger namespace are the most germane here.

Now, the ShowCurrentProcess macro here isn’t all that interesting, but when engaged will display the path to the current process in the output window.

You can examine the implementation of this macro and the other others listed in the dropdown list by opening the Macros IDE (Alt+F11).

A closer look at the implementation below reveals the use of the EnvDTE namespace and the OutputWindowPane, Process, and DTE objects within that namespace.

' This function displays the current debugger mode in the output window.

 Sub ShowCurrentProcess()

     Dim outputWinPane As EnvDTE.OutputWindowPane

     Dim proc As EnvDTE.Process

     outputWinPane = Utilities.GetOutputWindowPane("Debugger")

     proc = DTE.Debugger.CurrentProcess

     If (proc Is Nothing) Then

         outputWinPane.OutputString("No process is being debugged")

     Else

         outputWinPane.OutputString("" + Str(proc.ProcessID) + ": "

             + proc.Name + vbCrLf)

     End If

End Sub

DTE is the top most object in the Visual Studio automation model and provides access to the debugger as well as the IDE including toolbars, commands, the active document, and more. With programmatic control of these objects, you can create more advanced breakpoints and tracepoints, like, for instance, one that would analyze the stack trace and break only if method bar was called by method foo.

Check out the MSDN documentation on Visual Studio Extensibility for more information on building your own macros.

S is for… sqlmetal

joneil — Mon, 11 May 2009 07:00:00 GMT

sqlmetal is one of the rare cases where a Microsoft utility or application ends up seeing the light of day with a cool name! If you’re working with LINQ to SQL you may know what sqlmetal is, but since much of what it does is part of the Visual Studio designer experience there’s a fair chance you’ve been doing LINQ to SQL work and had no idea it existed.

sqlmetal is a command-line utility that you can use in lieu of the built-in Visual Studio designer to create a dbml (database markup language) file that defines the entities and DataContext for LINQ to SQL models. The utility is installed with the SDK that accompanies Visual Studio; on my machine I found it in

C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin

For sake of examples in the post, I’ll use the timeless Northwind database as the targeted database.

LINQ To SQL within Visual Studio

Within the Visual Studio environment, creating a LINQ to SQL model is pretty straightforward:

You add a new item in the Data category

and up comes the visual designer where you can drag and drop tables and procedures to the surface

save, and you get a couple of files created for you

the dbml file, a file that captures the schema from the database in XML format,

the layout file, an XML file used by the visual designer, and

the designer.cs file, which contains generated classes for the tables (entities) in the database.

LINQ to SQL with sqlmetal

With sqlmetal you can accomplish essentially the same task in two steps

1. Generate the dbml file, and

2. use the dbml file to generate the classes

There isn’t a layout file in this case, of course, since we’re doing everything outside of the Visual Studio IDE.

Output Comparison

I thought I might try to compare the files generated from within Visual Studio to those output by sqlmetal, expecting them to be nearly identical, but I stumbled upon some differences:

The designer default is to use smart pluralization, so from the Categories table, for instance, I’d get a class named Category. In sqlmetal, the default is to not do this, but you can use the /pluralize switch to engage that feature.
Associations between tables generated by sqlmetal have a naming convention of FK_foreignkeytable_primarykeytable, whereas the designer produces the name primarykeyentity_foreignkeyentity
sqlmetal adds a DeleteRule="NO ACTION" to primary key associations, but since that’s the default, the lack of the attribute in the designer-generated version is inconsequential.
Similarly, the sqlmetal generated code file explicitly includes CanBeNull="true" for some columns (I saw it specifically on the Image type), but true is the default for that attribute as well, so leaving it off is not an issue.

Which Method to Choose?

While I was a little surprised by the discrepancies in the files, none of them really affect the functionality. So, given that, why bother with the effort of bringing up the command-line, executing two commands, and importing files into your project, when you can get the same result right within the Visual Studio IDE? Here’s a couple of reasons to consider.

1. Performance

With large databases, the Visual Studio designer can be a bit slow. After all, it’s handling not only the dbml and code file generation, but also the visual layout of the classes and relationships. The point at which this becomes noticeable, as many other such variables, depends.

2. Scriptability

If you’re using msbuild scripts, for instance, then command line operations are right up your alley. If your schema is in a state of flux, using sqlmetal within a batch script is a reasonable method to refresh the dbml and code files. Within the Visual Studio IDE there isn’t a 'synchronize to database’ option, so if your schema changes, you have no recourse but to recreate the model from scratch in Visual Studio (or hack into the IDE-generated files).

Of course, if your schema is too volatile you’ll have issues in that developers may have written code addressing various entities and properties (tables and columns) that no longer compiles if you’ve renamed them, changed types, etc.

3. Flexibility

One of the criticisms of the default LINQ to SQL generation is the heavy use of attributes on the generated classes. Each entity has an attribute relating it to the table schema, and each property has an attribute relating it to the associated column’s properties. For instance, here’s a snippet of code for the TerritoryID property.
[Column(Storage="_TerritoryID", 
   DbType="NVarChar(20) NOT NULL", 
   CanBeNull=false, IsPrimaryKey=true)]
public string TerritoryID
{
    get
    {
        return this._TerritoryID;
    }
    set
    {
        if ((this._TerritoryID != value))
        {
            this.OnTerritoryIDChanging(value);
            this.SendPropertyChanging();
            this._TerritoryID = value;
            this.SendPropertyChanged("TerritoryID");
            this.OnTerritoryIDChanged();
        }
    }
}

Many developers are strong proponents of POCO (Plain-old CLR classes) and would prefer to use classes that are not marked by the various attributes tying the object to the underlying data store.

With sqlmetal, you have the option to generate an external XML mapping and nearly-POCO classes for your entities (below). By the way, I say nearly-POCO based on the fact that the classes generated still incorporate EntityRef and EntityState classes, thus pulling in the LINQ infrastructure. Classes and properties are, however, unadorned by attributes.

The resulting map XML file looks quite a bit like the dbml file, however, it includes a member and storage attribute to tie the abstracted model back to specific properties and storage fields in the POCO class, a class you might even have coded from scratch yourself.

In fact, this mapping file can help insulate you from backend changes in the database as well. For example, if the name of the field in the database changes, you need only update the mapping file. No modification of class files is needed – something impossible to do with the default attribute-based approach.

Instantiating your LINQ to SQL DataContext to incorporate a mapping file merely involves using an overloaded constructor that accepts a MappingSource, like this:

String connString = ConfigurationSettings.
     AppSettings["NorthwindConnectionString"];
XmlMappingSource map = XmlMappingSource.FromStream(
     File.Open("northwind.xml", FileMode.Open));
Northwind ctx = new Northwind(connString, map);

Additional References

If you want to look a bit more under the covers of sqlmetal, here’s a couple of reference links on MSDN:

Code Generation Tool (SqlMetal.exe)

Code Generation in LINQ to SQL

External Mapping Reference (LINQ to SQL)

There is no shortage of posts on techniques for using POCO with LINQ To SQL; a Live Search will bring you to plenty of reading on the subject! One of the hits even led me to an open source project on CodePlex called Close2Poco. I haven’t had a chance to check it out, but it takes the trivial setup I proposed here much further toward reality.

R is for... REST

joneil — Mon, 04 May 2009 07:08:05 GMT

REST stands for Representational State Transfer, an acronym coined by Dr. Roy Fielding in 2000 as part of his doctoral dissertation at the University of California, Irvine.

As Dr. Fielding states in Chapter 6,

Since 1994, the REST architectural style has been used to guide the design and development of the architecture for the modern Web.

REST is technically a formalization of his approach to building distributed network architectures, with the World Wide Web being the canonical example of its application. Today, however, REST is often positioned as an alternative technology to SOAP (Simple Object Access Protocol) for the implementation of web services. To that end:

REST is defined by four interface constraints: identification of resources; manipulation of resources through representations; self-descriptive messages; and, hypermedia as the engine of application state.

Section 5.1.5

Identification of Resources

A REST approach to services treats everything on the web as a resource, and every resource has a name – its Uniform Resource Identifier (or URI). A SOAP-based approach, in contrast, is operation-centric where the focus is on using the URI essentially as a method call, with parameters provided on the query string, as form variables, or perhaps in an encoded message body.

For sake of example, let’s look at Amazon’s Simple Storage Service (S3). The service provides functionality to store arbitrary objects in the cloud, by assigning them to ‘buckets’ created within the storage account (similar to a one level directory/file structure). So, your resource in this case can easily be expressed as a URI, such as

http://s3.amazonaws.com/mybucket/myobject

This URI, if provided in browser client for instance, will result in retrieving that particular resource (by virtue of the default GET action, which we’ll get to shortly).

Contrast that with a SOAP approach, which would be routed to a common URL:

http://s3.amazonaws.com/soap

and require a payload SOAP message similar to

<GetObject xmlns="http://doc.s3.amazonaws.com/2006-03-01">
  <Bucket>mybucket</Bucket>
  <Key>myobject</Key>
  <GetMetadata>true</GetMetadata>
  <GetData>true</GetData>
  <InlineData>true</InlineData>
  <AWSAccessKeyId>1D9FVRAYCP1VJEXAMPLE=</AWSAccessKeyId>
  <Timestamp>2009-05-01T12:00:00.183Z</Timestamp>
  <Signature>Iuyz3d3P0aTou39dzbqaEXAMPLE=</Signature>
</GetObject>

The contrast in approaches here is rather apparent. In REST, the object or resource you’re addressing is immediately discoverable, whereas in a SOAP approach, the URI tells you next to nothing, and you have to parse the XML message payload to determine both what you want to do (GetObject) and to what you want to do it (<Bucket> and <Key>).

Manipulation of Resources through Representations

The representation of a resource indicates the specific sequence of bytes that describes that resource. A resource's representation isn’t absolute and can be driven by information sent in the message that acts upon the resource. The ability to provide alternative representations provides a nimbleness that allows the resource to be treated in a format most conducive to the application at hand.

For instance, in the implementation of ADO.NET Data Services, a REST-based technology in .NET 3.5 SP1 for exposing data models over the web, two representations can be returned for a given resource depending on the Accept: HTTP header passed in the request:

The default format is Atom Publishing Protocol (AtomPub)
The alternative format, JavaScript Object Notation (JSON), can be engaged by setting the Accept header’s value to application/json

The default format provides integration with other applications that support the AtomPub format and also with rich client applications, such as Silverlight, that interface with Data Services. That format, however, isn’t as efficient when accessing services from within an AJAX-based client, and that’s where JSON comes in, providing a more compact format that can be quickly serialized for manipulation in the browser’s document object model (DOM).

Self-descriptive messages

In terms of RESTful services, the message transport is generally HTTP, a protocol that includes a number of operations that can be applied to the resource specified in the URI. Most implementations support the use of the following HTTP verbs to provide manipulation of the resource:

GET	Retrieve a resource representation
POST	Create a new resource based on representation provided in the HTTP message
PUT	Update a resource given the representation provided in the HTTP message
DELETE	Delete the resource

Conveniently, these operations correspond to the CRUD (Create-Read-Update-Delete) operations that are part of most data-centric applications. It’s this simple HTTP verb + URI approach for data access and manipulation that has propelled REST based services to become the mechanism of choice for simple data access in distributed applications.

Hypermedia as the engine of application state

The protocol of the web, HTTP, is at its core stateless, which has made life difficult for developers trying to build applications. Concepts such as cookies, ViewState in ASP.NET, and storing information in databases have all been used to overlay a sense of statefulness on the web.

REST has a goal “to improve server scalability by eliminating any need for the server to maintain an awareness of the client state beyond the current request.” A direct result of this is that the representation returned from a RESTful request must contain the entire state of the application at that point. That includes not only data, but also the enumeration of what you can do next in the application.

For example, consider a shopping cart application on which you’ve just done a search for an item. Such applications often make use of a cookie to tie the session to the stateful shopping cart for that user maintained on the server. Strictly speaking, this breaks the RESTful paradigm, since the state of the application is not wholly described by the current page – it takes the cookie value to provide the connection between this set of search results and the current user. If the page included a hidden field, for instance, that provides an ID for the user’s cart (which itself would be considered a resource in the REST paradigm), then the RESTful constraint would be met.

Q is for... Quirks

joneil — Mon, 27 Apr 2009 07:05:00 GMT

Quirks… we all have them, but rather than get too personal, we’ll constrain the domain for this post to web browsers.

In the early days of the web – pre-HTML and CSS (cascading style sheet) standards – browsers varied considerably over what features they implemented and how. Over time standards matured, and browser vendors have sought to come into full compliance with developing HTML and CSS standards (which is a good thing); however, it leaves a number of old and often broken pages out there which demand backward compatibility.

That’s where quirks mode comes in. It’s not an IE-specific concept, and essentially defines a baseline, pre-standards behavior for web page rendering. In any recent version of IE, for example, quirks mode means a page will display as it would in IE 5.5. The alternative to quirks mode is known as standards (or strict mode), and different browsers have different rules for determining which rendering mode to use. Those rules are founded in a concept known as doctype sniffing or doctype switching introduced with IE 5.0 for the Macintosh.

In IE8 (and IE7 for that matter), the presence of a <!DOCTYPE> declaration will often trigger standards (strict) mode. For instance, the Microsoft home page includes this declaration indicating standards mode:

<!-- DOCTYPE html PUBLIC 
   "-//W3C//DTD XHTML 1.0 Transitional//EN" 
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" -->

The absence of such a declaration will always trigger quirks mode, which makes sense since old-school pages, the ones relying on pre-standards behavior, were written before <!DOCTYPE> was a twinkle in Microsoft’s eye. Knowing which <!DOCTYPE> declarations indicate standards mode versus quirks mode in IE can be a bit of a challenge, so consult this table on MSDN for specifics. (For Mozilla-based browsers, like Firefox, check here, and for Opera, see here).

If you want to know what mode a given page is displayed in, you can use the nifty new Developer Tools in IE8 (accessible via Tools>Developer Tools or F12), which displays the Document Mode in its menu bar. For sake of example, the Amazon site does not have a <!DOCTYPE> tag and therefore renders in quirks mode, as the toolbar shows below:

You can also determine the mode of a page by executing a little JavaScript right from the URL text box in the browser. Below, the response of 5 indicates quirks mode. Other options are 7 and 8, indicating the standards mode operations of IE 7 and 8. For more detail on these modes, as well as how they work hand-in-hand with IE8’s compatibility view, check out my IE blog post of a couple of weeks ago.

Now as I mentioned before, quirks mode is not an IE-specific thing. For instance, it turns out that default home page for Firefox displays in quirks mode as well. In Firefox, you can use the View Page Info context menu option on the page to determine the mode:

What about other browsers? Opera? Safari? Use the document.compatMode property, which returns one of two values

BackCompat indicating quirks mode, or
CSS1Compat indicating standard mode (or almost-standards mode, more on that here)

For instance, Opera 9.64 reports the mode of amazon.com as follows

while Safari 4 shows microsoft.com as:

Now, you might be wondering why we used document.documentMode in the IE sample earlier, but document.compatMode here. With IE8, compatMode is deprecated in favor of documentMode, which has more granularity to differentiate between IE7 standards mode and IE8 standards mode. Of course, since this is an IE-specific DOM extension, it’s not going to work cross-browser.

Now, don’t let all this discussion distract you from what should be a goal of creating standards-compliant sites from now on. Quirks mode is there to support existing sites, kind of like the VHS player I keep around at home. If you haven’t graduated to updated standards (like DVDs) for your mainstream requirements, then yeah, you are a bit quirky yourself!

P is for… Partial Method

joneil — Mon, 20 Apr 2009 07:01:00 GMT

By now, most of you are likely familiar with the concept of partial classes, introduced in .NET 2.0 to both C# and Visual Basic. Simply put, classes can be marked with the partial keyword indicating that their implementation is split over multiple physical source code files.

This technique is quite apparent when you look at Windows Forms code files, where the designer.cs (or .vb) file contains a partial class representing the form. The designer class file contains a lot of glue code to create and initialize form controls and properties, so mucking around in it to add your own code and customization has always been an invitation for disaster: one errant Ctrl-X and you could be in for some rework.

With partial classes though, you can create another code file and just re-declare the class, again with the partial keyword, and via compiler magic the two separate code files will be combined into a single binary image – just as if you’d coded it in one place. It’s essentially syntactic sugar that helps promote separation of concerns and maintainability within your applications.

So that’s a partial class, but I though we were talking about partial methods?!

Indeed! Partial methods are less well known, but offer an interesting construct for extensibility at a lower level. You can think of a partial method as a place holder for an implementation that may (or may not) be provided.

One technology that demonstrates the value and power of partial methods is the ADO.NET Entity Framework (as does its cousin, LINQ to SQL). The Entity Framework is an object-relational mapping (ORM) framework that exposes an underlying data model as a set of .NET classes, essentially ‘objectifying’ and abstracting the data model, so that you can program to objects and let the framework worry about persisting modification to the ultimate data store, often a relational database.

With the Entity Framework you can generate a data model that maps objects directly to database tables (although the technology as a whole is far more powerful than that). So, for instance, when I use the Entity Framework against the venerable Northwind database, I’ll get a series of classes representing entities (here, tables) in the model, for example.

[global::System.Data.Objects.DataClasses.EdmEntityTypeAttribute(

    NamespaceName = "NorthwindModel", Name = "Categories")]

[global::System.Runtime.Serialization.DataContractAttribute(

    IsReference = true)]

[global::System.Serializable()]

public partial class Categories :

    global::System.Data.Objects.DataClasses.EntityObject

...

[global::System.Data.Objects.DataClasses.EdmEntityTypeAttribute(

    NamespaceName = "NorthwindModel", Name = "CustomerDemographics")]

[global::System.Runtime.Serialization.DataContractAttribute(

    IsReference = true)]

[global::System.Serializable()]

public partial class CustomerDemographics :

    global::System.Data.Objects.DataClasses.EntityObject

...

Note, the classes here, Categories and CustomerDemographics, are partial classes as well. Like a Windows Forms designer file, this model file is not really meant to be edited, since it will be refreshed whenever the model is modified through the visual design surface. Extensions should be made in a separate file where these classes are ‘repeated’ and additional code added to customize the behavior according to the needs of the application.

As you might suspect, if each table is represented as a class, each column in the table is represented as a property. So just as the Northwind table has a CategoryID, CategoryName, Description, and Picture column, so will the Entity Framework class have properties with the same names and types. The class actually exposes additional properties as well, namely collections that reflect relationships with other tables. So for instance, the Categories class has a property called Products, which contains all of the products in the specific category. This particular property exist because of the primary/foreign key relationship between the two tables, thereby making manifest the power of ORM technologies!

Let’s take a look at the implementation of one of those properties, CategoryName:

   1:  [global::System.Data.Objects.DataClasses.EdmScalarPropertyAttribute

   2:        (IsNullable = false)]

   3:  [global::System.Runtime.Serialization.DataMemberAttribute()]

   4:  public string CategoryName

   5:  {

   6:      get

   7:      {

   8:      return this._CategoryName;

   9:      }

  10:      set

  11:      {

  12:      this.OnCategoryNameChanging(value);

  13:      this.ReportPropertyChanging("CategoryName");

  14:      this._CategoryName = global::System.Data.Objects.DataClasses.

  15:                        StructuralObject.SetValidValue(value, false);

  16:      this.ReportPropertyChanged("CategoryName");

  17:      this.OnCategoryNameChanged();

  18:      }

  19:  }

  20:  private string _CategoryName;

  21:  partial void OnCategoryNameChanging(string value);

  22:  partial void OnCategoryNameChanged();

Note lines 21 and 22 where two of the methods are defined with the partial keyword. These methods are invoked by the property setter at lines 12 and 17, and can be thought of as lightweight events.

Currently, there is no implementation for those methods, so when this class is compiled the calls are essentially removed and there will be no trace of the method in the resulting IL (Intermediate Language). Since the implementation is optional, it’s a cleaner alternative than conditional compilation (#IF DEFINED) or dummy virtual method implementations.

Let’s say though that I want to extend the class definition here and ensure that the CategoryName always starts with a letter and is at least 5 characters long. To enforce that constraint, I can provide an implementation of OnCategoryNameChanging to enforce the rule and throw an exception if the value to be assigned does not meet the requirements. So, I’ll create a partial class in another file and implement the partial method there:

using System;
using System.Text.RegularExpressions;

namespace PartialMethodTest
{
    public partial class Categories
    {
        partial void OnCategoryNameChanging(string value)
        {
            if (!Regex.IsMatch(value, "^[A-Z].{4}") )
                throw new ArgumentException("Category Name is not valid");
        }
    }
}

Now we need to write a bit of code to test this out. I’m just using a simple console application to instantiate the model and grab the first category in the list. Then, I hardcode an invalid name to trigger the exception:

using System;
using System.Linq;

namespace PartialMethodTest
{
    class Program
    {
        static void Main(string[] args)
        {
            NorthwindEntities ctx = new NorthwindEntities();
            Categories firstCategory;

            firstCategory = ctx.Categories.FirstOrDefault(c => true);
            Console.WriteLine("The original category is: " +
               firstCategory.CategoryName);

            try
            {
                firstCategory.CategoryName = "1NET";
            }
            catch (ArgumentException exArg)
            {
                Console.WriteLine(exArg.Message);
            }

            Console.WriteLine("The modified category is: " + 
               firstCategory.CategoryName);
            Console.ReadLine();
        }
    }
}

The result, as you might expect, is something like:

So, with partial methods, I can pretty handily build a validation layer that is separated from my actual model. If I need to swap in a different set of validation logic to customize an application for one customer versus another, it’s a piece of cake.

The last thing I want to do here is drive home the point that a partial method invocation is not compiled into IL unless there is an implementation provided for it. To show that, let’s point ILDASM at the generated assembly, and look at the implementation for the setter of the CategoryName property. You can see a call to OnCategoryNameChanging but no call to OnCategoryNameChanged, which if you take a look at the C# code earlier in this post, is the last method that would be invoked in the setter. It’s not in the IL, because it’s a partial method, and we did not provide an implementation for it – no execution overhead and no code bloat for functionality you opt out of. Pretty cool, huh!

O is for… Oomph

joneil — Mon, 13 Apr 2009 07:01:00 GMT

Oomph?! no, I’m not making it up. Oomph is a toolkit for developers facilitating the incorporation of microformats into web applications.

Ok, so what are microformats, you ask? Here’s a definition from the go-to site on the subject, microformats.org:

Designed for humans first and machines second, microformats are a set of simple, open data formats built upon existing and widely adopted standards. Instead of throwing away what works today, microformats intend to solve simpler problems first by adapting to current behaviors and usage patterns (e.g. XHTML, blogging).

A Microformat Primer

What microformats do is apply existing XHTML tags to provide semantic meaning to a set of data. For instance, the vCard format (RFC2426) was introduced in the mid-90s as a file format to disseminate business contacts, but as you can see it’s a format meant for machines first:

BEGIN:VCARD VERSION:2.1 N;LANGUAGE=en-us:O'Neil;Jim FN:Jim O'Neil ORG:Microsoft TITLE:Developer Evangelist ADR;WORK;PREF:;;201 Jones Road;Waltham;MA;02541;United States of America LABEL;WORK;PREF;ENCODING=QUOTED-PRINTABLE:201 Jones Road=0D=0A= Waltham MA 02451 URL;WORK:http://blogs.msdn.com/jimoneil EMAIL;PREF;INTERNET:jim.oneil@microsoft.com REV:20090411T015215Z END:VCARD

The associated microformat is known as hCard and uses existing XHTML markup to contain the same information as part of a web page. Here’s the equivalent hCard information, along with the markup:

Display

Jim O'Neil
Microsoft
jim.oneil@microsoft.com

201 Jones Road
Waltham, MA, 02451 United States

Markup

<div class="vcard">
   <a class="fn url" href="http://blogs.msdn.com/jimoneil">
      Jim O'Neil</a>
   <div class="org">Microsoft</div>
   <a class="email" href="mailto:jim.oneil@microsoft.com">
      jim.oneil@microsoft.com</a> 
   <div class="adr">
      <div class="street-address">201 Jones Road</div>
      <span class="locality">Waltham</span>, 
      <span class="region">MA</span>, 
      <span class="postal-code">02451</span> 
      <span class="country-name">United States</span> 
   </div>
</div>

To the web page viewer the display looks no different than if had it been included with traditional markup; however, now that the markup exposes some semantics, it can be treated as a collection of data with specific meaning, and therein lies the value.

Oomph Microformat Toolkit

The Oomph Microformat Toolkit, which you can download from CodePlex, facilitates the use of microformats with three primary offerings:

an aggregator that detects microformats on the page and provides an overlay allowing users to quickly store calendar appointments (hCalendar) and contact information (hCard) to their local machine
a library of 14 CSS styles to be applied to hCard and hCalendar microformats
a Live Writer plug-in to ease the effort in producing microformats

Aggregator

An IE add-in included with the toolkit enables end-users to have web pages light up with the gleam (the icon you should see at the upper left of this page) when microformats are detected. The gleam can also be enabled by developers simply referencing two JavaScript files (one for jQuery and one for Oomph) to their pages. [Note: the IE add-in injects the needed JavaScript if not explicitly included on the page. If you’re developing your own pages with microformats, including the JavaScript yourself will ensure a consistent cross-browser experience for your users].

When hovering over the gleam, an overlay appears providing an interface to add the detected hCalendar and hCard items to your local calendar and contact list. Since I included a sample hCard in my post above, this page itself should be exhibiting the gleam at the upper left corner and when clicked result in the following overlay:

There are no event (hCalendar) entries, but my contact information does appear on the right, along with icons below it to add to my Outlook, Yahoo, or Mac contacts, and since my contact includes a location, I can select the map (or globe) icon at the upper left, and it will plot the locations on Virtual Earth! Cool, huh!

CSS Styles

If you don’t like the default overlay presentation, you can change it by modifying the oomph.js file that is part of the toolkit (and referenced on the target page). Or, if you simply want to reskin the display, there are multiple CSS files accompanying the toolkit that you can install on your server and reference within your microformat-outfitted pages. Here’s a couple of static samples (this page isn’t outfitted with the CSS file to see them ‘live’).

Live Writer plug-in

The Microsoft installer image includes the IE add-in, the CSS files referred to above, and a Live Writer plug-in to aid in authoring hCard microformats for your site. The plug-in collects the contact information and generates the requisite markup.

There are a few more Live Writer plug-ins available outside of Oomph as well:

Event Plugin (hCalendar)
Geo Microformat
XFN Link (XFN stands for XHTML Friends Network and is a microformat to capture human relationships via the rel attribute)

More Information

Here’s a number of additional Microsoft resources on Oomph and several links of note on the subject of microformats in general.

Oomph CodePlex project (documentation direct link)

Oomph on MIX On-Line

Oomph PDC Session (on Channel9)

Designing with Microformats (article by Tim Aidlin)

microformats.org

Microformats: Empowering Your Markup for Web 2.0 (on Amazon)

N is for… Nullable

joneil — Mon, 06 Apr 2009 07:10:00 GMT

Nullable<T> is a generic structure introduced with the .NET Framework 2.0 to support the concept of an undefined value. The T in Nullable<T> is a value type; reference types, like strings, support nullability by design. For instance, in C#:

String s = null; // works fine!
Int32 i = null;  // compilation error: cannot convert null to 'int'
                 // because it is a non-nullable value type

Note that since Nullable<T> is a structure, it’s a value type itself and therefore fairly lightweight. It’s the same size as the underlying type with the additional overhead of a boolean field, and instances are still placed on the stack versus the heap.

Fundamental to the type are the two properties Value and HasValue. HasValue is a boolean property that indicates whether or not the Value property is assigned. The code snippet below, for instance, yields the output that follows and throws an InvalidOperationException on Line 10 because of the attempt to access the Value property of the null-valued j.

   1:  Nullable<Int32> i = 5;

   2:  Nullable<Int32> j = null;

3:

   4:  Console.WriteLine(i.HasValue);

   5:  Console.WriteLine(i == null);

   6:  Console.WriteLine(i.Value);

7:

   8:  Console.WriteLine(j.HasValue);

   9:  Console.WriteLine(j == null);

  10:  Console.WriteLine(j.Value);

As you might expect, there’s some shortcuts available too. For instance, you can access i.Value as just i, and i.HasValue == false is equivalent to the condition i == null. There’s also a GetValueOrDefault method available, which will perform the null test and return the default value of the underlying type if the current value is actually null.

And there’s even a bit more syntactic sugar, as both C# and Visual Basic support the use of the ? as part of a synonym notation, so the following declarations are equivalent:

C# declarations		Visual Basic declarations
Nullable<Int32> i; Int32? i;		Dim i As Nullable(Of Int32) Dim i As Int32? Dim i? As Int32

Nullable types support both explicit and implicit conversions to their non-nullable counterparts, so consider the following C# snippet:

   1:  Int32  i;

   2:  Int32? j;

3:

   4:  i = j.Value;    // ok, but throws exception if j is null

   5:  i = (int) j;    // ok, but throws exception if j is null

   6:  i = j;          // compilation fails, explicit cast required

7:

   8:  j = null;       // null assignment

   9:  j = 10;         // implicit cast to nullable type

  10:  j = i;          // implicit cast to nullable type

Note, in Visual Basic, Option Strict is off by default, so in Visual Basic Line 6 would not cause a compilation error in the default scenario.

To make the scenarios in Lines 4 and 5 above bulletproof, you can test for the null in multiple ways as shown below:

Visual Basic

   1:  Int32  i;

   2:  Int32? j = null;

3:

   4:  if (j.HasValue)

   5:      i = j.Value;

   6:  else

   7:      i = 0;

8:

9:

  10:  if (j != null)

  11:      i = (int)j;

  12:  else

  13:      i = 0;

14:

15:

  16:  i = j.GetValueOrDefault();

17:

  18:  i = j ?? 0;

   1:  Dim i As Int32

   2:  Dim j As Int32? = Nothing

3:

   4:  If (j.HasValue) Then

   5:     i = j.Value

   6:  Else

   7:     i = 0

   8:  End If

9:

  10:  If (j <> Nothing) Then

  11:     i = CType(j, Int32)

  12:  Else

  13:     i = 0

  14:  End If

15:

  16:  i = j.GetValueOrDefault()

17:

  18:  i = If(j, 0)

Lines 4 through 16 are variations on constructs we’ve already discussed, and while they are all safe, the if constructs are clunky, and the GetValueOrDefault doesn’t offer much choice when the underlying value is indeed null. That’s where the coalesce operators on Line 16 (?? in C#, and If(x,y) in Visual Basic) come in. Each returns the value of the first argument (j) if the underlying value is non-null, and the second value (zero, here) if not.

This can come in handy when dealing with nullable boolean types for instance, since they cannot be used in C# conditional statements. Presuming you want to interpret a null as a false condition, the following snippet would work well; however, you might want to strongly consider whether use of three-valued boolean logic is a good idea in general.

Boolean? b = null;
if (b ?? false) 
    Console.WriteLine("Condition is true");
else
    Console.WriteLine("Condition is false or null");

Visual Basic actually handles nullable booleans differently, and the following compiles just fine (even with Option Strict on) – bringing to the surface a subtlety in the implementation across the languages.

Dim b As Boolean? = Nothing
If (b) Then
   Console.WriteLine("Condition is true")
Else
   Console.WriteLine("Condition is false or null")
End If

For more in depth information on the treatment of null types, check out the following MSDN articles:

M is for… M

joneil — Mon, 30 Mar 2009 07:02:00 GMT

M is for M: How cool is that?

You really can’t start talking about M without first mentioning Oslo, the code-name for Microsoft’s model-driven development infrastructure. Oslo was formally introduced at Microsoft PDC back in October 2008, and its overarching goal is to reduce the disconnect between developer intent and implementation.

In model-driven development, the model is the application, versus just a design artifact. You build a model via some tools, and you execute that model via a runtime environment, thus enhancing the transparency, flexibility, and productivity of the development process. Consider XAML (eXtensible Application Markup Language) for instance. XAML provides a model – or more precisely a domain specific language or DSL – for describing user interfaces. And this XAML can be consumed by the Windows Presentation Foundation (WPF) or Silverlight runtime to ‘execute the model.’

Oslo itself comprises three main components:

Repository – a SQL Server database to store models and metadata,

Quadrant – a visual design tool, and

M – a declarative language for modeling.

M, the topic of interest for this post, is a family of declarative, textual languages for building and working with models. Within this family are

MSchema – for describing constraints and types,

MGraph – for defining instances of structured data, and

MGrammar – for defining DSLs.

To get started, you’ll want to download the Oslo SDK; the current version is the January 2009 CTP. In addition to providing assemblies, samples, and documentation, the SDK sets up the SQL Server 2008 repository and provides a tool called Intellipad for authoring M documents. You can also work with M and Oslo in Visual Studio, via the “M” Project template installed by the SDK.

To make this all a bit more real, I’ll work with a simple domain (here, universities I’ve attended) to create a model, add some data, and develop a simple domain-specific language. In the process, I’ll touch on M’s three variants.

MSchema

Let’s get started by defining the model with MSchema. Below I’m using Intellipad , which ships with the Oslo CTP, to define my model.

The model includes two types, one representing the school and one representing a state. On lines 8 and 19, collections of these types (referred to as extents) are defined; the * indicates one or more occurrences. In line 19, the list of schools is further constrained to those universities with State values in the States collection, thus creating a relationship not unlike a primary-key/foreign-key relationship in a database. In fact, it actually does correlate to just such a relationship as you can see when bringing up the T-SQL preview:

The preview shows how the model will be instantiated within the SQL Server repository. When using Intellipad you can see the SQL dynamically updated in this view as the M model is modified, thus giving you some insight into how the model is translated into relational database concepts.

To load the model into the repository, I first compile the model into a binary M image file using the M compiler, which ships with the SDK. The m command has a number of additional switches as well which can be used to verify syntax, generate T-SQL scripts, and reference metadata from other image files.

Now that I have an image file, univ.mx, I can use the mx command to load the model into the repository. The command below loads the metadata and model into the default server and the tempdb database, but there are additional command-line parameters available to specify the destination. mx can also be used to export an image file from an existing schema in the database.

Using SQL Server Management Studio, I can check out the schema that was added to the the database. In this case, I used the basic TSQL10 transformation option (specified via the target parameter of the M compiler). If I had used the /target:Repository option to create the image file, additional views and triggers would have been created to support the Oslo repository design pattern.

MGraph

So, now that I have a model in the repository, I need to add some data. To do so I’ll use MGraph inside of Intellipad to populate a couple of states as well as the universities I’ve attended. Here you can see the SQL statements, namely INSERTs, that are generated from the model.

To update the repository, I’ll again use the m and mx commands:

As a result, I now have data populated in my repository, as you can see from the results of the select query in SQL Server Management Studio below.

MGrammar

While I was able to populate my model with data, the format of that data in MGraph was a bit obtuse. Actually, it looks a lot like JavaScript Object Notation (JSON), and not something that really connotes the domain of the data. What I’d like to be able to do is define a grammar that’s a bit more user friendly (read: no curly braces and commas!) to people that have domain knowledge but not necessarily implementation knowledge (e.g., analysts versus developers).

In the past, many of us have written grammars in Backus-Naur Form (BNF) and used tools like lex and yacc to define grammars and parsers to accomplish a similar goal. Here I’ll use MGrammar.

First, though, I’ll create a file that provides examples of my DSL, for instance, something like the following. Note, the data really isn’t important at this stage.

In Intellipad, I next create the start of my grammar by creating a module definition and saving it as a file with the mg extension. That extension indicates my intent to Intellipad to create a grammar, allows me to select the MGrammar Mode>Tree Preview to browse to my example file, and splits my Intellipad view into four panels

my example,
the MGrammar specification,
a preview of the syntax tree for my grammar, and
an errors view.

With the example and grammar specification side-by-side, you can tweak either to arrive at the desired results. The third pane of the right provides a representation of how your grammar will parse the DSL into your domain model. This particular grammar could use a bit more tweaking, for instance, note the extraneous quotation marks. That’s a bit beyond the scope of a blog post though, so for more information, I refer you to the links at the end of the article, and in particular to Shawn Wildermuth’s series on Textual Domain Specific Languages for Developers.

Now that I have a grammar (the .mg file), I can create an mgx file from it and use that image file to convert other instances of my DSL into MGraph files. In other words, I’m using the grammar file to translate files written in my DSL to the underlying MGraph format, which then allows them to be added into the repository just as I did before. The difference now though is that the source document is in my domain-specific language, not one with curly braces and commas.

So assume I have a document (unc.txt) with the following line:

"University of North Carolina" in "Chapel Hill","North Carolina" has 28136 students.

Using the mg and mgx command line utilities, I can transform my file in the DSL to an MGraph format:

At this point, I’m at the same place I was in the MGraph section above where I used the m and mx commands to generate the requisite SQL statements to update my model in the repository. Note, here I will have some consistency problems though, because of the extraneous quotation marks delimiting my state values. In the new record for the University of North Carolina, the state will be interpreted as "North Carolina", with quotes, whereas the current database has the quote-less version. The remedy here, of course, is to not gloss over the need for tweaking the grammar as I did a few paragraphs ago ;)

Wrap-up

This posting turned out to be much more of a tome than I expected, and we haven’t even talked about how to ‘execute’ the model! If you’re left feeling a bit confused, and wondering how and why all these steps are a good thing, don’t despair. The “Oslo” concept is really in its nascent stages, and we can expect the tooling and methodologies to be refined and streamlined as the technology matures. If you like to be on the bleeding edge, then you may already have tinkered around with Oslo and its related technologies, if not, and you have ‘real work’ to do, then just put it on your radar and check back from time to time to keep your finger on the pulse of where Microsoft is going with this model-driven development paradigm.

To further whet your appetite, here’s some more information on Oslo and M:

Oslo SDK (January 2009 CTP)
Oslo Developer Center
MGrammar in a Nutshell
Oslo Technical Articles
Blog: Oslo Modeling Language Team
MSDN Magazine: Build Metadata-Based Applications with the “Oslo” Platform
Blog posting: Why Oslo is Important

Jim O'Neil's Blog : A-to-Z

.NET from A to Z – The Index

Z is for… Zermatt

“Geneva” Server

Windows CardSpace “Geneva”

“Geneva” Framework (previously “Zermatt”)

ClaimType

Value and ValueType

Properties

Issuer and OriginalIssuer

Subject

References

Y is for… Yield

X is for… XML Literal

LINQ within XML Literals

Axis Properties

Child axis

Descendant axis

Attribute axis

W is for… WeakReference

V is for… Velocity

Velocity Physical and Logical Models

Data Taxonomy

Client API

References

U is for… unchecked

T is for… Tracepoint

Print a message

Run a macro

S is for… sqlmetal

LINQ To SQL within Visual Studio

LINQ to SQL with sqlmetal

Output Comparison

Which Method to Choose?

Additional References

R is for... REST

Identification of Resources

Self-descriptive messages

Hypermedia as the engine of application state

Read more about it

Q is for... Quirks

P is for… Partial Method

O is for… Oomph

A Microformat Primer

Oomph Microformat Toolkit

Aggregator

CSS Styles

Live Writer plug-in

More Information

N is for… Nullable

M is for… M

MSchema

MGraph

MGrammar

Wrap-up