In the application C# we call functions from Windows dll (C++ WinAPI). Attribute [DllImport("user32.dll")]

Компьютер, программы

→

C# (programming language)

In the application C# we call functions from Windows dll (C++ WinAPI). Attribute [DllImport("user32.dll")]

посмотрели 30789 раз

обновлено: 21 June 2023

CLR (Common Language Runtime) is a common language runtime.

Program code that runs under CLR is called managed code (managed code).

Code that runs outside of the CLR runtime is called unmanaged code (unmanaged code).
Examples of unmanaged code are Win32 API functions, COM components, and ActiveX interfaces.

Despite the large number of .NET Framework classes that contain many methods, the programmer still sometimes has to resort to unmanaged code.
It must be noted that the number of calls to unmanaged code decreases with the release of each new version .NET Framework. Microsoft hopes that there will come a time when all code can be made manageable and secure. But for now, the reality is that we can't do without Windows API function calls.

Example (call function Windows WinAPI)

C# Creating a new C# console application ... and write the code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// Include the DllImport attribute
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
     class Program
     {
          // Import the library user32.dll (contains WinAPI function MessageBox)
          [DllImport("user32.dll")]
          public static extern int MessageBox(IntPtr hWnd, String text, String caption, int options); // declare the method to C#

          static void Main(string[] args)
          {
               // Call MessageBox (the function Windows WinAPI will be called)
               MessageBox(IntPtr.Zero, "Hello!", "My Message", 0);
          }
     }
}

Example result

Description

Managed code .NET Framework can call an unmanaged function from the file dll (function Windows API) using a special mechanism Platform Invoke (abbr. P/Invoke).

In order to access any unmanaged library DLL, you must convert .NET objects into sets of struct, char* and function pointers, as required by the C language.

As programmers would say in their jargon, you need to marshal parameters. You can read about C# marshaling in the documentation ...

To call a DLL- function from C#, it must first be declared.
To do this, use the DllImport attribute

Sometimes in the examples you can also find this method (long and inconvenient): [System.Runtime.InteropServices.DllImport("User32.Dll")]
this is not for everyone.

The DllImport attribute tells the compiler where the entry point is, which allows the function to be called from the right place.

You should always use the IntPtr type for HWND, HMENU, and any other specifiers.

For LPCTSTR, use String, and interop services (interop services) will automatically marshally System.String to LPCTSTR before passing to Windows. The compiler looks for the above function SetWindowText in the file User32.dll and automatically converts your string to LPTSTR (TCHAR*) before calling it.

Each type in C# has its own type to be used in marshaling by default (default marshaling type). For strings, this is LPTSTR.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// Include the DllImport attribute
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
     class Program
     {
          // Import the library user32.dll (contains WinAPI function MessageBox)
          [DllImport("user32.dll")]
          public static extern void SetWindowText(IntPtr hwnd, String lpString);

          static void Main(string[] args)
          {
               // Call MessageBox (the function Windows WinAPI will be called)
               SetWindowText(IntPtr.Zero, "Hello!");
          }
     }
}

Calling functions Windows API that have an output string parameter char*

Suppose we need to call the function GetWindowText, which has a string output parameter char*. By default, LPTSTR is used for strings, but if we use System.String, as mentioned above, nothing will happen, since the System.String class does not allow you to modify the string. You need to use the StringBuilder class, which allows you to modify strings.

// for StringBuilder
using System.Text;

[DllImport("user32.dll")]
public static extern int GetWindowText(IntPtr hwnd, StringBuilder buf, int nMaxCount);

The type used for marshashling StringBuilder by default is also LPTSTR, but now GetWindowText can modify your string itself:

StringBuilder sTitleBar = new StringBuilder(255);
GetWindowText(this.Handle, sTitleBar, sTitleBar.Capacity);
MessageBox.Show(sTitleBar.ToString());

Thus, the answer to the question of how to call a function that has an output string parameter is to use the StringBuilder class.

To change the default marshaling type

For example, we want to call the function GetClassName, which takes the parameter LPSTR (char*) even in Unicode-версиях.
If you pass a string, the common language runtime (CLR) converts it to the TCHAR series. However, you can use the MarshalAs attribute to override what is suggested by default:

[DllImport("user32.dll")]
public static extern int GetClassName(IntPtr hwnd, [MarshalAs(UnmanagedType.LPStr)] StringBuilder buf, int nMaxCount);

Now, when you call GetClassName, .NET will pass your string as ANSI characters instead of "wide characters".

Calling functions that require struct

