Pourquoi utilisons-nous le mot-clé "new" lors de l'initialisation d'un Vector3, mais pas un entier?

Sur la base des commentaires récents, je voudrais proposer cette solution (via une méthode d'extension).

Vector3[,] coordsList  = new Vector3[2, 2]
{
    {(-1.32f,1.32f), (-1.32f,1.32f)},
    {(-1.32f,1.32f), (-1.32f,1.32f)}
};

et ensuite vous pourriez utiliser une méthode d'extension ...

public class Vector3
{
    public Vector3(float x, float y)
    {
        this.X = x;
        this.Y = y;
    }
    
    public float X { get; set; }
    public float Y { get; set; }
    
    public static implicit operator (float X, float Y)(Vector3 value)
    {
        return (value.X, value.Y);
    }

    public static implicit operator Vector3 ((float X, float Y) value)
    {
        return new Vector3(value.X, value.Y);
    }
}

Certes, la solution originale serait plus efficace, mais je ne savais pas que vous utilisiez une structure d'Unity à l'époque. Cependant, cette solution tente toujours de résoudre le même problème de lisibilité et de code répétitif.

Message d'origine

Je suppose que l'objectif de votre question est de faire sur la lisibilité et la refactorisation du code répétitif. Vous pouvez utiliser des tuples à côté de opérateurs implicites pour en faire un peu plus ce que vous voulez ....

public static class Vector3Extensions
{
    public static Vector3[,] ToVector3(this (float X, float Y, float Z)[,] value)
    {
        int columnCount = value.GetUpperBound(0);
        int rowCount = value.GetLength(0);
        
        var result = new Vector3[rowCount, columnCount];
        for (int i = 0; i < rowCount; i++)
        {
            for (int j = 0; j < columnCount; j++)
            {
                var tuple = ((float X, float Y, float Z))value.GetValue(i, j);
                result[i, j] = tuple.ToVector3();
            }
        }
        
        return result;
    }
    
    public static Vector3 ToVector3(this (float X, float Y, float Z) value)
    {
        return new Vector3(value.X, value.Y, value.Z);
    }
}

alors vous pouvez le construire comme ceci ...

var list  = new (float X, float Y, float Z)[2, 2]
{
    {(-1.32f, 0f, 1.32f), (-1.32f, 0f, 1.32f)},
    {(-1.32f, 0f, 1.32f), (-1.32f, 0f, 1.32f)}
};

Vector3[,] coordsList = list.ToVector3();

Vector3[][] list = new (float x, float y)[][]
{
    new[] { (1.5f, 3.4f), (1.5f, 6.8f) },
    new[] { (1.5f, 3.4f), (1.5f, 6.8f) },
    new[] { (1.5f, 3.4f), (1.5f, 6.8f) },
    new[] { (1.5f, 3.4f), (1.5f, 6.8f) },
}.Select(r => r.Select(v => new Vector3(v.x, v.y)).ToArray()).ToArray();
You could use Value Tuples (now supported in the latest version of Unity 2018.3) to construct your data in a readable and less tedious way - then you can use Select to transform these into Vector3s.I think most of the comments adequately cover your questions about the hows and whys of the new keyword here.

La raison pour laquelle Vector3 nécessite le mot clé new est qu'un Vector3 est une structure intégrée à Unity, donc chaque fois que vous utilisez le nouveau mot-clé, vous créez une nouvelle instance d'une structure Vector3 , alors qu'avec une string ou un int , ces types de données de base proviennent de C #.

J'espère que cela aidera à expliquer la différence!

Vos coordonnées sont une grille en miroir XY, ce qui signifie que vous n'avez qu'environ 6 valeurs uniques. Cependant, pour faciliter les choses, nous garderons également une trace des négatifs.

Vector3[,] coordsList = new Vector3[11,11];

void Init() { 

    for ( int x = 0; x < coordsList.GetLength(0); x++) {
        for ( int y = 0; y < coordsList.GetLength(1); y++ ) {
            coordsList[x, y] = new Vector3(-values[x], values[y]);
        }
    }
}

Maintenant, utilisez une boucle for imbriquée pour remplir votre tableau de coords:

float[] values = new float[] { 
    1.32f,  1.08f,  0.84f,  0.6f,  0.36f,  0.12f, 
   -0.12f, -0.36f, -0.6f, -0.84f, -1.08f, -1.32f };

Si vous souhaitez conserver des coordonnées disparates (c'est-à-dire non mappées sur une grille), il existe d'autres moyens de former les données d'entrée, mais la conversion en Vector3 ne se fera pas changer beaucoup du tout.