C#

private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)<br />
		{<br />
			if (serverThread != null)<br />
				serverThread.Abort();<br />
			if (clientThread != null)<br />
				clientThread.Abort();<br />
			if (receiveRoutineThread != null)<br />
				receiveRoutineThread.Abort();<br />
		}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            /// This is the Delphi code
            //function ListDLLExports(const FileName: string): TStringList;
            //type
            //  TDWordArray = array [0..$FFFFF] of DWORD;
            //var
            //  imageinfo: LoadedImage;
            //  pExportDirectory: PImageExportDirectory;
            //  dirsize: Cardinal;
            //  pDummy: PImageSectionHeader;
            //  i: Cardinal;
            //  pNameRVAs: ^TDWordArray;
            //  Name: string;
            //begin
            //  {$Warnings Off}
            //  Result := TStringList.Create;
            //  if MapAndLoad(PAnsiChar(FileName), nil, @imageinfo, True, True) then begin
            //    try
            //      pExportDirectory := ImageDirectoryEntryToData(imageinfo.MappedAddress, False, IMAGE_DIRECTORY_ENTRY_EXPORT, dirsize);

            //      if (pExportDirectory <> nil) then begin
            //        pNameRVAs := ImageRvaToVa(imageinfo.FileHeader, imageinfo.MappedAddress, DWORD(pExportDirectory^.AddressOfNames), pDummy);

            //        for i := 0 to pExportDirectory^.NumberOfNames - 1 do begin
            //          Name := PChar(ImageRvaToVa(imageinfo.FileHeader, imageinfo.MappedAddress, pNameRVAs^[i], pDummy));
            //          Result.Add(Name);
            //        end;
            //      end;
            //    finally
            //      UnMapAndLoad(@imageinfo);
            //    end;
            //  end;
            //  {$Warnings ON}
            //end;

            pInvoke.LOADED_IMAGE loadedImage = new pInvoke.LOADED_IMAGE();

            try
            {
                if (pInvoke.MapAndLoad("advapi32.dll", null, ref loadedImage, true, true))
                {
                    int dirSize = 0;
                    IntPtr pImageExportDirectory = pInvoke.ImageDirectoryEntryToData(loadedImage.MappedAddress, false, pInvoke.IMAGE_DIRECTORY_ENTRY_EXPORT, ref dirSize);
                    pInvoke.IMAGE_EXPORT_DIRECTORY imageExportDirectory = (pInvoke.IMAGE_EXPORT_DIRECTORY)Marshal.PtrToStructure(pImageExportDirectory, typeof(pInvoke.IMAGE_EXPORT_DIRECTORY));
                    pInvoke.IMAGE_SECTION_HEADER imageSectionHeader = new pInvoke.IMAGE_SECTION_HEADER();
                    IntPtr virtualAddressOfMappedFile = pInvoke.ImageRvaToVa(ref loadedImage.FileHeader, loadedImage.MappedAddress, imageExportDirectory.AddressOfNames, ref imageSectionHeader);

                    for (int i = 0; i < imageExportDirectory.NumberOfNames; i++)
                    {
                        /// 1. The variable Name should be of type string
                        /// 2. The variable virtualAddressOfMappedFile should be and Int[]
                        IntPtr Name = pInvoke.ImageRvaToVa(ref loadedImage.FileHeader, loadedImage.MappedAddress, virtualAddressOfMappedFile.ToInt32(), ref imageSectionHeader);

                        Console.WriteLine(Name);
                    }

                    pInvoke.UnMapAndLoad(ref loadedImage);
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.Message);
                pInvoke.UnMapAndLoad(ref loadedImage);
            }
            finally
            {
                Console.ReadLine();
            }
        }
    }

    public class pInvoke
    {
        public const int IMAGE_SIZEOF_SHORT_NAME = 8;
        public const int IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
        public const ushort IMAGE_DIRECTORY_ENTRY_EXPORT = 0;

        [DllImport("Imagehlp.dll")]
        public static extern bool MapAndLoad(string ImageName, string DllPath, ref LOADED_IMAGE LoadedImage, bool DotDll, bool ReadOnly);
        [DllImport("ImageHlp.dll")]
        public static extern bool UnMapAndLoad(ref LOADED_IMAGE LoadedImage);
        [DllImport("Dbghelp.dll")]
        public static extern IntPtr ImageDirectoryEntryToData(IntPtr Base, bool MappedAsImage, ushort DirectoryEntry, ref int Size);
        [DllImport("Dbghelp.dll")]
        public static extern IntPtr ImageRvaToVa(ref IMAGE_NT_HEADERS NtHeaders, IntPtr Base, int Rva, ref IMAGE_SECTION_HEADER LastRvaSection);

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct LOADED_IMAGE
        {
            public string ModuleName;
            public IntPtr hFile;
            public IntPtr MappedAddress;
            public IMAGE_NT_HEADERS FileHeader;
            public IMAGE_SECTION_HEADER LastRvaSection;
            public int NumberOfSections;
            public IMAGE_SECTION_HEADER Sections;
            public int Characteristics;
            public bool fSystemImage;
            public bool fDOSImage;
            public LIST_ENTRY Links;
            public int SizeOfImage;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct IMAGE_EXPORT_DIRECTORY
        {
            public int Characteristics;
            public int TimeDateStamp;
            public short MajorVersion;
            public short MinorVersion;
            public int Name;
            public int Base;
            public int NumberOfFunctions;
            public int NumberOfNames;
            public int AddressOfFunctions;
            public int AddressOfNames;
            public int AddressOfOrdinals;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct IMAGE_NT_HEADERS
        {
            /// DWORD Signature;  
            public int Signature;
            /// IMAGE_FILE_HEADER FileHeader;  
            public IMAGE_FILE_HEADER FileHeader;
            /// IMAGE_OPTIONAL_HEADER OptionalHeader;
            public IMAGE_OPTIONAL_HEADER OptionalHeader;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct LIST_ENTRY
        {
            /// struct _LIST_ENTRY *Flink;
            public IntPtr Flink;
            /// struct _LIST_ENTRY *Blink;
            public IntPtr Blink;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct IMAGE_SECTION_HEADER
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = IMAGE_SIZEOF_SHORT_NAME)]
            public byte[] Name;
            //union 
            //{    
            //    DWORD PhysicalAddress;    
            //    DWORD VirtualSize;  
            //} Misc;  
            public uint PhysicalAddress;
            //public uint VirtualSize;
            public uint VirtualAddress;
            public uint SizeOfRawData;
            public uint PointerToRawData;
            public uint PointerToRelocations;
            public uint PointerToLinenumbers;
            public short NumberOfRelocations;
            public short NumberOfLinenumbers;
            public uint Characteristics;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct IMAGE_FILE_HEADER
        {
            /// WORD Machine;  
            public ushort Machine;
            /// WORD NumberOfSections;  
            public ushort NumberOfSections;
            /// DWORD TimeDateStamp;  
            public uint TimeDateStamp;
            /// DWORD PointerToSymbolTable;  
            public uint PointerToSymbolTable;
            /// DWORD NumberOfSymbols;  
            public uint NumberOfSymbols;
            /// WORD SizeOfOptionalHeader;  
            public ushort SizeOfOptionalHeader;
            /// WORD Characteristics;
            public ushort Characteristics;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct IMAGE_OPTIONAL_HEADER
        {
            /// WORD Magic;  
            public ushort Magic;
            /// BYTE MajorLinkerVersion;  
            public byte MajorLinkerVersion;
            /// BYTE MinorLinkerVersion;  
            public byte MinorLinkerVersion;
            /// DWORD SizeOfCode;  
            public uint SizeOfCode;
            /// DWORD SizeOfInitializedData;  
            public uint SizeOfInitializedData;
            /// DWORD SizeOfUninitializedData;  
            public uint SizeOfUninitializedData;
            /// DWORD AddressOfEntryPoint;  
            public uint AddressOfEntryPoint;
            /// DWORD BaseOfCode;  
            public uint BaseOfCode;
            /// DWORD BaseOfData;  
            public uint BaseOfData;
            /// DWORD ImageBase;  
            public uint ImageBase;
            /// DWORD SectionAlignment;  
            public uint SectionAlignment;
            /// DWORD FileAlignment;  
            public uint FileAlignment;
            /// WORD MajorOperatingSystemVersion;  
            public ushort MajorOperatingSystemVersion;
            /// WORD MinorOperatingSystemVersion;  
            public ushort MinorOperatingSystemVersion;
            /// WORD MajorImageVersion;  
            public ushort MajorImageVersion;
            /// WORD MinorImageVersion;  
            public ushort MinorImageVersion;
            /// WORD MajorSubsystemVersion;  
            public ushort MajorSubsystemVersion;
            /// WORD MinorSubsystemVersion;  
            public ushort MinorSubsystemVersion;
            /// DWORD Win32VersionValue;  
            public uint Win32VersionValue;
            /// DWORD SizeOfImage;  
            public uint SizeOfImage;
            /// DWORD SizeOfHeaders;  
            public uint SizeOfHeaders;
            /// DWORD CheckSum;  
            public uint CheckSum;
            /// WORD Subsystem;  
            public ushort Subsystem;
            /// WORD DllCharacteristics;  
            public ushort DllCharacteristics;
            /// DWORD SizeOfStackReserve;  
            public uint SizeOfStackReserve;
            /// DWORD SizeOfStackCommit;  
            public uint SizeOfStackCommit;
            /// DWORD SizeOfHeapReserve;  
            public uint SizeOfHeapReserve;
            /// DWORD SizeOfHeapCommit;  
            public uint SizeOfHeapCommit;
            /// DWORD LoaderFlags;  
            public uint LoaderFlags;
            /// DWORD NumberOfRvaAndSizes;  
            public uint NumberOfRvaAndSizes;
            /// IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = IMAGE_NUMBEROF_DIRECTORY_ENTRIES)]
            public IMAGE_DATA_DIRECTORY[] DataDirectory;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        public struct IMAGE_DATA_DIRECTORY
        {
            /// DWORD VirtualAddress;
            public uint VirtualAddress;
            /// DWORD Size;
            public uint Size;
        }
    }
}