CBRegistry Component

Properties   Methods   Events   Config Settings   Errors  

The CBRegistry component allows applications to intercept and control registry requests.

Syntax

callback.CBFSFilter.Cbregistry

Remarks

The CBRegistry component gives applications the ability to intercept and registry requests, allowing them to be altered, handled, and blocked. Applications use standard filter rules to specify which requests they are interested in intercepting; and special filter rules to enforce access restrictions.

To learn more about the component's capabilities, please refer to the product's General Information topics.

Getting Started

1. If the component's system driver has not been installed yet, call the Install method to do so. This needs to be done only once.
   • In production, the driver can be installed (or updated) ahead of time by the application's installation script using the Installer DLL. Please refer to the Driver Installation topic for more information.
2. Call the Initialize method to initialize the CBRegistry component. This must be done each time the application starts.
3. Add one or more filter rules using methods like AddFilterRule. (Rules also can be added or removed after the filter is started.)
4. Call the StartFilter method to start filtering filesystem requests.
5. When finished, call the StopFilter method to stop filtering filesystem requests.
6. To uninstall the component's system driver, call the Uninstall method. This should not be done as part of the driver upgrade process.
   • In production, the driver can be uninstalled by the application's uninstallation script using the Installer DLL. Please refer to the Driver Installation topic for more information.

Property List

The following is the full list of the properties of the component with short descriptions. Click on the links for further details.

Method List

The following is the full list of the methods of the component with short descriptions. Click on the links for further details.

Event List

The following is the full list of the events fired by the component with short descriptions. Click on the links for further details.

Config Settings

The following is a list of config settings for the component with short descriptions. Click on the links for further details.

Active Property (CBRegistry Component)

This property notes whether the component is active and processing requests.

Syntax

• C#
• VB.NET

public bool Active { get; }

Public ReadOnly Property Active As Boolean

Default Value

False

Remarks

This property reflects whether the component is active and currently processing requests. It will be true after the filter has been attached successfully via a call to StartFilter.

This property is read-only and not available at design time.

Altitude Property (CBRegistry Component)

This property specifies the altitude the component's system driver should use.

Syntax

• C#
• VB.NET

public string Altitude { get; set; }

Public Property Altitude As String

Default Value

"400055"

Remarks

This property specifies the altitude that the component's system driver should use. A driver's altitude determines its absolute position in the stack of filter drivers; drivers with higher altitudes are attached toward the top of the stack, closer to the user mode, which allows them to process requests earlier.

Registry filter drivers are not required to specify an altitude; and this property's default empty value is interpreted as "no altitude". However, registry filter drivers that do not specify an altitude will always be attached near the top of the filter driver stack, which may not be desirable. Please refer to the Driver Altitudes topic for more information.

DefaultRules Property (CBRegistry Component)

This property includes a collection of default rules.

Syntax

• C#
• VB.NET

public RegDefaultRuleList DefaultRules { get; }

Public ReadOnly Property DefaultRules As RegDefaultRuleList

Remarks

This property holds a collection of RegDefaultRule objects, each of which represents a default rule. Please refer to the Default Rules topic for more information.

Use the following methods to manage default rules:

• AddDefaultRule
• DeleteDefaultRule
• SuspendDefaultRules

Note: Because default rules are managed by the component's system driver, this collection is not populated by default, nor is it updated by any of the aforementioned methods. Applications can call the CreateDefaultRulesSnapshot method to populate this collection; and must call the CloseDefaultRulesSnapshot method when finished working with it to release the associated memory.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

This property is read-only and not available at design time.

FilterRules Property (CBRegistry Component)

This property includes a collection of filter rules.

Syntax

• C#
• VB.NET

public RegFilterRuleList FilterRules { get; }

Public ReadOnly Property FilterRules As RegFilterRuleList

Remarks

This property holds a collection of RegFilterRule objects, each of which represents a standard filter rule, access rule, or both. Please refer to the File and Registry Filter Rules and Access Rules topics for more information.

Use the following methods to manage the rules in this collection:

• AddFilterRule
• DeleteFilterRule
• DeleteAllFilterRules

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

This property is read-only and not available at design time.

PassthroughRules Property (CBRegistry Component)

This properly includes a collection of passthrough rules.

Syntax

• C#
• VB.NET

public RegPassthroughRuleList PassthroughRules { get; }

Public ReadOnly Property PassthroughRules As RegPassthroughRuleList

Remarks

This property holds a collection of RegPassthroughRule objects, each of which represents a passthrough rule. Please refer to the Passthrough Rules topic for more information.

Use the following methods to manage the rules in this collection:

• AddPassthroughRule
• DeletePassthroughRule
• DeleteAllPassthroughRules

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

This property is read-only and not available at design time.

SerializeEvents Property (CBRegistry Component)

Whether events should be fired on a single worker thread, or many.

Syntax

• C#
• VB.NET

public CbregistrySerializeEvents SerializeEvents { get; set; }

enum CbregistrySerializeEvents {
  seOnMultipleThreads,
  seOnOneWorkerThread
}

Public Property SerializeEvents As CbregistrySerializeEvents

Enum CbregistrySerializeEvents
  seOnMultipleThreads
  seOnOneWorkerThread
End Enum

Default Value

0

Remarks

This property specifies whether the component should fire all events serially on a single worker thread, or concurrently on multiple worker threads. The possible values are:

Please refer to the Threading and Concurrency topic for more information.

Note: This property cannot be changed when Active is true, and it cannot be changed within events.

Tag Property (CBRegistry Component)

This property stores application-defined data specific to a particular instance of the component.

Syntax

• C#
• VB.NET

public long Tag { get; set; }

Public Property Tag As Long

Default Value

0

Remarks

This property can be used to store data specific to a particular instance of the component.

AddDefaultRule Method (CBRegistry Component)

This method adds a default rule.

Syntax

• C#
• VB.NET

public bool AddDefaultRule(string mask, int accessFlags, string productGUID);

Public Function AddDefaultRule(ByVal Mask As String, ByVal AccessFlags As Integer, ByVal ProductGUID As String) As Boolean

Remarks

This method adds a default rule for the registry keys that matches the specified Mask. Each rule in a ruleset is uniquely identified by its mask; if a rule with the specified mask already exists, the new rule's parameters are merged into it.

If the rule is added successfully, this method returns true; otherwise, it returns false.

Default rules, like access rules, instruct the component's system driver to apply certain access restrictions to matching registry keys. However, unlike access rules, default rules are managed by the driver directly; they are activated as soon as the driver loads at boot time, and then continue to be enforced at all times, regardless of whether or not the application that added them is open.

The Mask parameter must be a valid registry key mask according to the Registry Key Masks topic. Only the registry keys that match the specified mask will be covered by the rule.

The AccessFlags parameter specifies which access restrictions the component's system driver should apply to matching registry keys. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

The ProductGUID parameter identifies the application that the rule should be associated with in the registry. In most cases, the value passed for this parameter should be the same one that was used to call the Initialize method.

This method requires administrative rights to execute successfully. If the user account of the process that calls this method doesn't have such rights, the call will fail with an ERROR_PRIVILEGE_NOT_HELD (0x0522) error. Please refer to the Default Rules topic for more information.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

AddFilteredProcessById Method (CBRegistry Component)

This method adds a process, by process ID (PID), to the list of filtered processes.

Syntax

• C#
• VB.NET

public void AddFilteredProcessById(int processId, bool includeChildren);

Public Sub AddFilteredProcessById(ByVal ProcessId As Integer, ByVal IncludeChildren As Boolean)

Remarks

This method adds the process with the specified ProcessId (PID) to the list of processes whose requests should be filtered (i.e., that the component should fire events for).

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The ProcessId parameter specifies the PID of the process whose requests should be filtered. The value passed for this parameter must either be the PID of an existing process; or -1, which means "all processes". When adding a PID-based rule, you need to be aware of the PID Reuse behavior of Windows.

The IncludeChildren parameter specifies whether requests made by the specified process's children should also be filtered.

Note: This method can be called only when Active is true.

AddFilteredProcessByName Method (CBRegistry Component)

This method adds a process, by name, to the list of filtered processes.

Syntax

• C#
• VB.NET

public void AddFilteredProcessByName(string processName, bool includeChildren);

Public Sub AddFilteredProcessByName(ByVal ProcessName As String, ByVal IncludeChildren As Boolean)

Remarks

This method adds the process with the specified ProcessName to the list of processes whose requests should be filtered (i.e., that the component should fire events for).

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The ProcessName parameter must be a valid process executable name. It may optionally begin with a path, and both the name and the path (if present) may include wildcards (* and ?). A process with a matching executable name does not actually need to exist when this method is called.

The IncludeChildren parameter specifies whether requests made by the specified process's children should also be filtered.

Note: This method can be called only when Active is true.

AddFilterRule Method (CBRegistry Component)

This method adds a standard filter rule or access rule.

Syntax

• C#
• VB.NET

public bool AddFilterRule(string mask, int accessFlags, long controlFlags);

Public Function AddFilterRule(ByVal Mask As String, ByVal AccessFlags As Integer, ByVal ControlFlags As Long) As Boolean

Remarks

This method adds a standard filter rule or access rule for the registry keys that matches the specified Mask. Each rule in a ruleset is uniquely identified by its mask; if a rule with the specified mask already exists, the new rule's parameters are merged into it. If the rule is added successfully, this method returns true; otherwise, it returns false.

Standard filter rules determine which registry operations, of those performed on matching registry keys, the component should fire its events for. Access rules instruct the component's system driver to apply certain access restrictions to matching registry keys.

The Mask parameter must be a valid registry key mask according to the Registry Key Masks topic. Only the registry keys that match the specified mask will be covered by the rule.

The AccessFlags parameter specifies which access restrictions the component's system driver should apply to matching registry keys. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

The ControlFlags parameter specifies which registry operations the component should fire Control Events for. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

AddIgnoredProcessById Method (CBRegistry Component)

This method adds a process, by process Id (PID), to the list of ignored processes.

Syntax

• C#
• VB.NET

public void AddIgnoredProcessById(int processId, bool includeChildren);

Public Sub AddIgnoredProcessById(ByVal ProcessId As Integer, ByVal IncludeChildren As Boolean)

