schnittstellen implementieren c#

[taliaa]

Hey ,
ich hab mal ne frage und zwar hab ich:

interface IGemeinde{

string name{get;}
}

interface Ikreisfreigemeinde : IGemeinde
{
}

class Gemeinde : IGemeinde{
private string _name
public string name{get{return _name;}}
}

jetzt hab ich eine unterklasse

class KreisfreieGemeinde : Gemeinde,IKreisfreieGemeinde
{
private string _name;
public string name
{
get { return _name; }
}
public KreisfreieGemeinde(string name)
: base(name)
{
if (string.IsNullOrEmpty(name))
throw new Exception("kein name zugewiesen");
_name = name;
}

public override bool Equals(object obj)
{
KreisfreieGemeinde g = obj as KreisfreieGemeinde;
return g != null && base.Equals(obj)
&& this._name.Equals(g._name);

}

public override int GetHashCode()
{
return base.GetHashCode() ;
}

public override string ToString()
{
return base.ToString() ;
}


}

wenn ich in kreisfremdegemeinde jetzt base aufrufen will, wer wird adressiert ?Gemeinde oder die Ikreisfremdegemeinde?

Wieso muss ich nochmal private und public string name definieren,wird doch von der oberklasse geerbt?

Und wenn ich nur die Schnittstelle implementiere, kann ich den konstruktor über : base(name) nichtmehr aufrufen

über hilfe wäre ich froh!
Ps: über rechtschreibfehler soll hinweggesehen werden ,das sollte nur grob dargestellt werden, Das programm funktioniert atm auch so bekomme nur die warnung:

Warnung 2 'Daten.KreisangehörigeGemeinde.name' blendet den vererbten Member 'Daten.Gemeinde.name' aus. Verwenden Sie das new-Schlüsselwort, wenn das Ausblenden vorgesehen war.

[Mostey]

Mit base würdest du in diesem konkreten Fall die Klasse Gemeinde ansprechen.

Weißt du eigentlich, wann man ein Interface einsetzt und wann es Sinn macht, ein solches zu definieren? Dein Code ist unübersichtlich und ergibt für mich keinen Sinn.

Erkläre bitte mal, was du erreichen willst und was die Klassen repräsentieren.

Properties in einem Interface sind auch nicht unbedingt sauber, wenn sie vermieden werden können.

Sinnvoll wäre in deinem Beispiel wohl eher eine Basisklasse Gemeinde die ein Feld / eine Eigenschaft Name besitzt. Nun kannst du Unterklassen definieren (beispielsweise KreisfreieGemeinde) die von Gemeinde erben. Dementsprechend wird das Feld / die Eigenschaft Name mit übernommen.

Ein Interface setzt man ein, wenn es um eine Funktion geht. Beispielsweise wenn ich die Klassen Auto, Handy und Notebook hätte (mal ganz trivial) würde ich ein Interface IChargable (Funktion void Charge()) definieren, das jede Klasse implementiert und für sich selbst definiert. So könnte ich Instanzen von allen 3 Klassen mit Charge ansprechen, ohne zu wissen um welche Klasse es sich handelt.

IChargable someinterface = new Handy();
someinterface.Charge(); // -> Handy.Charge()

someinterface = new Auto();
someinterface.Charge(); // -> Auto.Charge()

[taliaa]

Danke für die Antwort.
Die interfaces sind vorgegeben und ich muss jedes implementieren. Da würde es für mich am meisten sinn machen wenn ich z.b die Klasse Gemeinde das Interface Igemeinde implementieren lass usw.
Jedoch muss ich auch den Base Konstruktor aufrufen da es so vorgegebn ist:

Schnittstellen können keine Konstruktoren vorgeben. Benutzen Sie daher bitte die folgenden Köpfe für Ihre Konstruktoren:

public Gemeinde(string name)
public KreisangehörigeGemeinde(string name, string landkreis) : base(name)
public KreisfreieGemeinde(string name) : base(name)

Es gibt Klassen Die Gemeinden und übergreifend Orte und ihre straßen(mit länge) beschreiben sollen. Aus einer mdb datei (datenbank) sollen vorhandene Orte/gemeinde gelesen werden und im einem Fenster soll der kürzeste weg zw. zwei orten berechnet werden (grob formuliert).Funktionen kommen ungefähr gar nicht vor aber wie gesagt ich muss interfaces implementieren.
Falls es dir was hilft könnte ich dir meinen Quellcode mal zusenden

mfg

[Mostey]

Alles klar, das ändert natürlich einiges. Wenn du Schnittstellen implementieren musst, würde ich die Eigenschaft Name im Interface definieren:

public interface IGemeinde
{
    string Name { get; set; }
}

und in der Klasse, die IGemeinde implementiert müsstest du diese Eigenschaft eben selbst noch einmal definieren:

public class KreisGemeinde : IGemeinde
{
    public string Name { get; set; }
}

Sieht zwar gleich aus, ist es aber nicht. Im Interface steckt die Deklaration, in der implementierenden Klasse die Definition.

Meiner Meinung nach, ist eine abstrakte Klasse hier vorzuziehen. Wenn du keine Funktionalität hast und nur mit Eigenschaften arbeitest, ist das vernünftig und du sparst dir sogar noch Schreibarbeit, da du in der erbenden Klasse nichts mehr machen musst.

public class Gemeinde
{
    public string Name { get; set; }
    
    public Gemeinde(string name)
    {
        Name = name;
    }
}

public class KreisGemeinde : Gemeinde
{
    public KreisGemeinde(string name)
          : base(name)
    { }
}

Das ist natürlich nur ein Faktor, hinzu kommen noch gewisse andere wie zum Beispiel die Standardimplementation. So etwas gibt es beim Interface nicht.

Mehr dazu: