¿Cómo se puede cambiar la configuración de red (dirección IP, DNS, WINS, el nombre de host) con el código en C#

Question

Estoy desarrollando un asistente para una máquina que se va a utilizar como una copia de seguridad de otras máquinas. Cuando reemplaza una máquina existente, necesita establecer su dirección IP, DNS, WINS y nombre de host para que coincida con la máquina que se reemplaza.

¿Hay una biblioteca en .NET (C#) que me permite hacer esto mediante programación?

Hay varias tarjetas de red, cada uno de los cuales es necesario establecer de forma individual.

EDITAR

Gracias TimothyP por su ejemplo. Me puso en movimiento en el camino correcto y la respuesta rápida fue increíble.

Gracias balexandre. Tu código es perfecto Tenía prisa y ya había adaptado el ejemplo al que TimothyP estaba vinculado, pero me hubiera encantado haber tenido tu código antes.

También hemos desarrollado una rutina utilizando técnicas similares para cambiar el nombre del equipo. Lo publicaré en el futuro así que suscríbase a estas preguntas RSS feed si desea que se lo informe. Puedo levantarlo más tarde hoy o el lunes después de un poco de limpieza.

Answer 1

Acaba de hacer esto en unos pocos minutos:

using System; 
using System.Management; 

namespace WindowsFormsApplication_CS 
{ 
    class NetworkManagement 
    { 
     /// <summary> 
     /// Set's a new IP Address and it's Submask of the local machine 
     /// </summary> 
     /// <param name="ip_address">The IP Address</param> 
     /// <param name="subnet_mask">The Submask IP Address</param> 
     /// <remarks>Requires a reference to the System.Management namespace</remarks> 
     public void setIP(string ip_address, string subnet_mask) 
     { 
      ManagementClass objMC = new ManagementClass("Win32_NetworkAdapterConfiguration"); 
      ManagementObjectCollection objMOC = objMC.GetInstances(); 

      foreach (ManagementObject objMO in objMOC) 
      { 
       if ((bool)objMO["IPEnabled"]) 
       { 
        try 
        { 
         ManagementBaseObject setIP; 
         ManagementBaseObject newIP = 
          objMO.GetMethodParameters("EnableStatic"); 

         newIP["IPAddress"] = new string[] { ip_address }; 
         newIP["SubnetMask"] = new string[] { subnet_mask }; 

         setIP = objMO.InvokeMethod("EnableStatic", newIP, null); 
        } 
        catch (Exception) 
        { 
         throw; 
        } 


       } 
      } 
     } 
     /// <summary> 
     /// Set's a new Gateway address of the local machine 
     /// </summary> 
     /// <param name="gateway">The Gateway IP Address</param> 
     /// <remarks>Requires a reference to the System.Management namespace</remarks> 
     public void setGateway(string gateway) 
     { 
      ManagementClass objMC = new ManagementClass("Win32_NetworkAdapterConfiguration"); 
      ManagementObjectCollection objMOC = objMC.GetInstances(); 

      foreach (ManagementObject objMO in objMOC) 
      { 
       if ((bool)objMO["IPEnabled"]) 
       { 
        try 
        { 
         ManagementBaseObject setGateway; 
         ManagementBaseObject newGateway = 
          objMO.GetMethodParameters("SetGateways"); 

         newGateway["DefaultIPGateway"] = new string[] { gateway }; 
         newGateway["GatewayCostMetric"] = new int[] { 1 }; 

         setGateway = objMO.InvokeMethod("SetGateways", newGateway, null); 
        } 
        catch (Exception) 
        { 
         throw; 
        } 
       } 
      } 
     } 
     /// <summary> 
     /// Set's the DNS Server of the local machine 
     /// </summary> 
     /// <param name="NIC">NIC address</param> 
     /// <param name="DNS">DNS server address</param> 
     /// <remarks>Requires a reference to the System.Management namespace</remarks> 
     public void setDNS(string NIC, string DNS) 
     { 
      ManagementClass objMC = new ManagementClass("Win32_NetworkAdapterConfiguration"); 
      ManagementObjectCollection objMOC = objMC.GetInstances(); 

      foreach (ManagementObject objMO in objMOC) 
      { 
       if ((bool)objMO["IPEnabled"]) 
       { 
        // if you are using the System.Net.NetworkInformation.NetworkInterface you'll need to change this line to if (objMO["Caption"].ToString().Contains(NIC)) and pass in the Description property instead of the name 
        if (objMO["Caption"].Equals(NIC)) 
        { 
         try 
         { 
          ManagementBaseObject newDNS = 
           objMO.GetMethodParameters("SetDNSServerSearchOrder"); 
          newDNS["DNSServerSearchOrder"] = DNS.Split(','); 
          ManagementBaseObject setDNS = 
           objMO.InvokeMethod("SetDNSServerSearchOrder", newDNS, null); 
         } 
         catch (Exception) 
         { 
          throw; 
         } 
        } 
       } 
      } 
     } 
     /// <summary> 
     /// Set's WINS of the local machine 
     /// </summary> 
     /// <param name="NIC">NIC Address</param> 
     /// <param name="priWINS">Primary WINS server address</param> 
     /// <param name="secWINS">Secondary WINS server address</param> 
     /// <remarks>Requires a reference to the System.Management namespace</remarks> 
     public void setWINS(string NIC, string priWINS, string secWINS) 
     { 
      ManagementClass objMC = new ManagementClass("Win32_NetworkAdapterConfiguration"); 
      ManagementObjectCollection objMOC = objMC.GetInstances(); 

      foreach (ManagementObject objMO in objMOC) 
      { 
       if ((bool)objMO["IPEnabled"]) 
       { 
        if (objMO["Caption"].Equals(NIC)) 
        { 
         try 
         { 
          ManagementBaseObject setWINS; 
          ManagementBaseObject wins = 
          objMO.GetMethodParameters("SetWINSServer"); 
          wins.SetPropertyValue("WINSPrimaryServer", priWINS); 
          wins.SetPropertyValue("WINSSecondaryServer", secWINS); 

          setWINS = objMO.InvokeMethod("SetWINSServer", wins, null); 
         } 
         catch (Exception) 
         { 
          throw; 
         } 
        } 
       } 
      } 
     } 
    } 
} 

Answer 2

espero que no le importa que le envía a un ejemplo, pero esto es realmente un ejemplo perfecto: http://www.codeproject.com/KB/cs/oazswitchnetconfig.aspx

Answer 3

me gusta la solución WMILinq. Aunque no es exactamente la solución a su problema, encuentra por debajo de un sabor de la misma:

using (WmiContext context = new WmiContext(@"\\.")) { 

    context.ManagementScope.Options.Impersonation = ImpersonationLevel.Impersonate; 
    context.Log = Console.Out; 

    var dnss = from nic in context.Source<Win32_NetworkAdapterConfiguration>() 
      where nic.IPEnabled 
      select nic; 

    var ips = from s in dnss.SelectMany(dns => dns.DNSServerSearchOrder) 
      select IPAddress.Parse(s); 
} 

http://www.codeplex.com/linq2wmi

Answer 4

refactorizado el código de balexandre un poco de lo que los objetos consigue eliminarse y las nuevas características del lenguaje de C# 3.5 + se utilizan (Linq, var, etc.). También se cambió el nombre de las variables a nombres más significativos. También fusioné algunas de las funciones para poder hacer más configuraciones con menos interacción de WMI. Eliminé el código WINS porque ya no necesito configurar WINS. Siéntase libre de agregar el código WINS si lo necesita.

Para el caso de que alguien le gusta usar el código refactorizado/modernizado lo puse de nuevo en la comunidad aquí.

/// <summary> 
/// Helper class to set networking configuration like IP address, DNS servers, etc. 
/// </summary> 
public class NetworkConfigurator 
{ 
    /// <summary> 
    /// Set's a new IP Address and it's Submask of the local machine 
    /// </summary> 
    /// <param name="ipAddress">The IP Address</param> 
    /// <param name="subnetMask">The Submask IP Address</param> 
    /// <param name="gateway">The gateway.</param> 
    /// <remarks>Requires a reference to the System.Management namespace</remarks> 
    public void SetIP(string ipAddress, string subnetMask, string gateway) 
    { 
     using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
     { 
      using (var networkConfigs = networkConfigMng.GetInstances()) 
      { 
       foreach (var managementObject in networkConfigs.Cast<ManagementObject>().Where(managementObject => (bool)managementObject["IPEnabled"])) 
       { 
        using (var newIP = managementObject.GetMethodParameters("EnableStatic")) 
        { 
         // Set new IP address and subnet if needed 
         if ((!String.IsNullOrEmpty(ipAddress)) || (!String.IsNullOrEmpty(subnetMask))) 
         { 
          if (!String.IsNullOrEmpty(ipAddress)) 
          { 
           newIP["IPAddress"] = new[] { ipAddress }; 
          } 

          if (!String.IsNullOrEmpty(subnetMask)) 
          { 
           newIP["SubnetMask"] = new[] { subnetMask }; 
          } 

          managementObject.InvokeMethod("EnableStatic", newIP, null); 
         } 

         // Set mew gateway if needed 
         if (!String.IsNullOrEmpty(gateway)) 
         { 
          using (var newGateway = managementObject.GetMethodParameters("SetGateways")) 
          { 
           newGateway["DefaultIPGateway"] = new[] { gateway }; 
           newGateway["GatewayCostMetric"] = new[] { 1 }; 
           managementObject.InvokeMethod("SetGateways", newGateway, null); 
          } 
         } 
        } 
       } 
      } 
     } 
    } 

    /// <summary> 
    /// Set's the DNS Server of the local machine 
    /// </summary> 
    /// <param name="nic">NIC address</param> 
    /// <param name="dnsServers">Comma seperated list of DNS server addresses</param> 
    /// <remarks>Requires a reference to the System.Management namespace</remarks> 
    public void SetNameservers(string nic, string dnsServers) 
    { 
     using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
     { 
      using (var networkConfigs = networkConfigMng.GetInstances()) 
      { 
       foreach (var managementObject in networkConfigs.Cast<ManagementObject>().Where(objMO => (bool)objMO["IPEnabled"] && objMO["Caption"].Equals(nic))) 
       { 
        using (var newDNS = managementObject.GetMethodParameters("SetDNSServerSearchOrder")) 
        { 
         newDNS["DNSServerSearchOrder"] = dnsServers.Split(','); 
         managementObject.InvokeMethod("SetDNSServerSearchOrder", newDNS, null); 
        } 
       } 
      } 
     } 
    } 
} 

Answer 5

cambio de IP dinámica en C# es muy fácil ...

Por favor, mire debajo de código y visitar: http://microsoftdotnetsolutions.blogspot.in/2012/12/dynamic-ip-change-in-c.html

Answer 6

Las respuestas existentes tienen código bastante roto. El método DNS no funciona en absoluto. Aquí está el código que he utilizado para configurar mi tarjeta de red:

public static class NetworkConfigurator 
{ 
    /// <summary> 
    /// Set's a new IP Address and it's Submask of the local machine 
    /// </summary> 
    /// <param name="ipAddress">The IP Address</param> 
    /// <param name="subnetMask">The Submask IP Address</param> 
    /// <param name="gateway">The gateway.</param> 
    /// <param name="nicDescription"></param> 
    /// <remarks>Requires a reference to the System.Management namespace</remarks> 
    public static void SetIP(string nicDescription, string[] ipAddresses, string subnetMask, string gateway) 
    { 
     using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
     { 
      using (var networkConfigs = networkConfigMng.GetInstances()) 
      { 
       foreach (var managementObject in networkConfigs.Cast<ManagementObject>().Where(mo => (bool)mo["IPEnabled"] && (string)mo["Description"] == nicDescription)) 
       { 
        using (var newIP = managementObject.GetMethodParameters("EnableStatic")) 
        { 
         // Set new IP address and subnet if needed 
         if (ipAddresses != null || !String.IsNullOrEmpty(subnetMask)) 
         { 
          if (ipAddresses != null) 
          { 
           newIP["IPAddress"] = ipAddresses; 
          } 

          if (!String.IsNullOrEmpty(subnetMask)) 
          { 
           newIP["SubnetMask"] = Array.ConvertAll(ipAddresses, _ => subnetMask); 
          } 

          managementObject.InvokeMethod("EnableStatic", newIP, null); 
         } 

         // Set mew gateway if needed 
         if (!String.IsNullOrEmpty(gateway)) 
         { 
          using (var newGateway = managementObject.GetMethodParameters("SetGateways")) 
          { 
           newGateway["DefaultIPGateway"] = new[] { gateway }; 
           newGateway["GatewayCostMetric"] = new[] { 1 }; 
           managementObject.InvokeMethod("SetGateways", newGateway, null); 
          } 
         } 
        } 
       } 
      } 
     } 
    } 

    /// <summary> 
    /// Set's the DNS Server of the local machine 
    /// </summary> 
    /// <param name="nic">NIC address</param> 
    /// <param name="dnsServers">Comma seperated list of DNS server addresses</param> 
    /// <remarks>Requires a reference to the System.Management namespace</remarks> 
    public static void SetNameservers(string nicDescription, string[] dnsServers) 
    { 
     using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
     { 
      using (var networkConfigs = networkConfigMng.GetInstances()) 
      { 
       foreach (var managementObject in networkConfigs.Cast<ManagementObject>().Where(mo => (bool)mo["IPEnabled"] && (string)mo["Description"] == nicDescription)) 
       { 
        using (var newDNS = managementObject.GetMethodParameters("SetDNSServerSearchOrder")) 
        { 
         newDNS["DNSServerSearchOrder"] = dnsServers; 
         managementObject.InvokeMethod("SetDNSServerSearchOrder", newDNS, null); 
        } 
       } 
      } 
     } 
    } 
} 

Answer 7

Un ejemplo un poco más concisa que se acumula en la parte superior de las otras respuestas aquí. Aproveché la generación de código que se incluye con Visual Studio para eliminar la mayor parte del código de invocación adicional y reemplazarlo con objetos tipados.

using System; 
    using System.Management; 

    namespace Utils 
    { 
     class NetworkManagement 
     { 
      /// <summary> 
      /// Returns a list of all the network interface class names that are currently enabled in the system 
      /// </summary> 
      /// <returns>list of nic names</returns> 
      public static string[] GetAllNicDescriptions() 
      { 
       List<string> nics = new List<string>(); 

       using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
       { 
        using (var networkConfigs = networkConfigMng.GetInstances()) 
        { 
         foreach (var config in networkConfigs.Cast<ManagementObject>() 
                      .Where(mo => (bool)mo["IPEnabled"]) 
                      .Select(x=> new NetworkAdapterConfiguration(x))) 
         { 
          nics.Add(config.Description); 
         } 
        } 
       } 

       return nics.ToArray(); 
      } 

      /// <summary> 
      /// Set's the DNS Server of the local machine 
      /// </summary> 
      /// <param name="nicDescription">The full description of the network interface class</param> 
      /// <param name="dnsServers">Comma seperated list of DNS server addresses</param> 
      /// <remarks>Requires a reference to the System.Management namespace</remarks> 
      public static bool SetNameservers(string nicDescription, string[] dnsServers, bool restart = false) 
      { 
       using (ManagementClass networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
       { 
        using (ManagementObjectCollection networkConfigs = networkConfigMng.GetInstances()) 
        { 
         foreach (ManagementObject mboDNS in networkConfigs.Cast<ManagementObject>().Where(mo => (bool)mo["IPEnabled"] && (string)mo["Description"] == nicDescription)) 
         { 
          // NAC class was generated by opening a developer console and entering: 
          // mgmtclassgen Win32_NetworkAdapterConfiguration -p NetworkAdapterConfiguration.cs 
          // See: http://blog.opennetcf.com/2008/06/24/disableenable-network-connections-under-vista/ 

          using (NetworkAdapterConfiguration config = new NetworkAdapterConfiguration(mboDNS)) 
          { 
           if (config.SetDNSServerSearchOrder(dnsServers) == 0) 
           { 
            RestartNetworkAdapter(nicDescription); 
           } 
          } 
         } 
        } 
       } 

       return false; 
      } 

      /// <summary> 
      /// Restarts a given Network adapter 
      /// </summary> 
      /// <param name="nicDescription">The full description of the network interface class</param> 
      public static void RestartNetworkAdapter(string nicDescription) 
      { 
       using (ManagementClass networkConfigMng = new ManagementClass("Win32_NetworkAdapter")) 
       { 
        using (ManagementObjectCollection networkConfigs = networkConfigMng.GetInstances()) 
        { 
         foreach (ManagementObject mboDNS in networkConfigs.Cast<ManagementObject>().Where(mo=> (string)mo["Description"] == nicDescription)) 
         { 
          // NA class was generated by opening dev console and entering 
          // mgmtclassgen Win32_NetworkAdapter -p NetworkAdapter.cs 
          using (NetworkAdapter adapter = new NetworkAdapter(mboDNS)) 
          { 
           adapter.Disable(); 
           adapter.Enable(); 
           Thread.Sleep(4000); // Wait a few secs until exiting, this will give the NIC enough time to re-connect 
           return; 
          } 
         } 
        } 
       } 
      } 

      /// <summary> 
      /// Get's the DNS Server of the local machine 
      /// </summary> 
      /// <param name="nicDescription">The full description of the network interface class</param> 
      public static string[] GetNameservers(string nicDescription) 
      { 
       using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
       { 
        using (var networkConfigs = networkConfigMng.GetInstances()) 
        { 
         foreach (var config in networkConfigs.Cast<ManagementObject>() 
                   .Where(mo => (bool)mo["IPEnabled"] && (string)mo["Description"] == nicDescription) 
                   .Select(x => new NetworkAdapterConfiguration(x))) 
         { 
          return config.DNSServerSearchOrder; 
         } 
        } 
       } 

       return null; 
      } 

      /// <summary> 
      /// Set's a new IP Address and it's Submask of the local machine 
      /// </summary> 
      /// <param name="nicDescription">The full description of the network interface class</param> 
      /// <param name="ipAddresses">The IP Address</param> 
      /// <param name="subnetMask">The Submask IP Address</param> 
      /// <param name="gateway">The gateway.</param> 
      /// <remarks>Requires a reference to the System.Management namespace</remarks> 
      public static void SetIP(string nicDescription, string[] ipAddresses, string subnetMask, string gateway) 
      { 
       using (var networkConfigMng = new ManagementClass("Win32_NetworkAdapterConfiguration")) 
       { 
        using (var networkConfigs = networkConfigMng.GetInstances()) 
        { 
         foreach (var config in networkConfigs.Cast<ManagementObject>() 
                     .Where(mo => (bool)mo["IPEnabled"] && (string)mo["Description"] == nicDescription) 
                     .Select(x=> new NetworkAdapterConfiguration(x))) 
         { 
          // Set the new IP and subnet masks if needed 
          config.EnableStatic(ipAddresses, Array.ConvertAll(ipAddresses, _ => subnetMask)); 

          // Set mew gateway if needed 
          if (!String.IsNullOrEmpty(gateway)) 
          { 
           config.SetGateways(new[] {gateway}, new ushort[] {1}); 
          } 
         } 
        } 
       } 
      } 

     } 
    } 

fuente completo: https://github.com/sverrirs/DnsHelper/blob/master/src/DnsHelperUI/NetworkManagement.cs