How can I make a new class to check for images types?

I am not sure why you are doing all this code when you can just check RawFormat

Gets the file format of this Image.

var image = Image.FromFile(@"D:\200.gif");
var isGif = image.RawFormat.Equals(ImageFormat.Gif);

However, if you really needed to do something like this, here is an extremely efficient way of achieving it. Note, this is actually pulled from one of my runtime libraries to check for binary sequences and modified for your example. So take it with a grain of salt.

public static class ImageTypeCheck
{
   public enum ImageFormats
   {
      bmp,
      jpeg,
      gif,
      tiff,
      png,
      unknown
   }

   private static readonly ImmutableArray<(Memory<byte> bytes, ImageFormats format)> Headers;

   private static readonly int MaxLength;
   static ImageTypeCheck()
   {

      Headers = ImmutableArray.Create(
         new (Memory<byte> bytes, ImageFormats format)[]
         {
            (Encoding.ASCII.GetBytes("BM"), ImageFormats.bmp),
            (Encoding.ASCII.GetBytes("GIF"), ImageFormats.gif),
            (new byte[] {137, 80, 78, 71}, ImageFormats.png)
         });
      MaxLength = Headers.Max(x => x.bytes.Length);
   }

   public static ImageFormats GetImageFormat(Image imageIn)
   {
      var buffer = new byte[MaxLength];
      using var ms = new MemoryStream();
      imageIn.Save(ms, imageIn.RawFormat);
      var span = buffer.AsSpan();
      ms.Position = 0;
      ms.Read(span);
      return GetImageFormat(span);
   }

   public static ImageFormats GetImageFormat(Stream stream)
   {
      var buffer = new byte[MaxLength];
      var span = buffer.AsSpan();
      stream.Read(span);
      return GetImageFormat(span);
   }

   public static ImageFormats GetImageFormat(ReadOnlySpan<byte> source)
   {
      foreach (var (bytes, format) in Headers)
         if (bytes.Span.SequenceEqual(source.Slice(0,bytes.Length)))
            return format;
      return ImageFormats.unknown;
   }
}

To prove that it will be faster then just sequence equals on an array, but also primarily just to use the new table feature of stackoverflow, I have a bunch of benchmarks to show the performance difference between a bunch of ways and how they allocate (if that is important to someone). Note that SequenceEqual on BitWiseEquatable span is more efficient and heavily optimised.

Environment

BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.630 (2004/?/20H1)
Intel Core i7-7700 CPU 3.60GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=5.0.101
  [Host]        : .NET Core 5.0.1 (CoreCLR 5.0.120.57516, CoreFX 5.0.120.57516), X64 RyuJIT  [AttachedDebugger]
  .NET Core 5.0 : .NET Core 5.0.1 (CoreCLR 5.0.120.57516, CoreFX 5.0.120.57516), X64 RyuJIT

Job=.NET Core 5.0  Runtime=.NET Core 5.0

Results

Test Code

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.NetCoreApp50)]
public class DumbTest
{
   [Params(10,100,1000)]
   public int N;

   private byte[] _bytes;
   private Memory<byte> _memory;
   private MemoryStream _ms;

   [GlobalSetup]
   public void GlobalSetup()
   {
      var r = new Random(32);
      _bytes = new byte[N];
      r.NextBytes(_bytes);
      _ms = new MemoryStream(_bytes);

       _memory = _bytes.AsMemory();

   }

   [Benchmark]
   public void Span()
   {
      _ms.Position = 0;
      var buffer = new byte[N];
      var span = buffer.AsSpan();
      _ms.Read(span);
      var asd =span.SequenceEqual(_bytes);
   }
   [Benchmark]
   public void SpanPool()
   {
      _ms.Position = 0;
      var buffer = arrayPool.Rent(N);
      try
      {
         var span = buffer.AsSpan(N);
         _ms.Read(span);
         var asd =span.SequenceEqual(_bytes);
      }
      finally
      {
         arrayPool.Return(buffer);
      }

   }
   
   [Benchmark]
   public void MemoryPool()
   {
      _ms.Position = 0;
      var buffer = arrayPool.Rent(N);
      try
      {
         var span = buffer.AsSpan(N);
         _ms.Read(span);
         var asd =span.SequenceEqual(_memory.Span);
      }
      finally
      {
         arrayPool.Return(buffer);
      }
   }

   [Benchmark]
   public void Memory()
   {
      _ms.Position = 0;
      var buffer = new byte[N];
      var span = buffer.AsSpan();
      _ms.Read(span);
      var asd =span.SequenceEqual(_memory.Span);
   }
   [Benchmark]
   public void Bytes()
   {
      _ms.Position = 0;
      var buffer = new byte[N];
      _ms.Read(buffer, 0, buffer.Length);
      var asd =buffer.SequenceEqual(_bytes);
   }

   private static readonly ArrayPool<byte> arrayPool = ArrayPool<byte>.Shared;
   [Benchmark]
   public void BytesPool()
   {
      _ms.Position = 0;
      var buffer = arrayPool.Rent(N);
      try
      {
         _ms.Read(buffer, 0, N);
         var asd =buffer.SequenceEqual(_bytes);
      }
      finally
      {
         arrayPool.Return(buffer);
      }

   }

}