public static TypeSummary[] BuildSummary(MigrationReport report)
        {
            IDictionary<string, TypeSummary> types = new Dictionary<string, TypeSummary>();

            foreach (MigrationReportMessage message in report.Messages)
            {
                TypeSummary type;
                string sourceType = message.SourceType ?? string.Empty;

                if (!types.TryGetValue(sourceType, out type))
                {
                    type = new TypeSummary(sourceType);
                    types.Add(sourceType, type);
                }

                type.AddMessage(message);
            }

            int typeCount = types.Count;
            string[] keys = new string[typeCount];
            TypeSummary[] values = new TypeSummary[typeCount];
            types.Keys.CopyTo(keys, 0);
            types.Values.CopyTo(values, 0);
            Array.Sort(keys, values);
            return values;
        }
Exemple #2
0
        private List <TypeSummary> GetParents(Type type)
        {
            var list = new List <TypeSummary>();

            var current = type;

            while (current.BaseType != null)
            {
                var summary = new TypeSummary {
                    Name = current.BaseType.Name, Fullname = GetFullTypeName(current.BaseType)
                };

                list.Add(summary);
                current = current.BaseType;
            }

            list.Reverse();
            return(list);
        }
Exemple #3
0
        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            //DataTable dt = this.TimeTrackData.Select("Where
            if (!string.IsNullOrEmpty(this.dayComboBox.SelectedValue.ToString()))
            {
                DataTable dt;
                string    selectedDate = dayComboBox.SelectedValue.ToString();
                typeSummary    = new Dictionary <int, TaskInfo>();
                taskSummary    = new Dictionary <int, TaskInfo>();
                subTaskSummary = new Dictionary <int, TaskInfo>();

                if (dayComboBox.SelectedValue.ToString() != "All Days")
                {
                    var results = from DataRow row in this.TimeTrackData.Rows
                                  where (DateTime.Parse(row["start_time"].ToString()).Date == DateTime.Parse(this.dayComboBox.SelectedValue.ToString()).Date
                                         //&& DateTime.Parse(row["start_time"].ToString()).Date <= DateTime.Parse(this.dayComboBox.SelectedValue.ToString()).Date.AddDays(1)
                                         )

                                  select row;

                    dt = results.CopyToDataTable();
                }
                else
                {
                    dt = this.TimeTrackData.Copy();
                }

                foreach (TaskInfo ti in TypeResults)
                {
                    int key;
                    if (selectedDate == "All Days" || selectedDate == ti.StartTime.Date.ToShortDateString())
                    {
                        if (TypeSummary.Any(type => type.Value.Type_Id == ti.Type_Id))
                        {
                            key = TypeSummary.FirstOrDefault(type => type.Value.Type_Id == ti.Type_Id).Key;
                            TypeSummary[key].Hours   += ti.Hours;
                            TypeSummary[key].Minutes += ti.Minutes;
                            TypeSummary[key].Seconds += ti.Seconds;
                            if (TypeSummary[key].Seconds >= 60)
                            {
                                TypeSummary[key].Minutes += 1;
                                TypeSummary[key].Seconds -= 60;
                            }
                            if (TypeSummary[key].Minutes >= 60)
                            {
                                TypeSummary[key].Hours   += 1;
                                TypeSummary[key].Minutes -= 60;
                            }
                        }
                        else
                        {
                            key = TypeSummary.Count;
                            TaskInfo newTi = ti.Clone() as TaskInfo;
                            TypeSummary.Add(key, newTi);
                        }
                    }
                }

                foreach (TaskInfo ti in TaskResults)
                {
                    int key;
                    if (selectedDate == "All Days" || selectedDate == ti.StartTime.Date.ToShortDateString())
                    {
                        if (TaskSummary.Any(type => type.Value.Type_Id == ti.Type_Id && type.Value.Task_Id == ti.Task_Id))
                        {
                            key = TaskSummary.FirstOrDefault(type => type.Value.Type_Id == ti.Type_Id && type.Value.Task_Id == ti.Task_Id).Key;
                            TaskSummary[key].Hours   += ti.Hours;
                            TaskSummary[key].Minutes += ti.Minutes;
                            TaskSummary[key].Seconds += ti.Seconds;
                            if (TaskSummary[key].Seconds >= 60)
                            {
                                TaskSummary[key].Minutes += 1;
                                TaskSummary[key].Seconds -= 60;
                            }
                            if (TaskSummary[key].Minutes >= 60)
                            {
                                TaskSummary[key].Hours   += 1;
                                TaskSummary[key].Minutes -= 60;
                            }
                        }
                        else
                        {
                            key = TaskSummary.Count;
                            TaskInfo newTi = ti.Clone() as TaskInfo;
                            TaskSummary.Add(key, newTi);
                        }
                    }
                }

                foreach (TaskInfo ti in SubTaskResults)
                {
                    int key;
                    if (selectedDate == "All Days" || selectedDate == ti.StartTime.Date.ToShortDateString())
                    {
                        if (SubTaskSummary.Any(type => type.Value.Type_Id == ti.Type_Id && type.Value.Task_Id == ti.Task_Id && type.Value.Sub_Task_Id == ti.Sub_Task_Id))
                        {
                            key = SubTaskSummary.FirstOrDefault(type => type.Value.Type_Id == ti.Type_Id && type.Value.Task_Id == ti.Task_Id && type.Value.Sub_Task_Id == ti.Sub_Task_Id).Key;
                            SubTaskSummary[key].Hours   += ti.Hours;
                            SubTaskSummary[key].Minutes += ti.Minutes;
                            SubTaskSummary[key].Seconds += ti.Seconds;
                            if (SubTaskSummary[key].Seconds >= 60)
                            {
                                SubTaskSummary[key].Minutes += 1;
                                SubTaskSummary[key].Seconds -= 60;
                            }
                            if (SubTaskSummary[key].Minutes >= 60)
                            {
                                SubTaskSummary[key].Hours   += 1;
                                SubTaskSummary[key].Minutes -= 60;
                            }
                        }
                        else
                        {
                            key = SubTaskSummary.Count;
                            TaskInfo newTi = ti.Clone() as TaskInfo;
                            SubTaskSummary.Add(key, newTi);
                        }
                    }
                }

                TypeResultsGridView.DataSource    = SummaryToDataTable(TypeSummary, TaskType.Type);
                TaskResultsGridView.DataSource    = SummaryToDataTable(TaskSummary, TaskType.Task);
                SubTaskResultsGridView.DataSource = SummaryToDataTable(SubTaskSummary, TaskType.SubTask);

                Series series = new Series()
                {
                    Name              = "Test",
                    Color             = System.Drawing.Color.Gray,
                    IsVisibleInLegend = true,
                    ChartType         = SeriesChartType.Bar
                };

                //series.Points.AddXY("1/2/14", 10);
                //SummaryToSeries(this.TypeChart, selectedDate, TypeSummary, TaskType.Type);

                //this.TypeChart.ser
                //dt.Rows.Add(results);
            }
        }
        private MonoBreakpointLocation FindNearestBreakpointLocation(bool isAnonymousFunctionExpression, string methodName, TypeSummary summary)
        {
            var tempBreakpointLocation = new MonoBreakpointLocation
            {
                LineDifference = int.MinValue,
                Method         = null,
                IlOffset       = -1,
            };

            int tempIlOffset       = 0;
            int tempLineDifference = 0;

            if (isAnonymousFunctionExpression)
            {
                // TODO: Filter correct anonymous functions with Name?
                foreach (var func in summary.AnonymousFunctions.Where(x => x.Key.Contains(methodName)))
                {
                    tempIlOffset = GetILOffset(this, func.Value, out tempLineDifference);
                    if (tempBreakpointLocation.LineDifference < tempLineDifference)
                    {
                        tempBreakpointLocation.LineDifference = tempLineDifference;
                        tempBreakpointLocation.IlOffset       = tempIlOffset;
                        tempBreakpointLocation.Method         = func.Value;

                        if (tempLineDifference == 0)
                        {
                            break;
                        }
                    }
                }
            }

            if (tempBreakpointLocation.Method == null || tempBreakpointLocation.IlOffset < 0)
            {
                tempBreakpointLocation.Method   = summary.Methods.FirstOrDefault(x => x.Name == methodName);
                tempBreakpointLocation.IlOffset = GetILOffset(this, tempBreakpointLocation.Method, out tempLineDifference);
            }

            if (tempBreakpointLocation.Method != null && tempBreakpointLocation.IlOffset >= 0)
            {
                var breakpointLocation = tempBreakpointLocation;
                return(tempBreakpointLocation);
            }

            return(null);
        }