static void Main(string[] args)
{
    var rsaHash = System.Security.Cryptography.SHA256.Create();
    using (var fileStream = File.Open(@"C:\MyFile.jpg", FileMode.Open))
    {
        var hash = rsaHash.ComputeHash(fileStream);
        var str = string.Join("", hash.Select(p => p.ToString("x2")));
        Console.WriteLine(str);
        Console.ReadKey();
    }
}

using System.Security.Cryptography;
using System.IO;

public class Crc32 : HashAlgorithm
{
    public const uint DefaultPolynomial = 0xEDB88320;
    public const uint DefaultSeed = 0xffffffff;

    private uint _hash;

    private readonly uint _seed;
    private readonly uint[] _table;

    private static uint[] defaultTable;

    public Crc32()
    {
        _table = InitializeTable(DefaultPolynomial);
        _seed = DefaultSeed;
        Initialize();
    }

    public Crc32(uint polynomial, uint seed)
    {
        _table = InitializeTable(polynomial);
        _seed = seed;
        Initialize();
    }

    public override void Initialize()
    {
        _hash = _seed;
    }

    protected override void HashCore(byte[] buffer, int start, int length)
    {
        _hash = CalculateHash(_table, _hash, buffer, start, length);
    }

    protected override byte[] HashFinal()
    {
        byte[] hashBuffer = UInt32ToBigEndianBytes(~_hash);
        HashValue = hashBuffer;
        return hashBuffer;
    }

    public override int HashSize
    {
        get { return 32; }
    }

    /// <summary> Рассчитывает контрольную сумму </summary>
    /// <param name="buffer">Буфер данных</param>
    /// <returns>Контрольная сумма</returns>
    public static uint Compute(byte[] buffer)
    {
        return ~CalculateHash(InitializeTable(DefaultPolynomial), DefaultSeed, buffer, 0, buffer.Length);
    }

    /// <summary> Рассчитывает контрольную сумму </summary>
    /// <param name="seed">Начальное значение</param>
    /// <param name="buffer">Буфер данных</param>
    /// <returns>Контрольная сумма</returns>
    public static uint Compute(uint seed, byte[] buffer)
    {
        return ~CalculateHash(InitializeTable(DefaultPolynomial), seed, buffer, 0, buffer.Length);
    }

    /// <summary> Рассчитывает контрольную сумму </summary>
    /// <param name="polynomial">Порождающий полином</param>
    /// <param name="seed">Начальное значение</param>
    /// <param name="buffer">Буфер данных</param>
    /// <returns>Контрольная сумма</returns>
    public static uint Compute(uint polynomial, uint seed, byte[] buffer)
    {
        return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length);
    }

    /// <summary> Инициализирует таблицу со значением полинома для каждого значения байта, чтоб не расчитывать их в процессе </summary>
    /// <param name="polynomial">Порождающий полином</param>
    private static uint[] InitializeTable(uint polynomial)
    {
        if (polynomial == DefaultPolynomial && defaultTable != null)
            return defaultTable;

        uint[] createTable = new uint[256];
        for (int i = 0; i < 256; i++)
        {
            uint entry = (uint)i;
            for (int j = 0; j < 8; j++)
            {
                if ((entry & 1) == 1)
                    entry = (entry >> 1) ^ polynomial;
                else
                    entry = entry >> 1;
            }

            createTable[i] = entry;
        }

        if (polynomial == DefaultPolynomial)
            defaultTable = createTable;

        return createTable;
    }

    private static uint CalculateHash(uint[] table, uint seed, byte[] buffer, int start, int size)
    {
        uint crc = seed;
        for (int i = start; i < size; i++)
        {
            unchecked
            {
                crc = (crc >> 8) ^ table[buffer[i] ^ crc & 0xff];
            }
        }
        return crc;
    }

    /// <summary> Преобразует результат вычисления хеша в 4 байта с инвертированием битов </summary>
    private static byte[] UInt32ToBigEndianBytes(uint x)
    {
        return new byte[] {
            (byte)((x >> 24) & 0xff),
            (byte)((x >> 16) & 0xff),
            (byte)((x >> 8) & 0xff),
            (byte)(x & 0xff)
        };
    }

    /// <summary> Рассчитывает контрольную сумму файла и возвращает её в виде 16 битного значения в строке </summary>
    public static string Get(string file)
    {
        Crc32 crc32 = new Crc32();
        string hash = string.Empty;

        using (FileStream fs = File.Open(file, FileMode.Open))
        {
            foreach (byte b in crc32.ComputeHash(fs))
            {
                hash += b.ToString("x2").ToLower();
            }
        }
        return hash;
    }
}