能否限定泛型参数必须是enum？泛型参数是enum时，怎么做枚举对象的==操作？

2013-09-26 09:04:30 894 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

条款10：优先选用限定作用域enum，而非不限定作用域enum 限定作用域enum的枚举值不会污染外围命名空间，减少与其他标识符冲突的风险。非限定作用域enum的枚举值可能与其他变量或枚举值重名，导致编译错误或逻辑混淆。在需要与C代码交互或必须隐式转换为整数的旧代码中，可能需保留非限定作用域enum。限定作用域enum支持前置声明（forward declaration），编译器可直接确定其底层类型（默认为。显式转换，避免意外的类型转换错误。非限定作用域enum会隐式转换为整数，可能引发未预期的行为。非限定作用域enum需看到定义才能确定底层类型，不利于模块化设计。阅读详情

下边的两种比较方式都会提示运算符“==”无法应用于“T”和“T”类型的操作数
加了where T:struct 或 where T:enum也不行（后一种语法就不对）
问题如题。。。



    enum MyEnum

    {

    }



    class MyClass<T> 

    {

        T value;



        public bool EqualTo(T obj)

        {

            return (T)value == (T)obj;  //error

            return value == obj;   //error

            //强制转换成int也不行，用object.Equals的结果又不是我想要的。。。

        }

    }

...全文

12【Java学习笔记】枚举类与泛型在Java语言中，使用关键字enum定义一个枚举类型。例：使用枚举类型来指定一周中的天数星期日，星期一，星期二，星期三，星期四，星期五，星期六在任何时候，如果需要代表一系列固定的常量，就应该使用枚举类型。在两种情况下，尽可能使用枚举类型：一种是自然的枚举类型，例如，表示太阳系中的行星或者员工的性别，这是一组固定的值，所以在程序中应该使用枚举类型来表示；另一种是程序在编译的时候，已经知道某个数据所有可能的值，也要尽可能的使用枚举类型。例如，在扑克牌游戏中,花色是固定的。阅读详情

phommy

C# 111,128 成员 642,536 内容

+ 关注 + 加入社区

切换为时间正序

threenewbee 2013-09-28

打赏
举报

好吧，ls有人提了。

threenewbee 2013-09-28

打赏
举报

引用 5 楼 phommy 的回复:

[quote=引用 4 楼 caozhy 的回复:] 你想做什么，比较引用是否相等，值是否相等，其中的某些字段相等，调用这个对象的==运算符，还是什么。

我想既然已经确定T是值类型，能不能就按值类型比较？进一步的，有没有办法告诉编译器我的T就是int枚举、就给我按数字（而不是一般的struct）进行比较？


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var m = new MyClass<MyEnum>(MyEnum.b);
            var s = m.EqualTo(MyEnum.b);
        }
    }

    enum MyEnum
    {
        a,
        b
    }

    class MyClass<T> where T : struct
    {
        T value;

        public MyClass(T value) { this.value = value; }

        public bool EqualTo(T obj)
        {
            //return (T)value == (T)obj; //编译错误
            //return value == obj; //编译错误
            //return (int)value == (int)obj;  //编译错误
            return obj.Equals(value); //结果对，但有装箱
        }
    }
}

[/quote] 你限定ICompareable就是了。 int double string等等都实现了它。

moonwrite 2013-09-27

打赏
举报

我是这样的~ class MyClass<T> where T : struct { //反射判断是否是枚举类型 Type t.IsEnum }

qldsrx 2013-09-27

打赏
举报

你如果是要避免装箱拆箱，可以使用这个方法： return Comparer<T>.Default.Compare(value, obj) == 0; 不过个人认为这里面装箱拆箱的性能损失是可以忽略的。最后吐槽下3楼，基础不够扎实，虽然枚举有个Enum类型是class，但是枚举值本身是值类型，非引用类型，因此限定struct。而事实上IL层面上对枚举值的转换处理也只有装箱拆箱动作，完全符合值类型的说法。

youzelin 2013-09-27

打赏
举报

直接上代码：


class MyClass<T> where T : struct
{
    public T Value { get; private set; }
    public MyClass(T value)
    {
        Value = value;
    }

    public bool EqualTo(T obj)
    {
        return obj.GetType().IsEnum ? Value.Equals(obj) : false;
    }
}
static void Main(string[] args)
{
    MyClass<StringComparison> myObj = new MyClass<StringComparison>(StringComparison.CurrentCulture);
    Console.WriteLine(myObj.EqualTo(StringComparison.CurrentCultureIgnoreCase));
    Console.ReadKey();
}

phommy 2013-09-27

打赏
举报

引用 4 楼 caozhy 的回复:

你想做什么，比较引用是否相等，值是否相等，其中的某些字段相等，调用这个对象的==运算符，还是什么。


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var m = new MyClass<MyEnum>(MyEnum.b);
            var s = m.EqualTo(MyEnum.b);
        }
    }

    enum MyEnum
    {
        a,
        b
    }

    class MyClass<T> where T : struct
    {
        T value;

        public MyClass(T value) { this.value = value; }

        public bool EqualTo(T obj)
        {
            //return (T)value == (T)obj; //编译错误
            //return value == obj; //编译错误
            //return (int)value == (int)obj;  //编译错误
            return obj.Equals(value); //结果对，但有装箱
        }
    }
}

黑色系菜鸟一枚 2013-09-27

打赏
举报

引用 7 楼 qldsrx 的回复:

你如果是要避免装箱拆箱，可以使用这个方法： return Comparer<T>.Default.Compare(value, obj) == 0; 不过个人认为这里面装箱拆箱的性能损失是可以忽略的。最后吐槽下3楼，基础不够扎实，虽然枚举有个Enum类型是class，但是枚举值本身是值类型，非引用类型，因此限定struct。而事实上IL层面上对枚举值的转换处理也只有装箱拆箱动作，完全符合值类型的说法。

原来如此，那我限定class还能传入枚举值是怎么回事…

phommy 2013-09-27

打赏
举报

引用 7 楼 qldsrx 的回复:

你如果是要避免装箱拆箱，可以使用这个方法： return Comparer<T>.Default.Compare(value, obj) == 0; 不过个人认为这里面装箱拆箱的性能损失是可以忽略的。最后吐槽下3楼，基础不够扎实，虽然枚举有个Enum类型是class，但是枚举值本身是值类型，非引用类型，因此限定struct。而事实上IL层面上对枚举值的转换处理也只有装箱拆箱动作，完全符合值类型的说法。

谢谢~ 我会写个代码测试两种方式的性能差别顺便我也吐槽下ms，为什么enum能默认实现IComparable，但不给默认实现IComparable<>。。。

threenewbee 2013-09-26

打赏
举报

你想做什么，比较引用是否相等，值是否相等，其中的某些字段相等，调用这个对象的==运算符，还是什么。

黑色系菜鸟一枚 2013-09-26

打赏
举报

两个T类型可以用做比较枚举是个引用类型，不是值类型，继承与Enum基类，所以要限制就限制到class 下面这段临时敲的代码毫无意义。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        public enum Myenum
        { 
           one,
           two,
            three,
        }
        static void Main(string[] args)
        {
            Person<Enum> p = new Person<Enum>();
            p.value = Myenum.one;
            Console.WriteLine(p.EqluasTo(Myenum.one));
            Console.ReadKey();
            
        }
    }
    public class Person<T>where T:class
    {
        public T value;
        public T Value { get { return this.value; } }

        public bool EqluasTo(T outher)
        {
            if (Value.ToString() == outher.ToString())
                return true;
            return false;
        }
      
    }
}

种草德鲁伊 2013-09-26

打赏
举报

还有就是先判断引用是否相同，再判断类型是否相同，再用Equals方法比较

种草德鲁伊 2013-09-26

打赏
举报

不能，最多限定struct

能否限定泛型参数必须是enum？泛型参数是enum时，怎么做枚举对象的==操作？

相关推荐