tests/src/Interop/PInvoke/Array/MarshalArrayAsField/AsLPArray/FldDef_LPArray.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System;
   6 using System.Runtime.InteropServices;
   7
   8 #region Sequential
   9 #region sequential stuct definition
  10 [StructLayout(LayoutKind.Sequential)]
  11 public struct S_INTArray_Seq
  12 {
  13     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  14     public int[] arr;
  15 }
  16
  17 [StructLayout(LayoutKind.Sequential)]
  18 public struct S_UINTArray_Seq
  19 {
  20     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  21     public uint[] arr;
  22 }
  23
  24 [StructLayout(LayoutKind.Sequential)]
  25 public struct S_SHORTArray_Seq
  26 {
  27     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  28     public short[] arr;
  29 }
  30
  31 [StructLayout(LayoutKind.Sequential)]
  32 public struct S_WORDArray_Seq
  33 {
  34     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  35     public ushort[] arr;
  36 }
  37
  38 [StructLayout(LayoutKind.Sequential)]
  39 public struct S_LONG64Array_Seq
  40 {
  41     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  42     public long[] arr;
  43 }
  44
  45 [StructLayout(LayoutKind.Sequential)]
  46 public struct S_ULONG64Array_Seq
  47 {
  48     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  49     public ulong[] arr;
  50 }
  51
  52 [StructLayout(LayoutKind.Sequential)]
  53 public struct S_DOUBLEArray_Seq
  54 {
  55     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  56     public double[] arr;
  57 }
  58
  59 [StructLayout(LayoutKind.Sequential)]
  60 public struct S_FLOATArray_Seq
  61 {
  62     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  63     public float[] arr;
  64 }
  65
  66 [StructLayout(LayoutKind.Sequential)]
  67 public struct S_BYTEArray_Seq
  68 {
  69     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  70     public byte[] arr;
  71 }
  72
  73 [StructLayout(LayoutKind.Sequential)]
  74 public struct S_CHARArray_Seq
  75 {
  76     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  77     public char[] arr;
  78 }
  79
  80 [StructLayout(LayoutKind.Sequential)]
  81 public struct S_LPSTRArray_Seq
  82 {
  83     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  84     public string[] arr;
  85 }
  86
  87 [StructLayout(LayoutKind.Sequential)]
  88 public struct S_LPCSTRArray_Seq
  89 {
  90     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
  91     public string[] arr;
  92 }
  93
  94 [StructLayout(LayoutKind.Sequential)]
  95 public struct S_BSTRArray_Seq
  96 {
  97     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE, ArraySubType = UnmanagedType.BStr)]
  98     public string[] arr;
  99 }
 100
 101 //struct array in a struct
 102 [StructLayout(LayoutKind.Sequential)]
 103 public struct TestStruct
 104 {
 105     public int x;
 106     public double d;
 107     public long l;
 108     public string str;
 109 }
 110
 111 [StructLayout(LayoutKind.Sequential)]
 112 public struct S_StructArray_Seq
 113 {
 114     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 115     public TestStruct[] arr;
 116 }
 117
 118 [StructLayout(LayoutKind.Sequential)]
 119 public struct S_BOOLArray_Seq
 120 {
 121     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 122     public bool[] arr;
 123 }
 124 #endregion
 125
 126 #region sequential class definition
 127 [StructLayout(LayoutKind.Sequential)]
 128 public class C_INTArray_Seq
 129 {
 130     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 131     public int[] arr;
 132 }
 133
 134 [StructLayout(LayoutKind.Sequential)]
 135 public class C_UINTArray_Seq
 136 {
 137     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 138     public uint[] arr;
 139 }
 140
 141 [StructLayout(LayoutKind.Sequential)]
 142 public class C_SHORTArray_Seq
 143 {
 144     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 145     public short[] arr;
 146 }
 147
 148 [StructLayout(LayoutKind.Sequential)]
 149 public class C_WORDArray_Seq
 150 {
 151     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 152     public ushort[] arr;
 153 }
 154
 155 [StructLayout(LayoutKind.Sequential)]
 156 public class C_LONG64Array_Seq
 157 {
 158     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 159     public long[] arr;
 160 }
 161
 162 [StructLayout(LayoutKind.Sequential)]
 163 public class C_ULONG64Array_Seq
 164 {
 165     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 166     public ulong[] arr;
 167 }
 168
 169 [StructLayout(LayoutKind.Sequential)]
 170 public class C_DOUBLEArray_Seq
 171 {
 172     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 173     public double[] arr;
 174 }
 175
 176 [StructLayout(LayoutKind.Sequential)]
 177 public class C_FLOATArray_Seq
 178 {
 179     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 180     public float[] arr;
 181 }
 182
 183 [StructLayout(LayoutKind.Sequential)]
 184 public class C_BYTEArray_Seq
 185 {
 186     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 187     public byte[] arr;
 188 }
 189
 190 [StructLayout(LayoutKind.Sequential)]
 191 public class C_CHARArray_Seq
 192 {
 193     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 194     public char[] arr;
 195 }
 196
 197 [StructLayout(LayoutKind.Sequential)]
 198 public class C_LPSTRArray_Seq
 199 {
 200     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 201     public string[] arr;
 202 }
 203
 204 [StructLayout(LayoutKind.Sequential)]
 205 public class C_LPCSTRArray_Seq
 206 {
 207     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 208     public string[] arr;
 209 }
 210
 211 [StructLayout(LayoutKind.Sequential)]
 212 public class C_BSTRArray_Seq
 213 {
 214     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE, ArraySubType = UnmanagedType.BStr)]
 215     public string[] arr;
 216 }
 217
 218 //struct array in a class
 219 [StructLayout(LayoutKind.Sequential)]
 220 public class C_StructArray_Seq
 221 {
 222     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 223     public TestStruct[] arr;
 224 }
 225
 226 [StructLayout(LayoutKind.Sequential)]
 227 public class C_BOOLArray_Seq
 228 {
 229     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 230     public bool[] arr;
 231 }
 232 #endregion
 233 #endregion
 234
 235 #region Explicit
 236
 237 #region explicit stuct definition
 238 [StructLayout(LayoutKind.Explicit)]
 239 public struct S_INTArray_Exp
 240 {
 241     [FieldOffset(0)]
 242     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 243     public int[] arr;
 244 }
 245
 246 [StructLayout(LayoutKind.Explicit)]
 247 public struct S_UINTArray_Exp
 248 {
 249     [FieldOffset(0)]
 250     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 251     public uint[] arr;
 252 }
 253
 254 [StructLayout(LayoutKind.Explicit)]
 255 public struct S_SHORTArray_Exp
 256 {
 257     [FieldOffset(0)]
 258     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 259     public short[] arr;
 260 }
 261
 262 [StructLayout(LayoutKind.Explicit)]
 263 public struct S_WORDArray_Exp
 264 {
 265     [FieldOffset(0)]
 266     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 267     public ushort[] arr;
 268 }
 269
 270 [StructLayout(LayoutKind.Explicit)]
 271 public struct S_LONG64Array_Exp
 272 {
 273     [FieldOffset(0)]
 274     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE, ArraySubType = UnmanagedType.I8)]
 275     public long[] arr;
 276 }
 277
 278 [StructLayout(LayoutKind.Explicit)]
 279 public struct S_ULONG64Array_Exp
 280 {
 281     [FieldOffset(0)]
 282     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 283     public ulong[] arr;
 284 }
 285
 286 [StructLayout(LayoutKind.Explicit)]
 287 public struct S_DOUBLEArray_Exp
 288 {
 289     [FieldOffset(0)]
 290     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 291     public double[] arr;
 292 }
 293
 294 [StructLayout(LayoutKind.Explicit)]
 295 public struct S_FLOATArray_Exp
 296 {
 297     [FieldOffset(0)]
 298     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 299     public float[] arr;
 300 }
 301
 302 [StructLayout(LayoutKind.Explicit)]
 303 public struct S_BYTEArray_Exp
 304 {
 305     [FieldOffset(0)]
 306     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 307     public byte[] arr;
 308 }
 309
 310 [StructLayout(LayoutKind.Explicit)]
 311 public struct S_CHARArray_Exp
 312 {
 313     [FieldOffset(0)]
 314     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 315     public char[] arr;
 316 }
 317
 318 [StructLayout(LayoutKind.Explicit)]
 319 public struct S_LPSTRArray_Exp
 320 {
 321     [FieldOffset(0)]
 322     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 323     public string[] arr;
 324 }
 325
 326 [StructLayout(LayoutKind.Explicit)]
 327 public struct S_LPCSTRArray_Exp
 328 {
 329     [FieldOffset(0)]
 330     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 331     public string[] arr;
 332 }
 333
 334 [StructLayout(LayoutKind.Explicit)]
 335 public struct S_BSTRArray_Exp
 336 {
 337     [FieldOffset(0)]
 338     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE, ArraySubType = UnmanagedType.BStr)]
 339     public string[] arr;
 340 }
 341
 342 //struct array in a struct
 343 [StructLayout(LayoutKind.Explicit)]
 344 public struct S_StructArray_Exp
 345 {
 346     [FieldOffset(0)]
 347     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 348     public TestStruct[] arr;
 349 }
 350
 351 [StructLayout(LayoutKind.Explicit)]
 352 public struct S_BOOLArray_Exp
 353 {
 354     [FieldOffset(0)]
 355     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 356     public bool[] arr;
 357 }
 358 #endregion
 359
 360 #region explicit class definition
 361 [StructLayout(LayoutKind.Explicit)]
 362 public class C_INTArray_Exp
 363 {
 364     [FieldOffset(0)]
 365     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 366     public int[] arr;
 367 }
 368
 369 [StructLayout(LayoutKind.Explicit)]
 370 public class C_UINTArray_Exp
 371 {
 372     [FieldOffset(0)]
 373     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 374     public uint[] arr;
 375 }
 376
 377 [StructLayout(LayoutKind.Explicit)]
 378 public class C_SHORTArray_Exp
 379 {
 380     [FieldOffset(0)]
 381     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 382     public short[] arr;
 383 }
 384
 385 [StructLayout(LayoutKind.Explicit)]
 386 public class C_WORDArray_Exp
 387 {
 388     [FieldOffset(0)]
 389     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 390     public ushort[] arr;
 391 }
 392
 393 [StructLayout(LayoutKind.Explicit, Pack = 8)]
 394 public class C_LONG64Array_Exp
 395 {
 396     [FieldOffset(0)]
 397     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 398     public long[] arr;
 399 }
 400
 401 [StructLayout(LayoutKind.Explicit)]
 402 public class C_ULONG64Array_Exp
 403 {
 404     [FieldOffset(0)]
 405     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 406     public ulong[] arr;
 407 }
 408
 409 [StructLayout(LayoutKind.Explicit)]
 410 public class C_DOUBLEArray_Exp
 411 {
 412     [FieldOffset(0)]
 413     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 414     public double[] arr;
 415 }
 416
 417 [StructLayout(LayoutKind.Explicit)]
 418 public class C_FLOATArray_Exp
 419 {
 420     [FieldOffset(0)]
 421     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 422     public float[] arr;
 423 }
 424
 425 [StructLayout(LayoutKind.Explicit)]
 426 public class C_BYTEArray_Exp
 427 {
 428     [FieldOffset(0)]
 429     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 430     public byte[] arr;
 431 }
 432
 433 [StructLayout(LayoutKind.Explicit)]
 434 public class C_CHARArray_Exp
 435 {
 436     [FieldOffset(0)]
 437     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 438     public char[] arr;
 439 }
 440
 441 [StructLayout(LayoutKind.Explicit)]
 442 public class C_LPSTRArray_Exp
 443 {
 444     [FieldOffset(0)]
 445     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 446     public string[] arr;
 447 }
 448
 449 [StructLayout(LayoutKind.Explicit)]
 450 public class C_LPCSTRArray_Exp
 451 {
 452     [FieldOffset(0)]
 453     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 454     public string[] arr;
 455 }
 456
 457 [StructLayout(LayoutKind.Explicit)]
 458 public class C_BSTRArray_Exp
 459 {
 460     [FieldOffset(0)]
 461     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE, ArraySubType = UnmanagedType.BStr)]
 462     public string[] arr;
 463 }
 464
 465 //struct array in a class
 466 [StructLayout(LayoutKind.Explicit)]
 467 public class C_StructArray_Exp
 468 {
 469     [FieldOffset(0)]
 470     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 471     public TestStruct[] arr;
 472 }
 473
 474 [StructLayout(LayoutKind.Explicit)]
 475 public class C_BOOLArray_Exp
 476 {
 477     [FieldOffset(0)]
 478     [MarshalAs(UnmanagedType.LPArray, SizeConst = Test.ARRAY_SIZE)]
 479     public bool[] arr;
 480 }
 481 #endregion
 482
 483 #endregion