.नेट कोर में डब्ल्यूसीएफ की जगह क्या है?

Question 1

मुझे .Net फ्रेमवर्क कंसोल एप्लिकेशन बनाने और Add(int x, int y)क्लास लाइब्रेरी (.Net फ्रेमवर्क) के साथ स्क्रैच से डब्ल्यूसीएफ सेवा के माध्यम से एक फ़ंक्शन को उजागर करने के लिए उपयोग किया जाता है । मैं सर्वर के भीतर इस फ़ंक्शन को प्रॉक्सी कॉल करने के लिए कंसोल एप्लिकेशन का उपयोग करता हूं।

हालाँकि अगर मैं कंसोल ऐप (.Net Core) और क्लास लाइब्रेरी (.Net Core) का उपयोग करता हूं, तो System.ServiceModel उपलब्ध नहीं है। मैंने कुछ Googling किया है, लेकिन मुझे समझ नहीं आया है कि इस उदाहरण में "WCF" को क्या बदलता है।

मैं Add(int x, int y)क्लास लाइब्रेरी के भीतर एक फ़ंक्शन को सभी नेट .Net कोर में एक कंसोल एप्लिकेशन में कैसे उजागर करूं ? मुझे System.ServiceModel.Web दिखाई देता है, और चूंकि यह क्रॉस प्लेटफॉर्म बनने की कोशिश कर रहा है, इसलिए मुझे एक RESTful सेवा बनानी होगी?

Question 2

WCF .NET कोर में समर्थित नहीं है क्योंकि यह एक विंडोज़ विशिष्ट तकनीक है और .NET कोर को क्रॉस-प्लेटफ़ॉर्म माना जाता है।

यदि आप अंतर-प्रक्रिया संचार को लागू कर रहे हैं, तो 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

आप .NET कोर एप्लिकेशन के अंदर वेब सेवाओं की मेजबानी के लिए gRPC का उपयोग कर सकते हैं।

परिचय

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

ऐसा लगता है, कि .NET फाउंडेशन द्वारा Microsoft समर्थन के साथ एक CoreWCF परियोजना रखी जाएगी ।

.NET फाउंडेशन के लिए कोर WCF का स्वागत करते हुए अधिक जानकारी

प्रारंभ में केवल netTcp और http ट्रांसपोर्ट लागू किया जाएगा।

Question 5

डब्ल्यूसीएफ कई काम करता है; यह नामांकित पाइप का उपयोग करके एक मशीन पर दो अनुप्रयोगों (प्रक्रियाओं) के बीच दूरस्थ प्रक्रिया कॉल करने का एक आसान तरीका है; यह एक उच्च वॉल्यूम आंतरिक क्लाइंट-सर्वर संचार चैनल हो सकता है। .NET घटकों के बीच, TCPIP पर द्विआधारी क्रमांकन का उपयोग करके; या यह SOAP के माध्यम से एक मानकीकृत क्रॉस-टेक्नोलॉजी API प्रदान कर सकता है। यहां तक कि MSMQ के माध्यम से अतुल्यकालिक संदेश जैसी चीजों के लिए भी इसका समर्थन है।

.NET कोर के लिए, उद्देश्य के आधार पर अलग-अलग प्रतिस्थापन हैं।

क्रॉस-प्लेटफ़ॉर्म API के लिए, आप इसे ASP.NET का उपयोग करके REST सेवा के साथ बदल देंगे।

अंतर-प्रक्रिया कनेक्शन, या क्लाइंट-सर्वर कनेक्शन के लिए, gRPC अच्छा होगा, @Gopi द्वारा दिए गए एक उत्कृष्ट उत्तर के साथ।

तो "डब्ल्यूसीएफ क्या बदलता है" का जवाब इस बात पर निर्भर करता है कि आप इसके लिए क्या उपयोग कर रहे हैं।

Question 6

एक समुदाय रेपो https://github.com/CoreWCF/CoreWCF है जो WCF के कुछ हिस्सों को लागू करता है। आप इसे कुछ सरल WCF सेवाओं का समर्थन करने के लिए उपयोग कर सकते हैं। हालाँकि सभी फीचर्स समर्थित नहीं हैं।

Question 7

इसलिए मेरे शोध से सर्वश्रेष्ठ समाधान में ऑटो-जेनरेट की गई प्रॉक्सी कक्षाएं नहीं हैं। यह सबसे अच्छा समाधान है कि एक RESTful सेवा का निर्माण और प्रतिक्रिया बॉडी को मॉडल ऑब्जेक्ट में क्रमबद्ध करना। जहां मॉडल एमवीसी डिजाइन पैटर्न में पाए जाने वाले सामान्य मॉडल ऑब्जेक्ट हैं।

आपके जवाबों के लिए शुक्रिया

Question 8

आप ASP.NET कोर वेब एपीआई की स्वयं-मेजबानी भी कर सकते हैं।

<!-- 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 कोर पोर्ट उपलब्ध है: https://github.com/dotnet/wcf यह अभी भी पूर्वावलोकन में है, लेकिन वे इसे सक्रिय रूप से विकसित कर रहे हैं।

Question 10

आज के रूप में सभी WCFCore selfhost उपलब्ध है कि स्थापित करने और उपयोग करने के लिए आसान नहीं हैं।
HostedService के लिए सबसे अच्छा यह विकल्प होगा क्योंकि gRPC ने पिछले उत्तर और नोटिस में दिखाया था कि 1 साल में कई चीजें बदल सकती हैं सुनिश्चित करें कि WCF कोर में केवल एक क्लाइंट के रूप में समर्थित है जो ठीक काम करता है।