Chapter 3 - Creating Types in C#
Classes
Fields
// A field is a variable that is a member of a class or struct.
var o = new Octopus();
o.Age.Dump();
class Octopus
{
string name;
public int Age = 10;
static readonly int legs = 8, eyes = 1;
}
Fields - readonly
// Readonly fields let you create *immutable* classes.
var o = new Octopus ("Jack");
o.Name.Dump();
o.Legs = 20; // Compile-time error
class Octopus
{
public readonly string Name;
public readonly int Legs = 8;
public Octopus (string name)
{
Name = name;
}
}
Constants - scoped to class
// Constants are factored out at compile-time and baked into the calling site.
Test.Message.Dump();
public class Test
{
public const string Message = "Hello World";
}
Constants - scoped to method
// Here, the calculation is performed at compile-time:
const double twoPI = 2 * System.Math.PI;
twoPI.Dump();
Methods - Expression-bodied
// Foo1 and Foo2 are equivalent:
Foo1 (10).Dump();
Foo2 (10).Dump();
int Foo1 (int x) { return x * 2; }
int Foo2 (int x) => x * 2;
Local methods
void Main()
{
WriteCubes();
}
void WriteCubes()
{
Console.WriteLine (Cube (3));
Console.WriteLine (Cube (4));
Console.WriteLine (Cube (5));
int Cube (int value) => value * value * value;
}
Local methods - with top-level statements
// When you use top-level statements, your methods are implicitly local.
// We can verify this by trying to access a variable outside the method:
int x = 3;
Foo();
// Foo is a local method
void Foo() => Console.WriteLine (x); // We can access x
Methods - Overloading
// We can overload Foo as follows:
void Foo (int x) { "int".Dump(); }
void Foo (double x) { "double".Dump(); }
void Foo (int x, float y) { "int, float".Dump(); }
void Foo (float x, int y) { "float, int".Dump(); }
// We have to use a Main() method here to test this,
// because methods in top-level statements are *local methods*
// which cannot be overloaded.
void Main()
{
Foo (123); // int
Foo (123.0); // double
Foo (123, 123F); // int, float
Foo (123F, 123); // float, int
}
Methods - Illegal Overloading
// The following overloads are prohibited:
void Foo (int x);
float Foo (int x); // Compile-time error
void Goo (int[] x);
void Goo (params int[] x); // Compile-time error
void Hoo (int x);
void Hoo (ref int x); // OK so far
void Hoo (out int x); // Compile-time error
void Main() {}
Constructors
Panda p = new Panda ("Petey"); // Call constructor
public class Panda
{
string name; // Define field
public Panda (string n) // Define constructor
{
name = n; // Initialization code (set up field)
}
}
Constructors - Overloading
// You can also overload constructors.
// Note the use of the "this" keyword to call another constructor:
new Wine (78).Dump();
new Wine (78, 2001).Dump();
public class Wine
{
public decimal Price;
public int Year;
public Wine (decimal price) { Price = price; }
public Wine (decimal price, int year) : this (price) { Year = year; }
}
Constructors - Nonpublic
// A common reason to have a nonpublic constructor is to control instance creation via a
// static method call:
Class1 c1 = Class1.Create(); // OK
Class1 c2 = new Class1(); // Error: Will not compile
public class Class1
{
Class1() { } // Private constructor
public static Class1 Create()
{
// Perform custom logic here to create & configure an instance of Class1
/* ... */
return new Class1();
}
}
Deconstructors
// To call the deconstructor, we use the following special syntax:
var rect = new Rectangle (3, 4);
(float width, float height) = rect; // Deconstruction
Console.WriteLine (width + " " + height); // 3 4
// We can also use implicit typing:
var (x, y) = rect; // Deconstruction
Console.WriteLine (x + " " + y);
// If the variables already exist, we can do a *deconstructing assignment*:
(x, y) = rect;
Console.WriteLine (x + " " + y);
class Rectangle
{
public readonly float Width, Height;
public Rectangle (float width, float height)
{
Width = width;
Height = height;
}
public void Deconstruct (out float width, out float height)
{
width = Width;
height = Height;
}
}
Object Initializers
// Fields or properties can be initialized in a single statement directly after construction:
// Object initialization syntax. Note that we can still specify constructor arguments:
Bunny b1 = new Bunny { Name="Bo", LikesCarrots=true, LikesHumans=false };
Bunny b2 = new Bunny ("Bo") { LikesCarrots=true, LikesHumans=false };
b1.Dump(); b2.Dump();
public class Bunny
{
public string Name;
public bool LikesCarrots;
public bool LikesHumans;
public Bunny () {}
public Bunny (string n) { Name = n; }
}
Object Initializer Alternative - Optional Parameters
// Instead of using object initializers, we could make Bunny’s constructor accept optional parameters.
// This has both pros and cons (see book):
Bunny b = new Bunny (
name: "Bo",
likesCarrots: true);
b.Dump();
public class Bunny
{
public string Name;
public bool LikesCarrots;
public bool LikesHumans;
public Bunny (
string name,
bool likesCarrots = false,
bool likesHumans = false)
{
Name = name;
LikesCarrots = likesCarrots;
LikesHumans = likesHumans;
}
}
The this Reference
// The this reference refers to the instance itself:
new Panda().Marry (new Panda());
public class Panda
{
public Panda Mate;
public void Marry (Panda partner)
{
Mate = partner;
partner.Mate = this;
}
}
Properties
// Properties look like fields from the outside but internally, they contain logic, like methods:
var stock = new Stock();
stock.CurrentPrice = 123.45M;
stock.CurrentPrice.Dump();
var stock2 = new Stock { CurrentPrice = 83.12M };
stock2.CurrentPrice.Dump();
public class Stock
{
decimal currentPrice; // The private "backing" field
public decimal CurrentPrice // The public property
{
get { return currentPrice; } set { currentPrice = value; }
}
}
Properties - calculated & read-only
// The Worth Property is a read-only calculated property.
var stock = new Stock { CurrentPrice = 50, SharesOwned = 100 };
stock.Worth.Dump();
public class Stock
{
decimal currentPrice; // The private "backing" field
public decimal CurrentPrice // The public property
{
get { return currentPrice; } set { currentPrice = value; }
}
decimal sharesOwned; // The private "backing" field
public decimal SharesOwned // The public property
{
get { return sharesOwned; } set { sharesOwned = value; }
}
public decimal Worth
{
get { return currentPrice * sharesOwned; }
}
}
Properties - expression-bodied
// The Worth Property is now an expression-bodied property.
var stock = new Stock { CurrentPrice = 50, SharesOwned = 100 };
stock.Worth.Dump();
public class Stock
{
decimal currentPrice; // The private "backing" field
public decimal CurrentPrice // The public property
{
get { return currentPrice; } set { currentPrice = value; }
}
decimal sharesOwned; // The private "backing" field
public decimal SharesOwned // The public property
{
get { return sharesOwned; } set { sharesOwned = value; }
}
public decimal Worth => currentPrice * sharesOwned; // Expression-bodied property
// From C# 7, we can take this further, and write both the get and set accessors in
// expression-bodied syntax:
public decimal Worth2
{
get => currentPrice * sharesOwned;
set => sharesOwned = value / currentPrice;
}
}
Automatic Properties
// Here's the preceding example rewritten with two automatic properties:
var stock = new Stock { CurrentPrice = 50, SharesOwned = 100 };
stock.Worth.Dump();
public class Stock
{
public decimal CurrentPrice { get; set; } // Automatic property
public decimal SharesOwned { get; set; } // Automatic property
public decimal Worth
{
get { return CurrentPrice * SharesOwned; }
}
}
Property Initializers
var stock = new Stock();
stock.CurrentPrice.Dump();
stock.Maximum.Dump();
public class Stock
{
public decimal CurrentPrice { get; set; } = 123;
public int Maximum { get; } = 999;
}
Properties - get & set accessibility
// In this example, the set accessors are private while the get accessors are public:
new Foo { X = 5 }; // Will not compile - X has a private set accessor.
public class Foo
{
private decimal x;
public decimal X
{
get { return x; }
private set { x = Math.Round (value, 2); }
}
public int Auto { get; private set; } // Automatic property
}
Indexers
// You can implement custom indexers with the this keyword:
Sentence s = new Sentence();
Console.WriteLine (s[3]); // fox
s[3] = "kangaroo";
Console.WriteLine (s[3]); // kangaroo
// Test the indexers that use C#'s Indices and Ranges:
Console.WriteLine (s [^1]); // fox
string[] firstTwoWords = s [..2].Dump(); // (The, quick)
class Sentence
{
string[] words = "The quick brown fox".Split();
public string this [int wordNum] // indexer
{
get { return words [wordNum]; }
set { words [wordNum] = value; }
}
// From C# 8, we can also define indexers that use the Index & Range types:
public string this [Index index] => words [index];
public string[] this [Range range] => words [range];
}
Static Constructors
// A static constructor executes once per type, rather than once per instance:
// Type is initialized only once
new Test();
new Test();
new Test();
class Test
{
static Test()
{
Console.WriteLine ("Type Initialized");
}
}
Static Constructors & Field Initialization Order
// Static field initializers run just before the static constructor is called:
Foo.X.Dump ("X"); // 0
Foo.Y.Dump ("Y"); // 3
class Foo
{
public static int X = Y; // 0
public static int Y = 3; // 3
}
Static Constructors & Field Initialization Order (Constructor Call)
// Another way to go awry:
Console.WriteLine (Foo.X); // 3
Util.NewProcess = true; // Force LINQPad to create new process on each run.
class Foo
{
public static Foo Instance = new Foo();
public static int X = 3;
Foo() => Console.WriteLine (X); // 0
}
Partial Types
// Partial types allow a type definition to be split—typically across multiple files:
new PaymentForm { X = 3, Y = 4 }.Dump();
partial class PaymentForm { public int X; }
partial class PaymentForm { public int Y; }
Partial Methods
// A partial type may contain partial methods. These let an auto-generated partial type
// provide customizable hooks for manual authoring.
var paymentForm = new PaymentForm (50);
partial class PaymentForm // In auto-generated file
{
public PaymentForm (decimal amount)
{
ValidatePayment (amount);
// ...
}
partial void ValidatePayment (decimal amount);
}
partial class PaymentForm // In hand-authored file
{
partial void ValidatePayment (decimal amount)
{
if (amount < 100)
throw new ArgumentOutOfRangeException ("amount", "Amount too low!");
}
}
Extended Partial Methods
// The presence of an accessiblity modifier on a partial method denotes an 'extended partial method'.
// Extended partial methods *must* have implementations:
public partial class Test
{
public partial void M1(); // Extended partial method
private partial void M2(); // Extended partial method
public partial bool IsValid (string identifier);
internal partial bool TryParse (string number, out int result);
}
public partial class Test
{
public partial void M1() { }
private partial void M2() {}
public partial bool IsValid (string identifier) => !string.IsNullOrEmpty (identifier);
internal partial bool TryParse (string number, out int result) => int.TryParse (number, out result);
}
The nameof operator
int count = 123;
nameof (count).Dump ("count");
nameof (StringBuilder.Length).Dump ("Length property on StringBuilder");
(nameof (StringBuilder) + "." + nameof (StringBuilder.Length)).Dump ("StringBuilder.Length");
Inheritance
Inheritance
// A class can inherit from another class to extend or customize the original class.
Stock msft = new Stock { Name = "MSFT", SharesOwned = 1000 };
Console.WriteLine (msft.Name); // MSFT
Console.WriteLine (msft.SharesOwned); // 1000
House mansion = new House { Name = "Mansion", Mortgage = 250000 };
Console.WriteLine (mansion.Name); // Mansion
Console.WriteLine (mansion.Mortgage); // 250000
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
Polymorphism
// A variable of type x can refer to an object that subclasses x.
// The Display method below accepts an Asset. This means means we can pass it any subtype:
Display (new Stock { Name="MSFT", SharesOwned=1000 });
Display (new House { Name="Mansion", Mortgage=100000 });
void Display (Asset asset)
{
Console.WriteLine (asset.Name);
}
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
Reference Conversions - Upcasting
// An upcast creates a base class reference from a subclass reference:
Stock msft = new Stock();
Asset a = msft; // Upcast
// After the upcast, the two variables still references the same Stock object:
Console.WriteLine (a == msft); // True
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
Reference Conversions - Downcasting
// A downcast operation creates a subclass reference from a base class reference.
Stock msft = new Stock();
Asset a = msft; // Upcast
Stock s = (Stock)a; // Downcast
Console.WriteLine (s.SharesOwned); // <No error>
Console.WriteLine (s == a); // True
Console.WriteLine (s == msft); // True
// A downcast requires an explicit cast because it can potentially fail at runtime:
House h = new House();
Asset a2 = h; // Upcast always succeeds
Stock s2 = (Stock)a2; // ERROR: Downcast fails: a is not a Stock
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
The is operator
// The is operator tests whether a reference conversion (or unboxing conversion) would succeed:
Asset a = new Asset();
if (a is Stock)
Console.WriteLine (((Stock)a).SharesOwned);
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
The is operator and pattern variables
// The is operator tests whether a reference conversion (or unboxing conversion) would succeed:
Asset a = new Stock { SharesOwned = 3 };
if (a is Stock s)
Console.WriteLine (s.SharesOwned);
// We can take this further:
if (a is Stock s2 && s2.SharesOwned > 100000)
Console.WriteLine ("Wealthy");
else
s2 = new Stock(); // s is in scope
Console.WriteLine (s2.SharesOwned); // Still in scope
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
The as operator
// The as operator performs a downcast that evaluates to null (rather than throwing an exception)
// if the downcast fails.
Asset a = new Asset();
Stock s = a as Stock; // s is null; no exception thrown
if (s != null) Console.WriteLine (s.SharesOwned); // Nothing written
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
Virtual Function Members
// A function marked as virtual can be overridden by subclasses wanting to provide a
// specialized implementation:
House mansion = new House { Name="McMansion", Mortgage=250000 };
Console.WriteLine (mansion.Liability); // 250000
public class Asset
{
public string Name;
public virtual decimal Liability => 0; // Virtual
}
public class House : Asset
{
public decimal Mortgage;
public override decimal Liability => Mortgage; // Overridden
}
public class Stock : Asset
{
public long SharesOwned;
// We won't override Liability here, because the default implementation will do.
}
Covariant returns
// From C# 9, we can override a method such that it returns a more derived (subclased) type:
House mansion1 = new House { Name = "McMansion", Mortgage = 250000 };
House mansion2 = mansion1.Clone();
public class Asset
{
public string Name;
public virtual Asset Clone() => new Asset { Name = Name };
}
public class House : Asset
{
public decimal Mortgage;
// We can return House when overriding:
public override House Clone() => new House { Name = Name, Mortgage = Mortgage };
}
Abstract Classes & Members
// A class declared as abstract can never be instantiated. Instead, only its concrete subclasses
// can be instantiated. Abstract classes are able to define abstract members.
new Stock { SharesOwned = 200, CurrentPrice = 123.45M }.NetValue.Dump();
public abstract class Asset // Note abstract keyword
{
public abstract decimal NetValue { get; } // Note empty implementation
}
public class Stock : Asset
{
public long SharesOwned;
public decimal CurrentPrice;
// Override like a virtual method.
public override decimal NetValue => CurrentPrice * SharesOwned;
}
Hiding Inherited Members with new
// A base class and a subclass may define identical members. This usually happens by accident:
B b = new B();
b.Counter.Dump(); // 2
// Notice the non-virtual behavior in the code below:
A referenceConvertedB = b;
referenceConvertedB.Counter.Dump(); // 1
public class A { public int Counter = 1; }
public class B : A { public int Counter = 2; }
// Occasionally, you want to hide a member deliberately, in which case you can apply the new
// modifier to the member in the subclass, to avoid the compiler warning. The behavior is the same:
public class X { public int Counter = 1; }
public class Y : X { public new int Counter = 2; }
new vs virtual
Overrider over = new Overrider();
BaseClass b1 = over;
over.Foo(); // Overrider.Foo
b1.Foo(); // Overrider.Foo
Hider h = new Hider();
BaseClass b2 = h;
h.Foo(); // Hider.Foo
b2.Foo(); // BaseClass.Foo
public class BaseClass
{
public virtual void Foo() { Console.WriteLine ("BaseClass.Foo"); }
}
public class Overrider : BaseClass
{
public override void Foo() { Console.WriteLine ("Overrider.Foo"); }
}
public class Hider : BaseClass
{
public new void Foo() { Console.WriteLine ("Hider.Foo"); }
}
Sealing Functions & Classes
// An overridden function member may seal its implementation with the sealed keyword to prevent it
// from being overridden by further subclasses:
House mansion = new House { Name="McMansion", Mortgage=250000 };
Console.WriteLine (mansion.Liability); // 250000
public class Asset
{
public string Name;
public virtual decimal Liability => 0; // Virtual
}
public class House : Asset
{
public decimal Mortgage;
public sealed override decimal Liability => Mortgage; // Overridden + sealed
}
// You can also seal the class itself, implicitly sealing all the virtual functions:
public sealed class Stock : Asset { /* ... */ }
Constructors & Inheritance
// A subclass must declare its own constructors. In doing so, it can call any of the
// base class’s constructors with the base keyword:
new Subclass (123);
public class Baseclass
{
public int X;
public Baseclass () { }
public Baseclass (int x) { this.X = x; }
}
public class Subclass : Baseclass
{
public Subclass (int x) : base (x) { }
}
Implicit Calling of the Parameterless Base Class Constructor
// If a constructor in a subclass omits the base keyword, the base type’s parameterless
// constructor is implicitly called:
new Subclass();
public class BaseClass
{
public int X;
public BaseClass() { X = 1; }
}
public class Subclass : BaseClass
{
public Subclass() { Console.WriteLine (X); } // 1
}
Overloading and Resolution
// When calling an overload method, the method with the most specific
// parameter type match has precedence, based on the *compile-time* variable type:
void Main()
{
Foo (new House()); // Calls Foo (House)
Asset a = new House();
Foo (a); // Calls Foo (Asset)
}
static void Foo (Asset a) { "Foo Asset".Dump(); }
static void Foo (House h) { "Foo House".Dump(); }
public class Asset
{
public string Name;
}
public class Stock : Asset // inherits from Asset
{
public long SharesOwned;
}
public class House : Asset // inherits from Asset
{
public decimal Mortgage;
}
The object Type
The object Type
// object (System.Object) is the ultimate base class for all types. Any type can be
// implicitly converted to object; we can leverage this to write a general-purpose Stack:
Stack stack = new Stack();
stack.Push ("sausage");
string s = (string)stack.Pop(); // Downcast, so explicit cast is needed
Console.WriteLine (s); // sausage
// You can even push value types:
stack.Push (3);
int three = (int)stack.Pop();
public class Stack
{
int position;
object[] data = new object [10];
public void Push (object obj) { data [position++] = obj; }
public object Pop() { return data [--position]; }
}
// Because Stack works with the object type, we can Push and Pop instances of any type
// to and from the Stack:
Boxing & Unboxing
// Boxing is the act of casting a value-type instance to a reference-type instance;
// unboxing is the reverse.
int x = 9;
object obj = x; // Box the int
int y = (int)obj; // Unbox the int
y.Dump();
Unboxing to Wrong Type
// When unboxing, the types must match exactly:
object obj = 9; // 9 is inferred to be of type int
long x = (long) obj; // InvalidCastException
Unboxing to Wrong Type - Fix
object obj = 9;
// First, unbox to the correct type (int), then implicitly convert to long:
long x = (int) obj;
x.Dump();
// This also works:
object obj2 = 3.5; // 3.5 is inferred to be of type double
int y = (int) (double) obj2; // x is now 3
y.Dump();
Copying Semantics of Boxing & Unboxing
// Boxing copies the value-type instance into the new object, and unboxing copies
// the contents of the object back into a value-type instance.
int i = 3;
object boxed = i;
i = 5;
Console.WriteLine (boxed); // 3
GetType and typeof
// All types in C# are represented at runtime with an instance of System.Type.
// There are two basic ways to get a System.Type object:
// • Call GetType on the instance.
// • Use the typeof operator on a type name.
Point p = new Point();
Console.WriteLine (p.GetType().Name); // Point
Console.WriteLine (typeof (Point).Name); // Point
Console.WriteLine (p.GetType() == typeof (Point)); // True
Console.WriteLine (p.X.GetType().Name); // Int32
Console.WriteLine (p.Y.GetType().FullName); // System.Int32
public class Point { public int X, Y; }
The ToString Method
// The ToString method is defined on System.Object and returns the default textual representation
// of a type instance:
// You can override the ToString method on custom types:
int x = 1;
string s = x.ToString(); // s is "1"
Panda p = new Panda { Name = "Petey" };
Console.WriteLine (p.ToString()); // Petey
public class Panda
{
public string Name;
public override string ToString() { return Name; }
}
Structs
Structs
// A struct is similar to a class, with several key differences (as described in the book).
// In particular, a struct is a value type rather than a reference type.
// The construction semantics are different, too:
Point p1 = new Point (); // p1.x and p1.y will be 0
p1.Dump();
Point p2 = new Point (1, 1); // p1.x and p1.y will be 1
p2.Dump();
public struct Point
{
public int X, Y;
public Point (int x, int y) { X = x; Y = y; }
// The parameterless constructor is implicit.
}
Structs - Illegal Construction Examples
// Changing the following struct to a class makes the type legal:
public struct Point
{
int x = 1; // Illegal: cannot initialize field
int y;
public Point() { } // Illegal: cannot have parameterless constructor
public Point (int x) { this.x = x; } // Illegal: must assign field y
}
ref Structs
var points = new Point [100]; // Error: will not compile!
ref struct Point { public int X, Y; }
class MyClass { Point P; } // Error: will not compile!
Access Modifiers
Access Modifiers - Examples
// The access modifiers are public, internal, protected and private.
//
// public is the default for members of an enum or interface.
// internal is the default for nonnested types.
// private is the default for everything else.
class Class1 {} // Class1 is internal (default) - visible to other types in same assembly
public class Class2 {} // Class2 is visible to everything, including types in other assemblies
class ClassA
{
int x; // x is private (default) - cannot be accessed from other types
}
class ClassB
{
internal int x; // x can be accessed from other types in same assembly
}
class BaseClass
{
void Foo() {} // Foo is private (default)
protected void Bar() {} // Foo is accessible to subclasses
}
class Subclass : BaseClass
{
void Test1() { Foo(); } // Error - cannot access Foo
void Test2() { Bar(); } // OK
}
Friend Assemblies
// Unsigned friend:
// [assembly: InternalsVisibleTo ("Friend")]
// Signed friend:
// [assembly: InternalsVisibleTo ("StrongFriend, PublicKey=0024f000048c...")]
// To obtain an assembly's public key, hit F5 to run the following code:
using (var dialog = new OpenFileDialog())
{
dialog.Title = "Locate assembly";
dialog.Filter = "Assembly files|*.dll;*.exe";
dialog.DefaultExt = ".dll";
if (dialog.ShowDialog() != DialogResult.OK) return;
if (!File.Exists (dialog.FileName)) return;
var aName = Assembly.LoadFile (dialog.FileName).GetName();
string key = string.Join ("",
aName.GetPublicKey().Select (b => b.ToString ("x2")).ToArray());
string assemAttrib = "[assembly: InternalsVisibleTo (\""
+ aName.Name
+ ", PublicKey=" + key.Dump ("Full Key")
+ "\")]";
assemAttrib.Dump ("Assembly Attribute");
Clipboard.SetText (assemAttrib);
}
Accessibility Capping
// A type caps the accessibility of its declared members:
class C // Class C is implicitly internal
{
public void Foo() {} // Foo's accessibility is capped at internal
}
void Main() { }
Restrictions on Access Modifiers
// When overriding a base class function, accessibility must be identical on the overridden function:
class BaseClass { protected virtual void Foo() {} }
class Subclass1 : BaseClass { protected override void Foo() {} } // OK
class Subclass2 : BaseClass { public override void Foo() {} } // Error
// A subclass itself can be less accessible than a base class, but not more:
internal class A { }
public class B : A { } // Error
Interfaces
Interfaces
// The IEnumerator interface is part of the .NET Framework, defined in System.Collections.
// We can define our own version of this as follows:
IEnumerator e = new Countdown();
while (e.MoveNext())
Console.Write (e.Current); // 109876543210
public interface IEnumerator
{
bool MoveNext();
object Current { get; }
void Reset();
}
// Here's a class that implements this interface:
class Countdown : IEnumerator
{
int count = 11;
public bool MoveNext () => count-- > 0;
public object Current => count;
public void Reset() { throw new NotSupportedException(); }
}
Extending an Interface
// We can extend interfaces - just like extending classes:
IRedoable r = null;
IUndoable u = r;
public interface IUndoable { void Undo(); }
public interface IRedoable : IUndoable { void Redo(); }
Explicit Interface Implementation
// Implementing multiple interfaces can sometimes result in a collision between member signatures.
// You can resolve such collisions by explicitly implementing an interface member:
Widget w = new Widget();
w.Foo(); // Widget's implementation of I1.Foo
((I1)w).Foo(); // Widget's implementation of I1.Foo
((I2)w).Foo(); // Widget's implementation of I2.Foo
interface I1 { void Foo(); }
interface I2 { int Foo(); }
public class Widget : I1, I2
{
public void Foo ()
{
Console.WriteLine ("Widget's implementation of I1.Foo");
}
int I2.Foo()
{
Console.WriteLine ("Widget's implementation of I2.Foo");
return 42;
}
}
// Another reason to explicitly implement interface members is to hide members that are
// highly specialized and distracting to a type’s normal use case.
Implementing Interface Members Virtually
// An implicitly implemented interface member is, by default, sealed. It must be marked
// virtual or abstract in the base class in order to be overridden:
// Calling the interface member through either the base class or the interface
// calls the subclass’s implementation:
RichTextBox r = new RichTextBox();
r.Undo(); // RichTextBox.Undo
((IUndoable)r).Undo(); // RichTextBox.Undo
((TextBox)r).Undo(); // RichTextBox.Undo
public interface IUndoable { void Undo(); }
public class TextBox : IUndoable
{
public virtual void Undo() => Console.WriteLine ("TextBox.Undo");
}
public class RichTextBox : TextBox
{
public override void Undo() => Console.WriteLine ("RichTextBox.Undo");
}
Reimplementing an Interface in a Subclass
// A subclass can reimplement any interface member already implemented by a base class.
// Reimplementation hijacks a member implementation (when called through the interface):
// Calling the reimplemented member through the interface calls the subclass’s implementation:
RichTextBox r = new RichTextBox();
r.Undo(); // RichTextBox.Undo Case 1
((IUndoable)r).Undo(); // RichTextBox.Undo Case 2
public interface IUndoable { void Undo(); }
public class TextBox : IUndoable
{
void IUndoable.Undo() => Console.WriteLine ("TextBox.Undo");
}
public class RichTextBox : TextBox, IUndoable
{
public new void Undo() => Console.WriteLine ("RichTextBox.Undo");
}
Reimplementing an Interface - Contrast
// Suppose that TextBox instead implemented Undo implicitly:
// This would give us another way to call Undo, which would “break” the system, as shown in Case 3:
RichTextBox r = new RichTextBox();
r.Undo(); // RichTextBox.Undo Case 1
((IUndoable)r).Undo(); // RichTextBox.Undo Case 2
((TextBox)r).Undo(); // TextBox.Undo Case 3
public interface IUndoable { void Undo(); }
public class TextBox : IUndoable
{
public void Undo() => Console.WriteLine ("TextBox.Undo");
}
public class RichTextBox : TextBox, IUndoable
{
public new void Undo() => Console.WriteLine ("RichTextBox.Undo");
}
Alternatives to interface reimplementation
// Even with explicit member implementation, interface reimplementation is problematic for a
// couple of reasons.
// The following pattern is a good alternative if you need explicit interface implementation:
IUndoable r = new RichTextBox();
r.Undo(); // RichTextBox.Undo
public interface IUndoable { void Undo(); }
public class TextBox : IUndoable
{
void IUndoable.Undo() => Undo(); // Calls method below
protected virtual void Undo() => Console.WriteLine ("TextBox.Undo");
}
public class RichTextBox : TextBox
{
protected override void Undo() => Console.WriteLine ("RichTextBox.Undo");
}
Interfaces and Boxing
// Casting a struct to an interface causes boxing. Calling an implicitly implemented
// member on a struct does not cause boxing:
S s = new S();
s.Foo(); // No boxing.
I i = s; // Box occurs when casting to interface.
i.Foo();
interface I { void Foo(); }
struct S : I { public void Foo() {} }
Default interface members
var logger = new Logger();
// We can't call the Log method directly:
// foo.Log ("message") // Won't compile
// But we can call it via the interface:
((ILogger)logger).Log ("message");
interface ILogger
{
void Log (string text) => Console.WriteLine (text);
}
class Logger : ILogger
{
// We don't need to implement anything
}
Default interface members - static members
ILogger.Prefix = "File log: ";
var logger = new Logger();
((ILogger)logger).Log ("message");
interface ILogger
{
void Log (string text) =>
Console.WriteLine (Prefix + text);
static string Prefix = "";
}
class Logger : ILogger
{
// We don't need to implement anything
}
Default interface members - scenario
ILogger foo = new Logger();
foo.Log (new Exception ("test"));
class Logger : ILogger
{
public void Log (string message) => Console.WriteLine (message);
}
interface ILogger
{
// Let's suppose the interface as always defined this method:
void Log (string message);
// Adding a new member to an interface need not break implementors:
public void Log (Exception ex) => Log (ExceptionHeader + ex.Message);
static string ExceptionHeader = "Exception: ";
}
Enums
Enums
// An enum is a special value type that lets you specify a group of named numeric constants:
BorderSide topSide = BorderSide.Top;
bool isTop = (topSide == BorderSide.Top);
isTop.Dump();
public enum BorderSide { Left, Right, Top, Bottom }
// You may specify an alternative integral type:
public enum BorderSideByte : byte { Left, Right, Top, Bottom }
// You may also specify an explicit underlying value for each enum member:
public enum BorderSideExplicit : byte { Left=1, Right=2, Top=10, Bottom=11 }
public enum BorderSidePartiallyExplicit : byte { Left=1, Right, Top=10, Bottom }
Enum Conversions
// You can convert an enum instance to and from its underlying integral value with an explicit cast:
int i = (int)BorderSide.Left;
i.Dump ("i");
BorderSide side = (BorderSide)i;
side.Dump ("side");
bool leftOrRight = (int)side <= 2;
leftOrRight.Dump ("leftOrRight");
HorizontalAlignment h = (HorizontalAlignment)BorderSide.Right;
h.Dump ("h");
BorderSide b = 0; // No cast required with the 0 literal.
b.Dump ("b");
public enum BorderSide { Left, Right, Top, Bottom }
public enum HorizontalAlignment
{
Left = BorderSide.Left,
Right = BorderSide.Right,
Center
}
Flags Enums
// You can combine enum members. To prevent ambiguities, members of a combinable enum require
// explicitly assigned values, typically in powers of two:
BorderSides leftRight = BorderSides.Left | BorderSides.Right;
if ((leftRight & BorderSides.Left) != 0)
Console.WriteLine ("Includes Left"); // Includes Left
string formatted = leftRight.ToString(); // "Left, Right"
BorderSides s = BorderSides.Left;
s |= BorderSides.Right;
Console.WriteLine (s == leftRight); // True
s ^= BorderSides.Right; // Toggles BorderSides.Right
Console.WriteLine (s); // Left
[Flags]
public enum BorderSides { None = 0, Left = 1, Right = 2, Top = 4, Bottom = 8 }
Flags Enums - Combinations
// For convenience, you can include combination members within an enum declaration itself:
BorderSides.All.Dump();
// The bitwise, arithmetic, and comparison operators return the result of processing
// the underlying integral values:
(BorderSides.All ^ BorderSides.LeftRight).Dump();
[Flags]
public enum BorderSides
{
None = 0,
Left = 1, Right = 2, Top = 4, Bottom = 8,
LeftRight = Left | Right,
TopBottom = Top | Bottom,
All = LeftRight | TopBottom
}
Type-Safety Issues
// Since an enum can be cast to and from its underlying integral type, the actual value
// it may have may fall outside the bounds of a legal enum member:
BorderSide b = (BorderSide)12345;
Console.WriteLine (b); // 12345
BorderSide b2 = BorderSide.Bottom;
b2++; // No errors
Console.WriteLine (b2); // 4 (illegal value)
// An invalid BorderSide would break the following method:
void Draw (BorderSide side)
{
if (side == BorderSide.Left) { /*...*/ }
else if (side == BorderSide.Right) { /*...*/ }
else if (side == BorderSide.Top) { /*...*/ }
else { /*...*/ } // Assume BorderSide.Bottom
}
public enum BorderSide { Left, Right, Top, Bottom }
Type-Safety Issues - Workaround
for (int i = 0; i <= 16; i++)
{
BorderSides side = (BorderSides)i;
Console.WriteLine (IsFlagDefined (side) + " " + side);
}
bool IsFlagDefined (Enum e)
{
decimal d;
return !decimal.TryParse (e.ToString(), out d);
}
[Flags]
public enum BorderSides { Left = 1, Right = 2, Top = 4, Bottom = 8 }
Nested Types
Nested Types
// A nested type is declared within the scope of another type. For example:
public class TopLevel
{
public class Nested { } // Nested class
public enum Color { Red, Blue, Tan } // Nested enum
}
static void Main()
{
TopLevel.Color color = TopLevel.Color.Red;
}
Nested Types - Private Member Visibility
public class TopLevel
{
static int x;
public class Nested
{
public static void Foo() { Console.WriteLine (TopLevel.x); }
}
}
static void Main()
{
TopLevel.Nested.Foo();
}
Nested Types - Protected Member Visibility
public class TopLevel
{
protected class Nested { }
}
public class SubTopLevel : TopLevel
{
static void Foo() { new TopLevel.Nested(); }
}
static void Main()
{
}
Generics
Generic Types
// A generic type declares type parameters—placeholder types to be filled in by the consumer
// of the generic type, which supplies the type arguments:
var stack = new Stack<int>();
stack.Push (5);
stack.Push (10);
int x = stack.Pop(); // x is 10
int y = stack.Pop(); // y is 5
x.Dump(); y.Dump();
public class Stack<T>
{
int position;
T[] data = new T [100];
public void Push (T obj) => data [position++] = obj;
public T Pop() => data [--position];
}
Why Generics Exist
// Generics exist to write code that is reusable across different types. Without generic types,
// writing a general-purpose stack would require a solution such as this:
// Now suppose we want a stack that stores just integers:
ObjectStack stack = new ObjectStack();
// It's easy to make mistakes:
stack.Push ("s"); // Wrong type, but no error!
int i = (int)stack.Pop(); // Downcast - runtime error!
public class ObjectStack
{
int position;
object[] data = new object [10];
public void Push (object obj) => data [position++] = obj;
public object Pop() => data [--position];
}
Generic Methods
// A generic method declares type parameters within the signature of a method.
int x = 5;
int y = 10;
Swap (ref x, ref y);
x.Dump(); y.Dump();
static void Swap<T> (ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
Declaring Type Parameters
// Type parameters can be introduced in the declaration of classes, structs, interfaces,
// delegates (covered in Chapter 4), and methods:
// To instantiate:
Dictionary<int, string> myDic = new Dictionary<int, string>();
// Or:
var myDicEasy = new Dictionary<int, string>();
struct Nullable<T>
{
public T Value { get; set; }
}
// A generic type or method can have multiple parameters:
class Dictionary<TKey, TValue> { /*...*/ }
// Generic type names and method names can be overloaded as long as the number of type
// parameters is different:
class A { }
class A<T> { }
class A<T1, T2> { }
Typeof and Unbound Generic Types
// It's possible for an unbound generic type to exist at runtime—purely as a Type object.
// The only way to specify an unbound generic type in C# is with the typeof operator:
Type a1 = typeof (A<>); // Unbound type (notice no type arguments).
Type a2 = typeof (A<,>); // Use commas to indicate multiple type args.
// You can also use the typeof operator to specify a closed type:
Type a3 = typeof (A<int, int>);
class A<T> { }
class A<T1, T2> { }
// or an open type (which is closed at runtime):
class B<T>
{
void X() { Type t = typeof (T); }
}
The default Generic Value
// The default keyword can be used to get the default value given a generic type parameter:
int[] numbers = { 1, 2, 3 };
Zap (numbers);
numbers.Dump();
static void Zap<T> (T[] array)
{
for (int i = 0; i < array.Length; i++)
array [i] = default (T);
}
Generic Constraints
/* Constraints can be applied to a type parameter restrict the type arguments.
where T : base-class // Base class constraint
where T : interface // Interface constraint
where T : class // Reference-type constraint
where T : struct // Value-type constraint (excludes Nullable types)
where T : new() // Parameterless constructor constraint
where U : T // Naked type constraint
*/
int z = Max (5, 10); // 10
string last = Max ("ant", "zoo"); // zoo
z.Dump(); last.Dump();
T Max<T> (T a, T b) where T : IComparable<T> // Self-referencing interface constraint
{
return a.CompareTo (b) > 0 ? a : b;
}
class SomeClass { }
interface Interface1 { }
class GenericClass<T> where T : SomeClass, Interface1 { } // Class & interface constraint
Parameterless Constructor Constraint
// The parameterless constructor constraint requires T to have a public parameterless constructor.
// If this constraint is defined, you can call new() on T:
var builders = new StringBuilder [100];
Initialize (builders);
builders [37].Dump();
static void Initialize<T> (T[] array) where T : new()
{
for (int i = 0; i < array.Length; i++)
array [i] = new T();
}
Naked Type Constraint
// The naked type constraint requires one type parameter to derive from another type parameter:
class Stack<T>
{
Stack<U> FilteredStack<U>() where U : T
{
/* ... */
return default(Stack<U>);
}
}
Subclassing Generic Typest
// A generic class can be subclassed just like a nongeneric class.
// The subclass can leave the base class’s type parameters open:
class Stack<T> { /*...*/ }
class SpecialStack<T> : Stack<T> { /*...*/ }
// Or the subclass can close the generic type parameters with a concrete type:
class IntStack : Stack<int> { /*...*/ }
// A subtype can also introduce fresh type arguments:
class List<T> { /*...*/ }
class KeyedList<T,TKey> : List<T> { /*...*/ }
Self-Referencing Generic Declarations
// A type can name itself as the concrete type when closing a type argument:
var b1 = new Balloon { Color = "Red", CC = 123 };
var b2 = new Balloon { Color = "Red", CC = 123 };
b1.Equals (b2).Dump();
public class Balloon : IEquatable<Balloon>
{
public string Color { get; set; }
public int CC { get; set; }
public bool Equals (Balloon b)
{
if (b == null) return false;
return b.Color == Color && b.CC == CC;
}
// In real life, we would override object.Equals / GetHashCode as well - see Chapter 6.
}
Static Data
// Static data is unique for each closed type:
Console.WriteLine (++Bob<int>.Count); // 1
Console.WriteLine (++Bob<int>.Count); // 2
Console.WriteLine (++Bob<string>.Count); // 1
Console.WriteLine (++Bob<object>.Count); // 1
class Bob<T> { public static int Count; }
Type Parameters & Conversions - Problem
// The most common scenario is when you want to perform a reference conversion:
StringBuilder Foo<T> (T arg)
{
if (arg is StringBuilder)
return (StringBuilder) arg; // Will not compile: Cannot convert T to StringBuilder
/*...*/
return null;
}
Type Parameters & Conversions - Solution #1
// The simplest solution is to instead use the as operator, which is unambiguous because
// it cannot perform custom conversions:
StringBuilder Foo<T> (T arg)
{
StringBuilder sb = arg as StringBuilder;
if (sb != null) return sb;
/*...*/
return null;
}
Type Parameters & Conversions - Solution #2
// A more general solution is to first cast to object:
StringBuilder Foo<T> (T arg)
{
if (arg is StringBuilder)
return (StringBuilder) (object) arg;
/*...*/
return null;
}
Type Parameters & Conversions - Unboxing
// Unboxing conversions can also introduce ambiguities; again the solution is to first cast to object:
int Foo<T> (T x) => (int) (object) x;
Covariance - Classes - Problem
// Generic classes are not covariant, to ensure static type safety. Consider the following:
// The following fails to compile:
Stack<Bear> bears = new Stack<Bear>();
Stack<Animal> animals = bears; // Compile-time error
// That restriction prevents the possibility of runtime failure with the following code:
animals.Push (new Camel()); // Trying to add Camel to bears
class Animal { }
class Bear : Animal { }
class Camel : Animal { }
public class Stack<T> // A simple Stack implementation
{
int position;
T[] data = new T [100];
public void Push (T obj) => data [position++] = obj;
public T Pop() => data [--position];
}
Covariance - Classes - Hindering Reusability
// Lack of covariance with classes can hinder reusability.
Stack<Bear> bears = new Stack<Bear>();
ZooCleaner.Wash (bears); // Will not compile!
class Animal {}
class Bear : Animal {}
class Camel : Animal {}
public class Stack<T> // A simple Stack implementation
{
int position;
T[] data = new T[100];
public void Push (T obj) => data[position++] = obj;
public T Pop() => data [--position];
}
static class ZooCleaner
{
public static void Wash (Stack<Animal> animals) { /*...*/ }
}
Covariance - Classes - Workaround
// Lack of covariance with classes can hinder reusability.
Stack<Bear> bears = new Stack<Bear>();
ZooCleaner.Wash (bears); // Works!
class Animal {}
class Bear : Animal {}
class Camel : Animal {}
public class Stack<T> // A simple Stack implementation
{
int position;
T[] data = new T[100];
public void Push (T obj) => data[position++] = obj;
public T Pop() => data[--position];
}
static class ZooCleaner
{
public static void Wash<T>(Stack<T> animals) where T : Animal { /*...*/ }
}
Covariance - Arrays
// For historical reasons, array types are covariant.
Bear[] bears = new Bear[3];
Animal[] animals = bears; // OK
// The downside of this reusability is that element assignments can fail at runtime:
animals[0] = new Camel(); // Runtime error
class Animal {}
class Bear : Animal {}
class Camel : Animal {}
Covariance - Interfaces
// As of C# 4.0, generic interfaces support covariance for type parameters marked with the out modifier:
var bears = new Stack<Bear>();
bears.Push (new Bear());
// Bears implements IPoppable<Bear>. We can convert to IPoppable<Animal>:
IPoppable<Animal> animals = bears; // Legal
Animal a = animals.Pop();
public interface IPoppable<out T> { T Pop(); }
class Animal {}
class Bear : Animal {}
class Camel : Animal {}
public class Stack<T> : IPoppable<T>
{
int position;
T[] data = new T [100];
public void Push (T obj) => data [position++] = obj;
public T Pop() => data [--position];
}
// This is also now legal:
class ZooCleaner
{
public static void Wash (IPoppable<Animal> animals) { /*...*/ }
}
Contravariance - Interfaces
// Type parameters marked with the in modifier indicate contravariance:
IPushable<Animal> animals = new Stack<Animal>();
IPushable<Bear> bears = animals; // Legal
bears.Push (new Bear());
public interface IPoppable<out T> { T Pop(); }
public interface IPushable<in T> { void Push (T obj); }
class Animal {}
class Bear : Animal {}
class Camel : Animal {}
// Note that Stack<T> can implement both IPoppable<T> and IPushable<T>:
public class Stack<T> : IPoppable<T>, IPushable<T>
{
int position;
T[] data = new T[100];
public void Push (T obj) => data[position++] = obj;
public T Pop() => data[--position];
}
Contravariance - More Examples
/* The following interface is defined as part of the .NET Framework:
public interface IComparer<in T>
{
// Returns a value indicating the relative ordering of a and b
int Compare (T a, T b);
}
*/
var objectComparer = Comparer<object>.Default;
IComparer<string> stringComparer = objectComparer;
int result = stringComparer.Compare ("Brett", "Jemaine");
result.Dump();