Pourquoi utiliser 'virtual' pour les propriétés de classe dans les définitions de modèle Entity Framework ?

Question

Dans le blog suivant : http://weblogs.asp.net/scottgu/archive/2010/07/16/code-first-development-with-entity-framework-4.aspx

Le blog contient l'exemple de code suivant :

public class Dinner
{
   public int DinnerID { get; set; }
   public string Title { get; set; }
   public DateTime EventDate { get; set; }
   public string Address { get; set; }
   public string HostedBy { get; set; }
   public virtual ICollection<RSVP> RSVPs { get; set; }
}

public class RSVP
{
   public int RsvpID { get; set; }
   public int DinnerID { get; set; }
   public string AttendeeEmail { get; set; }
   public virtual Dinner Dinner { get; set; }
}

Quel est le but de l'utilisation de virtual lors de la définition d'une propriété dans une classe ? Quel effet cela a-t-il ?

Answer 1

Le mot-clé virtual est utilisé pour modifier la déclaration d'une méthode, d'une propriété, d'un indexeur ou d'un événement et lui permettre d'être surchargée dans une classe dérivée. Par exemple, cette méthode peut être remplacée par toute classe qui en hérite :

public virtual double Area() 
{
    return x * y;
}

Vous ne pouvez pas utiliser le modificateur virtual avec les modificateurs static, abstract, private ou override. L'exemple suivant montre une propriété virtuelle :

class MyBaseClass
{
    // virtual auto-implemented property. Overrides can only
    // provide specialized behavior if they implement get and set accessors.
    public virtual string Name { get; set; }

    // ordinary virtual property with backing field
    private int num;
    public virtual int Number
    {
        get { return num; }
        set { num = value; }
    }
}

class MyDerivedClass : MyBaseClass
{
    private string name;

    // Override auto-implemented property with ordinary property
    // to provide specialized accessor behavior.
    public override string Name
    {
        get
        {
            return name;
        }
        set
        {
            if (value != String.Empty)
            {
                name = value;
            }
            else
            {
                name = "Unknown";
            }
        }
    }
}

Answer 2

On ne peut pas parler de membres virtuels sans faire référence à polymorphisme . En effet, une fonction, une propriété, un indexeur ou un événement d'une classe de base marqué comme virtuel sera permet la surcharge d'une classe dérivée.

Par défaut, les membres d'une classe sont non virtuels et ne peut pas être marqué comme tel si les modificateurs static, abstract, private, ou override.

Exemple Considérons le ToString() méthode dans System.Object . Comme cette méthode est un membre de System.Object, elle est héritée par toutes les classes et fournira les méthodes ToString() à toutes ces classes.

namespace VirtualMembersArticle
{
    public class Company
    {
        public string Name { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Company company = new Company() { Name = "Microsoft" };
            Console.WriteLine($"{company.ToString()}");
            Console.ReadLine();
        }   
    }
}

La sortie du code précédent est :

VirtualMembersArticle.Company

Considérons que nous voulons changer le comportement standard des méthodes ToString() héritées de System.Object dans notre classe Company. Pour atteindre ce but, il suffit d'utiliser le mot clé override pour déclarer une autre implémentation de cette méthode.

public class Company
{
    ...
    public override string ToString()
    {
        return $"Name: {this.Name}";
    }         
}

Désormais, lorsqu'une méthode virtuelle est invoquée, le run-time vérifie s'il existe un membre prioritaire dans la classe dérivée et l'appelle s'il est présent. Le résultat de notre application sera alors :

Name: Microsoft

En fait, si vous vérifiez la classe System.Object, vous constaterez que la méthode est marquée comme virtuelle.

namespace System
{
    [NullableContextAttribute(2)]
    public class Object
    {
        ....
        public virtual string? ToString();
        ....
    }
}