Zusammenstellung von C#-Grundkenntnissen: Grundkenntnisse (10) statisch

Wenn Sie auf die Methoden oder Attribute einer bestimmten Klasse zugreifen möchten, müssen Sie zuerst die Klasse instanziieren und dann das Objekt der Klasse plus ein Zeichen verwenden, um darauf zuzugreifen. Beispiel:
Es gibt eine Benutzerklasse und eine Klasse, die Passwörter verarbeitet (Verschlüsselung und Entschlüsselung). Nachdem keine Benutzerinstanz generiert wurde, muss die Passwortklasse das Passwort verschlüsseln und entschlüsseln.

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;
                }
            }
        }
    }
}

Aufruf:

    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();
        }
    }

Ergebnis:

Im von diesen beiden Klassen implementierten Code gibt es sind zwei Fragen.
1. Führen Sie für jeden instanziierten Benutzer

            DES des = new DES();

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

aus, was bedeutet, dass jedes Mal eine DES-Instanz instanziiert werden muss. Das ist nicht gut, wenn DES nur zum Aufrufen seiner Methoden instanziiert wird, aber es ist unpraktisch, es bei jedem Aufruf einer Methode zu instanziieren, und es erhöht auch den Speicherverbrauch.
2. Für

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

werden diese beiden Variablen von jeder Benutzerinstanz verwendet und ändern sich nicht. Allerdings muss bei jeder Instanziierung eines Benutzers Speicherplatz zugewiesen werden, was ebenfalls Speicher verbraucht und im Hinblick auf objektorientiertes Denken nicht sehr sinnvoll ist.

In diesem Fall ist es am besten, die beiden Methoden von DES zu teilen und sie direkt ohne Instanziierung aufzurufen. Zum Beispiel alle Methoden der Mathematik (Math.Abs(1);). Eine andere Möglichkeit besteht darin, die Schlüssel- und Wertvariablen im Benutzer auf öffentlich zu setzen. Sie können auch direkt auf sie zugreifen, und der Speicherplatz wird nur einmal zugewiesen und muss beim Instanziieren des Benutzers nicht separat zugewiesen werden.
Dies erfordert die Verwendung von static, also dem Schlüsselwort static. Die sogenannte Statik bedeutet, dass Mitglieder von einer Klasse gemeinsam genutzt werden. Mit anderen Worten: Als statisch deklarierte Mitglieder gehören nicht zu Objekten einer bestimmten Klasse, sondern zu allen Objekten dieser Klasse. Alle Mitglieder einer Klasse können als statisch deklariert werden und können statische Felder, statische Eigenschaften oder statische Methoden deklarieren. Hier müssen wir jedoch zwischen const und static unterscheiden, was bedeutet, dass der Wert einer Konstante während der Ausführung des Programms nicht geändert werden kann, während sich der Wert von static während der Ausführung ändern kann an anderer Stelle abgerufen werden.
Auf diese Weise kann die Statik wie folgt zur Optimierung des obigen Codes verwendet werden:

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;
                }
            }
        }
    }
}

Laufende Ergebnisse:

Aber es gibt Ein Problem: Allgemeine Methoden können auf statische Eigenschaften oder statische Methoden außerhalb der Methode zugreifen. Wenn Sie jedoch in einer statischen Methode auf Eigenschaften oder Methoden außerhalb der Methode zugreifen möchten, müssen die Eigenschaften und Methoden, auf die zugegriffen wird, ebenfalls statisch sein. Da allgemeine Attribute oder Methoden erst nach der Instanziierung verwendet werden können, während bei statischen Methoden der Speicherplatz direkt während der Kompilierung zugewiesen wird, ist es in statischen Methoden nicht möglich, andere Attribute oder Methoden aufzurufen, sondern nur statische gleichzeitig.

Das Obige ist die Zusammenstellung der Grundkenntnisse von C#: Grundkenntnisse (10) statischer Inhalt Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!