Remarks

This method adds the process with the specified ProcessId (PID) to the list of processes whose requests should be ignored (i.e., that the component should not fire events for).

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The ProcessId parameter specifies the PID of the process whose requests should be ignored. The value passed for this parameter must be the PID of an existing process. When adding a PID-based rule, you need to be aware of the PID Reuse behavior of Windows.

The IncludeChildren parameter specifies whether requests made by the specified process's children should also be ignored.

Note: The component's system driver ignores all processes' requests by default; applications should use this method only to explicitly exclude a process that would otherwise be filtered because of a process filtering rule added with AddFilteredProcessById or AddFilteredProcessByName.

Note: This method can be called only when Active is true.

AddIgnoredProcessByName Method (CBRegistry Component)

This method adds a process, by name, to the list of ignored processes.

Syntax

• C#
• VB.NET

public void AddIgnoredProcessByName(string processName, bool includeChildren);

Public Sub AddIgnoredProcessByName(ByVal ProcessName As String, ByVal IncludeChildren As Boolean)

Remarks

This method adds the process with the specified ProcessName to the list of processes whose requests should be ignored (i.e., that the component should not fire events for).

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The ProcessName parameter must be a valid process executable name. It may optionally begin with a path, and both the name and the path (if present) may include wildcards (* and ?). A process with a matching executable name does not actually need to exist when this method is called.

The IncludeChildren parameter specifies whether requests made by the specified process's children should also be ignored.

Note: The component's system driver ignores all processes' requests by default; applications should use this method only to explicitly exclude a process that would otherwise be filtered because of a process filtering rule added with AddFilteredProcessById or AddFilteredProcessByName.

Note: This method can be called only when Active is true.

AddPassthroughRule Method (CBRegistry Component)

This method adds a passthrough rule.

Syntax

• C#
• VB.NET

public bool AddPassthroughRule(string mask, int accessFlags, long controlFlags);

Public Function AddPassthroughRule(ByVal Mask As String, ByVal AccessFlags As Integer, ByVal ControlFlags As Long) As Boolean

Remarks

This method adds a passthrough rule for the registry keys that matches the specified Mask. Each rule in a ruleset is uniquely identified by its mask; if a rule with the specified mask already exists, the new rule's parameters are merged into it.

If the rule is added successfully, this method returns true; otherwise, it returns false.

Passthrough rules exclude matching registry keys from being processed by other filter rules.

The Mask parameter must be a valid registry key mask according to the Registry Key Masks topic. Only the registry keys that match the specified mask will be covered by the rule.

The AccessFlags parameter specifies which access restrictions the component's system driver should lift from matching registry keys. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

The ControlFlags parameter specifies which registry operations the component should not fire Control Events for. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

CloseDefaultRulesSnapshot Method (CBRegistry Component)

This method closes the previously created default rules snapshot.

Syntax

• C#
• VB.NET

public void CloseDefaultRulesSnapshot();

Public Sub CloseDefaultRulesSnapshot()

Remarks

This method closes the default rules snapshot previously created by CreateDefaultRulesSnapshot, releasing the memory associated with it. Please refer to that method's documentation for more information.

Note: This method cannot be called within events.

The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads (e.g., during the AfterFilterAttachToVolume and AfterFilterDetachFromVolume events) are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists both occur in a thread-safe manner.

Config Method (CBRegistry Component)

Sets or retrieves a configuration setting.

Syntax

• C#
• VB.NET

public string Config(string configurationString);

Public Function Config(ByVal ConfigurationString As String) As String

Remarks

Config is a generic method available in every component. It is used to set and retrieve configuration settings for the component.

These settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the component, access to these internal properties is provided through the Config method.

To set a configuration setting named PROPERTY, you must call Config("PROPERTY=VALUE"), where VALUE is the value of the setting expressed as a string. For boolean values, use the strings "True", "False", "0", "1", "Yes", or "No" (case does not matter).

To read (query) the value of a configuration setting, you must call Config("PROPERTY"). The value will be returned as a string.

CreateDefaultRulesSnapshot Method (CBRegistry Component)

This method creates a snapshot of information about the default rules that have been added.

Syntax

• C#
• VB.NET

public void CreateDefaultRulesSnapshot(string productGUID);

Public Sub CreateDefaultRulesSnapshot(ByVal ProductGUID As String)

Remarks

This method creates a snapshot of information about all default rules that have been added by the application identified by ProductGUID. This information is then used to populate the DefaultRules collection property.

When the application is finished working with the default rules snapshot, it must close it by calling the CloseDefaultRulesSnapshot method to release the associated memory. If this method is called again before an existing snapshot is closed, the component will attempt to close it before creating a new one.

Note: This method cannot be called within events.

The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads (e.g., during the AfterFilterAttachToVolume and AfterFilterDetachFromVolume events) are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists both occur in a thread-safe manner.

DeleteAllFilterRules Method (CBRegistry Component)

This method deletes all standard filter rules.

Syntax

• C#
• VB.NET

public bool DeleteAllFilterRules();

Public Function DeleteAllFilterRules() As Boolean

Remarks

This method deletes all standard filter rules that are currently present.

If the rules are deleted successfully, this method returns true; otherwise, it returns false.

To delete standard filter rules individually, use the DeleteFilterRule method instead.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

DeleteAllPassthroughRules Method (CBRegistry Component)

This method deletes all passthrough rules.

Syntax

• C#
• VB.NET

public bool DeleteAllPassthroughRules();

Public Function DeleteAllPassthroughRules() As Boolean

Remarks

This method deletes all passthrough rules that are currently present.

If the rules are deleted successfully, this method returns true; otherwise, it returns false.

To delete passthrough rules individually, use the DeletePassthroughRule method instead.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

DeleteDefaultRule Method (CBRegistry Component)

This method deletes a particular default rule.

Syntax

• C#
• VB.NET

public bool DeleteDefaultRule(string mask, int accessFlags, string productGUID);

Public Function DeleteDefaultRule(ByVal Mask As String, ByVal AccessFlags As Integer, ByVal ProductGUID As String) As Boolean

Remarks

This method deletes the specified AccessFlags from the default rule identified by Mask and associated with the application identified by ProductGUID. If AccessFlags includes all flags currently present in the rule, then the entire rule is deleted; otherwise, the flags specified by AccessFlags are simply removed from the rule.

If the flags or this rule are deleted successfully, this method returns true; otherwise, it returns false.

The Mask parameter must be the registry key mask of an existing rule. If a rule with the specified mask cannot be found, this method will fail.

The AccessFlags parameter specifies which access restrictions should be removed from the rule. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

In most cases, the value passed for the ProductGUID parameter should be the same one that was used to call the Initialize method. Please refer to the AddDefaultRule method's documentation for more information.

This method requires administrative rights to execute successfully. If the user account of the process that calls this method doesn't have such rights, the call will fail with an ERROR_PRIVILEGE_NOT_HELD (0x0522) error. Please refer to the Default Rules topic for more information.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

DeleteFilterRule Method (CBRegistry Component)

This method deletes a particular standard filter rule or access rule.

Syntax

• C#
• VB.NET

public bool DeleteFilterRule(string mask, int accessFlags, long controlFlags);

Public Function DeleteFilterRule(ByVal Mask As String, ByVal AccessFlags As Integer, ByVal ControlFlags As Long) As Boolean

Remarks

This method deletes the specified AccessFlags or ControlFlags from the standard filter rule or access rule identified by Mask. If the aforementioned parameters include all flags currently present in the rule, then the entire rule is deleted; otherwise, the specified flags are simply removed from the rule.

If the flags or this rule are deleted successfully, this method returns true; otherwise, it returns false.

The Mask parameter must be the registry key mask of an existing rule. If a rule with the specified mask cannot be found, this method will fail.

The AccessFlags parameter specifies which access restrictions should be removed from the rule. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

The ControlFlags parameter specifies which Control Event flags should be removed from the rule. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

To delete all standard filter rules and access rules, use the DeleteAllFilterRules method instead.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

DeletePassthroughRule Method (CBRegistry Component)

This method deletes a particular passthrough rule.

Syntax

• C#
• VB.NET

public bool DeletePassthroughRule(string mask, int accessFlags, long controlFlags);

Public Function DeletePassthroughRule(ByVal Mask As String, ByVal AccessFlags As Integer, ByVal ControlFlags As Long) As Boolean

Remarks

This method deletes the specified AccessFlags or ControlFlags from the passthrough rule identified by Mask. If the aforementioned parameters include all flags currently present in the rule, then the entire rule is deleted; otherwise, the specified flags are simply removed from the rule.

If the flags or this rule are deleted successfully, this method returns true; otherwise, it returns false.

The Mask parameter must be the registry key mask of an existing rule. If a rule with the specified mask cannot be found, this method will fail.

The AccessFlags parameter specifies which access restrictions should be removed from the rule. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

The ControlFlags parameter specifies which Control Event flags should be removed from the rule. The value passed for this parameter should be constructed by ORing together zero or more of the following flags:

To delete all passthrough rules, use the DeleteAllPassthroughRules method instead.

Note: The methods and properties related to rule management are not intended to be used from multiple threads at once. Applications that wish to use said methods and properties from multiple threads are responsible for employing proper thread synchronization techniques to ensure that manipulation and enumeration of the rule lists occurs in a thread-safe manner.

GetDriverStatus Method (CBRegistry Component)

This method retrieves the status of the component's system driver.

Syntax

• C#
• VB.NET

public int GetDriverStatus(string productGUID);

Public Function GetDriverStatus(ByVal ProductGUID As String) As Integer

Remarks

This method retrieves the status of the component's system driver. This status can then be used to verify whether it has been properly installed and is ready for use.

The value returned by the method corresponds to the dwCurrentState field of the SERVICE_STATUS structure from the Windows API. It will be one of the following:

ProductGUID is used to distinguish among driver installations performed by different applications. Such information is necessary to guard against unexpected situations, such as the driver being uninstalled by one application despite other applications still needing it.

Therefore, to ensure proper operation, it is critical that each individual application have its own unique ProductGUID value, and that applications (and their installation scripts) use that value when calling any of the following methods:

• Install
• Uninstall
• GetDriverStatus
• GetDriverVersion
• Initialize

