Microsoft.VisualStudio.Cache Tracks an active context. Obtain instances of this object from . Initializes a new instance of the class and creates a temporary file to indicate to all open processes that a context is open. The active context. The path to the directory where context files should be created. This directory will be created if it does not already exist. Gets the context itself. Closes a file (which may result in its deletion) that represents this open context. Checks whether a given context is active in any process. A hash of the context (i.e. the value from . if the context identified by is active in any process that shares . Utility methods that compare equality between two data structures by value. Checks for equality between two buffers. The first buffer. The second buffer. A value indicating whether the buffers are equal. Context that parameterizes an initialized instance. Backing field for the property. Gets an empty dictionary that uses the required comparer. Gets the absolute path to use as the base for any relative paths. Gets the contextual dimensions to implicitly add to any . Gets the hash of the content from the property. Contains the cloud-connecting methods of the service. An implementation of the , as made available via . Uploads all shareable cache entries associated with the active context. A cancellation token. A task that tracks the async operation. This method only uploads cache entries that were saved as shareable and that belong to a shareable context. If the context is not shareable (e.g. no git repo applies) or no shareable cache entries belong to it, this method does nothing but return a successful result. Thrown when the user does not have permission to upload to the Azure storage account. Thrown when the context does not support being shared. This may be because the open context is not bound to git, or because no storage account has been specified for the repo. Creates a for use with uploading or downloading blobs. if the caller requires a token that will grant write access to the container; otherwise. A cancellation token. An instance of , or if no Azure resource can be accessed. Thrown when the user has not been granted the necessary access to the Azure storage account. When overridden in a derived class, creates a token credential for use when gaining authorization to access an Azure Storage account. The tenant. A cancellation token. A token credential. Looks up the Azure Storage account info from the contextual repo. A cancellation token. The storage info, if any was found. The key to use in for the local, absolute path to what should be considered the base of the opened code container (e.g. solution directory or open folder). This activation argument is optional. Without it, the service will acquire the value from the . But with it, the cache service can be constructed more quickly and without any UI thread dependencies. It also provides the caller with the ability to control the context under which the cache is activated rather than inheriting it from the environment. A shared connection pool. This will *not* be disposed of when this is disposed. Initializes a new instance of the class. The context under which this cache service instance will operate. This value will be disposed of with the . The service broker through which other services may be obtained. The authorization service. This value will be disposed of with the . A shared connection pool. to dispose of when this instance is disposed. The service moniker this service was activated with. Event IDs raised to our . Occurs when the active context has been determined. Occurs when a cache entry is locally written. Occurs when a container is uploaded to cloud storage. Occurs when a container download from cloud storage is attempted. Occurs when a downloaded container is merged with the local database. Gets the value that is returned from . Gets the logging mechanism. Gets the default location for the cache. Gets the latest Visual Studio brokered services object that we support. Keep this value updated to whatever the latest offered by our reference assembly is. The property type need only be updated when a new service is required that doesn't appear on the version this property is typed as. Gets the service moniker this service was activated with. Gets the used by this instance. Gets a value indicating whether the active context can be shared. Gets a value indicating whether cache read operations that do not include a shareable parameter should default to accepting downloaded cache values. Initializes a new instance of the class. The service broker through which other services may be obtained. Service activation options. A shared pool of SQLite connections. This value will *not* be disposed of when the returned is disposed. A cancellation token. The newly initialized instance. Initializes a new instance of the class. The service broker through which other services may be obtained. Service activation options. A shared pool of SQLite connections. This value will *not* be disposed of when the returned is disposed. The that may be used to log actions taken by this cache service. A cancellation token. The newly initialized instance. The time a context must be inactive before being eligible for deletion. Creates a cache context based on the ambient environment. The service broker through which the ambient environment may be discovered. Service activation options. An optional logging system. A cancellation token. The cache context. Generates additional objects that may be used to lookup cache values when the has no match. A sequence of contexts. The further down the sequence, the less precise the match. An that hashes the output without buffering the full output. The length (in bytes) of the result of the hash identified by . Initializes a new instance of the class. Writes the content of a dictionary to a . The writer. The dictionary to write out. Finalizes the computation given the bytes already written and writes the hash to a buffer. The buffer to write the hash to. Encodes/decodes byte buffers to and from hexidecimal character representation. Encode some buffer as hex characters. The buffer to encode. The hex string. Encode some buffer as hex characters. The byte buffer to encode. The character buffer to initialize with hex. Excess space in this buffer will not be changed. Converts a hex string into a byte buffer. The hex-encoded buffer. The raw byte buffer. Converts a hex string into a byte buffer. The hex-encoded buffer. The buffer to initialize with the decoded hex data. Excess space in this buffer will not be changed. Extension methods to fill in for pre-netcoreapp3.1 targeting builds. Writes to a stream from a memory buffer. The stream to write to. The buffer to read from. A cancellation token. A task that indicates when the write operation is complete. This method shamelessly copied from the .NET Core 2.1 Stream class: https://github.com/dotnet/coreclr/blob/a113b1c803783c9d64f1f0e946ff9a853e3bc140/src/System.Private.CoreLib/shared/System/IO/Stream.cs#L672-L696. Contains the sqlite initializer call. Initializes sqlite's native bindings. Data types of sqlite columns. An integer. A floating point number. A string. A blob. Null, or an unset value. Flags that may be passed to the API. The database is opened in read-only mode. If the database does not already exist, an error is returned. The database is opened for reading and writing if possible, or reading only if the file is write protected by the operating system. In either case the database must already exist, otherwise an error is returned. The database file is created if it does not already exist. VFS only. VFS only. VFS only. The filename can be interpreted as a URI if this flag is set. The database will be opened as an in-memory database. The database is named by the "filename" argument for the purposes of cache-sharing, if shared cache mode is enabled, but the "filename" is otherwise ignored. VFS only. VFS only. VFS only. VFS only. VFS only. VFS only. VFS only. The new database connection will use the "multi-thread" threading mode. This means that separate threads are allowed to use SQLite at the same time, as long as each thread is using a different database connection. The new database connection will use the "serialized" threading mode. This means the multiple threads can safely attempt to use the same database connection at the same time. (Mutexes will block any actual concurrency, but in this mode there is no harm in trying.) The database is opened shared cache enabled, overriding the default shared cache setting provided by sqlite3_enable_shared_cache(). The database is opened shared cache disabled, overriding the default shared cache setting provided by sqlite3_enable_shared_cache(). VFS only. Flags that may be passed to the API. No flags. A hint to the query planner that the prepared statement will be retained for a long time and probably reused many times. Without this flag, sqlite3_prepare_v3() and sqlite3_prepare16_v3() assume that the prepared statement will be used just once or at most a few times and then destroyed using sqlite3_finalize() relatively soon. The current implementation acts on this hint by avoiding the use of lookaside memory so as not to deplete the limited store of lookaside memory. Future versions of SQLite may act on this hint differently. Sqlite error codes. Successful result. SQL error or missing database. Internal logic error in SQLite. Access permission denied. Callback routine requested an abort. The database file is locked. A table in the database is locked. A malloc() failed. Attempt to write a readonly database. Operation terminated by sqlite3_interrupt(). Some kind of disk I/O error occurred. The database disk image is malformed. Unknown opcode in sqlite3_file_control(). Insertion failed because database is full. Unable to open the database file. Database lock protocol error. Database is empty. The database schema changed. String or BLOB exceeds size limit. Abort due to constraint violation. Data type mismatch. Library used incorrectly. Uses OS features not supported on host. Authorization denied. Auxiliary database format error. 2nd parameter to sqlite3_bind out of range. File opened that is not a database file. Notifications from sqlite3_log(). Warnings from sqlite3_log(). sqlite3_step() has another row ready. sqlite3_step() has finished executing. Contains details regarding the schema of storage, including both sql db content and auxiliary file storage. A version string that changes whenever a breaking change is made. The simple filename of the sqlite database file. The name of the schema that the write cache tables belong to. The name of the schema that the persisted tables belong to. The name of the schema that an exported database is attached with. The maximum recommended times to retry an operation that fails with or . This value is set such that it is for all expected scenarios it essentially is infinite. If the retry count is exceeded, something has gone seriously wrong and the calling code ought to fail to draw attention to our failure. Searches for a cache hit based on Context. Searches for a cache hit based on Version rather than context. Searches for a cache hit in any related context for fuzzy matching. Sets a cache value in the cache table. The connection to use. The hash of environmental context, such as git commit. The container's key hash. The cached value. A value indicating whether the cached value is suitable for sharing across machines and users. The leaf name of the file whose content is the value of this entry. Retrieves a cache entry for a given context, container, name, and optionally version. The connection to use. The hash of environmental context, such as git commit. The container's key hash. A lazily-initialized collection of context hashes that may be considered for fuzzy cache hits. A value indicating whether reading cached values that were downloaded is allowed. Receives the sqlite statement from which the value may be obtained. The data can be obtained by passing this value (and column 0) to . Or if the data is large, column 0 will be NULL and a file name will be in column 1. Column 2 is the hash of the context in which the cached value was found. The caller must call with this value after reading the data if is returned from this method. if a value for this cache key was found; otherwise . Deletes all cache entries that point to a given external blob. The connection to use. The name of the blob that should not be referenced by the database any more. Purges stale entries from the cache. The sqlite connection to use. The number of inactive contexts we're willing to preserve, regardless of age. Contexts that have been accessed after this time will not be eligible for deletion. A cancellation token. Contexts will be preserved if they were accessed after or if they are among the most recently accessed contexts. All others will be deleted. Checks whether a recent context timestamp has already been set or if a timestamp refresh is warranted. The connection to use. The hash of environmental context, such as git commit. if the caller should switch to a write scheduler and call ; otherwise . Callers should already be on a non-exclusive scheduler. Anyone already on the exclusive scheduler should call directly. Records that a given context was just accessed, and thus any cache purge policy should consider this context as fresh. The connection to use. The hash of environmental context, such as git commit. Flushes the content of write cache to disk. The connection to use. Enumerate containers that contain cache entries for a given context. The connection to read from. The hash of the context to read containers from. An enumerable that lazily generates the container key hashes. The memory is only valid until enumeration resumes. Exports a subset of the database to another. The connection to use for reading the database. The hash of the context to be exported. The key of the container to be exported. The absolute path to the exported database file. Imports the cache entries from one database into another. The connection to import into. The path to the database to import from. Enumerates through each external blob and invokes a callback to perform some processing of it. The path to the database to open. A function that accepts each external blob name to perform processing. A cancellation token. A task that tracks the async operation. Computes the duration of a delay to wait before retrying a sqlite operation. The number of the attempt that just failed. 1 is the recommended first number. The time to wait before the next attempt. This function is implemented as an exponential backoff function. Each attempt waits twice as long as the previous attempt waited, with a max of 1 second. Gets a value indicating whether the caller might have luck with retrying a sqlite operation due to failing with some kind of temporary condition. The exception that was thrown from the operation. The number of times the operation has already been attempted. if the caller might retry; if retrying is not likely to succeed. The caller should ideally wait for a time specified by before retrying to increase the odds of success without consuming too many resources. Retrieves a cache entry for a given context, container, name, and optionally version. Retrieves a cache entry for a given container, name, and version. Retrieves a cache entry for a given container, name, and related context for fuzzy matching. Initializes a potentially brand new database. The database to initialize. The schema to add the tables and indexes to. Represents an open transaction and provides rollback and commit functionality. Initializes a new instance of the struct and begins a transaction. The connection to create the transaction on. to create a write transaction; to create an upgradeable read transaction. Rolls back the transaction if has not yet been called. Commits the transaction. A connection together with prepared statements. Instance members of this type are not thread-safe. Our cache of prepared statements for given sql strings. Initializes a new instance of the class. The pool this connection belongs to. The path to the directory that contains the sqlite database and any supporting files. Gets the underlying database object. Gets the pool that this connection belongs to. Compiles a given SQL query on this connection and returns a cached result. A repeatedly used SQL query. The compiled SQL statement. Throws an internal error exception if the caller is not on a intended for sqlite access. if the caller will be writing to the database; otherwise. A pool of objects. All members on this type are thread-safe. When this pool is disposed of, any currently rented connections are left open until they are returned. Initializes a new instance of the class that accesses a database in the default location. Initializes a new instance of the class. Gets the schedulers to use when accessing sqlite. Gets the path to the directory that contains the sqlite database. Gets the path to the external blob directory. Gets a disposal token. Disposes of managed and native resources owned by this object. A task that completes with disposal. Returns a wrapped in a rental so it can be returned to the pool when the caller is done using it. A rental that may be disposed to return it. Schedules a flush of the in-memory cache to disk. Schedules work on a scheduler designed to minimize LOCKED or BUSY result codes. This is only 100% effective when only one pool and process accesses a given file. The type of value returned from the . The function that accesses the sqlite database. This delegate must be prepared to execute again if it throws a with an error code of or . if the will write to the database; if only read access is required. to not throw if the instance is already disposed. A cancellation token. A task whose result will be the result from . A returnable wrapper around a pooled object. Initializes a new instance of the struct. The pool from which was drawn. The rented connection. Gets the sqlite connection object that was taken from the pool. Callers should not close this connection. If callers cannot return the connection in a clean state ready for subsequent users, avoid calling to return the connection to the pool and close the connection directly. An exception that represents an error from sqlite. Initializes a new instance of the class. Initializes a new instance of the class. Initializes a new instance of the class. Initializes a new instance of the class. The error code from sqlite. An additional message that may be supplied by sqlite. Initializes a new instance of the class. Gets the error code from sqlite. Extension methods on sqlite.raw methods. Throws an exception if a sqlite result code represents a failure. The result code. The message describing error details, if available. The result, if it wasn't an error. Thrown when represents an error. Throws an exception if a sqlite result code represents a failure. The result code. The connection that produced the error code. The result, if it wasn't an error. Thrown when represents an error. Describes the schema of the JSON file that may appear in a repo to identify the Azure Storage account to use to share the cache. Gets or sets the ID of the tenant with the subscription that contains the storage account. Gets or sets the name of the storage account. Gets or sets the name of the container to use. A strongly-typed resource class, for looking up localized strings, etc. Returns the cached ResourceManager instance used by this class. Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class. Looks up a localized string similar to Error while reading the value from the pipe.. Looks up a localized string similar to This operation requires service version {0} but {1} was activated. Obtain the newer version from {2} or later.. Looks up a localized string similar to Non-empty value required.. Looks up a localized string similar to No storage account has been set up for this repo.. Looks up a localized string similar to The open context is not tied to a supported version control system.. Looks up a localized string similar to The relative path base is not available, possibly because there is no open folder or solution.. The **HRESULT** data type is the same as the [SCODE](scode.md) data type. An **HRESULT** value consists of the following fields: - A 1-bit code indicating severity, where zero represents success and 1 represents failure. - A 4-bit reserved value. - An 11-bit code indicating responsibility for the error or warning, also known as a facility code. - A 16-bit code describing the error or warning. Most MAPI interface methods and functions return **HRESULT** values to provide detailed cause formation. **HRESULT** values are also used widely in OLE interface methods. OLE provides several macros for converting between **HRESULT** values and **SCODE** values, another common data type for error handling. > [!NOTE] > In 64-bit MAPI, **HRESULT** is still a 32-bit value. For information about the OLE use of **HRESULT** values, see the *OLE Programmer's Reference*. For more information about the use of these values in MAPI, see [Error Handling](error-handling-in-mapi.md) and any of the following interface methods: [IABLogon::GetLastError](iablogon-getlasterror.md) [IMAPISupport::GetLastError](imapisupport-getlasterror.md) [IMAPIControl::GetLastError](imapicontrol-getlasterror.md) [IMAPITable::GetLastError](imapitable-getlasterror.md) [IMAPIProp::GetLastError](imapiprop-getlasterror.md) [IMAPIViewAdviseSink::OnPrint](imapiviewadvisesink-onprint.md) Read more on learn.microsoft.com. A pointer to the IErrorInfo interface that provides more information about the error. You can specify to use the current IErrorInfo interface, or new IntPtr(-1) to ignore the current IErrorInfo interface and construct the exception just from the error code. , if it does not reflect an error. A pointer to a null-terminated, constant character string. A pointer to the first character in the string. The content should be considered readonly, as it was typed as constant in the SDK. Gets the number of characters up to the first null character (exclusive). Returns a with a copy of this character array, up to the first null character (exclusive). A , or if is . Returns a span of the characters in this string, up to the first null character (exclusive). The length of the inline array. Gets a ref to an individual element of the inline array. ⚠ Important ⚠: When this struct is on the stack, do not let the returned reference outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. GetCost method retrieves the current cost of either a machine-wide internet connection, or the first-hop of routing to a specific destination on a connection. A DWORD value that indicates the cost of the connection. The lowest 16 bits represent the cost level, and the highest 16 bits represent the flags. Possible values are defined by the NLM_CONNECTION_COST enumeration. An NLM_SOCKADDR structure containing the destination IPv4/IPv6 address. If NULL, this method will instead return the cost associated with the preferred connection used for machine Internet connectivity. Returns S_OK on success, otherwise an HRESULT error code is returned. This doc was truncated. Learn more about this API from learn.microsoft.com. GetDataPlanStatus retrieves the data plan status for either a machine-wide internet connection , or the first-hop of routing to a specific destination on a connection. Pointer to an NLM_DATAPLAN_STATUS structure that describes the data plan status associated with a connection used to route to a destination. If destIPAddr specifies a tunnel address, the first available data plan status in the interface stack is returned. An NLM_SOCKADDR structure containing the destination IPv4/IPv6 or tunnel address. If NULL, this method returns the cost associated with the preferred connection used for machine Internet connectivity. Returns S_OK on success, otherwise an HRESULT error code is returned. This doc was truncated. Learn more about this API from learn.microsoft.com. SetDestinationAddresses method registers specified destination IPv4/IPv6 addresses to receive cost or data plan status change notifications. The number of destination IPv4/IPv6 addresses in the list. A NLM_SOCKADDR structure containing a list of destination IPv4/IPv6 addresses to register for cost or data plan status change notification. If true, pDestIPAddrList will be appended to the existing address list; otherwise the existing list will be overwritten. Returns S_OK on success, otherwise an HRESULT error code is returned. This doc was truncated. This method must be called before IConnectionPoint::Advise. Once IConnectionPoint::Advise is called, this method will not complete successfully until last sink calls IConnectionPoint::UnAdvise. However, this method can be called multiple times prior to the call to IConnectionPoint::Advise. If a list of destination addresses indicated by pDestIPAddrList contains duplicate addresses, only one of each will be used to notify cost changes. Callers can clear a list of destinations by calling this function with length set to 0, destIPAddrList set NULL, and bAppend set FALSE. Read more on learn.microsoft.com. The NLM_CONNECTION_COST enumeration specifies a set of cost levels and cost flags supported in Windows 8 Cost APIs. The value returned by the INetworkConnectionCost::GetCost method can have multiple bits set with the values specified by this enumeration. The cost is unknown. The connection is unlimited and is considered to be unrestricted of usage charges and capacity constraints. The use of this connection is unrestricted up to a specific data transfer limit. This connection is regulated on a per byte basis. The connection is currently in an OverDataLimit state as it has exceeded the carrier specified data transfer limit. The network is experiencing high traffic load and is congested. The connection is roaming outside the network and affiliates of the home provider. The connection is approaching the data limit specified by the carrier. NLM_DATAPLAN_STATUS structure stores the current data plan status information supplied by the carrier. Learn more about this API from learn.microsoft.com. The unique ID of the interface associated with the data plan. This GUID is determined by the system when a data plan is first used by a system connection. An NLM_USAGE_DATA structure containing current data usage value expressed in megabytes, as well as the system time at the moment this value was last synced. If this value is not supplied, NLM_USAGE_DATA will indicate NLM_UNKNOWN_DATAPLAN_STATUS for UsageInMegabytes and a value of '0' will be set for LastSyncTime. Read more on learn.microsoft.com. The data plan usage limit expressed in megabytes. If this value is not supplied, a default value of NLM_UNKNOWN_DATAPLAN_STATUS is set. The maximum inbound connection bandwidth expressed in kbps. If this value is not supplied, a default value of NLM_UNKNOWN_DATAPLAN_STATUS is set. The maximum outbound connection bandwidth expressed in kbps. If this value is not supplied, a default value of NLM_UNKNOWN_DATAPLAN_STATUS is set. The start time of the next billing cycle. If this value is not supplied, a default value of '0' is set. The maximum suggested transfer size for this network expressed in megabytes. If this value is not supplied, a default value of NLM_UNKNOWN_DATAPLAN_STATUS is set. Reserved for future use. NLM_SOCKADDR structure contains the IPv4/IPv6 destination address. Learn more about this API from learn.microsoft.com. An IPv4/IPv6 destination address. NLM_USAGE_DATA structure stores information that indicates the data usage of a plan. If usage is not supplied, UsageInMegabytes is set to NLM_UNKNOWN_DATAPLAN_STATUS (0xFFFFFFFF), and LastSyncTime is set to 0. The data usage of a plan, represented in megabytes. The timestamp of last time synced with carriers about the data usage stored in this structure. Contains extern methods from "KERNEL32.dll". Closes an open object handle. A valid handle to an open object. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError. If the application is running under a debugger, the function will throw an exception if it receives either a handle value that is not valid or a pseudo-handle value. This can happen if you close a handle twice, or if you call CloseHandle on a handle returned by the FindFirstFile function instead of calling the FindClose function. The CloseHandle function closes handles to the following objects: This doc was truncated. Read more on learn.microsoft.com. Creates or opens a file or I/O device. The most commonly used I/O devices are as follows:\_file, file stream, directory, physical disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. (Unicode) The name of the file or device to be created or opened. You may use either forward slashes (/) or backslashes (\\) in this name. In the ANSI version of this function, the name is limited to MAX_PATH characters. To extend this limit to 32,767 wide characters, use this Unicode version of the function and prepend "\\\\?\\" to the path. For more information, see Naming Files, Paths, and Namespaces. For information on special device names, see Defining an MS-DOS Device Name. 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.
Tip Starting with Windows 10, version 1607, for the unicode version of this function (CreateFileW), you can opt-in to remove the MAX_PATH limitation without prepending "\\?\". See the "Maximum Path Length Limitation" section of Naming Files, Paths, and Namespaces for details.
 Read more on learn.microsoft.com. The requested access to the file or device, which can be summarized as read, write, both or neither zero). The most commonly used values are GENERIC_READ, GENERIC_WRITE, or both (GENERIC_READ | GENERIC_WRITE). For more information, see Generic Access Rights, File Security and Access Rights, File Access Rights Constants, and ACCESS_MASK. If this parameter is zero, the application can query certain metadata such as file, directory, or device attributes without accessing that file or device, even if GENERIC_READ access would have been denied. You cannot request an access mode that conflicts with the sharing mode that is specified by the dwShareMode parameter in an open request that already has an open handle. For more information, see the Remarks section of this topic and Creating and Opening Files. Read more on learn.microsoft.com. The requested sharing mode of the file or device, which can be read, write, both, delete, all of these, or none (refer to the following table). Access requests to attributes or extended attributes are not affected by this flag. If this parameter is zero and CreateFile succeeds, the file or device cannot be shared and cannot be opened again until the handle to the file or device is closed. For more information, see the Remarks section. You cannot request a sharing mode that conflicts with the access mode that is specified in an existing request that has an open handle. CreateFile would fail and the GetLastError function would return ERROR_SHARING_VIOLATION. To enable a process to share a file or device while another process has the file or device open, use a Read more on learn.microsoft.com. A pointer to a SECURITY_ATTRIBUTES structure that contains two separate but related data members: an optional security descriptor, and a Boolean value that determines whether the returned handle can be inherited by child processes. This parameter can be NULL. If this parameter is NULL, the handle returned by CreateFile cannot be inherited by any child processes the application may create and the file or device associated with the returned handle gets a default security descriptor. The lpSecurityDescriptor member of the structure specifies a SECURITY_DESCRIPTOR for a file or device. If this member is NULL, the file or device associated with the returned handle is assigned a default security descriptor. CreateFile ignores the lpSecurityDescriptor member when opening an existing file or device, but continues to use the bInheritHandle member. The bInheritHandle member of the structure specifies whether the returned handle can be inherited. For more information, see the Remarks section. Read more on learn.microsoft.com. An action to take on a file or device that exists or does not exist. For devices other than files, this parameter is usually set to OPEN_EXISTING. For more information, see the Remarks section. Read more on learn.microsoft.com. The file or device attributes and flags, FILE_ATTRIBUTE_NORMAL being the most common default value for files. This parameter can include any combination of the available file attributes (FILE_ATTRIBUTE_*). All other file attributes override FILE_ATTRIBUTE_NORMAL. This parameter can also contain combinations of flags (FILE_FLAG_*) for control of file or device caching behavior, access modes, and other special-purpose flags. These combine with any FILE_ATTRIBUTE_* values. This parameter can also contain Security Quality of Service (SQOS) information by specifying the SECURITY_SQOS_PRESENT flag. Additional SQOS-related flags information is presented in the table following the attributes and flags tables.
