Procedura dettagliata: utilizzo di servizi delle applicazioni client
In questo argomento viene descritto come creare un'applicazione Windows che utilizza i servizi delle applicazioni client per autenticare gli utenti e recuperare impostazioni e ruoli utente.
Questa procedura dettagliata prevede l'esecuzione delle attività seguenti:
Creare un'applicazione Windows Form e utilizzare Progettazione progetti di Visual Studio per attivare e configurare i servizi delle applicazioni client.
Creare una semplice applicazione servizio Web ASP.NET per l'hosting dei servizi delle applicazioni e il testing della configurazione client.
Aggiungere l'autenticazione basata su form all'applicazione. Si inizierà utilizzando un nome utente e una password specificati a livello di codice (hard-coded) per testare il servizio. Si proseguirà quindi aggiungendo un form di accesso specificandolo come provider di credenziali nella configurazione dell'applicazione.
Aggiungere la funzionalità basata sui ruoli, attivando e visualizzando un pulsante solo per gli utenti nel ruolo "amministratore".
Accedere alle impostazioni Web. Si inizierà con il caricamento delle impostazioni Web di un utente (test) autenticato nella pagina Impostazioni di Progettazione progetti. Si proseguirà quindi con l’utilizzo di Progettazione Windows Form per associare una casella di testo a un'impostazione Web. Infine si salverà il valore modificato nuovamente sul server.
Implementare la disconnessione. Si aggiungerà un'opzione di disconnessione al form e si chiamerà un metodo di disconnessione.
Attivare la modalità offline. Si fornirà una casella di controllo che consenta agli utenti di specificare lo stato della connessione. Si utilizzerà quindi questo valore per specificare se i provider di servizi delle applicazioni client dovranno utilizzare localmente i dati memorizzati nella cache anziché accedere ai servizi Web. Infine si autenticherà di nuovo l'utente corrente dopo che l'applicazione torna in modalità online.
Prerequisiti
Per completare questa procedura dettagliata, è necessario disporre del seguente componente:
- Visual Studio 2008.
Creazione dell'applicazione client
È innanzitutto necessario creare un progetto Windows Form. In questa procedura dettagliata vengono utilizzati i Windows Form perché familiari a più persone. Il processo è tuttavia simile per i progetti Windows Presentation Foundation (WPF).
Per creare un'applicazione client e attivare i servizi dell'applicazione client
In Visual Studio, selezionare l'opzione di menu File | Nuovo | Progetto.
Nel riquadro Tipi progetto della finestra di dialogo Nuovo progetto espandere il nodo Visual Basic o Visual C#, quindi selezionare il tipo di progetto Windows.
Assicurarsi che l'opzione .NET Framework 3.5 sia selezionata, quindi selezionare il modello Applicazione Windows Form.
Specificare ClientAppServicesDemo per il Nome del progetto, quindi scegliere OK.
In Visual Studio verrà aperto un nuovo progetto Windows Form
Scegliere Proprietà di ClientAppServicesDemo dal menu Progetto.
Verrà visualizzata la finestra Progettazione progetti.
Nella scheda Servizi selezionare Attiva servizi applicazioni client.
Assicurarsi che l'opzioneUsa autenticazione basata su form sia selezionata, quindi impostare Percorso servizio di autenticazione, Percorso servizi ruolie Percorso servizi impostazioni Web su https://localhost:55555/AppServices.
In Visual Basic, selezionare la scheda Applicazione e scegliere Definita dall'applicazione per Modalità di autenticazione.
Le impostazioni specificate nel file app.config dell'applicazione vengono archiviate nella finestra di progettazione.
A questo punto l'applicazione è configurata per accedere a tutti e tre i servizi dallo stesso host. Nella sezione successiva si creerà l’host come semplice applicazione servizio Web in modo che sia possibile testare la configurazione client.
Creazione dell'host per i servizi delle applicazioni
In questa sezione verrà creata una semplice applicazione servizio Web in grado di accedere ai dati dell'utente da un file di database SQL Server Compact 3.5 locale. Il database verrà quindi popolato mediante l'oggetto Strumento di amministrazione sito Web di ASP.NET. Questa semplice configurazione consente di testare rapidamente l'applicazione client. In alternativa, è possibile configurare l'host del servizio Web per accedere ai dati dell'utente da un database SQL Server completo o mediante le classi personalizzate MembershipProvider e RoleProvider. Per ulteriori informazioni, vedere Creazione e configurazione del database dei servizi per le applicazioni per SQL Server.
Nella procedura descritta di seguito viene creato e configurato il servizio Web di AppServices.
Per creare e configurare l'host dei servizi delle applicazioni
In Esplora soluzioni selezionare la soluzione ClientAppServicesDemo, quindi scegliere Aggiungi | Nuovo progetto dal menu File.
Nel riquadro Tipi progetto della finestra di dialogo Aggiungi nuovo progetto espandere il nodo Visual Basic o Visual C#, quindi scegliere il tipo di progetto Web.
Assicurarsi che l'opzione .NET Framework 3.5 sia selezionata, quindi selezionare il modello Applicazione servizio Web ASP.NET.
Specificare AppServices per il Nome del progetto, quindi scegliere OK.
Viene aggiunto un nuovo progetto di applicazione del servizio Web ASP.NET alla soluzione e nell'editor viene visualizzato il file Service1.asmx.vb o Service1.asmx.cs.
Nota
Il file Service1.asmx.vb o Service1.asmx.cs in questo esempio non viene utilizzato. È possibile chiuderlo ed eliminarlo da Esplora soluzioni per non ingombrare l'ambiente di lavoro.
In Esplora soluzioni selezionare il progetto AppServices, quindi scegliere Proprietà di AppServices dal menu Progetto.
Verrà visualizzata la finestra Progettazione progetti.
Nella scheda Web verificare che l'opzione Usa Visual Studio Development Server sia selezionata.
Selezionare Porta specifica, specificare il valore 55555, quindi specificare /AppServices per Percorso virtuale.
Salvare tutti i file.
In Esplora soluzioni aprire il file Web.config e individuare il tag di apertura <system.web>.
Aggiungere il seguente markup prima del tag <system.web>.
Gli elementi authenticationService, profileService e roleService in questo markup attivano e configurano i servizi delle applicazioni. Ai fini dell'esecuzione del test, l'attributo requireSSL dell'elemento authenticationService è impostato su "false". Gli attributi readAccessProperties e writeAccessProperties dell'elemento profileService indicano che la proprietà WebSettingsTestText è di lettura/scrittura.
Nota
Nel codice di produzione è consigliabile accedere al servizio di autenticazione sempre tramite SSL (Secure Sockets Layer) utilizzando il protocollo HTTPS. Per informazioni sulla configurazione di SSL, vedere Configuring Secure Sockets Layer (IIS 6.0 Operations Guide) (informazioni in lingua inglese).
<system.web.extensions> <scripting> <webServices> <authenticationService enabled="true" requireSSL = "false"/> <profileService enabled="true" readAccessProperties="WebSettingsTestText" writeAccessProperties="WebSettingsTestText" /> <roleService enabled="true"/> </webServices> </scripting> </system.web.extensions>Aggiungere il seguente markup dopo il tag di apertura <system.web> in modo che venga incluso nell'elemento <system.web>.
L'elemento profile configura una sola impostazione Web denominata WebSettingsTestText.
<profile enabled="true" > <properties> <add name="WebSettingsTestText" type="string" readOnly="false" defaultValue="DefaultText" serializeAs="String" allowAnonymous="false" /> </properties> </profile>
Nella procedura riportata di seguito, si utilizza lo strumento Amministrazione sito Web di ASP.NET per completare la configurazione del servizio e popolare il file di database locale. Vengono aggiunti due utenti a cui sono assegnati i nomi di dipendente e amministratore e i due ruoli corrispondenti. Le password utente sono rispettivamente dipendente! e amministratore!.
Per configurare l'appartenenza e i ruoli
In Esplora soluzioni, selezionare il progetto AppServices, quindi scegliere Configurazione ASP.NET dal menu Progetto.
Viene visualizzato lo Strumento Amministrazione sito Web di ASP.NET.
Nella scheda Sicurezza, scegliere Utilizzare la Configurazione guidata sicurezza per configurare la sicurezza mediante passaggi successivi.
La Configurazione guidata sicurezza si apre e viene visualizzato il passaggio Introduzione.
Scegliere Avanti.
Viene visualizzato il passaggio Selezione del metodo di accesso.
Selezionare Da Internet. Il servizio viene configurato in modo da utilizzare l'autenticazione basata su form anziché l'autenticazione di Windows.
Scegliere Avanti per due volte.
Viene visualizzato il passaggio Definizione dei ruoli.
Selezionare Attivare i ruoli per il sito Web.
Scegliere Avanti. Viene visualizzato il form Crea nuovo ruolo.
Nella casella di testo Nuovo nome ruolo, digitare amministratore e scegliere quindi Aggiungi ruolo.
Viene visualizzata la tabella Ruoli esistenti con il valore specificato.
Nella casella di testo Nuovo nome ruolo, sostituire amministratore con dipendente e selezionare quindi Aggiungi ruolo.
Il nuovo valore viene visualizzato nella tabella Ruoli esistenti.
Scegliere Avanti.
Viene visualizzato il passaggio Aggiunta di nuovi utenti.
Nel form Crea utente specificare i valori seguenti.
Nome utente
amministratore
Password
amministratore!
Conferma password
amministratore!
Posta elettronica
amministratore@contoso.com
Domanda segreta
amministratore
Risposta segreta
amministratore
Fare clic su Crea utente.
Viene visualizzato un messaggio che indica l'esito positivo dell'operazione.
Nota
Nel form è richiesta l'immissione dei valori Posta elettronica, Domanda segreta e Risposta segreta; in questo esempio tuttavia questi valori non vengono utilizzati.
Scegliere Continua.
Viene visualizzato nuovamente il form Crea utente.
Nel form Crea utente specificare i valori seguenti.
Nome utente
dipendente
Password
dipendente!
Conferma password
dipendente!
Posta elettronica
dipendente@contoso.com
Domanda segreta
Dipendente
Risposta segreta
dipendente
Fare clic su Crea utente.
Viene visualizzato un messaggio che indica l'esito positivo dell'operazione.
Scegliere Fine.
Viene visualizzato nuovamente lo Strumento Amministrazione sito Web di ASP.NET.
Scegliere Utenti amministratore.
Viene visualizzato l'elenco degli utenti.
Selezionare Modifica ruoli per l'utente dipendente e scegliere quindi il ruolo dipendente.
Selezionare Modifica ruoli per l'utente amministratore e scegliere quindi il ruolo amministratore.
Chiudere la finestra del browser contenente Strumento Amministrazione sito Web.
Se viene visualizzata una finestra di messaggio in cui viene chiesto se si desidera ricaricare il file Web.config modificato, fare clic su Sì.
Questo completa la configurazione del servizio Web. A questo punto è possibile premere F5 per eseguire l'applicazione client insieme alla quale verrà automaticamente avviato il Server di sviluppo ASP.NET. Il server rimarrà in esecuzione dopo la chiusura dell'applicazione, ma verrà riavviato al riavvio di quest'applicazione. In questo modo è possibile rilevare tutte le modifiche apportate al file Web.config.
Per arrestare manualmente il server, fare clic con il pulsante destro del mouse sull'icona di Server di sviluppo ASP.NET nell'area di notifica della barra delle applicazioni, quindi scegliere Arresta. Questa operazione è talvolta utile per assicurarsi che il riavvio venga eseguito correttamente.
Aggiunta dell'autenticazione basata su form
Nella seguente procedura si aggiungerà il codice al form principale che tenta di convalidare l'utente e nega l'accesso quando l'utente specifica credenziali non valide. Si utilizzeranno un nome utente e una password specificati a livello di codice per testare il servizio.
Per convalidare l'utente nel codice dell'applicazione
Nel progetto ClientAppServicesDemo in Esplora soluzioni aggiungere un riferimento all'assembly System.Web.
Selezionare il file Form1, quindi scegliere Visualizza | Codice dal menu principale di Visual Studio.
Nell'editor del codice aggiungere le seguenti istruzioni all'inizio del file Form1.
Imports System.Net Imports System.Threading Imports System.Web.ClientServices Imports System.Web.ClientServices.Providers Imports System.Web.Securityusing System.Net; using System.Threading; using System.Web.ClientServices; using System.Web.ClientServices.Providers; using System.Web.Security;In Esplora soluzioni fare doppio clic su Form1 per visualizzare la finestra di progettazione.
Nella finestra di progettazione fare doppio clic nell'area del form per generare un gestore eventi Form.Load denominato Form1_Load.
Verrà visualizzato il cursore nel metodo Form1_Load all'interno dell'editor del codice.
Aggiungere al metodo Form1_Load il seguente codice.
Questo codice nega l'accesso agli utenti non autenticati chiudendo l'applicazione. In alternativa, è possibile consentire agli utenti non autenticati di accedere al form ma non a specifiche funzionalità. Generalmente non è necessario specificare a livello di codice il nome utente e la password, tuttavia questa operazione è utile a scopo di test. Nella sezione successiva si sostituirà questo codice con un codice più affidabile che visualizza una finestra di dialogo di accesso e include la gestione delle eccezioni.
Si noti che il metodo static Membership.ValidateUser è incluso in .NET Framework versione 2.0. Questo metodo delega il lavoro al provider di autenticazione configurato e restituisce true se l'autenticazione viene eseguita correttamente. L'applicazione non richiede un riferimento diretto al provider di autenticazione del client.
If Not Membership.ValidateUser("manager", "manager!") Then MessageBox.Show("Unable to authenticate.", "Not logged in", _ MessageBoxButtons.OK, MessageBoxIcon.Error) Application.Exit() End Ifif (!Membership.ValidateUser("manager", "manager!")) { MessageBox.Show("Unable to authenticate.", "Not logged in", MessageBoxButtons.OK, MessageBoxIcon.Error); Application.Exit(); }
È ora possibile premere F5 per eseguire l'applicazione. Poiché sono stati specificati un nome utente e una password corretti, è possibile vedere il form.
Nota
Se non si è in grado di eseguire l'applicazione, provare ad arrestare il server di sviluppo ASP.NET. Al riavvio del server verificare che la porta sia impostata su 55555.
Per visualizzare invece il messaggio di errore, modificare i parametri ValidateUser. Sostituire ad esempio il secondo parametro "manager!" con una password incorretta quale "MANAGER".
Aggiunta di un form di accesso come provider di credenziali
È possibile acquisire le credenziali utente nel codice dell'applicazione e passarli al metodo ValidateUser. Tuttavia, è spesso utile separare il codice di acquisizione delle credenziali da quello dell'applicazione, qualora dovesse essere necessario modificarlo in seguito.
Nella procedura descritta di seguito si configurerà l'applicazione per utilizzare un provider di credenziali e quindi si modificherà la chiamata al metodo ValidateUser in modo da passare Empty per entrambi i parametri. Le stringhe vuote indicano al metodo ValidateUser di chiamare il metodo GetCredentials del provider di credenziali configurato.
Per configurare l'applicazione in modo da utilizzare un provider di credenziali
In Esplora soluzioni selezionare il progetto ClientAppServicesDemo, quindi scegliere Proprietà di ClientAppServicesDemo dal menu Progetto.
Verrà visualizzata la finestra Progettazione progetti.
Nella scheda Servizi impostare il valore seguente per Facoltativo: provider di credenziali. Questo valore indica il nome di tipo completo dell'assembly.
ClientAppServicesDemo.Login, ClientAppServicesDemoNel file di codice Form1 sostituire il codice nel metodo Form1_Load con il seguente codice.
Questo codice visualizza un messaggio di benvenuto e quindi chiama il metodo ValidateUsingCredentialsProvider che si aggiungerà nel passaggio successivo. Se l'utente non è autenticato, il metodo ValidateUsingCredentialsProvider restituisce false mentre il metodo Form1_Load restituisce. In questo modo si evita l'esecuzione di codice aggiuntivo prima di uscire dall'applicazione. Il messaggio di benvenuto è utile per capire quando viene riavviata l'applicazione. Si aggiungerà codice per riavviare l'applicazione quando si implementerà la disconnessione più avanti in questa procedura dettagliata.
MessageBox.Show("Welcome to the Client Application Services Demo.", _ "Welcome!") If Not ValidateUsingCredentialsProvider() Then ReturnMessageBox.Show("Welcome to the Client Application Services Demo.", "Welcome!"); if (!ValidateUsingCredentialsProvider()) return;Aggiungere il seguente metodo dopo il metodo Form1_Load.
Questo metodo passa stringhe vuote al metodo static Membership.ValidateUser in modo che venga visualizzata la finestra di dialogo Accesso. Se il servizio di autenticazione non è disponibile, il metodo ValidateUser genererà un'eccezione WebException. In questo caso, il metodo ValidateUsingCredentialsProvider visualizza un messaggio di avviso e chiede se l'utente desidera riprovare in modalità offline. Questa funzionalità richiede che la funzione Salva hash della password localmente per consentire l'accesso offline, descritta in Procedura: configurare i servizi delle applicazioni client, sia selezionata. Questa funzionalità è attivata per impostazione predefinita per i nuovi progetti.
Se l'utente non è convalidato, il metodo ValidateUsingCredentialsProvider visualizza un messaggio di errore e chiude l'applicazione. Quindi, restituisce il risultato del tentativo di autenticazione.
Private Function ValidateUsingCredentialsProvider() As Boolean Dim isAuthorized As Boolean = False Try ' Call ValidateUser with empty strings in order to display the ' login dialog box configured as a credentials provider. isAuthorized = Membership.ValidateUser( _ String.Empty, String.Empty) Catch ex As System.Net.WebException If DialogResult.OK = MessageBox.Show( _ "Unable to access the authentication service." & _ Environment.NewLine & "Attempt login in offline mode?", _ "Warning", MessageBoxButtons.OKCancel, _ MessageBoxIcon.Warning) Then ConnectivityStatus.IsOffline = True isAuthorized = Membership.ValidateUser( _ String.Empty, String.Empty) End If End Try If Not isAuthorized Then MessageBox.Show("Unable to authenticate.", "Not logged in", _ MessageBoxButtons.OK, MessageBoxIcon.Error) Application.Exit() End If Return isAuthorized End Functionprivate bool ValidateUsingCredentialsProvider() { bool isAuthorized = false; try { // Call ValidateUser with empty strings in order to display the // login dialog box configured as a credentials provider. isAuthorized = Membership.ValidateUser( String.Empty, String.Empty); } catch (System.Net.WebException) { if (DialogResult.OK == MessageBox.Show( "Unable to access the authentication service." + Environment.NewLine + "Attempt login in offline mode?", "Warning", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning)) { ConnectivityStatus.IsOffline = true; isAuthorized = Membership.ValidateUser( String.Empty, String.Empty); } } if (!isAuthorized) { MessageBox.Show("Unable to authenticate.", "Not logged in", MessageBoxButtons.OK, MessageBoxIcon.Error); Application.Exit(); } return isAuthorized; }
Creazione di un form di accesso
Un provider di credenziali è una classe che implementa l'interfaccia IClientFormsAuthenticationCredentialsProvider. Questa interfaccia dispone di un solo metodo denominato GetCredentials che restituisce un oggetto ClientFormsAuthenticationCredentials. Nelle seguenti procedure verrà illustrato come creare una finestra di dialogo di accesso che implementa GetCredentials in modo che venga visualizzata la finestra stessa e vengano restituite le credenziali specificate dall'utente.
È necessario seguire procedure separate per Visual Basic e C# perché Visual Basic include un modello Form di accesso, che accelera le operazioni e richiede la compilazione di meno codice.
Per creare una finestra di dialogo di accesso come provider di credenziali in Visual Basic
In Esplora soluzioni selezionare il progetto ClientAppServicesDemo, quindi scegliere Aggiungi nuovo elemento dal menu Progetto.
Nella finestra di dialogo Aggiungi nuovo elemento selezionare il modello Form di accesso, specificare Login.vb per il Nome dell'elemento, quindi scegliere Aggiungi.
In Progettazione Windows Form verrà visualizzata la finestra di dialogo di accesso.
Nella finestra di progettazione scegliere OK, quindi impostare DialogResult su OK nella finestra Proprietà.
Nella finestra di progettazione aggiungere un controllo CheckBox al form sotto alla casella di testo Password.
Nella finestra Proprietà specificare il valore rememberMeCheckBox per (Name) e il valore &Remember me per Text.
Scegliere Visualizza | Codice dal menu principale di Visual Studio.
Nell'editor del codice, aggiungere il seguente codice all'inizio del file.
Imports System.Web.ClientServices.ProvidersModificare la firma della classe in modo che quest'ultima implementi l'interfaccia IClientFormsAuthenticationCredentialsProvider.
Public Class Login Implements IClientFormsAuthenticationCredentialsProviderAssicurarsi che il cursore sia posizionato dopo IClientformsAuthenticationCredentialsProvider, quindi premere INVIO per generare il metodo GetCredentials.
Individuare l'implementazione GetCredentials quindi sostituirla con il seguente codice.
Public Function GetCredentials() As _ ClientFormsAuthenticationCredentials Implements _ IClientFormsAuthenticationCredentialsProvider.GetCredentials If Me.ShowDialog() = DialogResult.OK Then Return New ClientFormsAuthenticationCredentials( _ UsernameTextBox.Text, PasswordTextBox.Text, _ rememberMeCheckBox.Checked) Else Return Nothing End If End Function
Nella procedura C# seguente viene fornito l'elenco di codice completo per la generazione di una semplice finestra di dialogo di accesso. La parte importante di questa finestra di dialogo dal layout piuttosto essenziale è costituita dall'implementazione GetCredentials.
Per creare una finestra di dialogo di accesso come provider di credenziali in C#
In Esplora soluzioni selezionare il progetto ClientAppServicesDemo, quindi scegliere Aggiungi classe dal menu Progetto.
Nella finestra di dialogo Aggiungi nuovo elemento specificare Login.cs per Nome, quindi scegliere Aggiungi.
Il file Login.cs verrà aperto nell'editor del codice.
Sostituire il codice predefinito con il seguente.
using System.Windows.Forms; using System.Web.ClientServices.Providers; namespace ClientAppServicesDemo { class Login : Form, IClientFormsAuthenticationCredentialsProvider { private TextBox usernameTextBox; private TextBox passwordTextBox; private CheckBox rememberMeCheckBox; private Button OK; private Button cancel; private Label label1; private Label label2; public ClientFormsAuthenticationCredentials GetCredentials() { if (this.ShowDialog() == DialogResult.OK) { return new ClientFormsAuthenticationCredentials( usernameTextBox.Text, passwordTextBox.Text, rememberMeCheckBox.Checked); } else { return null; } } public Login() { InitializeComponent(); } private void CloseForm(object sender, System.EventArgs e) { this.Close(); } private void InitializeComponent() { this.label1 = new System.Windows.Forms.Label(); this.usernameTextBox = new System.Windows.Forms.TextBox(); this.label2 = new System.Windows.Forms.Label(); this.passwordTextBox = new System.Windows.Forms.TextBox(); this.rememberMeCheckBox = new System.Windows.Forms.CheckBox(); this.OK = new System.Windows.Forms.Button(); this.cancel = new System.Windows.Forms.Button(); this.SuspendLayout(); // // label1 // this.label1.AutoSize = true; this.label1.Location = new System.Drawing.Point(13, 13); this.label1.Name = "label1"; this.label1.Size = new System.Drawing.Size(58, 13); this.label1.TabIndex = 0; this.label1.Text = "&User name"; // // usernameTextBox // this.usernameTextBox.Location = new System.Drawing.Point(13, 30); this.usernameTextBox.Name = "usernameTextBox"; this.usernameTextBox.Size = new System.Drawing.Size(157, 20); this.usernameTextBox.TabIndex = 1; // // label2 // this.label2.AutoSize = true; this.label2.Location = new System.Drawing.Point(13, 57); this.label2.Name = "label2"; this.label2.Size = new System.Drawing.Size(53, 13); this.label2.TabIndex = 2; this.label2.Text = "&Password"; // // passwordTextBox // this.passwordTextBox.Location = new System.Drawing.Point(13, 74); this.passwordTextBox.Name = "passwordTextBox"; this.passwordTextBox.PasswordChar = '*'; this.passwordTextBox.Size = new System.Drawing.Size(157, 20); this.passwordTextBox.TabIndex = 3; // // rememberMeCheckBox // this.rememberMeCheckBox.AutoSize = true; this.rememberMeCheckBox.Location = new System.Drawing.Point(13, 101); this.rememberMeCheckBox.Name = "rememberMeCheckBox"; this.rememberMeCheckBox.Size = new System.Drawing.Size(94, 17); this.rememberMeCheckBox.TabIndex = 4; this.rememberMeCheckBox.Text = "&Remember me"; this.rememberMeCheckBox.UseVisualStyleBackColor = true; // // OK // this.OK.DialogResult = System.Windows.Forms.DialogResult.OK; this.OK.Location = new System.Drawing.Point(13, 125); this.OK.Name = "OK"; this.OK.Size = new System.Drawing.Size(75, 23); this.OK.TabIndex = 5; this.OK.Text = "&OK"; this.OK.UseVisualStyleBackColor = true; // // cancel // this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; this.cancel.Location = new System.Drawing.Point(95, 125); this.cancel.Name = "cancel"; this.cancel.Size = new System.Drawing.Size(75, 23); this.cancel.TabIndex = 6; this.cancel.Text = "&Cancel"; this.cancel.UseVisualStyleBackColor = true; // // Login // this.AcceptButton = this.OK; this.CancelButton = this.cancel; this.ClientSize = new System.Drawing.Size(187, 168); this.Controls.Add(this.cancel); this.Controls.Add(this.OK); this.Controls.Add(this.rememberMeCheckBox); this.Controls.Add(this.passwordTextBox); this.Controls.Add(this.label2); this.Controls.Add(this.usernameTextBox); this.Controls.Add(this.label1); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; this.MaximizeBox = false; this.MinimizeBox = false; this.Name = "Login"; this.Text = "Login"; this.ResumeLayout(false); this.PerformLayout(); } } }
È ora possibile eseguire l'applicazione e vedere la finestra di dialogo di accesso. Per testare questo codice, provare a specificare credenziali diverse, sia valide sia non valide, e verificare che sia possibile accedere al form solo con le credenziali valide. I nomi utente validi sono dipendente e amministratore con le rispettive password dipendente! e amministratore!.
Nota
Non selezionare Memorizza password in questa fase, altrimenti non sarà possibile accedere come altro utente finché non si implementerà la disconnessione più avanti in questa procedura dettagliata.
Aggiunta di funzionalità basate su ruoli
Nella seguente procedura si aggiungerà al form un pulsante che verrà visualizzato solo agli utenti nel ruolo amministratore.
Per modificare l'interfaccia utente basata sul ruolo utente
In Esplora soluzioni, nel progetto ClientAppServicesDemo, selezionare Form1, quindi scegliere Visualizza | Finestra di progettazione dal menu principale di Visual Studio.
Nella finestra di progettazione aggiungere un controllo Button al form dalla Casella degli strumenti.
Nella finestra Proprietà impostare le seguenti proprietà per il pulsante.
Proprietà
Valore
(Name)
managerOnlyButton
Text
&Manager task
Visible
False
Nell'editor di codice relativo a Form1, aggiungere il seguente codice alla fine del metodo Form1_Load.
Questo codice chiama il metodo DisplayButtonForManagerRole che si aggiungerà nel passaggio successivo.
DisplayButtonForManagerRole()DisplayButtonForManagerRole();Aggiungere il seguente metodo alla fine della classe Form1.
Questo metodo chiama il metodo IsInRole di IPrincipal restituito dalla proprietà static Thread.CurrentPrincipal. Per le applicazioni configurate per l'utilizzo dei servizi delle applicazioni client, questa proprietà restituisce ClientRolePrincipal. Poiché questa classe implementa l'interfaccia IPrincipal, non è necessario farvi riferimento in modo esplicito.
Se il ruolo dell'utente è "amministratore", il metodo DisplayButtonForManagerRole imposta la proprietà Visible di managerOnlyButton su true. Se un viene generata un'eccezione WebException, questo metodo visualizza anche un messaggio di errore che indica che il servizio dei ruoli non è disponibile.
Nota
Il metodo IsInRole restituirà sempre false se l'accesso utente è scaduto. Questo messaggio di errore non viene visualizzato se l'applicazione chiama il metodo IsInRole una volta subito dopo l'autenticazione, come illustrato nel codice di esempio nella presente procedura dettagliata. Se l'applicazione deve recuperare ruoli utente in altri momenti, è necessario aggiungere il codice per riconvalidare gli utenti con accesso scaduto. Se tutti gli utenti validi sono stati assegnati ai ruoli, è possibile determinare se l'accesso è scaduto chiamando il metodo ClientRoleProvider.GetRolesForUser. Se non viene restituito alcun ruolo, l'accesso è scaduto. Per un esempio di questa funzionalità, vedere il metodo GetRolesForUser. Questa funzionalità è necessaria solo se è stato selezionato Richiedi agli utenti di accedere di nuovo a ogni scadenza del cookie del server nella configurazione dell'applicazione. Per ulteriori informazioni, vedere Procedura: configurare i servizi delle applicazioni client.
Private Sub DisplayButtonForManagerRole() Try If Thread.CurrentPrincipal.IsInRole("manager") Then managerOnlyButton.Visible = True End If Catch ex As System.Net.WebException MessageBox.Show("Unable to access the roles service.", _ "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) End Try End Subprivate void DisplayButtonForManagerRole() { try { if (Thread.CurrentPrincipal.IsInRole("manager")) { managerOnlyButton.Visible = true; } } catch (System.Net.WebException) { MessageBox.Show("Unable to access the role service.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }
Se l'autenticazione viene eseguita correttamente, il provider di autenticazione del client imposta la proprietà Thread.CurrentPrincipal su un'istanza della classe ClientRolePrincipal. Questa classe implementa il metodo IsInRole in modo che il lavoro venga delegato al provider di ruoli configurato. Come in precedenza il codice dell'applicazione non richiede un riferimento diretto al provider di servizi.
È ora possibile eseguire l'applicazione e accedere come dipendente per non vedere il pulsante e come amministratore per visualizzarlo.
Accesso alle impostazioni Web
Nella seguente procedura si aggiungerà al form una casella di testo che verrà associata a un'impostazione Web. Come il codice precedente che utilizza autenticazione e ruoli, il codice delle impostazioni non accede direttamente al provider delle impostazioni. Utilizza invece la classe Settings fortemente tipizzata (alla quale si accede come Properties.Settings.Default in C# e come My.Settings in Visual Basic) generata per il progetto da Visual Studio.
Per utilizzare le impostazioni Web nell'interfaccia utente
Assicurarsi che il Server di sviluppo Web ASP.NET sia ancora in esecuzione controllando l'area di notifica della barra delle applicazioni. Se è stato arrestato il server, riavviare l'applicazione (la quale avvia automaticamente il server), quindi chiudere la finestra di dialogo di accesso.
In Esplora soluzioni selezionare il progetto ClientAppServicesDemo, quindi scegliere Proprietà di ClientAppServicesDemo dal menu Progetto.
Verrà visualizzata la finestra Progettazione progetti.
Nella scheda Impostazioni fare clic suCarica impostazioni Web.
Verrà visualizzata la finestra di dialogo Accesso.
Immettere le credenziali per il dipendente e l'amministratore, quindi fare clic su Accedi. L'impostazione Web che verrà utilizzata è configurata per l'accesso solo da parte di utenti autenticati. Pertanto, se si seleziona Ignora accesso, non verrà caricata alcuna impostazione.
L'impostazione WebSettingsTestText viene visualizzata nella finestra di progettazione con il valore predefinito DefaultText. Inoltre, per il progetto viene generata una classe Settings che contiene una proprietà WebSettingsTestText.
In Esplora soluzioni, nel progetto ClientAppServicesDemo, selezionare Form1, quindi scegliere Visualizza | Finestra di progettazione dal menu principale di Visual Studio.
Nella finestra di progettazione aggiungere un controllo TextBox al form.
Nella finestra Proprietà specificare il valore webSettingsTestTextBox per (Name).
Nell'editor del codice, aggiungere il seguente codice alla fine del metodo Form1_Load.
Questo codice chiama il metodo BindWebSettingsTestTextBox che si aggiungerà nel passaggio successivo.
BindWebSettingsTestTextBox()BindWebSettingsTestTextBox();Aggiungere il seguente metodo alla fine della classe Form1.
Questo metodo associa la proprietà Text di webSettingsTestTextBox alla proprietà WebSettingsTestText della classe Settings generata precedentemente in questa procedura. Se viene generata un'eccezione WebException, questo metodo visualizza inoltre un messaggio di errore che indica che il servizio di impostazioni Web non è disponibile.
Private Sub BindWebSettingsTestTextBox() Try Me.webSettingsTestTextBox.DataBindings.Add("Text", _ My.Settings, "WebSettingsTestText") Catch ex As WebException MessageBox.Show("Unable to access the Web settings service.", _ "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) End Try End Subprivate void BindWebSettingsTestTextBox() { try { this.webSettingsTestTextBox.DataBindings.Add("Text", Properties.Settings.Default, "WebSettingsTestText"); } catch (WebException) { MessageBox.Show("Unable to access the Web settings service.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }Nota
Si utilizzerà in genere un'associazione dati per abilitare la comunicazione bidirezionale automatica tra un controllo e un'impostazione Web. Tuttavia, è inoltre possibile accedere direttamente alle impostazioni Web come illustrato nell'esempio seguente:
webSettingsTestTextBox.Text = My.Settings.WebSettingsTestTextwebSettingsTestTextBox.Text = Properties.Settings.Default.WebSettingsTestText;Selezionare il form nella finestra di progettazione, quindi fare clic sul pulsante Eventi nella finestra Proprietà.
Selezionare l'evento FormClosing, quindi premere INVIO per generare un gestore eventi.
Sostituire il metodo generato con il seguente codice.
Il gestore eventi FormClosing chiama il metodo SaveSettings viene utilizzato anche dalla funzionalità di disconnessione che si aggiungerà nella sezione successiva. Il metodo SaveSettings verifica innanzitutto che l'utente non sia disconnesso. A questo scopo, controlla la proprietà AuthenticationType di IIdentity restituito dall'entità di protezione corrente, la quale viene recuperata mediante la proprietà static CurrentPrincipal. Se l'utente è stato autenticato per i servizi delle applicazioni client, il tipo di autenticazione sarà "ClientForms." Il metodo SaveSettings non può controllare solo la proprietà IIdentity.IsAuthenticated perché l'utente potrebbe utilizzare un'identità di Windows valida dopo la disconnessione.
Se l'utente non è disconnesso, il metodo SaveSettings chiama il metodo Save della classe Settings generata precedentemente in questa procedura. Questo metodo può generare un'eccezione WebException se il cookie di autenticazione è scaduto. Questa situazione si verifica solo se è stata selezionata l'opzione Richiedi agli utenti di accedere di nuovo a ogni scadenza del cookie del server nella configurazione dell'applicazione. Per ulteriori informazioni, vedere Procedura: configurare i servizi delle applicazioni client. Il metodo SaveSettings gestisce la scadenza del cookie chiamando ValidateUser per visualizzare la finestra di dialogo di accesso. Se l'utente accede correttamente, il metodo SaveSettings tenta di salvare nuovamente le impostazioni chiamando se stesso.
Come nel codice precedente, il metodo SaveSettings visualizza un messaggio di errore se il servizio remoto non è disponibile. Se il provider delle impostazioni non può accedere al servizio remoto, le impostazioni vengono ancora salvate nella cache locale e ricaricate all'avvio dell'applicazione.
Private Sub Form1_FormClosing(ByVal sender As Object, _ ByVal e As FormClosingEventArgs) Handles Me.FormClosing SaveSettings() End Sub Private Sub SaveSettings() ' Return without saving if the authentication type is not ' "ClientForms". This indicates that the user is logged out. If Not Thread.CurrentPrincipal.Identity.AuthenticationType _ .Equals("ClientForms") Then Return Try My.Settings.Save() Catch ex As WebException If ex.Message.Contains("You must log on to call this method.") Then MessageBox.Show( _ "Your login has expired. Please log in again to save " & _ "your settings.", "Attempting to save settings...") Dim isAuthorized As Boolean = False Try ' Call ValidateUser with empty strings in order to ' display the login dialog box configured as a ' credentials provider. If Not Membership.ValidateUser( _ String.Empty, String.Empty) Then MessageBox.Show("Unable to authenticate. " & _ "Settings were not saved on the remote service.", _ "Not logged in", MessageBoxButtons.OK, _ MessageBoxIcon.Error) Else ' Try again. SaveSettings() End If Catch ex2 As System.Net.WebException MessageBox.Show( _ "Unable to access the authentication service. " & _ "Settings were not saved on the remote service.", _ "Not logged in", MessageBoxButtons.OK, _ MessageBoxIcon.Warning) End Try Else MessageBox.Show("Unable to access the Web settings service. " & _ "Settings were not saved on the remote service.", _ "Not logged in", MessageBoxButtons.OK, _ MessageBoxIcon.Warning) End If End Try End Subprivate void Form1_FormClosing(object sender, FormClosingEventArgs e) { SaveSettings(); } private void SaveSettings() { // Return without saving if the authentication type is not // "ClientForms". This indicates that the user is logged out. if (!Thread.CurrentPrincipal.Identity.AuthenticationType .Equals("ClientForms")) return; try { Properties.Settings.Default.Save(); } catch (WebException ex) { if (ex.Message.Contains("You must log on to call this method.")) { MessageBox.Show( "Your login has expired. Please log in again to save " + "your settings.", "Attempting to save settings..."); try { // Call ValidateUser with empty strings in order to // display the login dialog box configured as a // credentials provider. if (!Membership.ValidateUser(String.Empty, String.Empty)) { MessageBox.Show("Unable to authenticate. " + "Settings were not saved on the remote service.", "Not logged in", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { // Try again. SaveSettings(); } } catch (System.Net.WebException) { MessageBox.Show( "Unable to access the authentication service. " + "Settings were not saved on the remote service.", "Not logged in", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } else { MessageBox.Show("Unable to access the Web settings service. " + "Settings were not saved on the remote service.", "Not logged in", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } }Aggiungere il seguente metodo alla fine della classe Form1.
Questo codice gestisce l'evento ClientSettingsProvider.SettingsSaved e visualizza un messaggio di avviso se non è stato possibile salvare un'impostazione. L'evento SettingsSaved non si verifica se il servizio delle impostazioni non è disponibile o se il cookie di autenticazione è scaduto. L'evento SettingsSaved si verifica ad esempio se l'utente si è già disconnesso. È possibile testare questo gestore eventi aggiungendo il codice di disconnessione al metodo SaveSettings direttamente prima della chiamata al metodo Save. Il codice di disconnessione che è possibile utilizzare verrà descritto nella sezione successiva.
Private WithEvents settingsProvider As ClientSettingsProvider = My.Settings _ .Providers("System.Web.ClientServices.Providers.ClientSettingsProvider") Private Sub Form1_SettingsSaved(ByVal sender As Object, _ ByVal e As SettingsSavedEventArgs) _ Handles settingsProvider.SettingsSaved ' If any settings were not saved, display a list of them. If e.FailedSettingsList.Count > 0 Then Dim failedSettings As String = String.Join( _ Environment.NewLine, e.FailedSettingsList.ToArray()) Dim message As String = String.Format("{0}{1}{1}{2}", _ "The following setting(s) were not saved:", _ Environment.NewLine, failedSettings) MessageBox.Show(message, "Unable to save settings", _ MessageBoxButtons.OK, MessageBoxIcon.Warning) End If End Subprivate void Form1_SettingsSaved(object sender, SettingsSavedEventArgs e) { // If any settings were not saved, display a list of them. if (e.FailedSettingsList.Count > 0) { String failedSettings = String.Join( Environment.NewLine, e.FailedSettingsList.ToArray()); String message = String.Format("{0}{1}{1}{2}", "The following setting(s) were not saved:", Environment.NewLine, failedSettings); MessageBox.Show(message, "Unable to save settings", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }Per il linguaggio C# aggiungere il seguente codice alla fine del metodo Form1_Load. Questo codice associa il metodo aggiunto nell'ultimo passaggio all'evento SettingsSaved.
((ClientSettingsProvider)Properties.Settings.Default.Providers ["System.Web.ClientServices.Providers.ClientSettingsProvider"]) .SettingsSaved += new EventHandler<SettingsSavedEventArgs>(Form1_SettingsSaved);
Per testare l'applicazione in questa fase, eseguire più volte questo codice sia come dipendente che come amministratore e digitare i diversi valori nella casella di testo. I valori rimarranno validi per tutte le sessioni di ciascun utente.
Implementazione della disconnessione.
Se l'utente seleziona la casella di controllo Memorizza password all'accesso, l'applicazione autenticherà automaticamente l'utente nelle esecuzioni successive. L'autenticazione automatica continuerà quindi mentre l'applicazione è in modalità offline o fino alla scadenza del cookie di autenticazione. Può tuttavia capitare che all'applicazione debbano accedere più utenti oppure un solo utente più volte con credenziali diverse. Per consentire questo scenario, è necessario implementare la funzionalità di disconnessione, come descritto nella seguente procedura.
Per implementare la funzionalità di disconnessione
Nella finestra di progettazione Form1 aggiungere un controllo Button al form dalla Casella degli strumenti.
Nella finestra Proprietà specificare il valore logoutButton per (Name) e &Log Out per Text.
Fare doppio clic su logoutButton per generare un gestore eventi Click.
Verrà visualizzato il cursore nel metodo logoutButton_Click all'interno dell'editor del codice.
Sostituire il metodo generato logoutButton_Click con il seguente codice.
Questo gestore eventi chiama innanzitutto il metodo SaveSettings aggiunto nella sezione precedente. Il gestore eventi chiama quindi il metodo ClientFormsAuthenticationMembershipProvider.Logout. Se il servizio di autenticazione non è disponibile, il metodo Logout genererà un'eccezione WebException. In questo caso, il metodo logoutButton_Click visualizza un messaggio di avviso e passa temporaneamente alla modalità offline per disconnettere l'utente. La modalità offline verrà descritta nella sezione successiva.
Con la disconnessone viene eliminato il cookie di autenticazione locale in modo che all'avvio dell'applicazione vengano richieste le credenziali di accesso. Dopo la disconnessione il gestore eventi riavvia l'applicazione. Dopo il riavvio dell'applicazione viene visualizzato il messaggio di benvenuto seguito dalla finestra di dialogo di accesso. Il messaggio di benvenuto serve a indicare in modo esplicito che l'applicazione è stata riavviata. Questo processo semplifica le operazioni qualora l'utente dovesse effettuare l'accesso per salvare le impostazioni e quindi eseguire di nuovo l'accesso a causa del riavvio dell'applicazione.
Private Sub logoutButton_Click(ByVal sender As Object, _ ByVal e As EventArgs) Handles logoutButton.Click SaveSettings() Dim authProvider As ClientFormsAuthenticationMembershipProvider = _ CType(System.Web.Security.Membership.Provider, _ ClientFormsAuthenticationMembershipProvider) Try authProvider.Logout() Catch ex As WebException MessageBox.Show("Unable to access the authentication service." & _ Environment.NewLine & "Logging off locally only.", _ "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) ConnectivityStatus.IsOffline = True authProvider.Logout() ConnectivityStatus.IsOffline = False End Try Application.Restart() End Subprivate void logoutButton_Click(object sender, EventArgs e) { SaveSettings(); ClientFormsAuthenticationMembershipProvider authProvider = (ClientFormsAuthenticationMembershipProvider) System.Web.Security.Membership.Provider; try { authProvider.Logout(); } catch (WebException ex) { MessageBox.Show("Unable to access the authentication service." + Environment.NewLine + "Logging off locally only.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); ConnectivityStatus.IsOffline = true; authProvider.Logout(); ConnectivityStatus.IsOffline = false; } Application.Restart(); }
Per testare la funzionalità di disconnessione, eseguire l'applicazione e selezionare Memorizza password nella finestra di dialogo Accesso. Quindi, chiudere e riavviare l'applicazione per assicurarsi di non dover più eseguire l'accesso. Riavviare quindi l'applicazione facendo clic su Disconnessione.
Attivazione della modalità offline
Nella seguente procedura si aggiungerà una casella di controllo al form per consentire all'utente di attivare la modalità offline. L'applicazioni indica che è attiva la modalità offline impostando la proprietà static ConnectivityStatus.IsOffline su true. Lo stato offline viene archiviato sul disco rigido locale nel percorso indicato dalla proprietà Application.UserAppDataPath. Ciò significa che lo stato offline viene archiviato in base all'utente e all'applicazione.
In modalità offline, tutte le risposte dei servizi delle applicazioni client recuperano i dati dalla cache locale anziché tentare di accedere ai servizi. Nella configurazione predefinita, i dati locali includono la password crittografata dell'utente, per consentire all'utente di effettuare l'accesso mentre l'applicazione è in modalità offline. Per ulteriori informazioni, vedere Procedura: configurare i servizi delle applicazioni client.
Per attivare la modalità offline nell'applicazione
In Esplora soluzioni, nel progetto ClientAppServicesDemo, selezionare Form1, quindi scegliere Visualizza | Finestra di progettazione dal menu principale di Visual Studio.
Nella finestra di progettazione aggiungere un controllo CheckBox al form.
Nella finestra Proprietà specificare il valore workOfflineCheckBox per (Name) e il valore &Work offline per Text.
Nella finestra Proprietà fare clic sul pulsante Eventi.
Selezionare l'evento CheckedChanged, quindi premere INVIO per generare un gestore eventi.
Sostituire il metodo generato con il seguente codice.
Questo codice aggiorna il valore IsOffline e riconvalida l'utente senza avvisi quando questi ritorna in modalità online. Il metodo ClientFormsIdentity.RevalidateUser utilizza le credenziali memorizzate nella cache in modo che l'utente non debba eseguire l'accesso in modo esplicito. Se il servizio di autenticazione non è disponibile, viene visualizzato un messaggio di avviso e l'applicazione rimane in modalità offline.
Nota
Il metodo RevalidateUser viene fornito solo per praticità e poiché non dispone di un valore restituito non può indicare se la riconvalida non è riuscita. La riconvalida può non riuscire, ad esempio, se le credenziali utente sono state modificato nel server. In questo caso, è necessario includere il codice che convalida in modo esplicito gli utenti dopo l'esito negativo di una chiamata al servizio. Per ulteriori informazioni, vedere la sezione Accesso alle impostazioni Web più in alto in questa procedura dettagliata.
Dopo la riconvalida, questo codice salva tutte le modifiche apportate alle impostazioni Web locali chiamando il metodo SaveSettings aggiunto in precedenza. Recupera quindi tutti i valori nel server chiamando il metodo Reload della classe Settings (alla quale si accede come Properties.Settings.Default in C# e My.Settings in Visual Basic) del progetto.
Private Sub workOfflineCheckBox_CheckedChanged( _ ByVal sender As Object, ByVal e As EventArgs) _ Handles workOfflineCheckBox.CheckedChanged ConnectivityStatus.IsOffline = workOfflineCheckBox.Checked If Not ConnectivityStatus.IsOffline Then Try ' Silently re-validate the user. CType(System.Threading.Thread.CurrentPrincipal.Identity, _ ClientFormsIdentity).RevalidateUser() ' If any settings have been changed locally, save the new ' new values to the Web settings service. SaveSettings() ' If any settings have not been changed locally, check ' the Web settings service for updates. My.Settings.Reload() Catch ex As WebException MessageBox.Show( _ "Unable to access the authentication service. " & _ Environment.NewLine + "Staying in offline mode.", _ "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) workOfflineCheckBox.Checked = True End Try End If End Subprivate void workOfflineCheckBox_CheckedChanged( object sender, EventArgs e) { ConnectivityStatus.IsOffline = workOfflineCheckBox.Checked; if (!ConnectivityStatus.IsOffline) { try { // Silently re-validate the user. ((ClientFormsIdentity) System.Threading.Thread.CurrentPrincipal.Identity) .RevalidateUser(); // If any settings have been changed locally, save the new // new values to the Web settings service. SaveSettings(); // If any settings have not been changed locally, check // the Web settings service for updates. Properties.Settings.Default.Reload(); } catch (WebException) { MessageBox.Show( "Unable to access the authentication service. " + Environment.NewLine + "Staying in offline mode.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); workOfflineCheckBox.Checked = true; } } }Aggiungere il seguente codice alla fine del metodo Form1_Load per assicurarsi che la casella di controllo visualizzi lo stato di connessione corrente.
workOfflineCheckBox.Checked = ConnectivityStatus.IsOfflineworkOfflineCheckBox.Checked = ConnectivityStatus.IsOffline;
Questo completa l'applicazione di esempio. Per testare la funzionalità offline, eseguire l'applicazione, accedere come dipendente o amministratore e quindi selezionare Offline. Modificare il valore nella casella di testo, quindi chiudere l'applicazione e riavviarla. Prima di effettuare l'accesso, fare clic con il pulsante destro del mouse sull'icona di Server di sviluppo ASP.NET nell'area di notifica della barra delle applicazioni, quindi scegliere Arresta. Eseguire l'accesso normalmente. Anche quando il server non è in esecuzione, resta possibile eseguire l'accesso. Modificare il valore della casella di testo e riavviare per visualizzare il valore modificato.
Riepilogo
In questa procedura dettagliata è stato descritto come attivare e utilizzare i servizi delle applicazioni client in un'applicazione Windows Form. Dopo avere configurato un server di prova, all'applicazione è stato aggiunto il codice che consente di autenticare gli utenti e recuperare i ruoli e le impostazioni dell'applicazione dal server. È stato inoltre descritto come attivare la modalità offline per consentire all'applicazione di utilizzare una cache di dati locale anziché i servizi remoti quando la connessione non è disponibile.
Passaggi successivi
In un'applicazione reale si accederà ai dati di molti utenti da un server remoto che non sempre potrebbe essere disponibile o che potrebbe arrestarsi senza avviso. Per rendere affidabile l'applicazione, è necessario reagire in maniera appropriata quando il servizio non è disponibile. Questa procedura dettagliata include blocchi try/catch che consentono di rilevare un'eccezione WebException e visualizzare un messaggio di errore quando il servizio non è disponibile. Nel codice di produzione può essere opportuno gestire questa situazione passando alla modalità offline, uscendo dall'applicazione o negando l'accesso alla funzionalità specifica.
Per aumentare la sicurezza dell'applicazione, assicurarsi di testare completamente l'applicazione e il server prima della distribuzione.
Vedere anche
Attività
Procedura: configurare i servizi delle applicazioni client
Procedura dettagliata: utilizzo dei servizi delle applicazioni ASP.NET
Concetti
Cenni preliminari sui servizi delle applicazioni client
Altre risorse
Strumento di amministrazione sito Web di ASP.NET
Creazione e configurazione del database dei servizi per le applicazioni per SQL Server