# Vererbung von C# Klassen



## Benni (5 November 2011)

Hi Leute, ich bins mal wieder
klappt zur Zeit einfach net so wie ich es mir vorstelle, naja vielleicht könnt Ihr mir ja ein wenig weiterhelfen

Und zwar geht es darum, dass ich vorhabe ein kleine Kartenspiel zu programmieren.
Unter neuer Spiel(neue Form) kann ich dann die Anzahl an Teilnehmern einstellen und auch Wählen ob es sich um einen Mensch oder um einen Computer handeln soll.

D.h. mein Problem nun, dass ich also eine Überklasse (Teilnehmer) haben möchte und zwei abgeleitete Klassen (Computer und Mensch) ich bekomm das mit dem Vererben allerdings in c# irgendwie net hin, hab schon überall gesucht und gegooglet allerdings leider ohne Erfolg, vielleicht könnt ihr mir ja weiter helfen.
Des weiteren möchte ich dann eine Liste aller Teilnehmer haben, in welchem der Name sowie (Computer oder Mensch) drin steht.

Ich hoffe es ist einigermaßen Verständlich angekommen, hauptsächlich geht es mir aber darum dass das mit den Vererbungen klappt. Bekomm es einfach net ohne Fehler hin.
P.S.: Die Klassen sind seperat geschrieben, sprich nicht in einer Form sondern als extra Klassenfile.

Gruß Benni


----------



## Bewareofthis (5 November 2011)

Servus,



> ... ich bekomm das mit dem Vererben allerdings in c# irgendwie net hin, hab  schon überall gesucht und gegooglet allerdings leider ohne Erfolg...



ohne deinen Code zu kennen können wir dir hier nur allgemeine Tipps/Hinweise geben...
Ich versuchs mal:

Namespaces und using:
http://openbook.galileocomputing.de/csharp/kap03.htm#t22
Grundlagen Vererbung in C#:
http://openbook.galileocomputing.de/csharp/kap06.htm

Wenn du ein "extra Klassenfile" verwendest musst Du es deinem Compiler natürlich mitteilen  --> Stichwort _namespace_ bzw. _using_

HTH

Tobi


----------



## Benni (5 November 2011)

Hey, danke, also vom Prinzip her sieht mein Programm folgendermaßen aus, kann es nicht mehr genau sagen, da ich es teilweise schon wieder rausgelöscht habe um andere dinge zu versuchen...

Die Basisklasse sieht folgendermaßen aus:

class Teilnehmer
{
             public class()
             {

             }
}

die beiden anderen Klassen sehen wie folgendermaßen aus:

class Spieler:Teilnehmer
{
          public Spieler():Teilnehmer()
          {

          }
}


class Computer:Teilnehmer
{
          public Computer():Teilnehmer()
          {

          }
}


Bei den Klassen ist es grad egal zumindest bei mir ob ich in den Konstruktoren etwas übergebe oder nicht...
Ich  bekomme immer Fehler... Irgendwie dass die eine Klasse keine Kostruktioren für 0-Argumente enthält oder so was...


----------



## LowLevelMahn (6 November 2011)

*Sorry Benni*

Sorry Benni

aber der Schnippsel ist nichts kompilierbares und auch kein C# (auch kein C++ oder Java ) - und am besten nicht für jede kleine Frage einen neuen Post machen sondern einfach an den alten anhängen

Eine Google-Suche bringt dich da schneller an dein Ziel: http://www.mycsharp.de/wbb2/thread.php?postid=3596266 (weiter unten)
und du solltest dich mit *override* und *virtual* beschäftigen


----------



## Larry Laffer (6 November 2011)

Hallo,
wenn ich es richtig verstanden habe gehst du es falsch rum an.
Ich würde eine Klasse "Spieler" anlegen, die alles beinhaltet, was du als sinnvoll erachtest und dann den "Computer" oder den "Teilnehmer" als neuen "Spieler" anlegen.
Ich würde das jetzt als Code posten bin aber im .Net-Bereich nur unter VB unterwegs. Das ändert aber nichts an der Vorgehensweise sondern nur etwas an der Code-Syntax.

Gruß
Larry


----------



## LowLevelMahn (6 November 2011)

*Gute Idee?*

@Larry Laffer



> wenn ich es richtig verstanden habe gehst du es falsch rum an.



richtig  und falsch gibt es da nicht - die Frage ist nur will er sauberes OOP  probieren - oder einfach nur den Code zum laufen bringen
Was du  beschreibst ist kein "gutes" OOP sondern einfach nur eine alleskönnende  Klasse deren Detailverhalten über Konstruktionsparameter eingestellt  werden kann.

also 


```
class NormalerSpielerOderComputer
{
   enum Typ { NormalerSpieler, Computer }
   public NormalerSpielerOderComputer( Typ  WasWillIchSein );

   public TuWasNoetigIst()
   {
      switch(Typ)
         case NormalerSpieler: ....
         case Computer:...
   }
}
```

funktioniert ist aber realtiv schmutzig - aber wie alles - es funktioniert

Probleme kommen dann auf wenn noch andere Varianten von Teilnehmern dazukommen z.B.

Spieler - normal lokal am Computer
Computer - oder auch NPC
SpielerÜbersNetzwerk 

usw.  da wird dann die kleine Klasse schnell eine Orgie an Code weil die  unterschiedlichen Varianten in einer Klasse vermischt sind
auch die unterschiedlichen Konstruktionsparameter z.B. der Spieler braucht erstmal nichts, der Computerspieler aber eine Spielstäre, der Netzwerkspiele eine Adresses usw.
solche  Variablen und Zustände vermischen sich in der Klasse obwohl ausser der Schnittstelle ins Spiel rein absolut keine Verbindung  zwischen diesen besteht

