How to append text to file in a UWP app

Question

I need to create a simple log class (just a "save to file" method) in a UWP app for debugging purpose but AppendTextAsync is much different from ofstream and I don't know how to use. This is my class

#pragma once
ref class winRTLog sealed
{
public:
    winRTLog();
    void save(Platform::String^ log);
private:
    Platform::String^ myFilename = L"myLog.txt";
    Windows::Storage::StorageFolder^ myFolder;
    Windows::Storage::StorageFile^ myFile;
    Windows::Foundation::IAsyncOperation<Windows::Storage::StorageFile^>^ createMyFile;
    concurrency::task<Windows::Storage::StorageFile^> myFileTask;
};

and here's the mess I've written so far trying to understand the documentation

#include "pch.h"
#include <ppltasks.h>   
#include "winRTLog.h"

winRTLog::winRTLog()
{
    myFolder = Windows::Storage::ApplicationData::Current->LocalFolder;
    createMyFile = myFolder->CreateFileAsync(myFilename, Windows::Storage::CreationCollisionOption::OpenIfExists);
    myFileTask = concurrency::create_task(myFolder->GetFileAsync(myFilename));
    //how to make myFile point the file I've created?
}

void winRTLog::save(Platform::String^ log)
{
    //?? 
    myFileTask.then([&]()
    {
        //how to use Windows::Storage::FileIO::AppendTextAsync
        //with myFile and log?
    });
}

The tag c++-cli is not that right, more along c++-cx – Gorice Sep 09 '16 at 10:12 — Gorice, Sep 09 '16 at 10:12

score 4 · Accepted Answer · answered Sep 10 '16 at 00:27

Don't use StorageFile APIs for saving data into local folder. Only use it if you need to: for APIs that require you passing them in a storage file or to access a place like pictures library which doesn't have a real path. StorageFile APIs are terribly slow compared to traditional APIs. Worst of all, all of the file operations are asynchronous, which means they're a pain to work with and even a bigger pain to debug.

For your scenario, I'd just use std::wofstream if you're familiar with it:

#include <fstream>

class winRTLog
{
public:
    winRTLog(Platform::String^ fileName);
    void save(Platform::String^ log);

private:
    std::wofstream m_OutStream;
};

winRTLog::winRTLog(Platform::String^ fileName) :
    m_OutStream(std::wstring(Windows::Storage::ApplicationData::Current->LocalFolder->Path->Data()) + L"\\" + fileName->Data(), std::ios::app)
{
    if (!m_OutStream.is_open())
        throw std::runtime_error("Failed to open the log file.");
}

void winRTLog::save(Platform::String^ log)
{
    m_OutStream << log->Data();
    if (m_OutStream.fail())
        throw std::runtime_error("Failed to write to the log file.");
}

Alternatively, you can use Win32 file APIs:

#include <memory>
#include <string>
#include <windows.h>

class winRTLog
{
public:
    winRTLog(Platform::String^ fileName);
    ~winRTLog();

    void save(Platform::String^ log);

private:
    HANDLE m_LogHandle;
};

winRTLog::winRTLog(Platform::String^ fileName)
{
    auto filePath = std::wstring(Windows::Storage::ApplicationData::Current->LocalFolder->Path->Data()) + L"\\" + fileName->Data();
    m_LogHandle = CreateFile2(filePath.c_str(), GENERIC_WRITE, 0, OPEN_ALWAYS, nullptr);
    if (m_LogHandle == INVALID_HANDLE_VALUE)
        throw std::runtime_error("Failed to open the log file: error code " + std::to_string(GetLastError()));

    if (SetFilePointer(m_LogHandle, 0, nullptr, FILE_END) == INVALID_SET_FILE_POINTER)
        throw std::runtime_error("Failed to set file pointer to the end of file: error code " + std::to_string(GetLastError()));
}

winRTLog::~winRTLog()
{
    if (m_LogHandle != INVALID_HANDLE_VALUE)
        CloseHandle(m_LogHandle);
}

void winRTLog::save(Platform::String^ log)
{
    // Convert to UTF8
    std::string utf8;
    utf8.resize(4 * log->Length());

    auto utf8Length = WideCharToMultiByte(CP_UTF8, 0, log->Data(), static_cast<int>(log->Length()), &utf8[0], static_cast<int>(4 * log->Length()), nullptr, nullptr);
    if (utf8Length == 0)
        throw std::runtime_error("Failed to convert log message to UTF8: error code " + std::to_string(GetLastError()));

    utf8.resize(utf8Length);

    // Write to actual log
    DWORD bytesWritten;
    auto writeResult = WriteFile(m_LogHandle, utf8.data(), static_cast<DWORD>(utf8.length()), &bytesWritten, nullptr);

    if (writeResult == FALSE || bytesWritten != utf8.length())
        throw std::runtime_error("Failed to write log message to the log file: error code " + std::to_string(GetLastError()));
}

Note, I used throwing std::runtime_error for error handling for example purposes: you might want to do it differently.

Thank you for the detailed answer. I tried the first solution, the file is created but nothing gets written on it (without throwing errors). Any idea why? — Gorice, Sep 10 '16 at 07:28
I tried both methods locally and they work for me. How much text do you write to the file? Maybe the contents are being buffered - did you try appending a line ending at the end of your message? You could also call .flush() on m_OutStream if you don't want buffering. Normally though, it gets flushed when you log a line ending or destroy the stream object. — Sunius, Sep 10 '16 at 09:38
Very few line of text, mainly numbers. Appending a line ending solved the problem. Thank you very much. — Gorice, Sep 10 '16 at 10:03
I used the second solution i.e. the winApi on windows 10 iot core (running on a raspberry pie). I needed to create a log file for a dll which is built with the app. I had been trying to use he StorageFile APIs but they are far too complex for what i needed to do. — drlolly, May 24 '23 at 14:11
I should also have said that the code was a UWP app. The dll was built as UW dll. — drlolly, May 24 '23 at 14:17

bunkerdive · Answer 2 · 2020-12-24T16:38:25.050

Based on the answer by @Sunius, but for C++/WinRT in a UWP app, noting that the log file will be in the %appdata%\..\Local\Packages\<YOUR_UWP_APP PACKAGE>\LocalState folder:

// WinRtLog.cpp
#include "WinRtLog.h"
#include "winrt/Windows.Storage.h"

using namespace winrt::Windows;

winRTLog::winRTLog(std::wstring fileName) :
    m_OutStream(std::wstring(Storage::ApplicationData::Current().LocalFolder().Path().data()) + L"\\" + fileName, std::ios::app)
{
    if (!m_OutStream.is_open())
        throw std::runtime_error("Failed to open the log file.");
}

void winRTLog::save(std::string log)
{
    m_OutStream << log.data();
    if (m_OutStream.fail())
        throw std::runtime_error("Failed to write to the log file.");
}

And the header:

// WinRtLog.h
#pragma once
#include <fstream>
#include "winrt/Windows.ApplicationModel.Core.h"

class winRTLog
{
    public:
        winRTLog(std::wstring fileName);
        void save(std::string log);

    private:
        std::wofstream m_OutStream;
};

Note that the broadFileSystemAccess capability is needed in your UWP Package.appxmanifest if the log file is to be stored in an arbitrary folder -- this capability must be set in code (the Appx GUI will not show it) as shown in this SO post.

How to append text to file in a UWP app

2 Answers2

Linked