blocks|key|3274043|text|我不会说“浪费”(一个额外的文件要花多少钱？)，但它通常是不合常规的。通常有一个类与枚举关联最紧密，我将它们放在同一个文件中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3274044|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|$]]

I wouldn't say "wasteful" (how much does an extra file cost?), but it is often inconventient. Usually there's one class that's most closely associtated with the enum, and I put them in the same file.

blocks|key|316801|text|这实际上只是一个偏好的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316802|我更喜欢将每个枚举放在它自己的文件中(对每个接口、类和结构也是如此，无论它们有多小)。当我来自另一个解决方案，或者没有对相关类型的引用时，可以更容易地找到它们。|316803|在每个文件中放入一个类型还可以更容易地识别源代码控制系统中的更改，而不会有差异。|316804|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This is really just a matter of preference.

I prefer to put each enumeration in its own file (likewise for each interface, class, and struct, no matter how small). It makes them easier to find when I'm coming from another solution or otherwise don't already have a reference to the type in question.

Putting a single type in each file also makes it easier to identify changes in source control systems without diffing.

blocks|key|315972|text|要问自己的问题是:+C#中的枚举类型是否表明我应该将它与我创建的所有其他类型区别对待？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|315973|如果枚举是公共的，则应将其视为任何其他公共类型。如果它是私有的，则将其声明为使用它的类的嵌套成员。没有令人信服的理由将两个公共类型放在同一个文件中，仅仅因为其中一个是枚举。它是一个公共类型的事实才是最重要的；类型的风格并不重要。|315974|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The question to ask yourself would be: is there anything about an enumeration type in C# that indicates I should treat it differently from all other types I create?

If the enumeration is public, it should be treated like any other public type. If it is private, declare it as a nested member of the class using it. There is no compelling reason to put two public types in the same file simply because one is an enumeration. The fact that it is a public type is all that matters; the flavor of type does not.

blocks|key|315990|text|将每种类型(类、结构、枚举)放入其自己的文件中的另一个优点是源代码控制。您可以轻松获取该类型的整个历史记录。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|315991|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|$]]

Another advantage of putting each type (class, struct, enum) in its own file is source control. You can easily get the entire history of the type.

blocks|key|316883|text|我主要放在命名空间的内部和类的外部，这样就可以很容易地访问该命名空间中的其他类，如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316884|namespace+UserManagement
{
++++public+enum+UserStatus+{+Active,+InActive+}
++++class+User
++++{
++++++++...
++++}
}|code-block|syntax|javascript|316885|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I place mostly inside in namespace and outside of class so that it is easily accessible other classes in that namespace like below.

<pre><code>namespace UserManagement
{
 public enum UserStatus { Active, InActive }
 class User
 {
 ...
 }
}
</code></pre>

blocks|key|3060821|text|一般来说，我更喜欢我的枚举与类在同一个文件中，因为它很可能是类的一个属性。例如，如果我有一个类Task，那么枚举TaskStatus将在同一个文件中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3060822|但是，如果我有更通用的枚举，那么我会将它们保存在不同的文件中。|3060823|entityMap^0|1B|4|1K|A|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Generally I prefer my enums to be in the same file as the Class that it will most probably be an attribute of. If for example I have a class <code>Task</code> then the enum <code>TaskStatus</code> will be in the same file.

However, if I have enums of a more generic nature, then I keep them contextually in various files.

blocks|key|313904|text|这取决于需要什么样的访问权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313905|如果枚举仅由单个类使用，则可以在该类中声明它，因为您不需要在其他任何地方使用它。|313906|对于由多个类使用的枚举或在公共API中使用的枚举，我将始终将定义保存在其自己的文件中的适当名称空间中。找到这种方法要容易得多，而且该策略遵循每个文件一个对象的模式，这种模式也很适合与类和接口一起使用。|313907|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It depends on what access is needed.

If the enum is only used by a single class, it's okay to declare it within that class because you don't need to use it anywhere else.

For enums used by multiple classes or in a public API, then I will always keep the definition in its own file in the appropriate namespace. It's far easier to find that way, and the strategy follows the pattern of one-object-per-file, which is good to use with classes and interfaces as well.

blocks|key|318812|text|我认为这取决于枚举的范围。例如，如果枚举特定于一个类，例如用于避免魔术常量场景，那么我会说将它放在与类相同的文件中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|318813|enum+SearchType+{+Forward,+Reverse+}|code-block|syntax|javascript|318814|如果枚举是通用的，并且可以由几个类用于不同的场景，那么我倾向于将它放在自己的文件中。例如，以下代码可用于多种用途：|318815|enum+Result+{+Success,+Error+}|318816|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think that depends on the scope of the enum. For example if the enum is specific to one class, for example used to avoid the magic constant scenario, then I would say put it in the same file as the class:

<pre><code>enum SearchType { Forward, Reverse }
</code></pre>

If the enum is general and can be used by several classes for different scenarios, then I would be inclined to use put it in its own file. For example the below could be used for several purposes:

<pre><code>enum Result { Success, Error }
</code></pre>

