FNV-1a hash in C#

FnvHash.cs

    /// <summary>
    /// A hash combiner that is implemented with the Fowler/Noll/Vo algorithm (FNV-1a). This is a mutable struct for performance reasons.
    /// </summary>
    public struct FnvHash
    {
        /// <summary>
        /// The starting point of the FNV hash.
        /// </summary>
        public const int Offset = unchecked((int)2166136261);

        /// <summary>
        /// The prime number used to compute the FNV hash.
        /// </summary>
        private const int Prime = 16777619;

        /// <summary>
        /// Gets the current result of the hash function.
        /// </summary>
        public int HashCode { get; private set; }

        /// <summary>
        /// Creates a new FNV hash initialized to <see cref="Offset"/>.
        /// </summary>
        public static FnvHash Create()
        {
            var result = new FnvHash();
            result.HashCode = Offset;
            return result;
        }

        /// <summary>
        /// Adds the specified byte to the hash.
        /// </summary>
        /// <param name="data">The byte to hash.</param>
        public void Combine(byte data)
        {
            unchecked
            {
                HashCode ^= data;
                HashCode *= Prime;
            }
        }

        /// <summary>
        /// Adds the specified integer to this hash, in little-endian order.
        /// </summary>
        /// <param name="data">The integer to hash.</param>
        public void Combine(int data)
        {
            Combine(unchecked((byte)data));
            Combine(unchecked((byte)(data >> 8)));
            Combine(unchecked((byte)(data >> 16)));
            Combine(unchecked((byte)(data >> 24)));
        }
    }

Why signed and not unsigned integers?

I don't remember, but most likely because the .NET hash types use signed integers. Which is an ancient holdover from an attempt to make .NET a language-independent virtual machine bytecode system, which never really panned out.