HidSharp

https://docs.seekye.com/hidsharp
Admin
HidSharp is a .NET library for communicating with HID (Human Interface Device) and serial devices,...
Tokens:152,651
Snippets:1,064
Trust Score:4.5
Update:10 months ago
Show doc for...
Tokens:
Raw
### OpenOption.FromGuid

Source: https://docs.seekye.com/hidsharp/html/685592e7-b4fa-a406-1561-f9d02a0293bd

Creates an OpenOption object from a Guid. This is useful for uniquely identifying and opening specific HID devices.

```APIDOC
## OpenOption.FromGuid

### Description
Creates an `OpenOption` object from a `Guid`. This method is used to specify a particular HID device to open based on its unique identifier.

### Method
`static OpenOption FromGuid(Guid guid)`

### Endpoint
N/A (This is a method documentation, not a REST API endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
Guid deviceGuid = new Guid("00000000-0000-0000-0000-000000000000"); // Replace with actual GUID
OpenOption option = OpenOption.FromGuid(deviceGuid);
```

### Response
#### Success Response (Type: OpenOption)
- **OpenOption**: An `OpenOption` object configured to open the device corresponding to the provided `Guid`.

#### Response Example
(Conceptual representation, as this is a method return value)
```json
{
  "_guid": "00000000-0000-0000-0000-000000000000" // Internal representation of the GUID
}
```

#### See Also
- `OpenOption Class`
- `HidSharp Namespace`
```

--------------------------------

### Start Method for HidDeviceInputReceiver in C#

Source: https://docs.seekye.com/hidsharp/html/6ff3a17f-a905-1691-5670-2e7dec46117d

Starts the HID report receiver using a HidStream. This method will continue processing until the stream is closed or the device is disconnected. Ensure that TryRead is called to retrieve the incoming HID reports.

```csharp
public void Start(
	HidStream stream
)
```

```vb
Public Sub Start (
	stream As HidStream
)
```

```cpp
public:
void Start(
	HidStream^ stream
)
```

```fsharp
member Start :
        stream : HidStream -> unit
```

--------------------------------

### Get Linux Implementation Detail GUID (C#)

Source: https://docs.seekye.com/hidsharp/html/a3298b42-0494-b9a8-dfd8-988992b5a2d3

Retrieves the static Guid representing the Linux operating system for device implementation details. This property is part of the HidSharp namespace and is used to identify devices running on Linux.

```csharp
public static Guid Linux { get; }
```

```vb
Public Shared ReadOnly Property Linux As Guid
	Get
```

```c++
public:
static property Guid Linux {
	Guid get ();
}
```

```fsharp
static member Linux : Guid with get
```

--------------------------------

### ImplementationDetail.Windows Property

Source: https://docs.seekye.com/hidsharp/html/f70f4db9-5070-44dc-222e-1ff9cec87a34

Represents the Guid for the Windows operating system within the HidSharp library.

```APIDOC
## Property ImplementationDetail.Windows

### Description
This property returns a Guid value that identifies the Windows operating system. It is part of the HidSharp library.

### Method
Get

### Endpoint
N/A (This is a property, not an API endpoint)

### Parameters
None

### Request Example
N/A

### Response
#### Success Response (200)
- **Value** (Guid) - The Guid representing the Windows operating system.

#### Response Example
```json
"a811e1a6-b357-4780-b090-73645318732a"
```
```

--------------------------------

### Windows Property Access in Multiple .NET Languages

Source: https://docs.seekye.com/hidsharp/html/f70f4db9-5070-44dc-222e-1ff9cec87a34

This snippet demonstrates how to access the static 'Windows' Guid property from the HidSharp library across various .NET programming languages. This property is used to identify devices running on the Windows operating system. No specific input is required for access, and the output is a Guid representing Windows.

```csharp
public static Guid Windows { get; }
```

```vb
Public Shared ReadOnly Property Windows As Guid
	Get
End Property
```

```cpp
public:
	static property Guid Windows {
		Guid get ();
	}
```

```fsharp
static member Windows : Guid with get
```

--------------------------------

### Get Options List for OpenConfiguration (Multiple Languages)

Source: https://docs.seekye.com/hidsharp/html/4bab1265-0e67-5b4c-6393-067d6988df2d

Retrieves a list of all currently set options for the OpenConfiguration. This method returns an IEnumerable<OpenOption> containing the configuration options.

```csharp
public IEnumerable<OpenOption> GetOptionsList()
```

```vbnet
Public Function GetOptionsList As IEnumerable(Of OpenOption)
```

```cpp
public: IEnumerable<OpenOption^>^ GetOptionsList()
```

```fsharp
member GetOptionsList : unit -> IEnumerable<OpenOption>
```

--------------------------------

### BleUuid Constructors

Source: https://docs.seekye.com/hidsharp/html/7e4a90f7-6d11-2512-ebdd-0cac16396b21

Demonstrates the different ways to initialize a BleUuid instance. These constructors allow for the creation of a BleUuid from a Guid, an Int32 (presumably a short UUID), or a String representation.

```csharp
public BleUuid(Guid guid);
public BleUuid(int shortUuid);
public BleUuid(string uuid);
```

```vb
Public Sub New(guid As Guid)
Public Sub New(shortUuid As Integer)
Public Sub New(uuid As String)
```

```cpp
public: BleUuid(Guid guid);
public: BleUuid(int shortUuid);
public: BleUuid(System::String^ uuid);
```

```fsharp
new : Guid -> BleUuid
new : int -> BleUuid
new : string -> BleUuid
```

--------------------------------

### ImplementationDetail.MacOS Property

Source: https://docs.seekye.com/hidsharp/html/8dfc44bf-f88d-f483-735c-4fc3aef053e0

Retrieves the Guid that identifies the macOS operating system. This is part of the HidSharp library.

```APIDOC
## Get MacOS Guid

### Description
Retrieves the Guid that identifies the macOS operating system.

### Method
GET

### Endpoint
N/A (This is a static property access, not a web endpoint)

### Parameters
None

### Request Example
None

### Response
#### Success Response (Property Value)
- **MacOS** (Guid) - A Guid representing the macOS operating system.

