MSDN Tips & Tricks

  • Articolo

I consigli degli esperti italiani per sfruttare al meglio gli strumenti di sviluppo e semplificare l’attività quotidiana.
In questa pagina

Team Foundation Server: Limitare i valori nel campo Assigned To dei Work Item con il Process Template Editor Team Foundation Server: Limitare i valori nel campo Assigned To dei Work Item con il Process Template Editor
Visual Studio Team System: Effettuare il Code Coverage da linea di comando Visual Studio Team System: Effettuare il Code Coverage da linea di comando
Usare la fotocamera con C# Usare la fotocamera con C#
Utilizzare i convertitori di valori nel binding di WPF Utilizzare i convertitori di valori nel binding di WPF

Team Foundation Server: Limitare i valori nel campo Assigned To dei Work Item con il Process Template Editor

Di Lorenzo Barbieri - Microsoft MVP

Team Foundation Server permette di gestire i Work Item tramite i comandi WitImport e WitExport (disponibili solo da riga di comando, dopo aver installato il Team Explorer sulla macchina).

Questi comandi permettono di scaricare dal server la definizione di un Work Item in formato XML, e di reimportarla sul server una volta che il Work Item è stato modificato.

Una delle modifiche più richieste ai Work Item è la possibilità di filtrare i valori presenti nel campo “Assigned To” del Work Item, che di default include tutti gli utenti che possono accedere al Team Foundation Server.

Esiste un articolo (disponibile sia in , sia in ) che mostra come usare i comandi WitImport e WitExport per modificare il comportamento del campo “Assigned To”. L’utilizzo di questi comandi richiede però la modifica manuale del file XML, modifica che non è più necessaria se si utilizza il Process Template Editor incluso nei Team Foundation Server Power Tools, scaricabili da qui (in inglese).

Il Process Template Editor è un tool che permette di modificare il Template con cui vengono creati i Team Project di Team Foundation Server, ma permette anche di collegarsi ad un Team Project esistente per modificarne i Work Item e le altre impostazioni (Figura 1).

*

Selezionando “Open WIT from Server” viene richiesto il server da usare, e poi viene richiesto di selezionare il Work Item del Team Project che ci interessa (Figura 2).

*

Nel caso dovessimo ripetere la modifica su più Team Project, conviene esportare il Work Item con il comando “Export WIT”, modificandolo lavorando con il comando “Open WIT from File”, e poi importando il Work Item in tutti i Team Project coinvolti con il comando “Import WIT”.

La procedura di modifica del Work Item però rimane la stessa.

Una volta caricato il Work Item, si deve scorrere fino al campo “Assigned To”, e bisogna premere “Open” (Figura 3).

*

Figura 3

Si va poi sulla sezione “Rules”, dove troviamo l’elemento VALIDUSER (Figura 4), che corrisponde all’omonimo elemento nel file XML di descrizione del Work Item, documentato qui (in inglese).

L’elemento VALIDUSER indica che in questo campo sono validi tutti gli utenti registrati sul Team Foundation Server, indipendentemente dal progetto sul quale sono assegnati.

*

Figura 4

Per limitare gli utenti a cui può essere assegnato il Work Item, bisogna prima di tutto eliminare l’elemento VALIDUSER, e poi aggiungere un nuovo elemento come mostrato in Figura 5:

*

Figura 5

Tra tutte le regole disponibili per tutti i casi (che il Process Template Editor non filtra) in questo contesto si può scegliere tra:

  • ALLOWEDVALUES – che limita la scelta ai soli utenti e gruppi in essa contenuti

  • SUGGESTEDVALUES – che permette all’utente di scegliere gli utenti in essa contenuti o di inserire un utente a mano

  • PROHIBITEDVALUES - che impedisce all’utente di selezionare gli utenti o i gruppi in essa contenuti (e che può essere usata in congiunzione con una delle altre due)

Per limitare, ad esempio, la scelta solo agli utenti del gruppo Contributors del Team Project, si può selezionare ALLOWEDVALUES e aggiungere l’elemento “[project]\Contributors” (come mostrato in Figura 6). Si noti l’uso di “[project]” al posto del nome corrente, in questo modo è possibile riutilizzare la definizione del Work Item anche in altri progetti.

*

Figura 6

Bisogna poi ricordarsi di selezionare le opzioni “Expand Item” e “Exclude Groups”, per far espandere nella Combo Box tutti gli utenti appartenenti al gruppo e per non far comparire nella Combo Box il nome del gruppo stesso (Figura 7).

*

Figura 7

A questo punto si può premere Ok e ritornare alla schermata di definizione del Work Item, dove si può premere “View XML” per vedere la definizione risultante (Figura 8).

*

Figura 8

A questo punto basta salvare il Work Item modificato (Figura 9) per poterlo provare.

*

Figura 9

Prima però, se i gruppi sono ancora quelli di default, bisogna aggiungere degli utenti al gruppo Contributors del Team Project, selezionando “Team Project Settings->Group Membership” dal menu contestuale del Team Project (Figura 10).

*

Figura 10

E’ possibile quindi selezionare il gruppo Contributors, e aggiungergli ad esempio l’utente “TFSRTM\CIO” (Figura 11).

*

Figura 11

A questo punto creando il Work Item l’unico valore presente nella Combo Box rimane proprio l’utente CIO (Figura 12). Cercando di inserire un utente non presente nel gruppo, non sarà possibile salvare il Work Item (Figura 13).

*

Figura 12

*

Figura 13

 

Visual Studio Team System: Effettuare il Code Coverage da linea di comando

Di Lorenzo Barbieri - Microsoft MVP

Visual Studio Team System include (nelle edizioni Software Developer, Software Tester e Team Suite) la funzionalità di Code Coverage che mostra quante e quali righe di codice sono state effettivamente eseguite durante una sessione di test.

La funzionalità è integrata in Visual Studio e può essere abilitata editando il file localtestrun.testrunconfig che viene inserito nella soluzione appena si crea un progetto di test (Figura 1).

*

Figura 1

E’ possibile selezionare quali Assembly vanno instrumentati (ovvero modificati per raccogliere le informazioni sulla copertura del codice).

Dopo aver eseguito i test è possibile vedere il risultato della copertura del codice direttamente dall’IDE di Visual Studio (Figura 2):

*

Figura 2

A volte però sarebbe utile poter disporre di queste informazioni anche su macchine di produzione, o sulle macchine degli utenti, senza dover installare tutto Visual Studio, e magari senza avere i sorgenti a portata di mano.

E’ possibile installare gli strumenti da riga di comando della sezione “Performance” di Visual Studio (che includono anche il Code Coverage) installando il file vs_profiler.exe nella cartella wcu del CD/DVD di Visual Studio.

A questo punto si può in strumentare manualmente gli Assembly che vanno testati utilizzando il comando:

vsinstr –coverage nomeAssembly.exe (o .dll)

il commando va ripetuto per ogni Assembly di cui vogliamo le informazioni di Code Coverage.

Una volta instrumentati gli Assembly, bisogna abilitare la raccolta delle informazioni di Code Coverage con il comando:

start vsperfmon -coverage –output:fileCoverage.coverage

Verrà aperta un’altra shell di comando dove verrà eseguita la raccolta dei dati di Coverage.

A questo punto è possible eseguire il programma e testare le funzionalità richieste. E’ anche possibile (se lo si è installato) eseguire il comando mstest.exe per eseguire gli eventuali test automatizzati (unit test, generic test, etc…).

Una volta terminata la raccolta dei dati, bisogna terminare la raccolta dei dati con il comando:

vsperfcmd –shutdown

Per analizzare il file di Coverage, è sufficiente portarlo su una macchina con installato Visual Studio (in una delle edizioni compatibili) e aprirlo.

Maggiori informazioni sul comando vsinstr possono essere trovate qui. Maggiori informazioni sui comandi vsperfmon e vsperfcmd possono essere trovate qui e qui.

Maggiori informazioni sull’installazione dei componenti di Visual Studio e sulle condizioni di licenza possono essere trovate qui (in Inglese).

Per un’introduzione a tutti gli strumenti da riga di comando per la gestione delle Performance si veda qui (in Inglese). Per avere la risposta alle domande più comuni sul Code Coverage si veda qui (in Inglese).

 

Usare la fotocamera con C#

Di Michele Locuratolo - Microsoft MVP

A partire dalla versione 5.0 di Windows Mobile, il numero di API del sistema operativo esposte è notevolmente aumentato. Questo a tutto vantaggio degli sviluppatori che possono, in tempi rapidi e senza l’ausilio di librerie esterne, creare applicazioni sempre più ricche di funzionalità.

Tra le tante, una delle funzionalità molto richieste e particolarmente difficili da implementare, è l’utilizzo della fotocamera. Pensiamo ad esempio ad applicazioni il cui scopo è fare un rilievo di dati da accompagnare con una o più immagini. A partire da Windows Mobile 5.0 e dal .NET Compact Framework 2.0 possiamo procedere in questo modo:

  1. Aggiungiamo al progetto un riferimento alla libreria Microsoft.WindowsMobile.Forms

  2. Creiamo una istanza della classe CameraCaptureDialog

  3. Usiamo il nome dell’immagine per creare una bitmap con l’immagine scattata

  4. Usiamo la bitmap nell’applicazione

ref.JPG

Figura 1: aggiunta del riferimento

Codice:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Microsoft.WindowsMobile.Forms;

namespace MSDN.Tips.Camera {
    public partial class Form1 : Form {
        public Form1() {
            InitializeComponent();
        }

        /// <summary>
        /// Avvia la fotocamera e recupera l'immagine
        /// </summary>
        /// <returns>Bitmap</returns>
        private Bitmap GetCameraPicture() {
            string _imageName = string.Empty;
            CameraCaptureDialog cameraCapture = new CameraCaptureDialog();
            cameraCapture.Mode = CameraCaptureMode.Still; //Cattura la sola immagine
            cameraCapture.Resolution = new Size(120, 160); //Imposta la risoluzione
            cameraCapture.StillQuality = CameraCaptureStillQuality.Default; //Imposta la qualità
            if (cameraCapture.ShowDialog() == DialogResult.OK ) {
                _imageName = cameraCapture.FileName;
            }
            Bitmap photo = new Bitmap(_imageName);
            cameraCapture.Dispose();
            return photo;
        }

        private void menuItem1_Click( object sender, EventArgs e ) {
            Application.Exit();
        }

        private void menuItem2_Click( object sender, EventArgs e ) {
            pbImgPreview.Image = GetCameraPicture();
        }
    }
}

Il risultato sarà il seguente

resultJPG.JPG

Figura 2: l'imagine acquisita

Al seguente indirizzo http://www.dotnetside.org/r.ashx?5 è disponibile uno screencast che mostra l’intera procedura.

 

Utilizzare i convertitori di valori nel binding di WPF

Il motore di binding introdotto in Windows Presentation Foundation è molto potente e versatile. Permette di recuperare valori all'interno di grafi complessi di oggetti per poi associarli a proprietà di elementi e controlli. Nella maggior parte dei casi non occorre preoccuparsi del tipo del valore da recuperare e poi da assegnare, poiché il motore di binding è in grado di convertire la maggior parte dei tipi. Nel caso questa operazione non riesca, è possibile passare all'espressione di binding una classe che implementi IValueConverter. Quest'interfaccia dispone di due metodi: Convert e ConvertBack. Il primo deve convertire dal valore originale al tipo che la proprietà accetta, mentre il secondo esegue l'operazione al contrario, nel caso in cui il motore debba prendere un nuovo valore (per esempio, proveniente da una TextBox), per associarla poi all'oggetto di destinazione.

I Converter risultano inoltre molto utili anche per compiere operazioni di formattazione dei numeri e delle stringhe. Si può scrivere quindi un converter "standard" da usare in più occasioni. Inoltre se il converter restituisce la costante DependencyProperty.UnsetValue, il motore di binding provvede ad utilizzare la proprietà FallbackValue come valore alternativo. Ecco la classe:

C#
public class StringFormatConverter : IValueConverter
{
    private bool _nullToUnset;

    public bool NullToUnset
    {
        get { return _nullToUnset; }
        set { _nullToUnset = value; }
    }

    public object Convert(object value, Type targetType, object parameter, 
System.Globalization.CultureInfo culture)
    {
        // Se nullo restituisco Unset
        if (value == null)
            return DependencyProperty.UnsetValue;

        // Formatto la stringa
        string formatString = parameter as string;
        if (formatString != null)
            return string.Format(culture, formatString, value);
        else
            return value.ToString();
    }

    public object ConvertBack(object value, Type targetType,
        object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotSupportedException();
    }
}
VB
Public Class StringFormatConverter
    Implements IValueConverter

    Private _nullToUnset As Boolean

    Public Function Convert(ByVal value As Object, ByVal targetType As Type, ByVal parameter As Object, 
ByVal culture As CultureInfo) As Object
        If (value Is Nothing) Then
            Return DependencyProperty.UnsetValue
        End If
        Dim formatString As String = TryCast(parameter,String)
        If (Not formatString Is Nothing) Then
            Return String.Format(culture, formatString, value)
        End If
        Return value.ToString
    End Function

    Public Function ConvertBack(ByVal value As Object, ByVal targetType As Type, ByVal parameter As Object, 
ByVal culture As CultureInfo) As Object
        Throw New NotSupportedException
    End Function


    Public Property NullToUnset As Boolean
        Get
            Return Me._nullToUnset
        End Get
        Set(ByVal value As Boolean)
            Me._nullToUnset = value
        End Set
    End Property

End Class

L'utilizzo del converter è abbastanza semplice: occorre prima di tutto dichiarare la classe tra le risorse in modo da instanziarla una sola volta e di sfruttarla in più occasioni.