Chris Skorlinski
Microsoft SQL Server Escalation Services

By default the SQL Replication Agent History cleanup job runs every 10 minutes and deletes any historical data older the 48 hours.  If you’re only running SQL Server Replication Agent a few times each day, you can reduce the frequency of this cleanup job and increase the retention period for historical data without impacting SQL Server Replication performance.  The additional data may be helpful with tracking down subscribers with slow synchronization times.

To adjust the SQL Replication Agent History cleanup job:

1) Right-click on the ‘Agent history clean up: distribution’ cleanup Job in SQL Server Agent and select Properties.

2) On the Schedules page, adjust the Job run frequency as needed.  For example, if you only synchronize your subscribers once a day, you can set the cleanup to also run once a day.

3) On the Steps page, click Edit to bring up the TSQL command.  You can increase the retention parameter to keep > 48 hours for Replication topologies which synchronize infrequently.  Don’t set this to high or so much historical data will be stored the distribution database performance is impacted.  If you need longer then say 1 week of data, consider moving the history data to an archived database.

 EXEC dbo.sp_MShistory_cleanup @history_retention = 48

The following posting below contains detailed information on the Merge session history tables along with scripts to pull out long running subscribers.

First up, the UI Design and Interaction Guide for Windows Phone 7 v2.0 has been updated from the ground up for beta. With additional information and a new layout we hope you will find more readable, this guide provides detailed information about UI elements and controls, UI system behaviors, and the interaction model for the touch interface based on the design system internally named Metro. Designers and developers should read this guide to learn about the dos and don’ts of UI implementations for their Windows Phone apps. We’ve made it easier to find specific guidance by putting it in bold in the right-hand column of each page.

Programming Windows 7 with WPF 4

Right now we have these articles for you to read, but check this page for more coming soon.

Programming the Task Bar in Windows 7 with WPF 4, Part One – Thumbnail Buttons
Learn how to create interactive thumbnail buttons for your applications that appear on the Windows 7 taskbar using Windows Presentation Foundation.

Programming the Task Bar in Windows 7 with WPF 4, Part Two – Jump Lists
Learn how to program the the Windows 7 Jump List which provides an enhanced user experience offering easy access to common tasks, recent files and custom items related to your applications.

Earlier this month, TechEd returned to New Orleans for the first time since Hurricane Katrina, bringing 10,500 attendees to the area. And now considering the oil disaster in the gulf (I must admit I agree with The Daily Show that something is trying to kill N.O.), there was no better time for an economic boost for the city. TechEd even caught the attention of the major local newspaper (The Times-Picayune), describing cloud computing and the technical in-depth training TechEd provided. But Visual Studio 201? Opps! =D

The best part of TechEd for me was being a local among the locals. I’ve said for years that “Community is walking among the people”, but having this sense of Community^2 was incredible. I felt like I’ve known local attendees all my life, and for non-locals, I found myself with every conversation playing tour guide, making sure they had the most enjoyable TechEd experience possible. Fortunately, a local told me about http://www.nomenu.com/ which was a lifesaver in giving people French Quarter restaurant recommendations.

Highlights

• In my opinion, the unsung hero of TechEd was Tiffany Ingargiola, an IT Pro at New Horizons in New Orleans. She was the go-to local person for so many of us trying to organize events, but needed a contact on the ground. And she’s awesome to follow on twitter.
• Instead of purchasing a center-stage booth, DevExpress decided to purchase the smallest booth possible and donate the rest to build a house
• GeekGive.org ran its first successful event by participating in a Habitat for Humanity build the Friday before TechEd, where I got to work side-by-side with my local area MVP Peter Kellner.
• I successfully nominated my undergrad professor from Miss State, Associated Dean of Engineering Dr. Donna Reese, to speak at the Women in Tech luncheon about how to retain women in CS programs. Over 400 women attended the event.
• The attendee party hosted *the* Zydeco band of New Orleans Rockin’ Dopsie, Jr, and the Zydeco Twisters. I don’t think the attendees realized how much of a treat it was to have the band that plays during the Lundi Gras cerebration every year, where a United States Coast Guard ship delivers The King of Rex to the Riverwalk stage for the Mayor of New Orleans to hand over control of the city to for Mardi Gras Day. Afterwards, I got a chance to shake his hand and let him know what an honor it was to meet him.

Lowlights

• N.O. was under a heat wave advisory for that week. Heat index was between 110-115(!) most days.
• On Tuesday, there was a city-wide Internet outage for nearly 30 minutes. I never heard what caused outage.
• The convention center food wasn’t quite Cajun. “Cajun meatloaf” just isn’t right. But, I said it was to encourage folks to support local merchants by eating at local shops across the street. =D
• The effects of the Oil Spill were readily apparent. Just a few blocks away from TechEd was the annual Oyster Festival, where locals held a jazz funeral. Additionally, on that Thursday, a 134-year old Oyster bar closed .

GeekGive.org Habitat build

Last year at TechEd, MVP Steve Andrews, MVP Mark Rosenberg, INETA members and I chatted about what we could do to help New Orleans. We came up with a concept similar to GiveCamp, but instead of donating code, we’ll donate volunteer hours. Driven by Steve Andrews, he created GeekGive.org for conference attendees to volunteer their time at a local charity before the conference starts.

There will be two technology previews shown. The first one will use the Silverlight player to decode the 3D content and dynamically apply anaglyph (red-cyan) transformations to the video. The video will play back on a conventional display using red-cyan glasses.   The 2^nd demo will use Silverlight to play the video without transformation and output to a Panasonic 3D plasma display. THX Media Director was instrumental in making the 2^nd demo possible. Here is a diagram of the demo flow:

Create the ASP.NET Project

I’ll start by creating a new empty ASP.NET application with Visual Studio 2010. Select the menu option File, New Project and select the ASP.NET Empty Web Application project template.

Setup the Database and Data Model

I’ll use my standard MoviesDB.mdf movies database. This database contains one table named Movies that looks like this:

I’ll use the ADO.NET Entity Framework to represent my database data:

1. Select the menu option Project, Add New Item and select the ADO.NET Entity Data Model project item. Name the data model MoviesDB.edmx and click the Add button.
2. In the Choose Model Contents step, select Generate from database and click the Next button.
3. In the Choose Your Data Connection step, leave all of the defaults and click the Next button.
4. In the Choose Your Data Objects step, select the Movies table and click the Finish button.

Unfortunately, Visual Studio 2010 cannot spell movie correctly You need to click on Movy and change the name of the class to Movie. In the Properties window, change the Entity Set Name to Movies.

Using a Generic Handler

In this section, we’ll use jQuery with an ASP.NET generic handler to insert a new record into the database. A generic handler is similar to an ASP.NET page, but it does not have any of the overhead. It consists of one method named ProcessRequest().

Select the menu option Project, Add New Item and select the Generic Handler project item. Name your new generic handler InsertMovie.ashx and click the Add button.

Modify your handler so it looks like Listing 1:

Listing 1 – InsertMovie.ashx

using System.Web;

namespace WebApplication1 {
    /// <summary>
    /// Inserts a new movie into the database
    /// </summary>
    public class InsertMovie : IHttpHandler {

        private MoviesDBEntities _dataContext = new MoviesDBEntities();

        public void ProcessRequest(HttpContext context) {
            context.Response.ContentType = "text/plain";

            // Extract form fields
            var title = context.Request["title"];
            var director = context.Request["director"];

            // Create movie to insert
            var movieToInsert = new Movie { Title = title, Director = director };

            // Save new movie to DB
            _dataContext.AddToMovies(movieToInsert);
            _dataContext.SaveChanges();

            // Return success
            context.Response.Write("success");
        }

        public bool IsReusable {
            get {
                return true;
            }
        }

    }
}

In Listing 1, the ProcessRequest() method is used to retrieve a title and director from form parameters. Next, a new Movie is created with the form values. Finally, the new movie is saved to the database and the string “success” is returned.

Using jQuery with the Generic Handler

We can call the InsertMovie.ashx generic handler from jQuery by using the standard jQuery post() method. The following HTML page illustrates how you can retrieve form field values and post the values to the generic handler:

Listing 2 – Default.htm

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Add Movie</title>

    <script src="http://ajax.microsoft.com/ajax/jquery/jquery-1.4.2.js" type="text/javascript"></script>
</head>
<body>

<form>
    <label>Title:</label>
    <input name="title" />

    <br />

    <label>Director:</label>
    <input name="director" />
</form>

<button id="btnAdd">Add Movie</button>

<script type="text/javascript">

    $("#btnAdd").click(function () {
        $.post("InsertMovie.ashx", $("form").serialize(), insertCallback);
    });

    function insertCallback(result) {
        if (result == "success") {
            alert("Movie added!");
        } else {
            alert("Could not add movie!");
        }
    }

</script>

</body>
</html>

When you open the page in Listing 2 in a web browser, you get a simple HTML form:

Notice that the page in Listing 2 includes the jQuery library. The jQuery library is included with the following SCRIPT tag:

<script src=”http://ajax.microsoft.com/ajax/jquery/jquery-1.4.2.js” type=”text/javascript”></script>

The jQuery library is included on the Microsoft Ajax CDN so you can always easily include the jQuery library in your applications. You can learn more about the CDN at this website:

http://www.asp.net/ajaxLibrary/cdn.ashx

When you click the Add Movie button, the jQuery post() method is called to post the form data to the InsertMovie.ashx generic handler. Notice that the form values are serialized into a URL encoded string by calling the jQuery serialize() method. The serialize() method uses the name attribute of form fields and not the id attribute.

Notes on this Approach

This is a very low-level approach to interacting with .NET through jQuery – but it is simple and it works! And, you don’t need to use any JavaScript libraries in addition to the jQuery library to use this approach.

The signature for the jQuery post() callback method looks like this:

callback(data, textStatus, XmlHttpRequest)

The second parameter, textStatus, returns the HTTP status code from the server. I tried returning different status codes from the generic handler with an eye towards implementing server validation by returning a status code such as 400 Bad Request when validation fails (see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html ). I finally figured out that the callback is not invoked when the textStatus has any value other than “success”.

Using a WCF Service

As an alternative to posting to a generic handler, you can create a WCF service.

You create a new WCF service by selecting the menu option Project, Add New Item and selecting the Ajax-enabled WCF Service project item. Name your WCF service InsertMovie.svc and click the Add button.

Modify the WCF service so that it looks like Listing 3:

Listing 3 – InsertMovie.svc

using System.ServiceModel;
using System.ServiceModel.Activation;

namespace WebApplication1 {

    [ServiceBehavior(IncludeExceptionDetailInFaults=true)]
    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class MovieService {

        private MoviesDBEntities _dataContext = new MoviesDBEntities();

        [OperationContract]
        public bool Insert(string title, string director) {
            // Create movie to insert
            var movieToInsert = new Movie { Title = title, Director = director };

            // Save new movie to DB
            _dataContext.AddToMovies(movieToInsert);
            _dataContext.SaveChanges();

            // Return movie (with primary key)
            return true;
        }

    }
}

The WCF service in Listing 3 uses the Entity Framework to insert a record into the Movies database table. The service always returns the value true.

Notice that the service in Listing 3 includes the following attribute:

[ServiceBehavior(IncludeExceptionDetailInFaults=true)]

You need to include this attribute if you want to get detailed error information back to the client. When you are building an application, you should always include this attribute. When you are ready to release your application, you should remove this attribute for security reasons.

Using jQuery with the WCF Service

Calling a WCF service from jQuery requires a little more work than calling a generic handler from jQuery. Here are some good blog posts on some of the issues with using jQuery with WCF:

• http://encosia.com/2008/06/05/3-mistakes-to-avoid-when-using-jquery-with-aspnet-ajax/
• http://encosia.com/2008/03/27/using-jquery-to-consume-aspnet-json-web-services/
• http://weblogs.asp.net/scottgu/archive/2007/04/04/json-hijacking-and-how-asp-net-ajax-1-0-mitigates-these-attacks.aspx
• http://www.west-wind.com/Weblog/posts/896411.aspx
• http://www.west-wind.com/weblog/posts/324917.aspx
• http://professionalaspnet.com/archive/tags/WCF/default.aspx

The primary requirement when calling WCF from jQuery is that the request use JSON:

• The request must include a content-type:application/json header.
• Any parameters included with the request must be JSON encoded.

Unfortunately, jQuery does not include a method for serializing JSON (Although, oddly, jQuery does include a parseJSON() method for deserializing JSON). Therefore, we need to use an additional library to handle the JSON serialization.

The page in Listing 4 illustrates how you can call a WCF service from jQuery.

Listing 4 – Default2.aspx

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Add Movie</title>

    <script src="http://ajax.microsoft.com/ajax/jquery/jquery-1.4.2.js" type="text/javascript"></script>
    <script src="Scripts/json2.js" type="text/javascript"></script>

</head>
<body>

<form>
    <label>Title:</label>
    <input id="title" />

    <br />

    <label>Director:</label>
    <input id="director" />
</form>

<button id="btnAdd">Add Movie</button>

<script type="text/javascript">

    $("#btnAdd").click(function () {
        // Convert the form into an object
        var data = { title: $("#title").val(), director: $("#director").val() };

        // JSONify the data
        data = JSON.stringify(data);

        // Post it
        $.ajax({
            type: "POST",
            contentType: "application/json; charset=utf-8",
            url: "MovieService.svc/Insert",
            data: data,
            dataType: "json",
            success: insertCallback
        });
    });

    function insertCallback(result) {
        // unwrap result
        result = result["d"];

        if (result === true) {
            alert("Movie added!");
        } else {
            alert("Could not add movie!");
        }
    }

</script>

</body>
</html>

There are several things to notice about Listing 4. First, notice that the page includes both the jQuery library and Douglas Crockford’s JSON2 library:

<script src=”Scripts/json2.js” type=”text/javascript”></script>

You need to include the JSON2 library to serialize the form values into JSON. You can download the JSON2 library from the following location:

http://www.json.org/js.html

When you click the button to submit the form, the form data is converted into a JavaScript object:

// Convert the form into an object

