In C#, we use the class (mostly) or struct (sometimes) C# keywords to define a type of object. You will learn about the difference between classes and structs in Chapter 6, Implementing Interfaces and Inheriting Classes. You can think of a type as being a blueprint or template for an object.

The concepts of OOP are briefly described here:

Building class libraries

Creating a class library

Defining a class in a namespace

1. Add a new class file named Person.cs.
2. Statically import System.Console.
3. Set the namespace to Packt.Shared.

using System;
using static System.Console;
namespace Packt.Shared
{
  public class Person
  {
  }
}

If you do not explicitly apply the public keyword, then it will only be accessible within the assembly that defined it. This is because the implicit access modifier for a class is internal. We need this class to be accessible outside the assembly, so we must make sure it is public.

Simplifying namespace declarations

using System; 
namespace Packt.Shared; // the class in this file is in this namespace
public class Person
{
}

Understanding members

Instantiating a class

Referencing an assembly

1. Use your preferred coding tool to add a new console app to the Chapter05 workspace/solution named PeopleApp.
2. If you are using Visual Studio Code:
   1. Select PeopleApp as the active OmniSharp project. When you see the pop-up warning message saying that required assets are missing, click Yes to add them.
   2. Edit PeopleApp.csproj to add a project reference to PacktLibrary, as shown highlighted in the following markup:

      <Project Sdk="Microsoft.NET.Sdk">
        <PropertyGroup>
          <OutputType>Exe</OutputType>
          <TargetFramework>net6.0</TargetFramework>
          <Nullable>enable</Nullable>
          <ImplicitUsings>enable</ImplicitUsings>
        </PropertyGroup>
        <ItemGroup>
          <ProjectReference Include="../PacktLibrary/PacktLibrary.csproj" />
        </ItemGroup>
      </Project>
      

   3. In a terminal, enter a command to compile the PeopleApp project and its dependency PacktLibrary project, as shown in the following command:

      dotnet build
      

3. If you are using Visual Studio:
   1. Set the startup project for the solution to the current selection.
   2. In Solution Explorer, select the PeopleApp project, navigate to Project | Add Project Reference…, check the box to select the PacktLibrary project, and then click OK.
   3. Navigate to Build | Build PeopleApp.

Importing a namespace to use a type

Understanding objects

The implementation of the ToString method in the System.Object type simply outputs the full namespace and type name.

Back in the original Person class, we could have explicitly told the compiler that Person inherits from the System.Object type, as shown in the following code:

public class Person : System.Object

When class B inherits from class A, we say that A is the base or superclass and B is the derived or subclass. In this case, System.Object is the base or superclass and Person is the derived or subclass.

You can also use the C# alias keyword object, as shown in the following code:

public class Person : object

Inheriting from System.Object

Let's make our class explicitly inherit from object and then review what members all objects have:

1. Modify your Person class to explicitly inherit from object.
2. Click inside the object keyword and press F12, or right-click on the object keyword and choose Go to Definition.

Figure 5.1: System.Object class definition

Storing data within fields

Defining fields

Inside the Person class, write statements to declare two public fields for storing a person's name and date of birth, as shown in the following code:

public class Person : object
{
  // fields
  public string Name;
  public DateTime DateOfBirth;
}

Understanding access modifiers

Part of encapsulation is choosing how visible the members are.

There are four access modifier keywords, and two combinations of access modifier keywords that you can apply to a class member, like a field or method, as shown in the following table:

Setting and outputting field values

Now we will use those fields in your code:

Storing a value using an enum type

An enum type is a very efficient way of storing one or more choices because, internally, it uses integer values in combination with a lookup table of string descriptions:

1. Add a new file to the PacktLibrary project named WondersOfTheAncientWorld.cs.
2. Modify the WondersOfTheAncientWorld.cs file, as shown in the following code:

   namespace Packt.Shared
   {
     public enum WondersOfTheAncientWorld
     {
       GreatPyramidOfGiza,
       HangingGardensOfBabylon,
       StatueOfZeusAtOlympia,
       TempleOfArtemisAtEphesus,
       MausoleumAtHalicarnassus,
       ColossusOfRhodes,
       LighthouseOfAlexandria
     }
   }
   

   Good Practice: If you use are writing code in a .NET Interactive notebook, then the code cell containing the enum must be above the code cell defining the Person class.

3. In the Person class, add the following statement to your list of fields:

   public WondersOfTheAncientWorld FavoriteAncientWonder;
   

4. In Program.cs, add the following statements:

   bob.FavoriteAncientWonder = WondersOfTheAncientWorld.StatueOfZeusAtOlympia;
   WriteLine(
     format: "{0}'s favorite wonder is {1}. Its integer is {2}.",
     arg0: bob.Name,
     arg1: bob.FavoriteAncientWonder,
     arg2: (int)bob.FavoriteAncientWonder);
   

5. Run the code and view the result, as shown in the following output:

   Bob Smith's favorite wonder is StatueOfZeusAtOlympia. Its integer is 2.
   

Storing multiple values using an enum type

Storing multiple values using collections

1. In Person.cs, import the System.Collections.Generic namespace, as shown in the following code:

   using System.Collections.Generic; // List<T>
   

2. Declare a new field in the Person class, as shown in the following code:

   public List<Person> Children = new List<Person>();
   

List<Person> is read aloud as "list of Person," for example, "the type of the property named Children is a list of Person instances." We explicitly changed the class library to target .NET Standard 2.0 (that uses the C# 7 compiler), so we cannot use target-typed new to initialize the Children field. If we had left it targeting .NET 6.0, then we could use target-typed new, as shown in the following code:

public List<Person> Children = new();

Understanding generic collections

Ironically, the term generics means we can use a more specific static type!

Making a field static

Sometimes, you want to define a field that only has one value that is shared across all instances.

Making a field constant

Figure 5.2: Examples of constants

Making a field read-only

1. In Person.cs, add a statement to declare an instance read-only field to store a person's home planet, as shown in the following code:

   // read-only fields
   public readonly string HomePlanet = "Earth";
   

2. In Program.cs, add a statement to write Bob's name and home planet to the console, as shown in the following code:

   WriteLine($"{bob.Name} was born on {bob.HomePlanet}");
   

3. Run the code and view the result, as shown in the following output:

   Bob Smith was born on Earth
   

Initializing fields with constructors

Defining multiple constructors

1. In Person.cs, add statements to define a second constructor that allows a developer to set initial values for the person's name and home planet, as shown in the following code:

   public Person(string initialName, string homePlanet)
   {
     Name = initialName;
     HomePlanet = homePlanet;
     Instantiated = DateTime.Now;
   }
   

2. In Program.cs, add statements to create another person using the constructor with two parameters, as shown in the following code:

   Person gunny = new(initialName: "Gunny", homePlanet: "Mars");
   WriteLine(format:
     "{0} of {1} was created at {2:hh:mm:ss} on a {2:dddd}.",
     arg0: gunny.Name,
     arg1: gunny.HomePlanet,
     arg2: gunny.Instantiated);
   

3. Run the code and view the result:

   Gunny of Mars was created at 11:59:25 on a Sunday
   

Constructors are a special category of method. Let's look at methods in more detail.

Writing and calling methods

Returning values from methods

• A method that performs some actions but does not return a value indicates this with the void type before the name of the method.
• A method that performs some actions and returns a value indicates this with the type of the return value before the name of the method.

• WriteToConsole: This will perform an action (writing some text to the console), but it will return nothing from the method, indicated by the void keyword.
• GetOrigin: This will return a text value, indicated by the string keyword.

Let's write the code:

1. In Person.cs, add statements to define the two methods that I described earlier, as shown in the following code:

   // methods
   public void WriteToConsole()
   {
     WriteLine($"{Name} was born on a {DateOfBirth:dddd}.");
   }
   public string GetOrigin()
   {
     return $"{Name} was born on {HomePlanet}.";
   }
   

2. In Program.cs, add statements to call the two methods, as shown in the following code:

   bob.WriteToConsole(); 
   WriteLine(bob.GetOrigin());
   

3. Run the code and view the result, as shown in the following output:

   Bob Smith was born on a Wednesday. 
   Bob Smith was born on Earth.
   

Combining multiple returned values using tuples

Each method can only return a single value that has a single type. That type could be a simple type, such as string in the previous example, a complex type, such as Person, or a collection type, such as List<Person>.

public class TextAndNumber
{
  public string Text;
  public int Number;
}
public class LifeTheUniverseAndEverything
{
  public TextAndNumber GetTheData()
  {
    return new TextAndNumber
    {
      Text = "What's the meaning of life?",
      Number = 42
    };
  }
}

Tuples have been a part of some languages such as F# since their first version, but .NET only added support for them with .NET 4.0 in 2010 using the System.Tuple type.

Language support for tuples

Let's explore tuples:

Naming the fields of a tuple

To access the fields of a tuple, the default names are Item1, Item2, and so on.

1. In Person.cs, add statements to define a method that returns a tuple with named fields, as shown in the following code:

   public (string Name, int Number) GetNamedFruit()
   {
     return (Name: "Apples", Number: 5);
   }
   

2. In Program.cs, add statements to call the method and output the tuple's named fields, as shown in the following code:

   var fruitNamed = bob.GetNamedFruit();
   WriteLine($"There are {fruitNamed.Number} {fruitNamed.Name}.");
   

3. Run the code and view the result, as shown in the following output:

   There are 5 Apples.
   

Inferring tuple names

In Program.cs, create two tuples, made of a string and int value each, as shown in the following code:

var thing1 = ("Neville", 4);
WriteLine($"{thing1.Item1} has {thing1.Item2} children.");
var thing2 = (bob.Name, bob.Children.Count); 
WriteLine($"{thing2.Name} has {thing2.Count} children.");

Deconstructing tuples

// store return value in a tuple variable with two fields
(string TheName, int TheNumber) tupleWithNamedFields = bob.GetNamedFruit();
// tupleWithNamedFields.TheName
// tupleWithNamedFields.TheNumber
// deconstruct return value into two separate variables
(string name, int number) = GetNamedFruit();
// name
// number

This has the effect of splitting the tuple into its parts and assigning those parts to new variables.

1. In Program.cs, add statements to deconstruct the tuple returned from the GetFruit method, as shown in the following code:

   (string fruitName, int fruitNumber) = bob.GetFruit();
   WriteLine($"Deconstructed: {fruitName}, {fruitNumber}");
   

2. Run the code and view the result, as shown in the following output:

   Deconstructed: Apples, 5
   

Deconstructing types

Defining and passing parameters to methods

Figure 5.3: An IntelliSense tooltip for a method with no overloads

Overloading methods

1. In Person.cs, change the name of the SayHelloTo method to SayHello.
2. In Program.cs, change the method call to use the SayHello method, and note that the quick info for the method tells you that it has one additional overload, 1/2, as well as 2/2, as shown in Figure 5.4:

   

Figure 5.4: An IntelliSense tooltip for an overloaded method

Passing optional and named parameters

We will now create a method with three optional parameters:

The default values for the command and number parameters have been replaced, but the default for active is still true.

Naming parameter values when calling methods

Controlling how parameters are passed

• By value (this is the default): Think of these as being in-only.
• By reference as a ref parameter: Think of these as being in-and-out.
• As an out parameter: Think of these as being out-only.

Let's see some examples of passing parameters in and out:

Simplified out parameters

In C# 7.0 and later, we can simplify code that uses the out variables.

int d = 10; 
int e = 20;
WriteLine($"Before: d = {d}, e = {e}, f doesn't exist yet!");
// simplified C# 7.0 or later syntax for the out parameter 
bob.PassingParameters(d, ref e, out int f); 
WriteLine($"After: d = {d}, e = {e}, f = {f}");

Understanding ref returns

Splitting classes using partial

Let's write some code that simulates this example:

1. In Person.cs, add the partial keyword, as shown highlighted in the following code:

   namespace Packt.Shared
   {
     public partial class Person
     {
   

2. In the PacktLibrary project/folder, add a new class file named PersonAutoGen.cs.
3. Add statements to the new file, as shown in the following code:

   namespace Packt.Shared
   {
     public partial class Person
     {
     }
   }
   

The rest of the code we write for this chapter will be written in the PersonAutoGen.cs file.

Controlling access with properties and indexers

Defining read-only properties

Requiring properties to be set during instantiation

public class Book
{
  public required string Isbn { get; set; }
  public string Title { get; set; }
}

Book novel = new();

Defining indexers

We will define an indexer to simplify access to the children of a person:

Pattern matching with objects

Creating and referencing a .NET 6 class library

1. Use your preferred coding tool to add a new class library named PacktLibraryModern to the workspace/solution named Chapter05.
2. In the PeopleApp project, add a reference to the PacktLibraryModern class library, as shown highlighted in the following markup:

   <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <Nullable>enable</Nullable>
       <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
     <ItemGroup>
       <ProjectReference Include="../PacktLibrary/PacktLibrary.csproj" />
       <ProjectReference 
         Include="../PacktLibraryModern/PacktLibraryModern.csproj" />
     </ItemGroup>
   </Project>
   

3. Build the PeopleApp project.

Defining flight passengers

Enhancements to pattern matching in C# 9 or later

You could also use the relational pattern in combination with the property pattern to avoid the nested switch expression, as shown in the following code:

FirstClassPassenger { AirMiles: > 35000 } => 1500,
FirstClassPassenger { AirMiles: > 15000 } => 1750M,
FirstClassPassenger => 2000M,

Working with records

Init-only properties

You have used object initialization syntax to instantiate objects and set initial properties throughout this chapter. Those properties can also be changed after instantiation.

1. In the PacktLibraryModern project/folder, add a new file named Records.cs.
2. In Records.cs, define an immutable person class, as shown in the following code:

   namespace Packt.Shared; // C# 10 file-scoped namespace
   public class ImmutablePerson
   {
     public string? FirstName { get; init; }
     public string? LastName { get; init; }
   }
   

3. In Program.cs, add statements to instantiate a new immutable person and then try to change one of its properties, as shown in the following code:

   ImmutablePerson jeff = new() 
   {
     FirstName = "Jeff",
     LastName = "Winger"
   };
   jeff.FirstName = "Geoff"; 
   

4. Compile the console app and note the compile error, as shown in the following output:

   Program.cs(254,7): error CS8852: Init-only property or indexer 'ImmutablePerson.FirstName' can only be assigned in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor. [/Users/markjprice/Code/Chapter05/PeopleApp/PeopleApp.csproj]
   

5. Comment out the attempt to set the FirstName property after instantiation.

Understanding records

Records should not have any state (properties and fields) that changes after instantiation. Instead, the idea is that you create new records from existing ones with any changed state. This is called non-destructive mutation. To do this, C# 9 introduced the with keyword:

Positional data members in records

Simplifying data members in records

public record ImmutableAnimal
{
  public string Name { get; init; } 
  public string Species { get; init; }
  public ImmutableAnimal(string name, string species)
  {
    Name = name;
    Species = species;
  }
  public void Deconstruct(out string name, out string species)
  {
    name = Name;
    species = Species;
  }
} 

1. In Records.cs, add statements to define another record using simplified syntax known as positional records, as shown in the following code:

   // simpler way to define a record
   // auto-generates the properties, constructor, and deconstructor
   public record ImmutableAnimal(string Name, string Species);
   

2. In Program.cs, add statements to construct and deconstruct immutable animals, as shown in the following code:

   ImmutableAnimal oscar = new("Oscar", "Labrador");
   var (who, what) = oscar; // calls Deconstruct method 
   WriteLine($"{who} is a {what}.");
   

3. Run the application and view the results, as shown in the following output:

   Oscar is a Labrador.
   

Practicing and exploring

Test your knowledge and understanding by answering some questions, get some hands-on practice, and explore this chapter's topics with deeper research.

Exercise 5.1 – Test your knowledge

Answer the following questions:

1. What are the six combinations of access modifier keywords and what do they do?
2. What is the difference between the static, const, and readonly keywords when applied to a type member?
3. What does a constructor do?
4. Why should you apply the [Flags] attribute to an enum type when you want to store combined values?
5. Why is the partial keyword useful?
6. What is a tuple?
7. What does the record keyword do?
8. What does overloading mean?
9. What is the difference between a field and a property?
10. How do you make a method parameter optional?

Exercise 5.2 – Explore topics

Use the links on the following page to learn more detail about the topics covered in this chapter: