앱이 백그라운드로 이동할 때 메모리 회수Free memory when your app moves to the background

이 문서에서는 일시 중단 및 종료 되지 않도록 백그라운드 상태로 이동할 때 앱에서 사용 하는 메모리 양을 줄이는 방법을 보여 줍니다.This article shows you how to reduce the amount of memory that your app uses when it moves to the background state so that it won't be suspended and possibly terminated.

새 백그라운드 이벤트New background events

Windows 10 버전 1607에는 두 가지 새로운 응용 프로그램 수명 주기 이벤트 인 이벤트, 즉 Enteredbackgroundleavingbackground이 도입 되었습니다.Windows 10, version 1607, introduces two new application lifecycle events, EnteredBackground and LeavingBackground. 이러한 이벤트를 통해 앱이 시작 되 고 배경을 벗어날 때이를 알 수 있습니다.These events let your app know when it is entering and leaving the background.

앱이 백그라운드로 이동 하면 시스템에서 적용 하는 메모리 제약 조건이 변경 될 수 있습니다.When your app moves into the background, the memory constraints enforced by the system may change. 이러한 이벤트를 사용 하 여 응용 프로그램이 백그라운드에서 일시 중단 되 고 종료 될 수 있도록 제한 보다 낮게 유지 하기 위해 현재 메모리 사용량과 사용 가능한 리소스를 확인 합니다.Use these events to check your current memory consumption and free resources in order to stay below the limit so that your app won't be suspended and possibly terminated while it is in the background.

앱 메모리 사용량을 제어 하기 위한 이벤트Events for controlling your app's memory usage

AppMemoryUsageLimitChanging 는 앱에서 사용할 수 있는 총 메모리 한도가 변경 되기 직전에 발생 합니다.MemoryManager.AppMemoryUsageLimitChanging is raised just before the limit of total memory the app can use is changed. 예를 들어 앱이 배경으로 이동 하 고 Xbox에서 메모리 제한은 1024MB에서 128MB로 변경 됩니다.For example, when the app moves into the background and on the Xbox the memory limit changes from 1024MB to 128MB.
이 이벤트는 플랫폼에서 앱을 일시 중단 하거나 종료 하는 것을 방지 하기 위해 처리 하는 가장 중요 한 이벤트입니다.This is the most important event to handle to keep the platform from suspending or terminating the app.

AppMemoryUsageIncreased 는 응용 프로그램의 메모리 소비가 AppMemoryUsageLevel 열거에서 더 높은 값으로 증가 했을 때 발생 합니다.MemoryManager.AppMemoryUsageIncreased is raised when the app's memory consumption has increased to a higher value in the AppMemoryUsageLevel enumeration. 예를 들어, 낮음 에서 중간까지입니다.For example, from Low to Medium. 이 이벤트를 처리 하는 것은 선택 사항 이지만 응용 프로그램이 여전히 제한을 초과 하는 경우에는 권장 됩니다.Handling this event is optional but recommended because the application is still responsible for staying under the limit.

AppMemoryUsageDecreased 는 응용 프로그램의 메모리 소비가 AppMemoryUsageLevel 열거에서 더 낮은 값으로 감소할 때 발생 합니다.MemoryManager.AppMemoryUsageDecreased is raised when the app's memory consumption has decreased to a lower value in the AppMemoryUsageLevel enumeration. 예를 들어, High 에서 Low사이입니다.For example, from High to Low. 이 이벤트를 처리 하는 것은 선택 사항 이지만 필요한 경우 응용 프로그램에서 추가 메모리를 할당할 수 있음을 나타냅니다.Handling this event is optional but indicates the application may be able to allocate additional memory if needed.

포그라운드 및 백그라운드 간 전환 처리Handle the transition between foreground and background

앱이 포그라운드에서 배경으로 이동 하면, 사용자의 배경 이벤트가 발생 합니다.When your app moves from the foreground to the background, the EnteredBackground event is raised. 앱이 포그라운드로 반환 되 면 Leavingbackground 이벤트가 발생 합니다.When your app returns to the foreground, the LeavingBackground event is raised. 앱을 만들 때 이러한 이벤트에 대 한 처리기를 등록할 수 있습니다.You can register handlers for these events when your app is created. 기본 프로젝트 템플릿에서는 App.xaml.cs의 App class 생성자에서이 작업을 수행 합니다.In the default project template, this is done in the App class constructor in App.xaml.cs.

백그라운드에서 실행 하면 앱이 유지할 수 있는 메모리 리소스가 줄어들지만, 앱의 현재 메모리 사용량과 현재 제한을 확인 하는 데 사용할 수 있는 AppMemoryUsageIncreasedAppMemoryUsageLimitChanging 이벤트에도 등록 해야 합니다.Because running in the background will reduce the memory resources your app is allowed to retain, you should also register for the AppMemoryUsageIncreased and AppMemoryUsageLimitChanging events which you can use to check your app's current memory usage and the current limit. 이러한 이벤트에 대 한 처리기는 다음 예제에 나와 있습니다.The handlers for these events are shown in the following examples. UWP 앱의 응용 프로그램 수명 주기에 대 한 자세한 내용은 앱 수명 주기를 참조 하세요.For more information on the application lifecycle for UWP apps, see App lifecycle.

public App()
{
    this.InitializeComponent();

    this.Suspending += OnSuspending;

    // Subscribe to key lifecyle events to know when the app
    // transitions to and from foreground and background.
    // Leaving the background is an important transition
    // because the app may need to restore UI.
    this.EnteredBackground += AppEnteredBackground;
    this.LeavingBackground += AppLeavingBackground;

    // During the transition from foreground to background the
    // memory limit allowed for the application changes. The application
    // has a short time to respond by bringing its memory usage
    // under the new limit.
    Windows.System.MemoryManager.AppMemoryUsageLimitChanging += MemoryManager_AppMemoryUsageLimitChanging;

    // After an application is backgrounded it is expected to stay
    // under a memory target to maintain priority to keep running.
    // Subscribe to the event that informs the app of this change.
    Windows.System.MemoryManager.AppMemoryUsageIncreased += MemoryManager_AppMemoryUsageIncreased;
}

지정 된 background 이벤트를 발생 시키면 현재 백그라운드에서 실행 중임을 나타내기 위해 추적 변수를 설정 합니다.When the EnteredBackground event is raised, set the tracking variable to indicate that you are currently running in the background. 이는 메모리 사용을 줄이기 위해 코드를 작성할 때 유용 합니다.This will be useful when you write the code for reducing memory usage.

/// <summary>
/// The application entered the background.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AppEnteredBackground(object sender, EnteredBackgroundEventArgs e)
{
    _isInBackgroundMode = true;

    // An application may wish to release views and view data
    // here since the UI is no longer visible.
    //
    // As a performance optimization, here we note instead that
    // the app has entered background mode with _isInBackgroundMode and
    // defer unloading views until AppMemoryUsageLimitChanging or
    // AppMemoryUsageIncreased is raised with an indication that
    // the application is under memory pressure.
}

앱이 백그라운드로 전환 되 면 시스템은 응용 프로그램에 대 한 메모리 제한을 줄여 현재 포그라운드 앱에 응답성이 뛰어난 사용자 환경을 제공 하기에 충분 한 리소스가 있는지 확인 합니다.When your app transitions to the background, the system reduces the memory limit for the app to ensure that the current foreground app has sufficient resources to provide a responsive user experience

AppMemoryUsageLimitChanging 이벤트 처리기를 사용 하면 할당 된 메모리가 감소 되었음을 앱에 알려 주고 처리기에 전달 된 이벤트 인수에 새 제한을 제공할 수 있습니다.The AppMemoryUsageLimitChanging event handler lets your app know that its allotted memory has been reduced and provides the new limit in the event arguments passed into the handler. 앱의 현재 사용량을 제공 하는 AppMemoryUsage 속성을 이벤트 인수의 newlimit 속성에 비교 합니다 .이 속성은 새 제한을 지정 합니다.Compare the MemoryManager.AppMemoryUsage property, which provides your app's current usage, to the NewLimit property of the event arguments, which specifies the new limit. 메모리 사용량이 제한을 초과 하는 경우 메모리 사용량을 줄여야 합니다.If your memory usage exceeds the limit, you need to reduce your memory usage.

이 예제에서이 작업은이 문서의 뒷부분에서 정의 되는 도우미 메서드 ReduceMemoryUsage에서 수행 됩니다.In this example, this is done in the helper method ReduceMemoryUsage, which is defined later in this article.

/// <summary>
/// Raised when the memory limit for the app is changing, such as when the app
/// enters the background.
/// </summary>
/// <remarks>
/// If the app is using more than the new limit, it must reduce memory within 2 seconds
/// on some platforms in order to avoid being suspended or terminated.
///
/// While some platforms will allow the application
/// to continue running over the limit, reducing usage in the time
/// allotted will enable the best experience across the broadest range of devices.
/// </remarks>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MemoryManager_AppMemoryUsageLimitChanging(object sender, AppMemoryUsageLimitChangingEventArgs e)
{
    // If app memory usage is over the limit, reduce usage within 2 seconds
    // so that the system does not suspend the app
    if (MemoryManager.AppMemoryUsage >= e.NewLimit)
    {
        ReduceMemoryUsage(e.NewLimit);
    }
}

참고

일부 장치 구성을 사용 하면 시스템에서 리소스 압력을 발생 시킬 때까지 응용 프로그램을 새 메모리 제한을 초과 하 여 계속 실행할 수 있으며 일부는 그렇지 않습니다.Some device configurations will allow an application to continue running over the new memory limit until the system experiences resource pressure, and some will not. 특히 Xbox에서 2 초 내에 새 제한에 따라 메모리를 줄이지 않는 경우 앱이 일시 중단 되거나 종료 됩니다.On Xbox, in particular, apps will be suspended or terminated if they do not reduce memory to under the new limits within 2 seconds. 즉,이 이벤트를 사용 하 여 가장 넓은 범위의 장치에서 최상의 환경을 제공할 수 있습니다 .이 이벤트는 발생 하는 이벤트의 2 초 이내에 리소스 사용량을 줄입니다.This means that you can deliver the best experience across the broadest range of devices by using this event to reduce resource usage below the limit within 2 seconds of the event being raised.

응용 프로그램의 메모리 사용량이 현재 백그라운드로 전환 될 때 백그라운드 앱에 대 한 메모리 제한을 초과 하는 경우 시간이 지남에 따라 메모리 사용이 증가 하 고 제한에 접근 하기 시작할 수 있습니다.It is possible that although your app's memory usage is currently under the memory limit for background apps when it first transitions to the background, it may increase its memory consumption over time and begin to approach the limit. AppMemoryUsageIncreased 는 현재 사용 중인 사용을 확인 하 고 필요한 경우 메모리를 확보할 수 있는 기회를 제공 합니다.The handler the AppMemoryUsageIncreased provides an opportunity to check your current usage when it increases and, if necessary, free memory.

AppMemoryUsageLevel 가 크거나 상한 인지 확인 하 고, 있는 경우 메모리 사용량을 줄입니다.Check to see if the AppMemoryUsageLevel is High or OverLimit, and if so, reduce your memory usage. 이 예제에서는 도우미 메서드인 ReduceMemoryUsage에서이를 처리 합니다.In this example this is handled by the helper method, ReduceMemoryUsage. AppMemoryUsageDecreased 이벤트를 구독 하 고, 앱이 제한에 도달 하 고 있는지 확인 하 고, 그렇다면 추가 리소스를 할당할 수 있습니다.You can also subscribe to the AppMemoryUsageDecreased event, check to see if your app is under the limit, and if so then you know you can allocate additional resources.

