Discussion :

[h4miel]

Bonjour a tous et merci d'avance de l'attention porté a ce post.
Je vous explique mon problème.
J'ai une chaîne de caractère sur laquelle je souhaite faire un Split().
Voici un exemple de chaîne de caractère.
"Appel les pompiers\n(x)Vérifier l'entrée[......\n......\n....]\nOuvrir le portail\n(.)contact le service technique[.......\n.......\n.......]\n(.)contact le prestataire\n(x)tester la sortie\nConsigner l'événement"

Mon problème: Je dois utiliser "\n" comme délimiteur, mais j'ai besoin que mon Split() ignore ce qui se trouve entre les crochet et qu'il me retourne donc:
"Appel les pompiers",
"(x)Vérifier l'entrée[......\n......\n....]",
"Ouvrir le portail",
"(.)contact le service technique[.......\n.......\n.......]",
...


[Edit]
Je réfléchi aussi à la possibilité de faire ça avec une Regex, mais elle n'est pas évidente a écrire non plus.

Voila, j’espère avoir été clair.
Si vous avez besoin du moindre éclaircissement n'hésitez pas.
Merci

[popo]

Pour quelle raison tu te compliques la vie ?
Soit tu changes le \n entre les crochets par autre chose. Soit tu change le \n de séparation par autre chose.

Est-tu obligé d'avoir le même séparateur ?

[h4miel]

Oui je dois utiliser le même séparateur, je ne me complique pas la tâche pour le plaisir .
Enfait j'utilise une fonction qui Split une première fois le string que je lui passe, en utilisant comme délimiteur le \n, puis si une des expressions spliter contient quelquechose entre crochet, je dois pouvoir Split le contenu entre crochet, et cela autant de fois qu'il y a de crochet dans mon string.
Pour etre un peu plus clair, je peux très bien avoir à traiter un string du genre:
"blablaba\n blalabala[efsgsrhh\n dsefsf[dsfsfoqs\n deffsgg]\n dsijfsffsf]\n dsfsfsfs\n dsdfsf"
Et cela doit me retourner en premier:
"blablaba"
"blalabala[efsgsrhh\n dsefsf[dsfsfoqs\n deffsgg]\n dsijfsffsf]"
"dsfsfsfs"
"dsdfsf"

puis au deuxième tour, ma fonction ne traite que l'expression qui contient des [] et doit retourner:
"efsgsrhh"
"dsefsf[dsfsfoqs\n deffsgg]"
" dsijfsffsf"

et enfin au troisième tour:
"dsfsfoqs"
"deffsgg"

Comme il peut y avoir une infinité d'expression entre crochet, je ne peux pas utiliser un délimiteur différents a chaque fois.

C'est assez difficile a saisir, j'espere que je m'exprime bien

[DotNetMatt]

Pas le temps de tester, donc pas sûr que ça marche du premier coup, ni que ça soit bien optimisé. L'idée c'est d'utiliser des expressions régulières et une méthode récursive. Exemple :

On split sur les "\n" :

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// La chaine d'entrée que l'on veut traiter
var input = "blablaba\n blalabala[efsgsrhh\n dsefsf[dsfsfoqs\n deffsgg]\n dsijfsffsf]\n dsfsfsfs\n dsdfsf";
 
// Ce qu'on cherche
var pattern = "\\n";
 
// Initialisation de la Regex
var r = new Regex(pattern);
 
// On split pour se débarasser des "\n"
var splitted = r.Split(input);
 
// On regroupe pour retrouver un string sans "\n"
var contat = string.Join("", splitted);

On chercher les "[" et les "]" :

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// On réinitialise le pattern
pattern = @"(\[)([a-z]*\s{1,2}[a-z]*)?(\[)([a-z]*)?\s{1,2}([a-z]*)?(\])\s{1,2}([a-z]*)(\])";
 
// On réinitialise la Regex avec le nouveau pattern
r = new Regex(pattern);
 
// On récupère les groupes qui matchent le pattern
var matches = r.Matches(splittedInput);
 
// On boucle sur chacun des matches afin de récupérer les groupes qui nous intéressent
foreach (Match match in matches)
{
    var extracted = match.Groups[x]; // remplacer x par le/les groupes qui sont intéressants
}

Ensuite l'idée est de mettre cette logique dans une méthode récursive qui va traiter l'ensemble de ta chaîne d'entrée au fur et à mesure. Il est peut-être possible d'optimiser la seconde regex. En attendant, voici comment la lire :
- Groupe 0 (\[) contient le "[" ouvrant
- Groupe 1 ([a-z]*\s+[a-z]*)? puis des chaînes de caractères alphabétiques séparées par un espace
- Groupe 2 (\[)? puis éventuellement un "[" ouvrant
- Groupe 3 ([a-z]*\s+?[a-z]*)? puis une chaîne de caractères alphabétiques, un espace et une chaîne de caractères
- Groupe 4 puis éventuellement une chaîne de caractères alphabétiques
- Groupe 5 (\]) puis éventuellement un "]" fermant
- \s+ puis un espace
- Groupe 6 ([a-z]*)? puis une chaîne de caractères alphabétiques
- Groupe 7 (\]) puis éventuellement un "]" fermant

Tel quel, ça devrait fonctionner pour l'exemple que tu as donné, mais si l'exemple est éloigné de la réalité, il y aura des ajustements à faire au niveau du pattern.

[h4miel]

Je vais essayer d'adapter ta solution pour mes besoins, mais j'ai l'impression que c'est bien plus compliquer que ce que je cherche.
Le fait d'enlever les \n et de rassembler le tout ne fait pas mes affaire non plus.
Tout ce dont j'ai besoin, c'est d'arriver à ignorer ce qui se trouve entre crochet lors de mon premier split(). Si j'arrive a faire ça, le reste se débloquera de lui même.
En tout cas merci beaucoup de ton aide.

[mkl238]

Bonjour,

Tu peux aussi le faire "à l'ancienne" comme par exemple ce qui suit (qui ne gère pas les crochets inclus mais ce ne serait pas plus compliqué que de compter le nombre de crochets ouvrants et retrancher les fermants):

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
string input = "Appel les pompiers\n(x)Vérifier l'entrée[......\n......\n....]\nOuvrir le portail\n(.)contact le service technique[.......\n.......\n.......]\n(.)contact le prestataire\n(x)tester la sortie\nConsigner l'événement";
 
List<string> output = new List<string>();
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < input.Length; i++)
{
    if (input[i] == '\n')
    {
        output.Add(stringBuilder.ToString());
        stringBuilder.Clear();
    }
    else
    {
        stringBuilder.Append(input[i]);
        if (input[i] == '[')
        {
            while (input[i] != ']')
            {
                stringBuilder.Append(input[++i]);
            }
        }
    }
}
output.Add(stringBuilder.ToString());