关于C#：从另一个构造函数调用一个构造函数


Call one constructor from another

我有两个构造函数，它们向只读字段提供值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Sample
{
    public Sample(string theIntAsString)
    {
        int i = int.Parse(theIntAsString);

        _intField = i;
    }

    public Sample(int theInt)
    {
        _intField = theInt;
    }


    public int IntProperty
    {
        get { return _intField; }
    }
    private readonly int _intField;

}

一个构造函数直接接收值，另一个进行计算并获取值，然后设置字段。

下面是要点：

  • 我不想复制设置代码。在这种情况下，只有一个字段已设置，但当然可以我们不止一个。
  • 要使字段只读，我需要从构造函数设置它们，所以我无法将共享代码"提取"到实用功能。
  • 我不知道怎么叫来自另一个的构造函数。

    • 有什么想法吗？

    这样地：

    1
    2
    public Sample(string str) : this(int.Parse(str)) {
    }
    相关讨论

    如果没有在自己的方法中进行初始化(例如，因为在初始化代码之前要做的太多，或者用try finally或其他任何方法包装它)，则可以让任何或所有构造函数通过引用初始化例程来传递只读变量，这样就可以随意操纵它们。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    class Sample
    {
        private readonly int _intField;
        public int IntProperty
        {
            get { return _intField; }
        }

        void setupStuff(ref int intField, int newValue)
        {
            intField = newValue;
        }

        public Sample(string theIntAsString)
        {
            int i = int.Parse(theIntAsString);
            setupStuff(ref _intField,i);
        }

        public Sample(int theInt)
        {
            setupStuff(ref _intField, theInt);
        }
    }
    相关讨论

    在构造函数主体之前，请使用以下任一项：

    1
    2
    3
    : base (parameters)

    : this (parameters)

    例子：

    1
    2
    3
    4
    5
    6
    7
    public class People: User
    {
       public People (int EmpID) : base (EmpID)
       {
          // Add more statements here.
       }
    }
    相关讨论

    我正在改进Supercat的答案。我想也可以做到以下几点：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    class Sample
    {
        private readonly int _intField;
        public int IntProperty
        {
            get { return _intField; }
        }

        void setupStuff(ref int intField, int newValue)
        {
            //Do some stuff here based upon the necessary initialized variables.
            intField = newValue;
        }

        public Sample(string theIntAsString, bool? doStuff = true)
        {
            //Initialization of some necessary variables.
            //==========================================
            int i = int.Parse(theIntAsString);
            // ................
            // .......................
            //==========================================

            if (!doStuff.HasValue || doStuff.Value == true)
               setupStuff(ref _intField,i);
        }

        public Sample(int theInt): this(theInt, false) //"false" param to avoid setupStuff() being called two times
        {
            setupStuff(ref _intField, theInt);
        }
    }
    相关讨论

    下面是一个调用另一个构造函数的示例，然后检查它所设置的属性。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
        public SomeClass(int i)
        {
            I = i;
        }

        public SomeClass(SomeOtherClass soc)
            : this(soc.J)
        {
            if (I==0)
            {
                I = DoSomethingHere();
            }
        }
    相关讨论

    是的，你可以在调用库或这个之前调用其他方法！

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class MyException : Exception
    {
        public MyException(int number) : base(ConvertToString(number))
        {
        }

        private static string ConvertToString(int number)
        {
          return number.toString()
        }

    }
    相关讨论

    当从基类继承类时，可以通过实例化派生类来调用基类构造函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    class sample
    {
        public int x;

        public sample(int value)
        {
            x = value;
        }
    }

    class der : sample
    {
        public int a;
        public int b;

        public der(int value1,int value2) : base(50)
        {
            a = value1;
            b = value2;
        }
    }

    class run
    {
        public static void Main(string[] args)
        {
            der obj = new der(10,20);

            System.Console.WriteLine(obj.x);
            System.Console.WriteLine(obj.a);
            System.Console.WriteLine(obj.b);
        }
    }

    样本程序的输出是

    50 10 20

    也可以使用this关键字从另一个构造函数调用构造函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    class sample
    {
        public int x;

        public sample(int value)
        {
            x = value;
        }

        public sample(sample obj) : this(obj.x)
        {
        }
    }

    class run
    {
        public static void Main(string[] args)
        {
            sample s = new sample(20);
            sample ss = new sample(s);

            System.Console.WriteLine(ss.x);
        }
    }

    这个示例程序的输出是

    20

    构造函数链接，也就是说，当您希望在单个调用中调用多个构造函数时，可以将"base"用于关系，将"this"用于同一类。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
      class BaseClass
    {
        public BaseClass():this(10)
        {
        }
        public BaseClass(int val)
        {
        }
    }
        class Program
        {
            static void Main(string[] args)
            {
                new BaseClass();
                ReadLine();
            }
        }