Sera le constructeur de classe de base est automatiquement appelé?

Oui, le constructeur de classe de base sera appelé automatiquement. Vous n'avez pas besoin d'ajouter un appel explicite à base() quand il y a un constructeur sans arguments.

Vous pouvez facilement tester cela par l'impression de l'âge du client après la construction (lien vers ideone avec une démo).

En c# à l'aide de classes de base et dérivées, IL FAUT CERTAINES IMPLICITE OU EXPLICITE d'un APPEL VERS un CONSTRUCTEUR DANS LA CLASSE de BASE DE LA CLASSE DÉRIVÉE.

Je n'ai pas compris comment tout cela fonctionnait jusqu'à ce que j'ai réalisé que fait.

En d'autres mots, lorsque vous vous connectez à une base de classe à une classe dérivée, certains constructeur doit être appelée dans la classe de base de la dérivée. La classe de base est toujours instancié premier de la classe dérivée par l'intermédiaire d'un appel vers un constructeur dans la classe de base. C# ne se soucie pas si c'est un constructeur par défaut ou de la non-constructeur par défaut avec les paramètres. C'est pourquoi vous pouvez laisser un constructeur par défaut dans toutes vos classes comme son appelé implicitement que SI aucune non-constructeur avec paramètre(s) est ajouté dans la classe de base.

Quand vous avez soudainement ajouter un non-par défaut du constructeur avec paramètre(s), il rompt le défaut caché de constructeur par défaut de la chaîne de création et d'appels. Dans votre classe de Base avec un non-constructeur par défaut, vous devez maintenant d'appeler que constructeur explicitement à partir de la classe dérivée ou ajouter un constructeur par défaut explicitement dans la classe de base.

Nous allons tester cela.....

//THIS WORKS!!!
class MyBaseClass0
{
//no default constructor - created automatically for you
}
class DerivedClass0 : MyBaseClass0
{
//no default constructor - created automatically for you and calls the base class default constructor above
}
//THIS WORKS!!!
class MyBaseClass1
{
//same as above
}
class DerivedClass1 : MyBaseClass1
{
public DerivedClass1()
{
//here the derived class default constructor is created explicitly but the call to the base class default constructor is implicitly called
}
}
//AND THIS WORKS!!!
class MyBaseClass2
{
//as above
}
class DerivedClass2 : MyBaseClass2
{
public DerivedClass2() : base()
{
//here we explicitly call the default constructor in the base class using base(). note its optional as base constructor would be called anyway here
}
}
//AND THIS WORKS!!!
class MyBaseClass3
{
//no default constructor
}
class DerivedClass3 : MyBaseClass3
{
public DerivedClass3(int x)//non-default constructor
{
//as above, the default constructor in the base class is called behind the scenes implicitly here
}
}
//AND THIS WORKS
class MyBaseClass4
{
//non default constructor but missing default constructor
public MyBaseClass4(string y)
{
}
}
class DerivedClass4 : MyBaseClass4
{
//non default constructor but missing default constructor
public DerivedClass4(int x) : base("hello")
{
//note that here, we have fulfilled the requirement that some constructor be called in base even if its not default
}
}
//BUT THIS FAILS!!!...until you either add in a base() call to the non-default constructor or add in the default constructor into base!
class MyBaseClass5
{
//1. EITHER ADD MISSING DEFAULT CONSTRUCTOR HERE AND CALL IT USING base() below....
public MyBaseClass5() { }
//2. Or use the non-default constructor and call to base("hello") below
//public MyBaseClass5(string y)
//{
//}
}
class DerivedClass5 : MyBaseClass5
{
public DerivedClass5(int x) : base()//1. Either ADD explicit call here to explicit default constructor in base class
{
}
//public DerivedClass5(int x) : base("hello")//2. Or ADD explicit call here to parameter-based constructor in base class
//{
//}
}

La raison tous les éléments ci-dessus est soit:
1. L'appel au constructeur par défaut de la classe de base est créé implicitement dans la classe de base et implicitement appelé à partir de la dérivée, car le non-constructeur par défaut a été ajoutée à la classe de base ou
2. Il y a un appel explicite à la non-par défaut , en fonction de paramètre de constructeur à l'aide de la base(myparamter)

• Ce qui est déroutant, c'est quand et pourquoi les constructeurs par défaut créé dans les classes de base et appelé à partir de classes dérivées. Que se produit uniquement si AUCUNE non-constructeurs par défaut apparaît dans la base.