/// <summary>
/// Handle system notifications that the app has increased its
/// memory usage level compared to its current target.
/// </summary>
/// <remarks>
/// The app may have increased its usage or the app may have moved
/// to the background and the system lowered the target for the app
/// In either case, if the application wants to maintain its priority
/// to avoid being suspended before other apps, it may need to reduce
/// its memory usage.
///
/// This is not a replacement for handling AppMemoryUsageLimitChanging
/// which is critical to ensure the app immediately gets below the new
/// limit. However, once the app is allowed to continue running and
/// policy is applied, some apps may wish to continue monitoring
/// usage to ensure they remain below the limit.
/// </remarks>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MemoryManager_AppMemoryUsageIncreased(object sender, object e)
{
    // Obtain the current usage level
    var level = MemoryManager.AppMemoryUsageLevel;

    // Check the usage level to determine whether reducing memory is necessary.
    // Memory usage may have been fine when initially entering the background but
    // the app may have increased its memory usage since then and will need to trim back.
    if (level == AppMemoryUsageLevel.OverLimit || level == AppMemoryUsageLevel.High)
    {
        ReduceMemoryUsage(MemoryManager.AppMemoryUsageLimit);
    }
}

ReduceMemoryUsage 는 백그라운드에서 실행 하는 동안 앱이 사용 제한을 초과 하는 경우 메모리를 해제 하기 위해 구현할 수 있는 도우미 메서드입니다.ReduceMemoryUsage is a helper method that you can implement to release memory when your app is over the usage limit while running in the background. 메모리를 해제 하는 방법은 앱의 세부 사항에 따라 달라 지지만 메모리를 확보 하는 데 권장 되는 방법 중 하나는 UI와 앱 보기와 관련 된 기타 리소스를 삭제 하는 것입니다.How you release memory depends on the specifics of your app, but one recommended way to free up memory is to dispose of your UI and the other resources associated with your app view. 이렇게 하려면 백그라운드 상태에서 실행 중인지 확인 하 고, 앱 창의 Content 속성을로 설정 하 null 고, UI 이벤트 처리기의 등록을 취소 하 고 페이지에 있을 수 있는 다른 모든 참조를 제거 합니다.To do so, ensure that you are running in the background state then set the Content property of your app's window to null and unregister your UI event handlers and remove any other references you may have to the page. UI 이벤트 처리기의 등록을 취소 하 고 페이지에 있을 수 있는 다른 참조를 지우면 페이지 리소스가 해제 되지 않습니다.Failing to unregister your UI event handlers and clearing any other references you may have to the page will prevent the page resources from being released. 그런 다음 GC를 호출 합니다. 을 수집 하 여 확보 된 메모리를 즉시 회수 합니다.Then call GC.Collect to reclaim the freed up memory immediately. 일반적으로 시스템에서 사용자에 대해 처리 하기 때문에 가비지 수집을 강제 적용 하지 않습니다.Typically you don't force garbage collection because the system will take care of it for you. 이 특정 경우에는 시스템에서 메모리를 회수할 수 있도록 응용 프로그램을 종료 해야 하는 가능성을 줄이기 위해 백그라운드에 전환 될 때이 응용 프로그램에 부과 되는 메모리의 양을 줄일 수 있습니다.In this specific case, we are reducing the amount of memory charged to this application as it goes into the background to reduce the likelihood that the system will determine that it should terminate the app to reclaim memory.

/// <summary>
/// Reduces application memory usage.
/// </summary>
/// <remarks>
/// When the app enters the background, receives a memory limit changing
/// event, or receives a memory usage increased event, it can
/// can optionally unload cached data or even its view content in
/// order to reduce memory usage and the chance of being suspended.
///
/// This must be called from multiple event handlers because an application may already
/// be in a high memory usage state when entering the background, or it
/// may be in a low memory usage state with no need to unload resources yet
/// and only enter a higher state later.
/// </remarks>
public void ReduceMemoryUsage(ulong limit)
{
    // If the app has caches or other memory it can free, it should do so now.
    // << App can release memory here >>

    // Additionally, if the application is currently
    // in background mode and still has a view with content
    // then the view can be released to save memory and
    // can be recreated again later when leaving the background.
    if (isInBackgroundMode && Window.Current.Content != null)
    {
        // Some apps may wish to use this helper to explicitly disconnect
        // child references.
        // VisualTreeHelper.DisconnectChildrenRecursive(Window.Current.Content);

        // Clear the view content. Note that views should rely on
        // events like Page.Unloaded to further release resources.
        // Release event handlers in views since references can
        // prevent objects from being collected.
        Window.Current.Content = null;
    }

    // Run the GC to collect released resources.
    GC.Collect();
}

창 콘텐츠가 수집 되 면 각 프레임은 연결 끊기 프로세스를 시작 합니다.When the window content is collected, each Frame begins its disconnection process. 시각적 개체 트리의 창 내용 아래에 페이지가 있으면 언로드된 이벤트를 발생 시킵니다.If there are Pages in the visual object tree under the window content, these will begin firing their Unloaded event. 페이지에 대 한 모든 참조가 제거 되지 않으면 페이지를 메모리에서 완전히 지울 수 없습니다.Pages cannot be completely cleared from memory unless all references to them are removed. 언로드된 콜백에서 다음 작업을 수행 하 여 메모리를 빠르게 해제할 수 있습니다.In the Unloaded callback, do the following to ensure that memory is quickly freed:

  • 페이지의 모든 대량 데이터 구조를 지우고로 설정 null 합니다.Clear and set any large data structures in your Page to null.
  • 페이지 내에 콜백 메서드가 있는 모든 이벤트 처리기를 등록 취소 합니다.Unregister all event handlers that have callback methods within the Page. 페이지에 대해 로드 된 이벤트 처리기 중에 이러한 콜백을 등록 해야 합니다.Make sure to register those callbacks during the Loaded event handler for the Page. 로드 된 이벤트는 UI가 다시 구성 고 페이지가 시각적 개체 트리에 추가 되었을 때 발생 합니다.The Loaded event is raised when the UI has been reconstituted and the Page has been added to the visual object tree.
  • GC.Collect방금 설정한 모든 대량 데이터 구조를 빠르게 수집 하기 위해 언로드된 콜백의 끝에서를 호출 null 합니다.Call GC.Collect at the end of the Unloaded callback to quickly garbage collect any of the large data structures you have just set to null. 다시 말하지만, 일반적으로 시스템이 사용자를 위해 처리 하기 때문에 가비지 수집을 강제 적용 하지 않습니다.Again, typically you don't force garbage collection because the system will take care of it for you. 이 특정 경우에는 시스템에서 메모리를 회수할 수 있도록 응용 프로그램을 종료 해야 하는 가능성을 줄이기 위해 백그라운드에 전환 될 때이 응용 프로그램에 부과 되는 메모리의 양을 줄일 수 있습니다.In this specific case, we are reducing the amount of memory charged to this application as it goes into the background to reduce the likelihood that the system will determine that it should terminate the app to reclaim memory.
private void MainPage_Unloaded(object sender, RoutedEventArgs e)
{
   // << free large data sructures and set them to null, here >>

   // Disconnect event handlers for this page so that the garbage
   // collector can free memory associated with the page
   Window.Current.Activated -= Current_Activated;
   GC.Collect();
}

Leavingbackground 이벤트 처리기에서 추적 변수 ()를 설정 isInBackgroundMode 하 여 앱이 백그라운드에서 더 이상 실행 되지 않음을 표시 합니다.In the LeavingBackground event handler, set the tracking variable (isInBackgroundMode) to indicate that your app is no longer running in the background. 다음으로, Content null 백그라운드에서 실행 하는 동안 메모리를 지우도록 응용 프로그램 보기를 삭제 한 경우 현재 창의 콘텐츠가 인지 확인 합니다.Next, check to see if the Content of the current window is null-- which it will be if you disposed of your app views in order to clear up memory while you were running in the background. 창 콘텐츠가 인 경우 null 앱 보기를 다시 빌드합니다.If the window content is null, rebuild your app view. 이 예제에서는 도우미 메서드 CreateRootFrame에 창 콘텐츠가 만들어집니다.In this example, the window content is created in the helper method CreateRootFrame.

/// <summary>
/// The application is leaving the background.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AppLeavingBackground(object sender, LeavingBackgroundEventArgs e)
{
    // Mark the transition out of the background state
    _isInBackgroundMode = false;

    // Restore view content if it was previously unloaded
    if (Window.Current.Content == null)
    {
        CreateRootFrame(ApplicationExecutionState.Running, string.Empty);
    }
}

CreateRootFrame helper 메서드는 앱에 대 한 보기 콘텐츠를 다시 만듭니다.The CreateRootFrame helper method recreates the view content for your app. 이 메서드의 코드는 기본 프로젝트 템플릿에 제공 된 Onlaunched 된 처리기 코드와 거의 동일 합니다.The code in this method is nearly identical to the OnLaunched handler code provided in the default project template. 한 가지 차이점은 시작 처리기가 LaunchActivatedEventArgsPreviousExecutionState 속성에서 이전 실행 상태를 결정 하 고 CreateRootFrame 메서드는 단순히 인수로 전달 된 이전 실행 상태를 가져오는 것입니다.The one difference is that the Launching handler determines the previous execution state from the PreviousExecutionState property of the LaunchActivatedEventArgs and the CreateRootFrame method simply gets the previous execution state passed in as an argument. 중복 된 코드를 최소화 하기 위해 기본 시작 이벤트 처리기 코드를 리팩터링하여 CreateRootFrame을 호출할 수 있습니다.To minimize duplicated code, you can refactor the default Launching event handler code to call CreateRootFrame.

void CreateRootFrame(ApplicationExecutionState previousExecutionState, string arguments)
{
    Frame rootFrame = Window.Current.Content as Frame;

    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null)
    {
        // Create a Frame to act as the navigation context and navigate to the first page
        rootFrame = new Frame();

        // Set the default language
        rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];

        rootFrame.NavigationFailed += OnNavigationFailed;

        if (previousExecutionState == ApplicationExecutionState.Terminated)
        {
            //TODO: Load state from previously suspended application
        }

        // Place the frame in the current Window
        Window.Current.Content = rootFrame;
    }

    if (rootFrame.Content == null)
    {
        // When the navigation stack isn't restored navigate to the first page,
        // configuring the new page by passing required information as a navigation
        // parameter
        rootFrame.Navigate(typeof(MainPage), arguments);
    }
}

지침Guidelines

전경에서 배경으로 이동Moving from the foreground to the background

앱이 포그라운드에서 백그라운드로 이동 하는 경우 시스템은 백그라운드에서 필요 하지 않은 리소스를 확보 하기 위해 앱을 대신 하 여 작동 합니다.When an app moves from the foreground to the background, the system does work on behalf of the app to free up resources that are not needed in the background. 예를 들어, UI 프레임 워크는 캐시 된 질감을 플러시하고 비디오 하위 시스템은 앱을 대신 하 여 할당 된 메모리를 해제 합니다.For example, the UI frameworks flush cached textures and the video subsystem frees memory allocated on behalf of the app. 그러나 응용 프로그램은 시스템에 의해 일시 중단 되거나 종료 되는 것을 방지 하기 위해 메모리 사용을 신중 하 게 모니터링 해야 합니다.However, an app will still need to carefully monitor its memory usage to avoid being suspended or terminated by the system.

