C #: multiple inheritance with non-abstract computable properties

Question

I am creating a series of interfaces / abstract classes that contain basic properties, and I would like to compute properties and multiple inheritance.

public abstract class /interface Modifiable
{
   public DateTime ModifiedDate {get; set;}

   public boo ModifiedToday
   {
     get { return DateTime.Now.AddDays(-1).CompareTo(ModifiedDate) >= 0; }
   } 

   public bool ModifiedInLastWeek
   {
     get { return DateTime.Now.AddDays(-7).CompareTo(ModifiedDate) >= 0; }
   }
}

public abstract class /interface Deletable
{
   public DateTime DeletionDate {get; set;}    

   public bool Deleted
   {
     get { return DeletionDate != default(DateTime) }
   }
}

Then I have a class that inherits from these two interfaces / abstract classes.

public class Something : Modifiable, Deletable 
{
  //
}

But a class cannot inherit from two abstract classes. Therefore, I then need to use interfaces, but with interfaces I cannot have method bodies. Then I have to define the exact same functions for several classes to implement these simple bool properties using interfaces.

, Deletable, , - , Deletable. , .

, , , , ?

Answer 1

. # .

, , , , .

, , , , .

Answer 2

, , , - .

public interface IModifiable
{
    DateTime ModifiedDate {get; set;}
}

public static class ModifiableExtensions
{
   public bool ModifiedToday(this IModifiable m)
   {
      return DateTime.Now.AddDays(-1).CompareTo(m.ModifiedDate) >= 0;
   } 

   public bool ModifiedInLastWeek(this IModifiable m)
   {
     return DateTime.Now.AddDays(-7).CompareTo(m.ModifiedDate) >= 0; 
   }

}

"" , , , -, . :

public class MyModifiable :IModifiable
{
     public ModifiedDate {get; set;}
}

:

MyModifiable m = new MyModifiable;

m.ModifiedDate = DateTime.Now;

bool isToday = m.ModifiedToday();

Answer 3

, , , . :

• Deletable, Modifiable .. ( ), . , , .
• , , . , ,
• -
• , Castle , , .

, . .NET, ++.NET Eiffel.NET.

Answer 4

, , / , :

interface IDrivable {
  void Drive();
}

interface IFlyable {
  void Fly();
}

class Car : IDrivable {
  public void Drive() { /* Implementation */ }
}

class Plane : IFlyable {
  public void Fly() { /* Implementation */ }
}

class MyClass : IDrivable, IFlyable {
  private IDrivable _car = new Car();
  private IFlyable _plane = new Plane();

  public void Drive() { _car.Drive(); }
  public void Fly() { _plane.Fly(); }
}

Answer 5

, # . :

• a la MyClass: MyBaseClass: EvenBasierClass
• . .

, , .

Answer 6

, . , , .

Regarding code implementation, you can always use extension methods:

public interface IModifiable
{
   public DateTime ModifiedDate {get; set;}
}

public interface IDeletable
{
   public DateTime DeletionDate {get; set;}    
}


public static class SomeExtentions
{
    public static bool IsModifiedToday(this IModifiable modifiable)
    {
        return DateTime.Now.AddDays(-1).CompareTo(modifiable.ModifiedDate) >= 0;
    } 

    public static bool IsModifiedInLastWeek(this IModifiable modifiable)
    {
        return DateTime.Now.AddDays(-7).CompareTo(modifiable.ModifiedDate) >= 0;
    }   
    public static bool IsDeleted(this IDeletable deletable)
    {
        return deletable.DeletionDate != default(DateTime);
    }
}

Answer 7

I would probably use a delegation to achieve this. Create Modifyable and Deletable as interfaces, then create their implementation. Give class instances Somethingfor these implementations. Here is an example for Deletable:

public interface Deletable
{
  DateTime DeletionDate{get;set;}
  bool Deleted{get;}
}

public class DeletableImpl : Deletable
{
  public DateTime DeletionDate{get; set;}
  public bool Deleted{get {return DeletionDate != default(DateTime);}}
}
// Do the same thing with Modifiable and ModifiableImpl

public class Something : Deletable, Modifiable
{
  private Deletable _deletable = new DeletableImpl();
  private Modifiable _modifiable = new ModifiableImpl();
  public DateTime DeletionDate
  {
    get{return _deletable.DeletionDate;}
    set{_deletable.DeletionDate = value;}
  }
  public bool Deleted{get{return _deletable.Deleted;}}
  public DateTime ModifiedDate {
    // and so on as above
}