Je n'ai pas grand-chose à ajouter, mais j'ai trouvé que j'ai besoin d'appeler MyConstructor() : base() sans paramètres dans 1 cas. J'ai une classe de base qui implémente INotifyPropertyChanged dans une voie où j'ai un RegisterProperties() une fonction virtuelle. Quand je la remplacer, elle est appelée dans le constructeur de base. Donc je finis par avoir à appeler dans la plus récemment dérivés sous-classes, parce que la base était apparemment appelé avant le substituée virtuel a été reconnu. Mon propriétés ne pas notifier à moins que je le fais. L'ensemble de la classe de base est ci-dessous.

J'ai ajouté un DatabaseTraits sous-classe directement en dessous. Sans la base vide() appel, mes propriétés, ne les appelez pas OnPropertyChanged().

[DataContract]
public abstract class DataModelBase : INotifyPropertyChanged, IDataErrorInfo {
#region Properties
[IgnoreDataMember]
public object Self {
get { return this; }
//only here to trigger change
set { OnPropertyChanged("Self"); }
}
#endregion Properties
#region Members
[IgnoreDataMember]
public Dispatcher Dispatcher { get; set; }
[DataMember]
private Dictionary<object, string> _properties = new Dictionary<object, string>();
#endregion Members
#region Initialization
public DataModelBase() {
if(Application.Current != null) Dispatcher = Application.Current.Dispatcher;
_properties.Clear();
RegisterProperties();
}
#endregion Initialization
#region Abstract Methods
///<summary>
///This method must be defined
///</summar
protected abstract void RegisterProperties();
#endregion Abstract Methods
#region Behavior
protected virtual void OnPropertyChanged(string propertyName) {
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
protected bool RegisterProperty<T>(ref T property, string propertyName) {
//causes problems in design mode
//if (property == null) throw new Exception("DataModelBase.RegisterProperty<T> : ref T property cannot be null.");
if (_properties.ContainsKey(property)) return false;
_properties.Add(property, propertyName);
return true;
}
protected string GetPropertyName<T>(ref T property) {
if (_properties.ContainsKey(property))
return _properties[property];
return string.Empty;
}
protected bool SetProperty<T>(ref T property, T value) {
//if (EqualityComparer<T>.Default.Equals(property, value)) return false;
property = value;
OnPropertyChanged(GetPropertyName(ref property));
OnPropertyChanged("Self");
return true;
}
[OnDeserialized]
public void AfterSerialization(StreamingContext context) {
if (Application.Current != null) Dispatcher = Application.Current.Dispatcher;
//---for some reason this member is not allocated after serialization
if (_properties == null) _properties = new Dictionary<object, string>();
_properties.Clear();
RegisterProperties();
}
#endregion Behavior
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
#endregion INotifyPropertyChanged Members
#region IDataErrorInfo Members
string IDataErrorInfo.Error {
get { throw new NotImplementedException(); }
}
string IDataErrorInfo.this[string propertyName] {
get { throw new NotImplementedException(); }
}
#endregion IDataErrorInfo Members
} //End class DataModelBaseclass DataModelBase
/*I decided to add an example subclass*/
[DataContract]
public abstract class DatabaseTraits : DataModelBase {
#region Properties
private long _id = -1;
[DataMember]
public long Id {
get { return _id; }
set { SetProperty(ref _id, value); }
}
private bool _isLocked = false;
[DataMember]
public bool IsLocked {
get { return _isLocked; }
set { SetProperty(ref _isLocked, value); }
}
private string _lockedBy = string.Empty;
[DataMember]
public string LockedBy {
get { return _lockedBy; }
set { SetProperty(ref _lockedBy, value); }
}
private DateTime _lockDate = new DateTime(0);
[DataMember]
public DateTime LockDate {
get { return _lockDate; }
set { SetProperty(ref _lockDate, value); }
}
private bool _isDeleted = false;
[DataMember]
public bool IsDeleted {
get { return _isDeleted; }
set { SetProperty(ref _isDeleted, value); }
}
#endregion Properties
#region Initialization
public DatabaseTraits() : base() {
/*makes sure my overriden RegisterProperties() is called.*/
}
protected override void RegisterProperties() {
RegisterProperty(ref _id, "Id");
RegisterProperty(ref _isLocked, "IsLocked");
RegisterProperty(ref _lockedBy, "LockedBy");
RegisterProperty(ref _lockDate, "LockDate");
RegisterProperty(ref _isDeleted, "IsDeleted");
}
#endregion Initialization
#region Methods
public void Copy(DatabaseTraits that) {
Id = that.Id;
IsLocked = that.IsLocked;
LockedBy = that.LockedBy;
LockDate = that.LockDate;
IsDeleted = that.IsDeleted;
}
#endregion Methods
}