C# StandardTileData类代码示例

        /// <summary>
        /// Agent that runs a scheduled task
        /// </summary>
        /// <param name="task">
        /// The invoked task
        /// </param>
        /// <remarks>
        /// This method is called when a periodic or resource intensive task is invoked
        /// </remarks>
        protected override void OnInvoke(ScheduledTask task)
        {
            var tileToFind = ShellTile.ActiveTiles.FirstOrDefault();

            if(tileToFind != null)
            {
                var tileData = new StandardTileData
                                   {
                                       BackTitle = "Jeg lever!",
                                       BackBackgroundImage = new Uri(_pictureUrl, UriKind.Absolute)
                                   };

                tileToFind.Update(tileData);
            }

            /*

            var toast = new ShellToast
                            {
                                Title = "Toast!",
                                Content = "Backgrond agent says hello!",
                            };
            toast.Show();

            */

            NotifyComplete();
        }

        public static void Create(Uri uri, StandardTileData data)
        {
            var bgImage = data.BackgroundImage;
            var backBgImage = data.BackBackgroundImage;

            bool found = false;
            if (bgImage != null && bgImage.IsAbsoluteUri)
            {
                data.BackgroundImage = null;
                found = true;
            }

            if (backBgImage != null && backBgImage.IsAbsoluteUri)
            {
                data.BackBackgroundImage = null;
                found = true;
            }

            ShellTile.Create(uri, data);

            //if no distant uri, do nothing
            if (!found)
                return;

            //find my tile
            ShellTile mytile = ShellTile.ActiveTiles.FirstOrDefault(currentTile => currentTile.NavigationUri == uri);
            if (mytile == null)
                return;

            //update the tile
            mytile.Update(new StandardTileData() { BackgroundImage = bgImage, BackBackgroundImage = backBgImage });
        }

        public static void Update()
        {
            try
            {
                // Application Tile is always the first Tile, even if it is not pinned to Start.
                ShellTile TileToFind = ShellTile.ActiveTiles.First();

                if (TileToFind != null)
                {
                    // Create the tile object and set some initial properties for the tile.
                    // The Count value of 12 will show the number 12 on the front of the Tile.
                    // Valid values are 1-99.
                    // A Count value of 0 will indicate that the Count should not be displayed.
                    int alarmCount = AlarmHelper.AlarmCount();
                    Alarm alarm = AlarmHelper.NearestAlarm();

                    StandardTileData NewTileData = new StandardTileData
                    {
                        BackgroundImage = new Uri("/Resources/Images/Tiles/BackgroundImage.png", UriKind.Relative),
                        Title = "Metro Calendar",
                        Count = alarmCount,
                        BackTitle = ((alarm == null) ? "Next alarm" : alarm.BeginTime.ToShortTimeString()),
                        BackContent = ((alarm == null) ? "No alarm" : alarm.Content),
                        BackBackgroundImage = new Uri("/Resources/Images/Tiles/BackBackgroundImage.png", UriKind.Relative)
                    };

                    TileToFind.Update(NewTileData);
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
            }
        }

        public static void Update(AccountData[] accountData)
        {
            if (accountData == null)
            {
                return;
            }

            var netWorth = accountData.Sum(data => data.Balance);
            var balanceIssueCount = accountData.Count(data => data.AccountType == "bank" && data.Balance < 0);
            var loginIssueCount = accountData.Count(data => data.LoginStatus == AccountLoginStatus.Invalid);

            var tile = ShellTile.ActiveTiles.First();

            var tileData = new StandardTileData();

            tileData.Count = loginIssueCount + balanceIssueCount;
            tileData.BackTitle = "Net Worth";
            tileData.BackContent = String.Format("{0:c}", netWorth);
            if (balanceIssueCount > 0)
            {
                tileData.BackgroundImage = new Uri("/Assets/Tiles/TileMediumIconRed.png", UriKind.Relative);
                tileData.BackBackgroundImage = new Uri("/Assets/Tiles/TileMediumRed.png", UriKind.Relative);
            }
            else
            {
                tileData.BackgroundImage = new Uri("/Assets/Tiles/TileMediumIcon.png", UriKind.Relative);
                tileData.BackBackgroundImage = new Uri(String.Empty, UriKind.Relative);
            }

            tile.Update(tileData);
        }

        private void PinTrip()
        {
            ShellTile tile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("/Views/TripDetails.xaml?tripId=" + PathResultsModel.SelectedPathOption.TripId.ToString()));

            if (tile == null)
            {
                IEnumerable<Path> paths = UnitOfWork.PathRepository.GetAllCached(UnitOfWork.PublicTransportOperatorRepository.GetAll());

                Path pinnedPath = paths.Where(x => x.TripId == PathResultsModel.SelectedPathOption.TripId).FirstOrDefault();

                if (pinnedPath == null)
                    return;

                pinnedPath.IsPinned = true;
                UnitOfWork.PathRepository.Insert(pinnedPath);
                UnitOfWork.Save();

                var newTile = new StandardTileData()
                {
                    Title = string.Format(AppResources.TripDetailsLiveTileText, PathResultsModel.Destination.ShortAddressText),
                    BackgroundImage = new Uri("/Images/Tiles/TileTrip7.png", UriKind.Relative),
                    BackContent = string.Format(AppResources.TripDetailsLiveTileBackText, PathResultsModel.SelectedPathOption.StartTime.Value.ToString("HH:mm"), PathResultsModel.Location.ShortAddressText, PathResultsModel.Destination.ShortAddressText)
                     
                };

                ShellTile.Create(new Uri("/Views/TripDetails.xaml?tripId=" + PathResultsModel.SelectedPathOption.TripId.ToString(), UriKind.Relative), newTile);
            }
            else
            {
                ShowPopup(CustomPopupMessageType.Error, AppResources.TileAlreadyPinnedErrorText, AppResources.CustomPopupGenericOkGotItMessage, null);
            }
        }

        /// <summary>
        /// Agent that runs a scheduled task
        /// </summary>
        /// <param name="task">
        /// The invoked task
        /// </param>
        /// <remarks>
        /// This method is called when a periodic or resource intensive task is invoked
        /// </remarks>
        protected override void OnInvoke(ScheduledTask task)
        {

            //TODO: Add code to perform your task in background

            /// If application uses both PeriodicTask and ResourceIntensiveTask
            if (task is PeriodicTask)
            {
                // Execute periodic task actions here.
                ShellTile TileToFind = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("TileID=2"));
                if (TileToFind != null)
                {
                     StandardTileData NewTileData = new StandardTileData
                        {
                            Title= "updated by scheduled task",
                            Count = System.DateTime.Now.Minute
                        };
                     TileToFind.Update(NewTileData);
                }
            }
            else
            {
                // Execute resource-intensive task actions here.
            }

            NotifyComplete();
           
        }

        /// <summary>
        /// Agent that runs a scheduled task
        /// </summary>
        /// <param name="task">
        /// The invoked task
        /// </param>
        /// <remarks>
        /// This method is called when a periodic or resource intensive task is invoked
        /// </remarks>
        //protected override void OnInvoke(ScheduledTask task)
        //{
        //    //TODO: Add code to perform your task in background
        //    NotifyComplete();
        //}
        protected override void OnInvoke(ScheduledTask task)
        {
            // some random number
            Random random = new Random();
            // get application tile
            ShellTile tile = ShellTile.ActiveTiles.First();
            if (null != tile)
            {
                // creata a new data for tile
                StandardTileData data = new StandardTileData();
                // tile foreground data
                data.Title = "Title text here";
                data.BackgroundImage = new Uri("/Images/Blue.jpg", UriKind.Relative);
                data.Count = random.Next(99);
                // to make tile flip add data to background also
                data.BackTitle = "Secret text here";
                data.BackBackgroundImage = new Uri("/Images/Green.jpg", UriKind.Relative);
                data.BackContent = "Back Content Text here...";
                // update tile
                tile.Update(data);
            }
            #if DEBUG_AGENT
            ScheduledActionService.LaunchForTest(task.Name, TimeSpan.FromSeconds(30));
            System.Diagnostics.Debug.WriteLine("Periodic task is started again: " + task.Name);
            #endif

            NotifyComplete();
        }

        void PodcastListDownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            int j = 0;
           
            if (IsolatedStorageSettings.ApplicationSettings.Contains("LastShowPostedOn"))
                LastShow = (DateTime)IsolatedStorageSettings.ApplicationSettings["LastShowPostedOn"];  

            try
            {
                var doc = XDocument.Parse(e.Result);
                var xChannel = doc.Descendants("channel").First();

                foreach (var item in xChannel.Descendants("item"))
                {                
                    if (RssHelper.ParseRssDate(RssHelper.getElementValue(item, "pubDate")) > LastShow)
                    {
                        j++;
                    }
                }
               
            }
            catch (Exception)
            {
                // do nothing just let the MinValue be returned
            }
            
            var tile = ShellTile.ActiveTiles.First();

            StandardTileData update = new StandardTileData();
            update.Count = j;
            update.BackBackgroundImage = new Uri("/Images/Background.png", UriKind.Relative);
            tile.Update(update);

            NotifyComplete();
        }

        public override void SetNotifications(IEnumerable<TileNotification> notifications)
        {
            if (!notifications.Any())
                return;

            StandardTileData mainTile = new StandardTileData();
            string content = "";

            if (notifications.Count() == 1)
            {
                var not = notifications.First();
                if (not.Type == TweetType.Mention)
                    content = String.Format(Resources.NewMention, not.From);
                else
                    content = String.Format(Resources.NewMessage, not.From);
            }
            else
            {
                if (notifications.Any(x => x.Type == TweetType.Mention) && notifications.Any(x => x.Type == TweetType.Message))
                    content = String.Format(Resources.NewXMentionsMessages, notifications.Count());
                else if (notifications.Any(x => x.Type == TweetType.Mention))
                    content = String.Format(Resources.NewXMentions, notifications.Count());
                else if (notifications.Any(x => x.Type == TweetType.Message))
                    content = String.Format(Resources.NewXMessages, notifications.Count());
            }

            mainTile.BackTitle = String.Format(Resources.ForX, GetChainOfNames(notifications.Select(x => x.To).Distinct().ToList()));
            mainTile.BackContent = content;

            mainTile.Count = notifications.Count();
            ShellTile.ActiveTiles.FirstOrDefault().Update(mainTile);
        }

        private void HandlePinClick (object sender, EventArgs e)
        {
            var vm = (SpeakerDetailsViewModel)DataContext;

            var uri = "/SpeakerDetails.xaml?key=" + vm.Key;

            var imageUri = default (Uri);
            try {
                imageUri = SpeakerImage.SaveAsTile ("Speaker-" + vm.ID);
            }
            catch (Exception) {
            }            

            var foundTile = ShellTile.ActiveTiles.FirstOrDefault (x => x.NavigationUri.ToString ().Contains (uri));

            if (foundTile != null) {
                foundTile.Delete ();
            }

            var tile = new StandardTileData {
                Title = vm.Name,
                BackContent = string.Format ("{0} at {1}", vm.Title, vm.Company),
                BackTitle = vm.Name,
                BackgroundImage = (imageUri != null) ? imageUri : new Uri ("/Background.png", UriKind.RelativeOrAbsolute),
            };

            ShellTile.Create (new Uri (uri, UriKind.Relative), tile);
        }

        private void btnUpdate_Click(object sender, RoutedEventArgs e)
        {
            ShellTile applicationTile = ShellTile.ActiveTiles.First();
            //ApplicationTile永远是所有已经激活了的磁贴中的第一个对象。

            //判断应用程序磁贴时候已经被pin到开始页面
            if (applicationTile != null)
            {
                int newCount=0;//消息数目,数目为0时，数字0将不会被显示到磁贴中去
                if (textBoxCount.Text != "")
                    newCount = int.Parse(textBoxCount.Text);

                //利用StandardTileData类型的数据来更新ApplicationTile
                //将用户输入的内容分别赋值给StandardTileData对象
                StandardTileData updateData = new StandardTileData
                {
                    Title=textBoxTitle.Text,
                    Count=newCount,
                    BackgroundImage=new Uri(textBoxBackgroundImage.Text,UriKind.RelativeOrAbsolute),
                    BackTitle=textBoxBackTitle.Text,
                    BackContent=textBoxBackContent.Text,
                    BackBackgroundImage=new Uri(textBoxBackBackgroundImage.Text,UriKind.RelativeOrAbsolute)
                };
                //调用磁贴对象的函数，传入StandardTileData的对象来更新应用程序磁贴
                applicationTile.Update(updateData);
                MessageBox.Show("已经更新ApplicationTile");
            }
        }

        public Task<bool> Pin(TileInfo tileInfo)
        {
            var result = false;
            if (IsPinned(tileInfo))
            {
                Unpin(tileInfo).Wait();
            }

            var tileData = new StandardTileData
            {
                Title = tileInfo.DisplayName,
                BackgroundImage = tileInfo.LogoUri,
                Count = tileInfo.Count,
                BackTitle = tileInfo.AppName,
                BackBackgroundImage = new Uri("", UriKind.Relative),
                BackContent = tileInfo.DisplayName
            };

            try
            {
                ShellTile.Create(new Uri(string.Format("/View/Shell.xaml?routeId={0}&routeName={1}", tileInfo.TileId, tileInfo.DisplayName), UriKind.Relative), tileData);
                result = true;
            }
            catch (Exception)
            {
                result = false;
            }

            return Task.FromResult<bool>(result);
        }

 void nzRSS_DSC(object sender, DownloadStringCompletedEventArgs e)
 {
     try
     {
         var rssData = (from rss in XElement.Parse(e.Result).Descendants("item")
                        select new PostMessage
                        {
                            title = rss.Element("title").Value
                        }).ToArray().Reverse();
         foreach (var item in rssData)
         {
             String nameData = item.title;
             var tile = ShellTile.ActiveTiles.First();
             var apptile = new StandardTileData();
             apptile.Title = "Здесь в...";
             apptile.BackgroundImage = new Uri("/TilePic.png", UriKind.RelativeOrAbsolute);
             apptile.BackContent = nameData;
             tile.Update(apptile);
         }
     }
     catch
     {
     }
     finally
     {
         NotifyComplete();
     }
 }

 private void toggleSetting_Clicked(object sender, RoutedEventArgs e)
 {
     StandardTileData tileData = new StandardTileData();
     tileData.BackContent = toggleSetting.IsChecked.ToString();
     tileData.Count = 10;
     ShellTile.ActiveTiles.First().Update(tileData);
 }

        public EntryPage()
        {
            InitializeComponent();
            StandardTileData sd = new StandardTileData
            {
                Title = "Property Viewer",
                BackgroundImage = new Uri("Background.png", UriKind.Relative),
                Count = 0
            };

            ShellTile st = ShellTile.ActiveTiles.ElementAt(0);
            st.Update(sd);
            client = new ImageServiceClient();

            string channelName = "ChannelName";
            httpChannel = HttpNotificationChannel.Find(channelName);
            if (httpChannel != null)
            {
                channelUri = httpChannel.ChannelUri;
                client.SetUrlAsync(channelUri);
            }
            else
            {
                httpChannel = new HttpNotificationChannel(channelName);
                httpChannel.ErrorOccurred += OnErrorOccurred;
                httpChannel.Open();
                channelUri = httpChannel.ChannelUri;

            }
            httpChannel.ChannelUriUpdated += OnChannelUriUpdated;
            client.resetCompleted += OnResetCompleted;
        }