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.

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.

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.

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

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

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:

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

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

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:

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:

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

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

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

And then we transfer:

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:

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

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

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.