MSDN Tips & Tricks

Articolo
03/19/2008

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

Tips & Tricks di ottobre

In questa pagina

Utilizzare il provider per Access per Membership, Roles e Profile API di ASP.NET 2.0
Notificare una variazione di stato di un’applicazione in background
Forzare un Get Latest Version con Team Explorer e fare il Check In di file modificati quando si era offline
Implementazione idiomatica del pattern Strategy utilizzando i delegate

Utilizzare il provider per Access per Membership, Roles e Profile API di ASP.NET 2.0

Di Daniele Bochicchio

Dopo aver scaricato il provider per Membership, Roles e Profile API da qui, è necessario procedere alla corretta installazione. Queste funzionalità consentono, rispettivamente, di aggiungere la gestione degli utenti (login, iscrizione, etc), il supporto per i ruoli e per il profilo (nome, data di nascita, etc) ad un’applicazione web sfruttando un approccio dichiarativo, senza necessità di scrivere codice per le operazioni da implementare.

Il provider è distribuito come Starter Kit di tipo class library, per cui è necessario possedere Visual C# 2005 Express o Visual Studio 2005 Standard Edition o superiore. Basta creare un nuovo progetto da Visual Studio o Visual C# 2005 Express, quindi selezionare “ASP.NET Access Provider” dalla voce “Starter Kits”.

Il risultato della compilazione è un assembly che va poi copiato nella directory \bin\ del sito web a cui si vogliono aggiungere queste funzionalità, dopo aver copiato anche il web.config distribuito sempre insieme allo Starter Kit.

Successivamente sarà possibile utilizzare i controlli di Membership, Roles o Profile API come spiegato nella registrazione di questo webcast.

Notificare una variazione di stato di un’applicazione in background

Di Mauro Servienti

Ci sono situazioni in cui abbiamo la necessità di notificare all’utente che nella nostra applicazione qualcosa è cambiato, nella maggior parte dei casi ci sono svariate soluzioni per questo task, da una semplice MessageBox a un messaggio nella StatusBar dell’applicazione e via dicendo.

Nel caso in cui la nostra applicazione non sia quella in primo piano le soluzioni appena proposte sono tutto tranne che efficaci perchè deleghano all’utente l’onere di controllare lo stato dell’applicazione in attesa di notifiche.

Una possibilità interessante è quella di attirare l’attenzione dell’utente facendo lampeggiare la nostra applicazione nella TaskBar di Windows, per fare questo purtroppo il Famework.NET non ci dà nessun supporto, è però decisamente semplice raggiungere lo stesso obiettivo utilizzando le API di Windows via P/Invoke.

La funzione da usare è FlashWindowEx esportata da User32.dll, la cui dichiarazione in C# è:

        [DllImport( "user32.dll" )]
static extern bool FlashWindowEx
(
[MarshalAs( UnmanagedType.Struct )]
	ref FLASHWINFO pfwi 
);

La struttura FLASHWINFO è invece dichiarata così:

       [StructLayout( LayoutKind.Sequential )]
struct FLASHWINFO
{
	[MarshalAs( UnmanagedType.U4 )]
	public int cbSize;
	public IntPtr hwnd;
	[MarshalAs( UnmanagedType.U4 )]
	public int dwFlags;
	[MarshalAs( UnmanagedType.U4 )]
	public int uCount;
	[MarshalAs( UnmanagedType.U4 )]
	public int dwTimeout;
}

Si evince subito che per far “lampeggiare” la nostra applicazione sarà suifficiente un semplice codice come il seguente:

        const int FLASHW_STOP = 0;
const int FLASHW_CAPTION = 0x00000001;
const int FLASHW_TRAY = 0x00000002;
const int FLASHW_ALL = ( FLASHW_CAPTION | FLASHW_TRAY );
const int FLASHW_TIMER = 0x00000004;
const int FLASHW_TIMERNOFG = 0x0000000C;

FLASHWINFO fi = new FLASHWINFO();
fi.cbSize = Marshal.SizeOf( typeof( FLASHWINFO ) );
// L'handle della finestra di cui eseguire il “flashing”
fi.hwnd = myWindowHandle;
//Come eseguire il flashing
fi.dwFlags = FLASHW_TRAY;
//Per quante volte
fi.uCount = 100;
/*
 Se non si imposta il timeout (che in realtà corrisponde al Blink rate)
 viene preso quello di default. Il valore è espresso in millisecondi,
 il default è 0, quindi usa quello dell'OS
*/
fi.dwTimeout = 0;
//Eseguiamo
FlashWindowEx( ref fi );

Per fermare il “flashing” è sufficiente richiamare lo stesso codice passando FLASHW_STOP al posto di FLASHW_TRAY.

Per ulteriori informazioni:

