Lesson 10. Interfaces

Mission link: An interface is where a C# model states what it promises rather than what it stores, and since C# 8 it can also carry implementations, which changes both what belongs in one and how a caller reaches it.
Primary source: Docs: "interface (C# Reference)", Microsoft Learn
Prerequisites: Lesson 9, Lesson 8

Warm-up

1. ▢ A switch expression's arms are all list patterns and it compiles with no warnings. What have you not been told?

2. ▢ What does x is { } value do?

3. ▢ A record has an init-only property of type string[]. Can a caller change the contents of that array?

Know this

An interface defines a contract, and now it can also carry implementations. Any class, record or struct implementing an interface must provide implementations of its members, and since C# 8 the interface itself may supply a default implementation for a member, along with static members providing one shared implementation of common functionality (interface).

The list of what an interface declaration may contain is longer than a Java background expects: methods, properties, indexers, events, constants, operators, a static constructor, nested types, and static fields, methods, properties, indexers and events. Access modifiers are explicit and any of them are allowed on interface members, with public the default for abstract methods.

What it may not contain is instance state, and the rule has a trap in it. Static fields are permitted; instance fields are not. Instance auto-properties are not supported either, because they would implicitly declare a hidden field. That produces the subtlest gotcha in this lesson:

public string Name { get; set; }

In a class or struct that declares an auto-implemented property with a compiler-generated field. In an interface it declares no such thing: it declares a property with no default implementation, which every implementing type must implement. Identical syntax, opposite meaning, and no diagnostic to tell you which one you wrote.

Why default implementations exist: versioning. The feature's purpose is adding a member to a published interface without breaking every existing implementer. Give the new member a default and code that already implements the interface keeps compiling, which is what makes an interface safe to extend at all.

The tutorial's own refinement is worth copying. Put the logic in a protected static helper on the interface and have the default member call it, so an implementing class that wants to extend the behaviour rather than replace it can call the same helper and add to its result. Without that, an implementer's only options are accepting the default or rewriting it from scratch.

Note what makes this workable given the no-instance-state rule: the interface may hold private static fields, which is how the tutorial parameterises its default implementation, with a public static method to set them. So a default implementation may use the interface's own statics plus whatever it can read through the interface's members, and nothing else.

A default member is not automatically part of the class's own surface. Start with the case the documentation spells out. If a class implements two interfaces declaring a member with the same signature, one class member serves both, and all three of sample.Paint(), control.Paint() and surface.Paint() call it. When you need the two interfaces to behave differently, you write an explicit interface implementation, prefixing the member name with the interface name, and the documentation states the consequence directly: such a member is only called through the specified interface. In its example, sample.Paint() is not accessible at all, and the call goes through sample as IControl.

The same shape governs default members. A class implementing the interface may override a default member either as a public method or as an explicit interface implementation. If it does neither, the implementation still lives on the interface rather than on the class, so calls reach it through an interface-typed reference rather than through the class. This is where the Java comparison matters most: a Java default method arrives on the implementing type as an inherited method you can just call, while in C# the useful mental model is that the class either declares the member or you talk to the interface.

Interface inheritance, in two rules. An interface may inherit from one or more base interfaces, and a type implementing the derived interface must implement the base interfaces' members as well as the derived one's. And when an interface overrides a method implemented in a base interface, it must use the explicit interface implementation syntax.

One forward pointer: an interface can also declare static abstract or static virtual members, requiring an implementing type to provide them, which is typically how an implementation is made to declare a set of overloaded operators. That belongs with generics, which is the next lesson.

Practice

1. ▢ You write public string Name { get; set; } inside an interface. What have you declared, and what would the same line mean in a class?

2. ▢ SampleClass implements IControl and ISurface, both declaring void Paint(). First it declares one public void Paint(). Then you change it so each interface behaves differently. What changes for a caller holding a SampleClass?

3. ▢ You maintain a published library with an ICustomer interface, and you need to add a ComputeLoyaltyDiscount member. How do you do it without breaking existing implementers, and how do you leave room for one to extend rather than replace your logic?

4. ▢ An interface cannot hold instance fields. How can a default implementation be parameterised at all?

5. ▢ Which claim about fields in an interface is correct?

   • a) An interface may declare instance fields as long as they stay private
   • b) An interface may declare static fields but never instance fields or auto-properties
   • c) An interface may declare no fields at all, whether static or instance
   • d) An interface may declare instance auto-properties, which the compiler backs with fields

Real-world reps

• [ ] Find an interface in C# you have access to that declares a property. Check whether any implementing type would be surprised to learn it must implement it, and whether the interface actually wanted an abstract class.
• [ ] Find a type implementing two interfaces. Work out whether any member serves both, and whether that is intentional.
• [ ] Tomorrow: take an interface you would like to add a method to, and write both versions: the breaking one and the one with a default implementation plus a protected static helper. Decide what the second version commits you to maintaining.

Going further

• Docs: "interface (C# Reference)", Microsoft Learn
• Docs: "Safely update interfaces using default interface methods", Microsoft Learn
• Docs: "Explicit Interface Implementation", Microsoft Learn
• Resources

Not landing? Reread the primary source at the top, since this lesson compresses it and compression is where understanding leaks. Check the glossary for any term that felt slippery.

If the lesson itself is unclear rather than the material, that is a defect: open an issue.