WPF UserControl Diseño Tiempo Tamaño

Para la mezcla, un truco poco conocido es agregar estos atributos a su control de usuario o ventana:

 xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
mc:Ignorable="d"
       d:DesignHeight="500" d:DesignWidth="600"

Esto establecerá la altura y el ancho del diseño en 500 y 600 respectivamente. Sin embargo, esto solo funcionará para el diseñador de mezclas. No el Diseñador de Visual Studio.

En cuanto al Diseñador de Visual Studio, su técnica es todo lo que funciona. Por eso no uso el Diseñador de Visual Studio. ;)

Aquí hay una lista de Atributos de Tiempo de diseño en el Diseñador de Silverlight. Son los mismos para el diseñador de WPF.

Enumera todos los valores d: disponibles en el Diseñador, tales como d:DesignHeight, d:DesignWidth, d:IsDesignTimeCreatable, d:CreateList y varios otros.

Hago esto todo el tiempo. Simplemente establezca los valores de ancho y alto en "auto" donde instancie su control, y esto anulará los valores de tiempo de diseño para ese control de usuario.

Ie: <loc:UserControl1 Width="auto" Height="auto" />

Otra opción es establecer una combinación de MinWidth y minHeight a un tamaño que permita el trabajo en tiempo de diseño, mientras que Width y Height permanecen "auto". Obviamente, esto solo funciona si no necesita que el UserControl tenga un tamaño menor que los valores mínimos en tiempo de ejecución.

Estaba buscando una solución similar a la utilizada en Blend y con sus menciones creé una clase de comportamiento simple con dos propiedades adjuntas Width & Height que se aplican solo en Desitime

public static class DesignBehavior 
{
    private static readonly Type OwnerType = typeof (DesignBehavior);

    #region Width

    public static readonly DependencyProperty WidthProperty =
        DependencyProperty.RegisterAttached(
            "Width",
            typeof (double),
            OwnerType,
            new FrameworkPropertyMetadata(double.NaN, new PropertyChangedCallback(WidthChangedCallback)));

    public static double GetWidth(DependencyObject depObj)
    {
        return (double)depObj.GetValue(WidthProperty);
    }

    public static void SetWidth(DependencyObject depObj, double value)
    {
        depObj.SetValue(WidthProperty, value);
    }

    private static void WidthChangedCallback(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
    {
        if (DesignerProperties.GetIsInDesignMode(depObj)) {
            depObj.SetValue(FrameworkElement.WidthProperty, e.NewValue);
        }
    }

    #endregion

    #region Height

    public static readonly DependencyProperty HeightProperty =
        DependencyProperty.RegisterAttached(
            "Height",
            typeof (double),
            OwnerType,
            new FrameworkPropertyMetadata(double.NaN, new PropertyChangedCallback(HeightChangedCallback)));

    public static double GetHeight(DependencyObject depObj)
    {
        return (double)depObj.GetValue(HeightProperty);
    }

    public static void SetHeight(DependencyObject depObj, double value)
    {
        depObj.SetValue(HeightProperty, value);
    }


    private static void HeightChangedCallback(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
    {
        if (DesignerProperties.GetIsInDesignMode(depObj)) {
            depObj.SetValue(FrameworkElement.HeightProperty, e.NewValue);
        }
    }

    #endregion

}

A continuación, en su UserControl acaba de establecer estas propiedades en Xaml

<UserControl x:Class="ExtendedDataGrid.Views.PersonOverviewView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:tool="http://schemas.microsoft.com/wpf/2008/toolkit"
    xmlns:b="clr-namespace:ExtendedDataGrid.Behaviors"
    b:DesignBehavior.Width="600" b:DesignBehavior.Height="200">
    <Grid>
         ...
    </Grid>
</UserControl>

Utilice MinWidth y minHeight en el control. De esa manera, lo verás en el diseñador, y en tiempo de ejecución se dimensionará de la manera que quieras.

Lo hago de manera similar, pero mi solución asegura que si agrega su control a un contenedor en modo diseño, aparecerá razonablemente.

protected override void OnVisualParentChanged(DependencyObject oldParent)
{
    if (this.Parent != null)
    {
       this.Width = double.NaN;
       this.Height = double.NaN;
    }
}

¿Qué piensas?

Gracias al responsable original de esta solución! Para aquellos que están interesados, aquí está en VB:

If LicenseManager.UsageMode <> LicenseUsageMode.Designtime Then
    Me.Width = Double.NaN
    Me.Height = Double.NaN
End If

Algunos han sugerido usar LicenseManager.UsageMode propiedad que nunca he visto antes, pero he utilizado el siguiente código.

if(!DesignerProperties.GetIsInDesignMode(this))
{
    this.Width = double.NaN;
    this.Height = double.NaN;
}

Esskar,

Solo quiero agregar que generalmente siempre debe llamar al método de la base cuando anula un método "On".

protected override void OnVisualParentChanged(DependencyObject oldParent)
{
    base.OnVisualParentChanged(oldParent);

    ...
}

Gran solución por cierto, lo estoy usando yo mismo ahora también.