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
| //////////////////////////////////////////////////////////////////////////////////////////////
// TRANSFORME UNE IMAGE SUR DISQUE EN TABLEAU D'OCTETS //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Transforme une image sur disque en un tableau d'octets compatibles BLOB</summary>
/// <param name="Chemin">Chemin complet vers l'image</param>
/// <returns>Retourne le tableau d'octets ou null si échec</returns>
//--------------------------------------------------------------------------------------------
public static byte[] ImageFileToBytes(string Chemin)
{
try
{
var fs = new FileStream(Chemin, FileMode.Open, FileAccess.Read); // créer flux de lecture du fichier image
byte[] logoBytes = new byte[fs.Length]; // créer tableau d'octets de la taille du fichier
fs.Read(logoBytes, 0, logoBytes.Length); // Lire le fichier dans le tableau d'octets
fs.Close(); // fermer le flux
return logoBytes; // retourner tableau d'octets de l'image
}
catch (Exception ex)
{
MessageBox.Show("Impossible de charger l'image spécifiée:\n\n"
+ ex.Message, "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
// TRANSFORME UN TABLEAU D'OCTETS EN IMAGE //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Transforme une représentation d'image sous forme d'un tableau d'octets en Image</summary>
/// <param name="logoBytes">Image sous forme d'un tableau d'octets</param>
//--------------------------------------------------------------------------------------------
public static Image BytesToImage(byte[] logoBytes)
{
if (logoBytes == null)
return null;
MemoryStream ms = new MemoryStream(logoBytes); // créer un mémorystream contenant le tableau d'octets
return Image.FromStream(ms); // lire image à partir du fichier mémoire
}
//////////////////////////////////////////////////////////////////////////////////////////////
// CONVERTIT N'IMPORTE QUEL OBJET EN TABLEAU D'OCTETS //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
// Permet de convertir n'importe quel objet en un tableau d'octets pouvant être stocké dans
// un champ de type BLOB.
// L'objet peut être également un tableau d'objets de type de base, ou personnel (classe etc)
// La technique s'appelle le Marshalling
//--------------------------------------------------------------------------------------------
/// <summary>Transforme un objet ou un tableau d'objets en un tableau d'octets qui le représente</summary>
/// <param name="objet">L'objet à sérialiser en tableau d'octets</param>
/// <returns>Retourne le tableau d'octets</returns>
//--------------------------------------------------------------------------------------------
public static byte[] ObjetToTableau(this Object objet)
{
if (objet == null) return null; // si on ne passe rien, on renvoie null
var bf = new BinaryFormatter(); // créer un objet de conversion
var ms = new MemoryStream(); // créer un flux de fichier mémoire
bf.Serialize(ms, objet); // sérialise l'objet en mémoire
var result = ms.ToArray(); // transforme la mémoire en un tableau d'octets
ms.Close(); // ferme le flux mémoire.
return result; // retourne le tableau
}
//////////////////////////////////////////////////////////////////////////////////////////////
// CONVERTIT UN TABLEAU D'OCTETS EN UN OBJET //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
// Permet de convertir un tableau d'octets représentant un objet en l'objet initial
// La technique s'appelle le Unmarshalling
//--------------------------------------------------------------------------------------------
/// <summary>Retransforme un tableau d'octets représentant un objet en l'objet de base sérialisé</summary>
/// <param name="tableau">Le tableau d'octets représentant l'objet sérialisé</param>
/// <returns>Retourne l'objet représenté, à caster par la méthode appelante dans le bon format</returns>
//--------------------------------------------------------------------------------------------
public static Object TableauToObjet(this byte[] tableau)
{
if (tableau == null) return null; // si on ne passe rien, on renvoie null
var bf = new BinaryFormatter(); // créer un objet de consersion
var ms = new MemoryStream(); // créer un flux de fichier mémoire
Object result; // l'objet de destination (sera casté par la méthode appelée)
ms.Write(tableau, 0, tableau.Length); // écrire le tableau en mémoire
ms.Position = 0; // Repointer au début de la mémoire
result = bf.Deserialize(ms) as object; // désérialise la mémoire dans l'objet
return result; // retourne l'objet désérialisé
} |
