限制 class 实例化并将其封装在另一个 class 中的属性中

Question

我正在写一个 .net Standard class 库，我想将它发布为一个内部包，所以我在同一个项目中有两个 classes，如下所示：

 public class classOne
{

     public void SomeMethod()
        {

        }
}




 public class classTwo
{

     private ClassOne _classOne;

     public classOne clsOne
        {
            get
            {
                lock (padlock)
                {
                    if (_classOne== null)
                        _classOne= new ClassOne ();

                    return _classOne;
                }
            }
        }
}

正如您在上面看到的，我希望开发人员将 class one 用作 classTwo 中的属性另外我想阻止 classOne 的实例化。调用 classOne 方法的唯一方法是通过 classTwo "clsOne" 属性.

    //I want this code
classTwo clsTwo = new classTwo();
clsTwo.clsOne.someMethod();


//And Prevent to do this code
classOne clsOnew= new classOne();
clsOne.someMethod();

我该如何实现？

Answer 1

我相信您希望 ClassOne 是静态的。

它应该看起来像这样。

public static class classOne
 {

   public static void SomeMethod()
    {
     // Your logic
    }

  }

然后在 ClassTwo 构造函数中或任何您希望调用该函数的地方，

public class classTwo
 {

   public classTwo()
    {
      classOne.SomeMethod();
    }

  }

Answer 2

我想你想要的是一个嵌套的 class.

public class ClassTwo
{

    public class ClassOne
    {
        // methods
    }
    // property
}

但是你会如何防止实例化呢？也许你可以尝试这样的事情：

public class ClassTwo
{
    private class Token
    {
        public static readonly Token Instance = new Token();
        private Token(){}
    }
    public class ClassOne
    {
        public ClassOne(Token token){}
        // methods
    }
    // property
}

因为令牌class在ClassTwo内部是私有的，所以只有ClassTwo可以用它来构造ClassOne。

Answer 3

您可以通过将 ClassOne 设为私有来修改对构造函数的访问。

如果我正确理解您的问题，ClassTwo 的唯一目的是允许访问 ClassOne 的单个实例，在这种情况下，您可以使用标准的 Singleton C# 模式来实现这一点class.

public sealed class ClassOne
{
    // Make the constructor private
    private ClassOne()
    {

    }

    private static ClassOne instance;
    private static readonly object _lock = new object();

    public static ClassOne Instance
    {
        get
        {
            // only get a new reference if one doesn't already exist
            if (instance == null)
            {
                lock (_lock)
                {
                    if (instance == null)
                    {
                        instance = new ClassOne();
                    }
                }
            }
            return instance;
        }
    }

    public void SomeMethod()
    {
        // Do work
    }
}

由于构造函数是私有的，我们不能在 class 本身之外创建 ClassOne 的实例。

// Valid
var instance = ClassOne.Instance;

// Invalid
var instance2 = new ClassOne();

instance.SomeMethod();

Answer 4

如果您只关心 ClassOne 不在您的包外实例化，您可以创建 ClassOne 的构造函数 internal。

如果您只希望 ClassOne 被 ClassTwo 实例化，您可以创建一个 public 接口，IClassOne 并使 ClassOne 实现 IClassOne 并成为 ClassTwo 内部的私有嵌套 class。

public interface IClassOne
{
    void SomeMethod();
}

public class ClassTwo
{
    private ClassOne _classOne;

    public IClassOne clsOne
    {
        get
        {
            lock (padlock)
            {
                if (_classOne== null)
                    _classOne= new ClassOne ();

                return _classOne;
            }
        }
    }

    private class ClassOne : IClassOne
    {
        public void SomeMethod()
        {
            // do something
        }
    }
}

限制 class 实例化并将其封装在另一个 class 中的属性中

Restrict class from instantiation and encapsulate it in property in another class

c#

class-library

nuget-package

限制 class 实例化并将其封装在另一个 class 中的 属性 中

Restrict class from instantiation and encapsulate it in property in another class

c#

class-library

nuget-package

限制 class 实例化并将其封装在另一个 class 中的属性中