LeeDumond.com

Using a GUID as an EntityKey in Entity Framework 4

Lee Dumond — Fri, 14 May 2010 14:42:00 GMT

Do you have tables that use GUIDs (columns of type uniqueidentifier) as primary keys in SQL Server? This scenario is now fully supported in Entity Framework 4, as long as you remember one little gotcha.

Yes, it’s been months since I’ve blogged, as I’ve been hammer-down on my upcoming book since the beginning of the year. However, I thought I’d put out a quick post as a heads-up to my fellow developers who, like me, are trying to get up to speed with Entity Framework 4. I recently ran into an issue concerning a rather common database scenario, which bugged me for the better part of a day. Surprisingly, I found no mention of it on any search engine. Hopefully, this post should help to remedy that situation.

The Scenario

Like many developers, I happen to be a fan of using uniqueidentifier columns as primary keys on database tables (as opposed to the other common practice of using integers). While I don’t do this all the time, in many cases I think it just makes sense, especially when the records in and of themselves don’t share a “sequential” relationship to one another. I understand this is a rather controversial topic in some circles; with good arguments on both sides. Quite frankly, whether you personally agree with this practice or not is beside the point. For the purposes of this discussion, it’s just important that you understand two things: one, that this done all the time; and two, that this scenario was not properly supported under Entity Framework V1.

The Problem

The specific issue concerns how identity values are assigned to new records under this scenario. Usually, a new GUID is generated in the database by using the SQL Server NEWID() function as the default binding for the PK column. In Entity Framework, as you probably know, when you insert a new record by calling the SaveChanges method on the ObjectContext, you are supposed to be able to access all of the properties of that record, including the new server-generated ID. In order for this to work, the provider has to support returning the identity value from the server. Under EF 1, the provider didn’t generate the required TSQL to make that happen.

When an entity is created from a database table in Entity Framework, it uses the primary key (or keys) from the table to create an EntityKey. Under EF1, there was certainly no problem creating entities with EntityKey of type Guid. You could query those entities just fine. You could even update them. But doing inserts with server-generated GUID values was a big fat no-go.

The usual workaround for this was to simply forgo generating the identity values in the database with the NEWID() function, and instead generate it on the client and pass it in as part of the entity’s constructor, as you can see in Listing 1.

using (EFSampleEntities context = new EFSampleEntities())
{
   Motorcycle motorcycle = new Motorcycle
                              {
                                 ID = Guid.NewGuid(),
                                 Make = "Suzuki", 
                                 Model = "B-King", 
                                 EngineCC = 1340
                              };
   context.Motorcycles.AddObject(motorcycle);
   context.SaveChanges();
}

Listing 1

How It Works Under Entity Framework 4

Obviously, failing to support server-generated GUID identity values was one (unfortunately, one of the many) shortcomings of Entity Framework V1. This was something the EF Team promised to address under the second version of the Entity Framework (dubbed Entity Framework “4” by the marketing geniuses at Microsoft, in an effort to make the EF version number match the .NET Framework version number, while thoroughly confusing us at the same time).

I was eager to give it a go the other day, so I set up a little test project with a SQL Server 2008 database, one tiny little table and a single-entity model. As you can see in Figure 1, the ID column of this table in the database is a primary key, is of type uniqueidentifier, and derives its default value from the NEWID() function.

Figure 1

The EF Designer screenshot in Figure 2 shows that the corresponding Motorcycle entity has an EntityKey of type Guid that maps to the table’s ID column.

Figure 2

Fantastic. So, I proceed to run the code from Listing 2 below, except this time I don’t generate the identity value on the client. The database is going to do that for me, thank you very much!

class Program
{
   static void Main(string[] args)
   {
      InsertRecord("Suzuki", "B-King", 1340);
   }

   private static void InsertRecord(string make, string model, int engineCC)
   {
      using (EFSampleEntities context = new EFSampleEntities())
      {
         Motorcycle motorcycle = new Motorcycle
                                    {
                                       Make = make, 
                                       Model = model, 
                                       EngineCC = engineCC
                                    };
         context.Motorcycles.AddObject(motorcycle);
         context.SaveChanges();
      }
   }
}

Listing 2

I type this in, press F5, and it all appears to work. Or… does it?

The answer is, yes and no. The record did get inserted into the database. But take a look at Figure 3:

Figure 3

The new GUID is all zeros! Well, that’s not cool. And so I go poking around the IDE for a few minutes and discover that Entity Framework has, for some reason, failed to recognize ID as an identity field that is generated on the database side. That is indicated by the StoreGeneratedPattern property of the ID property, visible in the Properties window, which was still set to None. No problem… clickety click, and that’s all fixed.

Figure 4

And so I run the code again and… whaaaaaaaa?!? The new GUID is still 00000000-0000-0000-0000-000000000000.

The Payoff

Okay, at this point I’ll admit I’m completely stuck for an answer. I write to my friend Julie Lerman, author of Programming Entity Framework and one of the most knowledgeable EF developers on planet Earth, and even she is stuck for an answer – a rare event indeed. I post a question on Stack Overflow. No answers there either.

Now, I’m wondering if this scenario really is supported in EF4 at all, as the team promised it would be. As seemed to happen so often in the first version of Entity Framework, it was difficult to know if it was the framework that was causing the problem, or if it was just me.

One pot of coffee, half a tank of premium unleaded, and a few hours of sleep later, I figured it out.

The issue lies in the fact that the Entity Framework designer is a representation of only the conceptual part of the data model. When you set the StoreGeneratedPattern attribute on an entity property using the designer, it merely adds an annotation to the property in the CDSL part of the underlying .edmx file.

<!-- CSDL content -->
<edmx:ConceptualModels>
  <Schema Namespace="EFSampleModel" Alias="Self" xmlns:annotation="http://schemas.microsoft.com/ado/2009/02/edm/annotation" xmlns="http://schemas.microsoft.com/ado/2008/09/edm">
    <EntityContainer Name="EFSampleEntities" annotation:LazyLoadingEnabled="true">
      <EntitySet Name="Motorcycles" EntityType="EFSampleModel.Motorcycle" />
    </EntityContainer>
    <EntityType Name="Motorcycle">
      <Key>
        <PropertyRef Name="ID" />
      </Key>
      <Property Name="ID" Type="Guid" Nullable="false" annotation:StoreGeneratedPattern="Identity" />
      <Property Name="Make" Type="String" Nullable="false" MaxLength="50" Unicode="true" FixedLength="false" />
      <Property Name="Model" Type="String" Nullable="false" MaxLength="50" Unicode="true" FixedLength="false" />
      <Property Name="EngineCC" Type="Int32" Nullable="false" />
    </EntityType>
  </Schema>
</edmx:ConceptualModels>

Listing 3

However, this action does not add the required attribute to the storage part of the data model. You actually have to open the .edmx file in an XML editor, find the identity column in the SSDL, and add the StoreGeneratedPattern attibute by hand.

<!-- SSDL content -->
<edmx:StorageModels>
  <Schema Namespace="EFSampleModel.Store" Alias="Self" Provider="System.Data.SqlClient" ProviderManifestToken="2008" xmlns:store="http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator" xmlns="http://schemas.microsoft.com/ado/2009/02/edm/ssdl">
    <EntityContainer Name="EFSampleModelStoreContainer">
      <EntitySet Name="Motorcycles" EntityType="EFSampleModel.Store.Motorcycles" store:Type="Tables" Schema="dbo" />
    </EntityContainer>
    <EntityType Name="Motorcycles">
      <Key>
        <PropertyRef Name="ID" />
      </Key>
      <Property Name="ID" Type="uniqueidentifier" Nullable="false" StoreGeneratedPattern="Identity" />           
      <Property Name="Make" Type="nvarchar" Nullable="false" MaxLength="50" />
      <Property Name="Model" Type="nvarchar" Nullable="false" MaxLength="50" />
      <Property Name="EngineCC" Type="int" Nullable="false" />
    </EntityType>
  </Schema>
</edmx:StorageModels>

Listing 4

Once you do this, inserts performed by the provider when calling SaveChanges will allow the database to generate the identity value properly, and retrieve the value reliably so that you can work with it through the ObjectContext.

In case you are wondering about the T-SQL that the provider actually generates to do the insert, then retrieve the GUID, you can find it below in Listing 5. It creates a temporary table to hold the identity value, uses an OUTPUT clause to grab the new value and insert it into the temporary table, then does a join between the temporary and main tables to select and return the value. Pretty clever stuff.

declare  @generated_keys  table(
                                [ID] uniqueidentifier
                                )
insert [dbo].[Motorcycles]
      ([Make],
       [Model],
       [EngineCC])
output inserted.[ID] into @generated_keys
values('Suzuki' /* @0 */,
       'B-King' /* @1 */,
       1340 /* @2 */)
select t.[ID]
from   @generated_keys as g
       join [dbo].[Motorcycles] as t
         on g.[ID] = t.[ID]
where  @@ROWCOUNT > 0

Listing 5

New in .NET 4: Don’t Forget to Dispose() your SmtpClient Instances

Lee Dumond — Tue, 23 Feb 2010 15:34:00 GMT

It seems the System.Net.Mail.SmptClient class has gotten a bit of a facelift in .NET 4.

Wow, it seems like forever since I’ve written a blog post. That’s because I’ve been heads-down on my new book, part of which involves getting up to speed on all of the newest features in ASP.NET 4.0.

I gotta admit that this one caught me by surprise though.

For the record, I will admit that I'm a little fanatical about disposing objects. As you (I hope) already know, that means remembering to call the Dispose() method on objects whose classes implement the IDisposable interface. It’s often tricky to remember which objects you need to dispose, since in many cases it’s not immediately obvious.

I thought I had this disposing stuff pretty much in my back pocket. That’s why I was so surprised when running some static code analysis on my Cyclemania project and seeing the following warning:

Warning 20 CA2000 : Microsoft.Reliability : In method 'TestEmail.btnSendTest_Click(object, EventArgs)', call System.IDisposable.Dispose on object 'new SmtpClient()' before all references to it are out of scope.

Whaaa??? What’s this? This can’t be right…

Well, as it turns out, the SmtpClient class does implement IDisposable, starting in .NET 4.

This is actually a good thing. The .NET 4 implementation of the SmtpClient class pools SMTP connections, which avoids the overhead of re-establishing a connection for every message when sending multiple messages to the same server. Since the same connection can be reused over and over in an application, there’s no way to determine when an application is finished using the client object. Calling Dispose() on it iterates through all established connections and sends a QUIT message, which allows the server to free up its own connection resources and begin processing. The TCP connection is then terminated, and any resources used by the underlying socket are released.

This means that, when you’re using SmtpClient to send mail in your .NET 4 application, you should adhere to the following:

// correct
try
{
   using (MailMessage message = new MailMessage())
   {
      message.Subject = "Test Email";
      message.Body = "This is a test email from .NET 4!";
      message.To.Add("test@example.com");

      using (SmtpClient client = new SmtpClient())
      {
         client.Send(message);
      }
   }
}         
catch (SmtpException)
{
   // handle exception here
}


// wrong
try
{
  using (MailMessage message = new MailMessage())
  {               
     message.Subject = "Test Email";
     message.Body = "This is a test email from .NET 3.5!";                  
     message.To.Add("test@example.com");

     new SmtpClient().Send(message);            
  }            
}         
catch (SmtpException)
{
  // handle exception here
}

Just one more .NET 4 “gotcha” to keep in mind.

UPDATE: Jeff Tucker (the guy who implemented this new feature) also points out in the comments below that SmtpClient will also close existing connections if you switch the host or port. Nice!

Wanna Help Me Write a Book?

Lee Dumond — Mon, 07 Dec 2009 15:07:00 GMT

It’s official – I’ll be writing the next installment in Wrox Press’ best-selling ASP.NET series. Here’s a sneak peek into ASP.NET 4.0 Website Programming: Problem – Design – Solution, and a way you – yes, you – can help make the book better, and even receive written credit in the book’s Acknowledgement section.

Marco Bellinaso’s ASP.NET 2.0 Website Programming: Problem Design Solution won’t be an easy act to to follow. Published in 2006, it went on to become one of the best-selling ASP.NET books of all time, and has been highly influential for thousands of web developers. For the past 3.5 years, it has been the book on how to develop a complete website from start-to-finish in ASP.NET.

It is my sincere hope that the upcoming ASP.NET 4.0 Website Programming: Problem – Design – Solution will be as useful to today’s generation of web developers going forward as Marco’s book has been. But to do that, I’m going to need your help.

About the Book

ASP.NET 4.0 Website Programming Problem – Design – Solution is intended to pick up where Marco’s ASP.NET 2.0 book left off. The book will take an example-driven, hands-on approach, while describing in detail the development of a complete ASP.NET 4.0 application from start to finish. In its pages, developers will discover unique and resourceful ways to handle the issues they face daily during the website development process.

It will be targeted at developers with a moderate degree of experience with ASP.NET 2.0. Those familiar with ASP.NET 3.5 will likely grasp the material a bit quicker, though ASP.NET 3.5 experience will neither be assumed nor required.

About the Application

The book introduces a brand new sample application called CycleMania. The site will function as a portal / social networking destination for motorcycle enthusiasts of all kinds.

The new CycleMania application retains the most popular features from the BeerHouse application featured in the 2.0 version of the book such as forums and an online store, as well as localization, personalization, and deployment projects. However, CycleMania introduces many new and exciting features, such as Blogs (this replaces the Articles module from the previous book), an Event Calendar, a Multimedia Gallery, comprehensive Search functionality, an enhanced Administration dashboard, and much more.

Where You Fit In

Like the original BeerHouse, CycleMania will be a fully functional, complete, ready-to-use application, deployable straight out of the box. Along with the accompanying book, it should also serve as a teaching aid that showcases much of the modern new thinking in ASP.NET Webforms application architecture, design principles, and design patterns; as well as Web standards, semantics, accessibility, advanced CSS techniques, and rich interactive UI. Ultimately, it will provide a solid framework from which readers will be able to develop their own scalable, secure, enterprise-level Web applications.

The success of the book relies on the success of the underlying sample application. My hope is to make it as comprehensive, solid, and bug-free as possible, while meeting the overall design goals stated above (in the limited amount of time I’ve been given, or course). In order to do that, I need to put as many minds to it as possible. The idea here is to solicit as much feedback from the community as I can. That’s where you come in.

Download it Now

At the risk of totally embarrassing myself, I am going to be posting iterations of Cyclemania on Codeplex for anyone to freely download. You will need Visual Studio 2010 Beta 2 or Visual Web Developer 2010 Express Beta 2 to run it (both of these are free).

The first Alpha version is already available. In it, you’ll find the basic UI, along with a couple of themes that you can switch between. The Membership parts are fairly complete as well, so you’ll be able to register, confirm registrations by email, log in, reset passwords, change your email address, password, or security question, and so on. In order to do most of those things, you’ll need to get email functionality working by configuring the <mailSettings> in the <system.net> section of Web.config to point to your own mail server, or use a SMTP development server like Antix.

That’s about it for right now, but I’ll be uploading new versions every few days. Download the latest release. Play with it. Abuse it. Run it through its paces, and let me know the following:

Have you found a bug? If so, report it by creating a new item in the Issue Tracker. If you have a suggested fix for it, even better! Contact me via the People section, or through the contact page of this blog, and send me what you’ve come up with. This includes XHTML validation and cross-browser issues as well!
Am I on the right track? Or am I all wet? Post thoughts, comments, and suggestions in the Discussions area. Let’s get some robust dialogue happening!
Got an idea for a theme? You’ll see I have two somewhat “fancy” themes created for the site already, but I’d love to have more. I especially need at least one simple, high-contrast theme which emphasizes accessibility. The good news is that the site doesn’t use skins, or any of the other features of the ASP.NET Themes system – just good ol’ fashioned Cascading Style Sheets. If you’re good with CSS, have at it and if it’s worthy, I’ll include it in the book. The more, the better!
Do you know Spanish? Part of the plan is to localize the site in both English and Spanish. Unfortunately, I don’t know a lick of Spanish. If you want to help with the translation (mostly single words and simple phrases), you’ll get mad props.

Of course, it would be of most help to keep up to date on the very latest and greatest version. The best way to do that is to subscribe to the project’s RSS feed, so you’ll know when new releases are posted. Also, be sure to follow me on Twitter, where’ll I’ll be tweeting updates and other relevant info as well.

Again, the most helpful helpers will receive written acknowledgements in the book. Your name in actual print, just like Navin R. Johnson. ;)

My sincere hope is, with your help, we’ll come up with a really great web application, and a really great book to go with it.

GraffitiCMS Going Open Source

Lee Dumond — Tue, 24 Nov 2009 22:16:00 GMT

Thanks in part to the many who forwarded, blogged, tweeted, and linked to my May 2009 plea to Telligent to turn GraffitiCMS over to the community, it now appears that Telligent will be doing exactly that.

It was a little over six months ago that I posted a modest proposal to the powers that be at Telligent and to the remaining community of GraffitiCMS users: in effect, that GraffitiCMS should be converted to an open-source project, rather than be allowed to languish in ever-increasing obscurity.

At that time, the company stated that OSS was something they had considered, but had rejected in favor of continuing development in-house. At the same time, a major new upgrade was promised for Q3 2009.

With summer 2009 having come and gone without the promised upgrades, and with Telligent’s level of support for Graffiti waning from merely dismal to completely non-existent, it looked for all the world that Graffiti had finally flatlined.

But then, at about 3:45 PM Central time today, this little bundle of joyful news popped up on my Twitter stream:

According to Scott, this will be released under a straight-up standard OSS license, and not the “shared source” scenario the company has dabbled with in the past. Congratulations to Rob Howard, Scott Watermasysk, and the rest of the Telligent management team for doing the right thing.

The Wisdom of Crowds: Implementing a Smart Ranking Algorithm

Lee Dumond — Mon, 09 Nov 2009 13:57:00 GMT

From blog posts to books, sorting a list of items by user rating is a very common task. In this blog post, we discover how the writings of an obscure 18th-century British minister lets us implement a “smart” ranking algorithm that takes into account the “wisdom of the crowd”, and presents a fairer and more accurate representation of results.

The Rating Problem

Let’s pretend for the moment that you’ve hankerin’ to pick up a few fresh tips on ASP.NET 3.5. You visit a bookstore and type “ASP.NET 3.5” into the search box. You obtain the results shown in Figure 1.¹

Figure 1

This site, like many others, allows users to rate products on a scale of 1 to 5. The average customer rating is displayed when browsing these products. (I’ve included both image-based and numerical displays for the purposes of this discussion). By sorting the results in order of customer rating as shown, you hope to discover which books are most popular among your peers.²

Examining Figure 1, it would appear that ASP.NET 3.5 Website Programming: Problem - Design – Solution is the most popular among these books, with a perfect 5-star rating; and that Pro ASP.NET 3.5 in C# 2008 is the least popular among the rated books, with but a single star to call its own. But, as I’m sure you already suspect, the average rating alone doesn’t tell us the whole story.

