Iceberg bot

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class Iceberging : Robot
    {
        [Parameter("Order Size", DefaultValue = 10000)]
        public int _OrderSize { get; set; }
        [Parameter("Order Multiplier", DefaultValue = 2)]
        public int _OrderMultiplier { get; set; }
        [Parameter("Order Type", DefaultValue = "Buy")]
        public string _OrderType { get; set; }
        [Parameter("Interval (seconds)", DefaultValue = 1)]
        public int _Interval { get; set; }
        [Parameter("Stop Loss (pips)", DefaultValue = 10)]
        public int _SL { get; set; }
        [Parameter("Take Profits (pips)", DefaultValue = 10)]
        public int _TP { get; set; }
        [Parameter("Close Orders on stop", DefaultValue = true)]
        public bool _CloseOrders { get; set; }

        int _count;
        TradeType _Tradetype;
        string _Label = "label";

        protected string GetLabel(string _TType)
        {
            Random rn = new Random(10);
            int x = rn.Next(100, 10000);
            _Label = _TType + x.ToString();

            var _CLD = History.FindLast(_Label);
            var _CLO = Positions.Find(_Label);
            while (_CLD != null || _CLO != null)
            {
                x++;
                _Label = _TType + x.ToString();
                _CLD = History.FindLast(_Label);
                _CLO = Positions.Find(_Label);
            }
            return _Label;
        }


        protected override void OnTimer()
        {
            _count++;

            if (_count <= _OrderMultiplier)
            {
                TradeResult _order = ExecuteMarketOrder(_Tradetype, Symbol, _OrderSize, _Label, _SL, _TP);
                if (!_order.IsSuccessful)
                {
                    Print("Error number {0}, Bot Will Stop", _order.Error);
                    Stop();
                }
            }

            base.OnTimer();
        }

        protected override void OnStart()
        {
            _Label = GetLabel(Symbol.Code);

            Print("Bot is Starting, the total size of the order is {0}", _OrderSize * _OrderMultiplier);

            if (_OrderType.ToLower() == "buy")
            {
                _Tradetype = TradeType.Buy;
            }
            else if (_OrderType.ToLower() == "sell")
            {
                _Tradetype = TradeType.Sell;
            }
            else
            {
                Print("Error: Please type 'buy' or 'sell'");
                Stop();
            }

            Timer.Start(_Interval);
        }

        protected override void OnStop()
        {
            if (_CloseOrders)
            {
                foreach (var pos in Positions)
                {
                    if (pos.Label == _Label)
                    {
                        TradeResult _OrderClose = ClosePosition(pos);

                        if (!_OrderClose.IsSuccessful)
                        {
                            Print("Warning, error {0} trying to close this position, bot will stop");
                            break;
                        }
                    }
                }

            }
        }
    }
}