C# 计算字符串的哈希值（MD5、SHA）

最新推荐文章于 2022-05-17 19:53:52 发布
最新推荐文章于 2022-05-17 19:53:52 发布
阅读量5.3k 收藏 6
点赞数
分类专栏： .NET技术 加解密 C#提高
C#提高 同时被 3 个专栏收录
137 篇文章 1 订阅
订阅专栏
.NET技术
50 篇文章 1 订阅
订阅专栏
加解密
8 篇文章 0 订阅
订阅专栏

http://my.oschina.net/Tsybius2014/blog/294249?p=1


一、关于本文

本文中是一个类库，包括下面几个函数：

1）计算32位MD5码（大小写）：Hash_MD5_32

2）计算16位MD5码（大小写）：Hash_MD5_16

3）计算32位2重MD5码（大小写）：Hash_2_MD5_32

4）计算16位2重MD5码（大小写）：Hash_2_MD5_16

5）计算SHA-1码（大小写）：Hash_SHA_1

6）计算SHA-256码（大小写）：Hash_SHA_256

7）计算SHA-384码（大小写）：Hash_SHA_384

8）计算SHA-512码（大小写）：Hash_SHA_512

编译后被打包成文件HashTools.dll，其他程序可以在添加引用后对这些函数进行调用

二、类库中各函数代码

0）类库结构

?
1
2
3
4
5
6
7
8
9
10
11
12
13
using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Threading.Tasks;
 
namespace  HashTools
{
     public  class  HashHelper
     {
         //各个函数
     }
}

1）计算32位MD5码（大小写）：Hash_MD5_32

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/// <summary>
/// 计算32位MD5码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_MD5_32( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.MD5CryptoServiceProvider MD5CSP
             =  new  System.Security.Cryptography.MD5CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = MD5CSP.ComputeHash(bytValue);
         MD5CSP.Clear();
 
         //根据计算得到的Hash码翻译为MD5码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

2）计算16位MD5码（大小写）：Hash_MD5_16

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/// <summary>
/// 计算16位MD5码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_MD5_16( string  word,  bool  toUpper =  true )
{
     try
     {
         string  sHash = Hash_MD5_32(word).Substring(8, 16);
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

3）计算32位2重MD5码（大小写）：Hash_2_MD5_32

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/// <summary>
/// 计算32位2重MD5码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_2_MD5_32( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.MD5CryptoServiceProvider MD5CSP
             =  new  System.Security.Cryptography.MD5CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = MD5CSP.ComputeHash(bytValue);
 
         //根据计算得到的Hash码翻译为MD5码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         bytValue = System.Text.Encoding.UTF8.GetBytes(sHash);
         bytHash = MD5CSP.ComputeHash(bytValue);
         MD5CSP.Clear();
         sHash =  "" ;
 
         //根据计算得到的Hash码翻译为MD5码
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

4）计算16位2重MD5码（大小写）：Hash_2_MD5_16

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/// <summary>
/// 计算16位2重MD5码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_2_MD5_16( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.MD5CryptoServiceProvider MD5CSP
                 =  new  System.Security.Cryptography.MD5CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = MD5CSP.ComputeHash(bytValue);
 
         //根据计算得到的Hash码翻译为MD5码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         sHash = sHash.Substring(8, 16);
 
         bytValue = System.Text.Encoding.UTF8.GetBytes(sHash);
         bytHash = MD5CSP.ComputeHash(bytValue);
         MD5CSP.Clear();
         sHash =  "" ;
 
         //根据计算得到的Hash码翻译为MD5码
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         sHash = sHash.Substring(8, 16);
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

5）计算SHA-1码（大小写）：Hash_SHA_1

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/// <summary>
/// 计算SHA-1码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_SHA_1( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.SHA1CryptoServiceProvider SHA1CSP
             =  new  System.Security.Cryptography.SHA1CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = SHA1CSP.ComputeHash(bytValue);
         SHA1CSP.Clear();
 
         //根据计算得到的Hash码翻译为SHA-1码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

6）计算SHA-256码（大小写）：Hash_SHA_256

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/// <summary>
/// 计算SHA-256码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_SHA_256( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.SHA256CryptoServiceProvider SHA256CSP
             =  new  System.Security.Cryptography.SHA256CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = SHA256CSP.ComputeHash(bytValue);
         SHA256CSP.Clear();
 
         //根据计算得到的Hash码翻译为SHA-1码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

7）计算SHA-384码（大小写）：Hash_SHA_384

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/// <summary>
/// 计算SHA-384码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_SHA_384( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.SHA384CryptoServiceProvider SHA384CSP
             =  new  System.Security.Cryptography.SHA384CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = SHA384CSP.ComputeHash(bytValue);
         SHA384CSP.Clear();
 
         //根据计算得到的Hash码翻译为SHA-1码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

8）计算SHA-512码（大小写）：Hash_SHA_512

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/// <summary>
/// 计算SHA-512码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public  static  string  Hash_SHA_512( string  word,  bool  toUpper =  true )
{
     try
     {
         System.Security.Cryptography.SHA512CryptoServiceProvider SHA512CSP
             =  new  System.Security.Cryptography.SHA512CryptoServiceProvider();
 
         byte [] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
         byte [] bytHash = SHA512CSP.ComputeHash(bytValue);
         SHA512CSP.Clear();
 
         //根据计算得到的Hash码翻译为SHA-1码
         string  sHash =  "" , sTemp =  "" ;
         for  ( int  counter = 0; counter < bytHash.Count(); counter++)
         {
             long  i = bytHash[counter] / 16;
             if  (i > 9)
             {
                 sTemp = (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp = (( char )(i + 0x30)).ToString();
             }
             i = bytHash[counter] % 16;
             if  (i > 9)
             {
                 sTemp += (( char )(i - 10 + 0x41)).ToString();
             }
             else
             {
                 sTemp += (( char )(i + 0x30)).ToString();
             }
             sHash += sTemp;
         }
 
         //根据大小写规则决定返回的字符串
         return  toUpper ? sHash : sHash.ToLower();
     }
     catch  (Exception ex)
     {
         throw  new  Exception(ex.Message);
     }
}

三、函数调用
建立项目ComputeHash，添加对HashTools.dll库的引用。并添加代码：

?
1
using  HashTools;

然后在Main函数中添加下列代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
static  void  Main( string [] args)
{
     Console.WriteLine( "MD5 of \"abc\"" );
 
     Console.WriteLine( "MD5_32(Upper): {0}" , 
         HashHelper.Hash_MD5_32( "abc" ));
     Console.WriteLine( "MD5_32(Lower): {0}" ,
         HashHelper.Hash_MD5_32( "abc" ,  false ));
 
     Console.WriteLine( "MD5_16(Upper): {0}" ,
         HashHelper.Hash_MD5_16( "abc" ));
     Console.WriteLine( "MD5_16(Lower): {0}" ,
         HashHelper.Hash_MD5_16( "abc" ,  false ));
 
     Console.WriteLine( "2_MD5_32(Upper): {0}" , 
         HashHelper.Hash_2_MD5_32( "abc" ));
     Console.WriteLine( "2_MD5_32(Lower): {0}" , 
         HashHelper.Hash_2_MD5_32( "abc" ,  false ));
 
     Console.WriteLine( "2_MD5_32(Upper): {0}" , 
         HashHelper.Hash_2_MD5_16( "abc" ));
     Console.WriteLine( "2_MD5_32(Lower): {0}" , 
         HashHelper.Hash_2_MD5_16( "abc" ,  false ));
 
     Console.WriteLine( "SHA of \"abc\"" );
 
     Console.WriteLine( "SHA-1(Upper): {0}" , 
         HashHelper.Hash_SHA_1( "abc" ));
     Console.WriteLine( "SHA-1(Lower): {0}" , 
         HashHelper.Hash_SHA_1( "abc" ,  false ));
 
     Console.WriteLine( "SHA-256(Upper): {0}" ,
         HashHelper.Hash_SHA_256( "abc" ));
     Console.WriteLine( "SHA-256(Lower): {0}" ,
         HashHelper.Hash_SHA_256( "abc" ,  false ));
 
     Console.WriteLine( "SHA-384(Upper): {0}" ,
         HashHelper.Hash_SHA_384( "abc" ));
     Console.WriteLine( "SHA-384(Lower): {0}" ,
         HashHelper.Hash_SHA_384( "abc" ,  false ));
 
     Console.WriteLine( "SHA-512(Upper): {0}" , 
         HashHelper.Hash_SHA_512( "abc" ));
     Console.WriteLine( "SHA-512(Lower): {0}" , 
         HashHelper.Hash_SHA_512( "abc" ,  false ));
 
     Console.ReadLine();
}
运行结果如下：

END
plean
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#计算字符串哈希值（MD5、SHA）的方法小结
09-03
主要介绍了C#计算字符串哈希值（MD5、SHA）的方法,以实例形式较为详细的分析总结了C#计算字符串哈希值的各种常用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C# 计算字符串MD5值
LuckyJoey的博客
10-24 546
public class GetMd5Hash : MonoBehaviour { // Start is called before the first frame update void Start() { Debug.Log(GetMd5HashString("Hello World")); } string GetMd5HashSt...
C#获取MD5哈希字符串
06-03 149
using System.Security.Cryptography; using System.Text; public class MD5Helper { private static MD5 md5 = MD5.Create(); //使用utf8编码将字符串散列 public static string GetMD5HashS...
c#编写的MD5加密类
牛牛的小窝
01-03 1583
 c#编写的MD5加密类 using System.Security.Cryptography;  //  //MD5加密函数  //  public string MD5(String str)  {   MD5 md5=new MD5CryptoServiceProvider();   byte[] data=System.Text.Encoding.Default.GetBytes(st
HOW TO：使用 C# .NET 计算和比较哈希值
livening的专栏
09-10 1083
using System;using System.Security.Cryptography;using System.Text;namespace ComputeAHash_csharp{ /// /// Summary description for Class1. /// class Class1 { static void Main(st
c#之如何计算哈希值字符串
weixin_30765577的博客
06-01 628
代码如下： /// <summary> /// 计算哈希值字符串 /// </summary> public static string ComputeHash(byte[] buffer) { if (buffer == null || buffer.Length < 1) ...
C＃：生成哈希字符串
寒冰屋的专栏
07-01 4437
目录 介绍 背景 哈希助手类 考虑 对象到哈希字符串的过程 多个对象组合的哈希 我们将更频繁地使用的方法 整个对象的哈希 重要的是记住 数据值散列 哈希结果 其他测试 奖励：字符串哈希 结论 下载源代码 - 5.9 KB 介绍 散列是将值转换为通常较短的固定长度的键/值，其表示原始值。几天前，我们不得不使用哈希比较来通过API在两个系统之间同步数据（显然，这不是使用...
C# 中使用 MD5 算法计算 hash （哈希）值的四种方法
热门推荐
西井学习笔记
11-23 1万+
在.net中，由 System.Security.Cryptography 命名空间提供了加密和哈希的几个类。其中 md5 编码由 MD5CryptoServiceProvider 实现。 在使用过程中由于 MD5CryptoServiceProvider 提供了多种方法去计算md5的hash值，反而令人搞不清楚，所以这里帖出计算md5的几种常见方法先引用命名空间： using System.Se
C#实现给定字符串生成MD5哈希的方法
09-03
主要介绍了C#实现给定字符串生成MD5哈希的方法,涉及C#操作字符串的相关技巧,需要的朋友可以参考下
哈希值MD5校验工具.zip
07-23
哈希值MD5校验工具.zip
C# Hash字符串
Sophie1797的博客
08-09 3839
C# Hash字符串 public static byte[] GetHash(string inputString) { HashAlgorithm algorithm = MD5.Create(); //or use SHA256.Create(); return algorithm.ComputeHash(Encoding.UTF8.GetBytes(input...
C#上位机开发（十五）—— 计算字符串哈希值和文件哈希值
Mculover666的博客（嵌入式）
05-17 1515
一、C#计算哈希值方法 1. 引用类库 using System.Security.Cryptography; 2. 计算哈希值 //Compute hash based on source data. tmpHash = new MD5CryptoServiceProvider().ComputeHash(tmpSource); 二、计算字符串哈希 （1）声明用于保存源数据的字符串变量，以及两个字节数组 (未定义的大小) 保存源字节和生成的哈希值。 string sSourceData; byte[]
c# 获取文件本身的哈希值
star__119的博客
11-15 6761
1. 哈希值是什么 我个人认为，哈希值是一个统称，也就是经过加密算法后得出的长度较短、位数固定的输出序列即散列值，这个哈希值是一个凭证，一个数字签名之类的，唯一对应你加密之前的东西，这都是我自个儿觉得的，也可能不是很准确啊 2. 加密算法（SHA1 MD5） using System; using System.IO; using System.Security.Cryptography; st...
大学物理册答案上下都有
最新发布
04-26
大学物理册答案上下都有
UWB超宽带信道研究及源码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
c# 将字符串转换sha-1哈希值。
06-02
在 C# 中，可以使用 System.Security.Cryptography 命名空间中的 SHA1 类来计算字符串的 SHA-1 哈希值。下面是一个示例代码： ```csharp using System; using System.Security.Cryptography; using System.Text; class Program { static void Main(string[] args) { string input = "hello world"; byte[] inputBytes = Encoding.UTF8.GetBytes(input); using (SHA1 sha1 = SHA1.Create()) { byte[] hashBytes = sha1.ComputeHash(inputBytes); string hashString = BitConverter.ToString(hashBytes).Replace("-", ""); Console.WriteLine("SHA1 hash of '{0}': {1}", input, hashString); } } } ``` 这段代码将字符串 "hello world" 转换为 UTF-8 编码的字节数组，然后使用 SHA1 类的 ComputeHash 方法计算哈希值。最后，使用 BitConverter 和 Replace 方法将哈希值转换为十六进制字符串。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值