Compilation des connaissances de base en C# : bases de C# (1)

Structure de base C#

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

namespace ConsoleApplication1
{
    class MyFirstClass
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world!");

            Console.ReadLine();
        }
    }
}

(1), définition de variable
7674b22ef33c73b930516fd6bc30b7a3 8a11bc632ea32a57b3e3693c7987c420;
Exemple, MyFirstClass myFirstClass;
(2), comment initialiser les variables
int a = 0;
string str=string.Empty;
int init = a*2;
(3). Portée des variables
Tout d'abord, vous devez clarifier les portées respectives de privé, protégé, interne et public.
Private-complètement privé, il ne peut être appelé que dans cette classe et ne peut pas être appelé dans des sous-classes ou d'autres classes. Lors de l'héritage, les sous-classes ne peuvent pas hériter de propriétés ou de méthodes privées.
Protected – Identique à private, mais la différence est que dans protected, les sous-classes peuvent accéder et hériter des membres et des méthodes.
interne-public, accessible dans la même assemblée, mais pas dans d'autres assemblées.
Public - Il est entièrement public et accessible tant qu'il se trouve dans un projet. Cependant, s'il s'agit d'un assembly différent, il doit faire référence à l'assembly dans lequel il se trouve.
Alors la portée des variables déclarées par ces types est la même que leur portée
La portée des variables générales est la suivante :
a La classe à laquelle appartient la variable est dans une certaine portée, et les attributs ou les méthodes ont également une certaine portée.
b. La portée d'une variable locale, avant l'accolade fermante de l'instruction de bloc ou de la méthode dans laquelle la variable est déclarée.
(4), constante
Lors de la déclaration d'une variable, ajoutez le mot-clé const devant la variable pour spécifier la variable comme constante.
Remarque :
　une constante doit être initialisée lorsqu'elle est déclarée, et elle ne peut pas être modifiée une fois sa valeur attribuée.
b Les constantes sont toujours statiques et il n'est pas nécessaire d'ajouter le mot-clé static lors de la déclaration des constantes.
(5) Traitement des chaînes
Le traitement des chaînes doit être utilisé plus souvent. Ceux couramment utilisés sont les suivants :
                                                                                                                                                                                                                                                        .

string testString = @"Hello,world!";
            testString.Substring(0, 1);
            testString.Trim();
            testString.TrimEnd('\n');
            testString.TrimStart('0');

(6) Utiliser des expressions régulières

Les expressions régulières sont largement utilisées dans les projets Vous pouvez vous référer à l'article suivant : Description des caractères réguliers : http://www.php.cn. /;
Règles régulières couramment utilisées : http://www.php.cn/.
(7) Qu'est-ce que le type CTS ?

Un assemblage donné peut contenir n'importe quel nombre de "types" différents. Dans le champ .NET, type est un terme général qui fait référence à tout membre de la collection {classe, interface, structure, énumération, délégué}. Lorsque vous créez des solutions dans des langages compatibles .NET, vous devrez probablement gérer ces types. Par exemple, un assembly peut définir une classe qui implémente certaines interfaces. Peut-être que l'une des méthodes d'interface prend un type d'énumération comme paramètre d'entrée et renvoie une structure lorsqu'elle est appelée.
CTS (Common Type System) est une spécification formelle qui spécifie comment les types doivent être définis pour être portés par le CLR. En règle générale, seuls ceux qui créent des outils ou des compilateurs ciblant la plate-forme .NET se soucient beaucoup du fonctionnement interne de CTS. Cependant, il est très important pour tous les programmeurs .NET d'apprendre à utiliser les cinq types définis par CTS dans le langage qu'ils utilisent. Voici un bref résumé.
Chaque langage prenant en charge .NET doit au moins prendre en charge le concept de type de classe, qui est la base de la programmation orientée objet (POO). Une classe peut être composée de nombreux membres (tels que des propriétés, des méthodes et des événements) et de données (champs). En C#, utilisez le mot-clé class pour déclarer une classe :

Table CTS class type

// C#类类型。
class Calc
{
    public int Add(int x, int y)
    { 
        return x + y; 
    }
}

Caractéristiques de classe

Signification dans le cycle de vie

Si la classe est "scellée"

类的特征	在生命周期里的意义
类是否被“密封”	密封类不能作为其他类的基类
类实现任何接口了吗	接口是抽象成员的集合，它在对象和对象的用 户间提供一个契约。CTS允许类或结构实现任 何数目的接口
类是具体的还是抽象的	抽象类是不能直接创建的，但是可以用来为派 生类型定义公共的行为。具体类可以直接创建
这个类的可见性是什么	每个类必须设置可见性。基本上，可见性定义了 该类是被外部程序集使用，还是仅能在定义了它 的程序集中使用

Une classe scellée ne peut pas être utilisée comme classe de base pour d'autres classes

La classe implémente-t-elle une interface

Une interface est une collection de membres abstraits qui fournit un contrat entre un objet et ses utilisateurs. CTS permet à une classe ou à une structure d'implémenter n'importe quel n'importe quel nombre d'interfaces

que la classe soit concrète ou abstraite

Les classes abstraites ne peuvent pas être créées directement, mais elles peuvent être utilisées pour définir des comportements publics pour les types dérivés. Des classes concrètes peuvent être créées directement

Quelle est la visibilité de cette classe ?

La visibilité doit être définie pour chaque classe. Fondamentalement, la visibilité définit si la classe est utilisée par un assembly externe ou ne peut être utilisée que dans l'assembly dans lequel elle est définie

（8) 数据类型如何分类以及各个数据类型范围？
http://www.php.cn/
（9）操作符
括号操作符
格式()
点操作符
格式 (E.I)
其中E是基本表达式或者预定义类型，I是一个标识符。C++里除了"."之外还有"::" "->"，C#里用点操作符来代替。比如一个类T有成员变量M，在C++里用T::M来引用，C#里用T。M来引用。另一点不同的是，C#里预定义类型也是从Object类派生出来的，因此也定义了成员变量，比如，I是一个short类型的变量，那么I。ToInt()操作将返回一个Int类型的值。
后缀加减操作符
格式:p++;p--; ++p; --p;
结果是给变量p加1或减1
new操作符
格式:a， new 类型(参数列表)
b，new 数组类型初始化列表
c，new 代表类型(表达式)
typeof操作符
该操作返回一个类型对应的system。type，如:

typeof(int); typeof(System。Int32); typeof(string);

各自的结果为int32，int32，string。typeof只对类型操作，不能对变
量操作，例如，"int I;typeof(I);"是不合法的

sizeof操作符
该操作可获得一个类型所占用的空间大小，以字节为单
位。该操作符用在unsafe模块中，如

Unsafe{
S=sizeof(int);
}

或者在调用该操作符的函数中使用该前缀。
单目操作符
(1)+-操作
(2)逻辑非:!(表达式)
(3)位非:～(表达式)
(4)强制类型转换: (T) 表达式
关系运算符
==，!=，，=， is
is用来判断一个变量是否是某一类型，例如，s is string
位逻辑操作符
&(位与)，|(位或)，^(异或)。可以对整数，布尔，和枚
举类型进行这三种操作。
条件逻辑操作符
包括&&(与)和||(或)
条件运算符
b x:y
b为真，结果是x，否则是y

以上就是C#基础知识整理：C#基础（1）的内容，更多相关内容请关注PHP中文网（www.php.cn）！