Structures/Generics

Question 1

Value-Types vs Reference-Types

Answer 1

Value Types (Structures, Enumerations)

• Mainly meant for storing simple values.
• Instances (examples) are called as “structure instances” or “enumeration instances”.
• Instances are stored in “Stack”. Every time when a method is called, a new stack will be created.

Question 2

Reference Types (string, Classes, Interfaces, Delegates)

Answer 2

• Mainly meant for storing complex / large amount of values.*Instances (examples) are called as “Objects” (Class Instances / Interface Instances / Delegate Instances).
• Instances (examples) are called as “Objects” (Class Instances / Interface Instances / Delegate Instances).

* Instances (objects) are stored in “heap”. Heap is only one for entire application.

Question 3

Structures

Answer 3

Structure is a “type”, similar to “class”, which can contain fields, methods, parameterized constructors, properties and events.

The instance of structure is called as “structure instance” or “structure variable”; but not called as ‘object’. We can’t create object for structure. Objects can be created only based on ‘class’.

Structure instances are stored in ‘stack’.

Structure doesn’t support ‘user-defined parameter-less constructor and also destructor.

Structure can’t inherit from other classes or structures.

Structure can implement one or more interfaces.

Structure doesn’t support virtual and abstract methods.

Structures are mainly meant for storing small amount of data (one or very few values).

Structures are faster than classes, as its instances are stored in ‘stack’.

Question 4

Class (vs) Structure- structures properties

Answer 4

Structures

Structures “value-types”.

Structure instances (includes fields) are stored in stack. Structures doesn’t require Heap.Structure instances (includes fields) are stored in stack. Structures doesn’t require Heap.

Suitable to store small data (only one or two values).

Memory allocation and de-allocation is faster, in case of one or two values.

Structures doesn’t support Parameter-less Constructor.

Structures doesn’t support inheritance (can’t be parent or child).

The “new” keyword just initializes all fields of the “structure instance”.

Structures doesn’t support abstract methods and virtual methods.

Structures doesn’t support destructors.

Structures are internally derived from “System.ValueType”. System.Object -> System.ValueType -> Structures

Structures doesn’t support to initialize “non-static fields“, in declaration.

Structures doesn’t support “protected” and “protected internal” access modifiers.

Structure instances doesn’t support to assign “null”.

Question 5

Class (vs) Structure- class

Answer 5

Classes
____________________________________________________

Classes are “reference-types”.

Class instances (objects) are stored in Heap; Class reference variables are stored in stack.

Suitable to store large data (any no. of values)

Memory allocation and de-allocation is a bit slower.

Classes support Parameter-less Constructor.

Classes support Inheritance.

The “new” keyword creates a new object.

Classes support abstract methods and virtual methods.

Classes support destructors.Classes are internally and directly derived from “System.Object”. System.Object -> Classes

Classes supports to initialize “non-static fields“, in declaration.

Classes support “protected” and “protected internal” access modifiers.

Class’s reference variables support to assign “null”.

Question 6

Constructors in Structures

Answer 6

C# provides a parameter-less constructor for every structure by default, which initializes all fields.

You can also create one or more user-defined parameterized constructors in structure.

Each parameterized constructor must initialize all fields; otherwise it will be compile-time error.

The “new” keyword used with structure, doesn’t create any object / allocate any memory in heap; It is a just a syntax to call constructor of structure.

Question 7

Read-only Structures

Answer 7

Use readonly structures in case of all of these below:

All fields are readonly.

All properties have only ‘get’ accessors (readonly properties).

There is a parameterized constructor that initializes all the fields.

You don’t want to allow to change any field or property of the structure.

Methods can read fields; but can’t modify.

‘Readonly structures’ is a new feature in C# 8.0.

This feature improves the performance of structures.

Question 8

Primitive Types as Structures

Answer 8

All primitive types are structures.

For example, “sbyte” is a primitive type, which is equivalent to “System.SByte” (can also be written as ‘SByte’) structure.

In C#, it is recommended to always use primitive types, instead of structure names.

Question 9

System.Object class

Answer 9

The “System.Object” is a pre-defined class, which is the “Ultimate super class (base class)” in .net.

All the classes and other types are inherited from System.Object directly / indirectly.

All C# classes, structures, interfaces, enumerations are children of System.Object class.

Every method defined in the Object class is available in all objects in the system as all classes in the .NET Framework are derived from Object class.

