wpf - microsoft - visual studio installer

Dividir un XAML grande en número de archivos Sub-XAML

Question

En mi aplicación WPF4 Desktop, hay un gran bloque con un menú de barra lateral que se repite en cada ventana y ocupa aproximadamente 70 líneas de XAML. Para mejorar la reutilización del código, me gustaría dividir el archivo XAML en dos archivos:

1. Archivo XAML que contiene código para el menú de la barra lateral (lines70 líneas)
2. Archivo XAML base que contiene «incluir / referencia» a archivo XAML con código de menú de barra lateral

Como entendí, hay dos formas de implementar mi problema:

1. Use ResourceDictionary
2. Utilice UserControl / CustomControl

Mis preguntas son:

1. ¿Cuál es la diferencia entre ResourceDictionary y UserControl ? ¿Podría darme ejemplos donde tengo que usar UserControl y donde ResourceDictionary ?

2. ¿Podría dar un ejemplo de código completo sobre cómo incluir / importar contenido de un archivo XAML a otro?

PS Aquí hay un ejemplo de código que quiero exportar a un archivo XAML separado:

<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 es solo un contenedor para sus estilos / plantillas, etc. Así que realmente tiene la opción de usar un estilo (y hacer referencia a él a través de un ResourceDictionary) o un UserControl.

Para diferenciar los dos, hágase una pregunta: ¿está implementando otro aspecto para un control existente, o está implementando algo realmente nuevo, que es más que un ListView (o un Borde, un ComboBox, etc.)? ? En el primer caso, usar un estilo; en este último, crea un nuevo UserControl.

Específicamente para su caso, me gustaría ir para un UserControl.

Código de ejemplo (aunque no esté lleno)

(Tenga en cuenta que se puede insertar una plantilla para el siguiente código con "Agregar nuevo UserControl" de VS)

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,
}
}

Ahora, puedes usar el control así:

<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 puede hacer uso de Expression Studio, en Expression Blend, simplemente puede hacer clic derecho en cualquier control y convertirlo en un control de usuario. Tan fácil como eso.

Los controles de usuario son buenos para dividir el archivo XAML. En esencia, se utiliza para redefinir el comportamiento de un control existente.

Sin embargo, con los controles de usuario, puede definir controles de diseño de WPF completos y convertirlos en un control de usuario, con el contenido secundario dentro de ellos. Esto es muy útil para un proyecto distribuido en múltiples desarrolladores, y también se puede utilizar para emular el comportamiento de un MDI, que está ausente en WPF.