示例#1
0
        public static void Init()
        {
            settings          = new Settings();
            db                = new DB();
            usedProxyModel    = new UsedProxyModel();
            usedAccountModel  = new UsedAccountModel();
            storage           = new StorageModel();
            emailStorageModel = new EmailStorageModel()
            {
                storage = storage
            };
            emailStack = new EmailStack()
            {
                allowEmails = settings.cache365.allowEmails, emailStorageModel = emailStorageModel
            };
            actionsLog = new ActionsLog();

            try { usedProxyModel.MigrateUp(); } catch (Exception) { }
            try { usedAccountModel.MigrateUp(); } catch (Exception) { }
            try { storage.MigrateUp(); } catch (Exception) { }

            accountsStack = new AccountsStack()
            {
                settings         = settings,
                usedAccountModel = usedAccountModel
            };

            //сделаем чтобы все аккаунты были помечены в базе хотя бы раз
            foreach (Account account in settings.cache365.accounts)
            {
                accountsStack.MarkBusy(account);
            }
        }
 private void ButtonClearLog_Click(object sender, EventArgs e)
 {
     if (MessageBox.Show(@"Очистить журнал?", @"Подтвердите удаление", MessageBoxButtons.YesNo) is
         DialogResult.Yes)
     {
         ActionsLog.Clear();
         Users.Log.Clear();
         MessageBox.Show("Журнал очищен");
     }
 }
示例#3
0
 public static void WriteAction(ActionsLog action, string username, ActionModule module)
 {
     var parameters = new Dictionary<string, object>();
     parameters.Add("@created_by", username);
     parameters.Add("@action", action.ToString());
     parameters.Add("@module", module.ToString());
     parameters.Add("@action_history_id", 0);
     parameters.Add("@remarks", string.Empty);
     dataBL.SaveData(StoredProcedure.Action_save,parameters);
 }
        /// <summary>
        /// Выводит в Excel записи обоих журналов (логов)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void ButtonViewLog_Click(object sender, EventArgs e)
        {
            var logs = Users.Log.GetLogRecords(); // list<LogRecord>

            logs.AddRange(ActionsLog.GetLogRecords());
            logs.Sort((record1, record2)
                      =>
                      record1.DateTime.CompareTo(record2.DateTime));


            if (logs.Count == 0)
            {
                MessageBox.Show(@"Журнал пуст. Показывать нечего.");
                return;
            }

            ButtonViewLog.Enabled = false;
            ButtonViewLog.Text    = @"Открытие Excel...";

            await Task.Run(() => ShowLog())
            .ConfigureAwait(true);           // и так по умолчанию вызовется в текущем контексте, т.е. UI, но чисто для понимания

            ButtonViewLog.Enabled = true;
            ButtonViewLog.Text    = @"Журнал";

            void ShowLog()
            {
                Parallel.Invoke(() =>
                {
                    var excelApp        = new Application();
                    var workbook        = excelApp.Workbooks.Add();
                    Worksheet worksheet = workbook.Worksheets[1];
                    //делаю заголовки

                    worksheet.Cells[1, 1] = "Время операции";
                    worksheet.Cells[1, 2] = "Действие";

                    var range1 = (Range)worksheet.Columns["A"];
                    var range2 = (Range)worksheet.Columns["B"];

                    for (var i = 1; i <= logs.Count; i++)
                    {
                        var record      = logs[i - 1];
                        range1.Cells[i] = record.DateTime;
                        range2.Cells[i] = record.Message;
                    }
                    range1.Columns.AutoFit();
                    range2.Columns.AutoFit();

                    excelApp.Visible     = true;
                    excelApp.UserControl =
                        true; // т.е. освобождение ресурсов объекта происходит при удалении его программно.
                });
            }
        }
示例#5
0
 // Use this for initialization
 void Start()
 {
     GameState.Set(GameState.State.IN_BATTLE);
     this.actionsLog = this.actionsLogGameObject.GetComponent <ActionsLog>();
     this.heroes     = this.actionsPanel.GetComponent <PlayerSquad>();
     this.enemies    = this.actionsPanel.GetComponent <EnemySquad>();
     this.enemy      = BattleQueue.enemy;
     foreach (Character h in BattleQueue.playerCharacters)
     {
         AddHero(Instantiate(h));
     }
     foreach (Character e in BattleQueue.enemyCharacters)
     {
         AddEnemy(Instantiate(e));
     }
     BattleQueue.playerSquad = this.heroes;
     BattleQueue.enemySquad  = this.enemies;
     LogAction("Battle started!");
 }
示例#6
0
    void Start()
    {
        player   = GameObject.Find("Postmanaut").GetComponent <PlayerControl>();
        endpoint = GameObject.Find("EndpointBar").GetComponent <EndpointBar>();
        actions  = GameObject.Find("ActionsLog").GetComponent <ActionsLog>();

        srLib = new SignalRLib();
        srLib.Init(signalRHubUrl, hubListenerName);

        srLib.ConnectionStarted += (object sender, ConnectionEventArgs e) =>
        {
            string hubName     = signalRHubUrl.Split('/').Last();
            string endpointUrl = signalRHubUrl.Replace(hubName, e.ConnectionId);

            Debug.Log(endpointUrl);
            endpoint.UpdateURL(endpointUrl);
        };

        srLib.MessageReceived += (object sender, MessageEventArgs e) =>
        {
            ActionCommand action = new ActionCommand();
            action = JsonUtility.FromJson <ActionCommand>(e.Message);

            if (!string.IsNullOrEmpty(action.direction))
            {
                player.SetDirection(action.direction);
            }

            if (!string.IsNullOrEmpty(action.perform))
            {
                player.PerformAction(action.perform);
            }

            actions.AddEntry(action);
        };
    }
        private async void ButtonStart_Click(object sender, EventArgs e)
        { // Отмена задачи - исключительная ситуация. Наверное, нормально.
            // Проверка на 0
            if (BoxNumber.Text == string.Empty ||
                BoxNumber.Text == @"0")
            {
                MessageBox.Show(@"Введите N > 0, чтобы начать вычисления");
                return;
            }


            var N = int.Parse(BoxNumber.Text);


            #region StartActions

            BoxResult.Clear();
            PanelResult.Visible  = true;
            ButtonCancel.Visible = true;
            ButtonStart.Enabled  = false;
            ButtonCancel.Enabled = true;


            #endregion


            #region Job

            var dateTimeStart = DateTime.Now;

            var cts = new CancellationTokenSource();
            ButtonCancel.Click += (sender1, e1) => cts.Cancel();
            // анонимный метод, не лямбда. Лямбда - другой объект, который, тем не менее, может конвертироваться.
            Closing += (o, args) => cts.Cancel();

            IProgress <int> progress =
                new Progress <int>(percentage =>
                                   progressBar1.Value =
                                       percentage);    // Handler - это Invoke, короче. Если быть точным, то SynchronizationContext.Post. Который посылает асинхронное сообщение в нужный синхр. контекст. Invoke, короче.

            var result = new long[N];
            //var    sbResultForTextBox = new StringBuilder(N * 5);
            var stringResult = string.Empty;

            var task = new Task(WorkWithResult, cts.Token);
            task.Start();
            label1.Text = @"Генерация...";

            try
            {
                await task.ConfigureAwait(true);
            }
            catch (OperationCanceledException)
            {
                // не знаю, что тут еще делать. Можно бы установить какой-то bool в true, но это и так есть в task.IsCanceled.
            }

            label1.Text          = @"Вывод результата...";
            ButtonCancel.Enabled = false;
            if (!task.IsCanceled)
            {
                progress.Report(0);

                var numberInsertions = stringResult.Length / 10_000;
                var lastInsertion    = stringResult.Length % 10_1000;
                var progressValue    = 0.0;
                var progressUnit     = 100d / (numberInsertions + (lastInsertion > 0 ? 1 : 0));


                for (var i = 0; i < numberInsertions; i++)
                {
                    await Task.Delay(1).ConfigureAwait(true);

                    BoxResult.AppendText(stringResult.Substring(i * 10_000,
                                                                10_000));
                    progress.Report((int)(progressValue += progressUnit));
                }

                if (lastInsertion != 0)
                {
                    await Task.Delay(1).ConfigureAwait(true);

                    BoxResult.AppendText(stringResult.Substring(stringResult.Length - lastInsertion,
                                                                lastInsertion));
                    progress.Report((int)(progressValue + progressUnit));
                }
            }

            ActionsLog.Add(new ActionsLogRecord(Users.CurrentUserName, N, task.IsCanceled, dateTimeStart));

            var    typeOfFile = CBoxTypeOfFile.SelectedIndex;
            string directoryForResult;
            if (typeOfFile > 0)
            {
                directoryForResult = BoxDirectoryForResult.Text;
                label1.Text        = @"Сохранение...";
                // ReSharper disable once MethodSupportsCancellation
                ButtonCancel.Enabled = false;
                await SaveToFile().ConfigureAwait(true); // отмены в этом методе нет.

                ButtonCancel.Enabled = true;
            }

            #endregion

            #region FinalActions

            progress.Report(0);

            PanelResultSettings.Enabled = true;
            ButtonChangeUser.Enabled    = true;

            ButtonCancel.Visible = false;
            ButtonStart.Enabled  = true;

            label1.Text = task.IsCanceled ? "Отменено" : "Готово";

            #endregion


            void WorkWithResult()
            {
                {
                    var sbResult      = new StringBuilder(N * 5);
                    var progressValue = 0.0;
                    var progressStep  = 100d / N / 2;

                    result[0] = PrimeNumbers.Next_prime(0);
                    progress.Report((int)(progressValue += progressStep * 2));

                    for (var i = 0; i < result.Length - 1; i++)
                    {
                        result[i + 1] = PrimeNumbers.Next_prime(result[i]);
                        cts.Token
                        .ThrowIfCancellationRequested();
                        progressValue += progressStep * 2;
                        if (i % 1000 == 0)
                        {
                            progress.Report((int)progressValue);
                        }
                    }

// ReSharper disable once ForCanBeConvertedToForeach
                    for (var i = 0; i < result.Length; i++)
                    {
                        var number = result[i];

                        sbResult.AppendLine(number.ToString());
                        cts.Token
                        .ThrowIfCancellationRequested();
                    }

                    stringResult = sbResult.ToString();
                }
            }

            Task SaveToFile()
            {
                var localTask = new Task(() =>
                {
                    var resultSaver =
                        new ResultSaver <long>(result, SettingsForResult.ItemResultSeparator);

                    try
                    {
                        resultSaver.SetDirectoryForResult(directoryForResult);
                    }
                    catch (Exception)
                    {
                        MessageBox.Show($@"Не удается создать указанный путь ""{
                                                directoryForResult
                                            }"" для сохранения результата. Возможно, вы назначили сохранение на флешку, а затем вытащили ее.");
                        return;
                    }

                    var actionsSaveResult = new Dictionary <int, Action <IProgress <int>, string, bool> >
                    {
                        [1] = resultSaver.SaveTextResultTo,
                        [2] = resultSaver.SavePdfResultTo
                    };
                    actionsSaveResult[typeOfFile]
                    .Invoke(progress, string.Empty, false);     //Invoke - потому что делегат.
                    if (typeOfFile > 0)
                    {
                        MessageBox.Show($@"Результат сохранен в указанную папку ""{directoryForResult}""",
                                        @"Уведомление");
                    }
                });

                localTask.Start();
                return(localTask);
            }
        }