Cast generic type build-in helper method

[PetSerAl]

Does .NET have build-in helper method with semantic like this?

[return: NotNullIfNotNull(nameof(value))]
public static TTo? CastSame<TFrom, TTo>(TFrom? value)
	where TFrom : allows ref struct
	where TTo : allows ref struct
{
	if (typeof(TTo) != typeof(TFrom))
	{
		throw new InvalidCastException();
	}
	return Unsafe.As<TFrom?, TTo?>(ref value);
}

So you can use it in generic context like this:

public static TOut? DoSomething<TIn, TOut>(TIn? value)
	where TIn : allows ref struct
	where TOut : allows ref struct
{
	if (typeof(TOut) == typeof(TIn))
	{
		return CastSame<TIn, TOut>(CaseSame(value));
	}
	if (typeof(TIn) == typeof(Span<char>) && typeof(TOut) == typeof(string))
	{
		return CastSame<string, TOut>(CaseSpanString(CastSame<TIn, Span<char>>(value)));
	}
	return CaseGeneric<TIn, TOut>(value);
}
public static T CaseSame<T>(T value)
	where T: allows ref struct;
public static string CaseSpanString(Span<char> value);
public static TOut? CaseGeneric<TIn, TOut>(TIn? value)
	where TIn : allows ref struct
	where TOut : allows ref struct;

[teo-tsirpanis]

You can implement CastSame like this:

[return: NotNullIfNotNull(nameof(value))]
public static unsafe TTo? CastSame<TFrom, TTo>(TFrom? value)
	where TFrom : allows ref struct
	where TTo : allows ref struct
{
	if (typeof(TTo) != typeof(TFrom))
	{
		throw new InvalidCastException();
	}
#pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type
	return *(TTo*)&value;
#pragma warning restore CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type
}

[PetSerAl]

Not really looking for alternative implementation of CastSame, but something build-in that preferable would be JIT intrinsic, so that JIT understand that it is basically no-op.

[tannergooding]

For value types (including ref structs) you can use Unsafe.BitCast<TFrom, TTo>(TFrom) which doesn't require taking the address and validates that TFrom/TTo are the same size. You can use Unsafe.As<T>(object) for reference types.

Once you've done the typeof(TTo) == typeof(TFrom) check then you know they're compatible

[PetSerAl]

I am aware of Unsafe.BitCast<TFrom, TTo>(TFrom), and it work fine for non-nullable value types.
As for Unsafe.As<T>(object), my issue with it is that: it only works when type compile time constrained to be reference type. For example: I can not just replace CastSame<string, TOut> with Unsafe.As<TOut>, even if I check typeof(TOut) == typeof(string) beforehand. Other way around it aslo impossible to replace CastSame<TOut, string> with Unsafe.As<string>, as TOut with allows ref struct anti-constraint is not allowed to be casted to object.