Tony Sneed's Blog

Microsoft has just released a full-fledged data grid for WPF, along with date picker and calendar controls. There is also a WPF Office Ribbon control. To get the binaries (and source code!), go here:

http://www.codeplex.com/wpf/Release/ProjectReleases.aspx?ReleaseId=15598

Enjoy.

For anyone unable to attend the Microsoft Professional Developers Conference (PDC) this week in Los Angeles, it is possible to view live recordings of the sessions here:

https://sessions.microsoftpdc.com/public/timeline.aspx

Just select the session you want to view, and then click the play button to view the recording.

I’ve also started collecting some of my favorite sessions (like the one by Anders Hejlsberg on C# 4.0) on my delicious web site:

http://delicious.com/tonysneed_wni3/pdc

Enjoy.

The nice thing about WCF is its ability to reach all types of clients, including those set up for communication with a traditional ASMX web service. In many cases, those clients reference a URL ending with an .asmx extension, and it’s not always practical to re-configure clients to use a WCF service that ends with .svc. It would be great if you could configure a WCF service with a basic http binding to respond to requests ending with .asmx.

There is quite good support for this scenario in WCF, and here is a blog post describing how to change web.config:
http://blogs.msdn.com/wenlong/archive/2007/09/18/how-to-use-asmx-extension-to-handle-wcf-requests.aspx

The key here is to specify the WCF ServiceBuildProvider to the .asmx extension, which enables you to create a WCF service file that includes a ServiceHost directive, but end it with .asmx instead of .svc. Note that if you are running IIS is ASP.NET compatibility mode, you’ll also want to change the HttpHandler for .asmx to the WCF HttpHandler. You can download a sample project here.

There are a couple of gotchas when managing concurrency issues with LINQ to SQL. First, when you catch a ChangeConflictException and allow the other user’s changes to win by calling ResolveAll on the DataContext’s ChangeConflicts property and passing RefreshMode.OverwriteCurrentValues, other non-conflictual changes will not be persisted because LINQ to SQL will roll back the transaction it started whenever there is an exception. To avoid this behavior, you need to wrap the call to SubmitChanges inside a “using” block that creates a new TransactionScope. Then right before the ending brace, you need to call Complete on the TransactionScope, which will ensure that the changes you tried to persist when calling SubmitChanges will in fact commit, even when you catch a ChangeConflictException.

// Persist non-conflict changes even when catching an exception
using (TransactionScope txScope = new TransactionScope())
{
    try
    {
        db.SubmitChanges
            (ConflictMode.ContinueOnConflict);
    }
    catch (ChangeConflictException)
    {
        Console.WriteLine("Re-submit changes? {Y/N}");
        ConsoleKey key = Console.ReadKey().Key;
        if (key == ConsoleKey.Y)
        {
            //Keep local data
            //db.ChangeConflicts.ResolveAll
                //(RefreshMode.KeepCurrentValues);
            foreach (ObjectChangeConflict conflict
                in db.ChangeConflicts)
            {
                conflict.Resolve
                    (RefreshMode.KeepCurrentValues);
            }
            // Overwrite other users' changes
            db.SubmitChanges();
        }
        else
        {
            // Refresh local data from the database
            db.ChangeConflicts.ResolveAll
                (RefreshMode.OverwriteCurrentValues);
        }
    }

    // Commit transaction
    txScope.Complete();
}

As you can see from this code, there are two ways you can resolve a change conflict. You can allow the other user’s changes to overwrite your own (shown in the ‘else’ block), or you can keep your current values and attempt to re-submit your changes to the database (as shown in the ‘if’ block), overwriting the other user’s changes with your own. As indicated, there is a problem lurking here. The ResolveAll method has a bug that refreshes database values, not just for the change conflicts, but for all updates in the change set, which results in an InvalidOperationException when you try to invoke SubmitChanges. The exception states that the timestamp property (which you are using for optimistic concurrency checking) is a computed value and cannot be changed. The answer is to iterate each change conflict and call Resolve on them individually. Thus, we avoid refreshing items for which there is not a change conflict, because those changes were applied the first time we called SubmitChanges.  You can download the full VS project here.

I just found a great post on how to format code sections in a WordPress blog:

http://www.thomasclaudiushuber.com/blog/2008/01/07/give-your-blog-code-the-visual-studio-look

Now the code in my blog should look a lot prettier.

static void Foo()
{
    // This is a comment
    Console.WriteLine("Print something to the console.");
}

I’ve been using NOD32 as my anti-virus for quite some time now, and I’ve been quite pleased with it. For the most part it runs silently in the background and does not impact system performance. However, I’ve discovered there are some issues related to running Visual Studio and its interaction with NOD32.

First of all, if you develop web applications with VS, you may run into trouble. After creating a web app based on the “File System” (using the ASP.NET development web server), I would not be able to run the app from Visual Studio. When pressing F5 or Ctrl+F5, Internet Explorer would state plainly that it could not display the web page. But on closer inspection, I noticed that the port number had been decremented by 2 from that used by the development web server.

I ran across a forum post, which referenced a blog post detailing the problem and how to solve it. It turns out NOD32 Protocol Filtering is the culprit. What you need to do is disable this feature for the ASP.NET development server. Open NOD32, press F5 to show advanced settings, then in the tree-view on the left expand Web Access Protection / HTTP / Web Browsers. Click the Add button to add WebDev.WebServer.EXE, located here:
C:\Program Files\Common Files\microsoft shared\DevServer\9.0

Click the checkbox until a Red X is displayed. This will solve the problem. As a postscript, I also had to add an exclusion for MS Word in order to publish this blog post. J

If you’ve been programming WCF for a while, you’re probably used to the convenience of using the proxy class generated by svcutil.exe when you add a Service Reference to a Visual Studio project. You’re also probably used to creating the proxy within a using block, so that its Dispose method is called and cleanup can take place in a robust fashion.

However, you may not be aware that closing the proxy at the end of the using block could result in an exception (for example, a Timeout or Communication exception) and that you should catch this exception and call Abort on the client channel, as described in this MSDN topic: http://msdn.microsoft.com/en-us/library/aa355056(VS.85).aspx.

using (MyServiceClient proxy = new MyServiceClient())
{
    proxy.SomeOperation();
} // Could throw an exception here

To remedy this, I wrote a code snippet that creates a partial class to extend the generated proxy class by implementing IDisposable and properly handling the cleanup. Although there are other approaches you could take, what I like about the code snippet is that it doesn’t require you to change the code that creates and uses the proxy. Here’s the code that the snippet produces:

namespace Client.MyService
{
    public partial class MyServiceClient : IDisposable
    {
        bool disposed;

        public void Dispose()
        {
            if (!disposed)
            {
                CloseChannel();
            }
            disposed = true;
        }

        void CloseChannel()
        {
            try
            {
                if (base.InnerChannel.State
                    != CommunicationState.Closed)
                {
                    this.InnerChannel.Close();
                }
            }
            catch
            {
                this.InnerChannel.Abort();
            }
        }
    }
}

The code snippet has placeholders for both the namespace name and the class name, which reflect what you specified when adding the Service Reference. You can download the code snippet here. To install it, place it in the My Code Snippets folder: …\Documents\Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets. Enjoy.