อะไรแทนที่ WCF ใน. Net Core

Question 1

ฉันคุ้นเคยกับการสร้างแอปพลิเคชันคอนโซล. Net Framework และเปิดเผยAdd(int x, int y)ฟังก์ชันผ่านบริการ WCF ตั้งแต่เริ่มต้นด้วย Class Library (.Net Framework) จากนั้นฉันใช้แอปพลิเคชันคอนโซลเพื่อพร็อกซีเรียกใช้ฟังก์ชันนี้ภายในเซิร์ฟเวอร์

อย่างไรก็ตามหากฉันใช้ Console App (.Net Core) และ Class Library (.Net Core) System.ServiceModel จะไม่พร้อมใช้งาน ฉันได้ทำ Googling ไปบ้างแล้ว แต่ยังไม่ทราบว่า WCF "แทนที่" อะไรในอินสแตนซ์นี้

ฉันจะแสดงAdd(int x, int y)ฟังก์ชันภายในไลบรารีคลาสไปยังแอปพลิเคชันคอนโซลทั้งหมดภายใน. Net Core ได้อย่างไร ฉันเห็น System.ServiceModel.Web และเนื่องจากนี่เป็นการพยายามข้ามแพลตฟอร์มฉันจึงต้องสร้างบริการ RESTful หรือไม่

Question 2

ไม่รองรับ WCF ใน. NET Core เนื่องจากเป็นเทคโนโลยีเฉพาะของ Windows และ. NET Core ควรเป็นแบบข้ามแพลตฟอร์ม

หากคุณกำลังใช้การสื่อสารระหว่างกระบวนการให้ลองใช้โครงการIpcServiceFramework

อนุญาตให้สร้างบริการในรูปแบบ WCF เช่นนี้:

จัดทำสัญญาบริการ

public interface IComputingService
{
    float AddFloat(float x, float y);
}

ใช้บริการ

class ComputingService : IComputingService
{
    public float AddFloat(float x, float y)
    {
        return x + y;
    }
}

โฮสต์บริการในแอปพลิเคชันคอนโซล

class Program
{
    static void Main(string[] args)
    {
        // configure DI
        IServiceCollection services = ConfigureServices(new ServiceCollection());

        // build and run service host
        new IpcServiceHostBuilder(services.BuildServiceProvider())
            .AddNamedPipeEndpoint<IComputingService>(name: "endpoint1", pipeName: "pipeName")
            .AddTcpEndpoint<IComputingService>(name: "endpoint2", ipEndpoint: IPAddress.Loopback, port: 45684)
            .Build()
            .Run();
    }

    private static IServiceCollection ConfigureServices(IServiceCollection services)
    {
        return services
            .AddIpc()
            .AddNamedPipe(options =>
            {
                options.ThreadCount = 2;
            })
            .AddService<IComputingService, ComputingService>();
    }
}

เรียกใช้บริการจากกระบวนการไคลเอ็นต์

IpcServiceClient<IComputingService> client = new IpcServiceClientBuilder<IComputingService>()
    .UseNamedPipe("pipeName") // or .UseTcp(IPAddress.Loopback, 45684) to invoke using TCP
    .Build();

float result = await client.InvokeAsync(x => x.AddFloat(1.23f, 4.56f));

Question 3

คุณสามารถใช้ gRPC สำหรับโฮสต์บริการเว็บภายในแอปพลิเคชันหลัก. NET

บทนำ

gRPC เป็นเฟรมเวิร์ก RPC โอเพ่นซอร์สประสิทธิภาพสูงที่พัฒนาโดย Google
เฟรมเวิร์กขึ้นอยู่กับโมเดลไคลเอ็นต์เซิร์ฟเวอร์ของการเรียกโพรซีเดอร์ระยะไกล ไคลเอนต์แอ็พพลิเคชันสามารถเรียกใช้เมธอดบนเซิร์ฟเวอร์แอ็พพลิเคชันได้โดยตรงราวกับว่าเป็นโลคัลอ็อบเจ็กต์

ตัวอย่าง

รหัสเซิร์ฟเวอร์

class Program
{
    static void Main(string[] args)
    {
        RunAsync().Wait();
    }

