.net 如何确定C#中是否存在隐式强制转换？

qq24tv8q 于 2023-02-20 发布在 .NET

关注(0)|答案(4)|浏览(108)

我有两个类型，T和U，我想知道是否从T到U定义了隐式强制转换操作符。
我知道IsAssignableFrom的存在，但这不是我要找的，因为它不处理隐式强制转换。
我在谷歌上搜索了一下，找到了this solution，但用作者自己的话说，这是一段丑陋的代码（它试图隐式地强制转换，如果有异常，则返回false，否则返回true ......）
它似乎在测试是否存在具有正确签名won't work for primitive types的op_Implicit方法。
有没有更干净的方法来确定隐式强制转换运算符的存在？

.net

来源：https://stackoverflow.com/questions/32025201/how-can-i-determine-if-an-implicit-cast-exists-in-c

4条答案

按热度按时间

fnatzsnv1#

可以使用反射来查找目标类型的隐式转换方法：

public static bool HasImplicitConversion(Type baseType, Type targetType)
{
    return baseType.GetMethods(BindingFlags.Public | BindingFlags.Static)
        .Where(mi => mi.Name == "op_Implicit" && mi.ReturnType == targetType)
        .Any(mi => {
            ParameterInfo pi = mi.GetParameters().FirstOrDefault();
            return pi != null && pi.ParameterType == baseType;
        });
}

您可以像这样使用它：

class X {}
class Y
{
    public static implicit operator X (Y y)
    {
        return new X();
    }

    public static implicit operator Y (X x)
    {
        return new Y();
    }
}

// and then:
bool conversionExists = HasImplicitConversion(typeof(Y), typeof(X));

注意，这只检查基类型（第一个传递的类型）上的隐式类型转换。从技术上讲，类型转换也可以定义在另一个类型上，所以您可能需要用相反的类型再次调用它（或将其构建到方法中）。隐式类型转换可能不存在于两个类型上。