Forzare un Get Latest Version con Team Explorer e fare il Check In di file modificati quando si era offline

Di Lorenzo Barbieri

A volte il Get Latest Version di Team Explorer sembra non funzionare. Questo comportamento apparentemente inspiegabile è dovuto al fatto che se le modifiche ai file vengono fatte senza utilizzare i tool appositi (TF.EXE, MSSCCI Provider per Visual Studio 6/.NET, etc...) queste non vengono rilevate da Team Explorer che non scaricherà i file dal Server credendo di avere già l’ultima versione all’interno del Workspace.

Per forzare lo scaricamento dei file dal Server è necessario utilizzare il comando Get Specific Version al posto del comando Get Latest Version:

Get Specific Version

Una volta invocato bisogna selezionare Latest Version come versione da scaricare e bisogna impostare Force get of file versions already in workspace.

Latest Version

E’ possibile forzare la sovrascrittura dei file modificati senza averne fatto il Check Out utilizzando l’opzione Overwrite writeable files that are not checked out.

E’ anche possibile inserire questi file sul server utilizzando il comando TFPT.EXE ONLINE che fa parte dei PowerToys di Team Foundation Server, che possono essere scaricati qui.

Se alcuni file sono stati cancellati, bisogna usare TFPT.EXE ONLINE /DELETE. Attenzione che questo tool non gestisce le operazioni di rinomina di file effettuate senza usare Team Explorer.

Implementazione idiomatica del pattern Strategy utilizzando i delegate

Di Riccardo Golia

Uno dei più noti ed usati design pattern della famiglia dei GoF (Gang of Four) è senza dubbio lo Strategy, pattern comportamentale che permette di definire un insieme di algoritmi (strategie concrete), incapsularli e renderli intercambiabili tra di loro, indipendentemente dal contesto di chiamata. Lo Strategy consente in questo modo agli algoritmi di variare indipendentemente dai client che ne fanno uso.

L'implementazione classica del pattern in questione fa uso di interfacce o classi astratte per definire il contratto base per ogni tipo di strategia concreta. Questo approccio è schematizzato in figura.

Secondo l'approccio basato su interfacce, la classe Context carica la strategia concreta di interesse utilizzando un riferimento di tipo IStrategy ed esegue l'algoritmo associato alla strategia caricata nell'ambito del metodo corrispondente di Context, disaccoppiando e isolando dal client l'algoritmo eseguito.

[C#]

       using System;

namespace Microsoft.MsdnItaly.Tips.Architecture.Strategy.Interface
{
    public interface IStrategy
    {
        string Print(string text);
    }
    
    public class ConcreteStrategy : IStrategy
    {
        public string Print(string text)
        {
            if (text == null)
                throw new ArgumentNullException("text");
            return text;
        }
    }
    
    public class Context
    {
        private IStrategy _strategy;

        public Context(IStrategy strategy)
        {
            if (strategy == null)
                throw new ArgumentNullException("strategy");
            _strategy = strategy;
        }
        
        public string Print(string text)
        {
            return _strategy.Print(text);
        }
    }

    public class StrategyWithInterface
    {
        public static void Main(string[] args)
        {
            IStrategy strategy = new ConcreteStrategy();
            Console.WriteLine(new Context(strategy).Print("Hello, World!"));
            Console.ReadLine();
        }
    }
}

[Visual Basic]

       Imports System

Namespace Microsoft.MsdnItaly.Tips.Architecture.Strategy.Interface

    Public Interface IStrategy

        Function Print(ByVal text As String) As String

    End Interface

    Public Class ConcreteStrategy
        Implements IStrategy

        Public Function Print(ByVal text As String) As String Implements IStrategy.Print
            If (text Is Nothing) Then Throw New ArgumentNullException("text")
            Return text
        End Function

    End Class

    Public Class Context

        Private _strategy As IStrategy

        Public Sub New(ByVal strategy As IStrategy)
            If (strategy Is Nothing) Then Throw New ArgumentNullException("strategy")
            _strategy = strategy
        End Sub

        Public Function Print(ByVal text As String) As String
            Return _strategy.Print(text)
        End Function

    End Class

    Public Class StrategyWithInterface

        Public Shared Sub Main(ByVal args As String())
            Dim strategy As IStrategy = New ConcreteStrategy()
            Console.WriteLine(New Context(strategy).Print("Hello, World!"))
            Console.ReadLine()
        End Sub

    End Class

End Namespace

Un approccio alternativo di natura idiomatica per implementare il pattern Strategy fa uso dei delegate al posto delle interfacce. Di fatto un delegate è un tipo che definisce un contratto basato sulla firma di un metodo. Pertanto, definendo un delegato come contratto base per la strategia da eseguire, è possibile utilizzarlo per associare in modo dinamico un metodo specifico che rispetti la firma ed esegua l'elaborazione.