Beispiel #1
0
        public Record(string firstname, string lastname, DateTime beginning, DateTime end)
        {
            FirstName = firstname;
            LastName  = lastname;

            Month = beginning.Month;
            Year  = beginning.Year;

            Beginning = beginning.ToString("H:mm");
            Ending    = end.ToString("H:mm");

            StartDay = beginning.Day;
            EndDay   = end.Day;

            //Property Begin se musí nastavit před property Time, protože Time s ní následně pracuje!
            Begin = beginning;
            End   = end;
            Time  = (end - beginning).ToString();

            if (StartDay == EndDay)
            {
                ConcatDay = StartDay.ToString();
            }
            else if (StartDay != EndDay & EndDay == 0)
            {
                ConcatDay = StartDay.ToString();
            }
            else
            {
                ConcatDay = StartDay + " až " + EndDay;
            }
        }
        private ChartingViewModel GetNext()
        {
            DateTime newStartDate;
            DateTime newFinishDate;

            if (IntervalType == DayConstant)
            {
                newStartDate  = StartDay.AddDays(1);
                newFinishDate = FinishDay.AddDays(1);
            }
            else if (IntervalType == WeekConstant)
            {
                newStartDate  = StartDay.AddDays(7).FirstDayOfWeek();
                newFinishDate = FinishDay.AddDays(7).LastDayOfWeek();
            }
            else
            {
                var previousMonth = StartDay.AddMonths(1);
                newStartDate  = new DateTime(previousMonth.Year, previousMonth.Month, 1);
                newFinishDate = StartDay.AddMonths(1).AddDays(-1);
            }
            // start date can be future date
            if (newStartDate < DateTime.Now)
            {
                StartDay  = newStartDate;
                FinishDay = newFinishDate;
            }

            return(new ChartingViewModel(AppService.GetStatisticData(StartDay, FinishDay), StartDay, FinishDay));
        }
Beispiel #3
0
        public void InitializeDdlSettingWindow(Ddl ddl)
        {
            InitializeComponent();

            DdlNameTextBox.Text = ddl.Name;
            DdlPriority.Value   = ddl.Priority;

            InitializeStartTime(ddl.StartTime);
            ChineseCheckbox.IsChecked = ddl.IsChineseCalender;
            InitializeEndTime(ddl.EndTime);

            var format = System.Threading.Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern;

            if (format == "M/d/yyyy")
            {
                StartMonth.SetValue(Grid.ColumnProperty, 0);
                StartDay.SetValue(Grid.ColumnProperty, 1);
                StartYear.SetValue(Grid.ColumnProperty, 2);

                EndMonth.SetValue(Grid.ColumnProperty, 0);
                EndDay.SetValue(Grid.ColumnProperty, 1);
                EndYear.SetValue(Grid.ColumnProperty, 2);
            }
            else if (format == "d/M/yyyy")
            {
                StartDay.SetValue(Grid.ColumnProperty, 0);
                StartMonth.SetValue(Grid.ColumnProperty, 1);
                StartYear.SetValue(Grid.ColumnProperty, 2);

                EndDay.SetValue(Grid.ColumnProperty, 0);
                EndMonth.SetValue(Grid.ColumnProperty, 1);
                EndYear.SetValue(Grid.ColumnProperty, 2);
            }


            LoopCheckbox.IsChecked = ddl.IsLoop;
            if (ddl.IsLoop)
            {
                InitializeLoopinterval(ddl.LoopInterval);
            }

            NoticeCheckbox.IsChecked = (ddl.Inform[0] == '1');
            WindowCheckbox.IsChecked = (ddl.Inform[1] == '1');
            SoundCheckbox.IsChecked  = (ddl.Inform[2] == '1');

            RemindCheckbox.IsChecked = ddl.IsRemind != -1;
            if (ddl.IsRemind != -1)
            {
                InitializeRemind(ddl.RemindInterval, ddl.RemindTime);
            }

            if (System.Threading.Thread.CurrentThread.CurrentUICulture.Name != "zh-CN")
            {
                ChineseCheckbox.Visibility = Visibility.Hidden;
                ChineseCheckbox.IsEnabled  = false;
            }
        }
Beispiel #4
0
    public void StartNewDay(StartDay startDay)
    {
        PlayerMovement.canMove = false;

        numberOfDay++;

        dayText.text = "";

        StartCoroutine(ShowDawn(startDay));
    }
