Compilation des connaissances de base C# : connaissances de base (12) objet super classe-Tutoriel C#.Net-php.cn

Trois fonctionnalités majeures de l'orientation objet : l'encapsulation, l'héritage et le polymorphisme. Alors d’où héritent les classes ? Dans les langages orientés objet, il existe le concept de classe de base ou de super classe, c'est-à-dire que toutes les classes héritent de cette classe. Cette super classe est appelée Objet. La classe Object est décrite dans .net comme ceci :
Prend en charge toutes les classes de la hiérarchie des classes .NET Framework et fournit des services de bas niveau pour les classes dérivées. Il s'agit de la classe de base ultime pour toutes les classes du .NET Framework ; c'est la racine de la hiérarchie des types.
Comme il s'agit d'une super classe, Object définit quelques méthodes clés. Comme suit :

Méthode Equals - utilisée pour comparer si deux instances sont égales.
public virtual bool Equals(Object obj), compare si l'instance actuelle est égale à obj ;
public static bool Equals(Object objA, Object objB), compare si les deux instances spécifiées sont égales.

Méthode Finalize - Permet à un objet de tenter de libérer des ressources et d'effectuer d'autres opérations de nettoyage avant que Garbage Collection ne récupère l'objet.

Méthode GetHashCode - Obtient la valeur de hachage d'un objet.

Méthode GetType - Récupère le type de l'instance actuelle.

Méthode MemberwiseClone - crée une copie superficielle de l'instance actuelle, c'est-à-dire que si l'instance actuelle a une valeur, seule la valeur du type valeur est obtenue dans l'instance nouvellement créée, et le type de référence n'obtient pas la valeur.

Méthode ReferenceEquals - compare deux instances pour voir si elles sont identiques, identiques à la méthode bool statique Equals (Object objA, Object objB).

Méthode ToString - Ceci est couramment utilisé pour renvoyer la chaîne de l'instance actuelle.
Object est une super classe, donc toutes les classes en C# ont ces méthodes.

Ce qui suit se concentre sur les méthodes Equals et ToString.
1. Comparaison d'objets
Il existe des types valeur et des types référence en C#. Une compréhension simple est que les types valeur stockent la valeur des objets, tandis que les types référence sont des références à des instances, similaires aux pointeurs en langage C. Par conséquent, lors de l'utilisation de la comparaison d'objets, le type valeur compare si les valeurs de deux objets sont égales et le type référence compare si la référence spécifiée fait référence au même objet. Bien entendu, les valeurs d'instance pointées par les types référence sont parfois comparées pour voir si elles sont identiques.
Ce qui suit est le code pour la comparaison d'objets :

using System;
using System.Collections.Generic;
using System.Text;

namespace YYS.CSharpStudy.MainConsole.AboutObject
{
    public class Int32Value : ICloneable
    {
        //字段，定义字段最好赋上初值
        private int intValue = 0;

        /// <summary>
        /// 属性
        /// </summary>
        public int IntValue
        {
            get
            {
                return this.intValue;
            }

            set
            {
                this.intValue = value;
            }
        }

        /// <summary>
        /// 定义一个无参构造器
        /// </summary>
        public Int32Value() { }

        /// <summary>
        /// 带参数的构造器
        /// </summary>
        public Int32Value(int value)
        {
            this.intValue = value;
        }

        ///// <summary>
        ///// 实现ICloneable接口
        ///// </summary>
        public object Clone()
        {
            return this.MemberwiseClone();
        }
    }
}

Copier après la connexion

Appel :

using System;
using YYS.CSharpStudy.MainConsole.AboutObject;

namespace YYS.CSharpStudy.MainConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明一个Int32Value类型的引用value1，指向一个实例
            Int32Value value1 = new Int32Value(30);

            //声明value2，指向value1，此时两个引用是指向一个实例的
            Int32Value value2 = value1;

            //使用==比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//相同

            //调用Clone，复制一个value1的副本，赋值给value2
            //此时是两个实例了
            value2 = (Int32Value)value1.Clone();

            //使用==比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//不相同

            //将value1赋给value2，此时他们指向同一个实例
            value2 = value1;

            //使用Equals比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//相同

            //调用Clone，复制一个value1的副本，赋值给value2
            //此时是两个实例了
            value2 = (Int32Value)value1.Clone();

            //使用Equals比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//不相同

            Console.ReadLine();
        }
    }
}

