Comprendre les services d'authentification et de profil d'ASP.NET AJAX

Cet article est la traduction la plus fidèle possible de l'article original : Understanding ASP.NET AJAX Authentication and Profile Application Services

Dans le Framework .NET 3.5, Microsoft fournit une importante mise à niveau de l'environnement ; non seulement un nouvel environnement de développement est disponible, mais LINQ (Language-Integrated Query, Requête intégrée au langage) et d'autres améliorations linguistiques des améliorations sont à venir. En outre, certaines caractéristiques familières d'autres outils, notamment les extensions ASP.NET AJAX, sont désormais incluses en tant que citoyennes de première classe dans la bibliothèque de classes du Framework. Ces extensions permettront de nombreuses nouvelles fonctionnalités client riche, y compris le rendu partiel des pages, sans nécessiter un rafraîchissement de toute la page, la capacité d'accéder à des services Web via des scripts coté client (y compris l'API de profilage d'ASP.NET), et une vaste API coté client, conçue pour refléter de nombreux schémas de contrôle existants dans les contrôles serveurs d'ASP.NET.

Ce livre blanc se penche sur la mise en oeuvre et l'utilisation des services d'authentification et de profils d'ASP.NET tels qu'ils sont exposés par le Framework ASP.NET AJAX Extensions. Les extensions AJAX rendent l'authentification par formulaires incroyablement facile à maintenir, comme il est (ainsi que le service de profils) exposé par le biais d'un script de proxy de service Web. Les AJAX Extensions permettent aussi une authentification personnalisée par l'intermédiaire de la classe AuthenticationServiceManager.

Ce livre blanc est fondé sur la version bêta 2 de Visual Studio 2008 et du Framework .NET 3.5. Ce livre blanc suppose également que vous travaillez avec Visual Studio 2008 Beta 2, et pas avec Visual Web Developer Express, et fournira des solutions basées sur l'interface utilisateur de Visual Studio. Quelques exemples de code pourraient utiliser des modèles de projets non disponibles dans Visual Web Developer Express.

Les services d'authentification et de profil d'ASP.NET sont fournis par le système d'authentification par formulaire d'ASP.NET, et sont des composants standard d'ASP.NET. Les extensions ASP.NET AJAX fournissent des accès sous forme de script à ces services via des script proxy, par le biais d'un modèle assez simple dans l'espace de noms Sys.Services de la bibliothèque client AJAX.

Le service d'authentification (Authentication service) permet aux utilisateurs de fournir des références (credentials), en vue de recevoir un cookie d'authentification et est le point d'accès pour permettre l'utilisation de profils d'utilisateur personnalisés, fournis par ASP.NET. L'utilisation du service d'authentification ASP.NET AJAX est compatible avec l'authentification par formulaires standard d'ASP.NET, par conséquent, une mise à niveau vers le service d'authentification AJAX ne provoquera pas de bug dans des applications utilisant l'authentification par formulaires (par exemple avec un contrôle de type Login).

Le service de profil permet l'intégration et le stockage automatique des données de l'utilisateur en fonction de son appartenance à un groupe, comme ceux fournis par le service d'authentification. Les données stockées sont définies par le fichier web.config, et les différents fournisseurs de services de profils prennent en charge la gestion des données. Comme dans le service d'authentification, le service de profil AJAX est compatible avec le service de profil standard d'ASP.NET, de sorte que les pages intégrant les fonctionnalités du service de profil d'ASP.NET ne seront pas endommagées par le support d'AJAX.

L'intégration des services d'authentification et de profil d'ASP.NET dans une application est hors de la portée de ce livre blanc. Pour plus d'informations sur le sujet, voir l'article de la bibliothèque de référence MSDN "Gestion des utilisateurs à l'aide de l'appartenance", à http://msdn.microsoft.com/fr-fr/library/tw292whz.aspx. ASP.NET comprend aussi un utilitaire pour mettre en place automatiquement un gestionnaire d'appartenance pour SQL Server, qui est le fournisseur de services d'authentification par défaut pour l'appartenance ASP.NET. Pour plus d'informations, voir l'article "ASP.NET SQL Server Registration Tool (Aspnet_regsql.exe)" à http://msdn.microsoft.com/fr-fr/library/ms229862(vs.80).aspx.

Le service d'authentification ASP.NET AJAX doit être activé dans le fichier web.config :

<system.web.extensions>      
	<scripting>           
		<webServices>                
			<authenticationService enabled="true" />         
		</webServices>    
	</scripting> 
</system.web.extensions>

Le service d'authentification requiert l'activation de l'authentification par formulaire ASP.NET, ainsi que l'activation des cookies sur le navigateur du client (un script ne permet pas une session sans cookie car une session sans cookie nécessite l'ajout de paramètres dans l'URL).

Une fois que le service d'authentification AJAX est activé et configuré, les scripts clients peuvent immédiatement profiter de l'objet Sys.Services.AuthenticationService. Principalement, les scripts clients voudront utiliser la méthode Login, ainsi que la propriété isLoggedIn. Plusieurs propriétés existent pour fournir des valeurs par défaut pour la méthode Login, qui peut accepter un grand nombre de paramètres.

Membres de Sys.Services.AuthenticationService▲

function AuthenticationFailureCallback(error, userContext, methodName);

function AuthenticationLoginCompletedCallback(validCredentials, userContext, methodName);

function AuthenticationLogoutCompletedCallback(result, userContext, methodName);

Exemple de code: connexion au service d'authentification▲

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %> 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml">      
	<head runat="server">           
		<title>Login Example</title>           
		<script type="text/javascript">       
		         
			function Login(){                     
				var userTextbox = $get("txtUser");                     
				var passTextbox = $get("txtPassword");                     
				Sys.Services.AuthenticationService.login(userTextbox.value,                          
					passTextbox.value, false, null, null, LoginServiceCompleted,                          
					LoginServiceFailed, "Context Info");                
			}                
			
			function Logout(){                     
				Sys.Services.AuthenticationService.logout(null, LogoutServiceCompleted,                          
					LoginServiceFailed, "Context Info");                
			}                
			
			function LoginServiceFailed(error, userContext, methodName){                     
				alert('There was an error with the authentication service:\n\n' + error);                
			}                
			
			function LoginServiceCompleted(validCredentials, userContext, methodName){                     
				if (validCredentials){                          
					alert('Great! You successfully logged in.');                     
				}else{                          
					alert('Oops! You gave us bad credentials!'); 
				}                
			}                
			
			function LogoutServiceCompleted(result, userContext, methodName){                     
				alert('You have been logged out from the web site.');                
			}           
			
		</script>      
	</head>      
	<body>           
		<form id="form1" runat="server">                
		<asp:ScriptManager ID="ScriptManager1" runat="server"                     
			EnableScriptLocalization="true">                
		</asp:ScriptManager>                
		<div>                     
			<asp:TextBox ID="txtUser" runat="Server"></asp:TextBox>                     
			<br />                     
			<asp:TextBox ID="txtPassword" runat="Server" TextMode="Password"/>                     
			<br />                     
			<asp:Button Text="Log in" ID="btnLogin" runat="server"                          
				OnClientClick="Login(); return false;" />               
		</div>           
		</form>      
	</body> 
</html>

Le service de profil ASP.NET est également exposé à travers les extensions ASP.NET AJAX. Comme service de profil ASP.NET fournit une API riche et granulaire, qui permet de stocker et de récupérer les données de l'utilisateur, cela peut être un excellent outil de productivité.

Le profil de service doit être activé dans le web.config, ce qu'il n'est pas par défaut. To do so, ensure that the profileService child element has enabled=”true” specified in web.config, and that you have specified which properties can be read or written as follows: Pour ce faire, veillez à ce que l'élément profileService ait la propriété enabled avec la valeur "true" dans le web.config, et que vous avez spécifié quelles propriétés peuvent être lues ou écrites de cette façon :

<system.web.extensions>      
	<scripting>
		<webServices>
			<profileService enabled="true"                     
				readAccessProperties=&#8221;Name,Address,BackgroundColor&#8221;                     
				writeAccessProperties=&#8221;BackgroundColor&#8221;/>           
		</webServices>      
	</scripting> 
</system.web.extensions>

Le service de profil doit aussi être configuré. Bien que la configuration du service de profil soit en dehors de la portée de ce livre blanc, il est intéressant de noter que des propriétés définies dans les paramètres de configuration d'un profil seront accessibles en tant que sous-propriétés du groupe. Par exemple, avec la section profil suivante spécifiée dans le web.config :

