Click here to Skip to main content
14,981,116 members
Please Sign up or sign in to vote.
0.00/5 (No votes)
See more:
Hi everyone.

I have question to ask.

I have a dll file written for reading&writing data on USB.
To use dll in VB.Net, one needs to integrate a .vb file which interface to
that dll file to use its functions, properties etc..

What I need is to use this dll in a C# project. is this possible?
if it's, how can I achieve it?


The code in my form class:


VB
Public Class frmUSB
    ' vendor and product IDs
    Private Const VendorID As Integer = &H1234    'Replace with your device's
    Private Const ProductID As Integer = &H1234      'product and vendor IDs

    ' read and write buffers
    Private Const BufferInSize As Integer = 1 'Size of the data buffer coming IN to the PC
    Private Const BufferOutSize As Integer = 1    'Size of the data buffer going OUT from the PC
    Dim BufferIn(BufferInSize) As Byte          'Received data will be stored here - the first byte in the array is unused
    Dim BufferOut(BufferOutSize) As Byte    'Transmitted data is stored here - the first item in the array must be 0

    ' ****************************************************************
    ' when the form loads, connect to the HID controller - pass
    ' the form window handle so that you can receive notification
    ' events...
    '*****************************************************************
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        ' do not remove!
        ConnectToHID(Me)
    End Sub

    '*****************************************************************
    ' disconnect from the HID controller...
    '*****************************************************************
    Private Sub Form1_FormClosed(ByVal sender As Object, ByVal e As System.Windows.Forms.FormClosedEventArgs) Handles Me.FormClosed
        DisconnectFromHID()
    End Sub

    '*****************************************************************
    ' a HID device has been plugged in...
    '*****************************************************************
    Public Sub OnPlugged(ByVal pHandle As Integer)
        If hidGetVendorID(pHandle) = VendorID And hidGetProductID(pHandle) = ProductID Then
            ' ** YOUR CODE HERE **
        End If
    End Sub

    '*****************************************************************
    ' a HID device has been unplugged...
    '*****************************************************************
    Public Sub OnUnplugged(ByVal pHandle As Integer)
        If hidGetVendorID(pHandle) = VendorID And hidGetProductID(pHandle) = ProductID Then
            hidSetReadNotify(hidGetHandle(VendorID, ProductID), False)
            ' ** YOUR CODE HERE **
        End If
    End Sub

    '*****************************************************************
    ' controller changed notification - called
    ' after ALL HID devices are plugged or unplugged
    '*****************************************************************
    Public Sub OnChanged()
        ' get the handle of the device we are interested in, then set
        ' its read notify flag to true - this ensures you get a read
        ' notification message when there is some data to read...
        Dim pHandle As Integer
        pHandle = hidGetHandle(VendorID, ProductID)
        hidSetReadNotify(hidGetHandle(VendorID, ProductID), True)
    End Sub

    '*****************************************************************
    ' on read event...
    '*****************************************************************
    Public Sub OnRead(ByVal pHandle As Integer)
        ' read the data (don't forget, pass the whole array)...
        If hidRead(pHandle, BufferIn(0)) Then

            TextBox1.Text = Str(BufferIn(1))
            ' ** YOUR CODE HERE **
            ' first byte is the report ID, e.g. BufferIn(0)
            ' the other bytes are the data from the microcontroller...
        End If
    End Sub

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        BufferOut(1) = Val(TextBox2.Text)
        hidWriteEx(VendorID, ProductID, BufferOut(0))

    End Sub
End Class


What can I use to send an instance of my form to HIDDLLInterface
(Equvalent for Me Keyword)?

The interface class code is given below:

Imports System
Imports System.Threading
Imports System.Runtime.InteropServices


