ElementName vs. RelativeResource?

Question

Quali delle Associazioni seguenti TextBlocks' costa di più prestazioni:

<Window  
  x:Name="Me"
  x:Class="MainWindow"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
  xmlns:src="clr-namespace:WpfApplication1" 
  Title="MainWindow">
  <StackPanel>
    <TextBlock Text="{Binding Title, ElementName=Me}"/>
    <TextBlock Text="{Binding Title, RelativeSource={RelativeSource AncestorType={x:Type src:MainWindow}}}"/>
  </StackPanel>    
</Window>

Sono sicuro che la mia domanda potrebbe richiedere diverso quando i TextBlocks sono in un elevato livello di annidamento avere molti fratelli e antenati.

Considerazioni

(basata su pensieri personali solo, potrei sbagliarmi in ogni particolare uno!):

• ElementName :

  • Potrebbe cercare e confrontare elemento corrente di un maggiore controllo, attraverso tutti i suoi figli, fratelli, zii e zii grandi tra cui antenati (forse c'è una HashTable di tutti i nomi registrati?)
  • Come una proprietà Name di un controllo dovrebbe costare meno prestazioni rispetto a chiamare GetType.
  • Confrontando una stringa è più conveniente che il confronto tipi, soprattutto quando si sa che la maggior parte dei controlli non hanno nemmeno il loro set Name.

• FindAncestor :

  • Will solo iterare attraverso gli antenati, non siblingls 'zii', 'cugini etc.
  • La maggior parte dei usi probabili GetType per determinare antenato tipo; GetType costa di più le prestazioni, allora un semplice getter proprietà Name (forse PS sono diversi?)

Answer 1

Di solito è una pessima idea per cercare di rispondere a questo genere di cose da discutere su quale pensi sarà più veloce. Molto meglio per costruire un esperimento per misurarla.

ho modificato la configurazione un po '- ho messo il relativo Xaml in un UserControl, e legato alla proprietà Name poiché UserControl non ha una proprietà Title. Ho quindi scritto il codice per creare una nuova istanza del controllo e aggiungerlo alla UI, e usato il Stopwatch per misurare il tempo impiegato per la costruzione e lo carica. (Mi metto i tempi appena prima di costruire il controllo utente, e mi fermo subito dopo il controllo utente alza la manifestazione Loaded.)

ho eseguito questo codice da un DispatcherTimer 20 volte al secondo in modo da poter prendere un sacco di misurazioni nella speranza di ridurre errore sperimentale. Per ridurre al minimo le distorsioni a causa di debug e codice diagnostica, sto correndo in una build di rilascio, e ho solo calcolare e stampare la media dopo 2000 iterazioni hanno completato.

Dopo 2000 iterazioni, l'approccio ElementName medie 887us.

Dopo 2000 iterazioni, l'approccio RelativeSource medie 959us.

Quindi ElementName è, in questo particolare esperimento, un po 'più veloce di RelativeSource. Caricamento di un UserControl banale con solo un Grid e uno TextBlock dove c'è un solo nome elemento, gli sguardi approccio ElementName di prendere il 92% del tempo di carico che l'approccio RelativeSource prende.

Naturalmente, sto misurando un piccolo, ad esempio artificiale qui. Le prestazioni del metodo ElementName potrebbe variare in base al numero di elementi di nome sono di portata. E ci possono essere altri fattori imprevisti che potrebbero produrre completamente diversi risultati in scenari reali. Quindi mi sento di raccomandare l'esecuzione di misure analoghe nel quadro di una vera e propria applicazione, se si vuole ottenere un quadro migliore.

I ripetuto l'esperimento con 10 TextBlocks invece di 1. ElementName 2020us poi mediati mentre l'approccio RelativeSource media 2073us, ancora una volta più di 2000 iterazioni per entrambi i test. Stranamente, c'è una differenza minore qui, non solo in termini relativi, ma in termini assoluti -. Gli esempi di un elemento ha mostrato una differenza di 72us, dove gli esempi di dieci elementi hanno mostrato una differenza di 53us

Sto iniziando a sospettare che sto causando una maggiore variabilità eseguendo i miei test sulla mia macchina principale, piuttosto che uno accuratamente configurato con il meno roba possibile per ridurre al minimo il rumore.

Ancora una variante: ancora con 10 blocchi di testo rilegati, ho aggiunto dieci, non rilegati, blocchi di testo denominati più vuote per il controllo utente. L'idea era di introdurre le cose più nominate - ElementName deve ora individuare un elemento denominato entro 11 cose nominate. La media per ElementName è ora 2775us. L'approccio RelativeSource con questi extra di 10 elementi nome è venuto fuori a 3041us.

Ancora una volta, ho la variabilità sospetto sulla mia macchina desktop qui -. Sembra strano che RelativeSource ha eseguito significativamente peggiore qui che nel scenario che avrebbe dovuto essere più a vantaggio di ElementName

In ogni caso, ciò che non sembrare ragionevolmente chiaro è che il costo di carico qui è molto più sensibile al numero di elementi che è di quale stile di rilegatura che si usa. C'è evidentemente un piccolo vantaggio per ElementName ma abbastanza piccolo (e con risultati abbastanza strani) per gettare sospetti sulla validità di concludere che sia necessariamente più veloce.

Così abbiamo potuto costruire più attenti esperimenti per ottenere un quadro migliore. Ma a mio avviso, se non è possibile dimostrare in modo conclusivo una differenza significativa in termini di prestazioni durante l'esecuzione su un normale computer, quindi è fondamentalmente uno spreco di tempo a discutere su quale sia più veloce.

Quindi, in conclusione: le prestazioni è la cosa sbagliata da concentrarsi su luiri. Scegliere a seconda di quale rende il codice più leggibile.

Answer 2

La successiva dei due esigenze per camminare albero visuale alla ricerca di un particolare tipo di antenato, dove, come gli sguardi prima direttamente al NameScope della finestra per un oggetto registrato con quel nome ... La mia ipotesi è che il secondo è marginalmente più lento ... che ha detto, non credo che ci sarà una significativa differenza di prestazioni.

Speranza che aiuta,

Aj