앱이 포그라운드에서 배경으로 이동 하면 먼저 AppMemoryUsageLimitChanging 이벤트가 발생 하 고,이 이벤트가 발생 합니다.When an app moves from the foreground to the background it will first get an EnteredBackground event and then a AppMemoryUsageLimitChanging event.

  • 응용 프로그램을 백그라운드에서 실행 하는 동안 필요 하지 않은 UI 리소스를 확보 하기 위해 사용자의 응용 프로그램 을 사용 합니다 .Do use the EnteredBackground event to free up UI resources that you know your app does not need while running in the background. 예를 들어, 노래의 커버 아트 이미지를 해제할 수 있습니다.For example, you could free the cover art image for a song.
  • AppMemoryUsageLimitChanging 이벤트 를 사용 하 여 앱 이 새 백그라운드 제한 보다 더 작은 메모리를 사용 하 고 있는지 확인 합니다.Do use the AppMemoryUsageLimitChanging event to ensure that your app is using less memory than the new background limit. 그렇지 않으면 리소스를 확보 해야 합니다.Make sure that you free up resources if not. 이렇게 하지 않으면 장치 특정 정책에 따라 앱이 일시 중단 되거나 종료 될 수 있습니다.If you do not, your app may be suspended or terminated according to device specific policy.
  • AppMemoryUsageLimitChanging 이벤트가 발생할 때 앱이 새 메모리 제한을 초과 하는 경우 가비지 수집기 를 수동으로 호출 합니다.Do manually invoke the garbage collector if your app is over the new memory limit when the AppMemoryUsageLimitChanging event is raised.
  • 변경 해야 하는 경우 백그라운드에서 실행 하는 동안 앱의 메모리 사용량을 계속 모니터링 하려면 AppMemoryUsageIncreased 이벤트 를 사용 합니다 .Do use the AppMemoryUsageIncreased event to continue to monitor your app’s memory usage while running in the background if you expect it to change. AppMemoryUsageLevel 가 크거나 같은 경우 리소스를 확보 해야 합니다 .If the AppMemoryUsageLevel is High or OverLimit make sure that you free up resources.
  • AppMemoryUsageLimitChanging 이벤트 처리기에서 UI 리소스를 해제 하는 것이 성능 최적화로 서는 안 됩니다.Consider freeing UI resources in the AppMemoryUsageLimitChanging event handler instead of in the EnteredBackground handler as a performance optimization. 앱이 배경 또는 전경에 있는지 여부를 추적 하는 데 사용할 수 있는 부울 값을 지정 합니다.Use a boolean value set in the EnteredBackground/LeavingBackground event handlers to track whether the app is in the background or foreground. 그런 다음 AppMemoryUsageLimitChanging 이벤트 처리기에서 AppMemoryUsage 가 제한을 초과 하 고 앱이 백그라운드 (부울 값을 기반으로) 인 경우 UI 리소스를 해제할 수 있습니다.Then in the AppMemoryUsageLimitChanging event handler, if AppMemoryUsage is over the limit and the app is in the background (based on the Boolean value) you can free UI resources.
  • 응용 프로그램 간의 전환이 사용자에 게 느리게 EnteredBackground 표시 될 수 있기 때문에 사용자에 게 장기 실행 작업을 수행 하지 마십시오 .Do not perform long running operations in the EnteredBackground event because you can cause the transition between applications to appear slow to the user.

백그라운드에서 전경으로 이동Moving from the background to the foreground

앱이 백그라운드에서 포그라운드로 이동할 때 앱은 먼저 AppMemoryUsageLimitChanging 이벤트와 Leavingbackground 이벤트를 가져옵니다.When an app moves from the background to the foreground, the app will first get an AppMemoryUsageLimitChanging event and then a LeavingBackground event.

  • Leavingbackground 이벤트 를 사용 하 여 백그라운드 로 이동할 때 앱이 삭제 한 UI 리소스를 다시 만듭니다.Do use the LeavingBackground event to recreate UI resources that your app discarded when moving into the background.
  • 백그라운드 미디어 재생 샘플 -앱이 백그라운드 상태로 이동할 때 메모리를 해제 하는 방법을 보여 줍니다.Background media playback sample - shows how to free memory when your app moves to the background state.
  • 진단 도구 -진단 도구를 사용 하 여 가비지 수집 이벤트를 관찰 하 고 앱에서 원하는 방식으로 메모리를 해제 하 고 있는지 확인 합니다.Diagnostic Tools - use the diagnostic tools to observe garbage collection events and validate that your app is releasing memory the way you expect it to.