Partage de ressources sur les didacticiels vidéo C#

"Tutoriel C#" est un cours d'introduction au langage C#. Dans le cours, il partira des concepts de base de la plateforme .NET et de C#, et fournira une introduction approfondie à la syntaxe de base du développement C#, logique de programme simple et utilisation des outils Visual Studio. Implémentation d'algorithmes couramment utilisés. En parallèle, nous espérons également qu'à travers des exercices liés au cours et des exercices de programmation, nous pourrons aider les étudiants à s'initier rapidement au langage C#.

Adresse de lecture du cours : http://www.php.cn/course/84.html

Le style d'enseignement de l'enseignant :

Les cours de l'enseignant sont simples et approfondis, de structure claire, analysés couche par couche, imbriqués, rigoureux dans l'argumentation, rigoureux dans la structure et l'utilisation le pouvoir logique de la pensée pour attirer l'attention des élèves. Force, utiliser la raison pour contrôler le processus d'enseignement en classe. En écoutant les cours de l'enseignant, les étudiants acquièrent non seulement des connaissances, mais reçoivent également une formation à la réflexion, et sont également influencés et influencés par l'attitude académique rigoureuse de l'enseignant

Le point le plus difficile de cette vidéo est C# multi -threading :

1. Raisons de l'utilisation des threads

1. la fiabilité des candidatures.

2. Les fils de discussion peuvent être utilisés pour simplifier le codage.

3. Les threads peuvent être utilisés pour réaliser une exécution simultanée.

2. Connaissances de base

1. Processus et thread : en tant qu'unité de base du programme d'exécution du système d'exploitation, le processus possède les ressources du programme d'application. Le processus contient des threads. par threads. Threads Ne possède pas de ressources.

2. Fil de premier plan et fil d'arrière-plan : les nouveaux fils de discussion créés via la classe Thread sont par défaut le fil de premier plan. Lorsque tous les threads de premier plan sont fermés, tous les threads d’arrière-plan seront également terminés directement sans lever d’exception.

3. Suspendre (Suspender) et réveiller (Resume) : étant donné que l'ordre d'exécution des threads et l'exécution du programme sont imprévisibles, l'utilisation de la suspension et du réveil est sujette à des blocages. il devrait être utilisé le moins possible.

4. Fil de blocage : rejoignez-le et bloquez le fil de discussion appelant jusqu'à ce que le fil de discussion se termine.

5. Terminez le thread : Abort : lancez une exception ThreadAbortException pour terminer le thread. Le thread terminé ne peut pas être réveillé. Interruption : lève une exception ThreadInterruptException pour mettre fin au thread et l'exécution peut continuer en interceptant l'exception.

6. Priorité du fil : Au-dessus de la normale En dessous de la normale La plus élevée la plus basse Normale, la valeur par défaut est Normale.

3. L'utilisation de threads

Les fonctions de thread sont transmises par délégation, et peuvent être sans paramètres ou avec paramètres (un seul paramètre peut être encapsulé dans une classe ou une structure).

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(new ThreadStart(TestMethod));
            Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));
            t1.IsBackground = true;
            t2.IsBackground = true;
            t1.Start();
            t2.Start("hello");
            Console.ReadKey();
        }

        public static void TestMethod()
        {
            Console.WriteLine("不带参数的线程函数");
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine("带参数的线程函数，参数为：{0}", datastr);
        }
    } 
}

4. Pool de threads

Étant donné que la création et la destruction de threads nécessitent une certaine quantité de surcharge, une utilisation excessive des threads entraînera cause En raison du gaspillage de ressources mémoire, pour des raisons de performances, le concept de pool de threads a été introduit. Le pool de threads maintient une file d'attente de requêtes. Le code du pool de threads extrait la tâche de la file d'attente, puis la délègue à un thread du pool de threads pour exécution. Le thread ne sera pas détruit immédiatement après l'exécution, afin que les tâches puissent être exécutées dans le pool de threads. La création et la destruction d'arrière-plan et de threads peuvent être réduites.

Le thread du pool de threads est par défaut le thread d'arrière-plan (IsBackground).

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //将工作项加入到线程池队列中，这里可以传递一个线程参数
            ThreadPool.QueueUserWorkItem(TestMethod, "Hello");
            Console.ReadKey();
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine(datastr);
        }
    }
}

