Alex Thissen Weblog Build 1.15.10.1971 : .NET FX 3.0

Workaround for missing "Edit WCF Configuration" menu option in Visual Studio

Alex Thissen — Thu, 28 Aug 2008 09:48:00 GMT

Sometimes when you have a clean install of Visual Studio 2005 or 2008 the context menu item "Edit WCF Configuration" for a app.config or web.config will not show.

The picture above does show the menu item I'm talking about, but you may find that it is not there.

Help is at hand: there is an easy workaround. Simply open up the Tools menu in Visual Studio and choose "Wcf Service Configuration Editor". This will start the exact same tool, but doesn't open your web/app.config. Close the tool straight away and right-click you config file. The "Edit WCF Configuration" context menu should be there now.

I don't know exactly when the context menu goes missing, but I found that it occurs regularly for Virtual PC images. It might be totally unrelated to that though. The workaround works in all cases I encountered so far.

Workflow Foundation performance

Alex Thissen — Sat, 04 Aug 2007 21:48:20 GMT

From my week in Redmond I still had notes on the performance session of WF. Instead of throwing them away, I thought I would share them. The session follows the technical artical 'Performance Characteristics of Windows Workflow Foundation' for the larger parts. This means that the points on performance below are complementary to the article. For more background and nice graphs, read the article.

1. Persistence service

Recommendation: Consider when to persist.

Persistence happens when:

the WorkflowRuntime instance is stopped,
a custom activity marked with PersistOnClose=true closes or
when UnloadOnIdle=true for the persistence provider.

An instance is handed to the persistence provider, which uses the binary formatter to serialize it, that then gets passed to a GZipStream to compress the binary stream. For unloading an instance first gets persisted, then unloaded from memory. Also, persistence occurs at the end of a TransactionScope (also marked as PersistOnClose).

2. Activity Execution Context cloning

Recommendation: Write custom activities instead of cloning where high performance is required.

Issue: Workflow runtime uses AEC to maintain activity instance state and to run compensation logic.

3. Transactions in WF Activities

Recommendation: Use IPendingWork for simple workflow database transactions. Check out the WorkflowCommitWorkBatch in the SDK samples for more information. The workflow instance initial state is copied before the transaction in case of rollback. The use of System.Transaction means MSDTC occurs only if necessary.

4. Nesting compensation

Recommendation: Avoid nesting of compensating activities where performance is desired.

Issue: Because compensation retains a copy of the workflow instance state, nested compensation causes the state to multiply.

5. Workflow tracking service

Recommendation: Review your tracking profile for the required number of tracking events. Track only the events you really need.

Issue: Database operations caused by tracking affect performance.

The number of track points can be modified at runtime by editing the tracking profile. When batching is used the load is about 5% CPU usage for the SQL Server. Turning it off will make SQL Server CPU usage go up to 75%. The tracking service database can be partitioned into multiple tables. See Moustafa's blog. There are stored procedures you can run yourself and you can turn on automatic partitioning.

6. Workflow activity complexity

Recommendation: Optimize factors affecting state

Issue: State size affects persistence time.

Factors: Numbers of fields on the class. Properties and dependency properties being accessed. Serives being consumed. Workflow queues being used. Activity execution overhead.

7. Workflow activation cost

Recommendation: Consider startup time.

Issue: First time tree creation and validation.

Activation occurs when the workflow host calls WorkflowRuntime.CreateWorkflow. This startup time increases with the number of activities.

8. ExternalDataExchange and parameters

Recommendation: Consider serialized event data size

Issue: ExternalDataExchange and parameters are serialized through WF internal queues. Giant chunks of data will take more time to get serialized.

9. Workflow declarative rules and policy

Recommendation: Consider performance of rules

Issue: Declarative rules take longer than code conditions

Using the RuleEngine class can improve performance over the Policy activity. Rule priorities and chaining have a big effect on performance.

10. Workflow instance dynamic update

Recommendation: Consider performance

Issue: This mechanism is slow.

What it does is:

instance is suspended
clone the instance
edit the clone
validate changes (all validators are called on the new tree)
apply changes

This has impact on tracking, tracing and persistence.

11. Workflow dependency properties

Recommendation: Avoid when regular properties can be used.

