web-dev-qa-db-fra.com

Quel est le but du mot clé "base" en c #?

Ainsi pour la classe de base utilisée pour certaines méthodes réutilisables communes dans chaque page de mon application ...

public class BaseClass:System.Web.UI.Page
{
   public string GetRandomPasswordUsingGUID(int length)
   {
      string guidResult = System.Guid.NewGuid().ToString();
      guidResult = guidResult.Replace("-", string.Empty);
      return guidResult.Substring(0, length);
   }
}

Donc, si je veux utiliser cette méthode, je voudrais juste faire,

public partial class forms_age_group : BaseClass
{
      protected void Page_Load(object sender, EventArgs e)
      {
            //i would just call it like this
            string pass = GetRandomPasswordUsingGUID(10);
      }
}

Il fait ce que je veux mais il y a un mot clé "Base" qui traite de la classe de base en c # ... Je veux vraiment savoir quand utiliser un mot clé de base dans ma classe dérivée ....

Tout bon exemple ...

c#keywordbase
42
Chendur Pandian

Le mot clé base est utilisé pour faire référence à la classe de base lorsque vous chaînez des constructeurs ou lorsque vous souhaitez accéder à un membre (méthode, propriété, tout) de la classe de base qui a été remplacé ou masqué dans la classe actuelle. Par exemple,

class A {
    protected virtual void Foo() {
        Console.WriteLine("I'm A");
    }
}

class B : A {
    protected override void Foo() {
        Console.WriteLine("I'm B");
    }

    public void Bar() {
        Foo();
        base.Foo();
    }
}

Avec ces définitions,

new B().Bar();

serait sortie

I'm B
I'm A
61
Matti Virkkunen

Si vous avez le même membre dans la classe et que c'est la classe super, le seul moyen d'appeler un membre depuis la classe super - en utilisant le mot clé base:

protected override void OnRender(EventArgs e)
{
   // do something

   base.OnRender(e);

   // just OnRender(e); will bring a StakOverFlowException
   // because it's equal to this.OnRender(e);
}
6
abatishchev

Vous utiliserez le mot clé base lorsque vous override une fonctionnalité tout en souhaitant que la fonctionnalité remplacée soit également appliquée.

exemple:

 public class Car
 {
     public virtual bool DetectHit() 
     { 
         detect if car bumped
         if bumped then activate airbag 
     }
 }


 public class SmartCar : Car
 {
     public override bool DetectHit()
     {
         bool isHit = base.DetectHit();

         if (isHit) { send sms and gps location to family and rescuer }

         // so the deriver of this smart car 
         // can still get the hit detection information
         return isHit; 
     }
 }


 public sealed class SafeCar : SmartCar
 {
     public override bool DetectHit()
     {
         bool isHit = base.DetectHit();

         if (isHit) { stop the engine }

         return isHit;
     }
 }
6
Michael Buen

Le mot clé base permet d'accéder aux membres de la classe de base qui ont été remplacés (ou masqués) par des membres de la sous-classe.

Par exemple:

public class Foo
{
    public virtual void Baz()
    {
        Console.WriteLine("Foo.Baz");
    }
}

public class Bar : Foo
{
    public override void Baz()
    {
        Console.WriteLine("Bar.Baz");
    }

    public override void Test()
    {
        base.Baz();
        Baz();
    }
}

L'appel de Bar.Test générerait alors:

Foo.Baz;
Bar.Baz;
2
Will Vousden

L’objet réel du mot clé «base» dans c # est le suivant: supposons que vous n’appeliez que le constructeur paramétré de la classe parente; vous pouvez ensuite utiliser base et transmettre les paramètres, voir l’illustration ci-dessous ... 

Exemple -

 class Clsparent
{
    public Clsparent()
    {
        Console.WriteLine("This is Clsparent class constructor");
    }
    public Clsparent(int a, int b)
    {
        Console.WriteLine("a value is=" + a + " , b value is=" + b);
    }
}
class Clschild : Clsparent
{
    public Clschild() : base(3, 4)
    {
        Console.WriteLine("This is Clschild class constructor");
    }
}
class Program
{
    static void Main(string[] args)
    {
        Clschild objclschild = new Clschild();
        Console.Read();
    }
}
0
Ajay Kaushik

Base est utilisé lorsque vous redéfinissez une méthode dans une classe dérivée, mais souhaitez simplement ajouter des fonctionnalités supplémentaires par rapport aux fonctionnalités d'origine.

Par exemple:

  // Calling the Area base method:
  public override void Foo() 
  {
     base.Foo(); //Executes the code in the base class

     RunAdditionalProcess(); //Executes additional code
  }
0
Jasper

Vous pouvez utiliser base pour renseigner des valeurs dans le constructeur de la classe de base d'un objet.

Exemple:

public class Class1
{
    public int ID { get; set; }
    public string Name { get; set; }
    public DateTime Birthday { get; set; }

    public Class1(int id, string name, DateTime birthday)
    {
        ID = id;
        Name = name;
        Birthday = birthday;
    }
}

public class Class2 : Class1
{
    public string Building { get; set; }
    public int SpotNumber { get; set; }
    public Class2(string building, int spotNumber, int id, 
        string name, DateTime birthday) : base(id, name, birthday)
    {
        Building = building;
        SpotNumber = spotNumber;
    }
}

public class Class3
{
    public Class3()
    {
        Class2 c = new Class2("Main", 2, 1090, "Mike Jones", DateTime.Today);
    }
}
0
Jon

Généralement, nous utilisons la classe de base pour réutiliser la propriété ou les méthodes dans la classe enfant de la classe de base. Il n'est donc pas nécessaire de répéter la même propriété et les mêmes méthodes dans la classe enfant.

Nous utilisons maintenant le mot clé base pour appeler directement un constructeur ou une méthode de la classe de base.

Exemple

public override void ParentMethod() 
  {
     base.ParentMethod(); //call the parent method

     //Next code.
  }

2) exemple

class child: parent
{
    public child() : base(3, 4) //if you have parameterised constructor in base class
    {

    }
}
0
Janmejay Kumar