Common Interview Questions

In C#, the default values for variables in a class and a struct are as follows:

• Class Variables: Class variables are initialized with default values based on their data type. For reference types (e.g., string, object), the default value is null. For numeric types (e.g., int, float), the default value is 0. For bool, the default value is false.

• Struct Variables: Struct variables are also initialized with default values based on their data type. For numeric types (e.g., int, float), the default value is 0. For bool, the default value is false. For reference types (e.g., string, object), the default value is an instance of the type with all its fields initialized to their default values.

You would choose to use a struct over a class in the following scenarios:

• Small Data Structures: Structs are more suitable for small data structures that primarily contain data and do not require complex behavior. They are lightweight and have a smaller memory footprint compared to classes.

• Value Semantics: If you want value semantics, where the object is copied when assigned or passed, rather than a reference, a struct is a better choice. This can be useful in scenarios where you want to avoid unintended side effects caused by modifying shared data.

• Performance Considerations: Structs are allocated on the stack and do not require garbage collection, making them more efficient in terms of memory usage and performance. If performance is a critical factor, using structs can be beneficial.

• Immutable Data: If the data in the structure is immutable (i.e., it cannot be modified after creation), using a struct can help enforce this immutability and prevent accidental modifications.

In C#, a struct can only inherit from an interface. It cannot inherit from another struct or class. Structs do not support inheritance in the same way that classes do. However, a struct can implement interfaces, allowing it to define and implement the members specified by the interface.

Yes, a struct in C# can implement interfaces. By implementing an interface, a struct can define and implement the members specified by the interface. This allows the struct to provide a certain behavior or functionality defined by the interface. However, it is important to note that structs cannot inherit from classes or other structs, so interface implementation is the only way to define additional behavior for a struct.

If we do not use the 'using' statement, we need to manually dispose of the object by calling its Dispose() method. Failing to do so can result in resource leaks and can cause the application to consume more memory than necessary. It is important to properly dispose of objects that implement IDisposable to free up system resources and improve the overall performance of the application.

Sure! One common example is when working with file streams. Instead of manually opening and closing the file stream, we can use the 'using' statement to automatically dispose of the stream after we are done with it. Here's an example:

using (FileStream fileStream = new FileStream("example.txt", FileMode.Open))
{
    // Code to read or write to the file
}

In this example, the file stream will be automatically disposed of when the code execution leaves the 'using' block, regardless of whether an exception occurs or not.

In C#, the 'using' statement is used to define namespaces that are used in the code file, while the 'import' statement is used in other programming languages like Python to bring in modules or libraries.

The 'using' statement in C# is used to create a reference to a namespace, allowing the code to access types and members within that namespace without having to fully qualify their names. It helps to simplify the code and make it more readable.

On the other hand, the 'import' statement in languages like Python is used to bring in modules or libraries that are not part of the built-in functionality. It allows the code to use functions, classes, and other objects defined in those modules or libraries without having to fully qualify their names.

No, you cannot change the value of a 'const' after it is declared. 'const' is a compile-time constant, and its value must be known at compile-time. Once a 'const' is declared, its value cannot be modified.

You would use 'readonly' instead of 'const' when you need a value that can be assigned at runtime, but cannot be modified after initialization. 'readonly' allows the value to be assigned at runtime, but only in the constructor or at the declaration. This is useful when you want to initialize a constant value based on some runtime logic or when the value needs to be different for each instance of a class.

Yes, 'readonly' can be used with reference types. When 'readonly' is used with a reference type, it means that the reference itself cannot be changed after initialization. However, the properties or fields of the referenced object can still be modified. It is important to note that 'readonly' only applies to the reference itself, not the referenced object.

Sure! Here's an example of when you would use 'ref' parameter:

void Swap(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

int x = 5;
int y = 10;
Swap(ref x, ref y);
Console.WriteLine(x); // Output: 10
Console.WriteLine(y); // Output: 5

And here's an example of when you would use 'out' parameter:

bool TryParse(string input, out int number)
{
    return int.TryParse(input, out number);
}

string userInput = "123";
if (TryParse(userInput, out int result))
{
    Console.WriteLine(result); // Output: 123
}

In the first example, 'ref' is used to swap the values of two variables. In the second example, 'out' is used to parse a string into an integer and return the result.

If you try to use an uninitialized variable as an 'out' parameter, you will get a compile-time error. 'out' parameters must be assigned a value inside the method before they are used. This is because 'out' parameters are used for output only, and the method is responsible for assigning a value to the parameter.

'out' and 'ref' can be used with both value types and reference types. When used with value types, the parameter is passed by reference, allowing the method to modify the value of the parameter. When used with reference types, the parameter is still passed by reference, but the method can modify the object that the parameter refers to, not the reference itself.

A destructor in C# is called automatically by the garbage collector when an object is no longer referenced or when the program terminates. It is not possible to explicitly call a destructor.

No, you cannot manually call a destructor in C#. The destructor is automatically called by the garbage collector when the object is no longer referenced or when the program terminates.

The main difference between a destructor and the 'Dispose' method is that a destructor is automatically called by the garbage collector, while the 'Dispose' method needs to be called explicitly by the developer to release resources. The 'Dispose' method is typically used for deterministic resource cleanup, while the destructor is used for non-deterministic resource cleanup.