vor 19 Minuten schrieb KeeperOfCoffee:

Mal langsam. 1+2*13+4

wäre ja dann.

double x = new Multiplikation(2, 13).Calculate();

double y = new Addition(new Addition(x, 1).Calculate(), 4).Calculate();

// y = 31

Die Frage ist also genau, wo du deine Multiplikation in der Rechnung haben willst.

Desweiteren solltest du das nicht in das Klick Ereignis des Buttons packen.

Ich denke, du musst es so sehen (1+2)*13+4

Es wird Anweisung für Anweisung verarbeitet.

Zitat

Dass der Text nicht superschön ist, stimmt. Du könntest dir jetzt überlegen, ob du in deinem ICalculation Interface noch eine Methode definierst, die eine "schöne" Ausgabe liefert. Beispielsweise:

public interface ICalculation
{
 double Calculate();
  string GetRepresentation();
}

public abstract class BinaryCalculation : ICalculation
{
 // ... bekannter Kram
  public abstract string GetRepresentation();
}

public class Addition : BinaryCalculation
{
 // ... bekannter Kram
  public string GetRepresentation()
  {
   return $"Addition: ({_firstOperand} + {_secondOperand})"; 
  }
}

//... beim Schreiben:
File.AppendAllText(_file, $"{calculation.GetRepresentation()}, result: {calculation.Calculate()}");

Damit bekämst du dann eine vernünftig lesbare Ausgabe à la "Addition: (5 + 4), result: 9".

 

p.s. Das ganze kann man auch durch überschreiben von ToString erreichen, ich finde das explizit aber manchmal angenehmer.

Hallo alergermi,

es funktioniert soweit. Danke für das Beispiel

Es muss aber noch ein override zwischen public und string.

public override string GetRepresentation()
        {
            return $"Addition: ({_firstOperand} + {_secondOperand})";
        }

 

Allerdings würde ich das so nicht machen, denn das würde wieder gegen das Single-Responsibility-Prinzip verstoßen, weil die Addition-Klasse wieder für zwei Dinge zuständig ist. Die Ausgabe sollte auch in der Nähe der View angesiedelt sein und nicht in der Geschäftslogik. Angenommen, man will die Addition unterschiedlich darstellen. Dann müsste man ja mehrere Methoden in ICalculation und ehe man sich versieht, besitzt das Interface plötzlich 50 Methoden.

Wenn man eine hübsche Ausgabe will, dann könnte man auch die benötigten Informationen zur Verfügung stellen und eine weitere Klasse bastelt aus den Informationen einen String.

vor 3 Minuten schrieb Whiz-zarD:

Wenn man eine hübsche Ausgabe will, dann könnte man auch die benötigten Informationen zur Verfügung stellen und eine weitere Klasse bastelt aus den Informationen einen String.

das oder die ToString() Methode zu überschreiben.

vor 3 Stunden schrieb Whiz-zarD:

Allerdings würde ich das so nicht machen, denn das würde wieder gegen das Single-Responsibility-Prinzip verstoßen, weil die Addition-Klasse wieder für zwei Dinge zuständig ist. Die Ausgabe sollte auch in der Nähe der View angesiedelt sein und nicht in der Geschäftslogik. Angenommen, man will die Addition unterschiedlich darstellen. Dann müsste man ja mehrere Methoden in ICalculation und ehe man sich versieht, besitzt das Interface plötzlich 50 Methoden.

Wenn man eine hübsche Ausgabe will, dann könnte man auch die benötigten Informationen zur Verfügung stellen und eine weitere Klasse bastelt aus den Informationen einen String.

Habe das mal versucht:

Klasse:

 class Ergebnis_String 
    {
        public double Operand { get; set; }
        public double Operand1 { get; set; }
        public double Ergebnis { get; set; }
        string _file = "C:\\C_Sharp\\Test.txt";

        public override string ToString()
        {
         return "Berechnung: " + Operand + " + " + Operand1 + " = " + Ergebnis;
         }
        public void String_in_Datei_schreiben()
        {         
            File.AppendAllText(_file, $"{ToString()}{Environment.NewLine}");
        }
    }

In der Form:

 private void button7_Click(object sender, EventArgs e)
        {
            double Wert1 = 24;
            double Wert2 = 25;
            Ergebnis_String Per = new Ergebnis_String();
            Addition Addi = new Addition(Wert1, Wert2);

            Per.Operand = Wert1;
            Per.Operand1 = Wert2;
            Per.Ergebnis = Addi.Calculate();
            Per.String_in_Datei_schreiben();          
        }

Dann steht in der Datei:

Berechnung: 24 + 25 = 49

 

Ich habe es noch mal wegen dem Single-Responsibility-Prinzip geändert und zwei Klassen daraus gemacht:

 public class In_Datei_schreiben_neu
    {
        private string _file;
        public In_Datei_schreiben_neu(string path)
        {
            _file = path; 
        }
        public void WriteToFile(string w) 
        {
            File.AppendAllText(_file, $"{w}{ Environment.NewLine}");
        }
    }

class Ergebnis_String2
    {
        public double Operand { get; set; }
        public double Operand1 { get; set; }
        public double Ergebnis { get; set; }
       
        public override string ToString()
        {
            return "Berechnung: " + Operand + " + " + Operand1 + " = " + Ergebnis;
        }
    }

In der Form:

 private void button8_Click(object sender, EventArgs e)
        {
            double Wert1 = 24;
            double Wert2 = 25;
            Ergebnis_String2 Per = new Ergebnis_String2();
            Addition Addi = new Addition(Wert1, Wert2);
            In_Datei_schreiben_neu SP = new In_Datei_schreiben_neu("C:\\C_Sharp\\Test4.txt");
            Per.Operand = Wert1;
            Per.Operand1 = Wert2;
            Per.Ergebnis = Addi.Calculate();
            SP.WriteToFile(Per.ToString());
        }

Schönes W.E.

 

Gruß

Eleu

Du kannst deine BinaryCalculation Klasse auch wie folgt umbauen:

  public abstract class BinaryCalculation : ICalculation
        {
            protected double _firstOperand;
            protected double _secondOperand;
            public BinaryCalculation(double a, double b)
            {
                _firstOperand = a;
                _secondOperand = b;
            }

            public abstract double Calculate();

            public override string ToString()
            {
                return $"Berechnung {_firstOperand} + {_secondOperand} = {Calculate()}";
            }
        }

Was mMn. nicht gegen das Single-Responsibility-Prinzips verstößt, da jedes Objekt in C# von Object abgeleitet ist und dadurch von Haus aus über ToString() die String Representation der Klasse liefert.

https://msdn.microsoft.com/de-de/library/system.object(v=vs.110).aspx

Bearbeitet 16. März 20187 j von r4phi

vor 2 Stunden schrieb r4phi:

Was mMn. nicht gegen das Single-Responsibility-Prinzips verstößt, da jedes Objekt in C# von Object abgeleitet ist und dadurch von Haus aus über ToString() die String Representation der Klasse liefert.

https://msdn.microsoft.com/de-de/library/system.object(v=vs.110).aspx

Ich habe es ausprobiert und es funktioniert.

In der Klasse ResultWrite, bei der Methode WriteResulttoFile muss dann folgendes stehen:

public void WriteResultToFile(ICalculation calculation)
        {
            File.AppendAllText(_file, $"{calculation.ToString()}{Environment.NewLine}");
        }

 

Bearbeitet 16. März 20187 j von Eleu
{calculation.Calculate()} muss noch entfernt werden

vor 4 Stunden schrieb r4phi:

Du kannst deine BinaryCalculation Klasse auch wie folgt umbauen

Was mMn. nicht gegen das Single-Responsibility-Prinzips verstößt, da jedes Objekt in C# von Object abgeleitet ist und dadurch von Haus aus über ToString() die String Representation der Klasse liefert.

https://msdn.microsoft.com/de-de/library/system.object(v=vs.110).aspx

Man kann halt auch mehrere Methoden, aus einer Klasse weiter vererben.

Habe das mal ohne BinaryCalculation mit dem Interface ICalculation der Klasse Addition und der Klasse ResultWriter gemacht:

 public class Addition : ICalculation
    {
        private double left;
        private double right;
        public Addition(double left, double right)
        {
            this.left = left;
            this.right = right;
        }
        public double Calculate()
        {
            return (this.left + this.right);
        }
        
        //Eine weitere Methode die vererbt werden soll
        string x = "Hallo Welt";
        public string WasMachen()
        {
            return x;
        }

    }

 

 public class ResultWriter
    {
        virtual public void SendToFile(ICalculation calculation)
        {
            using (System.IO.StreamWriter sw = new System.IO.StreamWriter("C:\\VB_net\\Test.txt", true))
            {    
				sw.WriteLine(calculation.Calculate());
                File.AppendAllText("C:\\VB_net\\Test2.txt", $"{calculation.WasMachen()}{Environment.NewLine}");
            }
        }
    }

Aber das geht dann nur, wenn man die neue Methode über das Interface ICalculation durchreicht.

public interface ICalculation
    {
        double Calculate();
        string WasMachen();
    }

In der Datei Test.txt steht das Ergebnis der Berechnung und in der Datei Test2.txt steht dann "Hallo Welt"