Merge pull request #622 from Juknum/master

Fix IEnumExplorerCommand.Next implementation

Author: dahall

Core/Collections/IEnumFromCom.cs

@@ -1,6 +1,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
 using Vanara.PInvoke;
 
 namespace Vanara.Collections;
@@ -45,8 +46,9 @@ public interface ICOMEnum<TElem>
 }
 
 /// <summary>
-/// Creates an enumerable class from a get next method in the form of HRESULT Next(uint, TItem[], out uint) and a reset method. Useful
-/// if a class doesn't support <see cref="IEnumerable"/> or <see cref="IEnumerable{T}"/> like some COM objects.
+/// Creates an enumerable class from a get next method and a reset method. Useful if a class doesn't support <see cref="IEnumerable"/>
+/// or <see cref="IEnumerable{T}"/> like some COM objects. The reflected Next method can expose its fetched-count parameter either as
+/// out uint or as IntPtr.
 /// </summary>
 /// <typeparam name="TItem">The type of the item.</typeparam>
 public class IEnumFromCom<TItem> : IEnumFromNext<TItem>
@@ -104,18 +106,40 @@ private bool TryGet([NotNullWhen(true)] out TItem? item)
 		return true;
 	}
 
-	private class ComEnumWrapper<T>(T o) where T : class, ICOMEnum<TItem>
+	private class ComEnumWrapper<T> where T : class, ICOMEnum<TItem>
 	{
-		private readonly T obj = o;
+		private readonly T obj;
+		private readonly bool nextUsesIntPtr;
+
+		public ComEnumWrapper(T o)
+		{
+			obj = o;
+			var nextMethod = typeof(T).GetMethod("Next") ?? throw new MissingMethodException(typeof(T).FullName, "Next");
+			var nextParams = nextMethod.GetParameters();
+			nextUsesIntPtr = nextParams.Length > 2 && nextParams[2].ParameterType == typeof(IntPtr);
+		}
 
 		public void ComObjReset() => ComInvoke("Reset");
 
 		public HRESULT ComObjTryGetNext(uint celt, TItem?[] rgelt, out uint celtFetched)
 		{
-			var para = new object[] { celt, rgelt, 0U };
-			var hr = (HRESULT?)ComInvoke("Next", para);
-			celtFetched = (uint)para[2];
-			return hr ?? HRESULT.S_OK;
+			IntPtr fetchedPtr = IntPtr.Zero;
+			try
+			{
+				var para = nextUsesIntPtr
+					? new object[] { celt, rgelt, fetchedPtr = Marshal.AllocHGlobal(sizeof(uint)) }
+					: new object[] { celt, rgelt, 0U };
+				if (fetchedPtr != IntPtr.Zero)
+					Marshal.WriteInt32(fetchedPtr, 0);
+				var hr = (HRESULT?)ComInvoke("Next", para);
+				celtFetched = nextUsesIntPtr ? unchecked((uint)Marshal.ReadInt32(fetchedPtr)) : (uint)para[2];
+				return hr ?? HRESULT.S_OK;
+			}
+			finally
+			{
+				if (fetchedPtr != IntPtr.Zero)
+					Marshal.FreeHGlobal(fetchedPtr);
+			}
 		}
 
 		private object? ComInvoke(string meth, object[]? p = null) => typeof(T).GetMethod(meth)?.Invoke(obj, p);

PInvoke/Shell32/ShObjIdl.IExplorerCommand.cs

@@ -100,7 +100,7 @@ public interface IEnumExplorerCommand : Vanara.Collections.ICOMEnum<IExplorerCom
 		/// <para>Type: <c>ULONG*</c></para>
 		/// <para>
 		/// When this method returns, contains a pointer to the number of elements actually retrieved. This pointer can be <c>NULL</c>
-		/// if this information is not needed.
+		/// if this information is not needed. In managed code, this optional pointer is represented by <see cref="IntPtr"/>.
 		/// </para>
 		/// </param>
 		/// <returns>
@@ -110,7 +110,7 @@ public interface IEnumExplorerCommand : Vanara.Collections.ICOMEnum<IExplorerCom
 		// https://docs.microsoft.com/en-us/windows/win32/api/shobjidl_core/nf-shobjidl_core-ienumexplorercommand-next HRESULT Next(
 		// ULONG celt, IExplorerCommand **pUICommand, ULONG *pceltFetched );
 		[PreserveSig]
-		HRESULT Next([In] uint celt, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Interface, SizeParamIndex = 0)] IExplorerCommand[] pUICommand, out uint pceltFetched);
+		HRESULT Next([In] uint celt, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Interface, SizeParamIndex = 0)] IExplorerCommand[] pUICommand, IntPtr pceltFetched);
 
 		/// <summary>Not currently implemented.</summary>
 		/// <param name="celt">

UnitTests/PInvoke/Shell32/IShellFolderTests.cs

@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using System.Linq;
+using System.Runtime.InteropServices;
 using Vanara.Collections;
 using static Vanara.PInvoke.PropSys;
 using static Vanara.PInvoke.Shell32;
@@ -50,6 +51,15 @@ public void EnumSearchesTest()
 
 	}
 
+	[Test]
+	public void EnumFromComIntPtrFetchedCountTest()
+	{
+		var enumObj = new IntPtrEnum();
+		var values = IEnumFromCom<int>.Create<IIntPtrEnum>(enumObj).ToArray();
+
+		Assert.That(values, Is.EqualTo(new[] { 1, 2 }));
+	}
+
 	[Test]
 	public void Issue530Test()
 	{
@@ -78,4 +88,31 @@ public void Issue581Test()
 		Assert.That(pFolder!.ParseDisplayName(default, default, System.IO.Path.GetFileName(TestCaseSources.WordDoc), out _, out var ppidl, ref attr), ResultIs.Successful);
 		Assert.That(ppidl, ResultIs.ValidHandle);
 	}
+
+	private interface IIntPtrEnum : ICOMEnum<int>
+	{
+		HRESULT Next(uint celt, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] int[] rgelt, IntPtr pceltFetched);
+
+		void Reset();
+	}
+
+	private sealed class IntPtrEnum : IIntPtrEnum
+	{
+		private readonly int[] values = [1, 2];
+		private int index;
+
+		public HRESULT Next(uint celt, int[] rgelt, IntPtr pceltFetched)
+		{
+			var fetched = 0;
+			while (fetched < celt && index < values.Length)
+				rgelt[fetched++] = values[index++];
+
+			if (pceltFetched != IntPtr.Zero)
+				Marshal.WriteInt32(pceltFetched, fetched);
+
+			return fetched == celt ? HRESULT.S_OK : HRESULT.S_FALSE;
+		}
+
+		public void Reset() => index = 0;
+	}
 }