BranchesTags

Repository files navigation

Crc32.NET

Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.

(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)

Installation through Nuget:

> Install-Package Crc32.NET

Version 1.1.0 Remarks

Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.

So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.

Version 1.2.0 Remarks

CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number. This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.

This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.

So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:

varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}

In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.

Description

This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.

If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.

Performance

This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.

LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s

Some notes

I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.

Api interface was taken from Crc32C.NET library. It is very handy for using in applications.

License

MIT license

About

Fast version of Crc32 algorithm for .NET

Resources

Readme
MIT license
Activity

Stars

205 stars

Watchers

9 watching

Forks

52 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Crc32.NET
Optimized and fast managed implementation of Crc32 & Crc32C (Castagnoly) algorithms for .NET and .NET Core.
(But if you need, I can add native implementation (with transparent .net wrapper) which is twice faster .NET version)
Installation through Nuget:
> Install-Package Crc32.NET
Version 1.1.0 Remarks
Initially, this library only support Crc32 checksum, but I found, that there are lack of .NET Core libraries for Crc32 calculation. So, I've added Crc32C (Castagnoli) managed implementation in this library. Other Crc32 variants (like Crc32Q or Crc32K) seems to be unpopular to implement it here.
So, if you need to use Crc32C for .NET Core, you can use this library. But if you only use 'big' .NET frameworks, it is better to use Crc32C.NET for Crc32C? because it has fast native implementation.
Version 1.2.0 Remarks
CRC algorithms has interesting feature: if we calculate it for some data and write result CRC data to end of source data, then calculate data with this CRC we'll receive a constant number.
This number is 0x2144DF1C for CRC32 and 0x48674BC7 for CRC32C.
This feature can be used for more convenient CRC usage, e.g. validation of correctness is a simple comparison with constant. There are no requirement to decode CRC value from input array and compare it with calculated data.
So in 1.2.0 version, I've added 2 methods (with overloads) to use this feature:
varinputArray=newbyte[realDataLength+4];// write real data to inputArrayCrc32Algorithm.ComputeAndWriteToEnd(inputArray);// last 4 bytes contains CRC// transferring data or writing reading, and checking as final operationif(!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray)){thrownewInvalidOperationException("Data was tampered");}
In other words, you should pass some input buffer to calculation function and it will write CRC data at last 4 bytes. After that, when you need validation, you should pass this buffer to validation function and it will return is data correct.
Description
This library is port of Crc32C.NET by Robert Važan but for Crc32 algorithm. Also, this library contains optimizations for managed code, so, it really faster than other Crc32 implementations.
If you do not not catch the difference, it is C (Castagnoli). I recommend to use Crc32C, not usual CRC32, because it can be faster (up to 20GB/s with native CPU implementation) and slightly better in error detection. But if you need exactly Crc32, this library is the best choice.
Performance
This library has code, which is optimized for .NET (implementation is not dumb copy-paste from google), as result, it is really fast in comparison with other implemenations.
LibrarySpeed
CH.Crc32 by Cliff Hammerschmidt117 MB/s
Crc32 by Dario Griffo401 MB/s
Klinkby.Checksum by Mads Breusch Klinkby400 MB/s
Data.HashFunction.CRC by Brandon Dahler206 MB/s
Dexiom.QuickCrc32 by Jonathan Paré364 MB/s
K4os.Hash.Crc by Milosz Krajewski399 MB/s
This library1170 MB/s
Some notes
I thought about making a pull request to Crc32 library, but it seems, this library was abandoned. Anyway, I implement my library to be fully compatible with Crc32 library. And you can switch from Crc32 library to this.
Api interface was taken from Crc32C.NET library. It is very handy for using in applications.
License
MIT license
About
Fast version of Crc32 algorithm for .NET
Resources
Readme
MIT license
Activity
Stars
205 stars
Watchers
9 watching
Forks
52 forks
Report repository
Releases
Packages
Used by
Contributors
Languages