Sep 22

Le complètement ou complètement automatique, ou encore par anglicisme complétion ou autocomplétion, est une fonctionnalité informatique permettant à l'utilisateur de limiter la quantité d'informations qu'il saisit avec son clavier, en se voyant proposer un complément qui pourrait convenir à la chaîne de caractères qu'il a commencé à taper. cf wikipédia

Dans cet exemple nous allons voir comment fonctionne l'autoCompletion à l'aide d'une liste de pays.

1) Création du WebService

Dans un premier temps, il faut créer le WebService qui renverra la liste des pays commençants par la saisie de l'utilisateur.

Ici le fichier du WebService se nomme "MyService.asmx"

a) Sans base de données

Pour comprendre de façon très simple le fonctionnement de ce controle, on ne va pas utiliser de base de données, mais un simple tableau qui renverra des pays "en dur".

Code :

[WebMethod]

public string[] GetCountries(string prefixText, int count)

{

ArrayList countryList = new ArrayList();

 

string[] countries = { "France", "Finland", "Allemagne", "Pologne", "Italie", "Etats-Unis", "Angleterre" };


foreach (string country in countries)

{

            if (country.ToLower().StartsWith(prefixText))

                countryList.Add(country);

}

 

return (string[])countryList.ToArray(typeof(string));

}

b) Avec une base de données

L'utilisation principale de ce contrôle sera couplée en générale à une base de données. Après les versions 1.0.1** de l'AjaxControlToolkit, on peut associer une valeur avec une clé (Id en général).

Code :

[WebMethod]

public String[] GetCountries(string prefixText, int count)

{

List<String> countries = new List<string>();

 

string strSql = "SELECT TOP " + count + " ID, NAME FROM COUNTRY WHERE NAME like @name + '%'";

 

using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["MyConn"].ConnectionString))

 

using (SqlCommand command = new SqlCommand(strSql, conn))

{

command.Parameters.Add("@name",

 

                   on clé/valeurdonn"System.Data.SqlDbType.NVarChar).Value = prefixText;

 

conn.Open();

 

using (SqlDataReader reader = command.ExecuteReader())

{

while (reader.Read())

{

countries.Add(AutoCompleteExtender.CreateAutoCompleteItem(

(String)reader["NAME"], (String)reader["ID"].ToString()));

}

}

 

conn.Close();

 

}

return countries.ToArray();

}

2) Ajouter le contrôle au client :

Le contrôle nécessite l'utilisation d'un ScriptManager, et d'un champs caché pour récupérer la valeur associé au champ.

Code :

<asp:ScriptManager runat="server" ID="sma"></asp:ScriptManager>

 

<asp:TextBox runat="server" ID="txtCountry" />

<asp:HiddenField runat="server" ID="hfCountryId" />

 

<ajaxToolkit:AutoCompleteExtender

runat="server"

BehaviorID="AutoCompleteEx"

ID="autoComplete1"

      TargetControlID="txtCountry"

ServicePath="MyService.asmx"

ServiceMethod="GetCountries"

      OnClientItemSelected="txtCountry_ClientItemSelected"

MinimumPrefixLength="2"

CompletionInterval="1000"

      EnableCaching="true"

CompletionSetCount="20"

CompletionListCssClass="AutoCompleteExtender_CompletionList"

CompletionListItemCssClass="AutoCompleteExtender_CompletionListItem"

      CompletionListHighlightedItemCssClass="AutoCompleteExtender_HighlightedItem"

      DelimiterCharacters=";, :">

</ajaxToolkit:AutoCompleteExtender>

 

<script type="text/javascript">

var txtCountry_ClientItemSelected = function(sender, e) {

$get('<%=hfCountryId.ClientID %>').value = e.get_value();

}

</script>

 

3) Récupérer la valeur renvoyée par le contrôle

protected void btnTest_Click(object sender, EventArgs e)

{

int id = Convert.ToInt32(hfCountryId.Value);

}

4) Appliquer un style au contrôle :

.AutoCompleteExtender_CompletionList

{

      background-color: window;

      color: windowtext;

      padding: 1px;

      font-size: small;

      background-color: Gray;

}

 

.AutoCompleteExtender_CompletionListItem

{

      text-align: left;

      background-color: White;

}

 

.AutoCompleteExtender_HighlightedItem

{

      background-color: Silver;

      color: windowtext;

      font-weight: bold;

      font-size: small;

}

Divers :

Ajouter la connectionString au Web.Config :

<connectionStrings>

   <add name="MyConn" connectionString="VotreChaine"/>

</connectionStrings>


Ajouter la référence à l'assembly dans le Web.Config :

<pages>

<controls>

………………………………

………………………………

<add tagPrefix="ajaxToolkit"

namespace="AjaxControlToolkit"

assembly="AjaxControlToolkit"/>

</controls>

</pages>

 

Sep 03

Au lieu d'avoir les pages d'erreurs par défaut, souvent désagréable à voir par le client, asp.net permet en quelques cliques de personnaliser ces pages.

1) Décommenter la section "customErrors" dans le web.config

et y modifier le nom des fichiers, on peut y placer aussi bien des pages html que des pages aspx.

<customErrors mode="On" defaultRedirect="GenericErrorPage.aspx">

<error statusCode="403" redirect="403.aspx" />

<error statusCode="404" redirect="404.aspx" />

</customErrors>

L'attribut "mode" peut prendre 3 valeurs :

On : La gestion des erreurs est activée en local et à distance.

Off : Gestion d'erreurs désactivée.

RemoteOnly : Gestion des erreurs activée seulement à distance, en local se seront les pages par défaut.

2) Créer les pages

Ensuite il faut créer ces pages, soit de façon très simple en mettant une image et le nom de l'erreur ou alors en affichant un message dynamique (voir 3)

3) Personnaliser ses pages d'erreurs

a) Créer une classe "BasePage" qui va hériter de "System.Web.UI.Page"

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Configuration;

 

/// <summary>

/// Description résumée de BasePage

/// </summary>

public class BasePage : System.Web.UI.Page

{

      public BasePage()

{

}

 

protected override void OnError(EventArgs e)

{

Exception ex = Server.GetLastError();

Session["LastError"] = ex.Message;

Response.Redirect("~/GenericErrorPage.aspx");

}

}

b) Faire hériter les pages utilisant cette gestion d'erreur par "BasePage" et non plus par "System.Web.UI.Page"

 

c) Commenter ou supprimer le corps de la méthode Application_Error dans le Global.asax

 

d) Modifier la page d'erreur générique :

 

protected void Page_Load(object sender, EventArgs e)

{

if (Session["LastError"] != null)

{

lblMessage.Text = Session["LastError"].ToString();

}

}

 

e) Voici à quoi peut ressembler votre page désormais :

 

 

f) Type de message

Le message peut-être plus ou moins développé en fonction du type de visiteurs (Si c'est un site grand public, on évitera de décrire l'erreur avec toute la stackTrace par exemple!)

Tags:
Sep 03

"L'URL-rewriting est une réécriture d'URL. La technique consistant à réécrire sous forme plus simple des URLs complexes. Cette technique est transparente pour l'internaute ainsi que pour les moteurs de recherches. Le but principal est d'obtenir un meilleur référencement."  cf kdj-webdesign.com

Le but de ce tutoriel est de transformer de façon transparente pour l'utilisateur ce genre d'url : 

Au lieu d'avoir ce type d'adresse : http://www.lesite.com/product.aspx?id=1&name?leNomDeMonProduit

on préférera la transformer en :  http://www.lesite.com/leNomDeMonProduit.html

A. Première technique

1) Ajouter la DLL nécessaire dans le répertoire Bin de votre site web

ThunderMain.URLRewriter.dll (4,50 kb) ou sur le site du projet "code source" : http://www.codeproject.com/aspnet/URLRewriter.asp

Clique droit sur le site, puis ajouter une référence pointant sur cette DLL.

2) Ajouter ou modifier le fichier Global.asax

Y ajouter cette méthode : 

void Application_BeginRequest(object sender, EventArgs e)

{

ThunderMain.URLRewriter.Rewriter.Process();

}

 

3) Modifier le fichier Web.config

a) Ajouter dans la section "configuration" :

 

<sectionGroup name="system.web">

<section name="urlrewrites"  