Note When CreateFile 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 dwFlagsAndAttributes. Special cases are detailed in Creating and Opening Files.
Some of the following file attributes and flags may only apply to files and not necessarily all other types of devices that CreateFile can open. For additional information, see the Remarks section of this topic and Creating and Opening Files. For more advanced access to file attributes, see SetFileAttributes. For a complete list of all file attributes with their values and descriptions, see File Attribute Constants. This doc was truncated. Read more on learn.microsoft.com. A valid handle to a template file with the GENERIC_READ access right. The template file supplies file attributes and extended attributes for the file that is being created. This parameter can be NULL. When opening an existing file, CreateFile ignores this parameter. When opening a new encrypted file, the file inherits the discretionary access control list from its parent directory. For additional information, see File Encryption. Read more on learn.microsoft.com. If the function succeeds, the return value is an open handle to the specified file, device, named pipe, or mail slot. If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. CreateFile was originally developed specifically for file interaction but has since been expanded and enhanced to include most other types of I/O devices and mechanisms available to Windows developers. This section attempts to cover the varied issues developers may experience when using CreateFile in different contexts and with different I/O types. The text attempts to use the word file only when referring specifically to data stored in an actual file on a file system. However, some uses of file may be referring more generally to an I/O object that supports file-like mechanisms. This liberal use of the term file is particularly prevalent in constant names and parameter names because of the previously mentioned historical reasons. When an application is finished using the object handle returned by CreateFile, use the CloseHandle function to close the handle. This not only frees up system resources, but can have wider influence on things like sharing the file or device and committing data to disk. Specifics are noted within this topic as appropriate. Windows Server 2003 and Windows XP: A sharing violation occurs if an attempt is made to open a file or directory for deletion on a remote computer when the value of the dwDesiredAccess parameter is the DELETE access flag (0x00010000) OR'ed with any other access flag, and the remote file or directory has not been opened with FILE_SHARE_DELETE. To avoid the sharing violation in this scenario, open the remote file or directory with the DELETE access right only, or call DeleteFile without first opening the file or directory for deletion. Some file systems, such as the NTFS file system, support compression or encryption for individual files and directories. On volumes that have a mounted file system with this support, a new file inherits the compression and encryption attributes of its directory. You cannot use CreateFile to control compression, decompression, or decryption on a file or directory. For more information, see Creating and Opening Files, File Compression and Decompression, and File Encryption. Windows Server 2003 and Windows XP: For backward compatibility purposes, CreateFile does not apply inheritance rules when you specify a security descriptor in lpSecurityAttributes. To support inheritance, functions that later query the security descriptor of this file may heuristically determine and report that inheritance is in effect. For more information, see Automatic Propagation of Inheritable ACEs. As stated previously, if the lpSecurityAttributes parameter is NULL, the handle returned by CreateFile cannot be inherited by any child processes your application may create. The following information regarding this parameter also applies: This doc was truncated. Read more on learn.microsoft.com. The SECURITY_ATTRIBUTES structure contains the security descriptor for an object and specifies whether the handle retrieved by specifying this structure is inheritable. The size, in bytes, of this structure. Set this value to the size of the **SECURITY\_ATTRIBUTES** structure. A pointer to a [**SECURITY\_DESCRIPTOR**](../winnt/ns-winnt-security_descriptor.md) structure that controls access to the object. If the value of this member is **NULL**, the object is assigned the default security descriptor associated with the [*access token*](/windows/win32/secauthz/access-tokens) of the calling process. This is not the same as granting access to everyone by assigning a **NULL** [*discretionary access control list*](/windows/win32/secauthz/dacls-and-aces) (DACL). By default, the default DACL in the access token of a process allows access only to the user represented by the access token. For information about creating a security descriptor, see [Creating a Security Descriptor](/windows/win32/secauthz/creating-a-security-descriptor-for-a-new-object-in-c--). Read more on learn.microsoft.com. A Boolean value that specifies whether the returned handle is inherited when a new process is created. If this member is **TRUE**, the new process inherits the handle. Specifies the priority of a member in overload resolution. When unspecified, the default priority is 0. Initializes a new instance of the class. The priority of the attributed member. Higher numbers are prioritized, lower numbers are deprioritized. 0 is the default if no attribute is present. The priority of the member. Indicates that a method will allow a variable number of arguments in its invocation. P39Nmx0leQamkfXcudKLNuMpRBxVstjpu9PcF8BaoY4=MJVlozaURJGQlh4ORmptjL6BRnlVE8H1NyvvqnY2qC2swolGAOXhKBNoENgCev6y+qSPuiUuUN2lTo179slA13WZIfObQ45B07DP4505o2E8aWh2rpIGcirZxa5FNeMY/ZZOezSZse2tQB7aygB8ZlGXR6vDCyD/lfbIl8vsgFtGw1Be5nxpCdcQrgRB5IPbrJTH9BQf3w7RbzJ63a2uRUJ2LKieDtkP0zor9nUA9FXweEdXMGNRf4TcFxdyBYS4RI2xp6FQeRqnhcrUzN4gGOZwwyIrnXTixiiLdRO4l1mOZnITfFHuOTuY+Ou4tDzGKArjSmlG73fupXLn0OdKfA==wEpIdXKb7lKn26sXpXuywkhxGplTQXxROLmNRZBrAHVBf7546RNXZwA/bzDqsuWTuPSC4T+I4j/z9j5/WqPuUw7SpnEPqWXc2xu7eN8kVyQt5170xkK6KHT4vVEkIvayPtIMLl0SgSCOy/pN5DJCi5ha7FlI84F1Qi2GumR+wQgCwHCVmU8Fj6Ik+B6akISXGCwe6X3rQFQngRFWQ/IrSkOkAOfy0EfvV+nZUo+FcbWuCZ6cb4Eq5I1ws/rZSeuwAWeedZcNt0VlNbsn4AnxBYQX4sj0dlko7JD5fWqeqq3/HzUNbBmLp9qeCXV8XlACn9YVWv900F47z04kVwpyTw==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