为什么我需要使用 C# 嵌套类

Why Would I Ever Need to Use C# Nested Classes

提问by

I'm trying to understand about nested classes in C#. I understand that a nested class is a class that is defined within another class, what I don't get is why I would ever need to do this.

我试图了解 C# 中的嵌套类。我知道嵌套类是在另一个类中定义的类，我不明白的是为什么我需要这样做。

回答by Noldorin

The purpose is typically just to restrict the scopeof the nested class. Nested classes compared to normal classes have the additional possibility of the privatemodifier (as well as protectedof course).

目的通常只是限制嵌套类的范围。与普通类相比，嵌套类具有额外的private修饰符可能性（protected当然还有）。

Basically, if you only need to use this class from within the "parent" class (in terms of scope), then it is usually appropiate to define it as a nested class. If this class might need to be used from without the assembly/library, then it is usually more convenient to the user to define it as a separate (sibling) class, whether or not there is any conceptual relationship between the two classes. Even though it is technically possible to create a publicclass nested within a publicparent class, this is in my opinion rarely an appropiate thing to implement.

基本上，如果您只需要从“父”类（就范围而言）中使用此类，那么通常将其定义为嵌套类是合适的。如果这个类可能需要在没有 assembly/library 的情况下使用，那么用户将它定义为一个单独的（同级）类通常更方便，无论这两个类之间是否存在任何概念上的关系。尽管在技术上可以创建public嵌套在public父类中的类，但在我看来，这很少是一个合适的实现方式。

回答by Mehrdad Afshari

A nested class can have private, protectedand protected internalaccess modifiers along with publicand internal.

嵌套类可以具有private,protected和protected internal访问修饰符以及public和internal。

For example, you are implementing the GetEnumerator()method that returns an IEnumerator<T>object. The consumers wouldn't care about the actual type of the object. All they know about it is that it implements that interface. The class you want to return doesn't have any direct use. You can declare that class as a privatenested class and return an instance of it (this is actually how the C# compiler implements iterators):

例如，您正在实现GetEnumerator()返回IEnumerator<T>对象的方法。消费者不会关心对象的实际类型。他们只知道它实现了那个接口。您要返回的类没有任何直接用途。您可以将该类声明为private嵌套类并返回它的一个实例（这实际上是 C# 编译器实现迭代器的方式）：

class MyUselessList : IEnumerable<int> {
    // ...
    private List<int> internalList;
    private class UselessListEnumerator : IEnumerator<int> {
        private MyUselessList obj;
        public UselessListEnumerator(MyUselessList o) {
           obj = o;
        }
        private int currentIndex = -1;
        public int Current {
           get { return obj.internalList[currentIndex]; }
        }
        public bool MoveNext() { 
           return ++currentIndex < obj.internalList.Count;
        }
    }
    public IEnumerator<int> GetEnumerator() {
        return new UselessListEnumerator(this);
    }
}

回答by Reed Copsey

There are times when it's useful to implement an interface that will be returned from within the class, but the implementation of that interface should be completely hidden from the outside world.

有时实现一个将从类内部返回的接口很有用，但该接口的实现应该对外界完全隐藏。

As an example - prior to the addition of yield to C#, one way to implement enumerators was to put the implementation of the enumerator as a private class within a collection. This would provide easy access to the members of the collection, but the outside world would not need/see the details of how this is implemented.

例如 - 在将 yield 添加到 C# 之前，实现枚举器的一种方法是将枚举器的实现作为集合中的私有类。这将提供对集合成员的轻松访问，但外部世界不需要/看到这是如何实现的细节。

回答by Fernando

Nested classes are very useful for implementing internal details that should not be exposed. If you use Reflector to check classes like Dictionary<Tkey,TValue> or Hashtable you'll find some examples.

嵌套类对于实现不应公开的内部细节非常有用。如果您使用 Reflector 检查像 Dictionary<Tkey,TValue> 或 Hashtable 这样的类，您会发现一些示例。

回答by ChrisW

what I don't get is why I would ever need to do this

我不明白的是为什么我需要这样做

I think you never needto do this. Given a nested class like this ...

我认为你永远不需要这样做。给定一个这样的嵌套类......

class A
{
  //B is used to help implement A
  class B
  {
    ...etc...
  }
  ...etc...
}

... you can always move the inner/nested class to global scope, like this ...

...你总是可以将内部/嵌套类移动到全局范围，就像这样......

class A
{
  ...etc...
}

//B is used to help implement A
class B
{
  ...etc...
}

However, when B is only used to help implement A, then making B an inner/nested class has two advantages:

但是，当 B 仅用于帮助实现 A 时，那么将 B 设为内部/嵌套类有两个优点：

• It doesn't pollute the global scope (e.g. client code which can see A doesn't know that the B class even exists)
• The methods of B implicitly have access to private members of A; whereas if B weren't nested inside A, B wouldn't be able to access members of A unless those members were internal or public; but then making those members internal or public would expose them to other classes too (not just B); so instead, keep those methods of A private and let B access them by declaring B as a nested class. If you know C++, this is like saying that in C# all nested classes are automatically a 'friend' of the class in which they're contained (and, that declaring a class as nested is the only way to declare friendship in C#, since C# doesn't have a friendkeyword).

• 它不会污染全局范围（例如，可以看到 A 的客户端代码甚至不知道 B 类存在）
• B 的方法隐式地可以访问 A 的私有成员；而如果 B 没有嵌套在 A 中，则 B 将无法访问 A 的成员，除非这些成员是内部成员或公共成员；但是然后将这些成员设置为内部或公开也会将它们暴露给其他类（不仅仅是 B）；因此，相反，将 A 的这些方法保留为私有，并通过将 B 声明为嵌套类来让 B 访问它们。如果您了解 C++，这就像说在 C# 中所有嵌套类都自动成为包含它们的类的“朋友”（并且，将类声明为嵌套类是在 C# 中声明友谊的唯一方法，因为C# 没有friend关键字）。

When I say that B can access private members of A, that's assuming that B has a reference to A; which it often does, since nested classes are often declared like this ...

当我说 B 可以访问 A 的私有成员时，那是假设 B 有对 A 的引用；它经常这样做，因为嵌套类通常是这样声明的......

class A
{
  //used to help implement A
  class B
  {
    A m_a;
    internal B(A a) { m_a = a; }
    ...methods of B can access private members of the m_a instance...
  }
  ...etc...
}

... and constructed from a method of A using code like this ...

...并使用这样的代码从 A 的方法构造...

//create an instance of B, whose implementation can access members of self
B b = new B(this);

You can see an example in Mehrdad's reply.

你可以在 Mehrdad 的回复中看到一个例子。

回答by Arjan Einbu

There is good uses of public nested members too...

公共嵌套成员也有很好的用途......

Nested classes have access to the private members of the outer class. So a scenario where this is the right way would be when creating a Comparer (ie. implementing the IComparer interface).

嵌套类可以访问外部类的私有成员。因此，在创建比较器（即实现 IComparer 接口）时，这是正确的方法。

In this example, the FirstNameComparer has access to the private _firstName member, which it wouldn't if the class was a seperate class...

在这个例子中， FirstNameComparer 可以访问私有的 _firstName 成员，如果类是一个单独的类，它就不会......

public class Person
{
    private string _firstName;
    private string _lastName;
    private DateTime _birthday;

    //...

    public class FirstNameComparer : IComparer<Person>
    {
        public int Compare(Person x, Person y)
        {
            return x._firstName.CompareTo(y._lastName);
        }
    }

}

回答by Eric Lippert

A pattern that I particularly like is to combine nested classes with the factory pattern:

我特别喜欢的一种模式是将嵌套类与工厂模式相结合：

public abstract class BankAccount
{
  private BankAccount() {} // prevent third-party subclassing.
  private sealed class SavingsAccount : BankAccount { ... }
  private sealed class ChequingAccount : BankAccount { ... }
  public static BankAccount MakeSavingAccount() { ... }
  public static BankAccount MakeChequingAccount() { ... }
}

By nesting the classes like this, I make it impossible for third parties to create their own subclasses. I have complete control over all the code that runs in any bankaccount object. And all my subclasses can share implementation details via the base class.

通过像这样嵌套类，我使第三方无法创建自己的子类。我可以完全控制在任何银行帐户对象中运行的所有代码。我所有的子类都可以通过基类共享实现细节。

回答by lambertwm

Maybe this is a good example of when to use nested classes?

也许这是什么时候使用嵌套类的一个很好的例子？

// ORIGINAL
class ImageCacheSettings { }
class ImageCacheEntry { }
class ImageCache
{
    ImageCacheSettings mSettings;
    List<ImageCacheEntry> mEntries;
}

And:

和：

// REFACTORED
class ImageCache
{
    Settings mSettings;
    List<Entry> mEntries;

    class Settings {}
    class Entry {}
}

PS: I've not taken into account which access modifiers should be applied (private, protected, public, internal)

PS：我没有考虑应该应用哪些访问修饰符（私有、受保护、公共、内部）