Создание UML-диаграммы

    public partial class Form1 : Form
    {
        private SortableBindingList<Apartment> Apartments = new SortableBindingList<Apartment>();
        public Form1()
        {
            InitializeComponent();
            dataGridView1.DataSource = Apartments;
            dataGridView1.Columns[0].HeaderText = "Кол-во комнат";
            dataGridView1.Columns[1].HeaderText = "Площадь";
            dataGridView1.Columns[2].HeaderText = "Район";
            dataGridView1.Columns[3].HeaderText = "Этаж";
            dataGridView1.Columns[4].HeaderText = "Кол-во комнат";
            dataGridView1.Columns[5].HeaderText = "Площадь";
            dataGridView1.Columns[6].HeaderText = "Район";
            dataGridView1.Columns[7].HeaderText = "Этаж";
        }
 
        private void AddButton_Click(object sender, EventArgs e)
        {
            SearchandAdd();
        }
        public void SearchandAdd()
        {
            label6.Text = "";
            AddRequest AR = new AddRequest();
            if (AR.ShowDialog() == DialogResult.OK)
            {
                byte rooms = Convert.ToByte(AR.textBox1.Text);
                double square = Convert.ToDouble(AR.textBox2.Text);
                string region = AR.textBox3.Text;
                byte floor = Convert.ToByte(AR.textBox4.Text);
                byte roomsn = Convert.ToByte(AR.textBox5.Text);
                double squaren = Convert.ToDouble(AR.textBox6.Text);
                string regionn = AR.textBox7.Text;
                byte floorn = Convert.ToByte(AR.textBox8.Text);
                if (Apartments.Count == 0) Apartments.Add(new Apartment(rooms, square, region, floor, roomsn, squaren, regionn, floorn));
                else
                {
                    var xapartment = Apartments.Where(t => t.Rooms == roomsn && t.Floor == floorn && t.RoomsN == rooms && t.FloorN == floor && 0 <= Math.Abs(t.Square - squaren) / (t.Square + squaren) / 2 * 0.01 && Math.Abs(t.Square - squaren) / (t.Square + squaren) / 2 * 0.01 <= 10 && 0 <= Math.Abs(t.SquareN - square) / (t.SquareN + square) / 2 * 0.01 && Math.Abs(t.SquareN - square) / (t.SquareN + square) / 2 * 0.01 <= 10).FirstOrDefault();
                    {
                        if (xapartment != null)
                        {
                            Apartments.Remove(xapartment);
                            label6.Text="Ваша новая " + AR.textBox5.Text + "-комнатная квартира площадью " + AR.textBox6.Text + " кв.м. находится на " + AR.textBox8.Text + " этаже в районе " + regionn;
                        }
                        else  Apartments.Add(new Apartment(rooms, square, region, floor, roomsn, squaren, regionn, floorn));
                    }
                }
                dataGridView1.DataSource = Apartments;
            }
        }
    }
 
    public class Apartment
    {
        public byte Rooms { get; set; }
        public double Square { get; set; }
        public string Region { get; set; }
        public byte Floor { get; set; }
        public byte RoomsN { get; set; }
        public double SquareN { get; set; }
        public string RegionN { get; set; }
        public byte FloorN { get; set; }
        public Apartment(byte rooms, double square, string region, byte floor, byte roomsN, double squareN, string regionN, byte floorN)
        {
            Rooms = rooms;
            Square = square;
            Region = region;
            Floor = floor;
            RoomsN = roomsN;
            SquareN = squareN;
            RegionN = regionN;
            FloorN = floorN;
        }
    }
    public class SortableBindingList<T> : BindingList<T>
    {
        private readonly Dictionary<Type, PropertyComparer<T>> comparers;
        private bool isSorted;
        private ListSortDirection listSortDirection;
        private PropertyDescriptor propertyDescriptor;
 
        public SortableBindingList()
            : base(new List<T>())
        {
            this.comparers = new Dictionary<Type, PropertyComparer<T>>();
        }
 
        public SortableBindingList(IEnumerable<T> enumeration)
            : base(new List<T>(enumeration))
        {
            this.comparers = new Dictionary<Type, PropertyComparer<T>>();
        }
 
        protected override bool SupportsSortingCore
        {
            get { return true; }
        }
 
        protected override bool IsSortedCore
        {
            get { return this.isSorted; }
        }
 
        protected override PropertyDescriptor SortPropertyCore
        {
            get { return this.propertyDescriptor; }
        }
 
        protected override ListSortDirection SortDirectionCore
        {
            get { return this.listSortDirection; }
        }
 
        protected override bool SupportsSearchingCore
        {
            get { return true; }
        }
 
        protected override void ApplySortCore(PropertyDescriptor property, ListSortDirection direction)
        {
            List<T> itemsList = (List<T>)this.Items;
 
            Type propertyType = property.PropertyType;
            PropertyComparer<T> comparer;
            if (!this.comparers.TryGetValue(propertyType, out comparer))
            {
                comparer = new PropertyComparer<T>(property, direction);
                this.comparers.Add(propertyType, comparer);
            }
 
            comparer.SetPropertyAndDirection(property, direction);
            itemsList.Sort(comparer);
 
            this.propertyDescriptor = property;
            this.listSortDirection = direction;
            this.isSorted = true;
 
            this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
        }
 
        protected override void RemoveSortCore()
        {
            this.isSorted = false;
            this.propertyDescriptor = base.SortPropertyCore;
            this.listSortDirection = base.SortDirectionCore;
 
            this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
        }
 
        protected override int FindCore(PropertyDescriptor property, object key)
        {
            int count = this.Count;
            for (int i = 0; i < count; ++i)
            {
                T element = this[i];
                if (property.GetValue(element).Equals(key))
                {
                    return i;
                }
            }
 
            return -1;
        }
    }
 
    public class PropertyComparer<T> : IComparer<T>
    {
        private readonly IComparer comparer;
        private PropertyDescriptor propertyDescriptor;
        private int reverse;
 
        public PropertyComparer(PropertyDescriptor property, ListSortDirection direction)
        {
            this.propertyDescriptor = property;
            Type comparerForPropertyType = typeof(Comparer<>).MakeGenericType(property.PropertyType);
            this.comparer = (IComparer)comparerForPropertyType.InvokeMember("Default", BindingFlags.Static | BindingFlags.GetProperty | BindingFlags.Public, null, null, null);
            this.SetListSortDirection(direction);
        }
 
        #region IComparer<T> Members
 
        public int Compare(T x, T y)
        {
            return this.reverse * this.comparer.Compare(this.propertyDescriptor.GetValue(x), this.propertyDescriptor.GetValue(y));
        }
 
        #endregion
 
        private void SetPropertyDescriptor(PropertyDescriptor descriptor)
        {
            this.propertyDescriptor = descriptor;
        }
 
        private void SetListSortDirection(ListSortDirection direction)
        {
            this.reverse = direction == ListSortDirection.Ascending ? 1 : -1;
        }
 
        public void SetPropertyAndDirection(PropertyDescriptor descriptor, ListSortDirection direction)
        {
            this.SetPropertyDescriptor(descriptor);
            this.SetListSortDirection(direction);
        }
    }