Cenni preliminari sugli storyboardStoryboards Overview

In questo argomento viene illustrato come utilizzare gli oggetti Storyboard per organizzare e applicare animazioni.This topic shows how to use Storyboard objects to organize and apply animations. Viene descritto come modificare in modo interattivo Storyboard oggetti e viene descritta la sintassi indiretta di destinazione della proprietà.It describes how to interactively manipulate Storyboard objects and describes indirect property targeting syntax.

PrerequisitiPrerequisites

Per comprendere questo argomento, è necessario conoscere i diversi tipi di animazione e le relative funzionalità di base.To understand this topic, you should be familiar with the different animation types and their basic features. Per un'introduzione alle animazioni, vedere Cenni preliminari sull'animazione.For an introduction to animation, see the Animation Overview. È anche necessario sapere come usare le proprietà associate.You should also know how to use attached properties. Per altre informazioni sulle proprietà associate, vedere Cenni preliminari sulle proprietà associate.For more information about attached properties, see the Attached Properties Overview.

Che cos'è uno storyboard?What Is a Storyboard?

Le animazioni non sono l'unico tipo utile della sequenza temporale.Animations are not the only useful type of timeline. Sono disponibili altre classi di sequenze temporali per organizzare set di sequenze temporali e per applicare le sequenze temporali alle proprietà.Other timeline classes are provided to help you organize sets of timelines, and to apply timelines to properties. Le sequenze temporali dei contenitori derivano dalla classe TimelineGroup e includono ParallelTimeline e Storyboard.Container timelines derive from the TimelineGroup class, and include ParallelTimeline and Storyboard.

Un Storyboard è un tipo di sequenza temporale del contenitore che fornisce informazioni di destinazione per le sequenze temporali in essa contenute.A Storyboard is a type of container timeline that provides targeting information for the timelines it contains. Uno storyboard può contenere qualsiasi tipo di Timeline, incluse altre animazioni e sequenze temporali del contenitore.A Storyboard can contain any type of Timeline, including other container timelines and animations. gli oggetti Storyboard consentono di combinare sequenze temporali che interessano una varietà di oggetti e proprietà in un unico albero della sequenza temporale, semplificando l'organizzazione e il controllo dei comportamenti temporali complessi.Storyboard objects enable you to combine timelines that affect a variety of objects and properties into a single timeline tree, making it easy to organize and control complex timing behaviors. Si supponga, ad esempio, di volere un pulsante che esegua queste tre operazioni.For example, suppose you want a button that does these three things.

  • Aumentare le dimensioni e cambiare colore quando l'utente seleziona il pulsante.Grow and change color when the user selects the button.

  • Ridursi e tornare nuovamente alle dimensioni originali quando si fa clic su di esso.Shrink away and then grow back to its original size when clicked.

  • Comprimersi e perdere il 50% di opacità quando viene disabilitato.Shrink and fade to 50 percent opacity when it becomes disabled.

In questo caso, si dispone di più set di animazioni che vengono applicati allo stesso oggetto e si desiderano riprodurre in momenti diversi, a seconda dello stato del pulsante.In this case, you have multiple sets of animations that apply to the same object, and you want to play at different times, dependent on the state of the button. gli oggetti Storyboard consentono di organizzare le animazioni e applicarle in gruppi a uno o più oggetti.Storyboard objects enable you to organize animations and apply them in groups to one or more objects.

Dov'è possibile usare uno storyboard?Where Can You Use a Storyboard?

È possibile usare un Storyboard per animare le proprietà di dipendenza delle classi animata (per altre informazioni su ciò che rende una classe animata, vedere Cenni preliminari sull'animazione).A Storyboard can be used to animate dependency properties of animatable classes (for more information about what makes a class animatable, see the Animation Overview). Tuttavia, poiché lo storyboard è una funzionalità a livello di Framework, l'oggetto deve appartenere all'NameScope di un FrameworkElement o di un FrameworkContentElement.However, because storyboarding is a framework-level feature, the object must belong to the NameScope of a FrameworkElement or a FrameworkContentElement.

Ad esempio, è possibile usare un Storyboard per eseguire le operazioni seguenti:For example, you could use a Storyboard to do the following:

Non è tuttavia possibile usare un Storyboard per animare una SolidColorBrush che non ha registrato il nome con un FrameworkElement o FrameworkContentElementoppure non è stato usato per impostare una proprietà di un FrameworkElement o FrameworkContentElement.However, you could not use a Storyboard to animate a SolidColorBrush that did not register its name with a FrameworkElement or FrameworkContentElement, or was not used to set a property of a FrameworkElement or FrameworkContentElement.

Come applicare animazioni con uno storyboardHow to Apply Animations with a Storyboard

Per usare un Storyboard per organizzare e applicare animazioni, è necessario aggiungere le animazioni come sequenze temporali figlio della Storyboard.To use a Storyboard to organize and apply animations, you add the animations as child timelines of the Storyboard. La classe Storyboard fornisce le proprietà Storyboard.TargetName e Storyboard.TargetProperty associate.The Storyboard class provides the Storyboard.TargetName and Storyboard.TargetProperty attached properties. Impostare queste proprietà su un'animazione per specificare l'oggetto di destinazione e la proprietà relativi.You set these properties on an animation to specify its target object and property.

Per applicare animazioni alle relative destinazioni, iniziare il Storyboard usando un'azione trigger o un metodo.To apply animations to their targets, you begin the Storyboard using a trigger action or a method. In XAMLXAMLsi usa un oggetto BeginStoryboard con un EventTrigger, Triggero DataTrigger.In XAMLXAML, you use a BeginStoryboard object with an EventTrigger, Trigger, or DataTrigger. Nel codice è anche possibile usare il metodo Begin.In code, you can also use the Begin method.

La tabella seguente illustra le diverse posizioni in cui sono supportate le tecniche di Storyboard BEGIN: per istanza, stile, modello di controllo e modello di dati.The following table shows the different places where each Storyboard begin technique is supported: per-instance, style, control template, and data template. "Per istanza" si riferisce alla tecnica di applicazione di un'animazione o uno storyboard direttamente a istanze di un oggetto, piuttosto che in uno stile, un modello di controllo o un modello di dati."Per-Instance" refers to the technique of applying an animation or storyboard directly to instances of an object, rather than in a style, control template, or data template.

Storyboard iniziato usando…Storyboard is begun using… Per istanzaPer-instance StileStyle Modello di controlloControl template Modello di datiData template EsempioExample
BeginStoryboard e un EventTriggerBeginStoryboard and an EventTrigger Yes Yes Yes Yes Animare una proprietà utilizzando uno storyboardAnimate a Property by Using a Storyboard
BeginStoryboard e una proprietà TriggerBeginStoryboard and a property Trigger NoNo Yes Yes Yes Attivare un'animazione quando il valore di una proprietà viene modificatoTrigger an Animation When a Property Value Changes
BeginStoryboard e un DataTriggerBeginStoryboard and a DataTrigger NoNo Yes Yes Yes Procedura: Attivare un'animazione quando i dati vengono modificatiHow to: Trigger an Animation When Data Changes
Metodo BeginBegin method Yes NoNo NoNo NoNo Animare una proprietà utilizzando uno storyboardAnimate a Property by Using a Storyboard

Nell'esempio seguente viene utilizzato un Storyboard per animare la Width di un elemento Rectangle e la Color di un SolidColorBrush utilizzato per disegnare tale Rectangle.The following example uses a Storyboard to animate the Width of a Rectangle element and the Color of a SolidColorBrush used to paint that Rectangle.

<!-- This example shows how to animate with a storyboard.-->
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="Microsoft.Samples.Animation.StoryboardsExample" 
  WindowTitle="Storyboards Example">
  <StackPanel Margin="20">
    
    <Rectangle Name="MyRectangle"
      Width="100"
      Height="100">
      <Rectangle.Fill>
        <SolidColorBrush x:Name="MySolidColorBrush" Color="Blue" />
      </Rectangle.Fill>
      <Rectangle.Triggers>
        <EventTrigger RoutedEvent="Rectangle.MouseEnter">
          <BeginStoryboard>
            <Storyboard>
              <DoubleAnimation 
                Storyboard.TargetName="MyRectangle"
                Storyboard.TargetProperty="Width"
                From="100" To="200" Duration="0:0:1" />
              
              <ColorAnimation 
                Storyboard.TargetName="MySolidColorBrush"
                Storyboard.TargetProperty="Color"
                From="Blue" To="Red" Duration="0:0:1" />  
            </Storyboard>
          </BeginStoryboard>
        </EventTrigger>
      </Rectangle.Triggers>
    </Rectangle> 
  </StackPanel>
</Page>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Data;
using System.Windows.Shapes;
using System.Windows.Input;

namespace Microsoft.Samples.Animation
{
    public class StoryboardsExample : Page
    {      
        public StoryboardsExample()
        {
            this.WindowTitle = "Storyboards Example";
            StackPanel myStackPanel = new StackPanel();
            myStackPanel.Margin = new Thickness(20);

            Rectangle myRectangle = new Rectangle();
            myRectangle.Name = "MyRectangle";
            
            // Create a name scope for the page.
            NameScope.SetNameScope(this, new NameScope());            
            
            this.RegisterName(myRectangle.Name, myRectangle);
            myRectangle.Width = 100;
            myRectangle.Height = 100;
            SolidColorBrush mySolidColorBrush = new SolidColorBrush(Colors.Blue);
            this.RegisterName("MySolidColorBrush", mySolidColorBrush);
            myRectangle.Fill = mySolidColorBrush;
            
            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
            myDoubleAnimation.From = 100;
            myDoubleAnimation.To = 200;
            myDoubleAnimation.Duration = new Duration(TimeSpan.FromSeconds(1));
            Storyboard.SetTargetName(myDoubleAnimation, myRectangle.Name);
            Storyboard.SetTargetProperty(myDoubleAnimation, 
                new PropertyPath(Rectangle.WidthProperty));
            
            ColorAnimation myColorAnimation = new ColorAnimation();
            myColorAnimation.From = Colors.Blue;
            myColorAnimation.To = Colors.Red;
            myColorAnimation.Duration = new Duration(TimeSpan.FromSeconds(1));
            Storyboard.SetTargetName(myColorAnimation, "MySolidColorBrush");
            Storyboard.SetTargetProperty(myColorAnimation, 
                new PropertyPath(SolidColorBrush.ColorProperty)); 
            Storyboard myStoryboard = new Storyboard();
            myStoryboard.Children.Add(myDoubleAnimation);
            myStoryboard.Children.Add(myColorAnimation);

            myRectangle.MouseEnter += delegate(object sender, MouseEventArgs e)
            {
                myStoryboard.Begin(this);
            };
            
            myStackPanel.Children.Add(myRectangle);
            this.Content = myStackPanel;
        } 
    }
}

Le sezioni seguenti descrivono in modo più dettagliato il TargetName e TargetProperty proprietà associate.The following sections describe the TargetName and TargetProperty attached properties in more detail.

Elementi del framework, elementi di contenuto del framework e oggetti FreezableTargeting Framework Elements, Framework Content Elements, and Freezables

Nella sezione precedente è stato indicato che per trovare la relativa destinazione un'animazione deve conoscere il nome e la proprietà relativi cui aggiungere un'animazione.The previous section mentioned that, for an animation to find its target, it must know the target's name and the property to animate. La specifica della proprietà da animare è semplice: è sufficiente impostare Storyboard.TargetProperty con il nome della proprietà a cui aggiungere un'animazione.Specifying the property to animate is straight forward: simply set Storyboard.TargetProperty with the name of the property to animate. Specificare il nome dell'oggetto di cui si desidera animare la proprietà impostando la proprietà Storyboard.TargetName sull'animazione.You specify the name of the object whose property you want to animate by setting the Storyboard.TargetName property on the animation.

Affinché la proprietà TargetName funzioni, è necessario che l'oggetto di destinazione disponga di un nome.For the TargetName property to work, the targeted object must have a name. L'assegnazione di un nome a un FrameworkElement o FrameworkContentElement in XAMLXAML è diversa dall'assegnazione di un nome a un oggetto Freezable.Assigning a name to a FrameworkElement or a FrameworkContentElement in XAMLXAML is different than assigning a name to a Freezable object.

Gli elementi del Framework sono le classi che ereditano dalla classe FrameworkElement.Framework elements are those classes that inherit from the FrameworkElement class. Esempi di elementi del Framework sono Window, DockPanel, Buttone Rectangle.Examples of framework elements include Window, DockPanel, Button, and Rectangle. Praticamente tutte le finestre, i pannelli e i controlli sono elementi.Essentially all windows, panels, and controls are elements. Gli elementi di contenuto del Framework sono le classi che ereditano dalla classe FrameworkContentElement.Framework content elements are those classes that inherit from the FrameworkContentElement class. Esempi di elementi di contenuto del Framework includono FlowDocument e Paragraph.Examples of framework content elements include FlowDocument and Paragraph. Se non si sa se un tipo è un elemento del framework o un elemento di contenuto del framework, verificare la presenza di una proprietà Name.If you're not sure whether a type is a framework element or a framework content element, check to see whether it has a Name property. Se è presente, è probabile che sia un elemento del framework o un elemento di contenuto del framework.If it does, it's probably a framework element or a framework content element. Per esserne certi, verificare la sezione Gerarchia di ereditarietà della relativa pagina di tipo.To be sure, check the Inheritance Hierarchy section of its type page.

Per abilitare la destinazione di un elemento del Framework o di un elemento di contenuto del Framework in XAMLXAML, impostare la relativa proprietà Name.To enable the targeting of a framework element or a framework content element in XAMLXAML, you set its Name property. Nel codice è anche necessario usare il metodo RegisterName per registrare il nome dell'elemento con l'elemento per il quale è stata creata una NameScope.In code, you also need to use the RegisterName method to register the element's name with the element for which you've created a NameScope.

Nell'esempio seguente, tratto dall'esempio precedente, viene assegnato il nome MyRectangle un Rectangle, un tipo di FrameworkElement.The following example, taken from the preceding example, assigns the name MyRectangle a Rectangle, a type of FrameworkElement.

<Rectangle Name="MyRectangle"
  Width="100"
  Height="100">
Rectangle myRectangle = new Rectangle();
myRectangle.Name = "MyRectangle";

// Create a name scope for the page.
NameScope.SetNameScope(this, new NameScope());            

this.RegisterName(myRectangle.Name, myRectangle);

Dopo aver impostato un nome, è possibile aggiungere un'animazione a una proprietà di quell'elemento.After it has a name, you can animate a property of that element.

<DoubleAnimation 
  Storyboard.TargetName="MyRectangle"
  Storyboard.TargetProperty="Width"
  From="100" To="200" Duration="0:0:1" />
Storyboard.SetTargetName(myDoubleAnimation, myRectangle.Name);
Storyboard.SetTargetProperty(myDoubleAnimation, 
    new PropertyPath(Rectangle.WidthProperty));

Freezable tipi sono le classi che ereditano dalla classe Freezable.Freezable types are those classes that inherit from the Freezable class. Esempi di Freezable includono SolidColorBrush, RotateTransforme GradientStop.Examples of Freezable include SolidColorBrush, RotateTransform, and GradientStop.

Per abilitare la destinazione di un Freezable da un'animazione in XAMLXAML, usare la direttiva x:Name per assegnarle un nome.To enable the targeting of a Freezable by an animation in XAMLXAML, you use the x:Name Directive to assign it a name. Nel codice usare il metodo RegisterName per registrarne il nome con l'elemento per cui è stato creato un NameScope.In code, you use the RegisterName method to register its name with the element for which you've created a NameScope.

Nell'esempio seguente viene assegnato un nome a un oggetto Freezable.The following example assigns a name to a Freezable object.

<SolidColorBrush x:Name="MySolidColorBrush" Color="Blue" />
SolidColorBrush mySolidColorBrush = new SolidColorBrush(Colors.Blue);
this.RegisterName("MySolidColorBrush", mySolidColorBrush);

L'oggetto può essere quindi impostato come destinazione da un'animazione.The object can then be targeted by an animation.

<ColorAnimation 
  Storyboard.TargetName="MySolidColorBrush"
  Storyboard.TargetProperty="Color"
  From="Blue" To="Red" Duration="0:0:1" />  
Storyboard.SetTargetName(myColorAnimation, "MySolidColorBrush");
Storyboard.SetTargetProperty(myColorAnimation, 
    new PropertyPath(SolidColorBrush.ColorProperty)); 

Storyboard oggetti utilizzano gli ambiti dei nomi per risolvere la proprietà TargetName.Storyboard objects use name scopes to resolve the TargetName property. Per altre informazioni sugli ambiti dei nomi WPF, vedere NameScope XAML WPF.For more information about WPF name scopes, see WPF XAML Namescopes. Se la proprietà TargetName viene omessa, l'animazione è destinata all'elemento in cui è definita oppure, nel caso di stili, all'elemento con stile.If the TargetName property is omitted, the animation targets the element on which it is defined, or, in the case of styles, the styled element.

Talvolta non è possibile assegnare un nome a un oggetto Freezable.Sometimes a name can't be assigned to a Freezable object. Se, ad esempio, un Freezable viene dichiarato come risorsa o viene usato per impostare un valore di proprietà in uno stile, non è possibile assegnargli un nome.For example, if a Freezable is declared as a resource or used to set a property value in a style, it can't be given a name. Poiché non dispone di un nome, non è possibile impostarlo direttamente come destinazione, ma può essere impostato indirettamente.Because it doesn't have a name, it can't be targeted directly—but it can be targeted indirectly. Le sezioni seguenti descrivono come usare l'impostazione indiretta delle destinazioni.The following sections describe how to use indirect targeting.

Impostazione indiretta delle destinazioniIndirect Targeting

In alcuni casi un Freezable non può essere indirizzato direttamente da un'animazione, ad esempio quando la Freezable viene dichiarata come risorsa o utilizzata per impostare un valore della proprietà in uno stile.There are times a Freezable can't be targeted directly by an animation, such as when the Freezable is declared as a resource or used to set a property value in a style. In questi casi, anche se non è possibile indirizzarlo direttamente, è comunque possibile aggiungere un'animazione all'oggetto Freezable.In these cases, even though you can't target it directly, you can still animate the Freezable object. Anziché impostare la proprietà TargetName con il nome del Freezable, assegnargli il nome dell'elemento a cui appartiene il Freezable ".Instead of setting the TargetName property with the name of the Freezable, you give it the name of the element to which the Freezable "belongs." Ad esempio, un SolidColorBrush usato per impostare il Fill di un elemento Rectangle appartiene a tale rettangolo.For example, a SolidColorBrush used to set the Fill of a rectangle element belongs to that rectangle. Per animare il pennello, impostare l'TargetProperty dell'animazione con una catena di proprietà che inizia in corrispondenza della proprietà dell'elemento del Framework o dell'elemento di contenuto del Framework in cui è stato utilizzato il Freezable per impostare e terminare con la proprietà Freezable per l'animazione.To animate the brush, you would set the animation's TargetProperty with a chain of properties that starts at the property of the framework element or framework content element the Freezable was used to set and ends with the Freezable property to animate.

<ColorAnimation 
  Storyboard.TargetName="Rectangle01"
  Storyboard.TargetProperty="Fill.Color"
  From="Blue" To="AliceBlue" Duration="0:0:1" />
DependencyProperty[] propertyChain =
    new DependencyProperty[]
        {Rectangle.FillProperty, SolidColorBrush.ColorProperty};
string thePath = "(0).(1)";
PropertyPath myPropertyPath = new PropertyPath(thePath, propertyChain);
Storyboard.SetTargetProperty(myColorAnimation, myPropertyPath);

Si noti che, se il Freezable è bloccato, verrà creato un clone e tale clone verrà animato.Note that, if the Freezable is frozen, a clone will be made, and that clone will be animated. In tal caso, la proprietà HasAnimatedProperties dell'oggetto originale continuerà a restituire false, perché l'oggetto originale non è effettivamente animato.When this happens, the original object's HasAnimatedProperties property continues to return false, because the original object is not actually animated. Per ulteriori informazioni sulla clonazione, vedere Cenni preliminari sugli oggetti Freezable.For more information about cloning, see the Freezable Objects Overview.

Si noti inoltre che, quando si usa l'impostazione indiretta delle destinazioni di proprietà, è possibile impostare come destinazione oggetti che non esistono.Also note that, when using indirect property targeting, it's possible to target objects that don't exist. Si supponga, ad esempio, che il Background di un pulsante specifico sia stato impostato con una SolidColorBrush e tenti di animare il colore, quando in realtà è stato usato un LinearGradientBrush per impostare lo sfondo del pulsante.For example, you might assume that the Background of a particular button was set with a SolidColorBrush and try to animate its Color, when in fact a LinearGradientBrush was used to set the button's Background. In questi casi non viene generata alcuna eccezione. l'animazione non ha un effetto visibile perché LinearGradientBrush non reagisce alle modifiche apportate alla proprietà Color.In these cases, no exception is thrown; the animation fails to have a visible effect because LinearGradientBrush does not react to changes to the Color property.

Le sezioni seguenti descrivono la sintassi dell'impostazione indiretta delle destinazioni di proprietà in modo più dettagliato.The following sections describe indirect property targeting syntax in more detail.

Impostazione indiretta della destinazione di una proprietà di un oggetto Freezable in XAMLIndirectly Targeting a Property of a Freezable in XAML

Per fare riferimento a una proprietà di un oggetto Freezable in XAMLXAML, usare la sintassi seguente.To target a property of a freezable in XAMLXAML, use the following syntax.

ElementPropertyName . FreezablePropertyNameElementPropertyName . FreezablePropertyName

PercorsoWhere

  • ElementPropertyName è la proprietà dell'FrameworkElement cui viene utilizzata la Freezable per impostare eElementPropertyName is the property of the FrameworkElement which the Freezable is used to set, and

  • FreezablePropertyName è la proprietà dell'Freezable a cui aggiungere un'animazione.FreezablePropertyName is the property of the Freezable to animate.

Nel codice seguente viene illustrato come animare il Color di un SolidColorBrush utilizzato per impostare il Fill di un elemento Rectangle.The following code shows how to animate the Color of a SolidColorBrush used to set the Fill of a rectangle element.

<Rectangle
  Name="Rectangle01"
  Height="100"
  Width="100"
  Fill="{StaticResource MySolidColorBrushResource}">
  <Rectangle.Triggers>
    <EventTrigger RoutedEvent="Rectangle.MouseEnter">
      <BeginStoryboard>
        <Storyboard>
          <ColorAnimation 
            Storyboard.TargetName="Rectangle01"
            Storyboard.TargetProperty="Fill.Color"
            From="Blue" To="AliceBlue" Duration="0:0:1" />
        </Storyboard>
      </BeginStoryboard>
    </EventTrigger>
  </Rectangle.Triggers>
</Rectangle>

Talvolta è necessario impostare come destinazione un oggetto freezable contenuto in una raccolta o una matrice.Sometimes you need to target a freezable contained in a collection or array.

Per impostare come destinazione un oggetto freezable contenuto in una raccolta, usare la sintassi del tracciato seguente.To target a freezable contained in a collection, you use the following path syntax.

ElementPropertyName .Children[ CollectionIndex ]. FreezablePropertyNameElementPropertyName .Children[ CollectionIndex ]. FreezablePropertyName

Dove CollectionIndex è l'indice dell'oggetto nella matrice o nella raccolta.Where CollectionIndex is the index of the object in its array or collection.

Si supponga, ad esempio, che un rettangolo disponga di una risorsa TransformGroup applicata alla relativa proprietà RenderTransform e di voler animare una delle trasformazioni in essa contenute.For example, suppose that a rectangle has a TransformGroup resource applied to its RenderTransform property, and you want to animate one of the transforms it contains.

<TransformGroup x:Key="MyTransformGroupResource"
  x:Shared="False">
  <ScaleTransform />
  <RotateTransform />
</TransformGroup>

Nel codice seguente viene illustrato come animare la proprietà Angle del RotateTransform illustrato nell'esempio precedente.The following code shows how to animate the Angle property of the RotateTransform shown in the previous example.

<Rectangle
  Name="Rectangle02"
  Height="100"
  Width="100"
  Fill="Blue"
  RenderTransform="{StaticResource MyTransformGroupResource}">
  <Rectangle.Triggers>
    <EventTrigger RoutedEvent="Rectangle.MouseEnter">
      <BeginStoryboard>
        <Storyboard>
          <DoubleAnimation 
            Storyboard.TargetName="Rectangle02"
            Storyboard.TargetProperty="RenderTransform.Children[1].Angle"
            From="0" To="360" Duration="0:0:1" />
        </Storyboard>
      </BeginStoryboard>
    </EventTrigger>
  </Rectangle.Triggers>
</Rectangle>  

Impostazione indiretta della destinazione di una proprietà di un oggetto Freezable nel codiceIndirectly Targeting a Property of a Freezable in Code

Nel codice viene creato un oggetto PropertyPath.In code, you create a PropertyPath object. Quando si crea la PropertyPath, è necessario specificare una Path e PathParameters.When you create the PropertyPath, you specify a Path and PathParameters.

Per creare PathParameters, è necessario creare una matrice di tipo DependencyProperty contenente un elenco di campi dell'identificatore della proprietà di dipendenza.To create PathParameters, you create an array of type DependencyProperty that contains a list of dependency property identifier fields. Il primo campo identificatore è per la proprietà del FrameworkElement o FrameworkContentElement che viene utilizzato il Freezable per impostare.The first identifier field is for the property of the FrameworkElement or FrameworkContentElement that the Freezable is used to set. Il campo identificatore successivo rappresenta la proprietà del Freezable di destinazione.The next identifier field represents the property of the Freezable to target. Considerarlo come una catena di proprietà che connette la Freezable all'oggetto FrameworkElement.Think of it as a chain of properties that connects the Freezable to the FrameworkElement object.

Di seguito è riportato un esempio di una catena di proprietà di dipendenza destinata al Color di un SolidColorBrush utilizzato per impostare il Fill di un elemento Rectangle.The following is an example of a dependency property chain that targets the Color of a SolidColorBrush used to set the Fill of a rectangle element.

DependencyProperty[] propertyChain =
    new DependencyProperty[]
        {Rectangle.FillProperty, SolidColorBrush.ColorProperty};

È anche necessario specificare un Path.You also need to specify a Path. Un Path è un String che indica al Path come interpretare la PathParameters.A Path is a String that tells the Path how to interpret its PathParameters. Usa la sintassi seguente.It uses the following syntax.

( OwnerPropertyArrayIndex ).( FreezablePropertyArrayIndex )( OwnerPropertyArrayIndex ).( FreezablePropertyArrayIndex )

PercorsoWhere

  • OwnerPropertyArrayIndex è l'indice della matrice di DependencyProperty che contiene l'identificatore della proprietà dell'oggetto FrameworkElement usato per impostare il FreezableOwnerPropertyArrayIndex is the index of the DependencyProperty array that contains the identifier of the FrameworkElement object's property that the Freezable is used to set, and

  • FreezablePropertyArrayIndex è l'indice della matrice di DependencyProperty contenente l'identificatore della proprietà di destinazione.FreezablePropertyArrayIndex is the index of the DependencyProperty array that contains the identifier of property to target.

Nell'esempio seguente viene illustrata la Path che dovrebbe accompagnare il PathParameters definito nell'esempio precedente.The following example shows the Path that would accompany the PathParameters defined in the preceding example.

DependencyProperty[] propertyChain =
    new DependencyProperty[]
        {Rectangle.FillProperty, SolidColorBrush.ColorProperty};
string thePath = "(0).(1)";

Nell'esempio seguente viene combinato il codice degli esempi precedenti per animare il Color di un SolidColorBrush utilizzato per impostare il Fill di un elemento Rectangle.The following example combines the code in the previous examples to animate the Color of a SolidColorBrush used to set the Fill of a rectangle element.


// Create a name scope for the page.
NameScope.SetNameScope(this, new NameScope()); 

Rectangle rectangle01 = new Rectangle();
rectangle01.Name = "Rectangle01";   
this.RegisterName(rectangle01.Name, rectangle01);
rectangle01.Width = 100;
rectangle01.Height = 100;
rectangle01.Fill = 
    (SolidColorBrush)this.Resources["MySolidColorBrushResource"];

ColorAnimation myColorAnimation = new ColorAnimation();
myColorAnimation.From = Colors.Blue;
myColorAnimation.To = Colors.AliceBlue;
myColorAnimation.Duration = new Duration(TimeSpan.FromSeconds(1));
Storyboard.SetTargetName(myColorAnimation, rectangle01.Name);

DependencyProperty[] propertyChain =
    new DependencyProperty[]
        {Rectangle.FillProperty, SolidColorBrush.ColorProperty};
string thePath = "(0).(1)";
PropertyPath myPropertyPath = new PropertyPath(thePath, propertyChain);
Storyboard.SetTargetProperty(myColorAnimation, myPropertyPath);

Storyboard myStoryboard = new Storyboard();
myStoryboard.Children.Add(myColorAnimation);
BeginStoryboard myBeginStoryboard = new BeginStoryboard();
myBeginStoryboard.Storyboard = myStoryboard;
EventTrigger myMouseEnterTrigger = new EventTrigger();
myMouseEnterTrigger.RoutedEvent = Rectangle.MouseEnterEvent;
myMouseEnterTrigger.Actions.Add(myBeginStoryboard);
rectangle01.Triggers.Add(myMouseEnterTrigger);

Talvolta è necessario impostare come destinazione un oggetto freezable contenuto in una raccolta o una matrice.Sometimes you need to target a freezable contained in a collection or array. Si supponga, ad esempio, che un rettangolo disponga di una risorsa TransformGroup applicata alla relativa proprietà RenderTransform e di voler animare una delle trasformazioni in essa contenute.For example, suppose that a rectangle has a TransformGroup resource applied to its RenderTransform property, and you want to animate one of the transforms it contains.

<TransformGroup x:Key="MyTransformGroupResource"
  x:Shared="False">
  <ScaleTransform />
  <RotateTransform />
</TransformGroup>  

Per fare riferimento a un Freezable contenuto in una raccolta, usare la sintassi del percorso seguente.To target a Freezable contained in a collection, you use the following path syntax.

( OwnerPropertyArrayIndex ).( CollectionChildrenPropertyArrayIndex ) [ CollectionIndex ].( FreezablePropertyArrayIndex )( OwnerPropertyArrayIndex ).( CollectionChildrenPropertyArrayIndex ) [ CollectionIndex ].( FreezablePropertyArrayIndex )

Dove CollectionIndex è l'indice dell'oggetto nella matrice o nella raccolta.Where CollectionIndex is the index of the object in its array or collection.

Per specificare come destinazione la proprietà Angle della RotateTransform, la seconda trasformazione nel TransformGroup, è necessario utilizzare i Path e PathParametersseguenti.To target the Angle property of the RotateTransform, the second transform in the TransformGroup, you would use the following Path and PathParameters.

DependencyProperty[] propertyChain =
    new DependencyProperty[]
        {
            Rectangle.RenderTransformProperty, 
            TransformGroup.ChildrenProperty,
            RotateTransform.AngleProperty
        };
string thePath = "(0).(1)[1].(2)";
PropertyPath myPropertyPath = new PropertyPath(thePath, propertyChain);
Storyboard.SetTargetProperty(myDoubleAnimation, myPropertyPath);

Nell'esempio seguente viene illustrato il codice completo per l'animazione del Angle di un RotateTransform contenuto all'interno di un TransformGroup.The following example shows the complete code for animating the Angle of a RotateTransform contained within a TransformGroup.

Rectangle rectangle02 = new Rectangle();
rectangle02.Name = "Rectangle02";
this.RegisterName(rectangle02.Name, rectangle02);
rectangle02.Width = 100;
rectangle02.Height = 100;
rectangle02.Fill = Brushes.Blue;
rectangle02.RenderTransform = 
    (TransformGroup)this.Resources["MyTransformGroupResource"];

DoubleAnimation myDoubleAnimation = new DoubleAnimation();
myDoubleAnimation.From = 0;
myDoubleAnimation.To = 360;
myDoubleAnimation.Duration = new Duration(TimeSpan.FromSeconds(1));
Storyboard.SetTargetName(myDoubleAnimation, rectangle02.Name);

DependencyProperty[] propertyChain =
    new DependencyProperty[]
        {
            Rectangle.RenderTransformProperty, 
            TransformGroup.ChildrenProperty,
            RotateTransform.AngleProperty
        };
string thePath = "(0).(1)[1].(2)";
PropertyPath myPropertyPath = new PropertyPath(thePath, propertyChain);
Storyboard.SetTargetProperty(myDoubleAnimation, myPropertyPath);

Storyboard myStoryboard = new Storyboard();
myStoryboard.Children.Add(myDoubleAnimation);
BeginStoryboard myBeginStoryboard = new BeginStoryboard();
myBeginStoryboard.Storyboard = myStoryboard;
EventTrigger myMouseEnterTrigger = new EventTrigger();
myMouseEnterTrigger.RoutedEvent = Rectangle.MouseEnterEvent;
myMouseEnterTrigger.Actions.Add(myBeginStoryboard);
rectangle02.Triggers.Add(myMouseEnterTrigger);

Impostazione indiretta della destinazione con un oggetto Freezable come punto di partenzaIndirectly Targeting with a Freezable as the Starting Point

Nelle sezioni precedenti è stato descritto come indirizzare indirettamente una Freezable iniziando con una FrameworkElement o FrameworkContentElement e creando una catena di proprietà a una sottoproprietà Freezable.The previous sections described how to indirectly target a Freezable by starting with a FrameworkElement or FrameworkContentElement and creating a property chain to a Freezable sub-property. È anche possibile usare un Freezable come punto di partenza e indirizzare indirettamente una delle relative sottoproprietà Freezable.You can also use a Freezable as a starting point and indirectly target one of its Freezable sub-properties. Una restrizione aggiuntiva si applica quando si usa un Freezable come punto di partenza per la destinazione indiretta: la Freezable iniziale e ogni Freezable tra di essa e la sottoproprietà di destinazione indirettamente non devono essere bloccate.One additional restriction applies when using a Freezable as a starting point for indirect targeting: the starting Freezable and every Freezable between it and the indirectly targeted sub-property must not be frozen.

Controllo interattivo di uno storyboard in XAMLInteractively Controlling a Storyboard in XAML

Per avviare uno storyboard in Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML), è possibile utilizzare un'azione BeginStoryboard trigger.To start a storyboard in Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML), you use a BeginStoryboard trigger action. BeginStoryboard distribuisce le animazioni agli oggetti e alle proprietà a cui viene aggiunta un'animazione e avvia lo storyboard.BeginStoryboard distributes the animations to the objects and properties they animate, and starts the storyboard. Per informazioni dettagliate su questo processo, vedere Cenni preliminari sull'animazione e sul sistema di temporizzazione. Se si assegna al BeginStoryboard un nome specificando la relativa proprietà Name, lo si imposta come storyboard controllabile.(For details about this process, see the Animation and Timing System Overview.) If you give the BeginStoryboard a name by specifying its Name property, you make it a controllable storyboard. È quindi possibile controllare in modo interattivo lo storyboard dopo l'avvio.You can then interactively control the storyboard after it's started. Di seguito è riportato un elenco di azioni dello storyboard controllabili da usare con i trigger di evento per controllare uno storyboard.The following is a list of controllable storyboard actions that you use with event triggers to control a storyboard.

Nell'esempio seguente le azioni di storyboard controllabili vengono usate per controllare uno storyboard in modo interattivo.In the following example, controllable storyboard actions are used to interactively control a storyboard.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="Microsoft.SDK.Animation.ControllableStoryboardExample"
  WindowTitle="Fading Rectangle Example">
  <StackPanel Margin="10">

    <Rectangle
      Name="MyRectangle"
      Width="100" 
      Height="100"
      Fill="Blue">
    </Rectangle>

    <Button Name="BeginButton">Begin</Button>
    <Button Name="PauseButton">Pause</Button>
    <Button Name="ResumeButton">Resume</Button>
    <Button Name="SkipToFillButton">Skip To Fill</Button>
    <Button Name="StopButton">Stop</Button>

    <StackPanel.Triggers>
      <EventTrigger RoutedEvent="Button.Click" SourceName="BeginButton">
        <BeginStoryboard Name="MyBeginStoryboard">
          <Storyboard>
            <DoubleAnimation
              Storyboard.TargetName="MyRectangle" 
              Storyboard.TargetProperty="(Rectangle.Opacity)"
              From="1.0" To="0.0" Duration="0:0:5" />
          </Storyboard>
        </BeginStoryboard>
      </EventTrigger>
      <EventTrigger RoutedEvent="Button.Click" SourceName="PauseButton">
        <PauseStoryboard BeginStoryboardName="MyBeginStoryboard" />
      </EventTrigger>
      <EventTrigger RoutedEvent="Button.Click" SourceName="ResumeButton">
        <ResumeStoryboard BeginStoryboardName="MyBeginStoryboard" />
      </EventTrigger>
      <EventTrigger RoutedEvent="Button.Click" SourceName="SkipToFillButton">
        <SkipStoryboardToFill BeginStoryboardName="MyBeginStoryboard" />
      </EventTrigger>
      <EventTrigger RoutedEvent="Button.Click" SourceName="StopButton">
        <StopStoryboard BeginStoryboardName="MyBeginStoryboard" />
      </EventTrigger>
    </StackPanel.Triggers>
  </StackPanel>
</Page>

Controllo interattivo di uno storyboard tramite il codiceInteractively Controlling a Storyboard by Using Code

Gli esempi precedenti hanno illustrato come aggiungere animazioni tramite le azioni trigger.The previous examples have shown how to animate using trigger actions. Nel codice è anche possibile controllare uno storyboard usando metodi interattivi della classe Storyboard.In code, you may also control a storyboard using interactive methods of the Storyboard class. Affinché un Storyboard venga reso interattivo nel codice, è necessario utilizzare l'overload appropriato del metodo Begin dello storyboard e specificare true per renderlo controllabile.For a Storyboard to be made interactive in code, you must use the appropriate overload of the storyboard's Begin method and specify true to make it controllable. Per altre informazioni, vedere Begin(FrameworkElement, Boolean).See the Begin(FrameworkElement, Boolean) page for more information.

L'elenco seguente illustra i metodi che possono essere usati per modificare un Storyboard dopo l'avvio:The following list shows the methods that can be used to manipulate a Storyboard after it has started:

Il vantaggio dell'uso di questi metodi è che non è necessario creare oggetti Trigger o TriggerAction. è necessario solo un riferimento al Storyboard controllabile che si vuole modificare.The advantage to using these methods is that you don't need to create Trigger or TriggerAction objects; you just need a reference to the controllable Storyboard you want to manipulate.

Nota

Tutte le azioni interattive eseguite su un Clocke quindi anche su un Storyboard si verificheranno al successivo ciclo del motore di temporizzazione che verrà eseguito poco prima del rendering successivo.All interactive actions taken on a Clock, and therefore also on a Storyboard will occur on the next tick of the timing engine which will happen shortly before the next render. Se, ad esempio, si usa il metodo Seek per passare a un altro punto di un'animazione, il valore della proprietà non viene modificato immediatamente, ma il valore viene modificato al successivo ciclo del motore di temporizzazione.For example, if you use the Seek method to jump to another point in an animation, the property value does not change instantly, rather, the value changes on the next tick of the timing engine.

Nell'esempio seguente viene illustrato come applicare e controllare le animazioni utilizzando i metodi interattivi della classe Storyboard.The following example shows how to apply and control animations using the interactive methods of the Storyboard class.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Shapes;
using System.Windows.Media;
using System.Windows.Media.Animation;

namespace SDKSample
{

    public class ControllableStoryboardExample : Page
    {
        private Storyboard myStoryboard;

        public ControllableStoryboardExample()
        {

            // Create a name scope for the page.

            NameScope.SetNameScope(this, new NameScope()); 
 
            this.WindowTitle = "Controllable Storyboard Example";
            StackPanel myStackPanel = new StackPanel();
            myStackPanel.Margin = new Thickness(10);

            // Create a rectangle.
            Rectangle myRectangle = new Rectangle();
            myRectangle.Name = "myRectangle";

            // Assign the rectangle a name by 
            // registering it with the page, so that
            // it can be targeted by storyboard
            // animations.
            this.RegisterName(myRectangle.Name, myRectangle);
            myRectangle.Width = 100;
            myRectangle.Height = 100;
            myRectangle.Fill = Brushes.Blue;
            myStackPanel.Children.Add(myRectangle);

            //
            // Create an animation and a storyboard to animate the
            // rectangle.
            //
            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
            myDoubleAnimation.From = 1.0;
            myDoubleAnimation.To = 0.0;
            myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(5000));
            myDoubleAnimation.AutoReverse = true;

            // Create the storyboard.
            myStoryboard = new Storyboard();
            myStoryboard.Children.Add(myDoubleAnimation);
            Storyboard.SetTargetName(myDoubleAnimation, myRectangle.Name);
            Storyboard.SetTargetProperty(myDoubleAnimation, new PropertyPath(Rectangle.OpacityProperty));

            //
            // Create some buttons to control the storyboard
            // and a panel to contain them.
            //
            StackPanel buttonPanel = new StackPanel();
            buttonPanel.Orientation = Orientation.Horizontal;
            Button beginButton = new Button();
            beginButton.Content = "Begin";
            beginButton.Click += new RoutedEventHandler(beginButton_Clicked);
            buttonPanel.Children.Add(beginButton);
            Button pauseButton = new Button();
            pauseButton.Content = "Pause";
            pauseButton.Click += new RoutedEventHandler(pauseButton_Clicked);
            buttonPanel.Children.Add(pauseButton);
            Button resumeButton = new Button();
            resumeButton.Content = "Resume";
            resumeButton.Click += new RoutedEventHandler(resumeButton_Clicked);
            buttonPanel.Children.Add(resumeButton);
            Button skipToFillButton = new Button();
            skipToFillButton.Content = "Skip to Fill";
            skipToFillButton.Click += new RoutedEventHandler(skipToFillButton_Clicked);
            buttonPanel.Children.Add(skipToFillButton);
            Button setSpeedRatioButton = new Button();
            setSpeedRatioButton.Content = "Triple Speed";
            setSpeedRatioButton.Click += new RoutedEventHandler(setSpeedRatioButton_Clicked);
            buttonPanel.Children.Add(setSpeedRatioButton);
            Button stopButton = new Button();
            stopButton.Content = "Stop";
            stopButton.Click += new RoutedEventHandler(stopButton_Clicked);
            buttonPanel.Children.Add(stopButton);
            myStackPanel.Children.Add(buttonPanel);
            this.Content = myStackPanel;        
        }

        // Begins the storyboard.
        private void beginButton_Clicked(object sender, RoutedEventArgs args)
        {
            // Specifying "true" as the second Begin parameter
            // makes this storyboard controllable.
            myStoryboard.Begin(this, true);
        }

        // Pauses the storyboard.
        private void pauseButton_Clicked(object sender, RoutedEventArgs args)
        {
            myStoryboard.Pause(this);
        }

        // Resumes the storyboard.
        private void resumeButton_Clicked(object sender, RoutedEventArgs args)
        {
            myStoryboard.Resume(this);
        }

        // Advances the storyboard to its fill period.
        private void skipToFillButton_Clicked(object sender, RoutedEventArgs args)
        {
            myStoryboard.SkipToFill(this);
        }

        // Updates the storyboard's speed.
        private void setSpeedRatioButton_Clicked(object sender, RoutedEventArgs args)
        {
            // Makes the storyboard progress three times as fast as normal.
            myStoryboard.SetSpeedRatio(this, 3);
        }

        // Stops the storyboard.
        private void stopButton_Clicked(object sender, RoutedEventArgs args)
        {
            myStoryboard.Stop(this);
        }         
    }
}

Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Shapes
Imports System.Windows.Media
Imports System.Windows.Media.Animation

Namespace SDKSample

    Public Class ControllableStoryboardExample
        Inherits Page
        Private myStoryboard As Storyboard

        Public Sub New()

            ' Create a name scope for the page.

            NameScope.SetNameScope(Me, New NameScope())

            Me.WindowTitle = "Controllable Storyboard Example"
            Dim myStackPanel As New StackPanel()
            myStackPanel.Margin = New Thickness(10)

            ' Create a rectangle.
            Dim myRectangle As New Rectangle()
            myRectangle.Name = "myRectangle"

            ' Assign the rectangle a name by 
            ' registering it with the page, so that
            ' it can be targeted by storyboard
            ' animations.
            Me.RegisterName(myRectangle.Name, myRectangle)
            myRectangle.Width = 100
            myRectangle.Height = 100
            myRectangle.Fill = Brushes.Blue
            myStackPanel.Children.Add(myRectangle)

            '
            ' Create an animation and a storyboard to animate the
            ' rectangle.
            '
            Dim myDoubleAnimation As New DoubleAnimation()
            myDoubleAnimation.From = 1.0
            myDoubleAnimation.To = 0.0
            myDoubleAnimation.Duration = New Duration(TimeSpan.FromMilliseconds(5000))
            myDoubleAnimation.AutoReverse = True

            ' Create the storyboard.
            myStoryboard = New Storyboard()
            myStoryboard.Children.Add(myDoubleAnimation)
            Storyboard.SetTargetName(myDoubleAnimation, myRectangle.Name)
            Storyboard.SetTargetProperty(myDoubleAnimation, New PropertyPath(Rectangle.OpacityProperty))

            '
            ' Create some buttons to control the storyboard
            ' and a panel to contain them.
            '
            Dim buttonPanel As New StackPanel()
            buttonPanel.Orientation = Orientation.Horizontal
            Dim beginButton As New Button()
            beginButton.Content = "Begin"
            AddHandler beginButton.Click, AddressOf beginButton_Clicked
            buttonPanel.Children.Add(beginButton)
            Dim pauseButton As New Button()
            pauseButton.Content = "Pause"
            AddHandler pauseButton.Click, AddressOf pauseButton_Clicked
            buttonPanel.Children.Add(pauseButton)
            Dim resumeButton As New Button()
            resumeButton.Content = "Resume"
            AddHandler resumeButton.Click, AddressOf resumeButton_Clicked
            buttonPanel.Children.Add(resumeButton)
            Dim skipToFillButton As New Button()
            skipToFillButton.Content = "Skip to Fill"
            AddHandler skipToFillButton.Click, AddressOf skipToFillButton_Clicked
            buttonPanel.Children.Add(skipToFillButton)
            Dim setSpeedRatioButton As New Button()
            setSpeedRatioButton.Content = "Triple Speed"
            AddHandler setSpeedRatioButton.Click, AddressOf setSpeedRatioButton_Clicked
            buttonPanel.Children.Add(setSpeedRatioButton)
            Dim stopButton As New Button()
            stopButton.Content = "Stop"
            AddHandler stopButton.Click, AddressOf stopButton_Clicked
            buttonPanel.Children.Add(stopButton)
            myStackPanel.Children.Add(buttonPanel)
            Me.Content = myStackPanel


        End Sub

        ' Begins the storyboard.
        Private Sub beginButton_Clicked(ByVal sender As Object, ByVal args As RoutedEventArgs)
            ' Specifying "true" as the second Begin parameter
            ' makes this storyboard controllable.
            myStoryboard.Begin(Me, True)

        End Sub

        ' Pauses the storyboard.
        Private Sub pauseButton_Clicked(ByVal sender As Object, ByVal args As RoutedEventArgs)
            myStoryboard.Pause(Me)

        End Sub

        ' Resumes the storyboard.
        Private Sub resumeButton_Clicked(ByVal sender As Object, ByVal args As RoutedEventArgs)
            myStoryboard.Resume(Me)

        End Sub

        ' Advances the storyboard to its fill period.
        Private Sub skipToFillButton_Clicked(ByVal sender As Object, ByVal args As RoutedEventArgs)
            myStoryboard.SkipToFill(Me)

        End Sub

        ' Updates the storyboard's speed.
        Private Sub setSpeedRatioButton_Clicked(ByVal sender As Object, ByVal args As RoutedEventArgs)
            ' Makes the storyboard progress three times as fast as normal.
            myStoryboard.SetSpeedRatio(Me, 3)

        End Sub

        ' Stops the storyboard.
        Private Sub stopButton_Clicked(ByVal sender As Object, ByVal args As RoutedEventArgs)
            myStoryboard.Stop(Me)

        End Sub

    End Class

End Namespace

Aggiungere un'animazione in uno stileAnimate in a Style

È possibile usare oggetti Storyboard per definire animazioni in un Style.You can use Storyboard objects to define animations in a Style. L'animazione con un Storyboard in una Style è simile all'uso di un Storyboard altrove, con le tre eccezioni seguenti:Animating with a Storyboard in a Style is similar to using a Storyboard elsewhere, with the following three exceptions:

  • Non si specifica un TargetName; il Storyboard ha sempre come destinazione l'elemento a cui viene applicata la Style.You don't specify a TargetName; the Storyboard always targets the element to which the Style is applied. Per Freezable gli oggetti di destinazione, è necessario usare la destinazione indiretta.To target Freezable objects, you must use indirect targeting. Per ulteriori informazioni sulla destinazione indiretta, vedere la sezione destinazione indiretta .For more information about indirect targeting, see the Indirect Targeting section.

  • Non è possibile specificare un SourceName per un EventTrigger o un Trigger.You can't specify a SourceName for an EventTrigger or a Trigger.

  • Non è possibile usare riferimenti a risorse dinamiche o espressioni di data binding per impostare i valori delle proprietà Storyboard o Animation.You can't use dynamic resource references or data binding expressions to set Storyboard or animation property values. Questo perché tutti gli elementi all'interno di un Style devono essere thread-safe e il sistema di temporizzazione deve FreezeStoryboard oggetti per renderli thread-safe.That's because everything inside a Style must be thread-safe, and the timing system must FreezeStoryboard objects to make them thread-safe. Non è possibile bloccare un Storyboard se la sequenza temporale figlio contiene riferimenti A risorse dinamiche o espressioni di data binding.A Storyboard cannot be frozen if it or its child timelines contain dynamic resource references or data binding expressions. Per ulteriori informazioni sul blocco e altre funzionalità di Freezable, vedere Cenni preliminari sugli oggetti Freezable.For more information about freezing and other Freezable features, see the Freezable Objects Overview.

  • In XAMLXAMLnon è possibile dichiarare gestori eventi per Storyboard o eventi di animazione.In XAMLXAML, you can't declare event handlers for Storyboard or animation events.

Per un esempio che illustra come definire uno storyboard in uno stile, vedere l'esempio animate in uno stile .For an example showing how to define a storyboard in a style, see the Animate in a Style example.

Eseguire un'animazione in un ControlTemplateAnimate in a ControlTemplate

È possibile usare oggetti Storyboard per definire animazioni in un ControlTemplate.You can use Storyboard objects to define animations in a ControlTemplate. L'animazione con un Storyboard in una ControlTemplate è simile all'uso di un Storyboard altrove, con le due eccezioni seguenti:Animating with a Storyboard in a ControlTemplate is similar to using a Storyboard elsewhere, with the following two exceptions:

Per un esempio che illustra come definire uno storyboard in una ControlTemplate, vedere l'esempio di animazione in un oggetto ControlTemplate .For an example showing how to define a storyboard in a ControlTemplate, see the Animate in a ControlTemplate example.

Aggiungere un'animazione quando viene modificato il valore di una proprietàAnimate When a Property Value Changes

Negli stili e nei modelli di controllo è possibile usare oggetti Trigger per avviare uno storyboard quando una proprietà viene modificata.In styles and control templates, you can use Trigger objects to start a storyboard when a property changes. Per esempi, vedere attivare un'animazione quando il valore di una proprietà viene modificato e animato in un oggetto ControlTemplate.For examples, see Trigger an Animation When a Property Value Changes and Animate in a ControlTemplate.

Le animazioni applicate dagli oggetti di proprietà Trigger si comportano in modo più complesso rispetto a EventTrigger animazioni o animazioni avviate con Storyboard metodi.Animations applied by property Trigger objects behave in a more complex fashion than EventTrigger animations or animations started using Storyboard methods. Le "consegne" con animazioni definite da altri oggetti Trigger, ma compongono con EventTrigger e animazioni attivate dal metodo.They "handoff" with animations defined by other Trigger objects, but compose with EventTrigger and method-triggered animations.

Vedere ancheSee also