Compilation des connaissances de base C# : connaissances de base (10) statiques

Si vous souhaitez accéder aux méthodes ou aux attributs d'une certaine classe, vous devez d'abord instancier la classe, puis utiliser l'objet de la classe plus un signe . Par exemple :
Il existe une classe d'utilisateurs et une classe qui gère les mots de passe (cryptage et déchiffrement). Une fois qu'une instance d'utilisateur n'est pas générée, la classe de mot de passe doit chiffrer et déchiffrer le mot de passe.

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace YYS.CSharpStudy.MainConsole.Static
{
    /// <summary>
    /// 用户类
    /// </summary>
    public class User
    {
        //加密解密用到的Key
        private string key = "20120719";
        //加密解密用到的向量
        private string ivalue = "12345678";

        private string userName;

        private string userEncryptPassword;

        private string userDecryptPassword;

        /// <summary>
        /// 用户名
        /// </summary>
        public string UserName
        {
            get
            {
                return userName;
            }
        }
        /// <summary>
        /// 用户密码，加密后的密码
        /// </summary>
        public string UserEncryptPassword
        {
            get
            {
                return userEncryptPassword;
            }
        }
        /// <summary>
        /// 用户密码，解密后的密码
        /// </summary>
        public string UserDecryptPassword
        {
            get
            {
                DES des = new DES();

                this.userDecryptPassword = des.Decrypt(userEncryptPassword, key, ivalue);

                return userDecryptPassword;
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="userPassword"></param>
        public User(string userName, string userPassword)
        {
            this.userName = userName;

            DES des = new DES();

            this.userEncryptPassword = des.Encrypt(userPassword, key, ivalue);
        }
    }

    /// <summary>
    /// 处理密码的类
    /// </summary>
    public class DES
    {
        /// <summary>
        /// 加密字符串
        /// </summary>
        public string Encrypt(string sourceString, string key, string iv)
        {
            try
            {
                byte[] btKey = Encoding.UTF8.GetBytes(key);

                byte[] btIV = Encoding.UTF8.GetBytes(iv);

                DESCryptoServiceProvider des = new DESCryptoServiceProvider();

                using (MemoryStream ms = new MemoryStream())
                {
                    byte[] inData = Encoding.UTF8.GetBytes(sourceString);
                    try
                    {
                        using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(btKey, btIV), CryptoStreamMode.Write))
                        {
                            cs.Write(inData, 0, inData.Length);

                            cs.FlushFinalBlock();
                        }

                        return Convert.ToBase64String(ms.ToArray());
                    }
                    catch
                    {
                        return sourceString;
                    }
                }
            }
            catch { }

            return sourceString;
        }

        /// <summary>
        /// 解密字符串
        /// </summary>
        public string Decrypt(string encryptedString, string key, string iv)
        {
            byte[] btKey = Encoding.UTF8.GetBytes(key);

            byte[] btIV = Encoding.UTF8.GetBytes(iv);

            DESCryptoServiceProvider des = new DESCryptoServiceProvider();

            using (MemoryStream ms = new MemoryStream())
            {
                byte[] inData = Convert.FromBase64String(encryptedString);
                try
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(btKey, btIV), CryptoStreamMode.Write))
                    {
                        cs.Write(inData, 0, inData.Length);

                        cs.FlushFinalBlock();
                    }

                    return Encoding.UTF8.GetString(ms.ToArray());
                }
                catch
                {
                    return encryptedString;
                }
            }
        }
    }
}

Appel :

    class Program
    {
        static void Main(string[] args)
        {
            User user = new User("yangyoushan", "000000");

            Console.WriteLine(string.Format("用户名：{0}", user.UserName));

            Console.WriteLine(string.Format("加密后的密码：{0}", user.UserEncryptPassword));

            Console.WriteLine(string.Format("明文的密码：{0}", user.UserDecryptPassword));

            Console.ReadKey();
        }
    }

Résultat :

Dans le code implémenté par ces deux classes, il y a sont deux questions.
1. Pour chaque utilisateur instancié, exécutez

            DES des = new DES();

            this.userEncryptPassword = des.Encrypt(userPassword, key, ivalue);

ce qui signifie qu'une instance DES doit être instanciée à chaque fois. Ce n'est pas bon. DES est instancié uniquement pour appeler ses méthodes, mais il n'est pas pratique de l'instancier à chaque fois qu'une méthode est appelée, et cela augmente également la consommation de mémoire.
2. Pour

        //加密解密用到的Key
        private string key = "20120719";
        //加密解密用到的向量
        private string ivalue = "12345678";

ces deux variables sont utilisées par chaque instance d'utilisateur et ne changeront pas. Cependant, de l'espace doit être alloué à chaque fois qu'un utilisateur est instancié, ce qui consomme également de la mémoire et n'est pas très raisonnable en termes de pensée orientée objet.

Dans ce cas, il est préférable de partager les deux méthodes de DES et de les appeler directement sans instanciation. Par exemple, toutes les méthodes mathématiques (Math.Abs(1);). Une autre consiste à définir les variables key et ivalue dans User sur publiques, et elles sont également accessibles directement, et l'espace mémoire n'est alloué qu'une seule fois, et il n'est pas nécessaire de l'allouer séparément lors de l'instanciation de l'utilisateur.
Cela nécessite l'utilisation de static, c'est-à-dire le mot-clé static. Ce qu'on appelle statique signifie que les membres sont partagés par une classe. En d’autres termes, les membres déclarés comme statiques n’appartiennent pas aux objets d’une classe spécifique, mais appartiennent à tous les objets de cette classe. Tous les membres d'une classe peuvent être déclarés statiques et peuvent déclarer des champs statiques, des propriétés statiques ou des méthodes statiques. Mais ici, nous devons faire la distinction entre const et static. Const signifie que la valeur d'une constante ne peut pas être modifiée pendant l'exécution du programme, tandis que static peut changer la valeur pendant l'exécution. Si elle est modifiée à un endroit, la valeur modifiée le sera. être consulté à d’autres endroits.
De cette manière, la statique peut être utilisée pour optimiser le code ci-dessus, comme suit :

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace YYS.CSharpStudy.MainConsole.Static
{
    /// <summary>
    /// 用户类
    /// </summary>
    public class User
    {
        //加密解密用到的Key
        private static string key = "20120719";
        //加密解密用到的向量
        private static string ivalue = "12345678";

        private string userName;

        private string userEncryptPassword;

        private string userDecryptPassword;

        /// <summary>
        /// 用户名
        /// </summary>
        public string UserName
        {
            get
            {
                return userName;
            }
        }
        /// <summary>
        /// 用户密码，加密后的密码
        /// </summary>
        public string UserEncryptPassword
        {
            get
            {
                return userEncryptPassword;
            }
        }
        /// <summary>
        /// 用户密码，解密后的密码
        /// </summary>
        public string UserDecryptPassword
        {
            get
            {
                //使用静态方法和静态字段
                this.userDecryptPassword = DES.Decrypt(userEncryptPassword, key, ivalue);

                return userDecryptPassword;
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="userPassword"></param>
        public User(string userName, string userPassword)
        {
            this.userName = userName;

            this.userEncryptPassword = DES.Encrypt(userPassword, key, ivalue);
        }
    }

    /// <summary>
    /// 处理密码的类
    /// </summary>
    public class DES
    {
        /// <summary>
        /// 加密字符串
        /// </summary>
        public static string Encrypt(string sourceString, string key, string iv)
        {
            try
            {
                byte[] btKey = Encoding.UTF8.GetBytes(key);

                byte[] btIV = Encoding.UTF8.GetBytes(iv);

                DESCryptoServiceProvider des = new DESCryptoServiceProvider();

                using (MemoryStream ms = new MemoryStream())
                {
                    byte[] inData = Encoding.UTF8.GetBytes(sourceString);
                    try
                    {
                        using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(btKey, btIV), CryptoStreamMode.Write))
                        {
                            cs.Write(inData, 0, inData.Length);

                            cs.FlushFinalBlock();
                        }

                        return Convert.ToBase64String(ms.ToArray());
                    }
                    catch
                    {
                        return sourceString;
                    }
                }
            }
            catch { }

            return sourceString;
        }

        /// <summary>
        /// 解密字符串
        /// </summary>
        public static string Decrypt(string encryptedString, string key, string iv)
        {
            byte[] btKey = Encoding.UTF8.GetBytes(key);

            byte[] btIV = Encoding.UTF8.GetBytes(iv);

            DESCryptoServiceProvider des = new DESCryptoServiceProvider();

            using (MemoryStream ms = new MemoryStream())
            {
                byte[] inData = Convert.FromBase64String(encryptedString);
                try
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(btKey, btIV), CryptoStreamMode.Write))
                    {
                        cs.Write(inData, 0, inData.Length);

                        cs.FlushFinalBlock();
                    }

                    return Encoding.UTF8.GetString(ms.ToArray());
                }
                catch
                {
                    return encryptedString;
                }
            }
        }
    }
}

Résultats d'exécution :

Mais il y a un problème, les méthodes générales peuvent accéder aux propriétés statiques ou aux méthodes statiques en dehors de la méthode. Mais si vous souhaitez accéder à des propriétés ou des méthodes en dehors de la méthode dans une méthode statique, les propriétés et méthodes auxquelles vous accédez doivent également être statiques. Étant donné que les attributs ou méthodes généraux ne peuvent être utilisés qu'après l'allocation d'espace après l'instanciation, tandis que l'espace mémoire statique est alloué directement lors de la compilation, il n'est donc pas possible d'appeler d'autres attributs ou méthodes dans les méthodes statiques, seuls les attributs statiques peuvent être appelés en même temps. temps.

Ce qui précède est la compilation des connaissances de base de C# : connaissances de base (10) contenu statique. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !