IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Android Discussion :

Optimisation : hashmaps


Sujet :

Android

  1. #1
    Membre du Club
    Inscrit en
    Janvier 2008
    Messages
    64
    Détails du profil
    Informations forums :
    Inscription : Janvier 2008
    Messages : 64
    Points : 53
    Points
    53
    Par défaut Optimisation : hashmaps
    Salut à tous,
    Je viens de changer une bonne partie de mon code et y ai ajouter des hashmap, le problème c'est que c'est aps du tout optimisé et ca se sent

    Voici un bout de code :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    public static enum datas{ALLAPPS, SMS, CONTACTS, BROWSER, PHONE, WPP};
     
    	private static HashMap<Object, Bitmap> DicoDataBmp = new HashMap<Object, Bitmap>(){{
    		put(datas.ALLAPPS, null);
    		put(datas.SMS, null);
    		put(datas.CONTACTS, null);
    		put(datas.BROWSER, null);
    		put(datas.PHONE, null);
    		put(datas.WPP, null);
    	}};
     
    	private static HashMap<Object, String> DicoDataFilename = new HashMap<Object, String>(){{
    		put(datas.ALLAPPS, "file_allapps.jpg");
    		put(datas.SMS, "file_sms.jpg");
    		put(datas.CONTACTS, "file_contacts.jpg");
    		put(datas.BROWSER, "file_browser.jpg");
    		put(datas.PHONE, "file_phone.jpg");
    		put(datas.WPP, "file_wpp.jpg");
    	}};
     
    	private static HashMap<Object, Integer> DicoDataDefaultDrawable = new HashMap<Object, Integer>(){{
    		put(datas.ALLAPPS, R.drawable.ic_allapps);
    		put(datas.SMS, R.drawable.sms);
    		put(datas.CONTACTS, R.drawable.contacts);
    		put(datas.BROWSER, R.drawable.web);
    		put(datas.PHONE, R.drawable.phone);
    		put(datas.WPP, R.drawable.wallpaper_01);
    	}};
     
    public static void blabla(Context context){
    		// Load images from sdcard
    		File sdcard = Environment.getExternalStorageDirectory();
    		String file;
    		Bitmap bmp;
    		Object key;
     
    		for(Entry<Object, String> dico : DicoDataFilename.entrySet()){
    			key = dico.getKey();
    			file = new File(sdcard + File.separator + dico.getValue()).getAbsolutePath();
    			bmp = BitmapFactory.decodeFile(file);
    			if(bmp == null){
    				DicoDataBmp.put(key, BitmapFactory.decodeResource(context.getResources(), DicoDataDefaultDrawable.get(key)));
    			}else{
    				DicoDataBmp.put(key, bmp);
    			}
    		}
     
     
    	}
    Et la les gens qui ont plus l'habitude que moi de faire du Java sur Android sautent certainement au plafond
    Déjà je comprend pas bien pourquoi je ne peut pas faire passer mes "datas" pour des int comme en C++ ... ca me parmettrait d'utiliser des ParseArray.

    Bref, auriez vous une idée de comment je pourrais optimiser ca ?
    Merci d'avance.


    Edit :
    J'ai changer un peu le code, mais ca reste lent :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    	private static final int ALLAPPS = 0;
    	private static final int SMS = 1;
    	private static final int CONTACTS = 2;
    	private static final int BROWSER = 3;
    	private static final int PHONE = 4;
    	private static final int WPP = 5;
    	private static SparseArray<Bitmap> DicoDataBmp = new SparseArray<Bitmap>(){{
    		append(ALLAPPS, null);
    		append(SMS, null);
    		append(CONTACTS, null);
    		append(BROWSER, null);
    		append(PHONE, null);
    		append(WPP, null);
    	}};
     
    	private static SparseArray<String> DicoDataFilename = new SparseArray<String>(){{
    		append(ALLAPPS, "file_allapps.jpg");
    		append(SMS, "file_sms.jpg");
    		append(CONTACTS, "file_contacts.jpg");
    		append(BROWSER, "file_browser.jpg");
    		append(PHONE, "file_phone.jpg");
    		append(WPP, "file_wpp.jpg");
    	}};
     
    	private static SparseIntArray DicoDataDefaultDrawable = new SparseIntArray(){{
    		append(ALLAPPS, R.drawable.ic_allapps);
    		append(SMS, R.drawable.sms);
    		append(CONTACTS, R.drawable.contacts);
    		append(BROWSER, R.drawable.web);
    		append(PHONE, R.drawable.phone);
    		append(WPP, R.drawable.wallpaper_01);
    	}};

  2. #2
    Modérateur
    Avatar de Hizin
    Homme Profil pro
    Développeur mobile
    Inscrit en
    Février 2010
    Messages
    2 180
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Développeur mobile

    Informations forums :
    Inscription : Février 2010
    Messages : 2 180
    Points : 5 072
    Points
    5 072
    Par défaut
    Première question : pourquoi ce besoin ?
    Deuxième question : pourquoi passer par des Map, List... ?
    Troisième question : pourquoi 3 maps ?

    J'imagine que tu as souvent besoin de ces images si tu es parti dans ce genre d'optimisation.
    Android est optimisé pour la création rapide d'image avec un système de cache pour éviter de régénérer X fois la même image. Tu peux en créer un local à ton application, qui sera plus performant (appel application - application contre application - système - cache - système - application), mais pour indiquer des pistes, il faudrait savoir ce que tu souhaites réaliser, et pourquoi tu pars dans cette direction
    C'est Android, PAS Androïd, ou Androïde didiou !
    Le premier est un OS, le second est la mauvaise orthographe du troisième, un mot français désignant un robot à forme humaine.

    Membre du comité contre la phrase "ça marche PAS" en titre et/ou explication de problème.

    N'oubliez pas de consulter les FAQ Android et les cours et tutoriels Android

  3. #3
    Membre éprouvé
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Janvier 2007
    Messages
    697
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Calvados (Basse Normandie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : Janvier 2007
    Messages : 697
    Points : 1 241
    Points
    1 241
    Par défaut
    Pour récupérer un int à partir d'un data, tu as la méthode ordinal() :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int index = datas.ALLAPPS.ordinal();
    à noter que pour récupérer une enum à partir d'un entier tu peux faire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    datas enumValue = datas.values()[index];
    Ensuite pour l'optimisation, je doute que charger seulement 6 images en mémoire, peux importe la manière, soit une opération couteuse. Si tu veux mon avis ton problème est ailleurs...
    Par exemple es-tu sur de ne pas rappeler blabla() plusieurs fois dans ton programme ? Autre chose, Je dis ça par hasard vu qu'on n'a pas le reste du code mais il vaut mieux éviter de charger tes images dans le thread graphique (celui par défaut). Tu peux pour cela utilser un nouveau Thread ou une AsyncTask.

  4. #4
    Membre du Club
    Inscrit en
    Janvier 2008
    Messages
    64
    Détails du profil
    Informations forums :
    Inscription : Janvier 2008
    Messages : 64
    Points : 53
    Points
    53
    Par défaut
    Merci pour vos réponses

    Hizin :
    Je l'ai fait par ce que avant je faisais plusieurs fois les mêmes opérations, et plutot que faire autant d'appel de fonctions je trouvais plus fun de faire une boucle qui fasse tout toute seule.
    C'est à dire au lieu de faire 6 fois ChargerImage, MettreImageDansLaBonneVar, SaveImageDansMobile j'ai voulu faire une boucle qui peut aller chercher toutes les infos dont elle a besoin (surtout que dans le futurs ils est possible que ces appels passe de 6 à 12 ou plus).
    D'où mon choix de Map, grace a un indice, je peux get/set la variable corresponde, le nom de fichier et la valeur par défaut de cette variable (3infos, 3maps).

    Atha2 :
    Super merci pour l'info sur les enums, je vais plutot utiliser des tableaux du coup ^^ (et je lance en effet le code dans un new Thread()).

    Je met le code complet si ca vous parle plus. (y'a une balise "secret" su ce forum, que se soit plus buvable ?)

    Cette classe permet de changer le theme du mobile, en l'occurence ici les 5 docks icons de bases et le wallpaper(wpp). L'application est plus grande que ca, je télécharge les infos des thèmes depuis une base de donnée (résultat en JSON), les affiches dans des bouttons, quand je clique sur un bouton je télécharge un JSON qui me donne les url vers les images dont j'ai besoin.
    Je set les images dans le themes manager et appelle "ApplyTheme(Context context)".

    Toute la partie telechargement et JSON va plutot rapidement (selon la connexion), c'est depuis que j'ai mis ces Map que ca met plus de temps.
    [SECRET]
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    public class ThemeManager {	
     
    	private static final int ALLAPPS = 0;
    	private static final int SMS = 1;
    	private static final int CONTACTS = 2;
    	private static final int BROWSER = 3;
    	private static final int PHONE = 4;
    	private static final int WPP = 5;
            // Le launcher utilise les img de cet Array pour set les dockIcon
    	private static SparseArray<Bitmap> DicoDataBmp = new SparseArray<Bitmap>(){{
    		append(ALLAPPS, null);
    		append(SMS, null);
    		append(CONTACTS, null);
    		append(BROWSER, null);
    		append(PHONE, null);
    		append(WPP, null);
    	}};
     
            // Les fichiers qui serviront à save les images en local
    	private static SparseArray<String> DicoDataFilename = new SparseArray<String>(){{
    		append(ALLAPPS, "file_allapps.jpg");
    		append(SMS, "file_sms.jpg");
    		append(CONTACTS, "file_contacts.jpg");
    		append(BROWSER, "file_browser.jpg");
    		append(PHONE, "file_phone.jpg");
    		append(WPP, "file_wpp.jpg");
    	}};
     
            // Les images par défauts du launcher
    	private static SparseIntArray DicoDataDefaultDrawable = new SparseIntArray(){{
    		append(ALLAPPS, R.drawable.ic_allapps);
    		append(SMS, R.drawable.sms);
    		append(CONTACTS, R.drawable.contacts);
    		append(BROWSER, R.drawable.web);
    		append(PHONE, R.drawable.phone);
    		append(WPP, R.drawable.wallpaper_01);
    	}};
     
     
    	private final static String CURRENT_THEME_PCKG = "currentThemePackage";
     
    	public static void ApplyTheme(Context context){
    		// Calls to tell the launcher to set the dock icons 
    		HelperUI.SetCustomDockToolbar(context,true);
    		final ArrayList<ApplicationInfo> list = (ArrayList<ApplicationInfo>) LauncherModel.sWorkspaceItems.clone();
    	    HelperUI.SetAppList(list,true);
     
                // Set wpp
    	    if(DicoDataBmp.get(WPP) != null){
    		    try {
    		    	WallpaperManager.getInstance(context).setBitmap(DicoDataBmp.get(WPP));
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    	    }
    	}
     
            // Cette fonction est applée au démarrage du launcher
    	public static void SetTheme(Context context){
    		// Load images from sdcard
    		File sdcard = Environment.getExternalStorageDirectory();
    		String file;
    		Bitmap bmp;
    		int key;
     
    		for(int i=0 ; i<DicoDataFilename.size() ; i++){
    			key = DicoDataFilename.keyAt(i);
    			file = new File(sdcard + File.separator + DicoDataFilename.get(key)).getAbsolutePath();
    			bmp = BitmapFactory.decodeFile(file);
    			if(bmp == null){
    				DicoDataBmp.put(key, BitmapFactory.decodeResource(context.getResources(), DicoDataDefaultDrawable.get(key)));
    			}else{
    				DicoDataBmp.put(key, bmp);
    			}
    		}
     
    		ApplyTheme(context);
     
    	}
     
    	public static void SetDefaultTheme(Context context){
    		File sdcard = Environment.getExternalStorageDirectory();
    		File file;
    		FileOutputStream fos;
    		int key;
    		try {
     
    			for(int i=0 ; i<DicoDataFilename.size() ; i++){
    				key = DicoDataFilename.keyAt(i);
    				file = new File(sdcard + File.separator + DicoDataFilename.get(key));
    				fos = new FileOutputStream(file);
    				fos.write(0);
     
    				DicoDataBmp.put(key, BitmapFactory.decodeResource(context.getResources(), DicoDataDefaultDrawable.get(key)));
    			}
     
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
     
    		ApplyTheme(context);
    	}
     
    	// Get/Set
     
    	// TODO:
    	// If set null, set default
    	public static Bitmap getIcoBrowser() {
    		return DicoDataBmp.get(BROWSER);
    	}
     
    	public static Bitmap getIcoPhone() {
    		return DicoDataBmp.get(PHONE);
    	}
     
    	public static Bitmap getIcoContacts() {
    		return DicoDataBmp.get(CONTACTS);
    	}
     
    	public static Bitmap getIcoSms() {
    		return DicoDataBmp.get(SMS);
    	}
     
    	public static Bitmap getIcoAllApps() {
    		return DicoDataBmp.get(ALLAPPS);
    	}
     
    	public static Bitmap getWpp(){
    		return DicoDataBmp.get(WPP);
    	}
     
    	public static void setIcoBrowser(Bitmap bmp) {
    		DicoDataBmp.put(BROWSER, bmp);
    		saveImageToSD(bmp, BROWSER);
    	}
     
    	public static void setIcoPhone(Bitmap bmp) {
    		DicoDataBmp.put(PHONE, bmp);
    		saveImageToSD(bmp, PHONE);
    	}
     
    	public static void setIcoContacts(Bitmap bmp) {
    		DicoDataBmp.put(CONTACTS, bmp);
    		saveImageToSD(bmp, CONTACTS);
    	}
     
    	public static void setIcoSms(Bitmap bmp) {
    		DicoDataBmp.put(SMS, bmp);
    		saveImageToSD(bmp, SMS);
    	}
     
    	public static void setIcoAllApps(Bitmap bmp) {
    		DicoDataBmp.put(ALLAPPS, bmp);
    		saveImageToSD(bmp, ALLAPPS);
    	}
     
    	public static void setWpp(Bitmap bmp){
    		DicoDataBmp.put(WPP, bmp);
    		saveImageToSD(bmp, WPP);
    	}
     
    	public static void setIcoBrowser(String url) {
    		Bitmap bmp = getBitmapFromURL(url);
    		DicoDataBmp.put(BROWSER, bmp );
    		saveImageToSD(bmp, BROWSER);
    	}
     
    	public static void setIcoPhone(String url) {
    		Bitmap bmp = getBitmapFromURL(url);
    		DicoDataBmp.put(PHONE, bmp );
    		saveImageToSD(bmp, PHONE);
    	}
     
    	public static void setIcoContacts(String url) {
    		Bitmap bmp = getBitmapFromURL(url);
    		DicoDataBmp.put(CONTACTS, bmp );
    		saveImageToSD(bmp, CONTACTS);
    	}
     
    	public static void setIcoSms(String url) {
    		Bitmap bmp = getBitmapFromURL(url);
    		DicoDataBmp.put(SMS, bmp );
    		saveImageToSD(bmp, SMS);
    	}
     
    	public static void setIcoAllApps(String url) {
    		Bitmap bmp = getBitmapFromURL(url);
    		DicoDataBmp.put(ALLAPPS, bmp );
    		saveImageToSD(bmp, ALLAPPS);
    	}
     
    	public static void setWpp(String url){
    		Bitmap bmp = getBitmapFromURL(url);
    		DicoDataBmp.put(WPP, bmp );
    		saveImageToSD(bmp, WPP);
    	}
     
    	public static Bitmap getBitmapFromURL(String src) {
    	    try {
    	        URL url = new URL(src);
    	        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    	        connection.setDoInput(true);
    	        connection.connect();
    	        InputStream input = connection.getInputStream();
    	        Bitmap myBitmap = BitmapFactory.decodeStream(input);
    	        return myBitmap;
    	    } catch (IOException e) {
    	        e.printStackTrace();
    	        return null;
    	    }
    	}
     
    	private static void saveImageToSD(Bitmap toSave, int data) {
     
    	    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
     
    	    toSave.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
     
    	    File file = new File(Environment.getExternalStorageDirectory()
    	            + File.separator + DicoDataFilename.get(data));
    	    try {
    	        file.createNewFile();
    	    } catch (IOException e) {
    	        e.printStackTrace();
    	    }
     
    	    FileOutputStream fos = null;
    	    try {
    	        fos = new FileOutputStream(file);
    	    } catch (FileNotFoundException e) {
    	        e.printStackTrace();
    	    }
    	    try {
    	        fos.write(bytes.toByteArray());
    	        fos.close();
    	    } catch (IOException e) {
    	        e.printStackTrace();
    	    }
    	}
     
     
    }
    [/SECRET]

  5. #5
    Modérateur
    Avatar de Hizin
    Homme Profil pro
    Développeur mobile
    Inscrit en
    Février 2010
    Messages
    2 180
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Développeur mobile

    Informations forums :
    Inscription : Février 2010
    Messages : 2 180
    Points : 5 072
    Points
    5 072
    Par défaut
    Ah, un sujet qui sort de l'habitude, j'étais plutôt dans une optique "ListView".

    Citation Envoyé par faucheuse
    D'où mon choix de Map, grace a un indice, je peux get/set la variable corresponde, le nom de fichier et la valeur par défaut de cette variable (3infos, 3maps).
    Une Map sert à réaliser un lien clé/valeur. Pour un lien position/valeur (ou entier/valeur), tu peux simplement te diriger vers une List, ou vers un Sparse.

    As-tu besoin de toutes ces images en même temps ?
    Tu pourrais mettre un système de lazy loading chargeant l'image uniquement à la demande.

    Tu vérifies si l'image est chargée, si ce n'est pas le cas, tu la charges, dans les 2 cas, tu la renvois.
    C'est Android, PAS Androïd, ou Androïde didiou !
    Le premier est un OS, le second est la mauvaise orthographe du troisième, un mot français désignant un robot à forme humaine.

    Membre du comité contre la phrase "ça marche PAS" en titre et/ou explication de problème.

    N'oubliez pas de consulter les FAQ Android et les cours et tutoriels Android

  6. #6
    Expert éminent sénior
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 481
    Points : 48 806
    Points
    48 806
    Par défaut
    Les maps ne jouent pas sur la lenteur, comme déjà dit.

    Par contre le code est assez lourds. Il y a moyen de fortement réduire ça!


    D'abord, les Enum, ça peux stocker des propriété (ben oui); donc les constantes, on peux les stocker directement dedans (à supposer que les valeurs soient connues à la compilation et constantes):


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public static enum Datas{
        ALLAPPS(R.drawable.ic_allapps,"file_allapps.jpg"), 
        SMS( R.drawable.sms,"file_sms.jpg"), 
        CONTACTS(R.drawable.contacts,"file_contacts.jpg"), 
        BROWSER(R.drawable.web,"file_browser.jpg"), 
        PHONE(R.drawable.phone,"file_phone.jpg"), 
        WPP(R.drawable.wallpaper_01,"file_wpp.jpg");
     
        Datas(int drawable, String file){
            this.file=file;
            this.drawable = drawable;
        }
        public int getDrawable(){return drawable;}
        public int getFile(){return file;}
    }
    Enfin, pour la HashMap qu'il te reste, il existe des EnumMap, bien plus performantes quand les clés sont des enums:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    private static Map<Datas,Bitmap> DicoDataBmp = new EnumMap<Datas, Bitmap>(); // pourquoi mettre des null au fait?

    Ce qui ramènerait ta boucle initiale à

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    		for(Datas data: Datas.values()){
    			file = new File(sdcard + File.separator + data.getFile()).getAbsolutePath();
    			bmp = BitmapFactory.decodeFile(file);
    			if(bmp == null){
    				DicoDataBmp.put(data, BitmapFactory.decodeResource(context.getResources(), data.getDrawable()));
    			}else{
    				DicoDataBmp.put(data, bmp);
    			}
    		}

  7. #7
    Membre du Club
    Inscrit en
    Janvier 2008
    Messages
    64
    Détails du profil
    Informations forums :
    Inscription : Janvier 2008
    Messages : 64
    Points : 53
    Points
    53
    Par défaut
    Super ! Merci beaucoup, je vais regarder tous ca ^^

Discussions similaires

  1. Optimisation de votre SGBDR et de vos requêtes...
    Par SQLpro dans le forum Langage SQL
    Réponses: 35
    Dernier message: 11/01/2013, 12h49
  2. [langage] Optimiser la lecture d'un fichier
    Par And_the_problem_is dans le forum Langage
    Réponses: 4
    Dernier message: 05/02/2003, 09h54
  3. [VB6] [BDD] Optimisation de l'accès aux données
    Par LadyArwen dans le forum VB 6 et antérieur
    Réponses: 8
    Dernier message: 30/01/2003, 14h27
  4. [langage]Problème de temps de lecture, optimisation
    Par And_the_problem_is dans le forum Langage
    Réponses: 2
    Dernier message: 08/01/2003, 09h47
  5. [langage] Optimiser la lecture d'un fichier
    Par And_the_problem_is dans le forum Langage
    Réponses: 2
    Dernier message: 11/06/2002, 11h24

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo