{"id":463,"date":"2023-04-01T20:33:32","date_gmt":"2023-04-01T13:33:32","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=463"},"modified":"2023-04-01T21:13:11","modified_gmt":"2023-04-01T14:13:11","slug":"csharp-abstract-class-and-interface","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-abstract-class-and-interface\/","title":{"rendered":"C# Abstract Class and Interface"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn when to use an abstract class and when to use an interface and the differences between an abstract class and an interface. <\/p>\n\n\n\n

Choosing between an abstract class and an interface<\/h2>\n\n\n\n

In C#, an abstract class<\/a> is similar to an interface<\/a>. However, the abstract class and interface serve different purposes. Therefore, it’s important to know when to use an abstract class and when to use an interface.<\/p>\n\n\n\n

Generally, when you want to model the is-a relationship and share a common implementation with all the subclasses, you use an abstract class. <\/p>\n\n\n\n

But when you want to create a contract that other classes must adhere to, you use an interface. <\/p>\n\n\n\n

The following example demonstrates how to use the abstract class Shape that has the Display() method shared by all of its subclasses:<\/p>\n\n\n

abstract<\/span> class<\/span> Shape<\/span>\n{\n    public<\/span> abstract<\/span> double<\/span> GetArea<\/span>(<\/span>)<\/span>;\n    public<\/span> abstract<\/span> double<\/span> GetPerimeter<\/span>(<\/span>)<\/span>;\n\n    public<\/span> void<\/span> Display<\/span>(<\/span>)<\/span>\n    {\n        Console.WriteLine($\"Area: {GetArea():F2}<\/span>, Perimeter: {GetPerimeter():F2}<\/span>\"<\/span>);\n    }\n}\n\nclass<\/span> Rectangle<\/span> : Shape<\/span>\n{\n    readonly<\/span> double<\/span> length;\n    readonly<\/span> double<\/span> width;\n\n    public<\/span> Rectangle<\/span>(double<\/span> length, double<\/span> width<\/span>)<\/span>\n    {\n        this<\/span>.length = length;\n        this<\/span>.width = width;\n    }\n\n    public<\/span> override<\/span> double<\/span> GetArea<\/span>(<\/span>)<\/span>\n    {\n        return<\/span> length * width;\n    }\n\n    public<\/span> override<\/span> double<\/span> GetPerimeter<\/span>(<\/span>)<\/span>\n    {\n        return<\/span> 2<\/span> * (length + width);\n    }\n}\n\nclass<\/span> Circle<\/span> : Shape<\/span>\n{\n    readonly<\/span> double<\/span> radius;\n\n    public<\/span> Circle<\/span>(double<\/span> radius<\/span>)<\/span>\n    {\n        this<\/span>.radius = radius;\n    }\n\n    public<\/span> override<\/span> double<\/span> GetArea<\/span>(<\/span>)<\/span>\n    {\n        return<\/span> Math.PI * radius * radius;\n    }\n\n    public<\/span> override<\/span> double<\/span> GetPerimeter<\/span>(<\/span>)<\/span>\n    {\n        return<\/span> 2<\/span> * Math.PI * radius;\n    }\n}\n\nclass<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> shapes = new<\/span> List<Shape>()\n        {\n            new<\/span> Rectangle(5<\/span>, 10<\/span>),\n            new<\/span> Circle(3<\/span>)\n        };\n\n        foreach<\/span> (var<\/span> shape in<\/span> shapes)\n        {\n            shape.Display();\n        }\n\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Area<\/span>: 50.00<\/span>, Perimeter<\/span>: 30.00<\/span>\nArea<\/span>: 28.27<\/span>, Perimeter<\/span>: 18.85<\/span><\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the Shape<\/code>  class is an abstract class that defines two abstract methods GetArea<\/code> and GetPerimeter<\/code>. Any class that inherits from the Shape class needs to implement these methods. <\/p>\n\n\n\n
The Shape<\/code> class also has a concrete method Display<\/code> that displays the area and perimeter of a shape. All the subclasses of the Shape<\/code> class will share the same Display<\/code> method.<\/p>\n\n\n\n
The Rectangle and Circle classes extend the Shape class. Both of these classes share the same implementation of Display<\/code> method, but they each provide their own implementation of GetArea<\/code> and GetPerimeter<\/code> methods.<\/p>\n\n\n\n
The following example demonstrates how to use an interface as a contract:<\/p>\n\n\n
interface<\/span> ILogger<\/span>\n{\n    void<\/span> Log<\/span>(string<\/span> message<\/span>)<\/span>;\n}\n\nclass<\/span> ConsoleLogger<\/span> : ILogger<\/span>\n{\n    public<\/span> void<\/span> Log<\/span>(string<\/span> message<\/span>)<\/span>\n    {\n        Console.WriteLine(message);\n    }\n}\n\nclass<\/span> FileLogger<\/span> : ILogger<\/span>\n{\n    private<\/span> readonly<\/span> string<\/span> filePath;\n\n    public<\/span> FileLogger<\/span>(string<\/span> filePath<\/span>)<\/span>\n    {\n        this<\/span>.filePath = filePath;\n    }\n\n    public<\/span> void<\/span> Log<\/span>(string<\/span> message<\/span>)<\/span>\n    {\n        using<\/span> StreamWriter writer = new<\/span> StreamWriter(filePath, true<\/span>);\n        writer.WriteLine(message);\n    }\n}\n\nclass<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        ILogger logger;\n\n        if<\/span> (args.Length > 0<\/span> && args[0<\/span>] == \"file\"<\/span>)\n        {\n            logger = new<\/span> FileLogger(\"log.txt\"<\/span>);\n        }\n        else<\/span>\n        {\n            logger = new<\/span> ConsoleLogger();\n        }\n\n        logger.Log(\"Starting application...\"<\/span>);\n\n        \/\/ ... <\/span>\n\n        logger.Log(\"Application stopped.\"<\/span>);\n    }\n}\n<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we define the ILogger<\/code> interface that has a single method Log<\/code>. The Log<\/code> method takes a string that represents the message to be logged.<\/p>\n\n\n\n
The ConsoleLogger<\/code> and FileLogger<\/code> classes implement the ILogger<\/code> interface and provide their own implementations of the Log<\/code> method.<\/p>\n\n\n\n
In the Main<\/code> method, we create an instance of ConsoleLogger<\/code> or FileLogger<\/code> based on the command line argument.<\/p>\n\n\n\n
If the argument is \"file\"<\/code>, we create a FileLogger<\/code> object. Otherwise, we create a ConsoleLogger<\/code> object.<\/p>\n\n\n\n
Regardless of whether FileLogger<\/code> or ConsoleLogger<\/code> instance was created, we call the Log<\/code> method to log some messages<\/p>\n\n\n\n
Since both FileLogger<\/code> and ConsoleLogger<\/code> classes implement the same interface, we can easily switch between them at runtime.<\/p>\n\n\n\n
Abstract class vs. Interface<\/h2>\n\n\n\n
The following table illustrates the differences between abstract classes and interfaces:<\/p>\n\n\n\n
Abstract Classes<\/th>Interfaces<\/th><\/tr><\/thead>
Shared implementation<\/td>Define a contract<\/td><\/tr>
Can only inherit from a single base class<\/td>Can implement any number of interfaces<\/td><\/tr>
Unconstrainted implementation code<\/td>Limited implementation code<\/td><\/tr>
Can have automatic properties<\/td>No automatic properties<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • Use an abstract class to model an is-a relationship and share a common implementation with all subclasses.<\/li>\n\n\n\n
  • Use an interface to represent a contract to which other classes must adhere.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t