Practice Now
C#
Bitmap
image format
programming
.NET

Find image format using Bitmap object in C

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions
C# & .NET

Introduction

In C#, the System.Drawing.Bitmap class provides the RawFormat property to determine an image's format (JPEG, PNG, GIF, BMP, TIFF, etc.) after loading it from a file or stream. This is useful when processing user-uploaded images where the file extension may be incorrect or missing, or when handling images from streams and byte arrays where no filename exists. The RawFormat property returns an ImageFormat object that you compare against known format constants like ImageFormat.Jpeg and ImageFormat.Png.

Basic Format Detection

csharp
1using System.Drawing;
2using System.Drawing.Imaging;
3
4// Load an image and check its format
5using (Bitmap bitmap = new Bitmap("photo.jpg"))
6{
7    ImageFormat format = bitmap.RawFormat;
8
9    if (format.Equals(ImageFormat.Jpeg))
10        Console.WriteLine("Format: JPEG");
11    else if (format.Equals(ImageFormat.Png))
12        Console.WriteLine("Format: PNG");
13    else if (format.Equals(ImageFormat.Gif))
14        Console.WriteLine("Format: GIF");
15    else if (format.Equals(ImageFormat.Bmp))
16        Console.WriteLine("Format: BMP");
17    else if (format.Equals(ImageFormat.Tiff))
18        Console.WriteLine("Format: TIFF");
19    else if (format.Equals(ImageFormat.Icon))
20        Console.WriteLine("Format: ICO");
21    else
22        Console.WriteLine($"Unknown format: {format.Guid}");
23}

RawFormat detects the actual binary format of the image data, regardless of the file extension. A file named photo.png that is actually a JPEG will correctly report as JPEG.

Helper Method for Format Detection

csharp
1using System.Drawing;
2using System.Drawing.Imaging;
3
4public static class ImageFormatHelper
5{
6    public static string GetImageFormat(Bitmap bitmap)
7    {
8        if (ImageFormat.Jpeg.Equals(bitmap.RawFormat)) return "JPEG";
9        if (ImageFormat.Png.Equals(bitmap.RawFormat))  return "PNG";
10        if (ImageFormat.Gif.Equals(bitmap.RawFormat))  return "GIF";
11        if (ImageFormat.Bmp.Equals(bitmap.RawFormat))  return "BMP";
12        if (ImageFormat.Tiff.Equals(bitmap.RawFormat)) return "TIFF";
13        if (ImageFormat.Icon.Equals(bitmap.RawFormat)) return "ICO";
14        if (ImageFormat.Emf.Equals(bitmap.RawFormat))  return "EMF";
15        if (ImageFormat.Wmf.Equals(bitmap.RawFormat))  return "WMF";
16        return "Unknown";
17    }
18
19    public static string GetFileExtension(Bitmap bitmap)
20    {
21        if (ImageFormat.Jpeg.Equals(bitmap.RawFormat)) return ".jpg";
22        if (ImageFormat.Png.Equals(bitmap.RawFormat))  return ".png";
23        if (ImageFormat.Gif.Equals(bitmap.RawFormat))  return ".gif";
24        if (ImageFormat.Bmp.Equals(bitmap.RawFormat))  return ".bmp";
25        if (ImageFormat.Tiff.Equals(bitmap.RawFormat)) return ".tiff";
26        if (ImageFormat.Icon.Equals(bitmap.RawFormat)) return ".ico";
27        return ".bin";
28    }
29}
30
31// Usage
32using (var bmp = new Bitmap("unknown_file"))
33{
34    Console.WriteLine($"Format: {ImageFormatHelper.GetImageFormat(bmp)}");
35    Console.WriteLine($"Extension: {ImageFormatHelper.GetFileExtension(bmp)}");
36}

Detecting Format from a Stream

csharp
1using System.Drawing;
2using System.Drawing.Imaging;
3using System.IO;
4
5// From a file stream
6using (FileStream fs = new FileStream("image.dat", FileMode.Open))
7using (Bitmap bitmap = new Bitmap(fs))
8{
9    string format = ImageFormatHelper.GetImageFormat(bitmap);
10    Console.WriteLine($"Stream image format: {format}");
11}
12
13// From a byte array (e.g., from a database or HTTP response)
14byte[] imageBytes = File.ReadAllBytes("photo.jpg");
15using (MemoryStream ms = new MemoryStream(imageBytes))
16using (Bitmap bitmap = new Bitmap(ms))
17{
18    string format = ImageFormatHelper.GetImageFormat(bitmap);
19    Console.WriteLine($"Byte array image format: {format}");
20}

When loading from streams, Bitmap reads the binary header to detect the format. The stream must remain open for the lifetime of the Bitmap object.

Using ImageCodecInfo for MIME Type

csharp
1using System.Drawing;
2using System.Drawing.Imaging;
3using System.Linq;
4
5public static string GetMimeType(Bitmap bitmap)
6{
7    ImageCodecInfo codec = ImageCodecInfo.GetImageDecoders()
8        .FirstOrDefault(c => c.FormatID == bitmap.RawFormat.Guid);
9
10    return codec?.MimeType ?? "application/octet-stream";
11}
12
13// Usage
14using (var bmp = new Bitmap("photo.jpg"))
15{
16    Console.WriteLine(GetMimeType(bmp));  // "image/jpeg"
17}

ImageCodecInfo.GetImageDecoders() returns all registered image codecs. Matching by FormatID gives you the MIME type (image/jpeg, image/png, etc.), which is useful for HTTP content-type headers.

Cross-Platform Alternative: ImageSharp

csharp
1// System.Drawing is Windows-only in .NET Core/.NET 5+
2// Use SixLabors.ImageSharp for cross-platform support
3
4// Install: dotnet add package SixLabors.ImageSharp
5
6using SixLabors.ImageSharp;
7using SixLabors.ImageSharp.Formats;
8
9IImageFormat format;
10using (Image image = Image.Load("photo.jpg", out format))
11{
12    Console.WriteLine($"Format: {format.Name}");           // "JPEG"
13    Console.WriteLine($"MIME: {format.DefaultMimeType}");  // "image/jpeg"
14    Console.WriteLine($"Size: {image.Width}x{image.Height}");
15}
16
17// Detect format without loading the full image
18IImageFormat detectedFormat = Image.DetectFormat("photo.jpg");
19Console.WriteLine(detectedFormat?.Name);  // "JPEG"

ImageSharp is the recommended replacement for System.Drawing in cross-platform .NET applications. It detects format directly during load and provides a clean API.

Reading Magic Bytes (Without Loading the Image)

csharp
1using System.IO;
2
3public static string DetectFormatByMagicBytes(string filePath)
4{
5    byte[] header = new byte[8];
6    using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
7    {
8        fs.Read(header, 0, header.Length);
9    }
10
11    // JPEG: FF D8 FF
12    if (header[0] == 0xFF && header[1] == 0xD8 && header[2] == 0xFF)
13        return "JPEG";
14
15    // PNG: 89 50 4E 47 0D 0A 1A 0A
16    if (header[0] == 0x89 && header[1] == 0x50 && header[2] == 0x4E && header[3] == 0x47)
17        return "PNG";
18
19    // GIF: 47 49 46 38
20    if (header[0] == 0x47 && header[1] == 0x49 && header[2] == 0x46)
21        return "GIF";
22
23    // BMP: 42 4D
24    if (header[0] == 0x42 && header[1] == 0x4D)
25        return "BMP";
26
27    return "Unknown";
28}

Magic bytes detection reads only the first few bytes of the file, making it much faster than loading the entire image into a Bitmap object. This is ideal for validating uploads before processing.

Common Pitfalls

  • Using == instead of .Equals() to compare ImageFormat: bitmap.RawFormat == ImageFormat.Jpeg compares references, not values, and may return false even for JPEG images. Always use bitmap.RawFormat.Equals(ImageFormat.Jpeg) or compare the Guid property.
  • Using System.Drawing on Linux or macOS: System.Drawing.Bitmap depends on GDI+ (Windows-only). On .NET Core/.NET 5+ non-Windows platforms, it throws PlatformNotSupportedException. Use SixLabors.ImageSharp or SkiaSharp for cross-platform applications.
  • Not disposing the Bitmap: Bitmap holds unmanaged GDI+ resources. Failing to call Dispose() (or use a using block) causes memory leaks, especially when processing many images in a loop.
  • Closing the source stream before the Bitmap: When loading from a Stream, the stream must remain open for the Bitmap's lifetime. Closing the stream prematurely causes GDI+ generic error exceptions on subsequent operations.
  • Trusting file extensions for format detection: File extensions can be wrong or spoofed. A file named .png may contain JPEG data. Always use RawFormat or magic bytes to detect the actual format, especially for user-uploaded files in security-sensitive contexts.

Summary

  • Use bitmap.RawFormat.Equals(ImageFormat.Jpeg) to check the image format
  • RawFormat detects the actual binary format, not the file extension
  • Use ImageCodecInfo to get the MIME type from the format GUID
  • For cross-platform .NET, use SixLabors.ImageSharp instead of System.Drawing
  • Magic bytes detection is fastest when you only need the format without loading the full image
  • Always use using blocks with Bitmap to prevent GDI+ resource leaks
Related reading
Course
Intermediate
27 lessons
14 hours
OOD Fundamentals

Master object-oriented design from first principles, SOLID, design patterns, and classic interview problems with hands-on coding.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.