Chapter 2: Speaking C# [Flashcarder]

Question

How does the **latest** setting differ from **latestmajor** in the `` configuration?

Answer 1

The ***latest*** setting uses the **highest major and minor number version** available, potentially enabling a minor version like 12.1 in the first half of 2024.

Answer 2

It uses the **highest available preview** version of the compiler, like 12.0 in July 2023 with .NET 8 Preview 6 installed.

Answer 3

By editing the **.csproj file** to add the `` element set to **preview**.

Answer 4

It allows using the **preview C# 13 compiler**, enabling exploration of new language features.

Answer 5

**Yes**, you can use a future version of the C# compiler with .NET 8 projects by setting the `` appropriately in the project file.

Answer 6

**Preview** versions should only be set for **exploration**, **not production** projects, as they are not supported by Microsoft and are more likely to have **bugs**.

Answer 7

In **November 2024**, making it possible to use the C# 13 compiler in projects that continue to target .NET 8 by setting `` to 13.

Answer 8

**C# 13** will be the default language version for **projects targeting .NET 9.**

Answer 9

Some new C# language features may require *changes in the underlying .NET libraries*, so **not all new features can be used when targeting older versions of .NET**.

Answer 10

Add the `#error version` statement in the Program.cs file to trigger a compiler error that reveals the **compiler and language version.**

Answer 11

The error reveals the **compiler version** (e.g., '4.8.0...') and the default **language version** (12.0) as part of the error message.

Answer 12

C# grammar includes **statements** and **blocks**. Additionally, **comments** are used to document code.

Answer 13

Besides **comments**, sensible **naming** for variables and functions, writing **unit tests**, and creating actual **documentation** are recommended practices for documenting code.

Answer 14

C# indicates the end of a statement with a semicolon (**;**).

Answer 15

Just as the order of words in an English sentence (e.g., placing adjectives before nouns) matters for clarity and meaning, the **order of types, variables, and expressions in C# statements is crucial** for the code's meaning and result.

Answer 16

An example of a C# statement is: `decimal totalPrice = subtotal + salesTax;` This statement includes: a **type** (*decimal*), a **variable** (*totalPrice*), and an **expression** (*subtotal + salesTax*) composed of **operands** (*subtotal, salesTax*) and an **operator** (*+*).

Answer 17

The order affects the **meaning** and the **result** of the expression, similar to how word order affects meaning in natural language sentences.

Answer 18

Comments are used to **document** code, **increasing understanding** of its functionality for others or for the original developer when revisiting the code later.

Answer 19

Use a double slash `//` at the beginning of the comment. The compiler ignores everything after `//` until the end of the line.

Answer 20

Use `/*` at the beginning and `*/` at the end of the comment block.

Answer 21

**Yes**, you can use /* and */ for commenting in the middle of a statement. For example: `decimal totalPrice = subtotal /* for this item */ + salesTax;`

Answer 22

Consider if the code can be **refactored** to be more understandable without lengthy comments. Well-designed code with clear function signatures and class encapsulation may reduce the need for extensive commenting.

Answer 23

In *Visual Studio 2022*, navigate to Edit | Advanced | Comment Selection or Uncomment Selection. In *Visual Studio Code*, navigate to Edit | Toggle Line Comment or Toggle Block Comment.

Answer 24

**Commenting** code involves adding descriptive text to explain code sections. **Commenting out** code means adding comment characters to make code statements inactive. **Uncommenting** means removing these comment characters.

Answer 25

C# uses **curly brackets** `{ }` to indicate a block of code.

Answer 26

A block in C# can define the **start and end of various language constructs**, including namespaces, classes, methods, or statements like foreach.

Answer 27

A **namespace** in C# is used to **organize code** into groups, preventing naming conflicts and managing classes. To access types in different namespaces, you need to use a ***using*** directive or a **fully qualified name**. For example: `using System;`

Answer 28

A **class** in C# contains the **members of an object**, including **methods**. For example: ```public class MyClass { public int Number; // Field public void Display() // Method { Console.WriteLine(Number); } }```

Answer 29

A **method** in C# contains **statements** that implement an **action** that an object can take. For example: ```public void Greet() // Method { Console.WriteLine("Hello, world!"); }```

Answer 30

These code editors provide a **feature to collapse and expand blocks** by toggling the [-] or [+] symbols or an arrow symbol in the left margin of the code.

Answer 31

Regions are **defined labeled areas around any statements**, allowing code editors to collapse and expand them similarly to blocks, helping to **organize code** into collapsible sections for better readability. For example: ``` #region Methods public void Display() { Console.WriteLine(number); } #endregion ```

Answer 32

