USE [StructuralTranslations]
GO
/****** Object:  Table [dbo].[Cultures]    Script Date: 10/01/2010 12:27:08 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[Cultures](
	[CultureId] [uniqueidentifier] NOT NULL CONSTRAINT [DF_Cultures_CultureId]  DEFAULT (newid()),
	[Code] [char](5) NOT NULL,
 CONSTRAINT [PK_Cultures] PRIMARY KEY CLUSTERED 
(
	[CultureId] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, 
ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Object:  Table [dbo].[Translations]    Script Date: 10/01/2010 12:27:08 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[Translations](
	[TranslationId] [uniqueidentifier] NOT NULL CONSTRAINT [DF_Dictionary_DictionaryId]  DEFAULT (newid()),
	[CultureId] [uniqueidentifier] NOT NULL,
	[Key] [varchar](6) NOT NULL,
	[Text] [varchar](max) NOT NULL,
 CONSTRAINT [PK_Dictionary] PRIMARY KEY CLUSTERED 
(
	[TranslationId] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
CREATE UNIQUE NONCLUSTERED INDEX [Key] ON [dbo].[Translations] 
(
	[Key] ASC,
	[CultureId] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, 
ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
GO
/****** Object:  ForeignKey [FK_Dictionary_Cultures]    Script Date: 10/01/2010 12:27:08 ******/
ALTER TABLE [dbo].[Translations]  WITH CHECK ADD  CONSTRAINT [FK_Dictionary_Cultures] FOREIGN KEY([CultureId])
REFERENCES [dbo].[Cultures] ([CultureId])
GO
ALTER TABLE [dbo].[Translations] CHECK CONSTRAINT [FK_Dictionary_Cultures]
GO

using System;
using System.Linq;

namespace Data
{
    /// <summary>
    /// Classe chargée de récupérer les données en base
    /// </summary>
    public class StructuralTranslationsProvider : IDisposable
    {
        private bool _disposed;
        private StructuralTraductionsDataContext db = new StructuralTraductionsDataContext();

        /// <summary>
        /// Retourne la totalité des traductions
        /// </summary>
        /// <returns></returns>
        public IQueryable<Translation> Load()
        {
            return from t in db.Translations
                   join c in db.Cultures on t.CultureId equals c.CultureId
                   select t;
        }

        #region IDisposable Membres

        /// <summary>
        /// Destructeur de la classe. Permet de libérer les ressources non gérées par le code selon un processus automatique.
        /// Permet de réaliser toutes les opérations de nettoyage nécessaires avant que les ressources 
        /// ne soient réclamées par le garbage collector
        /// </summary>
        ~StructuralTranslationsProvider()
        {
            Dispose(false);
        }

        /// <summary>
        /// Réalise les opérations définies par le code pour detruire les objets, 
        /// libérer ou réinitialiser les ressources non gérées.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Réalise les opérations définies par le code pour detruire les objets, 
        /// libérer ou réinitialiser les ressources non gérées.
        /// </summary>
        /// <param name="disposing">Spécifier <c>true</c> quand la méthode est 
        /// appelé directement ou non par le code. Sinon spécifier <c>false</c></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                db.Dispose();
                db = null;
                _disposed = true;
            }
        }

        #endregion
    }
}

          

/// <summary>
/// Chargement d'une traduction en fonction de la clef métier et la culture
/// </summary>
/// <param name="key">la clef métier</param>
/// <param name="culture">la culture</param>
/// <returns>la traduction</returns>
public static string Load(string key, CultureInfo culture)
{
    // Allons chercher en base de données
    using (StructuralTranslationsProvider db = new StructuralTranslationsProvider())
    {
        Translation t = db.Load().Where(x => x.Key == key && x.Culture.Code == culture.IetfLanguageTag).FirstOrDefault();
        // La clef existe
        if (t != null)
        {
            return t.Text;
        }
        else // La clef n'existe pas en base
        {
            return null;
        }
    }
}

          

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication.Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:Label ID="Label1" runat="server" Text="Label1"></asp:Label>
    </div>
    </form>
</body>
</html>

          

using System;

namespace WebApplication
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {

        }
    }
}

          

protected void Page_Load(object sender, EventArgs e)
{
    Label1.Text = StructuralTranslationsManager.Load("000001", CultureInfo.CreateSpecificCulture("fr-FR"));
}

          

protected void Page_Load(object sender, EventArgs e)
{
    Label1.Text = StructuralTranslationsManager.Load("000001", CultureInfo.CreateSpecificCulture("en-GB"));
}

          

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication.Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:Label ID="Label1" runat="server" Text='<%# Business.StructuralTranslationsManager.Load("000001", 
				System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")) %>'></asp:Label>
    </div>
    </form>
</body>
</html>

          

protected void Page_Load(object sender, EventArgs e)
{
    this.DataBind();
}

          

/// <summary>
/// Renvoi la culture correspondant à l'internaute en fonction du contexte http
/// </summary>
/// <param name="httpContext"></param>
/// <returns></returns>
public static CultureInfo GetTranslationCulture(HttpContext httpContext)
{
    try
    {
        // Culture en tenant compte de la première langue définie dans le navigateur
        return new CultureInfo(
            httpContext.Request.UserLanguages[0].ToString());
    }
    // Des erreurs peuvent se produire si la région n'est pas spécifiée dans
    // le code de la culture (ex: [fr] au lieu de [fr-FR])
    catch
    {
        // Culture en tenant compte du thread
        return Thread.CurrentThread.CurrentUICulture;
    }
}

          

protected void Page_Load(object sender, EventArgs e)
{
    Label1.Text = StructuralTranslationsManager.Load("000001", StructuralTranslationsManager.GetTranslationCulture(HttpContext.Current));
}

          

double num = Convert.ToDouble("1,234.5");

          

double num = Convert.ToDouble("1,234.5", CultureInfo.CreateSpecificCulture("en-GB"));

          

/// <summary>
/// Requête LINQ compilée pour récupérer une traduction selon sa clef et sa culture
/// </summary>
private Func<StructuralTraductionsDataContext, string, CultureInfo, IQueryable<Translation>> LoadByKeyAndCulture = CompiledQuery.Compile(
    (StructuralTraductionsDataContext db, string key, CultureInfo culture) => from t in db.Translations
                                                                                join c in db.Cultures on t.CultureId equals c.CultureId
                                                                                where t.Key == key && c.Code == culture.IetfLanguageTag
                                                                                select t
    );

/// <summary>
/// Retourne un enregistrement de la table de traductions
/// </summary>
/// <param name="key">la clef métier correspondant à une traduction</param>
/// <param name="culture">la culture associée à la traduction</param>
/// <returns></returns>
public Translation Load(string key, CultureInfo culture)
{
    if (!string.IsNullOrEmpty(key) && culture != null)
    {
        return LoadByKeyAndCulture(db, key, culture).FirstOrDefault();
    }
    else
    {
        return null;
    }
}

        

/// <summary>
/// Chargement d'une traduction en fonction de la clef métier et la culture
/// </summary>
/// <param name="key">la clef métier</param>
/// <param name="culture">la culture</param>
/// <returns>la traduction</returns>
public static string Load(string key, CultureInfo culture)
{
    // Allons chercher en base de données
    using (StructuralTranslationsProvider db = new StructuralTranslationsProvider())
    {
        Translation t = db.Load(key, culture);
        // La clef existe
        if (t != null)
        {
            return t.Text;
        }
        else // La clef n'existe pas non plus en base
        {
            return null;
        }
    }
}

        

/// <summary>
/// Requête LINQ compilée pour récupérer la totalité de la table
/// </summary>
private Func<StructuralTraductionsDataContext, IQueryable<Translation>> LoadAll = CompiledQuery.Compile(
    (StructuralTraductionsDataContext db) => from t in db.Translations
                                                join c in db.Cultures on t.CultureId equals c.CultureId
                                                select t
    );


/// <summary>
/// Retourne la totalité des traductions
/// </summary>
/// <returns></returns>
public IQueryable<Translation> Load()
{
    return LoadAll(db);
}

          

/// <summary>
/// Champ stockant les traductions regroupées selon la culture
/// </summary>
private static Hashtable translations = new Hashtable();

          

/// <summary>
/// Méthode permettant de charger toutes les traductions dans la <c>Hashtable</c>
/// </summary>
public static void LoadTranslationsInMemory()
{
    using (StructuralTranslationsProvider db = new StructuralTranslationsProvider())
    {
        // Regroupement des enregistrements selon leur culture
        var c = db.Load().GroupBy(x => x.Culture.Code);
        // Pour chaque culture
        foreach (var i in c)
        {
            // Si la culture n'existe pas dans la Hashtable
            if (!translations.ContainsKey(i.Key))
            {
                // On crée un dictionnaire trié de toutes les traductions liées à la culture en cours de traitement.
                // La clef du dictionnaire est la clef métier de la traduction
                Hashtable table = new Hashtable(i.ToDictionary(y => y.Key));
                // On ajoute le dictionnaire à la table Hashtable
                translations.Add(i.Key, table);
            }
            else
            {
                // Le dictionnaire existe déjà.
            }
        }
    }
}

          

protected void Application_Start(object sender, EventArgs e)
{
    // Rafraîchissement du dictionnaire de traductions
    StructuralTranslationsManager.LoadTranslationsInMemory();
}

          

/// <summary>
/// Chargement d'une traduction en fonction de la clef métier et la culture
/// </summary>
/// <param name="key">la clef métier</param>
/// <param name="culture">la culture</param>
/// <returns>la traduction</returns>
public static string Load(string key, CultureInfo culture)
{
    // Si la culture existe dans la variable "translations"
    if (translations.ContainsKey(culture.IetfLanguageTag))
    {
        // On récupère le dictionnaire associé
        Hashtable dico = translations[culture.IetfLanguageTag] as Hashtable;
        // Si le dictionnaire existe et qu'il contient la clef
        if (dico != null && dico.ContainsKey(key))
        {
            // On retourne la traduction
            return (dico[key] as Translation).Text;
        }
        else // Le dictionnaire existe mais ne contient pas la traduction. Il peut s'agir d'une nouvelle entrée
        {
            // Allons chercher en base de données
            using (StructuralTranslationsProvider db = new StructuralTranslationsProvider())
            {
                Translation t = db.Load(key, culture);
                // La clef existe
                if (t != null)
                {
                    // On l'ajoute au dictionnaire
                    (translations[culture.IetfLanguageTag] as Hashtable).Add(t.Key, t);
                    return t.Text;
                }
                else // La clef n'existe pas non plus en base
                {
                    return null;
                }
            }
        }
    }
    else // Le dictionnaire demandé n'existe pas.
    {
        return null;
    }
}

          

<asp:Label ID="Label1" runat="server" Text="##000001-Hello...##"></asp:Label>

          

Label1.Text = "##000001-Hello...##";

          

/// <summary>
/// Expression régulière permettant de récupérer le texte à traduire dans une chaîne
/// </summary>
private static Regex r = new Regex(@"##(?<key>[\d]{6})(?<text>[-]{1}[\w\D]*?)##",
    RegexOptions.Compiled);

/// <summary>
/// Remplace un pattern par la traduction correspondant à la clef et la culture
/// </summary>
/// <param name="html">chaîne à parser</param>
/// <param name="culture">culture représentant la langue de traduction</param>
/// <returns>la chaîne traduite</returns>
public static string Translate(string html, CultureInfo culture)
{
    return r.Replace(html, new MatchEvaluator(delegate(Match m)
        {
            string key = m.Groups["key"].Value;
            string result = Load(key, culture);
            if (!string.IsNullOrEmpty(result))
            {
                return result;
            }
            else
            {
                return string.Format("{0}{1}", key, m.Groups["text"].Value);
            }
        }
    ));
}

          

/// <summary>
/// No comment
/// </summary>
/// <param name="writer"></param>
protected override void Render(HtmlTextWriter writer)
{
    using (StringWriter sw = new StringWriter())
    {
        using (HtmlTextWriter hw = new HtmlTextWriter(sw))
        {
            base.Render(hw);
        }

        writer.Write(StructuralTranslationsManager.Translate(sw.ToString(),
            StructuralTranslationsManager.GetTranslationCulture(HttpContext.Current)));
    }
}

          

public partial class Default : BasePage
{
    protected void Page_Load(object sender, EventArgs e)
    {

    }
}

          

/// <summary>
/// Classe de base pour la factorisation de l'implémentation de la traduction
/// </summary>
public class BasePage : System.Web.UI.Page
{
    /// <summary>
    /// No comment
    /// </summary>
    /// <param name="writer"></param>
    protected override void Render(HtmlTextWriter writer)
    {
        using (StringWriter sw = new StringWriter())
        {
            using (HtmlTextWriter hw = new HtmlTextWriter(sw))
            {
                base.Render(hw);
            }

            writer.Write(StructuralTranslationsManager.Translate(sw.ToString(),
                StructuralTranslationsManager.GetTranslationCulture(HttpContext.Current)));
        }
    }
}