2. C# Language Basics || C# 10

Question 1

What is a statement block?

Answer 1

Series of statement surrounded by a pair of braces (all of this is a method)

int feetToInches (int feet)
{
  return 12 * feet;
}

Question 2

What is an “assembly”?

Answer 2

Assemblies are the fundamental units of deployment, version control, reuse, activation scoping, and security permissions for .NET-based applications. An assembly is a collection of types and resources that are built to work together and form a logical unit of functionality. Assemblies take the form of executable (.exe) or dynamic link library (.dll) files, and are the building blocks of .NET applications. They provide the common language runtime with the information it needs to be aware of type implementations.

In .NET and .NET Framework, you can build an assembly from one or more source code files. In .NET Framework, assemblies can contain one or more modules. This way, larger projects can be planned so that several developers can work on separate source code files or modules, which are combined to create a single assembly.

Assemblies have the following properties:

Assemblies are implemented as .exe or .dll files.

For libraries that target .NET Framework, you can share assemblies between applications by putting them in the global assembly cache (GAC). You must strong-name assemblies before you can include them in the GAC.

Assemblies are only loaded into memory if they're required. If they aren't used, they aren't loaded. Therefore, assemblies can be an efficient way to manage resources in larger projects.

You can programmatically obtain information about an assembly by using reflection.

You can load an assembly just to inspect it by using the MetadataLoadContext class on .NET and .NET Framework. MetadataLoadContext replaces the Assembly.ReflectionOnlyLoad methods.

Question 3

Name some predefined and custom types. What is the main difference between them?

Answer 3

Predefined: string, int, bool;
Custom: Person, Salary, Payment;

Predefined types dont need to be instantiated like custom does:

int three = 3;
Person jack = new Person(“Jack”);

Question 4

How would you describe static class?

Answer 4

Static members (data and function members) dont operate on the instance of the type e.g. Console.WriteLine() and not var x = new Console. Methods of the static class are available through class name (Console) and not instance name (x).

Question 5

What is a implicit conversion?

Answer 5

short -> int -> long;
Implicit conversion happens automatically: int -> long
Allowed when both are true:
1. The compiler can garuantee that they will always succeed;
2. No information is lost in conversion;

Question 6

What is an explicit conversion?

Answer 6

Explicit conversion require a cast and this type of conversion is required when one of the following is true:
1. The compiler cannot garuantee that they will always succeed
2. Information might be lost during conversion

Question 7

What are the types categories in C#?

Answer 7

• Value types
• Reference types
• Generic type parameters
• Pointer types

Question 8

Which types lay under the value type? (Name more than 3)

Answer 8

Value types comprise most built-in types (all numeric types, char and bool types) as well as custom struct and enum types

Question 9

Which types lay under reference type?

Answer 9

All classes, array, delegate, interface types. Includes predefined string type as well

Question 10

What is the fundamental difference between value and reference types?

Answer 10

The way they are handled in memory. Value type objects are always copied or created, but assigning a reference type the reference is copied not the object instance.

Question 11

What are nullable variables?

Answer 11

Variables which references points to no objects. Thats why we get NullReferenceException. This also means that value type cannot have a null as value if not declared otherwise (?)

Question 12

What is the difference between i++ and ++i?

Answer 12

Both are adding 1 to the variable, but the difference is whether we want variable’s value before or after the increment:

console.writeline(x++); outputs 0; value is now 1;

console.writeline(++x); outputs 1; value is 1;

Question 13

What is “short-circuiting”? Where it is encountered?

Answer 13

It is encountered when using && and || operators in a condition (comparing to & and |). In short if the first part of the condition is not true the following part is not evaluated, therefore if the first statement is false this statement wont throw a NullReferenceException
If ( sb != null && sb.Length >0)…

Question 14

What is a ternary operator?

Answer 14

Ternary operator ( condotional operator or shorthand if statement) - has the form “question ? AnswerA : AnswerB”

Question 15

Give an example of verbatim string

Answer 15

var string = @“\\server\files\heloworld.cs”;
It can also support multiple line strings

Question 16

Give an example of interpolated string

Answer 16

var sentence = $”Hi, my name is {name}!”;

Question 17

Can we combine verbatim and interpolated strings? How?

Answer 17

Yes we can. Interpolated string symbol must go before verbatim like so:
var string = $@“mixed string {x}”;

Question 18

What is an array?

Answer 18

Array represents a fixed number of variables (elements) of a particular type. The elements in array are always stored in a contiguous block of memory providing highly efficient access

Question 19

What’s an array initialisation expression?

Answer 19

Expression which lets you declare and populate an array in a single step:
char[] vowels = {‘a’, ‘e’, ‘i‘, ‘o ‘, ‘u’};

Question 20

What are the other types of array?

Answer 20

Multidimensional arrays: rectangular and jagged arrays.
Rectangular: represent n-dimentional block of memory.
Jagged arrays: arrays of arrays

Question 21

What is a variable?

Answer 21

A variable represents a storage location that has a modifiable value. A variable can be:
a local variable,
parameter (value, ref, out, or in),
field (instance or static) or
array element

Question 22

What are the stack and the heap? What are the differences between them?

Answer 22

Stack: block of memory for storing local variables and parameters. The stack logically grows and shrinks as a method or function is entered and exited. If the value type is not a local variable or parameter it lives wherever the variable was created.
Heap: memory in which objects (reference-type instances) reside. Whenever new object is created it is allocated on the heap and the reference to that object is returned. During a programs execution the heap begins filling up as new objects are created. The runtime has a garbage collector that periodically deallocated objects from the heap so the program does not run out of memory. An object is eligible for deallocation as soon as it’s not referenced by anything that’s itself “alive”

Question 23

What is a definite assignment?

Answer 23

Definite assignment is a concept in C# that ensures that all local variables are initialized with a value before they are used in the program.

When you declare a variable in C#, the compiler will ensure that you assign a value to it before you try to use it. If you attempt to use an uninitialized variable, you will get a compile-time error

• local variables must be assigned a value before they can be read;
• function arguments must be supplied when a method is called
• all other variables are automatically initialised by the runtime

Question 24

What are the default values for most common types? How to get them?

Answer 24

1. Reference type: null
2. Numerics and enum types: 0
3. Char type: ‘\0’
4. Bool type: false

To get them we can use “default” as:
Default(decimal) or decimal smth = default;

Question 25

Explain parameter modifier `ref`. how does it work under the hood?

Answer 25

“To pass by reference”. When creating and passing a variable with a `ref` modifier it refers to the same memory location. So when a parameter is passed to the method where it is changed, the original value in a variable also changes: ``` Int x = 8; Foo (ref x); Console. WriteLine(x); // x is now 9; Static void Foo (ref int p){ p++; } ```

Question 26

How does the “out” modifier work? Where is it used most frequently?

Answer 26

Parameters with out modifiers does NOT need to be assigned before entering the method and it MUST be assigned before coming out of it ``` string a, b; split(“Inga Reikale”, out a, out b); Console. Writeline(a); // Inga Console.Writeline(b); // Reikale static void Split(string fullName, out string firstName, out string lastName){ int i = fullName.LastIndexOf(“ “); firstName = fullName.Substring(0, i); lastName = fullName.Substring(i+1) } ```

Question 27

What is a “params” modifier?

Answer 27

Params modifier if applied to the last parameter of a method. It allows the method to accept any number of arguments of a particular type: ``` int Length(params int[] ints){ Console.WriteLine(ints.Length); } int totalLength = Length(1, 4, 5, 7); ```

Question 28

What are the optional parameters? How do you write one and what are the requirements?

Answer 28

A parameter is optional if it specifies a default value in its declaration: `void Foo(int x = 2){ Console.WriteLine(x);}` When calling Foo() we will get 2 printed in console even if we didn’t supply any parameters Requirements: - optional parameters cannot be marked with ref or out - mandatory parameters must occur before optional parameters in both declaration and the method call

Question 29

How operators are classified in C#?

Answer 29

Operators can be classed as unary, binary or ternary depending on the number of operands they work on (one, two or three). The binary operator ls always use infix notation in which the operator is placed between the two operands

Question 30

How does the **null-Coalescing** operator, **null-conditional** and **null-Coalescing Assignment** operator look like?

Answer 30

**null-Coalescing** : `var x = y ?? z;` // if y is not null take y, else take z; **null-Coalescing Assignment**: `x ??= y;` // if x is null assign y to x, else leave x as it is **null-conditional**: `var x = y?.ToString();` // if y is not null assign the returned item from he method, else assign null to x;

Question 31

How can you use switch statement to check a type?

Answer 31

With an 'object' type for the switch statement: ``` void TellTheType(object x) { switch (x) { `case int i:` // if not interested in value, we can use '_' instead of 'i' here; Console.WriteLine($"Its an int: {i}"); break; case string s: Console.WriteLine($"This is a string: {s}"); break; default: break; } } ```

Question 32

How can you write a switch statement as an expression?

Answer 32

``` var x = y switch { 1 => "one", 2 => "two" _ => "default value" }; ```

Question 33

Name all iteration statements

Answer 33

1. While 2. Do-While // event will happen at least once 3. For 4. Foreach

Question 34

Name all Jump statements

Answer 34

1. Break 2. Continue 3. Goto 4. Return 5. Throw

Question 35

What is a 'using' statement?

Answer 35

The 'using' element provides an elegant syntax for calling 'Dispose" on objects that implement IDisposable within try/finally block. ``` using (FileStream... ) { // write to file } ``` after all the necessary actions are finished the Dispose method is called on the method/block that implements the `IDisposable` interface

Question 36

What is a namespace?

Answer 36

The namespace keyword is used to declare a scope that contains a set of related objects. You can use a namespace to organize code elements and to create globally unique types. pvz System.Collections.Generic

Question 37

Let’s say that we have 2 identical namespaces in two different assemblies (.dll files) and you want to reference them but the program can’t compile because the name is ambiguous. How you should solve this?

Answer 37

By using the extern aliases. First need to modify application’s .csproj file, below the reference to our assemblies need to add: `Thing1` Then in desired file use this extern directive: ``` extern alias Thing1; Thing1.NamespaceObject.ClassObj x = new(); ```