We Keep Coding

Forcing a derived class to have a constructor with a signature

How do I force all derived classes of an interface to have a constructor with a signature? This doesn't work:
public interface Constructor<T> where T : Constructor<T>, new()
{
Constructor(T);
}
public interface IParameters
{
}
public interface IRule : Constructor<IParameters>
{
//IRule (IParameters); must exist
}

You can't, not via an interface. But you can sort of get at it with an abstract class. Similar to what the accepted answer here describes, try:
public abstract class MustInitialize<T>
{
public MustInitialize(T parameters)
{
}
}
public class Rule : MustInitialize<IParameters>, IRule
{
IParameters _parameters;
public Rule(IParameters parameters)
: base (parameters)
{
_parameters= parameters;
}
}

You can't force a specific constructor signature.
Even with an abstract class as demonstrated in Mark's answer, you can only force the constructor of the abstract class, but nothing is stopping the author of the derived class to do something like this:
public class Rule : MustInitialize<IParameters>, IRule
{
public Rule()
: base (new Parameters())
{
// Assuming Parameters is a class that implements the IParameters interface
}
}
However, you can force dependency injection by using method (setter) injection:
public interface IMethodInjection<T>
{
void Method(T injected);
}

I think you can design your base class like the following example:
public abstract class MyBase
{
private MyBase()
{
}
public MyBase(string a)
{
}
}
public class MyDerived : MyBase
{
public MyDerived(string a) : base(a)
{
}
}
You can even delete the private constructor if its not needed

How to define a generic abstract class that inherits a generic abstract class?

I have a class that inherits an abstract class which inherits another abstract class. I can define the most-super class as being generic just fine, but I don't know how to define the middle class as being generic before I express the actual type I want in the final ListResults class.
internal abstract class LowerCommand<T> {
public abstract void Execute();
public abstract List<T> ExecuteList();
}
// currently gives error for `T`
internal abstract class HigherCommand : Lowercommand<T> {
// ... defines other stuff, nothing to do with
// already instantiated methods or T ...
}
class ListResults : HigherCommand<Results>
{
public override void Execute() {...}
public override List<Results> ExecuteList() {...}
}
Thanks for your help.

You still need to define the generic type parameter T on the definition of HigherCommand so it can in turn properly define LowerCommand.
internal abstract class LowerCommand<T> {
public abstract void Execute();
public abstract List<T> ExecuteList();
}
// Note that HigherCommand require a declaration of `T`
internal abstract class HigherCommand<T> : LowerCommand<T> {
// ... defines other stuff, nothing to do with
// already instantiated methods or T ...
}
class ListResults : HigherCommand<Results>
{
public override void Execute() {...}
public override List<Results> ExecuteList() {...}
}

Can you override one of the abstract methods in a base class with another base class?

I have a base class that has some abstract methods on it and there are 21 classes that are inheriting from this base class. Now for one of those abstract methods I want to implement it with a common implementation for 6 of the 21 classes so I thought about creating another base class that would do this.
I am open to suggestions but my main purpose of creating another base class between the current base class and the 21 classes is to keep from repeating the same code in 6 of the 21 classes if I didn't have to.
Here is a sample of code to illustrate the situation:
public abstract class FooBase
{
public abstract string Bar();
public abstract string SomeMethod();
public virtual string OtherMethod()
{
return this.SomeMethod();
}
}
public abstract class AnotherBase : FooBase
{
public abstract string Bar();
public abstract string SomeMethod();
public override OtherMethod()
{
//this is the common method used by 6 of the classes
return "special string for the 6 classes";
}
}
public class Foo1 : FooBase
{
public override string Bar()
{
//do something specific for the Foo1 class here
return "Foo1 special string";
}
public override string SomeMethod()
{
//do something specific for the Foo1 class here
return "Foo1 special string";
}
}
public class Another2 : AnotherBase
{
public override string Bar()
{
//do something specific for the Another2 class here
return "Another special string";
}
public override string SomeMethod()
{
//do something specific for the Another2 class here
return "Another2 special string";
}
}

Yes, you can derive an abstract class from another abstract class
public abstract class FooBase
{
//Base class content
}
public abstract class AnotherBase : FooBase
{
//it is "optional" to make the definition of the abstract methods of the Parent class in here
}
When we say it is optional to define the abstract methods of the parent class inside of the child class, it is mandatory that the child class should be abstract.
public abstract class FooBase
{
public abstract string Bar();
public abstract string SomeMethod();
public abstract string OtherMethod();
}
public abstract class AnotherBase : FooBase
{
public override string OtherMethod()
{
//common method that you wanted to use for 6 of your classes
return "special string for the 6 classes";
}
}
//child class that inherits FooBase where none of the method is defined
public class Foo1 : FooBase
{
public override string Bar()
{
//definition
}
public override string SomeMethod()
{
//definition
}
public override string OtherMethod()
{
//definition
}
}
//child class that inherits AnotheBase that defines OtherMethod
public class Another2 : AnotherBase
{
public override string Bar()
{
//definition
}
public override string SomeMethod()
{
//definition
}
}
So I'm guessing that there will be 5 more classes like Another2 which inherits from AnotherBase that will have a common definition for OtherMethod

Yes, that is entirely possible and frequently done. There is no rule that says that you can have only one base class at the bottommost level of your class hierarchy; subclasses of that class can just as well be abstract and thereby become (somewhat more specialized) base classes for one group of classes indirectly derived from your general base class.

You should specify what exactly those classes do, but.. given the information you provided:
This is the exact problem that the Strategy pattern aims to solve, as shown in the example given in the Head First Design Patterns book.
You have an abstract Duck class, from which other ducks (e.g., RedheadDuck, MallardDuck) derive. The Duck class has a Quack method, that simply displays the string "quack" on the screen.
Now you are told to add a RubberDuck. This guy doesn't quack! So what do you do? Make Quack abstract and let the subclasses decide how to implement this? No, that'll lead to duplicated code.
Instead, you define an IQuackBehaviour interface with a Quack method. From there, you derive two classes, QuackBehaviour and SqueakBehaviour.
public class SqueakBehaviour: IQuackBehaviour
{
public void Quack(){
Console.WriteLine("squeak");
}
}
public class QuackBehaviour: IQuackBehaviour
{
public void Quack(){
Console.WriteLine("quack");
}
}
Now, you compose your ducks with this behaviour as appropriate:
public class MallardDuck : Duck
{
private IQuackBehaviour quackBehaviour = new QuackBehaviour();
public override void Quack()
{
quackBehaviour.Quack();
}
}
public class RubberDuck : Duck
{
private IQuackBehaviour quackBehaviour = new SqueakBehaviour();
public override void Quack()
{
quackBehaviour.Quack();
}
}
You can even inject an instance of IQuackBehaviour through a property if you want the ducks to change their behaviour at runtime.

Can I omit interface methods in abstract classes in C#?

I'm a Java developer who's trying to move into C#, and I'm trying to find a nice equivalent to some Java code. In Java, I can do this:
public interface MyInterface
{
public void theMethod();
}
public abstract class MyAbstractClass implements MyInterface
{
/* No interface implementation, because it's abstract */
}
public class MyClass extends MyAbstractClass
{
public void theMethod()
{
/* Implement missing interface methods in this class. */
}
}
What would be a C# equivalent to this? The best solutions using abstract/new/override etc all seem to result in 'theMethod' being declared with a body of some form or another in the abstract class. How can I go about removing reference to this method in the abstract class where it doesn't belong, whilst enforcing it's implementation in the concrete class?

You cannot, you would have to do it like this:
public interface MyInterface
{
void theMethod();
}
public abstract class MyAbstractClass : MyInterface
{
public abstract void theMethod();
}
public class MyClass : MyAbstractClass
{
public override void theMethod()
{
/* Implement missing interface methods in this class. */
}
}

No you would have to still have the method signature in the abstract class, but implement it in the derived class.
e.g.
public interface MyInterface
{
void theMethod();
}
public abstract class MyAbstractClass: MyInterface
{
public abstract void theMethod();
}
public class MyClass: MyAbstractClass
{
public override void theMethod()
{
/* implementation */
}
}

How to add member variable to an interface in c#

I know this may be basic but I cannot seem to add a member variable to an interface.
I tried inheriting the interface to an abstract class and add member variable to the abstract class but it still does not work. Here is my code:
public interface IBase {
void AddData();
void DeleteData();
}
public abstract class AbstractBase : IBase {
string ErrorMessage;
public abstract void AddData();
public abstract void DeleteData();
}
public class AClass : AbstractBase {
public override void AddData();
public override void DeleteData();
}
updated base on comment of Robert Fraser

You cannot add fields to an interface.Interface can only contain methods , so only methods , properties , events can be declared inside an interface decleration.In place of field you can use a property.
public interface IBase {
string ErrorMessage {get;set;}
void AddData();
void DeleteData();
}

public interface IBase {
void AddData();
void DeleteData();
}
public abstract class AbstractBase : IBase {
string ErrorMessage;
public abstract void AddData();
public abstract void DeleteData();
}
Workd for me. You were missing the "public" and "void" on the abstract class methods.

Since interfaces only declare non-implementation details, you cannot declare a member variable in an interface.
However, you can define a property on your interface, and implement the property in your class.

If it is something implementing classes need to implement then use a property definition i.e.
That said if it is something which needs to be private then that it not something which should be in an interface anyway.

Did you mean a property instead of a field?
public interface IBase {
string ErrorMessage { get; set; }
void AddData();
void DeleteData();
}
public abstract class AbstractBase : IBase {
abstract string ErrorMessage { get; set; }
// also, you need to declare a return type for the methods
abstract void AddData();
abstract void DeleteData();
}