Mickey Williams @ Neudesic

Surfacing a discussion that popped up on email recently... If you use HTTP-POST to send information from a browser to a web app, the browser will (correctly) complain if a user tries to navigate backwards using the browser's back button.

Really, the problem is about using postbacks even when they're really not needed. You can build a fairly well-featured site with a minimum of postbacks -- take a look at KBB.com, most of that site uses HTTP-GET.

A pretty good discussion of why the issue exists can be found here:

http://blog.andreloker.de/post/2008/06/Post-Redirect-Get.aspx

The article includes a description of the PRG pattern. Although the pattern is a bit difficult to implement with ASP.NET and webforms, it's very easy to build using the MVC bits (example here):

http://devlicio.us/blogs/tim_barcz/archive/2008/08/22/prg-pattern-in-the-asp-net-mvc-framework.aspx

The new CTP for Velocity is out. Velocity has made a lot of progress since the initial CTP, and this version includes API and perf improvements. Read more on the Velocity team blog and download the bits here:

http://www.microsoft.com/downloads/details.aspx?FamilyId=B24C3708-EEFF-4055-A867-19B5851E7CD2

I had a few questions in Denver at the Adopting VSTS 2008 event – I took some of them offline due to the timeline – here’s the info:

Q: How do I enlist a unit test into a performance profiling session?
In the Test Results window, right-click on any test and select Create Performance Session from the context menu. The Performance Wizard will be displayed, which enables you to kick of the performance session and profile the unit test’s execution.

From that point, it’s just like running any other performance session.

Q: How do I test a web service in an automated test?
Steve Lange has just posted a great description of how to do this: http://blogs.msdn.com/slange/archive/2008/05/23/creating-a-data-driven-web-test-against-a-web-service.aspx

Q: How do I spin up a web test from IIS logs?
http://blogs.msdn.com/joshch/archive/2006/07/03/655518.aspx

Q: How do I test an InfoPath form in SharePoint using a VSTS Web Test?
If you’re working with the InfoPath Forms Server, you need to create a custom extractor. In a nutshell, the issue is that InfoPath posts a bag of fairly opaque data back to the server. Some of this data is contextual, and some of it is not. A good description and sample code that we have leveraged can be found on CodePlex at:
http://www.codeplex.com/ipfswebtest

It turns out that MOSS will also use the forms server even in scenarios that don’t seem to use InfoPath. Mike Pham and I ran into this recently for a client, and I had to write a custom extractor that used a different index than used in the above article. I’ll try to clean up the code for an external post, but the only significant change I made from the above project is that I changed the CurrentFormData.CanaryValue to 24 instead of 25. If you stumble onto this blog post via a web search, feel free to drop me an email.

Q: What does an event subscription for a check-in policy override look like?
As I said in my presentation, there are a rather limited set of notification alerts available from the Explorer GUI. You can use bissubscribe.exe to create more sophisticated subscriptions, as described here:
http://blogs.msdn.com/darrenj/archive/2006/06/08/621902.aspx

The idea behind an alert that is triggered for a policy override is that the comment will be non-empty. A command-line for bissubscribe will look like:

bisSubscribe.exe /eventType CheckinEvent /userId corp\myuserid /address mickey@servergeek.com /deliveryType EmailHtml /filter "PolicyOverrideComment <>''"

A more convenient approach is to use Naren’s event subscription tool available here, which takes care of some of the plumbing, and just requires you to supply the filter expression (PolicyOverrideComment <>''):
http://blogs.msdn.com/narend/archive/2006/07/26/679440.aspx
or the newer tool available on CodePlex here:
http://www.codeplex.com/tfseventsubscription

Q: Multiple servers?
I have no idea what that comment means in my notes. I’m sure that at least one person would like information on multiple servers, but I have no idea what the context is. If you know, send me a note at first.last@neudesic.com, and I’ll post a follow-up.

Q: Where’s the TFS migration blog?
http://blogs.msdn.com/tfs_migration/

Q: Where is the tool for SVN->TFS migration?
It seems to have disappeared. If you’re a Neudesic person and you’re looking for a side project, see me.

Q: Where are your slides?
I’ve posted PDFs of my slides on skydrive at:
http://cid-d00ef348fc8a6f04.skydrive.live.com/self.aspx/VSTS-Denver%20May%202008
or
http://snurl.com/2c7wg

Microsoft has released Microsoft Search Server (MSS) 2008 and MSS Express. Both of these server products are free enterprise search products that are useful in scenarios where a full installation of MOSS is overkill -- you just want to have the enterprise search capability.

Info about the new products is here:

http://www.microsoft.com/enterprisesearch/products.aspx

And MSS Express is free. Get it here:

http://www.microsoft.com/enterprisesearch/serverproducts/searchserverexpress/download.aspx

Updated to make clear that only MSS Express is free.

The October VPC image for Orcas is now available:

http://www.microsoft.com/downloads/details.aspx?FamilyId=C09B5A2D-EB6A-44B6-8BBD-3764A2FDA9CE&displaylang=en

The beta drop of TFS SP1 is available, including bug fixes and new features like:

• Support for custom controls in workitems
• Remote HTTP access without the need for a VPN
• Support for Office 2007
• Support for moving the data warehouse to a separate server

However -- be aware that this is a beta drop, and the list of known problems is fairly nasty -- you should probably only install it on a pre-dogfood VPC image running on your oldest external drive during non-production hours. And wear gloves.

List of bugs fixed here:
http://blogs.msdn.com/bharry/archive/2006/09/28/775891.aspx

Features here:
http://blogs.msdn.com/bharry/archive/2006/09/26/772371.aspx

Beta issues here:
http://msdn.microsoft.com/vstudio/teamsystem/tfsknownissues_sp1.aspx

I learned to build 16-bit Windows apps with an 8088 and a copy of Petzold's "Programming Windows". I remember thinking that I would never learn the Windows API -- back then there were at least 300 or so method calls. I bought my first mouse, a hard drive (I was the first person I knew with a harddrive -- it was 5 megabytes of glorious luxury.)

As time went on, both Petzold and Microsoft reelased updates, and frankly Petzold stopped being my refeerence of choice. But his new WPF book is the best thing I've read in years, and is easily the best introduction to writing WPF applications.

Go. Buy it now:

http://www.amazon.com/Applications-Code-Markup-Presentation-Foundation/dp/0735619573

If you're using string.IsNullOrEmpty, be aware that there is a fatal bug in the JIT compiler that causes a null reference exception:

http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=113102

This means that String.IsNullOrEmpty is not safe for use in any production .NET 2.0 project.

Note that the "workaround" effectively amounts to "don't use string.IsNullOrEmpty" -- write your own version, and slap a MethodImpl attribute on the method to prevent JIT optimization.

I've been working on a project that has some fairly aggressive performance requirements, and believe me, some of the behavior I've seen with ASP.NET 2.0 caching is a bit odd, especially when you use output caching and cross-page posting at the same time.

In brief, if you use cross-page posts, the destination page uses the cache policy for the original page sometimes. And sometimes not. And sometimes raises an exception. I have discovered why this happens, and can demonstrate it with a three-page demo project (available here.) The bug was reported to Microsoft here.

In general, cross-page posts and caching work as expected. If each page is accessed directly, the cache policy for the page is properly evaluated. If the first page executes a cross-page post to either of the other pages, the cache policy for the destination page is used. Again, this is as expected.

However, if you simply access the PreviousPage property on any destination page, the cache policy for the previous page is used -- not the cache policy for the destination!

If the previous page and destination page both utilize a cache policy that involves varyByCustom, any attempt to access the PreviousPage property will cause an exception (because we attempt to overwrite the cache policy, causing a change to the VaryByCustom value.)

There are several problems here:

• The cache policy should not be spun up just because I'm checking to see if the previous page is null (frankly this is an argument for Eiffel's command-query separation principle)
• In fact, I argue that the cache policy should be predictable, and the current situation is certainly not.
• And the exception just blows chunks.

I'll try to post more about cache wierdness and internals as time permits.

I try not to whine too much on the blog, but I've been working on a side project that involves extending TFS eventing, and one of the first things I saw when I peeked under the covers was the definition of the notification web service method:

[WebMethod]
public void Notify(string eventXml, string tfsIdentityXml) 
{
  ...
} 

Now, not using WS-Eventing is certainly annoying, especially to those of us in the WS-* Breakfast Club, but the signature is downright embarrassing. Passing XML content as a string screams, "I'm really not sure I know what the hell I'm doing", and not in that cool punk-rock garage-band way. It's a key part of the extensibility plumbing. Could nobody have caught this in an SDR or something?

One of my talks tomorrow is on TFS source code control, and as part of the discussion, I'll be demonstrating custom checkin policies. A custom checkin policy runs when you attempt to modify the source archive, and is given veto power over your checkin. Well, it's really not a veto, but that's a long story... Anyhow, the Evaluate method is the core of a checkiin policy, and this one ensures that the source file has only one top-level type:

public override PolicyFailure[] Evaluate()
{
    List<PolicyFailure> changes = new List<PolicyFailure>();

    PendingChange[] pendingChanges = PendingCheckin.PendingChanges.CheckedPendingChanges;
    foreach (PendingChange change in pendingChanges)
    {
        if (Path.GetExtension(change.FileName) == ".cs")
        {
            if ((change.ChangeType == ChangeType.Edit) || 
                (change.ChangeType == ChangeType.Add))
            {
                if (!FileHasOneType(change.LocalItem))
                {
                    string msg = string.Format(Constants.FailureMessage, change.LocalItem);
                    PolicyFailure failure = new PolicyFailure(msg, this);
                    changes.Add(failure);
                }
           }
       }
   }
   return changes.ToArray();
}

The basic idea of Evaluate is that it returns an array of PolicyFailure instances. If the array is empty, the policy has succeeded. If the array has elements, they are reported back to the user.

If you're planning to be at my XLINQ talk this weekend at the San Diego CodeCamp, you might consider attending the C# 3.0 session first, where I'll be dicussing anonymous types, lambdas, and other topics. In the XLINQ talk, I'll be dicussing the differences between these two queries, and when one is more useful that the other:

from i in customers.Descendants("country").Select(x=>x.Value).Distinct()
orderby i
select new XElement("country", new XAttribute("name", i),
       from c in customers.Element("customers").Elements("customer")
       where i == (string)c.Element("country")
       select new XElement("customer", c.Element("name"))
                    )
       );

Versus this query:

from i in customers.Descendants("country").Select(country=>country.Value).Distinct()
join c in customers.Element("customers").Elements("customer")
       on i equals (string)c.Element("country")
orderby i
select new XElement("customer", c.Element("name"),new XAttribute("country", i))
);

They both return XML content, but you'll want to understand how to shape the content to match your needs. More at the talk...

In preparation for my (6) code camp talks next weekend, I'mupdating my samples. One thing that's changed slightly is the LINQ syntax. The code below thumbs through the Northwind database, and displays all customers in London, nesting the orders for each customer:

var orders = new XElement("CustomerOrders", new XAttribute("city", "london"),
        from c in db.Customers
        where c.City == "London"
        select new XElement("Customer", new XAttribute("id", c.CustomerID),
                             from o in db.Orders
                             where o.CustomerID == c.CustomerID
                             select new XElement("order", new XAttribute("id", o.OrderID))
                           )
                         );

The resulting XML looks something like:

<CustomerOrders city="london">
  <Customer id="AROUT">
    <order id="10355" />
    <order id="11016" />
  </Customer>
  <Customer id="BSBEV">
    <order id="10289" />
    <order id="11023" />
  </Customer>
  <Customer id="CONSH">
    <order id="10435" />
    <order id="10462" />
    <order id="10848" />
  </Customer>
  <Customer id="EASTC">
    <order id="10364" />
    <order id="11047" />
    <order id="11056" />
  </Customer>
</CustomerOrders>

There's more where that came from... My total talk gluttony includes talks on:

• C# 3.0
• WinFS (with Pete Orologas)
• Creating Custom Controls for ASP.NET 2.0
• Taking Advantage of Team System Version Control
• Creating Team Foundation Server Add-ins
• Using XLINQ

If/when you get tired of listening to me prattle on, other Neudesic speakers include Chris Rolon, David Pallmann, Steve Saxon, David Barkol, Brian Loesgen, Phil Scott, Robert Atland, and Ashish Agarwal.

The new LINQ bits are available here:

http://go.microsoft.com/fwlink/?LinkId=66144

Tom Archer posts about MSDN preferring (or not) one language over another (link from Brian Loesgen):
http://blogs.msdn.com/tomarcher/archive/2005/11/21/495282.aspx

My thoughts (I posted similar comments on Tom's blog):
I definitely prefer C# for my daily programming over VB.NET. Actually, the unordered list of programming languages I prefer is:

• Eiffel
• Spec#
• C#
• Scheme

However, the selection of programming language needs to fit the task at hand, and Eiffel and Spec# are not practical for most of my daily work. This has nothing to do with the quality of the languages -- I think Eiffel may be the perfect method and language for OO programming. However, I tend to be more productive in a team consulting environment for my current projects using Visual C#. However, after the revolution comes, you're all going to be using Eiffel. Or at least Spec#. So get ready.

I've used Visual Basic and Visual Basic.NET, and I've recently presented webcasts on Visual Basic.NET language features. I tend to think of Visual Basic the way I think of Escondido. It's alright and not completely unpleasant -- but I'm not going there unless someone needs me to be there.

As for examples, when I use C#, Spec# or Eiffel, I can express my examples better, there's less chance of error, and you're much more likely to get the content in a timely manner ;) So if you take into account marketplace realities and the relative audiences for all programming languages, you'll typically see my examples in C#.

The one issue I would raise is that there are language features in C# that do not map easily to VB, and I see many dual-code examples where the C# code is simply a literal translation of the VB. I've seen many C# examples that didn't employ the using(...){} syntax -- apparently because it didn't match the adjacent VB code (or maybe the author was more familiar with VB).  I would definitely prefer that examples in any language leverage the language rather than being presented in some weird common subset. Frankly, I'd be happy with examples in F# if it illustrated a better approach to solving the problem at hand.

And I'll try to add more Eiffel, Spec#, Scheme (and maybe Haskell) examples going forward.