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

Authentication Filters in Web APIs in dotnet core

Image
In ASP.NET Core Web APIs, authentication filters provide a powerful mechanism to secure your API endpoints. Here's a breakdown specifically for .NET Core: How it Works: Pipeline Integration: When a request hits your Web API, it goes through a series of processing stages called the pipeline. Authentication filters are registered within this pipeline. Filter Activation: Depending on the scope (global, controller, or action), specific filters are triggered for each request. Credential Validation: The filter inspects the request for credentials based on the configured authentication scheme. This could involve: Headers: Examining specific headers for API keys or tokens. Body: Checking for username and password combinations in the request body (common for basic authentication). Other Mechanisms: Depending on the scheme, credentials might be retrieved from cookies or URL parameters. IPrincipal Creation: If credentials are valid according to the filter's logic,...
Read more

Custom filters of asp.net core api

Image
Custom filters in ASP.NET Core Web APIs offer a powerful way to implement specific authentication logic beyond what built-in filters provide. Here's a breakdown of how to create and use them: Creating Custom Authentication Filters: 1. Inheritance: Your custom filter class typically inherits from AuthorizeAttribute or the IAuthorizationFilter interface.        AuthorizeAttribute: This is a simpler approach if your filter primarily relies on properties from the base class (like Roles or AuthenticationSchemes).       IAuthorizationFilter: This interface offers more control over the authorization process. You'll need to implement the OnAuthorization method to perform custom validation logic. 2. Custom Validation Logic: Within the OnAuthorization method (for IAuthorizationFilter ) or using properties like Roles and AuthenticationSchemes (for AuthorizeAttribute ), implement your authentication logic. This logic might involve:   ...
Read more

What is Middleware in asp.net core

Image
In ASP.NET Core, middleware refers to components that are added to the application pipeline to handle requests and responses. These components can perform various tasks such as authentication, logging, routing, and error handling. Middleware sits between the client and the server, intercepting and processing HTTP requests and responses as they flow through the pipeline. Each middleware component in the pipeline can inspect and optionally modify the request or response before passing it on to the next component in the pipeline. This modular approach allows developers to compose complex web applications by adding and arranging middleware components as needed. Here's a simple example of middleware in ASP.NET Core: ```csharp code using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Http; using System.Threading.Tasks; public class Startup {     public void Configure(IApplicationBuilder app)     {         app.Use(async (context, ne...
Read more