Regions can **act as commented blocks** that **summarize** what the block does, aiding in the **documentation** and **organization** of code, making it easier to navigate complex codebases.

Answer 33

**C# typically places both the open and close braces on their own lines at the same indentation level**, while languages like JavaScript often place the open brace at the end of the declaration statement.

Answer 34

**Yes**, you can use whatever brace style you prefer, as the compiler does not enforce a specific style. However, **it's easier to follow conventional style**.

Answer 35

The brace style where **both the open and close braces are on their own line and at the same indentation level** is the most commonly used in C#.

Answer 36

It's recommended to follow the **standards adopted by your development team** or, if you're a solo developer, to choose conventions that ensure your **code is readable and maintainable**, being kind to your future self by being consistent.

Answer 37

The **space**, **tab**, and **newline characters** are considered **white space** in C#.

Answer 38

Extra white space has **no effect on the compiler** and can be used for **formatting** code for better readability.

Answer 39

The only required white space is **between tokens that the compiler must recognize as separate**, such as between a type and a variable name. For example: `string firstName = "Ben";`

Answer 40

Examples include: **using, namespace, class, static, int, string, double, bool, if, switch, break, while, do, for, foreach, this,** and **true**.

Answer 41

Common symbol characters include: **"**, **'**, **+**, **-**, *, **/**, **%**, **@**, and **$**.

Answer 42

C# **keywords** are all in **lowercase**. **User-defined type names should not be all lowercase** to avoid compiler warnings and future reserved keyword conflicts.

Answer 43

**C# has about 100 keywords**, whereas the English language has more than 250,000 distinct words.

Answer 44

The difficulty arises because developers need to **learn and define new "words" or concepts** within the language, expanding beyond the basic keywords to understand and utilize the language fully.

Answer 45

Most programming languages, including C#, use English words for their syntax and keywords, such as "if" and "break."

Answer 46

By default, these IDEs show **C# keywords in blue and other code in black**, though this can be **customized**.

Answer 47

Go to Tools | Options, navigate to the Environment section, select Fonts and Colors, and then choose the display items to customize.

Answer 48

Answer 49

Plain text editors **do not provide feedback on syntax errors or code correctness**, unlike specialized IDEs or editors with language support.

Answer 50

They **highlight spelling and grammatical errors** in the code, such as method names that are incorrectly capitalized or statements missing a semicolon, using colored squiggly lines.

Answer 51

A namespace is like an **address that organizes code and helps to locate a specific method or type** within larger libraries. It's used to make code more manageable and to avoid name conflicts.

Answer 52

You use the ***using* directive to import a namespace**, e.g., `using System;`. This makes **all types** within that namespace available in your program without needing to specify the namespace prefix.

Answer 53

It simplifies the code by **eliminating the need to prefix every type with its namespace**, thereby making the code cleaner and more readable.

Answer 54

They **reduce the need to include common using statements at the top of every .cs file** by allowing a namespace to be imported once and made available throughout all .cs files in the project.

Answer 55

By **adding global using statements in a dedicated file, such as *GlobalUsings.cs***, which contains all the global using statements for the project.

Answer 56

It organizes global imports in one place, making the **project cleaner and easier to maintain** by avoiding repetitive namespace imports across multiple files.

Answer 57

While the book suggests a practical approach by naming the file ***GlobalUsings.cs***, it also notes that a de facto standard naming convention might emerge as developers get accustomed to this feature.

Answer 58

It generates a .GlobalUsings.g.cs file in the obj\Debug\net folder, which contains implicitly globally imported namespaces.

Answer 59

The list of implicitly **imported namespaces depends on the targeted SDK**, with different SDKs adding specific namespaces to the implicitly imported list.

Answer 60

The **Microsoft.NET.Sdk** imports basic namespaces like ***System***, ***System.IO***, and ***System.Linq***, among others. **Microsoft.NET.Sdk.Web** includes: ***all from Microsoft.NET.Sdk plu*s** web-specific namespaces like ***Microsoft.AspNetCore.Builder*** and ***Microsoft.Extensions.Hosting***.

Answer 61

By toggling on the "**Show All Files**" button in Solution Explorer and navigating through the **obj -> Debug -> net8.0** folders to find the file named .GlobalUsings.g.cs.

Answer 62

The **file name includes a *g* for generated** (e.g., .GlobalUsings.g.cs), and the file itself starts with a comment indicating it is autogenerated.

Answer 63

By specifying **Alias** or **Static attributes** in the element within the project file for the desired class, making it easier to reference in the code.

Answer 64

