Pointers (ArrayList to IntPtr and back)

du kan vel ikke sende en System.Collection.ArrayList til en Win32 API funktion ??

Marshal.ReadIntPtr
Marshal.PtrToStringAnsi
Marshal.Copy
Marshal.StructureToPtr

er nogle af de metoder jeg har brugt på IntPtr

Hej Arne,

Jo, for i forbindelse med EnumChildWindows vil jeg gerne have at den indsætter undervinduer i arraylisten som IntPtr objekter..

Jeg kan forstå at hele idéen med lParam er, at man netop kan sende arrays eller strings som pointers.

Altså vil jeg gerne vide hvordan jeg tager pointeren til Arraylisten og tildeler den som en IntPtr. Og omvendt.

Det kan du opnå ved at lade din ArrayList være et felt på klassen og blot tilføje til denne når callback funktionen kører.

Er det alligevel nødvendigt, skal du bruge et GCHandle (Garbage-Collector Handle), som dels gør at objektet ikke bliver garbage collected og dels at det ikke bliver flyttet fra dens memory plads. Endelig er der en metode, som muliggør at du kan få fat på GCHandle objektet ud fra en IntPtr til det, uden selv at skulle caste. Husk altid at Free() et GCHandle når du er færdig med det.

Jeg poster lige et eksempel:

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

namespace EnumChildrenTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Children to desktop window:");
            List<IntPtr> list = WindowEnumerator.GetChildren(WindowEnumerator.GetDesktopWindow());
            foreach (IntPtr ptr in list)
            {
                Console.WriteLine(ptr);
            }
        }
    }
   
    public class WindowEnumerator
    {
        /// <summary>
        /// Gets the children.
        /// </summary>
        /// <param name="hwndParent">The HWND parent.</param>
        /// <returns></returns>
        public static List<IntPtr> GetChildren(IntPtr hwndParent)
        {
            List<IntPtr> list = new List<IntPtr>();
            GCHandle handle = GCHandle.Alloc(list);
            try
            {
                EnumChildWindows(hwndParent, new EnumWindowProc(EnumWindowCallback), GCHandle.ToIntPtr(handle));
            }
            finally
            {
                if (handle.IsAllocated)
                    handle.Free();
            }
            return list;
        }

        private static bool EnumWindowCallback(IntPtr hwndChild, IntPtr lParam)
        {
            GCHandle handle = GCHandle.FromIntPtr(lParam);
            List<IntPtr> list = handle.Target as List<IntPtr>;
            if (list != null)
                list.Add(hwndChild);
            else
                throw new InvalidCastException("lParam did not point to a List of IntPtr");
            return true;
        }

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool EnumChildWindows(IntPtr hwndParent, EnumWindowProc callback, IntPtr lParam);

        [DllImport("user32.dll")]
        public static extern IntPtr GetDesktopWindow();
       
        [return: MarshalAs(UnmanagedType.Bool)]
        delegate bool EnumWindowProc(IntPtr hwndChild, IntPtr lParam);
       
    }
}

Hvad søren betyder    "List<IntPtr> list = new List<IntPtr>();"

Jeg har i øvrigt set eksemplet du benytter før. Jeg skal bruge NET 1.1, så System.Collections.Generic duer vist ikke :-)

så bruger du jo bare en ArrayList og caster når du henter ud

og når det er et callback til .NET kode, så giver en ArrayList jo pludselig mening

Arne: Ja ikke? :-)

Mener du, at jeg så bare skal skrive:
"ArrayList list = new ArrayList();"    i stedet for "List<IntPtr> list = new List<IntPtr>();"  ?

Jeg har ikke mulighed for at prøve det lige nu, men jeg ville for så vidt også gerne have det andet forklaret hvis muligt.

Ja, du kan blot bruge en ArrayList istedet for den generiske List. Og så selvfølgelig ændre castet i callback funktionen.

Som nævnt, skal jeg altså bruge .NET 1.1 frameworket. Som det ses i følgende, er GCHandle.FromIntPtr() en .NET 2.0 funktion. Andre løsningsforslag?

http://msdn2.microsoft.com/en-US/library/system.runtime.interopservices.gchandle.fromintptr(VS.80).aspx

Nå. Man kan åbenbart bare gøre det explicit, altså:

EnumChildWindows(hwndParent, new EnumWindowProc(EnumWindowCallback), (IntPtr)handle);

og

GCHandle handle = (GCHandle)lParam;


Det ser ud til at virke fint. Kan I dog forklare hvad "List<IntPtr> list = new List<IntPtr>();" går ud på? Altså jeg har ikke set <> brugt i C# før...

Jeg havde ikke lige lagt mærke til at FromIntPtr var 2.0 specifikt; men fint at du fandt en løsning alligevel.

"List" er en af de nye klasser i .NET Framework 2.0. < > er notationen for generics, som er en ny feature i C# 2.0. Populært sagt kan du med generics skrive samme kode der kan arbejde på flere forskellige typer. I eksemplet betyder List<IntPtr>: " en liste der arbejder på IntPtr", og Add metoden tager derfor IntPtr som argument, og indexeren returnerer IntPtr (i stedet for object, som på en arraylist). Dvs. du sparer nogle casts, og listen er typesikker, dvs. du kan være 100% sikker på at listen kun indeholder IntPtr's.

Collections som f.eks. List, er en af de helt oplagte steder at bruge Generics, men det kan også bruges til mange andre formål.

Mere om generics:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnvs05/html/csharp_generics.asp

Andre nye features i 2.0:
http://msdn.microsoft.com/msdnmag/issues/04/05/C20/

eller http://www.eksperten.dk/artikler/694