c# rpc_rpc c# - CSDN
  • C#实现简单的RPC

    2019-06-29 13:55:58
    demo地址:https://pan.baidu.com/s/1PeTdV2V9DF87jZTHdz4CyA 提取码:n2qm 参考地址:https://github.com/neuecc/MagicOnion 转载于:https://www.cnblogs.com/2018clg/p/9954163.html

    demo地址:https://pan.baidu.com/s/1PeTdV2V9DF87jZTHdz4CyA

    提取码:n2qm

    参考地址:https://github.com/neuecc/MagicOnion

    转载于:https://www.cnblogs.com/2018clg/p/9954163.html

    展开全文
  • C# Remoting(RPC调用)

    2019-12-02 17:58:51
    REMOTING是.NET自带的一种RPC调用方式。主要解决多个进程间互相的调用。 举例1:如现某一台电脑存在2个进程,进程1上存在一个按钮,点击按钮时会使进程2触发某个方法进行逻辑运算,那么我们存在的问题点在于如何让...

    REMOTING是.NET自带的一种RPC调用方式。主要解决多个进程间互相的调用。    

    举例1:如现某一台电脑存在2个进程,进程1上存在一个按钮,点击按钮时会使进程2触发某个方法进行逻辑运算,那么我们存在的问题点在于如何让进程1联通进程2,同时让进程2自己去触发自己的某个方法。  

    举例2:如某一台电脑存在2个进程,2个进程现在都有可能修改某一个LIST,可以同时向这一个LIST中添加值或者修改值,那么问题在于如何使2个进程操作的对象是同一个对象。  

    以上两个例子如出现类似场景,那么REMOTING就是你的一个好的选择。  

    当然,如果多个进程在不同电脑上,只要这几台电脑在同一网络中,REMOTING仍能帮你完成进程间调用,但是这时就不推荐使用REMOTING了,效率和准确度上会比写webserver服务要差。  

    原理

    建立一个公用的对象,该对象在服务端声明并共享出去,各个进程可以取到这个公共的对象,并修改该对象。如希望实现一个进程调用另一个进程,那么使用代理来实现该目的。TCP连接效率较快,但是基本只能用于本机。HTTP效率较慢,但是可以用于局域网。注意,服务端和客户端必须使用相同的协议。

    实际使用

    建立一个TCP通道

    TcpChannel channel = new TcpChannel(8080);
    ChannelServices.RegisterChannel(channel, false);

    建立一个HTTP通道

    HttpChannel channel = new HttpChannel(8226);
    ChannelServices.RegisterChannel(channel, false);

    在建立的通道上共享一个对象,并且服务名为test

    RemotingConfiguration.RegisterWellKnownServiceType(typeof(TestMessageMarshal), "test", WellKnownObjectMode.Singleton);

    共享对象的另一种方式

    MessageMarshal.TestMessageMarshal obj = new MessageMarshal.TestMessageMarshal();
    ObjRef objrefWellKnown = RemotingServices.Marshal(obj, "ServiceMessage");

    建立一个拥有共享调用的方法的类

     /*创建发送消息委托*/
        public delegate void SendMessageHandler(string messge);
        [Serializable]
        public class TestMessageMarshal : MarshalByRefObject
        {
            private Guid ID { get; set; }
            /*新建对象实例时重新创建标识编号*/
            public TestMessageMarshal()
            {
                ID = Guid.NewGuid();
            }
    
            /*创建发送消息事件*/
            public static event SendMessageHandler SendMessageEvent;
    
            /*发送消息*/
            [SoapMethod(XmlNamespace = "MessageMarshal", SoapAction = "MessageMarshal#SendMessage")]
            public void SendMessage(string messge)
            {
                if (SendMessageEvent != null)
                    SendMessageEvent(ID.ToString() + "\t" + messge);
            }
        }
    }

    直接获取共享的类方式(HTTP协议一样)

     IPerson obj = (IPerson)Activator.GetObject(typeof(RemotingObjects.IPerson), "tcp://localhost:8080/RemotingPersonService"

    通过建立客户端方式获取共享的类

    RemotingConfiguration.RegisterWellKnownClientType(typeof(MessageMarshal.TestMessageMarshal), "http://localhost:8226/test");
    /*创建消息实体*/
    MessageMarshal.TestMessageMarshal TestMessage = new MessageMarshal.TestMessageMarshal();

    关闭并取消注册的通道

    if (channel != null)
    {
        channel.StopListening(null);
        ChannelServices.UnregisterChannel(channel);
    }

    注销对象的另一种方式

    RemotingServices.Disconnect(obj);

     

    展开全文
  • 支持C#RPC

    2019-07-16 23:44:25
    RPC(Remote Procedure Call)----远程过程调用,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。RPC采用客户机/服务器模式。请求程序就是一个客户机,而服务提供程序就是一个服务器...

    RPC(Remote Procedure Call)----远程过程调用,它是一种通过网络从远程计算机程序上请求服务,
    而不需要了解底层网络技术的协议。
    RPC采用客户机/服务器模式。请求程序就是一个客户机,而服务提供程序就是一个服务器。

    web service:
    Web Service:严格来说是行业标准,也就是Web Service 规范,也称作WS-*规范,既不是框架,也不是技术。
    ASP.NET Web Service:微软提供了Web服务的开发框架,属于ASP.NET Framework的一部分,但是支持早起的WS规范。
    比如SOAP1.1。


    wcf:
    WCF 是一个分布式应用的开发框架,属于特定的技术,或者平台。既不是标准也不是规范。
    WCF其实一定程度上就是ASP.NET Web Service,因为它支持Web Service的行业标准和核心协议,
    因此ASP.NET Web Service和WSE能做的事情,它几乎都能胜任,跨平台和语言更不是问题

     

    thrift:
    thrift是一种可伸缩的跨语言服务的软件框架。它拥有功能强大的代码生成引擎,无缝地支持C++,C#,Java,
    Python和PHP和Ruby。

     

    .net Remoting:
    .net Remoting 是在DCOM等基础上发展起来的一种技术,它的主要目的是实现跨平台、跨语言、
    穿透企业防火墙,这也是他的基本特点,
    它支持HTTP以及TCP信道,而且它不仅能传输XML格式的SOAP包,也可以传输传统意义上的二进制流,这使得它变得效率更高
    也更加灵活。而且它不依赖于IIS.
    所以从这些方面上来讲WebService其实上是.net Remoting的一种特例。
    从微软的产品角度来看,可以说Remoting就是DCOM(分布式组件对象模型,分布式组件对象模式)的一种升级,
    它改善了很多功能,并极好的融合到.Net平台下。
    Remoting的通道主要有两种:Tcp和Http。以及不常用的IPC通道。

     

    HttpWebRequest

    这是微软自带的远程http调用库

     

    HttpClient

    这是微软自带的异步远程http调用库

     

    转载于:https://www.cnblogs.com/mayyan/p/9042161.html

    展开全文
  • 首先项目创建windows控制台程序,项目里面引用 写这篇文章时用的是thrift-csharp版本0.10.0 项目结构 服务端代码 using Common; using System; using System.Collections....using System.Threading...

    首先项目创建windows控制台程序,项目里面引用
    这里写图片描述

    写这篇文章时用的是thrift-csharp版本0.10.0
    项目结构
    这里写图片描述

    服务端代码

    using Common;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Thrift.Server;
    
    namespace ThriftServer
    {
        public class TestServer : ChatService.Iface
        {
            public List<string> GetList(string function2_arg1, int function2_arg2, List<string> function2_arg3)
            {
                List<string> list = new List<string>();
                Parallel.ForEach(function2_arg3, m =>
                {
                    list.Add($"{ function2_arg1},年龄 { function2_arg2},正在:{m}");
                });
                return list;
            }
    
            public string Say(string thing)
            {
                return thing + "测试数据";
            }
    
        }
    }
    
    using Common;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading.Tasks;
    using Thrift;
    using Thrift.Protocol;
    using Thrift.Server;
    using Thrift.Transport;
    
    namespace ThriftServer
    {
        class Program
        {
            static void Main(string[] args)
            {
                //TcpListener tcpListener = new TcpListener(System.Net.IPAddress.Parse("127.0.0.1"),7988);
                //TServerTransport transport =new TServerSocket(tcpListener);
                int port = 15789;
                TServerTransport transport = new TServerSocket(port);
    
                TestServer serverIfac = new TestServer();
                TProcessor processor = new ChatService.Processor(serverIfac);
                TServer server = new TThreadPoolServer(processor, transport);
    
                Task.Run(() =>
                {                
                    try
                    {
                        Console.WriteLine("服务启动,端口" + port);
                        server.Serve();                   
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("启动服务异常:" + ex.Message);
                    }
                });
    
                Console.ReadKey();
    
            }
        }
    }
    

    客户端代码

    using Thrift.Protocol;
    using Thrift.Transport;
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Client
    {
        class ClientDo
        {
            public static string GetServerData(string words, Common.ChatService.Client client)
            {
                //var transport = new TSocket("localhost", 15789);
                //var protocol = new TBinaryProtocol(transport);
                //var client = new  Common.ChatService.Client(protocol);
                //transport.Open();
    
                string allBooks = client.Say(words); // Actual Thrift call           
                return allBooks;
            }
    
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Thrift.Protocol;
    using Thrift.Transport;
    
    namespace Client
    {
        class Program
        {
    
            static void Main(string[] args)
            {
    
                var transport = new TSocket("localhost", 15789);
                var protocol = new TBinaryProtocol(transport);
                var client = new Common.ChatService.Client(protocol);
                transport.Open();
    
                ////测试一
                //Task.Run(() =>
                //{
                //    while (true)
                //    {
                //        Random m = new Random();
                //        int ronum = m.Next(10000);
                //        string words = ronum + "说" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                //        string backMsg = ClientDo.GetServerData(words, client);
                //        Console.WriteLine(backMsg);
                //        Task.Delay(1000).Wait();
                //    }
                //});
    
                //测试二
                List<string> data = new List<string>();
                data.Add("吃饭");
                data.Add("看书");
                data.Add("跑路");
                List<string> list=  client.GetList("欧阳修", 77, data);
                Parallel.ForEach(list,m=> {
                    Console.WriteLine(m);
                });
    
                //transport.Close();
    
                Console.ReadKey();
            }
    
        }
    }
    

    然后是ChatService类是生成的,需要用到thrift-0.11.0.exe
    怎么生成?
    首先打开windows的控制台,先进入到thrift-0.11.0.exe所在目录,然后执行命令,这个ChatService.cs是通过命令生成的
    命令生成cs文件:
    thrift-0.11.0.exe -gen csharp demo-interface.thrift

    生成的thrift模板文件里面,需要定义自己所需的方法,参考代码,比如文件:demo-interface.thrift

    namespace * Common
    
    service ChatService
    {
      string Say(1: string thing),
    
      list<string> GetList(
        1: string function2_arg1,
        2: i32 function2_arg2,
        3: list<string> function2_arg3
      ),
    }

    执行命令之后会在当前目录生成一个文件夹gen-csharp,里面包含生成的类文件ChatService.cs,将此文件粘贴到项目Common里面即可
    上图:
    这里写图片描述

    测试效果
    这里写图片描述

    这里有模板文件参考代码,文件名break1.thrift

    /*
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements. See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership. The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License. You may obtain a copy of the License at
     *
     *   http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing,
     * software distributed under the License is distributed on an
     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     * KIND, either express or implied. See the License for the
     * specific language governing permissions and limitations
     * under the License.
     */
    
    //Thrift Method removed from service base.
    
    namespace cpp test
    
    //constants
    const i32 const1 = 123;
    const double const2 = 23.3;
    const map<string,string> const3 = {"hello":"world", "thrift":"audit"};
    
    //Exception
    exception test_exception1 {
        1: i32 code;
        2: string json;
    }
    exception test_exception2 {
        1: i32 code;
        2: string json;
    }
    
    //Enums
    
    enum test_enum1 {
        enum1_value0 = 0,
        enum1_value1 = 1,
        enum1_value2 = 2,
        enum1_value5 = 5,
        enum1_value7 = 7,
        enum1_value8 = 8
    }
    
    enum test_enum2 {
        enum2_value0 = 0,
        enum2_value1 = 1,
        enum2_value2 = 2,
        enum2_value3 = 3
    }
    
    enum test_enum3 {
        enum3_value1 = 0,
        enum3_value2 = 1
    }
    
    struct test_struct1 {
        1: i16 struct1_member1,
        2: i32 struct1_member2,
        3: i64 struct1_member3,
        4: double struct1_member4 = 2.5,
        5: string struct1_member5 = "Audit test",
        6: bool struct1_member6,
        7: byte struct1_member7,
        8: binary struct1_member8,
        9: test_enum1 struct1_member9
    }
    
    struct test_struct2 {
        1: list<i16> struct2_member1,
        2: list<i32> struct2_member2,
        3: list<i64> struct2_member3= [23, 32],
        4: list<double> struct2_member4,
        5: list<string> struct2_member5,
        6: list<bool> struct2_member6,
        7: list<byte> struct2_member7,
        8: list<binary> struct2_member8,
        9: list<test_enum1> struct2_member9
    }
    
    struct test_struct3 {
        1: map<i16, i32> struct3_member1 = {1:2, 3:4},
        2: map<i64, double> struct3_member2 = {10:1.1, 20:2.1},
        3: map<string, bool> struct3_member3,
        4: map<byte, test_enum1> struct3_member4,
        5: map<test_enum2, test_enum3 > struct3_member5,
        7: map<double, string> struct3_member7
    }
    
    struct test_struct4 {
        1: i32 struct4_member1,
        2: optional i32 struct4_member2
    }
    
    struct test_struct5{
        1: double struct5_member1,
        2: string struct5_member2 = "Thrift Audit Test"
    }
    struct test_struct6 {
        1: i32 struct6_member1,
        2: required i32 struct6_member2
    }
    
    service base {
        oneway void base_oneway(
            1: i32 arg1),
    
        void base_function1(
            1: i16 function1_arg1,
            2: i32 function1_arg2,
            3: i64 function1_arg3,
            4: double function1_arg4,
            5: string function1_arg5,
            6: bool function1_arg6,
            7: test_enum1 function1_arg7,
            8: test_struct1 function1_arg8),
    
        void base_function2(
            1: list<i16> function2_arg1,
            2: list<i32> function2_arg2,
            3: list<i64> function2_arg3,
            4: list<double> function2_arg4,
            5: list<string> function2_arg5,
            6: list<bool> function2_arg6,
            7: list<byte> function2_arg7,
            8: list<test_enum1> function2_arg8,
            9: list<test_struct1> function2_arg9) throws (1:test_exception2 e),
    
    }
    
    service derived1 extends base {
    
        test_enum1 derived1_function1(
            1: i64 function1_arg1,
            2: double function1_arg2,
            3: test_enum1 function1_arg3) throws (1:test_exception2 e),
    
        i64 derived1_function2(
            1: list<i64> function2_arg1,
            2: list<double> function2_arg2,
            3: list<string> function2_arg3,
            4: list<byte> function2_arg4,
            5: list<test_enum1> function2_arg5) throws (1:test_exception2 e),
    
        double derived1_function3(
            1: string function3_arg1,
            2: bool function3_arg2) throws (1:test_exception2 e),
    
        string derived1_function4(
            1: string function4_arg1,
            2: bool function4_arg2) throws (1:test_exception2 e),
    
    
        bool derived1_function5(
            1: map<i64, double> function5_arg1,
            2: map<string, bool> function5_arg2,
            3: map<test_enum1, test_enum2> function5_arg3) throws (1:test_exception2 e),
    
        test_struct1 derived1_function6(
            1: double function6_arg1) throws (1:test_exception2 e),
    }
    
    service derived2 extends base {
    
        list<i32> derived2_function1(
            1: i32 function1_arg1) throws (1:test_exception2 e),
    
        list<test_enum1> derived2_function2(
            1:i64 function2_arg2) throws (1:test_exception2 e),
    
        list<test_struct1> derived2_function3(
            1:double function3_arg1) throws(1:test_exception2 e),
    
        map<double, string> derived2_function4(
            1:string function4_arg1) throws(1:test_exception2 e),
    
        map<test_enum1, test_enum2> derived2_function5(
            1:bool function5_arg1) throws(1:test_exception2 e),
    
        map<test_struct1, test_struct2> derived2_function6(
            1:bool function6_arg1) throws(1:test_exception2 e),
    
    }
    

    demo下载地址
    https://download.csdn.net/download/u011511086/10355584

    展开全文
  • c# 实现RPC框架的思路

    2019-10-06 13:41:58
    RPC框架,就是远程调用一个方法就像是本地调用一样。 用于网络消息的话,那么你的收发消息通过异步方法可以写在一起,很方便 核心代码 using System; using System.Collections; using System.Collections....
  • 转载:深入浅出 RPC - 浅出篇 转载:RPC框架与Dubbo完整使用 转载:深入浅出 RPC - 深入篇 一、RPC 1. RPC是什么 RPC(Remote Procedure Call Protocol)——远程过程调用协议,它是一种通过网络从远程计算机程序上...
  • 以前都是使用C#调用webservice服务或者wcf服务,由于特殊需求,需要调用python进行处理,大概流程是:客户端使用C#,服务端使用python,客户端发起调用,服务器执行,服务端执行后把结果返回给客户端 通信的桥梁...
  • net RPC 架构选型

    2020-07-29 14:20:14
    netcore Rpc框架选型,值得拥有,微服务架构必看书籍。。
  • 彻底明白RPC框架

    2017-12-01 15:46:06
    什么是RPC?三分钟完全搞明白
  • XML-RPC 实现C++和C#交互

    2019-05-12 02:06:26
    我们通常会面对这样的问题:整合不同平台或不同类库,这些类库可能来自不同的语言,甚至不同的操作系统。 如何解决这类棘手的问题呢? 一.... 解决不同语言交互的方法有不少,对我了解的windows系统和.NET平台,有...
  • c#自带remote,入门级demo,看看即可。。。个人看法:分布式中,用rpc真不如异步消息队列。。。
  • 10分钟实现RPC框架

    2018-08-08 11:40:35
    声明 ...其实整个流程是个很简单的rpc模型 1.服务端 接受客户端来的socket流, 接受约定为 1.1 方法名 1.2 参数类型 1.3 方法所需参数 2 客户端动态代理生成 代理service,调用该service的方...
  • 根据我们之前的对于RPC框架的基础介绍,NIO的理解以及Netty的学习,为下面自定义一个RPC框架的编写打下了基础。后面我们就来根据之前学习的RPC相关知识,使用Netty自己动手编写一个RPC框架。 一、设计思路 本篇...
  • 从零开始实现RPC框架 - RPC原理及实现 RPC概述 RPC(Remote Procedure Call)即远程过程调用,允许一台计算机调用另一台计算机上的程序得到结果,而代码中不需要做额外的编程,就像在本地调用一样。 现在互联网...
  • c# 创建 XML-RPC服务

    2012-08-10 15:44:52
    1、下载XML-PRC for .net 包,工程中引用CookComputing.XmlRpcV2.dll 2、接口文件 using System; using System.Collections.Generic; using System.Windows.Forms; using SMSServer;...namespace S
  • 本人平时开发学习过程中对RPC技术的一些认识,利用了代理和反射实现了一个简陋的RPC实现过程
  • C# 服务器HproseRpc使用

    2018-02-02 17:10:15
    下载C#版本Hprose.dll ...文档地址没有C#版本的文档,我是通看java文档来尝试使用C#文档,有相同的地方,网上还有1.3版本的文档,可以进行参考 文档地址:https://github.com/hprose/hprose-doc
  • 基于TCP实现的最简单RPC demo
  • 使用socket/反射/序列化等技术实现了一个基本的远程调用框架,可参考博客http://blog.csdn.net/u013177446/article/details/66473066
1 2 3 4 5 ... 20
收藏数 16,619
精华内容 6,647
关键字:

c# rpc