Of course, e-commerce sites understand this too. That’s why you’ll almost always find, in addition to the average customer rating, the number of customers who contributed to that rating, as shown in Figure 2.

Figure 2

Leveraging the Wisdom of the Crowd

Knowing the number of times an item has been rated makes the results much more meaningful to us – but have you stopped to consider exactly why this is so? Why do we lend more weight to a rating when an item has been rated by more individuals? This may appear to the casual observer as the manifestation of a “bandwagon effect” of some kind, but that’s not really the case. As it turns out, this is the result of an intuitive mental calculation that mirrors an actual real-word phenomenon - a true example of crowd intelligence in action. What’s more, as we shall soon see, this phenomenon can be modeled in software.

We see from Figure 2 that ASP.NET 3.5 Website Programming: Problem - Design – Solution has the highest average customer rating, and therefore resides at the top of the list. However, since it has only been rated once, we are less inclined to trust this result. Intuitively, we understand that with a small number of ratings, the probability of an anomalous rating (an “outlier” in statistical terms) having a significant impact on the average is greatly increased. In other words, a small number of ratings increases the chance that the overall average rating may be “inaccurate” – not arithmetically inaccurate of course, but inaccurate in the sense that the data doesn’t reflect a true consensus of typical, unbiased readers.

Now take a look at some of the other results. We see that ASP.NET 3.5 Unleashed appears lower on the list by virtue of its lower average rating of 4.8. Nevertheless, we instinctively lend much more weight to its rating data, because far more customers have rated it. If we’re laying down our hard-earned money, it would appear that ASP.NET 3.5 Unleashed is the surer bet (all other things being equal, of course). That 4.8 rating may not be the highest on the list, but a rational observer would invariably conclude that this is a more reliable figure, based on the relatively large proportion of the “crowd” which contributed to it.

Including the number of ratings lets us evaluate the average rating data of each individual item not only on its own, but in relation to all the other items. The more times an item has been rated, the more believable the data, and thus the more relative weight we place upon its average rating.

Wouldn’t it be great if we could somehow leverage the intelligence of the crowd, and reflect it in the results? What if we could rank and sort the results based not solely on the raw average rating, but on the believability of the average rating? Such a ranking algorithm would more accurately reflect how we perceive each item’s ratings in relation to each other. Using this algorithm, an item which received a single 5-star rating wouldn’t immediately jump to the top of the list; likewise, an item that received a single poor rating wouldn’t immediately be forced to the bottom. The “good stuff” (items which receive mostly high ratings from a relatively large proportion of the crowd) would appear near the top, while the “not-so-good” (again, as determined by the crowd) would be pushed lower.

Bayes’ Theorem

As it turns out, we can develop such an algorithm with the help of an 18th-century British Presbyterian minister named Thomas Bayes.

Like many learned men of his day, Reverend Bayes harbored a keen interest in mathematics. In an essay discovered and published in 1764 – three years after his death – he presents a special case of what eventually came to be known as Bayes’ theorem. Today, Bayes theorem is widely accepted among most statisticians. Applications of it can be found throughout many fields in science and engineering, from the evaluation of drug test results, to predicting the outcome of elections, to the development of spam-filtering software.

Bayes’ theorem states in part that probabilities are rationally coherent degrees of belief, or a degree of belief in a proposition given a body of well-specified information.³ Therefore, Bayes' theorem can be thought of as a representation of how an ideally rational individual would interpret the believability of an outcome, based on a series of prior outcomes.

Bayes’ theorem can be stated mathematically in terms of how the probability of an outcome A given B, is related to the converse probability of outcome B given A.

Applying Bayes’ Theorem to the Rating Problem

A Bayesian average is a method of calculating the mean of a set of data that is consistent with Bayes’ theorem.

Where:

C is a “weighting” constant, proportional to the typical size of the data set
m is the arithmetic mean taken over all known data
n is the size of the current data set

For our particular purposes, we can calculate the Bayesian average of each of our books by applying the formula above. This lets us derive a rating that is based on the “believability” of the raw data.

BA = ((AvgNumOfRatingsForAll * AvgRatingForAll) + TotalRating) / (RateCount + AvgNumOfRatingsForAll)

Where:

RateCount is the number of ratings given to this book
TotalRating is the sum of all ratings given to this book
AvgNumOfRatingsForAll is the average number of ratings for all books shown (where RateCount > 0)
AvgRatingForAll is the average unweighted rating for all books shown (where RateCount > 0)

In Figure 3, the results are now sorted by their Bayesian average. The star displays also reflect the calculated Bayesian average.

Figure 3

If you compare these results to those shown in Figure 2, several conclusions can be drawn:

The Bayesian average is a truer reflection of how the books are rated in relation to each other.
The Bayesian rank for books with a relatively small number of ratings tends to gravitate toward the average rating of all books.
The more ratings a book has received, the more “believable” the ratings are. Therefore, when a book has received a relatively large number of ratings, its Bayesian rank gravitates toward its unweighted average rating.

Keeping it Fair

As pointed out, the Bayesian average formula uses a constant C that determines how much “correction” is applied to the raw, unweighted average. By examining the formula, you’ll note that C is a “dampening” value that determines the “sensitivity” of the calculation.

This means that the higher the value of C, the more customer ratings it will take to influence the Bayesian average. In other words, C can be thought of as the number of ratings it will take to have a significant impact on the relative ranking of an item. Higher values of C make the results less sensitive to the determination of the crowd, while lower values of C do the opposite. This is something you might want to take into account when determining what value to use for C.

In practice, this value should be proportional to the typical size of the data set. In our example, we used the average number of ratings given to all rated items in the search result. This works well in most cases in which new items are added on a regular and ongoing basis, such as an inventory of retail items, blog posts, songs, videos, downloadable applications, and the like.

However, consider the case in which new items are added relatively infrequently. When the existing items already have a high number of ratings, a new item will have to receive many ratings in order to move up or down in the list. In your particular application, if you want to give new items a chance to move more quickly, you can reduce the value of C by a given factor, like so:

BA = ((AvgNumOfRatingsForAll * 0.75 * AvgRatingForAll) + TotalRating) / (RateCount + (AvgNumOfRatingsForAll * 0.75))

Summary

When sorting a list of items by the “raw” average of the ratings it has received, we often get a distorted view. Results are easily skewed by a small number of ratings (or even a single rating) given to any particular item.

In order to provide a more accurate picture, we need a smarter rating system – one that can accurately quantify the “wisdom of the crowd.” This is something we naturally do when the size of the “crowd” is known to us. When an item has received many ratings, that data should be considered more “reliable,” and therefore its ranking in the list should more closely reflect the crowd’s decision. When an item has received very few ratings, its ranking should approximate the average rating for all the items shown.

We can use Bayes’ theorem to derive a smart rating algorithm to accomplish this task. Furthermore, the weighting applied by the Bayesian average formula can be adjusted to suit different purposes, thus making new items more sensitive to the influence of the crowd.

Download the Code

If you’re interested in playing around with this on your own, you can download the solution/database I used to create the screenshots in this post. You can mess around with the database values and/or the weighting constant in order to see how different scenarios affect the results.

1. Book cover images courtesy of Amazon.com.

2. All screenshots are for illustrative purposes only, and should not be construed as an actual reflection of the popularity or quality of these titles in “real life,” okay?

3. From http://en.wikipedia.org/wiki/Bayes%27_theorem

Dynamic Help Removed From Visual Studio 2010

Lee Dumond — Mon, 02 Nov 2009 03:52:00 GMT

Been going blind looking for the Dynamic Help window in the new VS 2010 Beta 2? Me too… until I learned this bit of bad news from a inside source.

Like many of you, I’ve been messing around with the Visual Studio 2010 Beta 2. VS 2010 contains a number of long-awaited IDE improvements, like multiple monitor support, new editing and design tools, and a cleaner, more responsive WPF-based interface.

So far, I’m loving all of it. Well, almost all of it.

I happen to be a huge fan of Visual Studio’s Dynamic Help feature. This is a window containing links to related Help topics based on where you are in the IDE.

In fact, I recently wrote a blog post explaining how to integrate exception handling into the development cycle. The process I presented in that post makes good use of this handy feature.

In previous versions of Visual Studio, I’ve always placed the Dynamic Help window to the right side in Auto-Hide mode, ready at a moment’s notice. However, when I went to set up VS 2010 in the same way, I noticed that the Dynamic Help window appeared to have been left off the Help menu.

"Okay, no big deal," I thought. It is beta software after all. You can't really complain if a beta appears a little half-baked, right?

Nevertheless, this was still disappointing to me. I was tempted to report this as a bug, but just didn’t feel like dealing with the massive vortex of suck that is Microsoft Connect. So instead, I did what most other malcontented developers do – I complained on Twitter.

A few hours later - much to my chagrin - I received the following reply:

Whaaaaaa? This made absolutely no sense to me. I figured it couldn’t be true… until I learned that Charles Christian is actually a Project Manager on the Visual Studio Help Experience Team. So, there you go. I guess if anyone would be in a position to know, he’d be the guy.

Sure enough, a quick visit to the MSDN seemed to confirm it. Check it out below – no link to 4.0 up there near the top.

It looks like Visual Studio 2010 will definitely take some getting used to – because of all the new features added, and for at least one that was taken away.

I’ve asked Charles to provide an explanation as to why Dynamic Help was removed. As soon as I get a reply, I’ll update this post. Stay tuned.

UPDATE: Charles' explanation appears below in the comments.

Dr. Explain Gives Your Software a Brain

Lee Dumond — Wed, 28 Oct 2009 13:11:00 GMT

Thorough, detailed, and up-to-date documentation is one of the keys to success for any software application. Dr. Explain makes it easy (almost too easy) to create and maintain CHM help files, web-based HTML documentation, and even printable manuals.

Ask any developer to name his or her least favorite development-related tasks, and there’s a good chance that “creating documentation” will appear very close to the the top of that list.

While writing docs may not be nearly as sexy as architecting or slinging code, it’s a critically important component to any successful software project. Skimpy, incomplete, or disorganized documentation is not only a major impediment to new user adoption, it reflects poorly on the rest of the application, and even on your company as a whole. Despite what you may have heard, people do RTFM. Your software’s help file is invariably the first place users turns for assistance; if they can’t make head or tails of it, your chances of converting that trial download to a cash sale just went down considerably.

On the other hand, well-documented software is easier to sell, easier for your customers to train new users on, and much easier for you to support. Thorough, detailed, up-to-date help is one of the keys to helping users be productive, and productive users are happy users.

Of course, documenting software is time-consuming and tedious, right? I used to think so too. That was until I discovered a solution that makes the entire process easier and quicker than I ever thought possible.

Help That Practically Writes Itself

Dr. Explain from Indigo Byte Systems is a software help authoring tool. It provides a powerful, intuitive user interface for composing a tree-navigable help system for Windows/WPF, Java, and Flash applications, as well as Web sites. From a single source file, it can export to CHM, HTML, and rich text format (RTF). This helps you maintain all of your docs in one place while keeping everything consistent and timely – whether you electronically distribute help with your application, host it online, or deliver printed copies in the box.

While Dr. Explain has all the features you’d expect from a comprehensive help authoring system, it does one special thing amazingly well, which in my mind places it head and shoulders above other offerings in this category. Dr. Explain takes the most difficult, time-consuming, and tedious part of the documentation process – the annotation of user interfaces – and totally automates it.

Yes, you read that right. Let the built-in object capture tool take a screenshot of any part of your application – from a simple dialog, to a full window, to a web form…

…and from there it analyzes the structure, finds all the significant GUI elements, and automatically creates numbered callouts for all of them!

It optionally allows you to associate a definable portion of the screenshot with each annotation, and displays it (along with the descriptive text you provide) at the bottom. This provides helpful visual cues to your readers, as you can see from the CHM output.

A screenshot of the HTML output shows how a consistent look and feel is maintained between the CHM and HTML output.

Providing guidance for all the different screens in your application lies at the heart of effective documentation. Even with the drawing tools provided by many authoring systems, this process can take hours, even days. By scaffolding screenshot-based help topics in mere minutes, Dr. Explain dramatically cuts the time required to accomplish this task. Capture the screenshot, add the necessary descriptive text to the automatically generated annotations, and you’re practically done.

But Wait, There’s More…

Despite its amazing screenshot annotation abilities, Dr. Explain is no one-trick pony. It facilitates many other help-building functions as well, including the integration of context-sensitive (F1) help directly into any application; navigation tree management; creation of keyword indexes; full-featured RTF text editing with Unicode support; templating, theme, and CSS support; and lots more. All of this is included in the $125 standard license.

For an additional $40, an “advanced license” is available which unlocks some very spiffy features, the slickest of which is the ability to have Dr. Explain automatically crawl the entire submenu structure of a Win32 application on one go:

Other advanced features include the ability to invoke the Dr. Explain engine from the command line; the creation of pop-up tooltips; and a tool to generate Google sitemaps from HTML help pages.

To learn more; feel free to avail yourself of any of the following handy resources:

Dr. Explain features overview
A six-minute YouTube video demonstrating Dr. Explain in action
The Dr. Explain user forum
Pricing and licensing options

Summary

Whether your goal is to sell more software, reduce the burden on your help desk staff, or simply to pave an easier path to adoption for your open-source project, producing and providing excellent help documentation is critically important. Dr. Explain is an incredibly useful tool for this purpose, especially if your help files rely heavily on UI illustrations. Its automatic annotation capabilities perform nearly flawlessly, and cut the time required to generate screenshot-based help topic by several orders of magnitude.

A trial version is available that you may use as long as you wish. Until you register, you’ll be limited to five help topics per project, and all screen captures will be watermarked. While obviously not suitable for production work, it’s more that enough to let you try out the many features for yourself.

At $125 for a single-user license, Dr. Explain could easily pay for itself several times over in the scope of a single project, merely based on the amount of time saved. For $165, the Advanced License unlocks additional features you’re sure to find useful as well.

Wrox Blogs Are Now Live!

Lee Dumond — Thu, 22 Oct 2009 14:25:00 GMT

Wrox Press has added a blog site, featuring posts from authors and key staff, to its lineup of great programmer resources.

Just a quick post to let you all know that as of this week, the long-awaited Wrox Blogs are now live at the Wrox Press website. The next time you visit, be sure to note the prominent link on the home page menu.

There are only a few of us there right now, but that number is sure to grow as more of your favorite Wrox authors jump on board.

The guidelines that Wrox has given us in regards to content is pretty wide open, as long as the topics are programming-related, or related to our writing or editing activities. I hope to use my own little corner on the Wrox Blogs to supplement the material I’m publishing here, especially that having to do with Wrox stuff that I’m reading, writing, or editing.

If you’re a subscriber to LeeDumond.com (and if you are, I sincerely thank you), you might want to consider subscribing to the Wrox blog as well, to make sure you’re getting all the good stuff!

Subscribe to my Wrox Blog
Subscribe to all the Wrox Blogs

As I hope to be starting on a new book very soon, I’m sure I’ll have lots of cool things to write about. Stay tuned!

Integrating Exception Handling Into the Development Cycle

Lee Dumond — Wed, 14 Oct 2009 13:46:00 GMT

The time to start thinking about exception handling is right after you click File > New Project. Exception handling shouldn't be something you "tack-on" to an application after the fact. Here, I discuss a practical approach to incorporating exception handling into the normal code-writing process.

Recently, my friend Jef Claes wrote me via my contact page. In part, his inquiry reads:

In which part of the development cycle, do you have to start thinking about exception handling? How and when do you decide which exceptions to handle specifically, so they won't kill your whole page?

Geesh… I post a few articles and write a book about exception handling, and all of a sudden I’m Mr. Exception Guy. ;)

In all seriousness though, this is a great question. There are lots of resources out there that provide information about exception handling from a theoretical or academic point of view, but very few that present a practical approach to integrating exception handling into your day-to-day development cycle.

Here, I’d like to present my own general approach to exception handling.

Examine the Possibilities

I have written before about the importance of handling only specific exceptions. Of course, you can’t do that unless you know what exceptions could be thrown from your code. That means the first thing you should do is to discover which exceptions are possible.

How you do that depends on the framework or API you’re using. If you’re using the .NET Framework, the MSDN can tell you which exceptions might be thrown from any given method, constructor, property, event, or indexer.

Consider the following simple code, which writes a string of text to a text file. The string of text to write (txtEntry.Text), as well as a portion of the path value (txtPath.Text), is supplied by the user.

private void LogEntry()
{
   string workingDirectory = ConfigurationManager.AppSettings["directoryToLog"];

   if (!string.IsNullOrEmpty(workingDirectory))
   {
      string path = workingDirectory + txtPath.Text;

      using (StreamWriter writer = File.AppendText(path))
      {
         writer.WriteLine(DateTime.Now.ToString());
         writer.WriteLine("Entry: {0}", txtEntry.Text);
         writer.WriteLine("--------------------");
      }

      lblMessage.Text = "The entry " + txtEntry.Text + " was logged successfully.";
   }
   else
   {
      lblMessage.Text = "The required configuration setting is missing. The entry " + 
         txtEntry.Text + " was not logged.";
   }      
}

We can see the first call is to ConfigurationManager.AppSettings. If you place your cursor on the method in the IDE, the Dynamic Help window will show you a link to the method in the MSDN.

Clicking on this link will take you to the relevant MSDN page. The MSDN will show you any exceptions that could possibly be encountered from accessing this property.

Doing the same with the File.AppendText method yields the following result:

Finally, the WriteLine method shows the following:

As you can see, the Visual Studio IDE and accompanying documentation makes this pretty easy. Keep in mind that when you’re calling a third party API, your experience will definitely vary. A well-written API should include XML documentation that exposes via Intellisense any exceptions that could be thrown; and if you’re lucky, compiled documentation created by a tool such as Sandcastle. If not, you have to rely on whatever the API provides, or perhaps use Reflector to disassemble the binary.

Program Defensively

Now that we have a list of all the possible exceptions that can be thrown from our code, the next step is to determine which exceptions we can prevent, and which we can safely ignore.

In this case, we are supplying part of the path in the configuration file, and this branch of code only runs if that value is not null or empty. Therefore, we can be 100% certain that the argument we pass to File.AppendText will never be null. This lets us safely ignore ArgumentNullException from the File.AppendText method.

Next, we can employ defensive programming techniques to prevent most of the remaining exceptions that can be thrown from File.AppendText. By restricting and validating the user input, you can assure that the path supplied by the user can never be too long, contain invalid characters, or be in an invalid format. This relieves us from having to handle ArgumentException, PathTooLongException, or NotSupportedException. That leaves us two possible exceptions we might have to deal with.

