C# Constructor - chain AFTER iniitalization?

In the above, the constructor that takes an object as its parameter calls the constructor that takes a string (using the "this" operator).

You can use private methods, and call them from your constructors.

public class MyClass
{
  private int _myParam;
  private object _myObject;

  private void MyInit(object MyObject, int MyInt)
  {
    if(MyObject == null)
      _myObject = MyObject;
    else
      _myParam = MyInt;
  }

  public MyClass(int myParam)
  {
    MyInit(null, myParam);
  }

  public MyClass(object MyObject)
  {
    MyInit(MyObject, 0);
  }
}

Select allOpen in new window

folks - please don't take my example literally..i'm trying to express my point.  I completely understand how chaining works, I'm trying to see if there's a mechanism to initialize before chaining.

if not, then there's the possibility that the constructor throws a NullReferenceException instead of an ArgumentNullException. Here's a more well-formed example:

var test = Class1("abc", null)
this will throw a NullReferenceException, instead of an ArgumentNullException, which is more desireable

public class Class1
{
    public Class1(string a)
    {
    }

    public Class1(string b, MyObject c) : this( b + c.ToString() )
    {
    }
}

Select allOpen in new window

And then do the actual work of initializing your object in myInit instead of directly in the constructor.

tgerbert - what if I want myInit(string b) to be public?  its a completely valid publically available constructor in my case.

Ah! I could make myInit(string b) public, and have it call a private function that validates and stores the parameters.  the second constructor could do the same.  instead of chaining, it can call the same private function.  i guess this is the best I could do?

myInit isn't a constructor.  It's a private "worker" method that is called by the already publically accessible constructors.  This way, your constructor can make decisions and call the appropriate worker.  So in my little example above you can do either:

Class1 myObj = new Class1("Hello World", null);

or

Class1 myObj = new Class1("Hello", "world");

I think you've got it - just to clarify, in my code snippet above line 7 is the public constructor, which is calling the private function myInit.

tgerbert - correct, I understood the purpose of the private function.  What I was saying is that the private function itself defines a valid set of Constructor Parameters.  In your example, there was no pubic constructor that took just one string, which is a valid constructor in my case.

Basically the answer is that there's no good way to error-check and chain in my example.  You either chain and get NullReference or you Initializes and lose the benefits of chaining.