Entwickler-Ecke

C# - Die Sprache - Wasserpumpe


spitzname - Do 06.05.10 00:00
Titel: Wasserpumpe
Hallo, ich habe folgendes Problem zulösen und komme zur Zeit leider nicht weiter, die beigefügte Skizze soll mit folgenden 4 Klassen realisiert werden, die Klassen können biliebig ergänzt werden.

Das Wasser Läuft aus wenn die Schranke offen ist sonst bleibt das Wasser im Becken.
Der Knopf eins macht die Schranke auf der Knopf 2, oder wieder Knopf 1 wieder zu u.s.w.


C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
 
//class Pumpenbetrieb
class Pumpenbetrieb
    {
        
        static void Main(string[] args)
        {
            

        }
    }ende class Pumpenbetrieb



C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
 
public class Knopf
    {
           
       //standard Konstruktor
        public Knopf() { }

         
        //Den Knopf an die Schranke anschließen
        // wird aus Methode Main aus aufgerufen
        public void SetKnopf(Schranke aktSchranke) {
            
        }

        //Der Knopf wird betätigt, alleine schon der Aufruf der Funktion             
        //bedeutet das der Knopf betätigt wurde
        void pushKnopf()
        {
            
        }
      
    }//ende class Knopf



C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
 
public class Schranke
    {
                
        //Standard-Konstruktor
        public Schranke() { }

        // wird aus Methode Main aus aufgerufen
        public void SetWasser( Wasser aktWasser ) {}

        //Nachrichtenfunktion: Schranke umschalten
        public void HochRunterSchranke( ) {
                          
        }

        // Accessor: Schrankenzustand melden
        public int Status { get { } }

    }// ende class Schranke



C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
 
public class Wasser
    {          
        //eine interne Elementvariable auf "Wasser aus" = 0.
        public Wasser() { }

        //Nachrichtenfunktion: Wasser zu oder aufmachen
        public void Auf_oder_Zu_Wasser( ) {}

        
        //Diese Funktion gibt den Status des Wassers zurück (aus=0, an=1).
        public int Status { get { } }

    }// ende class Wasser



Ich habe mir erstmal überlegt, dass dieses Problem mit Delegates zulösen ist, und so habe ich angefangen, weiss aber nicht genau ob das Sinn macht.

C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
 
 //Delegates
 public delegate void KnopfSchranke(Schranke aktSchranke);
 public delegate void SchrankeWasser(Wasser aktWasser);

//class Pumpenbetrieb
class Pumpenbetrieb
    {
        
        static void Main(string[] args)
        {   

      //die Mhetoden bekannt machen
            Knopf k = new Knopf();
            KnopfSchranke Del_Knopf1;
            Del_Knopf1 = k.SetSchranke;
            
            Schranke s = new Schranke Schranke();
            SchrankeWasser Del_Schranke;
            Del_Schranke= s.SetWasser;

        }
    }ende class Pumpenbetrieb


public class Knopf
    {

        private Schranke _aktSchranke;
        
        //standard Konstruktor
        public Knopf() { _aktSchranke = null;  }

         
        //Den Knopf an die Schranke anschließen
        public void SetKnopf(Schranke aktSchranke) {
            this._aktSchranke = aktSchranke;
        }


        //Der Knopf wird betätigt, alleine schon der Aufruf der Funktion             
        //bedeutet das der Knopf betätigt wurde
        void pushKnopf()
        {
            
        }     

    }//ende class Knopf



public class Schranke
    {
        
    private Wasser aktWasser;
        private int status = Aus();
        

        //Standard-Konstruktor
        public Schranke() { aktWasser = null; status = 0;}

        //Das Relais an die Wasser anschließen
        public void SetWasser( Wasser aktWasser ) { 
          this.aktWasser = aktWasser;
        }

        //Nachrichtenfunktion: Schranke umschalten
        public void HochRunterSchranke( ) {
            if (this.status == Aus())
                this.status = Ein();
              else { this.status = Aus(); }              
        }

        // Accessor: Schrankenzustand melden
        public int Status { get { return this.status; } }
        

        //ein und aus Funktionen
    public static int Ein()
        {
            return 1;
        }

        public static int Aus()
        {
            return 0;
        }

    }// ende class Schranke

public class Wasser
    {   
        int aus;

        //eine interne Elementvariable auf "Wasser aus" = 0.
        public Wasser() { aus=0;}

        //Nachrichtenfunktion: Wasser zu oder aufmachen
        public void Auf_oder_Zu_Wasser( ) {}

        
        //Diese Funktion gibt den Status des Wassers zurück (aus=0, an=1).
        public int Status { get { } }


    }// ende class Wasser



Würde mich über Ideen und Tipps freuen,

gruß spitzname

Moderiert von user profile iconChristian S.: Code- durch C#-Tags ersetzt


spitzname - Do 06.05.10 00:05
danke voraus


danielf - Do 06.05.10 08:17
Delegates? Ich glaub du weißt nicht was das sind. Bitte verwende die korrekten Bezeichnungen. Das ist wichtig, damit wir wissen was du meinst. Außerdem hab ich dir im letzten Posten die Vorgehensweise mit Properties gezeigt - schade dass du dies ignorierst und unnötige und hässliche Setter Methode einbaust.

Zur Problembeschreibung sagst du sehr wenig. Ich kann mir nicht vorstellen, was passiert, wenn Knopf 1 bzw. Schrank1 Offen ist. Ist das Becken dann von jetzt auf nachher leer? Den Zulauf hast du gar nicht beschrieben und wieso müssen es vier Klassen sein?

Die OOP versucht reale Dinge in Klassen abzubilden. Deshalb mach das einfache:

Das Becken besteht aus einem Volumen, Zu- und Abläufe. (Ganz konkret wahrscheinlich noch mehr Dinge wie Inhalt, Farbe, Form, Gewicht... aber das ist soweit mal uninteressant weil auf der Skizze ja auch nicht erkennbar. Dementsprechend ergibt sich folgende Klasse Becken:

C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
 
class Becken 
{
   // Fassungsvolumen-Eigenschaft (kann nicht im Nachhinein verändert werden (wie in Echt ;) --> setter = private )
   public float Volumen { get; private set; }

   // Aktuelle Inhalt ( Kann nur von Becken selber verändert werden )
   public float Inhalt { get; private set; }

   // Liste von Zuläufen (im Nachhinein können neue Zulaeufe dazu kommen oder bestehende entfernt werden)
   public List<Kanal> Zulaeufe { get; set; }

   // Das Gleiche gilt für die Abläufe
   public List<Kanal> Ablaeufe { get; set; }

   // Wie bereits erwähnt muss die Größe des Becken bei dessen Entstehung festgelegt werden, dementsprechend machen wir einen Konstruktor
   public Becken(float volumen)
   {
       // speichern den Wert
       Volumen = volumen;
   }

   // UND HIER MÜSSTE NUN DIE LOGIK KOMMEN (leider bis dato keine beschrieben) 
   // Ich könnte mir hier etwas vorstellen in wie überprüfe jede Sekunde ob die jeweiligen Zu- und Ablaufkanale
   // offen oder zu sind und passe dementsprechend den aktuellen Inhalt an. Zum Beispiel (auf den Timer habe ich vorerst verzichtet):
   private void UpdateInhalt()
   {
      // Reduziere Inhalt
      VerarbeiteKanal(false, Ablaufe);

      // Berechne Zulauf
      VerarbeiteKanal(true, Zulaufe);
   }

   private void VerarbeiteKanaele(bool isZulauf, List<Kanal> kanaele)
   {
      foreach(var kanal in kanaele)
      {
          if (kanal .Offen)
          {
             Inhalt += isZulauf ? kanal .Durchflussmenge : -kanal .Durchflussmenge;
          }
      }
   }
}


Damit wäre das Becken beschrieben ...

Ein Kanal läßt sich daraus auch schon bleiten:

C#-Quelltext 
1:
2:
3:
4:
5:
6:
 
public class Kanal
{
   public bool Offen { get; set; }
   
   public float Durchflussmenge { get; set; }
}



In Kombination Kann das dann so aussehen:

C#-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
 
// Becken für 100 Liter anlegen
Becken becken = new Becken(100f);

// 2 Ablaufkanaele anlegen
becken.Ablaufe.Add(new Kanal{ Durchflussmenge = 5f; });
becken.Ablaufe.Add(new Kanal{ Durchflussmenge = 2f; });

// Zulauf anlegen
becken.Zulaeufe.Add(new Kanal{ Durchflussmenge = 3f; });

// Im weiteren Code dann durch Buttons oder so die Eigenschaften für Kanal Offen/Geschlossen setzen, zum Beispiel durch toggeln:
// Fuer den ersten Ablauf (du kannst dir oben auch seperat die einzelnen Instanzen merken und dann direkt auf diese verweisen)
becken.Ablaeufe[0].Offen = becken.Ablaeufe[0].Offen;


Soviel mal zur Inspiration.

Gruß


spitzname - Do 06.05.10 17:54
Vier Klassen sind aus didaktischen Gründen nötig, da ich die Komunikation zwischen Klassen üben und somit auch verstehen wollte. Danke dir für die viele Ideen :D , ich werde mir auf jeden Fall das eine oder das andere abschauen und versuchen es umzusetzen.


gruß spitzname


Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2025 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!