コード例 #1
0
        protected override async Task Work(CommunicationObject comObj)
        {
            FileData fileDataExp = comObj.GetData <FileData>();
            short    commandCode = comObj.CommandCode;
            short    errorCode   = comObj.ErrorCode;
            int      lengthData  = comObj.LengthData;

            comObj.SetData(commandCode, errorCode, fileDataExp);
            await comObj.SendAsync();

            await comObj.ReceiveAsync();

            commandCode = comObj.CommandCode;
            comObj.Set(commandCode);
            await comObj.SendAsync();
        }
コード例 #2
0
            public void Start()
            {
                if (isStart)
                {
                    return;
                }

                Action clientHandler;
                ConcurrentDictionary <short, Action> handlers;
                Guid handlerID;

                isStart.Value = true;

                Task.Factory.StartNew(async() =>
                {
                    CommunicationObject comObj = new CommunicationObject(mainConnection);

                    while (!cToken.IsCancellationRequested)
                    {
                        await comObj.ReceiveAsync().ConfigureAwait(false);

                        handlerID = comObj.GetData <Guid>();

                        if (clientHandlersMap.TryGetValue(handlerID, out handlers))
                        {
                            if (handlers.TryGetValue(comObj.CommandCode, out clientHandler))
                            {
                                clientHandler();
                            }
                            else
                            {
                                Logger.Write(Source.Client, $"Для команды с кодом {comObj.CommandCode} не зарегистрирован клиентский обработчик.");
                            }
                        }
                        else
                        {
                            Logger.Write(Source.Client, $"Для команд серверного обработчика с ID {handlerID} не найден ни один клиентский обработчик.");
                        }
                    }
                });
            }
コード例 #3
0
        public async Task StartService()
        {
            Data data = Data.Create();

            data.SetHandlerData(ID, Name);

            try
            {
                while (!cleanup && !ctSource.Token.IsCancellationRequested)
                {
                    Logger.Write(Source.Server, "Обработчик ожидает получения команды от клиента.", data: data);

                    await comObj.ReceiveAsync().ConfigureAwait(false);

                    if (comObj.CommandCode == NetSharpProtocol.Commands.STOP_HANDLER)
                    {
                        HandlerStopData stopData = comObj.GetData <HandlerStopData>();

                        Logger.Write(Source.Server, $"Получена команда на остановку обработчика с ID {stopData.HandlerID}.",
                                     data: Data.Create().SetHandlerData(ID, Name));

                        connectedClient.StopHandler(stopData.HandlerID, stopData.StopMode);
                    }
                    else
                    {
                        Logger.Write(Source.Server, "Запущен метод Work обработчика.", data: data);

                        workTask = Work(comObj);
                        await workTask.ConfigureAwait(false);

                        workTask = null;

                        Logger.Write(Source.Server, "Метод Work обработчика завершён.", data: data);
                    }
                }
            }
            finally
            {
                Cleanup();
            }
        }
コード例 #4
0
        public Tuple <short, short, FileData> SendAndReceiveData(short commandCode, short errorCode, FileData value)
        {
            Connection connection = TakeConnection(9001);

            try
            {
                using (CommunicationObject comObj = new CommunicationObject(connection))
                {
                    comObj.SetData(commandCode, errorCode, value);

                    comObj.SendAsync().Wait();
                    comObj.ReceiveAsync().Wait();

                    return(new Tuple <short, short, FileData>(comObj.CommandCode,
                                                              comObj.ErrorCode,
                                                              comObj.GetData <FileData>()));
                }
            }
            finally
            {
                ReleaseConnection(connection);
            }
        }