Hello my question is can someone help me with this code there are still errors in it
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;
using System;
[Robot("MyRobot", Description = "Ein einfacher Handelsroboter", Group = "Beispiel")]
public class MyRobot : Robot
{
[Parameter("Fast MA Period", DefaultValue = 10)]
public int FastMaPeriod { get; set; }
[Parameter("Slow MA Period", DefaultValue = 20)]
public int SlowMaPeriod { get; set; }

[Parameter("Risk per Trade (%)", DefaultValue = 1)]
public double RiskPercentage { get; set; }

[Parameter("Stop Loss (Pips)", DefaultValue = 20)]
public int StopLossPips { get; set; }

[Parameter("Take Profit (Pips)", DefaultValue = 40)]
public int TakeProfitPips { get; set; }

[Parameter("Enable Trailing Stop", DefaultValue = false)]
public bool EnableTrailingStop { get; set; }

private MovingAverage fastMa;
private MovingAverage slowMa;

protected override void OnStart()
{
    Print("Bot gestartet");
    // Initialisiere die Indikatoren
    fastMa = Indicators.MovingAverage(Bars.ClosePrices, FastMaPeriod, MovingAverageType.Simple);
    slowMa = Indicators.MovingAverage(Bars.ClosePrices, SlowMaPeriod, MovingAverageType.Simple);
}

protected override void OnTick()
{
    // Überprüfe, ob genügend Daten vorhanden sind
    if (Bars.ClosePrices.Count < Math.Max(FastMaPeriod, SlowMaPeriod))
        return;

    // Prüfe auf Kauf- oder Verkaufssignale
    if (fastMa.Result.Last(1) > slowMa.Result.Last(1) && fastMa.Result.Last(2) <= slowMa.Result.Last(2))
    {
        ExecuteTrade(TradeType.Buy);
    }
    else if (fastMa.Result.Last(1) < slowMa.Result.Last(1) && fastMa.Result.Last(2) >= slowMa.Result.Last(2))
    {
        ExecuteTrade(TradeType.Sell);
    }

    // Überprüfe Trailing Stop
    if (EnableTrailingStop)
    {
        ManageTrailingStop();
    }
}

private void ExecuteTrade(TradeType tradeType)
{
    double lotSize = CalculateLotSize();

    // Überprüfe, ob die Lotgröße kleiner als das Mindestvolumen ist
    if (lotSize < Symbol.VolumeInUnitsMin)
    {
        Print("Lotgröße kleiner als Mindestvolumen.");
        return;
    }

    var result = ExecuteMarketOrder(tradeType, SymbolName, lotSize);

    // Überprüfe das Ergebnis der Auftragsausführung
    if (!result.IsSuccessful)
    {
        Print($"Fehler beim Ausführen des Auftrags: {result.Error}");
        return;
    }

    // Setze Take-Profit und Stop-Loss nach erfolgreicher Ausführung
    var position = result.Position;

     // Fehlerbehandlung bei ModifyPosition hinzufügen
     var modifyResult = ModifyPosition(position,
         tradeType == TradeType.Buy ? position.EntryPrice - StopLossPips * Symbol.PipSize : position.EntryPrice + StopLossPips * Symbol.PipSize,
         tradeType == TradeType.Buy ? position.EntryPrice + TakeProfitPips * Symbol.PipSize : position.EntryPrice - TakeProfitPips * Symbol.PipSize);

     if (!modifyResult.IsSuccessful)
     {
         Print($"Fehler beim Setzen von SL/TP: {modifyResult.Error}");
     }
     else
     {
         Print($"Handel ausgeführt: {tradeType}, Lotgröße: {lotSize}, TP: {TakeProfitPips} Pips, SL: {StopLossPips} Pips");
     }
 }

 private double CalculateLotSize()
 {
     double accountRisk = Account.Balance * (RiskPercentage / 100);
     // Berechne die Lotgröße basierend auf dem Risiko und den Stop-Loss-Pips
     return accountRisk / (Symbol.PipValue * StopLossPips);
 }

 private void ManageTrailingStop()
 {
     foreach (var position in Positions.FindAll(SymbolName))
     {
         double newStopLossPrice;

         if (position.TradeType == TradeType.Buy)
         {
             newStopLossPrice = Bars.HighPrices.Last(1) - StopLossPips * Symbol.PipSize;

             if ((newStopLossPrice > position.StopLoss.GetValueOrDefault()) || !position.StopLoss.HasValue)
             {
                 var modifyResult = ModifyPosition(position,
                     newStopLossPrice,
                     position.TakeProfit);

                 if (!modifyResult.IsSuccessful)
                 {
                     Print($"Fehler beim Aktualisieren des Trailing Stops für Kaufposition: {modifyResult.Error}");
                 }
                 else
                 {
                     Print($"Trailing Stop für Kaufposition aktualisiert auf: {newStopLossPrice}");
                 }
             }
         }
         else if (position.TradeType == TradeType.Sell)
         {
             newStopLossPrice = Bars.LowPrices.Last(1) + StopLossPips * Symbol.PipSize;

             if ((newStopLossPrice < position.StopLoss.GetValueOrDefault()) || !position.StopLoss.HasValue)
             {
                 var modifyResult = ModifyPosition(position,
                     newStopLossPrice,
                     position.TakeProfit);

                 if (!modifyResult.IsSuccessful)
                 {
                     Print($"Fehler beim Aktualisieren des Trailing Stops für Verkaufsposition: {modifyResult.Error}");
                 }
                 else
                 {
                     Print($"Trailing Stop für Verkaufsposition aktualisiert auf: {newStopLossPrice}");
                 }
             }
         }
     }
 }

 protected override void OnStop()
 {
     Print("Bot gestoppt");
 }
}