单元测试图像序列化

我没能找到这个问题的答案，希望有人能帮助我。我试图使用以下代码来序列化和反序列化图像。

    public override string Serialize(Image image)
    {
        ImageFormat format = ImageFormat.Png;
        using (MemoryStream ms = new MemoryStream())
        {
            image.Save(ms, format);
            byte[] imageBytes = ms.ToArray();
            string base64String = Convert.ToBase64String(imageBytes);
            return base64String;
        }
    }
    public override Image Deserialize(string value)
    {
        if (string.IsNullOrWhiteSpace(value))
            throw new Exception("Invalid serialized string. Unable to deserialize image");
        byte[] imageBytes = Convert.FromBase64String(value);                        
        using (MemoryStream ms = new MemoryStream(imageBytes))
        {
            Image image = Image.FromStream(ms);
            return image;
        }           
    }

从一个视觉测试，这段代码工作如预期，但我无法通过单元测试验证这一点。我试图使用下面的代码来比较图像，我已经能够成功地进行单元测试，如果图像是相同的。

    public static bool IsEqualTo(this Image sourceImage, Image compareImage)
    {
        if (sourceImage.Size != compareImage.Size)
            return false;
        byte[] sourceHash = sourceImage.CreateHash();
        byte[] compareHash = compareImage.CreateHash();
        return sourceHash.IsEqualTo(compareHash);
    }
    private static byte[] CreateHash(this Image image)
    {
        ImageConverter converter = new ImageConverter();
        byte[] byteArray = (byte[])converter.ConvertTo(image, typeof(byte[]));
        SHA256Managed shaM = new SHA256Managed();
        byte[] hash = shaM.ComputeHash(byteArray);
        return hash;
    }
    private static bool IsEqualTo(this byte[] source, byte[] compare)
    {
        if (source.Length != compare.Length)
            return false;
        for (int i = 0; i < source.Length; i++)
            if (source[i] != compare[i])
                return false;
        return true;
    }

完成这两个部分后，我将尝试编写一个单元测试，该测试假设序列化成功发生，并将简单地验证我继续获得相同的序列化字符串。然后使用序列化字符串初始化一个新图像，我使用以下代码对其进行比较:

    [Fact]
    public void Deserialize_Success()
    {
        Image expected = this.LoadImage();
        string imageString = this.GetImageString();
        ImageSerializer serializer = new ImageSerializer();
        Image actual = serializer.Deserialize(imageString);
        bool match = expected.IsEqualTo(actual);
        Assert.True(match);
    }

如果我将映像保存到文件系统并执行可视化比较，看起来一切都像我预期的那样工作，但是单元测试将失败。我能想到的唯一一件事是，由于加载图像的方法导致了一个小的差异，这使得它看起来不同。

谁能告诉我如何才能成功地为此编写单元测试?

我发现问题的奇怪行为在图像字节数组序列化这是相似的。我试图使用相同的图像，他们使用http://en.wikipedia.org/wiki/File:Snow_flake_icon.png，但我看到的差异，甚至与此。以这个问题为指导，我仔细研究了正在创建的字节数组。

第一个主要区别是，在反序列化的图像中，前13个字节不存在。还有29个额外字节的额外方差，所有方差都在前46个字节中。我的问题是，我不认为我可以假设反序列化的图像总是有13个字节的偏移，我可以忽略前46个字节。

详细信息如下:

Expected Length: 17932  Actual Length: 17919
expected[0]=137         Actual Not Present
expected[1]=80          Actual Not Present
expected[2]=78          Actual Not Present
expected[3]=71          Actual Not Present
expected[4]=13          Actual Not Present
expected[5]=10          Actual Not Present
expected[6]=26          Actual Not Present
expected[7]=10          Actual Not Present
expected[8]=0           Actual Not Present
expected[9]=0           Actual Not Present
expected[10]=0          Actual Not Present
expected[11]=13         Actual Not Present
expected[12]=73         Actual Not Present
expected[13]=72         actual[13]=72
expected[14]=68         actual[14]=68
expected[15]=82         actual[15]=82
expected[16]=0          actual[16]=0
expected[17]=0          actual[17]=0
expected[18]=1          actual[18]=1
expected[19]=0          actual[19]=0
expected[20]=0          actual[20]=0
expected[22]=1          actual[22]=1
expected[24]=8          actual[24]=8
expected[25]=6          actual[25]=6
expected[26]=0          actual[26]=0
expected[27]=0          actual[27]=0
expected[28]=0          actual[28]=0
expected[29]=92         actual[29]=92
expected[30]=114        actual[30]=114
expected[31]=168        actual[31]=168
expected[32]=102        actual[32]=102
expected[35]=0          actual[35]=0
expected[36]=1          actual[36]=4
expected[37]=115        actual[37]=103
expected[38]=82         actual[38]=65
expected[39]=71         actual[39]=77
expected[40]=66         actual[40]=65
expected[42]=174        actual[42]=0
expected[43]=206        actual[43]=177
expected[44]=28         actual[44]=143
expected[45]=233        actual[45]=11