/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see
/// </para>
/// <para>Alternatives to using Transactional NTFS</para>
/// <para>.]</para>
/// <para>
/// Copies an existing file to a new file as a transacted operation, notifying the application of its progress through a callback function.
/// </para>
/// </summary>
/// <param name="lpExistingFileName">
/// <para>The name of an existing file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// <para>If does not exist, the <c>CopyFileTransacted</c> function fails, and the GetLastError function returns <c>ERROR_FILE_NOT_FOUND</c>.</para>
/// <para>The file must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="lpNewFileName">
/// <para>The name of the new file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpProgressRoutine">
/// <para>
/// The address of a callback function of type <c>LPPROGRESS_ROUTINE</c> that is called each time another portion of the file has
/// been copied. This parameter can be <c>NULL</c>. For more information on the progress callback function, see the
/// CopyProgressRoutine function.
/// </para>
/// </param>
/// <param name="lpData">
/// <para>The argument to be passed to the callback function. This parameter can be <c>NULL</c>.</para>
/// </param>
/// <param name="pbCancel">
/// <para>
/// If this flag is set to <c>TRUE</c> during the copy operation, the operation is canceled. Otherwise, the copy operation will
/// continue to completion.
/// </para>
/// </param>
/// <param name="dwCopyFlags">
/// <para>Flags that specify how the file is to be copied. This parameter can be a combination of the following values.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see
/// </para>
/// <para>Alternatives to using Transactional NTFS</para>
/// <para>.]</para>
/// <para>
/// Creates a new directory as a transacted operation, with the attributes of a specified template directory. If the underlying file
/// system supports security on files and directories, the function applies a specified security descriptor to the new directory. The
/// new directory retains the other attributes of the specified template directory.
/// </para>
/// </summary>
/// <param name="lpTemplateDirectory">
/// <para>The path of the directory to use as a template when creating the new directory. This parameter can be <c>NULL</c>.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// <para>The directory must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="lpNewDirectory">
/// <para>The path of the directory to be created.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpSecurityAttributes">
/// <para>
/// A pointer to a SECURITY_ATTRIBUTES structure. The <c>lpSecurityDescriptor</c> member of the structure specifies a security
/// descriptor for the new directory.
/// </para>
/// <para>
/// If is <c>NULL</c>, the directory gets a default security descriptor. The access control lists (ACL) in the default security
/// descriptor for a directory are inherited from its parent directory.
/// </para>
/// <para>
/// The target file system must support security on files and directories for this parameter to have an effect. This is indicated
/// when GetVolumeInformation returns <c>FS_PERSISTENT_ACLS</c>.
/// </para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>
/// If the function fails, the return value is zero (0). To get extended error information, call GetLastError. Possible errors
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see
/// </para>
/// <para>Alternatives to using Transactional NTFS</para>
/// <para>.]</para>
/// <para>
/// Creates or opens a file, file stream, or directory as a transacted operation. The function returns a handle that can be used to
/// access the object.
/// </para>
/// <para>
/// To perform this operation as a non-transacted operation or to access objects other than files (for example, named pipes, physical
/// devices, mailslots), use the CreateFile function.
/// </para>
/// <para>For more information about transactions, see the Remarks section of this topic.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of an object to be created or opened.</para>
/// <para>The object must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File. For
/// information on special device names, see Defining an MS-DOS Device Name.
/// </para>
/// <para>
/// To create a file stream, specify the name of the file, a colon, and then the name of the stream. For more information, see File Streams.
/// </para>
/// </param>
/// <param name="dwDesiredAccess">
/// <para>
/// The access to the object, which can be summarized as read, write, both or neither (zero). The most commonly used values are
/// <c>GENERIC_READ</c>, <c>GENERIC_WRITE</c>, or both ( <c>GENERIC_READ</c> | <c>GENERIC_WRITE</c>). For more information, see
/// Generic Access Rights and File Security and Access Rights.
/// </para>
/// <para>
/// If this parameter is zero, the application can query file, directory, or device attributes without accessing that file or device.
/// For more information, see the Remarks section of this topic.
/// </para>
/// <para>
/// You cannot request an access mode that conflicts with the sharing mode that is specified in an open request that has an open
/// handle. For more information, see Creating and Opening Files.
/// </para>
/// </param>
/// <param name="dwShareMode">
/// <para>The sharing mode of an object, which can be read, write, both, delete, all of these, or none (refer to the following table).</para>
/// <para>
/// If this parameter is zero and <c>CreateFileTransacted</c> succeeds, the object cannot be shared and cannot be opened again until
/// the handle is closed. For more information, see the Remarks section of this topic.
/// </para>
/// <para>
/// You cannot request a sharing mode that conflicts with the access mode that is specified in an open request that has an open
/// handle, because that would result in the following sharing violation: <c>ERROR_SHARING_VIOLATION</c>. For more information, see
/// Creating and Opening Files.
/// </para>
/// <para>
/// To enable a process to share an object while another process has the object open, use a combination of one or more of the
/// following values to specify the access mode they can request to open the object.
/// </para>
/// <para>
/// <c>Note</c> The sharing options for each open handle remain in effect until that handle is closed, regardless of process context.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>0 0x00000000</term>
/// <term>Disables subsequent open operations on an object to request any type of access to that object.</term>
/// </item>
/// <item>
/// <term>FILE_SHARE_DELETE 0x00000004</term>
/// <term>
/// Enables subsequent open operations on an object to request delete access. Otherwise, other processes cannot open the object if
/// they request delete access. If this flag is not specified, but the object has been opened for delete access, the function fails.
/// </term>
/// </item>
/// <item>
/// <term>FILE_SHARE_READ 0x00000001</term>
/// <term>
/// Enables subsequent open operations on an object to request read access. Otherwise, other processes cannot open the object if they
/// request read access. If this flag is not specified, but the object has been opened for read access, the function fails.
/// </term>
/// </item>
/// <item>
/// <term>FILE_SHARE_WRITE 0x00000002</term>
/// <term>
/// Enables subsequent open operations on an object to request write access. Otherwise, other processes cannot open the object if
/// they request write access. If this flag is not specified, but the object has been opened for write access or has a file mapping
/// with write access, the function fails.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="lpSecurityAttributes">
/// <para>
/// A pointer to a SECURITY_ATTRIBUTES structure that contains an optional security descriptor and also determines whether or not the
/// returned handle can be inherited by child processes. The parameter can be <c>NULL</c>.
/// </para>
/// <para>
/// If the parameter is <c>NULL</c>, the handle returned by <c>CreateFileTransacted</c> cannot be inherited by any child processes
/// your application may create and the object associated with the returned handle gets a default security descriptor.
/// </para>
/// <para>The <c>bInheritHandle</c> member of the structure specifies whether the returned handle can be inherited.</para>
/// <para>
/// The <c>lpSecurityDescriptor</c> member of the structure specifies a security descriptor for an object, but may also be <c>NULL</c>.
/// </para>
/// <para>
/// If <c>lpSecurityDescriptor</c> member is <c>NULL</c>, the object associated with the returned handle is assigned a default
/// security descriptor.
/// </para>
/// <para>
/// <c>CreateFileTransacted</c> ignores the <c>lpSecurityDescriptor</c> member when opening an existing file, but continues to use
/// the <c>bInheritHandle</c> member.
/// </para>
/// <para>For more information, see the Remarks section of this topic.</para>
/// </param>
/// <param name="dwCreationDisposition">
/// <para>An action to take on files that exist and do not exist.</para>
/// <para>For more information, see the Remarks section of this topic.</para>
/// <para>This parameter must be one of the following values, which cannot be combined.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>CREATE_ALWAYS 2</term>
/// <term>
/// Creates a new file, always. If the specified file exists and is writable, the function overwrites the file, the function
/// succeeds, and last-error code is set to ERROR_ALREADY_EXISTS (183). If the specified file does not exist and is a valid path, a
/// new file is created, the function succeeds, and the last-error code is set to zero. For more information, see the Remarks section
/// of this topic.
/// </term>
/// </item>
/// <item>
/// <term>CREATE_NEW 1</term>
/// <term>
/// Creates a new file, only if it does not already exist. If the specified file exists, the function fails and the last-error code
/// is set to ERROR_FILE_EXISTS (80). If the specified file does not exist and is a valid path to a writable location, a new file is created.
/// </term>
/// </item>
/// <item>
/// <term>OPEN_ALWAYS 4</term>
/// <term>
/// Opens a file, always. If the specified file exists, the function succeeds and the last-error code is set to ERROR_ALREADY_EXISTS
/// (183). If the specified file does not exist and is a valid path to a writable location, the function creates a file and the
/// last-error code is set to zero.
/// </term>
/// </item>
/// <item>
/// <term>OPEN_EXISTING 3</term>
/// <term>
/// Opens a file or device, only if it exists. If the specified file does not exist, the function fails and the last-error code is
/// set to ERROR_FILE_NOT_FOUND (2). For more information, see the Remarks section of this topic.
/// </term>
/// </item>
/// <item>
/// <term>TRUNCATE_EXISTING 5</term>
/// <term>
/// Opens a file and truncates it so that its size is zero bytes, only if it exists. If the specified file does not exist, the
/// function fails and the last-error code is set to ERROR_FILE_NOT_FOUND (2). The calling process must open the file with the
/// GENERIC_WRITE bit set as part of the parameter.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="dwFlagsAndAttributes">
/// <para>The file attributes and flags, <c>FILE_ATTRIBUTE_NORMAL</c> being the most common default value.</para>
/// <para>
/// This parameter can include any combination of the available file attributes ( <c>FILE_ATTRIBUTE_*</c>). All other file attributes
/// override <c>FILE_ATTRIBUTE_NORMAL</c>.
/// </para>
/// <para>
/// This parameter can also contain combinations of flags ( <c>FILE_FLAG_</c>) for control of buffering behavior, access modes, and
/// other special-purpose flags. These combine with any <c>FILE_ATTRIBUTE_</c> values.
/// </para>
/// <para>
/// This parameter can also contain Security Quality of Service (SQOS) information by specifying the <c>SECURITY_SQOS_PRESENT</c>
/// flag. Additional SQOS-related flags information is presented in the table following the attributes and flags tables.
/// </para>
/// <para>
/// <c>Note</c> When <c>CreateFileTransacted</c> opens an existing file, it generally combines the file flags with the file
/// attributes of the existing file, and ignores any file attributes supplied as part of . Special cases are detailed in Creating and
/// Opening Files.
/// </para>
/// <para>The following file attributes and flags are used only for file objects, not other types of objects that</para>
/// <para>CreateFileTransacted</para>
/// <para>
/// opens (additional information can be found in the Remarks section of this topic). For more advanced access to file attributes, see
/// </para>
/// <para>SetFileAttributes</para>
/// <para>. For a complete list of all file attributes with their values and descriptions, see</para>
/// <para>File Attribute Constants</para>
/// <para>.</para>
/// <list type="table">
/// <listheader>
/// <term>Attribute</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>FILE_ATTRIBUTE_ARCHIVE 32 (0x20)</term>
/// <term>The file should be archived. Applications use this attribute to mark files for backup or removal.</term>
/// <term>SMB 3.0 with Scale-out File Shares (SO)</term>
/// <term>No</term>
/// </item>
/// <item>
/// <term>Cluster Shared Volume File System (CsvFS)</term>
/// <term>No</term>
/// </item>
/// <item>
/// <term>Resilient File System (ReFS)</term>
/// <term>No</term>
/// </item>
/// </list>
/// <para>Note that SMB 3.0 does not support TxF.</para>
/// <para>Files</para>
/// <para>
/// If you try to create a file on a floppy drive that does not have a floppy disk or a CD-ROM drive that does not have a CD, the
/// system displays a message for the user to insert a disk or a CD. To prevent the system from displaying this message, call the
/// </para>
/// <para>SetErrorMode</para>
/// <para>function with</para>
/// <para>SEM_FAILCRITICALERRORS</para>
/// <para>.</para>
/// <para>For more information, see Creating and Opening Files.</para>
/// <para>
/// If you rename or delete a file and then restore it shortly afterward, the system searches the cache for file information to
/// restore. Cached information includes its short/long name pair and creation time.
/// </para>
/// <para>
/// If you call <c>CreateFileTransacted</c> on a file that is pending deletion as a result of a previous call to DeleteFile, the
/// function fails. The operating system delays file deletion until all handles to the file are closed. GetLastError returns <c>ERROR_ACCESS_DENIED</c>.
/// </para>
/// <para>
/// The parameter can be zero, allowing the application to query file attributes without accessing the file if the application is
/// running with adequate security settings. This is useful to test for the existence of a file without opening it for read and/or
/// write access, or to obtain other statistics about the file or directory. See Obtaining and Setting File Information and GetFileInformationByHandle.
/// </para>
/// <para>
/// When an application creates a file across a network, it is better to use <c>GENERIC_READ</c> | <c>GENERIC_WRITE</c> than to use
/// <c>GENERIC_WRITE</c> alone. The resulting code is faster, because the redirector can use the cache manager and send fewer SMBs
/// with more data. This combination also avoids an issue where writing to a file across a network can occasionally return <c>ERROR_ACCESS_DENIED</c>.
/// </para>
/// <para>File Streams</para>
/// <para>On NTFS file systems, you can use</para>
/// <para>CreateFileTransacted</para>
/// <para>to create separate streams within a file.</para>
/// <para>For more information, see File Streams.</para>
/// <para>Directories</para>
/// <para>An application cannot create a directory by using</para>
/// <para>CreateFileTransacted</para>
/// <para>, therefore only the</para>
/// <para>OPEN_EXISTING</para>
/// <para>value is valid for</para>
/// <para>dwCreationDisposition</para>
/// <para>for this use case. To create a directory, the application must call</para>
/// <para>CreateDirectoryTransacted</para>
/// <para>,</para>
/// <para>CreateDirectory</para>
/// <para>or</para>
/// <para>CreateDirectoryEx</para>
/// <para>.</para>
/// <para>
/// To open a directory using <c>CreateFileTransacted</c>, specify the <c>FILE_FLAG_BACKUP_SEMANTICS</c> flag as part of .
/// Appropriate security checks still apply when this flag is used without <c>SE_BACKUP_NAME</c> and <c>SE_RESTORE_NAME</c> privileges.
/// </para>
/// <para>
/// When using <c>CreateFileTransacted</c> to open a directory during defragmentation of a FAT or FAT32 file system volume, do not
/// specify the <c>MAXIMUM_ALLOWED</c> access right. Access to the directory is denied if this is done. Specify the
/// <c>GENERIC_READ</c> access right instead.
/// </para>
/// <para>For more information, see About Directory Management.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see
/// </para>
/// <para>Alternatives to using Transactional NTFS</para>
/// <para>.]</para>
/// <para>
/// Creates or opens a file, file stream, or directory as a transacted operation. The function returns a handle that can be used to
/// access the object.
/// </para>
/// <para>
/// To perform this operation as a non-transacted operation or to access objects other than files (for example, named pipes, physical
/// devices, mailslots), use the CreateFile function.
/// </para>
/// <para>For more information about transactions, see the Remarks section of this topic.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of an object to be created or opened.</para>
/// <para>The object must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File. For
/// information on special device names, see Defining an MS-DOS Device Name.
/// </para>
/// <para>
/// To create a file stream, specify the name of the file, a colon, and then the name of the stream. For more information, see File Streams.
/// </para>
/// </param>
/// <param name="dwDesiredAccess">
/// <para>
/// The access to the object, which can be summarized as read, write, both or neither (zero). The most commonly used values are
/// <c>GENERIC_READ</c>, <c>GENERIC_WRITE</c>, or both ( <c>GENERIC_READ</c> | <c>GENERIC_WRITE</c>). For more information, see
/// Generic Access Rights and File Security and Access Rights.
/// </para>
/// <para>
/// If this parameter is zero, the application can query file, directory, or device attributes without accessing that file or device.
/// For more information, see the Remarks section of this topic.
/// </para>
/// <para>
/// You cannot request an access mode that conflicts with the sharing mode that is specified in an open request that has an open
/// handle. For more information, see Creating and Opening Files.
/// </para>
/// </param>
/// <param name="dwShareMode">
/// <para>The sharing mode of an object, which can be read, write, both, delete, all of these, or none (refer to the following table).</para>
/// <para>
/// If this parameter is zero and <c>CreateFileTransacted</c> succeeds, the object cannot be shared and cannot be opened again until
/// the handle is closed. For more information, see the Remarks section of this topic.
/// </para>
/// <para>
/// You cannot request a sharing mode that conflicts with the access mode that is specified in an open request that has an open
/// handle, because that would result in the following sharing violation: <c>ERROR_SHARING_VIOLATION</c>. For more information, see
/// Creating and Opening Files.
/// </para>
/// <para>
/// To enable a process to share an object while another process has the object open, use a combination of one or more of the
/// following values to specify the access mode they can request to open the object.
/// </para>
/// <para>
/// <c>Note</c> The sharing options for each open handle remain in effect until that handle is closed, regardless of process context.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>0 0x00000000</term>
/// <term>Disables subsequent open operations on an object to request any type of access to that object.</term>
/// </item>
/// <item>
/// <term>FILE_SHARE_DELETE 0x00000004</term>
/// <term>
/// Enables subsequent open operations on an object to request delete access. Otherwise, other processes cannot open the object if
/// they request delete access. If this flag is not specified, but the object has been opened for delete access, the function fails.
/// </term>
/// </item>
/// <item>
/// <term>FILE_SHARE_READ 0x00000001</term>
/// <term>
/// Enables subsequent open operations on an object to request read access. Otherwise, other processes cannot open the object if they
/// request read access. If this flag is not specified, but the object has been opened for read access, the function fails.
/// </term>
/// </item>
/// <item>
/// <term>FILE_SHARE_WRITE 0x00000002</term>
/// <term>
/// Enables subsequent open operations on an object to request write access. Otherwise, other processes cannot open the object if
/// they request write access. If this flag is not specified, but the object has been opened for write access or has a file mapping
/// with write access, the function fails.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="lpSecurityAttributes">
/// <para>
/// A pointer to a SECURITY_ATTRIBUTES structure that contains an optional security descriptor and also determines whether or not the
/// returned handle can be inherited by child processes. The parameter can be <c>NULL</c>.
/// </para>
/// <para>
/// If the parameter is <c>NULL</c>, the handle returned by <c>CreateFileTransacted</c> cannot be inherited by any child processes
/// your application may create and the object associated with the returned handle gets a default security descriptor.
/// </para>
/// <para>The <c>bInheritHandle</c> member of the structure specifies whether the returned handle can be inherited.</para>
/// <para>
/// The <c>lpSecurityDescriptor</c> member of the structure specifies a security descriptor for an object, but may also be <c>NULL</c>.
/// </para>
/// <para>
/// If <c>lpSecurityDescriptor</c> member is <c>NULL</c>, the object associated with the returned handle is assigned a default
/// security descriptor.
/// </para>
/// <para>
/// <c>CreateFileTransacted</c> ignores the <c>lpSecurityDescriptor</c> member when opening an existing file, but continues to use
/// the <c>bInheritHandle</c> member.
/// </para>
/// <para>For more information, see the Remarks section of this topic.</para>
/// </param>
/// <param name="dwCreationDisposition">
/// <para>An action to take on files that exist and do not exist.</para>
/// <para>For more information, see the Remarks section of this topic.</para>
/// <para>This parameter must be one of the following values, which cannot be combined.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>CREATE_ALWAYS 2</term>
/// <term>
/// Creates a new file, always. If the specified file exists and is writable, the function overwrites the file, the function
/// succeeds, and last-error code is set to ERROR_ALREADY_EXISTS (183). If the specified file does not exist and is a valid path, a
/// new file is created, the function succeeds, and the last-error code is set to zero. For more information, see the Remarks section
/// of this topic.
/// </term>
/// </item>
/// <item>
/// <term>CREATE_NEW 1</term>
/// <term>
/// Creates a new file, only if it does not already exist. If the specified file exists, the function fails and the last-error code
/// is set to ERROR_FILE_EXISTS (80). If the specified file does not exist and is a valid path to a writable location, a new file is created.
/// </term>
/// </item>
/// <item>
/// <term>OPEN_ALWAYS 4</term>
/// <term>
/// Opens a file, always. If the specified file exists, the function succeeds and the last-error code is set to ERROR_ALREADY_EXISTS
/// (183). If the specified file does not exist and is a valid path to a writable location, the function creates a file and the
/// last-error code is set to zero.
/// </term>
/// </item>
/// <item>
/// <term>OPEN_EXISTING 3</term>
/// <term>
/// Opens a file or device, only if it exists. If the specified file does not exist, the function fails and the last-error code is
/// set to ERROR_FILE_NOT_FOUND (2). For more information, see the Remarks section of this topic.
/// </term>
/// </item>
/// <item>
/// <term>TRUNCATE_EXISTING 5</term>
/// <term>
/// Opens a file and truncates it so that its size is zero bytes, only if it exists. If the specified file does not exist, the
/// function fails and the last-error code is set to ERROR_FILE_NOT_FOUND (2). The calling process must open the file with the
/// GENERIC_WRITE bit set as part of the parameter.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="dwFlagsAndAttributes">
/// <para>The file attributes and flags, <c>FILE_ATTRIBUTE_NORMAL</c> being the most common default value.</para>
/// <para>
/// This parameter can include any combination of the available file attributes ( <c>FILE_ATTRIBUTE_*</c>). All other file attributes
/// override <c>FILE_ATTRIBUTE_NORMAL</c>.
/// </para>
/// <para>
/// This parameter can also contain combinations of flags ( <c>FILE_FLAG_</c>) for control of buffering behavior, access modes, and
/// other special-purpose flags. These combine with any <c>FILE_ATTRIBUTE_</c> values.
/// </para>
/// <para>
/// This parameter can also contain Security Quality of Service (SQOS) information by specifying the <c>SECURITY_SQOS_PRESENT</c>
/// flag. Additional SQOS-related flags information is presented in the table following the attributes and flags tables.
/// </para>
/// <para>
/// <c>Note</c> When <c>CreateFileTransacted</c> opens an existing file, it generally combines the file flags with the file
/// attributes of the existing file, and ignores any file attributes supplied as part of . Special cases are detailed in Creating and
/// Opening Files.
/// </para>
/// <para>The following file attributes and flags are used only for file objects, not other types of objects that</para>
/// <para>CreateFileTransacted</para>
/// <para>
/// opens (additional information can be found in the Remarks section of this topic). For more advanced access to file attributes, see
/// </para>
/// <para>SetFileAttributes</para>
/// <para>. For a complete list of all file attributes with their values and descriptions, see</para>
/// <para>File Attribute Constants</para>
/// <para>.</para>
/// <list type="table">
/// <listheader>
/// <term>Attribute</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>FILE_ATTRIBUTE_ARCHIVE 32 (0x20)</term>
/// <term>The file should be archived. Applications use this attribute to mark files for backup or removal.</term>
/// <term>SMB 3.0 with Scale-out File Shares (SO)</term>
/// <term>No</term>
/// </item>
/// <item>
/// <term>Cluster Shared Volume File System (CsvFS)</term>
/// <term>No</term>
/// </item>
/// <item>
/// <term>Resilient File System (ReFS)</term>
/// <term>No</term>
/// </item>
/// </list>
/// <para>Note that SMB 3.0 does not support TxF.</para>
/// <para>Files</para>
/// <para>
/// If you try to create a file on a floppy drive that does not have a floppy disk or a CD-ROM drive that does not have a CD, the
/// system displays a message for the user to insert a disk or a CD. To prevent the system from displaying this message, call the
/// </para>
/// <para>SetErrorMode</para>
/// <para>function with</para>
/// <para>SEM_FAILCRITICALERRORS</para>
/// <para>.</para>
/// <para>For more information, see Creating and Opening Files.</para>
/// <para>
/// If you rename or delete a file and then restore it shortly afterward, the system searches the cache for file information to
/// restore. Cached information includes its short/long name pair and creation time.
/// </para>
/// <para>
/// If you call <c>CreateFileTransacted</c> on a file that is pending deletion as a result of a previous call to DeleteFile, the
/// function fails. The operating system delays file deletion until all handles to the file are closed. GetLastError returns <c>ERROR_ACCESS_DENIED</c>.
/// </para>
/// <para>
/// The parameter can be zero, allowing the application to query file attributes without accessing the file if the application is
/// running with adequate security settings. This is useful to test for the existence of a file without opening it for read and/or
/// write access, or to obtain other statistics about the file or directory. See Obtaining and Setting File Information and GetFileInformationByHandle.
/// </para>
/// <para>
/// When an application creates a file across a network, it is better to use <c>GENERIC_READ</c> | <c>GENERIC_WRITE</c> than to use
/// <c>GENERIC_WRITE</c> alone. The resulting code is faster, because the redirector can use the cache manager and send fewer SMBs
/// with more data. This combination also avoids an issue where writing to a file across a network can occasionally return <c>ERROR_ACCESS_DENIED</c>.
/// </para>
/// <para>File Streams</para>
/// <para>On NTFS file systems, you can use</para>
/// <para>CreateFileTransacted</para>
/// <para>to create separate streams within a file.</para>
/// <para>For more information, see File Streams.</para>
/// <para>Directories</para>
/// <para>An application cannot create a directory by using</para>
/// <para>CreateFileTransacted</para>
/// <para>, therefore only the</para>
/// <para>OPEN_EXISTING</para>
/// <para>value is valid for</para>
/// <para>dwCreationDisposition</para>
/// <para>for this use case. To create a directory, the application must call</para>
/// <para>CreateDirectoryTransacted</para>
/// <para>,</para>
/// <para>CreateDirectory</para>
/// <para>or</para>
/// <para>CreateDirectoryEx</para>
/// <para>.</para>
/// <para>
/// To open a directory using <c>CreateFileTransacted</c>, specify the <c>FILE_FLAG_BACKUP_SEMANTICS</c> flag as part of .
/// Appropriate security checks still apply when this flag is used without <c>SE_BACKUP_NAME</c> and <c>SE_RESTORE_NAME</c> privileges.
/// </para>
/// <para>
/// When using <c>CreateFileTransacted</c> to open a directory during defragmentation of a FAT or FAT32 file system volume, do not
/// specify the <c>MAXIMUM_ALLOWED</c> access right. Access to the directory is denied if this is done. Specify the
/// <c>GENERIC_READ</c> access right instead.
/// </para>
/// <para>For more information, see About Directory Management.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see
/// </para>
/// <para>Alternatives to using Transactional NTFS</para>
/// <para>.]</para>
/// <para>
/// Establishes a hard link between an existing file and a new file as a transacted operation. This function is only supported on the
/// NTFS file system, and only for files, not directories.
/// </para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of the new file.</para>
/// <para>This parameter cannot specify the name of a directory.</para>
/// </param>
/// <param name="lpExistingFileName">
/// <para>The name of the existing file.</para>
/// <para>This parameter cannot specify the name of a directory.</para>
/// </param>
/// <param name="lpSecurityAttributes">
/// <para>Reserved; must be <c>NULL</c>.</para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero (0). To get extended error information, call GetLastError.</para>
/// <para>
/// The maximum number of hard links that can be created with this function is 1023 per file. If more than 1023 links are created for
/// a file, an error results.
/// </para>
/// <para>The files must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// Any directory entry for a file that is created with CreateFileTransacted or <c>CreateHardLinkTransacted</c> is a hard link to an
/// associated file. An additional hard link that is created with the <c>CreateHardLinkTransacted</c> function allows you to have
/// multiple directory entries for a file, that is, multiple hard links to the same file, which can be different names in the same
/// directory, or the same or different names in different directories. However, all hard links to a file must be on the same volume.
/// </para>
/// <para>
/// Because hard links are only directory entries for a file, when an application modifies a file through any hard link, all
/// applications that use any other hard link to the file see the changes. Also, all of the directory entries are updated if the file
/// changes. For example, if a file size changes, all of the hard links to the file show the new file size.
/// </para>
/// <para>
/// The security descriptor belongs to the file to which a hard link points. The link itself is only a directory entry, and does not
/// have a security descriptor. Therefore, when you change the security descriptor of a hard link, you a change the security
/// descriptor of the underlying file, and all hard links that point to the file allow the newly specified access. You cannot give a
/// file different security descriptors on a per-hard-link basis.
/// </para>
/// <para>
/// This function does not modify the security descriptor of the file to be linked to, even if security descriptor information is
/// passed in the parameter.
/// </para>
/// <para>
/// Use DeleteFileTransacted to delete hard links. You can delete them in any order regardless of the order in which they are created.
/// </para>
/// <para>
/// Flags, attributes, access, and sharing that are specified in CreateFileTransacted operate on a per-file basis. That is, if you
/// open a file that does not allow sharing, another application cannot share the file by creating a new hard link to the file.
/// </para>
/// <para>
/// When you create a hard link on the NTFS file system, the file attribute information in the directory entry is refreshed only when
/// the file is opened, or when GetFileInformationByHandle is called with the handle of a specific file.
/// </para>
/// <para><c>Symbolic links:</c> If the path points to a symbolic link, the function creates a hard link to the target.</para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Deletes an existing file as a transacted operation.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of the file to be deleted.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// <para>The file must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// If an application attempts to delete a file that does not exist, the <c>DeleteFileTransacted</c> function fails with
/// <c>ERROR_FILE_NOT_FOUND</c>. If the file is a read-only file, the function fails with <c>ERROR_ACCESS_DENIED</c>.
/// </para>
/// <para>The following list identifies some tips for deleting, removing, or closing files:</para>
/// <list type="bullet">
/// <item>
/// <term>To delete a read-only file, first you must remove the read-only attribute.</term>
/// </item>
/// <item>
/// <term>
/// To delete or rename a file, you must have either delete permission on the file, or delete child permission in the parent directory.
/// </term>
/// </item>
/// <item>
/// <term>To recursively delete the files in a directory, use the SHFileOperation function.</term>
/// </item>
/// <item>
/// <term>To remove an empty directory, use the RemoveDirectoryTransacted function.</term>
/// </item>
/// <item>
/// <term>To close an open file, use the CloseHandle function.</term>
/// </item>
/// </list>
/// <para>
/// If you set up a directory with all access except delete and delete child, and the access control lists (ACL) of new files are
/// inherited, then you can create a file without being able to delete it. However, then you can create a file, and then get all the
/// access you request on the handle that is returned to you at the time you create the file.
/// </para>
/// <para>
/// If you request delete permission at the time you create a file, you can delete or rename the file with that handle, but not with
/// any other handle. For more information, see File Security and Access Rights.
/// </para>
/// <para>
/// The <c>DeleteFileTransacted</c> function fails if an application attempts to delete a file that has other handles open for normal
/// I/O or as a memory-mapped file ( <c>FILE_SHARE_DELETE</c> must have been specified when other handles were opened).
/// </para>
/// <para>
/// The <c>DeleteFileTransacted</c> function marks a file for deletion on close. The file is deleted after the last transacted writer
/// handle to the file is closed, provided that the transaction is still active. If a file has been marked for deletion and a
/// transacted writer handle is still open after the transaction completes, the file will not be deleted.
/// </para>
/// <para>
/// <c>Symbolic links:</c> If the path points to a symbolic link, the symbolic link is deleted, not the target. To delete a target,
/// you must call CreateFile and specify <c>FILE_FLAG_DELETE_ON_CLOSE</c>.
/// </para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Searches a directory for a file or subdirectory with a name that matches a specific name as a transacted operation.</para>
/// <para>This function is the transacted form of the FindFirstFileEx function.</para>
/// <para>For the most basic version of this function, see FindFirstFile.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>
/// The directory or path, and the file name. The file name can include wildcard characters, for example, an asterisk (*) or a
/// question mark (?).
/// </para>
/// <para>
/// This parameter should not be <c>NULL</c>, an invalid string (for example, an empty string or a string that is missing the
/// terminating null character), or end in a trailing backslash ().
/// </para>
/// <para>
/// If the string ends with a wildcard, period (.), or directory name, the user must have access to the root and all subdirectories
/// on the path.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// <para>The file must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="fInfoLevelId">
/// <para>The information level of the returned data.</para>
/// <para>This parameter is one of the FINDEX_INFO_LEVELS enumeration values.</para>
/// </param>
/// <param name="lpFindFileData">
/// <para>A pointer to the WIN32_FIND_DATA structure that receives information about a found file or subdirectory.</para>
/// </param>
/// <param name="fSearchOp">
/// <para>The type of filtering to perform that is different from wildcard matching.</para>
/// <para>This parameter is one of the FINDEX_SEARCH_OPS enumeration values.</para>
/// </param>
/// <param name="lpSearchFilter">
/// <para>A pointer to the search criteria if the specified fSearchOp needs structured search information.</para>
/// <para>
/// At this time, none of the supported fSearchOp values require extended search information. Therefore, this pointer must be <c>NULL</c>.
/// </para>
/// </param>
/// <param name="dwAdditionalFlags">
/// <para>Specifies additional flags that control the search.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>FIND_FIRST_EX_CASE_SENSITIVE 1</term>
/// <term>Searches are case-sensitive.</term>
/// </item>
/// </list>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is a search handle used in a subsequent call to FindNextFile or FindClose, and the
/// lpFindFileData parameter contains information about the first file or directory found.
/// </para>
/// <para>
/// If the function fails or fails to locate files from the search string in the lpFileName parameter, the return value is
/// <c>INVALID_HANDLE_VALUE</c> and the contents of lpFindFileData are indeterminate. To get extended error information, call the
/// GetLastError function.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>FindFirstFileTransacted</c> function opens a search handle and returns information about the first file that the file
/// system finds with a name that matches the specified pattern. This may or may not be the first file or directory that appears in a
/// directory-listing application (such as the dir command) when given the same file name string pattern. This is because
/// <c>FindFirstFileTransacted</c> does no sorting of the search results. For additional information, see FindNextFile.
/// </para>
/// <para>The following list identifies some other search characteristics:</para>
/// <list type="bullet">
/// <item>
/// <term>The search is performed strictly on the name of the file, not on any attributes such as a date or a file type.</term>
/// </item>
/// <item>
/// <term>The search includes the long and short file names.</term>
/// </item>
/// <item>
/// <term>An attempt to open a search with a trailing backslash always fails.</term>
/// </item>
/// <item>
/// <term>
/// Passing an invalid string, <c>NULL</c>, or empty string for the lpFileName parameter is not a valid use of this function. Results
/// in this case are undefined.
/// </term>
/// </item>
/// </list>
/// <para>
/// <c>Note</c> In rare cases, file information on NTFS file systems may not be current at the time you call this function. To be
/// assured of getting the current file information, call the GetFileInformationByHandle function.
/// </para>
/// <para>
/// If the underlying file system does not support the specified type of filtering, other than directory filtering,
/// <c>FindFirstFileTransacted</c> fails with the error <c>ERROR_NOT_SUPPORTED</c>. The application must use FINDEX_SEARCH_OPS type
/// <c>FileExSearchNameMatch</c> and perform its own filtering.
/// </para>
/// <para>
/// After the search handle is established, use it in the FindNextFile function to search for other files that match the same pattern
/// with the same filtering that is being performed. When the search handle is not needed, it should be closed by using the FindClose function.
/// </para>
/// <para>
/// As stated previously, you cannot use a trailing backslash () in the lpFileName input string for <c>FindFirstFileTransacted</c>,
/// therefore it may not be obvious how to search root directories. If you want to see files or get the attributes of a root
/// directory, the following options would apply:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>To examine files in a root directory, you can use "C:\*" and step through the directory by using FindNextFile.</term>
/// </item>
/// <item>
/// <term>To get the attributes of a root directory, use the GetFileAttributes function.</term>
/// </item>
/// </list>
/// <para><c>Note</c> Prepending the string "\\?\" does not allow access to the root directory.</para>
/// <para>
/// On network shares, you can use an lpFileName in the form of the following: "\\server\service\*". However, you cannot use an
/// lpFileName that points to the share itself; for example, "\\server\service" is not valid.
/// </para>
/// <para>
/// To examine a directory that is not a root directory, use the path to that directory, without a trailing backslash. For example,
/// an argument of "C:\Windows" returns information about the directory "C:\Windows", not about a directory or file in "C:\Windows".
/// To examine the files and directories in "C:\Windows", use an lpFileName of "C:\Windows*".
/// </para>
/// <para>
/// Be aware that some other thread or process could create or delete a file with this name between the time you query for the result
/// and the time you act on the information. If this is a potential concern for your application, one possible solution is to use the
/// CreateFile function with <c>CREATE_NEW</c> (which fails if the file exists) or <c>OPEN_EXISTING</c> (which fails if the file does
/// not exist).
/// </para>
/// <para>
/// If you are writing a 32-bit application to list all the files in a directory and the application may be run on a 64-bit computer,
/// you should call Wow64DisableWow64FsRedirection before calling <c>FindFirstFileTransacted</c> and call
/// Wow64RevertWow64FsRedirection after the last call to FindNextFile. For more information, see File System Redirector.
/// </para>
/// <para>
/// If the path points to a symbolic link, the WIN32_FIND_DATA buffer contains information about the symbolic link, not the target.
/// </para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Retrieves file system attributes for a specified file or directory as a transacted operation.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of the file or directory.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// <para>
/// The file or directory must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.
/// </para>
/// </param>
/// <param name="fInfoLevelId">
/// <para>The level of attribute information to retrieve.</para>
/// <para>This parameter can be the following value from the GET_FILEEX_INFO_LEVELS enumeration.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GetFileExInfoStandard</term>
/// <term>The lpFileInformation parameter is a WIN32_FILE_ATTRIBUTE_DATA structure.</term>
/// </item>
/// </list>
/// </param>
/// <param name="lpFileInformation">
/// <para>A pointer to a buffer that receives the attribute information.</para>
/// <para>
/// The type of attribute information that is stored into this buffer is determined by the value of fInfoLevelId. If the fInfoLevelId
/// parameter is <c>GetFileExInfoStandard</c> then this parameter points to a WIN32_FILE_ATTRIBUTE_DATA structure
/// </para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero (0). To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// When <c>GetFileAttributesTransacted</c> is called on a directory that is a mounted folder, it returns the attributes of the
/// directory, not those of the root directory in the volume that the mounted folder associates with the directory. To obtain the
/// file attributes of the associated volume, call GetVolumeNameForVolumeMountPoint to obtain the name of the associated volume. Then
/// use the resulting name in a call to <c>GetFileAttributesTransacted</c>. The results are the attributes of the root directory on
/// the associated volume.
/// </para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Retrieves the full path and file name of the specified file as a transacted operation.</para>
/// <para>To perform this operation without transactions, use the GetFullPathName function.</para>
/// <para>For more information about file and path names, see File Names, Paths, and Namespaces.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of the file.</para>
/// <para>This string can use short (the 8.3 form) or long file names. This string can be a share or volume name.</para>
/// <para>The file must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="nBufferLength">
/// <para>The size of the buffer to receive the null-terminated string for the drive and path, in <c>TCHARs</c>.</para>
/// </param>
/// <param name="lpBuffer">
/// <para>A pointer to a buffer that receives the null-terminated string for the drive and path.</para>
/// </param>
/// <param name="lpFilePart">
/// <para>
/// A pointer to a buffer that receives the address (in lpBuffer) of the final file name component in the path. Specify <c>NULL</c>
/// if you do not need to receive this information.
/// </para>
/// <para>If lpBuffer points to a directory and not a file, lpFilePart receives 0 (zero).</para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is the length, in <c>TCHARs</c>, of the string copied to lpBuffer, not including the
/// terminating null character.
/// </para>
/// <para>
/// If the lpBuffer buffer is too small to contain the path, the return value is the size, in <c>TCHARs</c>, of the buffer that is
/// required to hold the path and the terminating null character.
/// </para>
/// <para>If the function fails for any other reason, the return value is zero. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// <c>GetFullPathNameTransacted</c> merges the name of the current drive and directory with a specified file name to determine the
/// full path and file name of a specified file. It also calculates the address of the file name portion of the full path and file
/// name. This function does not verify that the resulting path and file name are valid, or that they see an existing file on the
/// associated volume.
/// </para>
/// <para>
/// Share and volume names are valid input for lpFileName. For example, the following list identities the returned path and file
/// names if test-2 is a remote computer and U: is a network mapped drive:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>If you specify "\\test-2\q$\lh" the path returned is "\\test-2\q$\lh"</term>
/// </item>
/// <item>
/// <term>If you specify "\\?\UNC\test-2\q$\lh" the path returned is "\\?\UNC\test-2\q$\lh"</term>
/// </item>
/// <item>
/// <term>If you specify "U:" the path returned is "U:\"</term>
/// </item>
/// </list>
/// <para>
/// <c>GetFullPathNameTransacted</c> does not convert the specified file name, lpFileName. If the specified file name exists, you can
/// use GetLongPathNameTransacted, GetLongPathName, or GetShortPathName to convert to long or short path names, respectively.
/// </para>
/// <para>
/// If the return value is greater than the value specified in nBufferLength, you can call the function again with a buffer that is
/// large enough to hold the path. For an example of this case as well as using zero length buffer for dynamic allocation, see the
/// Example Code section.
/// </para>
/// <para>
/// <c>Note</c> Although the return value in this case is a length that includes the terminating null character, the return value on
/// success does not include the terminating null character in the count.
/// </para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Converts the specified path to its long form as a transacted operation.</para>
/// <para>To perform this operation without a transaction, use the GetLongPathName function.</para>
/// <para>For more information about file and path names, see Naming Files, Paths, and Namespaces.</para>
/// </summary>
/// <param name="lpszShortPath">
/// <para>The path to be converted.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> (260) characters. To extend this limit to 32,767
/// wide characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming Files,
/// Paths, and Namespaces.
/// </para>
/// <para>The path must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="lpszLongPath">
/// <para>A pointer to the buffer to receive the long path.</para>
/// <para>You can use the same buffer you used for the lpszShortPath parameter.</para>
/// </param>
/// <param name="cchBuffer">
/// <para>The size of the buffer lpszLongPath points to, in <c>TCHAR</c> s.</para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is the length, in <c>TCHAR</c> s, of the string copied to lpszLongPath, not including
/// the terminating null character.
/// </para>
/// <para>
/// If the lpBuffer buffer is too small to contain the path, the return value is the size, in <c>TCHAR</c> s, of the buffer that is
/// required to hold the path and the terminating null character.
/// </para>
/// <para>
/// If the function fails for any other reason, such as if the file does not exist, the return value is zero. To get extended error
/// information, call GetLastError.
/// </para>
/// </returns>
/// <remarks>
/// <para>On many file systems, a short file name contains a tilde () character.</para>
/// <para>
/// If a long path is not found, this function returns the name specified in the lpszShortPath parameter in the lpszLongPath parameter.
/// </para>
/// <para>
/// If the return value is greater than the value specified in cchBuffer, you can call the function again with a buffer that is large
/// enough to hold the path. For an example of this case, see the Example Code section for GetFullPathName.
/// </para>
/// <para>
/// <c>Note</c> Although the return value in this case is a length that includes the terminating null character, the return value on
/// success does not include the terminating null character in the count.
/// </para>
/// <para>
/// It is possible to have access to a file or directory but not have access to some of the parent directories of that file or
/// directory. As a result, <c>GetLongPathNameTransacted</c> may fail when it is unable to query the parent directory of a path
/// component to determine the long name for that component. This check can be skipped for directory components that have file
/// extensions longer than 3 characters, or total lengths longer than 12 characters. For more information, see the Short vs. Long
/// Names section of Naming Files, Paths, and Namespaces.
/// </para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Deletes an existing empty directory as a transacted operation.</para>
/// </summary>
/// <param name="lpPathName">
/// <para>
/// The path of the directory to be removed. The path must specify an empty directory, and the calling process must have delete
/// access to the directory.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see Naming a File.
/// </para>
/// <para>The directory must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="hTransaction">
/// <para>A handle to the transaction. This handle is returned by the CreateTransaction function.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>RemoveDirectoryTransacted</c> function marks a directory for deletion on close. Therefore, the directory is not removed
/// until the last handle to the directory is closed.
/// </para>
/// <para>
/// RemoveDirectory removes a directory junction, even if the contents of the target are not empty; the function removes directory
/// junctions regardless of the state of the target object.
/// </para>
/// <para>In Windows 8 and Windows Server 2012, this function is supported by the following technologies.</para>
/// [Microsoft strongly recommends developers utilize alternative means to achieve your application’s needs. Many scenarios that TxF
/// was developed for can be achieved through simpler and more readily available techniques. Furthermore, TxF may not be available in
/// future versions of Microsoft Windows. For more information, and alternatives to TxF, please see Alternatives to using
/// Transactional NTFS.]
/// </para>
/// <para>Sets the attributes for a file or directory as a transacted operation.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of the file whose attributes are to be set.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide
/// characters, call the Unicode version of the function and prepend "\?" to the path. For more information, see File Names, Paths,
/// and Namespaces.
/// </para>
/// <para>The file must reside on the local computer; otherwise, the function fails and the last error code is set to <c>ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE</c>.</para>
/// </param>
/// <param name="dwFileAttributes">
/// <para>The file attributes to set for the file.</para>
/// <para>
/// For a list of file attribute value and their descriptions, see File Attribute Constants. This parameter can be one or more
/// values, combined using the bitwise-OR operator. However, all other values override <c>FILE_ATTRIBUTE_NORMAL</c>.
/// </para>
/// <para>Not all attributes are supported by this function. For more information, see the Remarks section.</para>
/// <para>The following is a list of supported attribute values.</para>