Quel est vraiment le but de “base” clé en c#?

Donc pour servir de classe de base pour certains commum réutilisables méthodes 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);
      }
}

C'est ce que je veux, mais il y a une "Base" mot-clé qui traite de la classe de base en c# ...
Je veux vraiment savoir quand doit-utilisation de la base de mot-clé dans ma classe dérivée....

Tout bon exemple...

InformationsquelleAutor ACP | 2010-04-15

base c#keyword

62

La base mot-clé est utilisé pour faire référence à la classe de base lorsque le chaînage des constructeurs ou lorsque vous souhaitez accéder à un membre (une méthode, une propriété, n'importe quoi) dans la classe de base qui a été substituée ou cachés dans la classe en cours. 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 de
```
I'm B
I'm A
```
- Il n'est pas limité à des fonctions. Partout où il y a de l'ambiguïté dans les classes (parents et enfants), de la base de mots clés précise de la méthode/de membre des données de l'utilisateur est en train de parler.
- Bon point. Révisé-à-dire membre à la place.
- Serait A.Foo() faire la même chose que base.Foo()?
- Non, A. Foo() est une méthode statique de l'appel. Depuis A. Foo() n'est pas statique, vous recevrez un message d'erreur si vous n'avez ce.
InformationsquelleAutor Matti Virkkunen

Vous allez utiliser base mot-clé lorsque vous override une fonctionnalité, mais veulent toujours le substituée la fonctionnalité se produisent également.

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

+1 si(isHit) {supprimer le i et il prend une toute autre signification} 😉
qui pourrait être la raison principale pourquoi le langage C# concepteurs ne peuvent mettre en place VB.NET's IsNot mot-clé du langage C#. Il aura une apparence de crotte de nez 😀 heheh

InformationsquelleAutor Michael Buen

Si vous avez le même membre dans la classe et c'est super classe, le seul moyen d'appeler des membres de la classe super - aide base mot-clé:

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

InformationsquelleAutor abatishchev

La base mot-clé est utilisé pour accéder aux membres de la classe de base qui ont été remplacé (ou caché) par les 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();
    }
}

Appel Bar.Test serait alors de sortie:

Foo.Baz;
Bar.Baz;

InformationsquelleAutor Will Vousden

1

De Base est utilisé lorsque vous remplacez une méthode dans une classe dérivée, mais veulent juste ajouter des fonctionnalités supplémentaires en plus de la fonctionnalité 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
  }
```
InformationsquelleAutor Jasper

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

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

InformationsquelleAutor Jon

Le but réel de la “base” de mots clés de c# est comme suit: supposons que vous voulez l'appeler seulement le parent de la classe de constructeur paramétré - ensuite, vous pouvez utiliser la base et de passer les paramètres, veuillez consulter ci-dessous l'exemple...

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

InformationsquelleAutor Ajay Kaushik

0

Généralement, nous utilisons la classe de base de la réutilisation de la propriété ou de méthodes dans la classe fille de la classe de base, nous avons donc pas besoin de répéter la même propriété et des méthodes de nouveau dans la classe enfant.

Maintenant, nous utilisons le base mot-clé pour appeler un constructeur ou une méthode de classe de base directement.

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
    {

    }
}
```
InformationsquelleAutor Janmejay Kumar

Vous devez vous connecter pour publier un commentaire.