С# классы2

using System;
using System.Drawing;
namespace Ллаба_5
{
    public interface IShape
    {
        public double GetSquare();
        public double GetPerimetr();
    }

    public class Quadrangle : IShape
    {
        protected Point p1, p2, p3, p4;
        protected double sideA, sideB, sideC, sideD;
        protected double diag_1, diag_2;
        public double Diag1 => diag_1;
        public double Diag2 => diag_2;
        public double side { get => sideA; }

        public Quadrangle(Point p1, Point p2, Point p3, Point p4)
        {
            this.p1 = p1;
            this.p2 = p2;
            this.p3 = p3;
            this.p4 = p4;

            if (IsQuadrangle())
            {
                SetSides();
                SetDiagonals();
            }
            else
            {
                Console.WriteLine("Фигура не четырёхугольник");
            }
        }
        public Quadrangle(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
        {
            p1 = new Point(x1, y1);
            p2 = new Point(x2, y2);
            p3 = new Point(x3, y3);
            p4 = new Point(x4, y4);

            if (IsQuadrangle())
            {
                SetSides();
                SetDiagonals();
            }
            else
            {
                Console.WriteLine("Фигура не четырёхугольник");
            }
        }

        public bool IsQuadrangle()
        {
            // проверим лежат ли точки на одной прямой
            double X(double x, double x1, double x2) => (x - x1) / (x2 - x1);
            double Y(double y, double y1, double y2) => (y - y1) / (y2 - y1);
            if (X(p3.X, p1.X, p2.X) == Y(p3.Y, p1.Y, p2.Y)
                || X(p4.X, p1.X, p2.X) == Y(p4.Y, p1.Y, p2.Y)) return false;
            return true;
        }

        protected void SetSides()
        {
            sideA = Math.Sqrt(Math.Pow((p2.X - p1.X), 2) + Math.Pow((p2.Y - p1.Y), 2));
            sideB = Math.Sqrt(Math.Pow((p3.X - p2.X), 2) + Math.Pow((p3.Y - p2.Y), 2));
            sideC = Math.Sqrt(Math.Pow((p4.X - p3.X), 2) + Math.Pow((p4.Y - p3.Y), 2));
            sideD = Math.Sqrt(Math.Pow((p1.X - p4.X), 2) + Math.Pow((p1.Y - p4.Y), 2));
        }

        protected void SetDiagonals()
        {
            diag_1 = Math.Sqrt(Math.Pow((p1.X - p3.X), 2) + Math.Pow((p1.Y - p3.Y), 2));//считаем диагонали
            diag_2 = Math.Sqrt(Math.Pow((p2.X - p4.X), 2) + Math.Pow((p2.Y - p4.Y), 2));
        }
        public double GetSquare()
        {
            double polP = GetPerimetr() / 2; //полупериметр
            double alpha = Math.Acos((Math.Pow(sideA, 2) + Math.Pow(sideB, 2) - Math.Pow(diag_1, 2)) / (2 * sideA * sideB));
            double beta = Math.Acos((Math.Pow(sideC, 2) + Math.Pow(sideD, 2) - Math.Pow(diag_2, 2)) / (2 * sideB * sideD));
            var s = Math.Sqrt((polP - sideA) * (polP - sideB) * (polP - sideC) * (polP - sideD) - sideA * sideB * sideC * sideD * Math.Cos((alpha + beta) / 2));

            return s;
        }
        public double GetPerimetr() => sideA + sideB + sideC + sideD;
        public virtual void GetShapeStat()
        {
            if (IsQuadrangle())
                Console.WriteLine($"Четырёхугольник с вершинами\n" +
                $"p1 = ({p1.X}; {p1.Y}), p2 = ({p2.X}; {p2.Y}), p3 = ({p3.X}; {p3.Y}), p4 = ({p4.X}; {p4.Y})\n" +
                $"диагоналями {diag_1} и {diag_2}\n" +
                $"сторонами A = {sideA}, B = {sideB}, C = {sideC}, D = {sideD}" +
                $"Площадью = {GetSquare()} и периметром {GetPerimetr()}");
        }
    }

    public class Parallelogram : Quadrangle
    {
        Circle c1;
        public Parallelogram(Point p1, Point p2, Point p3, Point p4)
            : base(p1, p2, p3, p4)
        {
            if (!IsParallelogram())
                Console.WriteLine("Фигура не парраллелограм");

            // окружность вписана в параллелограмм тогда и только тогда
            // когда параллелограмм - ромб
            if (sideA == sideB && sideA == sideC && sideA == sideD)
            {
                c1 = new Circle((Diag1 / 2) * (Diag2 / 2) / side);
            }
        }

        public Parallelogram(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
            : base(x1, y1, x2, y2, x3, y3, x4, y4)
        {
            if (!IsParallelogram())
                Console.WriteLine("Фигура не парраллелограмм");

            // окружность вписана в параллелограмм тогда и только тогда
            // когда параллелограмм - ромб
            if (sideA == sideB && sideA == sideC && sideA == sideD)
            {
                c1 = new Circle((Diag1 / 2) * (Diag2 / 2) / side);
            }
        }

        public bool IsParallelogram() => sideA == sideC && sideB == sideD;

        public override void GetShapeStat()
        {
            if (IsParallelogram())
                Console.WriteLine($"Параллелограмм с вершинами\n" +
                $"p1 = ({p1.X}; {p1.Y}), p2 = ({p2.X}; {p2.Y}), p3 = ({p3.X}; {p3.Y}), p4 = ({p4.X}; {p4.Y})\n" +
                $"диагоналями {diag_1} и {diag_2}\n" +
                $"сторонами A = {sideA}, B = {sideB}, C = {sideC}, D = {sideD}" +
                $"Площадью = {GetSquare()} и периметром {GetPerimetr()}");
            else Console.WriteLine("Фигура не парраллелограм");
        }
    }


    public class Parallelepiped : Parallelogram
    {
        private double h;

        public Parallelepiped(Point p1, Point p2, Point p3, Point p4, double h)
            : base(p1, p2, p3, p4) { this.h = h; }

        public Parallelepiped(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, double h)
                : base(x1, y1, x2, y2, x3, y3, x4, y4) { this.h = h; }

        public double GetVolume() => base.GetSquare() * h;
        public new double GetSquare() => base.GetSquare() * 2 + 2 * sideA * h + 2 * sideB * h;

        public override void GetShapeStat()
        {
            Console.WriteLine($"Параллелепипед с вершинами\n" +
            $"p1 = ({p1.X}; {p1.Y}), p2 = ({p2.X}; {p2.Y}), p3 = ({p3.X}; {p3.Y}), p4 = ({p4.X}; {p4.Y})\n" +
            $"сторонами A = {sideA}, B = {sideB}, C = {sideC}, D = {sideD} и высотой {h} \n" +
            $"Площадью = {GetSquare()} и объёмом {GetSquare()}");
        }
    }

    public class Circle : IShape
    {
        double r;
        public double R { get => r; }
        public Circle(double r)
        {
            this.r = r;
        }

        public double GetSquare()
        {
            return Math.PI * r * r;
        }
        public double GetPerimetr()
        {
            return 2 * Math.PI * r;
        }
        public void GetShapeStat()
        {
            Console.WriteLine($"Круг с радиусом = {r}\n" +
                $"периметром = {GetPerimetr()} и площадью = {GetSquare()}");
        }

        public void ChangeR(Parallelogram p)
        {
            // если в параллелограмм можно вписать окружность то это ромб
            // тогда радиус ищем по известной формуле для высоты опущенной на гипотенузу
            r = (p.Diag1 / 2) * (p.Diag2 / 2) / p.side;
        }

    }

    class Program
    {
        public static void Task1()
        {
            int n;
            int m;
            int x1, x2, x3, x4, y1, y2, y3, y4;
            Console.WriteLine("Введите количество четырехугольников: ");
            n = Convert.ToInt32(Console.ReadLine());
            double AvgS = 0;
            double maxS = 0;
            double minS = double.MaxValue;
            int nmax = 0;
            int nmin = 0;
            // int sravn = 0;
            for (int i = 0; i < n; i++)
            {
                Console.WriteLine("Четырёхугольник " + (i + 1));
                Console.Write("x1: ");
                x1 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y1: ");
                y1 = Convert.ToInt32(Console.ReadLine());
                Console.Write("x2: ");
                x2 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y2: ");
                y2 = Convert.ToInt32(Console.ReadLine());
                Console.Write("x3: ");
                x3 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y3: ");
                y3 = Convert.ToInt32(Console.ReadLine());
                Console.Write("x4: ");
                x4 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y4: ");
                y4 = Convert.ToInt32(Console.ReadLine());
                Quadrangle a = new Quadrangle(x1, y1, x2, y2, x3, y3, x4, y4);
                if (a.IsQuadrangle())
                {
                    AvgS += a.GetSquare();
                }
                else Console.WriteLine("Фигура не четырёхугольник");
            }
            AvgS /= n;
            Console.WriteLine("среднюю  площадь четырехугольников = " + AvgS);
            Console.WriteLine();


            Console.WriteLine("Введите количество параллелограммов: ");
            m = Convert.ToInt32(Console.ReadLine());
            // int sravn = 0;
            for (int i = 0; i < m; i++)
            {
                Console.WriteLine("Параллелограмм " + (i + 1));
                Console.Write("x1: ");
                x1 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y1: ");
                y1 = Convert.ToInt32(Console.ReadLine());
                Console.Write("x2: ");
                x2 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y2: ");
                y2 = Convert.ToInt32(Console.ReadLine());
                Console.Write("x3: ");
                x3 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y3: ");
                y3 = Convert.ToInt32(Console.ReadLine());
                Console.Write("x4: ");
                x4 = Convert.ToInt32(Console.ReadLine());
                Console.Write("y4: ");
                y4 = Convert.ToInt32(Console.ReadLine());
                Parallelogram a = new Parallelogram(x1, y1, x2, y2, x3, y3, x4, y4);
                if (a.GetSquare() > maxS)
                {
                    maxS = a.GetSquare();
                    nmax = i + 1;
                }
                if (a.GetSquare() < minS)
                {
                    minS = a.GetSquare();
                    nmin = i + 1;
                }
            }
            Console.WriteLine($"Параллелограмм с максимальной площадью ({maxS}): " + nmax);
            Console.WriteLine($"Параллелограмм с минимальной площадью ({minS}): " + nmin);
            Console.ReadLine();
        }

        static void Main(string[] args)
        {
            Task1();
            Circle c1 = new Circle(3);
            c1.GetShapeStat();
        }
    }
}