Now, let’s consider the two exceptions that can be thrown from the TextWriter.WriteLine method. The first, ObjectDisposedException, can’t happen in this code because all of the WriteLine calls are made prior to closing the writer; so we’ll ignore it. The second, IOException, would normally be thrown in response to a disk or path error. Since we can’t prevent this from happening in code, this exception is a good candidate for handling.

Determine Which Exceptions To Handle

So far, we’ve taken two steps. First, we identified all possible exceptions. Second, we determined which exceptions can be either effectively prevented or safely ignored.

The remaining exceptions we have to worry about are:

ConfigurationErrorsException (from ConfigurationManager.AppSettings)
UnauthorizedAccessException (from File.AppendText)
DirectoryNotFoundException (from File.AppendText)
IOException (from writer.WriteLine)

Now, we must decide which of these we can and should handle, and why.

There are legitimate reasons for handling exceptions. Among these are:

Notifying the user, and if appropriate, allowing them to retry the operation
Wrapping the exception in a new exception, appending additional relevant detail
Wrapping a specific exception in a more general exception to prevent revealing sensitive details, such as exceptions thrown from a Web service
Using a finally block to clean up resources that might be abandoned if an exception occurs

In this simple example, notifying the user is probably sufficient.

private void LogEntry()
{
   string workingDirectory = null;

   try
   {
      workingDirectory = ConfigurationManager.AppSettings["directoryToLog"];
   }
   catch (ConfigurationErrorsException)
   {
      lblMessage.Text = "There was a problem accessing the configuration settings. The entry " +
                        txtEntry.Text + " was not logged.";
      return;
   }

   if (!string.IsNullOrEmpty(workingDirectory))
   {
      string path = string.Empty;

      try
      {
         path = workingDirectory + txtPath.Text;

         using (StreamWriter writer = File.AppendText(path))
         {
            writer.WriteLine(DateTime.Now.ToString());
            writer.WriteLine("Entry: {0}", txtEntry.Text);
            writer.WriteLine("--------------------");
         }

         lblMessage.Text = "The entry " + txtEntry.Text + " was logged successfully.";
      }
      catch (UnauthorizedAccessException)
      {
         lblMessage.Text = "You do not have the required permissions to access the path " +
                           path + " . The entry " + txtEntry.Text + " was not logged.";
      }
      catch (DirectoryNotFoundException)
      {
         lblMessage.Text = "Part of the path " + path + " was not found. The entry " +
                           txtEntry.Text + " was not logged.";
      }
      catch (IOException)
      {
         lblMessage.Text = "There was a problem accessing the path " + path + " . The entry " +
                           txtEntry.Text + " was not logged.";
      }
   }
   else
   {
      lblMessage.Text = "The required configuration setting is missing. The entry " + txtEntry.Text +
                        " was not logged.";
   }
}

Note that we’re tailoring the message sent back to the UI to be as informative as possible, without using the original Message property from the handled exception. While the Message property is quite useful for logging and debugging purposes, I generally find it’s not a good idea to pass a framework-generated exception message to your end users. For one, they often tend to be rather cryptic to non-developers. More importantly, it’s possible they could contain sensitive information. While the .NET Framework itself is pretty good at not revealing sensitive information in Message, you’ll find that many third-party APIs are not nearly as conscientious in this regard.

Also note that the order in which you handle exceptions can be important. Here we’re handling DirectoryNotFoundException before IOException. This is because DirectoryNotFoundException is a derived type of IOException, and derived types should always be handled first.

Do or Do Not. There is No Try.

If you can’t successfully handle an exception in code, it is best to let the application fail as quickly as possible.

I can hear some of you now: “What? Are you suggesting that we should let our applications fail?”

The answer is yes… that is, in fact, exactly what I am suggesting.

Part of handling exceptions successfully is facing the fact that you cannot successfully handle everything. Remember, an exception being thrown means your application has already crashed. Sometimes it is possible to handle the exception, giving the application a chance to recover or to retry the operation. Quite often though, you will encounter exceptions for which no sensible handling strategy exists, in which case catching the exception is totally pointless. Only catch exceptions which you are prepared to handle; otherwise let them go.

If you catch exceptions which you subsequently do not handle – usually through the use of general catch blocks – you merely postpone the inevitable. Allowing an application to continue in the face of an unhandled exception is not only wasteful, it’s dangerous. Values might be corrupted. Resources might be left in an unstable or unknown state. This is exactly why exceptions are thrown in the first place – to prevent a program from continuing under these conditions. If you can somehow correct or recover from the condition, then fine. If you cannot, then failing quickly is the best option.

Fail Gracefully

The fact is that in a production application, you never truly let any exception remain “unhandled” in a technical sense – the real question is not whether to handle exceptions, but where to handle them.

What I’m saying here is that you need to make absolutely sure you have a global exception handling mechanism in place. In a Windows application, that usually means handling the AppDomain.CurrentDomain.UnhandledException event. In an ASP.NET application, it means handling the HttpApplication.Error event, either manually or via the built-in ASP.NET default exception handler. This “last-chance” global handler lets you provide a friendly user experience when unrecoverable errors occur, as well as a central location from which to log exceptions that weren’t handled by your code.

Of course, once an exception reaches your global exception handler, it means execution has stopped and your application has failed. That happens – and as we’ve learned, sometimes there’s nothing you can do about it. But there’s no reason your application can’t fail gracefully.

Summary

In this post, I’ve outlined a series of steps you can use to sensibly and effectively integrate exception handling into the development cycle. These can be summarized as follows:

Use the available documentation to discover which exceptions are possible.
Determine which exceptions you can safely ignore, based on current state.
Where possible, use defensive programming techniques to prevent exceptions from being thrown.
Determine which of the remaining exceptions you should handle, and develop a strategy for doing so.
Allow any exceptions you cannot completely handle in code to propagate to your default exception handler.

This, in a nutshell, pretty much sums up how I approach exception handling as I write code. Hopefully, you’ll find this useful in your day-to-day routine as well.

Questions? Constructive criticism? Suggestions for improvement? Please let me know what you think in the comments below.

ASP.NET Profiles in Web Application Projects

Lee Dumond — Thu, 08 Oct 2009 11:45:00 GMT

Accessing ASP.NET profiles from a web application project is remarkably easy once you know how. Here’s how it’s done, along with a fully working implementation that you can download.

Earlier this year, I blogged about how to create a strongly-typed Profile that could be accessed from a class library. In response to popular demand, today I’m presenting a similar (but more substantial) example geared specifically toward accessing profiles in web application projects.