Beispiel #5
0
    IEnumerator ShowDawn(StartDay startDay)
    {
        while (dawn.alpha < 1)
        {
            dawn.alpha += Time.deltaTime * speed;
            yield return(null);
        }

        dayText.text = "Day " + numberOfDay.ToString();

        yield return(new WaitForSeconds(2f));

        StartCoroutine(HideDawn(startDay));
    }
Beispiel #6
0
        public override List <Period> GetPeriods()
        {
            List <Period> periods = new List <Period> ();

            var start = StartDay;

            while (start != StartDay.AddYears(1))
            {
                Period period = new Period(start, start);
                start = start.AddDays(1);

                periods.Add(period);
            }

            return(periods);
        }
Beispiel #7
0
        public StartDay GetFirstDay(int pIntYear)
        {
            StartDay lObjStartDay = new StartDay();

            try
            {
                lObjStartDay = mObjQueryManager.GetObjectsList <StartDay>("Name", pIntYear.ToString(), "[@UG_TR_DAY]").FirstOrDefault();
                //lStrFirstDay = mObjQueryManager.GetValue("U_FirstDay", "U_Year", pIntYear.ToString(), "[@UG_TR_DAY]");
            }
            catch (Exception lObjException)
            {
                LogService.WriteError("GetFirstDay: " + lObjException.Message);
                LogService.WriteError(lObjException);
                UIApplication.ShowError(string.Format("GetFirstDay: {0}", lObjException.Message));
            }
            return(lObjStartDay);
        }
