Code à barres 128 en c#

Soyez le premier à donner votre avis sur cette source.

Snippet vu 7 814 fois - Téléchargée 16 fois

Contenu du snippet

Fonction C# inspirée de celle en VB de Grandzebu prenant une chaine et en retournant une autre prête à être utilisée avec la police code128.ttf

Source / Exemple :


/// <summary>
    /// Retourne une chaîne à afficher en police code128.ttf pour obtenir le code à barres.
    /// </summary>
    /// <param name="chaine">chaîne à convertir</param>
    /// <returns>chaîne à afficher en police code128.ttf</returns>
    public string code128_pr_ttf(String chaine)
    {
        string Valeur_retour = "";
        Int32 code_Ascii;
        bool tableB;
        Int32 mini = 0;
        Int32 dummy = 0;
        Int32 checksum = 0;
        Int32 i;

        //Un caractère incorrect trouvé : retourne une chaine vide
        if (chaine.Length > 0)
        {
            for (i = 0; i < chaine.Length; i++)
            {
                code_Ascii = (Int32)chaine[i];
                if (code_Ascii < 32 || code_Ascii > 126)
                    return Valeur_retour;
            }
        }
        else
            return Valeur_retour;

        //Calculer la chaine de code en optimisant l'usage des tables B et C
        tableB = true;
        if (i >= 0)
        {
            i = 0;
            //i devient l'index sur la chaine
            while (i < chaine.Length)
            {
                if (tableB)
                {
                    //Voir si intéressant de passer en table C
                    //Oui pour 4 chiffres au début ou à la fin, sinon pour 6 chiffres
                    mini = (((i == 0) || ((i + 2) == chaine.Length)) ? 3 : 5);
                    mini--;
                    if ((i + mini) < chaine.Length)
                    {
                        while (mini >= 0)
                        {
                            if (Convert.ToInt32(chaine[i + mini]) < 48 || Convert.ToInt32(chaine[i + mini]) > 57)
                                break;
                            mini--;
                        }
                    }
                    //Choix table C
                    if (mini <= 0)
                    {
                        //Débuter sur table C
                        if (i == 0) {
                            Valeur_retour = Convert.ToString((char)210);
                        }
                        //Commuter sur table C
                        else {
                            Valeur_retour = Valeur_retour + (char)204;
                        }
                        tableB = false;
                    }
                    else
                    {
                        if (i == 0) Valeur_retour = Convert.ToString((char)209);
                        //Débuter sur table B
                    }
                }
                if (!tableB)
                {
                    //On est sur la table C, essayer de traiter 2 chiffres
                    mini = 2;
                    mini--;
                    if ((i + mini) < chaine.Length)
                    {
                        while (mini >= 0)
                        {
                            if (Convert.ToInt32(chaine[i + mini]) < 48 || Convert.ToInt32(chaine[i + mini]) > 57)
                                break;
                            mini--;
                        }
                    }
                    //OK pour 2 chiffres, les traiter
                    if (mini < 0) {
                        //Conversion.Val(Strings.Mid(chaine, i, 2));
                        dummy = Convert.ToInt32(chaine.Substring(i,2));
                        dummy = ((dummy < 95) ? dummy + 32 : dummy + 105);
                        Valeur_retour = Valeur_retour + (char)dummy;
                        i = i + 2;
     
                    }
                    //On n'a pas 2 chiffres, repasser en table B
                    else {
                        Valeur_retour = Valeur_retour + (char)205;
                        tableB = true;
                    }
                }
                if (tableB)
                {
                    //Traiter 1 caractère en table B
                    Valeur_retour = Valeur_retour + chaine[i].ToString();
                    i++;
                }
            }

            //Calcul de la clé de contrôle
            for (i = 0; i < Valeur_retour.Length; i++)
            {
                dummy = Convert.ToInt32(Valeur_retour[i]);
                dummy = (dummy < 127 ? dummy - 32 : dummy - 105);
                if (i == 0)
                    checksum = dummy;
                else
                    checksum += i * dummy;
            }
            checksum = checksum % 103;

            //Calcul du code ASCII de la clé
            checksum = (checksum < 95 ? checksum + 32 : checksum + 105);
            
            //Ajout de la clé et du STOP à la valeur de retour
            Valeur_retour = Valeur_retour + (char)checksum + (char)211;
        }
        return Valeur_retour;
    }

A voir également

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.