C# 如何确定在没有IConvertible的情况下是否可以将对象强制转换为其他类型

我有两个不相关的类：一个不是从另一个派生的。 这些类不实现IConvertible。这就是为什么它不起作用

幸运的是，从一个类到另一个类有一个隐式类运算符

例：考虑 -System.Data.Entity.DbSet -System.Data.Entity.DbSet

隐式强制转换运算符：

public static implicit operator DbSet (DbSet<TEntity> entry)

公共静态隐式运算符DbSet（DbSet条目）

以下工作：

DbSet<MyClass> x = new DbSet<MyClass>();
DbSet y = (DbSet) x;         // ok, x properly cast to y

DbSet x=new DbSet（）；
DbSet y=（DbSet）x；//好的，x正确地投射到y

以下操作不起作用：

object x = new DbSet<MyClass>();
object y1 = x as DbSet;      // y1 is null, because not derived from DbSet
object y2 = (DbSet) x;       // throws InvalidCastException

objectx=newdbset（）；
对象y1=x作为DbSet；//y1为空，因为它不是从DbSet派生的
对象y2=（DbSet）x；//抛出InvalidCastException

---

因此，是否可以检查一个对象是否可以在不引发异常的情况下投射到另一个对象？

您应该能够使用反射搜索转换方法：

object set = new DbSet<MyClass>();
var conv = set.GetType().GetMethod("op_Implicit", BindingFlags.Static | BindingFlags.Public, null, new[] { set.GetType() }, null);
if (conv != null && conv.ReturnType == typeof(DbSet))
{
    var rawSet = (DbSet)conv.Invoke(null, new object[] { set });
}

objectset=newdbset（）；
var conv=set.GetType（）.GetMethod（“op_Implicit”，BindingFlags.Static | BindingFlags.Public，null，new[]{set.GetType（）}，null）；
if（conv！=null&&conv.ReturnType==typeof（DbSet））
{
var rawSet=（DbSet）conv.Invoke（null，新对象[]{set}）；
}

您应该能够使用反射搜索转换方法：

object set = new DbSet<MyClass>();
var conv = set.GetType().GetMethod("op_Implicit", BindingFlags.Static | BindingFlags.Public, null, new[] { set.GetType() }, null);
if (conv != null && conv.ReturnType == typeof(DbSet))
{
    var rawSet = (DbSet)conv.Invoke(null, new object[] { set });
}

objectset=newdbset（）；
var conv=set.GetType（）.GetMethod（“op_Implicit”，BindingFlags.Static | BindingFlags.Public，null，new[]{set.GetType（）}，null）；
if（conv！=null&&conv.ReturnType==typeof（DbSet））
{
var rawSet=（DbSet）conv.Invoke（null，新对象[]{set}）；
}
李给出了答案。我通过创建一个扩展方法来测试它，该方法尝试将任何对象强制转换为任何类型，只要该对象对请求的类型具有隐式或显式强制转换运算符

public static class ObjectExtensionTryCast
{
    public static bool TryCast<T>(this object o, out T castedValue)
    {
        MethodInfo castMethod = new string[] { "op_Implicit", "op_Explicit" }
            .Select(methodName => o.GetType()
                .GetMethod(methodName, BindingFlags.Static | BindingFlags.Public, null, new[] { o.GetType() }, null))
            .Where(method => method.ReturnType == typeof(T))
            .FirstOrDefault();
        bool canCast = castMethod != null;
        castedValue = canCast ?
            (T)castMethod.Invoke(null, new object[] { o }) :
            default(T);
        return canCast;
    }
}

李给出了答案。我通过创建一个扩展方法来测试它，该方法尝试将任何对象强制转换为任何类型，只要该对象对请求的类型具有隐式或显式强制转换运算符

public static class ObjectExtensionTryCast
{
    public static bool TryCast<T>(this object o, out T castedValue)
    {
        MethodInfo castMethod = new string[] { "op_Implicit", "op_Explicit" }
            .Select(methodName => o.GetType()
                .GetMethod(methodName, BindingFlags.Static | BindingFlags.Public, null, new[] { o.GetType() }, null))
            .Where(method => method.ReturnType == typeof(T))
            .FirstOrDefault();
        bool canCast = castMethod != null;
        castedValue = canCast ?
            (T)castMethod.Invoke(null, new object[] { o }) :
            default(T);
        return canCast;
    }
}

这很有效。我不知道隐式和显式运算符都有预定义的名称。我现在要做的就是创建扩展函数object.TryCast。谢谢李！这很有效。我不知道隐式和显式运算符都有预定义的名称。我现在要做的就是创建扩展函数object.TryCast。谢谢李！