blocks|key|1698859|text|如果将枚举的基定义为long，则可以执行显式转换。我不知道是否可以使用隐式转换，因为枚举不能在其上定义方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1698860|public+enum+MyEnum+:+long
{
++++one+=+1,
++++two+=+2,
}

MyEnum+number+=+MyEnum.one;
long+i+=+(long)number;|code-block|syntax|javascript|1698861|此外，请注意，未初始化的枚举将默认为0值，即第一项-因此，在上面的情况下，最好也定义zero+=+0。|offset|length|style|CODE|1698862|entityMap^0|0|0|16|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you define the base of the enum as a long then you can perform explicit conversion. I don't know if you can use implicit conversions as enums cannot have methods defined on them.

<pre><code>public enum MyEnum : long
{
 one = 1,
 two = 2,
}

MyEnum number = MyEnum.one;
long i = (long)number;
</code></pre>

Also, be aware with this that an uninitalised enumeration will default to the 0 value, or the first item - so in the situation above it would probably be best to define <code>zero = 0</code> as well.

blocks|key|1698902|text|您不能在枚举类型上声明隐式转换，因为它们不能定义方法。C#+implicit关键字被编译成以'op_‘开头的方法，它在这种情况下不起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1698903|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/z5z9kes2(VS.80).aspx^0|U|8|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You cannot declare implicit conversions on enum types, because they can't define methods. The C# <a href="http://msdn.microsoft.com/en-us/library/z5z9kes2(VS.80).aspx" rel="noreferrer">implicit</a> keyword compiles into a method starting with 'op_', and it wouldn't work in this case.

blocks|key|1698938|text|您可能可以，但不是用于枚举(您不能向其添加方法)。您可以将隐式转换添加到您自己的类，以允许将枚举转换为它，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1698939|public+class+MyClass+{

++++public+static+implicit+operator+MyClass+(+MyEnum+input+)+{
++++++++//...
++++}
}

