C# : Interview questions (21-25)

 

  Questions :

• What is a static class in C#?
• How do you achieve multiple inheritance in C#?
• Explain the difference between an abstract class and an interface.
• What is the purpose of the "using" statement in C#?
• How does exception handling work in C#?

c# : Interview questions (16-20)

Answers :

Static Class in C#:

A static class in C# is a class that cannot be instantiated and can only contain static members such as static fields, static methods, and static properties. Static classes are commonly used to organize utility methods or constants that do not require an instance of the class to be created.

public static class MathHelper 
{
    public static int Add(int a, int b) 
    {
        return a + b;
    }
}

In this example, MathHelper is a static class containing a static method Add, which can be accessed without creating an instance of the class (MathHelper.Add(2, 3)).

Achieving Multiple Inheritance in C#:

C# does not support multiple inheritance, where a class can inherit from multiple classes. However, you can achieve similar functionality using interfaces, which allow a class to inherit from multiple interfaces.

interface IShape 
{
    void Draw();
}

interface IMovable 
{
    void Move();
}

class Circle : IShape, IMovable 
{
    public void Draw() 
    {
        // Implementation for drawing a circle...
    }

    public void Move() 
    {
        // Implementation for moving the circle...
    }
}

In this example, the Circle class implements both the IShape and IMovable interfaces, effectively achieving multiple inheritance of behavior.

Difference between Abstract Class and Interface:

• Abstract Class:

  • An abstract class in C# is a class that cannot be instantiated and may contain abstract methods (methods without a body).
  • An abstract class can contain both abstract and non-abstract (concrete) methods and properties.
  • A class can inherit from only one abstract class.
  • Abstract classes can have access modifiers (public, protected, etc.) for their members.
  • Abstract classes can have fields and constructors.

• Interface:

  • An interface in C# is a reference type that defines a contract for classes to implement. It contains method signatures, properties, events, and indexers without any implementation.
  • A class can implement multiple interfaces.
  • Interfaces cannot contain fields, constructors, or concrete methods (except for default interface methods introduced in C# 8.0).
  • Interfaces are implicitly public and cannot have access modifiers for their members.

Purpose of the "using" Statement in C#:

The "using" statement in C# is used to import namespaces or to manage resources that implement the IDisposable interface. It has two primary purposes:

• Namespace Importing: The "using" statement simplifies code by allowing you to reference types in a namespace without fully qualifying their names. It helps avoid naming conflicts and makes code more readable.

using System;

class Program 
{
    static void Main() 
    {
        Console.WriteLine("Hello, World!");
    }
}

• Resource Management: The "using" statement can be used to ensure that resources like file handles, database connections, or network sockets are properly disposed of when they are no longer needed, by automatically calling the Dispose method of objects that implement IDisposable.

using (var stream = new FileStream("file.txt", FileMode.Open)) 
{
    // Read from the file...
}

Exception Handling in C#:

Exception handling in C# allows you to gracefully handle runtime errors and abnormal conditions that occur during the execution of a program. It involves the use of try, catch, finally, and throw keywords.

• try: The try block encloses the code that might throw an exception.
• catch: The catch block catches and handles exceptions that are thrown within the try block. It specifies the type of exception to catch.
• finally: The finally block contains code that is always executed, regardless of whether an exception occurs. It is typically used to release resources or perform cleanup operations.
• throw: The throw keyword is used to manually throw an exception.

try 
{
    // Code that might throw an exception
}
catch (Exception ex) 
{
    // Handle the exception
}
finally 
{
    // Cleanup code
}

In summary, exception handling in C# allows you to handle errors and ensure the robustness and reliability of your applications.

C# : Interview questions (26-30)