Microsoft.VisualStudio.Cache Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code. This definition is provided by the IsExternalInit NuGet package (https://www.nuget.org/packages/IsExternalInit). Please see https://github.com/manuelroemer/IsExternalInit for more information. 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.. A pointer to a 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. A , or if is . Returns a span of the characters in this string. Returns a span of the characters in this string. 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. Learn more about this API from docs.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. 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 docs.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 docs.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 docs.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 bInheritHandlemember of the structure specifies whether the returned handle can be inherited. For more information, see the Remarks section. Read more on docs.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 docs.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 docs.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 docs.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. Learn more about this API from docs.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. Read more on docs.microsoft.com. 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 docs.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. L0t8SarejQ2YxGPHBt+rH0P4CFEW4/N7Nu/FEuvrfO4=aHS8sb9clJjIOqFtvjR3WaAPyaHq/ZkEWA1OioqJFnhx2t+D3Bi+W3CbVjbgJZhgPJVXuiqPk4FwQGOcTSvhe/QKgdB2ev/0RK7RqTcs/2XWOWwMjGJfZY0t0muJXyLixwovFax2XL7qmiVIOeYcsaZ7i8J1IIGJ2bNnd2DPgxge7w6zml0bBYVGn+z+rFM+Uy4DUjRDQTgaWF1xiLIiQYEBDJPrWLrIXnx3GOi+/2lJqoqwyqUJpxEABdif4G87KCgOfGPygQc+x+HI4iOHH5q9nfkZBBdUp1uEx66zCNAr1XJCjegQNGMInoUwWn01/q7x+xODp38sB+Ws9w5p1w==tCg32mOdDA6rBBnZSMwxwXegqiDEUFlvQH9Sxww07hY3w7L52tJxLg0mCZjcszQddI6W4NJYb5E9QM319kyyE0l8EvA/pgcxgljDP8E6XIlgVf6W40ms286Cr0azaA1f7vaJjjNhGsMqOSSSXTZDNnfKs5ENG0bkXeB2q5hrp0qLsm/TWO3oFjeROZVHN2tgETswHR3WKTm6QjnXgGNj+V6rSZJO/WkTqc8NesAo3Up/KjMwgc0e67x9llZLxRyyMWUBE9coT2+pUZqYAUDZ84nR1djnMY3PMDYiA84Gw5JpceeED38O0cEIvKdX8uG8oQa047+evMfDRr94MG9EWw==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