Diviser un grand XAML en nombre de fichiers Sub-XAML

Question

Dans mon application WPF4 Desktop, il y a un gros bloc avec un menu de barre latérale qui se répète dans chaque fenêtre et prend environ 70 lignes de XAML. Afin d'améliorer le code réutilisation, je voudrais partager le fichier XAML dans deux fichiers:

1. XAML fichier qui contient le code pour le menu de la barre latérale (≈70 lignes)
2. base fichier XAML qui contient «include/référence »XAML fichier avec le code barre de menu latérale

Comme je l'ai compris, il y a deux façons de mettre en œuvre mon problème:

1. Utilisez ResourceDictionary
2. Utilisez UserControl/CustomControl

Mes questions sont les suivantes:

1. Quelle est la différence entre ResourceDictionary et UserControl? Pourriez-vous me donner des exemples où je dois utiliser UserControl et où ResourceDictionary?

2. Pourriez-vous donner un exemple de code complet comment inclure/importer le contenu d'un fichier XAML à un autre?

P.S. Voici un exemple de code que je veux exporter de séparer XAML fichier:

<Border Style="{StaticResource Body_SideBarMenu_Border_Settings}"> 
    <StackPanel Style="{StaticResource Body_SideBarMenu}"> 

    <TextBlock Style="{StaticResource Body_SideBarMenu_Title}" 
      Text="{x:Static res:Resources.WinApp_SideBarMenu_Title}" /> 

     <TextBlock x:Name="SideBar_WinReports" 
       Style="{StaticResource Body_SideBarMenu_Item}" 
       Text="{x:Static res:Resources.DashListMarker}"> 
        <Hyperlink KeyboardNavigation.TabIndex="12" 
          Style="{StaticResource Body_SideBarMenu_Item_Hyperlink}" 
          Click="Call_WinReports_Click"> 
          <TextBlock Text="{x:Static res:Resources.WinApp_ModuleName_Reports}" /> 
        </Hyperlink> 
     </TextBlock> 

    </StackPanel> 
</Border> 

Answer 1

ResourceDictionary est juste un conteneur pour vos styles/modèles, etc Donc, vous avez vraiment un choix entre l'utilisation d'un style (et son référencement via un ResourceDictionary) ou un UserControl. Pour faire la différence entre les deux, posez-vous une question: implémentez-vous simplement un autre contrôle pour un contrôle existant, ou vous implémentez quelque chose de vraiment nouveau, qui est plus qu'un simple ListView (ou une Border, ou une ComboBox etc.)? Dans le premier cas, utilisez un style; dans ce dernier cas, créez un nouveau UserControl.

Spécifiquement pour votre cas, je voudrais opter pour un UserControl.

---

exemple de code (mais pas plein)

(S'il vous plaît noter qu'un modèle pour le code suivant peut être inséré avec "ajouter un nouveau UserControl" VS de)

Xaml:

<UserControl x:Class="SomeNamespace.SidebarMenu" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 

    <UserControl.Resources> <!-- you can define local styles here --> 
     <Style x:Key="SidebarMenuTextblock" TargetType=TextBlock> 
      ... 
     </Style> 
    </UserControl.Resources> 

    <Border Background=...> 
     <StackPanel> 

      <TextBlock 
       x:Name="Put_a_name_if_you_want_to_reference_this_item_in_code_behind" 
       Style="{StaticResource SidebarMenuTextblock}" 
       Text="{x:Static res:Resources.WinApp_SideBarMenu_Title}" /> 
      ...  </StackPanel> 
    </Border> 
</UserControl> 

.cs:

using System; 
using System.Windows; 
using System.Windows.Controls; 

namespace SomeNamespace 
{ 
    public partial class SidebarMenu : UserControl 
    { 
     public NumericUpDown() 
     { 
      InitializeComponent(); 
     } 
     ... 
     // define here your properties etc, 
    } 
} 

Maintenant, vous pouvez utiliser le contrôle comme ça:

<Window 
    x:Class="SomeOtherNamespace.MainWindow" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:controls="clr-namespace:SomeNamespace"> 

    <Grid> 
     <controls:SidebarMenu PropertyIfYouDefinedOne="SomeValue"/> 
     ... 
    </Grid> 

</Window> 

Answer 2

Si vous pouvez obtenir vos mains sur Expression Studio, dans Expression Blend, vous pouvez simplement un clic droit sur un contrôle et convertir à un contrôle de l'utilisateur. Aussi facile que ça.

Les contrôles utilisateur permettent de fractionner le fichier XAML. En substance, il est utilisé pour redéfinir le comportement d'un contrôle existant. Cependant, avec les contrôles utilisateur, vous pouvez définir des contrôles de mise en page WPF entiers et les convertir en un contrôle utilisateur, avec le contenu des enfants à l'intérieur. Ceci est très utile pour un projet réparti sur plusieurs développeurs, et peut également être utilisé pour émuler le comportement d'un MDI, qui est en quelque sorte absent de WPF.