C# C中带有“private”类的类修饰符问题

我有一个有很多方法的类：

public class MyClass {
    public bool checkConditions() {
        return checkCondition1() &&
               checkCondition2() &&
               checkCondition3();
    }

...conditions methods

    public void DoProcess() {
        FirstPartOfProcess();
        SecondPartOfProcess();
        ThirdPartOfProcess();
    }

...process methods
}

我确定了两个重要的工作领域，并决定将这些方法提取到自己的类中：

public class MyClass {
    private readonly MyClassConditions _conditions = new ...;
    private readonly MyClassProcessExecution = new ...;

    public bool checkConditions() {
        return _conditions.checkConditions();
    }

    public void DoProcess() {
        _process.DoProcess();
    }
}

在Java中，我将MyClassConditions和MyClassProcessExecution定义为包保护，但在C中我不能这样做

在C语言中，你会怎么做

是否将两个类都设置为MyClass的内部类？ 我有两个选择：要么在MyClass中定义它们，将所有内容都放在同一个文件中，这看起来既混乱又难看；要么将MyClass定义为部分类，一个文件用于MyClass，另一个文件用于MyClassConditions，另一个文件用于MyClassProcessExecution

将它们定义为内部的？ 我真的不太喜欢内部修饰符，因为我发现这些类对我的程序/汇编的其余部分根本没有任何价值，如果可能的话，我想隐藏它们。它们在程序的任何其他部分都不会有用/可重用

把它们公开？ 我不明白为什么，但我让这个选项在这里

还有别的吗？ 说吧

---

感谢将不会在当前程序集之外使用的帮助器类型类，如果这些方法将由多个类使用，则可以使用Internal

---

对于只由单个类使用的方法，我只会将它们设置为该类的私有类，或者如果它实际上是一个在其他任何地方都没有使用过的类，则使用内部类。如果代码不依赖于类的任何非静态成员，则还可以将代码分解为静态方法。

对于不会在当前程序集之外使用的帮助器类型类，如果多个类将使用这些方法，则可以使用内部方法

---

对于只由单个类使用的方法，我只会将它们设置为该类的私有类，或者如果它实际上是一个在其他任何地方都没有使用过的类，则使用内部类。如果代码不依赖于类中的任何非静态成员，您还可以将代码分解为静态方法。

您最好的选择可能是使用分部类，并将三个代码束放在单独的文件中添加到同一个类中。然后，您可以将条件代码和过程代码设置为私有，以便只有类本身可以访问它们。

您最好的选择可能是使用分部类，并将三个代码束放在单独的文件中，添加到同一个类中。然后，您可以将条件代码和过程代码设置为私有，以便只有类本身可以访问它们。

使用与重构的方法相同的访问修饰符创建类。只有当多人或自动化代码生成工具频繁修改同一类时，分部类才真正有用。它们只是真正避免了源代码合并地狱，因为源代码控件无法将多个编辑合并到同一个文件中。使用与重构方法相同的访问修饰符创建类。只有当多人或自动化代码生成工具频繁修改同一类时，分部类才真正有用。他们只是真正避免了源代码合并地狱，因为源代码控制程序不能将多个编辑合并到同一个文件中，所以会将代码混搭在一起

我能 将MyClass定义为分部类， 有一个文件用于MyClass，另一个用于 MyClassConditions和其他用于 MyClassProcessExecution

<>也许是我的C++背景，但是这是我的标准方法，虽然我把小助手类捆绑成一个文件。

因此，在我当前的一个项目中，产品类在Product.cs和ProductPrivate.cs之间划分

我能 将MyClass定义为分部类， 有一个文件用于MyClass，另一个用于 MyClassConditions和其他用于 MyClassProcessExecution

<>也许是我的C++背景，但是这是我的标准方法，虽然我把小助手类捆绑成一个文件。

---

因此，在我当前的一个项目中，Product类被划分为Product.cs和ProductPrivate.cs。我打算做一些其他的事情——公共/受保护/私有的问题可能并没有通过这一点得到具体解决，但我认为它比许多嵌套的内部类更易于维护

因为这听起来像是在一个顺序算法中有一组步骤，其中一个步骤的执行可能取决于也可能不取决于前一个步骤的执行。这种类型的顺序步骤处理有时可以使用该模式，尽管它与最初的意图略有不同。仅关注您的处理方法，例如，从以下内容开始：

class LargeClass
{
public void DoProcess()
{
  if (DoProcess1())
  {
    if (DoProcess2())
    {
      DoProcess3();
    }
  }
}

protected bool DoProcess1()
{
...
}

protected bool DoProcess2()
{
...
}

protected bool DoProcess3()
{
...
}

}

使用责任链，可以将每个步骤分解为一组具体的类，这些类继承自一些抽象的步骤类。抽象步骤类更负责确保调用下一个步骤（如果必要的先决条件是me） t

要进行设置，您需要在代码的某些部分执行以下操作：

var stepOne = new ConcreteStep1();
var stepTwo = new ConcreteStep2();
var stepThree = new ConcreteStep3();
stepOne.NextStep = stepTwo;
stepTwo.NextStep = stepThree;

bool success = stepOne.ExecuteStep();

这可能有助于清理单个类中的代码膨胀——我过去曾在一些顺序类型算法中使用过它，它有助于很好地隔离每个步骤。显然，您可以将相同的想法应用到您的条件检查中，或者将它们构建到每个步骤中（如果适用的话）。通过让ExecuteStep方法使用某种类型的state对象获取参数，您还可以在步骤之间传递状态

---

当然，如果您在这篇文章中真正关心的只是隐藏各个步骤，那么是的，您可以在创建步骤的类中使每个子步骤成为受保护的类。除非您以某种形式或方式向客户公开您的库，并且您不希望他们对您的执行步骤有任何类型的可见性，这似乎比使代码可维护的问题要小。

我要说的是另一件事——公共/受保护/私有的问题可能不是通过这一点特别解决的，但我认为它比许多嵌套的内部类更适合维护

因为这听起来像是在一个顺序算法中有一组步骤，其中一个步骤的执行可能取决于也可能不取决于前一个步骤的执行。这种类型的顺序步骤处理有时可以使用该模式，尽管它与最初的意图略有不同。仅关注您的处理方法，例如，从以下内容开始：

class LargeClass
{
public void DoProcess()
{
  if (DoProcess1())
  {
    if (DoProcess2())
    {
      DoProcess3();
    }
  }
}

protected bool DoProcess1()
{
...
}

protected bool DoProcess2()
{
...
}

protected bool DoProcess3()
{
...
}

}

使用责任链，可以将每个步骤分解为一组具体的类，这些类继承自一些抽象的步骤类。如果满足必要的前提条件，抽象步骤类更负责确保调用下一个步骤

public class AbstractStep
{
    public AbstractStep NextStep { get; set; }

    public virtual bool ExecuteStep
    {
       if (NextStep != null)
       {
         return NextStep.ExecuteStep();
       }
    }  
}

public class ConcreteStep1 : AbstractStep
{
    public bool ExecuteStep
    {
       // execute DoProcess1 stuff
       // call base
       return base.ExecuteStep();
    }
}

...

public class ConcreteStep3 : AbstractStep
{
     public bool ExecuteStep
     { 
        // Execute DoProcess3 stuff
        // call base
        return true; // or false?
      }
}

要进行设置，您需要在代码的某些部分执行以下操作：

var stepOne = new ConcreteStep1();
var stepTwo = new ConcreteStep2();
var stepThree = new ConcreteStep3();
stepOne.NextStep = stepTwo;
stepTwo.NextStep = stepThree;

bool success = stepOne.ExecuteStep();

这可能有助于清理单个类中的代码膨胀——我过去曾在一些顺序类型算法中使用过它，它有助于很好地隔离每个步骤。显然，您可以将相同的想法应用到您的条件检查中，或者将它们构建到每个步骤中（如果适用的话）。通过让ExecuteStep方法使用某种类型的state对象获取参数，您还可以在步骤之间传递状态

---

当然，如果您在这篇文章中真正关心的只是隐藏各个步骤，那么是的，您可以在创建步骤的类中使每个子步骤成为受保护的类。除非您以某种形式或方式向客户公开您的库，并且您不希望他们对您的执行步骤有任何类型的可见性，否则这似乎是一个比使代码可维护性更小的问题。

是的，它们不会在程序集外使用。但它们也不应该在课堂之外使用：是的，我编辑了我的答案以反映这种担忧。我不太喜欢内部类，因为在我看来，它们往往会把代码弄得乱七八糟，但如果它们不在其他任何地方使用，你可以在这里提出理由。我不认为将代码分解成静态方法有什么好处。方法还在，有什么好处？Stackoverflow是你的朋友；我看不出与OP的要求相关的任何优势。是的，它们不会在大会之外使用。但它们也不应该在课堂之外使用：是的，我编辑了我的答案以反映这种担忧。我不太喜欢内部类，因为在我看来，它们往往会把代码弄得乱七八糟，但如果它们不在其他任何地方使用，你可以在这里提出理由。我不认为将代码分解成静态方法有什么好处。方法还在，有什么好处？Stackoverflow是你的朋友；我看不出与OP的要求相关的任何优势。