Copier après la connexion

Résultat :

Comme on peut le voir à partir du code :

a. Pour les types référence, l'opérateur = passe la référence d'une variable à une autre, donc les variables des deux côtés de = font référence au même objet ; Pour deux références avec la même variable de référence, utilisez l'opérateur == pour renvoyer true

c. La méthode Clone de l'objet génère une nouvelle instance et renvoie une référence à l'instance. les instances sont identiques à l'objet d'origine, c'est-à-dire que la méthode Clone obtient une copie de l'objet. La méthode de protection MemberwiseClone héritée de la classe Object renvoie une copie de l'objet actuel

d Pour l'objet renvoyé par la méthode Clone, sa référence est différente de l'objet d'origine, et l'opérateur == renvoie false. ;

e. Le résultat de la méthode Equals héritée de Object est le même que l'opérateur == Il compare simplement si la référence actuelle (this) et la référence enregistrée par le paramètre font référence au même objet.

Sur la base du code ci-dessus, réécrivez la méthode Equals.

Appel

using System;
using System.Collections.Generic;
using System.Text;

namespace YYS.CSharpStudy.MainConsole.AboutObject
{
    public class Int32Value : ICloneable
    {
        //字段，定义字段最好赋上初值
        private int intValue = 0;

        /// <summary>
        /// 属性
        /// </summary>
        public int IntValue
        {
            get
            {
                return this.intValue;
            }

            set
            {
                this.intValue = value;
            }
        }

        /// <summary>
        /// 定义一个无参构造器
        /// </summary>
        public Int32Value() { }

        /// <summary>
        /// 带参数的构造器
        /// </summary>
        public Int32Value(int value)
        {
            this.intValue = value;
        }

        ///// <summary>
        ///// 实现ICloneable接口
        ///// </summary>
        public object Clone()
        {
            return this.MemberwiseClone();
        }

        /// <summary>
        /// 覆盖Equals方法
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            bool isEquals = Object.ReferenceEquals(obj, this);

            if (isEquals == false)
            {
                Int32Value value = obj as Int32Value;

                if (value != null)
                {
                    isEquals = value.intValue == this.intValue;
                }
            }
            return isEquals;
        }
    }
}

Copier après la connexion

Résultat :

using System;
using YYS.CSharpStudy.MainConsole.AboutObject;

namespace YYS.CSharpStudy.MainConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明一个Int32Value类型的引用value1，指向一个实例
            Int32Value value1 = new Int32Value(30);

            //声明value2，指向value1，此时两个引用是指向一个实例的
            Int32Value value2 = value1;

            //使用==比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//相同

            //调用Clone，复制一个value1的副本，赋值给value2
            //此时是两个实例了
            value2 = (Int32Value)value1.Clone();

            //使用==比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//不相同

            //将value1赋给value2，此时他们指向同一个实例
            value2 = value1;

            //使用Equals比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//相同

            //调用Clone，复制一个value1的副本，赋值给value2
            //此时是两个实例了
            value2 = (Int32Value)value1.Clone();

            //使用Equals比较
            Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//相同

            Console.ReadLine();
        }
    }
}

Copier après la connexion

Code modifié : couvre la méthode Equals et le résultat de l'exécution du programme est différent : Equals ne compare plus si les références d'objet enregistrées par deux variables sont les mêmes, mais compare si les objets référencés par les deux variables ont les mêmes valeurs de propriété.
Le processus d'exécution de Equals après écrasement est le suivant :
Jetons un coup d'œil au processus d'exécution spécifique de la méthode Equals après écrasement :

