如何在C＃中的构造函数中使用重载函数

Question

I want to create a geometry, based on different dimensions and a geometry flag, to determine if it is a cube or circle. To do so I have to use overload functions, but I do not know how i can utilize these in a class function to store my input. Here is what I did so far:

public void Object( double x, double y, double z)
        {
            name = "Cube";
            a = x;
            b = y;
            c = z;
        }
        public void Object(double r, double y)
        {
            name = "Cylinder";
            r1 = r;
            b = y;

        }

    protected double a{ get; private set; }
    protected double b{ get; private set; }
    protected double c{ get; private set; }
    protected double r1{ get; private set; }

First problem I have is, i can't use the declared variables multiple times, i have to to declare a variable for each possible object, in this case I can not save two variables on b , which is kinda ineffective.

My second problem is if i want to call the object in my dataclass like this along with other values it does not work:

public MeasureObject(double hash, string name, new Object obj(int n, different variables), double coordinates, ...)

{
 this.Hash = hash;
 this.Object=obj;
}

Is there a better way to implement a generic geometry in an object which can take an integer and n-different dimensions,lengths whatever?

Answer 1

Geometric objects have enough differences between them that it would be better to have separate classes.

For example, calculating the volume of each is done differently.

One solution could be to have a base class from which to inherit and have a factory class that determines which geometrical object instance you need based on the flag.

Answer 2

I would make a Cube and Cylinder class and an abstract class Geometry. You can then put the methods that are equal for both classes in the abstract class and override the others.

    public abstract class Shape
    {
        public int Height;
        public int Width;
        public int Depth;
        public double Area()
        {
            return Height * Width;
        }
        public abstract double Volume();
    }
    class Square : Shape
    {
        public Square(int height, int width)
        {
            Height = height;
            Width = width;            
        }
        public override double Volume()
        {
            throw new NotImplementedException();
        }            
    }
    class Cube : Shape
    {
        public Cube(int height, int width, int depth)
        {
            Height = height;
            Width = width;        
            Depth = depth;    
        }
        public override double Volume()
        {
            return Height * Width * Depth;
        }            
    }

Answer 3

I would design my classes this way:

namespace Geometry
{
    public interface IMeasurableSolid
    {
        double CalcSurface();
        double CalcVolume();
    }

    public class Sphere : IMeasurableSolid
    {
        public double Radius { get; set; }

        public Sphere(double radius)
        {
            if (radius <= 0)
            {
                throw new ArgumentOutOfRangeException("radius", "value must be positive");
            }
            this.Radius = radius;
        }

        public double CalcSurface()
        {
            return (Math.PI * 4 * Math.Pow(this.Radius, 2));
        }

        public double CalcVolume()
        {
            return (Math.PI * 4 * Math.Pow(this.Radius, 3) / 3);
        }
    }

    public class Cylinder : IMeasurableSolid
    {
        public double Height { get; set; }
        public double Radius { get; set; }

        public Cylinder(double height, double radius)
        {
            if (height <= 0)
            {
                throw new ArgumentOutOfRangeException("height", "value must be positive");
            }
            if (radius <= 0)
            {
                throw new ArgumentOutOfRangeException("radius", "value must be positive");
            }
            this.Height = height;
            this.Radius = radius;
        }

        public double CalcSurface()
        {
            return 2 * Math.PI * this.Radius * (this.Radius + this.Height);
        }

        public double CalcVolume()
        {
            return this.Height * Math.PI * Math.Pow(this.Radius, 2);
        }
    }
}

You can even derive Sphere and Cylinder from a base abstract class as Maarten Zeeman suggested; I prefer using Interfaces because I think it is a more versatile solution. Anyway you decide to do, please let me suggest you to conform to some best practices (you will find several examples here: https://www.roberthalf.com/technology/blog/4-best-practices-for-microsoft-net-framework-and-applications ). That is:

• avoid calling a class Object . It is a dangerous name. It can be confused with object by a simple mistyping. Call it Geometry , or Solid .
• choose explicit property names and uppercase them (Height, Length and Width are better than a, b, c).

Keep your model as close as possible to the reality you want to represent. It will be easier to properly design and maintain your classes.