Programmation avancée C# (3) - Explication détaillée des objets et des types

3.2 Classes et structures

La différence entre les classes et les structures est leur méthode de stockage en mémoire , Méthodes d'accès (similaires aux types de référence stockés sur le tas, tandis que les structures sont des types valeur stockés sur la pile) et leurs certaines caractéristiques .

Syntaxiquement, les classes sont très similaires aux structures. La principale différence est que les structures utilisent le mot-clé struct. est déclaré à la place de class .

3.3 Membres de la classe

3.3.1 Membres de données

Les membres de données contiennent des données de classe — Champs, Constantes et Événements Membres de .

　3.3.2 FonctionMembre

　 Les membres de fonction fournissent certaines fonctions pour exploiter les données dans la classe, notamment Méthodes, Propriétés, Constructeurs et Destructeurs Fonctions (terminateurs ) , opérateurs et indexeurs.

1. 
   

1. Méthode

La différence entre réf et sortie :

ref doit avoir été initialisé avant de passer, out n'est pas obligatoire.

L'essence de ref est de transmettre le type de valeur par référence, tandis que out est d'augmenter la valeur de retour.

Paramètre nommé : Vous pouvez spécifier son nom lors du processus de transmission du paramètre, le format est MethodName (ParameterName : Value)

Params Mot clé : doit être à la fin des paramètres de la méthode.

Surcharge des méthodes : Il ne peut pas y avoir de différence uniquement dans le type de retour, pas seulement basée sur la déclaration ref , Distinguer out ou params .

1. 
   

1. Attributs

Concept : Une propriété est une méthode ou une paire de méthodes Du point de vue du code client, c'est (elles) un champ.

L'accesseur get ne prend aucun paramètre et renvoie le type déclaré par la propriété.

L'accesseur set prend un paramètre value dont le type est le même que le type déclaré.

Modificateurs d'accès aux attributs : Dans les accesseurs get et set, il doit y avoir un niveau d'accès avec l'attribut.

1. 
   

1. Constructeur

La méthode de construction déclarative consiste à déclarer une méthode avec le même nom que la classe contenant, mais la méthode n'a pas de valeur de retour.

Si un constructeur avec des paramètres est fourni, le compilateur ne fournira pas automatiquement un constructeur par défaut.

　　　　 (1) Constructeur statique

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　log Initialisez ces champs et propriétés à partir d'une source externe avant d'utiliser la classe pour la première fois.

La bibliothèque d'exécution .NET ne garantit pas quand exécuter le constructeur statique, elle ne devrait donc pas être obligée d'exécuter le code dans le constructeur statique à un moment précis. Mais ce qui est garanti, c'est qu'il ne sera appelé qu'une seule fois avant toutes références.

Le constructeur sans paramètre peut être défini dans la même classe que le constructeur statique.

(2) Appeler d'autres constructeurs à partir du constructeur

🎜>ce Mots clés　3.3.3 Champs en lecture seule

　 La différence entre lecture seule

et const  : 　lecture seule

peut être assigné dans le constructeur, Et const ne peut pas être attribué n'importe où, il ne peut être qu'initialisé. 3.4 Types anonymes

　var

et Les nouveaux mots-clés peuvent être utilisés ensemble pour créer des types anonymes, par exemple. Le résultat est le suivant :

static void Main(string[] args)
 2 
 3 
 4         {
 5 
 6 
 7             var test = new { Name = "Earl Jones", Age = 17 };
 8 
 9 
10             Console.WriteLine(test.ToString());
11 
12 
13             Console.WriteLine(test.Name.GetType().ToString());
14 
15 
16             Console.WriteLine(test.Age.GetType().ToString());
17 
18 
19             Console.ReadKey();
20 
21 
22         }
复制代码

Le type de cet objet , le compilateur "faux" un nom pour celui-ci, mais seul le compilateur peut l'utiliser, nous ne pouvons et ne devons utiliser aucune réflexion de type sur le nouvel objet car ce ne sera pas un résultat cohérent.

3.5 Structure

La structure est un type valeur, pas un type référence, et ses

Les limitations du cycle de vie

sont les mêmes que celles du simple

type de données Lors du passage de la structure, vous pouvez utiliser le mot-clé ref pour réduire la perte de performances.

• La structure est généralement utilisée pour exprimer des données combinées simples.

• Les structures ne prennent pas en charge l'

  héritage, mais toutes les structures héritent de System.ValueType, qui à son tour hérite de System.Object.

• À l'aide de structures, vous pouvez spécifier la manière dont les champs sont disposés en mémoire.
  Pour les structures, le compilateur fournit toujours un constructeur par défaut sans argument, qui ne peut pas être remplacé, et les valeurs initiales ne peuvent pas être fournies pour les champs dans la structure. Il doit être fourni dans le constructeur.

• Les champs publics dans une structure sont des méthodes de programmation acceptables.

• 　　在定义结构时使用new关键字只不过是用于调用其构造函数，变量的声明实际上才是为结构分配空间，所以以下代码不被报错。

1 MyStruct myStruct /*= new MyStruct()*/;
2 myStruct.Name = "Earl Jones";
3 myStruct.Age = 17;

　　覆盖结构默认的构造函数会报错：

　　　　

3.6 弱引用

　　在代码中实例化一个类或结构时，只要有代码引用它，就会形成强引用。

　　强引用和弱引用的区别是，强引用只要有引用就不会被GC回收，而弱引用随时都可能被GC回收，所以使用它的时候必须确定其是否存活。如：

<span style="font-family: &#39;Microsoft YaHei&#39;;"><span style="color: #008080;">1</span> <span style="color: #000000;">    MyClass myClass;<br/></span><span style="color: #008080;">2</span>     WeakReference weakMyClass = <span style="color: #0000ff;">new</span> WeakReference(<span style="color: #0000ff;">new</span><span style="color: #000000;"> MyClass());<br/></span><span style="color: #008080;">3</span>     <span style="color: #0000ff;"><a href="http://www.php.cn/wiki/109.html" target="_blank">if</a></span><span style="color: #000000;"> (weakMyClass.IsAlive)<br/></span><span style="color: #008080;">4</span> <span style="color: #000000;">     {<br/></span><span style="color: #008080;">5</span>          myClass = weakMyClass.Target <span style="color: #0000ff;">as</span><span style="color: #000000;"> MyClass;<br/></span><span style="color: #008080;">6</span> <span style="color: #000000;">         Console.WriteLine(myClass.value); <br/></span><span style="color: #008080;">7</span> <span style="color: #000000;">      } </span></span>

3.7 部分类

　　Partial关键字可以允许把类、结构、方法或结构放在多个文件中。

　　如果声明类似使用了下面的关键字，这些关键字就必须应用于同一个类的所有部分：

• 　　访问修饰符

• 　　abstract

• 　　sealed

• 　　new

• 　　一般约束

3.9 Object类

　　所有类都继承自System.Object类。

　　方法：

• ToString();

• GetHashCode();

• Equals();这里有三个比较三个用于比较对象相等性的方法。

• Finalize();

• GetType();

• GMemberwiseClone();

3.10 扩展方法

　　扩展方法用于在某些不能直接修改源代码中的类中添加方法。

 1         using System; 
 2          
 3         namespace 扩展方法 
 4         { 
 5             class Program 
 6             { 
 7                 static void Main(string[] args) 
 8                 { 
 9                     MyClass myClass1 = new MyClass();
 10                     myClass1.SayHiToSomeone();
 11                     myClass1.SayHi();
 12                     Console.ReadKey();
 13                 }
 14             }
 15         
 16             class MyClass
 17             {
 18                  public void SayHi()
 19                 { 
20             Console.WriteLine("我是最原始的方法"); 
21             }
22             }
23         
24             static class AddMyClass
25             {
26                 static public void SayHiToSomeone(this MyClass myClass)27                 { 
28             Console.WriteLine("我是一个扩展方法"); 
29             }
30         
31                 static public void SayHi(this MyClass myClass)
32                 {
33              Console.WriteLine("我是扩展方法SayHi");
34              }
35             }
36         }

　　输出的结果：

　　

　　由上得出:

• 　　　　扩展方法必须定义在一个静态类中。

• 　　　　扩展方法的第一个参数为放在 this 后的类，这个方法就是这个类的一部分。

• 　　　　即是扩展方法是一个静态方法，也要使用调用实例方法的语法经行调用。

• 　　　　如果扩展方法与类中某个方法同名，就从来不会调用扩展方法。

 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!