What are the types of constructors in C#? What do static and private constructors do, how does chaining work, and which runs first?

Say it out loud, then check

One morning, every constructor

The BMW FS dealer portal, in time order. Each step names the kind of constructor at work.

The story

1. Before

   A finance quote is a dealer's offer to a BMW FS customer: the car's price and the months to pay. Three parts of the system build quotes: the dealer portal, the mobile app and a nightly import of dealer files. Before, Quote had no constructor of its own (a constructor is the code that runs when new builds an object). Each part built an empty quote and filled it in, each with its own checks.

   Dealer portalchecks the price

   Mobile appchecks the price

   Nightly importno check

   new Quote()then fill in values

   1/4Before: three parts of the system build quotes. Each makes an empty one, then fills it in.Each part has its own copy of the price check. The nightly import's copy was never written.A dealer file has a blank price. The import builds the quote anyway, and it is emailed out.Fix: the constructor checks the values, and throws an error if one is bad. All three go through it.

   BackPlayNext
2. Why it had to change

   When building an object and checking it are two separate steps, one path will skip the check one day. The compiler can't warn you, because an empty quote is perfectly legal code.

3. How it works now

   A constructor makes building and checking one step: new can't hand out the object until the constructor has finished. Here is what .NET does for one new, step by step:

   CallerQuote​Service

   .NETruns new

   Checksin Quote

   The objectin memory

   new Quote(52,000, 36)

   1/6The caller writes new Quote(52_000m, 36)..NET makes room for one Quote in memory, every value 0. Nobody can see it yet.Then it runs the constructor whose parameters match the call: the checks in Quote.The constructor checks the values. They pass, so it stores them in the object.Only now does the caller get a reference (the address) to a ready quote.Price 0: the check throws ArgumentException, C#'s error for a bad value. No reference comes back.

   BackPlayNext
4. What we gained

   One checked door for every path, and an empty new Quote() doesn't compile any more. The rest of the card shows the other kinds of constructor; every one of them goes through that same door.

In the lending API

The four constructors of Quote. Each marked line is one constructor type; the diagram above shows them running.

Only the key lines are shown; Deep walks the whole file.

The code, file by file

The quote class from the lending API and the service that calls it. Tap Next to walk the diagram with the code: one quote started, then copied.

What they ask next

The follow-ups interviews really ask. Answer out loud, then tap to check.

• ReportedIf a class has a static constructor and a default constructor, which runs first?

  The static one, once, just before the class is first used. The default one runs on every new, after it. Two new calls in a row run the static one once and the default one twice.

  class Sample
  {
    static Sample() { } // once
    public Sample() { } // every new
  }
   
  new Sample(); // static, then default
  new Sample(); // default only

  Next questions, in Deep →Where this was reported
• ReportedCan a constructor be private? Why would you make one?

  Yes. Then only code inside the class can call new. The class decides how its objects are made: for a singleton it makes exactly one itself and hands it out. Other uses: a factory method (a static method like Create that builds the object for you), and a class of only static helpers, though a static class says that more clearly.

  public class RateCard
  {
    public static RateCard Instance { get; }
      = new RateCard();
   
    private RateCard() { }
  }
   
  RateCard a = RateCard.Instance;
  // fine: the one shared object
   
  RateCard b = new RateCard();
  // compile error: the constructor
  // is private (CS0122)

  Diagram + next questions →Where this was reported
• ReportedWhat is constructor chaining, and why use it?

  One constructor calling another before its own body runs: : this(...) for another constructor in the same class, : base(...) for the parent class's. The point is one place for the checks. Short constructors fill in defaults and hand over, so a new rule reaches every way of building the object.

  Next questions, in Deep →See the bug it prevents →Where this was reported

Follow-up tree

Answer, then open the next level. That is the order an interviewer digs in.

Reporteda candidate was asked Intervieweran interviewer asks it

• ReportedIf a class has a static constructor and a default constructor, which runs first?

  The static one, once, just before the class is first used. The default one runs on every new, after it. Two new calls in a row run the static one once and the default one twice.

  class Sample
  {
    static Sample() { } // once
    public Sample() { } // every new
  }
   
  new Sample(); // static, then default
  new Sample(); // default only

  Where this was reported
  • And when there is a parent class?

    On .NET, each class's static constructor runs at that class's first use, so with TruckQuote : Quote the child's runs first. The diagram walks it. The C# docs don't promise an order between classes, so never write code that depends on it.

    Programnew Truck​Quote

    Truck​Quotechild

    Quoteparent

    new

    Truck static

    1/4new TruckQuote(...) is the first use of TruckQuote: its static constructor runs.Then TruckQuote's field initializers, before any parent code.Calling the parent's constructor is the first use of Quote: its static, field, body.Back in TruckQuote: its constructor bodies run last.

    BackPlayNext

    Go to the live tasks →
  • When exactly does a static constructor run?

    Just before the first object of the class is built, or the first time a static member is used, whichever comes first. If the class is never used, it never runs. If two requests arrive at once, .NET lets one thread run it and makes the other wait.

  • ReportedCan a static constructor have parameters, or be public?

    No to both. Nobody calls it, so nobody could pass a value: static Quote(int x) is error CS0132, "a static constructor must be parameterless". public static Quote() is error CS0515. A class has at most one.

    Where this was reported
• ReportedCan a constructor be private? Why would you make one?

  Yes. Then only code inside the class can call new. The class decides how its objects are made: for a singleton it makes exactly one itself and hands it out. Other uses: a factory method (a static method like Create that builds the object for you), and a class of only static helpers, though a static class says that more clearly.

  public class RateCard
  {
    public static RateCard Instance { get; }
      = new RateCard();
   
    private RateCard() { }
  }
   
  RateCard a = RateCard.Instance;
  // fine: the one shared object
   
  RateCard b = new RateCard();
  // compile error: the constructor
  // is private (CS0122)

  QuoteServiceerror CS0122

  class RateCardprivate RateCard()

  1/3QuoteService tries new RateCard(). The constructor is private, so it doesn't compile.Inside the class, the static Instance line can call it. It runs once and builds the one object.Everyone reads RateCard.Instance and gets the same object.

  BackPlayNext

  Where this was reported
  • Can another class inherit from it?

    Not when all its constructors are private, as here. A child's constructor must call a parent constructor, and a private one can't be reached: class BigRateCard : RateCard fails with CS0122. A class written inside RateCard could, because it counts as inside.

  • Why not…Would you hand-write a singleton in a .NET API?

    Rarely. I register the class with AddSingleton in Program.cs (registering services). The container builds one object and hands it to every class that asks, the class keeps a normal constructor, and a test can pass in a fake. A static Instance can't be swapped in a test.

  • Is that static Instance safe with many threads?

    Yes. Instance gets its value from a static field initializer (no static constructor needed). That is part of the class's one-time static setup, which .NET runs once, on one thread, while any other thread that needs the class waits.

• ReportedWhat is constructor chaining, and why use it?

  One constructor calling another before its own body runs: : this(...) for another constructor in the same class, : base(...) for the parent class's. The point is one place for the checks. Short constructors fill in defaults and hand over, so a new rule reaches every way of building the object.

  See the bug it prevents →Where this was reported
  • Which body runs first?

    The one you chain to. new Quote(52_000m) runs the full constructor's body first, then the short one's. With base, the parent's body runs before the child's.

  • With : this(...), do field initializers run twice?

    No. They run once per object, in the constructor at the end of the chain, the one that calls the parent. A real run gives each quote one Id.

  • What if I write no : base(...)?

    C# adds : base() for you: the parent's constructor with no parameters. If the parent has none, the child doesn't compile: error CS7036, "no argument given that corresponds to the required parameter".

• ReportedDoes C# have a copy constructor?

  Not one it writes for you, for a class. You write a constructor that takes the same type. Records are different: the compiler writes a copy constructor, and with uses it, so quote with { TermMonths = 48 } is a new record with one value changed.

  Zobi Web Solutions: write one and name the types
  • Shallow or deep?

    Whatever you write. Copying a list field copies only the reference, so both objects share one list: a shallow copy. Copy the list itself too.

    See the bug →
  • Why not…Why not MemberwiseClone or ICloneable?

    MemberwiseClone is a shallow copy, and it is protected, so only the class or a child can call it. ICloneable never says whether its copy is deep or shallow, so Microsoft's design guidelines say not to use it in public APIs. A copy constructor shows exactly what is copied.

• What happens if a static constructor throws?

  The class is broken until the app restarts. The first use throws TypeInitializationException with the real error inside it, and every later use throws the same one, because .NET never runs the static constructor again. Only a restart fixes it.

  System.TypeInitializationException: The type
  initializer for 'Quote' threw an exception.
   ---> System.TimeoutException: Execution
        Timeout Expired.

  Walk the incident →
• Why not…Can a constructor call a virtual method?

  It can, but don't: the parent's constructor would run the child's version before the child's constructor body has run, so anything set there is still 0 or null. The four pillars card walks it.

• What is a primary constructor?

  C# 12 lets you write parameters on the class line, public class QuoteService(TermCatalog terms). Common for services that get their parts from the DI container. The full answer, and why business objects keep a normal constructor, is on the constructor page.

Production bugs, and how to tell them

Each one: what you see, why, the fix in code, and the line to say.

• Quick quotes skipped the new credit rule

  Audit finding, BMW FS credit risk:
  14 quotes over $250,000 were made in the
  portal, which must refuse them (a credit
  manager handles those). All 14 came from
  the Quick quote screen.
  (no exception, no error log)

  Cause

  Quote had two constructors, and each had its own copy of the checks. A new rule, "the portal refuses quotes over 250,000; a credit manager handles those outside it", was added to the full constructor only. The Quick quote screen calls new Quote(price), the short one, so the rule never ran.

  Fix

  The short constructor keeps no checks of its own and chains with : this(price, 36). Every rule now lives in one constructor. A test builds a Quick quote over 250,000 and expects it refused.

  BeforeAfterQuoteRuleTests.cs

  Diagram · step 1Before: two constructors, and each has its own copy of the price check.Show diagram

  class Quotetwo constructors

  Quote(price)own copy: price > 0

  Quote(price, term)price > 0

  1public Quote(decimal price, int termMonths)2{3 if (price <= 0)4 throw new ArgumentException(5 "Price must be above 0.");6 if (price > 250_000m)7 throw new ArgumentException(8 "Over 250,000: credit manager.");9 Price = price;10 TermMonths = termMonths;11}12 13public Quote(decimal price)14{15 if (price <= 0)16 throw new ArgumentException(17 "Price must be above 0.");18 Price = price;19 TermMonths = 36;20}

  Before · Quote.cs · line 1 · 1 of 4The full constructor, with its own price check.

  BackNext line

  Say it

  We had copied the checks into two constructors, and one copy went stale when a rule was added. Chaining puts every check in one constructor, so any new rule reaches every way of building a quote. The test proves the short path runs it too.

• A revised quote changed the one the customer had

  Customer email, BMW FS dealer support:
  "My quote from Friday now lists Tyre and
  rim cover. I never asked for it."
  (no exception, no error log)

  Cause

  Quote gained an Extras list (add-ons such as a service plan). The copy constructor did Extras = other.Extras, which copies the reference, not the list. Both quotes pointed at one list, so adding tyre cover to the revision added it to the sent quote, and the same request saved both.

  Fix

  Copy the list itself: new List<string>(other.Extras) builds a new list holding the same items (it is List's own copy constructor). A test adds to the copy and checks the original still has one extra.

  BeforeAfterQuoteCopyTests.cs

  Diagram · step 1The sent quote holds a reference to its list of extras: one service plan.Show diagram

  sentExtras →

  List of extrasService plan

  1public List<string> Extras { get; }2// The main constructor starts it empty.3 4public Quote(Quote other)5 : this(other.Price, other.TermMonths)6{7 Extras = other.Extras;8}

  Before · Quote.cs · line 1 · 1 of 2The add-ons on this quote. Each quote should own its list.

  BackNext line

  Say it

  Our copy constructor was a shallow copy: it copied the reference to the list, not the list. Both quotes shared it, so changing the revision changed the sent quote. Now the constructor copies every list the quote owns, and a test proves the original doesn't change.

Traps

• Don't sayEvery class has a default constructor.SayOnly a class with no constructor written. Write any constructor and the free one is gone.
• Don't sayThe static constructor runs every time you create an object.SayOnce per class, for as long as the app runs, before the class is first used.
• Don't sayWith chaining, the constructor you called runs first.SayThe one it chains to runs first. The one you called finishes last.
• Don't sayThe parent's static constructor always runs before the child's.SayOn .NET, new Child() runs the child's static constructor first; the parent's runs when the parent is first touched. The docs don't promise an order, so don't depend on it.
• Don't sayA copy constructor copies everything.SayIt copies what you write. Copy a list field and both objects share one list; copy the list too.

Traps

What should you say instead? Tap to check.

• Don't sayEvery class has a default constructor.

  Say instead

  Only a class with no constructor written. Write any constructor and the free one is gone.

• Don't sayThe static constructor runs every time you create an object.

  Say instead

  Once per class, for as long as the app runs, before the class is first used.

• Don't sayWith chaining, the constructor you called runs first.

  Say instead

  The one it chains to runs first. The one you called finishes last.

• Don't sayThe parent's static constructor always runs before the child's.

  Say instead

  On .NET, new Child() runs the child's static constructor first; the parent's runs when the parent is first touched. The docs don't promise an order, so don't depend on it.

• Don't sayA copy constructor copies everything.

  Say instead

  It copies what you write. Copy a list field and both objects share one list; copy the list too.