Take, for example, the GetWindowRect function, which writes the screen coordinates of a window to the RECT structure. To call the function GetWindowRect and pass it the structure RECT, you need to use the type struct in combination with the attribute StructLayout

[StructLayout(LayoutKind.Sequential)]
public struct RECT
{
     public int left;
     public int top;
     public int right;
     public int bottom;
}

[DllImport("user32.dll")]
public static extern int GetWindowRect(IntPtr hwnd, ref RECT rc);

It is important to use C# ref so that CLR passes a parameter of type RECT as a reference. In this case, the function will be able to modify your object, rather than its unnamed copy in the stack.
After such a function declaration, you can call it in the code:

int w, h;
RECT rc = new RECT();
GetWindowRect(this.Handle, ref rc);
w = rc.right - rc.left;
h = rc.bottom - rc.top;
MessageBox.Show("Mold width: " + w + "\n\rMold height: " + h);

Note that ref is used in both the declaration and the function call. The default type used for marshaling types struct is LPStruct by default, so there is no need for the MarshalAs attribute. But if you want to use RECT as a class rather than struct, you need to implement a wrapper:

// If RECT is a class, not a structure (struct)
[DllImport("user32.dll")]
public static extern int GetWindowRect(IntPtr hwnd, [MarshalAs(UnmanagedType.LPStruct)] RECT rc);

Working with callback functions in C#

To use functions written in C# as Windows callback functions, you need to use: delegate

delegate bool EnumWindowsCB(int hwnd, int lparam);

After declaring your delegate type, you can write a wrapper for the Windows API function:

[DllImport("user32")]
public static extern int EnumWindows(EnumWindowsCB cb, int lparam);

Since the line with delegate simply declares the delegate type (delegate type), the delegate itself must be provided in the class:

public static bool MyEWP(int hwnd, int lparam)
{
// Doing something here
return true;
}

And then we transfer:

EnumWindowsCB cb = new EnumWindowsCB(MyEWP);
Win32.EnumWindows(cb, 0);

Astute readers will notice that I kept silent about the problem with lparam.

In C++ language, if LPARAM is given in EnumWindows, Windows will notify your callback function with this LPARAM. Usually, lparam is a pointer to some structure or class that contains the context information you need to perform your operations.

But remember: In .NET the word pointer cannot be pronounced! So what to do? You can declare your lparam as IntPtr and use GCHandle as its wrapper:

// lparam — this is type IntPtr
delegate bool EnumWindowsCB(int hwnd, IntPtr lparam);

// Place the object in the shell GCHandle
MyClass obj = new MyClass();
GCHandle gch = GCHandle.Alloc(obj);
EnumWindowsCB cb = new EnumWindowsCB(MyEWP);
Win32.EnumWindows(cb, (IntPtr)gch);
gch.Free();

Don't forget to call Free when you're done!
Sometimes in C# you have to free the memory yourself. To access pointer lparam inside an enumerator, use GCHandle.Target

public static bool MyEWP(int hwnd, IntPtr param)
{
     GCHandle gch = (GCHandle)param;
     MyClass c = (MyClass)gch.Target;

     // ... Use
     return true;
}

Below is a class I wrote that encapsulates EnumWindows in an array.
Instead of fiddling with all those delegates and callbacks, you write:

WindowArray wins = new WindowArray();
foreach (int hwnd in wins)
{
// doing something here...
}

C# File ListWin.cs

// WinArray generates ArrayList top-level windows using EnumWindows

using System;
using System.Collections;
using System.Runtime.InteropServices;

namespace WinArray
{
     public class WindowArray : ArrayList
     {
          private delegate bool EnumWindowsCB(int hwnd, IntPtr param);

          // Declared as private because only I need it
          [DllImport("user32")]
          private static extern int EnumWindows(EnumWindowsCB cb,
          IntPtr param);

          private static bool MyEnumWindowsCB(int hwnd, IntPtr param)
          {
               GCHandle gch = (GCHandle)param;
               WindowArray itw = (WindowArray)gch.Target;
               itw.Add(hwnd);
               return true;
          }

          // This is the only public (public) method.
          // Only you need to call him.
          public WindowArray()
          {
               GCHandle gch = GCHandle.Alloc(this);
               EnumWindowsCB ewcb = new EnumWindowsCB(MyEnumWindowsCB);
               EnumWindows(ewcb, (IntPtr)gch);
               gch.Free();
          }
     }
}

A small program ListWin (Appendix ListWin.cs), for enumerating top-level windows, allows you to view lists of HWND, class names, titles, and window rectangles using RECT or Rectangle.