Module HIDDLLInterface
    ' this is the interface to the HID controller DLL - you should not
    ' normally need to change anything in this file.
    '
    ' WinProc() calls your main form 'event' procedures - these are currently
    ' set to..
    '
    ' MainForm.OnPlugged(ByVal pHandle as long)
    ' MainForm.OnUnplugged(ByVal pHandle as long)
    ' MainForm.OnChanged()
    ' MainForm.OnRead(ByVal pHandle as long)


    ' HID interface API declarations...
    Declare Function hidConnect Lib "mcHID.dll" Alias "Connect" (ByVal pHostWin As Integer) As Boolean
    Declare Function hidDisconnect Lib "mcHID.dll" Alias "Disconnect" () As Boolean
    Declare Function hidGetItem Lib "mcHID.dll" Alias "GetItem" (ByVal pIndex As Integer) As Integer
    Declare Function hidGetItemCount Lib "mcHID.dll" Alias "GetItemCount" () As Integer
    Declare Function hidRead Lib "mcHID.dll" Alias "Read" (ByVal pHandle As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidWrite Lib "mcHID.dll" Alias "Write" (ByVal pHandle As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidReadEx Lib "mcHID.dll" Alias "ReadEx" (ByVal pVendorID As Integer, ByVal pProductID As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidWriteEx Lib "mcHID.dll" Alias "WriteEx" (ByVal pVendorID As Integer, ByVal pProductID As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidGetHandle Lib "mcHID.dll" Alias "GetHandle" (ByVal pVendoID As Integer, ByVal pProductID As Integer) As Integer
    Declare Function hidGetVendorID Lib "mcHID.dll" Alias "GetVendorID" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetProductID Lib "mcHID.dll" Alias "GetProductID" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetVersion Lib "mcHID.dll" Alias "GetVersion" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetVendorName Lib "mcHID.dll" Alias "GetVendorName" (ByVal pHandle As Integer, ByVal pText As String, ByVal pLen As Integer) As Integer
    Declare Function hidGetProductName Lib "mcHID.dll" Alias "GetProductName" (ByVal pHandle As Integer, ByVal pText As String, ByVal pLen As Integer) As Integer
    Declare Function hidGetSerialNumber Lib "mcHID.dll" Alias "GetSerialNumber" (ByVal pHandle As Integer, ByVal pText As String, ByVal pLen As Integer) As Integer
    Declare Function hidGetInputReportLength Lib "mcHID.dll" Alias "GetInputReportLength" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetOutputReportLength Lib "mcHID.dll" Alias "GetOutputReportLength" (ByVal pHandle As Integer) As Integer
    Declare Sub hidSetReadNotify Lib "mcHID.dll" Alias "SetReadNotify" (ByVal pHandle As Integer, ByVal pValue As Boolean)
    Declare Function hidIsReadNotifyEnabled Lib "mcHID.dll" Alias "IsReadNotifyEnabled" (ByVal pHandle As Integer) As Boolean
    Declare Function hidIsAvailable Lib "mcHID.dll" Alias "IsAvailable" (ByVal pVendorID As Integer, ByVal pProductID As Integer) As Boolean

    ' windows API declarations - used to set up messaging...

    Public Declare Function CallWindowProc Lib "user32" Alias "CallWindowProcA" (ByVal lpPrevWndFunc As Integer, ByVal hwnd As Integer, ByVal Msg As Integer, ByVal wParam As Integer, ByVal lParam As Integer) As Integer
    Public Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" _
                                          (ByVal hwnd As Integer, ByVal nIndex As Integer, ByVal dwNewLong As Integer) As Integer

    Delegate Function SubClassProcDelegate(ByVal hwnd As Integer, ByVal msg As Integer, ByVal wParam As Integer, ByVal lParam As Integer) As Integer
    Public Declare Function DelegateSetWindowLong Lib "USER32.DLL" Alias "SetWindowLongA" _
                                           (ByVal hwnd As Integer, ByVal attr As Integer, ByVal lval As SubClassProcDelegate) As Integer


    ' windows API Constants
    Public Const WM_APP As Integer = 32768
    Public Const GWL_WNDPROC As Short = -4

    ' HID message constants
    Private Const WM_HID_EVENT As Decimal = WM_APP + 200
    Private Const NOTIFY_PLUGGED As Short = 1
    Private Const NOTIFY_UNPLUGGED As Short = 2
    Private Const NOTIFY_CHANGED As Short = 3
    Private Const NOTIFY_READ As Short = 4

    ' local variables
    Private FPrevWinProc As Integer ' Handle to previous window procedure
    Private FWinHandle As Integer ' Handle to message window
    Private Ref_WinProc As New SubClassProcDelegate(AddressOf WinProc)
    Private HostForm As Object

    ' Set up a windows hook to receive notification
    ' messages from the HID controller DLL - then connect
    ' to the controller
    Public Function ConnectToHID(ByRef targetForm As Form) As Boolean
        Dim pHostWin As Integer = targetForm.Handle.ToInt32
        FWinHandle = pHostWin
        pHostWin = hidConnect(FWinHandle)
        FPrevWinProc = DelegateSetWindowLong(FWinHandle, GWL_WNDPROC, Ref_WinProc)
        HostForm = targetForm
    End Function

    ' Unhook from the HID controller and disconnect...
    Public Function DisconnectFromHID() As Boolean
        DisconnectFromHID = hidDisconnect
        SetWindowLong(FWinHandle, GWL_WNDPROC, FPrevWinProc)
    End Function


    ' This is the procedure that intercepts the HID controller messages...

    Private Function WinProc(ByVal pHWnd As Integer, ByVal pMsg As Integer, ByVal wParam As Integer, ByVal lParam As Integer) As Integer
        If pMsg = WM_HID_EVENT Then
            Select Case wParam

                ' HID device has been plugged message...
                Case Is = NOTIFY_PLUGGED
                    HostForm.OnPlugged(lParam)

                    ' HID device has been unplugged
                Case Is = NOTIFY_UNPLUGGED
                    HostForm.OnUnplugged(lParam)

                    ' controller has changed...
                Case Is = NOTIFY_CHANGED
                    HostForm.OnChanged()

                    ' read event...
                Case Is = NOTIFY_READ
                    HostForm.OnRead(lParam)
            End Select

        End If

        ' next...
        WinProc = CallWindowProc(FPrevWinProc, pHWnd, pMsg, wParam, lParam)

    End Function
End Module
Posted
Updated 21-Nov-11 23:00pm
v2

You could compile the VB code into another DLL and then add a reference to the VB DLL in C#. Since the VB DLL will be .Net you should be able to use it without DllImport's or the like.
   
Comments
Un_NaMeD 22-Nov-11 6:32am
   
Hi.
How can I compile VB code into another dll and referance to VB DLL in C#?
Un_NaMeD 22-Nov-11 8:58am
   
Sir, Could you please explain how can I do it?
lewax00 22-Nov-11 12:07pm
   
Create a new project of type "Class Library", add the reference to the DLL you're wrapping and the VB code to use it, then build it. Reference the resulting DLL from the C# project and you should be good to go.
Un_NaMeD 22-Nov-11 13:11pm
   
I'm away from my Pc now.
I'll try as soon as possible and make you aware.
Thank you, sir.
Hello,

You can use free online convesion tools.

For example http://www.developerfusion.com/tools/convert/vb-to-csharp/[^]

C#
using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;


static class HIDDLLInterface
{
    [DllImport("mcHID.dll", EntryPoint = "Connect", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    // this is the interface to the HID controller DLL - you should not
    // normally need to change anything in this file.
    //
    // WinProc() calls your main form 'event' procedures - these are currently
    // set to..
    //
    // MainForm.OnPlugged(ByVal pHandle as long)
    // MainForm.OnUnplugged(ByVal pHandle as long)
    // MainForm.OnChanged()
    // MainForm.OnRead(ByVal pHandle as long)


    // HID interface API declarations...
    public static extern bool hidConnect(int pHostWin);
    [DllImport("mcHID.dll", EntryPoint = "Disconnect", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidDisconnect();
    [DllImport("mcHID.dll", EntryPoint = "GetItem", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetItem(int pIndex);
    [DllImport("mcHID.dll", EntryPoint = "GetItemCount", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetItemCount();
    [DllImport("mcHID.dll", EntryPoint = "Read", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidRead(int pHandle, ref byte pData);
    [DllImport("mcHID.dll", EntryPoint = "Write", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidWrite(int pHandle, ref byte pData);
    [DllImport("mcHID.dll", EntryPoint = "ReadEx", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidReadEx(int pVendorID, int pProductID, ref byte pData);
    [DllImport("mcHID.dll", EntryPoint = "WriteEx", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidWriteEx(int pVendorID, int pProductID, ref byte pData);
    [DllImport("mcHID.dll", EntryPoint = "GetHandle", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetHandle(int pVendoID, int pProductID);
    [DllImport("mcHID.dll", EntryPoint = "GetVendorID", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetVendorID(int pHandle);
    [DllImport("mcHID.dll", EntryPoint = "GetProductID", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetProductID(int pHandle);
    [DllImport("mcHID.dll", EntryPoint = "GetVersion", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetVersion(int pHandle);
    [DllImport("mcHID.dll", EntryPoint = "GetVendorName", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetVendorName(int pHandle, string pText, int pLen);
    [DllImport("mcHID.dll", EntryPoint = "GetProductName", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetProductName(int pHandle, string pText, int pLen);
    [DllImport("mcHID.dll", EntryPoint = "GetSerialNumber", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetSerialNumber(int pHandle, string pText, int pLen);
    [DllImport("mcHID.dll", EntryPoint = "GetInputReportLength", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetInputReportLength(int pHandle);
    [DllImport("mcHID.dll", EntryPoint = "GetOutputReportLength", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int hidGetOutputReportLength(int pHandle);
    [DllImport("mcHID.dll", EntryPoint = "SetReadNotify", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern void hidSetReadNotify(int pHandle, bool pValue);
    [DllImport("mcHID.dll", EntryPoint = "IsReadNotifyEnabled", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidIsReadNotifyEnabled(int pHandle);
    [DllImport("mcHID.dll", EntryPoint = "IsAvailable", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern bool hidIsAvailable(int pVendorID, int pProductID);
    [DllImport("user32", EntryPoint = "CallWindowProcA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]

    // windows API declarations - used to set up messaging...

    public static extern int CallWindowProc(int lpPrevWndFunc, int hwnd, int Msg, int wParam, int lParam);
    [DllImport("user32", EntryPoint = "SetWindowLongA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int SetWindowLong(int hwnd, int nIndex, int dwNewLong);

    public delegate int SubClassProcDelegate(int hwnd, int msg, int wParam, int lParam);
    [DllImport("USER32.DLL", EntryPoint = "SetWindowLongA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
    public static extern int DelegateSetWindowLong(int hwnd, int attr, SubClassProcDelegate lval);


    // windows API Constants
    public const int WM_APP = 32768;
    public const short GWL_WNDPROC = -4;

    // HID message constants
    private const decimal WM_HID_EVENT = WM_APP + 200;
    private const short NOTIFY_PLUGGED = 1;
    private const short NOTIFY_UNPLUGGED = 2;
    private const short NOTIFY_CHANGED = 3;
    private const short NOTIFY_READ = 4;

    // local variables
        // Handle to previous window procedure
    private static int FPrevWinProc;
        // Handle to message window
    private static int FWinHandle;
    private static SubClassProcDelegate Ref_WinProc = new SubClassProcDelegate(WinProc);
    private static object HostForm;

    // Set up a windows hook to receive notification
    // messages from the HID controller DLL - then connect
    // to the controller
    public static bool ConnectToHID(ref Form targetForm)
    {
        int pHostWin = targetForm.Handle.ToInt32;
        FWinHandle = pHostWin;
        pHostWin = hidConnect(FWinHandle);
        FPrevWinProc = DelegateSetWindowLong(FWinHandle, GWL_WNDPROC, Ref_WinProc);
        HostForm = targetForm;
    }

    // Unhook from the HID controller and disconnect...
    public static bool DisconnectFromHID()
    {
        bool functionReturnValue = false;
        functionReturnValue = hidDisconnect();
        SetWindowLong(FWinHandle, GWL_WNDPROC, FPrevWinProc);
        return functionReturnValue;
    }


    // This is the procedure that intercepts the HID controller messages...

    private static int WinProc(int pHWnd, int pMsg, int wParam, int lParam)
    {
        if (pMsg == WM_HID_EVENT) {
            switch (wParam) {

                // HID device has been plugged message...
                case  // ERROR: Case labels with binary operators are unsupported : Equality
NOTIFY_PLUGGED:
                    HostForm.OnPlugged(lParam);
                    break;

                // HID device has been unplugged
                case  // ERROR: Case labels with binary operators are unsupported : Equality
NOTIFY_UNPLUGGED:
                    HostForm.OnUnplugged(lParam);
                    break;

                // controller has changed...
                case  // ERROR: Case labels with binary operators are unsupported : Equality
NOTIFY_CHANGED:
                    HostForm.OnChanged();
                    break;

                // read event...
                case  // ERROR: Case labels with binary operators are unsupported : Equality
NOTIFY_READ:
                    HostForm.OnRead(lParam);
                    break;
            }

        }

        // next...
        return CallWindowProc(FPrevWinProc, pHWnd, pMsg, wParam, lParam);

    }
}


All you will need to do is to correct the generated code and make it work.

Valery.
   
v2
Comments
Un_NaMeD 21-Nov-11 17:04pm
   
Hey Vallery.
I did it, but there becomes errors that I can't access the fuctions(OnRead,OnChanged,OnPlogged and the others)
Simon_Whale 22-Nov-11 5:28am
   
Code converters don't 100% convert between the 2 the most obvious that I am aware of is the event handlers.
You are Saying that you have DLL in VB.Net.
So for your kind Information you can use any Compiled Dll in any Language.
If you don't have compiled DLL then Create New Class Library in Vb.Net
and Create Compiled Dll.
After that by adding the reference of that Dll in your C# Project you can
able to use that DLL.
   
Comments
Un_NaMeD 22-Nov-11 6:35am
   
I'm afraid it's not compiled Dll, and I don't know what's in it :/
I just have .dll file.
You have to choices to achieve what you are after

1. Add the VB Project to your C# Solution and then add a reference to the dll that it generates.

2. Compile the VB Project into the DLL and then import a reference to it.


You can create a solution that contains VB projects and C# projects. you just can't have C# and VB.NET class files in the same project.
   
Comments
Un_NaMeD 22-Nov-11 6:47am
   
Hi.
Could'nt get adding VB project to C# solution?
Then Write the code in which Language?
Also, .dll is not compiled Dll, so I can't add dll as a referance.
Simon_Whale 22-Nov-11 6:53am
   
How to add the VB project into the solution with a C# project.

I am assuming that your VB project is a class library.

You need to save the C# project first and then from the file menu choose add and then existing project.

once you have the 2 project in the same solution build it.

then on the C# project right click and add references, on the projects tab choose the VB project.
Un_NaMeD 22-Nov-11 7:03am
   
Sir,
I did what you say.
Now My C# project Form1 appeared the same as VB project Form1.

At this point I will write code in VB.Net or C# for using dll?

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)




CodeProject, 20 Bay Street, 11th Floor Toronto, Ontario, Canada M5J 2N8 +1 (416) 849-8900