从PC机上并不能直接操作WINCE设备，装上了微软提供的工具包，也只能鼠标操作
在PC端上自己编程中写的．exe 想要操作 可以使用RAPI实现,下面是RAPI封装的一些常用函数
代码如下:
/*======================================================================================= OpenNETCF.Desktop.Communication.RAPI OpenNETCF.Desktop.Communication.RAPIException Copyright ?2003-2006, OpenNETCF.org This library is free software; you can redistribute it and/or modify it under the terms of the OpenNETCF.org Shared Source License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the OpenNETCF.org Shared Source License for more details. You should have received a copy of the OpenNETCF.org Shared Source License along with this library; if not, email [email protected] to request a copy. If you wish to contact the OpenNETCF Advisory Board to discuss licensing, please email [email protected]. For general enquiries, email [email protected] or visit our website at: http://www.opennetcf.org =======================================================================================*/ using System; using System.Runtime.InteropServices; using System.Text; using System.Threading; using System.IO; using System.Collections; namespace OpenNETCF.Desktop.Communication { /// <summary> /// RapiConnectedHandler delegate /// </summary> public delegate void RAPIConnectedHandler(); /// <summary> /// Windows CE Remote API functions /// </summary> public class RAPI : IDisposable { /// <summary> /// Event fired when a connection is made in asynchronous mode /// </summary> public event RAPIConnectedHandler RAPIConnected; /// <summary> /// Event fired when a connection is lost /// </summary> public event RAPIConnectedHandler RAPIDisconnected; private Thread m_initThread; private IntPtr m_hInitEvent = IntPtr.Zero; private int m_InitResult = 0; private bool m_connected = false; private bool m_killThread = false; private bool m_devicepresent = false; private RAPIINIT m_ri; private ActiveSync m_activesync; private int m_timeout = 0; private CFPerformanceMonitor m_perfmon; internal const int ERROR_NO_MORE_FILES = 18; private const short INVALID_HANDLE_VALUE = -1; private const short FILE_ATTRIBUTE_NORMAL = 0x80; /// <summary> /// RAPI object constructor /// </summary> public RAPI() { m_activesync = new ActiveSync(); m_perfmon = new CFPerformanceMonitor(this); m_activesync.Disconnect = new DisconnectHandler(activesync_Disconnect); m_activesync.Active = new ActiveHandler(m_activesync_Active); m_activesync.BeginListen(); } /// <summary> /// Object destructor /// </summary> ~RAPI() { m_activesync.EndListen(); if(m_connected) { CeRapiUninit(); } this.Dispose(); } /// <summary> /// Exposes access to MicroSoft ActiveSync methods and events /// </summary> public ActiveSync ActiveSync { get{ return m_activesync; } } /// <summary> /// Used to get performance statistics for a .NET Compact Framework application on a connected device /// <seealso cref="CFPerformanceMonitor"/><seealso cref="PerformanceStatistics"/> /// </summary> public CFPerformanceMonitor CFPerformanceMonitor { get{ return m_perfmon; } } /// <summary> /// Connects synchronously to the remote device /// </summary> public void Connect() { Connect(true, 0); } /// <summary> /// Connect asynchronously to the remote device with a timeout of 0 seconds /// </summary> /// <param name="WaitForInit">If true the method blocks until RAPI Initializes or throws an error. If false the contructor does not block and the RAPIConnected event signals successful device connection.</param> public void Connect(bool WaitForInit) { Connect(WaitForInit, 0); } /// <summary> /// Connect asynchronously to the remote device with a timeout of 0 seconds /// </summary> /// <param name="WaitForInit">If true the method blocks until RAPI Initializes or throws an error. If false the contructor does not block and the RAPIConnected event signals successful device connection.</param> /// <param name="TimeoutSeconds">Asynchronous connections can be set to timeout after a set number of seconds. Synchronous connection wait infinitely by default (and underlying RAPI design). For asynchronous connections, a timeout value of <b>-1</b> is infinite.</param> public void Connect(bool WaitForInit, int TimeoutSeconds) { int ret = 0; m_timeout = TimeoutSeconds; if(WaitForInit) { ret = CeRapiInit(); if( ret != 0) { int e = CeRapiGetError(); Marshal.ThrowExceptionForHR(ret); } lock(this) { m_connected = true; } // throw the connected event if(RAPIConnected != null) { RAPIConnected(); } return; } // non-blocking init call m_ri = new RAPIINIT(); m_ri.cbSize = Marshal.SizeOf(m_ri); m_ri.hrRapiInit = m_InitResult; m_hInitEvent = CreateEvent(IntPtr.Zero, 0, 0, "OpenNETCF.RAPI"); if((uint)m_hInitEvent == uint.MaxValue) { throw new RAPIException("Failed to Initialize RAPI"); } m_ri.heRapiInit = m_hInitEvent; ret = CeRapiInitEx(ref m_ri); if(ret != 0) { Marshal.ThrowExceptionForHR(ret); } // create a wait thread m_initThread = new Thread(new ThreadStart(InitThreadProc)); // Start thread m_initThread.Start(); } /// <summary> /// Disconnect from device /// </summary> public void Disconnect() { if(m_connected) { lock(this) { CeRapiUninit(); m_connected = false; } } } private void InitThreadProc() { int ret = 0; int timeout = m_timeout * 4; bool infinitetimeout = (timeout < 0); // check for Init event 4 times / sec do { // check for abort command from Dispose() if(m_killThread) { return; } // see if the event is set ret = WaitForSingleObject(m_ri.heRapiInit, 250); if((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED)) { throw new RAPIException("Failed to Initialize RAPI"); } if(! infinitetimeout) { if(timeout-- < 0) { throw new RAPIException("Timeout waiting for device connection"); } } } while(ret != WAIT_OBJECT_0); // check the hresult if(m_InitResult != 0) { Marshal.ThrowExceptionForHR(m_InitResult); } lock(this) { m_connected = true; } // throw the connected event if(RAPIConnected != null) { RAPIConnected(); } // clean up CloseHandle(m_hInitEvent); } /// <summary> /// Connected Property /// </summary> public bool Connected { get { return m_connected; } } /// <summary> /// Indicates whether ActiveSync currently has a connected device or not /// </summary> public bool DevicePresent { get { return m_devicepresent; } } #region ------ RAPI File and directory management functions ------- /// <summary> /// File Attributes /// </summary> public enum RAPIFileAttributes : int { /// <summary> /// File is read only /// </summary> ReadOnly = 0x0001, /// <summary> /// Hidden File /// </summary> Hidden = 0x0002, /// <summary> /// System File /// </summary> System = 0x0004, /// <summary> /// Directory /// </summary> Directory = 0x0010, /// <summary> /// Archive file /// </summary> Archive = 0x0020, /// <summary> /// File is in ROM /// </summary> InROM = 0x0040, /// <summary> /// Normal file /// </summary> Normal = 0x0080, /// <summary> /// Temporary directory /// </summary> Temporary = 0x0100, /// <summary> /// Sparse /// </summary> Sparse = 0x0200, /// <summary> /// Reparse point /// </summary> ReparsePt = 0x0400, /// <summary> /// Compressed file /// </summary> Compressed = 0x0800, /// <summary> /// Part of ROM module /// </summary> ROMModule = 0x2000 } /// <summary> /// Time enumeration for querying FileTime /// </summary> public enum RAPIFileTime : short { /// <summary> /// Time file was created /// </summary> CreateTime = 1, /// <summary> /// Time of last modification /// </summary> LastModifiedTime = 2, /// <summary> /// Time of last access /// </summary> LastAccessTime = 3 } // TODO: // CeFindAllFiles // CeSetFilePointer // CeSetEndOfFile /// <summary> /// Determines whether a file exists on the connected remote device /// </summary> /// <param name="RemoteFileName">Fully qualified path to the file or path on the device to test</param> /// <returns><b>true</b> if the file or directory exists, <b>false</b> if it does not</returns> public bool DeviceFileExists(string RemoteFileName) { // check for connection CheckConnection(); uint attr = CeGetFileAttributes( RemoteFileName ); if ( attr == 0xffffffff ) return false; return true; } /// <summary> /// Copy a device file to the connected PC /// </summary> /// <param name="LocalFileName">Name of destination file on PC</param> /// <param name="RemoteFileName">Name of source file on device</param> public void CopyFileFromDevice(string LocalFileName, string RemoteFileName) { CopyFileFromDevice(LocalFileName, RemoteFileName, false); } /// <summary> /// Copy a device file to the connected PC /// </summary> /// <param name="LocalFileName">Name of destination file on PC</param> /// <param name="RemoteFileName">Name of source file on device</param> /// <param name="Overwrite">Overwrites existing file on the device if <b>true</b>, fails if <b>false</b></param> public void CopyFileFromDevice(string LocalFileName, string RemoteFileName, bool Overwrite) { // check for connection CheckConnection(); FileStream localFile; IntPtr remoteFile = IntPtr.Zero; int bytesread = 0; int create = Overwrite ? CREATE_ALWAYS : CREATE_NEW; byte[] buffer = new byte[0x1000]; // 4k transfer buffer // open the remote (device) file remoteFile = CeCreateFile(RemoteFileName, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); // check for success if ((int)remoteFile == INVALID_HANDLE_VALUE) { throw new RAPIException("Could not open remote file"); } // create the local file localFile = new FileStream(LocalFileName, Overwrite ? FileMode.Create : FileMode.CreateNew, FileAccess.Write); // read data from remote file into buffer CeReadFile(remoteFile, buffer, 0x1000, ref bytesread, 0); while(bytesread > 0) { // write it into local file localFile.Write(buffer, 0, bytesread); // get more data if(! Convert.ToBoolean(CeReadFile(remoteFile, buffer, 0x1000, ref bytesread, 0))) { CeCloseHandle(remoteFile); localFile.Close(); throw new RAPIException("Failed to read device data"); } } // close the remote file CeCloseHandle(remoteFile); localFile.Flush(); // close the local file localFile.Close(); } /// <summary> /// Copy a PC file to a connected device /// </summary> /// <param name="LocalFileName">Name of source file on PC</param> /// <param name="RemoteFileName">Name of destination file on device</param> public void CopyFileToDevice(string LocalFileName, string RemoteFileName) { CopyFileToDevice(LocalFileName, RemoteFileName, false); } /// <summary> /// Copy a PC file to a connected device /// </summary> /// <param name="LocalFileName">Name of source file on PC</param> /// <param name="RemoteFileName">Name of destination file on device</param> /// <param name="Overwrite">Overwrites existing file on the device if <b>true</b>, fails if <b>false</b></param> public void CopyFileToDevice(string LocalFileName, string RemoteFileName, bool Overwrite) { // check for connection CheckConnection(); FileStream localFile; IntPtr remoteFile = IntPtr.Zero; int bytesread = 0; int byteswritten = 0; int filepos = 0; int create = Overwrite ? CREATE_ALWAYS : CREATE_NEW; byte[] buffer = new byte[0x1000]; // 4k transfer buffer // create the remote file remoteFile = CeCreateFile(RemoteFileName, GENERIC_WRITE, 0, 0, create, FILE_ATTRIBUTE_NORMAL, 0); // check for success if ((int)remoteFile == INVALID_HANDLE_VALUE) { throw new RAPIException("Could not create remote file"); } // open the local file localFile = new FileStream(LocalFileName, FileMode.Open); // read 4k of data bytesread = localFile.Read(buffer, filepos, buffer.Length); while(bytesread > 0) { // move remote file pointer # of bytes read filepos = bytesread; // write our buffer to the remote file if(! Convert.ToBoolean(CeWriteFile(remoteFile, buffer, bytesread, ref byteswritten, 0))) { // check for success CeCloseHandle(remoteFile); throw new RAPIException("Could not write to remote file"); } try { // refill the local buffer bytesread = localFile.Read(buffer, 0, buffer.Length); } catch(Exception) { bytesread = 0; } } // close the local file localFile.Close(); // close the remote file CeCloseHandle(remoteFile); // sync the date/times SetDeviceFileTime(RemoteFileName, RAPIFileTime.CreateTime, File.GetCreationTime(LocalFileName)); SetDeviceFileTime(RemoteFileName, RAPIFileTime.LastAccessTime, DateTime.Now); SetDeviceFileTime(RemoteFileName, RAPIFileTime.LastModifiedTime, File.GetLastWriteTime(LocalFileName)); } /// <summary> /// This function copies an existing device file to a new device file. /// </summary> /// <param name="SourceFile">Name of source file to copy</param> /// <param name="DestinationFile">Name of new, destination file</param> public void CopyFileOnDevice(string SourceFile, string DestinationFile) { CopyFileOnDevice(SourceFile, DestinationFile, false); } /// <summary> /// This function copies an existing device file to a new device file. /// </summary> /// <param name="ExistingFileName"></param> /// <param name="NewFileName"></param> /// <param name="Overwrite">Overwrites existing file on the device if <b>true</b>, fails if <b>false</b></param> public void CopyFileOnDevice(string ExistingFileName, string NewFileName, bool Overwrite) { CheckConnection(); if(! Convert.ToBoolean(CeCopyFile(ExistingFileName, NewFileName, Convert.ToInt32(!Overwrite)))) { throw new RAPIException("Cannot copy file"); } } /// <summary> /// Delete a file on the connected device /// </summary> /// <param name="FileName">File to delete</param> public void DeleteDeviceFile(string FileName) { CheckConnection(); if(! Convert.ToBoolean(CeDeleteFile(FileName))) { throw new RAPIException("Could not delete file"); } } /// <summary> /// Moves/renames an existing device file /// </summary> /// <param name="ExistingFileName">Name of existing file</param> /// <param name="NewFileName">New name to use for file</param> public void MoveDeviceFile(string ExistingFileName, string NewFileName) { CheckConnection(); if(! Convert.ToBoolean(CeMoveFile(ExistingFileName, NewFileName))) { throw new RAPIException("Cannot move file"); } } /// <summary> /// Get the attributes of a file on the connected device /// </summary> /// <param name="FileName">Name of file to retrieve attributes of</param> /// <returns>Attributes for given file name</returns> public RAPIFileAttributes GetDeviceFileAttributes(string FileName) { CheckConnection(); uint ret = 0; ret = CeGetFileAttributes(FileName); if(ret == 0xFFFFFFFF) { throw new RAPIException("Could not get file attributes"); } return (RAPIFileAttributes)ret; } /// <summary> /// Set the attributes for a file on the connected device /// </summary> /// <param name="FileName"></param> /// <param name="Attributes"></param> public void SetDeviceFileAttributes(string FileName, RAPIFileAttributes Attributes) { CheckConnection(); if(! Convert.ToBoolean(CeSetFileAttributes(FileName, (uint)Attributes))) { throw new RAPIException("Cannot set device file attributes"); } } /// <summary> /// Removes a directory from the connected device. /// </summary> /// <param name="PathName">Directory to remove</param> /// <param name="Recurse">If <b>true</b> the call will recursively delete any subfolders and files as well, including hidden, read-only and system files</param> public void RemoveDeviceDirectory(string PathName, bool Recurse) { CheckConnection(); if(!Recurse) { if(! Convert.ToBoolean(CeRemoveDirectory(PathName))) { throw new RAPIException("Could not remove directory"); } return; } FileList fi = null; StringBuilder wcPath = new StringBuilder (PathName); wcPath.Append("\\*"); CheckConnection(); fi = EnumFiles(wcPath.ToString()); if(fi != null) { foreach ( FileInformation fo in fi) { if(fo.FileAttributes.ToString() == "16") { StringBuilder svFullPath = new StringBuilder (PathName); svFullPath.Append("\\"); svFullPath.Append(fo.FileName); RemoveDeviceDirectory(svFullPath.ToString(), true); } else { StringBuilder svFullPath = new StringBuilder (PathName); svFullPath.Append("\\"); svFullPath.Append(fo.FileName); RAPIFileAttributes Attribs; Attribs = RAPIFileAttributes.Normal; SetDeviceFileAttributes(svFullPath.ToString(),Attribs); DeleteDeviceFile(svFullPath.ToString()); } } RemoveDeviceDirectory(PathName); } else { if(! Convert.ToBoolean(CeRemoveDirectory(PathName))) { throw new RAPIException("Could not remove directory"); } } } /// <summary> /// Given a path to a shortcut, returns the full path to the shortcut's target /// </summary> /// <param name="shortcutPath">Path to the shortcut</param> /// <returns>Path to the target</returns> public string GetDeviceShortcutTarget(string shortcutPath) { string targetPath = new string(' ', 255); if(! Convert.ToBoolean(CeSHGetShortcutTarget(shortcutPath, targetPath, 255))) { throw new RAPIException("Could not get target"); } return targetPath.Trim(); } /// <summary> /// Creates a shortcut /// </summary> /// <param name="ShortcutName">The fully qualifed path name, including the .lnk extension, of the shortcut to create</param> /// <param name="Target">Target path of the shortcut limited to 256 characters (use quoted string when target includes spaces)</param> /// <example>The following statement creates a shortcut on the remote desktop for the Smart Device Authentication Utility: /// <code>CreateDeviceShortcut("\\windows\\desktop\\.Net Debug.lnk", "\\windows\\sdauthutildevice.exe");</code> /// </example> public void CreateDeviceShortcut(string ShortcutName, string Target) { CheckConnection(); if(! Convert.ToBoolean(CeSHCreateShortcut(ShortcutName, Target))) { throw new RAPIException("Could not create shortcut"); } } /// <summary> /// Removes an empty directory from the connected device /// </summary> /// <param name="PathName">Directory to remove</param> public void RemoveDeviceDirectory(string PathName) { RemoveDeviceDirectory(PathName, false); } /// <summary> /// Creates a directory on the connected device /// </summary> /// <param name="PathName"></param> public void CreateDeviceDirectory(string PathName) { CheckConnection(); if(! Convert.ToBoolean(CeCreateDirectory(PathName, 0))) { throw new RAPIException("Could not create directory"); } } /// <summary> /// Get the size, in bytes, of a file on the connected device /// </summary> /// <param name="FileName"></param> /// <returns></returns> public long GetDeviceFileSize(string FileName) { CheckConnection(); IntPtr hFile = IntPtr.Zero; uint lowsize = 0; uint highsize = 0; hFile = CeCreateFile(FileName, 0, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); if((int)hFile == INVALID_HANDLE_VALUE) { throw new RAPIException("Could not open remote file"); } lowsize = CeGetFileSize(hFile, ref highsize); if(lowsize == uint.MaxValue) { CeCloseHandle(hFile); throw new RAPIException("Could not get file size"); } CeCloseHandle(hFile); return lowsize (highsize << 32); } /// <summary> /// Get a RAPIFileTime structure for the specified file /// </summary> /// <param name="FileName">Name of the file to check</param> /// <param name="DesiredTime">A RAPIFileTime</param> /// <returns>The DateTime for the specified value</returns> public DateTime GetDeviceFileTime(string FileName, RAPIFileTime DesiredTime) { CheckConnection(); IntPtr hFile = IntPtr.Zero; long created = 0; long modified = 0; long accessed = 0; hFile = CeCreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); if((int)hFile == INVALID_HANDLE_VALUE) { throw new RAPIException("Could not open remote file"); } if(! Convert.ToBoolean(CeGetFileTime(hFile, ref created, ref modified, ref accessed))) { CeCloseHandle(hFile); throw new RAPIException("Could not get file time"); } CeCloseHandle(hFile); switch(DesiredTime) { case RAPIFileTime.CreateTime: return DateTime.FromFileTime(created); case RAPIFileTime.LastAccessTime: return DateTime.FromFileTime(accessed); case RAPIFileTime.LastModifiedTime: return DateTime.FromFileTime(modified); default: throw new RAPIException("Invalid DesiredTime parameter"); } } /// <summary> /// Modified a FileTime for the specified file /// </summary> /// <param name="FileName">File to modify</param> /// <param name="DesiredTime">Time to modify</param> /// <param name="NewTime">New time to set</param> public void SetDeviceFileTime(string FileName, RAPIFileTime DesiredTime, DateTime NewTime) { CheckConnection(); IntPtr hFile = IntPtr.Zero; hFile = CeCreateFile(FileName, GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); if((int)hFile == INVALID_HANDLE_VALUE) { throw new RAPIException("Could not open remote file"); } SYSTEMTIME st = new SYSTEMTIME(NewTime); long ft = (long)st; long empty = 0; switch(DesiredTime) { case RAPIFileTime.CreateTime: if(! Convert.ToBoolean(CeSetFileTime(hFile, ref ft, ref empty, ref empty))) { CeCloseHandle(hFile); throw new RAPIException("Could not get file time"); } break; case RAPIFileTime.LastAccessTime: if(! Convert.ToBoolean(CeSetFileTime(hFile, ref empty, ref ft, ref empty))) { CeCloseHandle(hFile); throw new RAPIException("Could not get file time"); } break; case RAPIFileTime.LastModifiedTime: if(! Convert.ToBoolean(CeSetFileTime(hFile, ref empty, ref empty, ref ft))) { CeCloseHandle(hFile); throw new RAPIException("Could not get file time"); } break; default: throw new RAPIException("Invalid DesiredTime parameter"); } CeCloseHandle(hFile); } /// <summary> /// Launch a process of the connected device /// </summary> /// <param name="FileName">Name of application to launch</param> /// <param name="CommandLine">Command line parameters to pass to application</param> public void CreateProcess(string FileName, string CommandLine) { CheckConnection(); PROCESS_INFORMATION pi; if(CommandLine == null) { if(CeCreateProcess(FileName, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, out pi) == 0) { int errnum = CeGetLastError(); throw new RAPIException("Error " errnum.ToString("x") ": Cannot Create Process" ); } } else { if(CeCreateProcess(FileName, CommandLine, IntPtr.Zero, IntPtr.Zero, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, out pi) == 0) { int errnum = CeGetLastError(); throw new RAPIException("Error " errnum.ToString("x") ": Cannot Create Process" ); } } } /// <summary> /// Launch a process of the connected device /// </summary> /// <param name="FileName">Name of application to launch</param> public void CreateProcess(string FileName) { CreateProcess(FileName, null); } /// <summary> /// Method for calling non-stream-interface custom RAPI functions /// </summary> /// <param name="DLLPath">Device path to custom RAPI library</param> /// <param name="FunctionName">Exported name of custom RAPI function</param> /// <param name="InputData">Data to send to the custom RAPI function</param> /// <param name="OutputData">Data received from the custom RAPI function</param> public void Invoke(string DLLPath, string FunctionName, byte[] InputData, out byte[] OutputData) { // RAPI memory management is non-intuitive // you must allocate the input variable with LocalAlloc and then RAPI will release them // you must also call LocalFree on the output buffer though you never call LocalAlloc CheckConnection(); uint recvSize = 0; IntPtr recvData = IntPtr.Zero; // create a pointer to hold incoming data - RAPI will free this internally IntPtr sendData = Marshal.AllocHGlobal(InputData.Length); // copy outgoing data to the pointer - too bad we don't have a memcpy fcn for(int i = 0 ; i < InputData.Length ; i ) { Marshal.WriteInt16(sendData, i, InputData[i]); } // call the RAPI function CeRapiInvoke(DLLPath, FunctionName, (uint)InputData.Length, sendData, out recvSize, out recvData, IntPtr.Zero, 0); // allocate our managed array OutputData = new byte[recvSize]; // copy the returned data from unmanaged to managed memory Marshal.Copy(recvData, OutputData, 0, (int)recvSize); // RAPI called LocalAlloc on this internally so we must free it Marshal.FreeHGlobal(recvData); } /// <summary> /// Provides an ArrayList of FileInformation classes matching the criteria provided in the FileName parameter /// </summary> /// <param name="FileName">Long pointer to a null-terminated string that specifies a valid directory or path and filename, which can contain wildcard characters (* and ?).</param> /// <returns>An array of FileInformation objects</returns> public FileList EnumFiles(string FileName) { CheckConnection(); FileList fl = null; IntPtr hFile = IntPtr.Zero; FileInformation fi = new FileInformation(); hFile = CeFindFirstFile(FileName, fi); if(hFile != (IntPtr)INVALID_HANDLE_VALUE) { fl = new FileList(); fl.Add(fi); fi = new FileInformation(); while(CeFindNextFile(hFile, fi) != 0) { fl.Add(fi); fi = new FileInformation(); } CeFindClose(hFile); } return fl; } /// <summary> /// Gets info about the connected device /// </summary> /// <param name="pSI">SYSTEM_INFO structure populated by the call</param> public void GetDeviceSystemInfo(out SYSTEM_INFO pSI) { CheckConnection(); try { CeGetSystemInfo(out pSI); } catch(Exception) { throw new RAPIException("Error retrieving system info."); } } /// <summary> /// Gets the path to a system folder /// </summary> /// <param name="Folder"></param> /// <returns></returns> public string GetDeviceSystemFolderPath(SystemFolders Folder) { CheckConnection(); StringBuilder path = new StringBuilder(260); if(! Convert.ToBoolean(CeGetSpecialFolderPath((int)Folder, 260, path))) { throw new RAPIException("Cannot get folder path!"); } return path.ToString(); } #endregion internal void CheckConnection() { if(!m_devicepresent) { throw new RAPIException("No connected device."); } } #region non-file related functions /// <summary> /// This function fills in a SYSTEM_POWER_STATUS_EX structure /// </summary> /// <param name="PowerStatus"></param> public void GetDeviceSystemPowerStatus(out SYSTEM_POWER_STATUS_EX PowerStatus) { CheckConnection(); try { CeGetSystemPowerStatusEx(out PowerStatus, true); } catch(Exception) { throw new RAPIException("Error retrieving system power status."); } } /// <summary> /// This function fills in a STORE_INFORMATION structure with the size of the object store and the amount of free space currently in the object store /// </summary> /// <param name="StoreInfo"></param> public void GetDeviceStoreInformation(out STORE_INFORMATION StoreInfo) { CheckConnection(); try { CeGetStoreInformation(out StoreInfo); } catch(Exception) { throw new RAPIException("Error retrieving store information."); } } /// <summary> /// This function obtains extended information about the version of the operating system of the connected device. /// </summary> /// <param name="VersionInfo"></param> public void GetDeviceVersion(out OSVERSIONINFO VersionInfo) { CheckConnection(); bool b; VersionInfo.dwOSVersionInfoSize = Marshal.SizeOf(typeof(OSVERSIONINFO)); b = CeGetVersionEx(out VersionInfo); if(!b) { throw new RAPIException("Error retrieving version information.", Marshal.GetLastWin32Error()); } } /// <summary> /// Retrieves the memory status of the connected device /// </summary> /// <param name="ms"></param> public void GetDeviceMemoryStatus( out MEMORYSTATUS ms ) { CheckConnection(); CeGlobalMemoryStatus( out ms ); } /// <summary> /// This function retrieves device-specific information about a connected device. /// </summary> /// <param name="CapabiltyToGet">Capabilty to query</param> /// <returns>Value reported for capability</returns> public int GetDeviceCapabilities(DeviceCaps CapabiltyToGet) { CheckConnection(); return CeGetDesktopDeviceCaps((int)CapabiltyToGet); } /// <summary> /// Desktop equivalent of DMProcessConfigXML. Works similar to RapiConfig /// </summary> /// <param name="configXml">XML provisioning document</param> /// <param name="result">Resulting configuration document. Might contain error information</param> /// <returns>0 - success, or an HRESULT on error</returns> public int DeviceProcessConfigXml(string configXml, out string result) { result = configXml; IntPtr pOut = IntPtr.Zero; int ret = CeProcessConfig(configXml, 1, out pOut); if (pOut != IntPtr.Zero) { result = Marshal.PtrToStringUni(pOut); CeRapiFreeBuffer(pOut); } return ret; } #endregion #region P/Invoke declarations and constants private uint WAIT_OBJECT_0 = 0x00000000; private uint WAIT_ABANDONED = 0x00000080; private uint WAIT_FAILED = 0xffffffff; private int FILE_SHARE_READ = 0x00000001; private const short CREATE_NEW = 1; private const short CREATE_ALWAYS = 2; private const uint GENERIC_WRITE = 0x40000000; private const uint GENERIC_READ = 0x80000000; private const short OPEN_EXISTING = 3; [StructLayout(LayoutKind.Sequential)] internal struct RAPIINIT { public int cbSize; public IntPtr heRapiInit; public int hrRapiInit; } [StructLayout(LayoutKind.Sequential, Pack=4)] internal struct PROCESS_INFORMATION { public IntPtr hProcess; public IntPtr hThread; public int dwProcessID; public int dwThreadID; } // Used [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern IntPtr CeCreateFile( string lpFileName, uint dwDesiredAccess, int dwShareMode, int lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile); [DllImport("kernel32.dll", EntryPoint="WaitForSingleObject", SetLastError = true)] private static extern int WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds); [DllImport("kernel32.dll", CharSet=CharSet.Unicode, EntryPoint="CreateEvent", SetLastError = true)] private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, int bManualReset, int bInitialState, string lpName); [DllImport("kernel32.dll", EntryPoint="CloseHandle", SetLastError=true)] internal static extern int CloseHandle(IntPtr hObject); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeRapiInitEx ([MarshalAs(UnmanagedType.Struct)] ref RAPIINIT pRapiInit); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeRapiInit(); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeRapiGetError(); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeRapiUninit(); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeWriteFile(IntPtr hFile, byte[] lpBuffer, int nNumberOfbytesToWrite, ref int lpNumberOfbytesWritten, int lpOverlapped); [DllImport("rapi.dll", CharSet = CharSet.Unicode)] extern static void CeRapiFreeBuffer(IntPtr pBuffer); [DllImport("rapi.dll", EntryPoint = "#25", CharSet = CharSet.Unicode)] extern static int CeProcessConfig(string config, int flags, out IntPtr pResult); [DllImport("rapi.dll", CharSet = CharSet.Unicode)] internal static extern int CeCopyFile(string lpExistingFileName, string lpNewFileName, int bFailIfExists); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeDeleteFile(string lpFileName); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeMoveFile(string lpExistingFileName, string lpNewFileName); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern uint CeGetFileAttributes(string lpFileName); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeSetFileAttributes(string lpFileName, uint dwFileAttributes); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeRemoveDirectory(string lpPathName); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeCreateDirectory(string lpPathName, uint lpSecurityAttributes); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern uint CeGetFileSize(IntPtr hFile, ref uint lpFileSizeHigh); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeCloseHandle(IntPtr hObject); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeGetFileTime(IntPtr hFile, ref long lpCreationTime, ref long lpLastAccessTime, ref long lpLastWriteTime); [DllImport("rapi.dll", CharSet=CharSet.Unicode)] internal static extern int CeSetFileTime(IntPtr hFile, ref long lpCreationTime, ref long lpLastAccessTime, ref long lpLastWriteTime); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeGetLastError(); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeReadFile(IntPtr hFile, byte[] lpBuffer,int nNumberOfbytesToRead, ref int lpNumberOfbytesRead, int lpOverlapped); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal extern static int CeCreateProcess(string pszImageName, string pszCmdLine, IntPtr psaProcess, IntPtr psaThread, int fInheritHandles, int fdwCreate, IntPtr pvEnvironment, IntPtr pszCurDir, IntPtr psiStartInfo, out PROCESS_INFORMATION pi); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal extern static int CeCreateProcess(string pszImageName, IntPtr pszCmdLine, IntPtr psaProcess, IntPtr psaThread, int fInheritHandles, int fdwCreate, IntPtr pvEnvironment, IntPtr pszCurDir, IntPtr psiStartInfo, out PROCESS_INFORMATION pi); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal extern static int CeRapiInvoke(string pDllPath, string pFunctionName, uint cbInput, IntPtr pInput, out uint pcbOutput, out IntPtr ppOutput, IntPtr ppIRAPIStream, uint dwReserved); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal extern static IntPtr CeFindFirstFile(string lpFileName, byte[] lpFindFileData); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeFindNextFile(IntPtr hFindFile, byte[] lpFindFileData); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeFindClose(IntPtr hFindFile); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeSHCreateShortcut(string pShortcutName, string pTarget); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeSHGetShortcutTarget(string lpszShortcut, string lpszTarget, int cbMax); // unused so far... /* public const short ERROR_FILE_EXISTS = 80; public const short ERROR_INVALID_PARAMETER = 87; public const short ERROR_DISK_FULL = 112; */ [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeSetEndOfFile(int hFile); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeGetSystemInfo(out SYSTEM_INFO pSI); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeGetStoreInformation(out STORE_INFORMATION lpsi); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern bool CeGetSystemPowerStatusEx(out SYSTEM_POWER_STATUS_EX pStatus, bool fUpdate); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeGetSpecialFolderPath(int nFolder, uint nBufferLength, StringBuilder lpBuffer); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern bool CeGetVersionEx(out OSVERSIONINFO lpVersionInformation); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern void CeGlobalMemoryStatus(out MEMORYSTATUS msce); [DllImport("rapi.dll", CharSet=CharSet.Unicode, SetLastError=true)] internal static extern int CeGetDesktopDeviceCaps(int nIndex); #endregion #region IDisposable Members /// <summary> /// Dispose method /// </summary> public void Dispose() { lock(this) { m_killThread = true; } } #endregion private void activesync_Disconnect() { if (m_devicepresent) { CeRapiUninit(); m_devicepresent = false; } lock(this) { m_connected = false; } if(RAPIDisconnected != null) { RAPIDisconnected(); } } private void m_activesync_Active() { m_devicepresent = true; } } /// <summary> /// Exceptions thrown by the OpenNETCF.Communications.RAPI class /// </summary> public class RAPIException : System.Exception { private int win32Error; /// <summary> /// Contructor /// </summary> /// <param name="Message"></param> public RAPIException(string Message) : base(Message " " GetErrorMessage(Marshal.GetLastWin32Error())) { this.win32Error = RAPI.CeGetLastError(); } /// <summary> /// Contructor /// </summary> /// <param name="ex"></param> public RAPIException(Exception ex) : base(ex.Message) { this.win32Error = 0; } /// <summary> /// Contructor /// </summary> /// <param name="Message"></param> /// <param name="ErrorCode"></param> public RAPIException(string Message, int ErrorCode) : base(Message " " GetErrorMessage(ErrorCode)) { this.win32Error = ErrorCode; } /// <summary> /// Win32 Error value /// </summary> public int Win32Error { get { return win32Error; } } internal static string GetErrorMessage(int ErrNo) { if(ErrNo == 0) { return ""; } IntPtr pBuffer; int nLen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, ErrNo, 0, out pBuffer, 0, null); if ( nLen == 0 ) { return string.Format("Error {0} (0x{0:X})", ErrNo); } string sMsg = Marshal.PtrToStringUni(pBuffer, nLen); LocalFree(pBuffer); return sMsg; } private const int FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100; private const int FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200; private const int FORMAT_MESSAGE_FROM_STRING = 0x00000400; private const int FORMAT_MESSAGE_FROM_HMODULE = 0x00000800; private const int FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000; private const int FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x00002000; private const int FORMAT_MESSAGE_MAX_WIDTH_MASK = 0x000000FF; [DllImport("kernel32.dll", SetLastError=false, CharSet=CharSet.Unicode)] internal static extern int FormatMessage(int dwFlags, int lpSource, int dwMessageId, int dwLanguageId, out IntPtr lpBuffer, int nSize, int[] Arguments ); [DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Unicode)] internal static extern IntPtr LocalFree(IntPtr hMem); } /// <summary> /// This structure describes a file found by the FindFirstFile or FindNextFile. /// </summary> /// <seealso cref="M:OpenNETCF.Desktop.Communication.RAPI.EnumFiles(System.String@)"/> public class FileInformation //WIN32_FIND_DATA { private byte[] data = new byte[512]; /// <summary> /// Byte representation of FileInformation /// </summary> public static implicit operator byte[](FileInformation fi) { return fi.data; } /// <summary> /// File attributes of the file found. /// </summary> public int FileAttributes { get { return BitConverter.ToInt32(data, 0); } } /// <summary> /// UTC time at which the file was created. /// </summary> public DateTime CreateTime { get { long time = BitConverter.ToInt64(data, 4); return DateTime.FromFileTime(time); } } /// <summary> /// UTC time at which the file was last accessed. /// </summary> public DateTime LastAccessTime { get { long time = BitConverter.ToInt64(data, 12); return DateTime.FromFileTime(time); } } /// <summary> /// UTC time at which the file was modified. /// </summary> public DateTime LastWriteTime { get { long time = BitConverter.ToInt64(data, 20); return DateTime.FromFileTime(time); } } /// <summary> /// Size, in bytes, of file /// </summary> public long FileSize { get { return BitConverter.ToInt32(data, 28) (BitConverter.ToInt32(data, 32) << 32); } } /// <summary> /// Full name of the file /// </summary> public string FileName { get { return Encoding.Unicode.GetString(data, 40, 256).TrimEnd('\0'); } } } /// <summary> /// Describes the current status of the Object Store /// </summary> public struct STORE_INFORMATION { /// <summary> /// Size of the Object Store in Bytes /// </summary> public int dwStoreSize; /// <summary> /// Free space in the Object Store in Bytes /// </summary> public int dwFreeSize; } /// <summary> /// OSVERSIONINFO platform type /// </summary> public enum PlatformType : int { /// <summary> /// Win32 on Windows CE. /// </summary> VER_PLATFORM_WIN32_CE = 3 } /// <summary> /// Version info for the connected device /// </summary> public struct OSVERSIONINFO { internal int dwOSVersionInfoSize; /// <summary> /// Major /// </summary> public int dwMajorVersion; /// <summary> /// Minor /// </summary> public int dwMinorVersion; /// <summary> /// Build /// </summary> public int dwBuildNumber; /// <summary> /// Platform type /// </summary> public PlatformType dwPlatformId; } /// <summary> /// Device Capability COnstants (GetDeviceCapabilities) /// </summary> public enum DeviceCaps : short { /// <summary> /// Screen width in mm /// </summary> HorizontalSize = 4, /// <summary> /// Screen height in mm /// </summary> VerticalSize = 6, /// <summary> /// Screen width in pixels /// </summary> HorizontalResolution = 8, /// <summary> /// Screen height in raster lines /// </summary> VerticalResolution = 10, /// <summary> /// Number of adjacent color bits for each pixel /// </summary> BitsPerPixel = 12, } /// <summary> /// Memory information for a remote device /// </summary> [StructLayout(LayoutKind.Sequential)] public struct MEMORYSTATUS { internal uint dwLength; /// <summary> /// Current memory load (%) /// </summary> public int dwMemoryLoad; /// <summary> /// Total physical memory /// </summary> public int dwTotalPhys; /// <summary> /// Available Physical Memory /// </summary> public int dwAvailPhys; /// <summary> /// Total page files /// </summary> public int dwTotalPageFile; /// <summary> /// Available page files /// </summary> public int dwAvailPageFile; /// <summary> /// Totla virtual memory /// </summary> public int dwTotalVirtual; /// <summary> /// Available virtual memory /// </summary> public int dwAvailVirtual; } /// <summary> /// Structure for power information of mobile device /// </summary> public struct SYSTEM_POWER_STATUS_EX { /// <summary> /// AC Power status /// </summary> public byte ACLineStatus; /// <summary> /// Battery flag /// </summary> public byte BatteryFlag; /// <summary> /// Remaining battery life /// </summary> public byte BatteryLifePercent; internal byte Reserved1; /// <summary> /// Total battery life /// </summary> public int BatteryLifeTime; /// <summary> /// Battery life remaining /// </summary> public int BatteryFullLifeTime; internal byte Reserved2; /// <summary> /// Backup battery present /// </summary> public byte BackupBatteryFlag; /// <summary> /// Life remaining /// </summary> public byte BackupBatteryLifePercent; internal byte Reserved3; /// <summary> /// Life remaining /// </summary> public int BackupBatteryLifeTime; /// <summary> /// Total life when fully charged /// </summary> public int BackupBatteryFullLifeTime; } /// <summary> /// Processor Architecture values (GetSystemInfo) /// </summary> public enum ProcessorArchitecture : short { /// <summary> /// Intel /// </summary> Intel = 0, /// <summary> /// MIPS /// </summary> MIPS = 1, /// <summary> /// Alpha /// </summary> Alpha = 2, /// <summary> /// PowerPC /// </summary> PPC = 3, /// <summary> /// Hitachi SHx /// </summary> SHX = 4, /// <summary> /// ARM /// </summary> ARM = 5, /// <summary> /// IA64 /// </summary> IA64 = 6, /// <summary> /// Alpha 64 /// </summary> Alpha64 = 7, /// <summary> /// Unknown /// </summary> Unknown = -1 } /// <summary> /// Processor type values (GetSystemInfo) /// </summary> public enum ProcessorType : int { /// <summary> /// 386 /// </summary> PROCESSOR_INTEL_386 = 386, /// <summary> /// 486 /// </summary> PROCESSOR_INTEL_486 = 486, /// <summary> /// Pentium /// </summary> PROCESSOR_INTEL_PENTIUM = 586, /// <summary> /// P2 /// </summary> PROCESSOR_INTEL_PENTIUMII = 686, /// <summary> /// IA 64 /// </summary> PROCESSOR_INTEL_IA64 = 2200, /// <summary> /// MIPS 4000 series /// </summary> PROCESSOR_MIPS_R4000 = 4000, /// <summary> /// Alpha 21064 /// </summary> PROCESSOR_ALPHA_21064 = 21064, /// <summary> /// PowerPC 403 /// </summary> PROCESSOR_PPC_403 = 403, /// <summary> /// PowerPC 601 /// </summary> PROCESSOR_PPC_601 = 601, /// <summary> /// PowerPC 603 /// </summary> PROCESSOR_PPC_603 = 603, /// <summary> /// PowerPC 604 /// </summary> PROCESSOR_PPC_604 = 604, /// <summary> /// PowerPC 620 /// </summary> PROCESSOR_PPC_620 = 620, /// <summary> /// Hitachi SH3 /// </summary> PROCESSOR_HITACHI_SH3 = 10003, /// <summary> /// Hitachi SH3E /// </summary> PROCESSOR_HITACHI_SH3E = 10004, /// <summary> /// Hitachi SH4 /// </summary> PROCESSOR_HITACHI_SH4 = 10005, /// <summary> /// Motorola 821 /// </summary> PROCESSOR_MOTOROLA_821 = 821, /// <summary> /// Hitachi SH3 /// </summary> PROCESSOR_SHx_SH3 = 103, /// <summary> /// Hitachi SH4 /// </summary> PROCESSOR_SHx_SH4 = 104, /// <summary> /// Intel StrongARM /// </summary> PROCESSOR_STRONGARM = 2577, /// <summary> /// ARM720 /// </summary> PROCESSOR_ARM720 = 1824, /// <summary> /// ARM820 /// </summary> PROCESSOR_ARM820 = 2080, /// <summary> /// ARM920 /// </summary> PROCESSOR_ARM920 = 2336, /// <summary> /// ARM 7 /// </summary> PROCESSOR_ARM_7TDMI = 70001 } /// <summary> /// Data structure for GetSystemInfo /// </summary> public struct SYSTEM_INFO { /// <summary> /// Processor architecture /// </summary> public ProcessorArchitecture wProcessorArchitecture; internal ushort wReserved; /// <summary> /// Specifies the page size and the granularity of page protection and commitment. /// </summary> public int dwPageSize; /// <summary> /// Pointer to the lowest memory address accessible to applications and dynamic-link libraries (DLLs). /// </summary> public int lpMinimumApplicationAddress; /// <summary> /// Pointer to the highest memory address accessible to applications and DLLs. /// </summary> public int lpMaximumApplicationAddress; /// <summary> /// Specifies a mask representing the set of processors configured into the system. Bit 0 is processor 0; bit 31 is processor 31. /// </summary> public int dwActiveProcessorMask; /// <summary> /// Specifies the number of processors in the system. /// </summary> public int dwNumberOfProcessors; /// <summary> /// Specifies the type of processor in the system. /// </summary> public ProcessorType dwProcessorType; /// <summary> /// Specifies the granularity with which virtual memory is allocated. /// </summary> public int dwAllocationGranularity; /// <summary> /// Specifies the system抯 architecture-dependent processor level. /// </summary> public short wProcessorLevel; /// <summary> /// Specifies an architecture-dependent processor revision. /// </summary> public short wProcessorRevision; } /// <summary> /// Parameter for SHGetSpecialFolder /// </summary> /// <remarks>Not all platforms support all of these constants.</remarks> public enum SystemFolders { /// <summary> /// </summary> Personal = 0x05, /// <summary> /// "\Windows\Program Files" /// </summary> Programs = 0x02, /// <summary> /// "\Windows\Favorites" /// </summary> Favorites = 0x06, /// <summary> /// "\Windows\StartUp" /// </summary> StartUp = 0x07, /// <summary> /// recent files /// </summary> Recent = 0x08, /// <summary> /// "\Windows\Desktop" /// </summary> Desktop = 0x10, /// <summary> /// "\Windows\Fonts" /// </summary> Fonts = 0x14 } /// <summary> /// Collection class of FileInformation classes /// </summary> public class FileList : CollectionBase { internal FileList() { } /// <summary> /// Returns the FileInformation at the specified index /// </summary> public FileInformation this[int index] { get { return (FileInformation)List[index]; } } internal void Add(FileInformation fi) { List.Add(fi); } } }