**Statically importing** the *Console class* allows **calling its methods without prefixing** them with Console., and **aliasing** the *Environment class* enables referring to it with a **shorter or more convenient name**.

Answer 65

By **removing** or **setting** the element to disable in the project file, allowing for manual management of global using statements.

Answer 66

Just like verbs in English indicate action and change form based on tense, **methods in C# perform actions** and **can change how they are called or executed** based on the specifics of the action, a concept known as **overloading**.

Answer 67

Yes, the` Console.WriteLine()` method is an example of overloading. It can be called **with no arguments** to output just a line terminator, or **with arguments** to output a string, formatted numbers, and dates.

Answer 68

In C#, equivalents of nouns are **types, variables, fields,** and **properties**.

Answer 69

**Everything can be categorized as a type** in C#, which further includes **classes**, **structs**, **enums**, **interfaces**, or **delegates**.

Answer 70

While a **class is a specific kind of type** in C#, the **term "type" broadly refers to any categorization** within C# that can include classes, structs, and other categorizations. For example, *string* is a class, but *int* (which maps to System.Int32) is a struct.

Answer 71

C# itself only has a few **keywords** for types, such as *string* and *int*, which are **aliases** representing types provided by the **.NET platform**. The platform offers a vast **library of types** available to C#.

Answer 72

**Reflection** is used to discover the number of types and their methods available in a C# application.

Answer 73

***N0*** means to **format a number with zero decimal places**, making the output easier to read.

Answer 74

The challenge comes from the **vast number of types and methods** available to learn, with each type potentially having many members, including methods.

Answer 75

It's used to work with **assemblies**, **modules**, **types**, **methods**, and so on, **at runtime**, enabling the **analysis** and **manipulation** of the program's **metadata**.

Answer 76

These tools can help programmers **learn** new things by **explaining** existing code, suggesting **improvements**, and even **writing** code, enhancing **understanding** and **productivity**.

Answer 77

**Variables temporarily store data within the memory of a running program**, facilitating the processing of incoming data from sources like **files**, **databases**, or **user input**, and preparing it for **output**.

Answer 78

When the program ends, the **data stored in memory is lost** unless it has been output to persistent storage like **files** or **databases**.

Answer 79

When choosing a type for a variable, consider how much **space** it will occupy in memory and **how quickly** data of that type can be processed.

Answer 80

Different data types, such as *int* and *double*, can be likened to boxes of different sizes; **smaller data types may use less memory but could potentially be slower to process compared to larger data types**, especially on systems optimized for larger data units, like a 64-bit operating system.

Answer 81

***Camel case*** is used for **local variables** and **private fields** (e.g., `cost`, `orderDetail`). ***Pascal case*** (Title case) is used for **types**, **non-private fields**, and other members like **methods** (e.g., `String`, `Int32`, `Cost`).

Answer 82

Some programmers **prefix private field names with an underscore**, for example, `_dateOfBirth` instead of dateOfBirth.

Answer 83

Declare the variable with a **type followed by an identifier and assign a value using the = symbol**. For example: `double heightInMetres = 1.88;`.

Answer 84

``` ```The **nameof** keyword outputs the name of a variable. It is used within string interpolations or other expressions to refer to the variable name as a **string**. For example: `Console.WriteLine($"The variable {nameof(heightInMetres)}` has the value `{heightInMetres}`.");.

Answer 85

In C# 12, **nameof can now access instance data from a static context**, which is a change from earlier versions where nameof could only access static data in such contexts.

Answer 86

A literal value is a **notation used to represent a fixed value directly in the code**. Each data type has its own form of literal notation.

Answer 87

A single character, like 'A', is assigned to a **char type** using **single quotes**. For example,` char letter = 'A';`.

Answer 88

**A surrogate pair is a set of two System.Char values** needed to represent certain characters, like some Egyptian Hieroglyphs, in C#. Understanding this is important to avoid bugs, especially in multicultural applications.

Answer 89

A string is assigned using **double quotes** around the literal value. For example, `string firstName = "Bob";`. Strings can also be assigned from **function calls** or **constructors**, such as: `string horizontalLine = new('-', count: 74);`.

Answer 90

To output emojis, use Windows **Terminal** and set the **console output encoding to UTF-8** with `Console.OutputEncoding = System.Text.Encoding.UTF8;`, then use `Console.WriteLine()` to print the emoji.

Answer 91

Use the `char.ConvertFromUtf32()` method with the Unicode code point of the emoji, for example, `string grinningEmoji = char.ConvertFromUtf32(0x1F600);`.

Answer 92

Escape sequences in strings represent **special characters**, such as **tabs (\t)** and **new lines (\n)**, using a **backslash (\\)**.

Answer 93

The **compiler interprets backslashes as the start of an escape sequence**, which can lead to errors if the following characters form a valid escape sequence, such as \t being interpreted as a tab.

Answer 94

By using **verbatim string literals**, which are **prefixed with the @ symbol**, to tell the compiler to **ignore escape sequences** and interpret the string exactly as written.

Answer 95

`string filePath = @"C:\televisions\sony\bravia.txt";` This verbatim string literal correctly handles the backslashes without treating them as the start of escape sequences.

Answer 96

Raw string literals allow for **entering text without needing to escape special characters**. They were introduced to simplify the **inclusion of complex content like XML, HTML, or JSON** directly in the code.

Answer 97

Raw string literals are **enclosed by three or more double-quote characters (""") at both the start and end** of the literal.

Answer 98

If the **content itself includes sequences of three or more double-quotes**, you use additional double-quotes (e.g., four or five) to ensure the literal is correctly delimited.

Answer 99

C# adjusts the indentation based on the **alignment of the closing triple double-quotes**. The **compiler removes any common leading whitespace that matches the indentation of the closing quotes**.

Answer 100

If the closing quotes are aligned with the left margin, the indentation inside the raw string literal is preserved as it appears in the code, meaning **no indentation removal occurs.**

Answer 101

Raw interpolated string literals **combine raw strings with interpolation**. By prefixing the string with multiple dollar signs (e.g., **$$**), you specify that **pairs of curly braces** within the string represent **interpolated expressions**, while **single braces** are treated as **literal content**.

Answer 102

The **number of dollar signs at the start of the string indicates the number of curly braces that form an interpolated expression**. For example, **$$** means two curly braces (**{{}}**) enclose interpolated expressions.

Answer 103

``` var person = new { FirstName = "Alice", Age = 56 }; string json = $$""" { "first_name": "{{person.FirstName}}", "age": {{person.Age}}, "calculation": "{{{ 1 + 2 }}}" } """; Console.WriteLine(json); ``` This code **outputs JSON** where person.FirstName and person.Age are interpolated into the string, and calculations are performed within triple braces.

Answer 104

**Literal string:** Uses double quotes, can include escape sequences like \t for tab. **Raw string literal:** Enclosed in three or more double quotes, does not interpret escape sequences. **Verbatim string:** Prefixed with @, interprets backslashes literally and allows multiline strings. **Interpolated string:** Prefixed with $, enables embedding formatted variables directly within the string.

Answer 105

Determine whether you need to perform **arithmetic operations** on it. If the data involves **non-digit characters** for formatting (like phone numbers with parentheses or hyphens), it should be stored as a ***string***.

Answer 106

Natural numbers are used for **counting** and are **whole numbers starting from 0**. In computing, they can be represented as **unsigned integers** (e.g., ***uint*** in C#).

Answer 107

**Natural numbers** include **only positive values and zero**, represented by data types like ***uint***. **Integers** include **both positive and negative whole numbers and zero**, represented by data types like ***int***.

Answer 108

A **float**, which is a **single-precision floating-point number**, requires an '**F**' or '**f**' suffix in its declaration (e.g., `float realNumber = 2.3f;`). A **double**, which is a **double-precision floating-point number**, does **not need a suffix** and is the default for **decimal** values (e.g., `double anotherRealNumber = 2.3;`).

Answer 109

These data types are necessary for representing **numbers with fractional parts** and **different levels of precision**, such as scientific computations where big data is being processed

Answer 110

The binary number system, or **Base 2**, is used by computers to **store all data**. It uses only two digits, **0 and 1**, to represent any number.

Answer 111

Computers store the decimal number 10 as 00001010 in binary, which corresponds to the **bits being set at positions representing 8 and 2** (8 + 2 = 10).

Answer 112

The **decimal system**, also known as **Base 10**, is used by humans and includes ten digits from **0 to 9**. The **binary system**, used by computers, is **Base 2** and uses only two digits, **0 and 1**.

Answer 113

The binary system is **fundamental** for computing because computers store and process **data** using **bits**, which are inherently **binary**. Every operation in a computer, from arithmetic to data processing, is based on **binary calculations**.

Answer 114

C# 7 introduced the use of the **underscore _** as a **digit separator** to enhance the legibility of numeric literals.

Answer 115

Underscores can be **inserted between any digits of a number**, whether it's in decimal, binary, or hexadecimal notation, to improve readability.

Answer 116

The number one million can be written as **1_000_000** using digit separators to make it clearer.

Answer 117

**Decimal**: `int decimalNotation = 2_000_000;` **Binary**: `int binaryNotation = 0b_0001_1110_1000_0100_1000_0000;` **Hexadecimal**: `int hexadecimalNotation = 0x_001E_8480;`

Answer 118

By comparing the values using the **equality operator** (**==**) and outputting the result, for example: ```Console.WriteLine($"{decimalNotation == binaryNotation}"); Console.WriteLine($"{decimalNotation == hexadecimalNotation}");```

Answer 119

Use **string interpolation** and **formatting specifiers**: **Decimal:** `Console.WriteLine($"{decimalNotation:N0}");` **Hexadecimal:** `Console.WriteLine($"{decimalNotation:X}");`

Answer 120

The outputs demonstrate that the **same integer value can be expressed and verified in different numerical bases** (decimal, binary, and hexadecimal) within C#, confirming that these are just different ways to represent the same underlying value.

Answer 121

Computers use **binary-based** systems, which can lead to **precision issues** when converting decimal numbers into binary format. The ***float*** and ***double*** data types use **finite precision** which **can't accurately represent all real numbers.**

Answer 122

Most programming languages, including C#, follow the **IEEE 754 Standard for Floating-Point Arithmetic**, which was established by the Institute of Electrical and Electronics Engineers in 1985.

Answer 123

The sizeof() operator in C# returns the **number of bytes** that a type occupies in memory.

Answer 124

You can find the range of values a type can store by accessing the ***MinValue*** and ***MaxValue*** members of that type.

Answer 125

Although a ***double*** uses less memory (**8 bytes**) compared to a ***decimal*** (**16 bytes**), it can store larger numbers due to the way **floating-point arithmetic** is implemented, which allows it to represent very large or very small numbers but with *less precision* compared to decimal.

Answer 126

The **float type is less precise than the double type**, which can make comparisons appear *true* due to its lower accuracy, even when they are not mathematically exact.

Answer 127

It is recommended to **avoid using double for exact equality comparisons (==)** because of potential *inaccuracies*. Instead, use double when only relative comparisons (<, >) are necessary, such as comparing measurements where exact values are not crucial.

Answer 128

In binary, 0.1 is represented as a **repeating binary fraction** (0.0001100110011...), which cannot be precisely stored in a finite number of bits used by types like *float* or *double*, leading to **rounding errors**.

Answer 129

The ***decimal*** type maintains accuracy by **storing numbers as large integers and managing the decimal point's position.** This allows it to represent numbers precisely without rounding errors common in floating-point representations.

Answer 130

Use decimal for scenarios where **precision in real numbers is crucial**, such as **financial calculations**, **engineering**, and **scientific measurements**, where rounding errors from floating-point arithmetic can lead to significant discrepancies.

Answer 131

The ***System.Half** type*, introduced in *.NET 5*, is a data type that can **store real numbers** and typically uses **2 bytes** of memory.

Answer 132

Introduced in *.NET 7*, ***System.Int128*** and ***System.UInt128*** are types that can store **signed** and **unsigned** **integer values**, respectively, and *normally* use **16 bytes** of memory.

Answer 133

The **sizeof** operator can only be used to determine the size of new number types like ***System.Half*** and ***System.Int128*** within an **unsafe code block**, which requires enabling unsafe code in the project settings.

Answer 134

***System.Half*** uses **2 bytes** and can store numbers from **-65,504 to 65,504.** ***System.Int128*** uses **16 bytes** and can store numbers from approximately **-170 quadrillion to 170 quadrillion.**

Answer 135

Unsafe code is required for sizeof with certain types because **these operations bypass the *.NET runtime's* safety checks**, **allowing direct memory** access which is necessary for operations like measuring the size of newer or more complex data types.

Answer 136

Boolean variables can only store one of two values: **true** or **false**.

Answer 137

**Booleans** are primarily used to **control the flow** of programs, such as in **branching** (if-statements) and **looping** constructs.

Answer 138

The **object type** is a *special* type in C# that can **store any type of data**. However, its *flexibility* can lead to **messier code** and **poorer performance**, making it advisable to **avoid unless necessary**.

Answer 139

To perform type-specific operations on an object variable, you must **cast it to the appropriate type**. For example, to access the *Length* property of an object variable storing a string, you must cast it to string.

Answer 140

Using the object type should be limited due to its **impact on performance and code clarity**. It lacks type-specific properties and methods without explicit casting, which can complicate the code.

Answer 141

The dynamic type, introduced in C# 4, allows variables to **store any type of data and enables the invocation of methods, properties, and fields of an object** without an explicit cast at compile time.

Answer 142

Unlike variables of type object, **variables declared with the dynamic type do not require casting to access members**. However, this comes with a performance cost due to runtime type checking.

Answer 143

Using the dynamic type allows method and property **access directly without casting**, but this can lead to **runtime exceptions** if the accessed members do not exist on the runtime type of the object.

Answer 144

```dynamic something = 12; // int type assigned Console.WriteLine(something.Length); // This will throw a RuntimeBinderException at runtime because 'int' does not have a 'Length' property.```

Answer 145

IntelliSense or code completion does not work with dynamic types because their **resolution occurs at runtime, and the compiler does not check the type during build time.**

Answer 146

Local variables are **declared inside methods and only exist during the execution of that method**. Once the method *returns*, the local variables are no longer accessible.

Answer 147

Local variables that are **value types are released immediately when the method returns**, while local variables that are **reference types are released through garbage collection**.

Answer 148

Local variables can be declared with specific types by **specifying the type before the variable name.** For example: `int population = 67_000_000; // Integer type` `double weight = 1.88; // Double type` `decimal price = 4.99M; // Decimal type` `string fruit = "Apples"; // String type` `char letter = 'Z'; // Char type` `bool happy = true; // Boolean type`

Answer 149

Depending on the code editor and its settings, it may show green **squiggles** under each variable name and lighten their text color to warn that the variable is assigned but its value is never used.

Answer 150

The *var* keyword in C# allows for **type inference** where the compiler determines and assigns the **most specific type** based on the assigned value at compile time. This feature is available from C# 3 onwards.

Answer 151

Using *var* for type inference **does not affect runtime performance** because type resolution happens at compile time.

Answer 152

**L:** Infers a **long** type **UL:** Infers an **ulong** type **M:** Infers a **decimal** type **D:** Infers a **double** type **F:** Infers a **float** type

Answer 153

**Numeric literals without a decimal point default to int** unless a *suffix* is specified. **Numeric literals with a decimal point are inferred as double** unless a *suffix* like M or F is used. **Double quotes infer a string type**. **Single quotes infer a char type**. **True or false infer a bool type.**

Answer 154

Using *var* is considered **good practice when the type is obvious** from the right side of the assignment, making the code cleaner and less repetitive. However, if the **type is not clear, it's better to explicitly declare the variable** with a specific type to improve code readability and maintainability.

Answer 155

Introduced in C# 9, target-typed new **allows instantiation of objects without explicitly repeating the type if it's already specified**, simplifying the syntax and improving readability.

Answer 156

You can specify the variable type and use new() without specifying the type again. For example: `XmlDocument xml3 = new();`

Answer 157

When objects require their fields or properties to be set during initialization, the **syntax allows for inferred type setting**. For example: ```Person kim = new(); kim.BirthDate = new(1967, 12, 26); // Implicitly new DateTime```

Answer 158

This syntax **reduces the amount of code** needed, **clarifies the variable's type** at the start of the statement, and is **not limited to local variables** like *var*. It **improves readability** by focusing on the variable type first.

Answer 159

You should avoid using target-typed new **if you are working with compilers that predate C# 9**, as this feature will not be supported.

Answer 160

The default value of an int is **0**.

Answer 161

The default value of a bool is **False**.

Answer 162

default(DateTime) returns **01/01/0001 00:00:00.**

Answer 163

The default value of a string is **null**.

Answer 164

You can assign the default value to a variable by using the syntax **variable = default;**. For example, `number = default;` resets the number variable to its default value.

Answer 165

After setting a variable like `int number = 13;` to default, and then printing it, the output will be number reset to its default: **0**.

Answer 166

Console applications are **text-based**, **run at the command prompt**, and are often used for **simple scripting** tasks like compiling files or encrypting parts of a configuration file. They can also **accept arguments** to control their behavior.

Answer 167

The ***Write*** method **outputs text without a carriage return**, leaving the cursor at the end of the printed text, while the ***WriteLine*** method **outputs text followed by a carriage return**, moving the cursor to the start of the next line.

Answer 168

Use `Write("A"); Write("B"); Write("C");` to print "ABC" continuously on one line without carriage returns.

Answer 169

Use `WriteLine("A"); WriteLine("B"); WriteLine("C");` to print each letter on a new line, with the cursor moving to the next line after each letter.

Answer 170

You can format a string to display the cost of items using the ***Console.WriteLine ***or ***string.Format*** methods with *numbered positional arguments*, like this: `Console.WriteLine("{0} apples cost {1:C}", numberOfApples, pricePerApple * numberOfApples);`

Answer 171

The ***Write***, ***WriteLine***, and ***Format*** methods of the *Console* class support formatting strings using **numbered positional arguments.**

Answer 172

With *Console.WriteLine*, you can use **up to 3 named arguments (arg0, arg1, arg2)**. If you need to pass more than three values, you cannot use *named arguments*.

Answer 173

**Once you become comfortable with formatting strings**, it is suggested to stop using named parameters like `format:, arg0:, and arg1:` to streamline the code.

Answer 174

**Interpolated strings.**

Answer 175

The statement **must be all on one line.**

Answer 176

In C# 11 or later, you **can include a line break in the middle of an expression but not in the string text** itself.

Answer 177

**Interpolated strings can't be read from resource files to be localized**, making them less versatile for *international* applications.

Answer 178

**Before C# 10, string constants could only be combined using concatenation** with the **+** operator. C# 10 introduced the ability to use **interpolated strings for combining string constants**, enhancing readability and simplicity.

Answer 179

A *format string* in C# is used to specify **how a variable or expression should be formatted** when output. It follows the syntax **{ index [, alignment ] [ : formatString ] }**, where **index** refers to the **argument position**, **alignment** specifies how text should be **aligned** within a given width (positive for right, negative for left), and **formatString** determines the **formatting type** like number or currency.

Answer 180

The "N0" format string in C# formats a **number with thousand separators and no decimal places**. This helps in displaying numbers in a more **readable** form, especially when dealing with large values.

Answer 181

The "C" *format string* in C# is used for **currency formatting**. The output is formatted according to the currency and thousand separator conventions of the **current thread's culture settings**. For example, it might display pounds sterling with commas as thousand separators in the UK, and euros with dots as thousand separators in Germany.

Answer 182

Alignment in *format strings* is specified by **including an integer after the variable index and a comma inside the curly braces.** **Positive** integers align the text to the **right**, while **negative** integers align it to the **left**. This is useful for aligning columns in *tabular* outputs.

Answer 183

The '0' format code is a **zero placeholde**r. It **replaces the zero with the corresponding digit if present**; **otherwise, it uses zero**. For example, using 0000.00 to format the value 123.4 would result in 0123.40.

Answer 184

The '**#**' format code is a **digit placeholder**. It **replaces the hash with the corresponding digit if present; otherwise, it uses nothing.** For example, using ####.## to format the value 123.4 would result in 123.4.

Answer 185

The '**.**' is a **decimal point that sets the location of the decimal point in the number and respects cultural formatting** differences, such as using a dot (.) in US English and a comma (,) in French.

Answer 186

The '**,**' serves as a **group separator, inserting a localized group separator between each group.** It is also used to **scale a number by dividing it by multiples of 1,000 for each comma placed after the decimal point.** For example, formatting the value 1234567 with 0,000 would result in 1,234,567.

Answer 187

The '**%**' format code **multiplies the value by 100 and adds a percentage character** to the number, effectively converting it into a percentage format.

Answer 188

The '**\\**' is an **escape character that makes the next character a literal instead of a format code**, which helps include actual format symbols in the output text. For example, formatting the value 1234 with \\##,###\\# would give #1,234#.

Answer 189

The '**;**' is a **section separator that defines different format strings for positive, negative, and zero values.** For example, using the format string [0];(0);Zero, the number 13 would be formatted as [13], -13 as (13), and 0 as Zero.

Answer 190

The ***Console.ReadLine()*** method is used to get text input from the user. It waits for the user to type text and press Enter, returning the input as a *string* value.

Answer 191

To handle potential null return values from *Console.ReadLine(),* you can use the **nullable reference type notation string ?** for variables where null is an acceptable value, or the **null-forgiving operator !** to assert that the value will not be null.

Answer 192

Appending a ? after the string type in a variable declaration (e.g., `string? firstName`) **tells the C# compiler that the variable may hold a null value**, which helps avoid compiler *warnings* about possible null values.

Answer 193

The **null-forgiving operator ! is used to tell the compiler that a value will not be null**, even if the method called could technically return null. This operator **suppresses compiler warnings** about null values.

Answer 194

Importing a static class in C# 6 and later allows for **simplifying the code by eliminating the need to repeatedly specify the class name when calling its static members.** For example, by importing the *System.Console* class statically, you can use its methods like *WriteLine* directly without prefixing them with 'Console.', streamlining the code and reducing verbosity.

Answer 195

To statically import the System.Console class in a single file, you **add the statement `using static System.Console;`** at the top of the Program.cs file. This allows you to use all static methods from the *Console* class directly without the class name prefix.

Answer 196

In Visual Studio, you can simplify your code by using the **Find and Replace feature** to remove repeated 'Console.' references. First, select 'Console.' including the dot, navigate to Edit | Find and Replace | Quick Replace, leave the Replace box empty, click on 'Replace all', and then close the replace box.

Answer 197

Edit your `.csproj` file to include: ``` ```

Answer 198

The string[] args parameter in the *Main* method of a C# console application is used to **receive command-line arguments**. These arguments are passed as an *array of strings* to the application, allowing users to influence the application's *behavior at runtime* by providing different values when executing the program.

Answer 199

Command-line arguments are separated by **spaces**. To **include spaces** within an argument value and ensure it is treated as a single argument, the value should be **enclosed in single or double quotes**.

Answer 200

In .NET 6 and later top-level programs, the ***Program* class and its *Main* method are hidden**, but the **args array still exists** implicitly. The args array is automatically available for accessing command-line arguments, maintaining functionality without explicitly defining it in the code

Answer 201

To output and enumerate command-line arguments in a console application, use the following steps: **Output the number of arguments using**` WriteLine($"There are {args.Length} arguments.");`. **Iterate through the args array with a foreach loop** to display each argument, like so: ```foreach (string arg in args) { WriteLine(arg); }```

Answer 202

The try-catch statement is used to **handle exceptions** that occur when a platform-specific API is not supported by the current platform. For example, if an application tries to change the cursor size, which is not supported on macOS, wrapping this operation in a try-catch allows the program to catch the PlatformNotSupportedException and provide a user-friendly message instead of crashing.

Answer 203

You can use the ***OperatingSystem* class to check for specific operating systems and their versions**, allowing code to execute only on platforms that support certain features. For instance, `OperatingSystem.IsWindows()` checks for a Windows OS, and `OperatingSystem.IsIOSVersionAtLeast(major: 14, minor: 5)` checks for at least iOS 14.5.

Answer 204

Conditional compilation statements like **#if, #elif, #else, and #endif** **control the compilation of code based on defined symbols**, allowing developers to include or exclude code depending on the target platform. For example, `#if NET7_0_ANDROID` includes code only when compiling for Android under .NET 7. This method is used to **tailor applications to different environments without runtime overhead.**

Answer 205

These keywords are used for **implementing multitasking in graphical user interfaces** (GUIs), **improving scalability** of web applications and services, and **preventing blocking calls** when interacting with the filesystem, databases, and remote services.

Answer 206

C# 7.1 introduced the **ability to mark the *Main* method as async**, allowing the use of the **await** keyword directly within it.

Answer 207

By creating a **console app that makes an asynchronous HTTP request** using *HttpClient* to fetch a webpage (e.g., Apple’s home page) and outputs the content size.

Answer 208

To discover the compiler and language version in a C# file, you can use preprocessor directives such as #if, combined with symbols like __CSCSHARP__ and __VERSION__ to check compiler-specific conditions. Additionally, the **language version can be specified in the project file** (.csproj) with tag.

Answer 209

Types of Comments in C#: **Single-line comment:** Prefixed with //, comments the rest of the line. **Multi-line comment:** Enclosed between /* and */, comments out blocks of code.

Answer 210

**Verbatim string:** Denoted by a **@** symbol before the string (e.g., `@"C:\Files`"), it **ignores escape sequences** and prints everything within the quotes as is. **Interpolated string:** Prefixed with **$** (e.g., `$"Name: {name}"`), it allows **embedding of expressions** inside string literals using curly braces.

Answer 211

*float* and *double* types are **prone to rounding errors** because they represent floating point numbers in a binary format, which can lead to precision issues, especially when dealing with very large or very small numbers, or when exact decimal representation is required.

Answer 212

In C#, you can use ***sizeof*** operator to determine the number of bytes a type uses in memory. For instance, `sizeof(double); `returns 8, indicating that a double uses 8 bytes.

Answer 213

The *var* keyword should be used **when the type of a variable is obvious from the right side of the assignment**, or **when it doesn't matter to the reader what the exact type is**. It is mostly used for *local variable declaration* where the initial assignment provides sufficient detail to clearly infer the type.

Answer 214

The newest syntax in C# for creating an instance of a class uses **target-typed new**, which allows you to **omit the type name if it can be inferred** by the compiler: `XmlDocument doc = new();`

Answer 215

The *dynamic* type in C# **bypasses static type checking**. When using dynamic, **you lose compiler-time type checking and related *IntelliSense* support** in IDEs, which can lead to **runtime errors** if the operations being performed are not valid on the runtime type of the dynamic object.

Answer 216

To right-align text in a format string, you can **specify a positive number for the alignment component** in the format item. For example, **{0,10}** aligns the first argument to the right over a width of 10 characters.

Answer 217

In C#, arguments for a console application are **separated by spaces.** However, if an argument itself contains spaces, it should be enclosed in quotes.