Obsługa działania poza przeglądarką, cz. II

Artykuł
05/13/2010

Jak to zrobić: konfigurowanie aplikacji w sposób umożliwiający działanie poza przeglądarką

Program Visual Studio zapewnia obsługę projektantów umożliwiających działanie aplikacji programu Silverlight poza przeglądarką. W niniejszym dokumencie opisano obsługę projektantów oraz podstawy konfiguracji działania poza przeglądarką.

Uwaga:

Jeśli aplikacja działająca poza przeglądarką wymaga zasobów sieciowych wczytywanych zazwyczaj po uruchomieniu, konieczne będzie również wdrożenie obsługi trybu offline.

Aby skonfigurować obsługę działania poza przeglądarką:

W Eksploratorze rozwiązań zaznacz projekt programu Silverlight, w którym chcesz włączyć obsługę działania poza przeglądarką.
W menu Project (projekt) wybierz polecenie <nazwa projektu> Properties (właściwości).
Na karcie Silverlight wybierz pozycję Enable running application out of the browser (włącz uruchamianie aplikacji poza przeglądarką).
Kliknij pozycję Out-of-Browser Settings (ustawienia działania poza przeglądarką).
Spowoduje to wyświetlenie okna dialogowego Out-of-Browser Settings.
Określ wartości odpowiednich pól i kliknij przycisk OK. Wszystkie pola oprócz poniższych są opcjonalne:

Window Title (nazwa okna)
Shortcut name (nazwa skrótu)
Application description (opis aplikacji)

W poniższej tabeli ukazano miejsce wykorzystania poszczególnych wartości oraz odpowiednie właściwości klasy OutOfBrowserSettings (j.ang.) lub WindowSettings (j.ang.).

Pole	Opis	Właściwość
Window Title (nazwa okna)	Widoczna w pasku tytułu okna aplikacji działającej poza przeglądarką.	Title (j.ang.)
Width and Height (szerokość i wysokość)	Określa początkowe wymiary okna aplikacji działającej poza przeglądarką.	Width (j.ang.) i Height (j.ang.)
Set window location manually (określ lokalizację okna ręcznie)	Określa, czy początkowa pozycja okna aplikacji działającej poza przeglądarką będzie wyśrodkowana, czy też zgodna z określonymi wartościami Top i Left.	WindowStartupLocation (j.ang.)
Top and Left (góra i lewa strona)	Określa początkową lokalizację okna aplikacji działającej poza przeglądarką. Te pola są wyłączone, jeśli nie zostanie zaznaczona opcja Set window location manually (określ lokalizację okna ręcznie).	Top (j.ang.) i Left (j.ang.)
Shortcut name (nazwa skrótu)	Widoczna w oknie instalacyjnym poza przeglądarką i w skrócie lub skrótach zainstalowanej aplikacji.	ShortName (j.ang.)
Application description (opis aplikacji)	Widoczny jako etykietka narzędzia w skrótach do zainstalowanej aplikacji.	Blurb (j.ang.)
Icon fields (pola ikon)	System operacyjny wybiera odpowiednią ikonę do wyświetlania w następujących lokalizacjach: · Okno dialogowe instalacji. · Okno aplikacji. · Eksplorator Windows. · Pasek zadań systemu Windows. · Pasek dokowania na komputerach Macintosh.	Icons (j.ang.)
Use GPU Acceleration (używaj akceleracji GPU)	Określa, czy wydajność graficzna jest zwiększana dzięki zastosowaniu akceleracji sprzętowej.	EnableGPUAcceleration (j.ang.)
Show install menu (pokaż menu instalacyjne)	Określa, czy w menu aplikacji dostępnym po kliknięciu prawym przyciskiem myszy będzie dostępna opcja instalacji.	ShowInstallMenuItem (j.ang.)
Require elevated trust when running outside the browser (wymagaj podniesionych uprawnień podczas działania poza przeglądarką)	Określa poziom bezpieczeństwa, z jakim działa aplikacja.	SecuritySettings (j.ang.)
Window Style (styl okna)	Określa wygląd paska tytułu i obramowania okna aplikacji działającej poza przeglądarką.	WindowStyle (j.ang.)

Jeśli wartości Width i Height nie zostaną określone, w oknie aplikacji będzie używana domyślna wielkość 800x600 pikseli.

Jeśli nie zostaną określone ikony, będą używane ikony domyślne. W razie określenia ikon, należy podać po jednej ikonie dla każdej wielkości wskazanej w projektancie (16x16, 32x32, 48x48 i 128x128 pikseli).

Ikony muszą być plikami png dodanymi do projektu. Ich właściwość Action musi mieć wartość Content. Ponadto pliki png muszą mieć odpowiednie wymiary. System operacyjny będzie wybierał odpowiednią wielkość do użycia w różnych sytuacjach. Jeśli nie uda się wczytać odpowiedniej ikony, zostanie użyta ikona domyślna.

Uwaga:

Program Silverlight 3 nie obsługuje następujących właściwości:

Przykład

Wartości w oknie dialogowym Out-of-Browser Settings służą do wygenerowania pliku OutOfBrowserSettings.xml, zlokalizowanego w folderze Properties danego projektu (folder My Project w programie Visual Basic). Wszelkie zmiany w pliku są odzwierciedlane w projektancie. Plik ten służy do wypełnienia manifestu aplikacji (AppManifest.xaml) odpowiednim wartościami.

W celu skonfigurowania istniejącej aplikacji w sposób umożliwiający działanie poza przeglądarką bez potrzeby ponownego kompilowania należy dodać kod XML konfiguracji do istniejącego pliku xap. Należy skopiować właściwość Deployment..::.OutOfBrowserSettings (j.ang.) z poniższego przykładowego kodu do pliku manifestu, a następnie zaktualizować wartości.

Alternatywą do używania projektanta jest wypełnienie szablonu manifestu ustawieniami działania poza przeglądarką (plik AppManifest.xml w folderze Properties lub My Project) zgodnie z tym, co widać w poniższym przykładzie. Domyślnie szablon manifestu jest używany do wygenerowania manifestu aplikacji. Jednak w programie Visual Studio używanie kodu XML szablonu jest prostsze.

Uwaga:

W razie korzystania z okna dialogowego Out-of-Browser Settings nie można określić ustawień działania poza przeglądarką w manifeście aplikacji lub w szablonie manifestu. Próba wykonania takiego działania spowoduje zdublowanie informacji w manifeście. Powoduje to błąd podczas próby uruchomienia aplikacji.

<Deployment xmlns="https://schemas.microsoft.com/client/2007/deployment"
        xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
>
    <Deployment.Parts>
    </Deployment.Parts>
    <Deployment.OutOfBrowserSettings>
        <OutOfBrowserSettings 
            ShortName="Aplikacja działająca poza przeglądarką" 
            EnableGPUAcceleration="True"
            ShowInstallMenuItem="True">
            <OutOfBrowserSettings.Blurb>
                Ilustruje funkcjonalność działania poza przeglądarką.
            </OutOfBrowserSettings.Blurb>
            <OutOfBrowserSettings.Icons>
                <Icon Size="16,16">icons/16x16.png</Icon>
                <Icon Size="32,32">icons/32x32.png</Icon>
                <Icon Size="48,48">icons/48x48.png</Icon>
                <Icon Size="128,128">icons/128x128.png</Icon>
            </OutOfBrowserSettings.Icons>
            <OutOfBrowserSettings.WindowSettings>
                <WindowSettings 
                    Title="Przykładowa aplikacja działająca poza przeglądarką"
                    Height="600" Width="600" 
                    Left="0" Top="0" WindowStartupLocation="Manual"
                    WindowStyle="SingleBorderWindow"/>
            </OutOfBrowserSettings.WindowSettings>
            <OutOfBrowserSettings.SecuritySettings>
                <SecuritySettings ElevatedPermissions="Required" />
            </OutOfBrowserSettings.SecuritySettings>
        </OutOfBrowserSettings>
    </Deployment.OutOfBrowserSettings>
</Deployment>

Jak to zrobić: wdrażanie obsługi trybu offline w aplikacjach działających poza przeglądarką

W niniejszym dokumencie opisano sposób realizacji następujących często spotykanych scenariuszy związanych z aplikacjami programu Silverlight działającymi poza przeglądarką:

Określanie, czy aplikacja została zainstalowana lub czy jest uruchomiona poza przeglądarką. Umożliwia to np. wyświetlanie oznakowania marki, wyświetlanego zazwyczaj przy użyciu kodu HTML. W przykładzie podanym w niniejszym dokumencie informacje te zostają użyte do ukrycia przycisku instalacji lub wyświetlenia wskaźnika stanu sieci.
Określanie, czy dostępne jest połączenie sieciowe. Umożliwia to wyłączenie funkcjonalności zależnej od sieci lub ustawienie rozwiązań alternatywnych do zasobów sieciowych lub dostępnych przez przeglądarkę. W przykładzie podanym w niniejszym dokumencie informacje te zostają użyte do zaktualizowania wskaźnika połączenia sieciowego oraz do wyświetlenia lub ukrycia przycisku aktualizacji.
Określanie, czy dostępne są aktualizacje aplikacji. Jeśli dostępne jest połączenie, można pobrać nowe wersje aplikacji (o ile są takie dostępne) i wyświetlić monit o ponowne uruchomienie. W przykładzie podanym w niniejszym dokumencie przedstawiono podstawowe zastosowanie tej funkcjonalności.

Można dowolnie zmieniać wygląd i sposób działania aplikacji, która działa poza przeglądarką. Jednak w większości wypadków należy ograniczyć zmiany do minimum. Zapobiegnie to konieczności poznawania przez użytkowników nowego interfejsu. Jeśli aplikacja używa zasobów sieciowych należy jednak zawsze wyświetlić informację o stanie połączenia w interfejsie użytkownika.

W podanym przykładzie w kodzie XAML określony jest interfejs użytkownika wyświetlający informację o stanie połączenia sieciowego, przycisk instalacji, przycisk aktualizacji i kilka formantów TextBlock. Formanty te są powiązane z konfiguracją działania poza przeglądarką. Odpowiednie ustawienia są widoczne w kodzie XML na końcu niniejszego dokumentu. Można skopiować te ustawienia do okna dialogowego Out-of-Browser Settings (ustawienia działania poza przeglądarką) w programie Visual Studio. Można też włączyć obsługę działania poza przeglądarką w programie Visual Studio, a następnie skopiować kod XML do pliku OutOfBrowserSettings.xml projektu.

Odpowiedni kod określa wartość właściwości DataContext (j.ang.) używaną przez wiązania i obsługuje różne zdarzenia niezbędne do zaktualizowania interfejsu użytkownika.

Uruchamiając ten przykładowy kod, kliknij przycisk instalacji lub zainstaluj, używając odpowiedniego polecenia w menu dostępnym po kliknięciu prawym przyciskiem myszy. Po instalacji przycisk instalacji znika. W celu odinstalowania można kliknąć prawym przyciskiem myszy aplikację działającą poza przeglądarką lub aplikację internetową. Jednak przycisk instalacji zostanie wyświetlony ponownie jedynie po odinstalowaniu przy użyciu aplikacji internetowej. Jest to spowodowane tym, że aplikacja działająca poza przeglądarką nie jest już w żaden sposób połączona z wersją internetową. W razie odinstalowania przy użyciu aplikacji działającej poza przeglądarką przycisk instalacji zostanie wyświetlony ponownie dopiero po odświeżeniu strony internetowej.

Można przetestować wskaźnik połączenia sieciowego w aplikacji działającej poza przeglądarką, odłączając sieć, a następnie podłączając ją ponownie. Warto zauważyć, że kiedy połączenie jest niedostępne, przycisk aktualizacji znika.

Aby przetestować przycisk aktualizacji, należy dołączyć do rozwiązania Silverlight projekt aplikacji internetowej. Po zainstalowaniu aplikacji należy zmodyfikować i ponownie skompilować rozwiązanie w programie Visual Studio, a następnie kliknąć przycisk w celu pobrania aktualizacji.

Uruchom ten przykładowy kod

Przykład

XAML

<UserControl x:Class="OutOfBrowser.MainPage"
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" 
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml">
  <StackPanel x:Name="LayoutRoot" Background="White" Margin="20">

    <TextBlock x:Name="networkIndicator" FontWeight="Bold" FontSize="20"/>

    <Button x:Name="installButton" Content="instaluj" 
      HorizontalAlignment="Left" Margin="0,10" Padding="10,5" 
      Click="installButton_Click"/>
    <Button x:Name="updateButton" Content="sprawdź aktualizację"
      HorizontalAlignment="Left" Margin="0,10" Padding="10,5"  
      Click="updateButton_Click"/>

    <StackPanel Orientation="Horizontal">
      <TextBlock Text="ShortName = " FontWeight="Bold"/>
      <TextBlock Text="{Binding ShortName}"/>
    </StackPanel>

    <StackPanel Orientation="Horizontal">
      <TextBlock Text="Blurb = " FontWeight="Bold"/>
      <TextBlock Text="{Binding Blurb}"/>
    </StackPanel>

    <StackPanel Orientation="Horizontal">
      <TextBlock Text="WindowSettings.Title = " FontWeight="Bold"/>
      <TextBlock Text="{Binding WindowSettings.Title}"/>
    </StackPanel>

    <StackPanel Orientation="Horizontal">
      <TextBlock Text="WindowSettings.Height = " FontWeight="Bold"/>
      <TextBlock Text="{Binding WindowSettings.Height}"/>
    </StackPanel>

    <StackPanel Orientation="Horizontal">
      <TextBlock Text="WindowSettings.Width = " FontWeight="Bold"/>
      <TextBlock Text="{Binding WindowSettings.Width}"/>
    </StackPanel>

    <StackPanel Orientation="Horizontal">
        <TextBlock Text="IsRunningOutOfBrowser = " FontWeight="Bold"/>
        <TextBlock x:Name="isRunningOutOfBrowserTextBlock"/>
    </StackPanel>

    <StackPanel Orientation="Horizontal">
        <TextBlock Text="InstallState = " FontWeight="Bold"/>
        <TextBlock x:Name="installStateTextBlock"/>
    </StackPanel>

  </StackPanel>
</UserControl>

Visual Basic

Imports System
Imports System.Net.NetworkInformation
Imports System.Windows
Imports System.Windows.Controls

Partial Public Class MainPage
    Inherits UserControl

    Private WithEvents app As Application = Application.Current

    Public Sub New()

        InitializeComponent()
        LayoutRoot.DataContext = Deployment.Current.OutOfBrowserSettings
        UpdateUI()

        AddHandler NetworkChange.NetworkAddressChanged, _
            AddressOf UpdateNetworkIndicator

    End Sub

    Private Sub App_InstallStateChanged(ByVal sender As Object, _
        ByVal e As EventArgs) Handles app.InstallStateChanged

        UpdateUI()

    End Sub

    Private Sub UpdateUI()

        UpdateNetworkIndicator()

        If app.InstallState = InstallState.NotInstalled Then
            installButton.Visibility = Visibility.Visible
        Else
            installButton.Visibility = Visibility.Collapsed
        End If

        If app.IsRunningOutOfBrowser Then
            updateButton.Visibility = Visibility.Visible
        Else
            updateButton.Visibility = Visibility.Collapsed
        End If

        isRunningOutOfBrowserTextBlock.Text = _
            app.IsRunningOutOfBrowser.ToString()

        installStateTextBlock.Text = app.InstallState.ToString()

    End Sub

    Private Sub UpdateNetworkIndicator()

        If app.IsRunningOutOfBrowser Then
            networkIndicator.Visibility = Visibility.Visible
        Else
            networkIndicator.Visibility = Visibility.Collapsed
        End If



        Dim online As Boolean = NetworkInterface.GetIsNetworkAvailable()


        If online Then
            networkIndicator.Text = "ONLINE" 

            updateButton.Visibility = Visibility.Visible
        Else
            networkIndicator.Text = "OFFLINE"
            updateButton.Visibility = Visibility.Collapsed
        End If

    End Sub

    Private Sub installButton_Click(ByVal sender As Object, _
        ByVal e As RoutedEventArgs)

        Try
            app.Install()
        Catch ex As InvalidOperationException
            MessageBox.Show("Aplikacja jest już zainstalowana.")
        End Try

    End Sub

    Private Sub updateButton_Click(ByVal sender As Object, _
        ByVal e As RoutedEventArgs)

        app.CheckAndDownloadUpdateAsync()

    End Sub

    Private Sub App_CheckAndDownloadUpdateCompleted(ByVal sender As Object, _
        ByVal e As CheckAndDownloadUpdateCompletedEventArgs) _
        Handles app.CheckAndDownloadUpdateCompleted

        If e.UpdateAvailable Then

            MessageBox.Show("Pobrano aktualizację aplikacji. " & _
                "Ponownie uruchom aplikację, aby uruchomić nową wersję.")

        ElseIf e.Error IsNot Nothing AndAlso _
            TypeOf e.Error Is PlatformNotSupportedException Then

            MessageBox.Show("Dostępna jest aktualizacja aplikacji, " & _
                "wymaga ona jednak nowej wersji programu Silverlight. " & _
                "Przejdź na stronę główną aplikacji, aby dokonać uaktualnienia.")
        Else
            MessageBox.Show("Brak dostępnej aktualizacji.")
        End If

    End Sub

End Class

using System;
using System.Net.NetworkInformation;
using System.Windows;
using System.Windows.Controls;

namespace OutOfBrowser
{
    public partial class MainPage : UserControl
    {
        Application app = Application.Current;
        public MainPage()
        {
            InitializeComponent();
            LayoutRoot.DataContext = Deployment.Current.OutOfBrowserSettings;
            UpdateUI();
            app.CheckAndDownloadUpdateCompleted += 
                App_CheckAndDownloadUpdateCompleted;
            app.InstallStateChanged += (s,e) => UpdateUI();
            NetworkChange.NetworkAddressChanged += 
                (s, e) => UpdateNetworkIndicator();
        }

        private void UpdateUI()
        {
            UpdateNetworkIndicator();

            installButton.Visibility =
                app.InstallState == InstallState.NotInstalled ?
                Visibility.Visible : Visibility.Collapsed;

            updateButton.Visibility =
                app.IsRunningOutOfBrowser ? 
                Visibility.Visible : Visibility.Collapsed;

            isRunningOutOfBrowserTextBlock.Text = 
                app.IsRunningOutOfBrowser.ToString();

            installStateTextBlock.Text = app.InstallState.ToString();
        }

        private void UpdateNetworkIndicator()
        {
            networkIndicator.Visibility =
                app.IsRunningOutOfBrowser ?
                Visibility.Visible : Visibility.Collapsed;

            bool online = NetworkInterface.GetIsNetworkAvailable();

            networkIndicator.Text = online ?
                "ONLINE" : "OFFLINE";

            updateButton.Visibility = online ?
                Visibility.Visible : Visibility.Collapsed;
        }

        private void installButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                app.Install();
            }
            catch (InvalidOperationException)
            {
                MessageBox.Show("Aplikacja jest już zainstalowana.");
            }
        }

        private void updateButton_Click(object sender, RoutedEventArgs e)
        {
            app.CheckAndDownloadUpdateAsync();
        }

        private void App_CheckAndDownloadUpdateCompleted(object sender,
            CheckAndDownloadUpdateCompletedEventArgs e)
        {
            if (e.UpdateAvailable)
            {
                MessageBox.Show("Pobrano aktualizację aplikacji. " +
                    "Ponownie uruchom aplikację, aby uruchomić nową wersję.");
            }
            else if (e.Error != null && 
                e.Error is PlatformNotSupportedException)
            {
                MessageBox.Show("Dostępna jest aktualizacja aplikacji, " +
                    "wymaga ona jednak nowej wersji programu Silverlight. " +
                    "Przejdź na stronę główną aplikacji, aby dokonać uaktualnienia.");
            }
            else
            {
                MessageBox.Show("Brak dostępnej aktualizacji.");
            }
        }

    }
}
<OutOfBrowserSettings ShortName="Pokaz działania poza przeglądarką" 
  EnableGPUAcceleration="False" ShowInstallMenuItem="True">
  <OutOfBrowserSettings.Blurb>
    Ta aplikacja ilustruje działanie programu Silverlight poza przeglądarką.
  </OutOfBrowserSettings.Blurb>
  <OutOfBrowserSettings.WindowSettings>
    <WindowSettings Title="Pokaz działania programu Silverlight poza przeglądarką" 
      Height="250" Width="500" />
  </OutOfBrowserSettings.WindowSettings>
  <OutOfBrowserSettings.Icons />
</OutOfBrowserSettings>

Zaufane aplikacje

Domyślnie aplikacje oparte na programie Silverlight działają z ograniczonym zaufaniem, co oznacza, że działają w środowisku izolowanym pod względem zabezpieczeń. Aplikacje działające w izolowanym środowisku mają ograniczony dostęp do komputera lokalnego i są objęte innymi ograniczeniami, mającymi na celu zapobieżenie szkodliwemu działaniu.

Jednak w niektórych wypadkach ograniczenia te uniemożliwiają realizację pożądanym lub wymaganych scenariuszy. Szczególnie dotyczy to aplikacji biznesowych. Można jednak skonfigurować aplikacje działające poza przeglądarką tak, aby wymagały przyznania podniesionych uprawnień. Po zainstalowaniu aplikacje takie mogą ominąć część ograniczeń związanych z izolowanym środowiskiem. Aplikacje zaufane mogą np. uzyskać dostęp do plików użytkownika i używać trybu pełnoekranowego bez ograniczeń klawiaturowych.

W celu skonfigurowania aplikacji o podniesionym poziomie uprawnień można użyć projektanta programu Visual Studio. Projektant ustawia odpowiednie wartości w manifeście aplikacji. Można również zaktualizować manifest istniejącej aplikacji bez potrzeby ponownej kompilacji. Zazwyczaj jednak wykorzystanie podniesionych uprawnień wymaga zmodyfikowania funkcjonalności.

Po zainstalowaniu przez użytkownika aplikacji działającej poza przeglądarką, która wymaga podniesionych uprawnień, domyślne okno dialogowe zostaje zastąpione ostrzeżeniem o zabezpieczeniach. Ostrzeżenie to informuje, że aplikacja może uzyskać dostęp do danych użytkownika i należy zainstalować ją jedynie, jeśli pochodzi z zaufanej witryny. Po zainstalowaniu wszystkie aspekty działania aplikacji poza opisanymi w niniejszym dokumencie są identyczne z działaniem standardowej aplikacji działającej poza oknem przeglądarki.

Ostrzeżenie o zabezpieczeniach różni się w zależności od tego, czy aplikacja ma poprawny podpis cyfrowy. Aplikacje bez poprawnego podpisu (zwane też aplikacjami niezweryfikowanymi) stanowią większe zagrożenie, tak więc ostrzeżenie jest bardziej wyraźne. Na poniższej ilustracji ukazano ostrzeżenie dotyczące tej samej aplikacji przed dodaniem podpisu cyfrowego i po jego dodaniu.

Ostrzeżenie wyświetlane w przypadku niezweryfikowanej aplikacji.

Ostrzeżenie wyświetlane w przypadku zweryfikowanej aplikacji.

Więcej informacji można uzyskać w sekcji „Podpisywanie aplikacji” niniejszego dokumentu.

Większa część dokumentacji programu Silverlight powstaje przy założeniu, że wszystkie aplikacje działają w oknie przeglądarki w izolowanym środowisku. W niniejszym dokumencie opisano, w jaki sposób aplikacje zaufane różnią się od aplikacji działających w izolowanym środowisku. Dokładnie biorąc, opisano, jaką funkcjonalność udostępnia podniesiony poziom uprawnień oraz jak określić, czy dana aplikacja działa z podniesionymi uprawnieniami.

Uwaga:

Aplikacje zaufane działają wprawdzie z podniesionymi uprawnieniami, ale nie mają takich samych uprawnień, jak aplikacje komputerowe o pełnych uprawnieniach. Ułatwia to zachowanie kompatybilności z różnymi platformami. Jeśli wymagany jest nieograniczony dostęp do komputera użytkownika lub dodatkowa funkcjonalność niedostępna w programie Silverlight, doradzamy zastosowanie rozwiązania Windows Presentation Foundation (WPF). Ewentualnie można użyć innej aplikacji jako hosta dodatku plug-in Silverlight. Więcej informacji można uzyskać w dokumencie Alternatywne rozwiązania hostingu (j.ang.)

Zmniejszone ograniczenia dostępu międzydomenowego

Zaufane aplikacje mogą używać sieci i prowadzić komunikację za pomocą gniazd bez międzydomenowych lub międzyschematowych ograniczeń dostępu. Aplikacja zainstalowana w jednej poddomenie przy użyciu protokołu HTTP może uzyskać dostęp do plików multimediów w osobnej poddomenie przy użyciu protokołu HTTPS. Więcej informacji o komunikacji międzydomenowej można uzyskać w dokumencie Komunikacja i zabezpieczenia protokołu HTTP w programie Silverlight (j.ang.).

Ponadto zaufane aplikacje mogą używać klas sieciowych w obszarze nazw System.Net.Sockets (j.ang.) ze zmniejszonymi wymogami dotyczącymi testów zasad. Do klas tych należą nowe klasy UdpAnySourceMulticastClient (j.ang.) i UdpSingleSourceMulticastClient (j.ang.).

Aplikacje zaufane mogą nawiązać połączenie TCP z dowolnym portem dowolnego hosta bez potrzeby korzystania z pliku zasad międzydomenowych. Port docelowy nie musi już znajdować się w zakresie 4502-4534. W podobny sposób aplikacje zaufane używające klas UdpAnySourceMulticastClient (j.ang.) i UdpSingleSourceMulticastClient (j.ang.) mogą dołączyć do dowolnej grupy multiemisji przy użyciu dowolnego portu o wartości co najmniej 1024 bez potrzeby autoryzacji połączenia przez obiekt odpowiadający. Więcej informacji można uzyskać w dokumencie Związane z bezpieczeństwem ograniczenia dostępu sieciowego w programie Silverlight (j.ang.).

Zmniejszone wymagania związane ze zgodą użytkownika

Aplikacje działające w izolowanym środowisku wymagają zgody użytkownika, by uzyskać dostęp do funkcjonalności ustawienia StaysFullScreenWhenUnfocused (j.ang.) właściwości Content..::.FullScreenOptions (j.ang.) oraz klas Clipboard (j.ang.), AudioSink (j.ang.) i VideoSink (j.ang.). Aplikacje zaufane nie wymagają zgody użytkownika poza próbą uzyskania dostępu do funkcjonalności AudioSink (j.ang.) (mikrofon) i VideoSink (j.ang.) (kamera).

Zmniejszone wymagania związane z inicjalizacją przez użytkownika

Kilka funkcji programu Silverlight może być używanych tylko w reakcji na działanie użytkownika, np. zdarzenie kliknięcia przycisku. Wymagane jest również użycie tych funkcji w ciągu sekundy od działania użytkownika. Wymóg ten wiąże się z bezpieczeństwem i ma na celu zapobieżenie wykorzystania przez aplikacje funkcji systemu operacyjnego.

Aplikacje zaufane mogą używać większości z tych funkcji bez działania ze strony użytkownika. Można np. przejść w tryb pełnoekranowy przy użyciu modułu obsługi zdarzeń Application..::.Startup (j.ang.) lub zapisać dane w Schowku (j.ang.) po dłuższej operacji formatowania.

Obsługa działania pełnoekranowego

Jak podano w poprzednich sekcjach, aplikacje zaufane mogą wejść w tryb pełnoekranowy i pozostać w tym trybie bez potrzeby działania ze strony użytkownika lub zgody użytkownika. Aplikacje zaufane mogą też używać ustawienia StaysFullScreenWhenUnfocused (j.ang.) właściwości Content..::.FullScreenOptions (j.ang.).

Ponadto aplikacje zaufane przechodzące w tryb pełnoekranowy nie wyświetlają komunikatu „Press ESC to exit full-screen mode” (naciśnij klawisz ESC, aby opuścić tryb pełnoekranowy). Aplikacje zaufane w trybie pełnoekranowym nie przechwytują automatycznie naciśnięć klawiszy ani nie mają ograniczeń klawiaturowych.

Jedną z konsekwencji zmiany ograniczeń klawiszy jest to, że w aplikacji zaufanej naciśnięcie klawisza ESC nie spowoduje wyjścia z trybu pełnoekranowego. Umożliwia to zastosowanie klawisza ESC do innego celu. Należy jednak określić własny interfejs pozwalający wyjść z trybu pełnoekranowego.

Obsługa dostosowania okna

Aplikacje zaufane mogą ukrywać pasek tytułu i obramowanie okna aplikacji działającej poza przeglądarką, co pozwala na pełne dostosowanie interfejsu użytkownika.

Ukrycie paska tytułu i obramowania powoduje, że program Silverlight wyświetla jedynie zawartość aplikacji na białym tle. Tło nie jest przejrzyste, więc nie można używać tej funkcji w celu utworzenia aplikacji o nieregularnym kształcie. Dostępna jest jednak opcja zastosowania zaokrąglonych narożników o promieniu równym 9 pikseli. Więcej informacji można uzyskać w opisie właściwości WindowSettings..::.WindowStyle (j.ang.).

W celu zastąpienia funkcjonalności udostępnianej przez pasek tytułu i obramowanie można użyć interfejsów API klasy Window (j.ang.). Aby umożliwić użytkownikom przeciąganie okna lub obramowań okna, należy użyć metod DragMove (j.ang.) i DragResize (j.ang.). Można również dostosować pozycję i rozmiar okna, używając właściwości Left (j.ang.), Top (j.ang.), Width (j.ang.) i Height (j.ang.). Aby umożliwić użytkownikom minimalizowanie i maksymalizowanie okna, należy użyć właściwości WindowState (j.ang.). Aby umożliwić użytkownikom zamknięcie okna, należy użyć metody Close (j.ang.).

Dostęp do systemu plików

Zaufane aplikacje mogą uzyskać dostęp do typu System.IO (j.ang.) i typów pokrewnych, które są niedostępne w inny sposób. Umożliwia to bezpośredni dostęp do plików użytkowników bez potrzeby korzystania z klas OpenFileDialog (j.ang.) i SaveFileDialog (j.ang.). Możliwy jednak jest wyłącznie dostęp do plików w folderach użytkownika, tzn. MyDocuments (j.ang.), MyMusic (j.ang.), MyPictures (j.ang.) i MyVideos (j.ang.).

Uwaga:

Są to inne foldery niż biblioteki systemu Windows 7 o nazwach Documents, Music, Pictures i Videos. Foldery bibliotek zazwyczaj łączą zawartość folderów użytkowników z zawartością innych folderów, np. udostępnionych folderów multimediów. Jednak zaufane aplikacje nie mogą uzyskać dostępu do folderów niebędących folderami użytkowników (chyba że użyte zostaną klasy OpenFileDialog (j.ang.) i SaveFileDialog (j.ang.).

W celu uzyskania ścieżek do folderów użytkowników należy użyć metody Environment..::.GetFolderPath (j.ang.). Ścieżek tych nie można określić bezpośrednio.

W poniższej tabeli podano listę klas w obszarze nazw System.IO (j.ang.), których mogą używać zaufane aplikacje. Tabela ta wskazuje również, które elementy danej klasy nie są obsługiwane.

Klasa	Nieobsługiwane elementy
Directory (j.ang.)	GetCurrentDirectory GetDirectoryRoot SetCurrentDirectory
DirectoryInfo (j.ang.)	Root MoveTo
File (j.ang.)	SetAttributes
FileInfo (j.ang.)	(Wszystkie elementy są obsługiwane)
FileStream (j.ang.)	BeginRead BeginWrite CanRead CanSeek CanWrite EndRead EndWrite
Path (j.ang.)	GetTempFileName GetTempPath
StreamReader (j.ang.)	Konstruktory używające argumentu Stream
StreamWriter (j.ang.)	Konstruktory używające argumentu Stream

Integracja macierzysta

Zaufane aplikacje mają dostęp do części funkcjonalności macierzystego systemu operacyjnego. W systemie Windows zaufane aplikacje mogą np. używać funkcji automatyzacji i uzyskiwać dostęp do składników udostępnianych przez pakiet Office i inne aplikacje.

Sprawdzanie, czy aplikacja jest zaufana

Aby sprawdzić, czy dana aplikacja działa obecnie z podwyższonymi uprawnieniami, należy sprawdzić jej właściwości HasElevatedPermissions (j.ang.). Jest to przydatne, ponieważ umożliwia podanie alternatywnych ścieżek w kodzie, używanych, gdy aplikacja działa z ograniczonymi uprawnieniami (np. wewnątrz przeglądarki).

Kwestie bezpieczeństwa

Zaufane aplikacje nie mają wprawdzie pełnego dostępu do komputera-hosta, ale mogą uzyskać dostęp do danych osobistych i wyrządzić szkody. Dlatego też przeprowadzając ocenę lub inspekcję bezpieczeństwa należy traktować je jak aplikacje o pełnym dostępie. Aby zapobiec instalowaniu lub uruchamianiu zaufanych aplikacji przez użytkowników, administratorzy systemu mogą użyć ustawień zasad komputera w celu zablokowania dostępu zgodnie z informacjami podanymi w sekcji „Ograniczenia zasad związanych z podwyższonymi uprawnieniami” niniejszego dokumentu.

Zaufane aplikacje działają z uprawnieniami zwykłego użytkownika także wtedy, gdy zostaną zainstalowane przez użytkownika z uprawnieniami administratora. Jednak zaufane aplikacje mogą działać z podniesionymi uprawnieniami podczas debugowania przy programowaniu, należy więc pamiętać o przeprowadzeniu odpowiednich testów.

Program Silverlight uruchamia kod wszystkich aplikacji w obrębie wystąpienia AppDomain (j.ang.) o jednolitym poziomie uprawnień (zaufany lub izolowany). Do deweloperów aplikacji należy weryfikowanie składników zewnętrznych dołączonych do aplikacji.

Aplikacje działającą poza przeglądarką nie są bardziej bezpieczne od swoich witryn-hostów. Dlatego też użytkownicy powinni kierować się bezpieczeństwem witryny-hosta podczas instalowania lub aktualizowania aplikacji działających poza przeglądarką. Poniższa lista zawiera przykładowe działania, których wykonanie pozwala zwiększyć bezpieczeństwo.

Podpisanie aplikacji zgodnie z informacjami podanymi w sekcji „Podpisywanie aplikacji” niniejszego dokumentu.
Jeśli aplikacja uzyskuje dostęp do zasobów na serwerze-hoście, należy sprawdzić, czy wartość właściwości SilverlightHost..::.Source (j.ang.) odpowiada identyfikatorowi URI oczekiwanej witryny źródłowej.
Jeśli aplikacja wykorzystuje poufne informacje lub wczytuje dodatkowy kod z serwera, należy używać protokołu HTTPS w identyfikatorze URI aplikacji w celu zapewnienia bezpieczeństwa komunikacji. Należy zwrócić uwagę, że podczas sprawdzania aktualizacji zawsze jest używany identyfikator URI oryginalnej aplikacji (łącznie z protokołem).
Aplikacje działające poza przeglądarką mogą uzyskiwać dostęp do zasobów sieciowych przy użyciu protokołu HTTPS, kiedy dostępne jest połączenie. Nieprawidłowe certyfikaty i certyfikaty, których wartość upłynęła powodują niepowodzenie wywołań sieciowych. Obecnie jednak nie ma wbudowanego wskaźnika obecności bezpiecznego kanału. Wskaźnik taki można dodać, aby zwiększyć bezpieczeństwo użytkowników.

Podpisywanie aplikacji

Dodanie do zaufanej aplikacji podpisu cyfrowego ma duże znaczenie dla zabezpieczenia aplikacji. Podpis stanowi też ważną informację dla użytkownika rozważającego instalację. Ponadto jedynie zaufane aplikacje z ważnymi podpisami cyfrowymi mogą korzystać z mechanizmu aktualizacji poza oknem przeglądarki. Aby zaktualizować zaufaną aplikację bez ważnego podpisu, użytkownik musi ręcznie odinstalować starą wersję i zainstalować nową.

Aby dodać podpis cyfrowy do zaufanej aplikacji, należy użyć narzędzia SignTool.exe z certyfikatem podpisywania kodu Authenicode X.509. Można np. użyć następującego polecenia:

signtool sign /v /f certificateFile.pfxfileToSign

Podpisywanie kodu ma znaczenie tylko dla zaufanych aplikacji. Program Silverlight weryfikuje podpis i certyfikat za każdym razem, gdy użytkownik instaluje lub aktualizuje aplikację. Użytkownicy mogą zainstalować zaufaną aplikację bez ważnego podpisu. Jednak program Silverlight uniemożliwia aktualizowanie zaufanych aplikacji, o ile aktualizacja nie ma takiego samego poprawnego, zweryfikowanego certyfikatu podpisywania kodu, jak oryginalna aplikacja. Dodatkowo ważność certyfikatu nie może upłynąć, aby możliwa była aktualizacja. Należy pamiętać, aby uwzględnić datę ważności certyfikatu podczas planowania wdrażania i aktualizacji.

Uwaga:

Program Silverlight nie blokuje aktualizacji aplikacji, jeśli host źródłowy to localhost lub 127.0.0.1. Umożliwia to testowanie kodu aktualizacji bez podpisu cyfrowego.

Ograniczenia zasad związanych z podwyższonymi uprawnieniami

Administratorzy systemu mogą skonfigurować komputery w taki sposób, aby uniemożliwić użytkownikom instalowanie lub uruchamianie aplikacji działających poza oknem przeglądarki, które wymagają podniesionych uprawnień.

Jeśli instalowanie zaufanych aplikacji jest wyłączone, próba zainstalowania takiej aplikacji nie powiedzie się. W takim wypadku aplikacje już zainstalowane (lub zainstalowane przez administratora) będą działać poprawnie.

Jeśli uruchamianie zaufanych aplikacji jest wyłączone, próba uruchomienia takiej aplikacji spowoduje wyświetlenie pustego okna aplikacji poza przeglądarką. Zazwyczaj jednak w sytuacji, gdy wyłączone jest uruchamianie zaufanych aplikacji, wyłączone będzie również ich instalowanie.

Uwagi dotyczące wersji

Program Silverlight 3 nie obsługuje zaufanych aplikacji.

Jak to zrobić: uzyskiwanie dostępu do lokalnego systemu plików w zaufanych aplikacjach

Uwaga:

W niniejszym dokumencie opisano dostęp do plików w folderach użytkowników i przedstawiono listę interfejsów API dostępnych do użycia w zaufanych aplikacjach.

Uwaga:

Zaufane aplikacje nie są obsługiwane w programie Silverlight 3.

Procedury

Aby uzyskać dostęp do plików w folderach użytkownika

Obsługiwanych interfejsów API należy używać w taki sam sposób, jak w standardowej strukturze komputera, należy jednak stosować wskazane uprzednio wartości wyliczenia System..::.Environment..::.SpecialFolder (j.ang.) do konstruowania ścieżek. Prawidłowe użycie widać na poniższym przykładzie.

[VB]

Private Sub TestIO()
    If (Application.Current.HasElevatedPermissions) Then
        Dim myDocuments As String = Environment.GetFolderPath( _
            Environment.SpecialFolder.MyDocuments)
        Dim filename As String = "test.txt"
        Dim path As String = _
            System.IO.Path.Combine(myDocuments, filename)
        If File.Exists(path) Then
            Dim contents As String = File.ReadAllText(path)
            MessageBox.Show(contents)
        End If
    End If
End Sub

private void TestIO()
{
    if (Application.Current.HasElevatedPermissions)
    {
        string myDocuments = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments);
        string filename = "test.txt";
        string path = System.IO.Path.Combine(myDocuments, filename);
        if (File.Exists(path))
        {
            string contents = File.ReadAllText(path);
            MessageBox.Show(contents);
        }
    }
}

Więcej przykładów można uzyskać w opisach klas StreamReader (j.ang.), StreamWriter (j.ang.) i DirectoryInfo (j.ang.).

Jak to zrobić: Używanie automatyzacji w zaufanych aplikacjach

[Uwaga: Niniejsza dokumentacja dotyczy wersji wstępnej produktu. Odpowiednie informacje mogą ulec zmianie w przyszłych wersjach. Puste tematy są uwzględnione tymczasowo].

Zaufane aplikacje mogą integrować elementy macierzystej funkcjonalności systemu operacyjnego będącego hostem. W programie Silverlight 4 RC integracja macierzysta obejmuje m.in. możliwość uzyskania dostępu do interfejsów API automatyzacji w systemach operacyjnych Windows.

Automatyzacja to technologia używana przez aplikacje do udostępniania funkcjonalności narzędziom skryptów i innym aplikacjom. Automatyzacja pozwala np. dodać funkcje pakietu Office do aplikacji opartych na programie Silverlight.

Aplikacje lub komponenty udostępniające interfejsy API automatyzacji są zwane serwerami automatyzacji, a aplikacje uzyskujące dostęp do takich interfejsów API są zwane klientami automatyzacji. W niniejszym dokumencie opisano, jak umożliwić aplikacjom programu Silverlight działanie w charakterze klientów automatyzacji.

Uwaga:

Jedynie zaufane aplikacje działające poza przeglądarką w systemie Windows mogą uzyskać dostęp do interfejsów API automatyzacji. Dostępne są jedynie interfejsy udostępniane przez zainstalowane już składniki lub aplikacje. Więcej informacji można uzyskać w dokumentach Zaufane aplikacje i AutomationFactory (j.ang.).

Aby określić, czy funkcjonalność automatyzacji jest dostępna:

Użyj właściwości AutomationFactory..::.IsAvailable (j.ang.) tak, jak jest to ukazane w poniższym przykładzie kodu. Właściwość IsAvailable (j.ang.) wskazuje, czy aplikacja jest zaufana oraz czy działa poza przeglądarką w systemie operacyjnym Windows.

Visual Basic

Public Sub New()

    InitializeComponent()

    If AutomationFactory.IsAvailable Then
        ' Inicjalizuj program Outlook asynchronicznie, aby zachować sprawność interfejsu użytkownika.
        Dispatcher.BeginInvoke(AddressOf UseAutomation)
    Else
        MessageBox.Show("Automatyzacja niedostępna.")
    End If

End Sub

Private Sub UseAutomation()

    If InitializeOutlook() Then
        SearchEmail()
    Else
        MessageBox.Show("Program Outlook niedostępny.")
    End If

End Sub

public MainPage()
{
    InitializeComponent();

    if (AutomationFactory.IsAvailable)
    {
        // Inicjalizuj program Outlook asynchronicznie, aby zachować sprawność interfejsu użytkownika.
        Dispatcher.BeginInvoke(delegate
        {
            if (InitializeOutlook()) SearchEmail();
            else MessageBox.Show("Program Outlook niedostępny.");
        });
    }
    else
    {
        MessageBox.Show("Automatyzacja niedostępna.");
    }
}

Aby utworzyć lub pobrać obiekt automatyzacji:

Wywołaj metodę AutomationFactory..::.CreateObject (j.ang.) lub AutomationFactory..::.GetObject (j.ang.) za pomocą identyfikatora programowego (progID) wskazującego, który serwer automatyzacji ma zostać użyty. Jeśli automatyzacja jest niedostępna, te metody zwracają wyjątek NotSupportedException (j.ang.), a jeśli określony serwer automatyzacji jest niedostępny — wyjątek Exception (j.ang.).

Ogólnie biorąc, metoda CreateObject (j.ang.) utworzy nowe wystąpienie serwera automatyzacji, a metoda GetObject (j.ang.) pobierze ostatnio utworzone wystąpienie. Jednak dokładny sposób działania metod CreateObject (j.ang.) i GetObject (j.ang.) jest różny w zależności od składnika, należy więc zapoznać się z dokumentacją odpowiedniego składnika i przeprowadzić dokładne testy.

Przykład użyty w niniejszym dokumencie powoduje przeszukanie skrzynki odbiorczej programu Outlook użytkownika. Wymaga to, aby program Outlook był otwarty, tak więc poniższy kod powoduje najpierw podjęcie próby pobrania uruchomionego wystąpienia przez wywołanie metody GetObject (j.ang.). W razie zwrócenia wyjątku kod powoduje podjęcie próby otworzenia programu Outlook przez wywołanie metody CreateObject (j.ang.) oraz wyświetlenia skrzynki odbiorczej użytkownika. Jeśli zwrócony zostanie drugi wyjątek, oznacza to, że program Outlook najprawdopodobniej nie jest zainstalowany.

Odniesienie do serwera automatyzacji jest przechowywane w zmiennej typu Object (j.ang.) w języku Visual Basic lub w zmiennej typu dynamic w języku C#. Jest to konieczne, ponieważ informacje o typie są niedostępne aż do czasu uruchomienia. Jednak brak informacji o typie uniemożliwia też użycie technologii IntelliSense i debugowanie podczas kompilowania, co sprawia, że znajomość dokumentacji składnika ma jeszcze większe znaczenie.

Visual Basic

Private outlook As Object

Private Function InitializeOutlook() As Boolean

    Try
        ' Jeśli metoda GetObject zwróci wyjątek, oznacza to, że program Outlook 
        ' nie jest uruchomiony lub jest niedostępny.
        outlook = AutomationFactory.GetObject("Outlook.Application")
        Return True
    Catch
        Try
            ' Uruchom program Outlook i wyświetl skrzynkę odbiorczą, ale zminimalizuj, 
            ' aby uniknąć ukrycia aplikacji Silverlight.
            outlook =
                AutomationFactory.CreateObject("Outlook.Application")
            outlook.Session.GetDefaultFolder(6).Display() ' 6 = Inbox
            outlook.ActiveWindow.WindowState = 1  ' minimized
            Return True
        Catch
            ' Program Outlook jest niedostępny.
            Return False
        End Try
    End Try

private dynamic outlook;

private bool InitializeOutlook()
{
    try
    {
        // Jeśli metoda GetObject zwróci wyjątek, oznacza to, że program Outlook 
        // nie jest uruchomiony lub jest niedostępny.
        outlook = AutomationFactory.GetObject("Outlook.Application");
        return true;
    }
    catch (Exception)
    {
        try
        {
            // Uruchom program Outlook i wyświetl skrzynkę odbiorczą, ale zminimalizuj, 
            // aby uniknąć ukrycia aplikacji Silverlight.
            outlook = 
                AutomationFactory.CreateObject("Outlook.Application");
            outlook.Session.GetDefaultFolder(6 /* Inbox */).Display();
            outlook.ActiveWindow.WindowState = 1; // minimized
            return true;
        }
        catch (Exception)
        {
            // Program Outlook jest niedostępny.
            return false;
        }
    }
}

Aby obsługiwać zdarzenia automatyzacji

Użyj jednej z technik przedstawionych w poniższym przykładowym kodzie. Więcej informacji można uzyskać w dokumentacji klasy AutomationEvent (j.ang.).

Uwaga:

Zdarzenia zwracające wartości nie są obsługiwane.

Visual Basic

Private Sub SearchEmail()

    message.Text = "Wyszukiwanie pozycji 'Silverlight' w skrzynce odbiorczej..."

    outlook.AdvancedSearch("Inbox",
        "urn:schemas:mailheader:subject ci_phrasematch 'Silverlight'",
        True, "SubjectSearch")

    ' Poniższy kod ukazuje trzy sposoby obsługi zdarzeń 
    ' automatyzacji. W języku Visual Basic wszystkie trzy sposoby korzystają z klasy AutomationEvent. 

    searchEvent = AutomationFactory _
        .GetEvent(outlook, "AdvancedSearchComplete")

    ' Pierwszy sposób jest za prezentowany za pomocą klauzuli Handles 
    ' metody SearchEvent_EventRaised, która wymaga modyfikatora WithEvents
    ' w deklaracji zmiennej searchEvent.

    ' Drugi sposób korzysta ze składni AddHandler ze zdarzeniem EventRaised
    ' i nie wymaga modyfikatora WithEvents. 
    'AddHandler searchEvent.EventRaised, AddressOf SearchEvent_EventRaised

    ' Trzeci sposób korzysta z metody AutomationEvent.AddEventHandler i wymaga
    ' zastosowania obiektu delegowanego z podpisem API
    ' zgodnym ze zdarzeniem automatyzacji. 
    'searchEvent.AddEventHandler( _
    '   New AdvancedSearchCompleteDelegate(AddressOf SearchComplete))

End Sub

Private WithEvents searchEvent As AutomationEvent

Sub SearchEvent_EventRaised( _
    ByVal sender As Object, ByVal e As AutomationEventArgs) _
    Handles searchEvent.EventRaised

    SearchComplete(e.Arguments(0))

End Sub

' Niewymagane w wypadku pierwszego sposobu. 
Private Delegate Sub AdvancedSearchCompleteDelegate(ByRef search As Object)

Private Sub SearchComplete(ByRef search As Object)

    message.Visibility = System.Windows.Visibility.Collapsed
    items.Visibility = System.Windows.Visibility.Visible

    Dim searchResults As New List(Of String)
    For Each result As Object In search.Results
        searchResults.Add(result.Subject)
    Next
    items.ItemsSource = searchResults

End Sub

private void SearchEmail()
{
    message.Text = "Wyszukiwanie pozycji 'Silverlight' w skrzynce odbiorczej...";

    outlook.AdvancedSearch("Inbox",
        "urn:schemas:mailheader:subject ci_phrasematch 'Silverlight'",
        true, "SubjectSearch");

    // Poniższy kod ukazuje trzy sposoby obsługi zdarzeń 
    // automatyzacji. W dwóch pierwszych sposobach używana jest klasa AutomationEvent. 
    // Dwa ostatnie sposoby wymagają zastosowania obiektu delegowanego 
    // z podpisem API odpowiadającym zdarzeniu automatyzacji. 

    AutomationEvent searchEvent = AutomationFactory
        .GetEvent(outlook, "AdvancedSearchComplete");

    // Pierwszy sposób: 
    searchEvent.EventRaised += (sender, e) => {
        SearchComplete(e.Arguments[0]);
    };

    // Drugi sposób:
    //searchEvent.AddEventHandler(
    //    new AdvancedSearchCompleteDelegate(SearchComplete));

    // Trzeci sposób:
    //outlook.AdvancedSearchComplete +=
    //    new AdvancedSearchCompleteDelegate(SearchComplete);
}

// Niewymagane w wypadku pierwszego sposobu. 
//private delegate void AdvancedSearchCompleteDelegate(dynamic search);

private void SearchComplete(dynamic search)
{
    message.Visibility = System.Windows.Visibility.Collapsed;
    items.Visibility = System.Windows.Visibility.Visible;

    List<String> searchResults = new List<String>();
    foreach (dynamic result in search.Results)
    {
        searchResults.Add(result.Subject);
    }
    items.ItemsSource = searchResults;
}

Przykład

Powyższy fragment kodu jest związany z klasą UserControl (j.ang.) i ma nazwę MainPage. Ponżej podany jest fragment kodu XAML.

XAML

<Grid x:Name="LayoutRoot" Background="White">
    <TextBlock x:Name="message"/>
    <ListBox x:Name="items" Visibility="Collapsed"/>
</Grid>

Kompilowanie kodu

Aby można było używać słowa kluczowego dynamic języka C#, projekt musi zawierać odniesienie do biblioteki Microsoft.CSharp.dll.

Bezpieczeństwo

Kwestie bezpieczeństwa zaufanych aplikacji omówiono w dokumencie Zaufane aplikacje.

Obsługa działania poza przeglądarką, cz. II

Jak to zrobić: konfigurowanie aplikacji w sposób umożliwiający działanie poza przeglądarką

Aby skonfigurować obsługę działania poza przeglądarką:

Przykład

Jak to zrobić: wdrażanie obsługi trybu offline w aplikacjach działających poza przeglądarką

Przykład

Zaufane aplikacje

Zmniejszone ograniczenia dostępu międzydomenowego

Zmniejszone wymagania związane ze zgodą użytkownika

Zmniejszone wymagania związane z inicjalizacją przez użytkownika

Obsługa działania pełnoekranowego

Obsługa dostosowania okna

Dostęp do systemu plików

Integracja macierzysta

Sprawdzanie, czy aplikacja jest zaufana

Kwestie bezpieczeństwa

Podpisywanie aplikacji

Ograniczenia zasad związanych z podwyższonymi uprawnieniami

Uwagi dotyczące wersji

Jak to zrobić: uzyskiwanie dostępu do lokalnego systemu plików w zaufanych aplikacjach

Aby uzyskać dostęp do plików w folderach użytkownika

Jak to zrobić: Używanie automatyzacji w zaufanych aplikacjach

Aby określić, czy funkcjonalność automatyzacji jest dostępna:

Aby utworzyć lub pobrać obiekt automatyzacji:

Aby obsługiwać zdarzenia automatyzacji

Przykład

Kompilowanie kodu

Bezpieczeństwo

Dodatkowe zasoby