What is interface in c# explain with example


In C#, an interface is a contract that defines a set of methods, properties, events, or indexers that a class must implement. It provides a way to achieve multiple inheritances and helps in achieving abstraction. Here's a simple example:


// Define an interface named IShape
public interface IShape
{
    double CalculateArea(); // Method signature, to be implemented by classes
}

// Implement the interface in a class
public class Circle : IShape
{
    public double Radius { get; set; }

    public Circle(double radius)
    {
        Radius = radius;
    }

    // Implement the method from the interface
    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

// Another class implementing the same interface
public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }

    // Implement the method from the interface
    public double CalculateArea()
    {
        return Width * Height;
    }
}

class Program
{
    static void Main()
    {
        // Create instances of the classes
        Circle circle = new Circle(5);
        Rectangle rectangle = new Rectangle(4, 6);

        // Use the CalculateArea method through the interface
        Console.WriteLine($"Circle Area: {circle.CalculateArea()}");
        Console.WriteLine($"Rectangle Area: {rectangle.CalculateArea()}");
    }
}


In this example, `IShape` is the interface with a method `CalculateArea()`. Both the `Circle` and `Rectangle` classes implement this interface, providing their own implementation of the `CalculateArea` method. The `Main` method demonstrates how you can use objects of these classes through the common interface.

Comments

Post a Comment

Popular posts from this blog

Attribute-based routing in web api

Attribute-based routing is a feature in ASP.NET Web API (and ASP.NET Core MVC) that allows developers to define routes directly on controller actions or methods using attributes, rather than configuring routes in a centralized routing table. This approach enables developers to have more fine-grained control over routing, making the codebase more organized and easier to maintain. By decorating controller actions or methods with attributes like `[Route]`, `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, `[HttpDelete]`, etc., developers can specify the HTTP method and route template for each action, directly within the controller itself. This approach simplifies routing configuration and makes it more intuitive, especially for RESTful APIs where HTTP methods have specific meanings. For example, in ASP.NET Core MVC, you can define routes like this: ```csharp-code [Route("api/[controller]")] public class ProductsController : ControllerBase {     [HttpGet]     public IActionResult ...
Read more

Garbage collection in C# with example

Image
Garbage collection in C# is the automatic process of managing memory by identifying and reclaiming objects that are no longer needed, freeing up memory for reuse. It helps prevent memory leaks and makes memory management more efficient. Here's a simple example: ```csharp class MyClass {     public int Data;          public MyClass(int value)     {         Data = value;     } } class Program {     static void Main()     {         MyClass obj1 = new MyClass(42); // Create an object         MyClass obj2 = new MyClass(84); // Create another object         // Now, let's assume we no longer need obj1         obj1 = null; // Set obj1 to null to indicate it's no longer referenced         // At this point, the garbage collector may identify obj1 as unreachable         // a...
Read more

What is managed code and unmanaged code in c# with example

Image
Managed code and unmanaged code are terms used in the context of C# and the .NET framework to describe how the code is executed and managed by the runtime environment. Here's an explanation and an example of each: 1. Managed Code:    - Managed code refers to code that is executed within the .NET Common Language Runtime (CLR) environment. The CLR provides various services such as memory management, type safety, and garbage collection.    - C# code is typically considered managed code because it is compiled into an intermediate language (IL) that is executed by the CLR.    Example of managed code in C#:    ```csharp    using System;    class Program    {        static void Main()        {            Console.WriteLine("This is managed code executed by the CLR.");        }    }    ``` 2. Unmanaged Code...
Read more