Явное приведение универсального типа к другому типу в C#

Я думаю, что лучшее, что вы можете получить, это:

public class Point<T>
{
    public T X { get; set; }
    public T Y { get; set; }
    public T Z { get; set; }

    public Point<U> As<U>()
    {
        return new Point<U>()
        {
            X = Convert<U>(X),
            Y = Convert<U>(Y),
            Z = Convert<U>(Z)
        };
    }

    static U Convert<U>(T t) => (U)System.Convert.ChangeType(t, typeof(U));
}

Вы не можете определить общий оператор преобразования, поэтому вам нужна явная функция. Более того, простое приведение (U)t не сработает, поэтому вам нужно Convert.ChangeType (что сработает, если ваши типы числовые).

Применение:

var p1 = new Point<int> { X = 1, Y = 2, Z = 3 };
var p2 = p1.As<double>();

(работает, как ожидалось).

Насколько мне известно, такое универсальное приведение разрешено в C# только в том случае, если между T и U существует какое-то отношение наследования.

Ближайшим эквивалентом было бы определение универсального метода для преобразования:

public Point<U> To<U>()
{
    dynamic p = this;

    return new Point<U>((U)p.X, (U)p.Y, (U)p.Z);
}

Вы не можете напрямую преобразовать T в U, так как компилятор не может знать, будет ли это безопасно. Я использую ключевое слово dynamic, чтобы обойти это ограничение.

Подобно ответу Кевина, но без dynamic нужно использовать двойное приведение:

public Point<U> To<U>()
{
    return new Point<U>((U)(object)X, (U)(object)Y, (U)(object)Z);
}

Оба наших ответа не обнаруживают никаких проблем во время компиляции.

Вы не можете объявить операторы с дополнительными аргументами универсального типа, но вы можете объявить их для или из определенных универсальных типов, таких как Point<int>. C# также не позволит вам выполнять произвольные преобразования путем приведения от или к T.

Наименее шаблонным вариантом, который поддерживает хоть какую-то безопасность типов, будет ограничение параметра T значением IConvertible:

public class Point<T> where T : IConvertible
{
    // ...

    public static explicit operator Point<int>(Point<T> point)
    {
        // The IFormatProvider parameter has no effect on purely numeric conversions
        return new Point<int>(point.X.ToInt32(null), point.Y.ToInt32(null), point.Y.ToInt32(null));
    }    
}

Однако это не помешает пользователям объявлять бессмысленные, неподдерживаемые типы, такие как Point<DateTime>, которые затем будут выбрасываться во время выполнения при попытке преобразования.

Вы не можете определить дополнительные ограничения универсального типа, но вы можете сделать что-то подобное, используя операторы и методы.

public class Point<T>
{
    public T X { get; set; }
    public T Y { get; set; }
    public T Z { get; set; }

    public static explicit operator Point<T>(Point<int> v)
    {
        return v.As<T>();
    }

    public static explicit operator Point<T>(Point<double> v)
    {
        return v.As<T>();
    }

    public static explicit operator Point<T>(Point<float> v)
    {
        return v.As<T>();
    }

    public Point<TU> As<TU>()
    {
        return new Point<TU>()
        {
            X = ConvertTo<TU>(X),
            Y = ConvertTo<TU>(Y),
            Z = ConvertTo<TU>(Z)
        };
    }

    private static TU ConvertTo<TU>(T t)
    {
        return (TU) Convert.ChangeType(t, typeof(TU));
    }
}

Применение:

        Point<double> d = new Point<double>()
        {
            X = 10d, Y = 10d, Z = 10d
        };

        Point<int> i = (Point<int>) d;

        Point<float> f = (Point<float>) i;

        d = (Point<double>) f;