コード例 #1
0
        public static async Task Main()
        {
            var dbContext = new BulkInsertContext();

            var paymentRepositories = new List <IPaymentRepository>()
            {
                new EFDummyAddRepository(dbContext),
                new EFAddRepository(dbContext),
                new EFAddRangeRepository(dbContext),
                new SqlBulkCopyRepository(dbContext),
                new AutoDetectChangesDisabledPaymentRepositoryDecorator(new EFDummyAddRepository(dbContext)),
                new AutoDetectChangesDisabledPaymentRepositoryDecorator(new EFAddRepository(dbContext)),
                new AutoDetectChangesDisabledPaymentRepositoryDecorator(new EFAddRangeRepository(dbContext)),
                new AutoDetectChangesDisabledPaymentRepositoryDecorator(new SqlBulkCopyRepository(dbContext)),
                // new BulkInsertRepository(dbContext)
            };

            IPerformanceService performanceService = new PerformanceService();

            var result = await performanceService.CompareAsync(paymentRepositories);

            var serializedResult
                = JsonSerializer.Serialize(result, new JsonSerializerOptions {
                WriteIndented = true
            });

            Console.WriteLine(serializedResult);
            Console.Read();
        }
コード例 #2
0
        private void DGV_Binding()
        {
            PerformanceService service = new PerformanceService();

            perList = service.GetPerList();
            dgvPerformance.DataSource = perList;
        }
コード例 #3
0
        private void btnSearch_Click(object sender, EventArgs e)
        {
            string pid     = "";
            string process = "";

            if (cboProduct.SelectedIndex > 0)
            {
                pid = cboProduct.SelectedValue.ToString();
            }
            if (cboProcess.SelectedIndex > 0)
            {
                process = cboProcess.Text;
            }

            try
            {
                PerformanceService service = new PerformanceService();
                perList = service.SearchPerList(pid, process);

                string FromDate = periodSearchControl.dtFrom;
                string ToDate   = periodSearchControl.dtTo;

                List <PerformanceVO> PerformanceList = (from per in perList
                                                        where Convert.ToDateTime(FromDate) <= Convert.ToDateTime(per.production_sdate) &&
                                                        Convert.ToDateTime(per.production_sdate) <= Convert.ToDateTime(ToDate)
                                                        select per).ToList();
                dgvPerformance.DataSource = PerformanceList;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }
コード例 #4
0
        public void GetEvaluatedProfilesTest()
        {
            PerformanceService service = new PerformanceService();
            var profiles = service.GetEvaluatedProfiles();

            Assert.IsTrue(profiles != null);
        }
コード例 #5
0
        public static void BuildDocumentMap(FileData file)
        {
            lock (file.DocumentMap)
            {
                PerformanceService.StartEvent($"{PerformanceService.CONST_BuildDocumentMap}{file.Path}");
                try
                {
                    #region LazyLoad
                    if (file.IsCached_Lazy_DocumentMap)
                    {
                        Log.Write("Pulling DocumentMap from Cache", typeof(DocumentMapService).FullName, MethodBase.GetCurrentMethod().Name,
                                  LogEntryType.Warning);
                        return;
                    }
                    #endregion

                    file.DocumentMap.Clear();
                    List <iLineMatch> events = new List <iLineMatch>();
                    var performanceResults   = new List <EventPerformanceResult>();
                    var results = new List <DocumentEntry>();
                    int totalEvents;
                    events           = GetLines(file, performanceResults, out totalEvents);
                    file.DocumentMap = ProcessLines(file, events);
                    BuildDocumentMapValues(file);
                    file.DocumentMap.AddRange(new BuildDocumentMapGapService().Execute(file));
                    file.DocumentMap = BuildDocumentMapGapService.PostProcess(file.DocumentMap.OrderBy(n => n.iLine).ThenBy(n => n.Sort).ToList());
                }
                finally
                {
                    file.IsCached_Lazy_DocumentMap = true;
                }
                PerformanceService.StopEvent($"{PerformanceService.CONST_BuildDocumentMap}{file.Path}");
            }
        }
コード例 #6
0
        public void GetParticipantProfileScorecardByEvaluateeTest()
        {
            PerformanceService     service   = new PerformanceService();
            List <IpsQuestionInfo> questions = service.GetParticipantProfileScorecardByEvaluatee(72, 229, 217);

            Assert.IsFalse(questions != null);
        }
コード例 #7
0
        public void GetParticipantEvaluatorsTest()
        {
            PerformanceService        service    = new PerformanceService();
            List <IpsParticipantInfo> evaluators = service.GetParticipantEvaluators(77, 246);

            Assert.IsFalse(evaluators != null);
        }
コード例 #8
0
 public InfoModule(DiscordSocketClient discord, LoggingService logger, PerformanceService perf, BotInfoService botInfo, DocumentationCacheService cache)
 {
     this.discord = discord;
     this.logger  = logger;
     this.perf    = perf;
     this.botInfo = botInfo;
     this.cache   = cache;
 }
コード例 #9
0
        public void GetProfileScoreCardsTest()
        {
            PerformanceService  service   = new PerformanceService();
            DateTime            date      = new DateTime(2015, 06, 19); // PeriodDate = {6/19/2015 10:06:00 AM} 236
            IpsProfileScorecard scorecard = service.GetProfileScoreCards(60, 228, null, date);

            Assert.IsTrue(scorecard != null);
        }
コード例 #10
0
        public void GetPeriods()
        {
            PerformanceService service = new PerformanceService();
            //List<IpsScorecardPeriod> periods = service.GetProfileEvaluationPeriods(41, 216);
            List <IpsScorecardPeriod> periods = service.GetProfileEvaluationPeriods(60, 236);

            Assert.IsFalse(periods.Count > 0);
        }
コード例 #11
0
ファイル: Program.cs プロジェクト: bhamer/async-repository
        public void Main()
        {
            var uow = new MyUnitOfWork("connection string");
            var positionQueryRepo = new PositionQueryRepository("connection string");

            // Inject dependencies into services and go have fun
            var positionService    = new PositionService(uow, positionQueryRepo);
            var performanceService = new PerformanceService(positionQueryRepo);
        }
コード例 #12
0
        public void Render(string model)
        {
            _renderComplete.Reset();
            var r = new ReleaseUI($"Render ReleaseUI for {ViewModel.Model.File.Path}", true);

            ViewModel.RenderStarted();
            SuspendLayout();
            try
            {
                if (model == null)
                {
                    Log.WriteError("Model is NULL, this should not happen!", typeof(DocumentWindow).FullName, MethodBase.GetCurrentMethod().Name);
                    return;
                }


                if (InvokeRequired)
                {
                    Invoke(new Action <string>(Render), model);
                    return;
                }

                PerformanceService.StartEvent($"{PerformanceService.CONST_RenderDocument}{ViewModel.Model.File.Path}");
                OutputService.Log($"Document Render for {ViewModel.Model.File.Path}");
                Log.WriteEnter(typeof(DocumentWindow).FullName, MethodBase.GetCurrentMethod().Name);

                // Setting SelectionChangedDelayedEnabled for the first time
                if (!fctbDocument.SelectionChangedDelayedEnabled)
                {
                    fctbDocument.SelectionChangedDelayedEnabled = true;
                }
                scBase.Panel1Collapsed = !XmlDal.DataModel.Options.DocumentSourceInfo;
                PreCachePropertyLineData();
                r.DoEvents();
                sourceInfo.Render(ViewModel.Model.File);
                fctbDocument.ClearCache();
                r.DoEvents();
                fctbDocument.Text = model;
                r.DoEvents();
                ApplyFolding();
                // Force the control to paint itself now

                fctbDocument.Invalidate();
                StatusUpdate(StatusModel.Completed);
                Log.WriteTrace("Document Render Complete...", typeof(DocumentWindow).FullName, MethodBase.GetCurrentMethod().Name);
                PerformanceService.StopEvent($"Rebuild Active Document for {ViewModel.Model.File.Path}", true);
                PerformanceService.StopEvent($"{PerformanceService.CONST_RenderDocument}{ViewModel.Model.File.Path}", true);
                r.Stop();
            }
            finally
            {
                ResumeLayout();
                ViewModel.DocumentRenderComplete();
                _renderComplete.Set();
            }
        }
コード例 #13
0
        public void GetUserScorecardTest()
        {
            PerformanceService service = new PerformanceService();
            List <int>         ids     = new List <int>()
            {
                246
            };
            List <IpsQuestionInfo> questions = service.GetParticipantProfileScorecard(77, ids);

            Assert.IsFalse(questions != null);
        }
コード例 #14
0
        private void MainForm_Shown(object sender, EventArgs e)
        {
            DataPath.ExecutablePath = Application.ExecutablePath;
            mainMenu.Enabled        = false;
            mainMenu.Visible        = false;

            Text = string.Format("Sara.LogReader {0}", Application.ProductVersion);
            PerformanceService.StartEvent(PerformanceService.CONST_Startup);
            MainViewModel.StartUp(this, _openFileOnStartupPath);
            PerformanceService.StopEvent(PerformanceService.CONST_Startup);
        }
コード例 #15
0
        private void RenderCallback(TreeNodeCollection nodes)
        {
            var r = new ReleaseUI("DocumentMap.RenderCallback", true);

            if (IsDisposed)
            {
                return;
            }

            if (InvokeRequired)
            {
                Invoke(new Action <TreeNodeCollection>(RenderCallback), nodes);
                return;
            }

            #region Clear
            // Note: We are on the MainUI Thread.  We want to limit our activity to 50ms or less before we call Application.DoEvents (r.DoEvents)
            r.DoEvents("starting");
            var n = 0;
            for (int i = tvMapEntries.Nodes.Count - 1; i >= 0; i--)
            {
                n++;
                tvMapEntries.Nodes.RemoveAt(i);
                if (n % @break == 0)
                {
                    r.DoEvents("RemoveAt break");
                }
            }
            r.DoEvents("RemoveAt done");
            #endregion

            #region Add
            n = 0;
            foreach (TreeNode node in nodes)
            {
                n++;
                tvMapEntries.Nodes.Add(node);
                if (n % @break == 0)
                {
                    r.DoEvents("Node.Add break");
                }
            }
            r.DoEvents("Node.Add done");
            #endregion

            tvMapEntriesSplit.Clone(tvMapEntries);
            _isRendering = false;
            r.DoEvents("Clone");
            StatusPanel.StatusUpdate(StatusModel.Completed);
            ViewModel.RenderComplete();
            PerformanceService.StopEvent($"{PerformanceService.CONST_RenderDocumentMap}{ViewModel.LastPath}");
            r.Stop();
        }
コード例 #16
0
ファイル: PerformanceServer.cs プロジェクト: tpayne84/proxide
        public PerformanceServer(Arguments args)
        {
            var credentials = args.GetServerCredentials();

            server = new Server
            {
                Services = { PerformanceService.BindService(new PerformanceServiceImpl()) },
                Ports    = { new ServerPort("localhost", args.ServerPort, credentials) },
            };
            server.Start();
            Console.WriteLine($"C# Performance Server running in port {args.ServerPort}");
            Console.WriteLine($" - TLS: {credentials != ServerCredentials.Insecure}");
        }
コード例 #17
0
        public void GetUserProfiles()
        {
            PerformanceService service = new PerformanceService();
            //IpsUserProfiles profiles = service.GetUserProfiles(1122);


            DateTime todayDate = DateTime.Today;
            List <IpsUserProfile> activeProfiles    = new List <IpsUserProfile>();
            List <IpsUserProfile> completedProfiles = new List <IpsUserProfile>();
            List <IpsUserProfile> historyProfiles   = new List <IpsUserProfile>();

            var _ipsDataContext = service._ipsDataContext;

            //IpsUserProfiles profiles = service.GetUserProfiles(1073);
            //Assert.IsFalse(profiles != null);
        }
コード例 #18
0
        public static async Task Main(string[] args)
        {
            var service = new PerformanceService(null);

            if (args.Length < 1)
            {
                Console.WriteLine("url is required");
                return;
            }

            var url = args[0];

            var size = 100000;

            if (args.Length > 1)
            {
                size = int.Parse(args[1]);
            }


            var degree = 10;

            if (args.Length > 2)
            {
                degree = int.Parse(args[2]);
            }

            var handler = new HttpPerformanceDelegatingHandler(new HttpClientHandler());


            var client = new HttpClient(handler);


            var block = new ActionBlock <int>(async i => await client.GetAsync(string.Format(url, i)), new ExecutionDataflowBlockOptions {
                MaxDegreeOfParallelism = degree
            });

            foreach (var i in Enumerable.Range(0, size))
            {
                block.Post(i);
            }

            block.Complete();
            await block.Completion;
        }
コード例 #19
0
        /// <summary>
        /// Used to quickly rebuild the active documents cache.  Used to speed up development and exercise code
        /// </summary>
        public static void RebuildActiveDocument()
        {
            ThreadPool.QueueUserWorkItem(delegate
            {
                OutputService.ClearOutputWindow?.Invoke();
                PerformanceService.StartEvent($"Rebuild Active Document for {Current.Model.File.Path}");
                Thread.CurrentThread.Name = "Rebuild.Active.Document";

                var file = Current.Model.File;
                file.Clear();
                FileService.Build(file, true);
                file.IsCached_Lazy_NetworkMessages = false;
                NetworkService.CheckNetworkMessages(file, View.StatusUpdate, "Source");

                // Invalidate will force dependent Components to Render
                file.DataController.Invalidate();
            });
        }
コード例 #20
0
        public void Render(List <DocumentEntry> model)
        {
            var r = new ReleaseUI("DocumentMap.Render");

            PerformanceService.StartEvent($"{PerformanceService.CONST_RenderDocumentMap}{ViewModel.LastPath}");
            // Note: Invoke is handled through ViewModelbase - Sara
            if (_isRendering)
            {
                return;
            }

            if (!MainViewModel.StartupComplete)
            {
                StatusPanel.StatusUpdate(StatusModel.Completed);
                return;
            }

            if (model == null)
            {
                ShowWarning();
                StatusPanel.StatusUpdate(StatusModel.Completed);
                return;
            }

            _isRendering   = true;
            wpOpen.Visible = false;
            panel3.Visible = true;

            StatusPanel.StatusUpdate(StatusModel.StartStopWatch);
            StatusPanel.StatusUpdate(StatusModel.Update("Loading", ""));

            r.Stop();

            ThreadPool.QueueUserWorkItem(delegate
            {
                var sw = new Stopwatch("DocumentMap.Render.BuildTreeView");
                Thread.CurrentThread.Name = "Building.DocumentMap.TreeView";
                ViewModel.BuildTreeView(model, RenderCallback);
                sw.Stop(0);
            });
        }
コード例 #21
0
        static void Main(string[] args)
        {
            ExcelExportFileService  excelExportFileService = new ExcelExportFileService();
            IList <PerformanceInfo> performanceInfos       = new List <PerformanceInfo>();
            HashSet1 hashSet1 = new HashSet1();
            HashSet2 hashSet2 = new HashSet2();
            Task     task1    = new Task(() => hashSet1.Method());
            Task     task2    = new Task(() => hashSet2.Method());

            performanceInfos.Add(PerformanceService.MeasurePerformance(task1));
            performanceInfos.Add(PerformanceService.MeasurePerformance(task2));
            if (File.Exists(excelExportFileService.ExcelFilePath))
            {
                File.Delete(excelExportFileService.ExcelFilePath);
            }
            using (var excelPackage = new ExcelPackage(new System.IO.FileInfo(excelExportFileService.ExcelFilePath)))
            {
                ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.Add(excelExportFileService.PopulateWorkSheetName(null));
                excelExportFileService.ExportPerformanceInfoToExcel(performanceInfos, worksheet);
                excelPackage.Save();
            }
        }
コード例 #22
0
        public List <RmsReportMonitoringRaw> Monitoring(string mType, ClientResult clientResult)
        {
            try
            {
                var ret = new List <RmsReportMonitoringRaw>();
                if (string.IsNullOrEmpty(mType))
                {
                    return(ret);
                }
                if (clientResult == null)
                {
                    return(ret);
                }

                if (mType.ToLower() == "performance")
                {
                    var ps = new PerformanceService();
                    return(ps.Monitoring(clientResult));
                }
                else if (mType.ToLower() == "device")
                {
                    ret = CheckDevice(clientResult);
                }
                else
                {
                    throw new Exception("Monitoring Type Not Match. mType=" + mType);
                }


                return(ret);
            }
            catch (Exception ex)
            {
                throw new RMSAppException(this, "0500", "Monitoring failed. " + ex.Message, ex, false);
            }
        }
コード例 #23
0
        public static void StartUp(MainForm view, string fileOnStartupPath)
        {
            StopWatchOutput.Log = OutputService.Log;
            ReleaseOutput.Log   = OutputService.Log;
            View = view;

            Log.WriteTrace("Starting Sara.LogReader", typeof(MainViewModel).Name, MethodBase.GetCurrentMethod().Name);

            #region Loading Data
            PerformanceService.StartEvent(PerformanceService.CONST_LoadingDataFile);
            View.StatusUpdate(StatusModel.StartCountdown(PerformanceService.GetLastDuration("Loading DataFile")));
            View.StatusUpdate(StatusModel.Update("Starting Sara.LogReader", "Loading Cache"));

            try
            {
                MainService.LoadDataFile();
            }
            catch (Exception ex)
            {
                View.ShowError(ex.Message);
            }
            PerformanceService.StopEvent(PerformanceService.CONST_LoadingDataFile);

            View.StatusUpdate(StatusModel.StopCountdown);

            #endregion

            #region Loading Layout
            PerformanceService.StartEvent(PerformanceService.CONST_LoadingLayout);
            View.StatusUpdate(StatusModel.Update("Starting Sara.LogReader", "Initializing Controls"));
            StartupCreateWindows();
            View.StatusUpdate(StatusModel.StartStopWatch);
            View.StatusUpdate(StatusModel.Update(null, "Loading Layout"));
            _mDeserializeDockContent = StartupGetContentFromPersistString;
            var configFile = DataPath.GetConfigFilePath();

            try
            {
                if (File.Exists(configFile))
                {
                    View.LoadLayout(configFile, _mDeserializeDockContent);
                }
            }
            catch (Exception)
            {
                var msg =
                    $"\"{configFile}\" has become corrupted.  \nTo resolve the system will automatically reset the file to default settings.";
                Log.WriteTrace(msg, typeof(MainForm).FullName, MethodBase.GetCurrentMethod().Name);
                MessageBox.Show(msg, "System Error");
                File.Delete(configFile);
            }

            Log.WriteTrace($"Main UI Thread Id: {MainUIThreadId}", typeof(MainForm).FullName, MethodBase.GetCurrentMethod().Name);

            View.StatusUpdate(StatusModel.StartStopWatch);
            PerformanceService.StopEvent(PerformanceService.CONST_LoadingLayout);
            #endregion

            PerformanceService.StartEvent(PerformanceService.CONST_LoadingOther);
            View.StatusUpdate(StatusModel.Update(null, "Rendering..."));
            CurrentLineChangedEvent += View.ActiveDocumentLineChanged;

            view.Render(null);

            #region Options
            View.SetOptions(Options);
            ApplyHideOptions(false);
            #endregion Options

            Application.DoEvents();

            StartupOpenFile(fileOnStartupPath);

            // Note: The majority of the cpu cycles will occur on the MainUI thread.
            // This is why we are not running this in Parallel or on it's own Thread.
            // This means that if you have 10 documents to open and each takes 2 seconds your will be waiting for 10+ seconds. - Sara
            if (Options.RestoreOpenDocuments)
            {
                View.StatusUpdate(StatusModel.Update("Restoring Open Documents..."));
                var i     = 0;
                var count = Options.RestoreOpenDocumentsList.Count;
                foreach (var path in Options.RestoreOpenDocumentsList)
                {
                    i++;
                    OpenDocument(path);
                    View.StatusUpdate(StatusModel.UpdateDetail($"{i} of {count}"));
                }
            }

            ReadyViews();

            // Render the Filter window any time a Category changes - Sara
            XmlDal.DataModel.CategoryCacheDataController.InvalidateNotificationEvent += _mFilterViewModel.RenderDocument;

            StartupComplete = true;

            // Render Focused Document
            var _current = Documents.FirstOrDefault(model => model.View.DockHandler.IsActiveContentHandler);
            if (_current != null)
            {
                SetCurrent(_current);
            }

            DocumentFont = ColorService.ColorScheme.Current.GeneralFontObject;

            View.StatusUpdate(StatusModel.Completed);
            PerformanceService.StopEvent(PerformanceService.CONST_LoadingOther);
        }
コード例 #24
0
 public PerformanceController()
 {
     _perforamnce      = new PerformanceService();
     _admissionService = new AddmissionService();
 }
コード例 #25
0
 public ReportController()
 {
     _report           = new PerformanceReportService();
     _admissionService = new AddmissionService();
     _perforamnce      = new PerformanceService();
 }
コード例 #26
0
        public void GetPreviousEvaluationScoresTest()
        {
            PerformanceService service = new PerformanceService();

            service.GetPreviousEvaluationScores(5, 135);
        }
コード例 #27
0
        public void GetEvaluationAggregatedScoresTest()
        {
            PerformanceService service = new PerformanceService();

            service.GetEvaluationAggregatedScores(72, 217);
        }
コード例 #28
0
        /// <summary>
        /// STARTING POINT for Open Document
        ///
        /// Order of Operations
        /// 1.) MainViewModel.OnOpenDocument
        /// 2.) DocumentWindow.OpenFile
        /// 3.) MainViewModel.AddDocument
        /// </summary>
        public static void OpenDocument(string path, Action callback = null)
        {
            #region InvokeRequired
            if (View.InvokeRequired)
            {
                View.Invoke(new Action <string, Action>(OpenDocument), path, callback);
                return;
            }
            #endregion

            PerformanceService.StartEvent($"{PerformanceService.CONST_OpenDocument}{path}");
            Log.WriteEnter(typeof(MainViewModel).FullName, MethodBase.GetCurrentMethod().Name);

            lock (_syncOpenDocument)
            {
                #region Check if already open
                if (!File.Exists(path))
                {
                    MessageBox.Show(string.Format("They system cannot find the file specified: \"{0}\"", path));
                    return;
                }
                var doc = FindDocument(path) as DocumentWindow;

                if (doc != null)
                {
                    doc.DockHandler.Show();

                    var model = doc as DocumentWindow;
                    if (model != null)
                    {
                        SetCurrent(model.ViewModel);
                    }

                    callback?.Invoke();
                    return;
                }
                #endregion

                #region Create DocumentWindow
                doc = new DocumentWindow {
                    Text = Path.GetFileName(path)
                };
                try
                {
                    var model = new DocumentModel
                    {
                        Control = doc.PrepareDocument(path),
                        File    = XmlDal.CacheModel.GetFile(path)
                    };

                    doc.ViewModel.View.StatusUpdate(StatusModel.Update("Loading"));
                    doc.ViewModel.Model      = model;
                    model.File.Options       = Options;
                    model.File.DocumentModel = model;
                    Documents.Add(doc.ViewModel);
                    DocumentService.BuildDocument(model);
                }
                catch (Exception exception) { doc.Close(); MessageBox.Show(exception.Message); }
                #endregion

                #region Show
                if (View.DockPanel.DocumentStyle == DocumentStyle.SystemMdi)
                {
                    doc.MdiParent = View as Form;
                    doc.Show();
                }
                else
                {
                    doc.Show(View.DockPanel);
                }
                #endregion

                if (StartupComplete)
                {
                    SetCurrent(doc.ViewModel);
                }

                callback?.Invoke();

                PerformanceService.StopEvent($"{PerformanceService.CONST_OpenDocument}{path}");
                Log.WriteExit(typeof(MainViewModel).FullName, MethodBase.GetCurrentMethod().Name);
            }
        }