Currently, the C# language does not define a half alias so you must use the .NET type System.Half. This might change in the future.

Working with big integers

Let's explore numerics:

Working with complex numbers

(a + bi) + (c + di) = (a + c) + (b + d)i

Let's explore complex numbers:

1. In Program.cs, add statements to add two complex numbers, as shown in the following code:

   WriteLine("Working with complex numbers:");
   Complex c1 = new(real: 4, imaginary: 2);
   Complex c2 = new(real: 3, imaginary: 7);
   Complex c3 = c1 + c2;
   // output using default ToString implementation
   WriteLine($"{c1} added to {c2} is {c3}");
   // output using custom format
   WriteLine("{0} + {1}i added to {2} + {3}i is {4} + {5}i",
     c1.Real, c1.Imaginary, 
     c2.Real, c2.Imaginary,
     c3.Real, c3.Imaginary);
   

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

   Working with complex numbers:
   (4, 2) added to (3, 7) is (7, 9)
   4 + 2i added to 3 + 7i is 7 + 9i
   

Understanding quaternions

Huh? Yes, I know. I don't understand that either. Don't worry; we're not going to write any code using them! Suffice to say, they are good at describing spatial rotations, so video game engines use them, as do many computer simulations and flight control systems.

Working with text

Getting the length of a string

1. Use your preferred code editor to add a new console app named WorkingWithText to the Chapter08 solution/workspace:
   1. In Visual Studio, set the startup project for the solution to the current selection.
   2. In Visual Studio Code, select WorkingWithText as the active OmniSharp project.
2. In the WorkingWithText project, in Program.cs, add statements to define a variable to store the name of the city London, and then write its name and length to the console, as shown in the following code:

   string city = "London";
   WriteLine($"{city} is {city.Length} characters long.");
   

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

   London is 6 characters long.
   

Getting the characters of a string

Let's see this in action:

1. Add a statement to write the characters at the first and third positions in the string variable, as shown in the following code:

   WriteLine($"First char is {city[0]} and third is {city[2]}.");
   

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

   First char is L and third is n.
   

Splitting a string

1. Add statements to define a single string variable containing comma-separated city names, then use the Split method and specify that you want to treat commas as the separator, and then enumerate the returned array of string values, as shown in the following code:

   string cities = "Paris,Tehran,Chennai,Sydney,New York,Medellín"; 
   string[] citiesArray = cities.Split(',');
   WriteLine($"There are {citiesArray.Length} items in the array.");
   foreach (string item in citiesArray)
   {
     WriteLine(item);
   }
   

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

   There are 6 items in the array.
   Paris 
   Tehran 
   Chennai
   Sydney
   New York
   Medellín
   

Later in this chapter, you will learn how to handle more complex scenarios.

Getting part of a string

• Substring(startIndex, length): returns a substring starting at startIndex and containing the next length characters.
• Substring(startIndex): returns a substring starting at startIndex and containing all characters up to the end of the string.

Let's explore a simple example:

1. Add statements to store a person's full name in a string variable with a space character between the first and last name, find the position of the space, and then extract the first name and last name as two parts so that they can be recombined in a different order, as shown in the following code:

   string fullName = "Alan Jones";
   int indexOfTheSpace = fullName.IndexOf(' ');
   string firstName = fullName.Substring(
     startIndex: 0, length: indexOfTheSpace);
   string lastName = fullName.Substring(
     startIndex: indexOfTheSpace + 1);
   WriteLine($"Original: {fullName}");
   WriteLine($"Swapped: {lastName}, {firstName}"); 
   

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

   Original: Alan Jones
   Swapped: Jones, Alan
   

If the format of the initial full name was different, for example, "LastName, FirstName", then the code would need to be different. As an optional exercise, try writing some statements that would change the input "Jones, Alan" into "Alan Jones".

Checking a string for content

Joining, formatting, and other string members

Let's explore some of these methods:

Note that we could have simplified the second statement because WriteLine supports the same format codes as string.Format, as shown in the following code:

WriteLine("WriteLine: {0} cost {1:C} on {2:dddd}.",
  arg0: fruit, arg1: price, arg2: when);

Building strings efficiently

This might not be noticeable if you are only adding two string values, but if you concatenate inside a loop with many iterations, it can have a significant negative impact on performance and memory use. In Chapter 12, Improving Performance and Scalability Using Multitasking, you will learn how to concatenate string variables efficiently using the StringBuilder type.

Working with dates and times