Issue: Dependency properties are slower than regular .NET properties. There's just a few more .NET instructions in play.

12. Workflow state machine root activity

Recommendation: avoid deeply nested states.

Issue: state transitions in and out of deeply nested states are expensive due to tree navigation and AEC cloning.

13. Workflow runtime startup cost

Recommendation: only use one WorkflowRuntime per AppDomain

Issue: Instantiating WorkflowRuntime and calling StartRuntime is expensive.

Why? Retrieves runtime config parameters. Starts default and custom services. These are significant performance configuration settings:

Runtime: EnablePerformanceCounters (default true) and ValidateOnCreate (defaults to true)
TransactionService: EnableRetries
SchedulerService: MaxSimultaneousWorkflows
PersistenceService: EnableRetries, LoadIntervalSeconds, OwnershipTimeoutSeconds
TrackingService: EnableRetries, IsTransactional (has nothing to do with real transactions, but will batch up tracking database writes), UseDefaultProfile (default profile will track all workflow level events and activity level events), PartitionOnCompletion
DisableWorkflowDebugging

Workflow Foundation Rules in Orcas

Alex Thissen — Tue, 10 Apr 2007 21:21:04 GMT

Again, some background on where we are with rules in WF version 1 (in .NET FX 3.0):

The Rules framework in WF allow you to define discrete and atomic rules using simple semantics. This makes it very approachable. WF Rules distinguish conditions (boolean evaluations) and rules (if-then-else semantics, where the if-part uses a condition). There are several out-of-the-box activities that use conditions (IfElse, While, Replicator, Conditioned Activity Group (CAG)), and one Policy activity that works with a RuleSet, consisting of multiple rules. Obviously, custom activities allow you to use both conditions and rules.

The conditions and rules are defined in XAML format, as a XML representation of a CodeDOM object model for the IL that will eventually be executed. By default, the XAML is defined in a .rules file, embedded in the assembly as a manifest resource file. The default editor allows you to build the rules in a C# or VB-like language (side note: the "VB-like" language is a running gag at Class-A, where Mike Glaser coined this term during a Analysis Services training). These two flavors are as close to C#/VB as possible, but still an invention of the WF team. There is a document here that describes the differences (link and document will be up as soon as I get it from Moustafa Khalil Ahmed).

You can use tracking and tracing when working with rules. The RuleActionTrackingEvent tracks a rule name and the result of the condition evaluation. Rules condition evaluation is implicitly tracked by activity execution. All you need to do is build a tracking profile and listen for the user tracking events related to rules. This tracking is only available for rules executed from within a workflow. Tracing is provided by the Diagnostics API and involves nothing more than adding the tracing source for WF rules to your config file. This also means that (in contrast to tracking) rules tracing is available everywhere.

This is where we are at in v1.

Orcas rule changes involve an enhanced language support. In particular, there is support for

operator overloading
new operator
calling of extension methods.

Furthermore, WF includes bugfixes on bugs that have been reported so far.

As an example, take a look at this ELSE action of an imaginary rule that validates the order information:

System.Console.WriteLine("\tExecuting Rule: InvalidOrder")
this.invalidOrder = new Microsoft.Rules.Samples.OrderError(this.ItemNum)
this.errors = new Microsoft.Rules.Samples.OrderErrorCollection()
this.errors.Add(this.invalidOrder)
this.errors.ReportErrors()

Notice how the new operator is used. Then imagine that the ReportErrors method is actually an extension method. Calling it will work as expected.

So, my take on this is that there aren't many enhancements available in the Workflow rules. Just good things like the bugfixes and the extra bits of language support.

The WF team is planning for the post-Orcas release, but there are no concrete plans yet, at least not any that Moustafa would tell about (as they might change).

What's new in .NET Framework 3.5.20209 (March 2007 CTP) Part 1

Alex Thissen — Wed, 28 Feb 2007 09:44:00 GMT

The .NET Framework 3.5 build 3.5.20209 was released earlier this morning as part of the Visual Studio Orcas March 2007 CTP. Find the downloads here:

If you download the Virtual PC image, you get an image with both Team Foundation Server and VS Orcas installed. Update: ~~Recommended~~. See this post.