Beispiel #8
0
    IEnumerator HideDawn(StartDay startDay)
    {
        startDay();

        ItemSpawner[] itemSpawners = (ItemSpawner[])GameObject.FindObjectsOfType(typeof(ItemSpawner));

        foreach (ItemSpawner itemSpawner in itemSpawners)
        {
            itemSpawner.Spawn();
        }

        while (dawn.alpha > 0)
        {
            dawn.alpha -= Time.deltaTime * speed;
            yield return(null);
        }

        PlayerMovement.canMove = true;
    }
        private ChartingViewModel AddPrevious()
        {
            if (IntervalType == DayConstant)
            {
                StartDay  = StartDay.AddDays(-1);
                FinishDay = FinishDay.AddDays(-1);
            }
            else if (IntervalType == WeekConstant)
            {
                StartDay  = StartDay.AddDays(-7).FirstDayOfWeek();
                FinishDay = FinishDay.AddDays(-7).LastDayOfWeek();
            }
            else
            {
                var previousMonth = StartDay.AddMonths(-1);
                StartDay  = new DateTime(previousMonth.Year, previousMonth.Month, 1);
                FinishDay = StartDay.AddMonths(1).AddDays(-1);
            }

            return(new ChartingViewModel(AppService.GetStatisticData(StartDay, FinishDay), StartDay, FinishDay));
        }
        public string Load(string url)
        {
            var param   = new AkpReportParameters().GetParameters();
            var browser = Browser.GetBrowser();

            param.formParams["ctl00_ContentPlaceHolder1_Date1"] = StartDay.ToString("dd.MM.yyyy");
            param.formParams["ctl00_ContentPlaceHolder1_Date2"] = EndDate.ToString("dd.MM.yyyy");

            var reportPage = browser.NavigateToPage(new Uri(url));
            var form       = reportPage.FindForm(param.formId);

            foreach (string key in param.formParams)
            {
                form[key] = param.formParams[key];
            }
            foreach (string key in param.headParams)
            {
                browser.Headers.Add(key, param.headParams[key]);
            }
            form.Method = HttpVerb.Post;
            WebPage response = form.Submit();

            return(JObject.Parse(response)["result"].ToString());
        }
        public bool IsPlannable(IEnumerable <Course> courses, int priority, string code)
        {
            // dont do anything when this status already is unplannable...
            if (this.Status == Status.UNPLANNABLE)
            {
                return(false);
            }

            _logger.Debug("IsPlannable");

            if (!this.Intersects(courses))
            {
                _logger.Debug(string.Format(_culture, "Course with code {0} and startdate {1} doesn't intersect with other course", code, StartDay.ToString("dd-MM-yyyy")));
                return(true);
            }

            if (this.IntersectsOnlyWithStatus(courses, Status.UNPLANNABLE))
            {
                _logger.Debug(string.Format(_culture, "Course with code {0} and startdate {1} intersects only with unplannable implementations", code, StartDay.ToString("dd-MM-yyyy")));
                return(true);
            }

            if (this.IntersectsWithStatus(courses, Status.PLANNED))
            {
                _logger.Debug(string.Format(_culture, "Course with code {0} and startdate {1} intersects with planned implementation", code, StartDay.ToString("dd-MM-yyyy")));
                return(false);
            }

            return(true);

            List <string> scannedCourses = new List <string>();

            var coursesToCheck = courses.Where(course => course.Code != code).ToList();

            //Add self for intersection
            coursesToCheck.Add(new Course
            {
                Code     = code,
                Priority = priority,
                CourseImplementations = new List <CourseImplementation>
                {
                    this,
                },
            });

            _logger.Debug(string.Format(_culture, "Course with code {0} and startdate {1} returns IsPlannable", code, StartDay.ToString("dd-MM-yyyy")));

            return(IsPlannable(coursesToCheck, scannedCourses, priority));
        }
        private bool IsPlannable(IEnumerable <Course> courses, List <string> scannedCourses, int priority)
        {
            _logger.Debug(string.Format(_culture, "private IsPlannable with startdate {0}", StartDay.ToString("dd-MM-yyyy")));
            bool plannable = false;

            if (this.GetIntersectedCourseImplementations(courses).All(ci => ci.Status == Status.PLANNED))
            {
                _logger.Debug("All intersected course implementations are planned");
                return(false);
            }

            var notPlannedIntersectedCourses = this.GetIntersectedCourses(courses)
                                               .Where(course => course.CourseImplementations.All(ci => ci.Status != Status.PLANNED) && course.Priority <= priority);
            var notPlannedIntersectedCoursesWithoutScanned = notPlannedIntersectedCourses.Where(intersectedCourse => !scannedCourses.Contains(intersectedCourse.Code)).ToList();

            foreach (var intersectedCourse in notPlannedIntersectedCoursesWithoutScanned)
            {
                scannedCourses.Add(intersectedCourse.Code);

                if (intersectedCourse.HasIntersectedCourseWithFreeImplementation(courses, priority))
                {
                    _logger.Debug(string.Format(_culture, "Inersected course {0} intersects with course with free implementation", intersectedCourse.Code));
                    return(true);
                }

                if (!plannable)
                {
                    _logger.Debug(string.Format(_culture, "plannable is false recursive IsPlannable all implementations from instersected course {0}", intersectedCourse.Code));
                    plannable = intersectedCourse.CourseImplementations.Any(ci => ci.IsPlannable(courses, scannedCourses, priority));
                }
            }

            _logger.Debug(string.Format(_culture, "return plannable {0}", plannable));
            return(plannable);
        }
        public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
        {
            DateTime startDate;
            bool     isValidStartDate = SystemTime.TryParse(StartYear.GetValueOrDefault(), StartMonth.GetValueOrDefault(), StartDay.GetValueOrDefault(), out startDate);

            if (!isValidStartDate)
            {
                yield return(new ValidationResult(IndexResources.FromValid, new[] { "StartDay" }));
            }

            DateTime endDate;
            bool     isValidEndDate = SystemTime.TryParse(EndYear.GetValueOrDefault(), EndMonth.GetValueOrDefault(), EndDay.GetValueOrDefault(), out endDate);

            if (!isValidEndDate)
            {
                yield return(new ValidationResult(IndexResources.ToValid, new[] { "EndDay" }));
            }

            if (!(isValidStartDate && isValidEndDate))
            {
                // Stop further validation if either date is not a valid date
                yield break;
            }

            if (startDate > endDate)
            {
                yield return(new ValidationResult(IndexResources.FromDateAfterToDate, new[] { "StartYear" }));
            }
        }
Beispiel #14
0
        void ReleaseDesignerOutlets()
        {
            if (DatePickerBar != null)
            {
                DatePickerBar.Dispose();
                DatePickerBar = null;
            }

            if (DatePickerVacation != null)
            {
                DatePickerVacation.Dispose();
                DatePickerVacation = null;
            }

            if (DateToolBar != null)
            {
                DateToolBar.Dispose();
                DateToolBar = null;
            }

            if (DoneButton != null)
            {
                DoneButton.Dispose();
                DoneButton = null;
            }

            if (EndDay != null)
            {
                EndDay.Dispose();
                EndDay = null;
            }

            if (EndMonth != null)
            {
                EndMonth.Dispose();
                EndMonth = null;
            }

            if (EndYear != null)
            {
                EndYear.Dispose();
                EndYear = null;
            }

            if (Page != null)
            {
                Page.Dispose();
                Page = null;
            }

            if (PageImage != null)
            {
                PageImage.Dispose();
                PageImage = null;
            }

            if (StartDay != null)
            {
                StartDay.Dispose();
                StartDay = null;
            }

            if (StartMonth != null)
            {
                StartMonth.Dispose();
                StartMonth = null;
            }

            if (StartYear != null)
            {
                StartYear.Dispose();
                StartYear = null;
            }

            if (StatusSegment != null)
            {
                StatusSegment.Dispose();
                StatusSegment = null;
            }

            if (TypeImageView != null)
            {
                TypeImageView.Dispose();
                TypeImageView = null;
            }

            if (TypeText != null)
            {
                TypeText.Dispose();
                TypeText = null;
            }

            if (DatePickerToolbar != null)
            {
                DatePickerToolbar.Dispose();
                DatePickerToolbar = null;
            }
        }
        private async void Retrive_Option2_LongFilter(object sender, RoutedEventArgs e)
        {
            var rowKeys = new List <string>();

            var endTime = EndTimePicker.Time;
            var days    = EndDay.Date.Subtract(StartDay.Date).Days;

            for (var d = 0; d <= days; d++)
            {
                for (var hour = 0; hour <= endTime.Hours; hour++)
                {
                    var endMinutes = hour == endTime.Hours ? endTime.Minutes : 60;
                    for (var minute = 0; minute < endMinutes; minute++)
                    {
                        for (var second = 0; second <= 60; second++)
                        {
                            rowKeys.Add(StartDay.AddDays(d).AddHours(hour).AddMinutes(minute).AddSeconds(second).ToString("yyyyMMddHHmmss"));
                        }
                    }
                }
            }

            var table = tableClient.GetTableReference("option2");

            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();

                var finalResult = new List <MessageEntity>();
                var tasks       = new List <Task>();

                var partitionFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, StartDay.Date.ToString("yyyyMMdd"));
                var rowsFilter      = new StringBuilder();
                var k = 0;
                for (var i = 0; i < rowKeys.Count; i++)
                {
                    k++;
                    var r = rowKeys[i];
                    rowsFilter.Append(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, r));

                    if (i != rowKeys.Count - 1 && k != 700)
                    {
                        rowsFilter.Append(" " + TableOperators.Or + " ");
                    }

                    if (k == 700)
                    {
                        var combinedFilter = TableQuery.CombineFilters(partitionFilter, TableOperators.And, rowsFilter.ToString());
                        var query          = new TableQuery <MessageEntity>().Where(combinedFilter);

                        tasks.Add(Task.Run(async() =>
                        {
                            var token = new TableContinuationToken();
                            do
                            {
                                var seg = await table.ExecuteQuerySegmentedAsync(query, token);
                                token   = seg.ContinuationToken;

                                lock (finalResult)
                                {
                                    finalResult.AddRange(seg);
                                }
                            }while (token != null);
                        }));

                        rowsFilter.Clear();
                        k = 0;
                    }
                }

                if (rowsFilter.Length > 0)
                {
                    var combinedFilter = TableQuery.CombineFilters(partitionFilter, TableOperators.And, rowsFilter.ToString());
                    var query          = new TableQuery <MessageEntity>().Where(combinedFilter);

                    tasks.Add(Task.Run(async() =>
                    {
                        var token = new TableContinuationToken();
                        do
                        {
                            var seg = await table.ExecuteQuerySegmentedAsync(query, token);
                            token   = seg.ContinuationToken;
                            lock (finalResult)
                            {
                                finalResult.AddRange(seg);
                            }
                        }while (token != null);
                    }));
                }

                await Task.WhenAll(tasks);

                sw.Stop();
                ResultTextBox.Text = $"Option2 long filter: Found {finalResult.Count} records. It took {String.Format("{0:0.00000}", sw.Elapsed.TotalSeconds)} seconds.";
            }
            catch (Exception ex)
            {
                ResultTextBox.Text = ex.Message;
                Debug.WriteLine(ex.Message);
            }
        }
Beispiel #16
0
        public SetIntendedShipmentInfoForNotification ToRequest(Guid notificationId)
        {
            DateTime startDate;

            SystemTime.TryParse(StartYear.GetValueOrDefault(), StartMonth.GetValueOrDefault(), StartDay.GetValueOrDefault(), out startDate);

            DateTime endDate;

            SystemTime.TryParse(EndYear.GetValueOrDefault(), EndMonth.GetValueOrDefault(), EndDay.GetValueOrDefault(), out endDate);

            return(new SetIntendedShipmentInfoForNotification(
                       notificationId,
                       int.Parse(NumberOfShipments, NumberStyles.AllowThousands),
                       Convert.ToDecimal(Quantity),
                       Units.GetValueOrDefault(),
                       startDate,
                       endDate));
        }
Beispiel #17
0
        public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
        {
            if (!IsNumberOfShipmentsValid())
            {
                yield return(new ValidationResult(ShipmentResources.NumberOfShipmentsValid, new[] { "NumberOfShipments" }));
            }

            if (!IsQuantityValid() && Units.HasValue)
            {
                yield return(new ValidationResult(string.Format(ShipmentResources.DecimalPlacesValid,
                                                                ShipmentQuantityUnitsMetadata.Precision[Units.Value]), new[] { "Quantity" }));
            }

            DateTime startDate;
            bool     isValidStartDate = SystemTime.TryParse(StartYear.GetValueOrDefault(), StartMonth.GetValueOrDefault(), StartDay.GetValueOrDefault(), out startDate);

            if (!isValidStartDate)
            {
                yield return(new ValidationResult(ShipmentResources.FirstDepartureValid, new[] { "StartDay" }));
            }

            DateTime endDate;
            bool     isValidEndDate = SystemTime.TryParse(EndYear.GetValueOrDefault(), EndMonth.GetValueOrDefault(), EndDay.GetValueOrDefault(), out endDate);

            if (!isValidEndDate)
            {
                yield return(new ValidationResult(ShipmentResources.LastDepartureValid, new[] { "EndDay" }));
            }

            if (!(isValidStartDate && isValidEndDate))
            {
                // Stop further validation if either date is not a valid date
                yield break;
            }

            if (startDate < SystemTime.Now.Date && Status == NotificationStatus.NotSubmitted)
            {
                yield return(new ValidationResult(ShipmentResources.FirstDeparturePastDate, new[] { "StartDay" }));
            }

            if (startDate > endDate)
            {
                yield return(new ValidationResult(ShipmentResources.FirstDepartureBeforeLastDate, new[] { "StartYear" }));
            }

            var monthPeriodLength = IsPreconsentedRecoveryFacility ? 36 : 12;

            if (endDate >= startDate.AddMonths(monthPeriodLength))
            {
                yield return(new ValidationResult(string.Format(ShipmentResources.DepartureDateRange, monthPeriodLength), new[] { "EndYear" }));
            }
        }
