We Keep Coding

How to avoid calling the base class constructor

I'm just after a little advice on how to best organise the inheritance here. I have a class (below) that needs to use most of, and overide some of, the classes in the base ExportData class:
public class ExtendedExportData : ExportData
{
private tData _Data;
private ResStrings _diaStrings;
public ExtendedExportData(tData Data, ResStrings diaStrings)
: base(tData, diaStrings)
{
_tData = Data;
_diaStrings = diaStrings;
}
}
What isn't neccesary in this case is having to call the base constructor as none of the base class methods used in the class above require that initialisation, the constructor is only neccesary when creating an instance of the base class directly for other (verbose) purposes.
If i remove the base constructor i get an error on the sub-class constructor saying the base constructor doesn't take 0 arguments. How can i avoid this?
Here's the base class:
public class ExportData
{
private tData _Data;
private ResStrings _diaStrings;
public ExportLines(tData Data, ResStrings diaStrings)
{
_Data = Data;
_diaStrings = diaStrings;
}
}
Thanks in advance.

A constructor of the base class is always used - but when the base class has no explicitly defined constructor, C# will generate a public parameterless constructor automatically.
Similarly, if you don't explicitly mention : base(...) in your derived class, C# assumes you want to use the parameterless constructor of the base class.
As soon as you define a constructor, the parameterless constructor is not automatically generated anymore, and so you have to call : base(...).
You can easily change this by adding such a constructor to the base class:
public class ExportData
{
protected ExportData()
{
}
}
By making this constructor protected, only classes that inherit from ExportData can use this constructor, and they no longer have to include : base(...).

You can always have a parameterless constructor in the base class that does all the initialising it needs to i.e.:
public ExportData()
{
//Initialising here
}
And then in your example just call base() i.e.
public ExtendedExportData(tData Data, ResStrings diaStrings)
: base()

Couldn't you just create an empty constructor (public ExportData(){}) in ExportData class ?
Else you could do something like here.

I know that this is old question but for future similar problem solution finders I would write something else.
If I undersand this question properly there is more elegant and common solution. Just make your base class abstract. You can still call base constructor during inheritance.
More information can be found here:
Constructor of an abstract class in C#

The error is because the base class always has to be instantiated and your base class doesn't have a default constructor.
If you have functionality in your base class that's not needed in the base class review your inheritance architecture.

Abstract class with constructor, force inherited class to call it

I have an abstract class with constructor XYZ(string name).
Also I have a class that inherits from that abstract class.
How to force inherited class to call base(string name)?
Now I can use new Inherited() and it will not call base constructor. I want to force user to implement default constructor in inherited class.

A class without an explicit constructor has a parameterless constructor. In the other hand, if you implement a constructor with parameters and no paramterless constructor, your class won't be instantiable without arguments.
In other words:
public abstract class A
{
public A(string x)
{
}
}
public class B : A
{
// If you don't add ": base(x)"
// your code won't compile, because A has a
// constructor with parameters!
public B(string x) : base(x)
{
}
}
That is, if A has a parameterless constructor (or no explicit constructor), B will automatically call the base constructor. You don't need to code any further stuff here.
Otherwise, if your base class has a parameterless constructor and a constructor with parameters, you can't force a derived class to automatically call a constructor excepting the default one (i.e. the so-called parameterless constructor).
Workaround
Well, there's no special workaround here, but be aware C# supports optional parameters in both constructors and methods.
If you want to be 100% sure derived classes will call a concrete base constructor, you can implement your base class using a single parameterless constructor with optional parameters and use this instead of constructor overloading:
public class A
{
public A(string x = "hello world") // or just string x = null
{
}
}
Now if a B class derived A, B will always call A's base constructor, since x is optional and it has a default value.

How to force inherited class to call base(string name)
Make parameterless constructor in your abstract class private, or not add it at all. That's will force all derived classes to call the constructor you specified or there will be a compile error.
public abstract class BaseClass
{
protected BaseClass(string parameter)
{
}
}
public class DerivedClass : BaseClass
{
public DerivedClass()
{
}
}
Will end up with
'`Project.BaseClass`' does not contain a constructor that takes 0 arguments

You don't need to do anything. All derived class constructors must call a base class constructor (except for some particularly evil hacks, that you probably don't need to worry about). If none is explicitly specified in code, an implicit call to the base class's parameterless constructor is implied. If the base class has no parameterless constructor (as is the case if you add a constructor accepting a string and don't explicitly add a parameterless constructor), the class will not compile.

I have spent the last half hour or so experimenting once again with permutations of an abstract base class that has its default constructor marked as private and an overload that takes 4 parameters, and a derived class that has only the 4-parameter overload. Using the latest C# compiler (7.3), it is evident that in this situation:
The derived class must explicitly define the 4-parameter overload.
The overload in the derived class call to the 4-parameter overload must be explicit.
Base Class Constructor Signature
public OperatingParameterBase (
string pstrInternalName ,
string pstrDisplayName ,
T penmParameterType ,
U penmDefaultParameterSource )
Derived Class Constructor
internal OperatingParameter (
string pstrInternalName ,
string pstrDisplayName ,
T penmParameterType ,
U penmDefaultParameterSource )
: base (
pstrInternalName ,
pstrDisplayName ,
penmParameterType ,
penmDefaultParameterSource )
{
} // internal OperatingParameterExample constructor
I showed the whole constructor in the derived class to demonstrate that calling the base class constructor is its only absolute requirement. Since the work of the base constructor is irrelevant to this discussion, I left it out.

How can I avoid that the inherited class have to pass the base class constructor parameter

