Shulou(Shulou.com)06/02 Report--

What are the implementation methods of the Net Framework interface? I believe many inexperienced people are at a loss about this. Therefore, this paper summarizes the causes and solutions of the problem. Through this article, I hope you can solve this problem.

.net Framework allows us to provide a platform for deploying WEB applications. Its emergence is to help developers provide a good programming environment to help developers improve their program development efficiency. What we will learn in the future is the operation of the .net Framework interface.

Interface inheritance: the type inherits the method signature in the interface, not the method implementation.

When a type inherits an interface, it simply promises to provide the method implementation in it: if it is not provided, the type is considered abstract and therefore cannot be instantiated.

The .net Framework interface is simply an abstract type that contains a set of virtual methods, each with its name, parameters, and return value type. However, the interface method does not include any implementation.

Interfaces can also define events, no-parameter properties, and parameter-containing properties, because they are all merely syntactic abbreviations mapped to methods.

If the virtual keyword is omitted when implementing an interface method within a type, the method will be considered a sealed virtual method, and other types that inherit the implementation type will no longer be able to override the method.

When a type "inherits" an interface, it implements not only all the methods defined by that interface, but also all methods that the interface "inherits" from other interfaces.

The type that implements multiple interfaces allows us to think of its object as any of these interfaces.

Example of .net Framework API:

1. Use the interface to change fields in boxed value types

Struct Point

{

Public int x,y

Public void Change (int x pencil int y)

{

This.x=x; this.y=y

}

Public override String ToString ()

{

Return String.Format ("({0}, {1})", xQuery)

}

}

Class Program

{

Static void Main (string [] args)

{

Point p=new Point ()

Pp.x=p.y=1

P.Change (2Jing 2)

Console.Write (p); / / implement System.

Iformattable interface, calling the ToString method

Object: / / o points to the boxed Point object and displays (2)

Console.Write (o)

((Point) o) .change (3Jing 3)

Console.Write (o); / / unpack the boxed Point

To a temporary Point on the thread stack

The field value on this temporary Point is changed to 3, but the boxed Point

The object is not affected by this change, showing (2)

}

}

There is a problem. C# does not allow us to change the fields in the boxed value type. Let's make a revision using the .net Framework API:

Interface IChangeBoxedPoint

{

Void Change (Int32 x, Int32 y)

}

Struct Point: IChangeBoxedPoint

{

Public Int32 x, y

Public void Change (Int32 x, Int32 y)

{

This.x = x; this.y = y

}

/ * * /. * /

}

Class App

{

Static void Main ()

{

Point p=new Point ()

Object o=new object ()

/ * * /. * /

((IChangeBoxedPoint) p) .change (4,4)

/ / p boxing, changing the boxed object, but when Change returns

Boxed objects are immediately garbage collected

Console.WriteLine (p); / / (2pm 2)

((IChangeBoxedPoint) o) .change (5,5)

/ / there is no need to box here, so change the value of the boxed object Point

Console.WriteLine (o); / / (5pm 5)

There is no interface method in C # to do this.

}

}

two。 Display the implementation of .net Framework interface members

Public interface IComparable {Int32 CompareTo (object other);} struct SomeValueType:IComparable {private Int32 x; public SomeValueType (Int32 x) {this.x = x;} public Int32 CompareTo (SomeValueType other) {return (x-other.x);} Int32 IComparable.CompareTo (object other) {return CompareTo ((SomeValueType) other);}} public static void Main () {SomeValueType v1 = new SomeValueType (1); SomeValueType v2 = new SomeValueType (2); Int32 n N = v1.CompareTo (v2); / / No packing n = ((IComparable) v1) .Compareto (v2); / / v2 forced packing}

Pay attention to three points:

The name of the a.CompareTo method is preceded by the interface qualified name IComparable.CompareTo, which tells CLR that the method is called only if an IComparable object reference is used.

The implementation of b.IComparable.CompareTo is accomplished by calling the CompareTo method after transforming other into SomeValueType.

There is no public or protected access modifier before the c.IComparable.CompareTo method

Shows the benefits of the .net Framework interface method: type safety and reduced boxing operations.

After reading the above, have you mastered the implementation of the Net Framework interface? If you want to learn more skills or want to know more about it, you are welcome to follow the industry information channel, thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.