赞(0）回复(0）举报 2023-02-20

8ftvxx2r2#

我最终手动处理了原始类型场景。不是很优雅，但它很有效。
我还添加了额外的逻辑来处理可空类型和枚举。
我在用户定义类型场景中重用了Poke's code。

public class AvailableCastChecker
{
    public static bool CanCast(Type from, Type to)
    {
        if (from.IsAssignableFrom(to))
        {
            return true;
        }
        if (HasImplicitConversion(from, from, to)|| HasImplicitConversion(to, from, to))
        {
            return true;
        }
        List<Type> list;
        if (ImplicitNumericConversions.TryGetValue(from, out list))
        {
            if (list.Contains(to))
                return true;
        }

        if (to.IsEnum)
        {
            return CanCast(from, Enum.GetUnderlyingType(to));
        }
        if (Nullable.GetUnderlyingType(to) != null)
        {
            return CanCast(from, Nullable.GetUnderlyingType(to));
        }

        return false;
    }

    // https://msdn.microsoft.com/en-us/library/y5b434w4.aspx
    static Dictionary<Type,List<Type>> ImplicitNumericConversions = new Dictionary<Type, List<Type>>();

    static AvailableCastChecker()
    {
        ImplicitNumericConversions.Add(typeof(sbyte), new List<Type> {typeof(short), typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(byte), new List<Type> { typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(short), new List<Type> {  typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(ushort), new List<Type> { typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(int), new List<Type> { typeof(long), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(uint), new List<Type> { typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(long), new List<Type> { typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(char), new List<Type> { typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) });
        ImplicitNumericConversions.Add(typeof(float), new List<Type> { typeof(double) });
        ImplicitNumericConversions.Add(typeof(ulong), new List<Type> { typeof(float), typeof(double), typeof(decimal) });
    }

    static bool HasImplicitConversion(Type definedOn, Type baseType, Type targetType)
    {
        return definedOn.GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Where(mi => mi.Name == "op_Implicit" && mi.ReturnType == targetType)
            .Any(mi =>
            {
                ParameterInfo pi = mi.GetParameters().FirstOrDefault();
                return pi != null && pi.ParameterType == baseType;
            });

    }
}

赞(0）回复(0）举报 2023-02-20

syqv5f0l3#

Here's是我找到的一个解决方案。主要代码如下所示（经过一些简单的翻译）：

public static bool IsImplicitFrom(this Type type, Type fromType) {
    if (type == null || fromType == null) {
        return false;
    }

    // support for reference type
    if (type.IsByRef) { type = type.GetElementType(); }
    if (fromType.IsByRef) { fromType = type.GetElementType(); }

    // could always be convert to object
    if (type.Equals(typeof(object))) {
        return true;
    }

    // check if it could be convert using standard implicit cast
    if (IsStandardImplicitFrom(type, fromType)) {
        return true;
    }

    // determine implicit convert operator
    Type nonNullalbeType, nonNullableFromType;
    if (IsNullableType(type, out nonNullalbeType) && 
        IsNullableType(fromType, out nonNullableFromType)) {
        type = nonNullalbeType;
        fromType = nonNullableFromType;
    }

    return ConversionCache.GetImplicitConversion(fromType, type) != null;
}

internal static bool IsStandardImplicitFrom(this Type type, Type fromType) {
    // support for Nullable<T>
    if (!type.IsValueType || IsNullableType(ref type)) {
        fromType = GetNonNullableType(fromType);
    }

    // determine implicit value type convert
    HashSet<TypeCode> typeSet;
    if (!type.IsEnum && 
        ImplicitNumericConversions.TryGetValue(Type.GetTypeCode(type), out typeSet)) {
        if (!fromType.IsEnum && typeSet.Contains(Type.GetTypeCode(fromType))) {
            return true;
        }
    }

    // determine implicit reference type convert and boxing convert
    return type.IsAssignableFrom(fromType);
}

更新：Here's整个文件。

赞(0）回复(0）举报 2023-02-20

zpgglvta4#

虽然Brann's solution适用于许多情况，但它没有考虑对非基元类型的隐式强制转换的级联影响。
例如：将一个float赋值给一个Thickness（它有一个从double隐式转换而来的）应该返回true。我重写了代码来处理类似的情况。

public static class AvailableCastChecker
{
    public static bool CanCast(Type from, Type to)
    {
        if (to.IsAssignableFrom(from))
        {
            return true;
        }
        if (HasImplicitConversion(from, from, to) || HasImplicitConversion(to, from, to))
        {
            return true;
        }
        if (ImplicitNumericConversions.TryGetValue(to, out var list) &&
            (list.Contains(from) || list.Any(t => CanCast(from, t))))
        {
            return true;
        }
        if (to.IsEnum)
        {
            return CanCast(from, Enum.GetUnderlyingType(to));
        }
        return Nullable.GetUnderlyingType(to) != null && CanCast(from, Nullable.GetUnderlyingType(to));
    }

    // https://msdn.microsoft.com/en-us/library/y5b434w4.aspx
    private static Dictionary<Type, List<Type>> _implicitNumericConversions;
    private static Dictionary<Type, List<Type>> ImplicitNumericConversions => _implicitNumericConversions ?? (_implicitNumericConversions = new Dictionary<Type, List<Type>>()
    {
        {typeof(short), new List<Type> { typeof(sbyte), typeof(byte) }},
        {typeof(ushort), new List<Type> { typeof(byte), typeof(char) }},
        {typeof(int), new List<Type> { typeof(sbyte), typeof(byte), typeof(char), typeof(short), typeof(ushort) }},
        {typeof(uint), new List<Type> { typeof(byte), typeof(char), typeof(ushort) }},
        {typeof(long), new List<Type> {  typeof(sbyte), typeof(byte), typeof(char), typeof(short), typeof(ushort), typeof(int), typeof(uint) }},
        {typeof(ulong), new List<Type> { typeof(byte), typeof(char), typeof(ushort), typeof(uint) }},
        {typeof(float), new List<Type> { typeof(sbyte), typeof(byte), typeof(char), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong) }},
        {typeof(double), new List<Type> { typeof(sbyte), typeof(byte), typeof(char), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float) }}
    });

    private static bool HasImplicitPrimitiveConversion(Type from, Type to)
    {
        return ImplicitNumericConversions.TryGetValue(to, out var list) && list.Contains(from);
    }

    private static bool HasImplicitConversion(Type definedOn, Type from, Type to)
    {
        return definedOn.GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Where(mi => mi.Name == "op_Implicit"
                         && (mi.ReturnType == to || HasImplicitPrimitiveConversion(from, to)))
            .Any(mi =>
            {
                var pi = mi.GetParameters().FirstOrDefault();
                return pi != null && (pi.ParameterType == from || HasImplicitPrimitiveConversion(from, pi.ParameterType));
            });
    }
}

赞(0）回复(0）举报 2023-02-20

我来回答

.net 如何确定C#中是否存在隐式强制转换？

4条答案

相关问题

热门标签

最新问答