Наследование и(или) уменьшение объема кода — C#?

Question

[Adjist]

namespace ConsoleApplication10
{
 
 
    class Pryamoyg
    {
        private double x1;
        private double y1;
        private double x2;
        private double y2;
        private double x3;
        private double y3;
        private double x4;
        private double y4;
 
  
 
        private bool Proverka()
        {
            double k1, k2, g, k3, k4;
            bool p = false;
 
 
            k1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
            k2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
            k3 = Math.Sqrt(((x4 - x3) * (x4 - x3)) + ((y4 - y3) * (y4 - y3)));
            k4 = Math.Sqrt(((x1 - x4) * (x1 - x4)) + ((y1 - y4) * (y1 - y4)));
            g = Math.Sqrt(((x3 - x1) * (x3 - x1)) + ((y3 - y1) * (y3 - y1)));
            if ((g == Math.Sqrt(k1 * k1 + k2 * k2)) & (g == Math.Sqrt(k3 * k3 + k4 * k4)))
            {
 
                p = true;
            }
            return p;
 
        }
 
        public void Ploshad()
        {
            if (Proverka() == true)
            {
 
 
                double r1, r2, S;
                r1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                r2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
                S = r1 * r2;
                Console.WriteLine("Площадь: {0}", S);
            }
            else
            {
                Console.WriteLine("eto ne pryamoyg");
            }
        }
 
        public void Perim()
        {
 
            if (Proverka() == true)
            {
                double r1, r2, P;
 
                r1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                r2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
                P = (r1 + r2) * 2;
                Console.WriteLine("Периметр: {0}", P);
            }
            else
            {
                Console.WriteLine("eto ne pryamoyg");
            }
        }
 
        class Kvadrat
        {
            private double x1;
            private double y1;
            private double x2;
            private double y2;
            private double x3;
            private double y3;
            private double x4;
            private double y4;
 
            public Kvadrat(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
            {
                this.x1 = x1;
                this.x4 = x4;
                this.x2 = x2;
                this.x3 = x3;
                this.y1 = y1;
                this.y2 = y2;
                this.y3 = y3;
                this.y4 = y4;
            }
 
            private bool Proverka()
            {
                double k1, k2, g, k3, k4;
                bool p = false;
                k1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                k2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
                k3 = Math.Sqrt(((x4 - x3) * (x4 - x3)) + ((y4 - y3) * (y4 - y3)));
                g = Math.Sqrt(((x3 - x1) * (x3 - x1)) + ((y3 - y1) * (y3 - y1)));
                k4 = Math.Sqrt(((x1 - x4) * (x1 - x4)) + ((y1 - y4) * (y1 - y4)));
                if ((g == Math.Sqrt(k1 * k1 + k2 * k2)) & (k1 == k2) & (k1 == k3) & (k1 == k4))
                {
 
                    p = true;
                }
                return p;
            }
 
 
 
 
 
 
            public void Ploshad()
            {
 
                if (Proverka() == true)
                {
 
 
                    double r1, r2, S;
                    r1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                    r2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
                    S = r1 * r2;
                    Console.WriteLine("Площадь: {0}", S);
                }
                else
                {
                    Console.WriteLine("eto ne kvadr");
                }
            }
 
            public void Perim()
            {
 
                if (Proverka() == true)
                {
 
                    double r1, r2, P;
 
                    r1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                    r2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
                    P = (r1 + r2) * 2;
                    Console.WriteLine("Периметр: {0}", P);
                }
                else
                {
                    Console.WriteLine("eto ne kvadr");
                }
            }
 
            class Romb
            {
                private double x1;
                private double y1;
                private double x2;
                private double y2;
                private double x3;
                private double y3;
                private double x4;
                private double y4;
                public Romb(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
                {
                    this.x1 = x1;
                    this.x4 = x4;
                    this.x2 = x2;
                    this.x3 = x3;
                    this.y1 = y1;
                    this.y2 = y2;
                    this.y3 = y3;
                    this.y4 = y4;
                }
 
                private bool Proverka()
                {
                    double k1, k2, g, k3, k4;
                    bool p = false;
                    k1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                    k2 = Math.Sqrt(((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
                    k3 = Math.Sqrt(((x4 - x3) * (x4 - x3)) + ((y4 - y3) * (y4 - y3)));
                    g = Math.Sqrt(((x3 - x1) * (x3 - x1)) + ((y3 - y1) * (y3 - y1)));
                    k4 = Math.Sqrt(((x1 - x4) * (x1 - x4)) + ((y1 - y4) * (y1 - y4)));
                    if ((k1 == k2) & (k1 == k3) & (k1 == k4))
                    {
 
                        p = true;
                    }
                    return p;
                }
 
                public void Ploshad()
                {
 
                    if (Proverka() == true)
                    {
                        double r1, r2, S;
                        r1 = Math.Sqrt(((x3 - x1) * (x3 - x1)) + ((y3 - y1) * (y3 - y1)));
                        r2 = Math.Sqrt(((x4 - x2) * (x4 - x2)) + ((y4 - y2) * (y4 - y2)));
                        S = (r1 * r2) / 2;
                        Console.WriteLine("Площадь: {0}", S);
                    }
                    else
                    {
                        Console.WriteLine("eto ne romb");
                    }
                }
 
                public void Perim()
                {
 
                    if (Proverka() == true)
                    {
                        double r1, P;
 
                        r1 = Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
                        P = r1 * 4;
                        Console.WriteLine("Периметр: {0}", P);
                    }
                    else
                    {
                        Console.WriteLine("eto ne romb");
                    }
                }
            }
 
            class Trapecia
            {
                public double x1;
                public double y1;
                public double x2;
                public double y2;
                public double x3;
                public double y3;
                public double x4;
                public double y4;
 
                public void Ploshad()
                {
                    double a1, h1, S1, a2, h2, S2, a3, h3, S3, a4, h4, S4, S;
                    a1 = x2 - x1;
                    h1 = Math.Abs(y1 + (y2 - y1) / 2);
                    S1 = a1 * h1;
                    a2 = x3 - x2;
                    h2 = Math.Abs(y2 + (y3 - y2) / 2);
                    S2 = a2 * h2;
                    a3 = x4 - x3;
                    h3 = Math.Abs(y3 + (y4 - y3) / 2);
                    S3 = a3 * h3;
                    a4 = x1 - x4;
                    h4 = Math.Abs(y4 + (y1 - y4) / 2);
                    S4 = a4 * h4;
                    S = S1 + S2 + S3 + S4;
                    Console.WriteLine("Площадь: {0}", S);
                }
 
 
 
            }
 
            class Paral
            {
                public double x1;
                public double y1;
                public double x2;
                public double y2;
                public double x3;
                public double y3;
                public double x4;
                public double y4;
 
             
 
            }
 
            class Krug
            {
                public double r;
                public const double Pi = Math.PI;
 
                public void Ploshad()
                {
                    double S;
                    S = Pi * (r * r);
                    Console.WriteLine("Площадь : {0}", S);
                }
 
                public void DlinaO()
                {
                    double L;
                    L = 2 * Pi * r;
                    Console.WriteLine("Длина окружностти : {0}", L);
                }
 
            }

Это не просьба сделать за меня работу, а просто показать, как уменьшить код. Программа, вводим координаты и получаем в итоге ответ, но она огромна, пока читаю тему наследования, но до конца не понимаю, как уменьшить объем кода? Хотя бы часть с переменными x/y?
*часть программы удалена из-за ограничения в 10 тысяч символов

Comments

[Толстый Лорри]

Разбивайте код на сущности и изолируйте ответственность в них. Пары координат - это готовый тип Point. Он может также уметь находить декартово расстояние до другой точки. 4 объекта Point как углы - это фигура (четырехугольник), от которой могут наследоваться фигуры "квадрат", "ромб", "трапеция", добавляя свои проверки при вводе точек.
Также для анализа углов может пригодиться сущность из двух точек - прямая.

Дублирующиеся части кода (формулы) можно как вынести в отдельные приватные/защищенные методы, так и просто в лямбды.

Что-то вроде такого:

struct Point 
{
    public double X { get; set; }
    public double Y { get; set; }

    public double GetDistance(Point otherPoint)
    {
            return Math.Sqrt( 
                              Math.Pow(otherPoint.X - this.X, 2) 
                              + Math.Pow(otherPoint.Y - this.Y, 2) 
                          );
    }
}

struct Quadrilateral
{
    public Quadrilateral( Point leftTop,    Point rightTop,
                          Point leftBottom, Point rightBottom )
    {
        _leftTop = leftTop;
        _rightTop = rightTop;
        _rightBottom = rightBottom;
        _leftBottom = leftBottom;
    }


    public virtual double GetPerimeter ()
    {
        return _leftTop.GetDistance(_rightTop)
            +  _rightTop.GetDistance(_rightBottom)
            +  _rightBottom.GetDistance(_leftBottom)
            +  _leftBottom.GetDistance(_leftTop);
    }
    
    protected Point _leftTop;
    protected Point _rightTop;
    protected Point _leftBottom;
    protected Point _rightBottom;
}

struct Line
{
    public Line (Point p1, Point p2)
    {
        if (p1 == p2) throw new InvalidArgumentException("Это не линия!");

        _point1 = p1;
        _point2 = p2;
    }

    public double GetAngleWith(Line otherLine)
    {
        double a1 = _point2.Y - _point1.Y;
        double b1 = _point2.X - _point1.X;
        double a2 = otherLine._point2.Y - otherLine._point1.Y;
        double b2 = otherLine._point2.X - otherLine._point1.X;

        return Math.Acos(               ( b1 * b2 + a1 * a2 )
                            /   Math.Sqrt( Math.Pow(b1,2) + Math.Pow(a1,2) ) 
                              * Math.Sqrt( Math.Pow(b2,2) + Math.Pow(a2,2) ) 
                        );
    }

    private Point _point1;
    private Point _point2;
}

struct Square: Quadrilateral
{
    public Square( Point leftTop,    Point rightTop,
                  Point leftBottom, Point rightBottom)
        : base(leftTop, rightTop, leftBottom, rightBottom)
    {
        if ( !IsShapeValid() )
        {
            throw new InvalidArgumentException("Это не квадрат");
        }
    }

    public override double GetPerimeter()
    {
        return _leftTop.GetDistance(_rightTop) * 4.;
    }

    protected bool IsShapeValid()
    {
        Func<Line, Line, bool> checkAngle => (l1, l2) => l1.GetAngleWith(l2) - Math.Pi/2. < 0.01;

        var top = new Line(_leftTop, _rightTop);
        var right = new Line(_rightTop, _rightBottom);
        var bottom = new Line(_leftBottom, _rightBottom);
        var left = new Line(_leftTop, _leftBottom);

        return checkAngle(top, right)
            && checkAngle(bottom, right)
            && checkAngle(left, bottom)
            && checkAngle(left, top)
    }
}

Answer 1

[Дмитрий Еремин]

В учебнике Троелсона на примере фигур рассматривается принцип наследования

Сделайте класс figura (раз уж по английски никак) и там создайте члены

protected double x1;
protected double y1;
protected double x2;
protected double y2;
protected double x3;
protected double y3;
protected double x4;
protected double y4;

От него унаследуйте все свои круги и квадраты

Еще можно в figura определить абстрактные методы Ploshad() и Perim()
А у наследников определить реализацию - каждому свою.

Так правильнее. И вы сможете, например, работать с коллекцией фигур. Например

List<figura> figuri = new List<figura>();
figuri.Add(new krug());
figuri.Add(new romb());
figuri.Add(new kvadrat());

foreach(var fig in figuri)
{
Console.WriteLine(fig.ploshad());
}

Не сказать, что кода станет сильно меньше. Хотя вам не придется в каждом классе объявлять вот эту портянку из x1, x2... y4
Удобнее будет работать с семейством классов - это очень полезное изменение

Comments

[Рифат]

1. Для фигуры у которой число углов != 4 не подойдет
2. Для круга тоже не подойдет, т.к. у него нет углов

[Дмитрий Еремин]

Рифат: согласен. С кругом неудобно получается. Там можно использовать только первую пару x-y для обозначения центра. Но эт на коленке написано, можно больше оптимизаций
Но опять же, нужно Троелсона смотреть - там прям именно эта ситуация рассматривается.

[Станислав Силин]

Рифат: Можно сделать класс Figure без точек вообще, только методы(абстрактные), а потом сделать отдельно круг и все остальное с точками.

Answer 2

[Алексей Джо]

Важнее научится правильно именовать переменные и объекты: Krug - Disk, Ploshad - Area. Это важно.

На примере класса Krug (остальные фигуры по аналогии).
-Создается полиморфный тип. B данном примере преимущество не заметно, но в реальных проектах может быть много общих методов, которые могут в точности повторяться в классах наследниках.
-public const double Pi = Math.PI; - выкидывается, т.к. создает избыточность
-вместо S = Pi * (r * r); нужно использовать готовый метод Math.Pow
-лучше использовать инициализацию присваиванием double area = Math.PI * Math.Pow(Radius, 2); где это возможно
-методы должны возвращать значение без Console.WriteLine("Shape");, таким образом данный пример можно использовать в приложении WindowsForms, например
-можно добавить конструктор с параметром для инициализации св-ва Radius

class Shape
{
    //общие для фигур методы
    public virtual string GetShapeName()
    {
        return "Shape";
    }
}

class Disk : Shape
{
    public double Radius { get; set; }
    
    public double Area()
    {
        double area = Math.PI * Math.Pow(Radius, 2);
        return area;
    }
 
    public double Length()
    {
        double length = 2 * Math.PI * Radius;
        return length;
    }

    public override string GetShapeName()
    {
        return "Disk";
    }
}