Serginio's questions

我正在做某种 RPC。对 TCP / IP 上的汇率感兴趣

现在20字节左右的交换速率是每秒2000次调用。但是我觉得速度还可以。客户是

 private BinaryReader SendMessage(MemoryStream stream)
        {

            using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            { client.Connect(IpEndpoint);
                using (var ns = new NetworkStream(client))
                {
                    stream.Position = 0;
                    ns.Write(BitConverter.GetBytes((Int32)stream.Length), 0, 4);
                    stream.CopyTo(ns);

                    using (var br = new BinaryReader(ns))
                    {
                        var streamSize = br.ReadInt32();

                        var res = br.ReadBytes(streamSize);

                        var ms = new MemoryStream(res);
                        ms.Position = 0;
                        return new BinaryReader(ms);
                    }

            }
            }

和服务器

 public void Open(int НомерПорта = 6891, int КоличествоСлушателей = 1)
        {
            IsClosed = false;

            IPEndPoint ipEndpoint = new IPEndPoint(IPAddress.Any, НомерПорта);
            Server = new TcpListener(ipEndpoint);
            Server.Start();

            // Создадим задачи для прослушивания порта
            //При подключении клиента запустим метод ОбработкаСоединения
            // Подсмотрено здесь https://github.com/imatitya/netcorersi/blob/master/src/NETCoreRemoveServices.Core/Hosting/TcpServerListener.cs
            for (int i = 0; i < КоличествоСлушателей; i++)
                Server.AcceptTcpClientAsync().ContinueWith(OnConnect);

        }


        // Метод для обработки сообщения от клиента
        private void OnConnect(Task<TcpClient> task)
        {

            if (task.IsFaulted || task.IsCanceled)
            {
                // Скорее всего вызвано  Server.Stop();
                return;
            }

            // Получим клиента
            TcpClient client = task.Result;

            // И вызовем метод для обработки данных
            // 
            ExecuteMethod(client);

            // Если Server не закрыт то запускаем нового слушателя
            if (!IsClosed)
                Server.AcceptTcpClientAsync().ContinueWith(OnConnect);

        }


          static void SetResult(MemoryStream ms, NetworkStream ns)
        {
            ms.Position = 0;
            ns.Write(BitConverter.GetBytes((Int32)ms.Length), 0, 4);
            ms.CopyTo(ns);
            ns.Flush();


        }

        private void RunMethod(NetworkStream ns, MemoryStream ms)
        {
            using (BinaryReader br = new BinaryReader(ms))
            {
                var msRes = new MemoryStream();
                using(BinaryWriter bw= new BinaryWriter(msRes))
                { 
                    var cm = (CallMethod)br.ReadByte();

                    if (cm == CallMethod.CallFunc)
                    {

                        CallAsFunc(br, bw);




                    }

                    bw.Flush();
                    SetResult(msRes, ns);
                }

            }
        }
        private void ExecuteMethod(TcpClient client)
        {

            using (NetworkStream ns = client.GetStream())
            {

                // Получим данные с клиента и на основании этих данных
                //Создадим ДанныеДляКлиета1 котрый кроме данных содержит 
                //TcpClient для отправки ответа
                using (var br = new BinaryReader(ns))
                {
                    var streamSize = br.ReadInt32();

                    var res = br.ReadBytes(streamSize);

                    var ms = new MemoryStream(res);
                    ms.Position = 0;
                    RunMethod(ns, ms);
                }



            }

        }

通过 DinamicObject 调用

var wrap = Client.AutoWrapClient.GetProxy("127.0.0.1", 6891);

        int res = wrap.ReturnParam(3);
        Console.WriteLine(res);

        string str = wrap.ReturnParam("Hello");
        Console.WriteLine(str);

 var Тестовый = wrap.Тип("TestDllForCoreClr.Тестовый", "TestDll");
        var TO = wrap.New(Тестовый,"Свойство из Конструктора");
        int rs = TO.ПолучитьЧисло(89);
        count = 0;
        stopWatch.Restart();
        for (int i = 0; i < 10000; i++)
        {
            count += TO.ПолучитьЧисло(i);

        }

        stopWatch.Stop();

EventEmitter 是动态创建的

 public AddEventHandler(EventName: string, EventHandler: (value: any) => void):any {

        let ei: EventItem;
        let isFirst = false;

        if (!this.EventsList.has(EventName)) {
            let EventKey = window.CallNetMethod(0, "GetUniqueString");

            let Event = new EventEmitter<any>(true);
            ei = new EventItem(EventKey, Event);
            this.EventEmittersList.set(EventKey, Event);
            NetObject.EventCallers.set(EventKey, this.RaiseEvent.bind(this));

并称

 public RaiseEvent(EventKey: string, value: any)
    {
      // Если есть подписчики, то вызываем их
        if (this.EventEmittersList.has(EventKey))
        {
            this.EventEmittersList.get(EventKey).emit(value);
        }

    }

但问题是表单不响应接收到的数据的变化。

如果我从同一个对象使用 Timer

public SetTimer(func:(value: any)=>void)
        {
            let timer = Observable.timer(2000, 1000);
            timer.subscribe((value: any) => { func(value) });
        }

然后它甚至通过调用一个空委托来更新表单

this.AddEventHandlerResult = this.WOWE.AddEventHandler("TestEvent3", (value: any) => { this.EventsRes.push(new EventRes("TestEvent3", value)); });

this.WOWE.SetTimer((value: any) => {});

当然，我可以将其更改为 Observable.create 但问题是是否可以使用 EventEmitter 以及如何使用？

更改为可观察

class EventEmitter
{

    public data: Observable<any>;
    public dataObserver: Observer<any>;

    constructor() {
        this.data = Observable.create((observer: any) => this.dataObserver = <Observer<any>>observer);

        alert("this.data"+this.data);
    }

    public subscribe(EventHandler: (value: any) => void)
    {

      return  this.data.subscribe(EventHandler);

    }

    public emit(value: any)
    {
        this.dataObserver.next(value);
    }

    public Complete()
    {
        this.dataObserver.complete();

    }
}

效果是一样的。是不是上下文不一样。告诉我谁知道。

我想为 .Net 类制作一个通用代理，包括使用 Proxy 类。但是难点是我无法理解什么时候作为方法调用，什么时候通过属性调用

例如，您需要联系，例如通过 http 到服务。传递密钥、方法名称、参数并获取响应作为密钥和结果

但它看起来像这样

let res = await this.counter.proxy.AllHello1("Всем Привет");

所有的序列化都发生在Proxy get中，反序列化发生在传递key和result的事件中

对于属性，您需要返回一个 Promise
对于方法，您需要返回创建 Promise 的函数

class CounterComponent {
    public currentCount: any;
    public dictionary = {};
    public proxy: any;
    constructor() { this.SetProxy(); }

    private GetPromise(name: PropertyKey,args)
    {

        let key = Guid.newGuid();
        let promise = new Promise((resolve, reject) => {
            let item = new Item(resolve, args, name);
            this.dictionary[key] = item;

        });


        return promise;
    }
    private SetProxy(): void {

        let self=this;
        this.proxy = new Proxy({}, {

            get: function(rcvr: any, name: PropertyKey)
            {
                // Для свойства нужно вернуть Promise
                if (name == "AllHello3")
                    return self.GetPromise(name, []);
                // А для Метода нужно вернуть функцию создающую Promise
                return (...args) => {
                   return self.GetPromise(name,args)
                };    
            }
        });
    }

    public async CallMethodAsync() {
        this.currentCount = await this.proxy.AllHello("Всем Привет");
    }

    public setResult(): void {

        let key: string;
        for (let name in this.dictionary) {
            key = name;
        }

        let item = <Item>this.dictionary[key];
        delete this.dictionary[key];
        item.resolve(item.value);
    }
}

相应地调用

console.log('before async result ');
let res = await this.counter.proxy.AllHello1("Всем Привет");
console.log('Всем привет ' + res);
res = await this.counter.proxy.AllHello2();
console.log('func ' + res);
res = await this.counter.proxy.AllHello3;
console.log('property ' + res);

我决定沉迷于 TypeScript 和 es6，尤其是 Proxy。

问题是在调试器 (Edge) 中显示了参数的内容和长度，但在代码中，所有转换为数组的方法都返回 [] 或访问长度返回 0。

  class Item {
    constructor(public resolve: any, public value: any) { };
}


class CounterComponent {
    public currentCount: any;
    private dictionary = {};
    private proxy: any;
     constructor() { this.SetProxy(); }
    private SetProxy(): void {

        this.proxy = new Proxy({}, {

            get: (rcvr, name) => {

                return () => {

                    let args: Array<any> = [];
                    let length = arguments.length; //length==0
                    let args1 = [...arguments];    //args1==[]
                    for (let i = 0; i < arguments.length; i++) {
                        args.push(arguments[i]);

                    }

                    let promise = new Promise((resolve, reject) => {
                        //  resolve(123);
                        let item = new Item(resolve, args);
                        this.dictionary[name] = item;

                    });


                    return promise;

                };

            }


        });
    }
    public async CallMethodAsync() {


        this.currentCount = await this.proxy.AllHello("Всем Привет");
    }

    public setResult(): void {

        let key: string;
        for (let name in this.dictionary) {
            key = name;

        }

        let item = <Item>this.dictionary[key];
        item.resolve(item.value);

    }
}

同时等待fulfills。是否有一个 C# 模拟终结器来了解对象何时被垃圾收集。