11/16/24, 10:56 PM C# in a Nutshell - Code Listings
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
https://w w w .albahari.com/nutshell/E12-CH03.aspx 1/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
// 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()
https://w w w .albahari.com/nutshell/E12-CH03.aspx 2/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
{
// 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);
// The following mix-and-match is permitted, from C# 10:
double x1 = 0;
(x1, double y2) = rect;
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;
https://w w w .albahari.com/nutshell/E12-CH03.aspx 3/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
}
}
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; }
}
https://w w w .albahari.com/nutshell/E12-CH03.aspx 4/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
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; }
}
// In 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];
https://w w w .albahari.com/nutshell/E12-CH03.aspx 5/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
Primary Constructors
// From C# 12, you can include a parameter list directly after a class (or struct) declaration.
// This instructs the compiler to automatically build a primary constructor using the primary
// constructor parameters (firstName and lastName).
Person p = new Person ("Alice", "Jones");
p.Print(); // Alice Jones
class Person (string firstName, string lastName)
{
public void Print() => Console.WriteLine (firstName + " " + lastName);
}
// See also query://../Inheritance/Inheritance_with_primary_constructors
Primary Constructors - additional constructors
Person p = new Person ("Alice", "Jones", 33);
p.Print(); // Alice Jones
class Person (string firstName, string lastName)
{
int _age;
// The constructor that C# builds is called primary because any additional constructors
// that you choose to (explicitly) write must invoke it:
public Person (string firstName, string lastName, int age)
: this (firstName, lastName) // Must call the primary constructor
{
_age = age;
}
public void Print() => Console.WriteLine (firstName + " " + lastName + " " + _age);
}
// See also query://../Inheritance/Inheritance_with_primary_constructors
Primary Constructors and initializers
// The accessibility of primary constructor parameters extends to field and property initializers.
// In the following example, we use field and property initializers to assign firstName to a public
// field, and lastName to a public property:
Person p = new Person ("Alice", "Jones");
p.Dump();
class Person (string firstName, string lastName)
{
public readonly string FirstName = firstName; // Field
public string LastName { get; } = lastName; // Property
}
Primary Constructors - masking
// Fields (or properties) can reuse primary constructor parameter names:
Person p = new Person ("Alice", "Jones");
p.Print();
class Person (string firstName, string lastName)
{
// In this scenario, the field or property takes precedence, thereby masking
// the primary constructor parameter, except on the righthand side of field and
// property initializers:
readonly string firstName = firstName;
readonly string lastName = lastName;
public void Print() => Console.WriteLine (firstName + " " + lastName);
}
Primary Constructors - validating
new Person1 ("Alice", "Jones").Print(); // Alice Jones
new Person2 ("Alice", "Jones").Print(); // Alice JONES
var p3 = new Person3 ("Alice", null); // throws ArgumentNullException
class Person1 (string firstName, string lastName)
{
// Sometimes it’s useful to perform computation in field initializers:
public readonly string FullName = firstName + " " + lastName;
public void Print() => Console.WriteLine (FullName);
}
class Person2 (string firstName, string lastName)
{
// Save an uppercase version of lastName to a field of the same name
https://w w w .albahari.com/nutshell/E12-CH03.aspx 6/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
// (masking the original value):
readonly string lastName = lastName.ToUpper();
public void Print() => Console.WriteLine (firstName + " " + lastName);
}
class Person3 (string firstName, string lastName)
{
// Validate lastName upon construction, ensuring that it cannot be null:
readonly string lastName = (lastName == null)
? throw new ArgumentNullException ("lastName")
: lastName;
public void Print() => Console.WriteLine (firstName + " " + lastName);
}
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);
}
https://w w w .albahari.com/nutshell/E12-CH03.aspx 7/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
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
The object Type
Structs
Access Modifiers
Interfaces
Enums
Nested Types
Generics
C# 12
in a Nutshell
About the Book
Code Listings
C# 12 in a Nutshell
C# 10 in a Nutshell
C# 9.0 in a Nutshell
C# 8.0 in a Nutshell
C# 7.0 in a Nutshell
https://w w w .albahari.com/nutshell/E12-CH03.aspx 8/9
11/16/24, 10:56 PM C# in a Nutshell - Code Listings
Extras
Contact
Buy print or Kindle edition
Buy PDF edition
Read via O'Reilly subscription
https://w w w .albahari.com/nutshell/E12-CH03.aspx 9/9