I have a base classe and an inheriting child class.
The base classes constructor accepts a parameter which I do not want to pass from my child constructor.
The parameter is a generic List<MyInterface>
Is that possible with C#?
at the moment my child class constructor looks like this:
public ChildClass() : base (new List<MyInterface>());
Is there a better way without having to new up the List?

If your base class constructor expects a parameter you have to pass that parameter from Child class.
You have two options.
Define a parameterless constructor in base class and then you can avoid passing your parameter. (Based on comment from #aevitas, if you are going to follow that approach, you may define the parameterless constructor as protected, as that will only be available to child classes)
Like:
public class BaseClass
{
public BaseClass() // or protected
{
//does nothing
}
}
and then call it like:
public ChildClass() : base ();
or just
public ChildClass() //Since base() would be called implicitly.
The other option is what you are using now, You can pass a new empty instance of your list or null as per your requirement.
You should also revisit your design. Not having a parameterless constructor in the base class implies that the class object requires that particular parameter to to work. Working around it is a code smell.

You could add a parameter-less constructor on your base class that creates the new List for you? Other than that, no, you have to do that.
You would have two constructors, like this:
public BaseClass(List<MyInterface> newList)
{
//blah blah blah
}
public BaseClass()
{
var myList = new List<MyInterface>();
}

Your base class must either
A) define a parameterless constructor so that you can invoke base()
Or
B) be ok with accepting a null value for the List<MyInterface> param

Like everyone has said you either need a parameterless constuctor in the base class or you need to pass the parameter. If the parameter is not needed at all in the child class then that could be a code smell.
If you only want your child class to have access to a parameterless constructor and no other you could make it protected.
public class BaseClass {
protected BaseClass() : this(new List<MyInterface>()) {
}
public BaseClass(List<MyInterface> newList)
{
//blah blah blah
}
}

Derived class explicit base constructor call

I am trying to learn C#. The below data is from a Microsoft C# help website.
I don't understand this statement, "If a base class does not offer a default constructor, the derived class must make an explicit call to a base constructor by using base."
I thought that if there is no default constructor for a class, C# will automatically assign default values to int, char or whatever is declared in a class. If a base class does not have a constructor and it has a child class, does the rule mentioned in the last sentence not apply? Please clarify.
In a derived class, if a base-class constructor is not called explicitly by using the base keyword, the default constructor, if there is one, is called implicitly. This means that the following constructor declarations are effectively the same:
C#
public Manager(int initialdata)
{
//Add further instructions here.
}
C#
public Manager(int initialdata)
: base()
{
//Add further instructions here.
}
If a base class does not offer a default constructor, the derived class must make an explicit call to a base constructor by using base.

If you do not define a constructor for a class:
public class DemoClass
{
public void SomeFunction() { }
}
C# will add a default (parameterless) constructor for you. In this case; nothing special needs to be done with derived classes, as they will use the provided default constructor. Of course, you can always define your own default (parameterless) constructor:
public class DemoClass
{
public void DemoClass() { }
public void SomeFunction() { }
}
Which still doesn't require anything special for derived classes, since they can still use it. If however, you define a parameterized constructor, without defining a default:
public class DemoClass
{
public void DemoClass(string argument) { }
public void SomeFunction() { }
}
Now there is no default (parameterless) constructor for derived classes to use; and you need to say which constructor to use with base:
public class DerivedClass : DemoClass
{
public DerivedClass() : base(String.Empty) { }
}

What is meaing of "A struct cannot have an initializer in the form: base (argument-list)."

Based on http://msdn.microsoft.com/en-us/library/aa288208%28v=vs.71%29.aspx
Struct constructors are similar to class constructors, except for the following differences:
Structs cannot contain explicit
parameterless constructors. Struct
members are automatically
initialized to their default values.
A struct cannot have an initializer
in the form: base (argument-list).
I have problems to understand Item 2. Can someone give me a concrete example?

Basically, structs do not support inheritance. Although techincally they do inherit from the base class object, item 2 states that you cannot call the base class constructor explicitly.
More info here: http://msdn.microsoft.com/en-us/library/aa288471%28v=vs.71%29.aspx

struct (implicitly) derive immediately from System.ValueType and the only constructor on that abstract class is protected and parameterless. These are facts by the language specification and the statement you are questioning is a consequence of these facts and stated explicitly in the language specification from §11.3.8:
A struct instance constructor is not permitted to include a constructor initializer of the form base(...).
For reference types that derive from classes that have an accessible non-parameterless constructor, you can do the following:
class Base {
private readonly string baseName;
public string BaseName { get { return this.baseName; } }
public Base(string baseName) { this.baseName = baseName; }
}
class Derived : Base {
private readonly string derivedName;
public string DerivedName { get { return this.derivedName; } }
public Derived(string baseName, string derivedName) : base(baseName) {
this.derivedName = derivedName;
}
}
The point is that a Derived is a Base and as such, a constructor for Base needs to be invoked to completely initialize the new instance of Derived (i.e., the parts of Derived that make it a Base need to be initialized). Invoking the base constructor through the syntax base(...) lets you invoke the appropriate constructor.
The statement you are questioning about struct states that it is not permitted to have such an invocation. This is mostly because there can never be such a constructor per the facts stated in the first sentence of this answer.

Here is an example of an initializer in the form: base (argument-list).
public class Foo
{
public Foo(int i) { Debug.WriteLine(i); }
}
public class Bar: Foo
{
public Bar() : base(4) {} // Prints '4' to debug via the base class's constructor.
}
Structs do not support inheritance, so explicitly calling the base class's constructor is not allowed.