Compilation des connaissances de base en C# : classes et structures C# (2)

　1. Qu'est-ce qu'un constructeur ? Quels sont les constructeurs ? Quelles sont les définitions, modalités de mise en œuvre et précautions de chaque constructeur ?
Le soi-disant constructeur est une méthode. Cette méthode peut initialiser l'objet, c'est-à-dire qu'après avoir exécuté cette fonction, la mémoire ouvrira toujours un espace pour les objets de cette classe. Il existe trois types : le constructeur normal, c'est-à-dire le constructeur d'instanciation ; le constructeur statique privé ;
Constructeur d'instanciation :

    public class Example
    {
        private string property1 = string.Empty;

        private string property2 = @"hello";

        private int property3 = 0;

        public Example()//成员都是声明时的初始值，这种默认的构造器，也可以不写。
        {

        }

        public Example(string p1, string p2, int p3)//传入的值初始化
        {
            this.property1 = p1;

            this.property2 = p2;

            this.property3 = p3;
        }
    }

Constructeur privé :
Le constructeur privé n'est pas accessible de l'extérieur, alors comment l'instancier, voir mode singleton, privé est utilisé ici Constructeur :

http://www.php.cn/

Constructeur statique :
Regardez d'abord l'exemple :

 public class StaticConstruct
    {
        static StaticConstruct()
        {
            Console.WriteLine(@"静态构造函数");
        }

        public StaticConstruct()
        {
            Console.WriteLine(@"实例化构造函数");
        }

        public StaticConstruct(string flage)
        {
            Console.WriteLine(@"带参构造函数");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            StaticConstruct strc = new StaticConstruct();

            StaticConstruct strcValue = new StaticConstruct(string.Empty);

            Console.ReadLine();
        }
    }

Résultat :

Caractéristiques des constructeurs statiques : les modificateurs d'accès ne sont pas autorisés dans les constructeurs statiques ; lors de l'instanciation, le constructeur statique est d'abord automatiquement appelé, ce qui signifie que l'appel du constructeur statique est incontrôlable et qu'il n'y en a qu'un dans une classe ; ; il ne peut pas être hérité.
2. Quelles sont les utilisations de Ce mot-clé et du Mot-clé de base ? Implémenter le code ?
(1), ce mot-clé :
Ceci, comme son nom l'indique, fait référence à la signification de cette classe et fait référence aux membres de la classe actuelle. Bien sûr, si le programme est en cours d'exécution, on peut dire avec précision que cela fait référence au membre de l'objet de la classe actuelle et que sa fonction est de distinguer l'objet. Parce qu'une classe peut avoir N objets. Cependant, le mot clé this ne peut pas être utilisé dans la classe statique. La raison est qu'il est impossible pour static d'instancier plusieurs objets. Il n'en a qu'un, il n'est donc pas nécessaire de l'utiliser pour distinguer les objets. Les variables généralement utilisées sont les suivantes :
a. Les variables portant le même nom dans les méthodes ou les constructeurs.

     public class MyTestA
    {
        private string testA = string.Empty;

        public MyTestA(string testA)
        {
            this.testA = testA;
        }

        public void Handler(string testA)
        {
            this.testA = testA;
        }
    }

b. Méthodes get et set

    public class MyTestB
    {
        private string testB = string.Empty;

        public string TestB
        {
            get 
            { 
                return this.testB;
            }
            set 
            { 
                this.testB = value;
            }
        }
    }

c. Passer l'instance
Par exemple, dans l'événement

    public class MyTestC
    {
        public event EventHandler OnTestCEvent = null;

        private void Send_OntestEvent(object sender,EventArgs e)
        {
            if (OnTestCEvent != null)
            {
                OnTestCEvent(sender, e);
            }
        }

        private void TestEvent()
        {
            Send_OntestEvent(this, null);
        }
    }

    public class MyTestD
    {
        MyTestC testC = new MyTestC();

        public event EventHandler OnTestDEvent = null;

        private void Send_OnTestDEvent(object sender, EventArgs e)
        {
            if (OnTestDEvent != null)
            {
                OnTestDEvent(sender, e);
            }
        }

        public MyTestD()
        {
            testC.OnTestCEvent += new EventHandler(testC_OnTestEvent);
        }

        void testC_OnTestEvent(object sender, EventArgs e)
        {
            Send_OnTestDEvent(sender, e);
        }
    }

    public class MyTestE
    {
        MyTestD testD = new MyTestD();

        public MyTestE()
        {
            this.testD.OnTestDEvent += new EventHandler(testD_OnTestDEvent);
        }

        void testD_OnTestDEvent(object sender, EventArgs e)
        {
            MyTestC testC = sender as MyTestC;//通过MytestD将对象转了过来

            if (testC != null)
            {
                //代码
            }
        }
    }

(2) Mot clé de base :
est généralement utilisé pour que les sous-classes accèdent aux classes parentes.
L'une est, lors du remplacement de la méthode de la classe parent,

    public class ParentClass
    {
        public virtual void MethodA()
        {
            Console.WriteLine(@"基类的方法");
        }
    }

    public class ChildClass : ParentClass
    {
        public override void MethodA()
        {
            base.MethodA();

            Console.WriteLine("派生类方法");
        }
    }

L'autre est que la sous-classe appelle le constructeur de la classe parent,

    public class ParentClass
    {
        public ParentClass(string flage)
        {
            Console.WriteLine(@"基类构造函数");
        }

        public virtual void MethodA()
        {
            Console.WriteLine(@"基类的方法");
        }
    }

    public class ChildClass : ParentClass
    {
        public ChildClass(string flage)

            : base(flage)
        {

        }

        public override void MethodA()
        {
            base.MethodA();

            Console.WriteLine("派生类方法");
        }
    }

　3. c'est un reflet ? Comment mettre en œuvre la réflexion ? Quels sont les avantages et les inconvénients de la réflexion ? Quand utiliser la réflexion ?
http://blog.csdn.net/yysyangyangyangshan/article/details/7028589

Ce qui précède est la connaissance de base de C# : Classe et structure C# (2) Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !