What is the difference between a class and an object, and what types of constructors does C# have?

Say it out loud, then check

One object and two constructors

Follow one loan from the first new to a rejected rate, and watch which constructor runs when.

The story

1. Before

   Before this, a quote could be created empty, saved, and given a rate later. A typo or a skipped field produced a row that looked fine until a repayment schedule divided by a zero rate. Nobody could say where the bad state entered, because every setter accepted anything.

In the lending API

The key file: the static part runs once, the checks run for every object, and the overload chains to them.

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

The code, file by file

Two files and a caller, .NET 8. Tap Next to follow the first new, a second object, a chained overload, a private constructor and a rejected rate.

What they ask next

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

• ReportedWhat are the different types of constructors?

  Instance constructors: parameterless (often called the default constructor) and parameterized/overloaded. Static constructors initialize the type itself. Private constructors restrict creation. C# has no separate copy constructor; it is an ordinary constructor that takes the same type.

  Next questions, in Deep →Where this was reported
• ReportedWhat is the difference between a class and an object?

  A class is the type you declare once: fields, properties, methods, and the rules. An object is one instance of that type at run time, with its own field values. The class is the compiler's contract; the object is the thing in memory.

  Next questions, in Deep →Where this was reported
• ReportedWhat is constructor chaining, and in what order do the parts run?

  Chaining is one constructor calling another before its own body. this(...) calls another constructor of the same class; base(...) calls the parent's constructor. The target constructor runs first, including field initializers, then your body.

  Next questions, in Deep →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

• ReportedWhat are the different types of constructors?

  Instance constructors: parameterless (often called the default constructor) and parameterized/overloaded. Static constructors initialize the type itself. Private constructors restrict creation. C# has no separate copy constructor; it is an ordinary constructor that takes the same type.

  Where this was reported
  • ReportedIf a class has a static constructor and a default constructor, which runs first?

    The static one. The type is initialized before the first instance is created: static field initializers, then the static constructor body. Then, for the object, instance field initializers, then the instance constructor body. The one exception is a static field initializer that creates the class itself; that instance constructor runs first.

    Where this was reported
  • ReportedCan a static constructor take arguments?

    No. It takes no parameters and has no access modifier, and the runtime calls it; you cannot call it yourself. It runs once per type per process.

    Where this was reported
  • If I write only a static constructor, does C# still add a public parameterless one?

    Yes. A static constructor does not count as an instance constructor, so the compiler still adds a public parameterless instance constructor when no instance constructor is declared.

    public class Loan
    {
      static Loan() { }
    }
    var l = new Loan(); // allowed

• ReportedWhat is the difference between a class and an object?

  A class is the type you declare once: fields, properties, methods, and the rules. An object is one instance of that type at run time, with its own field values. The class is the compiler's contract; the object is the thing in memory.

  Where this was reported
  • Where does the object live?

    A class is a reference type, so the object lives on the managed heap. The variable holds a reference to it. Two variables can point at one object; copying the variable copies the reference, not the object. Reference types.

  • Is a class itself an object?

    At run time the runtime has a type object that describes the class, reachable through typeof. But that is metadata, not an instance of your class. Your class's constructor creates instances of the class, not new types.

• ReportedWhat is constructor chaining, and in what order do the parts run?

  Chaining is one constructor calling another before its own body. this(...) calls another constructor of the same class; base(...) calls the parent's constructor. The target constructor runs first, including field initializers, then your body.

  Where this was reported
  • Why chain instead of copying the validation?

    One place owns the invariant (a rule the object must always satisfy, such as rate > 0). Every overload reaches the same checks, so a new overload cannot silently skip one. The overload usually supplies a default, then delegates.

    public Loan(decimal amount)
      : this(amount, 9.5m, 60) { }

  • Does the base constructor run before or after the child's field initializers?

    After. In C#, the child's instance field initializers run, then the base constructor runs its own field initializers and body, then the child's body. This surprises people who expect the parent to run first.

    class Child : Parent
    {
      int _x = Log("child field");
    }

• When would you use a private constructor?

  Three common cases: a factory that controls creation and returns a cached or validated instance; a singleton; and a class with only static members in older code, where a static class is the modern choice. A class whose only constructors are private also cannot be subclassed from outside: class Child : Loan fails to compile, because a child cannot call a base constructor.

  Where this was reported
  • What is the difference between a private constructor and a sealed class?

    A private constructor stops outside code creating the type (and stops subclassing). sealed stops subclassing but still allows a public constructor and normal instances. They solve different problems.

• What happens if you declare no constructor at all?

  C# adds a public parameterless instance constructor that does nothing beyond the field initializers and the base call. It disappears as soon as you declare any instance constructor, so adding one can break callers that used new Foo().

  var l = new Loan(); // compiler-added ctor
   
  public class Loan { }

• Does C# have a copy constructor?

  Not built in. You can write a constructor that takes the same type and copies fields. For reference fields, choose shallow (share the reference) or deep (copy the inner objects too, so the copy cannot change the original).

  public Loan(Loan other)
  {
    Amount = other.Amount;
    _charges = new List<Charge>(other._charges);
  }

• Can a constructor be async?

  No. A constructor cannot be async (marked to run asynchronously) and cannot await (pause until an async call finishes), because an object must be fully built before the caller gets the reference. Use a static async factory that awaits the work, then calls a private constructor with the finished values.

  // _repo is a static data-access object
  private static readonly ILoanRepo _repo
    = new LoanRepo();
   
  public static async Task<Loan>
    LoadAsync(int id)
  {
    var data = await _repo.GetAsync(id);
    return new Loan(data);
  }

• What is a primary constructor in C# 12?

  Parameters written on the class declaration itself, captured by the class (stored as fields its methods can use). They are a concise way to receive constructor arguments, not a replacement for validation: the compiler does not add checks. Use them for small classes, and still validate in the body or a helper.

• Why validate in the constructor instead of a setter or a service?

  The constructor is the only place every instance must pass through. If it rejects invalid input, no later method needs to defend against it, and the failure names the row that supplied the values. Setters can be forgotten; a service can be bypassed.

Traps

• Don't saySay the static constructor runs once per object.SayIt runs once per type for the life of the process, before the first object or static member is used.
• Don't saySay the base constructor always runs before the child's field initializers.SayIn C#, the child's field initializers run first, then the base constructor, then the child's body.
• Don't saySay a private constructor makes the class sealed.SayIt blocks outside new, and a class with only private constructors cannot be subclassed from outside, but sealed is the explicit keyword for stopping inheritance.
• Don't saySay C# has a default copy constructor.SayIt does not; a copy constructor is one you write, and you choose shallow or deep copying.
• Don't sayPut a database or file read in a static constructor.SayIt runs once and its failure is cached, so there is no retry until the process restarts. Build it at start-up and fail the deploy instead.

Traps

What should you say instead? Tap to check.

• Don't saySay the static constructor runs once per object.

  Say instead

  It runs once per type for the life of the process, before the first object or static member is used.

• Don't saySay the base constructor always runs before the child's field initializers.

  Say instead

  In C#, the child's field initializers run first, then the base constructor, then the child's body.

• Don't saySay a private constructor makes the class sealed.

  Say instead

  It blocks outside new, and a class with only private constructors cannot be subclassed from outside, but sealed is the explicit keyword for stopping inheritance.

• Don't saySay C# has a default copy constructor.

  Say instead

  It does not; a copy constructor is one you write, and you choose shallow or deep copying.

• Don't sayPut a database or file read in a static constructor.

  Say instead

  It runs once and its failure is cached, so there is no retry until the process restarts. Build it at start-up and fail the deploy instead.