ich würde eher wie Benni zu einer leichten Basisklasse - wenn nicht sogar zu einem Interface greifen

Aber um die Schnittstelle zu designen muesste erstmal klar sein was den so ein "Teilnehmer" für interaktion mit dem Spiel hat

also z.B. alle Teilnehmer koennen einen Zug ausführen oder sowas - also haette das Interface eine FuehreNaechstenZugAus Methode, was für Informationen braucht der Teilnehmer (seine Schnittstelle) vom dem Spiel
und was für Informationen fliessen vom Teilnehmer wieder an das Spiel zurück - Fragen über Fragen die nur Benni beantworten kann


----------



## Benni (6 November 2011)

Hey, danke an eure aktive anteilnahme.

Also ein Teilnehmer soll eine Karte ausspielen können bzw. nach und nach alle. Sind alle Karten gespielt fängt die nächste Runde an, wobei das ja nicht direkt mit der Klasse Spieler/Teilnehmer zu tun hat. Außerdem ist in jeder Spielrunde die Anzahl an verfügbaren Karten anderst. Dann wird eben wenn ich ein neues Spiel starte ausgewählt ob es menschliche Spieler sind oder ob ein Computer/Programm mitspielt...
D.h. als Spieler brauche ich zum jetzigten Stand nichts anderes können als die überklasse Teilnehmer. Der Computer hingegen muss alles können was ein Teilnehmer kann braucht jedoch noch zusätzliche Methoden um je nach dem eine gute Karte herauszusuchen.
Deshalb dachte ich hier mal an Vererbung um einiges an Code zu ersparen.
Sorry für den oben getippten Code-Schnipsel aber hatte da gerade nicht mein PC zur Verfügung und hatte auch nicht mehr das ursprüngliche Programm da,

aber ich stell mir das so ungefähr vor:


----------



## Benni (6 November 2011)

using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
namespace
WindowsFormsApplication1

{
 
class Teilnehmer
    {
string Name;
int Teilnehmernummer;
List<string> Karten = new List<string>();
//**********************************************************************
 
//Konstruktoren
 
public Teilnehmer(string Name, int Teilnehmernummer)
{
this.Name = Name;
this.Teilnehmernummer = Teilnehmernummer;
}
//**********************************************************************
public string Get_Name()
{
 
return Name;
}
public void gespielte_Karte_löschen(string Karte)
 
//Zum ausspielen der gewünschten Karte
        {
for (int i = 0; i < Karten.Count; i++)
Karten.Remove(Karte);
            }
        }


----------



## Benni (6 November 2011)

//**********************************************************************
 
//Setzen der jeweiligen Karten und Kartenanzahl
 
public void Set_Karten_1(string Karte1)
        {
Karten.Clear();
this.Karten.Add(Karte1);
        }
public void Set_Karten_2(string Karte1, string Karte2)
        {

Karten.Clear();
 
this.Karten.Add(Karte1);
this.Karten.Add(Karte2);
        }

public void Set_Karten_3(string Karte1, string Karte2, string Karte3)
        {
Karten.Clear();
this.Karten.Add(Karte1);
this.Karten.Add(Karte2);
this.Karten.Add(Karte3);
        }


----------



## Benni (6 November 2011)

public void Set_Karten_4(string Karte1, string Karte2, string Karte3, string Karte4)
        {
Karten.Clear();
this.Karten.Add(Karte1);
this.Karten.Add(Karte2);
this.Karten.Add(Karte3);
this.Karten.Add(Karte4);
        }
public void Set_Karten_5(string Karte1, string Karte2, string Karte3, string Karte4, string Karte5)
        {
Karten.Clear();
this.Karten.Add(Karte1);
this.Karten.Add(Karte2);
this.Karten.Add(Karte3);
this.Karten.Add(Karte4);
this.Karten.Add(Karte5);
        }


----------



## Benni (6 November 2011)

Und so weiter ist noch ein paar Zum setzen der Karten bis 8 und noch ein zwei Return für die Karten und so weiter.

und dann kommen eben noch die beiden Klassen Spieler und Computer, wobei ich bei Computer noch keinerlei Code geschrieben habe, hier eben mal der Code für Spieler wobei ich das mit dem übergeben an die Überklasse noch nicht kapiert habe, egal wieviel ich mir gegoogelt habe oder sonst wo nachgelesen, ich bekomm es einfach nicht korekt hin, ich finde auch niergendwo eine gute Beschreibung, in welcher alles genauenst erklärt ist

using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Collections; 

namespace
WindowsFormsApplication1
{
class Spieler:Teilnehmer

    {
public Spieler():base(string Name,int Teilnehmernummer)
        {

        }
    }
}


----------



## Bewareofthis (6 November 2011)

Du machst es uns echt nicht leicht 

am besten ist es wenn du uns noch sagst wie die Fehlermeldung des Compilers lautet und in welcher Zeile...
Ich versuchs nochmal:

```
class Spieler:Teilnehmer
         {
            public Spieler(string Name, int Teilnehmernummer)
                : base(Name, Teilnehmernummer)
            {

             }
          }
```

HTH

Tobi


----------



## Benni (7 November 2011)

Hey Tobi und alle anderen, ich glaube ich habe es gerade eben hinbekommen, zumindest hat er zur Zeit keine Kompilerfehler mehr.

Danke euch allen für Eure Hilfe und Geduld.

Gruß Benni


----------

