1. Structure in C #
In C #, you can use the struct keyword to define a structure, the level is consistent with the class, written under the namespace.
1) Properties, fields, methods and constructors can be defined in the structure. The sample code is as follows:
// Define the structure
struct Point
{
// Define the field
private int x;
// Package field
public int X
{
get {return x;}
set {x = value;}
}
// define method
public void Result ()
{
}
// Define the constructor
public Point (int n)
{
this.x = n;
//Console.WriteLine(n);
}
}
So, what are the differences between declaring classes and structures?
① In any case, the C # compiler will generate a parameterless constructor for the structure;
When we explicitly define a parameterless constructor, an error will be reported at compile time. The results are as follows:
The compiler tells us that the structure cannot contain an explicit parameterless constructor
But when writing code like this, the compiler does not report an error, the code is as follows:
// The parameterless constructor can be called here
Point p = new Point ();
Console.WriteLine (p.GetType ());
The results are as follows:
Although the structure cannot explicitly declare a parameterless constructor, the programmer can explicitly call the structure's parameterless constructor, indicating that the C # compiler will generate a parameterless constructor for the structure anyway.
② Fields in the structure cannot be assigned initial values;
③ In the constructor of the structure, each field of the structure must be assigned a value;
When we are not talking about explicit constructors, we can not assign values to member fields, but once the constructor is declared, we must assign values to all member fields
To assign values to all member fields, the code is as follows:
// Define the constructor
public Point (int n)
{
this.x = n;
//Console.WriteLine(n);
}
④ Assignment of attributes in the constructor is not considered to assign values to fields, and attributes do not necessarily operate on fields;
So when we assign initial values to the fields in the constructor, the correct code should be
// Define the constructor
public Point (int n)
{
// The correct value can be assigned to the field
this.x = n;
// Assign values to properties in the constructor, but not necessarily manipulate fields
this.X = n;
//Console.WriteLine(n);
}
2) The numerical type of the structure
The structure in C # is a value type, and its object and member fields are allocated on the stack, as shown below:
So when we wrote the following code, what happened in the memory?
// The parameterless constructor can be called here
Point p = new Point ();
// Assign the value of p
p.X = 100;
// Assign p to Point's new object p1
Point p1 = p;
What happened to Point p1 = p? details as following:
Declare the structure object without using the "new" keyword. If you do not use the "new" keyword to declare the structure object, because the constructor is not called, this time the structure object has no value. The constructor of the structure must assign values to all fields of the structure, so when creating a structure object through the "new" keyword, this object is initialized by the constructor and has a default initial value. The example code is as follows:
class Program
{
static void Main (string [] args)
{
// There is no way to call the default constructor initialization
Point p;
Console.WriteLine (p);
// It will call the default constructor to initialize the Point object
Point p1 = new Point ();
Console.WriteLine (p1);
Console.ReadKey ();
}
}
// Define the structure
struct Point
{
// The initial value is assigned when defined, the compiler will report an error
private int x;
}
Errors will be reported during compilation:
3) The structure cannot use automatic attributes
When I wrote the automatic attribute in the first article, I decompiled the source code and knew that the automatic attribute would generate a default field. In the constructor of the structure, you need to assign a value to each field, but the compiler does not know the name of the field. Therefore, there is no way to use automatic attributes.
So when do you define a class and when do you define a structure?
First of all, we all know that the access speed of the stack is relatively fast compared to the heap. But the stack space is relatively small compared to the heap.
①When we want to represent a lightweight object, we can define the structure and improve the access speed.
②Choose according to the influence of passing value, define the class when the reference to be passed, and define the structure when the copy is to be passed.
Second, about GC (.NET garbage collection)
1) The space variable allocated in the stack will be immediately recovered by the CLR once it goes out of scope; the following code:
// When defining the value type n, the space occupied by n in the stack will be immediately recovered by the CLR after the program exits the main function
static void Main (string [] args)
{
int n = 5;
Console.WriteLine (n);
}
2) The object allocated in the heap, when there is no reference to any variable, the object will be marked as garbage object, waiting for the garbage collector to recycle
The GC will regularly clean up garbage objects in the heap space. This time frequency is beyond the control of the programmer and is determined by the CLR. Therefore, when an object is marked as a garbage object, it is not necessarily recycled immediately.
3) Destructor
When recycling garbage objects, the destructor is automatically called by the GC. Mainly to perform some clean-up work.
The destructor does not have access modifiers, you cannot have your parameters, use "~" to modify. As the following code example:
class Program
{
// When defining the value type n, the space occupied by n in the stack will be immediately recovered by the CLR after the program exits the main function
static void Main (string [] args)
{
int n = 5;
OperateFile operate = new OperateFile ();
operate.FileWrite ();
// After executing the write operation, the destructor of this class will be called to release the control of the file object
//Console.WriteLine(n);
}
}
// Define the operation of the class on the file on the hard disk
class OperateFile
{
// Define the method of writing files
public void FileWrite ()
{}
// Define the action to be performed after calling this class
~ OperateFile ()
{
// Release the control of the operation file object
}
}
Third, the difference between static members and instance members:
Static members need to be modified by the static keyword, while instance members are not modified by the static keyword. The difference between them is as follows:
class Program
{
static void Main (string [] args)
{
// The static member belongs to the class, and can be accessed directly by "class name. Static member"
Person.Run ();
// The instance member belongs to the object and needs to be accessed by "object name. Instance member"
Person p = new Person ();
p.Sing ();
}
}
class Person
{
// Static member variable
private static int nAge;
// Instance member variables
private string strName;
public static void Run ()
{
Console.WriteLine ("I will run!");
}
public void Sing ()
{
Console.WriteLine ("I can sing");
}
}
When the class is loaded for the first time (that is, the class is first loaded into memory), all static members under the class will be loaded. As many objects as instance members have, as many objects will be created.
Static members are only loaded into the static storage area, only created once, and will not be released until the program exits.
Look at the code below:
class Program
{
static void Main (string [] args)
{
Person p = new Person ();
Person p1 = new Person ();
Person p2 = new Person ();
}
}
class Person
{
// Static member variable
private static int nAge;
// Instance member variables
private string strName;
public static void Run ()
{
Console.WriteLine ("I will run!");
}
public void Sing ()
{
Console.WriteLine ("I can sing");
}
}
So what happened in memory? As shown below:
It is obvious from the above that defining static members can affect the execution efficiency of the program. So when do you define static member variables?
①When the variable needs to be shared ②When the method needs to be called repeatedly
2) Instance members cannot be called directly in static methods.
When the class is first loaded, the static members have been loaded into the static storage area. At this time, the class object may not be created, so the class member field cannot be called in the static method. The example code is as follows:
Neither this nor base keywords can be used in static methods.
②The object of the class can be created to indicate that the members of the object operate in static methods. The code is as follows:
public static void Run ()
{
Person p = new Person ();
p.strName = "Hadron";
Console.WriteLine ("I will run!");
}
③ Static methods can definitely be called in instance members, because static members must exist at this time, the code is as follows:
public static void Run ()
{
Person p = new Person ();
p.strName = "Hadron";
Console.WriteLine ("I will run!");
}
public void Sing ()
{
// When the instance method is called, the object instance will be created, so you can access the instance field in the instance method
this.strName = "Zi Qiang";
strName = "子 强";
// Call static member
Run ();
Console.WriteLine ("I can sing");
}
Comparison of static members and instance members:
①The life cycle is different
Static members are only released when the program ends, and instance members are released when there is no object reference
② The storage location in the memory is different
Static members are stored in the static storage area, and instance members are in the managed heap.
Four, static class
① The static class is modified by the static keyword
// Define two static classes
static class Person
{}
internal static class Cat
{}
② Only static member variables can be lived in static class, otherwise an error will be reported (because when accessing the instance member, the class object may not have been created yet)
③ There can be no instance constructor in the static class (if there is an instance constructor, the static class can be instantiated, all are static members, and no instance members are called)
The correct method of declaration:
static class Person
{
// private int nAge;
private static string strName;
static Person ()
{
}
}
④ The static class cannot be inherited. Decompile the two classes just now. The result is as follows:
You will find that the essence of a static class is an abstract sealed class, so it cannot be inherited and instantiated. Therefore, the constructor of the static class must not have an access modifier
2) So when do you declare static classes?
If all members of this class need to be shared, you can declare this class as a static class.
And you cannot declare a static type variable in a general object (when accessing the static variable, the object may not have been created yet).
3) Constructor of static class
Static classes can have static constructors (and all classes can have static constructors), as follows:
class Program
{
static void Main (string [] args)
{
Cat c;
Cat c1 = new Cat ();
Console.ReadKey ();
}
}
class Cat
{
private int n;
public string strName;
// Instance constructor
public Cat ()
{
Console.WriteLine ("Look who performs 2 first");
}
// Static constructor
static Cat ()
{
Console.WriteLine ("Look who performs 1 first");
}
}
The results are as follows:
From this we can know that the static constructor will be executed before the instance constructor
And
// Do not execute static constructor
Cat c;
When we add the following code in the Main () function is:
static void Main (string [] args)
{
// Do not execute static constructor
Cat c;
Cat c1 = new Cat ();
Cat c2 = new Cat ();
Console.ReadKey ();
}
The results are as follows:
Explain that the static constructor is executed only once.
Okay, this time the sharing is over. I hope to help you understand the basic concepts of C #.