The .NET FX 3.5.20209 contains a load of new assemblies and features. It's amazing how big the leap forward is. Instead of repeating the list of all the new features (that you can find at any of the download locations above), I will give my first hour impressions on the new FX. Here we go. I have some BIG things to show you.

Workflow gets WCF support

The System.WorkflowServices assembly will make you drool. There are some new Activities for you to use in your workflow. These are called SendActivity and ReceiveActivity. These activities can be used inside a workflow to communicate to and from the workflow as a WCF service.

Also, a new WorkflowServiceHost (plus corresponding WorkflowServiceHostFactory) complements the existing ServiceHost class for hosting services. It has a read-only property for the WorkflowRuntime and adds a WorkflowRuntimeBehavior to the end points automatically. It is this behavior that hosts the workflow's runtime.

The NetTcpContentBinding and WSHttpContextBinding are two new WCF bindings that derive from NetTcpBinding and WSHttpBinding respectively. They add the concept of contexts to the existing bindings. You will get two properties that you can set: ContextExchangeMechanism and ContextProtectionLevel. Both implementations use the ContextBindingElement class to bring

ChannelManagerService is a new runtime service that registers handlers for the lifetime events of a workflow in the hosted runtime. It will manage the cache of WCF channels that are opened and used for a particular workflow instance.

AJAX ASP.NET Extensions integrated

The ASP.NET 2.0 AJAX Extensions 1.0 are now integrated into the framework. They still exist in the System.Web.Extensions assembly and have been merged with the other stuff already there.

Client services

There are a whole bunch of new classes in the namespaces System.Web.ClientServices and System.Web.ClientServices.Providers. These classes seem to be intended in conjunction with Smart Client applications, that can have an off-line (network connection) state. The providers are used for authentication, profiles and roles, just like for the application services. Here they have created a separate interface for the service contracts (where this is not the case for Application services). Finally, there is the possibility to retrieve and/or store client settings.

Changes in System.Web.Extensions.dll

Quick recap: the extension to ASP.NET 2.0 already included the RolesService and LoginService classes, which are WCF services with operations to attempt to log a user in and retrieve their roles. It also already had a ListView control and a DataPager that combine to form a pageable list view. These come complete with designers. And, there is a new Web Event for errors in web services, called WebServiceErrorEvent, that you can leverage in your ASP.NET health monitoring.

Apart from the addition of the AJAX extensions and client services, there is now a third WCF service named ProfilesService, that can get profile properties from a user (possibly a member through Membership). Also, some minor renames in namespaces. The three WCF services are no longer under System.Web.Security, but System.Web.ApplicationServices.

Build provider for WCF

Last, but not least, a new build provider is introduced for ASP.NET web sites, that can build service proxies for you by importing service map files (.svcmap). These files are created when adding Service References to an ASP.NET Web site and contain all details of the referenced services, including their meta-data files such as XSD schemas.

More on .NET FX 3.5 and Visual Studio Orcas in later posts.

Hosting the LoginService in .NET 3.5

Alex Thissen — Sat, 17 Feb 2007 11:26:07 GMT

The January 2007 CTP version of Visual Studio "Orcas" has .NET FX 3.5 version 3.5.11209. One of the assemblies is System.Web.Extensions and hosts some great new additions to the ASP.NET stack. It has new classes in the namespace System.Web.Security, two of which are LoginService and RolesService. In this post we will take a look at the LoginService.

The LoginService class allows you to perform ASP.NET 2.0 Membership validation through a WCF service. This way other applications can also benefit from your efforts of setting up the membership service and maintaining the member store behind it. Let's see how you do that:

The LoginService has been decorated by the ServiceContract attribute. Four of its members are opted-in as operations via the OperationContract attribute: IsLoggedIn, Login, Logout and ValidateUser. A small fragment of the class:

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Required)]

[ServiceContract]

public class LoginService

{

public static event AuthenticatingEventHandler Authenticating;

public static event CreatingCookieEventHandler CreatingCookie;

static LoginService();

[OperationContract]

private bool IsLoggedIn();

[OperationContract]

private bool Login(string username, string password, string customCredential, bool isPersistent);

[OperationContract]

private void Logout();

protected virtual void OnAuthenticating(AuthenticatingEventArgs e);

protected virtual void OnCreatingCookie(CreatingCookieEventArgs e);

[OperationContract]

private bool ValidateUser(string username, string password, string customCredential);

// ...

}