blocks|key|3274121|text|我倾向于将枚举放在它们自己的文件中，原因很简单:与类和结构一样，如果您想要找到类型的定义，那么知道的确切位置是很好的:在相同名称的文件中。(公平地说，在VS中也可以使用"Go+to+Definition“。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3274122|显然，它可能会失控。我工作的一位同事甚至为代表制作了单独的文件。|3274123|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I tend to put enums in their own file for a very simple reason: as with classes and structs, it's nice to know exactly where to look if you want to find a type's definition: in the file of the same name. (To be fair, in VS you can always use "Go to Definition," too.)

Obviously, it can get out of hand. A colleague where I work even makes separate files for delegates.

blocks|key|313890|text|对枚举使用单独文件的一个好处是，您可以删除使用枚举的原始类，并使用枚举编写一个新类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313891|如果枚举独立于原始类，则将其放在单独的文件中会使将来的更改更容易。|313892|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

One advantage of using a separate file for enums is that you can delete the original class that used the enum and write a new class using the enum.

If the enum is independent of the original class then putting it in a separate file makes future changes easier.

blocks|key|3060992|text|如果您使用的是Visual+Studio的USysWare文件浏览器外接程序，则可以在解决方案中非常快速地找到具有特定名称的文件。想象一下，在一个巨大的解决方案中，寻找一个不在自己的文件中的枚举，而是隐藏在某个文件中的枚举。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3060993|对于小的解决方案，这并不重要，但对于大的解决方案，将类和枚举保存在自己的文件中就变得更加重要。您可以快速找到它们，编辑它们，等等。我强烈地，强烈地建议把你的枚举放在它自己的文件里。|3060994|如前所述..。一个最终只有几kb大小的文件有多浪费？|3060995|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If you are using the USysWare File Browser add-in for Visual Studio, you can very quickly find files of particular names in your solution. Imagine looking for an enum that is not in its own file but instead buried in some file in a gigantic solution.

For small solutions, it doesn't matter, but for large ones, it becomes all the more important to keep classes and enums in their own files. You can quickly find them, edit them, and more. I highly, highly recommend putting your enum in its own file.

And as was stated... How wasteful is a file that ends up only being a couple of kb anyways?

blocks|key|3061012|text|如果您在一个解决方案中有多个项目。那么最好创建另一个项目Utilities。然后创建一个文件夹\Enumerations并创建一个嵌套的static+class。然后分配每个静态类，您将在其中创建与项目名称相对应的枚举。例如，您有一个名为DatabaseReader和DatabaseUsers的项目，那么您可以将该静态类命名为|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3061013|public+static+class+EnumUtility+{
++++#region+--Database+Readers+Enum
++++public+static+class+EnumDBReader+{
+++++++++public+enum+Actions+{+Create,+Retrieve,+Update,+Delete};+
++++}
++++#endregion

++++#region+--Database+Users+Enum
++++public+static+class+EnumDBUsers+{
+++++++++public+enum+UserIdentity+{+user,+admin+};+
++++}
++++#endregion

}|code-block|syntax|javascript|3061014|然后，可以在每个项目的整个解决方案中使用的整个枚举将在其上声明。使用#region将每个关注点分开。这样，查找任何枚举就更容易了。|3061015|entityMap^0|S|9|1B|D|1W|C|0|0|Z|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

If you have multiple projects in one solution. Then better create another project <code>Utilities</code>. Then create a Folder <code>\Enumerations</code> and create a nested <code>static class</code>. And then assign each static class where you will create enum that corresponds to the name of your projects. For example you have a project named DatabaseReader and DatabaseUsers then you may name the static class like

<pre><code>public static class EnumUtility {
 #region --Database Readers Enum
 public static class EnumDBReader {
 public enum Actions { Create, Retrieve, Update, Delete}; 
 }
 #endregion

 #region --Database Users Enum
 public static class EnumDBUsers {
 public enum UserIdentity { user, admin }; 
 }
 #endregion

}
</code></pre>

Then entire enum that can be used in the entire solutions per projects will be declared on it. Use #<code>region</code> to separate each concern. By this, it is easier to look for any enums

blocks|key|3060815|text|我喜欢有一个名为E的公共枚举文件，其中包含每个单独的枚举，然后任何枚举都可以用E...而且他们都在一个地方管理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3060816|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|$]]

I like to have one public enums file named E containing each seperate enum, then any enum can be accessed with E... and they are in one place to manage.

I have a class which uses an enumeration, the enum is currently in its own file which seems wasteful.

What is the general opinion on enums being placed within the namespace of a file that they are consumed in? Or should the enum really live in its own cs file? 

Edit

I should mention that while the class in question uses these enumerations, so does external callers. In other words, another class can set these enumerations. So they are not used internally to the class, otherwise this question would be a no brainer.

Should enums in C# have their own file?

我有一个使用枚举的类，枚举当前在它自己的文件中，这似乎很浪费。对于枚举放在使用它们的文件的名称空间中，一般的看法是什么？或者枚举真的应该存在于自己的cs文件中吗？编辑值得一提的是，虽然有问题的类使用这些枚举，但外部调用者也是如此。换句话说，另一个类可以设置这些枚举。因此，它们不会在类内部使用，否则这个问题将是不费吹灰之力的。

问C#中的枚举是否应该有自己的文件？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的枚举是否应该有自己的文件？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的枚举是否应该有自己的文件？
EN