    private static async Task RunAsync()
    {
        var server = new Grpc.Core.Server
        {
            Ports = { { "127.0.0.1", 5000, ServerCredentials.Insecure } },
            Services =
            {
                ServerServiceDefinition.CreateBuilder()
                    .AddMethod(Descriptors.Method, async (requestStream, responseStream, context) =>
                    {
                        await requestStream.ForEachAsync(async additionRequest =>
                        {
                            Console.WriteLine($"Recieved addition request, number1 = {additionRequest.X} --- number2 = {additionRequest.Y}");
                            await responseStream.WriteAsync(new AdditionResponse {Output = additionRequest.X + additionRequest.Y});
                        });
                    })
                    .Build()
            }
        };

        server.Start();

        Console.WriteLine($"Server started under [127.0.0.1:5000]. Press Enter to stop it...");
        Console.ReadLine();

        await server.ShutdownAsync();
    }
}

รหัสลูกค้า

class Program
{
    static void Main(string[] args)
    {
        RunAsync().Wait();
    }

    private static async Task RunAsync()
    {
        var channel = new Channel("127.0.0.1", 5000, ChannelCredentials.Insecure);
        var invoker = new DefaultCallInvoker(channel);
        using (var call = invoker.AsyncDuplexStreamingCall(Descriptors.Method, null, new CallOptions{}))
        {
            var responseCompleted = call.ResponseStream
                .ForEachAsync(async response => 
                {
                    Console.WriteLine($"Output: {response.Output}");
                });

            await call.RequestStream.WriteAsync(new AdditionRequest { X = 1, Y = 2});
            Console.ReadLine();

            await call.RequestStream.CompleteAsync();
            await responseCompleted;
        }

        Console.WriteLine("Press enter to stop...");
        Console.ReadLine();

        await channel.ShutdownAsync();
    }
}

คลาสที่ใช้ร่วมกันระหว่างไคลเอนต์และเซิร์ฟเวอร์

[Schema]
public class AdditionRequest
{
    [Id(0)]
    public int X { get; set; }
    [Id(1)]
    public int Y { get; set; }
}

[Schema]
public class AdditionResponse
{
    [Id(0)]
    public int Output { get; set; }
}

ตัวบ่งชี้บริการ

using Grpc.Core;
public class Descriptors
{
    public static Method<AdditionRequest, AdditionResponse> Method =
            new Method<AdditionRequest, AdditionResponse>(
                type: MethodType.DuplexStreaming,
                serviceName: "AdditonService",
                name: "AdditionMethod",
                requestMarshaller: Marshallers.Create(
                    serializer: Serializer<AdditionRequest>.ToBytes,
                    deserializer: Serializer<AdditionRequest>.FromBytes),
                responseMarshaller: Marshallers.Create(
                    serializer: Serializer<AdditionResponse>.ToBytes,
                    deserializer: Serializer<AdditionResponse>.FromBytes));
}

Serializer / Deserializer

public static class Serializer<T>
{
    public static byte[] ToBytes(T obj)
    {
        var buffer = new OutputBuffer();
        var writer = new FastBinaryWriter<OutputBuffer>(buffer);
        Serialize.To(writer, obj);
        var output = new byte[buffer.Data.Count];
        Array.Copy(buffer.Data.Array, 0, output, 0, (int)buffer.Position);
        return output;
    }

    public static T FromBytes(byte[] bytes)
    {
        var buffer = new InputBuffer(bytes);
        var data = Deserialize<T>.From(new FastBinaryReader<InputBuffer>(buffer));
        return data;
    }
}

เอาต์พุต

ตัวอย่างผลลัพธ์ของไคลเอ็นต์

เอาต์พุตเซิร์ฟเวอร์ตัวอย่าง

อ้างอิง

เกณฑ์มาตรฐาน

http://csharptest.net/787/benchmarking-wcf-compared-to-rpclibrary/index.html

Question 4

ดูเหมือนว่าจะมีโครงการCoreWCF ที่ดูแลโดย. NET Foundation พร้อมการสนับสนุนของ Microsoft

รายละเอียดเพิ่มเติมที่Welcoming Core WCF to the .NET Foundation

ในขั้นต้นจะดำเนินการเฉพาะการขนส่ง netTcp และ http เท่านั้น

Question 5

WCF ทำหลายอย่าง มันเป็นวิธีง่ายๆในการเรียกโพรซีเดอร์ระยะไกลระหว่างสองแอพพลิเคชั่น (กระบวนการ) ในเครื่องเดียวโดยใช้ชื่อไปป์ อาจเป็นช่องทางการสื่อสารไคลเอนต์เซิร์ฟเวอร์ภายในปริมาณมากระหว่างคอมโพเนนต์. NET โดยใช้ไบนารีอนุกรมผ่าน TCPIP หรือสามารถให้ API ข้ามเทคโนโลยีที่เป็นมาตรฐานเช่นผ่าน SOAP มันยังรองรับสิ่งต่างๆเช่นการส่งข้อความแบบอะซิงโครนัสผ่าน MSMQ

