[PowerShell / WPF] Exécuter une commande PowerShell dans WPF
Alors qu’un collègue admin dont je ne citerai pas le nom souhaitait savoir comment réaliser ceci, je me suis dit qu’un petit coup de pouce de la part d’un développeur serait sympa !! :D
Tout d’abord, il faut ajouter la référence Sytem.Management.Automation à notre application. Hors, le problème est qu’elle ne nous est pas proposée dans la liste des références disponibles. Cependant, nous allons quand même pouvoir la référencer éditant le fichier csproj à la main avec le bloc notes.
Voici la ligne à ajouter à l’intérieur de la balise ItemGroup :
<Reference Include="System.Management.Automation" />
A la réouverture de notre projet, la référence est maintenant bien ajoutée et il faut ensuite ajouter l’espace de nom à notre classe :
using System.Management.Automation;
Rentrons maintenant dans le vif du sujet :
J’ai créé, pour l’exemple, une classe CommandResult qui contient deux propriétés : Nom et Definition :
public class CommandResult
{
public string Name { get; set; }
public string Definition { get; set; }
}J’ai créé aussi une classe CommandManager qui contient une méthode GetPSCommands permettant de renvoyer une liste de CommandResult correspondant à toutes les commandes existants en PowerShell :
public class CommandManager
{
public List<CommandResult> GetPSCommands()
{
//On créé un pipeline powershell permettant d'exécuter des commandes
PowerShell powershell = PowerShell.Create();
//On ajoute la commande souhaitée
powershell.AddCommand("get-command");
//On exécute la commande
IAsyncResult result = powershell.BeginInvoke();
PSDataCollection<PSObject> lstPSData = powershell.EndInvoke(result);
List<CommandResult> lstResults = new List<CommandResult>();
if (!lstPSData.Count.Equals(0))
//On récupère les membres souhaités de chaque résultat
lstResults = (from o in lstPSData
select new CommandResult()
{
Definition = o.Members["Definition"].Value.ToString(),
Name = o.Members["Name"].Value.ToString()
}).ToList();
return lstResults;
}
}Plus d’infos à propos des types de chaque objet utilisé sur la msdn.
Maintenant nous allons afficher les résultats dans une simple ListView d’une application WPF :
Voilà pour le côté XAML :
<Grid>
<ListView x:Name="lstResultCommand">
<ListView.View>
<GridView>
<GridViewColumn DisplayMemberBinding="{Binding Path=Name}" />
<GridViewColumn DisplayMemberBinding="{Binding Path=Definition}" />
</GridView>
</ListView.View>
</ListView>
</Grid>
Voilà pour le côté code-behind :
public Window1()
{
InitializeComponent();
this.lstResultCommand.ItemsSource = new CommandManager().GetPSCommands();
}Et maintenant voici le résultat :
[WPF]Drag’n’Move d’un objet sur une surface
Voici comment implémenter une fonctionnalité de Drag’n’Move sur une surface comme un Canvas par exemple.
Tout d’abord, voici l’architecture des contrôles que l’on utilisera pour réaliser cette fonctionnalité du côté XAML :
<Window x:Class="DragNMove.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Window1" Height="300" Width="300">
<Grid>
<Canvas x:Name="drag_surface" Background="Azure">
<Label x:Name="drag_label"
MouseDown="drag_label_MouseDown"
MouseMove="drag_label_MouseMove"
MouseUp="drag_label_MouseUp"
Content="Mon Label">
</Label>
</Canvas>
</Grid>
</Window>
Dans mon exemple j’ai choisi de pouvoir déplacer un label dans un canvas.
On peut noter que l’on va s’abonner à 3 évènements afin de réaliser notre fonctionnalité :
- MouseDown : Cet évènement va nous permettre de verrouiller le mouvement de la souris sur notre label : même si la souris sort hors des limites du contrôle, la fonctionnalité de drag’n’move sera active.
Il est aussi possible de préciser le bouton de la souris sur lequel on souhaite activer la fonctionnalité.
- MouseMove : C’est dans cet évènement que l’on va déplacer le contrôle dans notre surface.
- MouseUp : C’est dans cet évènement que le déverrouillera le mouvement de la souris sur le contrôle.
Voici donc l’implémentation de ces 3 évènements :
private void drag_label_MouseDown(object sender, MouseButtonEventArgs e)
{
//On verrouille la souris sur le label
//si le bouton gauche est pressé
if (e.LeftButton.Equals(MouseButtonState.Pressed))
this.drag_button.CaptureMouse();
}
private void drag_label_MouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton.Equals(MouseButtonState.Pressed))
{
//On modifie la position du label dans le canvas
//en récupérant la position de la souris
Canvas.SetLeft(this.drag_button, e.GetPosition(this.drag_surface).X);
Canvas.SetTop(this.drag_button, e.GetPosition(this.drag_surface).Y);
}
}
private void drag_label_MouseUp(object sender, MouseButtonEventArgs e)
{
//On déverrouille la souris
this.drag_button.ReleaseMouseCapture();
}
Et voilà c’est terminé !…il vous est tout de même possible d’améliorer le tout pour limiter le déplacement à l’intérieur du canvas.
[ASP.NET MVC] Partie 1 : Présentation de MVC
Il y a environ 1 mois est sorti la version Release Candidate d’ASP.NET MVC, je vais donc réaliser une saga MVC afin de faire partager au plus nombre cette alternative au développement Web forms !
Dans ce premier billet, je vais faire une présentation générale de l’architecture d’une application MVC.
Tout d’abord il vous est possible de télécharger ASP.NET MVC ici.
ASP.NET MVC est l’implémentation du design pattern MVC (déjà très connu) pour la conception d’applications web. Ce design pattern permet le découpage de notre application en 3 couches disctinctes : Model, View and Controller.
MODEL : Cette couche va contenir l’accès aux données via Linq-To-SQL/Entities ou via votre propre provider de données. Cette couche permettra aussi la mise à jour des données affichées dans la vue.
View : Cette couche correspond à l’interface de votre application. Elle permettra d’afficher les données du model et de récupérer les entrées utilisateurs.
Controller : C’est la couche qui pilotera toute votre application. Elle permettra de gérer les actions à réaliser sur les formulaires suivant les actions utilisateurs. De plus, elle gèrera les modifications à apporter à la couche Model donc aux données.
Les avantages de réaliser une telle architecture sont :
- Facilité de mise en place des tests unitaires : en effet, des tests unitaires peuvent êtres mis en place pour chaque couche séparée les unes des autres.
- Un mapping d’URL permettant d’avoir nativement des URL optimisées pour le référencement et pour l’URL rewriting.
- Routage de chaque action utilisateur vers le contrôleur correspondant. Il n’y pas plus de notion de postback comme pour les webforms mais on parle d’action.
Dans un prochain billet je montrerai plus en détails ASP.NET MVC en présentant le template fournit dans l’add-on Visual studio 2008. J’expliquerai les fonctionnement basique de ce type de développement d’applications web.
[.NET] Exposer un flux RSS à l’aide d’un HttpHandler
Dans un précédent post, j’avais montré comment créer un flux RSS à l’aide du Framework 3.5.
A présent, nous allons voir comment exposer un flux RSS à l’aide d’un HttpHandler.
Lors d’une requête HTTP en ASP.NET une page ASPX est demandée au serveur. Dans le cas d’un HttpHandler, ce n’est plus une page qui est demandée mais une classe.
Dans un premier temps, il faut préciser à notre application ASP.NET quelle classe devra être appelée lorsque notre requête HTTP sera traitée. Pour cela, nous devons ajouter dans le fichier de configuration de notre application les éléments suivants :
<httpHandlers>
<add verb="*" path="rssfeed.axd" validate="true" type="Syndication.RssFeedHandler"/>
</httpHandlers>
L’attribut “path” indique l’url relative de la requête qui renverra vers le traitement de notre classe.
L’attribut “type” indique le nom de notre classe qui sera traitée.
Passons maintenant à la création de notre classe qui sera appelée lors du traitement de la requête. Cette classe doit implémenter l’interface IHttpHandler contenant les méthode IsReusable et ProcessRequest.
C’est dans la méthode ProcessRequest que se fera tout le traitement. En effet, elle prend en paramètre le contexte HTTP à de la requête.
Pour exposer notre flux RSS, il va donc faloir écrire le flux XML dans la réponse renvoyée au navigateur du client. Pour cela, nous allons créer un XmlWriter qui écrira dans le flux de sortie de la réponse envoyée au client :
XmlWriter wr = XmlWriter.Create(context.Response.OutputStream);
Il suffit ensuite de créer notre flux RSS (voir ce post) et de l’écrire dans notre XmlWriter.
/*
Voir post précédent pour la création du flux
*/Atom10FeedFormatter formatter = new Atom10FeedFormatter(feed);
formatter.WriteTo(wr);
wr.Flush();
wr.Close();
Désormais, lorsque l’on navigue vers l’URL : http://monsite.fr/rssfeed.axd, notre flux rss s’affiche correctement.
Il est possible ensuite d’apporter des améliorations à notre flux RSS. Par exemple, la possibilité à l’utilisateur de choisir le format (RSS 2.0 ou Atom 1.0) de son flux.
Pour cela, nous allons prendre en compte la valeur d’un paramètre passé dans l’URL afin de choisir le formattage du flux :
http://monsite.fr/rssfeed.axd?format=rss ou http://monsite.fr/rssfeed.axd?format=atom
Une petite modification est à faire dans le code de notre classe appelée pour traiter la requête :
if (context.Request.QueryString["format"].Equals("rss"))
{
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(wr);
}
else if (context.Request.QueryString["format"].Equals("atom"))
{
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(wr);
}
[.NET] Créer un flux RSS à l’aide du Framework 3.5
Dans un précédent post, j’ai montré comment à l’aide du Framework 3.5 il était possible de consommer un flux RSS. A présent, nous allons voir comment créer un flux RSS à l'aide de ces outils du Framework.
Tout d’abord il faut ajouter la référence System.ServiceModel.Web à notre projet.
Un flux RSS est représenté par la classe SyndicationFeed. Grâce à cette classe, nous allons pouvoir spécifier le titre, la description, les items, etc… qui composent notre flux.
SyndicationFeed feed = new SyndicationFeed();
Nous allons créer nos items qui seront contenus dans le flux. Pour cela, nous allons créer une liste de SyndicationItem qui seront la représentation de nos items dans le flux RSS. On pourra spécifier pour chaque item : le nom, la description, le lien, etc…
feed.Description = new TextSyndicationContent("Ceci est mon flux RSS de test");
feed.Title = new TextSyndicationContent("Flux RSS de test");
List<SyndicationItem> lstItems = new List<SyndicationItem>();
lstItems.Add(new SyndicationItem("Premier item", "Ceci est mon premier item", new System.Uri(http://www.dotnet-france.com/item1)));
lstItems.Add(new SyndicationItem("Second item", "Ceci est mon second item", new System.Uri(http://www.dotnet-france.com/item2)));
Une fois les items tous créés, il faut les ajouter au flux :
feed.Items = lstItems;
Ensuite, il faut pouvoir formatter le flux de telle sorte qu’il soit interprétable par le navigateur.
On peut, par l’intermédiaire d’un “formatter” transposer notre flux en Atom 1.0 ou RSS 2.0.
Pour cela, on créé un objet de type Atom10FeedFormatter ou Rss20FeedFormatter.
Dans cet objet nous allons charger le flux à interpréter :
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
ou
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
Voilà, il ne reste plus qu’à exposer le flux RSS précédemment créé afin qu’il soit visible aux utilisateurs !
Pour cela, il existe plusieurs méthodes :
- Utilisation d’un service avec l’aide d’un ServiceSyndicationLibrary (depuis le Framework 3.5)
- Utilisation d’un HttpHandler (expliqué dans le prochain post)
[.NET]Consommer un flux RSS à l’aide du Framework 3.5
Le Framework 3.5 met à notre disposition des outils très simple d’utilisation afin de consommer un flux RSS. Il nous sera alors possible de l’exploiter à notre guise dans notre code.
Un flux RSS est représenté dans le Framework 3.5 par la classe SyndicationFeed.
Attention : Il faut ajouter la référence System.ServiceModel.Web à votre projet pour utiliser les objets qui sont explicités dans cet article. Les objets permettant de manipuler les flux RSS sont issus de l'espace de nom suivant :
using System.ServiceModel.Syndication;
Tout d’abord, il faut récupérer le flux RSS à charger. Pour cela nous allons utiliser un objet de type XmlReader. Nous allons créer ce XmlReader en appelant la méthode statique Create prenant en paramètre un string correspondant à l’URI du flux à récupérer.
XmlReader reader = XmlReader.Create("http://blogs.dotnet-france.com/rss.axd");
Pour charger un flux RSS, on va utiliser la méthode statique Load de la classe SyndicationFeed qui prend en paramètre un objet de type XmlReader correspondant au flux RSS à charger.
SyndicationFeed feed = SyndicationFeed.Load(reader);
Notre objet SyndicationFeed possède une propriété Items de type IEnumerable<SyndicationItem>. On va pouvoir venir itérer sur cette propriété afin de récupérer le contenu du flux comme par exemple tous les titres des articles des blogs, etc…
IEnumerable<string> lstTitresArticles =
(from i in feed.Items
select i.Title.Text);
Je ne vais pas détailler toutes les propriétés de chaque item, mais il vous est possible entre autre de récupérer la date de publication, le titre, le résumé, les catégories, les liens, etc...
[ASP.NET]Définir la culture d’une application ASP.NET
Lorsqu’une application doit être traduite dans plusieurs langues afin qu’elle soit utilisée dans plusieurs pays il est nécéssaire d’utiliser la globalisation.
La globalisation permet donc à votre application de modifier le contenu de celle-ci suivant la langue du navigateur ou de la langue sélectionnée par l’utilisateur par exemple.
Nous allons voir comment définir ces paramètres.
Tout d’abord, il faut savoir que les propriétés permettant de spécifier la langue d’une application sont identifiées par deux paramètres :
- La langue : par exemple en pour la langue anglaise ou es pour l’espagnol
- La culture : par exemple GB pour la Grande Bretagne ou IT pour l’Italie
Ces deux paramètres forment une chaîne de caractères (string) qui doit être spécifiée dans les propriétés de culture de l’application. Ces propriétés sont :
- Culture : permet la mise en forme des dates, des devises, des nombres…
- UICulture : permet de définir les ressources qui sont chargées pour la page
Pour une page ASP.NET, il nous est possible de spécifier en dur la culture grâce à la propriété suivante dans la directive @Page :
<%@ Page Culture=”fr-FR” UICulture=”fr” %>
Il est aussi possible de configurer la culture pour toutes les pages dans le fichier de configuration de l’application web.config :
<globalization culture="fr-FR" uiCulture="fr" />
Nous pouvons aussi spécifier la valeur “auto” pour les paramètres de culture afin que la page ou l’application récupère automatiquement la première des langues de la liste du navigateur du client.
Pour modifier la langue de notre navigateur il faut procéder ainsi (pour IE) : Outils => Options Internet => Langues.
On peut récupérer par programme la liste des langues du navigateur (voir image ci-dessus) grâce à la collection de string UserLanguages contenue dans l’objet Request.
Par exemple, si nous souhaitons récupérer la troisième langue préférée de l’utilisateur dans son navigateur et spécifier la culture de notre application avec il faudra écrire :
Culture = Request.UserLanguages[2];
UICulture = Request.UserLanguages[2];
Attention, nous avons spécifié la culture de la page, cependant cette spécification doit être faite au bon moment pour que les contrôles de la page, à leur création, prennent bien en compte la culture. En effet, l’initialisation de la culture se fait très tôt dans le cycle de vie de la page avant que les contrôles ne soient créés.
Pour cela, il faut substituer la méthode InitializeCulture de notre page :
protected override void InitializeCulture()
{
Culture = Request.UserLanguages[2];
UICulture = Request.UserLanguages[2];
}
[.NET]Authentification grâce à un annuaire Active Directory v2
Dans mon précédent post (à lire ici), j'ai présenté comment authentifier des utilisateurs à partir d'un annuaire Active Directory. La méthode que j'ai utilisé est une méthode assez ancienne.
Voici donc une autre méthode (plus récente) permettant d'arriver au même effet. Vous pourrez constater que cette méthode est plus orientée dans la configuration de l'application via le fichier web.config.
Dans cette méthode nous allons utiliser ActiveDirectoryMembershipProvider.
Pour cela, nous allons tout d'abord configurer l'application ASP.NET en rajoutant une ConnectionString.
Il faut faire pointer cette connectionString vers le conteneur contenant nos utilisateurs dans l'annuaire Active Directory.
Ensuite, il faut rajouter l'élément <membership> après l'élément <authorization>.
<membership defaultProvider="monProviderAD">
<providers>
<add
name="monProviderAD"
type="System.Web.Security.ActiveDirectoryMembershipProvider, System.Web, Version=2.0.0.0,
Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
connectionStringName="ConnexionAD"
connectionUsername="bertranddomain\administrator"
connectionPassword="adminpasswd"/>
</providers>
</membership>
Dans cet élément, nous ajoutons un fournisseur dont on précise plusieurs choses :
- Le nom
- Le type : System.Web.Security.ActiveDirectoryMembershipProvider
- Le nom de la connectionString à laquelle se réferrer : celle que l'on a créé plus haut (ConnexionAD)
- Le nom du compte avec lequel se connecter sur l'annuaire Active Directory: connectionUsername="bertranddomain\administrator"
- Le mot de passe correspondant au compte expliqué ci-dessus : connectionPassword="adminpasswd"
Attention à bien définir le defaultProvider à la valeur du nom de celui que l'on vient de créer.
Pour se connecter à l'annuaire Active Directory, ActiveDirectoryMemberShip utilise le compte indiqué dans le provider que l'on a créé ci-dessus.
Comme pour la première méthode que j'avais utilisé pour implémenter l'authentification à un annuaire Active Directory, il ne faut pas oublier de configurer l'application pour accepter l'authentification par formulaire.
Voilà, désormais, pour vous connecter à l'application et être authentifié grâce à l'annuaire Active Directory, il vous suffit d'utiliser un compte actif de l'annuaire.
[.NET]Authentification grâce à un annuaire Active Directory
Pour la conception d'une application d'entreprise, il est possible que vous ayez besoin de gérer l'authentification des utilisateurs. Pour éviter de recréer une base de données d'utilisateurs propre à votre application, il peut être utile d'utiliser l'annuaire Active Directory contenant les utilisateurs de l'entreprise.
Nous allons donc voir comment il est possible d'utiliser ce système :
En tout premier lieu, il faut ajouter la référence System.DirectoryServices à votre projet :
Il faut ensuite configurer l'application afin qu'elle accepte l'authentification par formulaire ainsi que le nom du formulaire permettant l'authentification :
<authentication mode="Forms">
<forms loginUrl="Login.aspx" name="AuthCookieAD" timeout="120" path="/">
</forms>
</authentication>
Puis il faut configurer les autorisations pour les différents types d'utilisateurs (authentifiés, anonymes,...) :
<authorization>
<allow users="*"/>
<deny users="?"/>
</authorization>
Ici, nous acceptons seulement les utilisateurs authentifiés. Les utilisateurs anonymes seront redirigés vers la page de login précisée dans l'authentification réalisée ci-dessus.
Désormais, l'application est configurée pour accepter l'authentification par formulaire, il ne reste plus qu'à développer l'authentification à un annuaire Active Directory.
Pour mettre en oeuvre une authentification à un annuaire Active Directory, il faut tout d'abord inclure le namespace suivant :
using System.DirectoryServices;
Ensuite il faut créer une entrée LDAP :
DirectoryEntry entry = new DirectoryEntry(domainName, userName,userPasswd, authenticationType);
Les paramètres spécifiés sont les suivants :
- Le nom de domaine (string)auquel se connecter : "LDAP://" + nomdudomaine
- Le nom d'utilisateur (string)avec lequel se connecter
- Le mot de passe (string)correspondant à l'utilisateur avec lequel on se connecte
- Le type d'authentification (AuthenticationTypes). Par exemple : AuthenticationTypes.Anonymous
AuthenticationTypes.Secure
AuthenticationTypes.SecureSocketsLayer
Nous allons pouvoir rechercher notre entrée dans l'annuaire Active Directory grâce à un "searcher" :
DirectorySearcher search = new DirectorySearcher(entry);
Il est possible de spécifier des options de recherche pour notre "searcher" :
Grâce à l'option ci-dessous, nous restreignons la recherche aux utilisateurs seulement.
search.Filter = "(objectClass=user)";
Nous allons spécifier aussi la profondeur de la recherche grâce à l'énumération SearchScope. Cette énumération possède 3 valeurs :
- SearchScope.Base : Limite la recherche à l'objet de base. Ne retourne qu'une valeur.
- SearchScope.OneLevel : Recherche les objets enfants immédiats de l'objet de base mais exclut l'objet de base.
- SearchScope.Subtree : Effectue une recherche dans l'intégralité du sous-arbre, en prenant en compte tous ses enfants et l'objet de base.
search.SearchScope = SearchScope.Subtree;
Une fois que l'on a paramétré notre recherche, il faut en récupérer le résultat. Pour cela, on nous allons créer un
SearchResult.
SearchResult result = search.FindOne();
Nous ne récupérons que le premiere entrée trouvée. Il est aussi possible de récupérer toutes les entrées grâce à la méthode FindAll() qui retourne une SearchResultCollection.
Si la recherche ne contient aucun résultat, c'est que l'utilisateur n'existe pas et qu'il ne peut donc pas être authentifié.
Pour conclure, voici un exemple de fonction que vous pouvez implémenter pour identifier un utilisateur :
public bool IsAuthenticated(string username, string passwd,ref Exception ex)
{
try
{
DirectoryEntry entry = new DirectoryEntry("LDAP://" + _domain, username, passwd, AuthenticationTypes.Secure);
DirectorySearcher search = new DirectorySearcher(entry);
search.Filter = "(objectClass=user)";
search.SearchScope = SearchScope.Subtree;
SearchResult result = search.FindOne();
return (result != null);
}
catch (Exception e)
{
ex = e;
return false;
}
}