WCF services are often the part of a .NET Framework estate that blocks everything else. The server side of WCF was never ported to .NET Core or modern .NET, so moving the rest of the application raises the question of what happens to the services. There are three realistic destinations, plus the option of staying put.

First, separate the client from the server

The WCF client is available on modern .NET through the System.ServiceModel.* NuGet packages maintained in the dotnet/wcf repository. An application that only calls SOAP services can usually move to .NET 10 and keep calling them, subject to the bindings it uses being supported.

The server side is the problem. If you host services, you need one of the options below.

Option 0: leave the services on .NET Framework

.NET Framework 4.8 remains supported as part of Windows. A WCF service that rarely changes can stay on .NET Framework while the applications around it move to .NET 10, as long as the shared contracts live in a library both sides can use. This is a valid interim state, but it keeps Windows servers and an older toolchain in your estate.

Option 1: CoreWCF

CoreWCF is a port of the service side of WCF to modern .NET. It is a .NET Foundation project, and Microsoft publishes a support policy for it: at the time of writing, CoreWCF 1.9 is supported on .NET 10 and .NET 11, and the supported packages are CoreWCF.Primitives, CoreWCF.Http, CoreWCF.NetTcp, CoreWCF.WebHttp and CoreWCF.ConfigurationManager. Other packages in the repository, such as those for message queues, are community-maintained.

The appeal is that existing clients do not change. Service contracts, data contracts and the SOAP wire format stay the same, so third-party systems calling your service do not need to know it moved. Most of the work is in hosting and configuration rather than in business logic:

using CoreWCF;
using CoreWCF.Configuration;
using CoreWCF.Description;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddServiceModelServices();
builder.Services.AddServiceModelMetadata();

var app = builder.Build();

app.UseServiceModel(serviceBuilder =>
{
    serviceBuilder.AddService<OrderService>();
    serviceBuilder.AddServiceEndpoint<OrderService, IOrderService>(
        new BasicHttpBinding(BasicHttpSecurityMode.Transport), "/OrderService.svc");

    var metadata = app.Services.GetRequiredService<ServiceMetadataBehavior>();
    metadata.HttpsGetEnabled = true;
});

app.Run();

Minimal illustrative example. Keep your existing contract namespaces and endpoint addresses so the wire format is unchanged.

Points to check before committing to CoreWCF:

  • Bindings and security modes. Not every WCF binding, behaviour and WS-* feature is implemented. Compare what your system.serviceModel configuration uses with what CoreWCF supports, especially message-level security.
  • Configuration. Most configuration moves into code. CoreWCF.ConfigurationManager can read a subset of the old XML configuration, which helps with a first port.
  • Version currency. CoreWCF minor versions have a support window tied to the next release, so plan to take updates regularly.

Option 2: gRPC

gRPC on ASP.NET Core is the closest modern equivalent to WCF's contract-first, strongly typed style. Contracts are written in Protocol Buffers (.proto files), code is generated for clients and servers in many languages, messages are compact binary, and server, client and bidirectional streaming are built in.

The trade-offs:

  • Every client changes. gRPC is a different protocol and contract format. Existing SOAP clients must be rewritten against the new contract.
  • Browsers cannot call gRPC directly. Browser applications need gRPC-Web, which does not support client streaming or bidirectional streaming. Alternatively, gRPC JSON transcoding exposes the same services as JSON over HTTP.
  • HTTP/2 everywhere. Load balancers, proxies and hosting must support HTTP/2 end to end. Check Microsoft's supported platforms list for your hosting model.

gRPC suits internal service-to-service communication where you control both ends, call volumes are high and the streaming features are useful.

Option 3: REST / HTTP APIs

An HTTP API with JSON payloads and an OpenAPI description is the most widely compatible choice. Browsers, mobile apps, partners in any language, Power Platform custom connectors and AI tool integrations can all consume it. ASP.NET Core can generate OpenAPI documents from your endpoints.

The cost is redesign. WCF operations are remote procedure calls; a good HTTP API is shaped around resources, status codes and caching. A direct translation (POST /GetOrder) works but throws away much of the benefit. Like gRPC, every existing client changes.

Decision table by client type

Who calls the serviceUsual choiceWhy
External or third-party SOAP clients you cannot changeCoreWCF (or stay on .NET Framework)Only option that keeps the existing contract and wire format.
Internal .NET clients you control, high call volumegRPCStrong typing, efficient payloads, streaming. Clients regenerate from .proto.
Browser or single-page applicationsRESTNative browser support. gRPC-Web is possible with streaming limits.
Mobile appsREST, or gRPC where the platform library supports itREST is simpler to cache and debug over mobile networks.
Partners, Power Platform, AI tools, integration platformsREST with OpenAPIOpenAPI is what these tools import.
Duplex callbacks or long-lived notificationsgRPC streaming or SignalRModern replacements for WCF callback contracts; check CoreWCF support if clients must stay unchanged.
Queued messaging (MSMQ bindings)A message brokerQueues are better served by a broker than by a request/response framework.

Comparison by compatibility and effort

CoreWCFgRPCREST
Existing SOAP clients keep workingYes, if bindings are supportedNoNo
Contract changesNoneRewrite as .protoRedesign as resources
Server-side effortLow to medium (hosting, configuration)Medium (new contracts, mapping)Medium to high (API design, mapping)
Client-side effortNoneHigh (every client)High (every client)
Browser supportPoor (SOAP)Via gRPC-Web or transcodingNative
Main riskUnsupported WCF featuresHTTP/2 infrastructure, client coordinationClient coordination, API design quality

A combined path

These options are not exclusive. A pattern that limits risk:

  1. Move the business logic out of the service classes into plain libraries, if it is not already separate.
  2. Host the existing contracts on CoreWCF on .NET 10. Clients see no change, and the Windows-only hosting dependency goes.
  3. Add REST or gRPC endpoints alongside, calling the same libraries.
  4. Move clients to the new endpoints at their own pace, and monitor SOAP traffic per client.
  5. Retire the SOAP endpoints when traffic stops.

Testing the move

Whatever you choose, test with real traffic shapes. For CoreWCF, capture representative SOAP requests (with personal data removed), replay them against old and new hosts and compare the responses: namespaces, element order, null handling and date formats are where differences appear. For gRPC or REST, write contract tests for each operation before switching clients, and run old and new endpoints in parallel until the comparison is clean.

Authentication deserves its own test plan. Windows authentication and certificate-based message security in WCF map to different mechanisms in ASP.NET Core, and getting this wrong usually shows up as a production outage rather than a failed build.

Deciding what to do with your WCF services?

We review WCF estates, recommend a path per service and carry out the migration as part of wider .NET modernisation work.

.NET modernisation