.NET Upgrade Assistant Now Migrates WCF Services to CoreWCF

Sam Spencer, Microsoft’s .NET Core team program manager, announced on November 4th, 2022, that the Upgrade Assistant .NET tool now includes a preview of an extension that migrates Windows Communication Foundation (WCF) service code from .NET Framework to .NET Standard targeting .NET 6 and later versions. The WCF code is migrated to the CoreWCF library, an open-source port of WCF for .NET Core.

The WCF migration extension for the Upgrade Assistant can convert single ServiceHost instances. It reads the original configuration file and creates a new one for CoreWCF. It moves the System.ServiceModel class references to CoreWCF ones. It migrates the ServiceHost instance to ASP.NET Core hosting model with the UseServiceModel extension method.

Windows Communication Foundation (WCF) was launched with .NET Framework 3 in 2006 to unify existing SOAP and RPC communication protocols into a single .NET protocol. The original WCF code usually relies heavily on configuration XML files to set endpoints, protocols, and communication attributes.

The migrated CoreWCF code moves those configuration settings into the startup code. The configuration file for CoreWCF is minimal, stating only the correspondence between the service contract and implementation classes.

Sample CalculatorService console application Main method after migration:

using System;
using CoreWCF;
using CoreWCF.Configuration;
using CoreWCF.Description;
using CoreWCF.Security;

// Host the service within console application.
public static async Task Main() {
  var builder = WebApplication.CreateBuilder();

  // Set up port (previously this was done in configuration,
  // but CoreWCF requires it be done in code)
  builder.WebHost.UseNetTcp(8090);
  builder.WebHost.ConfigureKestrel(options => {
    options.ListenAnyIP(8080);
  });

  // Add CoreWCF services to the ASP.NET Core app's DI container
  builder.Services.AddServiceModelServices()
   .AddServiceModelConfigurationManagerFile("wcf.config")
   .AddServiceModelMetadata()
   .AddTransient<CalculatorSample.CalculatorService>();

  var app = builder.Build();
  // Enable getting metadata/wsdl
  var serviceMetadataBehavior =
   app.Services.GetRequiredService<ServiceMetadataBehavior>();
  serviceMetadataBehavior.HttpGetEnabled = true;
  serviceMetadataBehavior.HttpGetUrl = new Uri("http://localhost:8080/CalculatorSample/metadata");

  // Configure CoreWCF endpoints in the ASP.NET Core hosts
  app.UseServiceModel(serviceBuilder => {
    serviceBuilder.AddService<CalculatorSample.CalculatorService>(
     serviceOptions => {
       serviceOptions.DebugBehavior.IncludeExceptionDetailInFaults = true;
     });
    
    serviceBuilder.ConfigureServiceHostBase<CalculatorSample.CalculatorService>(
     serviceHost => {});
  });

  await app.StartAsync();
  Console.WriteLine("The service is ready.");
  Console.WriteLine("Press <ENTER> to terminate service.");
  Console.WriteLine();
  Console.ReadLine();
  await app.StopAsync();
}

.NET Upgrade Assistant is an automated command-line tool that migrates .NET Framework project files to the latest versions of .NET. It supports C# and Visual Basic projects and migrates different legacy technologies such as ASP.NET MVC, Windows Forms, Windows Presentation Foundation (WPF), Universal Windows Platform (UWP), and Xamarin.Forms. It can be run in analysis or upgrade mode. However, Microsoft warns that manual steps will still be needed to migrate the application code fully and recommends the users of the tool be familiar with the official .NET porting guidance.

CoreWCF project was officially released in April 2022, although it began already in 2019. Its aim is to provide a subset of the most frequently used functionality from WCF service on the .NET platform. It is .NET Standard 2.0 compatible, allowing it to be migrated in place on .NET Framework 4.6.2 or above. It covers HTTP and TCP transport protocols with mainstream WCF bindings.

CoreWCF is not to be confused with WCF client libraries project, which provides support for consuming WCF services from .NET applications, implementing the client part of the original WCF framework.

The features that aren’t implemented at the moment in CoreWCF are named pipes transport protocol (there are indications that it will be released later), legacy bindings such as WS2007HttpBinding or NetPeerTcpBinding, advanced messaging security configuration, and support for queues and distributed transactions. Due to the multi-platform nature of modern .NET, it is understandable that the Windows-specific functionality of WCF is not migrated, except for the Windows Authentication mechanism support.

While Microsoft now supports CoreWCF as part of the general .NET platform, it recommends using modern communication protocols such as gRPC for new projects and leaving CoreWCF with the task of modernising server applications running on .NET Framework that have strong dependencies on WCF and SOAP.

Matt Connew, a member of CoreWCF team, states that the long-term intended goal of CoreWCF is to become the umbrella communication protocol by also incorporating gRPC, protobuf, and other protocol support by getting rid of SOAP architectural decisions in the library core. It seems to reflect the belief among the .NET developers that WCF promised to be a generic communication framework with different supported protocols. However, it was bogged by the complexity of configuration and tooling support.