C# ਵਿੱਚ interfaces ਕੀ ਹਨ?

Question

Accepted Answer

ਇੱਕ **interface** ਇੱਕ **contract** ਨੂੰ define ਕਰਦਾ ਹੈ — members (methods, properties) ਦਾ ਇੱਕ set ਜਿਸਨੂੰ implementing classes ਮੁਹੱਈਆ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਕਿਸੇ implementation ਤੋਂ ਬਿਨਾ (ਰਵਾਇਤੀ ਤੌਰ ਤੇ)। ਇੱਕ class **multiple** interfaces ਨੂੰ implement ਕਰ ਸਕਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਉਹ C# ਵਿੱਚ flexible, decoupled, testable design ਲਈ ਮੁੱਖ ਬਣ ਜਾਂਦੇ ਹਨ। ## Interface ਨੂੰ define ਕਰਨਾ ਅਤੇ implement ਕਰਨਾ ```csharp public interface IShape { double Area(); // a method signature (no body) string Name { get; } // a property } public class Circle : IShape // implement the interface { public double Radius { get; set; } public double Area() => Math.PI * Radius * Radius; // must implement public string Name => "Circle"; } ``` ਇੱਕ interface (ਪਰਿਪਾਟੀ ਅਨੁਸਾਰ `IXxx` ਨਾਮ ਦਿੱਤਾ ਗਿਆ) implementation ਤੋਂ ਬਿਨਾ members ਨੂੰ declare ਕਰਦਾ ਹੈ; ਇੱਕ class ਜੋ ਇਸਨੂੰ implement ਕਰਦੀ ਹੈ **ਜ਼ਰੂਰ** ਉਨ੍ਹਾਂ ਨੂੰ ਮੁਹੱਈਆ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। (C# 8 ਤੋਂ, interfaces ਕੋਲ *default* implementations ਹੋ ਸਕਦੀ ਹਨ, ਪਰ contract ਰਾਲ ਪ੍ਰਮੁੱਖ ਹੈ।) ## Multiple interfaces (ਬਨਾਮ single inheritance) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` ਇੱਕ class **ਬਹੁਤ ਸਾਰੇ** interfaces ਨੂੰ implement ਕਰ ਸਕਦੀ ਹੈ (ਬਿਲਕੁਲ single class inheritance ਦੇ ਉਲਟ) — ਇਹ C# ਦਾ unrelated types ਵਿੱਚ capabilities ਨੂੰ ਸਾਂਝਾ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹੈ। ## Interfaces ਰਾਹੀਂ Polymorphism (ਮੁੱਖ ਲਾਭ) ```csharp // program to the INTERFACE — works with ANY implementation List shapes = new() { new Circle(), new Square() }; foreach (IShape s in shapes) Console.WriteLine(s.Area()); // calls each type's implementation void Process(IRepository repo) { } // depend on an interface, not a concrete class ``` ## Common .NET interfaces ਅਤੇ testability ```csharp IEnumerable, IDisposable, IComparable, IEquatable // framework interfaces // interfaces enable mocking in tests (depend on an interface, inject a mock) public class Service(IEmailSender sender) { } // inject any IEmailSender (real or mock) ``` ## ਇਸ ਦਾ ਮਹੱਤਵ Interfaces C# ਦੇ ਚੰਗੇ design ਲਈ ਕੇਂਦਰੀ ਹਨ ਅਤੇ .NET framework ਅਤੇ ਆਧੁਨਿਕ C# applications ਦੀ ਬਣਤਰ ਦਾ ਮੂਲ ਹੈ, ਇਸ ਲਈ ਉਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ। Interfaces **contracts** ਨੂੰ define ਕਰਦੇ ਹਨ (ਇੱਕ type ਕੀ ਕਰ ਸਕਦਾ ਹੈ) implementation ਤੋਂ ਬਿਨਾ, ਅਤੇ ਇੱਕ class **multiple** interfaces ਨੂੰ implement ਕਰ ਸਕਦੀ ਹੈ — ਜਿਸ ਨਾਲ ਉਹ C# ਦਾ flexible, decoupled design ਲਈ ਪ੍ਰਮੁੱਖ ਟੂਲ ਬਣ ਜਾਂਦੇ ਹਨ ਅਤੇ single-inheritance ਦੀਆਂ ਸੀਮਾਵਾਂ ਦਾ ਇਸ ਦਾ ਜਵਾਬ (unrelated types ਵਿੱਚ capabilities ਨੂੰ ਸਾਂਝਾ ਕਰਨਾ)। ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਲਾਭ ਹੈ **loose coupling ਅਤੇ testability** ਨੂੰ ਸਮਰੱਥ ਬਣਾਨਾ: concrete classes ਦੀ ਬਜਾਏ interfaces 'ਤੇ depend ਕਰਨ ਦੁਆਰਾ (