C# basic knowledge compilation: C# classes and structures (1)

1. Structural and functional characteristics? Implement code?
The structure is defined with the struct keyword, which is similar to the class, but has essential differences. The structure is essentially a value type, it does not require allocation.
Characteristics of structure:
(1) When the structure is passed as a parameter, it is passed by value.
(2). The constructor of the structure must take parameters.
(3). Structure instantiation does not require new.
(4). Structures cannot be inherited, but interfaces can be implemented.
(5). Instance fields cannot be initialized in the structure.
Example:

using System;
using System.Collections.Generic;
using System.Text;

namespace TestStruct
{
    class Program
    {
        public struct Circle     //定义一个圆
        {
            private const double pi = 3.1415926;

            public double radius;  //半径

            /// <summary>
            /// 构造函数
            /// </summary>
            public Circle(double r)
            {
                radius = r;
            }
            /// <summary>
            /// 面积
            /// </summary>
            public double CArea()
            {
                return 3.14 * radius * radius;
            }

        }

        static void Main(string[] args)
        {
            Circle circle1;    //不用new实例化

            circle1.radius = 5;

            Console.WriteLine("圆面积为：" + circle1.CArea());

            Circle circle2 = new Circle(1);  //用new实例化

            Console.WriteLine("圆面积为：" + circle2.CArea());

            Console.ReadLine();
        }
    }
}

2. What is delegation? Features? When to use delegates instead of interfaces? How to declare, instantiate and use delegates?

(1) A delegate is a class that defines the type of a method. A method can be used as a parameter of another method. Avoid using branches in the program,

The program will be more scalable.
Example:

  class Program
    {
        public delegate void PrinteDelegate(string name);

        private static void PrinteEnglish(string name)
        {
            Console.WriteLine("Your Name: " + name);
        }

        private static void PrinteChinese(string name)
        {
            Console.WriteLine("你的大名： " + name);
        }

        private static void Printe(string name, PrinteDelegate MakeGreeting)
        {
            MakeGreeting(name);
        }

        static void Main(string[] args)
        {
            Printe("Sam Young", PrinteEnglish);

            Printe("白杨树", PrinteChinese);

            Console.ReadLine();
        }
    }

(2). A delegate is similar to a C++ function pointer, but it is type-safe.

Delegate allows methods to be passed as parameters.

Delegates can be used to define callback methods.

Delegates can be chained together; for example, multiple methods can be called on an event.

The method does not need to match the delegate signature exactly. For more information, see Covariance and Contravariance.

C# version 2.0 introduced the concept of anonymous methods, which allow blocks of code to be passed as arguments in place of individually defined methods.

Using delegates, I think it should be used when branches need to call different methods. But for example, in factory mode, different classes

are instantiated according to branches, and interfaces are used in this case.

A delegate is a class that defines the type of a method so that the method can be passed as a parameter of another method. This dynamically assigns the method

The method of giving parameters can avoid using a large number of If-Else (Switch) statements in the program, and at the same time make the program more scalable

.

3. What is a partial class/sub-class? What features? Implement code? Applications? How many rules need to be followed?
Partial class is to use the partial keyword to divide a class into several independent files, but it is still one class in essence. Generally, when a class has too many rows or some functions are relatively independent, partial classes can be used. The most common ones are Form.cs and Form.designer.cs.
Generally, the following rules need to be followed:
(1), the partial keyword must be used

(2), although there are different parts, each part must have the same accessibility, such as public , private, etc.

(3). If any part is declared abstract and sealed, the entire type is considered abstract and sealed

(4). If any part When declaring to inherit a base class, the entire type will inherit the class

(5). Each part can specify different base interfaces, and the final type will implement all interfaces listed in all partial declarations

(6). Any class, structure or interface member declared in a partial definition is available to all other parts.

(7) Nested types can be partial, even if they This is also true if the type in which it is nested is not itself partial.

The above is the summary of C# basic knowledge: C# classes and structures (1). For more related content, please pay attention to the PHP Chinese website (www.php.cn)!