Odzyskaj wykorzystanie sieci procesowej

Question

Jak mogę uzyskać proces wysyłania/odbierania bajtów? preferowany sposób robi to za pomocą C#.

Szukałem tego bardzo często i nie znalazłem żadnego prostego rozwiązania. Niektóre rozwiązania sugerowały instalację WinPCap na komputerze i pracę z tą biblioteką.

Tak jak ten gość zapytał: Need "Processes with Network Activity" functionality in managed code - Like resmon.exe does it Nie chcę, żeby narzut lib.

Czy istnieje proste rozwiązanie tego problemu? Właściwie chcę dokładnie te dane, które daje Monitor zasobów systemu Windows w zakładce "Procesy z aktywnością sieciową":

W jaki sposób Monitor zasobów systemu Windows otrzymuje te informacje? Dowolny przykład?

Próbowano również użyć metody licznika wymienionej tutaj: Missing network sent/received , ale bez powodzenia - ponieważ nie każdy proces jest wyświetlany pod tym licznikiem. I znowu zastanawiam się, w jaki sposób Monitor zasobów otrzymuje tę informację, nawet bez użycia tego licznika ...

Answer 1

Można użyć PerformanceCounter. Przykładowy kod:

//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 
} 

I to jest dostać liczników wydajności dla karty sieciowej. Zauważ, że nie jest proces specyficzny

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

Resource Monitor wykorzystuje ETW - na szczęście, Microsoft stworzył piękny nuget .net wrapper aby łatwiej korzystać.

napisałem coś takiego niedawno zgłosić powrotem sieć mój proces Io:

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; } 
    } 
}