/// <summary> /// Waits for a pending asynchronous write operation to complete. /// </summary> /// <param name="asyncResult">The <see cref="IAsyncResult"/> object representing the asynchonous operation, /// as returned by <see cref="BeginWrite"/>.</param> /// <returns>The number of bytes transfered during the operation.</returns> /// <remarks>Every call to <see cref="BeginWrite"/> must have a matching call to <see cref="EndWrite"/> to dispose /// of any resources used and to retrieve the result of the operation. When the operation was successful the method returns the number /// of bytes that were transfered. If an error occurred during the operation this method will throw the exceptions that would /// otherwise have ocurred during the operation. If the operation is not yet finished EndWrite will wait for the /// operation to finish before returning.</remarks> public void EndWrite(IAsyncResult asyncResult) { if (asyncResult == null) { // throw new NullReferenceException("asyncResult cannot be null"); LogAndThrowException(new NullReferenceException("asyncResult cannot be null")); } if (!(asyncResult is USBAsyncResult)) { // throw new ArgumentException("AsyncResult object was not created by calling BeginWrite on this class."); LogAndThrowException(new ArgumentException("AsyncResult object was not created by calling BeginWrite on this class.")); } USBAsyncResult result = (USBAsyncResult)asyncResult; try { // todo: check duplicate end writes? if (!result.IsCompleted) { result.AsyncWaitHandle.WaitOne(); } if (result.Error != null) { // throw new USBException("Asynchronous write to pipe has failed.", result.Error); LogAndThrowException(new USBException("Asynchronous write to pipe has failed.", result.Error)); } } finally { result.Dispose(); } }
/// <summary>Initiates an asynchronous read operation on the pipe. </summary> /// <param name="buffer">Buffer that will receive the data read from the pipe.</param> /// <param name="offset">Byte offset within the buffer at which to begin writing the data received.</param> /// <param name="length">Length of the data to transfer.</param> /// <param name="userCallback">An optional asynchronous callback, to be called when the operation is complete. Can be null if no callback is required.</param> /// <param name="stateObject">A user-provided object that distinguishes this particular asynchronous operation. Can be null if not required.</param> /// <returns>An <see cref="IAsyncResult"/> object repesenting the asynchronous operation, which could still be pending.</returns> /// <remarks>This method always completes immediately even if the operation is still pending. The <see cref="IAsyncResult"/> object returned represents the operation /// and must be passed to <see cref="EndRead"/> to retrieve the result of the operation. For every call to this method a matching call to /// <see cref="EndRead"/> must be made. When <paramref name="userCallback"/> specifies a callback function, this function will be called when the operation is completed. The optional /// <paramref name="stateObject"/> parameter can be used to pass user-defined information to this callback or the <see cref="IAsyncResult"/>. The <see cref="IAsyncResult"/> /// also provides an event handle (<see cref="IAsyncResult.AsyncWaitHandle" />) that will be triggered when the operation is complete as well. /// </remarks> public IAsyncResult BeginRead(byte[] buffer, int offset, int length, AsyncCallback userCallback, object stateObject) { CheckReadParams(buffer, offset, length); USBAsyncResult result = new USBAsyncResult(userCallback, stateObject); try { _device.InternalDevice.ReadPipeOverlapped(Interface.InterfaceIndex, _pipeInfo.PipeId, buffer, offset, length, result); } catch (API.APIException e) { if (result != null) { result.Dispose(); } // throw new USBException("Failed to read from pipe.", e); LogAndThrowException(new USBException("Failed to read from pipe.", e)); } catch (Exception e) { if (result != null) { result.Dispose(); } // throw; LogException(e); throw; } return(result); }
/// <summary>Initiates an asynchronous write operation on the pipe. </summary> /// <param name="buffer">Buffer that contains the data to write to the pipe.</param> /// <param name="offset">Byte offset within the buffer from which to begin writing.</param> /// <param name="length">Length of the data to transfer.</param> /// <param name="userCallback">An optional asynchronous callback, to be called when the operation is complete. Can be null if no callback is required.</param> /// <param name="stateObject">A user-provided object that distinguishes this particular asynchronous operation. Can be null if not required.</param> /// <returns>An <see cref="IAsyncResult"/> object repesenting the asynchronous operation, which could still be pending.</returns> /// <remarks>This method always completes immediately even if the operation is still pending. The <see cref="IAsyncResult"/> object returned represents the operation /// and must be passed to <see cref="EndWrite"/> to retrieve the result of the operation. For every call to this method a matching call to /// <see cref="EndWrite"/> must be made. When <paramref name="userCallback"/> specifies a callback function, this function will be called when the operation is completed. The optional /// <paramref name="stateObject"/> parameter can be used to pass user-defined information to this callback or the <see cref="IAsyncResult"/>. The <see cref="IAsyncResult"/> /// also provides an event handle (<see cref="IAsyncResult.AsyncWaitHandle" />) that will be triggered when the operation is complete as well. /// </remarks> public IAsyncResult BeginWrite(byte[] buffer, int offset, int length, AsyncCallback userCallback, object stateObject) { CheckWriteParams(buffer, offset, length); USBAsyncResult result = new USBAsyncResult(userCallback, stateObject); try { _device.InternalDevice.WriteOverlapped(Interface.InterfaceIndex, _pipeInfo.PipeId, buffer, offset, length, result); } catch (API.APIException e) { if (result != null) { result.Dispose(); } throw new USBException("Failed to write to pipe.", e); } catch (Exception) { if (result != null) { result.Dispose(); } throw; } return(result); }
/// <summary> /// Waits for a pending asynchronous read operation to complete. /// </summary> /// <param name="asyncResult">The <see cref="IAsyncResult"/> object representing the asynchonous operation, /// as returned by <see cref="BeginRead"/>.</param> /// <returns>The number of bytes transfered during the operation.</returns> /// <remarks>Every call to <see cref="BeginRead"/> must have a matching call to <see cref="EndRead"/> to dispose /// of any resources used and to retrieve the result of the operation. When the operation was successful the method returns the number /// of bytes that were transfered. If an error occurred during the operation this method will throw the exceptions that would /// otherwise have ocurred during the operation. If the operation is not yet finished EndWrite will wait for the /// operation to finish before returning.</remarks> public int EndRead(IAsyncResult asyncResult) { if (asyncResult == null) { throw new NullReferenceException("asyncResult cannot be null"); } if (!(asyncResult is USBAsyncResult)) { throw new ArgumentException("AsyncResult object was not created by calling BeginRead on this class."); } // todo: check duplicate end reads? USBAsyncResult result = (USBAsyncResult)asyncResult; try { if (!result.IsCompleted) { result.AsyncWaitHandle.WaitOne(); } if (result.Error != null) { throw new USBException("Asynchronous read from pipe has failed.", result.Error); } return(result.BytesTransfered); } finally { result.Dispose(); } }
internal void WaitForCompletion() { if (asyncResult == null) { throw new ScopeIOException("Can't wait for command's completion before executing command"); } try { if (endPoint.IsOut) { endPoint.EndWrite(asyncResult); } else if (endPoint.IsIn) { endPoint.EndRead(asyncResult); } else { throw new ScopeIOException("Unknown endpoint type"); } } catch (USBException e) { Error = e; bytesTransferred = 0; buffer = null; return; } MadWizard.WinUSBNet.USBAsyncResult usbresult = (MadWizard.WinUSBNet.USBAsyncResult)asyncResult; if (usbresult.Error != null) { Error = usbresult.Error; success = false; bytesTransferred = 0; buffer = null; } else { bytesTransferred = usbresult.BytesTransfered; } }
/// <summary>Initiates an asynchronous write operation on the pipe. </summary> /// <param name="buffer">Buffer that contains the data to write to the pipe.</param> /// <param name="offset">Byte offset within the buffer from which to begin writing.</param> /// <param name="length">Length of the data to transfer.</param> /// <param name="userCallback">An optional asynchronous callback, to be called when the operation is complete. Can be null if no callback is required.</param> /// <param name="stateObject">A user-provided object that distinguishes this particular asynchronous operation. Can be null if not required.</param> /// <returns>An <see cref="IAsyncResult"/> object repesenting the asynchronous operation, which could still be pending.</returns> /// <remarks>This method always completes immediately even if the operation is still pending. The <see cref="IAsyncResult"/> object returned represents the operation /// and must be passed to <see cref="EndWrite"/> to retrieve the result of the operation. For every call to this method a matching call to /// <see cref="EndWrite"/> must be made. When <paramref name="userCallback"/> specifies a callback function, this function will be called when the operation is completed. The optional /// <paramref name="stateObject"/> parameter can be used to pass user-defined information to this callback or the <see cref="IAsyncResult"/>. The <see cref="IAsyncResult"/> /// also provides an event handle (<see cref="IAsyncResult.AsyncWaitHandle" />) that will be triggered when the operation is complete as well. /// </remarks> public IAsyncResult BeginWrite(byte[] buffer, int offset, int length, AsyncCallback userCallback, object stateObject) { CheckWriteParams(buffer, offset, length); LogLastWrite(buffer, offset, length); USBAsyncResult result = new USBAsyncResult(userCallback, stateObject); try { _device.InternalDevice.WriteOverlapped(Interface.InterfaceIndex, _pipeInfo.PipeId, buffer, offset, length, result); } catch (API.APIException e) { if (result != null) { result.Dispose(); } byte[] SubBuffer = new byte[(length < 16 ? length : 16)]; Array.Copy(buffer, offset, SubBuffer, 0, (length < 16 ? length : 16)); // throw new USBException("Failed to write to pipe: " + WPinternals.Converter.ConvertHexToString(SubBuffer, ""), e); LogAndThrowException(new USBException("Failed to write to pipe: " + WPinternals.Converter.ConvertHexToString(SubBuffer, ""), e)); } catch (Exception e) { if (result != null) { result.Dispose(); } // throw; LogException(e); throw; } return(result); }
/// <summary>Initiates an asynchronous write operation on the pipe. </summary> /// <param name="buffer">Buffer that contains the data to write to the pipe.</param> /// <param name="offset">Byte offset within the buffer from which to begin writing.</param> /// <param name="length">Length of the data to transfer.</param> /// <param name="userCallback">An optional asynchronous callback, to be called when the operation is complete. Can be null if no callback is required.</param> /// <param name="stateObject">A user-provided object that distinguishes this particular asynchronous operation. Can be null if not required.</param> /// <returns>An <see cref="IAsyncResult"/> object repesenting the asynchronous operation, which could still be pending.</returns> /// <remarks>This method always completes immediately even if the operation is still pending. The <see cref="IAsyncResult"/> object returned represents the operation /// and must be passed to <see cref="EndWrite"/> to retrieve the result of the operation. For every call to this method a matching call to /// <see cref="EndWrite"/> must be made. When <paramref name="userCallback"/> specifies a callback function, this function will be called when the operation is completed. The optional /// <paramref name="stateObject"/> parameter can be used to pass user-defined information to this callback or the <see cref="IAsyncResult"/>. The <see cref="IAsyncResult"/> /// also provides an event handle (<see cref="IAsyncResult.AsyncWaitHandle" />) that will be triggered when the operation is complete as well. /// </remarks> public IAsyncResult BeginWrite(byte[] buffer, int offset, int length, AsyncCallback userCallback, object stateObject) { CheckWriteParams(buffer, offset, length); USBAsyncResult result = new USBAsyncResult(userCallback, stateObject); try { _device.InternalDevice.WriteOverlapped(Interface.InterfaceIndex, _pipeInfo.PipeId, buffer, offset, length, result); } catch (API.APIException e) { if (result != null) result.Dispose(); throw new USBException("Failed to write to pipe.", e); } catch (Exception) { if (result != null) result.Dispose(); throw; } return result; }
/// <summary> /// Initiates an asynchronous control transfer over the default control endpoint. This method allows both IN and OUT direction transfers, depending /// on the highest bit of the <paramref name="requestType"/> parameter. Alternatively, <see cref="BeginControlIn(byte,byte,int,int,byte[],int,AsyncCallback,object)"/> and /// <see cref="BeginControlIn(byte,byte,int,int,byte[],int,AsyncCallback,object)"/> can be used for asynchronous control transfers in a specific direction, which is /// the recommended way because it prevents using the wrong direction accidentally. Use the BeginControlTransfer method when the direction is not /// known at compile time. </summary> /// <param name="requestType">The setup packet request type.</param> /// <param name="request">The setup packet device request.</param> /// <param name="value">The value member in the setup packet. Its meaning depends on the request. Value should be between zero and 65535 (0xFFFF).</param> /// <param name="index">The index member in the setup packet. Its meaning depends on the request. Index should be between zero and 65535 (0xFFFF).</param> /// <param name="buffer">The data to transfer in the data stage of the control. When the transfer is in the IN direction the data received will be /// written to this buffer. For an OUT direction transfer the contents of the buffer are written sent through the pipe. Note: This buffer is not allowed /// to change for the duration of the asynchronous operation.</param> /// <param name="length">Length of the data to transfer. Must be equal to or less than the length of <paramref name="buffer"/>. The setup packet's length member will be set to this length.</param> /// <param name="userCallback">An optional asynchronous callback, to be called when the control transfer is complete. Can be null if no callback is required.</param> /// <param name="stateObject">A user-provided object that distinguishes this particular asynchronous operation. Can be null if not required.</param> /// <returns>An <see cref="IAsyncResult"/> object repesenting the asynchronous control transfer, which could still be pending.</returns> /// <remarks>This method always completes immediately even if the operation is still pending. The <see cref="IAsyncResult"/> object returned represents the operation /// and must be passed to <see cref="EndControlTransfer"/> to retrieve the result of the operation. For every call to this method a matching call to /// <see cref="EndControlTransfer"/> must be made. When <paramref name="userCallback"/> specifies a callback function, this function will be called when the operation is completed. The optional /// <paramref name="stateObject"/> parameter can be used to pass user-defined information to this callback or the <see cref="IAsyncResult"/>. The <see cref="IAsyncResult"/> /// also provides an event handle (<see cref="IAsyncResult.AsyncWaitHandle" />) that will be triggered when the operation is complete as well. /// </remarks> public IAsyncResult BeginControlTransfer(byte requestType, byte request, int value, int index, byte[] buffer, int length, AsyncCallback userCallback, object stateObject) { // Parameters are int and not ushort because ushort is not CLS compliant. CheckNotDisposed(); CheckControlParams(value, index, buffer, length); USBAsyncResult result = new USBAsyncResult(userCallback, stateObject); try { _wuDevice.ControlTransferOverlapped(requestType, request, (ushort)value, (ushort)index, (ushort)length, buffer, result); } catch (API.APIException e) { if (result != null) result.Dispose(); throw new USBException("Asynchronous control transfer failed", e); } catch (Exception) { if (result != null) result.Dispose(); throw; } return result; }