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

Question

我正在写一个.net标准类库，我想把它作为一个内部包发布，所以我在同一个项目中有两个类，比如说：

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

正如您在上面看到的，我希望开发人员使用类一作为类二内部的属性。我还希望防止类一的实例化。调用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();