0 
class Program
{
    static void Main(string[] args)
    {
        Master m = new Master(37);
        Content c = new Content(m);
    }
}

我定义了两个类。第一个如下：

internal class Content 
{
    private Master _parentMaster;

    private Content _contentChildren;

    #region Constructor

    internal Content(Master master)
    {
        this._parentMaster = master;
    }
    internal Content(Master master, long contentId)
    {
        this._parentMaster = master;
        _getContent(contentId);
    }

    #endregion

    #region Private Methods

    private void _getContent(long contentId)
    {
        contentRepository.getContent(contentId, _parentMaster.MasterId);
    }

    #endregion

    #region Internal Methods

    internal void AddContent()
    {
        // code omitted
    }
    internal void UpdateContent()
    {
        // code omitted
    }

    internal void GetChildren()
    {
        // code imitted
    }
    internal void GetRootContent()
    {
        // code omitted
    }

    #endregion

    #region Properties

    // code omitted

    #endregion

}

第二个：

public class Master
{
    private MasterEntities _master;
    private List<Master> _masters;

    #region Constructor

    internal Master()
    {
        _master = new MasterEntities();
    }
    internal Master(long masterId)
    {
        _getMaster(masterId);
    }

    #endregion

    #region Private Methods

    internal void _getMaster()
    {
            // code omitted
    }

    #region Properties

    internal long MasterId
    {
        get
        {
            return _master.id;
        }
        set
        {
            _master.id = value;
        }
    }
    // code omitted

    #endregion

}

这是实现这两个类的正确方法吗？还是更好地实现嵌套类？如果是，如何使用嵌套类获得“Main”中所述的相同结果？

4

2 回答 2

1

无论您是否有嵌套类，都没有太大区别。它只会改变您访问类类型的方式，但不会改变类的行为。嵌套类看不到封闭类的成员，除非它有对它的引用。

说，我们有这个嵌套类

public class Containing
{
    public class Nested
    {
    }
}

现在您可以从外部访问Containing课程

Containing.Nested obj = new Containing.Nested();

包含类的行为类似于命名空间。对于其他嵌套类型也是如此。如果嵌套类型紧密绑定到包含类，我只会使用嵌套类型。一个很好的例子是enum仅在特定类中使用。

public class SomeData
{
    public enum MyValueType
    {
        Aaa, Bbb, Ccc
    }

    public MyValueType MyValue { get; set; }
}

Content您的班级可能就是这种情况。是否让您的代码更易于理解和结构更好由您决定。

于 2012-07-20T15:40:40.013 回答
1

如果一个类完全是另一个类的实现细节，我通常只使用嵌套类——在这种情况下，我将嵌套类设为私有。如果一个类需要在另一个类之外使用，在这种情况下我通常不会有嵌套类。

例外可能是应用于另一个类、委托签名或 EventArgs 派生类的枚举。

但是，在大多数情况下，它是风格的。如果您发现将一个类嵌套在另一个类中可以提供更好的可读性或可维护性，那么这确实是个人选择。

于 2012-07-20T16:07:36.127 回答