C# Comment puis-je tester un fichier est un fichier jpeg?

Plusieurs options:

Vous pouvez vérifier l'extension du fichier:

static bool HasJpegExtension(string filename)
{
    //add other possible extensions here
    return Path.GetExtension(filename).Equals(".jpg", StringComparison.InvariantCultureIgnoreCase)
        || Path.GetExtension(filename).Equals(".jpeg", StringComparison.InvariantCultureIgnoreCase);
}

ou vérifiez l'exactitude de l' nombre magique dans l'en-tête du fichier:

static bool HasJpegHeader(string filename)
{
    using (BinaryReader br = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.Read)))
    {
        UInt16 soi = br.ReadUInt16();  //Start of Image (SOI) marker (FFD8)
        UInt16 marker = br.ReadUInt16(); //JFIF marker (FFE0) or EXIF marker(FFE1)

        return soi == 0xd8ff && (marker & 0xe0ff) == 0xe0ff;
    }
}

Une autre option serait de charger l'image et à la vérification du bon type. Cependant, cette méthode est moins efficace (sauf si vous allez à la charge de l'image de toute façon), mais sera probablement vous donner un résultat fiable (Être conscient du coût supplémentaire de chargement et de décompression aussi bien que possible la gestion des exceptions):

static bool IsJpegImage(string filename)
{
    try
    {
        using (System.Drawing.Image img = System.Drawing.Image.FromFile(filename)) 
        {           
            //Two image formats can be compared using the Equals method
            //See http://msdn.microsoft.com/en-us/library/system.drawing.imaging.imageformat.aspx
            //
            return img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg);
        }
    }
    catch (OutOfMemoryException)
    {
        //Image.FromFile throws an OutOfMemoryException 
        //if the file does not have a valid image format or
        //GDI+ does not support the pixel format of the file.
        //
        return false;
    }
}

OMG, beaucoup de ces exemples de code sont faux, faux, faux.

EXIF des fichiers d'avoir un marqueur de 0xff*e1*, JFIF fichiers ont un marqueur de 0xff*e0*. Donc tout le code qui s'appuie sur 0xffe0 pour détecter un fichier JPEG manquez toutes EXIF des fichiers.

Voici une version qui permet de détecter à la fois, et peut facilement être modifié pour revenir seulement pour JFIF ou seulement pour les EXIF. (Utile lorsque vous essayez de récupérer vos photos de iPhone, par exemple).

    public static bool HasJpegHeader(string filename)
    {
        try
        {
            //0000000: ffd8 ffe0 0010 4a46 4946 0001 0101 0048  ......JFIF.....H
            //0000000: ffd8 ffe1 14f8 4578 6966 0000 4d4d 002a  ......Exif..MM.*    
            using (BinaryReader br = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.ReadWrite)))
            {
                UInt16 soi = br.ReadUInt16();  //Start of Image (SOI) marker (FFD8)
                UInt16 marker = br.ReadUInt16(); //JFIF marker (FFE0) EXIF marker (FFE1)
                UInt16 markerSize = br.ReadUInt16(); //size of marker data (incl. marker)
                UInt32 four = br.ReadUInt32(); //JFIF 0x4649464a or Exif  0x66697845

                Boolean isJpeg = soi == 0xd8ff && (marker & 0xe0ff) == 0xe0ff;
                Boolean isExif = isJpeg && four == 0x66697845;
                Boolean isJfif = isJpeg && four == 0x4649464a;

                if (isJpeg) 
                {
                    if (isExif)
                        Console.WriteLine("EXIF: {0}", filename);
                    else if (isJfif)
                        Console.WriteLine("JFIF: {0}", filename);
                    else
                        Console.WriteLine("JPEG: {0}", filename);
                }

                return isJpeg;
                return isJfif;
                return isExif;
            }
        }
        catch
        {
            return false;
        }
    }

Vous pourriez trouver de la documentation sur le format de fichier jpeg, plus précisément les informations d'en-tête. Puis essayez de lire ces informations à partir du fichier et de le comparer à celui qui est attendu jpeg octets d'en-tête.

Une fois que vous avez l'extension, vous pouvez utiliser une expression régulière pour la valider.

^.*\.(jpg|JPG)$

Selon le contexte dans lequel vous êtes en train de regarder ce fichier, vous devez vous rappeler que vous ne pouvez pas ouvrir le fichier jusqu'à ce que l'utilisateur vous indique pour l'ouvrir.

(Le lien est une Raymond Chen entrée de blog.)

Le code ici:

http://mark.michaelis.net/Blog/RetrievingMetaDataFromJPEGFilesUsingC.aspx

Vous montre comment récupérer les Méta-Données. Je pense que cela pourrait lever une exception si votre image n'est pas valide JPEG.

La meilleure façon serait de l'essayer et de créer une image en utilisant le Dessin.Bitmap (string) constructeur et voir si elle omet de le faire ou lève une exception. Le problème avec certaines des réponses sont cela: d'une part, l'extension est purement arbitraire, il pourrait être jpg, jpeg, jpe, bob, tim, que ce soit. Deuxièmement, en utilisant seulement l'en-tête n'est pas assez pour être sûr à 100%. Il peut déterminer avec certitude qu'un fichier n'est pas au format jpeg, mais ne peut pas garantir qu'un fichier est un fichier jpeg, l'arbitraire d'un fichier binaire pourrait avoir la même séquence d'octets au début.

après l'enregistrement de l'extension de fichier de lire les quatre premiers octets de l'image et les deux derniers octets de l'image comme ceci, faites cela pour les deux derniers octets de la valeur 255 , 217
pour d'autres peuvent le faire
Valider image à partir d'un fichier en C#
http://www.garykessler.net/library/file_sigs.html

//after check extention of file
byte[] ValidFileSignture = new byte[] { 255, 216, 255, 224 };
byte[] bufferforCheck = new byte[ValidFileSignture.Length];
Stream _inputStream = file.InputStream;
byte[] bufferforCheck1 = new byte[] { 255, 216, 255, 224 };
_inputStream.Read(bufferforCheck, 0, ValidFileSignture.Length);
if (!Enumerable.SequenceEqual(bufferforCheck, ValidFileSignture))
{
    //file OK
}