Derived classes can override Equals, GetHashCode and ToString methods of Object class.

System.Object class is meant for achieving “type safety” in C#.

Question 10

Methods of System.Object class

Answer 10

System.Object Class [Pre-defined]

namespace System
{
class Object
{
virtual bool Equals( object value );
virtual int GetHashCode( );
Type GetType( );
virtual string ToString( );
}
}

› bool Equals( object value )

Compares the current object with the given argument object; returns true, if both are same objects; returns false, if both are different objects.

› int GetHashCode( object value )

Returns the a number that represents the object. It is not guarantee that the hash code is unique, by default.

› Type GetType( )

Returns the name of the class (including namespace path), based on which, the object is created.

› string ToString( )

By default, it returns the name of the class (including namespace path), based on which, the object is created.

It is virtual method, which can be overridden in the child class.

Question 11

Boxing

Answer 11

It is a process of converting a value from “Value-Type Data Type” to “Reference-Type Data Type”, if they are compatible data types.

This can be done automatically [no need of any syntax].

Question 12

Unboxing

Answer 12

It is a process of converting a value from “Reference-Type Data Type” to “Value-Type Data Type”, if they are compatible data types.

This should be done explicitly (by using explicit casting).

Question 13

Generics

Answer 13

Generic class is a class, which contains one or more “type parameters”.

You must pass any data type (standard data type / structure / class), while creating object for the generic class.Object of Generic Class - Example

Question 14

Object of Generic Class - Example

Answer 14

ClassName<int> referenceVariable = new ClassName<int> ( );</int></int>

The same field may belong to different data types, w.r.t. different objects of the same class.

You will decide the data type of the field, while creating the object, rather than while creating field in the class.

It helps you in code reuse, performance and type-safety.

You can create your own generic-classes, generic-methods, generic-interfaces and generic-delegates.

You can create generic collection classes. The .NET framework class library contains many new generic collection classes in System.Collections.Generic namespace.

The generic type parameter (T) acts as “temporary data type”, which represents the actual data type, provided by the user, while creating object.

You can have multiple “generic type parameters” in the same class (for use for different fields.

Generics are introduced in C# 2.0.

Question 15

Generic Constraints

Answer 15

Generic Constraints are used to specify the types allowed to be accepted in the “generic type parameter”.

where T : class

where T : struct

where T : ClassName

where T : InterfaceName

where T : new( )

Question 16

Understanding Generic Constraints

Answer 16

Advantage: You can restrict what type of data types (class names) allowed to be passed while creating object.

In C#, constraints are used to restrict a generics to accept only particular type or its derived types.

By using ‘where’ keyword, we can apply constraints on generics.

You can apply multiple constraints on generic classes or methods based on your requirements.

Question 17

Generic Methods

Answer 17

Generic Method is a method that has one or more generic parameter(s).

You can restrict what type of data types to be allowed to be passed to the parameter while calling the method.

Question 18

Nullable Types

Answer 18

Value Types (structures, enumerations)

-Value Types are by default non-nullable types.
-Non-nullable types doesn’t support ‘null’ values to be assigned to its variables.

Reference Types (classes, interfaces)
-Reference Types are by default nullable types.
-Nullable types support ‘null’ values assigned to its variables.
-They don’t require the following syntax.

Question 19

What is null?

Answer 19

Represents ‘blank’ value.

Eg: In Employee class, the ‘int CreditCardNumber’ can be ‘null’.

Question 20

Null coalescing operator

Answer 20

The ‘null coalescing operator’ checks whether the value is null or not.

It returns the left-hand-side operand if the value is not null.

It returns the right-hand-side operand if the value is null.

Advantage: Simplifying the syntax of ‘if statement’ to check if the value is null.

Syntax:

variableName ?? valueIfNull

Question 21

Null Propagation Operator

Answer 21

The “Null Propagation Operator ( ?. ) and ( ? [] ) checks the value of left-hand operand whether it is null or not.

It returns the right-hand-side operand (property or method), if the value is not null.

It returns null, if the value is null.

It accesses the property or method, only if the reference variable is “not null”; just returns “null”, if the reference variable is “null”.

Null Propagation Operator ( ?. ) - Syntax

referenceVariable?.fieldName;

– is same as –

(referenceVariable == null)? null : referenceVariable.fieldName;

Advantage: We can invoke desired member (property or method) after checking if null.

Question 22

Extension Methods

Answer 22

Extension method is a method injected (added) into an existing class (or struct or interface), without modifying the source code of that class (or struct or interface).

Question 23

Extension Methods properties

Answer 23

The developer of ClassLibrary, creates a class with a set of methods. The consumer of ClassLibrary, can add additional methods to the same class, without modifying the source code of the ClassLibrary.

You can add additional methods to pre-defined classes / structures such as String, Int32, Console etc.

You must create a static class with a static method; that it will be added as a non-static method to the specified class.

This feature is introduced in C# 3.0.

The first parameter of extension must be having “this” keyword; followed by the class name / structure name, to which you want to add the extension method. Eg: this ClassName parameter

The parameter (with ‘this’ keyword) represents the current object, just like “this” keyword in the instance methods.

Extension method can have any no. of additional parameters, where the “this” keyword parameter is must.

Extension method does not support method overriding. That means, extension method’s signature can’t be same as any existing method.

You can also add extension methods to sealed class.

‘Extension Methods’ concept can’t be used to create fields, properties, or events.

The static class of extension method can’t be inner class.

The namespace in which the static class of extension method is created, must be imported in order to call the extension method as non-static method.

Question 24

Pattern Matching

Answer 24

It allows you to declare a variable, while checking the data type (class) of a reference variable, and automatically type-casts the reference variable into the specified data type (class).

Advantage: Simplified syntax to perform multiple checks of data types and type-casts.

Question 25

Implicitly-Typed Variables

Answer 25

The variables that are declared with ‘var’ keyword are called as ‘implicitly-typed variables’ (a.k.a type-inference).

VAR VARIABLES

Implicitly-typed variables are declared without specifying the ‘type’ explicitly; so that the C# compiler automatically identifies the appropriate data type at compilation-time, based on the value assigned at the time of declaration.

While declaration, the ‘type’ of implicitly-typed variables is fixed. It is not possible to change the type of that variable or assign “other type of values” into the implicitly typed variables, after declaration.

Implicitly Typed Variables can only be “local variables”; can’t be used for method parameters, return type or fields.

Implicitly Typed Variables must be initialized along with declaration.

It is not possible to declare multiple implicitly typed variables in the same statement. Eg: var x = 10, y = 20; //error

It is not possible to assign “null” into implicitly typed variables (while declaration). Eg: var x = null; //error

Question 26

Dynamically-Typed Variables

Answer 26

Dynamically Typed Variables are the variables that are declared with ‘dynamic’ keyword.

Declared without specifying the type explicitly.

There is no fixed type for the variable.

You can assign any type of value to these variables.

C# compiler skips “type-checking” at compilation time; instead, it resolves the data types of its values, at run time.

The “dynamic” type variables are converted as “object” type in most cases. Eg: dynamic dynamicVariable = 100; -> object dynamicaVariable = 100;

The Dynamically Typed Variable can change its data type, any no. of times, at run time.

Methods and other members of ‘dynamically typed variables’ will not be checked by the compiler at compilation time; will be checked by CLR at run time.

If the method or other member not available, it would not cause compile-time error; it raises run-time error, when the execution flow encountered that particular statement. Eg: dynamicVariable.NonExistingMethod( ); //run-time error (exception)

The Dynamically Typed Variables need not be initialized, while declaration.

The Dynamically Typed Variable doesn’t have “Intellisense” in Visual Studio.

The “dynamic” keyword is allowed for local variables, method parameters, fields, properties, return types etc.

Question 27

Inner Classes

Answer 27

“Inner Class” (a.k.a. Nested Class) is a class, which is created in another class (outer-class or containing-class).

Advantage: We can create all inter-related classes of a class, “inner classes”.

Syntax to access inner classes: OuterClassName.InnerClassName

By default, inner class is “private”; so it is accessible within the same outer class. To make it available to outside of the outer class, you can use other access modifiers such as “protected”, “private protected”, “internal”, “protected internal” or “public”.

A nested class can be declared as a private (default), public, protected, internal, protected internal, or private protected.

Outer class can’t access the members of inner class directly, without object.

Inner class can’t access the members of outer class directly, without object.

You are allowed to create objects of inner class in outer class; and vice versa; but you can’t do both; if you create objects vice-versa, it causes StackOverflowException.

You can create a child class for the inner class, outside the outer class.

Question 28

Garbage Collection

Answer 28

Garbage Collection is a process of deleting objects from memory, to free-up memory; so the same memory can be re-used.

Question 29

How Garbage Collection Works?

Answer 29

CLR automatically allocates memory for all objects created any where in the application, whenever it encounters “new ClassName( )” statement. This process is called as “Memory Management”, which is done by “Memory Manager” component of CLR.

All objects are stored in “Heap” (a.k.a. virtual memory).

Heap is only-one for the entire application life time.

The default heap size 64 MB (approx.), and extendable.

When CLR can’t find space for storing new objects, it performs a process called “Garbage Collection” automatically, which includes “identification of un-referenced objects and deleting them from heap; so that making room for new objects”. This process is done by “Garbage Collector (GC)” component of CLR.

Question 30

How GC decides if objects are alive?

Answer 30

› GC checks belongs information from the MSIL code:

› It collects references of an object.

› The objects that are referenced by at least one reference variable (or reference field) are “alive objects”; others are “dead objects” or “un-used objects”.

Question 31

When GC gets triggered?

Answer 31

There are NO specific timings for GC to get triggered.

GC automatically gets trigged in the following conditions:

• When the “heap” is full or free space is too low.
• When we call GC.Collect() explicitly.

Question 32

Generations in GC

Answer 32

Heap contains three segments (called generations):

Generation 2 [Long-Lived Generation]

Generation 1 [Survival Generation]

Generation 0 [Short-Lived Generation]

Question 33

Generation 0 GC

Answer 33

The “Generation 0” is the youngest generation and contains newly created short-lived objects and collected at first priority. The objects survive longer, are promoted to “Generation 1”.

Eg: The newly created objects.

Question 34

Generation 1 GC

Answer 34

The “Generation 1” is buffer between “Generation 0” and “Generation 2”.

The “Generation 1” mainly contains frequently-used and longer-lived objects.

Eg: The objects created in the previously-executed methods, but still accessible.

Question 35

Generation 2 GC

Answer 35

The “Generation 2” contains the longest-lived objects that were created long-back and still is being used, by different statements in the program.

Eg: The objects that referenced with static fields.

Question 36

Managed (vs) Unmanaged Resources

Answer 36

Managed Resources

The objects that are created by CLR are called as “Managed Resources”.

These will participate in “Garbage Collection” process, which is a part of .NET Framework.

Unmanaged Resources

The objects that are not created by CLR and not managed by CLR are called as “Un-managed resources”.

Eg: File streams, database connections

Question 37

Clearing Unmanaged Resources

Answer 37

Destructor

Clears unmanaged resources just before deleting the object; i.e. generally at the end of application execution.

Dispose

Clears unmanaged resources after the specific task (work) is completed; so no need to wait till end of application execution.

Question 38

Destructor

Answer 38

Destructor is a special method of the class, which is used to close un-managed resources (such as database connections and file connections), that are opened during the class execution.

Syntax:

~ClassName( )
{
//body here…
}

We close database connections and file connections; so no memory wastage or leakage.

Destructor doesn’t de-allocate any memory; it just will be called by CLR (.net runtime engine) automatically, just before a moment of deleting the object of the class.

Question 39

Rules of Destructor

Answer 39

Destructor’s name should be same as class name, started with ~ (tilde) character.

A Destructor is unique to its class i.e. there cannot be more than one destructor in a class.

Destructor can’t have parameters or return value.

Destructor is “public” by default, we can’t change its access modifier.

Destructor doesn’t support any other modifiers such as “virtual”, “abstract”, “override” etc.

Destructors can be defined only in classes; but not in structs, interfaces etc.

Destructors can’t be overloaded or inherited.

Destructors are usually called at the end of program execution.

Question 40

Destructor (vs) Finalize method

Answer 40

Internally, destructor is compiled as the “Finalize” method.

The “destructor” is a term belongs to C# language; the “Finalize” method belongs to .net framework generally; and both are same (interchangeable).

The compiled Finalize method calls the Finalize method of corresponding base class.

Question 41

IDisposable and Dispose

Answer 41

The “IDisposable” interface of “System” namespace, has a method called “Dispose”, which is used to close un-managed resources that are created during the life-time of the object.

The un-managed resources include file streams and database connections.

At the end of “using” statement, automatically “Dispose” method will be called.

Dispose is better than Destructor, because we need wait till ‘end of application execution’ to clear unmanaged resources; we clear them immediately after usage.

Question 42

Using Declaration

Answer 42

You can prefix “using” keyword before the local variable declaration, in order to call “Dispose” method when that variable goes out of scope.