TimeLine поля

       
        /// <summary> получение данных </summary>
        /// <param name="name">Название полосы </param>
        /// Например: "первый", "второй"
        private IList<StripSegmentDto> GetXmlInformation(string name)
        {
            IList<StripSegmentDto> list = null;
            
            //загружаем xml файл
            XDocument xDoc = XDocument.Load(@"../../strips.xml");
            double beginPoint, endPoint;
            //получаем все узлы в xml файле
            foreach (var elm in xDoc.Descendants("strips"))
            {
                foreach(var strip in elm)
                {
                    if(strip.Attribute("name") == name)
                    {
                        foreach (var segment in strip)
                        {
                              list.add(new StripSegmentDto(double.Parse(segment.Attribute("begin").Value,
                                segment.Attribute("end").Value)));
                        } 
                    }
                }
            }
            return list;
        }

IList<StripSegmentDto> firstLine = GetXmlInformation("первый");
IList<StripSegmentDto> secondLine = GetXmlInformation("второй");

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Xml.Serialization;
 
namespace Models
{
 
    [Serializable()]
    [DesignerCategory("code")]
    [XmlType(AnonymousType = true)]
    [XmlRoot(Namespace = "", IsNullable = false, ElementName = "root")]
    public class RootXml
    {
 
        [XmlElement()]
        public SegmentXml range { get; set; }
 
        [XmlArrayItem("strip", IsNullable = false)]
        public List<StripXml> strips { get; set; }
    }
 
    [Serializable()]
    [DesignerCategory("code")]
    [XmlType(AnonymousType = true)]
    public class SegmentXml
    {
 
        [XmlAttribute()]
        public int id { get; set; }
 
        [XmlAttribute()]
        public double begin { get; set; }
 
        [XmlAttribute()]
        public double end { get; set; }
    }
 
    [Serializable()]
    [DesignerCategory("code")]
    [XmlType(AnonymousType = true)]
    public class StripXml
    {
        [XmlElement("segment")]
        public List<SegmentXml> segments { get; set; }
 
        [XmlAttribute()]
        public int id { get; set; }
 
        [XmlAttribute()]
        public string name { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
 
namespace Models
{
    // Часть Модели отвечающая за загрузку/сохранение данных.
    public partial class StripsModel
    {
        /// <summary>Имя XML-файла с данными</summary>
        public string FileName { get; }
 
        /// <summary>Конструктор с заданием имени файла с данными.</summary>
        /// <param name="fileName">Имя XML-файла с данными</param>
        public StripsModel(string fileName)
        {
            if (string.IsNullOrWhiteSpace(fileName))
                throw new ArgumentNullException(nameof(fileName));
            FileName = fileName;
        }
 
        /// <summary>Полный контейнер с данными.</summary>
        protected RootXml RootXml { get; set; }
 
        /// <summary>Диапазон фильтрации из последнего запроса.</summary>
        protected SegmentXml Range => RootXml.range;
 
        /// <summary>Список полос с сегментами.</summary>
        protected List<StripXml> Strips => RootXml.strips;
 
        /// <summary>Сериализатор XML-файла.</summary>
        protected static readonly XmlSerializer serlz
            = new XmlSerializer(typeof(RootXml));
 
        /// <summary>Загрузка данных.</summary>
        public void Load()
        {
            using (FileStream file = File.OpenRead(FileName))
                RootXml = (RootXml)serlz.Deserialize(file);
 
            //// Сортировка всех полос
            //foreach (StripXml strip in Strips)
            //    strip.segments.Sort(CompareSegmentXml);
        }
 
        /// <summary>Сохранение данных.</summary>
        public void Save()
        {
            using (FileStream file = File.Create(FileName))
                serlz.Serialize(file, RootXml);
        }
 
        //static int CompareSegmentXml(SegmentXml left, SegmentXml right)
        //{
        //    if (left == null)
        //        return right == null ? 0 : -1;
        //    if (right == null)
        //        return 1;
        //    return left.begin.CompareTo(right.begin);
        //}
    }
}

using Models;
using System.Windows;
 
namespace StripSegments
{
    /// <summary>
    /// Логика взаимодействия для App.xaml
    /// </summary>
    public partial class App : Application
    {
        public App()
        {// В этой строке точка останова. После останова дальше по F11.
            string fileName = "strips.xml";
            StripsModel model = new StripsModel(fileName);
            model.Load();
        }
 
    }
}

using System.Collections.Generic;
using System.Linq;
 
namespace Models
{
    /// <summary>Модель с исходными данными</summary>
    public partial class StripsModel
    {
 
        /// <summary>Синхронное получение всех Полос с Сегментами из заданного диапазона.</summary>
        /// <param name="range">Диапазон фильтрации Сегментов.</param>
        /// <returns>Неизменяемую коллекцию всех Полос с Сегментами из заданного диапазона.</returns>
        public IReadOnlyCollection<StripDto> GetStrips(SegmentDto range)
        {
 
            // Запоминание диапазона запроса.
            Range.begin = range.Begin;
            Range.end = range.End;
 
            // Создание списка полос.
            List<StripDto> list = new List<StripDto>(Strips.Count);
            foreach (StripXml strip in Strips)
                list.Add(new StripDto
                (
                    strip.id,
                    strip.name,
                    // Вызов метода фильтрующего Сегменты.
                    GetSegments(Range, strip.segments),
                    range
                ));
 
            // Возврат неизменяемой оболочки списка.
            return list.AsReadOnly();
        }
 
        /// <summary>Статический метод фильтрации Сегментов.</summary>
        /// <param name="range">Диапазон фильтрации.</param>
        /// <param name="segments">Последовательность Сегментов.</param>
        /// <returns></returns>
        public static IReadOnlyCollection<SegmentDto> GetSegments(SegmentXml range, IEnumerable<SegmentXml> segments)
        {
            // Получение Сегментов котрые начинаются до заданного 
            // дииапазона, но заканчиваются внутри него.
            var listMin = segments
                .OrderBy(sg => sg.end)
                .SkipWhile(sg => sg.end <= range.begin)
                .OrderBy(sg => sg.begin)
                .TakeWhile(sg => sg.begin < range.begin);
 
            // Получение Сегментов начинающихся внутри заданного Диапазона.
            var listMax = segments
                .OrderBy(sg => sg.begin)
                .SkipWhile(sg => sg.begin < range.begin)
                .TakeWhile(sg => sg.begin < range.end);
 
            // Соединение полученных последовательностей,
            // преобразование в последовательность типа SegmentDto,
            // сортировка по началу Сегмента,
            // получение списка и его неизменяемой оболочки.
            return listMin.Concat(listMax)
                .Select(sg => CopyToDto(sg))
                .OrderBy(sg => sg.Begin)
                .ToList().AsReadOnly();
        }
 
        // Получение Диапазона последнего запроса.
        public SegmentDto GetRange() => CopyToDto(Range);
 
        // Получение SegmentDto из SegmentXml
        public static SegmentDto CopyToDto(SegmentXml segment)
            => new SegmentDto(segment.id, segment.begin, segment.end);
    }
 
}

using System.Collections.Generic;
using System.Threading.Tasks;
 
namespace Models
{
    /// <summary>Модель с исходными данными</summary>
    public partial class StripsModel
    {
 
        /// <summary>Асинхронное  получение всех Полос с Сегментами из заданного диапазона.</summary>
        /// <param name="range">Диапазон фильтрации Сегментов.</param>
        /// <returns>Выполняемую задачу результатом которой является неизменяемая коллекция
        /// всех Полос с Сегментами из заданного диапазона.</returns>
        public Task<IReadOnlyCollection<StripDto>> GetStripsAsync(SegmentDto range)
            => Task.Factory.StartNew(GetStrips, range);
 
        /// <summary>Перегрузка для использовании в Task.</summary>
        /// <param name="range">Дипазон фильтрации Сегментов.</param>
        /// <returns>Неизменяемую коллекцию всех Полос с Сегментами из заданного диапазона.</returns>
        public IReadOnlyCollection<StripDto> GetStrips(object range)
            => GetStrips((SegmentDto)range);
 
        /// <summary>Асинхронная загрузка данных.</summary>
        /// <returns>Выполняемую задачу с загрузкой данных.</returns>
        public Task LoadAsync() => Task.Run(Load);
 
    }
 
}

using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
 
namespace StripSegments
{
    /// <summary>
    /// Логика взаимодействия для StripUC.xaml
    /// </summary>
    public partial class StripUC : UserControl
    {
        public StripUC()
        {
            InitializeComponent();
        }
 
        /// <summary>Источник последовательности Сегментов.</summary>
        public IEnumerable<StripSegment> SegmentsSource
        {
            get { return (IEnumerable<StripSegment>)GetValue(SegmentsSourceProperty); }
            set { SetValue(SegmentsSourceProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for SegmentsSource.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SegmentsSourceProperty =
            DependencyProperty.Register(nameof(SegmentsSource), typeof(IEnumerable<StripSegment>), typeof(StripUC), new PropertyMetadata(null));
    }
}

using System.Collections.Generic;
 
namespace StripSegments
{
    /// <summary>Вспомогательный класс
    /// для создания списка Сегментов в XAML.</summary>
    public class SegmentList : List<StripSegment>{}
}

using Common;
using Models;
using System;
using System.Collections.ObjectModel;
 
namespace StripSegments
{
    /// <summary>Класс Полосы.</summary>
    public class Strip : OnPropertyChangedClass, ICloneable<Strip>, IDto<StripDto>
    {
        #region Поля, хранящие значения одноимённых свойств
        private string _name;
        private StripDto _dto;
        private StripSegment _range;
        #endregion
 
        /// <summary>Имя Полосы.</summary>
        public string Name { get => _name; set => SetProperty(ref _name, value); }
 
        /// <summary>Сегменты Полосы.</summary>
        public ObservableCollection<StripSegment> Segments { get; }
            = new ObservableCollection<StripSegment>();
 
        /// <summary>Диапазон полосы.</summary>
        public StripSegment Range { get => _range; set => SetProperty(ref _range, value); }
 
        public StripDto Copy() => throw new NotImplementedException();
 
        public void CopyFrom(StripDto dto)
        {
            Name = dto.Name;
            Range.CopyFrom(dto.Range);
 
            // Изменение значений существующих элементов
            int i;
            for (i = 0; i < Segments.Count && i < dto.Segments.Count; i++)
                Segments[i].CopyFrom(dto.Segments[i]);
 
            // Удаление лишних элементов
            if (i < Segments.Count)
                for (; i < Segments.Count; i++)
                    Segments.RemoveAt(i);
 
            // Добавление нехватающих элементов
            else if (i < dto.Segments.Count)
                for (; i < dto.Segments.Count; i++)
                    Segments.Add(StripSegment.Create(dto.Segments[i]));
 
        }
 
        public void CopyTo(StripDto obj) => throw new NotImplementedException();
 
        #region Реализация интерфейса IDto<StripSegmentDto>
        public StripDto Dto { get => _dto; private set => SetProperty(ref _dto, value); }
        public void SetDto(StripDto newDto) => CopyFrom(Dto = newDto);
        #endregion
 
        #region Реализация интерфейса ICloneable<StripSegment>
        public Strip Clone() => (Strip)((ICloneable)this).Clone();
        object ICloneable.Clone() => MemberwiseClone();
        #endregion
    }
}

using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
 
namespace StripSegments
{
    /// <summary>
    /// Логика взаимодействия для StripUC.xaml
    /// </summary>
    public partial class StripUC : UserControl
    {
        public StripUC()
        {
            InitializeComponent();
        }
 
        /// <summary>Полоса с данными.</summary>
        public Strip Strip
        {
            get { return (Strip)GetValue(StripProperty); }
            set { SetValue(StripProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for Strip.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty StripProperty =
            DependencyProperty.Register(nameof(Strip), typeof(Strip), typeof(StripUC), new PropertyMetadata(null, StripChanged));
 
        private static void StripChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            StripUC stripUC = (StripUC)d;
            stripUC.SegmentsSource = stripUC.Strip?.Segments;
        }
 
        /// <summary>Источник последовательности Сегментов.
        /// Свойство Только Для Чтения.</summary>
        public IEnumerable<StripSegment> SegmentsSource
        {
            get { return (IEnumerable<StripSegment>)GetValue(SegmentsSourceProperty); }
            private set { SetValue(SegmentsSourcePropertyKey, value); }
        }
 
        // Using a DependencyProperty as the backing store for SegmentsSource.  This enables animation, styling, binding, etc...
        public static readonly DependencyPropertyKey SegmentsSourcePropertyKey =
            DependencyProperty.RegisterReadOnly(nameof(SegmentsSource), typeof(IEnumerable<StripSegment>), typeof(StripUC), new PropertyMetadata(null));
        public static readonly DependencyProperty SegmentsSourceProperty = SegmentsSourcePropertyKey.DependencyProperty;
    }
}

using System;
using System.Globalization;
using System.Linq;
using System.Windows.Data;
 
namespace StripSegments
{
    public class LengthScaleConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            // Все параметры в массиве values:
            // 0 - Преобразуемая Длина
            // 1 - длина Диапазона
            // 2 - ширина Контрола
            if (values == null)
                return null;
 
            // Получение первых трёх значений и перевод их в double.
            double[] nums = values.Take(3).OfType<double>().ToArray();
            if (nums.Length != 3)
                return null;
 
            // Присваивание значений переменным для наглядности
            double lengthSource = nums[0];
            double lengthRange = nums[1];
            double width = nums[2];
 
            return lengthSource * width / lengthRange;
        }
 
        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
 
}

using System;
using System.Globalization;
using System.Linq;
using System.Windows.Data;
 
namespace StripSegments
{
    public class OffsetScaleConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            // Все параметры в массиве values:
            // 0 - Начало Сегмента
            // 1 - Смещение (Начало) Диапазона
            // 2 - длина Диапазона
            // 3 - ширина Контрола
            if (values == null)
                return null;
 
            // Получение первых трёх значений и перевод их в double.
            double[] nums = values.Take(4).OfType<double>().ToArray();
            if (nums.Length != 4)
                return null;
 
            // Присваивание значений переменным для наглядности
            double begin = nums[0];
            double offset = nums[1];
            double length = nums[2];
            double width = nums[3];
 
            return (begin - offset) * width / length;
        }
 
        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
 
}

using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
 
namespace StripSegments
{
    /// <summary>
    /// Логика взаимодействия для StripsUC.xaml
    /// </summary>
    public partial class StripsUC : UserControl
    {
        public StripsUC()
        {
            InitializeComponent();
        }
 
        /// <summary>Источник последовательностм полос.</summary>
        public IEnumerable<Strip> StripsSource
        {
            get { return (IEnumerable<Strip>)GetValue(StripsSourceProperty); }
            set { SetValue(StripsSourceProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for StripsSource.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty StripsSourceProperty =
            DependencyProperty.Register(nameof(StripsSource), typeof(IEnumerable<Strip>), typeof(StripsUC), new PropertyMetadata(null));
    }
}

using System.Collections.Generic;
 
namespace StripSegments
{
    /// <summary>Вспомогательный класс
    /// для создания списка Полос в XAML.</summary>
    public class StripList : List<Strip> { }
}

using Common;
using Models;
using System;
using System.Collections.ObjectModel;
 
namespace StripSegments
{
    /// <summary>ViewModel - только свойства и реализация команд.</summary>
    public class StripsViewModelProperties : OnPropertyChangedClass
    {
        #region Поля для хранения значений свойств
        private double _step;
        private Segment _size = new Segment();
        private Segment _range = new Segment();
        #endregion
 
        /// <summary>Шаг изменения.</summary>
        public double Step { get => _step; set => SetProperty(ref _step, value); }
 
        /// <summary>Обший размер.</summary>
        public Segment Size { get => _size; set => SetProperty(ref _size, value); }
 
        /// <summary>Оторбражаемый диапазон.</summary>
        public Segment Range { get => _range; set => SetProperty(ref _range, value); }
 
        /// <summary>Коллекция полос.</summary>
        public ObservableCollection<Strip> Strips { get; } = new ObservableCollection<Strip>();
 
        private RelayActionCommand _nextStepCommand;
        /// <summary>Команда на один шаг вперёд.</summary>
        public RelayActionCommand NextStepCommand => _nextStepCommand
            ?? (_nextStepCommand = new RelayActionCommand(NextStepMetod, NextStepCanMetod));
 
        private bool NextStepCanMetod()
            => Range.End < Size.End;
 
        private void NextStepMetod()
        {
            GetStrips(new SegmentDto(Range.Begin + Step, Range.End + Step));
        }
 
        /// <summary>Метод изменения видимого диапазона. 
        /// Должен переопредляться в производном классе.</summary>
        /// <param name="segmentDto">Новый Диапазон.</param>
        protected virtual void GetStrips(SegmentDto segmentDto) { throw new NotImplementedException(); }
 
        private RelayActionCommand _prevStepCommand;
        /// <summary>Команда на один шаг назад.</summary>
        public RelayActionCommand PrevStepCommand => _prevStepCommand
            ?? (_prevStepCommand = new RelayActionCommand(PrevStepMetod, PrevStepCanMetod));
 
        private bool PrevStepCanMetod()
            => Range.Begin > Size.Begin;
 
        private void PrevStepMetod()
        {
            GetStrips(new SegmentDto(Range.Begin - Step, Range.End - Step));
        }
 
        /// <summary>Загрузка данных.
        /// Должен переопредляться в производном классе.</summary>
        public virtual void Load() { throw new NotImplementedException(); }
    }
 
}

using System;
using System.ComponentModel;
using System.Globalization;
using System.Windows.Data;
 
namespace Common
{
    /// <summary>Мультиконвертер - возвращает среднее double значение массива полученных значений.</summary>
    public class DoubleMediumConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if (values == null)
                return null;
 
            int count = 0;
            double sum = 0;
            foreach (object value in values)
            {
                if (value is double val)
                {
                    count++;
 
                    sum += val;
                }
                else if (TypeDescriptor.GetConverter(typeof(double)).IsValid(value))
                {
                    count++;
 
                    sum += (double)TypeDescriptor.GetConverter(typeof(double)).ConvertFrom(value);
                }
            }
            if (count == 0)
                return null;
            return sum / count;
        }
 
 
 
        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
 
}

using System;
using System.Globalization;
using System.Windows.Data;
 
namespace StripSegments
{
    /// <summary>Мультиконвертер для расчёта Maximum и Minimum ScrollBar.</summary>
    public class SizeToValueConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if ((string)parameter == "+")
                return (double)values[0] + (double)values[1] * 0.5;
            if ((string)parameter == "-")
                return (double)values[0] - (double)values[1] * 0.5;
            return null;
        }
 
        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
 
}

using System.Windows;
 
namespace StripSegments
{
    /// <summary>
    /// Логика взаимодействия для MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void LineLeftCommand_CanExecute(object sender, System.Windows.Input.CanExecuteRoutedEventArgs e)
        {
            StripsViewModelProperties viewModel = (StripsViewModelProperties)DataContext;
            e.CanExecute = viewModel.PrevStepCommand.CanExecute(null);
            e.Handled = true;
        }
 
        private void LineLeftCommand_Executed(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
        {
            StripsViewModelProperties viewModel = (StripsViewModelProperties)DataContext;
            viewModel.PrevStepCommand.Execute(null);
            e.Handled = true;
        }
 
        private void LineRightCommand_CanExecute(object sender, System.Windows.Input.CanExecuteRoutedEventArgs e)
        {
            StripsViewModelProperties viewModel = (StripsViewModelProperties)DataContext;
            e.CanExecute = viewModel.NextStepCommand.CanExecute(null);
            e.Handled = true;
        }
 
        private void LineRightCommand_Executed(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
        {
            StripsViewModelProperties viewModel = (StripsViewModelProperties)DataContext;
            viewModel.NextStepCommand.Execute(null);
            e.Handled = true;
        }
    }
 
}

using Models;
using System;
using System.Collections.Generic;
using System.Windows;
 
namespace StripSegments
{
 
    public class StripsViewModel : StripsViewModelProperties
    {
        private readonly StripsModel Model;
 
        public StripsViewModel(StripsModel model) => Model = model;
 
        public override void Load()
        {
            Model.Load();
            Step = Model.GetStep();
            Size = Segment.Create(Model.GetSize());
            Range = Segment.Create(Model.GetRange());
            GetStrips(Model.GetRange());
        }
 
        protected async override void GetStrips(SegmentDto segmentDto)
        {
 
            IReadOnlyList<StripDto> strips = await Model.GetStripsAsync(segmentDto).ConfigureAwait(true);
 
            if (Application.Current.Dispatcher.CheckAccess())
                UpdateStrips(strips);
            else
                Application.Current.Dispatcher.BeginInvoke((Action<IReadOnlyList<StripDto>>)UpdateStrips, strips);
 
        }
 
        private void UpdateStrips(IReadOnlyList<StripDto> strips)
        {
            Range.CopyFrom(Model.GetRange());
 
 
            // Изменение значений существующих элементов
            int i;
            for (i = 0; i < Strips.Count && i < strips.Count; i++)
                Strips[i].SetDto(strips[i]);
 
            // Удаление лишних элементов
            if (i < Strips.Count)
                for (; i < Strips.Count; i++)
                    Strips.RemoveAt(i);
 
            // Добавление нехватающих элементов
            else if (i < strips.Count)
                for (; i < strips.Count; i++)
                    Strips.Add(Strip.Create(strips[i]));
        }
    }
 
}

using Models;
using System.Windows;
 
namespace StripSegments
{
    /// <summary>
    /// Логика взаимодействия для App.xaml
    /// </summary>
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            string fileName = "strips.xml";
            StripsModel model = new StripsModel(fileName);
 
            StripsViewModel viewModel = new StripsViewModel(model);
 
            MainWindow = new MainWindow() { DataContext = viewModel };
 
            MainWindow.Show();
 
            viewModel.Load();
        }
    }
}

    public class GetStripInformation
    {
        protected static readonly Random rand = new Random();
 
        /// <summary> Получение рандомных позиций сегментов </summary>
        /// <param name="count"> Целочисленное количество рандомных сегментов</param>
        public IList<SegmentDto> GetRandomList(int count)
        {
            var list = new List<SegmentDto>();
 
            if (count <= 0)
                throw new ArgumentOutOfRangeException(nameof(count), "Количество меньше одного");
            else
            {
                int temp = rand.Next(0, 200);
                int randEnd = rand.Next(temp + 50, temp + 250);
 
                for (int i = 0; i < count; i++)
                {
                    list.Add(new SegmentDto(temp, randEnd));
                    temp = rand.Next(randEnd, randEnd + 200);
                    randEnd = rand.Next(temp + 50, temp + 250);
                }
            }
 
            return list;
        }
    }

    class Program
    {
        
        static void Main(string[] args)
        {
            GetStripInformation lol = new GetStripInformation();
            IList<SegmentDto> list = lol.GetRandomList(50);
 
            foreach(var kek in list)
            {
                Console.WriteLine(kek.Begin +", "+kek.End + "\n");
            }
        }
    }