Qual è veramente lo scopo della parola chiave "base" in C#?
Domanda
Quindi per la classe di base usata per alcuni metodi riutilizzabili in ogni pagina della mia applicazione ...
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);
}
}
Quindi, se voglio usare questo metodo, lo farei,
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);
}
}
Fa quello che voglio ma c'è una parola chiave "base" che si occupa della classe base in C# ... Voglio davvero sapere quando dovrei usare la parola chiave di base nella mia classe derivata ...
Qualsiasi buon esempio ...
Soluzione
Il base
La parola chiave viene utilizzata per fare riferimento alla classe di base quando si esegue il concatenamento dei costruttori o quando si desidera accedere a un membro (metodo, proprietà, qualsiasi cosa) nella classe base che è stata sovrascritta o nascosta nella classe corrente. Per esempio,
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();
}
}
Con queste definizioni,
new B().Bar();
sarebbe uscito
I'm B
I'm A
Altri suggerimenti
Userai base
Parole chiave quando tu override
una funzionalità, ma desidera ancora che si verifichino anche la funzionalità sovrascritta.
esempio:
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;
}
}
Se hai lo stesso membro in classe ed è Super Class, l'unico modo per chiamare il membro di Super Class - usando base
parola chiave:
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);
}
Il base
La parola chiave viene utilizzata per accedere ai membri della classe base che sono stati sovrascritti (o nascosti) dai membri della sottoclasse.
Per esempio:
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();
}
}
Chiamata Bar.Test
Output quindi:
Foo.Baz;
Bar.Baz;
La base viene utilizzata quando si sostituisce un metodo in una classe derivata, ma si desidera solo aggiungere funzionalità aggiuntive in cima alla funzionalità originale
Per esempio:
// Calling the Area base method:
public override void Foo()
{
base.Foo(); //Executes the code in the base class
RunAdditionalProcess(); //Executes additional code
}
È possibile utilizzare la base per riempire i valori nel costruttore della classe base di un oggetto.
Esempio:
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);
}
}
Il vero scopo della parola chiave "base" in C# è il seguente: Supponiamo di voler chiamare solo il costruttore parametrizzato della classe principale - quindi puoi usare la base e passare i parametri, vedi sotto l'esempio ...
Esempio -
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();
}
}
In generale, stiamo usando la classe base per riutilizzare la proprietà o i metodi nella classe figlio della classe base, quindi non è necessario ripetere la stessa proprietà e metodi nella classe figlio.
Ora usiamo il base Parola chiave per chiamare direttamente un costruttore o un metodo dalla classe base.
Esempio
public override void ParentMethod()
{
base.ParentMethod(); //call the parent method
//Next code.
}
2) Esempio
class child: parent
{
public child() : base(3, 4) //if you have parameterised constructor in base class
{
}
}