Errori, bug, domande - pagina 2450
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Tuttavia, dice esattamente la stessa cosa sull'inciampo nelle macro. Comunque, lo controlleremo, naturalmente.
Lo sviluppo di questo progetto ha ancora un enorme potenziale, soprattutto in termini di miglioramento del linguaggio usando le proprie risorse, perché molte cose in MQL non sono ancora state implementate e molte cose funzionano male (bug) e gli sviluppatori, da quanto ho capito, non hanno intenzione di migliorare nulla nel linguaggio stesso.
Per elaborare le macro devo implementare uno strato aggiuntivo da qualche parte vicino all'inizio dell'intera catena - descrivere la grammatica delle macro, analizzarle nel sorgente einterpretarle (ottenere il risultato sorgente/valore per ogni macro). Questo è complicato, e l'applicazione è necessaria solo per alcuni programmatori MQL, quindi non c'è sviluppo.
Per quanto riguarda l'uso dell'hash per identificare i cambiamenti nei prodotti, non credo che questa sia una soluzione (o non ho idea di quale caso d'uso stiamo parlando). Di solito avete bisogno di un anno o due dopo la generazione di qualche ex-file per capire quale versione era un particolare modulo in esso e la sua fonte. Per fare questo probabilmente avete bisogno di collegare il processo di compilazione con i sistemi di controllo delle versioni. L'hashing non è un'opzione.
Aiutatemi con OnTradeTransaction(). Il comportamento descritto qui sotto è normale? Ho controllato nel tester - è così :( E su un account "live"?
OnTick() ha un ciclo che chiude le posizioni in ordine.
OnTradeTrancaction() calcola il numero di posizioni aperte.
L'Expert Advisor lo fa in questo modo: prima chiude il ciclo fino alla fine, poi va a OnTradeTransaction ed esegue i calcoli nello stesso ordine.
In altre parole, non
а
cioè funziona in modo sequenziale invece che in parallelo.
Se quanto descritto sopra è normale, risulta che OnTradeTransaction() può essere usato in modo sicuro solo in Expert Advisors che aprono/chiudono un solo ordine. Se c'è una griglia o una griglia a più simboli (o una griglia a più simboli, che è dove si trova :) ) - l'algoritmo si rompe.
Citazione dalla documentazione
Una richiesta di compravendita inviata manualmente dal terminale o tramite le funzioni OrderSend()/OrderSendAsync() può generare diverse transazioni commerciali consecutive sul server commerciale. Inoltre, l'ordine di arrivo di queste transazioni al terminale non è garantito, quindi non possiamo costruire il nostro algoritmo di trading aspettando l'arrivo di una transazione commerciale dopo l'altra.
Di conseguenza, tutto sarà calcolato, ma non nella sequenza prevista.
Potete spiegare perché avete deciso di contare il numero di posizioni in OnTradeTrancaction()? Se il calcolo non è organizzato correttamente, non si può escludere che ci siano operazioni inutili. Dopo tutto, se chiudete diverse posizioni nel ciclo, non c'è bisogno di ricalcolarle tutte dopo aver chiuso ogni posizione. È sufficiente contarli una volta dopo che il ciclo è finito. Oppure, disporre in OnTradeTrancaction() in modo tale che la quantità aumenti di 1 quando il tipo IN è impostato, e diminuisca quando il tipo OUT è impostato. E anche in questo caso, se la posizione non è chiusa completamente, bisogna tenerne conto.
Potete spiegare perché avete deciso di contare il numero di posizioni in OnTradeTrancaction()?
Se si conta su ogni tick - è ad alta intensità di risorse, particolarmente evidente nel tester di strategia. Non sarebbe più corretto contare solo all'evento Trade, cioè quando qualcosa nella lista delle posizioni aperte cambia effettivamente? Con OnTradeTransaction(), è più facile controllare l'intervento dell'utente nell'EA. (Ci sono alcuni precedenti :)
In questo robot stavo testando la possibilità di chiudere la griglia con lo schema: Perdita + profitto > X , quindi chiudere entrambi (di solito su simboli diversi). Ma si verifica un fallimento, perché anche se sono chiusi, il tester non ne è consapevole, e procede all'iterazione successiva, "accoppiando" erroneamente quelli esistenti con quelli già chiusi. Cioè ho dovuto aggiungere un ricalcolo dopo ogni chiusura.
Ho ricalcolato con un contatore azzerato e su tutti quelli aperti prima, non +1 / -1
Citazione dalla documentazione
Sono d'accordo, era troppo rischioso usare OnTradeTransaction() inizialmente. In realtà, probabilmente lo rifiuterei nei casi in cui le richieste non sono asincrone - solo problemi da esso.
Per una griglia a più simboli, l'asincronia è buona. Ecco perché sceglierei la seconda opzione.
Sto già pensando in quella direzione ;)
***
In questo robot ho testato la possibilità di chiudere le griglie secondo lo schema: perdita + profitto > X , quindi chiudere entrambi (di solito su simboli diversi).
***
Se sai che vuoi chiudere esattamente queste due posizioni, è meglio memorizzare i ticket di queste posizioni, e chiuderle fino a quando non le chiudi (ATTENZIONE: niente while e Sleep - dai l'ordine di chiudere, esci da OnTick, controlla se ci sono altre posizioni con questi ticket - se sì, prova a chiuderle di nuovo e esci da OnTick).
Se sapete che dovete chiudere esattamente queste due posizioni, è meglio ricordare i ticker di queste posizioni e chiuderle finché non le chiudete (NOTA: niente while e Sleep - dare ordini di chiusura, uscire da OnTick, controllare se ci sono altre posizioni con questi ticker - se ci sono, allora provare a chiudere di nuovo e uscire da OnTick).
Questa è un'idea preziosa. Forse OnTick() forma un array con il biglietto e prova a chiuderlo una volta, e OnTimer() controlla se ce ne sono altri e chiude, se ci sono.
Ci possono essere diversi minuti tra un tick e l'altro, quindi passiamo il compito al timerIdea preziosa. Forse è così: OnTick() genera un array con i ticket e prova a chiudere una volta, mentre OnTimer() controlla se sono ancora presenti e chiude se lo sono.
Tra un ticchettio e l'altro possono passare diversi minuti, quindi passiamo il compito a un timerAbbandonerei TUTTO mentre, Sleep e OnTimer per il compito di chiudere le posizioni. Farei così: sparo ordini di chiusura - uscita OnTick, al prossimo tick controllerei se le posizioni con i ticket necessari sono ancora vive - di nuovo sparo ordini di chiusura, e così via attraverso il ciclo via entrata/uscita a OnTick.
La logica è la seguente: la chiusura di una posizione è la prima priorità, quindi il ciclo di chiusura è all'inizio di OnTick. E la formazione di una matrice di ticket di chiusura può essere situata ovunque suTick - anche alla fine.
***
Ci possono essere diversi minuti tra un tick e l'altro, quindi passiamo il compito al timerQuindi, non c'è niente che possiamo fare - dobbiamo solo aspettare una nuova zecca.
OnTick() genera un array con i ticket e prova a chiuderli una volta, e OnTimer() controlla se sono ancora presenti e li chiude se lo sono.
Un'altra opzione (per il mondo reale, questa è la migliore) è quella di eseguire l'EA in un ambiente virtuale (lì c'è un'esecuzione perfetta), e nel mondo reale solo la sincronizzazione con quello virtuale.
Quindi non c'è niente da fare - basta aspettare il prossimo tick.
Se, per esempio, c'è un guasto di rete, allora aspettare il prossimo tick è un'occasione persa per chiudere.
Se, per esempio, c'è un guasto di rete, allora aspettare il prossimo tick significa perdere un'opportunità per chiudere.
Guasto di rete == disconnessione? Se non c'è internet, allora niente può essere chiuso o aperto - che razza di opportunità persa è questa?
In generale, se il sistema di trading è molto sensibile ad ogni starnuto (un errore di connessione o qualcosa del genere) - allora al diavolo un tale sistema di trading.