• DateTime: represents a combined date and time value for a fixed point in time.
• TimeSpan: represents a duration of time.

These two types are often used together. For example, if you subtract one DateTime value from another, the result is a TimeSpan. If you add a TimeSpan to a DateTime then the result is a DateTime value.

Specifying date and time values

An alternative is to provide the value as a string to be parsed, but this can be misinterpreted depending on the default culture of the thread. For example, in the UK, dates are specified as day/month/year, compared to the US, where dates are specified as month/day/year.

Let's see what you might want to do with dates and times:

Globalization with dates and times

Working with only a date or a time

Let's use them to plan a party for the Queen of England:

Pattern matching with regular expressions

Let's try out some example regular expressions:

1. Use your preferred code editor to add a new console app named WorkingWithRegularExpressions to the Chapter08 solution/workspace.
2. In Visual Studio Code, select WorkingWithRegularExpressions as the active OmniSharp project.
3. In Program.cs, import the following namespace:

   using System.Text.RegularExpressions;
   

Checking for digits entered as text

Regular expression performance improvements

With .NET 5 and later, the System.Text.RegularExpressions namespace has rewritten internals to squeeze out maximum performance. Common regular expression benchmarks using methods like IsMatch are now five times faster. And the best thing is, you do not have to change your code to get the benefits!

Understanding the syntax of a regular expression

In addition, here are some regular expression quantifiers that affect the previous symbols in a regular expression:

Examples of regular expressions

Splitting a complex comma-separated string

"Monsters, Inc.","I, Tonya","Lock, Stock and Two Smoking Barrels"

The string value uses double quotes around each film title. We can use these to identify whether we need to split on a comma (or not). The Split method is not powerful enough, so we can use a regular expression instead.

1. Add statements to store a complex comma-separated string variable, and then split it in a dumb way using the Split method, as shown in the following code:

   string films = "\"Monsters, Inc.\",\"I, Tonya\",\"Lock, Stock and Two Smoking Barrels\"";
   WriteLine($"Films to split: {films}");
   string[] filmsDumb = films.Split(',');
   WriteLine("Splitting with string.Split method:"); 
   foreach (string film in filmsDumb)
   {
     WriteLine(film);
   }
   

2. Add statements to define a regular expression to split and write the film titles in a smart way, as shown in the following code:

   WriteLine();
   Regex csv = new(
     "(?:^|,)(?=[^\"]|(\")?)\"?((?(1)[^\"]*|[^,\"]*))\"?(?=,|$)");
   MatchCollection filmsSmart = csv.Matches(films);
   WriteLine("Splitting with regular expression:"); 
   foreach (Match film in filmsSmart)
   {
     WriteLine(film.Groups[2].Value);
   }
   

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

   Splitting with string.Split method: 
   "Monsters
    Inc." 
   "I
    Tonya" 
   "Lock
    Stock and Two Smoking Barrels" 
   Splitting with regular expression: 
   Monsters, Inc.
   I, Tonya
   Lock, Stock and Two Smoking Barrels
   

Storing multiple objects in collections

A collection is a data structure in memory that can manage multiple items in different ways, although all collections have some shared functionality.

The most common types in .NET for working with collections are shown in the following table:

Common features of all collections

namespace System.Collections
{
  public interface ICollection : IEnumerable
  {
    int Count { get; }
    bool IsSynchronized { get; }
    object SyncRoot { get; }
    void CopyTo(Array array, int index);
  }
}

For example, if we had a collection named passengers, we could do this:

int howMany = passengers.Count;

namespace System.Collections
{
  public interface IEnumerable
  {
    IEnumerator GetEnumerator();
  }
}
namespace System.Collections
{
  public interface IEnumerator
  {
    object Current { get; }
    bool MoveNext();
    void Reset();
  }
}

For example, to perform an action on each object in the passengers collection, we could write the following code:

foreach (Passenger p in passengers)
{
  // perform an action on each passenger
}

namespace System.Collections.Generic
{
  public interface ICollection<T> : IEnumerable<T>, IEnumerable
  {
    int Count { get; }
    bool IsReadOnly { get; }
    void Add(T item);
    void Clear();
    bool Contains(T item);
    void CopyTo(T[] array, int index);
    bool Remove(T item);
  }
}

Improving performance by ensuring the capacity of a collection

Since .NET Core 2.1, types like Dictionary<T> and HashSet<T> have also had EnsureCapacity.

In .NET 6 and later, collections like List<T>, Queue<T>, and Stack<T> now have an EnsureCapacity method too, as shown in the following code:

