Quelle est la différence entre StaticResource et DynamicResource dans WPF?

j'étais aussi confus à leur sujet. Voir l'exemple ci-dessous:

<Window x:Class="WpfApplicationWPF.CommandsWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="CommandsWindow" Height="300" Width="300">

    <StackPanel>
        <Button Name="ButtonNew" 
                Click="ButtonNew_Click" 
                Background="{DynamicResource PinkBrush}">NEW</Button>
        <Image Name="ImageNew" 
               Source="pack://application:,,,/images/winter.jpg"></Image>
    </StackPanel>


    <Window.Background>
        <DynamicResource ResourceKey="PinkBrush"></DynamicResource>
    </Window.Background>

</Window>

ici, j'ai utilisé la ressource dynamique pour bouton et fenêtre et je ne l'ai déclaré nulle part.Une fois l'exécution terminée, la débrouillardise de la hiérarchie sera vérifiée.Puisque je ne l'ai pas défini, je suppose que la valeur par défaut sera utilisée.

si j'ajoute le code ci-dessous pour cliquer en cas de bouton, puisqu'ils utilisent DynamicResource, le fond sera mis à jour en conséquence.

private void ButtonNew_Click(object sender, RoutedEventArgs e)
{
    this.Resources.Add(  "PinkBrush"
                         ,new SolidColorBrush(SystemColors.DesktopColor)
                       );
}

S'ils avaient utilisé StaticResource:

• la ressource doit être déclarée dans XAML
• Et trop "avant" ils sont utilisés.

J'espère avoir dissipé une certaine confusion.

StaticResource sera résolu sur la construction de l'objet.

DynamicResource sera évalué et résolu chaque fois que control aura besoin de la ressource.

les ressources logiques vous permettent de définir des objets dans XAML, qui ne font pas partie de visual tree mais peuvent être utilisés dans votre interface utilisateur. Un des exemples d'une ressource logique est Brush, qui est utilisé pour fournir un schéma de couleurs. Généralement ces objets sont définies comme des ressources, qui sont utilisées par plusieurs éléments de l'application.

<Window.Resources>
    <RadialGradientBrush x:Key="myGradientBrush">
        <GradientStop Color="Green" Offset="0"/>
        <GradientStop Color="Blue" Offset="2"/>
    </RadialGradientBrush>
</Window.Resources>

maintenant, la ressource déclarée ci-dessus pourrait être utilisée comme ressource statique ou dynamique. Un point à retenir est que, lorsqu'on utilise des ressources statiques, il faut d'abord les définir dans le code XAML, avant de pouvoir les renvoyer. Les ressources statiques et dynamiques peuvent être utilisées comme:

<Grid Background="{StaticResource myGradientBrush}"></Grid>

ou:

<Grid Background="{DynamicResource myGradientBrush}"></Grid>

la différence entre StaticResource et DynamicResource réside dans la façon dont les ressources sont récupérées par les éléments de référencement. La ressource StaticResource n'est récupérée qu'une seule fois par l'élément de référence et est utilisée pendant toute la durée de vie de la ressource. Sur l'autre main, DynamicResource sont acquis chaque fois que l'objet référencé est utilisé.

en le mettant de manière plus simple, si la propriété de couleur de RadialGradientBrush est changée dans le code en Orange et rose, alors il ne réfléchira sur les éléments que lorsque la ressource est utilisée comme source dynamique. Ci-dessous est le code pour changer la ressource dans le code:

RadialGradientBrush radialGradientBrush =
    new RadialGradientBrush(Colors.Orange, Colors.Pink);
this.Resources["myGradientBrush"] = radialGradientBrush;

L'inconvénient de DynamicResource est qu'il réduit les performances de l'application parce que les ressources sont extraites à chaque fois ils sont utilisés. La meilleure pratique consiste à utiliser la ressource Dynamic jusqu'à ce qu'il y ait une raison spécifique d'utiliser la ressource Dynamic.

Source:

WPF: StaticResource vs. DynamicResource

1. StaticResource utilise première de la valeur. DynamicResource utilise la valeur last .
2. DynamicResource peut être utilisé pour le style imbriqué, StaticResource ne peut pas.

supposons que vous ayez ce dictionnaire de Style imbriqué. Le vert clair est au niveau des racines tandis que le rose est niché à l'intérieur d'une grille.

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Style TargetType="{x:Type Grid}">
        <Style.Resources>
            <Style TargetType="{x:Type Button}" x:Key="ConflictButton">
                <Setter Property="Background" Value="Pink"/>
            </Style>
        </Style.Resources>
    </Style>
    <Style TargetType="{x:Type Button}" x:Key="ConflictButton">
        <Setter Property="Background" Value="LightGreen"/>
    </Style>
</ResourceDictionary>

:

<Window x:Class="WpfStyleDemo.ConflictingStyleWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ConflictingStyleWindow" Height="100" Width="100">
    <Window.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="Styles/ConflictingStyle.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Window.Resources>
    <Grid>
        <Button Style="{DynamicResource ConflictButton}" Content="Test"/>
    </Grid>
</Window>

StaticResource va rendre le bouton comme LightGreen, la première valeur qu'il a trouvé dans le style. DynamicResource va surcharger le bouton LightGreen aussi rose qu'il rend la grille.

StaticResource

DynamicResource

gardez à l'esprit que VS Designer traite DynamicResource comme StaticResource. Elle permettra d'obtenir une première valeur. Dans ce cas, VS Designer affichera le bouton comme LightGreen bien qu'il se termine réellement en Rose.

StaticResource va lancer une erreur lorsque le style root-level (LightGreen) est supprimé.

Quelle est la principale différence. Comme la mémoire ou la performance implications

la différence entre les ressources statiques et dynamiques vient lorsque l'objet sous-jacent change. Si votre pinceau défini dans la collection de ressources a été accédé en code et défini à une instance d'objet différente, Rectangle ne détectera pas ce changement.

ressources statiques récupérées une fois par élément de référence et utilisées pour la durée de vie du ressources. Tandis que les ressources dynamiques récupèrent chaque fois qu'elles sont utilisées.

l'inconvénient des ressources dynamiques est qu'elles ont tendance à diminuer les performances des applications.

y a-t-il des règles dans WPF comme" brosses are always static "et" templates are always dynamic " etc.?

la meilleure pratique est d'utiliser des ressources statiques à moins qu'il n'y ait une raison spécifique comme vous voulez changer la ressource dans le code derrière dynamiquement. Un autre exemple d'instance dans laquelle vous souhaiteriez utiliser des resoruces dynamiques est lorsque vous utilisez les SystemBrushes, les SystenFonts et les paramètres du système.

a trouvé toutes les réponses utiles, je voulais juste ajouter un cas d'utilisation de plus.

dans un scénario composite WPF, votre contrôle de l'utilisateur peut utiliser des ressources définies dans n'importe quelle fenêtre/Contrôle parent (qui va héberger ce contrôle de l'utilisateur) en se référant à cette ressource comme DynamicResource.

comme mentionné par d'autres, Staticresource sera consulté au moment de la compilation. Les contrôles d'utilisateur ne peuvent pas se référer aux ressources qui sont définies dans l'hébergement / parent contrôle. Bien que, DynamicResource pourrait être utilisé dans ce cas.

avantage Important de la dynamique des ressources

si le démarrage de l'application prend très longtemps, vous devez utiliser des ressources dynamiques, parce que les ressources statiques sont toujours chargées lorsque la fenêtre ou l'application est créée, alors que les ressources dynamiques sont chargés lorsqu'ils sont d'abord utilisés.

cependant, vous ne verrez aucun avantage à moins que votre ressource est extrêmement grande et complexe.

la différence entre StaticResource et DynamicResource réside dans la façon dont les ressources sont récupérées par les éléments de référencement. La ressource StaticResource n'est récupérée qu'une seule fois par l'élément de référence et est utilisée pendant toute la durée de vie de la ressource. D'autre part, DynamicResource sont acquis chaque fois que l'objet référencé est utilisé.

Voici la principale différence entre les ressources statiques et dynamiques:

1. ressource Statique permettra d'évaluer la ressource qu'une seule fois tandis que la dynamique de la ressource sera évalué chaque fois que la ressource nécessaire.

2.La ressource dynamique a plus de frais généraux de performance que les ressources statiques parce qu'elle cherche des ressources chaque fois qu'elle demande ou a besoin.

3.Ressource statique est plus rapide, mais il prend un peu plus de temps pour charger la page ou la fenêtre que la ressource dynamique parce que les ressources dynamiques sont chargées quand vous les utilisez réellement.

Dynamique des ressources peut être utilisée uniquement lorsque la propriété est sur un objet qui est dérivé de la dépendance de l'objet ou gelé où, comme les ressources statiques peuvent être utilisés n'importe où. Vous pouvez abstraire tout le contrôle en utilisant des ressources statiques.

les ressources statiques sont utilisées dans les circonstances suivantes:

1. lorsque la modification des ressources de réaction à l'exécution n'est pas nécessaire.
2. Si vous avez besoin d'une bonne performance avec beaucoup de ressources.
3. tout en référençant des ressources dans le même dictionnaire.

ressources dynamiques:

1. valeur de la propriété ou du thème de setter de style n'est pas connue jusqu'à l'exécution
   • cela comprend le système, l'application, les paramètres basés sur le thème
   • comprend également les référence.
2. faisant référence à de grandes ressources qui ne peuvent pas se charger lorsque page, windows, usercontrol se charge.
3. référencement des styles de thème dans un contrôle personnalisé.

Statique visée ressources d'évaluer la ressource qu'une seule fois et après que si les ressources du changement de ces modifications ne sont pas répercutées dans la liaison. Tandis que les ressources dynamiques référées sont évaluées chaque fois que la ressource est nécessaire.