C - partial keyword

introduction

partial Keyword is used to split a class 、 A structure 、 The definition of an interface or a method into two or more files . Each source file contains a part of the type or method definition , When you compile an application, you put all the parts together . In the design Framework when , Can be fully utilized partial This feature .

Division class

Under what circumstances do you need to split class definitions ？

1. When dealing with large projects , Making a class distributed in multiple independent files allows multiple programmers to process the class at the same time .
2. When using automatically generated source files , You can add code without having to recreate the source file . Visual Studio Creating Windows forms 、Web This method is used when the service wrapper code, etc . You can create code that uses these classes , In this way, there is no need to modify Visual Studio Generated files .
3. When using the source generator to generate additional functions in a class .

Example

take Coords class The division is in 2 Defined in files .

CoordsOne.cs
Defined Coords Class constructor
Pay attention to the signature partial class Coords

namespace ConsoleApp1.PartialClass
{
    
    public partial class Coords
    {
    
        private int x;
        private int y;

        public Coords(int x, int y)
        {
    
            this.x = x;
            this.y = y;
        }
    }
}

CoordsTwo.cs
Defined Coords class
Pay attention to the signature partial class Coords

namespace ConsoleApp1.PartialClass
{
    
    public partial class Coords
    {
    
        public void PrintCoords()
        {
    
            Console.WriteLine("Coords: {0},{1}", x, y);
        }
    }
}

TestPartial.cs
Test the above partial classes

using ConsoleApp1.PartialClass;

namespace ConsoleApp1
{
    
    internal class TestPartial
    {
    
        static void Main(string[] args)
        {
    
            Coords coords = new Coords(10, 20);
            coords.PrintCoords();
        }
    }
}

result ：

Coords: 10,20

partial Segment restrictions

The following rules should be followed when dealing with partial class definitions ：

• All partial type definitions to be parts of the same type must use partial To embellish .
  for example , The following class declaration generates an error ：

public partial class A {
     }
//public class A { } // Error, must also be marked partial

• partial Modifiers can only appear next to keywords class、struct or interface Front position .

• Nested partial types are allowed in partial type definitions , As shown in the following example ：

partial class ClassWithNestedClass
{
    
    partial class NestedClass {
     }
}

partial class ClassWithNestedClass
{
    
    partial class NestedClass {
     }
}

• All partition type definitions the first mock exam must be in the same assembly and the same module. （.exe or .dll file ） Defined in . A partial definition cannot span more than one module . After testing, the files of these parts must be in the same namespace .
  Or the example above ,CoordsThree.cs It's also defined as partial class , however comparison CoordsOne.cs and CoordsTwo.cs Not in the same namespace , Will make mistakes .
  
  

• The class name and generic type parameters must match in all partial type definitions . Generic types can be partial . Each partial declaration must use the same parameter names in the same order .

• If a keyword appears in a partial type definition , The keyword cannot conflict with the keyword specified in other partial definitions of the same type ：public,private,protected,internal,abstract,sealed etc.
  take CoordsOne.cs in public Change to internal, Generate access attribute conflict .
  

Divisional interface and structure

Empathy , You can also develop partial structures and interfaces

partial interface ITest
{
    
    void Interface_Test();
}

partial interface ITest
{
    
    void Interface_Test2();
}

partial struct S1
{
    
    void Struct_Test() {
     }
}

partial struct S1
{
    
    void Struct_Test2() {
     }
}

Partial methods

A partial method defines a signature in part of a partial type , And the implementation is defined in another part of this type . Through the partial method , Class designer can provide method hooks similar to event handlers , So that developers can decide whether to implement . If the developer does not provide an implementation , Then the compiler deletes the signature at compile time . The following conditions apply to the partial method ：

• The declaration must contain the following keywords partial start .

• The signatures in the parts of a partial type must match .

• Constructors 、 finalizers 、 Overload operator 、 It is not allowed to use partial keyword .

for example ：

namespace PM
{
    
    partial class A
    {
    
        partial void OnSomethingHappened(string s);
    }

    // This part can be in a separate file.
    partial class A
    {
    
        // Comment out this method and the program
        // will still compile.
        partial void OnSomethingHappened(String s)
        {
    
            Console.WriteLine("Something happened: {0}", s);
        }
    }
}

In the following cases , You don't need to use a partial method to achieve ：

• There are no accessibility modifiers （ Include default special ）.
• return void.
• There are no output parameters .
• There are no modifiers below ：virtual、override、sealed、new or extern.

this and partial The difference between

C# - this Usage of There is an introduction to this It has the function of extending class methods , that this and partial The difference is ？

1. The difference in concept ,this It is to expand the original function ,partial It is to divide the whole into several parts for storage , Easy to maintain .
2. The difference in implementation
   patial The signature of the branch shall be consistent , Must be partial class/interface/struct Name, The file names are different .
   this The extension class name is different , But it must be a static class , Static method , The first parameter of the method must be this ClassName
3. The difference between calls
   partial All documents of the division must be in the same namespace Namespace
   this Extensions can be in different namespaces , But you need to import extended namespace Namespace before calling the extended method .