Discussion :

[maa]

Bonjour,

Je cherche à implémenter en c# l'équivalent de la fonction Clipper suivante :

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
 
 STRTRAN()
 Recherche et remplace des caractères dans une chaîne de caractères ou un
 champ mémo
------------------------------------------------------------------------------
 Syntaxe
 
     STRTRAN(<cChaine>, <cCherche>,
        [<cRemplace>], [<nDebut>], [<nCompte>]) --> cNouvChaine
 
 Arguments
 
     <cChaine> est la chaîne de caractères ou le champ mémo à parcourir.
 
     <cCherche> est la séquence de caractères à trouver.
 
     <cRemplace> est la séquence de caractères devant remplacer
     <cCherche>. Si cet argument n'est pas spécifié, les occurrences trouvées
     sont remplacées par une chaîne vide ("").
 
     <nDebut> est la première occurrence à remplacer. Si cet argument est
     omis, la valeur par défaut est un.
 
     <nCompte> est le nombre d'occurrences à remplacer. Si cet argument
     n'est pas spécifié, la valeur par défaut est tout.

Comment faire cela le plus efficacement possible. C'est une fonction qui va être appelée en série par SQL server sur plusieurs millions d'enregistrements. J'ai besoin qu'elle soit le plus efficace possible.

Merci d'avance pour vos suggestions.

[NoCxDev2]

Salut !

Simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
String SourceString = "0101";
SourceString.Replace("0", "2");

Donnera "2121".

Sinon jette un œil sur les expressions régulière si tu veux rechercher des éléments plus complexe dans la string source.

[NoCxDev2]

Pour ce qui est des autres paramètres regarde les methodes (SubString, IndexOf) disponibles sur une String.

Tu à tout à disposition.

GL

[maa]

Je vois comment faire avec IndexOf + substring + replace. Mais je cherche la méthode la plus efficace possible.

[NoCxDev2]

Ah le problème est sur la performance!

Dans ce cas utilise la classe StringBuilder pour des opérations rapides.
Car beaucoup de méthodes de la classe String utilisent des objets temporaires qui peuvent couter cher.

Par contre String.IndexOf est une des méthodes les plus rapide. Par exemple utiliser IndexOf avec des liste de keyValue pour toutes les lettres est plus rapide que ToUpper ou ToLower.

Il faut creuser un peu.

[maa]

ok merci, j'ai opté pour ça. Un peut redondant, mais efficace je crois.

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
 
        static string Replace(string cChaine, string cCherche, string cRemplace, int? nDebut, int? nCompte)
        {
            if (cRemplace == null)
                cRemplace = string.Empty;
 
            bool lFirstParam = nDebut != null && nDebut != 1;
            bool lSecondParam = nCompte != null;
 
            if (nCompte == 0)
                return cChaine;
 
            if (lFirstParam && lSecondParam)
            {
                int j = -1;
                for (int i = 0; i < nDebut; i++)
                {
                    int j2 = cChaine.IndexOf(cCherche, j + 1);
                    if (j2 < j)
                        return cChaine;
                    j = j2;
                }
                int k = j - 1;
                for (int i = 0; i < nCompte; i++)
                {
                    int k2 = cChaine.IndexOf(cCherche, k + 1);
                    if (k2 < k)
                        return string.Concat(cChaine.Substring(0, j), cChaine.Substring(j).Replace(cCherche, cRemplace));
                    k = k2;
                }
                if (k > j)
                    k += cCherche.Length;
                return string.Concat(cChaine.Substring(0, j), cChaine.Substring(j, k - j).Replace(cCherche, cRemplace), cChaine.Substring(k));
            }
            else if (lFirstParam)
            {
                int j = -1;
                for (int i = 0; i < nDebut; i++)
                {
                    int j2 = cChaine.IndexOf(cCherche, j + 1);
                    if (j2 < j)
                        return cChaine;
                    j = j2;
                }
                return string.Concat(cChaine.Substring(0, j), cChaine.Substring(j).Replace(cCherche, cRemplace));
            }
            else if (lSecondParam)
            {
                int k = -1;
                for (int i = 0; i < nCompte; i++)
                {
                    int k2 = cChaine.IndexOf(cCherche, k + 1);
                    if (k2 < k)
                        return cChaine.Replace(cCherche, cRemplace);
                    k = k2;
                }
                k += cCherche.Length;
                return string.Concat(cChaine.Substring(0, k).Replace(cCherche, cRemplace), cChaine.Substring(k));
            }
            else
                return cChaine.Replace(cCherche, cRemplace);
        }

[NoCxDev2]

Ouep, pas top niveau réutilisation du code mais çà semble efficace.

Un seul petit commentaire, tu pourrais utiliser le polymorphisme plutôt que les type Nullable, c'est plus agréable à l'utilisation. Enfin seulement si c'est une méthode utiliser par des tiers.

Bye

[maa]

En fait je suis obligé d'utiliser le type object car un projet pour SQL Server n'accepte pas les type nullable en paramètre des fonctions portant l'attribut SqlFunction.

[harz62]

Si tu peux refactorise ta méthode pour améliorer sa lisibilité ainsi que sa facilité de maintenance.

[maa]

oui mais je perds en efficacité. Peux être pas beaucoup ? J'ai du mal à m'en rendre compte...

[NoCxDev2]

Tu pourrais utiliser les paramètres optionnels de c# :

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
 
    public int Addition(String s, params int[] numbers) {
       int temp = 0;
       foreach( int i in numbers ) {
          temp += i;
          Console.WriteLine( s + i.ToString() );
       }
       return temp;
    }

OU

Avoir plusieurs signature pour ta méthode (c'est le plus propre) :

static string Replace(string cChaine, string cCherche, string cRemplace)
static string Replace(string cChaine, string cCherche, string cRemplace, int nDebut)
static string Replace(string cChaine, string cCherche, string cRemplace, int nCompte)
static string Replace(string cChaine, string cCherche, string cRemplace, int nDebut, int nCompte)

Qui finissent tous par appeler la plus complète.

OU

Utiliser le Wrapper "Integer" plutot que le type de base "int". Car le passage d'un Integer se fait par référence donc peut être null.
Sachant que la conversion Integer>int et int>Integer se fait automatiquement.

static string Replace(string cChaine, string cCherche, string cRemplace, Integer nDebut, Integer nCompte)

Voila!

[maa]

Je ne peux pas avoir plusieurs ovlerload pour une méthode dans un projet SQL Server.
Je ne souhaite pas appeler à chaque fois la méthode la plus complexe car je vais alors parfois concaténer des chaines vides ou faire des substring sur une longueur de 0 ce qui est du travail inutile...
Pour le wrapper Integer, à quel namespace appartient t-il ? Je ne l'ai pas dans l'intellisens.

[harz62]

Tu pourrais utiliser les paramètres optionnels de c#

Euh les paramètres optionnels n'existent pas en C#.

Pour le wrapper Integer, à quel namespace appartient t-il ? Je ne l'ai pas dans l'intellisens.

On passe un entier via un SqlParameter de type SqlType.Integer

[NoCxDev2]

Euh les paramètres optionnels n'existent pas en C#.

As-tu pris la peine de regarder mon exemple ?

Cela existe, et permet d'avoir un comportement se rapprochant des paramètres optionnels.

Bye