Question

我正在.Net中创建一个库

我有一个名为DataManager的静态类。

public static class NewDataManager
{
    public static Soccer Soccer { get; private set; }

    static NewDataManager()
    {
         Soccer =  new Classes.Soccer.Soccer();
    }
}

足球课程就像：

public class Soccer
{
    public static Mapping.Mapping Mappings { get; private set; }

    public Soccer()
    {
        Mappings = new Mapping.Mapping();
    }
}

而Mapping类只是另一个公共空类。

当我在另一个项目中使用此项目作为参考时，我可以访问我的对象，如

NewDataManager.Soccer.Mappings

没关系，这就是我想要的。问题是，我可以在引用项目中初始化所有类，如

var s = new Soccer();
var m = new Mapping();

我希望这些类只能通过我的NewDataManager类访问，使用我的库的项目不应该能够初始化类。

我该如何限制？

Answer 1

这是有效实现您想要的一种方式。将Soccer嵌套在NewDataManager内，然后您就可以执行以下操作：

public static class NewDataManager
{
    public static ISoccer SoccerInstance { get; private set; }

    static NewDataManager()
    {
         SoccerInstance =  new Soccer();
    }

    private class Soccer : ISoccer
    {

        public Soccer()
        {
        }
    }
}

public interface ISoccer {}

创建嵌套类private意味着它不能在NewDataManger之外访问，但您仍然可以通过实现公共接口来公开它。当然，您可以添加需要向界面公开的任何属性，以便它们可用于调用代码。我放弃了Mapping属性，简化了我的例子。

现在，如果你不想上课，你就不必这样做了。您可以将它们标记为internal，但它们不会对其他装配体可见，但它们将在同一装配体中可见。这意味着除NewDataManger之外的同一程序集中的类将能够看到它们（并创建新实例），但其他程序集不会获胜。这对你来说已经足够了。

Answer 2

要防止其他程序集实例化类，请创建其构造函数internal：

public class Soccer
{
    public static Mapping.Mapping Mappings { get; private set; }

    internal Soccer()  //  <-- instead of 'public'
    {
        Mappings = new Mapping.Mapping();
    }
}

public class Mapping
{
    internal Mapping()
    {
    }
}

（顺便说一句，看起来你有名为Soccer和Mapping的名称空间。Don't do this.）

Answer 3

因为这些课程是公开的 - 您可以从＆＃34;随时随地访问＃34;

公共

The type or member can be accessed by any other code in the same assembly or another assembly that references it.

私有

The type or member can be accessed only by code in the same class or struct.

保护

The type or member can be accessed only by code in the same class or struct, or in a class that is derived from that class.

内部

The type or member can be accessed by any code in the same assembly, but not from another assembly.

MSDN article about access modifiers

Answer 4

让我扩展VisualBean的解决方案：类具有可访问性特征，就像他描述的函数一样 - 公共，私有，受保护，内部等。

所以第一个解决方案就是在同一个程序集中定义NewDataManager和Soccer类，并将Soccer internal和NewDataManager公之于众，如下所示：

public class NewDataManager{/*Your code goes here*/}
internal class Soccer{/*Your code goes here, 2*/}

在另一个文件中，您可以放置其余代码。

然而，有些替代方案可能更合适（取决于您的情况）。如果一个类只能被一个类型的另一个类访问，那么它应该与该类相关。为了在类中包含类，您有两种方法：

使构造函数受到保护，并使类继承另一个类（如果对象相互扩展，这是一个很好的解决方案），即

class Soccer{protected Soccer(){} /*Rest of the code goes here*/}
class NewDataManager:Soccer{// NewDataManagerStuff }

或者让生成成为一个需要发件人成为您正在寻找的类的事件，这可能会稍微复杂一些。

祝你好运，我希望能帮助你。：）

Answer 5

只需将Mapping类插入NewDataManager，如下所示：

public static partial class NewDataManager 
{
    // NewDataManager class code
}

public partial class NewDataManager
{
    public static class Mapping
    {
        // Mapping class code
    }
}

OR

public static class NewDataManager 
{
    // NewDataManager class code

    public static class Mapping
    {
        //Mapping class code
    }
}

使类只能由静态对象访问

5 个答案: