using System;
using System.Text;
using System.Collections.Generic;
using System.Security.Cryptography;
                                       
public class Program
{
       public static void Main()
       {
                       var ControlNumberSource = "613471366090123,17122020,142324,489,4000032793,1";
               
            var sequence = Encoding.ASCII.GetBytes( ControlNumberSource );
            using( var crc32 = new Crc32() ) {
                crc32.Initialize();
                crc32.ComputeHash( sequence );
                var calculatedCrc32 = BitConverter.ToUInt32( crc32.Hash, 0 );
                var ControlNumber = (int)(calculatedCrc32 % 1000);
                if( ControlNumber == 0 ) {
                    ControlNumber = 1;
                }

                               Console.WriteLine($"calculatedCrc32: {calculatedCrc32}, ControlNumber: {ControlNumber}");
                               // calculatedCrc32: 2147742393, ControlNumber: 393
            }
               
       }
}

    public sealed class Crc32 : HashAlgorithm {
        public const uint DefaultPolynomial = 0xedb88320u;
        public const uint DefaultSeed = 0xffffffffu;

        private static uint[] _defaultTable;

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

        public Crc32()
            : this( DefaultPolynomial, DefaultSeed ) {
        }

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

        public override int HashSize => 32;

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

        protected override void HashCore( byte[] array, int ibStart, int cbSize ) {
            _hash = CalculateHash( _table, _hash, array, ibStart, cbSize );
        }

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

        public static uint Compute( byte[] buffer ) {
            return Compute( DefaultSeed, buffer );
        }

        public static uint Compute( uint seed, byte[] buffer ) {
            return Compute( DefaultPolynomial, seed, buffer );
        }

        public static uint Compute( uint polynomial, uint seed, byte[] buffer ) {
            return ~CalculateHash( InitializeTable( polynomial ), seed, buffer, 0, buffer.Length );
        }

        private static uint[] InitializeTable( uint polynomial ) {
            if( polynomial == DefaultPolynomial && _defaultTable != null ) {
                return _defaultTable;
            }

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

            if( polynomial == DefaultPolynomial ) {
                _defaultTable = createTable;
            }

            return createTable;
        }

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

        private static byte[] UInt32ToBigEndianBytes( uint uint32 ) {
            var result = BitConverter.GetBytes( uint32 );
            if( BitConverter.IsLittleEndian ) {
                Array.Reverse( result );
            }
            return result;
        }
    }