TabItem dans un fichier XAML distinct

Est-il possible de mettre un TabItem dans un autre XAML et de référence à quelque chose comme ceci:

<TabControl>
     <local:MyTabItem/>
</TabControl>



In Separate XAML:
<UserControl x:Class="MyProject.MyTabItem"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <TabItem Header="MyTab">

    </TabItem>
</UserControl>

Bien sûr, cela ne fonctionne pas, mais je me demande comment puis-je faire cela?

source d'informationauteur John Sheares

tabitem wpf

Si ce que vous voulez faire est simplement de rendre le code plus facile à gérer alors je vous recommande la définition de chaque onglet données dans un contrôle utilisateur, mais qui ont encore le TabItem dans l'onglet principal de contrôle.

Supposons que votre code d'origine:

<TabControl>
    <TabItem Header="Tab 1">
        <Grid>
            <TextBlock Text="Tab Data" />
        </Grid>
    </TabItem>
</TabControl>

Pour rendre le code plus facile à gérer, vous risquez de casser l'onglet contenu dans un UserControl tels que:

<UserControl x:Class="WpfApplication19.Tab1Data"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             >
    <Grid>
        <TextBlock Text="Tab Data" />
    </Grid>
</UserControl>

Puis utilisez-le contrôle de l'utilisateur dans votre TabControl comme ceci:

    <TabControl>
        <TabItem Header="Tab 1">
            <tabData:Tab1Data />
        </TabItem>
    </TabControl>

Si vous voulez vraiment inclure la TabItem dans votre contrôle de l'utilisateur alors vous pouvez le faire en créant d'abord un contrôle de l'utilisateur, et puis changer le type de l'utilisateur de contrôler le type TabItem (assurez-vous de changer dans le code xaml nœud racine et le code-behind).

Ce serait vous laisser avec un contrôle onglet qui ressemble à ceci:

    <TabControl>
        <tabData:TabItem1 />
        <tabData:TabItem2 />
        <tabData:TabItem3 />
    </TabControl>

Et chaque TabItem1 'de Contrôle de l'Utilisateur" serait de type TabItem. Voici un exemple:

<TabItem x:Class="WpfApplication19.TabItem1"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Header="Tab 1"
         >
    <Grid>
        <TextBlock Text="Tab Data" />
    </Grid>
</TabItem>

Et comme je l'ai mentionné, assurez-vous de modifier le code derrière, de sorte qu'il s'étend TabItem au lieu de contrôle de l'utilisateur:

public partial class TabItem1 : TabItem
{
    public TabItem1()
    {
        InitializeComponent();
    }
}

La réponse précédente de Tony Borres déjà couvre les aspects les plus importants. Mais le commentaire demande d'accès de code derrière. Je vais donc étendre l'exemple de Tony pour montrer cet aspect, trop. Cette réponse montre les espaces de noms requis. J'ai ajouté à la réponse de Tony, trop.

Pour simplement rendre le code plus facile à gérer, il est recommandé de définir chaque onglet données dans un contrôle utilisateur, mais qui ont encore le TabItem dans l'onglet principal de contrôle. Cette stratégie est utile par exemple pour contourner FxCop CA1505: "Éviter désuète code" lors de l'utilisation d'un contrôle onglet avec plusieurs onglet articles.

Supposons que c'est le code d'origine:

<Window x:Class="WpfApplication19.MainWindow" ...>
    <TabControl>
        <TabItem Header="Tab 1">
            <Grid>
                <TextBlock Text="Data on Tab 1" Name="txtData1" />
            </Grid>
        </TabItem>
        <TabItem Header="Tab 2">
            <Grid>
                <TextBlock Text="Data on Tab 2" Name="txtData2" />
            </Grid>
        </TabItem>
    </TabControl>
</Window>

Pour rendre le code plus facile à gérer l'onglet contenu peut être déplacé dans un UserControl tels que:

<UserControl x:Class="WpfApplication19.Tab1Data"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             Loaded="OnControlLoaded"
             >
    <Grid>
        <TextBlock Text="Data on Tab 1" Name="txtData1" />
    </Grid>
</UserControl>

Et il est alors possible d'utiliser le nouveau contrôle utilisateur dans le TabControl comme ceci:

<Window x:Class="WpfApplication19.MainWindow"
        xmlns:tabData="clr-namespace:WpfApplication19" ...>
    <TabControl>
        <TabItem Header="Tab 1">
            <tabData:Tab1Data x:Name="ucTab1Data" />
        </TabItem>
        <TabItem Header="Tab 2">
            <Grid>
                <TextBlock Text="Data on Tab 2" Name="txtData2"/>
            </Grid>
        </TabItem>
    </TabControl>
</Window>

Maintenant il possible d'accéder à l'intérieur-wigdets de l'utilisateur de contrôler à partir de la fenêtre principale et vice-versa. Veuillez noter que le "x:" en face de l'utilisateur nom du contrôle.

public partial class MainWindow : Window
{
    private void AccessWidgetWithinUserControl()
    {
        ucTab1Data.txtData1.Text = "New text on Tab 1";
    }
}

public partial class Tab1Data : UserControl
{
    private MainWindow mainWindow = null; //Reference to the MainWindow

    public Tab1Data()
    {
        InitializeComponent();
    }

    //get a reference to main windows when it is available.
    //The Loaded Event is set in the XAML code above.
    private void OnControlLoaded(object sender, RoutedEventArgs e)
    {
        mainWindow = Window.GetWindow(this) as MainWindow;
    }

    private void AccessMainWindowsWidget()
    {
        mainWindow.txtData2.Text = "New text on Tab 2 in the main window";
    }
}

Le code d'accès txtData2 serait le même, même si est embarqué dans son propre contrôle de l'utilisateur.

2

Sur la surface, cela sonne comme il serait mieux résolus par un style et/ou d'un modèle pour la TabItem de contrôle que vous pouvez enregistrer dans un fichier de ressources distinct. Combien vous avez besoin pour personnaliser le réel TabItem permettra de déterminer si vous pouvez simplement utiliser un style ou si vous avez besoin d'un modèle.

Ce que vous pouvez faire est de définir un Style nommé pour chaque TabItem dans un autre fichier de ressources comme, créer un MyResources.xaml qui ressemble à quelque chose comme ceci:
```
<ResourceDictionary>
    <Style x:Key="MyTabItem" TargetType="{x:Type TabItem}">
      
    </Style>
</ResourceDictionary>
```
Ensuite dans votre Application principale.fichier xaml de la fusion dans le dictionnaire de ressources:
```
<Application.Resources>
    <ResourceDictionary>
        <ResourceDictionary.MergedDictionaries>
            <ResourceDictionary Source="MyResources.xaml"/>
        </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
</Application.Resources>
```
Enfin dans votre application, vous permettrait de tirer parti de ces Styles simplement en faisant:
```
<TabItem Style="{DynamicResource MyTabItem}" />
```

Je pense que ce que vous voulez est d'obtenir TabItem Contenu déclarer séparément. Depuis TabItem est un ContentControl vous pouvez présenter un UserControl que son contenu.

<TabControl>
   <TabItem> 
       <local:YourTabContent1/>
   </TabItem>
   <TabItem> 
       <local:YourTabContent2/>
   </TabItem>
</TabControl>

En Séparer XAML:

<UserControl x:Class="MyProject.YourTabContent1"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <......blah blah.../>
</UserControl>

Dans un autre XAML, vous pouvez avoir un contenu 2

<UserControl x:Class="MyProject.YourTabContent2"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
   <......blah blah.../>
</UserControl>

Vous devez vous connecter pour publier un commentaire.