Willy laroche

B10g $ur 13$ t3chn0$ M!cr0$0ft 3t p1u$ $! 4ff!n!té$…

Récupérer des paramètres AppSettings du Web.Config (ASP.NET)

Un commentaire

Dans ce nouvel article, je vais présenter comment récupérer les clés AppSettings du Web.Config à partir d’un projet Silverlight 3. Nous verrons au fur et à mesure comment mettre en place la solution.
La solution n’est pas forcément la plus optimale, mais je vous invite à me laisser quelques messages si besoin.

  • Résumé global de la solution

L’idée est donc de récupérer les clés du Web.Config par l’intermédiaire d’un web service interne à la solution et les enregistrer dans un dictionnaire similaire à un projet Web Application ASP.NET classique.

  • Petit rappel
La problématique d’un projet Silverlight, c’est qu’il est indépendant de la solution qui l’héberge. C’est pour cela qu’il existe plusieurs manières pour transmettre des paramètres de la Web Application (ASP.NET) vers Silverlight.
Le Web.Config est le fichier xml de configuration qui est référencé côté ASP.NET. Il permet de centraliser  beaucoup d’informations, comme des chaines de connexion aux bases de données et bien sûr des paramètres  de l’application. Il existe plusieurs façon de transmettre des paramètres pour l’application Silverlight mais je vais exposer mon approche.
Sommaire
  1. Création de la solution
  2. Modification du Web.Config 
  3. Création de la couche Tools
  4. Création du Web Service de configuration de l’application
  5. Accès au Web Service côté Silverlight
  6. Appel du Web Service au chargement de l’application
  7. Accès aux clés côté Silverlight

1. Création de la solution

La 1ère approche est donc de déclarer des paramètres dans la page qui héberge l’application Silverlight (dans cet exemple : SilverlightApplication1TestPage.aspx).

Nous allons créer un nouveau projet :

La solution est enfin créée et comporte 2 projets :

2. Modification du Web.Config
Ouvrez le fichier Web.Config et ajouter les clés contenant les paramètres de votre application :

       <appSettings>
             <addkey=« Param1« value=« Value1« />
             <addkey=« Param2« value=« Value2« />
             <addkey=« Param3« value=« http://willylaroche.blogspot.com« />
       appSettings>

3. Création de la couche Tools

Ajouter un nouveau projet à la solution : Silverlight Class Library que l’on nommera « Tools »
Renommez le fichier « class1.cs » par « Application_Tools.cs » et ajoutez le code ci-dessous :
namespace Tools
{
    public class Application_Tools
    {
        ///

        /// Application Settings
        ///
        public static Dictionary<string, string> AppSettings;
    }
}
Ajout d’un Dictionnaire dans lequel nous stockerons les clés du « Web.Config » et les 2 autres méthodes permettent d’encoder le message du web service que nous allons créer ci-dessous.
namespace Tools
{
    public class Application_Tools
    {
        ///

        /// Application Settings
        ///
        public static Dictionary<string, string> AppSettings;
        ///

        /// Gets the bytes from string.
        ///
        ///
The STR.
        ///
        public static string GetBytesFromString(string str)
        {
            byte[] tab = Encoding.UTF8.GetBytes(str);
            return Convert.ToBase64String(tab);
        }
        ///

        /// Gets the string from bytes.
        ///
        ///
The base64.
        ///
        public static string GetStringFromBytes(string base64)
        {
            byte[] raw = Convert.FromBase64String(base64);
            return Encoding.UTF8.GetString(raw, 0, raw.Length);
        }
    }
}
Ajouter ce projet en référence dans chacun des projets :
SilverlightApplication1
SilverlightApplication1.Web
(Click droit sur le projet => Add Reference…)

4. Création du Web Service de configuration de l’application

Sur le projet Web, Ajouter un nouvel item de type Web Service, que nous nommerons : « Configuration_WS.asmx ».
Éditez ce fichier, supprimez la web méthode générée et ajouter le code ci-dessous :
    public class Configuration_WS : System.Web.Services.WebService
    {
        ///

        /// Gets the app settings.
        ///
        ///
        [WebMethod]
        public List<string[]> GetAppSettings()
        {
            List<string[]> appSettings = new List<string[]>();
            for (int i = 0; i < ConfigurationManager.AppSettings.Count; i++)
            {
                //appSettings.Add(new string[]
                //{
                //    ConfigurationManager.AppSettings.GetKey(i),
                //    ConfigurationManager.AppSettings[i]
                //});
                appSettings.Add(new string[]
                {
                    Tools.Application_Tools
                         .GetBytesFromString(ConfigurationManager.AppSettings.GetKey(i)),
                   
                    Tools.Application_Tools
                         .GetBytesFromString(ConfigurationManager.AppSettings[i])
                });
            }
            return appSettings;
        }
    }
La web méthode GetAppSettings retourne les clés contenus dans la balisedu Web.Config.
Dans un premier temps nous retournerons les clés en clair, ce qui n’est pas sécurisé bien sûr.
Le code commenté utilise les méthode de la libraire « Tools » pour encoder les chaines de caractères.
Nous allons tester notre Web Service :
Click droit sur le fichier Configuration.asmx => View in Browser
Les clés sont bien récupérées. Vous pouvez dé-commenter le code et le remplacer par l’actuel, et refaire la même manipulation pour vérifier que les clés sont bien encodées.
Nous allons maintenant mettre en place l’accès à ce Web Service côté Silverlight.
5. Accès au Web Service côté Silverlight
Pour accéder au Web Service créé dans la Web Application, nous ajoutons une « Service Reference » :
Click droit => Add Service Reference.
Click sur « Discover ». Nommez la référence : « Configuration_WS ».
Sur le projet Silverlight, crééez une nouvelle classe : « ConfigurationManager.cs ».
Cette classe est un singleton, permettant d’accéder à ma web méthode créée auparavant, mais de manière asynchrone, c’est à dire, qu’il y a une phase d’appel, et une phase de réponse.
La phase de réponse permet de récupérer les valeurs du Web.Config et de les enregistrer dans le dictionnaire « AppSettings » de la classe « Application_Tools » (librairie « Tools »).
Voici le code :
namespace SilverlightApplication1
{
    public sealed class ConfigurationManager
    {
        #region ———————– Fields ————————–
        private static volatile ConfigurationManager _instance;
        private static object _syncRoot = new Object();
        private Configuration_WS.Configuration_WSSoapClient _ws;
        public delegate void EventHandler(object sender, EventArgs e);
        public event EventHandler GetAppSettings_Completed;
        #endregion
        #region ———————– Instance —————————-
        ///

        /// Gets the instance.
        ///
        ///The instance.
        public static ConfigurationManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_syncRoot)
                    {
                        if (_instance == null)
                            _instance = new ConfigurationManager();
                    }
                }
                return _instance;
            }
        }
        #endregion
        #region ———————– Constructor ————————–
        ///

        /// Initializes a new instance of the class.
        ///
        public ConfigurationManager()
        {
        }
        #endregion
        #region ———————– Methods ————————–
        ///

        /// Gets the app settings.
        ///
        ///
The ws URL.
        public void GetAppSettings(string wsUrl)
        {
            string e = Application.Current.Host.Source.AbsoluteUri;
           
            BasicHttpBinding bind = new BasicHttpBinding();
            EndpointAddress endpoint = new EndpointAddress(wsUrl);
            bind.MaxReceivedMessageSize = bind.MaxReceivedMessageSize;
            _ws = new Configuration_WS.Configuration_WSSoapClient(bind, endpoint);
            _ws.GetAppSettingsAsync();
            _ws.GetAppSettingsCompleted += new EventHandler
                .GetAppSettingsCompletedEventArgs>(_ws_GetAppSettingsCompleted);
        }
        #endregion
        #region ———————– Events ————————–
        ///

        /// Handles the GetAppSettingsCompleted event of the _ws control.
        ///
        ///
The source of the event.
        ///
