Question

今天，我一直在阅读静态类和私有构造函数。

静态类 - 我们无法在静态类上创建实例。我们不能继承静态类。只生成单个实例。

私有构造函数 - 我们无法创建实例。我们不能继承。（我不知道生成了多少个实例。）

我创建了两个控制台应用程序，即一个用于静态类，一个用于私有构造函数。

静态类代码

我理解生成的构造函数中的单个对象被调用一次。

私人构造函数代码

现在，我还没有理解是否生成了任何对象。

我有两个问题。

问题1.我没有发现Private构造函数和Static类之间有任何特别的区别。你能告诉我在哪种情况下我应该使用私有构造函数，我应该在哪里使用Static类，因为我可以使用它们。

问题2.如果我使用私有构造函数，会生成多少个对象？

感谢。

编辑：

我认为人们并不理解我的问题。我知道静态构造函数总是在第一个引用上调用一次。静态构造函数用于初始化类的静态成员。

问题1.我有一种情况：我需要创建一个无法实例化的类。我可以通过静态类或私有构造函数来完成。所以我的问题是＆＃34;两者之间有什么区别吗？我应该使用哪一个？＆＃34;

问题2.如果我使用私有构造函数，会创建多少个对象？如果answer为0，则私有构造函数的内存分配在CLR中如何工作。如果我使用私有构造函数，则没有内存分配。

Answer 1

您调用static方法的两个示例中，两者之间的区别在于第一个方法是在static类中调用的，无法实例化。第二类可以实例化，但是你没有选择。

第一个示例中的static构造函数在需要时在运行时自动运行，通常只运行一次。

private构造函数永远不会运行，因为您从未实例化testPrivateConstructor对象。不是因为它是private。

编辑：

Q1：如果您需要一个无法实例化的类，请使用static类。如果需要初始化静态成员（或单例模式），则只使用private构造函数而不是static类。

Q2：如果使用private构造函数，则可以在类本身中实例化类的实例，因此创建的对象数取决于实例化新对象的次数。

Answer 2

你在这里混合了几件不同的东西

静态类public static class MyClass只能包含静态元素，永远不会被初始化

构造函数（无论是公共的还是私有的）总是在类的实例中创建，public或private只表示构造函数的可见性。

这在实现单例设计时通常使用

private MyClass()
{
}
private static MyClass _Singleton;
public static MyClass Singleton
{
    get
    {
        if(_Singleton==null) _Singleton = new MyClass();
        return _Singleton
    }
}

}

另一个是类初始化器，这有点令人困惑，因为它的语法非常类似于一个构造函数，禁止添加静态关键字和缺少参数

static MyClass()
{
    //configure static variables on first us only
    b = //read value from file or other resource not avalable at compile time
    a = b.Lenth; //can't be be done in class body as b would not have been initialised yet
}
private static int a;
private static string b;

如果您的课程无法实例化，那么您只能声明为静态，其他任何事情都不会这样做，

如果您调用私有构造函数，则每次调用都会创建一个实例

类初始化器永远不会被称为在第一次使用类时自动触发，并且不会创建实例

编辑：这是您的测试程序的修订版

public static class StaticClassExample
{
    public static void ClassFunction()
    {
        Console.WriteList("This is a class function")
    }
}
public static class InitialisedStaticClassExample
{
    static InitialisedStaticClassExample()
    {
        Console.WriteList("This class has been initialised")
    }
    public static void ClassFunction()
    {
        Console.WriteList("This is a class function")
    }
}
public class PrivateConstuctorClassExample
{
    static PrivateConstuctorClassExample()
    {
        Console.WriteList("This class has been initialised")
    }
    private PrivateConstuctorClassExample()
    {
        Console.WriteList("This class has been Instantiated")
    }
    public static void ClassFunction()
    {
        Console.WriteList("This is a class function");
        var instance = new PrivateConstuctorClassExample();
        instance.InstanceFunction();
    }
    public void InstanceFunction()
    {
        Console.WriteList("This is a instance function")
    }
}

Answer 3

当类是第一次调用静态构造函数时引用。静态构造函数用于初始化静态成员这个班。

在非静态类中，私有或公共构造函数不会调用。静态成员不会通过私有或初始化公共建设者。

见下面的例子

    class Program
    {
        static void Main(string[] args)
        {
            OnlyOne.SetMyName("I m the only one."); //static constructor will be called first time when the class will be referenced.
            Console.WriteLine(OnlyOne.GetMyName());

            NoInstance.SetMyName("I have private constructor"); //No constructor will be called when the class will be referenced.
            Console.WriteLine(NoInstance.GetMyName());

            Console.Read();
        }
    }

    static class OnlyOne
    {
        static string name;
        /// <summary>
        /// This will be called first time when even the class will be referenced.
        /// </summary>
        static OnlyOne()
        {
            name = string.Empty;
            Console.WriteLine("Static constructor is called");
        }

        public static string GetMyName()
        {
            return name;
        }

        public static void SetMyName(string newName)
        {
            name = newName;
        }
    }

    public class NoInstance
    {
        static string name;
        private NoInstance()
        {
            name = string.Empty;
            Console.WriteLine("No instance private constructor is called");
        }

        public static string GetMyName()
        {
            return name;
        }

        public static void SetMyName(string newName)
        {
            name = newName;
        }
    }
}

Answer 4

问题2：0

问题1：您使用静态构造函数创建了一个静态类，但在您的情况下您不需要该实例，因为该方法也是静态的，并且运行静态方法所需的唯一内容是类定义 - 否实例

你的第二个类也可以不用构造实例 - 静态方法不需要一个。由于这是一个私有构造函数，因此只有类方法可以创建实例。你会使用私有构造函数只在我猜的单例模式的情况下 - 没有私有构造函数的本地调用者它是没有用的。

Answer 5

在创建类的实例时调用类的构造函数。在初始化类时调用静态构造函数。阅读this

在示例1中，当您访问类的静态方法时，将初始化静态构造函数。这与静态或非静态类相关。

在示例2中，您的私有构造函数不是静态的。由于没有创建实例，因此未调用构造函数。必须通过创建类的实例来调用它。

私有构造函数用于控制类实例的构造和销毁。因为，在这种情况下，只有类可以调用它的构造函数。您需要一个静态方法来获取类的实例

例如，

public class TestPrivateConstructor
{

private TestPrivateConstructor()
{
  Console.WriteLine("Instance is created, Private Constructor called");
}

static TestPrivateConstructor _instance;

public static TestPrivateConstructor GetInstance()
{
    if(_instance == null)
    {
       _instance = new TestPrivateConstructor();
    }
    return _instance;
}

public static void DisposeInstance()
{
   if(_instance !=null)
   {
      _instance.Dispose();
      _instance = null;
   }
}
public void TestMethod()
{
  Console.WriteLine("Test MEthod Called");
}
void Dispose()
{
 //Do something
}
}

对于上面的代码，请尝试使用此代码。现在，在创建实例时调用私有构造函数。

class Program
{
   public static void Main(string[] args)
   {
     //Private constructor
     TestPrivateConstructor.GetInstance()
   }
}

使用上述方法，您可以控制对象的构造和销毁。如果您还有任何疑问，请随时提出。

静态类VS私有构造函数

5 个答案: