C# 笔记

最新推荐文章于 2024-04-16 09:05:53 发布
最新推荐文章于 2024-04-16 09:05:53 发布
阅读量987 收藏 2
点赞数
分类专栏： C#笔记 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DK18397606232/article/details/105965556
版权

目录

1.string转流

2.RSA个人笔记类（XML+PEM格式）【十分杂乱】

3.RSA简单操作类（XML+PEM）【来源个人笔记类整理结果】

4.从资源文件中拉取（获取/下载）文件

5.获取串口名称

6.WriteINI

7.反射与泛型_DataTable 转 类   的操作类

8.随缘更新0.0     。。。。。。。。。。

1.string转流

string str= "123";
StringReader sr = new StringReader(str);

2.RSA个人笔记类（XML+PEM格式）【十分杂乱】

using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Encodings;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.X509;
using System.IO;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Web;

namespace RSA加解密
{
    public class RSA
    {
        #region RSA 的密钥产生
        /// <summary>
        /// 生成密钥对【XML格式】
        /// </summary>
        /// <param name="xmlKeys">私钥</param>
        /// <param name="xmlPublicKey">公钥</param>
        public static void XMLRSAKey(out string xmlKeys, out string xmlPublicKey)
        {
            try
            {
                System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                xmlKeys = rsa.ToXmlString(true);
                xmlPublicKey = rsa.ToXmlString(false);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 生成密钥对【Pem格式】
        /// </summary>
        /// <param name="pemKeys"></param>
        /// <param name="pemPublicKey"></param>
        public static void PemRSAKey(out string pemKeys, out string pemPublicKey)
        {
            try
            {
                System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                pemKeys = XmlToPemPrivate(rsa.ToXmlString(true));
                pemPublicKey = XmlToPemPublic(rsa.ToXmlString(false));
                
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #endregion

        #region RSA加密函数
        //############################################################################## 
        //RSA 方式加密 
        //KEY必须是XML的形式,返回的是字符串 
        //该加密方式有长度限制的！
        //############################################################################## 

        /// <summary>
        /// RSA加密【XML格式，字符串】
        /// </summary>
        /// <param name="xmlPublicKey">公钥</param>
        /// <param name="encryptString">待加密的字符串</param>
        /// <returns></returns>
        public static string XMLRSAEncrypt(string xmlPublicKey, string encryptString)
        {
            try
            {
                byte[] PlainTextBArray;
                byte[] CypherTextBArray;
                string Result;
                System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(xmlPublicKey);
                PlainTextBArray = (new UnicodeEncoding()).GetBytes(encryptString);
                CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);
                Result = Convert.ToBase64String(CypherTextBArray);
                return Result;
            }
            catch (Exception ex)
            {
                return "";
            }
        }
        /// <summary>
        /// RSA加密【XML格式，字节】
        /// </summary>
        /// <param name="xmlPublicKey">公钥</param>
        /// <param name="EncryptString">待加密的字节数组</param>
        /// <returns></returns>
        public string XMLRSAEncrypt(string xmlPublicKey, byte[] EncryptString)
        {
            try
            {
                byte[] CypherTextBArray;
                string Result;
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(xmlPublicKey);
                CypherTextBArray = rsa.Encrypt(EncryptString, false);
                Result = Convert.ToBase64String(CypherTextBArray);
                return Result;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// RSA加密【Pem格式】
        /// </summary>
        /// <param name="PubKey">公钥</param>
        /// <param name="data">需加密数据</param>
        /// <returns></returns>
        public static string PemRSAEncrypt(string PubKey, string data)
        {
            StringReader sr = new StringReader(PubKey);
            AsymmetricKeyParameter publickey = new PemReader(sr).ReadObject() as AsymmetricKeyParameter;

            if (publickey == null)
                throw new Exception("私钥读取失败");

            try
            {
                var engine = new Pkcs1Encoding(new RsaEngine());
                engine.Init(true, publickey);


                byte[] bytes = Encoding.UTF8.GetBytes(data);//Encoding.UTF8.GetBytes(data);
                bytes = engine.ProcessBlock(bytes, 0, bytes.Length);

                return Convert.ToBase64String(bytes);// Convert.ToBase64String(bytes);
            }
            catch
            {
                throw new Exception("加密失败");
            }
        }

        #endregion

        #region RSA的解密函数        
        /// <summary>
        /// RSA解密【XML格式，字符串】
        /// </summary>
        /// <param name="xmlPrivateKey">私钥</param>
        /// <param name="decryptString">待解密的字符串</param>
        /// <returns></returns>
        public static string XMLRSADecrypt(string xmlPrivateKey, string decryptString)
        {
            try
            {
                byte[] PlainTextBArray;
                byte[] DypherTextBArray;
                string Result;
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(xmlPrivateKey);
                PlainTextBArray = Convert.FromBase64String(decryptString);
                DypherTextBArray = rsa.Decrypt(PlainTextBArray, false);
                Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
                return Result;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// RSA解密【XML格式，字节】 
        /// </summary>
        /// <param name="xmlPrivateKey">私钥</param>
        /// <param name="DecryptString">待解密的字节数组</param>
        /// <returns></returns>
        public string XMLRSADecrypt(string xmlPrivateKey, byte[] DecryptString)
        {
            try
            {
                byte[] DypherTextBArray;
                string Result;
                System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(xmlPrivateKey);
                DypherTextBArray = rsa.Decrypt(DecryptString, false);
                Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
                return Result;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// RSA解密【Pem格式，字符串】
        /// </summary>
        /// <param name="PriKey">私钥</param>
        /// <param name="str">加密字后符串</param>
        /// <returns></returns>
        public static string PemRSADecrypt(string PriKey, string str)
        {
            byte[] bytes = Convert.FromBase64String(str);// Convert.FromBase64String(data);
            StringReader sr = new StringReader(PriKey);
            AsymmetricKeyParameter prikey = new PemReader(sr).ReadObject() as AsymmetricKeyParameter;

            if (prikey == null)
                throw new Exception("私钥读取失败");

            try
            {
                var engine = new Pkcs1Encoding(new RsaEngine());
                engine.Init(false, prikey);
                bytes = engine.ProcessBlock(bytes, 0, bytes.Length);

                return Encoding.UTF8.GetString(bytes);Encoding.UTF8.GetString(bytes);
            }
            catch
            {
                throw new Exception("解密失败");
            }
        }

        #endregion

        #region 签名

        /// <summary>
        /// 签名
        /// </summary>
        /// <param name="str">需签名的数据</param>
        /// <returns>签名后的值</returns>
        public static string XMLSign(string str, string str_privateKey)
        {
            //根据需要加签时的哈希算法转化成对应的hash字符节
            byte[] bt = Encoding.GetEncoding("utf-8").GetBytes(str);
            var sha256 = new SHA256CryptoServiceProvider();
            byte[] rgbHash = sha256.ComputeHash(bt);

            RSACryptoServiceProvider key = new RSACryptoServiceProvider();
            key.FromXmlString(str_privateKey);
            RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
            formatter.SetHashAlgorithm("SHA256");                                            //此处是你需要加签的hash算法，需要和上边你计算的hash值的算法一致，不然会报错。
            byte[] inArray = formatter.CreateSignature(rgbHash);
            return Convert.ToBase64String(inArray);
        }

        /// <summary>
        /// 签名
        /// </summary>
        /// <param name="str">需签名的数据</param>
        /// <returns>签名后的值</returns>
        public static string PemSign(string str, string str_privateKey)
        {
            str_privateKey = PemToXmlKey(str_privateKey, true);
            //根据需要加签时的哈希算法转化成对应的hash字符节
            byte[] bt = Encoding.GetEncoding("utf-8").GetBytes(str);
            var sha256 = new SHA256CryptoServiceProvider();
            byte[] rgbHash = sha256.ComputeHash(bt);

            RSACryptoServiceProvider key = new RSACryptoServiceProvider();
            key.FromXmlString(str_privateKey);
            RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
            formatter.SetHashAlgorithm("SHA256");                                            //此处是你需要加签的hash算法，需要和上边你计算的hash值的算法一致，不然会报错。
            byte[] inArray = formatter.CreateSignature(rgbHash);
            return Convert.ToBase64String(inArray);
        }

        /// <summary>
        /// 签名验证
        /// </summary>
        /// <param name="str">待验证的字符串</param>
        /// <param name="sign">加签之后的字符串</param>
        /// <returns>签名是否符合</returns>
        public static bool XMLSignCheck(string str, string sign, string str_publicKey)
        {
            try
            {
                byte[] bt = Encoding.GetEncoding("utf-8").GetBytes(str);
                var sha256 = new SHA256CryptoServiceProvider();
                byte[] rgbHash = sha256.ComputeHash(bt);

                RSACryptoServiceProvider key = new RSACryptoServiceProvider();
                key.FromXmlString(str_publicKey);
                RSAPKCS1SignatureDeformatter deformatter = new RSAPKCS1SignatureDeformatter(key);
                deformatter.SetHashAlgorithm("SHA256");
                byte[] rgbSignature = Convert.FromBase64String(sign);
                if (deformatter.VerifySignature(rgbHash, rgbSignature))
                {
                    return true;
                }
                return false;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 签名验证
        /// </summary>
        /// <param name="str">待验证的字符串</param>
        /// <param name="sign">加签之后的字符串</param>
        /// <returns>签名是否符合</returns>
        public static bool PemSignCheck(string str, string sign, string str_publicKey)
        {
            try
            {
                str_publicKey = PemToXmlKey(str_publicKey, false);
                byte[] bt = Encoding.GetEncoding("utf-8").GetBytes(str);
                var sha256 = new SHA256CryptoServiceProvider();
                byte[] rgbHash = sha256.ComputeHash(bt);

                RSACryptoServiceProvider key = new RSACryptoServiceProvider();
                key.FromXmlString(str_publicKey);
                RSAPKCS1SignatureDeformatter deformatter = new RSAPKCS1SignatureDeformatter(key);
                deformatter.SetHashAlgorithm("SHA256");
                byte[] rgbSignature = Convert.FromBase64String(sign);
                if (deformatter.VerifySignature(rgbHash, rgbSignature))
                {
                    return true;
                }
                return false;
            }
            catch(Exception ex)
            {
                return false;
            }
        }

        #endregion

        #region xml转pem

        //参考连接：https://www.jianshu.com/p/faefcc58c79b
        //工具网址1：https://the-x.cn/certificate/PemToXml.aspx
        //工具网址2：https://superdry.apphb.com/tools/online-rsa-key-converter
        //需要依赖一个第三方库，叫BouncyCastle ；在线获取安装包的代码是：PM >Install-Package BouncyCastle


        /// <summary>
        ///  XML格式公钥转PEM格式公钥
        /// </summary>
        /// <param name="xml">XML格式的公钥</param>
        /// <param name="saveFile">保存文件的物理路径</param>
        public static string XmlToPemPublic(string xml, string saveFile = "")
        {
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xml);
            var p = rsa.ExportParameters(false);
            RsaKeyParameters key = new RsaKeyParameters(false, new BigInteger(1, p.Modulus), new BigInteger(1, p.Exponent));
            //从Pem文件读取
            //using (var sw = new StreamWriter(saveFile))
            //{
            //    var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
            //    pemWriter.WriteObject(key);
            //}

            SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(key);
            byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
            string publicKey = Convert.ToBase64String(serializedPublicBytes);
            return Format(publicKey, 1);
        }

        /// <summary>
        ///  XML格式私钥转PEM
        /// </summary>
        /// <param name="xml">XML格式私钥</param>
        /// <param name="saveFile">保存文件的物理路径</param>
        public static string XmlToPemPrivate(string xml, string saveFile = "")
        {
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xml);
            var p = rsa.ExportParameters(true);
            var key = new RsaPrivateCrtKeyParameters(
                new BigInteger(1, p.Modulus), new BigInteger(1, p.Exponent), new BigInteger(1, p.D),
                new BigInteger(1, p.P), new BigInteger(1, p.Q), new BigInteger(1, p.DP), new BigInteger(1, p.DQ),
                new BigInteger(1, p.InverseQ));
            //从Pem文件读取
            //using (var sw = new StreamWriter(saveFile))
            //{
            //    var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
            //    pemWriter.WriteObject(key);
            //}

            PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(key);
            byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
            string privateKey = Convert.ToBase64String(serializedPrivateBytes);
            return Format(privateKey, 2);
        }

        /// <summary>
        ///  格式化公钥/私钥
        /// </summary>
        /// <param name="key">生成的公钥/私钥</param>
        /// <param name="type">1:公钥 2:私钥</param>
        /// <returns>PEM格式的公钥/私钥</returns>
        public static string Format(string key, int type)
        {
            string result = string.Empty;

            int length = key.Length / 64;
            for (int i = 0; i < length; i++)
            {
                int start = i * 64;
                result = result + key.Substring(start, 64) + "\r\n";
            }

            result = result + key.Substring(length * 64);
            if (type == 1)
            {
                result = result.Insert(0, "-----BEGIN PUBLIC KEY-----\r\n");
                result += "\r\n-----END PUBLIC KEY-----";
            }
            if (type == 2)
            {
                result = result.Insert(0, "-----BEGIN PRIVATE KEY-----\r\n");
                result += "\r\n-----END PRIVATE KEY-----";
            }

            return result;
        }



        /// <summary>
        /// XML密钥转Pem密钥
        /// </summary>
        /// <param name="RSAKey">RSA密钥</param>
        /// <param name="isPrivateKey">是否是私钥</param>
        /// <returns>Pem密钥</returns>
        public static string XmlKeyToPem(string RSAKey, bool isPrivateKey)
        {
            string pemKey = string.Empty;
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(RSAKey);
            RSAParameters rsaPara = new RSAParameters();
            RsaKeyParameters key = null;
            //RSA私钥
            if (isPrivateKey)
            {
                rsaPara = rsa.ExportParameters(true);
                key = new RsaPrivateCrtKeyParameters(
                    new BigInteger(1, rsaPara.Modulus), new BigInteger(1, rsaPara.Exponent), new BigInteger(1, rsaPara.D),
                    new BigInteger(1, rsaPara.P), new BigInteger(1, rsaPara.Q), new BigInteger(1, rsaPara.DP), new BigInteger(1, rsaPara.DQ),
                    new BigInteger(1, rsaPara.InverseQ));
            }
            //RSA公钥
            else
            {
                rsaPara = rsa.ExportParameters(false);
                key = new RsaKeyParameters(false,
                    new BigInteger(1, rsaPara.Modulus),
                    new BigInteger(1, rsaPara.Exponent));
            }
            using (TextWriter sw = new StringWriter())
            {
                var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
                pemWriter.WriteObject(key);
                pemWriter.Writer.Flush();
                pemKey = sw.ToString();
            }
            return pemKey;
        }

        #endregion

        #region Pem转xml

        /// <summary>
        ///  一对Pem格式密钥转xml
        /// </summary>
        /// <param name="PrivateKey"></param>
        /// <param name="PublicKey"></param>
        /// <param name="XmlPriKey"></param>
        /// <param name="XmlPubKey"></param>
        public static void CouplePemToXml(string PrivateKey, string PublicKey, out string XmlPriKey, out string XmlPubKey)
        {
            PrivateKey = PrivateKey.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "");
            PublicKey = PublicKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "");
            //-------------------------------------------将PEM格式密钥对转换为XML格式密钥对------------------------------------------

            //将PEM格式的密钥对转换为XML格式供以下加密解密使用

            //PEM格式私钥转XML格式
            RsaPrivateCrtKeyParameters privateKey = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(PrivateKey));
            RSACryptoServiceProvider rcsp = new RSACryptoServiceProvider();
            RSAParameters parms = new RSAParameters();
            //So the thing changed is offcourse the ToByteArrayUnsigned() instead of
            //ToByteArray()
            //将私钥的因子、参数等信息序列化进RSAParameters对象中，私钥中的Modulus和Exponent按照某种规则组合起来其实就是公钥！
            parms.Modulus = privateKey.Modulus.ToByteArrayUnsigned();
            parms.P = privateKey.P.ToByteArrayUnsigned();
            parms.Q = privateKey.Q.ToByteArrayUnsigned();
            parms.DP = privateKey.DP.ToByteArrayUnsigned();
            parms.DQ = privateKey.DQ.ToByteArrayUnsigned();
            parms.InverseQ = privateKey.QInv.ToByteArrayUnsigned();
            parms.D = privateKey.Exponent.ToByteArrayUnsigned();
            parms.Exponent = privateKey.PublicExponent.ToByteArrayUnsigned();
            //So now this now appears to work.
            rcsp.ImportParameters(parms);
            PrivateKey = rcsp.ToXmlString(true);//XML秘钥
                                                //PEM格式公钥转XML格式
                                                //公钥的转换只需要提供Modulus（译：模数、系数）和Exponent（译：指数）两个参数即可，以下代码为只转换公钥。
                                                //------------------------------------------------------------------------------------------------------------------------
                                                //RsaKeyParameters publicKey = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(PublicKey));
                                                //parms = new RSAParameters();
                                                //rcsp = new RSACryptoServiceProvider();
                                                //parms.Modulus = publicKey.Modulus.ToByteArrayUnsigned();
                                                //parms.Exponent = publicKey.Exponent.ToByteArrayUnsigned();
                                                //rcsp.ImportParameters(parms);
                                                //------------------------------------------------------------------------------------------------------------------------
            PublicKey = rcsp.ToXmlString(false);//XML公钥
            XmlPriKey = PrivateKey;
            XmlPubKey = PublicKey;
        }

        /// <summary>
        /// Pem密钥转XML密钥
        /// </summary>
        /// <param name="pemKey">Pem密钥</param>
        /// <param name="isPrivateKey">是否是私钥</param>
        /// <returns>RSA密钥</returns>
        public static string PemToXmlKey(string pemKey, bool isPrivateKey)
        {
            if (isPrivateKey)
            {
                pemKey = pemKey.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "");
            }
            else
            {
                pemKey = pemKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "");
            }
            string rsaKey = string.Empty;
            object pemObject = null;
            RSAParameters rsaPara = new RSAParameters();
            using (StringReader sReader = new StringReader(pemKey))
            {
                var pemReader = new Org.BouncyCastle.OpenSsl.PemReader(sReader);
                pemObject = pemReader.ReadObject();
            }
            //RSA私钥
            if (isPrivateKey)
            {
                RsaPrivateCrtKeyParameters key = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(pemKey));
                rsaPara = new RSAParameters
                {
                    Modulus = key.Modulus.ToByteArrayUnsigned(),
                    Exponent = key.PublicExponent.ToByteArrayUnsigned(),
                    D = key.Exponent.ToByteArrayUnsigned(),
                    P = key.P.ToByteArrayUnsigned(),
                    Q = key.Q.ToByteArrayUnsigned(),
                    DP = key.DP.ToByteArrayUnsigned(),
                    DQ = key.DQ.ToByteArrayUnsigned(),
                    InverseQ = key.QInv.ToByteArrayUnsigned(),
                };
            }
            //RSA公钥
            else
            {
                RsaKeyParameters key = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(pemKey));
                rsaPara.Modulus = key.Modulus.ToByteArrayUnsigned();
                rsaPara.Exponent = key.Exponent.ToByteArrayUnsigned();
            }
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.ImportParameters(rsaPara);
            using (StringWriter sw = new StringWriter())
            {
                sw.Write(rsa.ToXmlString(isPrivateKey ? true : false));
                rsaKey = sw.ToString();
            }
            return rsaKey;
        }

        #endregion

    }
}

3.RSA简单操作类（XML+PEM）【来源个人笔记类整理结果】

点击进入查看----->      C# RSA操作类（XML与PEM互转）带demo

4.从资源文件中拉取（获取/下载）文件

可以把文件放在exe内，而不是很多资源文件夹

首先需要把文件放入资源文件夹

然后将资源文件改为嵌入式资源

然后就开始码代码啦！

 

/// <summary>
        /// 从资源文件中抽取资源文件
        /// </summary>
        /// <param name="resFileName">资源文件名称（资源文件名称必须包含目录，目录间用“.”隔开,最外层是项目默认命名空间）</param>
        /// <param name="outputFile">输出文件</param>
        public static void ExtractResFile(string resFileName, string outputFile)
        {
            BufferedStream inStream = null;
            FileStream outStream = null;
            try
            {
                Assembly asm = Assembly.GetExecutingAssembly(); //读取嵌入式资源
                inStream = new BufferedStream(asm.GetManifestResourceStream(resFileName));
                outStream = new FileStream(outputFile, FileMode.Create, FileAccess.Write);

                byte[] buffer = new byte[1024];
                int length;

                while ((length = inStream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    outStream.Write(buffer, 0, length);
                }
                outStream.Flush();
            }
            finally
            {
                if (outStream != null)
                {
                    outStream.Close();
                }
                if (inStream != null)
                {
                    inStream.Close();
                }
            }
        }




//调用示例：
//ExtractResFile("命名空间.Resources.CSSReadCardNoServices.exe", @"C:\Program Files (x86)\CSSReadCardNo\CSSReadCardNoServices.exe");

5.获取串口名称

//需要再引用中添加该命名空间
using System.Management;


private static void GetMyComName()
        {
            try
            {
                using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("select * from Win32_PnPEntity"))
                {
                    var hardInfos = searcher.Get();
                    int index = 1;
                    foreach (var hardInfo in hardInfos)
                    {
                        if (hardInfo.Properties["Name"].Value != null && hardInfo.Properties["Name"].Value.ToString().Contains("(COM"))
                        {
                            String strComName = hardInfo.Properties["Name"].Value.ToString();//这是获取到的串口名称
//以下是截取需要的串口名称，从而获得串口号，comname是定义的全局变量，大家可以适当修改即可
                            if (strComName.Contains("USB Serial Port"))
                            {
                                comname = System.Text.RegularExpressions.Regex.Replace(strComName, @"(.*\()(.*)(\).*)", "$2");
                                return;
                            }
                            else
                            {
                                comname = "";
                            }
                            index += 1;
                        }
                    }
                }
                Console.ReadKey();
            }
            catch
            {

            }
        }

6.WriteINI

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace CSInOutRegistration
{
    public class WriteINI
    {
        public static string inipath = AppDomain.CurrentDomain.BaseDirectory + "Config.ini";

        //声明API函数

        [DllImport("kernel32")]
        private static extern long WritePrivateProfileString(string section, string key, string val, string filePath);
        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString(string section, string key, string def, StringBuilder retVal, int size, string filePath);
        /// <summary> 
        /// 构造方法 
        /// </summary> 
        /// <param name="INIPath">文件路径</param> 
        public void IniFiles(string INIPath)
        {
            inipath = INIPath;
        }

        public void IniFiles() { }

        /// <summary> 
        /// 写入INI文件 
        /// </summary> 
        /// <param name="Section">项目名称(如 [TypeName] )</param> 
        /// <param name="Key">键</param> 
        /// <param name="Value">值</param> 
        public static void IniWriteValue(string Section, string Key, string Value)
        {
            WritePrivateProfileString(Section, Key, Value, inipath);
        }
        /// <summary> 
        /// 读出INI文件 
        /// </summary> 
        /// <param name="Section">项目名称(如 [TypeName] )</param> 
        /// <param name="Key">键</param> 
        public static string IniReadValue(string Section, string Key)
        {
            StringBuilder temp = new StringBuilder(500);
            int i = GetPrivateProfileString(Section, Key, "", temp, 500, inipath);
            return temp.ToString();
        }
        /// <summary> 
        /// 验证文件是否存在 
        /// </summary> 
        /// <returns>布尔值</returns> 
        public bool ExistINIFile()
        {
            return File.Exists(inipath);
        }
    }
}

7.反射与泛型_DataTable 转 类   的操作类

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace CSQueryKing
{
    class DtConvent<T> where T : new()
    {
        public static List<T> DtToClass(DataTable dt)
        {
            List<T> list = new List<T>();
            string tempName = "";
            // 获得此模型的类型   
            Type type = typeof(T);
            foreach (DataRow dr in dt.Rows)
            {
                T t = new T();
                // 获得此模型的公共属性      
                PropertyInfo[] propertys = t.GetType().GetProperties();
                foreach (var pi in propertys)
                {
                    tempName = pi.Name;  // 检查DataTable是否包含此列   
                    if (dt.Columns.Contains(tempName))
                    {
                        // 判断此属性是否有Setter (可写属性),如果没有则跳出    
                        if (!pi.CanWrite) continue;
                        object value = dr[tempName];
                        if (value != DBNull.Value)
                            pi.SetValue(t, value, null);
                    }
                }
                list.Add(t);
            }
            return list;
        }
    }
}

8.随缘更新0.0     。。。。。。。。。。。

道空
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 与JAVA 的RSA 加密解密交互，互通，C#使用BouncyCastle来实现私钥加密，公钥解密的方法...
weixin_30564785的博客
05-01 848
因为C#的RSA加密解密只有公钥加密，私钥解密，没有私钥加密，公钥解密。在网上查了很久也没有很好的实现。BouncyCastle的文档少之又少。很多人可能会说，C#也是可以的，通过Biginteger开源类来实现，不过那个是有一个文章，不过他加密出来的是16进制结果的。根本不能和JAVA互通。连加密出来的都不和C#原生的加密出来的结果格式一样。所以还是没有好的解决方法。 接下来还是不断的找资料，...
ras私钥c#转java_C#和JAVA的RSA密钥、公钥转换
weixin_33561009的博客
12-24 406
BouncyCastle Crypto转换格式转换要用到一个开源加密库Bouncy Castle Crypto APIs，using System;using System.Xml;using Org.BouncyCastle.Asn1.Pkcs;using Org.BouncyCastle.Asn1.X509;using Org.BouncyCastle.Crypto.Parameters;us...
C# RSA操作类（XML与PEM互转）带demo
DK18397606232的博客
05-07 2316
Tip：简单整理的操作类，供大家参考 using Org.BouncyCastle.Asn1.Pkcs; using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Encodings; using Org.BouncyCastle.Crypto.Engines; ...
C#安全API
weixin_30535565的博客
11-17 187
Bouncycastle库C#版 官网地址为：http://www.bouncycastle.org/csharp/。 http://blog.csdn.net/popozhu/article/details/5812662 http://www.xuebuyuan.com/301023.html 从PEM文件读取秘钥 PemReader r = new PemReade...
机器码、序列号、认证码、注册码的生成算法（四）
lweiyue的专栏
06-06 1万+
生成注册码（非对称加解密） 我们再列出几种生成注册码的情况： （1）软件生成一个机器码，交给开发者，开发者提供一个注册码。 （2）把用户名交给开发者，开发者提供一个注册码。 （3）直接向开发者索取一个注册码。 在算法上，这几种情况并无太大区别。如果我们有一个原始的码（机器码或用户名），我们把它设为x，那么注册码就是x的一个函数y=f(x)。如果是第三种情况，那么x可能是一个随机数（也可能...
Java——DESUtil加解密工具类
Thancks
10-10 3441
工具类代码如下： package util; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.nio.file.Files; import java.nio.file.Paths; import j
csharp用BouncyCastle进行国密签名&加解密
pridas的博客
10-19 5280
using System; using System.Collections.Generic; using System.Linq; using System.Web; using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Asn1.GM; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Security; u
国密算法（SM2）在C#里面的简单封装_c# sm2，在阿里工作5年了
最新发布
04-16 2257
【代码】国密算法（SM2）在C#里面的简单封装_c# sm2，在阿里工作5年了。
C#笔记整理
12-26
C#笔记整理涵盖了从基础到高级的C#编程概念，是个人学习过程中的重要资料。 一、C#基础 1. 变量与数据类型：C#支持基本数据类型如int、float、double、bool，以及引用类型如string、object等。变量必须先声明后...
C#笔记和练习，C#笔记和练习
03-13
1. **C#笔记.docx** 这份文档可能包含了C#的基础语法和高级特性。C#的基础部分可能涵盖变量、数据类型（如int, string, bool等）、控制流（如if语句、for循环、while循环）、函数、类和对象的创建与使用。高级部分...
C# 笔记本电池状态信息获取代码（VS.net）
08-18
在C#编程中，获取笔记本电池状态信息是一个常见的任务，特别是在开发系统监控或者电源管理相关的应用时。这个任务可以通过调用Windows操作系统提供的Win32 API函数来实现。下面将详细介绍如何利用C#来获取电池状态，...
简单的c#笔记
05-15
### C#基础知识精要 #### 一、C#教程概览 - **适用人群**：适合初学者以及希望深入理解C#语言特性的开发者。 - **预备知识**：熟悉基本的编程概念，如变量、循环等。 - **教程内容**： - **编译与执行C#程序**：...
C#基础笔记
08-20
【C#基础笔记】 C#（读作"C sharp"）是一种面向对象的编程语言，由微软公司开发，主要用于构建Windows应用程序、Web应用以及游戏。它以其简洁、类型安全和性能高效而著称，并且在.NET框架的支持下，C#成为了开发者...
证书生成
weixin_44669878的博客
06-23 1329
证书生成 基于BouncyCastle开源库，可以轻松制作X509证书、CRL、pkcs10、pkcs12，支持国际通用的RSA、ECC算法。制作SM2证书可以通过扩展BouncyCastle库来实现，需加入SM2签名算法DerObjectIdentifier标识1.2.156.10197.1.501(基于SM3的SM2算法签名)，密钥对的...
.net用BouncyCastle进行签名&加解密
pridas的博客
07-17 1万+
.net用BouncyCastle进行签名&加解密
C#实现SM2国密签名签验签和加密解密
qiuhui123456的博客
05-21 1万+
话不多说，上码。 依赖，BouncyCastle.Crypto.dll ，经测试，可与java版本的bcprov-jdk15on-1.62.jar互通。 在这里插入代码片 using Org.BouncyCastle.Crypto.Engines; using Org.BouncyCastle.Crypto.Signers; using System; using System.Text; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyC
ras私钥c#转java_C# Java Ras 密钥转换
weixin_42510053的博客
12-24 317
代码如下：引用using Org.BouncyCastle.Crypto.Generators;using Org.BouncyCastle.Crypto.Parameters;using Org.BouncyCastle.Crypto;using Org.BouncyCastle.Asn1.X509;using Org.BouncyCastle.Asn1.Pkcs;using Org.Bounc...
C#实现RSA公钥加密私钥解密、私钥加密公钥解密以及Pcks12、X509证书加解密、签名验签
热门推荐
sky 胡萝卜星星
01-25 1万+
RSA的私钥签名公钥验签可以见http://blog.csdn.net/starfd/article/details/51917916，所以这里就没提供对应代码，具体代码如下： using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.Pkcs; using Org.BouncyCastle.Asn1.X509; ...
DBHelper(使用参数化+事务查询和执行)
DK18397606232的博客
12-26 1555
using System; using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Data.SqlClient; using System.Linq; using System.Text; using System.Threading.Tasks; namespac...
C#快速入门：从21天学通C#笔记
"21天学通C#读书笔记" 这篇读书笔记主要涵盖了C#编程语言的基础知识，适合有一定编程基础，尤其是Java基础的学习者快速上手。C#是由微软开发的一种面向对象的语言，它在很多方面与Java和C++相似，使得从其他语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值