MyClass+m+=+MyEnum.One;|code-block|syntax|javascript|1698940|问题是为什么？|1698941|一般而言，.Net避免(您也应该避免)任何可能丢失数据的隐式转换。|1698942|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You probably could, but not for the enum (you can't add a method to it). You could add an implicit conversion to you own class to allow an enum to be converted to it, 

<pre><code>public class MyClass {

 public static implicit operator MyClass ( MyEnum input ) {
 //...
 }
}

MyClass m = MyEnum.One;
</code></pre>

The question would be why?

In general .Net avoids (and you should too) any implicit conversion where data can be lost.

blocks|key|1698983|text|为枚举类型引入隐式转换会破坏类型安全，所以我不建议这样做。你为什么要这么做呢？我见过的唯一的用例是，当您想要将枚举值放入具有预定义布局的结构中时。但即使这样，您也可以在结构中使用枚举类型，只需告诉Marshaller他应该如何处理它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1698984|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Introducing implicit conversions for enum types would break type safety, so I'd not recommend to do that. Why would you want to do that? The only use case for this I've seen is when you want to put the enum values into a structure with a pre-defined layout. But even then, you can use the enum type in the structure and just tell the Marshaller what he should do with this.

blocks|key|1699048|text|你不能做隐式转换(除了零)，你也不能写你自己的实例方法--但是，你可以写你自己的扩展方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699049|public+enum+MyEnum+{+A,+B,+C+}
public+static+class+MyEnumExt
{
++++public+static+int+Value(this+MyEnum+foo)+{+return+(int)foo;+}
++++static+void+Main()
++++{
++++++++MyEnum+val+=+MyEnum.A;
++++++++int+i+=+val.Value();
++++}
}|code-block|syntax|javascript|1699050|不过，这并不能给你带来很多好处(与仅仅进行显式类型转换相比)。|1699051|我见过的人们想要它的主要原因之一是通过泛型--即bool+IsFlagSet<T>(T+value,+T+flag);方法--来进行[Flags]操作。不幸的是，C#+3.0不支持泛型上的运算符，但您可以使用things+like+this来解决这个问题，这使得运算符在泛型中完全可用。|offset|length|style|CODE|1699052|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pobox.com/~skeet/csharp/miscutil/usage/genericoperators.html^0|0|0|0|O|Z|1U|7|2W|G|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]|$K|12|L|13|M|N]]|9|@$K|14|L|15|1|16]]|A|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

You can't do implict conversions (except for zero), and you can't write your own instance methods - however, you can probably write your own extension methods:

<pre><code>public enum MyEnum { A, B, C }
public static class MyEnumExt
{
 public static int Value(this MyEnum foo) { return (int)foo; }
 static void Main()
 {
 MyEnum val = MyEnum.A;
 int i = val.Value();
 }
}
</code></pre>

This doesn't give you a lot, though (compared to just doing an explicit cast).

One of the main times I've seen people want this is for doing <code>[Flags]</code> manipulation via generics - i.e. a <code>bool IsFlagSet&lt;T&gt;(T value, T flag);</code> method. Unfortunately, C# 3.0 doesn't support operators on generics, but you can get around this using <a href="http://www.pobox.com/~skeet/csharp/miscutil/usage/genericoperators.html" rel="noreferrer">things like this</a>, which make operators fully available with generics.

blocks|key|1699123|text|有一个解决方案。请考虑以下几点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699124|public+sealed+class+AccountStatus
{
++++public+static+readonly+AccountStatus+Open+=+new+AccountStatus(1);
++++public+static+readonly+AccountStatus+Closed+=+new+AccountStatus(2);

++++public+static+readonly+SortedList<byte,+AccountStatus>+Values+=+new+SortedList<byte,+AccountStatus>();
++++private+readonly+byte+Value;

++++private+AccountStatus(byte+value)
++++{
++++++++this.Value+=+value;
++++++++Values.Add(value,+this);
++++}


++++public+static+implicit+operator+AccountStatus(byte+value)
++++{
++++++++return+Values[value];
++++}

++++public+static+implicit+operator+byte(AccountStatus+value)
++++{
++++++++return+value.Value;
++++}
}|code-block|syntax|javascript|1699125|上面提供了隐式转换：|1699126|++++++++AccountStatus+openedAccount+=+1;++++++++++++//+Works
++++++++byte+openedValue+=+AccountStatus.Open;++++++//+Works|1699127|与声明一个普通的枚举相比，这是一项相当多的工作(尽管您可以将上面的一些内容重构为一个通用的通用基类)。您可以更进一步，让基类实现IComparable+&+IEquatable，以及添加方法以返回DescriptionAttributes的值、声明的名称等。|1699128|我编写了一个基类(RichEnum<>)来处理大部分繁重的工作，它将上面的枚举声明简化为：|1699129|public+sealed+class+AccountStatus+:+RichEnum<byte,+AccountStatus>
{
++++public+static+readonly+AccountStatus+Open+=+new+AccountStatus(1);
++++public+static+readonly+AccountStatus+Closed+=+new+AccountStatus(2);

++++private+AccountStatus(byte+value)+:+base+(value)
++++{
++++}

++++public+static+implicit+operator+AccountStatus(byte+value)
++++{
++++++++return+Convert(value);
++++}
}|1699130|基类(RichEnum)如下所示。|1699131|using+System;
using+System.Collections.Generic;
using+System.ComponentModel;
using+System.Diagnostics;
using+System.Linq;
using+System.Reflection;
using+System.Resources;

namespace+Ethica
{
++++using+Reflection;
++++using+Text;

++++[DebuggerDisplay("{Value}+({Name})")]
++++public+abstract+class+RichEnum<TValue,+TDerived>
++++++++++++++++:+IEquatable<TDerived>,
++++++++++++++++++IComparable<TDerived>,
++++++++++++++++++IComparable,+IComparer<TDerived>
++++++++where+TValue+:+struct+,+IComparable<TValue>,+IEquatable<TValue>
++++++++where+TDerived+:+RichEnum<TValue,+TDerived>
++++{
++++++++#region+Backing+Fields

++++++++///+<summary>
++++++++///+The+value+of+the+enum+item
++++++++///+</summary>
++++++++public+readonly+TValue+Value;

++++++++///+<summary>
++++++++///+The+public+field+name,+determined+from+reflection
++++++++///+</summary>
++++++++private+string+_name;

++++++++///+<summary>
++++++++///+The+DescriptionAttribute,+if+any,+linked+to+the+declaring+field
++++++++///+</summary>
++++++++private+DescriptionAttribute+_descriptionAttribute;

++++++++///+<summary>
++++++++///+Reverse+lookup+to+convert+values+back+to+local+instances
++++++++///+</summary>
++++++++private+static+SortedList<TValue,+TDerived>+_values;

++++++++private+static+bool+_isInitialized;


++++++++#endregion

++++++++#region+Constructors

++++++++protected+RichEnum(TValue+value)
++++++++{
++++++++++++if+(_values+==+null)
++++++++++++++++_values+=+new+SortedList<TValue,+TDerived>();
++++++++++++this.Value+=+value;
++++++++++++_values.Add(value,+(TDerived)this);
++++++++}

++++++++#endregion

++++++++#region+Properties

++++++++public+string+Name
++++++++{
++++++++++++get
++++++++++++{
++++++++++++++++CheckInitialized();
++++++++++++++++return+_name;
++++++++++++}
++++++++}

++++++++public+string+Description
++++++++{
++++++++++++get
++++++++++++{
++++++++++++++++CheckInitialized();

++++++++++++++++if+(_descriptionAttribute+!=+null)
++++++++++++++++++++return+_descriptionAttribute.Description;

++++++++++++++++return+_name;
++++++++++++}
++++++++}

++++++++#endregion

++++++++#region+Initialization

++++++++private+static+void+CheckInitialized()
++++++++{
++++++++++++if+(!_isInitialized)
++++++++++++{
++++++++++++++++ResourceManager+_resources+=+new+ResourceManager(typeof(TDerived).Name,+typeof(TDerived).Assembly);

++++++++++++++++var+fields+=+typeof(TDerived)
++++++++++++++++++++++++++++++++.GetFields(BindingFlags.Static+%7C+BindingFlags.GetField+%7C+BindingFlags.Public)
++++++++++++++++++++++++++++++++.Where(t+=>+t.FieldType+==+typeof(TDerived));

++++++++++++++++foreach+(var+field+in+fields)
++++++++++++++++{

++++++++++++++++++++TDerived+instance+=+(TDerived)field.GetValue(null);
++++++++++++++++++++instance._name+=+field.Name;
++++++++++++++++++++instance._descriptionAttribute+=+field.GetAttribute<DescriptionAttribute>();

++++++++++++++++++++var+displayName+=+field.Name.ToPhrase();
++++++++++++++++}
++++++++++++++++_isInitialized+=+true;
++++++++++++}
++++++++}

++++++++#endregion

++++++++#region+Conversion+and+Equality

++++++++public+static+TDerived+Convert(TValue+value)
++++++++{
++++++++++++return+_values[value];
++++++++}

++++++++public+static+bool+TryConvert(TValue+value,+out+TDerived+result)
++++++++{
++++++++++++return+_values.TryGetValue(value,+out+result);
++++++++}

++++++++public+static+implicit+operator+TValue(RichEnum<TValue,+TDerived>+value)
++++++++{
++++++++++++return+value.Value;
++++++++}

++++++++public+static+implicit+operator+RichEnum<TValue,+TDerived>(TValue+value)
++++++++{
++++++++++++return+_values[value];
++++++++}

++++++++public+static+implicit+operator+TDerived(RichEnum<TValue,+TDerived>+value)
++++++++{
++++++++++++return+value;
++++++++}

++++++++public+override+string+ToString()
++++++++{
++++++++++++return+_name;
++++++++}

++++++++#endregion

++++++++#region+IEquatable<TDerived>+Members

++++++++public+override+bool+Equals(object+obj)
++++++++{
++++++++++++if+(obj+!=+null)
++++++++++++{
++++++++++++++++if+(obj+is+TValue)
++++++++++++++++++++return+Value.Equals((TValue)obj);

++++++++++++++++if+(obj+is+TDerived)
++++++++++++++++++++return+Value.Equals(((TDerived)obj).Value);
++++++++++++}
++++++++++++return+false;
++++++++}

++++++++bool+IEquatable<TDerived>.Equals(TDerived+other)
++++++++{
++++++++++++return+Value.Equals(other.Value);
++++++++}


++++++++public+override+int+GetHashCode()
++++++++{
++++++++++++return+Value.GetHashCode();
++++++++}

++++++++#endregion

++++++++#region+IComparable+Members

++++++++int+IComparable<TDerived>.CompareTo(TDerived+other)
++++++++{
++++++++++++return+Value.CompareTo(other.Value);
++++++++}

++++++++int+IComparable.CompareTo(object+obj)
++++++++{
++++++++++++if+(obj+!=+null)
++++++++++++{
++++++++++++++++if+(obj+is+TValue)
++++++++++++++++++++return+Value.CompareTo((TValue)obj);

++++++++++++++++if+(obj+is+TDerived)
++++++++++++++++++++return+Value.CompareTo(((TDerived)obj).Value);
++++++++++++}
++++++++++++return+-1;
++++++++}

++++++++int+IComparer<TDerived>.Compare(TDerived+x,+TDerived+y)
++++++++{
++++++++++++return+(x+==+null)+?+-1+:
+++++++++++++++++++(y+==+null)+?+1+:
++++++++++++++++++++x.Value.CompareTo(y.Value);
++++++++}

++++++++#endregion

++++++++public+static+IEnumerable<TDerived>+Values
++++++++{
++++++++++++get
++++++++++++{
++++++++++++++++return+_values.Values;
++++++++++++}
++++++++}

++++++++public+static+TDerived+Parse(string+name)
++++++++{
++++++++++++foreach+(TDerived+value+in+_values.Values)
++++++++++++++++if+(0+==+string.Compare(value.Name,+name,+true)+%7C%7C+0+==+string.Compare(value.DisplayName,+name,+true))
++++++++++++++++++++return+value;

++++++++++++return+null;
++++++++}
++++}
}|1699132|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

There is a solution. Consider the following:

<pre><code>public sealed class AccountStatus
{
 public static readonly AccountStatus Open = new AccountStatus(1);
 public static readonly AccountStatus Closed = new AccountStatus(2);

 public static readonly SortedList&lt;byte, AccountStatus&gt; Values = new SortedList&lt;byte, AccountStatus&gt;();
 private readonly byte Value;

 private AccountStatus(byte value)
 {
 this.Value = value;
 Values.Add(value, this);
 }


 public static implicit operator AccountStatus(byte value)
 {
 return Values[value];
 }

 public static implicit operator byte(AccountStatus value)
 {
 return value.Value;
 }
}
</code></pre>

The above offers implicit conversion:

<pre><code> AccountStatus openedAccount = 1; // Works
 byte openedValue = AccountStatus.Open; // Works
</code></pre>

This is a fair bit more work than declaring a normal enum (though you can refactor some of the above into a common generic base class). You can go even further by having the base class implement IComparable &amp; IEquatable, as well as adding methods to return the value of DescriptionAttributes, declared names, etc, etc.

I wrote a base class (RichEnum&lt;>) to handle most fo the grunt work, which eases the above declaration of enums down to:

<pre><code>public sealed class AccountStatus : RichEnum&lt;byte, AccountStatus&gt;
{
 public static readonly AccountStatus Open = new AccountStatus(1);
 public static readonly AccountStatus Closed = new AccountStatus(2);

 private AccountStatus(byte value) : base (value)
 {
 }

 public static implicit operator AccountStatus(byte value)
 {
 return Convert(value);
 }
}
</code></pre>

The base class (RichEnum) is listed below.

<pre><code>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Resources;

namespace Ethica
{
 using Reflection;
 using Text;

 [DebuggerDisplay("{Value} ({Name})")]
 public abstract class RichEnum&lt;TValue, TDerived&gt;
 : IEquatable&lt;TDerived&gt;,
 IComparable&lt;TDerived&gt;,
 IComparable, IComparer&lt;TDerived&gt;
 where TValue : struct , IComparable&lt;TValue&gt;, IEquatable&lt;TValue&gt;
 where TDerived : RichEnum&lt;TValue, TDerived&gt;
 {
 #region Backing Fields

 /// &lt;summary&gt;
 /// The value of the enum item
 /// &lt;/summary&gt;
 public readonly TValue Value;

 /// &lt;summary&gt;
 /// The public field name, determined from reflection
 /// &lt;/summary&gt;
 private string _name;

 /// &lt;summary&gt;
 /// The DescriptionAttribute, if any, linked to the declaring field
 /// &lt;/summary&gt;
 private DescriptionAttribute _descriptionAttribute;

 /// &lt;summary&gt;
 /// Reverse lookup to convert values back to local instances
 /// &lt;/summary&gt;
 private static SortedList&lt;TValue, TDerived&gt; _values;

 private static bool _isInitialized;


 #endregion

 #region Constructors

 protected RichEnum(TValue value)
 {
 if (_values == null)
 _values = new SortedList&lt;TValue, TDerived&gt;();
 this.Value = value;
 _values.Add(value, (TDerived)this);
 }

 #endregion

 #region Properties

 public string Name
 {
 get
 {
 CheckInitialized();
 return _name;
 }
 }

 public string Description
 {
 get
 {
 CheckInitialized();

 if (_descriptionAttribute != null)
 return _descriptionAttribute.Description;

 return _name;
 }
 }

 #endregion

 #region Initialization

 private static void CheckInitialized()
 {
 if (!_isInitialized)
 {
 ResourceManager _resources = new ResourceManager(typeof(TDerived).Name, typeof(TDerived).Assembly);

 var fields = typeof(TDerived)
 .GetFields(BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public)
 .Where(t =&gt; t.FieldType == typeof(TDerived));

 foreach (var field in fields)
 {

 TDerived instance = (TDerived)field.GetValue(null);
 instance._name = field.Name;
 instance._descriptionAttribute = field.GetAttribute&lt;DescriptionAttribute&gt;();

 var displayName = field.Name.ToPhrase();
 }
 _isInitialized = true;
 }
 }

 #endregion

 #region Conversion and Equality

 public static TDerived Convert(TValue value)
 {
 return _values[value];
 }

 public static bool TryConvert(TValue value, out TDerived result)
 {
 return _values.TryGetValue(value, out result);
 }

 public static implicit operator TValue(RichEnum&lt;TValue, TDerived&gt; value)
 {
 return value.Value;
 }

 public static implicit operator RichEnum&lt;TValue, TDerived&gt;(TValue value)
 {
 return _values[value];
 }

 public static implicit operator TDerived(RichEnum&lt;TValue, TDerived&gt; value)
 {
 return value;
 }

 public override string ToString()
 {
 return _name;
 }

 #endregion

 #region IEquatable&lt;TDerived&gt; Members

 public override bool Equals(object obj)
 {
 if (obj != null)
 {
 if (obj is TValue)
 return Value.Equals((TValue)obj);

 if (obj is TDerived)
 return Value.Equals(((TDerived)obj).Value);
 }
 return false;
 }

 bool IEquatable&lt;TDerived&gt;.Equals(TDerived other)
 {
 return Value.Equals(other.Value);
 }


 public override int GetHashCode()
 {
 return Value.GetHashCode();
 }

 #endregion

 #region IComparable Members

 int IComparable&lt;TDerived&gt;.CompareTo(TDerived other)
 {
 return Value.CompareTo(other.Value);
 }

 int IComparable.CompareTo(object obj)
 {
 if (obj != null)
 {
 if (obj is TValue)
 return Value.CompareTo((TValue)obj);

 if (obj is TDerived)
 return Value.CompareTo(((TDerived)obj).Value);
 }
 return -1;
 }

 int IComparer&lt;TDerived&gt;.Compare(TDerived x, TDerived y)
 {
 return (x == null) ? -1 :
 (y == null) ? 1 :
 x.Value.CompareTo(y.Value);
 }

 #endregion

 public static IEnumerable&lt;TDerived&gt; Values
 {
 get
 {
 return _values.Values;
 }
 }

 public static TDerived Parse(string name)
 {
 foreach (TDerived value in _values.Values)
 if (0 == string.Compare(value.Name, name, true) || 0 == string.Compare(value.DisplayName, name, true))
 return value;

 return null;
 }
 }
}
</code></pre>

blocks|key|1483983|text|struct+PseudoEnum
{
++++public+const+int+
++++++++++++++INPT+=+0,
++++++++++++++CTXT+=+1,
++++++++++++++OUTP+=+2;
};

//+...

var+arr+=+new+String[3];

arr[PseudoEnum.CTXT]+=+"can";
arr[PseudoEnum.INPT]+=+"use";
arr[PseudoEnum.CTXT]+=+"as";
arr[PseudoEnum.CTXT]+=+"array";
arr[PseudoEnum.OUTP]+=+"index";|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1483984|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>struct PseudoEnum
{
 public const int 
 INPT = 0,
 CTXT = 1,
 OUTP = 2;
};

// ...

var arr = new String[3];

arr[PseudoEnum.CTXT] = "can";
arr[PseudoEnum.INPT] = "use";
arr[PseudoEnum.CTXT] = "as";
arr[PseudoEnum.CTXT] = "array";
arr[PseudoEnum.OUTP] = "index";
</code></pre>

blocks|key|1484045|text|我从这里找到了更简单的解决方案，https://codereview.stackexchange.com/questions/7566/enum-vs-int-wrapper-struct我从那个链接粘贴了下面的代码，以防将来它不能工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1484046|struct+Day
{
++++readonly+int+day;

++++public+static+readonly+Day+Monday+=+0;
++++public+static+readonly+Day+Tuesday+=+1;
++++public+static+readonly+Day+Wednesday+=+2;
++++public+static+readonly+Day+Thursday+=+3;
++++public+static+readonly+Day+Friday+=+4;
++++public+static+readonly+Day+Saturday+=+5;
++++public+static+readonly+Day+Sunday+=+6;

++++private+Day(int+day)
++++{
++++++++this.day+=+day;
++++}

++++public+static+implicit+operator+int(Day+value)
++++{
++++++++return+value.day;
++++}

++++public+static+implicit+operator+Day(int+value)
++++{
++++++++return+new+Day(value);
++++}
}|code-block|syntax|javascript|1484047|entityMap|0|LINK|mutability|MUTABLE|url|https://codereview.stackexchange.com/questions/7566/enum-vs-int-wrapper-struct^0|G|26|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I found even easier solution taken from here <a href="https://codereview.stackexchange.com/questions/7566/enum-vs-int-wrapper-struct">https://codereview.stackexchange.com/questions/7566/enum-vs-int-wrapper-struct</a> I pasted the code below from that link just in case it does not work in the future.

<pre><code>struct Day
{
 readonly int day;

 public static readonly Day Monday = 0;
 public static readonly Day Tuesday = 1;
 public static readonly Day Wednesday = 2;
 public static readonly Day Thursday = 3;
 public static readonly Day Friday = 4;
 public static readonly Day Saturday = 5;
 public static readonly Day Sunday = 6;

 private Day(int day)
 {
 this.day = day;
 }

 public static implicit operator int(Day value)
 {
 return value.day;
 }

 public static implicit operator Day(int value)
 {
 return new Day(value);
 }
}
</code></pre>

blocks|key|1699209|text|正因为如此，枚举对我来说基本上是无用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699210|我最后一直在做与图片相关的事情：|1699211|the+simple+solution|offset|length|1699212|经典的示例问题是用于检测按键的VirtualKey集。|1699213|enum+VKeys+:+ushort
{
a+=+1,
b+=+2,
c+=+3
}
//+the+goal+is+to+index+the+array+using+predefined+constants
int[]+array+=+new+int[500];
var+x+=+array[VKeys.VK_LSHIFT];+|code-block|syntax|javascript|1699214|这里的问题是你不能用枚举来索引数组，因为它不能隐式地将枚举转换成ushort+(即使我们是基于ushort的枚举)|1699215|在这个特定的上下文中，枚举被以下数据结构所取代。。。。|1699216|public+static+class+VKeys
{
public+const+ushort
a+=+1,
b+=+2,+
c+=+3;
}|1699217|entityMap|0|LINK|mutability|MUTABLE|url|https://i.stack.imgur.com/CTOcU.png^0|0|0|0|J|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@$F|15|G|16|1|17]]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|1C|8|@]|9|@]|A|$M|N]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

enums are largely useless for me because of this, OP.

I end up doing pic-related all the time:

<a href="https://i.stack.imgur.com/CTOcU.png" rel="nofollow noreferrer">the simple solution</a>

classic example problem is the VirtualKey set for detecting keypresses. 

<pre><code>enum VKeys : ushort
{
a = 1,
b = 2,
c = 3
}
// the goal is to index the array using predefined constants
int[] array = new int[500];
var x = array[VKeys.VK_LSHIFT]; 
</code></pre>

problem here is you can't index the array with the enum because it can't implicitly convert enum to ushort (even though we even based the enum on ushort)

in this specific context, enums are obsoleted by the following datastructure
. . . .

<pre><code>public static class VKeys
{
public const ushort
a = 1,
b = 2, 
c = 3;
}
</code></pre>

blocks|key|1484170|text|@BatteryBackupUnit嘿，这听起来像是一个很酷的解决方案，但你能在这里解释一下这部分吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1484171|不幸的是，我在.NET+4.7.2中得到了一个"InvalidCastException“：|1484172|+_name+=+new+Lazy<string>(
++++++++++++++++()+=>+EnumInstanceToNameMapping
+++++++++++++++++++++.First(x+=>+ReferenceEquals(this,+x.Instance))
+++++++++++++++++++++.Name);|code-block|syntax|javascript|1484173|我不知道为什么，我已经创建了一个RichEnum的派生类型，并像你在示例中所做的那样进行了初始化，但我得到了这个年度异常。|1484174|我会很高兴得到一些帮助，因为我很喜欢这种方法。|1484175|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

