Извлечение сетевого процесса процесса

Question

Как я могу получить процесс отправки/получения байтов? предпочтительный способ делает это с C#.

Я искал это много, и я не нашел простого решения для этого. Некоторые решения предложили установить WinPCap на машину и работать с этим lib.

Как этот парень спросил: Need "Processes with Network Activity" functionality in managed code - Like resmon.exe does it Я не хочу накладных расходов на lib.

Есть ли простое решение для этого? На самом деле я хочу точно данные, которые монитор ресурсов Windows дает на вкладке «Процессы с сетевой активностью»:

Как монитор ресурсов Windows получает эту информацию? Любой пример?

Кроме того, пытался использовать метод счетчика, который упоминается здесь: Missing network sent/received , но без успеха - не каждый процесс показан под этим счетчиком. И снова мне интересно, как монитор ресурсов получает эту информацию даже без использования этого счетчика ...

Answer 1

Вы можете использовать PerformanceCounter. Образец кода:

//Define 
string pn = "MyProcessName.exe"; 
var readOpSec = new PerformanceCounter("Process","IO Read Operations/sec", pn); 
var writeOpSec = new PerformanceCounter("Process","IO Write Operations/sec", pn); 
var dataOpSec = new PerformanceCounter("Process","IO Data Operations/sec", pn); 
var readBytesSec = new PerformanceCounter("Process","IO Read Bytes/sec", pn); 
var writeByteSec = new PerformanceCounter("Process","IO Write Bytes/sec", pn); 
var dataBytesSec = new PerformanceCounter("Process","IO Data Bytes/sec", pn); 

var counters = new List<PerformanceCounter> 
       { 
       readOpSec, 
       writeOpSec, 
       dataOpSec, 
       readBytesSec, 
       writeByteSec, 
       dataBytesSec 
       }; 

// get current value 
foreach (PerformanceCounter counter in counters) 
{ 
    float rawValue = counter.NextValue(); 

    // display the value 
} 

И это для получения счетчиков производительности для сетевой карты. Обратите внимание, что не обрабатывают конкретный

string cn = "get connection string from WMI"; 

var networkBytesSent = new PerformanceCounter("Network Interface", "Bytes Sent/sec", cn); 
var networkBytesReceived = new PerformanceCounter("Network Interface", "Bytes Received/sec", cn); 
var networkBytesTotal = new PerformanceCounter("Network Interface", "Bytes Total/sec", cn); 

Counters.Add(networkBytesSent); 
Counters.Add(networkBytesReceived); 
Counters.Add(networkBytesTotal); 

Answer 2

монитора ресурсов использует ETW - к счастью, Microsoft создала хороший nuget .net wrapper, чтобы сделать его проще в использовании.

я написал что-то вроде этого в последнее время сообщить сети моего процесса Ио:

using System; 
using System.Diagnostics; 
using System.Threading.Tasks; 
using Microsoft.Diagnostics.Tracing.Parsers; 
using Microsoft.Diagnostics.Tracing.Session; 

namespace ProcessMonitoring 
{ 
    public sealed class NetworkPerformanceReporter : IDisposable 
    { 
     private DateTime m_EtwStartTime; 
     private TraceEventSession m_EtwSession; 

     private readonly Counters m_Counters = new Counters(); 

     private class Counters 
     { 
      public long Received; 
      public long Sent; 
     } 

     private NetworkPerformanceReporter() { } 

     public static NetworkPerformanceReporter Create() 
     { 
      var networkPerformancePresenter = new NetworkPerformanceReporter(); 
      networkPerformancePresenter.Initialise(); 
      return networkPerformancePresenter; 
     } 

     private void Initialise() 
     { 
      // Note that the ETW class blocks processing messages, so should be run on a different thread if you want the application to remain responsive. 
      Task.Run(() => StartEtwSession()); 
     } 

     private void StartEtwSession() 
     { 
      try 
      { 
       var processId = Process.GetCurrentProcess().Id; 
       ResetCounters(); 

       using (m_EtwSession = new TraceEventSession("MyKernelAndClrEventsSession")) 
       { 
        m_EtwSession.EnableKernelProvider(KernelTraceEventParser.Keywords.NetworkTCPIP); 

        m_EtwSession.Source.Kernel.TcpIpRecv += data => 
        { 
         if (data.ProcessID == processId) 
         { 
          lock (m_Counters) 
          { 
           m_Counters.Received += data.size; 
          } 
         } 
        }; 

        m_EtwSession.Source.Kernel.TcpIpSend += data => 
        { 
         if (data.ProcessID == processId) 
         { 
          lock (m_Counters) 
          { 
           m_Counters.Sent += data.size; 
          } 
         } 
        }; 

        m_EtwSession.Source.Process(); 
       } 
      } 
      catch 
      { 
       ResetCounters(); // Stop reporting figures 
       // Probably should log the exception 
      } 
     } 

     public NetworkPerformanceData GetNetworkPerformanceData() 
     { 
      var timeDifferenceInSeconds = (DateTime.Now - m_EtwStartTime).TotalSeconds; 

      NetworkPerformanceData networkData; 

      lock (m_Counters) 
      { 
       networkData = new NetworkPerformanceData 
       { 
        BytesReceived = Convert.ToInt64(m_Counters.Received/timeDifferenceInSeconds), 
        BytesSent = Convert.ToInt64(m_Counters.Sent/timeDifferenceInSeconds) 
       }; 

      } 

      // Reset the counters to get a fresh reading for next time this is called. 
      ResetCounters(); 

      return networkData; 
     } 

     private void ResetCounters() 
     { 
      lock (m_Counters) 
      { 
       m_Counters.Sent = 0; 
       m_Counters.Received = 0; 
      } 
      m_EtwStartTime = DateTime.Now; 
     } 

     public void Dispose() 
     { 
      m_EtwSession?.Dispose(); 
     } 
    } 

    public sealed class NetworkPerformanceData 
    { 
     public long BytesReceived { get; set; } 
     public long BytesSent { get; set; } 
    } 
}