A Utilisez la méthode statique Object ReferenceEquals pour comparer le. le paramètre obj et la référence de l'objet actuel (this ) sont les mêmes, si la référence est la même, ce doit être le même objet

b Si la variable obj et la référence actuelle ne sont pas les mêmes, utilisez l'opérateur as ; pour essayer de convertir le type obj en le même type que l'objet actuel. Une conversion réussie signifie obj La variable fait référence au même objet que la classe d'objet actuelle. L'opérateur as convertit la référence de l'objet, sinon il renvoie null Uniquement les objets. du même type doivent être comparés. Les objets de types différents doivent être des objets différents ;

c. Si comme si l'opérateur convertit avec succès l'objet, il comparera en outre si les valeurs de champ de la référence d'objet actuelle (cela ) et l'objet référencé par le paramètre obj sont égaux.
On peut le voir à partir des deux morceaux de code ci-dessus :

== et la méthode Equals de la classe Object comparent toutes deux si les références des objets sont les mêmes, mais ne comparent pas si les champs des objets sont égaux ; et la méthode Equals peut être remplacée, afin de lui permettre d'effectuer une comparaison d'équivalence ou d'autres comparaisons sur les champs de l'objet.
Par conséquent, si vous devez comparer deux variables de type référence C#, vous ne pouvez utiliser que l'opérateur == sauf si vous êtes sûr que ce qui doit être comparé est une référence d'objet. Sinon, vous devez utiliser la méthode Equals de l'objet. pour empêcher la classe à laquelle appartient l'objet de remplacer cette méthode.

上面是引用类型的比较，相对来说，值类型的比较就比较纯粹。值类型是不存在引用的，所以值类型就是比较两个对象值是否相等。当然如果覆盖了Equals方法就除外了。不过一般情况下，我们无需覆盖Equals方法。对于引用类型来说，等值比较就是比较对象的引用，引用不同的两个对象应该就是不同的对象；对于值类型来说，比较的就是所有字段的值，字段值不同的两个对象是不同的对象。只有在特殊情况下，才需要覆盖Equals方法，已定义某个类特殊的对象比较方法。
对于覆盖Equals方法，要注意：
注意：理论上可以用任意代码覆盖Equals方法，但要保证如下原则：
a、Equals只能用于对象比较，不能做其它任何用途；
b、对于两个已存在的对象，在对象未作任何改变的情况下，无论任何时候调用Equals方法，返回的结果应该是一样的；
c、对于对象a和b，则a.Equalse(b)和b.Equals(a)返回的结果应该是一样的；
d、覆盖了Equals方法，同时要覆盖GetHashCode(方法)，这个后面再详细说明。

二、ToString()
代码：

   public class Int32Value : ICloneable
    {
        //字段，定义字段最好赋上初值
        private int intValue = 0;

        /// <summary>
        /// 属性
        /// </summary>
        public int IntValue
        {
            get
            {
                return this.intValue;
            }

            set
            {
                this.intValue = value;
            }
        }

        /// <summary>
        /// 定义一个无参构造器
        /// </summary>
        public Int32Value() { }

        /// <summary>
        /// 带参数的构造器
        /// </summary>
        public Int32Value(int value)
        {
            this.intValue = value;
        }

        ///// <summary>
        ///// 实现ICloneable接口
        ///// </summary>
        public object Clone()
        {
            return this.MemberwiseClone();
        }

     
        /// <summary>
        /// 重写ToString方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return this.intValue.ToString();

            //return "重写ToString";
        }
    }

Copier après la connexion

调用：

     class Program
    {
        static void Main(string[] args)
        {
            Int32Value value = new Int32Value(30);

            Console.WriteLine(value.ToString());//30

            //Console.WriteLine(value.ToString());//重写ToString

            Console.ReadLine();
        }
    }

Copier après la connexion

可以看出，ToString方法可以用任意代码覆盖，只要返回string即可，但是在覆盖时也要返回符合需求的返回值。

以上就是C#基础知识整理：基础知识（12）超类Object 的内容，更多相关内容请关注PHP中文网（www.php.cn）！