inizializzazione globale fallita!!!!!!! - pagina 5

Nuovo commento
 
deysmacro:
Comment() non ha effetto sul grafico, la maggior parte delle volte.

  if(ObjectFind(Symbol()+"Lot_Size_Label")==0)
   {         
  int x_check=ObjectGet(Symbol()+"Lot_Size_Label",OBJPROP_XDISTANCE);
  int y_check=ObjectGet(Symbol()+"Lot_Size_Label",OBJPROP_YDISTANCE);
  Comment(x_check+ " , "+y_check); 
   }

Comment() per controllare quali sono i dati delle coordinazioni.

Dovrebbero cambiare quando l'etichetta va a destra, ma non lo fanno.

Cioè, le coordinazioni sono quelle che dovrebbero essere.

L'etichetta scompare a destra.

 

Le coordinate sono XDISTANCE = 225; YDISTANCE = 27; CORNER = 3;

In primo luogo, caricando l'indi sul grafico, l'etichetta è al suo posto:

Secondo, chiudendo MT4 e riavviandolo, l'etichetta va a destra:

Terzo, dopo aver spostato i Tf, l'etichetta salta indietro:

È qualcosa che ha a che fare con le ancore relative al calcolo dell'angolo e deve essere un bug in B646.

 
Cosa c'entra tutto questo con l'inizializzazione globale fallita?
 
SDC:
Cosa c'entra tutto questo con l'inizializzazione globale fallita?

Quel B646 è seriamente buggato!
 
Dadas:


Grazie, ho avuto lo stesso problema con gli oggetti che non venivano cancellati all'uscita.

Stavo sviluppando alcuni indi e ho ottenuto questi strani risultati, poi ho visto che nella lista degli oggetti erano ancora lì.

Ho aggirato la cosa, probabilmente nel modo più semplice, con ObjectDelete() nella start().

Sì, cambiando init() con OnInit() e deinit() con OnDeinit() le etichette sono tornate giuste! Grazie!

Poi, dopo un po', non l'ha più fatto!!! Stanno ancora facendo la stessa danza.


Non c'è di che, Dadas. Non userei ObjectDelete() nel metodo di avvio, però. È meglio farlo in OnDeInit(). La ragione è questa: se metti il codice in OnStart() o OnCalculate() sarà eseguito ogni volta che arriva un tick. Questo non va bene per due motivi: 1) aggiunge un sacco di operazioni che consumano tempo che non ci si può permettere di sprecare in un'applicazione in tempo reale e 2) non ha senso farlo nella maggior parte delle situazioni - di solito è importante solo quando un grafico viene deinizializzato. Dovresti farlo nei metodi di "avvio" solo se un cambiamento di prezzo influenzerà i tuoi oggetti in qualche modo. Come esempio, considerate questo (che è parte di un'applicazione che ho intenzione di vendere, ma condividere questo è bello :-) ). 

// If no trade is progress, there is no Position Value to display
      if (ObjectFind("PositionValue") > 0)
                ObjectDelete("PositionValue");
                
      if (ObjectFind("PipsProfitLoss") > 0)
                ObjectDelete("PipsProfitLoss");
                
      if (ObjectFind("CurrentStop") > 0)
                ObjectDelete("CurrentStop");
                
      if (ObjectFind("PipsLockedIn") > 0)
                ObjectDelete("PipsLockedIn");
                
      if (ObjectFind("ProfitLockedIn") > 0)
                ObjectDelete("ProfitLockedIn");
                
      if (GlobalVariableCheck(CurrentPairPercentageRisk))
         GlobalVariableDel(CurrentPairPercentageRisk);

Questo codice cattura gli oggetti che sono rimasti da un trade chiuso, se esistono.

A proposito, NON farlo: 

string AcctCurrency = AccountCurrency();
       
      if (AcctCurrency == "")
          return(rates_total);

Hai frainteso l'intento del codice. È progettato per NON eseguire l'indie finché il server non si è "sistemato". Ecco perché restituisco 0. In questo modo il codice indie non verrà eseguito finché tutte le informazioni di cui ha bisogno non saranno disponibili. Onestamente non ho ancora lavorato con OnCalculate() perché non ne ho avuto bisogno, ma posso dire che quello che stai facendo è un invito al disastro. Non state dicendo al vostro programma: "Non eseguite questo codice finché non avete dati validi", state solo gettando le cose al vento e sperando per il meglio. A dire la verità, non so cosa farebbe il tuo codice se non ricevesse informazioni affidabili dal server. Dopo una considerevole quantità di letture, il loro nuovo metodo OnCalculate() non ha senso per me. mi sembra che stia inutilmente calcolando e consegnando un carico di informazioni che fareste da soli se ne aveste bisogno e risparmiando il tempo di calcolo non preoccupandovi di ciò che non vi serve. Non sono sicuro di cosa stiano cercando di ottenere con questo.

Buon Coding!

 
ProfessorMetal:


Non c'è di che, Dadas. Non userei ObjectDelete() nel metodo iniziale, però. È meglio farlo in OnDeInit(). La ragione è questa: se metti il codice in OnStart() o OnCalculate() sarà eseguito ogni volta che arriva un tick. Questo non va bene per due motivi: 1) aggiunge un sacco di operazioni che consumano tempo che non ci si può permettere di sprecare in un'applicazione in tempo reale e 2) non ha senso farlo nella maggior parte delle situazioni - di solito è importante solo quando un grafico viene deinizializzato. Dovresti farlo nei metodi di "avvio" solo se un cambiamento di prezzo influenzerà i tuoi oggetti in qualche modo. Come esempio, considerate questo (che è parte di un'applicazione che ho intenzione di vendere, ma condividere questo è bello :-) ).

Questo codice cattura gli oggetti che sono stati lasciati da uno scambio chiuso, se esistono.

A proposito, NON farlo:

Hai frainteso l'intento del codice. È progettato per NON eseguire l'indie fino a quando il server si è "sistemato". Ecco perché restituisco 0. In questo modo il codice indie non verrà eseguito finché tutte le informazioni di cui ha bisogno non saranno disponibili. Onestamente non ho ancora lavorato con OnCalculate() perché non ne ho avuto bisogno, ma posso dire che quello che stai facendo è un invito al disastro. Non state dicendo al vostro programma: "Non eseguite questo codice finché non avete dati validi", state solo gettando le cose al vento e sperando per il meglio. A dire la verità, non so cosa farebbe il tuo codice se non ricevesse informazioni affidabili dal server. Dopo una considerevole quantità di letture, il loro nuovo metodo OnCalculate() non ha senso per me. mi sembra che stia inutilmente calcolando e consegnando un carico di informazioni che fareste da soli se ne aveste bisogno e risparmiando il tempo di calcolo non preoccupandovi di ciò che non vi serve. Non sono sicuro di cosa stiano cercando di ottenere con questo.

Felice codifica!


Grazie ancora!

Ho trovato la risposta alle etichette fluttuanti.

Sembra che ora dobbiamo legare l'ancora dell'oggetto nel codice stesso:

https://docs.mql4.com/en/constants/objectconstants/enum_anchorpoint

Quindi, devo aggiungere qualcosa come il seguente: 

if(Corner==0) Anchor=ANCHOR_LEFT;
if(Corner==1) Anchor=ANCHOR_RIGHT;
if(Corner==2) Anchor=ANCHOR_LEFT;
if(Corner==3) Anchor=ANCHOR_RIGHT;

e poi usare un'altra linea per impostare l'oggetto:

    ObjectSet(objname,OBJPROP_ANCHOR,Anchor);

La vita non sta certo diventando più facile!

E poi questo non aiuta, dopo tutto!

BTW. Vi dirò cosa stanno cercando di ottenere:

Vogliono impedire al maggior numero possibile di persone di scherzare con i codici.

Deve essere il più commerciale possibile.

Fino a poco tempo fa, quasi chiunque era in grado di pasticciare con il semplice mql4.

Ora, l'obiettivo è di commercializzare tutto!

 
Dadas:

Quel B646 è seriamente buggato!
Potrebbe essere così, ma l'inizializzazione globale fallita è un errore specifico non collegato a questa discussione sui punti di ancoraggio degli oggetti.
 
ProfessorMetal:


Il loro nuovo metodo OnCalculate() non ha senso per me. mi sembra che stia inutilmente calcolando e consegnando un carico di informazioni che faresti da solo se ne avessi bisogno e risparmiando il tempo di calcolo non preoccupandoti di ciò di cui non hai bisogno. Non sono sicuro di cosa stiano cercando di ottenere con questo.

Buona codifica!

OnCalculate fornisce il risultato del calcolo di quante barre sono già state elaborate dall'indicatore. Sostituisce la vecchia funzione IndicatorCounted. Raggiunge anche la compatibilità con mql5 perché gli array di serie gli vengono passati per riferimento, contro il vecchio modo di mql4 di usare gli array di serie globali. Da un punto di vista di codifica c'è poca differenza.

 

Ancora una volta, sei il benvenuto, Dadas. Avevo dimenticato di usare le proprietà ANCHOR anche se ne faccio uso in alcune delle mie cose.

SDC, grazie per le informazioni. La documentazione non chiarisce bene il suo scopo. Sospetto che il significato possa essersi perso nella traduzione dal russo all'inglese. Ora ha più senso. Presumo che non sia inteso per essere usato al posto di OnStart() ma invece usato al posto di IndicatorCounted(). Sarebbe una buona aggiunta alla documentazione fornire un esempio che mostri una sorta di "prima" e "dopo" la sostituzione di IndicatorCounted() con OnCalculate(). Dovrò tornare indietro e rivedere la documentazione alla luce della tua spiegazione e vedere come i pezzi si uniscono. Grazie ancora.

Prof

 

Si usa int OnCalculate() al posto di int start(). Viene eseguito su ogni tick come start(). Un prima e un dopo avrebbero un aspetto simile a questo,

int start()
  {
   int i=0, limit=0;
   int counted_bars=IndicatorCounted();
//---- check for possible errors
   if(counted_bars < 0) return(-1);
//----
   limit = Bars-counted_bars-1;
   for (i = limit; i >= 0; i--)
   {
//---- indicator calculations
   }
   return(0);
  }

//--------------------------------------------------
//--------------------------------------------------

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
   int i=0, limit=0;
//--- check for possible errors
   if(prev_calculated < 0) return(-1);
//---
   limit = rates_total-prev_calculated;
   for(i = limit; i >= 0; i--)
   {
//--- indicator calculations
   }
   return(rates_total);
  }

I parametri formali di OnCalculate lo rendono più autonomo, il programmatore non deve fare affidamento sulla chiamata di tutti i tipi di globali che apparentemente nei circoli oop è un cattivo programmatore, uno schiaffo sul polso. In pratica non c'è molta differenza tra l'uso di entrambi. Inoltre OnCalculate è lo stesso di mql5 quindi avete la possibilità di scrivere codice compatibile.

12345678
Nuovo commento