Discussion :

[nebule]

Bonjour,

J'ai cherché, testé, recherché, retesté mais sans succès.

J'ai un besoin simple : j'ai un fichier dont je connais le chemin et je souhaite le transformer en tableau de byte[].

J'ai essayé avec plusieurs inputstream / outputstream &co mais je comprends pas grand chose !

Quelqu'un pourrait-il m'éclaire

Merci

[TigrouMeow]

Cadeau :

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
 
        static public byte[] StreamtoByteArray(Stream stream)
        {
            int offset = 0;
            int remaining = (int)stream.Length;
            byte[] data = new byte[remaining];
            while (remaining > 0)
            {
                int read = stream.Read(data, offset, remaining);
                if (read <= 0)
                    throw new EndOfStreamException();
                remaining -= read;
                offset += read;
            }
            return data;
        }
 
        static public byte[] FileToByteArray(string path)
        {
            FileStream fs = new FileStream(path, FileMode.Open);
            byte[] binary = StreamtoByteArray(fs);
            fs.Close();
            return binary;
        }

Plus qu'à appeler FileToByteArray ! Par contre il me semble que y'a une technique un peu plus directe avec .NET 2, mais perso j'utilise ce qui est au dessus depuis un bon moment, et ça marche bien.

[nebule]

Cadeau :

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
 
        static public byte[] StreamtoByteArray(Stream stream)
        {
            int offset = 0;
            int remaining = (int)stream.Length;
            byte[] data = new byte[remaining];
            while (remaining > 0)
            {
                int read = stream.Read(data, offset, remaining);
                if (read <= 0)
                    throw new EndOfStreamException();
                remaining -= read;
                offset += read;
            }
            return data;
        }
 
        static public byte[] FileToByteArray(string path)
        {
            FileStream fs = new FileStream(path, FileMode.Open);
            byte[] binary = StreamtoByteArray(fs);
            fs.Close();
            return binary;
        }

Plus qu'à appeler FileToByteArray ! Par contre il me semble que y'a une technique un peu plus directe avec .NET 2, mais perso j'utilise ce qui est au dessus depuis un bon moment, et ça marche bien.

Merci, par contre si je ne m'abuse, s'est pas du java

[TigrouMeow]

Pfiouuuuuuuuuuuu Ahah, bon j'espère que la logique est la même, que mon post serve à quelque chose

[nebule]

Pfiouuuuuuuuuuuu Ahah, bon j'espère que la logique est la même, que mon post serve à qqchose

La logique oui mais les classe à utiliser non et s'est la que je bloque

[nebule]

Element de réponse trouvé sur un vieux vieux post (merci )

http://www.developpez.net/forums/showthread.php?t=38795

[Janitrix]

Il faut avoir l'esprit clair pour comprendre comment fonctionne tous ces Streams .

Voici ce que je ferais (je sors ça de tête, c'est non testé, c'est juste pour te montrer la voie) :

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
 
/* On créer une nouvelle méthode qui retourne un tableau de byte
et avec un trhows IOException afin de pouvoir gérer les erreurs à notre guise */
public byte[] getArrayByteFromFile(File f) throws IOException {
/* On récupère la taille du fichier en octet,
donc le nombre de byte qu'on devra lire */
int length = f.length();
/* On crée un tableau de byte avec une longueur
égal à la taille du fichier (logique non :mrgreen: ?)*/
byte[] data = new byte[length];
/* Partie intéressante : on crée un BufferedInputStream,
qui va nous permettre de lire plusieurs byte d'un coup */
BufferedInputStream in = new BufferedInputStream(new FileInputStream(f));
/* On lit la totalité du ficher. Le premier paramètre est le tableau de byte qui va recevoir les données,
le deuxième est la position dans le fichier où on commence à lire les données (donc zéro puisqu'on commence au début du fichier),
enfin le dernier paramètre est le nombre d'octet que l'on veut lire,
ici on donne length puisqu'on veut lire la totalité du fichier d'un coup. */
int result = in.read(data, 0, length);
 
return data;
}

Pour voir en détail la classe BufferedInputStream...

La variable result contient -1 si la fin du fichier a été atteinte, autrement dit, si la lecture a réussie, cette variable doit contenir -1. Enfin, je crois.

Bonne chance

[edit] Arf, j'ai mis 7 minutes à rédiger mon post, j'ai pas vu que tu avais la réponse

[BartRoX]

Pfiouuuuuuuuuuuu Ahah, bon j'espère que la logique est la même, que mon post serve à quelque chose

Moi je développe en C#, et 5 ans plus tard, ton post m'aura été utile, merci !

(Et merci Google )