Querying machine specs

Question

Quali sono alcuni modi in cui posso interrogare le specifiche della macchina locale (una serie di cose dalle specifiche della CPU, versione del sistema operativo, specifiche della scheda grafica e driver, ecc.) tramite un'interfaccia programmatica? Stiamo scrivendo una semplice app in C # per testare la compatibilità della nostra app principale e vogliamo farla scaricare alcune metriche di sistema, ma non riesco a trovare da dove cominciare, quali interfacce usare, librerie, qualsiasi cosa.

Ho provato tutti i tipi di ricerche, ma riesco a trovare solo programmi e GUI, che richiedono l'interazione o l'installazione di un utente.

In alternativa, un piccolo programma da riga di comando funzionerebbe altrettanto bene, purché ci fosse permesso di distribuirlo con l'app di test.

Ho trovato un programma che ottiene alcune delle specifiche che vorrei, PsInfo . Tuttavia, sembra che ogni utente accetti una licenza quando viene eseguito per la prima volta, anche se si tratta di un'app da riga di comando. Inoltre, si occupa solo di informazioni su OS / CPU e ne avrò bisogno di più.

Inoltre: ho dimenticato di menzionare esplicitamente, ma questo in effetti sarà necessario solo per i computer Windows. Siete veloci!

Modifica: questo WMI sembra quello di cui ho bisogno, grazie! Piuttosto una lattina di worm, quindi devo immergermi. Indica che per alcune cose l'utente deve avere i privilegi di amministratore; questo probabilmente non sarà un grosso problema, ma potrebbe limitarlo un po '.

Answer 1

Per questo tipo di informazioni WMI È tuo amico. Fortunatamente gestire WMI in .NET è molto più semplice che nel mondo non gestito. Ci sono molti articoli disponibili per iniziare, come questo , o questo per recuperare le informazioni sul processore.

Finirai per scrivere query simili a SQL su oggetti nello spazio dei nomi WMI per recuperare le informazioni che desideri.

Answer 2

Forse cerca di usare Strumentazione gestione Windows (WMI), supponendo che si tratti di un computer Windows che si prevede di eseguire una query. Dai un'occhiata al Creatore di codici WMI di Microsoft. Può facilmente iniziare con esempi di codice in alcune lingue.

WMI funziona in modo eccellente fino all'era di Windows 2000, ma può funzionare anche su macchine Win98 con un po 'di aiuto.

Finché hai, o puoi fornire, le credenziali di amministratore per la macchina su cui stai cercando di interrogare, WMI è sicuramente la strada da percorrere.

Answer 3

Potrei anche pubblicare il codice di base che ho usato per ottenere tutto ciò di cui avevo bisogno, usando WMI come è stato suggerito qui.

Devo includere un riferimento a System.Management nel progetto c #. Quindi, la fonte stessa è probabilmente terribilmente formata in c #, ma non ci ho mai scritto prima ed è per uno strumento interno, quindi è un po 'oltre il punto. L'ho semplificato un po ', quindi si tratta solo di produrre le specifiche della macchina (lo strumento fa altre cose oltre a quello). Ogni chiamata a LogClass () scarica tutte le sue proprietà. Per ulteriori classi da scaricare, basta dare un'occhiata alla sezione MSDN su Classi WMI .

using System;
using System.Collections.Generic;
using System.Text;
using System.Management;
using System.IO;

namespace SyTest
{
  class Program
  {
    static StreamWriter specStream;

    static void Main(string[] args)
    {
      FileStream specFile =
          new FileStream("machine-specs.txt",FileMode.Create,FileAccess.Write);
      specStream = new StreamWriter(specFile);

      LogClass("Win32_DesktopMonitor");
      LogClass("Win32_VideoController");
      LogClass("Win32_Processor");
      // etc

      specStream.Close();
      specFile.Close();
    }

    static void LogClass(string strTable)
    {
      if (strTable.Length <= 0) return;
      specStream.Write("--- " + strTable + " ---\r\n\r\n");
      WqlObjectQuery wqlQuery =
          new WqlObjectQuery("SELECT * FROM " + strTable);
      ManagementObjectSearcher searcher =
          new ManagementObjectSearcher(wqlQuery);
      try
      {
        if (searcher.Get().Count <= 0)
        {
          specStream.Write("Class has no instances\r\n\r\n");
        }
        foreach (ManagementObject obj in searcher.Get())
        {
          specStream.Write("* " + obj.ToString() + "\r\n");

          if (obj.Properties.Count <= 0)
          {
            specStream.Write("Class instance has no properties\r\n");
            continue;
          }

          foreach (System.Management.PropertyData prop in obj.Properties)
          {
            LogAttr(obj, prop.Name);
          }

          specStream.Write("\r\n");
        }
      }
      catch { specStream.Write("Class does not exist\r\n\r\n"); }
    }
    static void LogAttr(ManagementObject obj, string str)
    {
      if (str.Length <= 0) return;
      string strValue = "";
      try
      {
        strValue = obj[str].ToString();
        try
        {
          string[] pstrTmp = ((string[])obj[str]);
          if (pstrTmp.Length > 0) strValue = String.Join(", ", pstrTmp);
        }
        catch { } // Problem casting, fall back on original assignment
      }
      catch { strValue = "[UNDEFINED]"; }
      specStream.Write(str + ": " + strValue + "\r\n");
    }
  }
}

Answer 4

Nel caso strano che avresti sviluppato per Linux, potresti trovare cose fantastiche nello pseudofilesystem / proc .

Answer 5

Se decidi di utilizzare WMI, potresti voler controllare WMI Code Creator di Microsoft. Rende abbastanza facile gestire WMI.

Answer 6

Esiste un pacchetto nuget chiamato MissingLinq.Linq2Management che ha racchiuso praticamente tutto ciò che riguarda WMI in un bel oggetto fortemente tipizzato. Sembra abbastanza carino.

https://missinglinq.codeplex.com/