List<string> names = new();
names.EnsureCapacity(10_000);
// load ten thousand names into the list

Understanding collection choices

Lists

namespace System.Collections.Generic
{
  [DefaultMember("Item")] // aka this indexer
  public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
  {
    T this[int index] { get; set; }
    int IndexOf(T item);
    void Insert(int index, T item);
    void RemoveAt(int index);
  }
}

IList<T> derives from ICollection<T> so it has a Count property, and an Add method to put an item at the end of the collection, as well as an Insert method to put an item in the list at a specified position, and RemoveAt to remove an item at a specified position.

If a new item (for example, Santiago) is inserted between London and Sydney, then the index of Sydney is automatically incremented. Therefore, you must be aware that an item's index can change after inserting or removing items, as shown in the following table:

Dictionaries

Think of the key as being like an index entry in a real-world dictionary. It allows you to quickly find the definition of a word because the words (for example, keys) are kept sorted, and if we know we're looking for the definition of manatee, we would jump to the middle of the dictionary to start looking, because the letter M is in the middle of the alphabet.

namespace System.Collections.Generic
{
  [DefaultMember("Item")] // aka this indexer
  public interface IDictionary<TKey, TValue>
    : ICollection<KeyValuePair<TKey, TValue>>,
      IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
  {
    TValue this[TKey key] { get; set; }
    ICollection<TKey> Keys { get; }
    ICollection<TValue> Values { get; }
    void Add(TKey key, TValue value);
    bool ContainsKey(TKey key);
    bool Remove(TKey key);
    bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value);
  }
}

Items in a dictionary are instances of the struct, aka the value type KeyValuePair<TKey, TValue>, where TKey is the type of the key and TValue is the type of the value, as shown in the following code:

namespace System.Collections.Generic
{
  public readonly struct KeyValuePair<TKey, TValue>
  {
    public KeyValuePair(TKey key, TValue value);
    public TKey Key { get; }
    public TValue Value { get; }
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void Deconstruct(out TKey key, out TValue value);
    public override string ToString();
  }
}

Stacks

For example, word processors use a stack to remember the sequence of actions you have recently performed, and then when you press Ctrl + Z, it will undo the last action in the stack, and then the next-to-last action, and so on.

Queues

For example, background processes use a queue to process work items in the order that they arrive, just like people standing in line at the post office.

.NET 6 introduces the PriorityQueue, where each item in the queue has a priority value assigned as well as their position in the queue.

Sets

Collection methods summary

Working with lists

Let's explore lists:

Working with dictionaries

Working with queues

Let's explore queues:

Sorting collections

A List<T> class can be sorted by manually calling its Sort method (but remember that the indexes of each item will change). Manually sorting a list of string values or other built-in types will work without extra effort on your part, but if you create a collection of your own type, then that type must implement an interface named IComparable. You learned how to do this in Chapter 6, Implementing Interfaces and Inheriting Classes.

Sometimes it would be useful to have an automatically sorted collection, that is, one that maintains the items in a sorted order as you add and remove them.

There are multiple auto-sorting collections to choose from. The differences between these sorted collections are often subtle but can have an impact on the memory requirements and performance of your application, so it is worth putting effort into picking the most appropriate option for your requirements.

More specialized collections

Working with a compact array of bit values

Working with efficient lists

Using immutable collections

If you import the System.Collections.Immutable namespace, then any collection that implements IEnumerable<T> is given six extension methods to convert it into an immutable list, dictionary, hash set, and so on.

Let's see a simple example:

void ProcessCollection<T>(IEnumerable<T> collection)
{
  // process the items in the collection,
  // perhaps using a foreach statement
}

I could pass an array, a list, a queue, a stack, or anything else that implements IEnumerable<T> into this method and it will process the items. However, the flexibility to pass any collection to this method comes at a performance cost.

But the worst performance problem with IEnumerable<T> is that the iteration has to allocate an object on the heap. To avoid this memory allocation, you should define your method using a concrete type, as shown highlighted in the following code:

void ProcessCollection<T>(List<T> collection)
{
  // process the items in the collection,
  // perhaps using a foreach statement
}

Working with spans, indexes, and ranges

One of Microsoft's goals with .NET Core 2.1 was to improve performance and resource usage. A key .NET feature that enables this is the Span<T> type.

Using memory efficiently using spans

When manipulating arrays, you will often create new copies of subsets of existing ones so that you can process just the subset. This is not efficient because duplicate objects must be created in memory.

Before we look at spans in more detail, we need to understand some related objects: indexes and ranges.

Identifying positions with the Index type

You learned in the previous topic that objects in a list can be accessed by passing an integer into their indexer, as shown in the following code:

int index = 3;
Person p = people[index]; // fourth person in array
char letter = name[index]; // fourth letter in name

// two ways to define the same index, 3 in from the start 
Index i1 = new(value: 3); // counts from the start 
Index i2 = 3; // using implicit int conversion operator
// two ways to define the same index, 5 in from the end
Index i3 = new(value: 5, fromEnd: true); 
Index i4 = ^5; // using the caret operator

Identifying ranges with the Range type

Range r1 = new(start: new Index(3), end: new Index(7));
Range r2 = new(start: 3, end: 7); // using implicit int conversion
Range r3 = 3..7; // using C# 8.0 or later syntax
Range r4 = Range.StartAt(3); // from index 3 to last index
Range r5 = 3..; // from index 3 to last index
Range r6 = Range.EndAt(3); // from index 0 to index 3
Range r7 = ..3; // from index 0 to index 3

Extension methods have been added to string values (that internally use an array of char), int arrays, and spans to make ranges easier to work with. These extension methods accept a range as a parameter and return a Span<T>. This makes them very memory efficient.

Using indexes, ranges, and spans

Working with network resources

Working with URIs, DNS, and IP addresses

Pinging a server

The metadata comprises items of information about your code. The metadata is generated automatically from your code (for example, information about the types and members) or applied to your code using attributes.

// an assembly-level attribute
[assembly: AssemblyTitle("Working with Reflection")]
// a type-level attribute
[Serializable] 
public class Person
{
  // a member-level attribute 
  [Obsolete("Deprecated: use Run instead.")] 
  public void Walk()
  {
...

Attribute-based programming is used a lot in app models like ASP.NET Core to enable features like routing, security, and caching.

Versioning of assemblies

• Major: Breaking changes.
• Minor: Non-breaking changes, including new features, and often bug fixes.
• Patch: Non-breaking bug fixes.

• Prerelease: Unsupported preview releases.
• Build number: Nightly builds.

Creating custom attributes

What is the <Program>$+<>c type?

Doing more with reflection

Let us see what can be achieved with ImageSharp:

• SixLabors.ImageSharp.Drawing
• SixLabors.ImageSharp.Web

Internationalizing your code

ISO is not an acronym. ISO is a reference to the Greek word isos (which means equal).

Localization is about customizing the user interface to support a language, for example, changing the label of a button to be Close (en) or Fermer (fr). Since localization is more about the language, it doesn't always need to know about the region, although ironically enough, standardization (en-US) and standardisation (en-GB) suggest otherwise.

Detecting and changing the current culture

Let's write some code:

Practicing and exploring

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

Exercise 8.1 – Test your knowledge

Use the web to answer the following questions:

1. What is the maximum number of characters that can be stored in a string variable?
2. When and why should you use a SecureString type?
3. When is it appropriate to use a StringBuilder class?
4. When should you use a LinkedList<T> class?
5. When should you use a SortedDictionary<T> class rather than a SortedList<T> class?
6. What is the ISO culture code for Welsh?
7. What is the difference between localization, globalization, and internationalization?
8. In a regular expression, what does $ mean?
9. In a regular expression, how can you represent digits?
10. Why should you not use the official standard for email addresses to create a regular expression to validate a user's email address?

Exercise 8.2 – Practice regular expressions

In the Chapter08 solution/workspace, create a console application named Exercise02 that prompts the user to enter a regular expression and then prompts the user to enter some input and compare the two for a match until the user presses Esc, as shown in the following output:

The default regular expression checks for at least one digit.
Enter a regular expression (or press ENTER to use the default): ^[a-z]+$ 
Enter some input: apples
apples matches ^[a-z]+$? True
Press ESC to end or any key to try again.
Enter a regular expression (or press ENTER to use the default): ^[a-z]+$ 
Enter some input: abc123xyz
abc123xyz matches ^[a-z]+$? False
Press ESC to end or any key to try again.

Exercise 8.3 – Practice writing extension methods

In the Chapter08 solution/workspace, create a class library named Exercise03 that defines extension methods that extend number types such as BigInteger and int with a method named ToWords that returns a string describing the number; for example, 18,000,000 would be eighteen million, and 18,456,002,032,011,000,007 would be eighteen quintillion, four hundred and fifty-six quadrillion, two trillion, thirty-two billion, eleven million, and seven.