1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Runtime.InteropServices;
using System.Text;
// Name of namespace matches the name of the assembly on purpose to
// ensure that we can handle this (mostly an issue for C++ code generation).
namespace PInvoke
{
internal class Program
{
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
private static extern int Square(int intValue);
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
private static extern int IsTrue(bool boolValue);
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
private static extern int CheckIncremental(int[] array, int sz);
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
private static extern int Inc(ref int value);
[DllImport("*", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi)]
private static extern int VerifyAnsiString(string str);
[DllImport("*", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
private static extern int VerifyUnicodeString(string str);
[DllImport("*", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
private static extern int VerifyStringBuilder(StringBuilder sb);
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
public static extern bool SafeHandleTest(SafeMemoryHandle sh1, Int64 sh1Value);
[DllImport("*", CallingConvention = CallingConvention.StdCall, SetLastError = true)]
public static extern bool LastErrorTest();
public static int Main(string[] args)
{
TestBlittableType();
TestBoolean();
TestArrays();
TestByRef();
TestString();
TestLastError();
TestSafeHandle();
return 100;
}
public static void ThrowIfNotEquals<T>(T expected, T actual, string message)
{
if (!Object.Equals(expected, actual))
{
message += "\nExpected: " + expected + "\n";
message += "Actual: " + actual + "\n";
throw new Exception(message);
}
}
private static void TestBlittableType()
{
Console.WriteLine("Testing marshalling blittable types");
ThrowIfNotEquals(100, Square(10), "Int marshalling failed");
}
private static void TestBoolean()
{
Console.WriteLine("Testing marshalling boolean");
ThrowIfNotEquals(1, IsTrue(true), "Bool marshalling failed");
ThrowIfNotEquals(0, IsTrue(false), "Bool marshalling failed");
}
private static void TestArrays()
{
Console.WriteLine("Testing marshalling arrays");
const int ArraySize = 100;
int[] arr = new int[ArraySize];
for (int i = 0; i < ArraySize; i++)
arr[i] = i;
ThrowIfNotEquals(0, CheckIncremental(arr, ArraySize), "Array marshalling failed");
}
private static void TestByRef()
{
Console.WriteLine("Testing marshalling by ref");
int value = 100;
ThrowIfNotEquals(0, Inc(ref value), "By ref marshalling failed");
ThrowIfNotEquals(101, value, "By ref marshalling failed");
}
private static void TestString()
{
Console.WriteLine("Testing marshalling string");
ThrowIfNotEquals(1, VerifyAnsiString("Hello World"), "Ansi String marshalling failed.");
ThrowIfNotEquals(1, VerifyUnicodeString("Hello World"), "Unicode String marshalling failed.");
}
private static void TestLastError()
{
Console.WriteLine("Testing last error");
ThrowIfNotEquals(true, LastErrorTest(), "GetLastWin32Error is not zero");
ThrowIfNotEquals(12345, Marshal.GetLastWin32Error(), "Last Error test failed");
}
private static void TestSafeHandle()
{
Console.WriteLine("Testing marshalling SafeHandle");
SafeMemoryHandle hnd = SafeMemoryHandle.AllocateMemory(1000);
IntPtr hndIntPtr = hnd.DangerousGetHandle(); //get the IntPtr associated with hnd
long val = hndIntPtr.ToInt64(); //return the 64-bit value associated with hnd
ThrowIfNotEquals(true, SafeHandleTest(hnd, val), "SafeHandle marshalling failed.");
}
}
public class SafeMemoryHandle : SafeHandle //SafeHandle subclass
{
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
public static extern SafeMemoryHandle AllocateMemory(int size);
[DllImport("*", CallingConvention = CallingConvention.StdCall)]
public static extern bool ReleaseMemory(IntPtr handle);
public SafeMemoryHandle()
: base(IntPtr.Zero, true)
{
}
private static readonly IntPtr _invalidHandleValue = new IntPtr(-1);
public override bool IsInvalid
{
get { return handle == IntPtr.Zero || handle == _invalidHandleValue; }
}
override protected bool ReleaseHandle()
{
return ReleaseMemory(handle);
}
} //end of SafeMemoryHandle class
}
|
