Demande conseils pour la localisation (traduction)

Bonjour,

Mon projet est constitué de 3 applications que je voudrais localiser.
J'aimerais que les 3 applications utilisent un "fichier" de traduction commun.

Comment d'après vous dois-je m'y prendre pour que les traductions communes se retrouvent dans un unique .dll et que je puisse y accéder à partir de mes 3 applications?

Merci!!

Bonjour

Perso, mais ça n'engage que moi, je trouve le système de localisation par dll assez pourri dans le sens ou si tu veux éditer une traduction, tu es un peu bloqué
par l'utilisation de visual studio.

Pour remédier à celà, je préfère utiliser le système suivant:

Un fichier XML de traduction par langue, genre FR.xml, UK.xml, etc...
et qui contient la sérialisation d'une liste genre (exemple rapide, j'ai pas le code sous la main)
Code:

1 2 3 4 5 6 7 8 List<traduction> items = new List<traduction> ... class traduction { public string id; public string traduction; }
et ensuite, dans mon code, j'ai un singleton qui gère le chargement du fichier et quelques méthodes genre:
Code:

1 2 Translate(Form f); string trad TranslateText(string id);
La méthode Translate fait de la récursivité pour lister tous les controles appartenant à mon controle et qui utilise le nom du controle comme clé de recherche.
L'avantage de mon système est que je peux changer le fichier de langue facilement, voir, à la volée dans l'application.

Voilà ma technique :)

Merci pour ta réponse' Ça a en effet l'air bien attirant! Aurais-tu par hasard un lien vers ta méthode décrite ici..mais un peu pleus étoffée?

Merci!

Bah non, parce que en fait, s'est un développement que j'ai fait dans le cadre de mon boulot :)

Mais je peux te donner ça quand même :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Serialization;
 
namespace MyTranslater
{
    public class Translate
    {
        private static Translate instance = null;
        private Dictionary<string, TranslateItem> items = new Dictionary<string, TranslateItem>();
        private List<TranslateItem> listItems = null;
 
        public List<TranslateItem> ListItems
        {
            get { return listItems; }
            set { listItems = value; }
        }
 
        public static Translate GetInstance()
        {
            if (instance == null)
            {
                instance = new Translate();
            }
 
            return instance;
        }
 
        public string GetText(string id)
        {
            if (items != null)
            {
                if (items.ContainsKey(id.ToUpper()))
                {
                    return items[id.ToUpper()].Text;
                }
                else
                {
                    return string.Empty;
                }
            }
            else
            {
                return string.Empty;
            }
        }
 
        public void Create()
        {
            listItems = new List<TranslateItem>();
            items = new Dictionary<string, TranslateItem>();
        }
 
        public void TranslateControle(Control control)
        {
            control.Text = GetText(control.Name);
            foreach (Control child in control.Controls)
            {
                TranslateControle(child);
            }
        }
 
        public void TranslateAll(List<Control> controle)
        {
            foreach (Control c in controle)
            {
                TranslateControle(c);
            }
        }
 
        public void Load(string file)
        {
            if (File.Exists(file))
            {
                XmlSerializer xml = new XmlSerializer(typeof(List<TranslateItem>));
                StreamReader reader = new StreamReader(file, Encoding.UTF8);
                listItems = (List<TranslateItem>)xml.Deserialize(reader);
                reader.Close();
                items = new Dictionary<string, TranslateItem>();
                if (listItems != null)
                {
                    foreach (TranslateItem item in listItems)
                    {
                        if (!items.ContainsKey(item.Id.ToUpper()))
                        {
                            items.Add(item.Id.ToUpper(), item);
                        }
                    }
                }
            }
        }
 
        public void Save(string file)
        {
            XmlSerializer xml = new XmlSerializer(typeof(List<TranslateItem>));
            StreamWriter writer = new StreamWriter(file, false, Encoding.UTF8);
            xml.Serialize(writer, listItems);
            writer.Close();
        }
 
        public void Generate(Form f)
        {
            Generate(GetControls(f));
        }
 
        public void Generate(List<Control> controles)
        {
            listItems = new List<TranslateItem>();
            foreach (Control c in controles)
            {
                AddControl(c);
            }
        }
 
        private void AddControl(Control c)
        {
            if (c.Name != string.Empty)
            {
                if (!items.ContainsKey(c.Name.ToUpper()))
                {
                    TranslateItem item = new TranslateItem(c.Name.ToUpper(), c.Text);
                    listItems.Add(item);
                    items.Add(c.Name.ToUpper(), item);
                }
            }
            foreach (Control child in c.Controls)
            {
                AddControl(child);
            }
        }
 
        public void TranslateForm(Form form)
        {
            TranslateAll(GetControls(form));
        }
 
        public List<Control> GetControls(Control form)
        {
            List<Control> controlList = new List<Control>();
            controlList.Add(form);
            //foreach (Control c in form.Controls)
            //{
            //    controlList.Add(c);
            //}
            return controlList;
        }
    }
 
    public class TranslateItem
    {
        private string id = string.Empty;
        private string text = string.Empty;
 
        public string Text
        {
            get { return text; }
            set { text = value; }
        }
 
        public string Id
        {
            get { return id; }
            set { id = value; }
        }
 
        public TranslateItem()
        {
        }
 
        public TranslateItem(string a, string b)
        {
            id = a;
            text = b;
        }
    }
}

Après, faudra surement adapter en fonction du contexte pour que des controles qui utilisent non pas "controls" mais autres choses (datagridview par exemple) soient traduits
(je pense aux colonnes d'un DGV par exemple)

Waow...extraordinaire :-)
Je regarde ça de très près!!
Un tout grand merci!!