Discussion :

[degio1er]

Salut à tous,
j'ai un fichier .txt avec une ligne qui possède des caractères invisibles à Windows. Quand j'importe ce fichier sous UNIX, ses caractères apparaissent clairement.

La ligne sous Windows :

021000012509140420121600000000000xxxxxxxxxxxxxxxxxxxxxxxx00000

la ligne sous UNIX :

\357\273\277021000012509140420121600000000000xxxxxxxxxxxxxxxxxxxxxxxx00000

Mon souci est de pouvoir vérifier la présence de ses caractères et ramener un message erreur avec la ligne concernée.

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
 
//Effectue un test sur le fichier afin de contrôler les caractères invisibles
                bool retour = true;
                int longueurLigne = 128; // Les caractères maximum sur une ligne doivent etre de 128.
                StreamReader sr = new StreamReader(FILEDIALOG.FileName, Encoding.UTF8); //recuperation du fichier à controler
 
                string s = string.Empty;
                while ((s = sr.ReadLine()) != null)
                {
                    if (s.Length > longueurLigne)
                    {
                        retour = false;
                        string[] lines_caractere = { "Présence de caractères invisibles sur la ligne : " + " " + s };
                        //remplir le fichier erreur.txt avec retour à la ligne
                        System.IO.File.WriteAllLines(Application.StartupPath + "\\erreur.txt", lines_caractere);
                        TXT.Text = "";
                    }
                }
                string text = Convert.ToString(retour);

Ce code ne détecte pas la présence des caractères invisibles en début de lignes et Je sollicite votre aide.

[sevyc64]

Le caractère représenté par la notation \357\273\277 dans ton exemple est très certainement un caractère invisible appelé "espace insécable sans chasse" ("zero-width no-break space" en anglais), codé sur 4 octets. Lorsque ce caractère est situé en toute première place d'un fichier, ce n'est pas un caractère mais ce que l'on appelle le BOM (Byte Order Mark) qui est là pour indiqué que ton fichier est en enregistré au format unicode et indique quel type d'unicode.

La solution est soit d'ouvrir ton fichier en spécifiant que c'est de l'unicode avec BOM, si ton logiciel le permet, soit de convertir ton fichier en unicode sans BOM. Dans ce cas, ce caractère n'y serait pas, et le logiciel devra savoir quel unicode il devra utiliser (ce qui généralement ne pose aucun problème).

[tomlev]

Effectivement "\357\273\277" correspond à la notation octale du BOM UTF-8 (EF BB BF en hexa)

Normalement les éditeurs modernes savent traiter correctement ce code qui indique que le fichier est encodé en UTF-8 ; en aucun cas ils ne doivent être affichés. Je ne sais pas quel éditeur tu utilises sous UNIX, mais il doit dater un peu

Ce code ne détecte pas la présence des caractères invisibles en début de lignes

Au contraire, il les détecte et les ignore, ce qui est le comportement correct... Pourquoi cherches-tu à contrôler la présence de ces caractères ?

[degio1er]

Merci à sevyc64 et tomlev pour vos réponses.

Pourquoi cherches-tu à contrôler la présence de ces caractères ?

Le nombre d'enregistrements sur une ligne doit être de 128 caractères. Alors je veux pouvoir vérifier la présence de ces "espaces insécables sans chasse" afin de détecter si le nombre d'enregistrements sur une ligne n'excède pas les 128 caractères. Le traitement de ce fichier se fait sur un applicatif installé sur le système UNIX. Les caractères sont invisibles et ignorés sous WINDOWS mais visibles sous UNIX et du coup cela crée un problème. Je ne sais pas si mon explication est claire.

Comment puis-je détecter la présence de ces caractères en début de fichier ?

[tomlev]

OK, donc il faut que tu re-encodes le fichier dans un format que ton applicatif UNIX comprend. Est-ce qu'il comprend l'UTF-8 sans BOM au moins?

Si oui tu peux faire ça :

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
 
var utf8WithoutBOM = new UTF8Encoding(false);
TranscodeFile(inputFile, Encoding.UTF8, outputFile, utf8WithoutBOM);
 
...
 
private void TranscodeFile(string inputFile, Encoding inputEncoding, string outputFile, Encoding outputEncoding)
{
     using (var reader = new StreamReader(inputFile, inputEncoding))
     using (var writer = new StreamWriter(outputFile, false, outputEncoding))
     {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            writer.WriteLine(line);
        }
     }
}

Si ça marche pas bien (par exemple les caractères accentués qui passent pas), essaie avec un autre encodage comme Encoding.Default ou Encoding.GetEncoding("iso-8859-1") à la place de utf8WithoutBOM

[degio1er]

OK, donc il faut que tu re-encodes le fichier dans un format que ton applicatif UNIX comprend. Est-ce qu'il comprend l'UTF-8 sans BOM au moins?

tomlev, re-encodé le fichier ne résoudra pas le problème. Je serai encore obligé de traiter un fichier en sortie avec le nouveau code. Or je veux simplement vérifier la présences des caractères "espaces insécables sans chasse" et afficher un message d'erreur à l'utilisateur afin qu'il transfert le fichier au service compétent pour la correction sur UNIX.

Je fais ce code qui me renvoi pour l'instant l'encodage du fichier, mais je n'arrive toujours pas à détecter la présence des caractères dans le fichier.

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
 
utf8 = new UTF8Encoding(false);
                string fileName = FILEDIALOGBIAO.FileName;
                string[] lignes = File.ReadAllLines(fileName);
                int lignesfichier = lignes.Length;
 
                Encoding enc = null;
                FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
                if (file.CanSeek)
                {
                    byte[] bom = new byte[4]; // Obtenez la marque d'ordre d'octet, s'il en existe un
                    file.Read(bom, 0, 4);
                    if (bom[0] == 0xef && bom[1] == 0xbb && bom[2] == 0xbf) // utf-8
                    {
                        enc = Encoding.UTF8;
                    }
                    else if ((bom[0] == 0xff && bom[1] == 0xfe) || // ucs-2le, ucs-4le, and ucs-16le
                        (bom[0] == 0 && bom[1] == 0 && bom[2] == 0xfe && bom[3] == 0xff)) // ucs-4
                    {
                        enc = Encoding.Unicode;
                    }
                    else if (bom[0] == 0xfe && bom[1] == 0xff) // utf-16 and ucs-2
                    {
                        enc = Encoding.BigEndianUnicode;
                    }
                    else // ANSI, Default
                    {
                        enc = Encoding.Default;
                    }
                    // Maintenant repositionner le fichier curseur au début du fichier
                    file.Seek(0, SeekOrigin.Begin);
                }
                else
                {
                    enc = Encoding.Default;
 
                }
                MessageBox.Show(Convert.ToString(enc));