This method is available in both the component API and the Installer DLL included with the product; please refer to the Driver Installation topic for more information about the latter.

Note: This method cannot be called within events.

GetDriverVersion Method (CBRegistry Component)

This method retrieves the version of the component's system driver.

Syntax

• C#
• VB.NET

public long GetDriverVersion(string productGUID);

Public Function GetDriverVersion(ByVal ProductGUID As String) As Long

Remarks

This method retrieves the version of the component's system driver. The value is returned as a 64-bit integer composed of four 16-bit words that each correspond to a piece of the overall module version. For example, a version of 2.32.6.28 would cause the value 0x000200200006001C to be returned.

If the component's system driver is not installed, this method returns 0.

ProductGUID is used to distinguish among driver installations performed by different applications. Such information is necessary to guard against unexpected situations, such as the driver being uninstalled by one application despite other applications still needing it.

Therefore, to ensure proper operation, it is critical that each individual application have its own unique ProductGUID value, and that applications (and their installation scripts) use that value when calling any of the following methods:

• Install
• Uninstall
• GetDriverStatus
• GetDriverVersion
• Initialize

This method is available in both the component API and the Installer DLL included with the product; please refer to the Driver Installation topic for more information about the latter.

Note: This method cannot be called within events.

GetOriginatorProcessId Method (CBRegistry Component)

This method retrieves the process Id (PID) that initiated the operation.

Syntax

• C#
• VB.NET

public int GetOriginatorProcessId();

Public Function GetOriginatorProcessId() As Integer

Remarks

This method can be called within events fired for registry operations to retrieve the process Id (PID) that initiated the operation. If the query fails, this method returns 0.

Note: PIDs are not unique and may be reused by different processes over time (although in practice, this is uncommon).

Note: This method can be called only within events.

GetOriginatorProcessName Method (CBRegistry Component)

This method retrieves the name of the process that initiated the operation.

Syntax

• C#
• VB.NET

public string GetOriginatorProcessName();

Public Function GetOriginatorProcessName() As String

Remarks

This method can be called within events fired for registry operations to retrieve the name of the process that initiated the operation. If the query fails, this method returns empty string.

Note: This method can be called only within events.

GetOriginatorThreadId Method (CBRegistry Component)

This method retrieves the thread Id that initiated the operation.

Syntax

• C#
• VB.NET

public int GetOriginatorThreadId();

Public Function GetOriginatorThreadId() As Integer

Remarks

This method can be called within events fired for registry operations to retrieve the thread Id that initiated the operation. If the query fails, this method returns 0.

Note: Thread Ids are not unique and may be reused by different threads over time.

Note: This method can be called only within events.

GetOriginatorToken Method (CBRegistry Component)

This method retrieves the security token associated with the process that initiated the operation.

Syntax

• C#
• VB.NET

public long GetOriginatorToken();

Public Function GetOriginatorToken() As Long

Remarks

This method can be called within events fired for registry operations to retrieve the security token associated with the process that initiated the operation. If the query fails, this method returns INVALID_HANDLE_VALUE.

The security token returned by this method can be passed to the Windows API's GetTokenInformation function to obtain more information about the process.

Note: When applications are finished using the returned security token, they must close it using the Windows API's CloseHandle function.

Note: This method can be called only within events.

Initialize Method (CBRegistry Component)

This method initializes the component.

Syntax

• C#
• VB.NET

public void Initialize(string productGUID);

Public Sub Initialize(ByVal ProductGUID As String)

Remarks

This method initializes the component and must be called each time the application starts before attempting to call any of the component's other methods with the exception of installation-related methods.

ProductGUID is used to distinguish among driver installations performed by different applications. Such information is necessary to guard against unexpected situations, such as the driver being uninstalled by one application despite other applications still needing it.

Therefore, to ensure proper operation, it is critical that each individual application have its own unique ProductGUID value, and that applications (and their installation scripts) use that value when calling any of the following methods:

• Install
• Uninstall
• GetDriverStatus
• GetDriverVersion
• Initialize

If the required driver was not installed using the Install method with the same value of ProductGUID, Initialize will return a ERROR_FILE_NOT_FOUND error (Win32 error code 2).

If the loaded kernel-mode driver is older than the user-mode API, Initialize will return a ERROR_INVALID_KERNEL_INFO_VERSION error (Win32 error code 340). In this situation, an update of the driver using the Install method is required before the component can be used.

Install Method (CBRegistry Component)

This method installs (or upgrades) the component's system driver.

Syntax

• C#
• VB.NET

public bool Install(string cabFileName, string productGUID, string pathToInstall, int flags);

Public Function Install(ByVal CabFileName As String, ByVal ProductGUID As String, ByVal PathToInstall As String, ByVal Flags As Integer) As Boolean

Remarks

This method is used to install or upgrade the component's system driver. If the system must be rebooted to complete the installation process, this method returns true; otherwise, it returns false.

Important: To upgrade the component's driver, use only the Install method. Previously installed versions of the driver should not be uninstalled first. Calling the Install method will upgrade the previously installed version.

Please refer to the Driver Installation topic for more information.

CabFileName must be the path of the .cab file containing the component's system driver.

Note: This .cab file must remain on the target system (or be available in some other way) after installation, because it is required to uninstall the driver from the system.

ProductGUID is used to distinguish among driver installations performed by different applications. Such information is necessary to guard against unexpected situations, such as the driver being uninstalled by one application despite other applications still needing it.

Therefore, to ensure proper operation, it is critical that each individual application have its own unique ProductGUID value, and that applications (and their installation scripts) use that value when calling any of the following methods:

• Install
• Uninstall
• GetDriverStatus
• GetDriverVersion
• Initialize

PathToInstall controls where the driver is installed. Pass empty string (highly recommended) to automatically install the driver to the appropriate Windows system directory.

Flags specifies various installation options and should contain zero or more of the following flags, ORed together:

This method is available in both the component API and the Installer DLL included with the product; please refer to the Driver Installation topic for more information about the latter.

This method requires administrative rights to execute successfully. If the user account of the process that calls this method doesn't have such rights, the call will fail with an ERROR_PRIVILEGE_NOT_HELD (0x0522) error.

Note: This method cannot be called within events.

RemoveFilteredProcessById Method (CBRegistry Component)

This method removes a process, by process Id (PID), from the list of filtered processes.

Syntax

• C#
• VB.NET

public void RemoveFilteredProcessById(int processId);

Public Sub RemoveFilteredProcessById(ByVal ProcessId As Integer)

Remarks

This method removes the process with the specified ProcessId (PID) from the list of processes whose requests should be filtered.

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The value passed for ProcessId must be one that was previously used to call AddFilteredProcessById; please refer to its documentation for more information.

Note: This method can be called only when Active is true.

RemoveFilteredProcessByName Method (CBRegistry Component)

This method removes a process, by name, from the list of filtered processes.

Syntax

• C#
• VB.NET

public void RemoveFilteredProcessByName(string processName);

Public Sub RemoveFilteredProcessByName(ByVal ProcessName As String)

Remarks

This method removes the process with the specified ProcessName from the list of processes whose requests should be filtered.

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The value passed for ProcessName must be one that was previously used to call AddFilteredProcessByName; please refer to its documentation for more information.

Note: This method can be called only when Active is true.

RemoveIgnoredProcessById Method (CBRegistry Component)

This method removes a process, by process Id (PID), from the list of ignored processes.

Syntax

• C#
• VB.NET

public void RemoveIgnoredProcessById(int processId);

Public Sub RemoveIgnoredProcessById(ByVal ProcessId As Integer)

Remarks

This method removes the process with the specified ProcessId (PID) from the list of processes whose requests should be ignored.

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The value passed for ProcessId must be one that was previously used to call AddIgnoredProcessById; please refer to its documentation for more information.

Note: This method can be called only when Active is true.

RemoveIgnoredProcessByName Method (CBRegistry Component)

This method removes a process, by name, from the list of ignored processes.

Syntax

• C#
• VB.NET

public void RemoveIgnoredProcessByName(string processName);

Public Sub RemoveIgnoredProcessByName(ByVal ProcessName As String)

Remarks

This method removes the process with the specified ProcessName from the list of processes whose requests should be ignored.

This method is provided for compatibility with CBFS Registry 2017. Use of the new AddFilterRule, DeleteFilterRule, and related methods is recommended instead.

The value passed for ProcessName must be one that was previously used to call AddIgnoredProcessByName; please refer to its documentation for more information.

Note: This method can be called only when Active is true.

ResetTimeout Method (CBRegistry Component)

This method resets the timeout duration for the current event handler.

Syntax

• C#
• VB.NET

public bool ResetTimeout(int timeout);

Public Function ResetTimeout(ByVal Timeout As Integer) As Boolean

Remarks

When event timeouts are being enforced, this method can be called within an event handler to inform the component that request processing is taking longer than expected.

If called successfully, this method returns true, and the current event handler's timeout timer is immediately reset to 0; when it reaches the number of milliseconds specified by Timeout, the driver will either "release" the underlying request and pass it onwards, or cancel it by reporting an error; whichever is most appropriate for the event in question. Please refer to the Timeouts topic for more information.

Passing 0 for Timeout disables the timeout timer for the current event handler, allowing it to take as long as it needs to complete.

Note: This method can be called only within events.

ShutdownSystem Method (CBRegistry Component)

Shuts down or reboots the operating system.

Syntax

• C#
• VB.NET

public bool ShutdownSystem(string shutdownPrompt, int timeout, bool forceCloseApps, bool reboot);

Public Function ShutdownSystem(ByVal ShutdownPrompt As String, ByVal Timeout As Integer, ByVal ForceCloseApps As Boolean, ByVal Reboot As Boolean) As Boolean

Remarks

This method shuts down or (if Reboot is true) reboots the operating system. If the appropriate privileges cannot be obtained, or if the InitiateSystemShutdown system call returns false, then this method will return false; otherwise, it returns true. This method can be used if the installation or uninstallation function requires the system to be rebooted in order to complete.

ShutdownPrompt, if non-empty, specifies a message that the OS should display to the user for Timeout seconds. If empty string is passed for ShutdownPrompt, no message is displayed and the Timeout parameter's value is ignored.

