.NET Framework 4.5 cinq fonctionnalités intéressantes partagées

Introduction

Cela fait presque un an que .NET 4.5 est sorti. Mais avec la plupart des versions récentes de Microsoft, des problèmes de communication avec les développeurs .NET ont révélé que les développeurs ne connaissent qu'une ou deux fonctionnalités, et que d'autres fonctionnalités ne restent que sur MSDN et existent sous la forme d'une simple documentation.

Par exemple, lorsque vous demandez à un développeur .NET quelles sont les nouveautés du noyau .NETFramework, la plupart d'entre eux vous répondront simplement async et attendent (du moins avec moi, les personnes à qui nous avons parlé seulement parlé de ces propriétés).

De plus, il est difficile de comprendre toutes les nouveautés. Parce que ces fonctionnalités ne sont peut-être pas aussi intéressantes qu’elles le paraissent pour le travail que vous développez actuellement.

Donc, dans cet article, je souhaite mentionner 5 fonctionnalités que j'aime dans le noyau .NET 4.5. Bien sûr, c’est peut-être simplement ma préférence et non la vôtre. Mais ce que je fais, c'est que je pense également à la communauté .NET dans son ensemble lorsque je choisis ces fonctionnalités, et j'espère répondre à cette attente.

Astuce : Cet article ne traite pas des nouvelles fonctionnalités de ASP.NET, WCF, WPF, WWF, etc. Je n'ai parlé que des nouvelles fonctionnalités du noyau.

Fonctionnalité 1 : Async et Await (Développeur de code)

Cette fonctionnalité a été surfaite et tous les évangélistes .NET en parlent. Mais c'est toujours ce que j'aime et vous comprendrez pourquoi ce n'est qu'à quelques lignes d'ici.

Async et wait sont des marqueurs qui marquent où le contrôle doit revenir au code lorsque la tâche (thread) se termine.

Essayons de comprendre la signification de la déclaration ci-dessus à travers le code suivant. Si vous comprenez le déroulement du code suivant :

1. Static void main() appelle la méthode Method() depuis le début.

2. La méthode Method() génère une tâche (thread) nommée LongTask, et le thread attendra 10 secondes.

3. Dans le même temps, après avoir appelé la tâche, le contrôle revient à la méthode Method() pour continuer à exécuter le code restant. En d'autres termes, LongTask fonctionne toujours comme on l'appelait multithread (Task.Run...). Par exemple, attendez 10 secondes et le reste de la méthode Method() est exécuté.

Maintenant, dans le même scénario, nous souhaitons que l'étape 3 soit réalisée différemment. Nous voulons qu'une fois l'exécution de LongTask() terminée, le contrôle revienne à la méthode Method pour exécuter le code suivant. Les mots-clés « async » et « wait » peuvent aider à réaliser les fonctions ci-dessus.

Voici trois points clés à retenir concernant les mots-clés "async" et "wait" :

1. Async et wait sont A paire de mots-clés. Vous ne pouvez pas les utiliser indépendamment.

2. Appliqué de manière asynchrone aux méthodes. Ce mot-clé est un indicateur, ce qui signifie que la méthode aura un mot-clé wait.

3. Le mot-clé wait marque l'emplacement où l'exécution de la tâche reprend. Vous trouvez donc toujours ce mot-clé associé à la tâche.

Vous trouverez ci-dessous une version révisée du code discuté précédemment, dans laquelle nous appliquons async et wait. Toutes les autres étapes restent telles que décrites ci-dessus, mais « l'étape 3 » sera effectuée une fois l'« étape 2 » terminée. Pour faire simple, le contrôle revient à la méthode Method() une fois la tâche terminée.

Maintenant que vous avez entendu parler de « async » et « wait », permettez-moi de poser une question. Le code ci-dessus peut également être implémenté via Task.Wait ou Task.ContinueWith, alors quelle est la différence entre eux ? Je laisse cette question comme devoir pour vous.

Fonction 2 : CommoditéZipCompression (compression Zip)

Zip est l'un des formats de fichiers les plus acceptés. Le format Zip est pris en charge par presque tous les systèmes d'exploitation sous certains noms intégrés.

• Dans les systèmes d'exploitation Windows, il est implémenté sous le nom de « Fichier compressé ».

• Dans les systèmes d'exploitation MAC, il est implémenté sous le nom de "Document Utility".