Beispiel #18
0
        private async void Retrive_Option4(object sender, RoutedEventArgs e)
        {
            ResultTextBox.Text = "";

            var table     = tableClient.GetTableReference("option4");
            var startTime = StartTimePicker.Time;
            var endTime   = EndTimePicker.Time;
            var days      = EndDay.Date.Subtract(StartDay.Date).Days;

            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();

                var finalResult = new List <MessageEntity>();
                var tasks       = new List <Task>();

                for (var d = 0; d <= days; d++)
                {
                    for (var hour = 0; hour <= endTime.Hours; hour++)
                    {
                        var endMinutes = d == days && hour == endTime.Hours ? endTime.Minutes : 60;

                        if (endMinutes == 60) // full hour
                        {
                            var partitionFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, StartDay.AddDays(d).AddHours(hour).ToString("yyyyMMddHH"));
                            var query           = new TableQuery <MergedMessageEntity_Option4>().Where(partitionFilter);

                            tasks.Add(Task.Run(async() =>
                            {
                                //Stopwatch sw1 = new Stopwatch();
                                //sw1.Start();

                                var token = new TableContinuationToken();
                                do
                                {
                                    var seg = await table.ExecuteQuerySegmentedAsync(query, token);
                                    token   = seg.ContinuationToken;


                                    var messages = seg.SelectMany(merged =>
                                    {
                                        var mm = new List <MessageEntity>();

                                        for (var sec = 0; sec < 60; sec++)
                                        {
                                            var m     = new MessageEntity();
                                            m.Sensor1 = merged.Sensor1Dict[$"{sec}"];
                                            m.Sensor2 = merged.Sensor2Dict[$"{sec}"];
                                            m.Sensor3 = merged.Sensor3Dict[$"{sec}"];
                                            m.Sensor4 = merged.Sensor4Dict[$"{sec}"];
                                            m.Sensor5 = merged.Sensor5Dict[$"{sec}"];
                                            mm.Add(m);
                                        }

                                        return(mm);
                                    });

                                    lock (finalResult)
                                    {
                                        finalResult.AddRange(messages);
                                    }
                                }while (token != null);

                                //sw1.Stop();
                                //Debug.WriteLine($"Retrieve 1 hour block takes: {String.Format("{0:0.00000}", sw1.Elapsed.TotalSeconds)}");
                            }));
                        }
                        else // left minutes
                        {
                            var h               = StartDay.AddDays(d).AddHours(hour);
                            var rowKeys         = new List <string>();
                            var partitionFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, h.ToString("yyyyMMddHH"));
                            for (var i = 0; i <= endMinutes; i++)
                            {
                                rowKeys.Add(h.AddMinutes(i).ToString("yyyyMMddHHmm"));
                            }

                            var rowsFilter = new StringBuilder();
                            for (var i = 0; i < rowKeys.Count; i++)
                            {
                                var r = rowKeys[i];
                                rowsFilter.Append(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, r));

                                if (i != rowKeys.Count - 1)
                                {
                                    rowsFilter.Append(" " + TableOperators.Or + " ");
                                }
                            }

                            if (rowsFilter.Length > 0)
                            {
                                var combinedFilter = TableQuery.CombineFilters(partitionFilter, TableOperators.And, rowsFilter.ToString());
                                var query          = new TableQuery <MergedMessageEntity_Option4>().Where(combinedFilter);

                                tasks.Add(Task.Run(async() =>
                                {
                                    //Stopwatch sw1 = new Stopwatch();
                                    //sw1.Start();

                                    var token = new TableContinuationToken();
                                    do
                                    {
                                        var seg = await table.ExecuteQuerySegmentedAsync(query, token);
                                        token   = seg.ContinuationToken;


                                        var messages = seg.SelectMany(merged =>
                                        {
                                            var mm = new List <MessageEntity>();

                                            for (var sec = 0; sec < 60; sec++)
                                            {
                                                var m     = new MessageEntity();
                                                m.Sensor1 = merged.Sensor1Dict[$"{sec}"];
                                                m.Sensor2 = merged.Sensor2Dict[$"{sec}"];
                                                m.Sensor3 = merged.Sensor3Dict[$"{sec}"];
                                                m.Sensor4 = merged.Sensor4Dict[$"{sec}"];
                                                m.Sensor5 = merged.Sensor5Dict[$"{sec}"];
                                                mm.Add(m);
                                            }

                                            return(mm);
                                        });

                                        lock (finalResult)
                                        {
                                            finalResult.AddRange(messages);
                                        }
                                    }while (token != null);

                                    //sw1.Stop();
                                    //Debug.WriteLine($"Retrieve left minutes {leftMinutes} takes: {String.Format("{0:0.00000}", sw1.Elapsed.TotalSeconds)}");
                                }));
                            }
                        }
                    }
                }


                await Task.WhenAll(tasks);

                sw.Stop();
                ResultTextBox.Text = $"Option4: Found {finalResult.Count} records. It took {String.Format("{0:0.00000}", sw.Elapsed.TotalSeconds)} seconds.";
            }
            catch (Exception ex)
            {
                ResultTextBox.Text = ex.Message;
                Debug.WriteLine(ex.Message);
            }
        }
Beispiel #19
0
 public override string ToString()
 {
     return(StartDay.ToString() + ";" + EndDay.ToString());
 }