สำหรับ. NET Core มีการเปลี่ยนที่แตกต่างกันตามวัตถุประสงค์

สำหรับ API ข้ามแพลตฟอร์มคุณจะแทนที่สิ่งนี้ด้วยบริการ REST โดยใช้ ASP.NET

สำหรับการเชื่อมต่อระหว่างกระบวนการหรือการเชื่อมต่อไคลเอนต์เซิร์ฟเวอร์ gRPC จะดีด้วยคำตอบที่ยอดเยี่ยมจาก @Gopi

ดังนั้นคำตอบของ "สิ่งที่แทนที่ WCF" ขึ้นอยู่กับว่าคุณใช้มันเพื่ออะไร

Question 6

มีชุมชน repo https://github.com/CoreWCF/CoreWCFที่ใช้บางส่วนของ WCF คุณสามารถใช้เพื่อสนับสนุนบริการ WCF ง่ายๆ อย่างไรก็ตามไม่รองรับคุณสมบัติทั้งหมด

Question 7

ดังนั้นจากการวิจัยของฉันทางออกที่ดีที่สุดไม่มีคลาสพร็อกซีที่สร้างขึ้นโดยอัตโนมัติ ทางออกที่ดีที่สุดนี้คือการสร้างบริการ RESTful และทำให้เนื้อหาการตอบสนองเป็นแบบ โดยที่โมเดลเป็นวัตถุโมเดลทั่วไปที่พบในรูปแบบการออกแบบ MVC

ขอบคุณสำหรับการตอบกลับของคุณ

Question 8

คุณยังสามารถโฮสต์ ASP.NET Core Web API ด้วยตนเองได้

<!-- SelfHosted.csproj -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <!-- see: https://docs.microsoft.com/en-us/aspnet/core/migration/22-to-30?view=aspnetcore-3.1&tabs=visual-studio#framework-reference -->
    <FrameworkReference Include="Microsoft.AspNetCore.App" />
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="3.1.0" />
  </ItemGroup>

</Project>

// Program.cs
using System.IO;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;

namespace SelfHosted
{
    class Program
    {
        static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            // see: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host?view=aspnetcore-3.1
            return Host.CreateDefaultBuilder(args)
                .ConfigureHostConfiguration(configHost =>
                {
                    configHost.SetBasePath(Directory.GetCurrentDirectory());
                    configHost.AddJsonFile("appsettings.json", optional: true);
                    configHost.AddEnvironmentVariables(prefix: "SelfHosted_");
                    configHost.AddCommandLine(args);
                })
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.CaptureStartupErrors(true);
                    webBuilder.UseStartup<Startup>();
                });
        }
    }
}

// Startup.cs
using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace SelfHosted
{
    public class Startup
    {
        public Startup(IConfiguration configuration, IWebHostEnvironment env)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            // see: https://github.com/aspnet/AspNetCore.Docs/tree/master/aspnetcore/web-api/index/samples/3.x
            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Error");
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseStaticFiles();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

// Controllers\TestController.cs
using System.Net.Mime;
using Microsoft.AspNetCore.Mvc;

namespace SelfHosted.Controllers
{
    [ApiController]
    [Produces(MediaTypeNames.Application.Json)]
    [Route("[controller]")]
    public class HelloController : SelfHostedControllerBase
    {
        [HttpGet]
        public ActionResult<string> HelloWorld() => "Hello World!";

        [HttpGet("{name}")]
        public ActionResult<string> HelloName(string name) => $"Hello {name}!";
    }
}

Question 9

มีพอร์ต. NET Core ให้ใช้งาน: https://github.com/dotnet/wcf ยังอยู่ในการแสดงตัวอย่าง แต่พวกเขากำลังพัฒนาอย่างต่อเนื่อง

Question 10

ณ วันนี้ WCFCore selfhost Available ทั้งหมดไม่ใช่เรื่องง่ายที่จะติดตั้งและใช้งาน
สิ่งที่ดีที่สุดสำหรับ HostedService จะเป็นทางเลือกอื่นตามที่ gRPC แสดงไว้ในคำตอบก่อนหน้านี้และสังเกตว่าใน 1 ปีสามารถเปลี่ยนแปลงหลายสิ่งได้อย่างแน่นอนว่า WCF รองรับใน Core เป็นไคลเอนต์ที่ทำงานได้ดีเท่านั้น