Qual é a diferença entre StaticResource e DynamicResource no WPF?
https://stackoverflow.com/questions/200839
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Ao usar recursos como escovas, modelos e estilos em WPF, eles podem ser especificados quer como StaticResources
<Rectangle Fill="{StaticResource MyBrush}" />
ou como um DynamicResource
<ItemsControl ItemTemplate="{DynamicResource MyItemTemplate}" />
Na maioria das vezes (sempre?), Apenas um funciona eo outro vai jogar exceção durante a execução. Mas eu gostaria de saber por que:
- O que é a principal diferença. Como implicações de memória ou de desempenho
- Existem regras em WPF como "pincéis são sempre estática" e "modelos são sempre dinâmico" etc.?
I assumem a escolha entre estática vs dinâmica não é tão arbitrário quanto parece ... mas não consigo ver o padrão.
Solução
A StaticResource será resolvido e atribuído à propriedade durante o carregamento do XAML que ocorre antes da aplicação é realmente executado. Só vai ser atribuído uma vez e quaisquer alterações ao recurso dicionário ignorado.
A DynamicResource cessionários um objeto de expressão para a propriedade durante o carregamento, mas na verdade não procurar o recurso até a execução quando o objeto de expressão é solicitado para o valor. Este adia olhando para cima o recurso até que seja necessário em tempo de execução. Um bom exemplo seria uma referência para a frente para um recurso definidos mais tarde, na XAML. Outro exemplo é um recurso que não existe mesmo até a execução. Ele irá atualizar o alvo se o dicionário de recurso de origem é alterado.
Outras dicas
Eu também estava confuso sobre eles. Veja este exemplo abaixo:
<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>
Aqui eu tenho de recursos dinâmica usada para o botão ea janela e não ter declarado que anywhere.Upon tempo de execução, o ResourceDictionary da hierarquia será checked.Since eu não tenha definido isso, eu acho que o padrão será usado.
Se eu adicionar o código abaixo para clicar caso de Button, uma vez que utilizam DynamicResource, o fundo será actualizado em conformidade.
private void ButtonNew_Click(object sender, RoutedEventArgs e)
{
this.Resources.Add( "PinkBrush"
,new SolidColorBrush(SystemColors.DesktopColor)
);
}
Se eles tivessem usado StaticResource:
- O recurso tem que ser declarada em XAML
- E isso também "antes" eles são usados.
Hope Limpei alguma confusão.
StaticResource será resolvido na construção do objeto.
DynamicResource serão avaliados e resolvidos todos os controle de tempo precisa do recurso.
recursos lógicos permitem definir objetos em XAML, que não são parte da árvore visual, mas podem ser usados ??em sua interface de usuário. Um dos exemplos de um recurso lógico é Brush, que é usado para fornecer um esquema de cores. Geralmente esses objectos são definidos como recursos, que são utilizados por vários elementos das aplicações.
<Window.Resources>
<RadialGradientBrush x:Key="myGradientBrush">
<GradientStop Color="Green" Offset="0"/>
<GradientStop Color="Blue" Offset="2"/>
</RadialGradientBrush>
</Window.Resources>
Agora, acima do recurso declararam poderia ser usado como estático ou dinâmico de recursos. Um ponto a lembrar é que, quando se utiliza recursos estáticos, deve ser definido pela primeira vez em código XAML, antes que ele possa ser referido. recursos estáticos e dinâmicos pode ser usado como:
<Grid Background="{StaticResource myGradientBrush}"></Grid>
ou
<Grid Background="{DynamicResource myGradientBrush}"></Grid>
A diferença entre StaticResource e DynamicResource mentiras na forma como os recursos são recuperados pelos elementos de referência. StaticResource são recuperadas apenas uma vez pelo elemento de referência e usado para toda a vida do recurso. Por outro lado, DynamicResource são adquiridos cada vez que o objeto referenciado é usado.
Colocá-lo de forma mais simples, se a propriedade cor de RadialGradientBrush é alterado no código para laranja e rosa, em seguida, ele vai refletir sobre elementos somente quando recurso é usado como DynamicResource. Abaixo está o código para alterar o recurso em código:
RadialGradientBrush radialGradientBrush =
new RadialGradientBrush(Colors.Orange, Colors.Pink);
this.Resources["myGradientBrush"] = radialGradientBrush;
O demérito de DynamicResource é que ele reduz o desempenho do aplicativo porque os recursos são recuperadas cada vez que eles são usados. A melhor prática é usar StaticResource até que haja uma razão específica para uso DynamicResource.
- usos StaticResource início valor. usos DynamicResource última valor.
- DynamicResource pode ser usado para o estilo aninhado, StaticResource não pode.
Suponha que você tenha este dicionário estilo aninhado. Lightgreen está no nível raiz, enquanto Rosa está aninhado dentro de um Grid.
<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>
Em vista:
<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 tornará o botão como Lightgreen, o primeiro valor que encontrou no estilo. DynamicResource irá substituir o botão Lightgreen tão rosa quanto ele processa o Grid.
StaticResource
DynamicResource
Tenha em mente que VS Designer trata DynamicResource como StaticResource. Ele terá primeiro valor. Neste caso, VS Designer tornará o botão como Lightgreen embora, na verdade, acaba como rosa.
StaticResource irá lançar um erro quando o estilo de nível raiz (Lightgreen) é removida.
Qual é a principal diferença. Como implicações de memória ou de desempenho
A diferença entre estática e recursos dinâmicos acontece quando as mudanças objeto subjacente. Se o seu pincel definido na coleção Resources foram acessados ??no código e conjunto a uma instância de objeto diferente, Retângulo não irá detectar esta mudança.
estática Recursos recuperados uma vez referenciando elemento e usado para a vida útil dos recursos. Considerando que, DynamicResources recuperar cada vez que eles são usados.
A desvantagem de recursos dinâmicos é que eles tendem a diminuir o desempenho do aplicativo.
Existem regras em WPF como "pincéis são sempre estática" e "modelos são sempre dinâmico" etc.?
A melhor prática é usar estática Recursos a menos que haja uma razão específica, como você quiser recursos mudança no código por trás dinamicamente. Outro exemplo de caso em que você gostaria de usar t resoruces dinâmicos incluem quando você usa os SystemBrushes, SystenFonts e parâmetros do sistema.
Encontrado todas as respostas úteis, só queria acrescentar mais um caso de uso.
Em um cenário WPF composto, seu controle de usuário pode fazer uso de recursos definidos em qualquer outra janela pai / controle (que vai acolher este controle do usuário), referindo-se a esse recurso como DynamicResource.
Como mencionado por outros, StaticResource será olhou para cima em tempo de compilação. controles de usuário não pode se referir a esses recursos que são definidos em sediar controle / pai. Embora, DynamicResource poderia ser usado neste caso.
benefício importante dos recursos dinâmicos
Se a inicialização do aplicativo leva tempo extremamente longo, você deve usar recursos dinâmicos, porque os recursos estáticos são sempre carregados quando a janela ou aplicativo é criado, enquanto os recursos dinâmicos são carregados quando eles são usados ??em primeiro lugar.
No entanto, você não vai ver qualquer benefício a não ser que o seu recurso é extremamente grande e complexo.
recursos dinâmicos só pode ser usado quando a propriedade sendo definida é no objeto que é derivado do objeto de dependência ou freezable onde, como recursos estáticos pode ser usado em qualquer lugar. Pode abstrato controle afastado inteiro usando recursos estáticos.
recursos estáticos são usados ??nas seguintes circunstâncias:
- Quando as alterações de recursos reação em tempo de execução não é necessária.
- Se você precisa de um bom desempenho com muitos recursos.
- Enquanto referenciando recursos dentro do mesmo dicionário.
recursos dinâmicos:
- Valor da propriedade ou tema setter estilo não é conhecido até a execução
- Este incluem o sistema, aplicação, configurações de tema base
- Isto também inclui referências à frente.
- Fazendo referência a grandes recursos que podem não carregar quando página, janelas, cargas UserControl.
- Fazendo referência a estilos do tema em um controle personalizado.