Hosting the service

Both the LoginService and RolesService need the services of the ASP.NET pipeline. They indicate so by the AspNetCompatibilityRequirements attribute. This also means that this service must be hosted in IIS, instead of another type of host. Some easy steps are needed:

Create an ASP.NET Web Site or Application and add a reference to System.ServiceModel.dll and to System.Web.Extensions.dll. You can try all of this in a VPC with the Janurary 2007 build of VS Orcas, or copy the System.Web.Extensions.dll file from the VPC to your .NET 3.0 machine and use Visual Studio 2005 SP1 (I did the latter).
Add a .svc file (e.g. LoginService.svc) for the WCF service and change the ServiceHost directive to the following:

<%@ServiceHost Language=C# Debug="true" Service="System.Web.Security.LoginService" %>

Note that no CodeBehindFile attribute is needed, since the service type is already compiled.
Create a web.config (if necessary and add a <system.serviceModel> element:

<system.serviceModel>

<serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>

<behaviors>

<serviceBehaviors>

<behavior name="aspNetBehavior">

<serviceMetadata httpGetEnabled="true"/>

<serviceDebug includeExceptionDetailInFaults="true"/>

</behavior>

</serviceBehaviors>

</behaviors>

<services>

<service behaviorConfiguration="aspNetBehavior" name="System.Web.Security.LoginService">

<endpoint binding="basicHttpBinding" bindingConfiguration="" name="LoginServiceEndPoint" contract="System.Web.Security.LoginService"/>

<endpoint address="MEX" binding="mexHttpBinding" bindingConfiguration="" name="MEX" bindingName="MEX" contract="IMetadataExchange"/>

</service>

</services>

</system.serviceModel>

The bolded part is perhaps the important bit here. This is where the ASP.NET compatibility is enabled. If you do not specify this, the service will not be available.
Change the authentication mode of ASP.NET to Forms Authentication. You can do this by editing the web.config yourself or the ASP.NET Website Administration Tool, whichever you prefer best. While you're at it, create one or more test accounts in the Membership store, if you do not have an existing one. Membership is enabled by default, and the AspNetDb.mdf SQL Server Express database should be created automatically in your App_Data folder.
Save it all and visit the URL http://localhost:1337/ASPNETServicesViaWCF/LoginService.svc, subsituting your port number and site names if needed.

Creating a client

At this point you will have a working WCF service that allows clients to use the Membership services over WCF. Creating a client application is pretty straightforward, with one caveat. Just add a Service Reference and call the WCF service via the generated proxy like so:

class Program

{

static void Main(string[] args)

{

string username = "alex", password = "Str0n5P@ssmoRD";

LoginService proxy = new LoginServiceClient();

Console.WriteLine("Validate user '{0}': {1}", username,

proxy.ValidateUser(username, password, String.Empty));

Console.WriteLine("Log in successful: {0}",

proxy.Login(username, password, String.Empty, true));

Console.WriteLine("Logged in: {0}", proxy.IsLoggedIn());

}

The result of this bit of client code shows the following output:

You need to make sure that you allow and enable the client to accept cookies if you want to make use of a persistent login. The configuration is in your binding to the service. It should look like this:

<system.serviceModel>

<binding name="LoginServiceEndPoint" allowCookies="true" />

</basicHttpBinding>

</bindings>

<endpoint address="http://localhost:1337/ASPNETServicesViaWCF/LoginService.svc"

binding="basicHttpBinding" bindingConfiguration="LoginServiceEndPoint"

contract="WCFMeetsASPNET.localhost.LoginService" name="LoginServiceEndPoint" />

</client>

</system.serviceModel>

</configuration>

Extensibility points

There are also two extensibility points in the service, provided by the two static (!) events Authenticating and CreatingCookie on the LoginService class. Each of these can have a single (although you could attach more: not recommended) handler attached in the global.asax. The constructor of the HttpApplication derived class is a good place to attach the handler to each of the events.

public class Global: HttpApplication

{

public Global()

{

LoginService.Authenticating += new AuthenticatingEventHandler(LoginService_Authenticating);

LoginService.CreatingCookie += new CreatingCookieEventHandler(LoginService_CreatingCookie);

}

void LoginService_CreatingCookie(object sender, CreatingCookieEventArgs e)

{

// User name might not be same as login name

string realUserName = AuthenticationHelper.GetUserNameFromLogin(e.Username);

FormsAuthentication.SetAuthCookie(realUserName, e.IsPersistent);

e.CookieIsSet = true;

}

void LoginService_Authenticating(object sender, AuthenticatingEventArgs e)

{

bool authenticated = Membership.ValidateUser(e.Username, e.Password);

string ticket = e.CustomCredential;

e.Authenticated = authenticated && TicketAuthenticator.IsValidTicket(ticket);

e.AuthenticationIsComplete = true;

}

Two possible scenarios are implemented in the code fragment above.

First off, you are able to use custom credentials for your login. These could be used instead of the username and password or complement it. The event arguments for Authenticating give you the user name, password and custom credentials as a set of string properties. The boolean Authenticated property indicates whether the login has succeeded. If you managed to perform authentication the AuthenticationIsComplete should be set to true, or the regular mechanism will kick in (which may be what you want).

The other extensibility point is in the creation of the cookie. The handler for the CreatingCookie event gets arguments of type CreatingCookieEventArgs, that disclose the user name, password, custom credential and whether a persistent cookie should be created. You are given the opportunity to set the cookie yourself. Depending on the circumstances you could decide to not issue a persistent cookie, or alter the username before the cookie is created. However, to do so, you must set the cookie yourself and indicate that you have done so by changing CookieIsSet to true. Also, the cookie that you issue must be a Forms Authentication cookie, containing a encrypted FormsAuthenticationTicket.

Some critical notes

Although the addition of a WCF service that offers Membership authentication is really nice, I do raise some eyebrows to the implementation of the service. As good practice dictates the service interface should be separated from the implementation. But, it is not. This makes the use of the service less flexible. You will not be able to substitute your own alternative implementation of the same interface. Then again, remember this is a CTP implementation, and the LoginService might or might not make it into the final release as it is now (or at all). Also, what will the plans be for the Login service that the Microsoft AJAX Library 1.0 makes use of? We'll see. Time will tell.

Happy progging.

XPS Essentials

Alex Thissen — Tue, 13 Feb 2007 11:02:00 GMT

Windows Presentation Foundation also introduced the Xml Paper Specification (XPS): Microsoft's counterpart to Adobe Portable Document Format (PDF). Where you need the Adobe Reader application to view PDF files, you will also need a viewer to see XPS documents.

This is where the XPS Essentials Pack comes in. You can download it here. Once installed it will give you:

XPS Document Writer
Metadata and thumbnail handlers
Rich-preview provider
Search and index filters
XPSDrv print driver components

These components let you create, view, preview, search, index and organize your XPS documents. You should check out the XPS Viewer EP application, which is a pretty nice WPF application. In thumbnail view it will show all pages in a grid. When you hover over one of the thumbnails it will enlarge to the foreground in an animated fashion. The direct neighbors will also come up a bit, giving a bubbling like effect.

If you happened to install the Beta 2 version you will find that de-installing the beta is not possible by running the setup again or by visiting Add/Remove Programs in your control panel.

Instead you should run the following command from the command line:

msiexec /uninstall XPSEP.msi

This will allow you to install XPS Essentials Pack 1.0 without problems after that.

Side note: as you can see in the picture above, the XPS Document Writer still has some problems with PowerPoint and the Frutiger 57Cn font of Class-A.

.NET 3.0 balloon joke

Alex Thissen — Wed, 08 Nov 2006 01:41:00 GMT

On theWPFblog you can see the celebration of the release of the .NET Framework 3.0. This post shows a nice set of balloons over the logo and release date of .NET FX 3.0. Real nice demonstration of the possibilities of WPF, … except that it is a Flash animation!

Releases for VS2005RTM

Alex Thissen — Sat, 21 Jan 2006 01:51:00 GMT

Just a set of links to stuff that has been released for the VS2005 RTM:

Now you know as well.