#### Response Example
```json
{
  "MacOS": "some-guid-value"
}
```
```

--------------------------------

### OpenOption.FromGuid Method Across C# Languages

Source: https://docs.seekye.com/hidsharp/html/685592e7-b4fa-a406-1561-f9d02a0293bd

Demonstrates the syntax for the OpenOption.FromGuid method, which creates an OpenOption instance from a System.Guid. This method is available in various C# supported languages. It takes a Guid as input and returns an OpenOption.

```csharp
public static OpenOption FromGuid(
	Guid guid
)
```

```vb
Public Shared Function FromGuid (
	guid As Guid
) As OpenOption
```

```cpp
public: static OpenOption^ FromGuid(
	Guid guid
)
```

```fsharp
static member FromGuid :
        guid : Guid -> OpenOption
```

--------------------------------

### Send Get Feature Request (F#)

Source: https://docs.seekye.com/hidsharp/html/8301b95f-b727-e7d1-9655-30805a542236

Sends a Get Feature setup request using a byte array in F#. The buffer should be pre-filled with the Report ID.

```fsharp
member GetFeature :
        buffer : byte[] -> unit
```

--------------------------------

### Send Get Feature Request (C#)

Source: https://docs.seekye.com/hidsharp/html/8301b95f-b727-e7d1-9655-30805a542236

Sends a Get Feature setup request using a byte buffer in C#. The buffer should be pre-filled with the Report ID.

```csharp
public void GetFeature(
	byte[] buffer
)
```

--------------------------------

### HidDevice.TryOpen Overloads

Source: https://docs.seekye.com/hidsharp/html/2190fe3c-def0-d816-9482-b2668f89c263

This section details the various overloads for the TryOpen method on the HidDevice class, which are used to establish a connection to a HID device.

```APIDOC
## HidDevice.TryOpen Method

### Description

Tries to make a connection to the device. This method has multiple overloads to accommodate different connection scenarios and configurations.

### Method

`TryOpen` is a method of the `HidDevice` class.

### Endpoint

N/A (This is a library method, not a web API endpoint.)

### Parameters

#### Overload 1: TryOpen(DeviceStream)

*   **deviceStream** (DeviceStream) - Required - Represents the stream to use for the device connection.

#### Overload 2: TryOpen(HidStream)

*   **hidStream** (HidStream) - Required - Represents the HID stream to use for the device connection.

#### Overload 3: TryOpen(OpenConfiguration, DeviceStream)

*   **configuration** (OpenConfiguration) - Required - The configuration settings for opening the device.
*   **deviceStream** (DeviceStream) - Required - Represents the stream to use for the device connection.

#### Overload 4: TryOpen(OpenConfiguration, HidStream)

*   **configuration** (OpenConfiguration) - Required - The configuration settings for opening the device.
*   **hidStream** (HidStream) - Required - Represents the HID stream to use for the device connection.

#### Overload 5: TryOpen(OpenConfiguration, DeviceStream, Exception)

*   **configuration** (OpenConfiguration) - Required - The configuration settings for opening the device.
*   **deviceStream** (DeviceStream) - Required - Represents the stream to use for the device connection.
*   **exception** (Exception) - Required - An exception object to store any errors that occur during the opening process.

### Request Example

```csharp
// Example for Overload 1:
HidDevice device = ...; // Assume device is already initialized
DeviceStream stream = ...; // Assume stream is already initialized

bool success = device.TryOpen(stream);
```

### Response

#### Success Response

*   **bool** (bool) - Returns `true` if the device was successfully opened, `false` otherwise.

#### Response Example

```json
// No direct JSON response for this method. It returns a boolean value.
// Example of checking the return value:
try {
    if (device.TryOpen(hidStream)) {
        Console.WriteLine("Device opened successfully.");
    } else {
        Console.WriteLine("Failed to open device.");
    }
} catch (Exception ex) {
    Console.WriteLine($"An error occurred: {ex.Message}");
}
```

### See Also

*   [HidDevice Class](link_to_hiddevice_class)
*   [HidSharp Namespace](link_to_hidsharp_namespace)

```

--------------------------------

### Send Get Feature Request (VB)

Source: https://docs.seekye.com/hidsharp/html/8301b95f-b727-e7d1-9655-30805a542236

Sends a Get Feature setup request using a byte buffer in Visual Basic. The buffer should be pre-filled with the Report ID.

```vb
Public Sub GetFeature (
	buffer As Byte()
)
```

--------------------------------

### Send Get Feature Request (C++)

Source: https://docs.seekye.com/hidsharp/html/8301b95f-b727-e7d1-9655-30805a542236

Sends a Get Feature setup request using an unsigned char array (byte array) in C++. The buffer should be pre-filled with the Report ID.

```cpp
public: void GetFeature(
	array<unsigned char>^ buffer
)
```

--------------------------------

### Create OpenOption Instance (C#)

Source: https://docs.seekye.com/hidsharp/html/74a05b3d-96c3-9a7c-277e-b2c4c7da7f0d

This C# code snippet demonstrates how to use the `OpenOption.New` method to create a new `OpenOption` instance. It requires a GUID, deserialization and serialization callbacks, and optionally accepts a default value and a friendly name.

```csharp
public static OpenOption New(
	Guid guid,
	OpenOptionDeserializeCallback deserializeCallback,
	OpenOptionSerializeCallback serializeCallback,
	Object defaultValue = null,
	string friendlyName = null
)
```

```vbnet
Public Shared Function New (
	guid As Guid,
	deserializeCallback As OpenOptionDeserializeCallback,
	serializeCallback As OpenOptionSerializeCallback,
	Optional defaultValue As Object = Nothing,
	Optional friendlyName As String = Nothing
) As OpenOption
```

```cpp
public: static OpenOption^ New(
	Guid guid,
	OpenOptionDeserializeCallback^ deserializeCallback,
	OpenOptionSerializeCallback^ serializeCallback,
	Object^ defaultValue = nullptr,
	String^ friendlyName = nullptr
)
```

```fsharp
static member New :
        guid : Guid *
        deserializeCallback : OpenOptionDeserializeCallback *
        serializeCallback : OpenOptionSerializeCallback *
        ?defaultValue : Object *
        ?friendlyName : string
(* Defaults:
        let _defaultValue = defaultArg defaultValue null
        let _friendlyName = defaultArg friendlyName null
*)
-> OpenOption
```

--------------------------------

### Device.TryOpen Method - F#

Source: https://docs.seekye.com/hidsharp/html/ba411697-db18-8b7c-423d-f76350c38c41

Demonstrates the Device.TryOpen method signature in F#. This functional approach uses byref parameters for output values, aligning with F# conventions.

```fsharp
member TryOpen :
        openConfig : OpenConfiguration * 
        stream : DeviceStream byref * 
        exception : Exception byref -> bool 

```

--------------------------------

### Device.Open()

Source: https://docs.seekye.com/hidsharp/html/e47a3f3e-3da6-7738-d276-0c1a87792e44

Establishes a connection to the HID device and returns a DeviceStream for communication. Throws an exception if the connection fails.

```APIDOC
## GET /websites/seekye_hidsharp/Device/Open

### Description
Establishes a connection to the HID device. This method should be called to obtain a stream for communicating with the device. If the connection cannot be made, an exception will be thrown.

### Method
GET

### Endpoint
/websites/seekye_hidsharp/Device/Open

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this operation."
}
```

### Response
#### Success Response (200)
- **DeviceStream** (DeviceStream) - The stream to use to communicate with the device.

#### Response Example
```json
{
  "example": "Represents the DeviceStream object returned upon successful connection."
}
```
```

--------------------------------

### Get SerialDevice Guid (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/a630084d-4b00-244f-2a8a-96cca8872bdc

This property returns the Guid that identifies a serial device. It is a static read-only property available across multiple .NET languages. No specific dependencies are required beyond the HidSharp assembly.

```C#
public static Guid SerialDevice { get; }
```

```VB
Public Shared ReadOnly Property SerialDevice As Guid
	Get
```

```C++
public:
static property Guid SerialDevice {
	Guid get ();
}
```

```F#
static member SerialDevice : Guid with get
```

--------------------------------

### HidDeviceInputReceiver.Start Method

Source: https://docs.seekye.com/hidsharp/html/6ff3a17f-a905-1691-5670-2e7dec46117d

Starts the HID device input receiver. This method will continuously receive reports until the associated stream is closed or the HID device is disconnected. It is essential to call TryRead to process incoming reports.

```APIDOC
## HidDeviceInputReceiver.Start Method

### Description
Starts the HID device input receiver. It will continue until the stream is closed or the device is disconnected. Be sure to call TryRead(Byte[], Int32, Report) to read HID reports as they come in.

### Method
POST

### Endpoint
/websites/seekye_hidsharp/inputreceiver/start

### Parameters
#### Query Parameters
- **stream** (HidStream) - Required - The stream to receive on.

### Request Example
```json
{
  "stream": "HidStream_object"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the operation was successful.

#### Response Example
```json
{
  "status": "started"
}
```
```

--------------------------------

### HidStream.GetFeature Method

Source: https://docs.seekye.com/hidsharp/html/e1739c36-3c1f-0cb1-e86d-a5e66af58614

Sends a Get Feature setup request. This method is abstract and must be implemented by subclasses.

```APIDOC
## GET /websites/seekye_hidsharp/HidStream/GetFeature

### Description
Sends a Get Feature setup request. This method is abstract and must be implemented by subclasses.

### Method
GET (or appropriate method based on context, typically POST for setup requests)

### Endpoint
/websites/seekye_hidsharp/HidStream/GetFeature

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **buffer** (Byte[]) - Required - The buffer to fill. Place the Report ID in the byte at index offset.
- **offset** (Int32) - Required - The index in the buffer to begin filling with data.
- **count** (Int32) - Required - The number of bytes in the feature request.

### Request Example
```json
{
  "buffer": "base64EncodedBuffer",
  "offset": 0,
  "count": 10
}
```

### Response
#### Success Response (200)
This method returns void, indicating success or failure through exceptions.

#### Response Example
(No explicit response body for void methods; exceptions indicate errors)

```

--------------------------------

### Get HidDevice Guid Property (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/f904cf65-bb49-4fd5-6e6d-0596a2abd3c8

Retrieves the static Guid representing a HID device from the ImplementationDetail class. This property is read-only and does not require any input parameters. It is commonly used to identify or filter HID devices within applications.

```csharp
public static Guid HidDevice { get; }
```

```vb
Public Shared ReadOnly Property HidDevice As Guid
	Get
```

```cpp
public:
static property Guid HidDevice {
	Guid get ();
}
```

```fsharp
static member HidDevice : Guid with get
```

--------------------------------

### ImplementationDetail Properties Overview

Source: https://docs.seekye.com/hidsharp/html/df76fda4-c323-cde2-17d4-39ef2e00d59e

This section provides an overview of the properties associated with the ImplementationDetail type, detailing its characteristics related to device type, underlying API, and operating system.

```APIDOC
## ImplementationDetail Properties

### Description
This document details the properties of the ImplementationDetail type, which provides information about the nature of a HID device implementation.

### Properties

*   **BleDevice** (Boolean) - Indicates if the device is a Bluetooth Low Energy device.
*   **HidDevice** (Boolean) - Indicates if the device is a HID (Human Interface Device).
*   **HidrawApi** (Boolean) - Indicates if the device is implemented using the Linux hidraw API.
*   **Linux** (Boolean) - Indicates if the device is running on a Linux operating system.
*   **MacOS** (Boolean) - Indicates if the device is running on a macOS operating system.
*   **SerialDevice** (Boolean) - Indicates if the device is a serial device.
*   **Windows** (Boolean) - Indicates if the device is running on a Windows operating system.

### See Also

*   ImplementationDetail Class
*   HidSharp Namespace

### Copyright
Copyright 2010-2025 James F. Bellinger
Send comments on this topic to hidsharp@seekye.com
```

--------------------------------

### Get MacOS Guid (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/8dfc44bf-f88d-f483-735c-4fc3aef053e0

This code snippet demonstrates how to access the `MacOS` static property from the `HidSharp.ImplementationDetail` class. This property returns a `Guid` value that identifies devices running on macOS. No external dependencies are required beyond the HidSharp library.

```C#
public static Guid MacOS { get; }
```

```VB
Public Shared ReadOnly Property MacOS As Guid
	Get
```

```C++
public:
	static property Guid MacOS {
		Guid get ();
	}
```

```F#
static member MacOS : Guid with get
```

--------------------------------

### TryOpen Method in F#

Source: https://docs.seekye.com/hidsharp/html/bbe8a22a-fc81-1643-a489-81c5c52c30d3

Attempts to open a HidDevice using the provided OpenConfiguration. Returns a boolean indicating success and provides the HidStream by reference. Ensure OpenConfiguration is valid before calling.

```fsharp
member TryOpen :
        openConfig : OpenConfiguration * 
        stream : HidStream byref -> bool 
```

--------------------------------

### OpenOption.Equals Method Documentation

Source: https://docs.seekye.com/hidsharp/html/a7fe77d6-4ec6-5d0b-dd78-4ef063daa3dc

Documentation for the OpenOption.Equals method, which compares two OpenOption objects for equality.

```APIDOC
## OpenOption.Equals Method

### Description
Checks whether the current OpenOption object is equal to another object.

### Method
`Equals`

### Endpoint
N/A (This is a class method, not an API endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
Not applicable for this method.

### Response
#### Success Response (Boolean)
- **Returns** (Boolean) - `true` if the specified object is equal to the current object; otherwise, `false`.

#### Response Example
Not applicable for this method.
```

--------------------------------

### Send Get Feature Request with HidStream.GetFeature in C#

Source: https://docs.seekye.com/hidsharp/html/e1739c36-3c1f-0cb1-e86d-a5e66af58614

The GetFeature method in HidSharp is used to send a Get Feature setup request. It takes a byte buffer, an offset, and a count as parameters to fill the buffer with feature data. The Report ID is placed at the specified offset in the buffer.

```csharp
public abstract void GetFeature(
	byte[] buffer,
	int offset,
	int count
)
```

```vb
Public MustOverride Sub GetFeature (
	buffer As Byte(),
	offset As Integer,
	count As Integer
)
```

```cpp
public:
virtual void GetFeature(
	array<unsigned char>^ buffer,
	int offset,
	int count
) abstract
```

```fsharp
abstract GetFeature :
        buffer : byte[] *
        offset : int *
        count : int -> unit
```

--------------------------------

### Initialize OpenConfiguration Constructor in C++

Source: https://docs.seekye.com/hidsharp/html/c2ee1239-fafc-46d1-826c-bf7984a38b2a

Initializes a new instance of the OpenConfiguration class in C++. This is a parameterless constructor.

```cpp
public:
OpenConfiguration()
```

--------------------------------

### HidStream GetFeature Method

Source: https://docs.seekye.com/hidsharp/html/84fec7d4-c067-b873-df47-2d8cef5730b8

Sends a Get Feature setup request to the HID device. This method is used to retrieve feature reports from the device. Overloads are provided for different parameter configurations.

```C#
public abstract void GetFeature(byte[] data);
public abstract void GetFeature(byte[] data, int offset, int count);
```

--------------------------------

### Get Bluetooth Low Energy Device GUID (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/b7e74272-162c-69f0-4ef9-5f997ada4a7a

This static read-only property returns a Guid that uniquely identifies Bluetooth Low Energy (BLE) devices within the HidSharp library. It is used to filter or identify BLE devices during HID device enumeration or interaction. No specific inputs are required as it is a static property.

```csharp
public static Guid BleDevice { get; }
```

```vbnet
Public Shared ReadOnly Property BleDevice As Guid
	Get
```

```cpp
public:
	static property Guid BleDevice {
		Guid get ();
	}
```

```fsharp
static member BleDevice : Guid with get
```

--------------------------------

### TryOpen Method in C++

Source: https://docs.seekye.com/hidsharp/html/bbe8a22a-fc81-1643-a489-81c5c52c30d3

Attempts to open a HidDevice using the provided OpenConfiguration. If successful, it returns true and populates the HidStream output parameter. Ensure OpenConfiguration is valid before calling.

```cpp
public: bool TryOpen(
	OpenConfiguration^ openConfig,
	[OutAttribute] HidStream^% stream
)
```

--------------------------------

### OpenOption Class Methods

Source: https://docs.seekye.com/hidsharp/html/c6d6c0ed-6fa7-76b1-e8b4-13b5aaa332ab

This section lists the methods available in the OpenOption class.

```APIDOC
## OpenOption Class Methods

### Description
Methods available for the OpenOption class.

### Methods

- **Deserialize**(SerializationInfo, StreamingContext) - Deserializes the OpenOption object.
- **Equals**(Object) - (Overrides Object.Equals(Object).) Determines whether the specified object is equal to the current object.
- **FromGuid**(Guid) - Creates an OpenOption object from a GUID.
- **GetHashCode**() - (Overrides Object.GetHashCode().) Serves as the default hash function.
- **New**() - Creates a new instance of the OpenOption class.
- **Serialize**(SerializationInfo, StreamingContext) - Serializes the OpenOption object.
- **ToString**() - (Overrides Object.ToString().) Returns a string that represents the current object.
```

--------------------------------

### EncodedItem.IsShortTag Property - F# Example

Source: https://docs.seekye.com/hidsharp/html/fdabc478-45af-d00f-f535-717e9f3420c2

Presents the IsShortTag property signature in F#. This read-only boolean property, accessed via 'get', indicates whether the EncodedItem is considered a short tag. It's a member of the EncodedItem type within the HidSharp library.

```fsharp
member IsShortTag : bool with get
```

--------------------------------

### Get All HID, BLE, and Serial Devices (C#)

Source: https://docs.seekye.com/hidsharp/html/06a95dd2-046d-09ee-a9d4-f71722579653

Retrieves a list of all connected HID, BLE, and serial devices using the GetAllDevices() method of the DeviceList class. This method requires no parameters.

```csharp
DeviceList.GetAllDevices()
```

--------------------------------

### Initialize DeviceUninstallOptions Constructor (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/13a429d1-3842-83a0-8746-0b89c50ec0a7

Initializes a new instance of the DeviceUninstallOptions class. This constructor has no parameters and is used to create a default instance of the options.

```csharp
public DeviceUninstallOptions()
```

```vb
Public Sub New
```

```cpp
public: DeviceUninstallOptions()
```

```fsharp
new : unit -> DeviceUninstallOptions
```

--------------------------------

### Implicit Operator Guid to BleUuid

Source: https://docs.seekye.com/hidsharp/html/6597be71-7db0-d4b5-b237-36ad22892d34

Provides the C#, VB, and C++ syntax for the implicit conversion operator that allows a Guid to be converted to a BleUuid.

```APIDOC
## Implicit Operator Guid to BleUuid

### Description
This section details the implicit conversion operator that allows a `System.Guid` to be implicitly converted to a `BleUuid` object. This operator is available in C#, VB, and C++.

### Method
Implicit Conversion Operator

### Endpoint
N/A (This is a language construct, not an API endpoint)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```csharp
Guid myGuid = Guid.NewGuid();
BleUuid myBleUuid = myGuid; // Implicit conversion
```

### Response
#### Success Response
N/A (This is a language construct, not an API call)

#### Response Example
N/A
```

--------------------------------

### Device.TryOpen Method

Source: https://docs.seekye.com/hidsharp/html/64a44b82-2e57-3948-807b-9ac113ed375b

Attempts to establish a connection to the device. If successful, it returns a DeviceStream.

```APIDOC
## Device.TryOpen Method

### Description
Attempts to make a connection to the device. If successful, it provides a `DeviceStream` for communication.

### Method
GET (or a custom method if it's a library function)

### Endpoint
`/websites/seekye_hidsharp/Device/TryOpen`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
(Not applicable for this method as it's likely a library function call)

### Response
#### Success Response (200)
- **stream** (DeviceStream) - The stream to use to communicate with the device.
- **return value** (Boolean) - `true` if the connection was successful, `false` otherwise.

#### Response Example
```json
{
  "stream": {},
  "returnValue": true
}
```

#### Error Response
(Details not provided in the input text)
```

--------------------------------

### Initialize BleUuid with Guid (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/64a67d19-35c5-9ae3-e7ac-208cce00b8a7

Constructs a new BleUuid object by providing a System.Guid. This is useful for creating BleUuid instances when you already have a GUID representation. It's part of the HidSharp.Experimental namespace.

```csharp
public BleUuid(
	Guid guid
)
```

```vb
Public Sub New (
	guid As Guid
)
```

```cpp
public:
BleUuid(
	Guid guid
)
```

```fsharp
new :
        guid : Guid -> BleUuid
```

--------------------------------

### Implicit Conversion: BleUuid to Guid (C#, VB, C++)

Source: https://docs.seekye.com/hidsharp/html/1a5c0b11-d5cd-a4c9-f5c0-a5b511dfffe0

This snippet demonstrates the implicit conversion operator that allows a BleUuid object to be directly converted to a Guid object. This functionality is available in C#, Visual Basic, and C++.

```csharp
public static implicit operator Guid (
	BleUuid uuid
)
```

```vb
Public Shared Widening Operator CType (
	uuid As BleUuid
) As Guid
```

```cpp
static implicit operator Guid (
	BleUuid uuid
)
```

--------------------------------

### Initialize OpenConfiguration Constructor in C#

Source: https://docs.seekye.com/hidsharp/html/c2ee1239-fafc-46d1-826c-bf7984a38b2a

Initializes a new instance of the OpenConfiguration class in C#. This is a parameterless constructor.

```csharp
public OpenConfiguration()
```

--------------------------------

### LogInfo Method in C# (HidSharp)

Source: https://docs.seekye.com/hidsharp/html/f468ce22-cd95-2f40-84a2-012970e2ae05

Logs an informational message for device uninstallation. This method takes a string as input and does not return any value. It is part of the HidSharp library.

```csharp
public void LogInfo(
	string message
)
```

```vb
Public Sub LogInfo (
	message As String
)
```

```cpp
public:
void LogInfo(
	String^ message
)
```

```fsharp
member LogInfo :
        message : string -> unit
```

--------------------------------

### BleUuid Constructor (Guid)

Source: https://docs.seekye.com/hidsharp/html/64a67d19-35c5-9ae3-e7ac-208cce00b8a7

Initializes a new instance of the BleUuid class using a System.Guid.

```APIDOC
## BleUuid Constructor (Guid)

### Description
Initializes a new instance of the BleUuid class using a System.Guid.

### Method
Constructor

### Endpoint
N/A (Class Constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Assuming 'myGuid' is a valid System.Guid
BleUuid uuid = new BleUuid(myGuid);
```

### Response
#### Success Response (Instance Creation)
Creates an instance of the BleUuid class.

#### Response Example
(Instance of BleUuid object)
```

--------------------------------

### HidDevice Methods

Source: https://docs.seekye.com/hidsharp/html/8048f117-2419-b61a-43f2-bce2a0c10838

This section details various methods provided by the HidDevice class in the HidSharp library for interacting with HID devices.

```APIDOC
## HidDevice Methods

### Description
Methods for interacting with HID devices, including retrieving device information and managing device connections.

### Methods

#### GetFileSystemName
*   **Description**: Returns the file system path of the device. This can be used to check permissions on Linux hidraw, for instance.
*   **Inherited From**: Device

#### GetFriendlyName
*   **Description**: Returns a name appropriate for display.
*   **Overrides**: Device.GetFriendlyName()

#### GetManufacturer()
*   **Description**: Returns the manufacturer name.
*   **Inherited From**: Device

#### GetManufacturer(GetStringFlags)
*   **Description**: Returns the manufacturer name.
*   **Inherited From**: Device

#### GetMaxFeatureReportLength
*   **Description**: Returns the maximum feature report length, including the Report ID byte. If the device does not use Report IDs, use 0 for the first byte.

#### GetMaxInputReportLength
*   **Description**: Returns the maximum input report length, including the Report ID byte. If the device does not use Report IDs, the first byte will always be 0.

#### GetMaxOutputReportLength
*   **Description**: Returns the maximum output report length, including the Report ID byte. If the device does not use Report IDs, use 0 for the first byte.

#### GetProductName()
*   **Description**: Returns the product name.
*   **Inherited From**: Device

#### GetProductName(GetStringFlags)
*   **Description**: Returns the product name.
*   **Inherited From**: Device

#### GetRawReportDescriptor
*   **Description**: Returns the raw report descriptor of the USB device.

#### GetReportDescriptor
*   **Description**: Retrieves and parses the report descriptor of the USB device.

#### GetSerialNumber()
*   **Description**: Returns the device serial number.
*   **Inherited From**: Device

#### GetSerialNumber(GetStringFlags)
*   **Description**: Returns the device serial number.
*   **Inherited From**: Device

#### GetSerialPorts
*   **Description**: Returns the serial ports of the composite USB device. Currently this is only supported on Windows.

#### GetUsbPort
*   **Description**: (No description provided in source)

#### HasImplementationDetail
*   **Overrides**: Device.HasImplementationDetail(Guid)

#### Open()
*   **Description**: (No description provided in source)

#### Open(OpenConfiguration)
*   **Description**: (No description provided in source)

#### ToString
*   **Description**: Returns a string that represents the current object.
*   **Overrides**: Object.ToString()

#### TryOpen(DeviceStream)
*   **Description**: Tries to make a connection to the device.
*   **Inherited From**: Device

#### TryOpen(HidStream)
*   **Description**: (No description provided in source)

#### TryOpen(OpenConfiguration, DeviceStream)
*   **Inherited From**: Device

#### TryOpen(OpenConfiguration, HidStream)
*   **Description**: (No description provided in source)

#### TryOpen(OpenConfiguration, DeviceStream, Exception)
*   **Inherited From**: Device

```

--------------------------------

### Implicit Conversion from Guid to BleUuid (C#, VB, C++)

Source: https://docs.seekye.com/hidsharp/html/6597be71-7db0-d4b5-b237-36ad22892d34

This snippet demonstrates the implicit conversion operator that allows a System.Guid to be directly converted into a BleUuid object. This is useful for simplifying code when a GUID needs to be represented as a BleUuid. The conversion is handled by the HIDSharp library.

```csharp
public static implicit operator BleUuid (
	Guid guid
)
```

```vb
Public Shared Widening Operator CType (
	guid As Guid
) As BleUuid
```

```cpp
static implicit operator BleUuid (
	Guid guid
)
```

--------------------------------

### Convert BleUuid to Guid (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/1b5907ae-310e-2d19-68a3-0a3a8db40da1

The ToGuid method converts a BleUuid structure to a System.Guid. This is useful for interoperability with other systems or libraries that use the standard Guid format. No specific dependencies are required beyond the HidSharp library itself. The method takes no arguments and returns a Guid.

```csharp
public Guid ToGuid()

```

```vb
Public Function ToGuid As Guid

```

```cpp
public:
Guid ToGuid()

```

```fsharp
member ToGuid : unit -> Guid 

```

--------------------------------

### Get All HID Devices (C#)

Source: https://docs.seekye.com/hidsharp/html/06a95dd2-046d-09ee-a9d4-f71722579653

Retrieves a list of all connected Human Interface Devices (HID). This method is a straightforward way to get all available HID devices without specific filtering.

```csharp
DeviceList.GetHidDevices()
```

--------------------------------

### TryOpen Method in C#

Source: https://docs.seekye.com/hidsharp/html/bbe8a22a-fc81-1643-a489-81c5c52c30d3

Attempts to open a HidDevice using the provided OpenConfiguration. If successful, it returns true and populates the HidStream output parameter. Ensure OpenConfiguration is valid before calling.

```csharp
public bool TryOpen(
	OpenConfiguration openConfig,
	out HidStream stream
)
```

--------------------------------

### DeviceUninstallOptions Class Syntax (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/a81cf0e1-6d68-5c5d-e209-7ca33ca70ba6

This snippet shows the syntax for the DeviceUninstallOptions class in C#, Visual Basic, C++, and F#. This class is part of the HidSharp library and is marked as sealed, indicating it cannot be inherited from.

```csharp
public sealed class DeviceUninstallOptions

```

```vbnet
Public NotInheritable Class DeviceUninstallOptions

```

```cpp
public ref class DeviceUninstallOptions sealed

```

```fsharp
[<SealedAttribute>]
type DeviceUninstallOptions =  class end

```

--------------------------------

### Declare Started Event - C#, VB, C++, F#

Source: https://docs.seekye.com/hidsharp/html/95a5ea0c-61ed-387a-c9c2-b8dbaa004040

This snippet shows the declaration of the 'Started' event for the HidDeviceInputReceiver class. The event is of type System.EventHandler and is implemented across C#, VB.NET, C++/CLI, and F#.

```csharp
public event EventHandler Started
```

```vb
Public Event Started As EventHandler
```

```cpp
public:
 event EventHandler^ Started {
	void add (EventHandler^ value);
	void remove (EventHandler^ value);
 }
```

```fsharp
member Started : IEvent<EventHandler,
    EventArgs>
```

--------------------------------

### Clone Method Implementation (Multiple Languages)

Source: https://docs.seekye.com/hidsharp/html/5fb8734d-7c58-fe16-10a3-d3d122426558

The Clone method creates and returns a deep copy of the current OpenConfiguration object. This is useful for modifying configuration settings without affecting the original object. It takes no parameters.

```C#
public OpenConfiguration Clone()
```

```VB
Public Function Clone As OpenConfiguration
```

```C++
public:
OpenConfiguration^ Clone()
```

```F#
member Clone : unit -> OpenConfiguration
```

--------------------------------

### Get HidDeviceOrNull - VB.NET

Source: https://docs.seekye.com/hidsharp/html/3f45cd8c-d906-b58b-a751-c543d8778fc6

Gets the first connected HID device that matches the specified optional parameters: vendorID, productID, releaseNumberBcd, and serialNumber. If no device matches, it returns Nothing. This function is available in the HidSharp library.

```vb
Public Function GetHidDeviceOrNull (
	Optional vendorID As Nullable(Of Integer) = Nothing,
	Optional productID As Nullable(Of Integer) = Nothing,
	Optional releaseNumberBcd As Nullable(Of Integer) = Nothing,
	Optional serialNumber As String = Nothing
) As HidDevice
```

--------------------------------

### TryOpen Method for HidDevice in C++

Source: https://docs.seekye.com/hidsharp/html/a6c330fc-3e6c-2448-67ab-47f8dc90a3d8

This C++ snippet illustrates the TryOpen method for a HidDevice. It attempts to open the device and returns a HidStream through the 'stream' reference parameter on success. The HidDevice must be correctly initialized prior to calling this method.

```cpp
public: bool TryOpen(
	[OutAttribute] HidStream^% stream
)
```

--------------------------------

### DeviceList API

Source: https://docs.seekye.com/hidsharp/html/dd6edb84-59a0-b6aa-3568-257e4613a66a

Provides access to a list of all available HID devices on the system.

```APIDOC
## GET /devices

### Description
Retrieves a list of all available HID devices connected to the system.

### Method
GET

### Endpoint
/devices

### Parameters
#### Query Parameters
- **Filter** (DeviceFilter) - Optional - A delegate used to filter the list of devices.

### Request Example
```
GET /devices?Filter=...
```

### Response
#### Success Response (200)
- **devices** (DeviceList) - A DeviceList object containing all enumerated HidDevice objects.

#### Response Example
```json
{
  "devices": [
    {
      "deviceInfo": {...},
      "manufacturer": "Example Manufacturer",
      "product": "Example Product"
    }
  ]
}
```
```

--------------------------------

### Check if Drivers are Being Installed (C#)

Source: https://docs.seekye.com/hidsharp/html/3096cc52-ee8a-529e-050b-be6d48691872

This C# code snippet demonstrates how to access the `AreDriversBeingInstalled` property. It returns a boolean value indicating if drivers are currently being installed for the filtered device list. No specific dependencies are required beyond the HidSharp library.

```C#
public override bool AreDriversBeingInstalled { get; }
```

```VB
Public Overrides ReadOnly Property AreDriversBeingInstalled As Boolean
	Get
End Property
```

```C++
public:
	virtual property bool AreDriversBeingInstalled {
		bool get () override;
	}
```

```F#
abstract AreDriversBeingInstalled : bool with get
override AreDriversBeingInstalled : bool with get
```

--------------------------------

### OpenOption.Guid Property Access (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/6f4c5dfb-d22b-40e5-b14a-2b32ac25a68a

Demonstrates how to access the Guid property of the OpenOption class in various .NET languages. This property is read-only and returns a Guid value. No external dependencies are required beyond the HidSharp library.

```C#
public Guid Guid { get; }
```

```VB
Public ReadOnly Property Guid As Guid
	Get
```

```C++
public:
	property Guid Guid {
		Guid get ();
	}
```

```F#
member Guid : Guid with get
```

--------------------------------

### HidSharp FilteredDeviceList Class Overview

Source: https://docs.seekye.com/hidsharp/html/25499a4c-8450-948a-02e3-34445b6124a0

Provides an overview of the FilteredDeviceList class, its inheritance, namespace, and assembly information.

```APIDOC
## HidSharp FilteredDeviceList Class

### Description
Represents a filtered list of connected HID, BLE, and serial devices. This class inherits from `DeviceList` and provides methods to retrieve devices based on specific criteria.

### Namespace
HidSharp

### Assembly
HidSharp.dll
```

--------------------------------

### BeginWrite Asynchronous Write Operation in VB (HIDSharp)

Source: https://docs.seekye.com/hidsharp/html/54903c9d-cabc-b4a7-0f55-2414ada5ae40

Starts an asynchronous write to a DeviceStream in Visual Basic. This function requires a byte array, starting offset, number of bytes to write, an asynchronous callback, and a state object. It returns an IAsyncResult for tracking the operation.

```vbnet
Public Overrides Function BeginWrite (
	buffer As Byte(),
	offset As Integer,
	count As Integer,
	callback As AsyncCallback,
	state As Object
) As IAsyncResult
```

--------------------------------

### HidDevice Methods (C#)

Source: https://docs.seekye.com/hidsharp/html/88779f6a-5225-def4-d363-0cadd10719a2

Lists key methods available on the HidDevice class for interacting with the device. This includes methods for retrieving report lengths, device names, serial numbers, and opening device streams.

```csharp
public abstract string GetFileSystemName();
public abstract string GetFriendlyName();
public abstract string GetManufacturer();
public abstract string GetManufacturer(GetStringFlags flags);
public abstract int GetMaxFeatureReportLength();
public abstract int GetMaxInputReportLength();
public abstract int GetMaxOutputReportLength();
public abstract string GetProductName();
public abstract string GetProductName(GetStringFlags flags);
public abstract byte[] GetRawReportDescriptor();
public abstract ReportDescriptor GetReportDescriptor();
public abstract string GetSerialNumber();
public abstract string GetSerialNumber(GetStringFlags flags);
public abstract IEnumerable<string> GetSerialPorts();
public abstract UsbPort GetUsbPort();
public abstract bool HasImplementationDetail(Guid guid);
public abstract HidStream Open();
public abstract HidStream Open(OpenConfiguration configuration);
public abstract override string ToString();
public abstract bool TryOpen(out HidStream stream);
public abstract bool TryOpen(OpenConfiguration configuration, out HidStream stream);
```

--------------------------------

### BleUuid.ToGuid Method

Source: https://docs.seekye.com/hidsharp/html/1b5907ae-310e-2d19-68a3-0a3a8db40da1

Converts a BleUuid to a Guid.

```APIDOC
## BleUuid.ToGuid Method

### Description
Converts the BleUuid structure to a Guid.

### Method
This method does not take any parameters and returns a Guid.

### Endpoint
N/A (This is a method within a library, not a REST API endpoint)

### Parameters
None

### Request Body
None

### Request Example
```csharp
Guid guid = bleUuid.ToGuid();
```

### Response
#### Success Response
- **Guid** (Guid) - The Guid representation of the BleUuid.

#### Response Example
```json
{
  "guid": "00000000-0000-0000-0000-000000000000"
}
```
```

--------------------------------

### DeviceException Methods

Source: https://docs.seekye.com/hidsharp/html/cee72e52-3e11-199c-b46e-23627fac6a69

This section describes the various methods available on the DeviceException class for creating and managing exceptions associated with HIDSharp devices.

```APIDOC
## DeviceException Methods

### Description
Provides methods for creating and accessing device-related exceptions.

### Methods

#### CreateIOException(Device, String)
Initializes a new instance of the IOException class, and associates a Device with it.

**Method:** N/A (Constructor or Factory Method)
**Parameters:**
- **Device** (Device) - The device associated with the exception.
- **String** (String) - A message describing the exception.

#### CreateIOException(Device, String, Int32)
Initializes a new instance of the IOException class, and associates a Device with it.

**Method:** N/A (Constructor or Factory Method)
**Parameters:**
- **Device** (Device) - The device associated with the exception.
- **String** (String) - A message describing the exception.
- **Int32** (Int32) - An error code.

#### CreateIOExceptionForSharingViolation()
Creates an IOException specifically for a sharing violation.

**Method:** N/A (Factory Method)

#### CreateUnauthorizedAccessException(Device, String)
Initializes a new instance of the UnauthorizedAccessException class, and associates a Device with it.

**Method:** N/A (Constructor or Factory Method)
**Parameters:**
- **Device** (Device) - The device associated with the exception.
- **String** (String) - A message describing the exception.

#### GetDevice()
Gets the Device associated with the exception, if any.

**Method:** GET
**Endpoint:** N/A (Instance Method)
**Returns:**
- **Device** (Device) - The associated device, or null if none.
```

--------------------------------

### TryOpen Method for HidDevice in VB.NET

Source: https://docs.seekye.com/hidsharp/html/a6c330fc-3e6c-2448-67ab-47f8dc90a3d8

This VB.NET code snippet shows how to use the TryOpen method with a HidDevice. The method attempts to establish a connection and outputs the HidStream via the 'stream' parameter upon success. Proper initialization of the HidDevice is a prerequisite.

```vb
Public Function TryOpen (
	<OutAttribute> ByRef stream As HidStream
) As Boolean
```

--------------------------------

### Check Driver Installation Status (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/634061b3-5669-f7f5-3fb6-713ec8ca7d58

The AreDriversBeingInstalled property is an abstract boolean property that returns true if drivers are currently being installed for the HID device. It is accessible in various .NET languages including C#, Visual Basic, C++, and F#.

```C#
public abstract bool AreDriversBeingInstalled { get; }
```

```VB
Public MustOverride ReadOnly Property AreDriversBeingInstalled As Boolean
	Get
```

```C++
public:
	virtual property bool AreDriversBeingInstalled {
		bool get () abstract;
	}
```

```F#
abstract AreDriversBeingInstalled : bool with get
```

--------------------------------

### OpenOption Class Properties

Source: https://docs.seekye.com/hidsharp/html/c6d6c0ed-6fa7-76b1-e8b4-13b5aaa332ab

This section details the properties available for configuring the opening of a HID device stream using the OpenOption class.

```APIDOC
## OpenOption Class Properties

### Description
Properties that configure how a HID device stream is opened.

### Properties

- **Exclusive** (bool) - Optional - Use HIDSharp's exclusivity layer. This allows one process using HIDSharp to lock other processes out of using a HID device. Processes may request interruption, allowing interprocess cooperation. Defaults to false.
- **FriendlyName** (string) - Optional - Gets the friendly name of the device.
- **Guid** (Guid) - Optional - Gets the GUID of the device.
- **Interruptible** (bool) - Optional - Allow other processes to send interruption requests. If another other process with higher priority attempts to open the HID device this process is using, this process will receive an InterruptRequested event on an arbitrary thread. Exclusive must be true for this to work. Defaults to false.
- **Priority** (ProcessPriority) - Optional - The priority of the process. This is used for interruption requests. Exclusive must be true for this to work. Defaults to Normal.
- **TimeoutIfInterruptible** (int) - Optional - The amount of time to wait for an interruptible process to give up the HID device before failing to open the stream. Defaults to 3000 milliseconds.
- **TimeoutIfTransient** (int) - Optional - The amount of time to wait for a transient process to give up the HID device before failing to open the stream. Defaults to 30000 milliseconds.
- **Transient** (bool) - Optional - If a HID device is opened by another process transiently, HIDSharp will wait some time for the process to give up the HID device before failing to open the stream. Exclusive must be true for this to work. Defaults to false.

### Default Values
- **Exclusive**: false
- **Interruptible**: false
- **Priority**: Normal
- **TimeoutIfInterruptible**: 3000 milliseconds
- **TimeoutIfTransient**: 30000 milliseconds
- **Transient**: false
```

--------------------------------

### BleDevice.HasImplementationDetail Method Signature (C#, VB, C++, F#)

Source: https://docs.seekye.com/hidsharp/html/a19c1a00-4a52-94b5-da79-04163bb4a84c

Provides the method signature for BleDevice.HasImplementationDetail across C#, Visual Basic, C++, and F#. This method checks if a given GUID corresponds to an implementation detail supported by the BLE device. It takes a Guid as input and returns a Boolean.

```csharp
public override bool HasImplementationDetail(
	Guid detail
)
```

```vb
Public Overrides Function HasImplementationDetail (
	detail As Guid
) As Boolean
```

```cpp
public: virtual bool HasImplementationDetail(
	Guid detail
) override
```

```fsharp
abstract HasImplementationDetail :
        detail : Guid -> bool 
override HasImplementationDetail :
        detail : Guid -> bool
```

--------------------------------

### Get Manufacturer

Source: https://docs.seekye.com/hidsharp/html/c30ee6d4-5aec-66a0-521b-6076e4783573

Retrieves the manufacturer name of the device.

```APIDOC
## GET /websites/seekye_hidsharp/Device/GetManufacturer

### Description
Returns the manufacturer name of the device.

### Method
GET

### Endpoint
/websites/seekye_hidsharp/Device/GetManufacturer

### Parameters

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **manufacturerName** (String) - The name of the device manufacturer.

#### Response Example
```json
{
  "manufacturerName": "Example Manufacturer"
}
```
```

--------------------------------

### Device.TryOpen Method in C# (HIDSharp)

Source: https://docs.seekye.com/hidsharp/html/67c8689e-42e1-1c5a-3e06-86d6eb869753

Attempts to open a HID device using the specified OpenConfiguration. Returns true if successful and provides a DeviceStream; otherwise, returns false.

```C#
public bool TryOpen(
	OpenConfiguration openConfig,
	out DeviceStream stream
)
```

```VB
Public Function TryOpen (
	openConfig As OpenConfiguration,
	<OutAttribute> ByRef stream As DeviceStream
) As Boolean
```

```C++
public: bool TryOpen(
	OpenConfiguration^ openConfig,
	[OutAttribute] DeviceStream^% stream
)
```

```F#
member TryOpen :
        openConfig : OpenConfiguration *
        stream : DeviceStream byref -> bool

```
Tokens:
Raw