添加点数组

Question

有谁知道如何将点值添加到数组？

Answer 1

为什么你想要的数组是double？你可以使用一个Point数组;

Point[] points = new Point[2]; 
points[0] = new Point(15,15); 
points[1] = new Point(200,220); 

double someResult = (points[0].x - points[1].x) * (points[0].y - points[1].y); 

或循环它们;

for (int i = 0; i < points.Lenght; i++) 
{ 
     // do something with points[i] 
} 

或者带一个列表;

List<Point> points = new List<Point>(); 
points.Add(new Point(1,1)); //ect 

或

List<Point> points = new { new Point(1,1), new point(2,2) //ect }; 

foreach (Point p in points) 
{ 
    // do something with p 
} 

，你可能有利于通过循环一些随机LINQ;

double xTotal = points.Aggregate((c, n) => c.x + n.y); // gives sum or all x values 
double yTotal = points.Aggregate((c, n) => c.y + n.y); 

当我添加两个点到一个数组，这是否意味着该数组将保存4个值？

排序该阵列将保存两个Point实例。每个人都有x和y价值，但通常你会说数组持有2个值。如果你只是想组4双打，你可能根本不想使用Point。你可以声明一个结构像;

public struct Rect 
{ 
    double a; 
    double b; 
    double c; 
    double d; 
} 

，有你的4个双打更很好地组合在一起。或者你可以使用Tuple<double, double, double, double>，虽然大多数开发者可能会觉得有点奇怪（嘿，我至少喜欢它们）。但是，它是只读的。

var tuple = new Tuple<double, double, double, double(1, 2, 3, 4); 

Answer 2

我建议你来声明一个类，那就是：

public class Rectangle 
{ 
    public Rectangle(Point left, Point right) 
    { 
     Left = left; 
     Right = right; 
    } 

    private Point Left{get; set;} 

    private Point Right{get; set;} 

    public double CalculateArea() 
    { 
     return (points[0].x - points[1].x) * (points[0].y - points[1].y); 
    } 

} 

这里是你如何使用它：

var rec = new Rectangle(new Point(15,15), new Point(200,220)); 
var someResult = rec.CalculateArea(); 

Answer 3

一般来说，你会过得更好的重构你的程序使用Point数组，因为它具有更多的语义含义。

但如果这是一个真正的矩形（不是任何四边的形状，你需要四点而不是两个），你可以这样做：

public double[] ConvertPointsToArray(Point topLeft, Point bottomRight) 
{ 
    var points = new double[4]; 
    points[0] = topLeft.x; 
    points[1] = topLeft.y; 
    points[2] = bottomRight.x; 
    points[3] = bottomRight.y; 
    return points; 
} 

然后你就可以使用这样的阵列：

var points = ConvertPointsToArray(left, right); 
var value = (points[0] - points[2]) * (points[1] - points[3]); 

但正如你所看到的，你必须知道点是如何在阵列中的编码，很容易陷入困境。

有两个点的矩形类会更有用。