2

我有一个具有通用类型“G”的类

在我的班级模型中，我有

public class DetailElement : ElementDefinition

假设我有这样的方法

        public void DoSomething<G>(G generic)
            where G : ElementDefinition
        {
            if (generic is DetailElement)
            {
                ((DetailElement)generic).DescEN = "Hello people"; //line 1
                //////
                ElementDefinition element = generic;
                ((DetailElement)element).DescEN = "Hello again"; //line 3
                //////
                (generic as DetailElement).DescEN = "Howdy"; //line 5
            }
            else
            {
                //do other stuff
            }
        }

编译器在第 1 行报告一个错误：

Cannot convert type 'G' to 'DetailElement'

但是第 3 行工作正常。我可以通过执行第 5 行中编写的代码来解决这个问题。

我想知道的是为什么编译器会在第 1 行报告错误，而不是在第 3 行报告错误，因为据我所知，它们是相同的。

编辑：恐怕我可能会遗漏一些重要的框架逻辑

edit2：虽然编译器错误的解决方案很重要，但我的问题是为什么编译器在第 1 行而不是在第 3 行报告错误。

4

4 回答 4

7

如果G被限制为DetailElement( where G : DetailElement)，那么您可以继续G转换为 ElementDefinition，即“ (ElementDefinition) generic”。但是因为G可能是运行时ElementDefinition以外DetailElement的另一个子类，所以它不允许在类型未知且无法验证的编译时使用它。

在第 3 行中，您从中转换的类型已知为 an ElementDefinition，因此您所做的只是 up-cast。编译器不知道它是否会在运行时成功转换，但它会在那里信任你。编译器对泛型不太信任。

第as5 行中的运算符也可能返回 null 并且编译器不会静态检查类型以查看它在这种情况下是否安全。您可以使用as任何类型，而不仅仅是与ElementDefinition.

从我可以转换到泛型类型参数和从泛型类型参数转换吗？在 MSDN 上：

编译器只允许您将泛型类型参数隐式转换为对象或约束指定的类型。

这种隐式转换当然是类型安全的，因为在编译时会发现任何不兼容性。

编译器将允许您将泛型类型参数显式转换为任何接口，但不能转换为类：

   interface ISomeInterface {...}
   class SomeClass {...}
   class MyClass<T> 
    {
      void SomeMethod(T t)
       {
         ISomeInterface obj1 = (ISomeInterface)t;//Compiles
         SomeClass      obj2 = (SomeClass)t;     //Does not compile
       }
    }

但是，您可以使用临时对象变量强制将泛型类型参数强制转换为任何其他类型

 void SomeMethod<T>(T t) 
  { object temp = t;
    MyOtherClass obj = (MyOtherClass)temp;  
  }

不用说，这种显式转换是危险的，因为如果使用的具体类型而不是泛型类型参数不是从您显式转换为的类型派生的，它可能会在运行时引发异常。

is一个更好的方法是使用or运算符，而不是冒着抛出异常的风险as。如果is泛型类型参数是查询类型，则运算符返回 true，as如果类型兼容，则执行强制转换，否则返回 null。

public void SomeMethod(T t)
 {
   if(t is int) {...}

   string str = t as string;
   if(str != null) {...}
 }
于 2008-10-08T17:43:16.527 回答
1

您的 where 子句不应该是“where G : DetailElement”吗？

在您编写的代码中，DetailElement 是 ElementDefinition，但 ElementDefinition 不一定是 DetailElement。所以隐式转换是非法的。

您是否可以将其他类型的 ElementDefinition 传递给此方法？如果是这样，当您尝试将它们转换为 DetailElement 实例时，它们将引发异常。

编辑：

好的，既然您已经更改了代码清单，我可以看到您正在检查类型以确保在输入该代码块之前它确实是一个 DetailElement。不幸的是，事实是你不能隐式地向下转型，即使你已经自己检查了类型。我认为您真的应该在块的开头使用“as”关键字：

DetailElement detail = generic as DetailElement;
if (detail == null) {
   // process other types of ElementDefinition
} else {
   // process DetailElement objects
}

更好的是，为什么不使用多态性让每种 ElementDefinition 定义自己的 DoSomething 方法，让 CLR 为您处理类型检查和方法调用？

于 2008-10-08T17:42:38.010 回答
1

通常，向上转换是一种代码味道。您可以通过方法重载来避免它。试试这个：

public void DoSomething(DetailElement detailElement)
{
    // do DetailElement specific stuff
}

public void DoSomething<G>(G elementDefinition)
    where G : ElementDefinition
{
    // do generic ElementDefinition stuff
}

然后，您可以使用以下代码来利用方法重载：

DetailElement foo = new DetailElement();

DoSomething(foo); // calls the non-generic method
DoSomething((ElementDefinition) foo); // calls the generic method
于 2008-10-08T19:13:26.220 回答
0

如果您有很多担心的 ElementDefinitions，这将导致更多的代码，但可能是您将得到的不涉及的最巧妙的代码，那就是胡说八道。

    public void DoSomething<G>(G generic)
        where G : ElementDefinition
    {
        DetailElement detail = generic as DetailElement;
        if (detail != null)
        {
            detail.DescEN = "Hello people";
        }
        else
        {
            //do other stuff
        }
    }

当我需要此类信息时，我在临时对象变量中使用了另一种可能的解决方案。

DetailElement detail = (DetailElement)(object)generic;

它有效，但 as 形式可能是最好的。

于 2008-10-08T18:37:55.510 回答