WPF UserControl Moment de la Conception de la Taille

Dans Visual Studio ajouter la Largeur et la Hauteur de l'attribut de votre UserControl XAML, mais dans le code-behind insérer cette

public UserControl1()
{
    InitializeComponent();
    if (LicenseManager.UsageMode != LicenseUsageMode.Designtime)
    {
        this.Width = double.NaN; ;
        this.Height = double.NaN; ;
    }
}

Cette fonction vérifie si le contrôle est en cours d'exécution en mode création. Si non (runtime), qui va définir la Largeur et la Hauteur de NaN (Pas un nombre) qui est la valeur que vous définissez si vous supprimez les attributs Width et Height dans le code XAML.

Ainsi, au moment de la conception, vous aurez le préréglage de la largeur et de la hauteur (y compris si vous placez le contrôle de l'utilisateur dans un formulaire) et à l'exécution, il accostera en fonction de son conteneur parent.

Espère que ça aide.

Voici une liste de Les Attributs de conception dans le Concepteur Silverlight. Ils sont les mêmes pour le concepteur WPF.

Il répertorie tous les d: valeurs disponibles dans le Concepteur, tels que d:DesignHeight, d:DesignWidth, d:IsDesignTimeCreatable, d:CreateList et plusieurs autres.

J'étais à la recherche de solution similaire comme celui utilisé dans le Mélange et avec vos mentions j'ai créé comportement simple classe avec deux propriétés attachées Largeur & Hauteur qui sont appliquées que dans des DesinTime

public static de la classe DesignBehavior 
{ 
private static readonly Type OwnerType = typeof (DesignBehavior); 

#région Largeur 

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

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

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

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

#endregion 

#Hauteur de région 

public static readonly DependencyProperty HeightProperty = 
DependencyProperty.RegisterAttached( 
"La hauteur", 
typeof (double), 
OwnerType, 
nouveau FrameworkPropertyMetadata(double.NaN, nouvelle PropertyChangedCallback(HeightChangedCallback))); 

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

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


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

#endregion 

} 

Puis dans votre UserControl que vous venez de définir ces propriétés dans le code Xaml

<UserControl x:Class="ExtendedDataGrid.Les vues.PersonOverviewView" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:outil="http://schemas.microsoft.com/wpf/2008/toolkit" 
xmlns:b="clr-namespace:ExtendedDataGrid.Les comportements" 
b:DesignBehavior.Largeur="600" b:DesignBehavior.Height="200"> 
<Grid> 
... 
</Grid> 
</UserControl> 

Je le fais similaire, mais ma solution assure que si vous ajoutez à votre contrôle d'un conteneur en mode de conception, il apparaît raisonnable.

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

qu'en pensez-vous?

Certains ont suggéré d'utiliser l'LicenseManager.UsageMode bien que je n'ai jamais vu avant, mais j'ai utilisé le code suivant.

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

esskar,

Je tiens juste à ajouter que vous devriez toujours faire appel à la méthode de la base lors de la substitution d'une "Sur" la méthode.

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

    ...
}

Grand contournement par le chemin, je l'utilise moi-même maintenant.