This article describes the implementation method of C# interface. Share it for your reference. The details are as follows:
Before explaining the analysis of C# implementation interface instances, let’s take a look at the definition of C# interface. If a class derives from an interface, it will execute certain functions. Not all object-oriented languages support interfaces, so this section will introduce in detail the problem of C# implementing interfaces.
Notes on C# implementation interface:
Developers familiar with COM should note that although C# interfaces are conceptually similar to COM interfaces, they are different and have different underlying structures. For example, C# interfaces are not derived from IUnknown. The C# interface provides a contract based on .NET functions. Unlike COM interfaces, C# interfaces do not represent any type of binary standard.
The following lists the complete definition of a predefined interface for Microsoft. IDisposable contains a method Dispose(), which is executed by the class to clean up the code:
public interface IDisposable
{
void Dispose();
}
The above code shows that declaring an interface is syntactically identical to declaring an abstract class, but does not allow the execution of any member of the interface. Generally speaking, an interface can only contain declarations of methods, properties, indexers and events.
The C# implementation interface cannot be instantiated, it can only contain the signatures of its members. Interfaces cannot have constructors (how to build objects that cannot be instantiated) or fields (as this implies some internal execution methods). Interface definitions also allow for inclusion operator overloading, but this is not because there is anything wrong with declaring them in principle, but because interfaces are usually public contracts, including operator overloading can cause some incompatible issues with other .NET languages, such as incompatibility with the .NET language, because operator overloading is not supported.
Modifiers on members are not allowed in the interface definition. Interface members are always public and cannot be declared virtual or static. If needed, it should be declared by the executed class, so it is best to declare access modifiers through the executed class, just like the code above.
For example, IDisposable. If the class wants to declare as a public type so that the method Dispose() is executed, the class must execute IDisposable. In C#, this means that the class is derived from IDisposable.
class SomeClass : IDisposable
{
// this class MUST contain an implementation of the
// () method, otherwise
// you get a compilation error
public void Dispose()
{
// implementation of Dispose() method
}
// rest of class
}
In this example, if SomeClass is derived from IDisposable but does not contain the same Dispose() implementation code as the one signed in IDisposable, you will get a compilation error because the class breaks the contract that implements IDisposable. Of course, the compiler allows classes to have a Dispose() method that is not derived from IDisposable. The problem is that other codes cannot recognize that SomeClass supports IDisposable features.
Notes on C# implementation interface:
IDisposable is a fairly simple interface that defines only one method. Most interfaces contain many members.
Another example of an interface is the foreach loop in C#. In fact, the internal way foreach loops works is to query the object and see if it implements the interface. If so, the C# compiler inserts the IL code and iterates over the members of the collection using the methods on this interface. Otherwise, foreach will raise an exception.
I hope this article will be helpful to everyone's C# programming.