<profile enabled="true">      
	<properties>           
		<add name="Name" type="System.String"/>           
		<group name="Address">                
			<add name="Line1" type="System.String"/>                
			<add name="Line2" type="System.String"/>                
			<add name="City" type="System.String"/>                
			<add name="State" type="System.String"/>                
			<add name="Zip" type="System.String"/>           
		</group>           
		<add name="BackgroundColor" type="System.Drawing.Color"/>      
	</properties> 
</profile>

Les scripts coté client seraient en mesure d'accéder à Name, Address.Line1, Address.Line2, Address.City, Address.State, Address.Zip, et BackgroundColor en tant que propriétés du champ properties de la classe ProfileService.

Membres de Sys.Services.ProfileService▲

Sys.Services.ProfileService.properties.Address.State

function AuthenticationFailureCallback(error, userContext, methodName);

function ProfileSaveComplete(numPropsSaved, userContext, methodName);

function ProfileLoadComplete(numPropsLoaded, userContext, methodName);

Exemple de code : Récupération des données de profil durant le chargement d'une page▲

function Page_Load(){      
	if (Sys.Services.AuthenticationService.get_isLoggedIn()){           
		Sys.Services.ProfileService.load();      
	} 
} 

function ProfileLoaded(numPropsLoaded, userContext, methodName){      
	document.documentElement.style.backgroundColor = Sys.Services.ProfileService.properties.BackgroundColor; 
}

Sys.Services.ProfileService.set_defaultLoadCompletedCallback(ProfileLoaded);

ys.Services.ProfileService.load(null, ProfileLoaded, null, null);

Les extensions ASP.NET AJAX vous permettent de créer un fournisseur de service d'authentification personnalisé, en exposant votre fonctionnalité par l'intermédiaire d'un service web personnalisé. Pour être utilisé, votre service web doit exposer deux méthodes, Login et Logout, et ces méthodes doivent être spécifiées avec la même signature que le service web par défaut d'authentification ASP.NET AJAX.

Une fois que vous avez créé le service Web personnalisé, vous devez spécifier le chemin vers ce service, que ce soit de façon déclarative sur votre page, programmatiquement dans le code, ou via un script coté client.

Définition du chemin de façon déclarative▲

<asp:ScriptManager ID="ScriptManager1" runat="server">
      <AuthenticationService Path="~/AuthService.asmx" /> 
</asp:ScriptManager>

Définition du chemin dans le code▲

protected void Page_Load(object sender, EventArgs e) {      
	this.ScriptManager1.AuthenticationService.Path = "~/AuthService.asmx"; 
}

Définition du chemin dans le script coté client▲

function Login() {      
	var userTextbox = $get("txtUser");      
	var passTextbox = $get("txtPassword");      
	Sys.Services.AuthenticationService.set_path("./AuthService.asmx");      
	Sys.Services.AuthenticationService.login(userTextbox.value, passTextbox.value, false, 
	           null, null, LoginServiceCompleted, LoginServiceFailed, "Context Info"); 
}

Exemples de services Web pour une authentification personnalisée ▲

<%@ WebService Language="C#" Class="AuthService" %> 

using System; 
using System.Web; 
using System.Web.Services; 
using System.Web.Services.Protocols; 
using System.Web.Script.Services; 

[ScriptService] 
[WebService] 
public class AuthService : WebService {
	[WebMethod]      
	public bool Login(string userName, string password, bool createCookie){
		Session["LoggedInUser"] = userName;
		return true;
	}      
	
	[WebMethod]
	public void Logout(){
		Session.Abandon();      
	} 
}

Les services ASP.NET - en particulier, les services de profil, d'appartenance à un groupe (membership), et d'authentification - sont facilement exposés en JavaScript sur le navigateur du client. Cela permet aux développeurs d'intégrer leur code côté client avec les mécanismes d'authentification de façon transparente, sans dépendre de contrôles tels que les UpdatePanels et de manipulations lourdes. Les données de profil peuvent aussi être protégées du client, en utilisant des paramètres de configuration web; aucune donnée n'est disponible par défaut, et les développeurs doivent activer pour les propriétés de profil.

En outre, en créant des implémentations de services Web simplifiées avec des signatures de méthode équivalentes, les développeurs peuvent créer des fournisseurs de scripts personnalisés pour ces services intrinsèques à ASP.NET. Le support de ces techniques simplifie le développement d'applications client riche, tout en fournissant aux développeurs une grande flexibilité pour répondre à des besoins spécifiques.