@BatteryBackupUnit
Hey this sounds like a cool solution but could you explain this part here?
Since im getting with .NET 4.7.2 an &quot;InvalidCastException&quot; out of this sadly :/
<pre><code> _name = new Lazy&lt;string&gt;(
 () =&gt; EnumInstanceToNameMapping
 .First(x =&gt; ReferenceEquals(this, x.Instance))
 .Name);
</code></pre>
I dont know why, i have created a derived type of the RichEnum and initialized as everything u did in the example but i getthis annyoingg exception..
Would be glad of some help to this since i like this approach alot tbh.

blocks|key|1484211|text|这是一种基于adminSoftDK's+answer的不同风格。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1484212|///+<summary>
///+Based+on+https://datatracker.ietf.org/doc/html/rfc4346#appendix-A.1
///+</summary>
[DebuggerDisplay("{_value}")]
public+struct+HandshakeContentType
{
++++#region+Types
++++public+const+byte+ChangeCipher+=+0x14;
++++public+const+byte+Alert+=+0x15;
++++public+const+byte+Handshake+=+0x16;
++++public+const+byte+ApplicationData+=+0x17;
++++#endregion

++++byte+_value;
++++private+HandshakeContentType(byte+value)
++++{
++++++++_value+=+value;

++++++++switch+(_value)
++++++++{
++++++++++++case+ChangeCipher:
++++++++++++case+Alert:
++++++++++++case+Handshake:
++++++++++++case+ApplicationData:
++++++++++++++++break;

++++++++++++default:
++++++++++++++++throw+new+InvalidOperationException($"An+invalid+handshake+content+type+(${value})+was+provided.");
++++++++}
++++}

++++#region+Methods
++++public+static+implicit+operator+byte(HandshakeContentType+type)+=>+type._value;
++++public+static+implicit+operator+HandshakeContentType(byte+b)+=>+new+HandshakeContentType(b);
++++#endregion
}|code-block|syntax|javascript|1484213|这允许您在switch语句中使用此struct，我认为这非常棒。|style|CODE|1484214|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/39141171/8058709^0|6|K|0|0|0|5|6|H|6|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]|$A|12|B|13|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here's a different flavour based on <a href="https://stackoverflow.com/a/39141171/8058709">adminSoftDK's answer</a>.
<pre><code>/// &lt;summary&gt;
/// Based on https://datatracker.ietf.org/doc/html/rfc4346#appendix-A.1
/// &lt;/summary&gt;
[DebuggerDisplay(&quot;{_value}&quot;)]
public struct HandshakeContentType
{
 #region Types
 public const byte ChangeCipher = 0x14;
 public const byte Alert = 0x15;
 public const byte Handshake = 0x16;
 public const byte ApplicationData = 0x17;
 #endregion

 byte _value;
 private HandshakeContentType(byte value)
 {
 _value = value;

 switch (_value)
 {
 case ChangeCipher:
 case Alert:
 case Handshake:
 case ApplicationData:
 break;

 default:
 throw new InvalidOperationException($&quot;An invalid handshake content type (${value}) was provided.&quot;);
 }
 }

 #region Methods
 public static implicit operator byte(HandshakeContentType type) =&gt; type._value;
 public static implicit operator HandshakeContentType(byte b) =&gt; new HandshakeContentType(b);
 #endregion
}
</code></pre>
This allows you to use this <code>struct</code> with <code>switch</code> statements which I think is pretty awesome.

Is it possible to define an implicit conversion of enums in c#?

something that could achieve this?

<pre><code>public enum MyEnum
{
 one = 1, two = 2
}

MyEnum number = MyEnum.one;
long i = number;
</code></pre>

If not, why not?

Can we define implicit conversions of enums in c#?

数据结构

是否可以在c#中定义枚举的隐式转换？能做到这一点的东西吗？public enum MyEnum{    one = 1, two = 2}MyEnum number = MyEnum.one;long i = number;若否，原因为何？

问我们可以在c#中定义枚举的隐式转换吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我们可以在c#中定义枚举的隐式转换吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我们可以在c#中定义枚举的隐式转换吗？
EN