IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Windows Forms Discussion :

[C#] Icon to byte[]


Sujet :

Windows Forms

  1. #1
    Membre confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2008
    Messages
    337
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Septembre 2008
    Messages : 337
    Points : 456
    Points
    456
    Par défaut [C#] Icon to byte[]
    Bonjour ,
    J'ai un petit soucis, je souhaite afficher des icons sur certains de mes boutons qui sont générés dynamiquement en fonction d'une table sql(1boutons par ligne), j'ai donc ajouté un champ Image dans ma table.

    Pour gérer cette table j'ai un formulaire, auquel j'ai ajouté une picture box où l'image sera affichée.
    J'ai ajouté un bouton parcourir pour aller charger un fichier .ico, que je met dans ma picture box de cette façon

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    private void parcourir_Click(object sender, EventArgs e)
            {
                OpenFileDialog o = new OpenFileDialog();
                o.InitialDirectory = "c:\\";
                o.Filter = "Icone (*.ico)|*.ico";
                o.RestoreDirectory = true;
                if (o.ShowDialog() == DialogResult.OK)
                {
                    pictureBox1.Image = Image.FromFile(o.FileName);
                }
            }
    Lorsque l'utilisateur enregistre, j'essaie de convertir mon image en tableau de byte, c'est là que le souci se pose

    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
     
    private void bt_save_Click(object sender, EventArgs e)
            {
     
                DataRowView maRow = (DataRowView) maTableBindingSource.Current;
                if (pictureBox1.Image != null)
                {
                     MemoryStream stream = new MemoryStream();
                     pictureBox1.Image.Save(stream,System.Drawing.Imaging.ImageFormat.Icon);
                     maRow["Icone"] = stream.ToArray();
                }
                else
                {
                    r["Icone"] = DBNull.Value;
                }
                maTableBindingSource.EndEdit();
                monTableAdapter.Update(monDataSet);
                majContexte(0);
            }
    L'erreur se produit lors de la méthode .Save()
    System.ArgumentNullException La valeur ne peut pas être null. Nom du paramètre*: encoder.
    Par contre elle ne se produit qu'avec System.Drawing.Imaging.ImageFormat.Icon, ca marche très bien en Bmp ou jpeg sauf que je souhaite garder la transparence de l'icon.

    Si quelqu'un a une solution ou des suggestions, je suis tout ouïe.

    Merci d'avance.

  2. #2
    Membre confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2008
    Messages
    337
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Septembre 2008
    Messages : 337
    Points : 456
    Points
    456
    Par défaut
    J'ai pour le moment contourné le problème en enregistrant en BMP et en rendant la transparence à mon image au moment où je l'ajoute dans mon bouton mais ca serais plus propre si je pouvais l'enregistrer en icon.

    méthode qui rend la transparence à mon image :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    public static void transparenceImage(Image i)
            {
                ((Bitmap)i).MakeTransparent(((Bitmap)i).GetPixel(0, i.Size.Height - 1));
            }
    Je reste donc ouvert à vos propositions ....

    a+

  3. #3
    Membre éprouvé
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    612
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Juin 2008
    Messages : 612
    Points : 1 050
    Points
    1 050
    Par défaut
    Salut
    -----

    Je ne sais pas si ça peut t'être utile, mais voici les méthodes que je me suis créées pour manipuler les objets et images dans une BDD :

    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
    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é
            }
    A+
    Claude

  4. #4
    Membre confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2008
    Messages
    337
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Septembre 2008
    Messages : 337
    Points : 456
    Points
    456
    Par défaut
    Je vais essayer çà !

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Image(Icon) vers byte[]
    Par SheikYerbouti dans le forum Entrée/Sortie
    Réponses: 2
    Dernier message: 19/12/2007, 19h03
  2. Main icon (16 bits)
    Par DR dans le forum C++Builder
    Réponses: 2
    Dernier message: 02/09/2002, 09h23
  3. Attribuer une icone à une application
    Par k_boy dans le forum x86 32-bits / 64-bits
    Réponses: 4
    Dernier message: 31/08/2002, 02h38
  4. [FORMS] Chemin des icones (intégré FAQ 150 QR)
    Par jerome62 dans le forum Forms
    Réponses: 2
    Dernier message: 30/07/2002, 09h32
  5. [Kylix] icone associée à un programme
    Par Anonymous dans le forum EDI
    Réponses: 1
    Dernier message: 22/03/2002, 10h43

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo