Type Extension for Implicit Assignability Checking

[dotnetcadet]

Like typeof(T).IsAssignableTo(Type type) and typeof(T).IsAssignableFrom(Type type), I was wondering if there would be any issues of adding the following extensions to the runtime?

Example

void Main()
{
	typeof(SomeValue)
		.IsImplicitlyAssignableFrom(typeof(Guid))
		.Dump();
}


public static class TypeExtensions
{
	public static bool IsImplicitlyAssignableTo(this Type source, Type target)
	{
		var impliedConverstion = source.GetMethods(BindingFlags.Public | BindingFlags.Static)
			.Where(p=>p.Name == "op_Implicit" && p.ReturnType == target);

		return source.IsAssignableFrom(target) || impliedConverstion.Any();
	}
	public static bool IsImplicitlyAssignableFrom(this Type target, Type source)
	{
		var impliedConverstion = source.GetMethods(BindingFlags.Public | BindingFlags.Static)
			.Where(p => p.Name == "op_Implicit" && p.ReturnType == target);

		return source.IsAssignableFrom(target) || impliedConverstion.Any();
	}
}

public readonly struct SomeValue :
	IEquatable<SomeValue>,
	IEqualityComparer<SomeValue>
{
	public SomeValue(Guid value)
	{
		Value = value;
	}

	public Guid Value { get; }
	
	public override string ToString()
	{
		return Value.ToString();
	}
	public override bool Equals(object? instance)
	{
		if (instance is SomeValue value)
		{
			return Equals(value);
		}
		return false;
	}
	public override int GetHashCode()
	{
		return HashCode.Combine(typeof(SomeValue), Value);
	}
	public bool Equals(SomeValue other)
	{
		return Value.Equals(other.Value);
	}
	public bool Equals(SomeValue left, SomeValue right)
	{
		return left.Equals(right);
	}
	public int GetHashCode(SomeValue instance)
	{
		return instance.GetHashCode();
	}

	public static implicit operator SomeValue(Guid value) => new SomeValue(value);
	public static implicit operator Guid(SomeValue value) => value.Value;
}

[huoyaoyuan]

Implicit conversion is a concept of high level language (C#/VB/F#). There's no "implicit assignability" via conversion operator in IL/reflection. The operator need to be invoked explicitly.

[dotnetcadet]

@huoyaoyuan,

Ah, I see what you're saying. So regardless of whether it's implicit or explicit the compiler is generating method calls to be invoked for the conversion as shown in the first picture below?

However, what about the last picture? Granted you'll get an InvalidCastException, does the IL castclass not check for assignability?

[huoyaoyuan]

So regardless of whether it's implicit or explicit the compiler is generating method calls to be invoked for the conversion as shown in the first picture below?

Yes. The call can be inlined in native assembly though.

However, what about the last picture?

castclass is the instruction that does the assignability check and throws InvalidCastException.