标签: generics

为什么将这两种方法放在同一个类中是不合法的？

class Test{
   void add(Set<Integer> ii){}
   void add(Set<String> ss){}
}

我明白了 compilation error

方法add(Set)具有与Test类型中的另一种方法相同的擦除add(Set).

虽然我可以解决它,但我想知道为什么javac不喜欢这个.

我可以看到,在许多情况下,这两种方法的逻辑非常相似,可以用一个方法代替

public void add(Set<?> set){}

方法,但情况并非总是如此.

如果你想要有两个constructors接受这些参数的话,这是非常烦人的,因为那时你不能只改变其中一个的名字constructors.

可能重复:
通用方法和多个约束

我需要一个具有两个类型约束的泛型函数,每个约束都继承自不同的基类.我知道如何使用一种类型:

void foo<T>() where T : BaseClass

但是,我不知道如何使用两种类型:

void foo<TOne, TTwo>() where TOne : BaseOne // and TTwo : BaseTwo ???

你怎么做到这一点？(使用.NET 2)

是否有一种常见的方法将单个类型的项传递给T需要IEnumerable<T>参数的方法 ？语言是C#,框架版本2.0.

目前我正在使用一个辅助方法(它是.Net 2.0,所以我有一大堆类似于LINQ的转换/投射辅助方法),但这看起来很愚蠢:

public static class IEnumerableExt
{
    // usage: IEnumerableExt.FromSingleItem(someObject);
    public static IEnumerable<T> FromSingleItem<T>(T item)
    {
        yield return item; 
    }
}

其他方式当然是创建和填充a List<T>或an Array而不是传递它IEnumerable<T>.

[编辑]作为扩展方法,它可能被命名为:

public static class IEnumerableExt
{
    // usage: someObject.SingleItemAsEnumerable();
    public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
    {
        yield return item; 
    }
}

我在这里错过了什么吗？

[Edit2]我们发现someObject.Yield()(正如@Peter在下面的评论中所建议的那样)是这个扩展方法的最佳名称,主要是为了简洁,所以如果有人想要抓住它的话,它会与XML注释一起:

public static class IEnumerableExt
{
    /// <summary>
    /// Wraps this object instance into an IEnumerable&lt;T&gt;
    /// consisting of a …

任何人都可以告诉我是否有一种方法可以使用泛型来限制泛型类型参数T:

• Int16
• Int32
• Int64
• UInt16
• UInt32
• UInt64

我知道的where关键字,但无法找到一个接口只有这些类型,

就像是:

static bool IntegerFunction<T>(T value) where T : INumeric 

根据MSDN中==运营商的文档,

对于预定义的值类型,如果操作数的值相等,则相等运算符(==)返回true,否则返回false.对于除string之外的引用类型,如果其两个操作数引用同一对象,则==返回true.对于字符串类型,==比较字符串的值.用户定义的值类型可以重载==运算符(请参阅运算符).用户定义的引用类型也是如此,尽管 默认情况下==的行为与上述预定义和用户定义的引用类型相同.

那么为什么这段代码片段无法编译呢？

bool Compare<T>(T x, T y) { return x == y; }

我得到错误运算符'=='不能应用于'T'和'T'类型的操作数.我想知道为什么,因为据我所知,==运算符是针对所有类型预定义的？

编辑:谢谢大家.起初我没有注意到该声明仅涉及引用类型.我还认为为所有值类型提供了逐位比较,我现在知道这是不正确的.

但是,如果我使用引用类型,==操作符是否会使用预定义的引用比较,或者如果类型定义了一个,它是否会使用运算符的重载版本？

编辑2:通过反复试验,我们了解到==操作员在使用不受限制的泛型类型时将使用预定义的参考比较.实际上,编译器将使用它可以为限制类型参数找到的最佳方法,但不会再看了.例如,true即使Test.test<B>(new B(), new B())被调用,下面的代码也会始终打印:

class A { public static bool operator==(A x, A y) { return true; } }
class B : A { public static bool operator==(B x, B y) { return false; } }
class Test { void test<T>(T a, T …

我有一个IEnumerable<T>方法,我用来在WebForms页面中找到控件.

该方法是递归的,当返回yield return递归调用的值时,我遇到一些问题,返回我想要的类型.

我的代码如下:

    public static IEnumerable<Control> 
                               GetDeepControlsByType<T>(this Control control)
    {
        foreach(Control c in control.Controls)
        {
            if (c is T)
            {
                yield return c;
            }

            if(c.Controls.Count > 0)
            {
                yield return c.GetDeepControlsByType<T>();
            }
        }
    }

这当前抛出"无法转换表达式类型"错误.但是IEnumerable<Object>,如果此方法返回类型,则代码构建,但输出中返回错误的类型.

有没有使用yield return同时也使用递归的方法？

我想知道Java中是否存在使用always" extends"而不是" implements"来定义类型参数边界的特殊原因.

例:

public interface C {}
public class A<B implements C>{} 

被禁止但是

public class A<B extends C>{} 

是正确的.这是什么原因？

我的项目中有一个派生类的泛型类.

public class GenericClass<T> : GenericInterface<T>
{
}

public class Test : GenericClass<SomeType>
{
}

有没有办法找出一个Type对象是否来自GenericClass？

t.IsSubclassOf(typeof(GenericClass<>))

不起作用.

能否请您解释where T : class, new()以下代码行中的含义？

void Add<T>(T item) where T : class, new();

我有一个像这样定义的泛型方法:

public void MyMethod<T>(T myArgument)

我想要做的第一件事是检查myArgument的值是否是该类型的默认值,如下所示:

if (myArgument == default(T))

但是这不能编译,因为我没有保证T将实现==运算符.所以我把代码改为:

if (myArgument.Equals(default(T)))

现在这个编译,但是如果myArgument为null则会失败,这是我正在测试的一部分.我可以像这样添加一个显式的空检查:

if (myArgument == null || myArgument.Equals(default(T)))

现在这让我感到多余.ReSharper甚至建议我将myArgument == null部分更改为myArgument == default(T),这是我开始的地方.有没有更好的方法来解决这个问题？

我需要支持两种引用类型和值类型.