Introduction to the difference between interfaces and classes in .NET

Interfaces and classes are often used in our daily development. What is the difference between the two? What are the advantages and disadvantages? The following article will introduce to you relevant information about the difference between interfaces and classes in .NET. Friends who need it can refer to it. Let's take a look together.

Preface

Everyone should know that .Net provides an interface, which is different from the type definition of Class or Struct. In some cases, interfaces seem to be the same as abstract classes, so some people think that abstract classes can be completely replaced by interfaces in .Net. In fact, this is not the case. Interfaces and abstract classes each have their own strengths and weaknesses, so they are often used in combination in applications to complement each other. Not much to say below, let’s take a look at the detailed introduction.

Next, let’s talk about the difference between abstract classes and interfaces:

The difference is that the concepts expressed by the two are different. Abstract class is a high degree of aggregation of a class of things, so for subclasses that inherit abstract classes, it is a "yes" relationship for abstract classes; interfaces define behavioral specifications, so for subclasses that implement interfaces , relative to the interface, it is "the behavior needs to be completed according to the interface." This may sound a bit false, but here’s an example. For example, dog is a general term for all canine animals, Pekingese is dog, and Shepherd is dog. Then the general characteristics of dogs will be found in Pekingese and Shepherd. So compared to Pekingese and Shepherd, dog is It belongs to the abstract type of this kind of thing; and for the action of "barking", dogs can bark and birds can also bark. Obviously, the former is equivalent to the abstract class, while the latter refers to the interface.

Difference 2: When an abstract class defines a type method, the implementation part of the method may or may not be given; but for an interface, the implementation part cannot be given for any method defined in it.

For example:

publicabstractclassAbsTest
{
publicvirtualvoidTest()
{
Debug.WriteLine("Test");
}
publicabstractvoidNewTest();
}
publicinterfaceITest
{
voidTest();
voidNewTest();
}

Difference three, inheritance classes have different implementations of the methods involved in the two. The inherited class does not need to rewrite the abstract methods defined by the abstract class, that is to say, the methods of the abstract class can be extended; for the methods or attributes defined by the interface class, the corresponding methods must be given in the inherited class. The methods and properties are implemented.

Difference 4: In an abstract class, if a new method is added, it does not need to be used for any processing in the inherited class; but for interfaces, the inherited class needs to be modified to provide a newly defined method.

Now that we know the difference between the two, let’s talk about the advantages of interfaces over abstract classes.

Benefits 1: Interfaces can not only act on reference types, but also on value types. As for abstract classes, they can only act on reference types.

Benefit 2: .Net type inheritance can only be single inheritance, which means that a type can only inherit one type, but can inherit multiple interfaces. In fact, I agree with this point. Multiple inheritance will make the inheritance tree confusing.

Benefit 3: Since the interface only defines properties and methods and has little to do with the actual implemented type, the interface can be reused by multiple types. In contrast, the relationship between abstract classes and inherited classes is closer.

Benefit 4: Through interfaces, the attributes and methods exposed by a type can be reduced, thereby making it easier to protect type objects. When a type that implements an interface may contain other methods or attributes, but when the method returns, it can return the interface object. In this way, the calling end can only access the relevant elements of the object through the methods or attributes provided by the interface, which can effectively protect the object. other elements.

Benefit 5: Reduce the unboxing operations of value types. For value type data defined by Struct, when it is stored in a collection, it needs to be unboxed every time it is taken out. In this case, the method of combining Struct+Interface is used to reduce the unboxing operation.

Compared to abstract classes, interfaces have so many benefits, but interfaces have a fatal weakness, that is, the methods and properties defined by the interface can only be relative to the type that inherits it (unless modified in the inherited class) function label defined by the interface), then when it comes to multi-layer inheritance relationships, it is difficult to implement it using interfaces alone. Because if each type inherits the interface and implements it, not to mention that writing code is more cumbersome, and sometimes the execution result is wrong, especially when the subtype object is implicitly converted into a base class object for access.

At this time, it needs to be implemented using interfaces combined with virtual methods. In fact, in inheritance, should we use interfaces or abstract classes? The interface is fixed and conventional, so the implementation of the corresponding methods and properties of the interface must be provided in the inherited class. For abstract classes, the implementation of the definition method of the abstract class runs through the entire inheritance tree, so the implementation or rewriting of the methods is uncertain. Therefore, relatively speaking, abstract classes are more flexible than interfaces.

A simple comparison table between the two is given below.

	Interface	Abstract class
Multiple inheritance	Supported	Not supported
Type restrictions	No	Yes, it can only be a reference type
method implementation	The method implementation must be given in the inherited type	It does not need to be given in the inherited class
Extensibility	More troublesome	Relatively flexible
Multi-layer inheritance	It’s more troublesome, you need to use virtual functions	It’s more flexible

In general, interfaces and abstract classes are language means provided by .Net to better realize the inheritance relationship between types, and the two are somewhat complementary to each other. Therefore, I do not emphasize what to use and what not to use. The key to the problem is how to apply these two methods reasonably to the program. This is crucial.

Summarize

The above is the detailed content of Introduction to the difference between interfaces and classes in .NET. For more information, please follow other related articles on the PHP Chinese website!