Uppdatera en live-panel från en bakgrundsaktivitet

2025-06-10

Anmärkning

Lives Tiles är en Windows 10-funktion som inte stöds i senare versioner av Windows. För nya appar rekommenderar vi att du följer den aktuella vägledningen för appikoner.

Använd en bakgrundsaktivitet för att uppdatera appens livepanel med nytt innehåll.

viktiga API:er

Skapa bakgrundsaktivitetsprojektet

Om du vill aktivera en live-panel för din app lägger du till ett nytt Windows Runtime-komponentprojekt i din lösning. Det här är en separat sammansättning som operativsystemet läser in och kör i bakgrunden när en användare installerar din app.

Högerklicka på lösningen i Solution Explorer, klicka på Lägg tilloch klicka sedan på Nytt projekt.
I dialogrutan Lägg till nytt projekt väljer du mallen Windows Runtime Component i avsnittet Installerat > andra språk > Visual C# > Windows Universal.
Ge projektet namnet BackgroundTasks och klicka eller tryck på OK. Microsoft Visual Studio lägger till det nya projektet i lösningen.
I huvudprojektet lägger du till en referens till Projektet BackgroundTasks.

Implementera bakgrundsuppgiften

Implementera gränssnittet IBackgroundTask för att skapa en klass som uppdaterar appens livepanel. Ditt bakgrundsarbete ska placeras i metoden Kör. I det här fallet är uppgiften att hämta ett syndikeringsflöde för MSDN-bloggarna. Om du vill förhindra att aktiviteten stängs i förtid medan asynkron kod fortfarande körs får du en deferral.

I Solution Explorer byter du namn på den automatiskt genererade filen, Class1.cs, till BlogFeedBackgroundTask.cs.
I BlogFeedBackgroundTask.cs ersätter du den automatiskt genererade koden med stub-koden för klassen BlogFeedBackgroundTask.
I implementeringen av körmetoden lägger du till kod för metoderna GetMSDNBlogFeed och UpdateTile.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// Added during quickstart
using Windows.ApplicationModel.Background;
using Windows.Data.Xml.Dom;
using Windows.UI.Notifications;
using Windows.Web.Syndication;

namespace BackgroundTasks
{
    public sealed class BlogFeedBackgroundTask  : IBackgroundTask
    {
        public async void Run( IBackgroundTaskInstance taskInstance )
        {
            // Get a deferral, to prevent the task from closing prematurely
            // while asynchronous code is still running.
            BackgroundTaskDeferral deferral = taskInstance.GetDeferral();

            // Download the feed.
            var feed = await GetMSDNBlogFeed();

            // Update the live tile with the feed items.
            UpdateTile( feed );

            // Inform the system that the task is finished.
            deferral.Complete();
        }

        private static async Task<SyndicationFeed> GetMSDNBlogFeed()
        {
            SyndicationFeed feed = null;

            try
            {
                // Create a syndication client that downloads the feed.  
                SyndicationClient client = new SyndicationClient();
                client.BypassCacheOnRetrieve = true;
                client.SetRequestHeader( customHeaderName, customHeaderValue );

                // Download the feed.
                feed = await client.RetrieveFeedAsync( new Uri( feedUrl ) );
            }
            catch( Exception ex )
            {
                Debug.WriteLine( ex.ToString() );
            }

            return feed;
        }

        private static void UpdateTile( SyndicationFeed feed )
        {
            // Create a tile update manager for the specified syndication feed.
            var updater = TileUpdateManager.CreateTileUpdaterForApplication();
            updater.EnableNotificationQueue( true );
            updater.Clear();

            // Keep track of the number feed items that get tile notifications.
            int itemCount = 0;

            // Create a tile notification for each feed item.
            foreach( var item in feed.Items )
            {
                XmlDocument tileXml = TileUpdateManager.GetTemplateContent( TileTemplateType.TileWide310x150Text03 );

                var title = item.Title;
                string titleText = title.Text == null ? String.Empty : title.Text;
                tileXml.GetElementsByTagName( textElementName )[0].InnerText = titleText;

                // Create a new tile notification.
                updater.Update( new TileNotification( tileXml ) );

                // Don't create more than 5 notifications.
                if( itemCount++ > 5 ) break;
            }
        }

        // Although most HTTP servers do not require User-Agent header, others will reject the request or return
        // a different response if this header is missing. Use SetRequestHeader() to add custom headers.
        static string customHeaderName = "User-Agent";
        static string customHeaderValue = "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)";