ForceCloseApps specifies whether the OS should forcefully close all applications. Please keep in mind that forceful closing of applications with unsaved data can lead to data loss.

Reboot specifies whether the OS should reboot (true) or just shut down (false).

This method is available in both the component API and the Installer DLL included with the product; please refer to the Driver Installation topic for more information about the latter.

Note: This method cannot be called within events.

StartFilter Method (CBRegistry Component)

This method starts filtering registry operations.

Syntax

• C#
• VB.NET

public void StartFilter(int timeout);

Public Sub StartFilter(ByVal Timeout As Integer)

Remarks

This method attaches the filter, causing the component's driver to start filtering registry operations according to the filter rules currently present. Rules can be added and removed both before and after this method is called, so long as the Initialize method is called before doing anything else.

The Timeout parameter specifies how many milliseconds the driver should wait for events to execute before releasing or cancelling the underlying OS requests; please refer to the Timeouts topic for more information. Valid values are 0, which disables event timeouts, and values greater than or equal to 3000. When event timeouts are in effect, event handlers can call ResetTimeout to reset the timer if they require additional time to complete.

This method can fail for a number of reasons, including (but not limited to) the following:

• If the component's system driver has not been properly installed, or is awaiting a system reboot (as indicated by the return value of Install), this method fails with an ERROR_FILE_NOT_FOUND (2) error code.
• If the Initialize method has not been called yet, this method fails with an ERROR_NOT_READY (21) error code.
• If the filter is already Active, this method fails with an ERROR_CONNECTION_ACTIVE (1230) error code.
• If an invalid value is passed for Timeout, this method fails with an ERROR_IMPLEMENTATION_LIMIT (1292) error code.

StopFilter Method (CBRegistry Component)

This method stops filtering registry operations.

Syntax

• C#
• VB.NET

public void StopFilter();

Public Sub StopFilter()

Remarks

This method detaches the filter, causing the component's driver to stop filtering registry operations. This method will block until all pending requests have completed and the filter has been detached.

SuspendDefaultRules Method (CBRegistry Component)

This method suspends all default rules until the application exits.

Syntax

• C#
• VB.NET

public bool SuspendDefaultRules(string productGUID);

Public Function SuspendDefaultRules(ByVal ProductGUID As String) As Boolean

Remarks

This method suspends (i.e., deactivates) all default rules associated with the application identified by ProductGUID until the application exits. If the rules are suspended successfully, this method returns true; otherwise, it returns false.

In most cases, the value passed for the ProductGUID parameter should be the same one that was used to call the Initialize method.

When the application exits, the component's system driver will reactivate the suspended rules and start enforcing them once again.

ToggleProcessProtection Method (CBRegistry Component)

This method enables or disables termination protection for the application.

Syntax

• C#
• VB.NET

public bool ToggleProcessProtection(bool enabled);

Public Function ToggleProcessProtection(ByVal Enabled As Boolean) As Boolean

Remarks

This method controls the termination protection mechanism, which applications can enable to prevent their process and threads from being terminated. If successful, this method returns true; otherwise, it returns false.

The Enabled parameter specifies whether termination protection should be enabled (true) or disabled (false); it is disabled by default. If termination protection is enabled, an application must disable it before attempting to exit.

Note: When developing a GUI-based application, please keep in mind that the termination protection mechanism does not intercept Windows' notifications like WM_CLOSE or WM_QUIT; applications must intercept and handle such messages themselves if they wish to protect their UI. Please refer to Microsoft's Window Notifications articles for more information.

Uninstall Method (CBRegistry Component)

This method uninstalls the component's system driver.

Syntax

• C#
• VB.NET

public bool Uninstall(string cabFileName, string productGUID, string installedPath, int flags);

Public Function Uninstall(ByVal CabFileName As String, ByVal ProductGUID As String, ByVal InstalledPath As String, ByVal Flags As Integer) As Boolean

Remarks

This method is used to uninstall the component's system driver. If the system must be rebooted to complete the uninstallation process, this method returns true; otherwise, it returns false.

Important: To upgrade the component's driver, use only the Install method. Previously installed versions of the driver should not be uninstalled first. Calling the Install method will upgrade the previously installed version.

Please refer to the Driver Installation topic for more information.

The same values must be passed for the CabFileName, ProductGUID, and InstalledPath parameters as were passed when Install was called; please refer to its documentation for more information.

Flags specifies which versions of the component's system driver should be uninstalled and which should be set by ORing together one or more of the following values:

This method is available in both the component API and the Installer DLL included with the product; please refer to the Driver Installation topic for more information about the latter.

This method requires administrative rights to execute successfully. If the user account of the process that calls this method doesn't have such rights, the call will fail with an ERROR_PRIVILEGE_NOT_HELD (0x0522) error.

Note: This method cannot be called within events.

AfterCloseKey Event (CBRegistry Component)

This event fires after a registry key is closed.

Syntax

• C#
• VB.NET

public event OnAfterCloseKeyHandler OnAfterCloseKey;

public delegate void OnAfterCloseKeyHandler(object sender, CbregistryAfterCloseKeyEventArgs e);

public class CbregistryAfterCloseKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int ResultCode { get; set; }
}

Public Event OnAfterCloseKey As OnAfterCloseKeyHandler

Public Delegate Sub OnAfterCloseKeyHandler(sender As Object, e As CbregistryAfterCloseKeyEventArgs)

Public Class CbregistryAfterCloseKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key is closed.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_CLOSE_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterCreateKey Event (CBRegistry Component)

This event fires after a registry key is created.

Syntax

• C#
• VB.NET

public event OnAfterCreateKeyHandler OnAfterCreateKey;

public delegate void OnAfterCreateKeyHandler(object sender, CbregistryAfterCreateKeyEventArgs e);

public class CbregistryAfterCreateKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public long KeyHandle { get; set; }
  public IntPtr KeyHandleContext { get; set; }
  public int GrantedAccess { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterCreateKey As OnAfterCreateKeyHandler

Public Delegate Sub OnAfterCreateKeyHandler(sender As Object, e As CbregistryAfterCreateKeyEventArgs)

Public Class CbregistryAfterCreateKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property KeyHandle As Long
  Public Property KeyHandleContext As IntPtr
  Public Property GrantedAccess As Integer
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key is created.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_CREATE_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The KeyHandle parameter specifies a handle to a registry key that should be opened instead of the one this event fired for. Applications can set this parameter to redirect access to the registry key associated with the specified handle.

The KeyHandleContext parameter is a placeholder for application-defined data associated with the application-provided registry key handle. Please refer to the Contexts topic for more information.

The GrantedAccess parameter specifies the granted access rights for an application-provided registry key handle. Applications that set KeyHandle must also set this parameter. Please refer to Microsoft's Registry Key Security and Access Rights article for more information about possible values.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterDeleteKey Event (CBRegistry Component)

This event fires after a registry key is deleted.

Syntax

• C#
• VB.NET

public event OnAfterDeleteKeyHandler OnAfterDeleteKey;

public delegate void OnAfterDeleteKeyHandler(object sender, CbregistryAfterDeleteKeyEventArgs e);

public class CbregistryAfterDeleteKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterDeleteKey As OnAfterDeleteKeyHandler

Public Delegate Sub OnAfterDeleteKeyHandler(sender As Object, e As CbregistryAfterDeleteKeyEventArgs)

Public Class CbregistryAfterDeleteKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key is deleted.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_DELETE_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterDeleteValue Event (CBRegistry Component)

This event fires after a registry value is deleted.

Syntax

• C#
• VB.NET

public event OnAfterDeleteValueHandler OnAfterDeleteValue;

public delegate void OnAfterDeleteValueHandler(object sender, CbregistryAfterDeleteValueEventArgs e);

public class CbregistryAfterDeleteValueEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterDeleteValue As OnAfterDeleteValueHandler

Public Delegate Sub OnAfterDeleteValueHandler(sender As Object, e As CbregistryAfterDeleteValueEventArgs)

Public Class CbregistryAfterDeleteValueEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry value is deleted.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_DELETE_VALUE flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires. A similar strategy can be applied if the application needs the registry value's name, which can be stored in KeyContext during the corresponding Before* event.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterEnumerateKey Event (CBRegistry Component)

This event fires after a subkey's information is retrieved during key enumeration.

Syntax

• C#
• VB.NET

public event OnAfterEnumerateKeyHandler OnAfterEnumerateKey;

public delegate void OnAfterEnumerateKeyHandler(object sender, CbregistryAfterEnumerateKeyEventArgs e);

public class CbregistryAfterEnumerateKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public int Index { get; }
  public int ValidFields { get; }
  public DateTime LastWriteTime { get; set; }
  public string Name { get; set; }
  public string ClassName { get; set; }
  public int SubKeys { get; set; }
  public int MaxNameLength { get; set; }
  public int MaxClassNameLength { get; set; }
  public int Values { get; set; }
  public int MaxValueNameLength { get; set; }
  public int MaxValueDataSize { get; set; }
  public bool VirtualizationCandidate { get; set; }
  public bool VirtualizationEnabled { get; set; }
  public bool VirtualTarget { get; set; }
  public bool VirtualStore { get; set; }
  public bool VirtualSource { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterEnumerateKey As OnAfterEnumerateKeyHandler

Public Delegate Sub OnAfterEnumerateKeyHandler(sender As Object, e As CbregistryAfterEnumerateKeyEventArgs)

Public Class CbregistryAfterEnumerateKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public ReadOnly Property Index As Integer
  Public ReadOnly Property ValidFields As Integer
  Public Property LastWriteTime As DateTime
  Public Property Name As String
  Public Property ClassName As String
  Public Property SubKeys As Integer
  Public Property MaxNameLength As Integer
  Public Property MaxClassNameLength As Integer
  Public Property Values As Integer
  Public Property MaxValueNameLength As Integer
  Public Property MaxValueDataSize As Integer
  Public Property VirtualizationCandidate As Boolean
  Public Property VirtualizationEnabled As Boolean
  Public Property VirtualTarget As Boolean
  Public Property VirtualStore As Boolean
  Public Property VirtualSource As Boolean
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a subkey's information is retrieved during enumeration of a registry key's subkeys.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_ENUM_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Index parameter reflects the zero-based index of the key (within the registry key being enumerated).

The ValidFields parameter indicates which pieces of information about the key were retrieved. The value of this parameter is a combination of one or more of the following:

The LastWriteTime parameter specifies when the key was last changed, specified in UTC.

The Name parameter specifies the key's name. The maximum length of a registry key name is 255 characters.

The ClassName parameter specifies the key's class name. The maximum length of a registry key class name is 255 characters.

The SubKeys parameter specifies the number of subkeys that the key has.

The MaxNameLength parameter specifies the length, in bytes, of the key's longest subkey name.

The MaxClassNameLength parameter specifies the length, in bytes, of the key's longest subkey class name.

The Values parameter specifies the number of values the key has.

The MaxValueNameLength parameter specifies the length, in bytes, of the key's longest value name.

The MaxValueDataSize parameter specifies the length, in bytes, of the subkey's largest value data size.

The VirtualizationCandidate parameter specifies whether the key is part of the virtualization namespace scope.

The VirtualizationEnabled parameter specifies whether virtualization is enabled on the key. This parameter can only be true if VirtualizationCandidate is true.

The VirtualTarget parameter specifies whether the key is a virtual key. This parameter can only be true if both VirtualizationCandidate and VirtualizationEnabled are both false. Its value is only valid on virtual store key handles.

The VirtualStore parameter specifies whether the key is part of the virtual store path.

The VirtualSource parameter specifies whether the key has ever been virtualized. This parameter can only be true if VirtualizationCandidate is true.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterEnumerateValue Event (CBRegistry Component)

This event fires after a registry value's information is retrieved during key value enumeration.

Syntax

• C#
• VB.NET

public event OnAfterEnumerateValueHandler OnAfterEnumerateValue;

public delegate void OnAfterEnumerateValueHandler(object sender, CbregistryAfterEnumerateValueEventArgs e);

public class CbregistryAfterEnumerateValueEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public int Index { get; }
  public int ValidFields { get; }
  public string ValueName { get; set; }
  public int ValueType { get; set; }
  public long IntegerValue { get; set; }
  public string StringValue { get; set; }
  public IntPtr BinaryValue { get; }
  public int MaxBinaryValueSize { get; }
  public int BinaryValueSize { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterEnumerateValue As OnAfterEnumerateValueHandler

Public Delegate Sub OnAfterEnumerateValueHandler(sender As Object, e As CbregistryAfterEnumerateValueEventArgs)

Public Class CbregistryAfterEnumerateValueEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public ReadOnly Property Index As Integer
  Public ReadOnly Property ValidFields As Integer
  Public Property ValueName As String
  Public Property ValueType As Integer
  Public Property IntegerValue As Long
  Public Property StringValue As String
  Public ReadOnly Property BinaryValue As IntPtr
  Public ReadOnly Property MaxBinaryValueSize As Integer
  Public Property BinaryValueSize As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry value's information is retrieved during enumeration of a registry key's values.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_ENUM_VALUE flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Index parameter reflects the zero-based index of the registry value (within the registry key being enumerated).

The ValidFields parameter indicates which pieces of information about the registry value were retrieved. The value of this parameter is a combination of one or more of the following:

The ValueName parameter specifies the registry value's name.

The ValueType parameter specifies the registry value's type and determines which of the other parameters holds the registry value's data (please refer to their descriptions for more information). Possible values are as follows:

The IntegerValue parameter specifies the registry value's data if ValueType is REG_VALUETYPE_DWORD or REG_VALUETYPE_QWORD.

The StringValue parameter specifies the registry value's data if ValueType is REG_VALUETYPE_SZ, REG_VALUETYPE_EXPAND_SZ, or REG_VALUETYPE_MULTI_SZ.

For REG_VALUETYPE_MULTI_SZ, data are formatted as multiple individual ETB-terminated strings concatenated together into a single null-terminated string (where ETB is the End-of-Transmission-Block character; 23/0x17). For example, the strings This is, a multistring, and value. would be encoded as This is[ETB]a multistring[ETB]value.[ETB][NUL].

Note: As Microsoft's Registry Value Types article describes, the native multistring data format uses null terminators for the individual strings (e.g., This is[NUL]a multistring[NUL]value.[NUL][NUL]); CBRegistry converts the individual null terminators to/from ETB characters internally for applications' convenience.

The BinaryValue parameter points to a memory buffer that holds the registry value's data if ValueType is REG_VALUETYPE_BINARY. The MaxBinaryValueSize and BinaryValueSize parameter specify the capacity of the BinaryValue buffer and the length of the data it contains, respectively, in bytes.

Always check MaxBinaryValueSize before copying any data into the BinaryValue buffer. If the buffer is large enough to hold all of the data, copy the data into it, and then update BinaryValueSize accordingly. If the buffer is not large enough, do not copy any data into it; instead, set BinaryValueSize to the required buffer size (i.e., the size of the data) and return the ERROR_MORE_DATA (234) error code via ResultCode.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterGetKeySecurity Event (CBRegistry Component)

This event fires after a registry key's security attributes are changed.

Syntax

• C#
• VB.NET

public event OnAfterGetKeySecurityHandler OnAfterGetKeySecurity;

public delegate void OnAfterGetKeySecurityHandler(object sender, CbregistryAfterGetKeySecurityEventArgs e);

public class CbregistryAfterGetKeySecurityEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public int SecurityInformation { get; }
  public IntPtr SecurityDescriptor { get; }
  public int Length { get; }
  public int LengthNeeded { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterGetKeySecurity As OnAfterGetKeySecurityHandler

Public Delegate Sub OnAfterGetKeySecurityHandler(sender As Object, e As CbregistryAfterGetKeySecurityEventArgs)

Public Class CbregistryAfterGetKeySecurityEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public ReadOnly Property SecurityInformation As Integer
  Public ReadOnly Property SecurityDescriptor As IntPtr
  Public ReadOnly Property Length As Integer
  Public Property LengthNeeded As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after security attributes are changed for the registry key specified by KeyContext.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_GET_KEY_SECURITY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The SecurityInformation parameter indicates which pieces of security information were requested. Please refer to Microsoft's SECURITY_INFORMATION data type documentation for more information about possible values.

The SecurityDescriptor parameter points to a memory buffer that, if the request was successful, contains the requested security information. The Length parameter reflects the length of the data, in bytes. Please see the Buffer Parameters topic for more information on how to work with memory buffer event parameters.

The data are formatted as a SECURITY_DESCRIPTOR structure in self-relative format; please refer to the Microsoft's documentation for more information.

Applications that wish to modify the security information may do so by replacing the data in the SecurityDescriptor buffer. If the current Length is too small to accommodate the new security information, set LengthNeeded to the number of bytes necessary to hold the data, and return the ERROR_INSUFFICIENT_BUFFER error code via ResultCode.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterOpenKey Event (CBRegistry Component)

This event fires after a registry key is opened.

Syntax

• C#
• VB.NET

public event OnAfterOpenKeyHandler OnAfterOpenKey;

public delegate void OnAfterOpenKeyHandler(object sender, CbregistryAfterOpenKeyEventArgs e);

public class CbregistryAfterOpenKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public long KeyHandle { get; set; }
  public IntPtr KeyHandleContext { get; set; }
  public int GrantedAccess { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterOpenKey As OnAfterOpenKeyHandler

Public Delegate Sub OnAfterOpenKeyHandler(sender As Object, e As CbregistryAfterOpenKeyEventArgs)

Public Class CbregistryAfterOpenKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property KeyHandle As Long
  Public Property KeyHandleContext As IntPtr
  Public Property GrantedAccess As Integer
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key is opened.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_OPEN_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The KeyHandle parameter specifies a handle to a registry key that should be opened instead of the one this event fired for. Applications can set this parameter to redirect access to the registry key associated with the specified handle.

The KeyHandleContext parameter is a placeholder for application-defined data associated with the application-provided registry key handle. Please refer to the Contexts topic for more information.

The GrantedAccess parameter specifies the granted access rights for an application-provided registry key handle. Applications that set KeyHandle must also set this parameter. Please refer to Microsoft's Registry Key Security and Access Rights article for more information about possible values.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterQueryKey Event (CBRegistry Component)

This event fires after a registry key's information is retrieved.

Syntax

• C#
• VB.NET

public event OnAfterQueryKeyHandler OnAfterQueryKey;

public delegate void OnAfterQueryKeyHandler(object sender, CbregistryAfterQueryKeyEventArgs e);

public class CbregistryAfterQueryKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public int ValidFields { get; }
  public DateTime LastWriteTime { get; set; }
  public string Name { get; set; }
  public string ClassName { get; set; }
  public int SubKeys { get; set; }
  public int MaxNameLength { get; set; }
  public int MaxClassNameLength { get; set; }
  public int Values { get; set; }
  public int MaxValueNameLength { get; set; }
  public int MaxValueDataSize { get; set; }
  public bool VirtualizationCandidate { get; set; }
  public bool VirtualizationEnabled { get; set; }
  public bool VirtualTarget { get; set; }
  public bool VirtualStore { get; set; }
  public bool VirtualSource { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterQueryKey As OnAfterQueryKeyHandler

Public Delegate Sub OnAfterQueryKeyHandler(sender As Object, e As CbregistryAfterQueryKeyEventArgs)

Public Class CbregistryAfterQueryKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public ReadOnly Property ValidFields As Integer
  Public Property LastWriteTime As DateTime
  Public Property Name As String
  Public Property ClassName As String
  Public Property SubKeys As Integer
  Public Property MaxNameLength As Integer
  Public Property MaxClassNameLength As Integer
  Public Property Values As Integer
  Public Property MaxValueNameLength As Integer
  Public Property MaxValueDataSize As Integer
  Public Property VirtualizationCandidate As Boolean
  Public Property VirtualizationEnabled As Boolean
  Public Property VirtualTarget As Boolean
  Public Property VirtualStore As Boolean
  Public Property VirtualSource As Boolean
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key's information is retrieved.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_QUERY_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The ValidFields parameter indicates which pieces of information about the key were retrieved. The value of this parameter is a combination of one or more of the following:

The LastWriteTime parameter specifies when the key was last changed, specified in UTC.

The Name parameter specifies the key's name. The maximum length of a registry key name is 255 characters.

The ClassName parameter specifies the key's class name. The maximum length of a registry key class name is 255 characters.

The SubKeys parameter specifies the number of subkeys that the key has.

The MaxNameLength parameter specifies the length, in bytes, of the key's longest subkey name.

The MaxClassNameLength parameter specifies the length, in bytes, of the key's longest subkey class name.

The Values parameter specifies the number of values the key has.

The MaxValueNameLength parameter specifies the length, in bytes, of the key's longest value name.

The MaxValueDataSize parameter specifies the length, in bytes, of the subkey's largest value data size.

The VirtualizationCandidate parameter specifies whether the key is part of the virtualization namespace scope.

The VirtualizationEnabled parameter specifies whether virtualization is enabled on the key. This parameter can only be true if VirtualizationCandidate is true.

The VirtualTarget parameter specifies whether the key is a virtual key. This parameter can only be true if both VirtualizationCandidate and VirtualizationEnabled are both false. Its value is only valid on virtual store key handles.

The VirtualStore parameter specifies whether the key is part of the virtual store path.

The VirtualSource parameter specifies whether the key has ever been virtualized. This parameter can only be true if VirtualizationCandidate is true.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterQueryValue Event (CBRegistry Component)

This event fires after a registry value's information is retrieved.

Syntax

• C#
• VB.NET

public event OnAfterQueryValueHandler OnAfterQueryValue;

public delegate void OnAfterQueryValueHandler(object sender, CbregistryAfterQueryValueEventArgs e);

public class CbregistryAfterQueryValueEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public string ValueName { get; }
  public int ValidFields { get; }
  public int ValueType { get; set; }
  public long IntegerValue { get; set; }
  public string StringValue { get; set; }
  public IntPtr BinaryValue { get; }
  public int MaxBinaryValueSize { get; }
  public int BinaryValueSize { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterQueryValue As OnAfterQueryValueHandler

Public Delegate Sub OnAfterQueryValueHandler(sender As Object, e As CbregistryAfterQueryValueEventArgs)

Public Class CbregistryAfterQueryValueEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public ReadOnly Property ValueName As String
  Public ReadOnly Property ValidFields As Integer
  Public Property ValueType As Integer
  Public Property IntegerValue As Long
  Public Property StringValue As String
  Public ReadOnly Property BinaryValue As IntPtr
  Public ReadOnly Property MaxBinaryValueSize As Integer
  Public Property BinaryValueSize As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry value's information is retrieved.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_QUERY_VALUE flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The ValueName parameter reflects the name of the registry value.

The ValidFields parameter indicates which pieces of information about the registry value were retrieved. The value of this parameter is a combination of one or more of the following:

The ValueType parameter specifies the registry value's type and determines which of the other parameters holds the registry value's data (please refer to their descriptions for more information). Possible values are as follows:

The IntegerValue parameter specifies the registry value's data if ValueType is REG_VALUETYPE_DWORD or REG_VALUETYPE_QWORD.

The StringValue parameter specifies the registry value's data if ValueType is REG_VALUETYPE_SZ, REG_VALUETYPE_EXPAND_SZ, or REG_VALUETYPE_MULTI_SZ.

For REG_VALUETYPE_MULTI_SZ, data are formatted as multiple individual ETB-terminated strings concatenated together into a single null-terminated string (where ETB is the End-of-Transmission-Block character; 23/0x17). For example, the strings This is, a multistring, and value. would be encoded as This is[ETB]a multistring[ETB]value.[ETB][NUL].

Note: As Microsoft's Registry Value Types article describes, the native multistring data format uses null terminators for the individual strings (e.g., This is[NUL]a multistring[NUL]value.[NUL][NUL]); CBRegistry converts the individual null terminators to/from ETB characters internally for applications' convenience.

The BinaryValue parameter points to a memory buffer that holds the registry value's data if ValueType is REG_VALUETYPE_BINARY. The MaxBinaryValueSize and BinaryValueSize parameter specify the capacity of the BinaryValue buffer and the length of the data it contains, respectively, in bytes.

Always check MaxBinaryValueSize before copying any data into the BinaryValue buffer. If the buffer is large enough to hold all of the data, copy the data into it, and then update BinaryValueSize accordingly. If the buffer is not large enough, do not copy any data into it; instead, set BinaryValueSize to the required buffer size (i.e., the size of the data) and return the ERROR_MORE_DATA (234) error code via ResultCode.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterRenameKey Event (CBRegistry Component)

This event fires after a registry key is renamed.

Syntax

• C#
• VB.NET

public event OnAfterRenameKeyHandler OnAfterRenameKey;

public delegate void OnAfterRenameKeyHandler(object sender, CbregistryAfterRenameKeyEventArgs e);

public class CbregistryAfterRenameKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterRenameKey As OnAfterRenameKeyHandler

Public Delegate Sub OnAfterRenameKeyHandler(sender As Object, e As CbregistryAfterRenameKeyEventArgs)

Public Class CbregistryAfterRenameKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key is renamed.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_RENAME_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's old or new names for performance reasons; applications that need them should store them in KeyContext during the BeforeCreateKey/BeforeOpenKey and BeforeRenameKey events so that they can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterSetKey Event (CBRegistry Component)

This event fires after a registry key's information is updated.

Syntax

• C#
• VB.NET

public event OnAfterSetKeyHandler OnAfterSetKey;

public delegate void OnAfterSetKeyHandler(object sender, CbregistryAfterSetKeyEventArgs e);

public class CbregistryAfterSetKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterSetKey As OnAfterSetKeyHandler

Public Delegate Sub OnAfterSetKeyHandler(sender As Object, e As CbregistryAfterSetKeyEventArgs)

Public Class CbregistryAfterSetKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry key's information is updated.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_SET_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterSetKeySecurity Event (CBRegistry Component)

This event fires after a registry key's security attributes are changed.

Syntax

• C#
• VB.NET

public event OnAfterSetKeySecurityHandler OnAfterSetKeySecurity;

public delegate void OnAfterSetKeySecurityHandler(object sender, CbregistryAfterSetKeySecurityEventArgs e);

public class CbregistryAfterSetKeySecurityEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public int SecurityInformation { get; }
  public IntPtr SecurityDescriptor { get; }
  public int Length { get; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterSetKeySecurity As OnAfterSetKeySecurityHandler

Public Delegate Sub OnAfterSetKeySecurityHandler(sender As Object, e As CbregistryAfterSetKeySecurityEventArgs)

Public Class CbregistryAfterSetKeySecurityEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public ReadOnly Property SecurityInformation As Integer
  Public ReadOnly Property SecurityDescriptor As IntPtr
  Public ReadOnly Property Length As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after security attributes are changed for the registry key specified by KeyContext.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_SET_KEY_SECURITY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The SecurityInformation parameter reflects which pieces of security information, of those present in SecurityDescriptor, were to be set. Please refer to Microsoft's SECURITY_INFORMATION data type documentation for more information about possible values.

The SecurityDescriptor parameter points to a memory buffer that contains the new security information. The Length parameter reflects the length of this data, in bytes. Please see the Buffer Parameters topic for more information on how to work with memory buffer event parameters.

The data are formatted as a SECURITY_DESCRIPTOR structure in self-relative format; please refer to the Microsoft's documentation for more information.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

AfterSetValue Event (CBRegistry Component)

This event fires after a registry value is set or updated.

Syntax

• C#
• VB.NET

public event OnAfterSetValueHandler OnAfterSetValue;

public delegate void OnAfterSetValueHandler(object sender, CbregistryAfterSetValueEventArgs e);

public class CbregistryAfterSetValueEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Status { get; set; }
  public bool Processed { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnAfterSetValue As OnAfterSetValueHandler

Public Delegate Sub OnAfterSetValueHandler(sender As Object, e As CbregistryAfterSetValueEventArgs)

Public Class CbregistryAfterSetValueEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Status As Integer
  Public Property Processed As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires after a registry value is set or updated.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_AFTER_SET_VALUE flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires. A similar strategy can be applied if the application needs the registry value's name, which can be stored in KeyContext during the corresponding Before* event.

The Status parameter contains a Win32 error code that indicates the outcome of the operation; 0 indicates success. This value is returned to the request originator if no other status is returned from this event. Applications may change this parameter's value if they want a different Win32 error code to be returned.

The Processed parameter indicates whether the response values have been modified. Applications must set this parameter to true if they have altered any of the parameters related to the response values.

Note: This parameter's value is ignored if an error is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeCloseKey Event (CBRegistry Component)

This event fires before a registry key is closed.

Syntax

• C#
• VB.NET

public event OnBeforeCloseKeyHandler OnBeforeCloseKey;

public delegate void OnBeforeCloseKeyHandler(object sender, CbregistryBeforeCloseKeyEventArgs e);

public class CbregistryBeforeCloseKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeCloseKey As OnBeforeCloseKeyHandler

Public Delegate Sub OnBeforeCloseKeyHandler(sender As Object, e As CbregistryBeforeCloseKeyEventArgs)

Public Class CbregistryBeforeCloseKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry key is closed.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_CLOSE_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeCreateKey Event (CBRegistry Component)

This event fires before a registry key is created.

Syntax

• C#
• VB.NET

public event OnBeforeCreateKeyHandler OnBeforeCreateKey;

public delegate void OnBeforeCreateKeyHandler(object sender, CbregistryBeforeCreateKeyEventArgs e);

public class CbregistryBeforeCreateKeyEventArgs : EventArgs {
  public string FullName { get; }
  public int DesiredAccess { get; }
  public long KeyHandle { get; set; }
  public IntPtr KeyHandleContext { get; set; }
  public long GrantedAccess { get; set; }
  public IntPtr KeyContext { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeCreateKey As OnBeforeCreateKeyHandler

Public Delegate Sub OnBeforeCreateKeyHandler(sender As Object, e As CbregistryBeforeCreateKeyEventArgs)

Public Class CbregistryBeforeCreateKeyEventArgs Inherits EventArgs
  Public ReadOnly Property FullName As String
  Public ReadOnly Property DesiredAccess As Integer
  Public Property KeyHandle As Long
  Public Property KeyHandleContext As IntPtr
  Public Property GrantedAccess As Long
  Public Property KeyContext As IntPtr
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry key is created.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_CREATE_KEY flag.

The FullName parameter reflects the "full" name of the registry key being created, specified, by default, in system format (e.g., HKEY_LOCAL_MACHINE\System\... will be \Registry\Machine\System\...). If the ResolveNtNameToWin32Name configuration setting is enabled, the name will be converted to the more common Win32 format. Applications that intend to use the registry key's name during later events should store it in KeyContext during this event. Please refer to the Contexts topic for more information.

The DesiredAccess parameter reflects the access rights specified by the requestor. Please refer to Microsoft's Registry Key Security and Access Rights article for more information about possible values.

The KeyHandle parameter specifies a handle to a registry key that should be opened instead of the one this event fired for. Applications can set this parameter to redirect access to the registry key associated with the specified handle.

The KeyHandleContext parameter is a placeholder for application-defined data associated with the application-provided registry key handle. Please refer to the Contexts topic for more information.

The GrantedAccess parameter specifies the granted access rights for an application-provided registry key handle. Applications that set KeyHandle must also set this parameter. Please refer to Microsoft's Registry Key Security and Access Rights article for more information about possible values.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeDeleteKey Event (CBRegistry Component)

This event fires before a registry key is deleted.

Syntax

• C#
• VB.NET

public event OnBeforeDeleteKeyHandler OnBeforeDeleteKey;

public delegate void OnBeforeDeleteKeyHandler(object sender, CbregistryBeforeDeleteKeyEventArgs e);

public class CbregistryBeforeDeleteKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public bool Processed { get; set; }
  public bool FireAfterEvent { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeDeleteKey As OnBeforeDeleteKeyHandler

Public Delegate Sub OnBeforeDeleteKeyHandler(sender As Object, e As CbregistryBeforeDeleteKeyEventArgs)

Public Class CbregistryBeforeDeleteKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public Property Processed As Boolean
  Public Property FireAfterEvent As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry key is deleted.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_DELETE_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Processed parameter indicates whether the underlying request has been handled successfully. Applications should set this parameter to true if they have handled the request themselves (this will prevent the corresponding After* event from being called).

Note: This parameter's value is ignored if an error is returned via ResultCode.

The FireAfterEvent parameter specifies whether the corresponding After* event should be fired; it is true by default.

Note: Regardless of how this parameter is set, the corresponding After* event will not fire if Processed is true, or if an error code is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeDeleteValue Event (CBRegistry Component)

This event fires before a registry value is deleted.

Syntax

• C#
• VB.NET

public event OnBeforeDeleteValueHandler OnBeforeDeleteValue;

public delegate void OnBeforeDeleteValueHandler(object sender, CbregistryBeforeDeleteValueEventArgs e);

public class CbregistryBeforeDeleteValueEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public string ValueName { get; }
  public bool Processed { get; set; }
  public bool FireAfterEvent { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeDeleteValue As OnBeforeDeleteValueHandler

Public Delegate Sub OnBeforeDeleteValueHandler(sender As Object, e As CbregistryBeforeDeleteValueEventArgs)

Public Class CbregistryBeforeDeleteValueEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public ReadOnly Property ValueName As String
  Public Property Processed As Boolean
  Public Property FireAfterEvent As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry value is deleted.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_DELETE_VALUE flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The ValueName parameter reflects the name of the registry value. Applications that intend to use the registry value's name during later events should store it in KeyContext during this event. Please refer to the Contexts topic for more information.

The Processed parameter indicates whether the underlying request has been handled successfully. Applications should set this parameter to true if they have handled the request themselves (this will prevent the corresponding After* event from being called).

Note: This parameter's value is ignored if an error is returned via ResultCode.

The FireAfterEvent parameter specifies whether the corresponding After* event should be fired; it is true by default.

Note: Regardless of how this parameter is set, the corresponding After* event will not fire if Processed is true, or if an error code is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeEnumerateKey Event (CBRegistry Component)

This event fires before a subkey's information is retrieved during key enumeration.

Syntax

• C#
• VB.NET

public event OnBeforeEnumerateKeyHandler OnBeforeEnumerateKey;

public delegate void OnBeforeEnumerateKeyHandler(object sender, CbregistryBeforeEnumerateKeyEventArgs e);

public class CbregistryBeforeEnumerateKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Index { get; }
  public int RequestedFields { get; }
  public DateTime LastWriteTime { get; set; }
  public string Name { get; set; }
  public string ClassName { get; set; }
  public int SubKeys { get; set; }
  public int MaxNameLength { get; set; }
  public int MaxClassNameLength { get; set; }
  public int Values { get; set; }
  public int MaxValueNameLength { get; set; }
  public int MaxValueDataSize { get; set; }
  public bool VirtualizationCandidate { get; set; }
  public bool VirtualizationEnabled { get; set; }
  public bool VirtualTarget { get; set; }
  public bool VirtualStore { get; set; }
  public bool VirtualSource { get; set; }
  public bool Processed { get; set; }
  public bool FireAfterEvent { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeEnumerateKey As OnBeforeEnumerateKeyHandler

Public Delegate Sub OnBeforeEnumerateKeyHandler(sender As Object, e As CbregistryBeforeEnumerateKeyEventArgs)

Public Class CbregistryBeforeEnumerateKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public ReadOnly Property Index As Integer
  Public ReadOnly Property RequestedFields As Integer
  Public Property LastWriteTime As DateTime
  Public Property Name As String
  Public Property ClassName As String
  Public Property SubKeys As Integer
  Public Property MaxNameLength As Integer
  Public Property MaxClassNameLength As Integer
  Public Property Values As Integer
  Public Property MaxValueNameLength As Integer
  Public Property MaxValueDataSize As Integer
  Public Property VirtualizationCandidate As Boolean
  Public Property VirtualizationEnabled As Boolean
  Public Property VirtualTarget As Boolean
  Public Property VirtualStore As Boolean
  Public Property VirtualSource As Boolean
  Public Property Processed As Boolean
  Public Property FireAfterEvent As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a subkey's information is retrieved during enumeration of a registry key's subkeys.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_ENUM_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Index parameter reflects the zero-based index of the key (within the registry key being enumerated).

The RequestedFields parameter indicates which pieces of information about the key were requested. The value of this parameter is a combination of one or more of the following:

The LastWriteTime parameter specifies when the key was last changed, specified in UTC.

The Name parameter specifies the key's name. The maximum length of a registry key name is 255 characters.

The ClassName parameter specifies the key's class name. The maximum length of a registry key class name is 255 characters.

The SubKeys parameter specifies the number of subkeys that the key has.

The MaxNameLength parameter specifies the length, in bytes, of the key's longest subkey name.

The MaxClassNameLength parameter specifies the length, in bytes, of the key's longest subkey class name.

The Values parameter specifies the number of values the key has.

The MaxValueNameLength parameter specifies the length, in bytes, of the key's longest value name.

The MaxValueDataSize parameter specifies the length, in bytes, of the subkey's largest value data size.

The VirtualizationCandidate parameter specifies whether the key is part of the virtualization namespace scope.

The VirtualizationEnabled parameter specifies whether virtualization is enabled on the key. This parameter can only be true if VirtualizationCandidate is true.

The VirtualTarget parameter specifies whether the key is a virtual key. This parameter can only be true if both VirtualizationCandidate and VirtualizationEnabled are both false. Its value is only valid on virtual store key handles.

The VirtualStore parameter specifies whether the key is part of the virtual store path.

The VirtualSource parameter specifies whether the key has ever been virtualized. This parameter can only be true if VirtualizationCandidate is true.

The Processed parameter indicates whether the underlying request has been handled successfully. Applications should set this parameter to true if they have handled the request themselves (this will prevent the corresponding After* event from being called).

Note: This parameter's value is ignored if an error is returned via ResultCode.

The FireAfterEvent parameter specifies whether the corresponding After* event should be fired; it is true by default.

Note: Regardless of how this parameter is set, the corresponding After* event will not fire if Processed is true, or if an error code is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeEnumerateValue Event (CBRegistry Component)

This event fires before a registry value's information is retrieved during key value enumeration.

Syntax

• C#
• VB.NET

public event OnBeforeEnumerateValueHandler OnBeforeEnumerateValue;

public delegate void OnBeforeEnumerateValueHandler(object sender, CbregistryBeforeEnumerateValueEventArgs e);

public class CbregistryBeforeEnumerateValueEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int Index { get; }
  public int RequestedFields { get; }
  public string ValueName { get; set; }
  public int ValueType { get; set; }
  public long IntegerValue { get; set; }
  public string StringValue { get; set; }
  public IntPtr BinaryValue { get; }
  public int MaxBinaryValueSize { get; }
  public int BinaryValueSize { get; set; }
  public bool Processed { get; set; }
  public bool FireAfterEvent { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeEnumerateValue As OnBeforeEnumerateValueHandler

Public Delegate Sub OnBeforeEnumerateValueHandler(sender As Object, e As CbregistryBeforeEnumerateValueEventArgs)

Public Class CbregistryBeforeEnumerateValueEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public ReadOnly Property Index As Integer
  Public ReadOnly Property RequestedFields As Integer
  Public Property ValueName As String
  Public Property ValueType As Integer
  Public Property IntegerValue As Long
  Public Property StringValue As String
  Public ReadOnly Property BinaryValue As IntPtr
  Public ReadOnly Property MaxBinaryValueSize As Integer
  Public Property BinaryValueSize As Integer
  Public Property Processed As Boolean
  Public Property FireAfterEvent As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry value's information is retrieved during enumeration of a registry key's values.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_ENUM_VALUE flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The Index parameter reflects the zero-based index of the registry value (within the registry key being enumerated).

The RequestedFields parameter indicates which pieces of information about the registry value were requested. The value of this parameter is a combination of one or more of the following:

The ValueName parameter specifies the registry value's name.

The ValueType parameter specifies the registry value's type and determines which of the other parameters holds the registry value's data (please refer to their descriptions for more information). Possible values are as follows:

The IntegerValue parameter specifies the registry value's data if ValueType is REG_VALUETYPE_DWORD or REG_VALUETYPE_QWORD.

The StringValue parameter specifies the registry value's data if ValueType is REG_VALUETYPE_SZ, REG_VALUETYPE_EXPAND_SZ, or REG_VALUETYPE_MULTI_SZ.

For REG_VALUETYPE_MULTI_SZ, data are formatted as multiple individual ETB-terminated strings concatenated together into a single null-terminated string (where ETB is the End-of-Transmission-Block character; 23/0x17). For example, the strings This is, a multistring, and value. would be encoded as This is[ETB]a multistring[ETB]value.[ETB][NUL].

Note: As Microsoft's Registry Value Types article describes, the native multistring data format uses null terminators for the individual strings (e.g., This is[NUL]a multistring[NUL]value.[NUL][NUL]); CBRegistry converts the individual null terminators to/from ETB characters internally for applications' convenience.

The BinaryValue parameter points to a memory buffer that holds the registry value's data if ValueType is REG_VALUETYPE_BINARY. The MaxBinaryValueSize and BinaryValueSize parameter specify the capacity of the BinaryValue buffer and the length of the data it contains, respectively, in bytes.

Always check MaxBinaryValueSize before copying any data into the BinaryValue buffer. If the buffer is large enough to hold all of the data, copy the data into it, and then update BinaryValueSize accordingly. If the buffer is not large enough, do not copy any data into it; instead, set BinaryValueSize to the required buffer size (i.e., the size of the data) and return the ERROR_MORE_DATA (234) error code via ResultCode.

The Processed parameter indicates whether the underlying request has been handled successfully. Applications should set this parameter to true if they have handled the request themselves (this will prevent the corresponding After* event from being called).

Note: This parameter's value is ignored if an error is returned via ResultCode.

The FireAfterEvent parameter specifies whether the corresponding After* event should be fired; it is true by default.

Note: Regardless of how this parameter is set, the corresponding After* event will not fire if Processed is true, or if an error code is returned via ResultCode.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeGetKeySecurity Event (CBRegistry Component)

This event fires before a registry key's security attributes are retrieved.

Syntax

• C#
• VB.NET

public event OnBeforeGetKeySecurityHandler OnBeforeGetKeySecurity;

public delegate void OnBeforeGetKeySecurityHandler(object sender, CbregistryBeforeGetKeySecurityEventArgs e);

public class CbregistryBeforeGetKeySecurityEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int SecurityInformation { get; }
  public IntPtr SecurityDescriptor { get; }
  public int Length { get; }
  public int LengthNeeded { get; set; }
  public bool Processed { get; set; }
  public bool FireAfterEvent { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeGetKeySecurity As OnBeforeGetKeySecurityHandler

Public Delegate Sub OnBeforeGetKeySecurityHandler(sender As Object, e As CbregistryBeforeGetKeySecurityEventArgs)

Public Class CbregistryBeforeGetKeySecurityEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public ReadOnly Property SecurityInformation As Integer
  Public ReadOnly Property SecurityDescriptor As IntPtr
  Public ReadOnly Property Length As Integer
  Public Property LengthNeeded As Integer
  Public Property Processed As Boolean
  Public Property FireAfterEvent As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before security attributes are retrieved for the registry key specified by KeyContext.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_GET_KEY_SECURITY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The SecurityInformation parameter indicates which pieces of security information are requested. Please refer to Microsoft's SECURITY_INFORMATION data type documentation for more information about possible values.

The SecurityDescriptor parameter points to a memory buffer that receives the requested security information. The buffer referenced by the SecurityDescriptor parameter may be modified by the event handler if the operation is completed without passing it further to other filters and the filesystem driver. The Length parameter reflects the capacity of the SecurityDescriptor buffer, in bytes.

If the capacity reflected by the Length parameter is not sufficient to accommodate the security information, set LengthNeeded to the number of bytes necessary to hold the data, and return the ERROR_INSUFFICIENT_BUFFER error code via ResultCode.

Please see the Buffer Parameters topic for more information on how to work with memory buffer event parameters.

The returned data will be formatted as a SECURITY_DESCRIPTOR structure in self-relative format; please refer to the Microsoft's documentation for more information.

The Processed parameter indicates whether the underlying request has been handled successfully. Applications should set this parameter to true if they have handled the request themselves (this will prevent the corresponding After* event from being called).

Note: This parameter's value is ignored if an error is returned via ResultCode.

The FireAfterEvent parameter specifies whether the corresponding After* event should be fired; it is true by default.

Note: Regardless of how this parameter is set, the corresponding After* event will not fire if Processed is true, or if an error code is returned via ResultCode.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeOpenKey Event (CBRegistry Component)

This event fires before a registry key is opened.

Syntax

• C#
• VB.NET

public event OnBeforeOpenKeyHandler OnBeforeOpenKey;

public delegate void OnBeforeOpenKeyHandler(object sender, CbregistryBeforeOpenKeyEventArgs e);

public class CbregistryBeforeOpenKeyEventArgs : EventArgs {
  public string FullName { get; }
  public int DesiredAccess { get; }
  public long KeyHandle { get; set; }
  public IntPtr KeyHandleContext { get; set; }
  public int GrantedAccess { get; set; }
  public IntPtr KeyContext { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeOpenKey As OnBeforeOpenKeyHandler

Public Delegate Sub OnBeforeOpenKeyHandler(sender As Object, e As CbregistryBeforeOpenKeyEventArgs)

Public Class CbregistryBeforeOpenKeyEventArgs Inherits EventArgs
  Public ReadOnly Property FullName As String
  Public ReadOnly Property DesiredAccess As Integer
  Public Property KeyHandle As Long
  Public Property KeyHandleContext As IntPtr
  Public Property GrantedAccess As Integer
  Public Property KeyContext As IntPtr
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry key is opened.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_OPEN_KEY flag.

The FullName parameter reflects the "full" name of the registry key being opened, specified, by default, in system format (e.g., HKEY_LOCAL_MACHINE\System\... will be \Registry\Machine\System\...). If the ResolveNtNameToWin32Name configuration setting is enabled, the name will be converted to the more common Win32 format. Applications that intend to use the registry key's name during later events should store it in KeyContext during this event. Please refer to the Contexts topic for more information.

The DesiredAccess parameter reflects the access rights specified by the requestor. Please refer to Microsoft's Registry Key Security and Access Rights article for more information about possible values.

The KeyHandle parameter specifies a handle to a registry key that should be opened instead of the one this event fired for. Applications can set this parameter to redirect access to the registry key associated with the specified handle.

The KeyHandleContext parameter is a placeholder for application-defined data associated with the application-provided registry key handle. Please refer to the Contexts topic for more information.

The GrantedAccess parameter specifies the granted access rights for an application-provided registry key handle. Applications that set KeyHandle must also set this parameter. Please refer to Microsoft's Registry Key Security and Access Rights article for more information about possible values.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

The StopFiltering parameter specifies whether the component's system driver should ignore all further operations for the registry key; it is false by default. Applications may set this parameter to true to prevent any further events from firing for the registry key.

The ResultCode parameter will always be 0 when the event is fired. If the event cannot be handled in a "successful" manner for some reason (e.g., a resource is not available or security checks failed), set it to a nonzero value to report an appropriate error. Please see the Error Reporting and Handling topic for more information.

This event is fired synchronously; please refer to the Event Types topic for more information.

BeforeQueryKey Event (CBRegistry Component)

This event fires before a registry key's information is retrieved.

Syntax

• C#
• VB.NET

public event OnBeforeQueryKeyHandler OnBeforeQueryKey;

public delegate void OnBeforeQueryKeyHandler(object sender, CbregistryBeforeQueryKeyEventArgs e);

public class CbregistryBeforeQueryKeyEventArgs : EventArgs {
  public IntPtr KeyContext { get; }
  public int RequestedFields { get; }
  public DateTime LastWriteTime { get; set; }
  public string Name { get; set; }
  public string ClassName { get; set; }
  public int SubKeys { get; set; }
  public int MaxNameLength { get; set; }
  public int MaxClassNameLength { get; set; }
  public int Values { get; set; }
  public int MaxValueNameLength { get; set; }
  public int MaxValueDataSize { get; set; }
  public bool VirtualizationCandidate { get; set; }
  public bool VirtualizationEnabled { get; set; }
  public bool VirtualTarget { get; set; }
  public bool VirtualStore { get; set; }
  public bool VirtualSource { get; set; }
  public bool Processed { get; set; }
  public bool FireAfterEvent { get; set; }
  public bool StopFiltering { get; set; }
  public int ResultCode { get; set; }
}

Public Event OnBeforeQueryKey As OnBeforeQueryKeyHandler

Public Delegate Sub OnBeforeQueryKeyHandler(sender As Object, e As CbregistryBeforeQueryKeyEventArgs)

Public Class CbregistryBeforeQueryKeyEventArgs Inherits EventArgs
  Public ReadOnly Property KeyContext As IntPtr
  Public ReadOnly Property RequestedFields As Integer
  Public Property LastWriteTime As DateTime
  Public Property Name As String
  Public Property ClassName As String
  Public Property SubKeys As Integer
  Public Property MaxNameLength As Integer
  Public Property MaxClassNameLength As Integer
  Public Property Values As Integer
  Public Property MaxValueNameLength As Integer
  Public Property MaxValueDataSize As Integer
  Public Property VirtualizationCandidate As Boolean
  Public Property VirtualizationEnabled As Boolean
  Public Property VirtualTarget As Boolean
  Public Property VirtualStore As Boolean
  Public Property VirtualSource As Boolean
  Public Property Processed As Boolean
  Public Property FireAfterEvent As Boolean
  Public Property StopFiltering As Boolean
  Public Property ResultCode As Integer
End Class

Remarks

This event fires before a registry key's information is retrieved.

Applications need to handle this event only if they have added a standard filter rule that includes the REG_CE_BEFORE_QUERY_KEY flag.

The KeyContext parameter is a placeholder for application-defined data associated with the registry key. Please refer to the Contexts topic for more information.

Note: This event does not expose the registry key's name for performance reasons; applications that need it should store it in KeyContext during the BeforeCreateKey/BeforeOpenKey event so that it can be retrieved when this event fires.

The RequestedFields parameter indicates which pieces of information about the key were requested. The value of this parameter is a combination of one or more of the following: