This class will allow you to create a temp file and it will allow you write formatted output to the file. You can do things like ".Write( L"param %d", parameter1 );"

It's very easy to use this class, simply create an instance and call Register in the constructor of your App/Class. Then simply call Write/WriteLine to write to the log file. When you are done call UnRegister to close the file. Register/UnRegister functions are there to provide your class ref counting. This will be helpful when you have one global instance of this Logger but multiple classes are using it. In this scenario you only want to close & flush the file when all classes using this logger are gone. So make sure to call Register/UnRegister in Constructor/Destructor respectively.

DebugLogger logger;
logger.Register();
logger.Write( L"param %d", 123 );
logger.UnRegister();

Full Source code:

#pragma once
/******************************************************************************
*
* Author: Asim Goheer
*
* DebugLogger will allow you to write logs to local folder in 
* Windows Runtime C++ projects.
*
* This class will allow you to log everything to isolated storage(or local folder). Once all the 
* logging is done it will do proper clean-up and release the file.
* 
******************************************************************************/


#include <wrl/async.h>
#include "HStringOwner.h"
#include "CSOwner.h"
#include <time.h>

class DebugLogger
{
public:
   DebugLogger() : m_csNewLine( L"\r\n" )
   {
      InitializeCriticalSectionEx( &m_critSec, 0, 0 );
   }

   virtual ~DebugLogger()
   {
      DeleteCriticalSection( &m_critSec );
   }

   void Register()
   {
      CRITICAL_SECTION_OWNER( m_critSec );
      if( m_registerCount == 0 )
         Init();

      m_registerCount++;
   }

   void UnRegister()
   {
      if( !m_pDataWriter )
         return;

      Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IAsyncOperation< UINT32 > > pAsyncAction;
      m_pDataWriter->StoreAsync( &pAsyncAction );

      pAsyncAction->put_Completed( Microsoft::WRL::Callback< ABI::Windows::Foundation::IAsyncOperationCompletedHandler< UINT32 > >(
         [ this ] ( ABI::Windows::Foundation::IAsyncOperation< UINT32 >* pHandler, AsyncStatus status )
      {
         if( !pHandler || status != AsyncStatus::Completed )
            return S_OK;

         Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IAsyncOperation< bool > > pAsyncAction;
         m_pIIStream->FlushAsync( &pAsyncAction );

         pAsyncAction->put_Completed( Microsoft::WRL::Callback< ABI::Windows::Foundation::IAsyncOperationCompletedHandler< bool > >(
            [ this ] ( ABI::Windows::Foundation::IAsyncOperation< bool >* pHandler, AsyncStatus status )
         {
            if( !pHandler || status != AsyncStatus::Completed )
               return S_OK;

            CRITICAL_SECTION_OWNER( m_critSec );
            m_registerCount--;
            if( m_registerCount == 0 )
            {
               {
                  // close the file
                  Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IClosable > pICloseable;
                  HRESULT hr = m_pDataWriter.As< ABI::Windows::Foundation::IClosable >( &pICloseable );
                  if( SUCCEEDED( hr ) )
                     pICloseable->Close();
               }

               {
                  // close the file
                  Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IClosable > pICloseable;
                  HRESULT hr = m_pIIStream.As< ABI::Windows::Foundation::IClosable >( &pICloseable );
                  if( SUCCEEDED( hr ) )
                     pICloseable->Close();
               }

               {
                  // close the file
                  Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IClosable > pICloseable;
                  HRESULT hr = m_randomAccessStream.As< ABI::Windows::Foundation::IClosable >( &pICloseable );
                  if( SUCCEEDED( hr ) )
                     pICloseable->Close();
               }
            }

            return S_OK;
         } ).Get() );

         return S_OK;
      } ).Get() );
   }

   void WriteLine( wchar_t* wzString )
   {
      if( !m_pDataWriter )
         return;

      CRITICAL_SECTION_OWNER( m_critSec );

      HStringOwner csString( wzString );

      UINT32 length = 0;
      HRESULT hr = m_pDataWriter->WriteString( csString, &length );
      if( FAILED( hr ) )
         return;

      length = 0;
      hr = m_pDataWriter->WriteString( m_csNewLine, &length );
      if( FAILED( hr ) )
         return;
   }

   void Write( wchar_t* fmt, ... )
   {

      wchar_t szBuf[ 512 ];
      szBuf[ 0 ] = '\0';

      try
      {
         int nSize = 0;

         va_list args;
         va_start( args, fmt );
         nSize = _vsnwprintf_s( szBuf, _countof( szBuf ), _TRUNCATE, fmt, args ); // C4996
         va_end( args );

         WriteLine( szBuf );
      }
      catch( ... )
      {
         WriteLine( L"Exception" );
      }
   }

private:
   void Init()
   {
      {
         CRITICAL_SECTION_OWNER( m_critSec );

         if( initDone )
            return;

         initDone = true;
      }

      m_logFileCreatedEvent.Attach( CreateEventEx( nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS ) );

      if( SUCCEEDED( CreateLogFile() ) )
      {
         WaitForSingleObjectEx( m_logFileCreatedEvent.Get(), INFINITE, FALSE );
      }
   }

   void CreateLogFileError( HRESULT hr )
   {
      SetEvent( m_logFileCreatedEvent.Get() );
   }

   HRESULT CreateLogFile()
   {
      Microsoft::WRL::ComPtr< ABI::Windows::Storage::IApplicationDataStatics > applicationDataStatics;
      HRESULT hr = Windows::Foundation::GetActivationFactory( Microsoft::WRL::Wrappers::HStringReference( RuntimeClass_Windows_Storage_ApplicationData ).Get(), &applicationDataStatics );
      if( FAILED( hr ) )
      {
         return hr;
      }

      Microsoft::WRL::ComPtr< ABI::Windows::Storage::IApplicationData > applicationData;
      hr = applicationDataStatics->get_Current( &applicationData );
      if( FAILED( hr ) )
      {
         return hr;
      }

      Microsoft::WRL::ComPtr< ABI::Windows::Storage::IStorageFolder > storageFolder;
      hr = applicationData->get_LocalFolder( &storageFolder );
      if( FAILED( hr ) )
      {
         return hr;
      }

      HStringOwner logFileName( L"log.txt" );

      Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IAsyncOperation< ABI::Windows::Storage::StorageFile* > > pAsyncAction;
      hr = storageFolder->CreateFileAsync( logFileName,  ABI::Windows::Storage::CreationCollisionOption::CreationCollisionOption_ReplaceExisting, &pAsyncAction );
      if( FAILED( hr ) )
      {
         return hr;
      }

      pAsyncAction->put_Completed( Microsoft::WRL::Callback< ABI::Windows::Foundation::IAsyncOperationCompletedHandler< ABI::Windows::Storage::StorageFile* > >(
         [ this ] ( ABI::Windows::Foundation::IAsyncOperation< ABI::Windows::Storage::StorageFile* >* pHandler, AsyncStatus status )
         {
            if( pHandler == nullptr || status != AsyncStatus::Completed )
            {
               CreateLogFileError( E_ABORT );
               return S_OK;
            }

            ABI::Windows::Storage::IStorageFile* pStorageFile = nullptr;
            HRESULT hr = pHandler->GetResults( &pStorageFile );
            if( FAILED( hr ) || !pStorageFile )
            {
               CreateLogFileError( hr );
               return S_OK;
            }

            Microsoft::WRL::ComPtr< ABI::Windows::Foundation::IAsyncOperation< ABI::Windows::Storage::Streams::IRandomAccessStream* > > pAsyncAction;
            hr = pStorageFile->OpenAsync(  ABI::Windows::Storage::FileAccessMode::FileAccessMode_ReadWrite, &pAsyncAction );
            if( FAILED( hr ) )
            {
               CreateLogFileError( hr );
               return S_OK;
            }

            pAsyncAction->put_Completed( Microsoft::WRL::Callback< ABI::Windows::Foundation::IAsyncOperationCompletedHandler< ABI::Windows::Storage::Streams::IRandomAccessStream* > >(
               [ this ] ( ABI::Windows::Foundation::IAsyncOperation< ABI::Windows::Storage::Streams::IRandomAccessStream* >* pHandler, AsyncStatus status )
               {
                  if( pHandler == nullptr || status != AsyncStatus::Completed )
                  {
                     CreateLogFileError( E_ABORT );
                     return S_OK;
                  }

                  HRESULT hr = pHandler->GetResults( &m_randomAccessStream );
                  if( FAILED( hr ) || !m_randomAccessStream )
                  {
                     CreateLogFileError( hr );
                     return S_OK;
                  }

                  hr = m_randomAccessStream->GetOutputStreamAt( 0, &m_pIIStream );
                  if( FAILED( hr ) || !m_pIIStream )
                  {
                     CreateLogFileError( hr );
                     return S_OK;
                  }

                  CreateDataWriter( m_pIIStream );

                  wchar_t buffer[ 256 ];
                  GetCurrentDateTime( buffer, sizeof( buffer ) / sizeof( wchar_t ) );
                  Write( L"Log file created %s", buffer );

                  return S_OK;
               } ).Get() );

            return S_OK;

         } ).Get() );

      return S_OK;
   }

   void CreateDataWriter( Microsoft::WRL::ComPtr< ABI::Windows::Storage::Streams::IOutputStream >& pStream )
   {
      Microsoft::WRL::ComPtr< ABI::Windows::Storage::Streams::IDataWriter > dataWriter;

      Microsoft::WRL::ComPtr< ABI::Windows::Storage::Streams::IDataWriterFactory > data_writer_factory;
      HRESULT hr = Windows::Foundation::GetActivationFactory( Microsoft::WRL::Wrappers::HStringReference( RuntimeClass_Windows_Storage_Streams_DataWriter ).Get(), &data_writer_factory );
      if( FAILED( hr ) )
      {
         CreateLogFileError( hr );
         return;
      }

      hr = data_writer_factory->CreateDataWriter( *pStream.GetAddressOf(), &m_pDataWriter );
      if( FAILED( hr ) )
      {
         CreateLogFileError( hr );
         return;
      }

      SetEvent( m_logFileCreatedEvent.Get() );
   }

   void GetCurrentDateTime( wchar_t* wzBuffer, int wcBufferLen )
   {
      time_t now = time( 0 );
      struct tm tstruct;
      localtime_s( &tstruct, &now );
      wcsftime( wzBuffer, wcBufferLen, L"%Y-%m-%d.%X", &tstruct );
   }


private:
   CRITICAL_SECTION  m_critSec;
   HStringOwner m_csNewLine;

   Microsoft::WRL::Wrappers::Event m_logFileCreatedEvent;
   Microsoft::WRL::ComPtr< ABI::Windows::Storage::Streams::IDataWriter > m_pDataWriter;
   Microsoft::WRL::ComPtr< ABI::Windows::Storage::Streams::IRandomAccessStream > m_randomAccessStream;
   Microsoft::WRL::ComPtr< ABI::Windows::Storage::Streams::IOutputStream > m_pIIStream;

   int m_registerCount { 0 };
   bool initDone { false };
};


 

void DummyFunction()
{
 EnterCriticalSection( &m_cs );
 
 if( m_count == 0 )
 {
 // since we are returning early leave the critical section
 LeaveCriticalSection( &m_cs );
 return;
 }
 
 // do some dummy work here
 m_count = m_count + 1;
 CallingSomeDummyFunction();
 
 LeaveCriticalSection( &m_cs );
}

As you can see this solution is not very scalable, as every time you have to return early you will have to call "LeaveCriticalSection" otherwise you will deadlock. A very bad workaround that some developers use is to use "goto" statements. Look at the following example:

void DummyFunction()
{
 EnterCriticalSection( &m_cs );
 
 if( m_count == 0 )
 {
 goto done:
 }
 
 // do some dummy work here
 m_count = m_count + 1;
 CallingSomeDummyFunction();
 
done:
 LeaveCriticalSection( &m_cs );
}

This will simplify things because now you do not have to call "LeaveCriticalSection" every time you want to return early, but on the other hand you will be stuck with jumps to prehistoric-goto statements. Also this will make your code hard to follow.

Modern day solution to this problem will be to use a class that will manage the ownership of critical section (full source code of CriticalSectionOwner below).

void DummyFunction()
{
 CriticalSectionOwner csOwner( m_cs );
 
 if( m_count == 0 )
 return;
 
 // do some dummy work here
 m_count = m_count + 1;
 CallingSomeDummyFunction();
}

If you use "CriticalSectionOwner" wrapper class then you will not have to worry about cleanup-when-returning-early, cleanup-when-exceptions-happen, returning-values-from-your function. You can even write a small macro around this class so that you do not have to declare a variable every time. For example:

bool DummyFunction()
{
 CRITICAL_SECTION_OWNER( m_cs );
 
 if( m_count == 0 )
 return false;
 
 // do some dummy work here
 m_count = m_count + 1;
 CallingSomeDummyFunction();
 return true;
}

This will keep things simple and neat.

Full Source Code of CriticalSectionOwner:

#pragma once
 /******************************************************************************
 *
 * Author: Asim Goheer
 *
 * CriticalSectionOwner is a very lightweight helper class to make critical
 * section management easier. 
 *
 * This helper will guarantee proper cleanup, becase in case of an exception
 * it's destructor will run thus releasing critical section.
 * 
 * This helper will also allow you to return early from a function. Because
 * when you return early from a function the destructor will automatically
 * release critical section.
 *
 ******************************************************************************/
 
 class CriticalSectionOwner
 {
 public:
 // constructor
 CriticalSectionOwner( CRITICAL_SECTION& cs ) : m_cs( cs )
 {
 EnterCriticalSection( &m_cs );
 }
 
 // destructor
 ~CriticalSectionOwner()
 {
 LeaveCriticalSection( &m_cs );
 }
 
 private:
 // Disable copy constructor
 CriticalSectionOwner( const CriticalSectionOwner& ) = delete;
 
 private:
 CRITICAL_SECTION& m_cs;
 };
 
 // Define a macro that we can use
 #define CRITICAL_SECTION_OWNER( x ) CriticalSectionOwner csOwner( x );
 

Example: 

 WRL::ComPtr< Streams::IRandomAccessStream > randomAccessStream;
 // set randomAccessStream to something here.

 WRL::ComPtr< IClosable > pICloseable;
 HRESULT hr = randomAccessStream.As< IClosable >( &pICloseable );
 if( SUCCEEDED( hr ) )
 pICloseable->Close(); // Call Close on Stream

If you are just using pure C++ (without /CX) you will have to do lot more work to accomplish the same thing. Here is how you will do it:

 WRL::ComPtr< IAsyncOperation< Streams::IRandomAccessStream* > > pAsyncAction;
 IStorageFile* pStorageFile = nullptr; //we are assuming storageFolder is initialized in the next line before calling OpenAsync

 HRESULT hr = pStorageFile->OpenAsync( FileAccessMode::FileAccessMode_ReadWrite, &pAsyncAction );
 if( FAILED( hr ) )
 {
 // report error
 return E_FAIL;
 }
 
 pAsyncAction->put_Completed( Microsoft::WRL::Callback< IAsyncOperationCompletedHandler< Streams::IRandomAccessStream* > >(
 [ this ] ( IAsyncOperation< Streams::IRandomAccessStream* >* pHandler, AsyncStatus status )
 {
 // check status and use the stream here
 return S_OK;
 } ).Get() );
 
 return S_OK;
 
 } ).Get() );

C++ developers normally keep their strings in "wchar_t*" format, however Windows Runtime APIs require them in HSTRING format. APIs exists to convert between them, but you have to make sure that you call them properly, otherwise memory leaks will happen.

This class will management of HSTRINGs easier. You simply create a HStringOwner object on the stack. Once this object goes out of scope, it will be destroyed.

Benefits:

1. Easy creation of HSTRING
2. Lifetime management of HSTRING
3. Proper cleanup of HSTRING in case of exception
4. Allows you to return early from your function without running a block of code specifically for cleanup.

#pragma once
 /******************************************************************************
 *
 * Author : Asim Goheer
 *
 * HStringOwner is a very lightweight helper class to make HSTRING
 * management easier. 
 *
 * This helper will guarantee proper cleanup, becase in case of an exception
 * it's destructor will run thus releasing the string
 * 
 * This helper will also allow you to return early from a function. Because
 * when you return early from a function the destructor will automatically
 * release the string
 *
 ******************************************************************************/
 
 
 class HStringOwner
 {
 public:
 HStringOwner( wchar_t* wzSource )
 {
 HRESULT hr = WindowsCreateString( wzSource, wcslen( wzSource ), &m_hString );
 if( FAILED( hr ) )
 {
 // throw exception here
 }
 }
 
 virtual ~HStringOwner()
 {
 WindowsDeleteString( m_hString );
 }
 
 operator HSTRING () const
 {
 return m_hString;
 }
 
 private:
 HStringOwner( const HStringOwner& );
 
 HSTRING m_hString;
 };