Zum Inhalt springen

Eigene Klasse in VB.net umschreiben für C#


Eleu

Empfohlene Beiträge

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.

Link zu diesem Kommentar
Auf anderen Seiten teilen

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})";
        }

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

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.

Link zu diesem Kommentar
Auf anderen Seiten teilen

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

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

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

Link zu diesem Kommentar
Auf anderen Seiten teilen

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 von r4phi
Link zu diesem Kommentar
Auf anderen Seiten teilen

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 von Eleu
{calculation.Calculate()} muss noch entfernt werden
Link zu diesem Kommentar
Auf anderen Seiten teilen

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"

Link zu diesem Kommentar
Auf anderen Seiten teilen

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...