标签: generic-constraints

我正在构建一个扩展Enum.Parse概念的函数

• 允许在未找到枚举值的情况下解析默认值
• 不区分大小写

所以我写了以下内容:

public static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum
{
    if (string.IsNullOrEmpty(value)) return defaultValue;
    foreach (T item in Enum.GetValues(typeof(T)))
    {
        if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
    }
    return defaultValue;
}

我得到一个Error Constraint不能是特殊类System.Enum.

很公平,但是有一个解决方法允许Generic Enum,或者我将不得不模仿该Parse函数并将类型作为属性传递,这会迫使您的代码出现丑陋的拳击要求.

编辑以下所有建议都非常感谢,谢谢.

已经解决了(我已离开循环以保持不区分大小写 - 我在解析XML时使用它)

public static class EnumUtils
{
    public static T ParseEnum<T>(string value, T defaultValue) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("T must be an enumerated type");
        if (string.IsNullOrEmpty(value)) return …

在C#中,您可以对通用方法设置约束,例如:

public class A {

    public static void Method<T> (T a) where T : new() {
        //...do something...
    }

}

您指定的T应该具有不需要参数的构造函数.我想知道是否有办法添加一个约束,如" 存在一个带float[,]参数的构造函数？ "

以下代码无法编译:

public class A {

    public static void Method<T> (T a) where T : new(float[,] u) {
        //...do something...
    }

}

解决方法也有用吗？

在未能获得类似以下内容的编译之后:

public class Gen<T> where T : System.Array
{
}

有错误

约束不能是特殊的类`System.Array'

我开始疑惑,究竟什么是 "特殊班级"？

当人们System.Enum在泛型约束中指定时,人们似乎经常会遇到同样的错误.我得到了相同的结果System.Object,System.Delegate,System.MulticastDelegate和System.ValueType也.

还有更多吗？我在C#中找不到关于"特殊类"的任何信息.

此外,什么是如此特殊的,我们不能把它们作为一个泛型类型约束类？

物品类

public class Item
{
    public bool Check(int value) { ... }
}

具有泛型类型约束的基本抽象类

public abstract class ClassBase<TItem>
    where TItem : Item
{
    protected IList<TItem> items;

    public ClassBase(IEnumerable<TItem> items)
    {
        this.items = items.ToList();
    }    

    public abstract bool CheckAll(int value);
}

没有约束的继承类

public class MyClass<TItem> : ClassBase<TItem>
{
    public override bool CheckAll(int value)
    {
        bool result = true;
        foreach(TItem item in this.items)
        {
            if (!item.Check(value)) // this doesn't work
            {
                result = false;
                break;
            }
        }
        return result;
    }
}

我想知道为什么泛型类型约束不可继承？因为如果我的继承类继承自基类并传递其对基类具有约束的泛型类型,则它自动意味着继承类中的泛型类型应具有相同的约束而不显式定义它.不应该吗？ …

可能重复:可以为
Nullable类型作为通用参数？

我遇到了泛型类型约束非常奇怪的事情.我有一个这样的课:

public SomeClass<T> where T:class
{
}

但是,我发现我不能像我期望的那样使用可空类型:

new SomeClass<int?>();

我得到一个int?必须是引用类型的错误.Nullable真的只是一个带有语法糖的结构,使它看起来像一个引用类型吗？

看完这个问题问完全是"特级"是的,我剩下什么问题,为什么六班System.Object,System.Array,System.Delegate,System.Enum和System.ValueType被选择和硬编码的特殊班,防止它们被用来作为约束泛型类或方法.

很容易理解为什么System.Object在那里; 所有类都继承,System.Object因此不需要将其作为约束包含在内.我不清楚的是为什么其他人被选为这个特殊班级的一部分.

^{PS:特殊类在尝试将它们用作约束时引发编译错误CS0702.}

假设我们有一些像这样的测试接口/类:

abstract class Plant {
    public abstract String getName();
}

interface Eatable { }

class Apple extends Plant implements Eatable {
    @Override
    public String getName() {
        return "Apple";
    }
}

class Rose extends Plant {
    @Override
    public String getName() {
        return "Rose";
    }
}

interface Animal {
    <T extends Plant & Eatable> void eat(T plant);
}

您可以看到Animal.eat具有约束的通用方法.现在我的Human班级是这样的:

class Human implements Animal {
    @Override
    public void eat(Plant plant) {
    }
}

编译好.你可以看到Human.eat比限制较少Animal.eat,因为Eatable …

昨天,我向朋友们解释了C#的通用限制.在展示where T : CLASSNAME约束时,我掀起了这样的事情:

public class UnusableClass<T> where T : UnusableClass<T>
{
    public static int method(T input){
        return 0;
    }
}

并且看到它编译真的很惊讶.然而,经过一番思考之后,我认为从编译器的角度来看它是完全合法的 - UnusableClass<T>与其他任何可用于此约束的类一样多.

然而,这留下了几个问题:如何使用这个类？是否有可能

1. 实例化吗？
2. 继承吗？
3. 调用它的静态方法int method？

如果是的话,怎么样？

如果其中任何一种都可能,那么它的类型T是什么？

因此,定义了TypeScript中的索引签名:

字典

[key: string]: T

排列

[index: number]: T

这些可以包装成一些简单,可重用的类型:

type DictionaryIndex<T> = {
    [key: string]: T
}

type ArrayIndex<T> = {
    [index: number]: T
}

现在我想将它们包装成单一类型.我试过这个:

type Index<TKey extends string|number, TValue> = {
    [key: TKey]: TValue
}

由于以下错误,这不会编译:

索引签名参数必须是"string"或"number"类型.

这不可能吗？

到底是为了什么？

因为

foo(obj: Index<string, Bar>)
foo(obj: Index<string, Bar> & Fooable<string>)

看起来比

foo(obj: { [key: string]: Bar })
foo(obj: { [key: string]: Bar, canFoo: (foo: string) => Bar })

鉴于以下代码......

type Indexable<TKey, TValue> = { [index: TKey]: TValue }

这会产生以下错误:

索引签名参数类型必须是"字符串"或"数字".

有没有办法约束TKey为'字符串'或'数字'？