[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] Profiler ses applications WPF
Ayant développé une application WPF que je trouvai très gourmande en ressources, j’ai eu à profiler celle-ci afin de savoir précisément quelles animations ou quels composants consommaient trop de ressources.
Pour cela, un outil très performant et très puissant m’a permis de réaliser cela : la WPF Performance Suite présent dans le SDK de Windows.
Pour vous éviter d’avoir à télécharger tout le SDK voici le msi directement téléchargeable ici.
Cette application se compose de plusieurs fonctionnalités de profilage organisable par onglets :
Le premier onglet contenant l’application Perforator va vous permettre d’analyser le rendu de votre application : vous pourrez observer le rafraichissement de vos animations, le nombre de frames/seconde, etc…
La seconde application est Visual Profiler. Cette application va vous permettre de profiler les services WPF permettant la gestion des évènements et la disposition des éléments dans votre application.
Je ne présenterai que l’application Perforator qui m’a le plus aidé dans mon cas. Pour les autres applications, je vous conseille l’article de la msdn qui est très bien fait à ce sujet.
Perforator vous permet, par exemple, en temps réel, de modifier les paramètres de rendu de votre application afin d’observer les fluctuations que cela apporte. De plus, chose très intéressante dans mon cas, les rafraichissement de chaque composant de votre application est mis en avant grâce à une coloration de ces composants. A chaque rafraichissement du composant, celui-ci change de couleur. Pour cela, il faut activer l’option : “Show dirty region update overlay”. Voici ce que l’on observe :
En passant sur un des boutons, on déclenche une animation et la zone d’animation se colore d’une couleur différente à chaque rafraichissement, c’est-à-dire très rapidement !
On peut donc facilement observer les animations consommatrices de ressources par exemple.
Ces outils sont donc très puissants et je vous recommande de lire l’article de la msdn que j’ai précité plus haut pour avoir une vision complète de tout ce qu'il est possible de visualiser à l'aide de cette d'outils. Je n’ai en effet délibérément présenté qu’une des nombreuses fonctionnalités de cette suite.
[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.