C# Gibt es eine Möglichkeit, dass meine Basisklasse und abgeleitete Klasse Interface-Methoden getrennt implementieren können?

Question

Ich weiß, die Frage ist verwirrend, aber es ist schwer, einen guten Titel für dieses Problem zu finden, also werde ich hier mehr beschreiben.

ich eine Schnittstelle A mit 2 Methoden, IsValidRow() und IsFileValid() ich eine Basisklasse B und eine abgeleitete Klasse C Das Ziel hier ist, dass ich die Basisklasse wollen IsFileValid() implementieren, so dass es von allen vererbt werden können die Klassen, die von der Basisklasse und jeder abgeleiteten Klasse abgeleitet sind, um IsValidRow() zu implementieren.

Das Problem ist, dass IsFileValid() ruft IsValidRow() innerhalb. Wenn ich das tue

B:A 

A erfordert IsValidRow() in B. umgesetzt werden

Derzeit meine abgeleiteten Klasse C erbt von der Basisklasse und der Schnittstelle atm.

Es macht mir nichts aus, alles zu restrukturieren, solange die Anforderungen für die beiden Methoden erfüllt sind (Eine wird einmal in einer Basisklasse oder etwas implementiert und übernimmt die andere, während die andere in jeder abgeleiteten Klasse implementiert wird)

interface IFileValidator 
{ 
    Pair<bool, string> IsValidRow(List<string> row); 

    bool IsFileValid(string file); 
} 

class FileValidator : IFileValidator 
{ 
    public bool IsFileValid(string file) 
    { 
     // calls IsValidRow() 
     IsValidRow(); 
    } 
} 

class FacilitiesCalendarValidator : FileValidator, IFileValidator 
{ 

    public Pair<bool, string> IsValidRow(List<string> row) 
    { 
      //stuff 
    } 
} 

Answer 1

Es ist für beide Fälle möglich.

Für optional überschreibbare Methoden deklarieren Sie die Basisklassenmethoden als virtual und override in der untergeordneten Klasse.

Für Methoden, deren Implementierung von einer untergeordneten Klasse bereitgestellt werden muss, markieren Sie die Klasse und die Methode als abstract.

Sie müssen eine virtual-Methode in einer untergeordneten Klasse nicht überschreiben, sodass die Implementierung übernommen wird, es sei denn, Sie entscheiden sich explizit für override.

Zum Beispiel:

interface IInterface 
{ 
    int Transform(int a, int b); 
    int AnotherTransform(int a, int b); 
} 

abstract class A : IInterface 
{ 
    public virtual int Transform(int a, int b) 
    { 
     return a + b; 
    } 

    public abstract int AnotherTransform(int a, int b); 
} 

class B : A 
{ 
    public override int Transform(int a, int b) 
    { 
     return a - b; 
    } 

    public override int AnotherTransform(int a, int b) 
    { 
     return a * b; 
    } 
} 

Answer 2

Sie können die Methode IsValidRow() markieren als abstract:

namespace test 
{ 
    interface A 
    { 
     bool IsFileValue(); 
     bool IsValidRow(); 
    } 

    abstract class B : A 
    { 
     public bool IsFileValue() 
     { 
      return IsValidRow(); 
     } 

     public abstract bool IsValidRow(); 
    } 

    class C : B 
    { 
     public override bool IsValidRow() 
     { 
      return true; 
     } 
    } 
} 

Answer 3

ich eine Lösung für Sie Schnittstelle Segregations Prinzip zu bedienen ist. was bedeutet das, zwei interfaces zu deklarieren. Die erste eine Methode haben, die IsFileValid() und die zweite Schnittstelle implementieren, wobei die erste Schnittstelle ist und eine andere Methode, die IsFileValid() ähnliche

Interface A { void IsFileValid(); } 
    Interface B : A { void IsValidRow();} 

und die Basisklasse Schnittstelle implementieren A und alle abgeleiteten Klassen implementieren die Schnittstelle ist B wie Dies.

public class Base : A 
{ 
     void IsFileValid(){ // immplementaion details} 
} 

public class Child : Base, B 
{ 
     void IsValidRow(){// immplementaion details}  
} 

Glücklich Coding