Question

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

 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不在程序包外部实例化，则可以将ClassOne构造为internal。

如果只希望ClassOne被ClassTwo实例化，则可以创建一个公共接口IClassOne并让ClassOne实现IClassOne并成为ClassTwo中的私有嵌套类。

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
        }
    }
}

Answer 2

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

它应该看起来像这样。

public static class classOne
 {

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

  }

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

public class classTwo
 {

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

  }

Answer 3

我认为您想要的是一个嵌套类。

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
}

因为令牌类在ClassTwo中是私有的，所以只有ClassTwo可以使用它来构造ClassOne。

Answer 4

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

如果我能正确理解您的问题，ClassTwo的唯一目的是允许访问ClassOne的单个实例，在这种情况下，您可以使用标准的Singleton C＃模式在一个类中实现该功能。

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
    }
}

由于构造函数是私有的，因此我们无法在类本身之外创建ClassOne的实例。

// Valid
var instance = ClassOne.Instance;

// Invalid
var instance2 = new ClassOne();

instance.SomeMethod();

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

4 个答案: