Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1630 connectés 

  FORUM HardWare.fr
  Programmation
  C#/.NET managed

  [VB .NET] Comment utiliser une classe écrite en C#

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[VB .NET] Comment utiliser une classe écrite en C#

n°1796220
matz
Posté le 06-10-2008 à 17:15:00  profilanswer
 

Bonjour,
 
Je développe une petite appli pour un Windows CE, avec VS 2008, en VB .NET. J'ai besoin d'accéder aux process du Windows CE mais la fonction System.Diagnostics.Process.GetProcessesByName n'existe pas. Donc je voudrais utiliser une classe que j'ai vue sur MSDN :
 
http://msdn.microsoft.com/en-us/library/aa446560.aspx
 
J'ai téléchargé le source de la classe Process.cs (cf à la fin) et je l'ai ajouté à mon projet VB, mais je n'arrive pas à instancier un objet avec cette classe, style  
 
Dim p as new Process
 
Quelqu'un sait comme je peux m'en sortir et utiliser une classe écrite en C# en VB ?
 
Merci
 
Matz
 
Code de la classe :

Code :
  1. using System;
  2. using System.Collections;
  3. using System.Runtime.InteropServices;
  4. using System.Text;
  6. namespace ToolHelp
  7. {
  8. #region Process class
  9. /// <summary>
  10. /// Summary description for Process.
  11. /// </summary>
  12. public class Process
  13. {
  14.  private string processName;
  15.  private IntPtr handle;
  16.  private int threadCount;
  17.  private int baseAddress;
  20.  //default constructor
  21.  public Process()
  22.  {
  24.  }
  26.  private Process(IntPtr id, string procname, int threadcount, int baseaddress)
  27.  {
  28.   handle = id;
  29.   processName = procname;
  30.   threadCount = threadcount;
  31.   baseAddress = baseaddress;
  32.  }
  34.  //ToString implementation for ListBox binding
  35.  public override string ToString()
  36.  {
  37.   return processName;
  38.  }
  40.  public int BaseAddress
  41.  {
  42.   get
  43.   {
  44.    return baseAddress;
  45.   }
  46.  }
  48.  public int ThreadCount
  49.  {
  50.   get
  51.   {
  52.    return threadCount;
  53.   }
  54.  }
  56.  public IntPtr Handle
  57.  {
  58.   get
  59.   {
  60.    return handle;
  61.   }
  62.  }
  64.  public string ProcessName
  65.  {
  66.   get
  67.   {
  68.    return processName;
  69.   }
  70.  }
  72.  public int BaseAddess
  73.  {
  74.   get
  75.   {
  76.    return baseAddress;
  77.   }
  78.  }
  81.  public void Kill()
  82.  {
  83.   IntPtr hProcess;
  85.   hProcess = OpenProcess(PROCESS_TERMINATE, false, (int) handle);
  87.   if(hProcess != (IntPtr) INVALID_HANDLE_VALUE)
  88.   {
  89.    bool bRet;
  90.    bRet = TerminateProcess(hProcess, 0);
  91.    CloseHandle(hProcess);
  92.   }
  95.  }
  97.  public static Process[] GetProcesses()
  98.  {
  99.   ArrayList procList = new ArrayList();
  101.   IntPtr handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  103.   if ((int)handle > 0)
  104.   {
  105.    try
  106.    {
  107.     PROCESSENTRY32 peCurrent;
  108.     PROCESSENTRY32 pe32 = new PROCESSENTRY32();
  109.     //Get byte array to pass to the API calls
  110.     byte[] peBytes = pe32.ToByteArray();
  111.     //Get the first process
  112.     int retval = Process32First(handle, peBytes);
  114.     while(retval == 1)
  115.     {
  116.      //Convert bytes to the class
  117.      peCurrent = new PROCESSENTRY32(peBytes);
  118.      //New instance
  119.      Process proc = new Process(new IntPtr((int)peCurrent.PID), peCurrent.Name, (int)peCurrent.ThreadCount, (int)peCurrent.BaseAddress);
  121.      procList.Add(proc);
  123.      retval = Process32Next(handle, peBytes);
  124.     }
  125.    }
  126.    catch(Exception ex)
  127.    {
  128.     throw new Exception("Exception: " + ex.Message);
  129.    }
  131.    //Close handle
  132.    CloseToolhelp32Snapshot(handle);
  134.    return (Process[])procList.ToArray(typeof(Process));
  136.   }
  137.   else
  138.   {
  139.    throw new Exception("Unable to create snapshot" );
  140.   }
  143.  }
  145.  #endregion
  147.  #region PROCESSENTRY32 implementation
  149. //  typedef struct tagPROCESSENTRY32  
  150. //  {  
  151. //   DWORD dwSize;  
  152. //   DWORD cntUsage;  
  153. //   DWORD th32ProcessID;  
  154. //   DWORD th32DefaultHeapID;  
  155. //   DWORD th32ModuleID;  
  156. //   DWORD cntThreads;  
  157. //   DWORD th32ParentProcessID;  
  158. //   LONG pcPriClassBase;  
  159. //   DWORD dwFlags;  
  160. //   TCHAR szExeFile[MAX_PATH];  
  161. //   DWORD th32MemoryBase;
  162. //   DWORD th32AccessKey;
  163. //  } PROCESSENTRY32;
  165.  private class PROCESSENTRY32
  166.  {
  167.   // constants for structure definition
  168.   private const int SizeOffset = 0;
  169.   private const int UsageOffset = 4;
  170.   private const int ProcessIDOffset=8;
  171.   private const int DefaultHeapIDOffset = 12;
  172.   private const int ModuleIDOffset = 16;
  173.   private const int ThreadsOffset = 20;
  174.   private const int ParentProcessIDOffset = 24;
  175.   private const int PriClassBaseOffset = 28;
  176.   private const int dwFlagsOffset = 32;
  177.   private const int ExeFileOffset = 36;
  178.   private const int MemoryBaseOffset = 556;
  179.   private const int AccessKeyOffset = 560;
  180.   private const int Size = 564;
  181.   private const int MAX_PATH = 260;
  183.   // data members
  184.   public uint dwSize;
  185.   public uint cntUsage;
  186.   public uint th32ProcessID;
  187.   public uint th32DefaultHeapID;
  188.   public uint th32ModuleID;
  189.   public uint cntThreads;
  190.   public uint th32ParentProcessID;
  191.   public long pcPriClassBase;
  192.   public uint dwFlags;
  193.   public string szExeFile;
  194.   public uint th32MemoryBase;
  195.   public uint th32AccessKey;
  197.   //Default constructor
  198.   public PROCESSENTRY32()
  199.   {
  202.   }
  204.   // create a PROCESSENTRY instance based on a byte array  
  205.   public PROCESSENTRY32(byte[] aData)
  206.   {
  207.    dwSize = GetUInt(aData, SizeOffset);
  208.    cntUsage = GetUInt(aData, UsageOffset);
  209.    th32ProcessID = GetUInt(aData, ProcessIDOffset);
  210.    th32DefaultHeapID = GetUInt(aData, DefaultHeapIDOffset);
  211.    th32ModuleID = GetUInt(aData, ModuleIDOffset);
  212.    cntThreads = GetUInt(aData, ThreadsOffset);
  213.    th32ParentProcessID = GetUInt(aData, ParentProcessIDOffset);
  214.    pcPriClassBase = (long) GetUInt(aData, PriClassBaseOffset);
  215.    dwFlags = GetUInt(aData, dwFlagsOffset);
  216.    szExeFile = GetString(aData, ExeFileOffset, MAX_PATH);
  217.    th32MemoryBase = GetUInt(aData, MemoryBaseOffset);
  218.    th32AccessKey = GetUInt(aData, AccessKeyOffset);
  219.   }
  221.   #region Helper conversion functions
  222.   // utility:  get a uint from the byte array
  223.   private static uint GetUInt(byte[] aData, int Offset)
  224.   {
  225.    return BitConverter.ToUInt32(aData, Offset);
  226.   }
  228.   // utility:  set a uint int the byte array
  229.   private static void SetUInt(byte[] aData, int Offset, int Value)
  230.   {
  231.    byte[] buint = BitConverter.GetBytes(Value);
  232.    Buffer.BlockCopy(buint, 0, aData, Offset, buint.Length);
  233.   }
  235.   // utility:  get a ushort from the byte array
  236.   private static ushort GetUShort(byte[] aData, int Offset)
  237.   {
  238.    return BitConverter.ToUInt16(aData, Offset);
  239.   }
  241.   // utility:  set a ushort int the byte array
  242.   private static void SetUShort(byte[] aData, int Offset, int Value)
  243.   {
  244.    byte[] bushort = BitConverter.GetBytes((short)Value);
  245.    Buffer.BlockCopy(bushort, 0, aData, Offset, bushort.Length);
  246.   }
  248.   // utility:  get a unicode string from the byte array
  249.   private static string GetString(byte[] aData, int Offset, int Length)
  250.   {
  251.    String sReturn =  Encoding.Unicode.GetString(aData, Offset, Length);
  252.    return sReturn;
  253.   }
  255.   // utility:  set a unicode string in the byte array
  256.   private static void SetString(byte[] aData, int Offset, string Value)
  257.   {
  258.    byte[] arr = Encoding.ASCII.GetBytes(Value);
  259.    Buffer.BlockCopy(arr, 0, aData, Offset, arr.Length);
  260.   }
  261.   #endregion
  263.   // create an initialized data array
  264.   public byte[] ToByteArray()
  265.   {
  266.    byte[] aData;
  267.    aData = new byte[Size];
  268.    //set the Size member
  269.    SetUInt(aData, SizeOffset, Size);
  270.    return aData;
  271.   }
  273.   public string Name
  274.   {
  275.    get
  276.    {
  277.     return szExeFile.Substring(0, szExeFile.IndexOf('\0'));
  278.    }
  279.   }
  281.   public ulong PID
  282.   {
  283.    get
  284.    {
  285.     return th32ProcessID;
  286.    }
  287.   }
  289.   public ulong BaseAddress
  290.   {
  291.    get
  292.    {
  293.     return th32MemoryBase;
  294.    }
  295.   }
  297.   public ulong ThreadCount
  298.   {
  299.    get
  300.    {
  301.     return cntThreads;
  302.    }
  303.   }
  304.  }
  305.  #endregion
  307.  #region PInvoke declarations
  308.  private const int TH32CS_SNAPPROCESS = 0x00000002;
  309.  [DllImport("toolhelp.dll" )]
  310.  public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processid);
  311.  [DllImport("toolhelp.dll" )]
  312.  public static extern int CloseToolhelp32Snapshot(IntPtr handle);
  313.  [DllImport("toolhelp.dll" )]
  314.  public static extern int Process32First(IntPtr handle, byte[] pe);
  315.  [DllImport("toolhelp.dll" )]
  316.  public static extern int Process32Next(IntPtr handle, byte[] pe);
  317.  [DllImport("coredll.dll" )]
  318.  private static extern IntPtr OpenProcess(int flags, bool fInherit, int PID);
  319.  private const int PROCESS_TERMINATE = 1;
  320.  [DllImport("coredll.dll" )]
  321.  private static extern bool TerminateProcess(IntPtr hProcess, uint ExitCode);
  322.  [DllImport("coredll.dll" )]
  323.  private static extern bool CloseHandle(IntPtr handle);
  324.  private const int INVALID_HANDLE_VALUE = -1;
  326.  #endregion
  327. }
  328. }

mood
Publicité
Posté le 06-10-2008 à 17:15:00  profilanswer
 

n°1796426
Harkonnen
Modérateur
Un modo pour les bannir tous
Posté le 07-10-2008 à 00:09:31  profilanswer
 

il faut compiler ta classe C# en .netmodule et la joindre à ton projet. regarde ici pour plus d'infos
http://blogs.msdn.com/junfeng/arch [...] 71683.aspx


---------------
J'ai un string dans l'array (Paris Hilton)

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C#/.NET managed

  [VB .NET] Comment utiliser une classe écrite en C#

 

Sujets relatifs
probleme C (surement facile a regler )utiliser des accents dans les noms de variables ?
[C] Cherche quelqu'un pour me programmer qqchose : payé.Excel, VB, "lier" des lignes
Namespace, PO et Visual C++Allocation memoire C++
C++ et XNA[Résolu] Manipulation de dates par FILETIME et SYSTEMTIME
Help programme en C[C++ MFC] CFileDialog n'affiche pas les disques durs
Plus de sujets relatifs à : [VB .NET] Comment utiliser une classe écrite en C#

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.125 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR