Question

问题的简短版本 - 为什么我不能这样做？我只限于.NET 3.5。

T[] genericArray;

// Obviously T should be float!
genericArray = new T[3]{ 1.0f, 2.0f, 0.0f };

// Can't do this either, why the hell not
genericArray = new float[3]{ 1.0f, 2.0f, 0.0f };

更长的版本 -

我在这里使用Unity引擎，虽然这并不重要。是什么 - 我试图在其固定的Vector2（2个浮点数）和Vector3（3个浮点数）和我的通用Vector＆lt;＆gt;之间进行转换。类。我无法将类型直接转换为泛型数组。

using UnityEngine;

public struct Vector<T>
{
    private readonly T[] _axes;

    #region Constructors
    public Vector(int axisCount)
    {
        this._axes = new T[axisCount];
    }

    public Vector(T x, T y)
    {
        this._axes = new T[2] { x, y };
    }

    public Vector(T x, T y, T z)
    {
        this._axes = new T[3]{x, y, z};
    }

    public Vector(Vector2 vector2)
    {
        // This doesn't work
        this._axes = new T[2] { vector2.x, vector2.y };
    }

    public Vector(Vector3 vector3)
    {
        // Nor does this
        this._axes = new T[3] { vector3.x, vector3.y, vector3.z };
    }
    #endregion

    #region Properties
    public T this[int i]
    {
        get { return _axes[i]; }
        set { _axes[i] = value; }
    }

    public T X
    {
        get { return _axes[0];}
        set { _axes[0] = value; }
    }

    public T Y
    {
        get { return _axes[1]; }
        set { _axes[1] = value; }
    }

    public T Z
    {
        get
        {
            return this._axes.Length < 2 ? default(T) : _axes[2];
        }
        set
        {
            if (this._axes.Length < 2)
                return;

            _axes[2] = value;
        }
    }
    #endregion

    #region Type Converters
    public static explicit operator Vector<T>(Vector2 vector2)
    {
        Vector<T> vector = new Vector<T>(vector2);

        return vector;
    }

    public static explicit operator Vector<T>(Vector3 vector3)
    {
        Vector<T> vector = new Vector<T>(vector3);

        return vector;
    }
    #endregion
}

Answer 1

“Generic”表示“适用于任何类型”。

您的示例代码不是通用的，因为它仅在T为float时才有效。

虽然您无法将Vector2D转换为Vector＆lt; T＆amp; gt，但您当然可以将Vector2D转换为Vector＆lt; float＆gt;。向Vector2D添加Convert方法或提供一组扩展方法，如下所示：

public static class VectorExtensions
{
    public static Vector<float> ToGenericVector(this Vector2D vector)
    {
        return new Vector<float>(vector.X, vector.Y);
    }

    public static Vector2D ToVector2D(this Vector<float> vector)
    {
        return new Vector2D(vector.X, vector.Y);
    }
}

用法：

Vector<float> v = new Vector<float>(3, 5);

Vector2D v2 = v.ToVector2D();

Answer 2

如果T被定义为float，则Vector<T>为Vector<float>，那么这将有效（在受限制的T上），但如果您只想进行本地转换：

var genericArray = new float[3]{ 1.0f, 2.0f, 0.0f };

当然，这会将T限制为浮点数（编译器无法将任何内容转换为T并且知道这一点），看起来你应该在整个类中用float替换T，如果是这样的话，是吗？处理非浮动向量？

在这种情况下，您需要以下内容：

var genericArray = new T[3]{ X, Y, Z };

Answer 3

您不能在方法中暗示泛型参数的类型。

而且，正如我之前所说，您发布的代码并不代表Generic类型参数的有效用法。

泛型参数将在类或方法签名中定义。

public class Class1<T>
{
    public T[] Method(params T[] args)
    {
        return args;
    }
}

public class Demo
{
    public Demo()
    {
        var c1 = new Class1<float>();
        float[] result = c1.Method(1.1f, 2.2f);
    }
}

Answer 4

你说：

// This doesn't work
this._axes = new T[2] { vector2.x, vector2.y };

以下工作（因为所有内容都可以转换为object，并允许从object到T的后续转换，但如果类型不兼容，可能会在运行时失败，或者在这种情况下，如果无法进行拆箱）：

this._axes = new T[2] { (T)(object)vector2.x, (T)(object)vector2.y };

也就是说，使类通用是完全没有意义的。

将Type类型转换为Generic数组？

4 个答案: