FrameworkElement.Loaded Evento

// Register
event_token Loaded(RoutedEventHandler const& handler) const;

// Revoke with event_token
void Loaded(event_token const* cookie) const;

// Revoke with event_revoker
FrameworkElement::Loaded_revoker Loaded(auto_revoke_t, RoutedEventHandler const& handler) const;

public event RoutedEventHandler Loaded;

function onLoaded(eventArgs) { /* Your code */ }
frameworkElement.addEventListener("loaded", onLoaded);
frameworkElement.removeEventListener("loaded", onLoaded);
- or -
frameworkElement.onloaded = onLoaded;

Public Custom Event Loaded As RoutedEventHandler 

<frameworkElement Loaded="eventhandler"/>
 

Tipo de evento

Exemplos

Manipuladores para Carregado e Descarregado são anexados automaticamente a qualquer página que use a classe NavigationHelper dos modelos de projeto para suporte. A fiação do evento é feita no construtor. O manipulador é escrito usando um lambda e anexa outros manipuladores de eventos para que a navegação de página possa usar eventos de mouse ou teclado.

this.Page.Loaded += (sender, e) =>
{
// Keyboard and mouse navigation only apply when occupying the entire window
if (this.Page.ActualHeight == Window.Current.Bounds.Height &&
    this.Page.ActualWidth == Window.Current.Bounds.Width)
    {
        // Listen to the window directly so focus isn't required
        Window.Current.CoreWindow.Dispatcher.AcceleratorKeyActivated +=
            CoreDispatcher_AcceleratorKeyActivated;
            Window.Current.CoreWindow.PointerPressed +=
            this.CoreWindow_PointerPressed;
    }
};

O evento Loaded é um bom momento para iniciar animações decorativas que não estão vinculadas a animações de tema ou outros gatilhos. Este exemplo mostra como disparar um PointAnimation em XAML, conectando um manipulador Loaded a um método que chama Begin em um Storyboard de animação.

<Canvas Width="450" Height="350">
    <Canvas.Resources>
        <Storyboard x:Name="myStoryboard">

            <!-- Animate the center point of the ellipse from 100 X, 300 Y
             to 400 X, 100 Y over 5 seconds. -->
            <PointAnimation
             Storyboard.TargetProperty="Center"
             Storyboard.TargetName="MyAnimatedEllipseGeometry"
             Duration="0:0:5" 
             From="100,300"
             To="400,100"
             RepeatBehavior="Forever" EnableDependentAnimation="True"/>

        </Storyboard>
    </Canvas.Resources>
    <Path Fill="Blue" Loaded="Start_Animation">
        <Path.Data>

            <!-- Describes an ellipse. -->
            <EllipseGeometry x:Name="MyAnimatedEllipseGeometry"
             Center="200,100" RadiusX="15" RadiusY="15" />
        </Path.Data>
    </Path>
</Canvas>

// Start the animation when the object loads
void SampleApp::Page::Start_Animation(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    myStoryboard->Begin();
}

// Start the animation when the object loads
private void Start_Animation(object sender, RoutedEventArgs e)
{
    myStoryboard.Begin();
}

' Start the animation when the object loads
Private Sub Start_Animation(ByVal sender As Object, ByVal e As EventArgs)
    myStoryboard.Begin()
End Sub

Comentários

Embora esse evento use o delegado RoutedEventHandler e RoutedEventArgs como dados de evento, o evento não é um evento roteado. Ele só pode ser manipulado no elemento que origina o evento (em outras palavras, o remetente). OriginalSource nos dados de evento para esse evento é sempre nulo.

Tempo de vida carregado e objeto

Na implementação do Windows Runtime, é garantido que o evento Loaded ocorra depois que um modelo de controle é aplicado e você pode obter referências a objetos criados aplicando o modelo XAML.

O evento Loaded pode ser usado como um ponto para conectar manipuladores de eventos em elementos provenientes de um modelo ou para invocar a lógica que depende da existência de elementos filho que são o resultado de um modelo aplicado. Carregado é o evento de tempo de vida do objeto preferencial para manipular estruturas de árvore de elementos com o código do aplicativo antes da exibição de controles XAML para sua interface do usuário. Também é apropriado chamar o método VisualStateManager.GoToState de um manipulador Loaded para definir um estado de exibição inicial definido no modelo, se não houver nenhum outro evento que também ocorra no layout inicial (SizeChanged ocorre no layout inicial).

O intervalo de Loaded na implementação de Windows Runtime é semelhante ao tempo na implementação do WPF (Windows Presentation Foundation). Por outro lado, a implementação do Microsoft Silverlight tem um problema de tempo em que você não pode confiar no modelo que está sendo carregado quando Carregado. Se você estiver migrando XAML ou code-behind dessas estruturas XAML, convém ajustar o que você faz em um manipulador Loaded para ser apropriado para o tempo de carregamento de modelo da implementação do Windows Runtime.

Para acessar os itens provenientes de um modelo aplicado, você pode usar os métodos estáticos VisualTreeHelper e navegar pelos elementos filho por índice. Ou você pode chamar o método FindName no elemento raiz do conteúdo modelo para encontrar uma parte específica do modelo com um determinado valor de atributo x:Name . Observe que você deve chamar FindName na raiz do modelo em vez do controle em si, porque há um namescope XAML criado sempre que os objetos são criados por um modelo específico para esse modelo (para obter mais informações, consulte Namescopes XAML). Para acessar a raiz do modelo, use VisualTreeHelper.GetChild(target,0) onde target é o objeto em que o modelo é aplicado. Depois de obter essa raiz, você poderá acessar as partes nomeadas depois disso.

Se você estiver derivando de um controle existente, em vez de manipular Loaded por instância, poderá substituir OnApplyTemplate para tornar o comportamento parte do comportamento da classe padrão. OnApplyTemplate destina-se especificamente como o retorno de chamada para essa situação, em que você tem uma árvore de objetos do modelo aplicado e agora deseja examinar ou ajustar os visuais. Essa é uma parte fundamental da definição de comportamento para um controle personalizado, incluindo ações como declarar os estados visuais iniciais e manipuladores de classe de fiação que não podem ser definidos usando o padrão de substituição OnEvent . Uma diferença é que, no escopo OnApplyTemplate , você deve usar GetTemplateChild para localizar partes nomeadas em vez de FindName.

LayoutUpdated é um evento relacionado. O evento LayoutUpdated é o último evento de "tempo de vida do objeto" na sequência de habilitação de um controle e ocorre após Loaded. No entanto, LayoutUpdated é acionado para objetos envolvidos em uma alteração de layout, não apenas pais sucessivos na árvore. Vários objetos em uma interface do usuário podem disparar LayoutUpdated ao mesmo tempo. As alterações de layout ocorrem por vários motivos, como o usuário alterando o estado de exibição ou a resolução da tela ou o redimensionamento programático de outros elementos na mesma interface do usuário ou contêiner de layout. Por esse motivo, Loaded geralmente é uma opção melhor para executar o código que funciona com um layout inicial ou um modelo aplicado.

Para o código do aplicativo que usa a navegação entre páginas, não use Page.OnNavigatedTo para manipulação de elementos ou alteração de estado de controles na página de destino. O método virtual OnNavigatedTo é invocado antes que o modelo seja carregado, portanto, os elementos dos modelos ainda não estão disponíveis. Em vez disso, anexe um manipulador de eventos Loaded na raiz do conteúdo da página recém-carregada e execute quaisquer manipulações de elemento, alterações de estado, fiação de evento e assim por diante no manipulador de eventos Loaded.

Aplica-se a

Confira também

• OnApplyTemplate()
• VisualTreeHelper
• Template
• Visão geral de eventos e eventos roteados
• Início Rápido: modelos de controle