Performance UserControl/CustomControl

Question

Ho già cercato un sacco di siti sulla rete, ma non ho trovato alcuna soluzione. L'affermazione è che non esiste alcuna differenza di prestazioni tra un UserControl e un CustomControl.

Ma ho la seguente classe di test X, UserControl, CustomControl e MainWindow:

public class X : INotifyPropertyChanged 
{ 
    private string _title; 
    public string Title 

    { 
     get 
     { 
      return _title; 
     } 
     set 
     { 
      if (value == _title) 
      { 
       return; 
      } 
      _title = value; 
      OnPropertyChanged("Title"); 
     } 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 

    [NotifyPropertyChangedInvocator] 
    protected virtual void OnPropertyChanged(string propertyName) 
    { 
     PropertyChangedEventHandler handler = PropertyChanged; 
     if (handler != null) 
     { 
      handler(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 
} 

UserControl:

<UserControl x:Class="controlperformance.DisplayView" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"> 

<Grid Name="root" Background="LightGray"> 
    <TextBlock Text="{Binding Title}" /> 
</Grid> 

</UserControl> 

CustomControl:

public class DisplayControl : Control 
{ 
    #region Title 

    public string Title 
    { 
     get 
     { 
      return (string)GetValue(TitleProperty); 
     } 
     set 
     { 
      SetValue(TitleProperty, value); 
     } 
    } 

    public static readonly DependencyProperty TitleProperty = DependencyProperty.Register("Title", 
                          typeof(string), 
                          typeof(DisplayControl), 
                          new PropertyMetadata(default(string))); 

    #endregion 

    static DisplayControl() 
    { 
     DefaultStyleKeyProperty.OverrideMetadata(typeof(DisplayControl), new FrameworkPropertyMetadata(typeof(DisplayControl))); 
    } 
} 

Xaml:

<Setter Property="Template"> 
     <Setter.Value> 
      <ControlTemplate TargetType="{x:Type local:DisplayControl}"> 

       <Grid Background="white"> 
        <TextBlock Text="{TemplateBinding Title}" /> 
       </Grid> 

      </ControlTemplate> 
     </Setter.Value> 
    </Setter> 
</Style> 

MainWindow:

public partial class MainWindow : Window 
{ 
    Stopwatch sw = new Stopwatch(); 

    public MainWindow() 
    { 

     InitializeComponent(); 

     Loaded += OnLoaded; 

     sw.Start(); 

     ObservableCollection<X> list = new ObservableCollection<X>(); 
     Random r = new Random(); 

     for (int i = 0; i < 50000; i++) 
     { 
      list.Add(new X { Title = r.Next().ToString()}); 
     } 

     itemscontrol.ItemsSource = list; 
    } 

    private void OnLoaded(object sender, RoutedEventArgs routedEventArgs) 
    { 
     sw.Stop(); 
     MessageBox.Show(sw.Elapsed.ToString()); 
    } 
} 

MainWindow Content:

<ItemsControl Name="itemscontrol"> 
      <ItemsControl.ItemTemplate> 
       <!--<DataTemplate DataType="{x:Type Controlperformance:X}"> 
        <Controlperformance:DisplayView DataContext="{Binding}" /> 
       </DataTemplate>--> 
       <DataTemplate DataType="{x:Type Controlperformance:X}"> 
        <Controlperformance:DisplayControl Title="{Binding Title}"/> 
       </DataTemplate> 
      </ItemsControl.ItemTemplate> 
</ItemsControl> 

Quando si utilizza il CustomControl, MessageBox mostra circa. 20 secondi sul mio computer, ma quando si utilizza l'UserControl, ci vuole circa un minuto! Sostituendo il controllo con la sua griglia un TextBox, è persino più veloce di CustomControl (~ 16 sec).

Qualcuno può vedere dove si trova il collo di bottiglia? Il problema si presenta nella mia applicazione del mondo reale, dove il Template/Control sarebbe molto più complesso.

Grazie mille,

micro

Answer 1

Questa è una risposta in ritardo, ma la differenza fondamentale è che un controllo utente è quasi come una finestra che si ha la il controllo stesso e poi altri controlli come, pulsanti, griglie, caselle di testo, ecc. possono essere aggiunti ad esso. La differenza fondamentale tra una finestra e il controllo utente è che il controllo utente può e deve essere visualizzato all'interno di una finestra.

Un controllo personalizzato d'altra parte è solo un controllo, può essere utilizzato per creare un controllo con una funzionalità specifica per la quale non ci sono controlli incorporati o per dare un controllo esistente, come pulsanti, caselle di testo, ecc. stile specifico per abbinare il tema della tua applicazione. È inoltre possibile aggiungere funzionalità extra ai controlli esistenti utilizzando un controllo personalizzato come l'aggiunta di un'etichetta a una casella di testo per mostrarne lo scopo.

La differenza nel tempo di caricamento è essenzialmente un riflesso delle diverse finalità dell'utente e dei controlli personalizzati, con un controllo utente carica il controllo e gli elementi all'interno di tale controllo in modo che il tempo di caricamento possa essere più lungo. Con un controllo personalizzato, solo il controllo stesso deve essere caricato in modo tale che non impiegherà più tempo a caricarsi rispetto a molti controlli WPF, ad esempio un pulsante Controllo personalizzato non dovrebbe richiedere più tempo di un controllo a pulsante incorporato.