如何在WP7中实时监控内存使用量

在windows phone 7 里开发的程序在运行过程中如果内存使用超过90M程序就会自动退出，但是在模拟器上没有这个限制，因此必须有方法帮助你在调试程序的时候时刻监控内存占用，否则即使在模拟器上没问题，一旦到了真机上就可能会出问题，最近在开发中我就遇到了这个问题，经过摸索，发现phone7提供了DeviceExtendedProperties可用于取得内存使用情况。

办法一：在app.xaml.cs里加入一个timer, 设置每间隔一段时间输出内存占用值到控制台：

1.在app.xaml.cs里添加下列函数：

        void timer_Tick(object sender, EventArgs e)        
         {            //GC.GetTotalMemory(true);            
             long deviceTotalMemory = (long)Microsoft.Phone.Info.DeviceExtendedProperties.GetValue("DeviceTotalMemory");            
             long applicationCurrentMemoryUsage = (long)Microsoft.Phone.Info.DeviceExtendedProperties.GetValue("ApplicationCurrentMemoryUsage");            
             long applicationPeakMemoryUsage = (long)Microsoft.Phone.Info.DeviceExtendedProperties.GetValue("ApplicationPeakMemoryUsage");             
             System.Diagnostics.Debug.WriteLine(DateTime.Now.ToLongTimeString());            
             System.Diagnostics.Debug.WriteLine("Device Total : " + deviceTotalMemory.ToString());           
             System.Diagnostics.Debug.WriteLine("App Current : " + applicationCurrentMemoryUsage.ToString());            
             System.Diagnostics.Debug.WriteLine("App Peak : " + applicationPeakMemoryUsage.ToString());        
         }

2。在构造函数public App{}里添加 ：

            System.Windows.Threading.DispatcherTimer timer = new System.Windows.Threading.DispatcherTimer();
            timer.Interval = TimeSpan.FromMilliseconds(1000d);
            timer.Tick += new EventHandler(timer_Tick);
            timer.Start();

 

办法二：

  使用MemoryDiagnosticsHelper.cs类,下面是源代码，将此文件添加到工程中。

然后将MemoryDiagnosticsHelper.Start(TimeSpan.FromMilliseconds(500), true); 这一句添加到构造函数public App{}里

   if (System.Diagnostics.Debugger.IsAttached)

{

...
MemoryDiagnosticsHelper.Start(TimeSpan.FromMilliseconds(500), true);

...

}

 

用模拟器debug你的程序，手机界面右侧边会多出一条显示实时内存状态的信息。

 

 

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Controls.Primitives;
using System.Windows.Threading;
using Microsoft.Phone.Info;
using System.Diagnostics;
using System.Collections.Generic;

namespace MemoryDiagnostics
{
  /// <summary>
  /// Helper class for showing current memory usage
  /// </summary>
  public static class MemoryDiagnosticsHelper
  {
    static Popup popup;
    static TextBlock currentMemoryBlock;
    static TextBlock peakMemoryBlock;
    static DispatcherTimer timer;
    static bool forceGc;
    const long MAX_MEMORY = 90 * 1024 * 1024; // 90MB, per marketplace
    static int lastSafetyBand = -1; // to avoid needless changes of colour

    const long MAX_CHECKPOINTS = 10; // adjust as needed
    static Queue<MemoryCheckpoint> recentCheckpoints;

    static bool alreadyFailedPeak = false; // to avoid endless Asserts

    /// <summary>
    /// Starts the memory diagnostic timer and shows the counter
    /// </summary>
    /// <param name="timespan">The timespan between counter updates</param>
    /// <param name="forceGc">Whether or not to force a GC before collecting memory stats</param>
    [Conditional("DEBUG")]
    public static void Start(TimeSpan timespan, bool forceGc)
    {
      if (timer != null)
        throw new InvalidOperationException("Diagnostics already running");

      MemoryDiagnosticsHelper.forceGc = forceGc;
      recentCheckpoints = new Queue<MemoryCheckpoint>();

      StartTimer(timespan);
      ShowPopup();
    }

    /// <summary>
    /// Stops the timer and hides the counter
    /// </summary>
    [Conditional("DEBUG")]
    public static void Stop()
    {
      HidePopup();
      StopTimer();
      recentCheckpoints = null;
    }

    /// <summary>
    /// Add a checkpoint to the system to help diagnose failures. Ignored in retail mode
    /// </summary>
    /// <param name="text">Text to describe the most recent thing that happened</param>
    [Conditional("DEBUG")]
    public static void Checkpoint(string text)
    {
      if (recentCheckpoints == null)
        return;

      if (recentCheckpoints.Count >= MAX_CHECKPOINTS - 1)
        recentCheckpoints.Dequeue();

      recentCheckpoints.Enqueue(new MemoryCheckpoint(text, GetCurrentMemoryUsage()));
    }

    /// <summary>
    /// Recent checkpoints stored by the app; will always be empty in retail mode
    /// </summary>
    public static IEnumerable<MemoryCheckpoint> RecentCheckpoints
    {
      get
      {
        if (recentCheckpoints == null)
          yield break;

        foreach (MemoryCheckpoint checkpoint in recentCheckpoints)
          yield return checkpoint;
      }
    }

    /// <summary>
    /// Gets the current memory usage, in bytes. Returns zero in non-debug mode
    /// </summary>
    /// <returns>Current usage</returns>
    public static long GetCurrentMemoryUsage()
    {
#if DEBUG
      // don't use DeviceExtendedProperties for release builds (requires a capability)
      return (long)DeviceExtendedProperties.GetValue("ApplicationCurrentMemoryUsage");
#else
      return 0;
#endif
    }

    /// <summary>
    /// Gets the peak memory usage, in bytes. Returns zero in non-debug mode
    /// </summary>
    /// <returns>Peak memory usage</returns>
    public static long GetPeakMemoryUsage()
    {
#if DEBUG
      // don't use DeviceExtendedProperties for release builds (requires a capability)
      return (long)DeviceExtendedProperties.GetValue("ApplicationPeakMemoryUsage");
#else
      return 0;
#endif
    }

    private static void ShowPopup()
    {
      popup = new Popup();
      double fontSize = (double)Application.Current.Resources["PhoneFontSizeSmall"] - 2;
      Brush foreground = (Brush)Application.Current.Resources["PhoneForegroundBrush"];
      StackPanel sp = new StackPanel { Orientation = Orientation.Horizontal, Background = (Brush)Application.Current.Resources["PhoneSemitransparentBrush"] };
      currentMemoryBlock = new TextBlock { Text = "---", FontSize = fontSize, Foreground = foreground };
      peakMemoryBlock = new TextBlock { Text = "", FontSize = fontSize, Foreground = foreground, Margin = new Thickness(5, 0, 0, 0) };
      sp.Children.Add(currentMemoryBlock);
      sp.Children.Add(new TextBlock { Text = " kb", FontSize = fontSize, Foreground = foreground });
      sp.Children.Add(peakMemoryBlock);
      sp.RenderTransform = new CompositeTransform { Rotation = 90, TranslateX = 480, TranslateY = 425, CenterX = 0, CenterY = 0 };
      popup.Child = sp;
      popup.IsOpen = true;
    }

    private static void StartTimer(TimeSpan timespan)
    {
      timer = new DispatcherTimer();
      timer.Interval = timespan;
      timer.Tick += new EventHandler(timer_Tick);
      timer.Start();
    }

    static void timer_Tick(object sender, EventArgs e)
    {
      if (forceGc)
        GC.Collect();

      UpdateCurrentMemoryUsage();
      UpdatePeakMemoryUsage();
    }

    private static void UpdatePeakMemoryUsage()
    {
      if (alreadyFailedPeak)
        return;

      long peak = GetPeakMemoryUsage();
      if (peak >= MAX_MEMORY)
      {
        alreadyFailedPeak = true;
        Checkpoint("*MEMORY USAGE FAIL*");
        peakMemoryBlock.Text = "FAIL!";
        peakMemoryBlock.Foreground = new SolidColorBrush(Colors.Red);
        if (Debugger.IsAttached)
          Debug.Assert(false, "Peak memory condition violated");
      }
    }

    private static void UpdateCurrentMemoryUsage()
    {
      long mem = GetCurrentMemoryUsage();
      currentMemoryBlock.Text = string.Format("{0:N}", mem / 1024);
      int safetyBand = GetSafetyBand(mem);
      if (safetyBand != lastSafetyBand)
      {
        currentMemoryBlock.Foreground = GetBrushForSafetyBand(safetyBand);
        lastSafetyBand = safetyBand;
      }
    }

    private static Brush GetBrushForSafetyBand(int safetyBand)
    {
      switch (safetyBand)
      {
        case 0:
          return new SolidColorBrush(Colors.Green);

        case 1:
          return new SolidColorBrush(Colors.Orange);

        default:
          return new SolidColorBrush(Colors.Red);
      }
    }

    private static int GetSafetyBand(long mem)
    {
      double percent = (double)mem / (double)MAX_MEMORY;
      if (percent <= 0.75)
        return 0;

      if (percent <= 0.90)
        return 1;

      return 2;
    }

    private static void StopTimer()
    {
      timer.Stop();
      timer = null;
    }

    private static void HidePopup()
    {
      popup.IsOpen = false;
      popup = null;
    }
  }

  /// <summary>
  /// Holds checkpoint information for diagnosing memory usage
  /// </summary>
  public class MemoryCheckpoint
  {
    /// <summary>
    /// Creates a new instance
    /// </summary>
    /// <param name="text">Text for the checkpoint</param>
    /// <param name="memoryUsage">Memory usage at the time of the checkpoint</param>
    internal MemoryCheckpoint(string text, long memoryUsage)
    {
      Text = text;
      MemoryUsage = memoryUsage;
    }

    /// <summary>
    /// The text associated with this checkpoint
    /// </summary>
    public string Text { get; private set; }

    /// <summary>
    /// The memory usage at the time of the checkpoint
    /// </summary>
    public long MemoryUsage { get; private set; }
  }
}