type="ThunderMain.URLRewriter.Rewriter,&#xA; ThunderMain.URLRewriter, Version=1.0.783.30976,&#xA; Culture=neutral, PublicKeyToken=7a95f6f4820c8dc3"/>

</sectionGroup>

b) Ajouter dans la section "System.Web" :

<urlrewrites>

<rule>

<url>product_1.html</url>

            <rewrite>product.aspx?id=1</rewrite>

      </rule>

      <rule>

            <url>product_2.html</url>

            <rewrite>article.aspx?id=2</rewrite>

      </rule>

</urlrewrites>

On peut ajouter autant de balises "rule" que l'on désire. On peut également utiliser des patterns comme <url>product_(.*).html</url> etc...

 

Si cette technique ne marche pas, il se peut que votre serveur web n'interprète pas les pages html comme des pages dynamiques. Il faudra donc modifier la configuration de celui-ci.

 

B. Deuxième technique

Télécharger la dll à cette adresse : http://urlrewriter.net/

Modifier le web.config comme cela :

Ajouter la section :

<section name="rewriter"

requirePermission="false"                

type="Intelligencia.UrlRewriter.Configuration.RewriterConfigurationSectionHandler, Intelligencia.UrlRewriter" />


Dans le HttpModule :

<add name="UrlRewriter" type="Intelligencia.UrlRewriter.RewriterHttpModule, Intelligencia.UrlRewriter"/>

 

Après la le </system.web> :

<rewriter>

    <rewrite url="~/([0-9]+)-(.+).html" to="~/Default.aspx?id=$1&amp;titre=$2" />

  </rewriter>


Sep 01

"En informatique, un obfuscateur est un utilitaire qui transforme le bytecode d'un programme en un bytecode aux fonctions équivalentes mais plus difficile à décompiler.

Le but de cet outil est de protéger un programme d'attaques ou d'intrusions notamment dans le domaine de l'espionnage industriel." cf Wikipédia

Cette technique permet d'obtenir un code impénétrable.

Introduction

Pour ce tutorial, je vais utiliser une classe très simple, la classe HelloWorld.cs, contenant une propriété, deux constructeurs et une méthode :

//-----------------------------------------------------------------------

// <copyright file="HelloWorld.cs" company="PH">

//     Copyright (c) PH. All rights reserved.

// </copyright>

// <author>PH</author>

// <date>01/09/2010</date>

//-----------------------------------------------------------------------

namespace Dotfuscator

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

 

    /// <summary>

    /// HelloWorld Class

    /// </summary>

    public class HelloWorld

    {

        /// <summary>

        /// Initializes a new instance of the HelloWorld class

        /// </summary>

        public HelloWorld()

        {

        }

 

        /// <summary>

        /// Initializes a new instance of the HelloWorld class with parameters

        /// <param name="text">text parameter</param>

        /// </summary>

        public HelloWorld(string text)

        {

            this.Text = text;

        }

 

        /// <summary>

        /// Gets or sets Texte

        /// </summary>

        public string Text { get; set; }

 

        /// <summary>

        /// Get "hello world" string

        /// </summary>

        /// <returns>The "Hello World" string</returns>

        public string GetHelloText()

        {

            return "Hello World";

        }

    }

}

 

1) Analyser une DLL non obfusquée avec "Reflector"

Reflector est disponible ici

On peut distinguer clairement la propriété ainsi que la méthode.

 

 

2) Ouvrir "DotFuscator"

Soit en allant dans : Programmes/Microsoft Visual Studio 2008/Visual Studio Tools/Dotfuscator Community Edition

Ou alors directement à partir de visual studio en allant dans l'onglet Outils puis Dotfuscator Community Edition

 

A l'ouverture, un écran propose de sélectionner un type de projet. Pour une première utilisation laisser "Créer un nouveau projet".

L'onglet "Entrée" devient actif, il suffit de cliquer sur l'icone Ouvrir "Rechercher et ajouter un assembly à la liste", et d'y ajouter votre ou vos DLL.

 

Enregistrer le projet.

 

Rendez-vous ensuite dans l'onglet "Générer", vous pouvez changer le répertoire de destination si nécessaire puis cliquer sur "Générer".

 

Maintenant vous pouvez aller dans l'onglet "Sortie" pour comparer avec l'analyse de Reflector.