The instance containing the event data.
        void _ws_GetAppSettingsCompleted(object sender, Configuration_WS.GetAppSettingsCompletedEventArgs e)
        {
            Tools.Application_Tools.AppSettings = new Dictionary<string, string>();
           
            try
            {
                foreach (var item in e.Result)
                {
                    Tools.Application_Tools.AppSettings.Add(
                        Tools.Application_Tools.GetStringFromBytes(item[0]),
                        Tools.Application_Tools.GetStringFromBytes(item[1])
                        );
                }
            }
            catch
            {
                Tools.Application_Tools.AppSettings = null;
            }
            EventArgs ev = new EventArgs();
            if (GetAppSettings_Completed != null)
                GetAppSettings_Completed(this, ev);
        }
        #endregion
    }
6. Appel du Web Service au chargement de l’application
Ouvrez le fichier « App.xaml.cs ».
La fonction « Application_Startup » lance l’exécution de l’application.
Nous allons diviser ce traitement en 2 : au lieu de lancer l’initialisation du « MainPage », on va faire l’appel au Web Service, et ajouter un évènement de retour permettant d’effectuer la suite du traitement de l’application.
namespace SilverlightApplication1
{
    public partial class App : Application
    {
        public App()
        {
            this.Startup += this.Application_Startup;
            this.UnhandledException += this.Application_UnhandledException;
            InitializeComponent();
        }
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            //Get Application Settings (Works on Localhost)
            string wsUrl = App.Current.Host.Source.AbsoluteUri
                           .Replace(App.Current.Host.Source.AbsolutePath, «  ») + « /Configuration_WS.asmx »;
            //Set your final url here or in default.aspx in Silverlight « InitParams » markup
            //Get the value with e.InitParams["KEY_OF_YOUR_URL"]
           
            //Get Application Settings
            ConfigurationManager.Instance.GetAppSettings(wsUrl);
            //Add Completed Event Whene Data Are Loaded
            ConfigurationManager.Instance.GetAppSettings_Completed
                += new ConfigurationManager.EventHandler(Instance_GetAppSettings_Completed);
           
        }
        void Instance_GetAppSettings_Completed(object sender, EventArgs e)
        {
            //Data are loaded, let’s go…           
            this.RootVisual = new MainPage();
        }
        private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
        {
             //…
        }
    }
}
7. Accès aux clés côté Silverlight
Maintenant, dans l’application, les clés seront accessible via la classe « Tools » :
Donc dans n’importe quelle page xaml.cs, appelez les paramètres avec :
Exemple :
Tools.Application_Tools.AppSettings["Param1"] donnera : Value1
Tools.Application_Tools.AppSettings["Param2"] donnera : Value2
Tools.Application_Tools.AppSettings["Param3"] donnera : http://willylaroche.blogspot.com

Exemple :
Dans la page Home.xaml.cs :

        public Home()
        {
            InitializeComponent();
            ChildWindow cw = new ErrorWindow(«  »,
                « Param1= « 
                + Tools.Application_Tools.AppSettings[« Param1″]
                + « \nParam2= « 
                + Tools.Application_Tools.AppSettings[« Param2″]
                + « \nParam3= « 
                + Tools.Application_Tools.AppSettings[« Param3″]
                );
            cw.Show();
        }
Voilà !!!
Conclusion
La solution de l’encodage n’est bien évidemment pas sécurisée, mais pour des applications internes en entreprise, cela peut convenir. Dans le cas où l’application est sur internet, je recommande donc de remplacer les fonctions d’encodage par du cryptage.
Le code source du projet (Visual Studio 2010) sont disponibles ici : SilverlightApplication1.zip
About these ads

Une réflexion sur “Récupérer des paramètres AppSettings du Web.Config (ASP.NET)

  1. Salut,

    Merci pour l’article.
    Perso j’utilise wcf pour communiquer avec des flasheurs win ce mais le chapitre sur l’app setting avec le web.config m’a bien servi.
    ;)

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

Suivre

Recevez les nouvelles publications par mail.