        static string textElementName = "text";
        static string feedUrl = @"http://blogs.msdn.com/b/MainFeed.aspx?Type=BlogsOnly";
    }
}

Konfigurera paketmanifestet

Om du vill konfigurera paketmanifestet öppnar du det och lägger till en ny bakgrundsuppgiftsdeklaration. Ange startpunkt för uppgiften till klassnamnet, inklusive dess namnområde.

Öppna Package.appxmanifest i Solution Explorer.
Klicka eller tryck på fliken -deklarationer.
Under Tillgängliga deklarationerväljer du BackgroundTasks och klickar på Lägg till. Visual Studio lägger till BackgroundTasks under Stödda deklarationer.
Under Aktivitetstyper som stöds, kontrollera att Timer är markerad.
Under Appinställningaranger du startpunkten till BackgroundTasks.BlogFeedBackgroundTask.
Klicka eller tryck på fliken Program-UI.
Ange Märke och Paneltext.
Ange en sökväg till en ikon på 24 x 24 bildpunkter i fältet -märkeslogotyp. Viktigt Den här ikonen får endast använda monokroma och transparenta bildpunkter.
I fältet Liten logotyp anger du en sökväg till en 30 x 30 bildpunktsikon.
I fältet brett logotyp anger du en sökväg till en ikon med 310 x 150 bildpunkter.

Registrera bakgrundsaktiviteten

Skapa en BackgroundTaskBuilder- för att registrera uppgiften.

Obs Från och med Windows 8.1 verifieras parametrar för registrering av bakgrundsaktiviteter vid tidpunkten för registreringen. Ett fel returneras om någon av registreringsparametrarna är ogiltiga. Din app måste kunna hantera scenarier där registreringen av bakgrundsaktiviteter misslyckas, till exempel genom att använda en villkorsstyrd instruktion för att söka efter registreringsfel och sedan försöka registrera igen med hjälp av olika parametervärden.

På appens huvudsida lägger du till metoden RegisterBackgroundTask och anropar den i OnNavigatedTo händelsehanterare.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Windows.ApplicationModel.Background;
using Windows.Data.Xml.Dom;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.Web.Syndication;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/p/?LinkID=234238

namespace ContosoApp
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected override void OnNavigatedTo( NavigationEventArgs e )
        {
            this.RegisterBackgroundTask();
        }


        private async void RegisterBackgroundTask()
        {
            var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
            if( backgroundAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy ||
                backgroundAccessStatus == BackgroundAccessStatus.AlwaysAllowed )
            {
                foreach( var task in BackgroundTaskRegistration.AllTasks )
                {
                    if( task.Value.Name == taskName )
                    {
                        task.Value.Unregister( true );
                    }
                }

                BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
                taskBuilder.Name = taskName;
                taskBuilder.TaskEntryPoint = taskEntryPoint;
                taskBuilder.SetTrigger( new TimeTrigger( 15, false ) );
                var registration = taskBuilder.Register();
            }
        }

        private const string taskName = "BlogFeedBackgroundTask";
        private const string taskEntryPoint = "BackgroundTasks.BlogFeedBackgroundTask";
    }
}

Felsöka bakgrundsaktiviteten

Om du vill felsöka bakgrundsaktiviteten anger du en brytpunkt i aktivitetens Kör-metod. I verktygsfältet Felsökningsplats, välj din bakgrundsuppgift. Detta gör att systemet anropar run-metoden omedelbart.

Ange en brytpunkt i aktivitetens Kör-metod.
Tryck på F5 eller tryck på Felsök > Starta felsökning för att distribuera och köra appen.
När appen har lanserats växlar du tillbaka till Visual Studio.
Kontrollera att verktygsfältet Felsökningsplats är synligt. Den finns på menyn Visa > verktygsfält.
I verktygsfältet Felsökningsplats klickar du på listrutan Pausa och väljer BlogFeedBackgroundTask.
Visual Studio pauserar körningen vid brytpunkten.
Tryck på F5 eller tryck på Felsök > Fortsätt för att fortsätta köra appen.
Tryck på Skift+F5 eller tryck på Felsök > Sluta felsöka för att stoppa felsökningen.
Gå tillbaka till appens panel på startskärmen. Efter några sekunder visas panelmeddelanden på appens panel.

Feedback

Var den här sidan till hjälp?