UWP, c++\cx, Memory leak with file and folder management

Stefano Rosini 0 Reputation points

UWP application, c++\cx language, 10.0.17763.0 target platform: if I create a loop that creates and then destroys a directory then the committed memory of the process grows indefinitely. On a machine with 32GB of RAM and 1T of disk I got up to 5GB of occupied memory. How can I avoid this?

Windows 10
Windows 10
A Microsoft operating system that runs on personal computers and tablets.
10,588 questions
Universal Windows Platform (UWP)
{count} votes

2 answers

Sort by: Most helpful
  1. Wesley Li 4,275 Reputation points


    When dealing with memory leaks in a UWP application that creates and destroys directories, consider the following steps to prevent excessive memory usage:

    1.Properly Release Resources:

    When creating and destroying directories, ensure that you release any resources associated with them.

    Close file handles, dispose of objects, and unsubscribe from events.

    Failing to release resources can lead to memory leaks.

    2.Use Smart Pointers or RAII:

    In C++/CX, consider using smart pointers (such as Microsoft::WRL::ComPtr) or RAII (Resource Acquisition Is Initialization) patterns.

    Smart pointers automatically manage the lifetime of objects and release them when they go out of scope.

    RAII ensures that resources are properly released when an object is destroyed.

    3.Avoid Circular References:

    Circular references can prevent objects from being properly garbage collected.

    Be cautious when using event handlers, delegates, or other constructs that create references between objects.

    Use weak references (Platform::WeakReference) to break circular references.

    4.Check for Event Handlers and Subscriptions:

    If you’re subscribing to events (e.g., file system events), ensure that you unsubscribe when the object is no longer needed.

    Otherwise, the event handler may keep the object alive, leading to memory leaks.

    5.Profile and Monitor Memory Usage:

    Use memory profiling tools (e.g., Windows Performance Analyzer) to identify memory leaks.

    Monitor memory usage during the loop that creates and destroys directories.

    Look for patterns where memory usage keeps increasing.

    6.Verify Directory Cleanup:

    Double-check that the directories are being properly cleaned up after destruction.

    Ensure that any temporary files or subdirectories are also removed.

    7.Test on Different Platforms and Configurations:

    Test your UWP application on different Windows versions and configurations.

    Memory leak behavior may vary based on the OS version and other factors.

    8.Consider Using WinRT APIs:

    While C++/CX provides a bridge to WinRT, consider using WinRT APIs directly.

    WinRT APIs are designed with modern memory management in mind and may offer better memory handling.

    Memory leaks can be subtle and challenging to diagnose. Regularly review your code, use debugging tools, and follow best practices to minimize memory leaks.

    Note: The provided Python code is for illustrative purposes only and does not directly apply to UWP development.

    0 comments No comments

  2. Deleted

    This answer has been deleted due to a violation of our Code of Conduct. The answer was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.

    Comments have been turned off. Learn more