À l'heure actuelle, dans .NET, nous n'avons pas de support intégré pour effectuer la compression Zip. De nombreux développeurs utilisent des composants tiers tels que « DotnetZip ». Dans .NET 4.5, l'attribut Zip est intégré au framework lui-même, intégré à l' espace de noms de System.IO.Compression.

Dans la première étape, vous devez référencer les deux espaces de noms :

• System.IO.Compression.FileSystem

• System.IO.Compression

Faites ensuite référence aux deux espaces de noms suivants :

using System.IO.Compression;

Si vous souhaitez compresser des fichiers à partir d'un dossier, vous pouvez appeler le CreateFromDirectory suivant fonction illustrée ci-dessous.

ZipFile.CreateFromDirectory(@"D:\data",@"D:\data.zip");

Si vous souhaitez décompresser, vous pouvez appeler la fonction ExtractToDirectory comme indiqué dans le code suivant.

ZipFile.ExtractToDirectory(@"D:\data.zip", @"D:\data\unzip");

Caractéristique 3 : Expression régulière Timeout (timeout)

« L'expression régulière » a toujours été le premier choix pour manière de vérification. Si vous débutez avec les expressions régulières, consultez Expressions régulières où j'explique le fonctionnement des expressions régulières. Mais c'est précisément à cause de l'analyse logique typique des expressions régulières qu'elles sont exposées aux attaques DOS. Essayons de comprendre ce que je viens de dire.

À titre d'exemple, veuillez considérer cette expression régulière - "^(d+)$". Cette expression régulière indique qu'il ne peut y avoir que des nombres. Vous pouvez également voir le diagramme des symboles d’expression régulière, qui montre comment l’expression régulière sera évaluée. Supposons maintenant que nous souhaitions vérifier "123456X". Cela aura 6 chemins comme indiqué dans l’image ci-dessous.

Mais si on ajoute un numéro de plus, il y aura 7 chemins. En d’autres termes, à mesure que la longueur des caractères augmente, l’expression régulière prendra plus de temps à s’exécuter. Autrement dit, le temps d’évaluation évolue linéairement avec la longueur des caractères.

Changeons maintenant l'expression régulière définie précédemment de "^(d+)$" à "^(d+)+$". Si vous regardez le diagramme de notation regex, c'est assez complexe. Si nous essayons maintenant de vérifier "123456X", il y aura 32 chemins. Si vous ajoutez un caractère supplémentaire, le nombre de chemins passera à 64.

En d'autres termes, la surcharge temporelle dans l'expression régulière ci-dessus est liée de manière exponentielle au nombre de caractères.

Maintenant, ce que vous vous demandez peut-être, est-ce important ? L'augmentation linéaire du temps d'évaluation peut être exploitée par des pirates informatiques pour mener des attaques DOS (déni de service). Ils peuvent déployer une chaîne suffisamment longue et suffisamment longue pour que votre application se bloque pour toujours.

Une solution appropriée à ce problème consiste à définir un délai d'attente pour l'exécution d'une expression régulière. La bonne nouvelle est que dans .NET 4.5, vous pouvez définir une propriété de délai d'attente comme indiqué dans le code suivant. Ainsi, si vous recevez une chaîne malveillante, l'application ne s'exécutera pas éternellement dans la boucle.

try
{
  var regEx = new Regex(@”^(\d+)+$”, RegexOptions.Singleline, TimeSpan.FromSeconds(2));
  var match = regEx.Match(“123453109839109283090492309480329489812093809x”);
}
catch (RegexMatchTimeoutException ex)
{
  Console.WriteLine(“Regex Timeout”);
}

Fonctionnalité 4 : Optimiser le Fichier de configuration (améliorer les performances de démarrage)

Nous savons tous que le code .NET est semi- -format compilé. Au moment de l'exécution, le compilateur JIT (Just-in-Time) exécute et convertit ce code IL semi-compilé en code natif machine. L'une des principales plaintes concernant le JIT est que lorsqu'une application .NET est exécutée pour la première fois, elle s'exécute très lentement car le JIT est occupé à convertir le code IL en code machine.

Afin de réduire ce temps de démarrage, il existe quelque chose appelé "fichier de configuration d'optimisation" dans .NET4.5. Un fichier de configuration n'est rien de plus qu'un simple fichier qui enregistre une liste de méthodes dont votre application a besoin pour démarrer son exécution. Ainsi, lorsque l'application démarre, le JIT en arrière-plan s'exécute et commence à convertir le code IL de ces méthodes en langage machine/natif.

Ce JIT d'arrière-plan compile les méthodes de démarrage sur plusieurs processeurs pour réduire davantage le temps de démarrage. Notez également que vous aurez besoin d'un processeur multicœur pour réaliser une optimisation de profil. Si vous ne disposez pas d'un processeur multicœur, ce paramètre sera ignoré.

　　为了创建“配置文件”这个文件，首先你需要引入System.Runtime命名空间。然后你可以调用静态类ProfileOptimization的SetProfileRoot和StartProfile方法。现在当应用启动后台JIT，它将会读取配置文件并且在后台编译启动方法从而降低启动时间。

using System.Runtime;

// Call the Setprofilerroot and Startprofile method
ProfileOptimization.SetProfileRoot(@"D:\ProfileFile");

ProfileOptimization.StartProfile("ProfileFile");

　　重要提示：ASP.NET 4.5和Silverlight 5应用默认支持Profileoptimization。所以上述代码在这些技术中无需编写。

　　特性5：垃圾回收（垃圾后台清理）

　　垃圾回收在.NET应用中是一项真正繁重的任务。当是ASP.NET应用的时候，它变得更繁重。ASP.NET应用在服务器运行，许多客户端向服务器发送请求从而产生对象负荷，使得垃圾回收确实努力清理不需要的对象。

　　在.NET4.0中，当垃圾回收运行清理的时候，所有的应用程序线程都暂停了。在上图中你可以看到我们有3个应用程序线程在执行。有两个垃圾回收运行在不同的线程上。一个垃圾回收线程对应一个逻辑处理器。现在应用程序线程运行并执行它们的任务，伴随着这些应用程序线程的执行它们也创建了操作对象。

　　在某个时间点，后台垃圾回收运行开始清理。当这些垃圾回收开始清理的时候，它们暂停了所有的应用程序线程。这使得服务器/应用程序在那一刻不响应了。

　　为了克服上述问题，服务器垃圾回收被引进了。在服务器垃圾回收机制中多创建了一个运行在后台的线程。这个线程在后台运行并持续清理2代对象（关于垃圾回收0,1和2代的视频）从而降低主垃圾回收线程的开销。由于双垃圾回收线程的执行，主应用程序线程很少被暂停，进而增加了应用程序吞吐量。为了使用服务器垃圾回收，我们需要使用gcServer XML标签并且将它置为true。

<configuration>
   <runtime>
      <gcserver></gcserver>
   </runtime>
</configuration>

　　另三个值得探索的特性

　　设置默认应用程序域的区域性

　　在上一个版本的.NET中如果我想设置区域性那么我需要在每个线程中设置。下面的示例程序演示了在线程级别设置区域性的痛苦。当我们有大量多线程应用程序的时候这是真正的痛苦。

CultureInfo cul = new CultureInfo(strCulture);
Thread.CurrentThread.CurrentCulture = cul;
Thread.CurrentThread.CurrentUICulture = cul;

　　在4.5中我们可以在应用程序域级别设置区域性并且所有在这个应用程序域当中的线程都会继承这个区域性。下面就是如何实现DefaultThreadCurrentCulture的示例代码。

CultureInfo culture = CultureInfo.CreateSpecificCulture("fr-FR");

CultureInfo.DefaultThreadCurrentCulture = culture;

　　数组支持超过2GB容量

　　我不确定在什么样的情景下我们会需要2GB的容器。所以我个人并不清楚我们将在哪用到这个特性。如果我曾需要如此之大的容器我会把它分解成小份。但我确信在框架中启用此功能应该有个很好的理由。

　　控制台支持Unicode编码

　　我把这个特性留在讨论范围之外是因为非常少的人用控制台程序工作。我曾见过有人把控制台用于学术目的。总而言之，我们现在也对控制台应用有了Unicode编码支持。

　　引用

• http://msdn.microsoft.com/en-us/library/ms171868.aspx

• Mr Sukesh marla的精彩文章ASP.NET 4.5 new features

　　当你有空的时候，一定来看看我的网站 www.questpond.com关于.NET4.5面试问和答，我已经在这方面有了不少努力。

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!