10

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

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

Private Constructor - 我们无法创建实例。我们不能继承。（我不知道生成了多少实例。）

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

静态类代码

在此处输入图像描述

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

私有构造函数代码

在此处输入图像描述

现在，我不明白是否生成了任何对象。

我有两个问题。

问题 1. 我没有发现 Private 构造函数和 Static 类之间有什么特别的区别。您能否建议我在哪种情况下应该使用 Private Constructor 以及应该在哪里使用静态类，因为我可以同时使用它们。

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

谢谢。

编辑 ：

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

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

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

4

5 回答 5

4

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

第一个例子中的static构造函数在需要的时候在运行时自动运行，一般只运行一次。

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

编辑：

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

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

于 2016-06-23T11:22:29.540 回答
2

你在这里混合了一些不同的东西

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

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

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

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")
    }
}
于 2016-06-23T12:13:12.303 回答
1
  • 当类被引用时，静态构造函数将被第一次调用。静态构造函数用于初始化类的静态成员。

  • 在非静态类中，不会调用私有或公共构造函数。静态成员不会被私有或公共构造函数初始化。

    见下面的例子

        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;
        }
    }
}
于 2016-06-23T11:17:45.903 回答
0

问题2：0

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

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

于 2016-06-23T11:25:03.367 回答
0

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

在示例 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()
   }
}

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

于 2016-06-23T11:28:30.540 回答