Sous Visual Studio 2012, l’équipe Microsoft a ajouté une nouvelle fonctionnalité : le choix de l’algorithme de signature. Pour l’heure Visual Studio 2012 propose deux fonctions de hachage cryptographique :
SHA1RSA (lire SHA 1 de RSA)
SHA256RSA (lire SHA 256 de RSA)
Vous pouvez ainsi créer un nom fort de votre assemblage basé sur l’une des ces deux fonctions.
Assemblies are the building blocks of the .NET Framework; they form the fundamental unit of deployment, version control, reuse, activation scoping, and security permissions. An assembly provides the common language runtime with the information it needs to be aware of type implementations. It is a collection of types and resources that are built to work together and form a logical unit of functionality. To the runtime, a type does not exist outside the context of an assembly [Microsoft Press].
Part 1 : The signature
The signature. NET it guaranteed the integrity your original content. The process thus takes its meaning in terms of security and guarantee of authenticity of your program.
In. NET, signing an assembly. Net can be segment it into two components:
The hash of its contents
The strong name
Part 2 : The strong name
There can be more than one component (DLL) with the same naming, but with different versions. This can lead to many conflicts.
A SN Key is used to uniquely identify a component.
A strong name is composed of the :
version
Name
Public key
Private key
Culture and CPU architecture
Part 3 : Sign an assembly using IDE VS 2010
1- In the properties of your project check «Sign the assembly »
2- Enter your key name.
After enter your key name, Visual Studio will generate a key file : yourKeyName.snk
Your can protect you key name using a password.
Part 4 : Protect your key file with password
Enter a passwrod if you don’t trust the people with access to the assembly.
In general, you should protect it with a password if you don’t trust the people with access to the assembly, which is not common
Part 5 : Sign an assembly using Al.exe ( Assembly Linker)
First step : Create a key file using sn.exe (Strong Name tool)
Option -Vf can verifies the strong name contained in assembly (-vf forces the verifies even if it has been disabled using the –Vr option).
Second step : Sign your assembly using Al.exe
Part 6 : Sign an assembly using AssemblyInfo file
In the file AssemblyInfo, add the AssemblyKeyFileAttribute or the AssemblyKeyNameAttribute, specifying the name of the file or container that contains the key pair.
If your assembly have a dependency for another assembly (his parent) you must sign it.
Juste pour vous informer que certains billets de ce blog seront désormais écrits en anglais. Pour ceux d’entre vous qui ne comprennent pas cette langue, veuillez utiliser les boutons de traduction situés en haut à gauche de l’écran (soit à votre droite).
Hi, dans quelques heures la plénière spécialement pensée pour les développeurs débutera.
Ne pouvant me déplacer cette année pour vivre en personne les nombreuses sessions techniques qui seront présentées sur 3 jours (12, 13 et 14 Février 2013), j’invite tous les développeurs, professionnels de TI, décideurs informatiques à ne pas manquer cet évènement exceptionnel qui se tiendra au Palais des Congrès de Paris à Issy-Les-Moulineaux, clamartois et clamartoises suivez mon regard .
Les TechDays sont des rendez-vous annuel de Microsoft destinés aux développeurs, professionnels et décideurs de l’informatique. Ce salon est l’un des évènements IT le plus important en Europe de l’Ouest.
Mardi 12 février • 9H00 – 10H00 : Plénière “Développeurs, c’est vous le chef !!”.
Dans ce billet, nous nous attarderons sur le débogage d’une WAZA ASP.NET MVC 4.
Dans le billet précédent, nous avons préparé le terrain pour écrire du code. Notre application ressemblera à ceci :
Voici le contenu de notre fichier d’entrée (index.cshtml)
Pour commencer le débogage, appuyer la touche <F5> de votre clavier.
Démarrer ensuite l’émulateur.
Pour afficher l’interface utilisateur de l’émulateur, faite un clique droit sur l’icone de Windows Azure et sélectionnez “Show Compute Emulator UI”.
Le volet gauche de l’interface utilisateur affiche les instances de rôle en cours d’exécution dans l’émulateur. Vous pouvez cliquer sur le service ou les rôles pour afficher cycle de vie, les log et des informations de diagnostic.
Note : Lorsque vous mettez fin à l’exécution de votre application (STOP), l’émulateur de calcul et de stockage ne sont pas arrêtés. Vous devez les arrêter explicitement dans la barre d’état système.
Nouvelles instances lors du débogage
L’on peut modifier la configuration d’une application en cours d’exécution dans le débogueur. Toutefois, si vous ajoutez des instances supplémentaires d’un rôle à une application en cours d’exécution, le débogueur ne l’attache pas automatiquement.
Pour déboguer vos nouvelles instances, vous devez explicitement les attacher à leurs processus.
Pour se faire, cliquez sur le menu ‘Déboguer’, ensuite ‘Attacher au processus’, sélectionnez le processus WaHostBoot.exe , puis cliquez sur ‘Attacher’.
Si vous arrêtez le débogage puis redémarrez les service dans le débogueur, le débogueur s’attachera automatiquement à toutes les instances des rôles en cours d’exécution.
Nous arrivons à la fin de notre sprint sur ASP.NET MVC 4. Dans notre périple, j’ai abordé les thèmes tels :
Modèle
Vue
Contrôleur
Moteur de rendu
Inspecteur de page
RAZOR ou ASPX
De nos jours il est plus simple de développer et déployer une application ASP.NET MVC 4.
En ce qui concerne le moteur de rendu RAZOR, ce dernier offre de meilleurs options pour les développeurs. Le codage est plus rapide, expressif et très simple. Sa syntaxe est assez compact et rend la lisibilité globale du balisage et du code plus fluide.
Dans un futur, je consacrerai une série de billets exclusivement sur le moteur “RAZOR”.
Dans ce billet, nous nous attarderons sur le développement et le déploiement sur Windows Azure d’une application ASP.NET MVC 4 en utilisant les outils de développement disponibles dans Visual Studio 2012.
Au menu :
Les services de la plateforme Azure
La plateforme Windows Azure
Installation d’outils de développement Windows Azure
Création d’une WAZA
Déboguer une WAZA
Publication d’une WAZA
1. La plateforme Windows Azure
La plateforme Azure correspond aux offres d’informatique cloud de Microsoft de type PaaS ( Platform as a Service) et IaaS Infrastructure as a service).
2. Les services de la plateformes Azure
Cette plateforme est composée de :
– Windows Azure (PaaS, services cloud, machines virtuelles, IaaS)
- Windows Azure SQL Databases (SQL Azure –> Ancien nom)– Windows Azure MarketPlace (Applications, DataMarcket)– Windows Azure Mobile Services– Windows Azure Media Services– Autres services (Services de bus, ACS (Acces Control Services), …)
Ces services sont regroupés sur la figure suivante :
Je vous inviterai à démarrer Visual Studio 2012 et à passer à l’action .
3. Installation d’outils de développement Windows Azure
Lorsque vous développer des applications Windows Azure, vous devez démarrer Visual Studio 2012 en mode ‘Administrateur’. Dans le cas contraire, vous serez confronté à une erreur lors de l’exécution de votre application :
Pour Démarrer Visual Studio en mode administrateur suivre les étapes suivantes :
Étape 1 : Fermer Visual Studio (si ouvert)
Étape 2 : Faites un clic droit sur le raccourci (ou icône) de Visual Studio 2012.
Étape 3 : Sous l’onglet “Compatibilité”, cocher la case “Exécuter ce programme en tant que administrateur”.
Étape 4 : Enfin un clic sur “Appliquer” puis sur “OK”.
Quel merveilleux matin, lorsqu’en lisant mes courriels, j’ai découvert le courriel de L.G. Manager du programme de la communauté “MVP Lead” …
J’ai été nominé MVP en reconnaissance de mes contributions et de mon implication dans des communautés techniques Microsoft.
Merci à L.G. pour cette reconnaissance, à Microsoft qui ne cesse de valoriser l’expertise technique des membres de la communauté, à chacun de vous qui avez contribuez de près comme de loin.
Cette reconnaissance m’amène à continuer de m’impliquer d’avantage au sein de la communauté, ce que je ferai dans les jours, mois et année à venir par la grâce de Dieu.
Dans ce billet, nous verrons comment utiliser les attributs d’informations de l’appelant (Caller Info Attributes – CIA ) lorsqu’on cible une version plus ancienne du Framework.
Dans le billet précédent, j’ai parlé des attributs d’informations de l’appelant comme l’une des nouveautés de C# 5 et disponible sous le Framework 4.5.
À supposer que l’on souhaite cibler une version du Framework plus ancien (Par exemple 4), les attributs d’informations de l’appelant ne sont disponibles que dans la version 4.5, que faire? Y a t-il une astuce qui permettrait l’utilisation des attributs d’informations de l’appelant si l’on cible une version ancienne du Framework? Et bien, oui!
Si on définit nos propres attributs et qu’on les placent dans l’espace de noms où le compilateur s’attend à les trouver, on ferra croire au compilateur que nos attributs sont bien présents.
Démo :
Ajoutons un nouveau projet dans la solution “CallerInformation"
Affichons les propriétés de notre projet et modifions la cible du Framework (Dans notre cas la version 4)
Ajoutons notre classe d’attributs :
namespace System.Runtime.CompilerServices
{
class CallerInfoAttributes
{
//CallerMemberNameAttribute
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
}
// CallerFilePathAttribute
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
public sealed class CallerFilePathAttribute : Attribute
{
}
// CallerLineNumberAttribute
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
public sealed class CallerLineNumberAttribute : Attribute
{
}
}
}
Après compilation et exécution, l’on s’aperçoit que nos attributs ont été pris en compte par le compilateur.
Cette fonctionnalité peut être utilisée pour cibler les versions 2.0, 3.0, 3.5 et 4 du Framework, bien évidemment sous Visual Studio 2012.
N.B. : Le compilateur vérifie uniquement que les trois types d’attributs existent, peu importe la DLL dans laquelle ils se trouvent.
L’une des nouvelles fonctionnalité de C# 5 sont les attributs d’informations de l’appelant.
Ces attributs sont en fait trois attributs (CallerMemberName, CallerFilePath, CallerLineNumber) des trois classes(CallerMemberNameAttribute, CallerFilePathAttribute, CallerLineNumberAttribute) que l’on peut utiliser dans les arguments des méthodes, afin d’obtenir plus d’informations sur l’élément appelant. Avec ces trois attributs, l’on peut ainsi récupérer le nom du fichier source qui a appelé, le numéro de ligne dans ce fichier et le nom de l’élément appelant.
Petit résumé :
CallerMemberName: Retourne le nom du fichier code source de l’appelant.
CallerFilePath: Retourne le numéro de ligne du fichier code de l’appelant.
CallerLineNumber: Retourne le nom de l’élément appelant.
Avant d’entre dans le vif du sujet pour une démonstration, il est important de comprendre le fonctionnement des paramètres optionnels.
Paramètres optionnels
Les paramètres optionnels ont vu le jour avec la sortie de C# 4.
Chaque paramètre optionnel est associé à une valeur par défaut dans le cadre de sa définition. Si aucun argument n’est envoyé pour ce paramètre, la valeur par défaut est utilisée.
La bonne utilisation des paramètres optionnels, réduit de façon significative l’usage des surcharges des méthodes.
public class Program
{
static void Main(string[] args)
{
new ParametresOptionnels().Display("K", "Nestor Aimé", 15, "Masculin" );
}
}
Résultat :
Dans cet exemple, l’on constate que l’un des paramètres optionnels (pays) a pris la valeur par défaut (“Canada”).
Les attributs d’informations de l’appelant (Caller Info Attributes)
Comme mentionné au début de ce billet, avec C# 5, nous pouvons désormais utiliser certains attributs (CallerMemberName, CallerFilePath, CallerLineNumber) pour obtenir de l’information sur l’appelant. Ces trois attributs peuvent s’avérer très efficace lors du développement des solutions de logs et de diagnostiques. Ces attributs sont définis dans l’espace de nom System.Runtime.CompilerServices.
Démo :
public class CallerInfoAttributes
{
public void Display(string nom, string prenom, int age, string sexe = "Masculin", string nationalite = "Canadien",
[CallerMemberName] string appelant = "",
[CallerFilePath] string fichier = "",
[CallerLineNumber] int noLigne = 0)
{
Console.WriteLine("============================================================");
Console.WriteLine("Les attributs d'informations de l'appelant");
Console.WriteLine("============================================================");
Console.WriteLine("Bonjour " + prenom + " " + nom + ", vous avez " + age + " ans " + " et êtes de nationalité " + nationalite);
Console.WriteLine("Cette méthode est appelée dans la méthode: " + appelant + ", du fichier " + fichier + ", à la ligne " + noLigne);
}
}
static void Main(string[] args)
{
new ParametresOptionnels().Display("K", "Nestor Aimé", 15, "Masculin");
new CallerInfoAttributes().Display("K", "Nestor Aimé", 15, "Masculin");
}
Résultat :
N’est ce pas merveilleux!
Quelques détails de la démo:
CallerMemberName : permet de récupérer le nom du membre ayant appelé la méthode Display. Ici l’« élément » est une méthode (Dans certains cas l’élément peut -être une propriété, un constructeur ou encore un destructeur).
CallerFilePath : permet de récupérer le nom du fichier code source d’où provient l’appel (Main).
CallerLineNumber : permet de récupérer la ligne du fichier code source d’où provient l’appel (14).
Bon à savoir : L’attribut CallerMemberName implémente l’interface INotifyPropertyChanged.
.
.
) lorsqu’on cible une version plus ancienne du Framework. 
Commentaires récents