Générer un code barre ean13 et le sauvegarder dans un pdf (avec pdfsharp)

Soyez le premier à donner votre avis sur cette source.

Vue 10 704 fois - Téléchargée 1 296 fois

Description

Ce petit code génère un code barre EAN13 sur base de son numéro et le sauvegarde dans un fichier PDF grâce à la librairie PDFsharp !

REM : Vous devez avant toutes choses, installer la police : "ean13.ttf"
Pour se faire, copier/coller dans "c:\Windows\Fonts"

Source / Exemple :


Voici la partie de création de la phrase qui deviendra le code barre :

            String code = "9780201185379"; // Exemple de code EAN13
            /*String code = args[0];*/ //Pour récupérer le code EAN13 placé en paramètre

            /* prend le premier chiffre du string et le transforme en int */
            int nombre = Convert.ToInt32(new string(code[0], 1));  

            String resultat = "";
            resultat += nombre;

            /* le premier nombre détermine la séquence de codage de la première moitier du code EAN13 */
            switch (nombre)
            {
                case 0:
                        for (int i = 1; i < 7; i++)
                        {
                            nombre = Convert.ToInt32(new string(code[i], 1));
                            resultat += odd(nombre);
                        }
                        break;
                case 1: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[4], 1)));
                        resultat += even(Convert.ToInt32(new string(code[5], 1)));
                        resultat += even(Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 2: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += even(Convert.ToInt32(new string(code[4], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[5], 1)));
                        resultat += even(Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 3: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += even(Convert.ToInt32(new string(code[4], 1)));
                        resultat += even(Convert.ToInt32(new string(code[5], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 4: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += even(Convert.ToInt32(new string(code[2], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[3], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[4], 1)));
                        resultat += even(Convert.ToInt32(new string(code[5], 1)));
                        resultat += even(Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 5: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += even(Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[4], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[5], 1)));
                        resultat += even(Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 6: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += even(Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += even(Convert.ToInt32(new string(code[4], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[5], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 7: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += even(Convert.ToInt32(new string(code[2], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[3], 1)));
                        resultat += even(Convert.ToInt32(new string(code[4], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[5], 1)));
                        resultat += even(Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 8: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += even(Convert.ToInt32(new string(code[4], 1)));
                        resultat += even(Convert.ToInt32(new string(code[5], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[6], 1)));
                        break;
                case 9: resultat += odd (Convert.ToInt32(new string(code[1], 1)));
                        resultat += even(Convert.ToInt32(new string(code[2], 1)));
                        resultat += even(Convert.ToInt32(new string(code[3], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[4], 1)));
                        resultat += even(Convert.ToInt32(new string(code[5], 1)));
                        resultat += odd (Convert.ToInt32(new string(code[6], 1)));
                        break;
            }

            /* Ajout du caractère séparateur !*/
            resultat += '*';

            /* codage de la deuxième moitier du code EAN13 */
            for (int i = 7; i < 13; i++)
            {
                nombre = Convert.ToInt32(new string(code[i], 1));
                resultat += right(nombre);
            }

            /* Ajout du caractère de fin */
            resultat += '+';

            /* Affichage de la phrase générée à partie du code EAN */
            Console.WriteLine("Phrase codée : " + resultat);
         }

                public static char tete(int num)
        {
            switch (num)
            {
                case 0: return '#';
                case 1: return '$';
                case 2: return '%'; 
                case 3: return '&'; 
                case 4: return '(';
                case 5: return ')';
                case 6: return '*'; 
                case 7: return '+'; 
                case 8: return ',';
                case 9: return '-';
            }
            return ' ';
        }

        public static char odd(int num)
        {
            switch (num)
            {
                case 0: return 'A';
                case 1: return 'B';
                case 2: return 'C';
                case 3: return 'D';
                case 4: return 'E';
                case 5: return 'F';
                case 6: return 'G';
                case 7: return 'H';
                case 8: return 'I';
                case 9: return 'J';
            }
            return ' ';
        }

        public static char even(int num)
        {
            switch (num)
            {
                case 0: return 'K';
                case 1: return 'L';
                case 2: return 'M';
                case 3: return 'N';
                case 4: return 'O';
                case 5: return 'P';
                case 6: return 'Q';
                case 7: return 'R';
                case 8: return 'S';
                case 9: return 'T';
            }
            return ' ';
        }

        public static char right(int num) 
        {
            switch (num)
            {
                case 0: return 'a';
                case 1: return 'b';
                case 2: return 'c';
                case 3: return 'd';
                case 4: return 'e';
                case 5: return 'f';
                case 6: return 'g';
                case 7: return 'h';
                case 8: return 'i';
                case 9: return 'j';
            }
            return ' ';
        }

Conclusion :


en espérant que ce code puisse vous aider !

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

excellente contribution!

est-ce que la fonction tete doit être utilisée dans un cas particulier?

salutations
fred_paris19
Messages postés
1
Date d'inscription
jeudi 23 novembre 2006
Statut
Membre
Dernière intervention
16 novembre 2010

Ça marche nickel.

Un barcode EAN13 utilise normalement le 13e chiffre comme checksum. Les chiffres du code ont des poids différents selon leur emplacement, pair ou impair.
(cf http://www.easesoft.net/Upc-ean13.html)

On peut le calculer comme suit (attention le args[0] ne doit plus être que de 12 caractères).

int checksum = 0;
for (int i = 1; i<12 ; i+=2)
checksum += Convert.ToInt32(code[i]-48);
checksum *= 3;
for (int i = 0; i<12; i+=2)
checksum += Convert.ToInt32(code[i]-48);

checksum = (10 - checksum % 10) % 10;
code += checksum.ToString(); // on ajoute un 13e chiffre de checksum
cs_Warny
Messages postés
478
Date d'inscription
mercredi 7 août 2002
Statut
Membre
Dernière intervention
10 juin 2015

Une petite remarque sur ton code :
Accumuler des chaîne dans une string est un tueur de mémoire.
Il faut utiliser à la place une structure de type StringBuilder spécialisée dans ce type d'utilisation.

En fait, quand tu fais "aa' + "bb" tu produits 3 chaînes en mémoire "aa", "bb" et le résultats "aabb". Ces chaînes coexistent jusqu'à ce que celles qui sont inutilisé soient mangées par le garbage collector.
Maintenant, si je rajoute "cc" à ma chaîne résultat, j'ai 5 chaînes en mémoire, celles déjà citées, plus "cc" plus "aabbcc", et aisi de suite. L'augmentation de l'occupation mémoire est comprise entre une fonction linéaire (j'ajoute la chaîne en une fois) et une augementation carrée (si j'ajoute caractère par caractère, les résultantes occuperont le carré du nombre de caractères ajoutés)
Avec un StringBuilder, on créé une structure d'une certaine taille en mémoire dans laquelle on copie brutalement les chaînes ajoutées. Si on dépasse la taille de la structure, on créé un bloc un peu plus loin. l'augmentation de la taille mémoire est linéaire, et légèrement supérieure à la taille de la chaîne résultante. Et surtout, il n'y a pas de redondance.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.