Exemple #1
0
        public void Start(ref bool cycleRead)
        {
            // mtx = new Mutex();
            // listBars = new List<Data>();

            try
            {
                mutexCmd = Mutex.OpenExisting(mutexCommand);
            }
            catch
            {
                mutexCmd = new Mutex(false, mutexCommand);
            }
            try
            {
                mutexDat = Mutex.OpenExisting(mutexData);
            }
            catch
            {
                mutexDat = new Mutex(false, mutexData);
            }
            // Создаст, или подключится к уже созданной памяти с таким именем
            //MemoryMappedFile Memory = MemoryMappedFile.CreateOrOpen("Memory", 200000, MemoryMappedFileAccess.ReadWrite);
            //MemoryMappedFile Flag = MemoryMappedFile.CreateOrOpen("Flag", 1, MemoryMappedFileAccess.ReadWrite);
            //MemoryMappedFile Command = MemoryMappedFile.CreateOrOpen("Command", 128, MemoryMappedFileAccess.ReadWrite);
            //MemoryMappedFile FlagCommand = MemoryMappedFile.CreateOrOpen("FlagCommand", 1, MemoryMappedFileAccess.ReadWrite);
            //// Создает поток для чтения
            //StreamReader SR_Memory = new StreamReader(Memory.CreateViewStream(), System.Text.Encoding.Default);
            //// Создает поток для записи
            //StreamWriter SW_Memory = new StreamWriter(Memory.CreateViewStream(), System.Text.Encoding.Default);

            //StreamReader SR_Flag = new StreamReader(Flag.CreateViewStream(), System.Text.Encoding.Default);
            //StreamWriter SW_Flag = new StreamWriter(Flag.CreateViewStream(), System.Text.Encoding.Default);

            //StreamReader SR_Command = new StreamReader(Command.CreateViewStream(), System.Text.Encoding.Default);
            //SW_Command = new StreamWriter(Command.CreateViewStream(), System.Text.Encoding.Default);

            //SR_FlagCommand = new StreamReader(FlagCommand.CreateViewStream(), System.Text.Encoding.Default);
            //SW_FlagCommand = new StreamWriter(FlagCommand.CreateViewStream(), System.Text.Encoding.Default);

            CleanMemmory();

            string Msg  = "";
            string flag = "";

            SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
            SW_Flag.Write("o");
            SW_Flag.Flush();

            SW_FlagCommand.BaseStream.Seek(0, SeekOrigin.Begin);
            SW_FlagCommand.Write("o");
            SW_FlagCommand.Flush();

            //Task.Run(() =>
            //{
            //    DataReception.SetQUIKCommandData(SW_Command, SR_FlagCommand, SW_FlagCommand, GetCommandString(Security.LKOH, TimeFrame.INTERVAL_M5) + ";" + GetCommandString(Security.NLMK, TimeFrame.INTERVAL_M5));
            //    DataReception.SetQUIKCommandData(SW_Command, SR_FlagCommand, SW_FlagCommand, GetCommandString(Security.GMKN, TimeFrame.INTERVAL_M5));
            //});


            // Цикл работает пока Run == true
            int m = 0;

            while (cycleRead)
            {
                do
                {
                    SR_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                    flag = SR_Flag.ReadToEnd().Trim('\0', '\r', '\n');
                    if (!cycleRead)
                    {
                        break;
                    }
                }while (flag == "o" || flag == "c");


                SR_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                flag = SR_Flag.ReadToEnd().Trim('\0', '\r', '\n');
                if (flag != "c" && (flag == "p" || flag == "l"))
                {
                    mutexDat.WaitOne();
                    ++m;

                    Logger.Info($@"Обнаружил какие-то данные, пытаюсь считать..");

                    //     Console.WriteLine("Get data from c++");
                    if (flag == "p")
                    {
                        //      Console.WriteLine("Get data == p");
                        string str;
                        do
                        {
                            SR_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                            flag = SR_Flag.ReadToEnd().Trim('\0', '\r', '\n');
                            if (flag != "e")
                            {
                                // Встает в начало потока для чтения
                                SR_Memory.BaseStream.Seek(0, SeekOrigin.Begin);
                                // Считывает данные из потока памяти, обрезая ненужные байты
                                str  = SR_Memory.ReadToEnd().Trim('\0', '\r', '\n');
                                Msg += str;
                                //        Console.WriteLine(Msg.Length);
                                // Встает в начало потока для записи
                                SW_Memory.BaseStream.Seek(0, SeekOrigin.Begin);
                                // Очищает память, заполняя "нулевыми байтами"
                                for (int i = 0; i < 200000; i++)
                                {
                                    SW_Memory.Write("\0");
                                }
                                SW_Memory.Flush();

                                if (flag == "l")
                                {
                                    //SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                                    //SW_Flag.Write("e");
                                    //SW_Flag.Flush();
                                }
                                else if (flag == "p")
                                {
                                    //       Console.WriteLine("Write e");
                                    SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                                    SW_Flag.Write("e");
                                    SW_Flag.Flush();
                                    SR_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                                    flag = SR_Flag.ReadToEnd().Trim('\0', '\r', '\n');
                                    while (flag == "e")
                                    {
                                        mutexDat.ReleaseMutex();
                                        --m;

                                        SR_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                                        flag = SR_Flag.ReadToEnd().Trim('\0', '\r', '\n');
                                        mutexDat.WaitOne();
                                        ++m;
                                        Thread.Sleep(100);
                                    }
                                }
                            }
                            // Thread.Sleep(10);
                        }while (flag != "l");
                    }
                    if (flag == "l")
                    {
                        SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                        SW_Flag.Write("c");
                        SW_Flag.Flush();
                        // Встает в начало потока для чтения
                        SR_Memory.BaseStream.Seek(0, SeekOrigin.Begin);
                        // Считывает данные из потока памяти, обрезая ненужные байты
                        Msg += SR_Memory.ReadToEnd().Trim('\0', '\r', '\n');
                    }

                    String[] substrings = Msg.Split(';');

                    if (Msg != "" && substrings.Count() > 3)
                    {
                        // Потокобезопасно выводит сообщение в текстовое поле
                        // TB delegateShow = Program.ShowText;

                        delegateShow.BeginInvoke(listBars, substrings, SW_Command, SR_FlagCommand, SW_FlagCommand, null, null);

                        Msg = String.Empty;

                        SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                        SW_Flag.Write("c");
                        SW_Flag.Flush();

                        // Встает в начало потока для записи
                        SW_Memory.BaseStream.Seek(0, SeekOrigin.Begin);
                        // Очищает память, заполняя "нулевыми байтами"
                        for (int i = 0; i < 200000; i++)
                        {
                            SW_Memory.Write("\0");
                        }
                        // Очищает все буферы для SW_Memory и вызывает запись всех данных буфера в основной поток
                        SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                        SW_Flag.Write("o");
                        SW_Flag.Flush();
                        SW_Memory.Flush();
                    }
                    else
                    {
                        Logger.Info($@"Данные свечей не пришли, пробую сформировать еще запрос...");
                        Data temp = listBars.FirstOrDefault(x => x.Name == substrings[0] && x.TimeFrame == Int32.Parse(substrings[1]));
                        Task.Run(() =>
                        {
                            SetQUIKCommandDataObject(SW_Command, SR_FlagCommand, SW_FlagCommand, temp.ClassCod + ';' + temp.Name + ';' + temp.TimeFrame + ';' + temp.Time.Count);
                        });

                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine(temp.ClassCod + ';' + temp.Name + ';' + temp.TimeFrame + ';' + temp.Time.Count);
                        Console.ResetColor();

                        Msg = String.Empty;

                        SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                        SW_Flag.Write("c");
                        SW_Flag.Flush();

                        // Встает в начало потока для записи
                        SW_Memory.BaseStream.Seek(0, SeekOrigin.Begin);
                        // Очищает память, заполняя "нулевыми байтами"
                        for (int i = 0; i < 200000; i++)
                        {
                            SW_Memory.Write("\0");
                        }
                        // Очищает все буферы для SW_Memory и вызывает запись всех данных буфера в основной поток
                        SW_Flag.BaseStream.Seek(0, SeekOrigin.Begin);
                        SW_Flag.Write("o");
                        SW_Flag.Flush();
                        SW_Memory.Flush();
                        temp.ProcessType = "SendCommand";
                    }
                    mutexDat.ReleaseMutex();
                    --m;
                }
            }
            CleanMemmory();
            // По завершению цикла, закрывает все потоки и освобождает именованную память
            SR_Memory.Close();
            SW_Memory.Close();
            Memory.Dispose();
        }