C# : Interview questions (16-20)

 

  Questions :

• Can you implement multiple interfaces in C#?
• What is a namespace in C#?
• Explain the concept of encapsulation.
• What is a constructor in C#?
• Differentiate between a class and an object.

C# : Interview questions (11-15)

Answers :

Implementing Multiple Interfaces in C#:

Yes, C# allows a class to implement multiple interfaces, enabling it to define behaviour specified by each interface. Multiple interfaces can be separated by commas in the class declaration.

interface IShape 
{
    void Draw();
}

interface IMovable 
{
    void Move();
}

class Circle : IShape, IMovable 
{
    public void Draw() 
    {
        Console.WriteLine("Drawing a circle...");
    }

    public void Move() 
    {
        Console.WriteLine("Moving the circle...");
    }
}

In this example, the Circle class implements both the IShape and IMovable interfaces, providing concrete implementations for the Draw and Move methods defined by each interface.

Namespace in C#:

A namespace in C# is a way to organize and group related classes, interfaces, enumerations, and other types into logical containers. It helps prevent naming conflicts and makes it easier to manage and maintain large codebases.

namespace MyNamespace 
{
    class MyClass 
    {
        // Class members
    }
}

In this example, MyClass is defined within the MyNamespace namespace. To use classes defined in a namespace, you can either fully qualify the name (MyNamespace.MyClass) or use a using directive to import the namespace (using MyNamespace;).

Encapsulation:

Encapsulation is a fundamental concept in object-oriented programming that involves bundling data (attributes or fields) and methods (functions or procedures) that operate on the data into a single unit known as a class. It hides the internal state of an object and restricts access to it through public methods, thereby promoting data abstraction and information hiding.

class Car 
{
    private string model;

    public string Model 
    {
        get { return model; }
        set { model = value; }
    }

    public void Start() 
    {
        // Start the car
    }

    public void Stop() 
    {
        // Stop the car
    }
}

In this example, model is encapsulated within the Car class, and access to it is controlled through public getter and setter methods (Model). This allows for controlled manipulation of the model attribute and ensures data integrity.

Constructor in C#:

A constructor in C# is a special method that is automatically called when an instance of a class is created. It is used to initialize the object's state, allocate resources, and perform any other setup tasks necessary for the object to function properly.

class Person 
{
    private string name;

    public Person(string name) 
    {
        this.name = name;
    }

    public void Display() 
    {
        Console.WriteLine("Name: " + name);
    }
}

In this example, Person class has a constructor that takes a name parameter and initializes the name field. When an instance of Person is created, the constructor is automatically invoked to initialize the object.

5. Class vs. Object:

• Class: A class in C# is a blueprint or template that defines the structure and behaviour of objects. It encapsulates data (attributes) and methods (functions) that operate on the data. Classes serve as a blueprint for creating multiple instances of objects with similar characteristics.

• Object: An object in C# is an instance of a class. It represents a real-world entity or concept and encapsulates its own state (data) and behaviour (methods). Objects are created using constructors and can interact with each other by invoking methods and accessing properties defined by their class.

In summary, classes define the structure and behaviour of objects, while objects represent instances of classes with specific states and behaviours.

C# : Interview questions (21-25)