Question

因此，对于我的应用程序的每个页面中的某些常用可重用方法的已使用基类...

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

所以，如果我想使用这种方法，我会这样做，

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

它做我想要的但是有一个“Base”关键字处理c＃中的基类... 我真的想知道什么时候应该在我的派生类中使用base关键字....

任何好的例子......

Answer 1

base关键字用于在链接构造函数时引用基类，或者当您想要访问已在当前类中重写或隐藏的基类中的成员（方法，属性，任何内容）时。例如，

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

有了这些定义，

new B().Bar();

会输出

I'm B
I'm A

Answer 2

当您base使用某个功能时，您将使用override关键字，但仍希望发生重写功能。

示例：

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

Answer 3

如果你在课堂上拥有相同的成员并且它是超类，那么使用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);
}

Answer 4

base关键字用于访问基类中已被子类中的成员覆盖（或隐藏）的成员。

例如：

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

然后调用Bar.Test输出：

Foo.Baz;
Bar.Baz;

Answer 5

在覆盖派生类中的方法但只想在原始功能之上添加其他功能时使用Base

例如：

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

     RunAdditionalProcess(); //Executes additional code
  }

Answer 6

Base有两种使用方式。

具有功能的基础
具有变量的基础。

具有功能的基础

当base与函数一起使用时，其目的是在子类继承父类时使用参数调用父类。我将举例说明。

在以下示例控制台打印中。.

参数为1 这是子构造器

现在，如果您删除了基数（参数），则将打印控制台。.

这是父级构造函数，这是子构造器

从子类实例化对象时，实例化构造函数后立即对其进行调用。当您从子类继承父类时，将同时调用父类和子类中的两个构造函数，因为它们都已实例化。使用base（）时，您可以直接在父类中调用构造函数。因此，如果说base（），则表示父类中的构造函数没有任何参数，使用base（parameter）时，它表示父类中带有参数的构造函数。这是一种函数重载。在base（）括号内使用的参数变量的类型由与base一起使用的函数的参数列表定义（在以下示例中为child（int参数））

using System;

class Parent
{
    public Parent()
    {
        Console.WriteLine("This is Parent Constructor");
    }
    public Parent(int parameter)
    {
        Console.WriteLine("parameter is " + parameter);
    }
}

class Child : Parent
{
    public Child(int parameter): base(parameter)
    {
        Console.WriteLine("This is child constructor");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Child childObject = new Child(1);
    }
}

演示 https://repl.it/@donqq/baseKeyword#main.cs

具有变量的基础。

在下面的示例中，控制台打印。

父母，孩子。

在下面的示例中，如果您使用base关键字，则意味着您要寻址由子类继承的父类。如果使用此方法，则将寻址到类本身，这意味着在实例化子类时将其子类化，从而调用其构造函数。因此，当您使用base.value时，它意味着您引用了父类中的变量，而当您引用this.value时，则意味着您引用了子类中的变量。当两个关键字具有相同的名称时，您可以区分使用此基址和哪个关键字来指代哪个变量。请记住，您不能在函数外部的类中使用base这个关键字。您必须在函数内部使用它们来引用在全局级别初始化的变量。同样，您不能使用它们来引用在函数内部初始化的局部变量。

using System;

class Parent
{
    public string value = "Parent";
}

class Child : Parent
{
    public string value = "Child";

    public Child() {
      Console.WriteLine(base.value);
      Console.WriteLine(this.value);
    }

}

class Program
{
    static void Main(string[] args)
    {
        Child childObject = new Child();
    }
}

演示 https://repl.it/@donqq/Base-Class

Answer 7

您可以使用base来填充对象基类的构造函数中的值。

示例：

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

Answer 8

c＃中“ base”关键字的真实目的如下：假设您只想调用父类的参数化构造函数-那么您可以使用base并传递参数，请参见下面的示例...

示例-

gcloud dataproc clusters create hive-cluster \
    --scopes sql-admin \
    --image-version 1.3 \
    --master-boot-disk-size 15 \
    --num-workers 0 \
    --initialization-actions gs://dataproc-initialization-actions/cloud-sql-proxy/cloud-sql-proxy.sh\
    --properties hive:hive.metastore.warehouse.dir=gs://project-warehouse/datasets \
    --metadata "hive-metastore-instance=$PROJECT:$REGION:hive-metastore"\
    --initialization-action-timeout 30m

Answer 9

通常，我们使用基类重用基类的子类中的属性或方法，因此我们无需在子类中再次重复相同的属性和方法。

现在，我们使用 base 关键字直接从基类中调用构造函数或方法。

示例

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

     //Next code.
  }

2）示例

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

    }
}

c＃中“base”关键字的目的是什么？

9 个答案: