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.serviceModelconfiguration uses with what CoreWCF supports, especially message-level security. - Configuration. Most configuration moves into code.
CoreWCF.ConfigurationManagercan 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 service | Usual choice | Why |
|---|---|---|
| External or third-party SOAP clients you cannot change | CoreWCF (or stay on .NET Framework) | Only option that keeps the existing contract and wire format. |
| Internal .NET clients you control, high call volume | gRPC | Strong typing, efficient payloads, streaming. Clients regenerate from .proto. |
| Browser or single-page applications | REST | Native browser support. gRPC-Web is possible with streaming limits. |
| Mobile apps | REST, or gRPC where the platform library supports it | REST is simpler to cache and debug over mobile networks. |
| Partners, Power Platform, AI tools, integration platforms | REST with OpenAPI | OpenAPI is what these tools import. |
| Duplex callbacks or long-lived notifications | gRPC streaming or SignalR | Modern replacements for WCF callback contracts; check CoreWCF support if clients must stay unchanged. |
| Queued messaging (MSMQ bindings) | A message broker | Queues are better served by a broker than by a request/response framework. |
Comparison by compatibility and effort
| CoreWCF | gRPC | REST | |
|---|---|---|---|
| Existing SOAP clients keep working | Yes, if bindings are supported | No | No |
| Contract changes | None | Rewrite as .proto | Redesign as resources |
| Server-side effort | Low to medium (hosting, configuration) | Medium (new contracts, mapping) | Medium to high (API design, mapping) |
| Client-side effort | None | High (every client) | High (every client) |
| Browser support | Poor (SOAP) | Via gRPC-Web or transcoding | Native |
| Main risk | Unsupported WCF features | HTTP/2 infrastructure, client coordination | Client coordination, API design quality |
A combined path
These options are not exclusive. A pattern that limits risk:
- Move the business logic out of the service classes into plain libraries, if it is not already separate.
- Host the existing contracts on CoreWCF on .NET 10. Clients see no change, and the Windows-only hosting dependency goes.
- Add REST or gRPC endpoints alongside, calling the same libraries.
- Move clients to the new endpoints at their own pace, and monitor SOAP traffic per client.
- 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.