5. Classe de tâches

Il est très simple d'utiliser la méthode QueueUserWorkItem() de ThreadPool pour lancer un exécution de thread asynchrone. Mais le plus gros problème avec cette méthode est qu'il n'y a pas de mécanisme intégré pour vous informer quand l'opération est terminée, et existe-t-il un mécanisme intégré pour obtenir une valeur de retour une fois l'opération terminée. À cette fin, vous pouvez utiliser la classe Task de System.Threading.Tasks.

Construisez un objet Task et transmettez le type de retour d'une opération pour le paramètre générique TResult.

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            t.Wait();
            Console.WriteLine(t.Result);
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //结果太大，抛出异常
            return sum;
        }
    }
}

Lorsqu'une tâche est terminée, une nouvelle tâche sera automatiquement démarrée.
Une fois qu'une tâche est terminée, elle peut démarrer une autre tâche. Le code précédent est réécrit ci-dessous sans bloquer aucun thread.

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            //t.Wait();
            Task cwt = t.ContinueWith(task => Console.WriteLine("The result is {0}",t.Result));
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //结果溢出，抛出异常
            return sum;
        }
    }
}

6. Exécution asynchrone des délégués

Appels asynchrones des délégués : BeginInvoke() et EndInvoke()

namespace Test
{
    public delegate string MyDelegate(object data);
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate mydelegate = new MyDelegate(TestMethod);
            IAsyncResult result = mydelegate.BeginInvoke("Thread Param", TestCallback, "Callback Param");

            //异步执行完成
            string resultstr = mydelegate.EndInvoke(result);
        }

        //线程函数
        public static string TestMethod(object data)
        {
            string datastr = data as string;
            return datastr;
        }

        //异步回调函数
        public static void TestCallback(IAsyncResult data)
        {
            Console.WriteLine(data.AsyncState);
        }
    }
}

Synchronisation des threads

　1) Opération atomique (verrouillée) : toutes les méthodes effectuent une opération de lecture ou d'écriture atomique.

2) Instruction lock() : évitez de verrouiller le type public, sinon l'instance dépassera la portée du contrôle du code. Définissez un objet privé à verrouiller.

　3) Monitor implémente la synchronisation des threads

　 L'acquisition et la libération de verrous exclusifs sont réalisées via Monitor.Enter() et Monitor.Exit() Après l'acquisition, les ressources sont exclusives et aucune autre. les threads sont autorisés à accéder.

Il existe également une méthode TryEnter, qui ne bloquera pas et n'attendra pas lorsque la ressource ne peut pas être demandée. Vous pouvez définir un délai d'attente et renvoyer false si elle ne peut pas être obtenue.

　4) ReaderWriterLock

　 Lorsque l'opération de ressource implique plus de lecture et moins d'écriture, afin d'améliorer l'utilisation des ressources, le verrou de l'opération de lecture est un verrou partagé, afin que plusieurs threads puissent lire la ressource simultanément. L'opération d'écriture est un verrou exclusif et un seul thread est autorisé à fonctionner.

5) La classe d'événement implémente la synchronisation

La classe d'événements a deux états, l'état terminé et l'état non terminé. L'appel de WaitOne dans l'état terminé peut demander le succès et définir l'état temporel sur l'état terminé via Set.

1) AutoResetEvent (événement de réinitialisation automatique)

2) ManualResetEvent (événement de réinitialisation manuelle)

6) Sémaphore (Sémaphore)

Signal La quantité est une variable int maintenue par l'objet noyau. Lorsqu'elle est à 0, le thread est bloqué. Lorsqu'elle est supérieure à 0, elle est débloquée. Lorsque le thread en attente sur un sémaphore est débloqué, le nombre de sémaphores est de +1.

Le thread diminue le sémaphore de 1 via WaitOne et augmente le sémaphore de 1 via Release C'est très simple à utiliser.

7) Mutex (Mutex)

Ressource exclusive, l'utilisation est similaire à Semaphore.

8) Synchronisation inter-processus

La synchronisation au niveau du système peut être réalisée en définissant le nom de l'objet de synchronisation. Différentes applications identifient différents objets de synchronisation via le nom de l'objet de synchronisation.

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!