为什么我需要使用 C# 嵌套类 [重复]

Question

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

Answer 1

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

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() { ... }
}

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

Answer 2

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

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

Answer 3

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

例如，您正在实现返回IEnumerator<T> 对象的GetEnumerator() 方法。消费者不会关心对象的实际类型。他们所知道的只是它实现了该接口。您要返回的类没有任何直接用途。您可以将该类声明为 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);
    }
}

Answer 4

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

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

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

...您始终可以将内部/嵌套类移动到全局范围，就像这样...

class A
{
  ...etc...
}

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

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

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

当我说 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...
}

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

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

您可以在 Mehrdad 的回复中看到一个示例。

Answer 5

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

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

在此示例中，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._firstName);
        }
    }
}

Answer 6

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

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

Answer 7

嵌套类对于实现不应暴露的内部细节非常有用。如果您使用 Reflector 检查 Dictionary 或 Hashtable 等类，您会发现一些示例。

Answer 8

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

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

还有：

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

    class Settings {}
    class Entry {}
}

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