var data = { title: $(”#title”).val(), director: $(”#director”).val() };

Next, the data is serialized into JSON using the JSON2 library:

// JSONify the data

var data = JSON.stringify(data);

Finally, the form data is posted to the WCF service by calling the jQuery ajax() method:

// Post it

$.ajax({

  type: ”POST”,

  contentType: ”application/json; charset=utf-8″,

  url: ”MovieService.svc/Insert”,

  data: data,

  dataType: ”json”,

  success: insertCallback

});

You can’t use the standard jQuery post() method because you must set the content-type of the request to be application/json. Otherwise, the WCF service will reject the request for security reasons. For details, see the Scott Guthrie blog post:

http://weblogs.asp.net/scottgu/archive/2007/04/04/json-hijacking-and-how-asp-net-ajax-1-0-mitigates-these-attacks.aspx

The insertCallback() method is called when the WCF service returns a response. This method looks like this:

function insertCallback(result) {

  // unwrap result

  result = result["d"];

  if (result === true) {

      alert(”Movie added!”);

  } else {

    alert(”Could not add movie!”);

  }

}

When we called the jQuery ajax() method, we set the dataType to JSON. That causes the jQuery ajax() method to deserialize the response from the WCF service from JSON into a JavaScript object automatically. The following value is passed to the insertCallback method:

{”d”:true}

For security reasons, a WCF service always returns a response with a “d” wrapper. The following line of code removes the “d” wrapper:

// unwrap result

result = result["d"];

To learn more about the “d” wrapper, I recommend that you read the following blog posts:

• http://encosia.com/2009/02/10/a-breaking-change-between-versions-of-aspnet-ajax/
• http://encosia.com/2009/06/29/never-worry-about-asp-net-ajaxs-d-again/

Summary

In this blog entry, I explored two methods of inserting a database record using jQuery and .NET. First, we created a generic handler and called the handler from jQuery. This is a very low-level approach. However, it is a simple approach that works.

Next, we looked at how you can call a WCF service using jQuery. This approach required a little more work because you need to serialize objects into JSON. We used the JSON2 library to perform the serialization.

In the next blog post, I want to explore how you can use jQuery with OData and WCF Data Services

Here’s some good links to check out for VS2010:

• Visual Studio 2010 and .NET Framework 4 Release Candidate
• Visual Studio 2010 Walkthroughs
• Visual Studio 2010 and .NET Framework 4 Training Kit
• Visual Studio 2010 Samples
• Visual Studio 2010 Product Information

Right after the Keynote I had a session that I’ve spoken about many times before (always a crowd pleaser) on VB10 / C#4 language features which are covered in these walkthroughs, articles and videos, on MSDN:

• Creating and Using Dynamic Objects (C# and Visual Basic)
• Embedding Types from Managed Assemblies (C# and Visual Basic)
• Use Named and Optional Arguments in Office Programming (C# Programming Guide)
• Create a Collection Used by a Collection Initializer
• Create an Add Extension Method Used by a Collection Initializer
• Generic Co- and Contravariance in Visual Basic 2010
• VS 2010 VB Language Features Video Series
• C# 4.0 Video Series

I also did an off-the-cuff talk yesterday with Jon Aneja at lunch on using Open XML and XML Literals in VB to manipulate Office document formats.

• Article: Taking Advantage of LINQ and XML in Microsoft Office 2007
• Article: Mail Merging Into a Single Word Document Using XML Literals
• Article: Merging Text & Photos into a Word Document using Open XML SDK
• Screencast: Showing off the Open XML SDK and LINQ
• Screencast: More Fun with Office and XML Literals
• Code: Working with Open XML in Visual Basic

My last session was today on Building Office Productivity Solutions with Visual Studio 2010 and according to the evals it went well just like my language talk. We created an OBA for good old Northwind Traders, bringing them into the 21st century.   I showed the new features of VS2010 that makes Office development easier focusing on RAD data binding (including WPF) and designers, ribbon and the other available designers, as well as SharePoint 2010 tools around workflow and visual web parts.

My main goal was to provide a real-world scenario and architecture but keep the demo code manageable and simple while also introducing folks to all the RAD designers available. This way you can take apart the sample easily and reuse just the pieces you need. Check out the code and all the articles here: http://code.msdn.microsoft.com/OBANorthwind and check out the VSTO Developer Center for more awesome resources: http://msdn.com/vsto

Some of the new features that make Office development and deployment easier are covered in these walkthroughs:

• Office Programming (C# and Visual Basic)
• Embedding Type Information from Microsoft Office Assemblies (C# and Visual Basic)
• Deploying Multiple Office Solutions in a Single ClickOnce Installer
• Copying a Document to the End User Computer after a ClickOnce Installation
• SharePoint Development in Visual Studio 2010

Here are some pictures from the conference which was held at a really nice Microsoft facility in Mississauga

Fortunately we can also load a workflow from the XAML file itself and execute the resulting workflow activity. This is done using the ActivityXamlServices class that will let us load the XAML file and return an activity, to be exact it returns a DynamicActivity as a wrapper around your definition.

The simplest option is just to call Load() passing in the file name like this:

Activity workflow = ActivityXamlServices.Load("YourWorkflow.xaml");

If you are using activities, or other types, from the local assembly this is going to fail though and you need a slightly more verbose way of doing thing like this:

var settings = new XamlXmlReaderSettings()

{

    LocalAssembly = typeof(SendForManualApproval).Assembly

};

var reader = new XamlXmlReader("YourWorkflow.xaml", settings);

Activity workflow = ActivityXamlServices.Load(reader);

We need to use the XamlXmlReaderSettings to indicate what the local assembly reference in the XAML is.