There are plenty of blog posts that talk about this, but unfortunately very few that show how to do it. Most of them instead refer to this relatively obscure add-in for Visual Studio 2005 (apparently. you’re out of luck if you’re using Visual Studio 2008). However, the good news is you don’t need a third party add-in or build task for this, as implementing this functionality yourself is not difficult at all.

If you’re reading this, I’ll assume you’re aware of the differences between an ASP.NET web site and a web application, so I won’t go into the various differences in great detail (feel free to consult the MSDN for more information). For our purposes, it’s just important to understand that in a web application project, there is no ProfileCommon class or Page.Profile property to work with, as we’re accustomed to seeing in web site projects – hence the problem.

Web site projects accomplish this bit of magic through dynamic compilation – essentially creating the needed objects at runtime, “on the fly” as it were. In effect we will be doing the exact same thing, but the old-fashioned way – with a simple hand-written proxy class.

Writing a Profile Proxy Class

Let’s assume for the sake of discussion that we have several bits of user information we want to store in profile.

first name
last name
date of birth
gender
the user’s time zone
the user’s preferred culture

Now, we could store these as separate value types, but in practice I find it easier to group related properties together in a class. So let’s create a class Personal to store the first four properties, and a class Preferences to store the time zone and culture. Make sure to decorate these classes with the [Serializable] attribute.

namespace LD.Sample.BLL
{
   using System;

   [Serializable]
   public class Personal
   {
      public string FirstName { get; set; }

      public string LastName { get; set; }

      public DateTime DateOfBirth { get; set; }

      public Gender Gender { get; set; }
   }
}

namespace LD.Sample.BLL
{
   using System;

   [Serializable]
   public class Preferences
   {
      public string TimeZone { get; set; }
      
      public string Culture { get; set; }
   }
}

Next, we’ll write a class that will define the profile we want, incorporating the two custom types shown above as properties. This class will inherit ProfileBase . Let’s call it CustomProfile.

namespace LD.Sample.BLL
{
   using System.Web;
   using System.Web.Profile;

   public class CustomProfile : ProfileBase
   {
      public Personal Personal
      {
         get { return (Personal) GetPropertyValue("Personal"); }
      }

      public Preferences Preferences
      {
         get { return (Preferences) GetPropertyValue("Preferences"); }
      }

      /// <summary>
      /// Get the profile of the currently logged-on user.
      /// </summary>      
      public static CustomProfile GetProfile()
      {
         return (CustomProfile) HttpContext.Current.Profile;
      }

      /// <summary>
      /// Gets the profile of a specific user.
      /// </summary>
      /// <param name="userName">The user name of the user whose profile you want to retrieve.</param>
      public static CustomProfile GetProfile(string userName)
      {
         return (CustomProfile) Create(userName);
      }
   }
}

Note that I’ve also included two overloaded static GetProfile methods. GetProfile() lets us obtain the profile of the current user, while GetProfile(string userName) lets us get the profile of a specific user (for administrative purposes, or when creating a new member, for example).

One more thing – and this is very important – we need to define the provider in web.config.

<profile defaultProvider="LD.SampleWAP.ProfileProvider" inherits="LD.Sample.BLL.CustomProfile">
<providers>
   <add name="LD.SampleWAP.ProfileProvider"
   type="System.Web.Profile.SqlProfileProvider"
   applicationName="/"
   connectionStringName="LocalSqlServer"/>
</providers>

You’ll see that our provider is of type System.Web.Profile.SqlProfileProvider. Of course, this assumes that the database to which this is pointing has been configured with the schema required to support SqlProfileProvider.

Also note the inherits attribute in <profile>. This is what tells the provider where to obtain the profile properties – in our case, from the CustomProfile class. When you do this, you do not want to define the properties declaratively in web.config, as you would in a website project. If you do, you’ll get a System.Configuration.ConfigurationException, informing you that the profile property has already been defined.

Usage

And that, believe it or not, is all there is to setting up a strongly-typed profile for use in a web application project. Now, let’s take a look at how you can use this newly-implemented goodness.

Here is some code that shows setting profile values for the currently logged-on user.

CustomProfile profile = CustomProfile.GetProfile();

profile.Personal.FirstName = "Tami";
profile.Personal.LastName = "Gharst";
profile.Personal.DateOfBirth = new DateTime(1972, 7, 10);
profile.Personal.Gender = Gender.Female;
profile.Preferences.TimeZone = "W. Europe Standard Time";
profile.Preferences.Culture = "de-DE";

profile.Save();

Here is some code that shows setting profile values for a specific user with the user name “Lee”.

CustomProfile profile = CustomProfile.GetProfile("Lee");

profile.Personal.FirstName = "Lee";
profile.Personal.LastName = "Dumond";
profile.Personal.DateOfBirth = new DateTime(1961, 10, 9);
profile.Personal.Gender = Gender.Male;
profile.Preferences.TimeZone = "Central Standard Time";
profile.Preferences.Culture = "en-US";

profile.Save();

If you like, you can make this even simpler by adding a Profile property to the page you’re working with – or even better, inherit your pages from a base type and add it there, so it’s available to all of your pages. This lets you set and retrieve profile properties with the familiar ASP.NET web site syntax.

// set profile properties

Profile.Personal.FirstName = "Lee";
Profile.Personal.LastName = "Dumond";
Profile.Personal.DateOfBirth = new DateTime(1961, 10, 9);
Profile.Personal.Gender = Gender.Male;
Profile.Preferences.TimeZone = "Central Standard Time";
Profile.Preferences.Culture = "en-US";

Profile.Save();

// display profile properties

lblDisplay.Text =
   string.Format(
      "User {0} had a real name of {1} {2}, was born on {3}, lives in the {4} time zone, and has a preferred culture of {5}.",
      Profile.UserName, 
      Profile.Personal.FirstName, 
      Profile.Personal.LastName,
      Profile.Personal.DateOfBirth.ToShortDateString(),
      Profile.Preferences.TimeZone,
      Profile.Preferences.Culture);

Sample Application

As I mentioned, I’ve included a downloadable web application solution that demonstrates web application profiles in action. When you run it, you’ll be greeted by the following screen:

There are screens that let you display a profile, edit a profile, and create a new one.

Examining the source code, along with the preceding explanation, should make understanding these concepts a snap.

I hope this helps the next time you find yourself needing access to profile properties from a web application!

Download sample code: WebApplicationProfileSample.zip