无法理解什么是“Where T：”在 C# 中

发布于 2024-12-04 17:00:10 字数 263 浏览 0 评论 0原文

 public class TwitterResponse<T>
        where T : Core.ITwitterObject
    {
       // all properties and methods here
    }

有人可以简单地向我解释一下这是什么吗？这里的“where T:Core.ITwitterObject”部分是什么？在 Twitterizer 源代码中看到了这一点。有什么例子可以更好地理解这一点吗？

原文

 public class TwitterResponse<T>
        where T : Core.ITwitterObject
    {
       // all properties and methods here
    }

Can someone explain me what is this in simple terms ? what is "where T :Core.ITwitterObject " part here ? Have seen this in Twitterizer source code. Any examples to better understand this ?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

夏の忆 2024-12-11 17:00:10

这意味着 T 必须实现接口 Core.ITwitterObject。

如果将未实现此接口的类型 T 传递给泛型，则会发生编译时错误。

此条件允许编译器在 T 实例上调用在 Core.ITwitterObject 中声明的函数。

有关详细信息，请参阅文档。

示例：

interface IFoo { void Perform(); }

class FooList<T> where T : IFoo
{
    List<T> foos;
    ...
    void PerformForAll()
    {
        foreach (T foo in foos)
            foo.Perform(); // this line compiles because the compiler knows
                           // that T implements IFoo
    }
}

这比常规方法有一个优势

interface IFoo { void Perform(); }

class FooList
{
    List<IFoo> foos;
    ...
    void PerformForAll()
    {
        foreach (IFoo foo in foos)
            foo.Perform();
    }
    // added example method
    IFoo First { get { return foos[0]; } }
}

，因为像 First 这样的方法会更加类型安全，您不需要从 IFoo 向下转换为 SomeRandomFooImpl< /代码>。

This means that T must implement interface Core.ITwitterObject.

If you pass to the generic a type T not implementing this interface, a compile-time error occurs.

This condition allows the compiler to call the functions which are declared in Core.ITwitterObject on instances of T.

Look at the documentation for more information.

Example:

interface IFoo { void Perform(); }

class FooList<T> where T : IFoo
{
    List<T> foos;
    ...
    void PerformForAll()
    {
        foreach (T foo in foos)
            foo.Perform(); // this line compiles because the compiler knows
                           // that T implements IFoo
    }
}

This has an advantage over the customary

interface IFoo { void Perform(); }

class FooList
{
    List<IFoo> foos;
    ...
    void PerformForAll()
    {
        foreach (IFoo foo in foos)
            foo.Perform();
    }
    // added example method
    IFoo First { get { return foos[0]; } }
}

because the methods like First would be more type-safe, you won't need to downcast from IFoo to SomeRandomFooImpl.

回复收藏 0 原文