C＃将首选和备用dns地址分成变量 [英] C# separate preferred and alternate dns addresses into variables

问题描述

我有一个c＃脚本，它将检索NIC的首选和备用DNS地址。但是，我无法将每个变量放入一个单独的变量中。我的脚本将给出以下输出作为示例：192.168.30.1192.168.30.2



我尝试使用子字符串，但它会切断两个IP的值。输出看起来像一个字符串，但我不能像一个字符串格式化。



关于如何在每个dns入口IP中使用自己的变量的想法？任何帮助将不胜感激



提前谢谢你。以下是我的脚本的一部分：

  class 计划
 {
 静态  void  Main（ string  [] args）
 {
 
  string  dns_name_one =  ; 
 NetworkInterface [] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces（）; 
 
  foreach （NetworkInterface networkInterface  in  networkInterfaces）
 {
  if （networkInterface.OperationalStatus == OperationalStatus.Up）
 {
 IPInterfaceProperties ipProperties = networkInterface.GetIPProperties（）; 
 IPAddressCollection dnsAddresses = ipProperties.DnsAddresses; 
 
  foreach （IPAddress dns  in  dnsAddresses）
 {
 dns_name_one = Convert.ToString（dns）; 
 Console.Write（dns_name_one）; 
} 
 Console.ReadLine（）; 
} 
} 
 
 
 
} 
} 

我尝试过：



使用子字符串编辑我想要将其放入变量的内容。尝试研究一种获得首选或替代dns IP的方法。

解决方案

在你最内层的循环中， dns 是一个IPAddress对象，所以要在字符串中获取它，你只需要调用它的 .ToString（）方法。

< pre lang =C＃> foreach （IPAddress dns in dnsAddresses）
{
dns_name_one = dns.ToString（）;
Console.Write（dns_name_one）;
}

现在，没有一种简洁的方法可以将每个地址放入自己的变量中，因为你不知道你要使用多少个地址得到。所以，你不要把每个地址放在它自己的变量中。你把它们放在一个系列中。



但是！你已经在一个集合中拥有它们了。 IPAddressCollection dnsAddresses 是IPAddress对象的集合。



问题是你想用它们做什么？要将地址以可读格式转储到控制台，它只是：

  foreach （IPAddress address  dnsAddresses中的class =code-keyword> 
 Console.WriteLine（地址）; 

对的调用在这种情况下，地址上的.ToString（）是自动的。



I可能会使用这样的东西来返回Dns IP地址的集合：

  static  IList< IPAddress> GetCurrentDnsServersForActiveInterfaces（）
 {
 List< IPAddress> returnAddresses =  new  List< IPAddress>（）; 
 
 NetworkInterface [] nics = NetworkInterface.GetAllNetworkInterfaces（）; 
 
  foreach （ var  nic  in  nics）
 {
  if （nic.OperationalStatus == OperationalStatus.Up）
 {
 IPInterfaceProperties ipProperties = nic.GetIPProperties（）; 
 IPAddressCollection addresses = ipProperties.DnsAddresses; 
 
  foreach （IP地址 地址）
 {
 returnAddresses.Add（address）; 
} 
} 
} 
 
  return  returnAddresses; 
} 
 

这将返回所有活动适配器的所有活动DNS服务器地址，包括IPv4和IPv6 。

Quote：

我的脚本将提供以下输出作为示例：192.168.30.1192.168.30 .2

首先，您需要更改脚本以在每个IP地址后或每个IP地址后附加一个分隔符。

like：192.168.30.1- 192.168.30.2-

然后将脚本输出分成ip地址很容易。



如果你想使用那些ip in您可能希望将它们存储在可调整大小的列表中的脚本。

这是一些帮助:)



<$ p $使用系统;
使用System.Collections.Generic;
使用System.Diagnostics;
使用System.IO;
使用System.Linq.Expressions;
使用System.Management;
使用System.Threading;

///< summary>
///一个Helper类，它提供了设置/获取网络配置的便捷方法。
///< / summary>
公共静态类WmiHelper
{
///< summary>
///在NIC（网络接口卡）上启用DHCP。
///< / summary>
///< param name =nicName> NIC的名称。< / param>
public static void SetDhcp（string nicName）
{
var mc = new ManagementClass（Win32_NetworkAdapterConfiguration）;
var moc = mc.GetInstances（）;

foreach（ManagementObject mo in moc）
{
//确保这是一个支持IP的设备。不像存储卡或VM Ware
if（（bool）mo [IPEnabled]）
{
if（mo [Caption] .Equals（nicName））
{
ManagementBaseObject newDns = mo.GetMethodParameters（SetDNSServerSearchOrder）;
newDns [DNSServerSearchOrder] = null;
ManagementBaseObject enableDhcp = mo.InvokeMethod（EnableDHCP，null，null）;
ManagementBaseObject setDns = mo.InvokeMethod（SetDNSServerSearchOrder，newDns，null）;
}
}
}
}

///< summary>
///为指定的网卡名称设置IP
/// Win32_NetworkAdapterConfiguration类的EnableStatic方法：
/// https://msdn.microsoft.com/en-us/ library / aa390383（v = vs.85）.aspx
///< / summary>
///< param name =nicName>网卡的标题< / param>
///< param name =ipAddresses>包含一个或多个IP< / param>的逗号分隔字符串
///< param name =subnetMask>子网掩码< / param>
///< param name =gateway> Gateway IP< / param>
///< param name =dnsSearchOrder>以逗号分隔的DNS IP< / param>
///< returns>带有错误消息的字符串，成功时为空。< / returns>
public static string SetIp（
string nicName，
string ipAddresses，
string subnetMask，
string gateway，
string dnsSearchOrder）
{
尝试
{
////返回成功测试;

if（string.IsNullOrEmpty（ipAddresses）|| string.IsNullOrEmpty（subnetMask））
{
return错误：IP地址或子网掩码不能为空。;
}

var mc = new ManagementClass（Win32_NetworkAdapterConfiguration）;
var moc = mc.GetInstances（）;

foreach（ManagementObject mo in moc）
{
//确保这是一个支持IP的设备。不像存储卡或VM Ware
//// if（（bool）mo [IPEnabled]）
{
if（mo [Caption]。Equals（nicName） ）
{
ManagementBaseObject setIp = null;
int retries = 0;

for（int retry = 0; retry< 5; retry ++）
{
mo [IPEnabled] = false;

if（！string.IsNullOrEmpty（gateway））
{
ManagementBaseObject newGate = mo.GetMethodParameters（SetGateways）;
newGate [DefaultIPGateway] = new [] {gateway};
newGate [GatewayCostMetric] = new [] {1};
ManagementBaseObject setGateways = mo.InvokeMethod（SetGateways，newGate，null）;
}

if（！string.IsNullOrEmpty（dnsSearchOrder））
{
ManagementBaseObject newDns = mo.GetMethodParameters（SetDNSServerSearchOrder）;
newDns [DNSServerSearchOrder] = dnsSearchOrder.Split（'，'）;
ManagementBaseObject setDns = mo.InvokeMethod（SetDNSServerSearchOrder，newDns，null）;
}

ManagementBaseObject newIp = mo.GetMethodParameters（EnableStatic）;
newIp [IPAddress] = ipAddresses.Split（'，'）;
newIp [SubnetMask] = subnetMask.Split（'，'）;
mo [IPEnabled] = true;
setIp = mo.InvokeMethod（EnableStatic，newIp，null）;
Thread.Sleep（100）;

var ip = ipAddresses.Split（'，'）[0];
var ipCheck =（（string []）mo [IPAddress]）[0];

if（ip == ipCheck）
{
//成功。
休息;
}
else
{
retries ++;
}
}

if（setIp == null）
{
return错误：SetIp（）失败;
}

var result = setIp.Properties [ReturnValue];
Debug.Print（WmiHelper.SetIp（）result =+ result.Value）;

switch（Convert.ToUInt32（result.Value））
{
case 0：
if（retries> 0）
{
返回成功后+重试+重试;
}

Debug.Print（成功！）;
返回成功;
案例1：
返回成功但需要重新启动;

案例64：
返回您的Plattform不支持​​;

case 66：
返回invalid Subnetmask+ subnetMask;

案例68：
返回无效参数;

案例70：
返回无效的IP地址+ ipAddresses;

案例71：
返回无效网关IP地址+网关;

case 80：
返回无法配置TCP / IP服务;

案例81：
返回无法配置DHCP服务;

case 84：
返回适配器未启用IP;

案例90：
返回参数越界;

案例91：
返回拒绝访问;

案例92：
返回内存不足;

case 100：
返回未在适配器上启用DHCP;

case 2147786788：
returnWrite lock not enabled！;

默认值：
返回错误+ result.Value;
}

休息;
}
}
}
}
catch（Exception ex）
{
Debug.Print（ex.Message）;
}

//好的
返回成功;
}

///< summary>
///返回指定NIC的网卡配置
///< / summary>
///< param name =nicName> NIC的名称< / param>
///< param name =ipAdresses> IP数组< / param>
///< param name =subnets>子网掩码数组< / param>
///< param name =gateways>网关数组< / param>
///< param name =dnses> DNS IP数组< / param>
///< param name =dhcp> dhcp。< / param>
public static void GetIp（
string nicName，
out string [] ipAdresses，
out string [] subnets，
out string [] gateways，
out string [] dnses，
out bool dhcp）
{
ipAdresses = null;
subnets = null;
gateways = null;
dnses = null;
dhcp = false;

var mc = new ManagementClass（Win32_NetworkAdapterConfiguration）;
var moc = mc.GetInstances（）;
Debug.Print（nicName =+ nicName）;

foreach（var mo in moc）
{
//确保这是一个支持IP的设备。不像存储卡或VM Ware
// if（（bool）mo [ipEnabled]）
{
string nicNameWmi = mo [Caption]。ToString（）;
Debug.Print（nicNameWmi =+ nicNameWmi）;

// if（mo [Caption] .Equals（nicName））
if（nicNameWmi.Contains（nicName））
{
//// foreach（mo.Properties中的var属性）
//// {
//// Debug.Print（property.Name）;
////}

ipAdresses =（string []）mo [IPAddress];
subnets =（string []）mo [IPSubnet];
gateways =（string []）mo [DefaultIPGateway];
dnses =（string []）mo [DNSServerSearchOrder];
dhcp =（bool）mo [DHCPEnabled];
////Debug.Print(\"DHCPEnabled =+ dhcp）;
休息;
}
}
}
}

///< summary>
///返回已安装的网络接口列表
///< / summary>
///< returns>字符串< / returns>的数组列表
public static List< string> GetNicNames（）
{
var nicNames = new List< string>（）;
var mc = new ManagementClass（Win32_NetworkAdapterConfiguration）;
var moc = mc.GetInstances（）;

foreach（var mo in moc）
{
if（（bool）mo [ipEnabled]）
{
nicNames.Add（mo [ 标题]的ToString（））;
}
}

返回nicNames;
}
}

Hi,

I have a c# script that will retrieve the preferred and alternate dns addresses of a NIC. However, I'm having trouble putting each one into a separate variable. My script will give the following output as an example: 192.168.30.1192.168.30.2

I have tried using a substring, but it will cut off values from both IPs. The output looks like one string, but I can't format it like one.

Any ideas on how to get each dns entry IP in it's own variable? Any help would be much appreciated

Thank you in advance. Below is part of my script:

class Program
    {
        static void Main(string[] args)
        {

           string dns_name_one = "";
           NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

            foreach (NetworkInterface networkInterface in networkInterfaces)
            {
                if (networkInterface.OperationalStatus == OperationalStatus.Up)
                {
                    IPInterfaceProperties ipProperties = networkInterface.GetIPProperties();
                    IPAddressCollection dnsAddresses = ipProperties.DnsAddresses;

                    foreach (IPAddress dns in dnsAddresses)
                    {
                        dns_name_one = Convert.ToString(dns);
                        Console.Write(dns_name_one);
                    }
                    Console.ReadLine();
                }
            }
                    
                
            
        }
    }

What I have tried:

Using a substring to edit what I want to put it in a variable. Try researching a way to just get the preferred, or alternate dns IP.

解决方案

In your inner-most loop, dns is an IPAddress object, so to get it in a string, you just need to call its .ToString() method.

foreach (IPAddress dns in dnsAddresses)
{
    dns_name_one = dns.ToString();
    Console.Write(dns_name_one);
}

Now, there isn't a neat way to get each address into its own variable because you have no idea how many addresses you're going to get. So, you don't put each address in it's own variable. You put them in a collection.

But! You ALREADY have them in a collection. The IPAddressCollection dnsAddresses is a collection of IPAddress objects.

The question is what do you want to do with them? To dump the address in readable format to the console, it's just:

foreach (IPAddress address in dnsAddresses)
    Console.WriteLine(address);

The call to .ToString() on the address is automatic in this case.

I'd probably use something like this to return a collection of Dns IPAddresses:

static IList<IPAddress> GetCurrentDnsServersForActiveInterfaces()
{
    List<IPAddress> returnAddresses = new List<IPAddress>();

    NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();

    foreach (var nic in nics)
    {
        if (nic.OperationalStatus == OperationalStatus.Up)
        {
            IPInterfaceProperties ipProperties = nic.GetIPProperties();
            IPAddressCollection addresses = ipProperties.DnsAddresses;

            foreach (IPAddress address in addresses)
            {
                returnAddresses.Add(address);
            }
        }
    }

    return returnAddresses;
}

That will return all active DNS server addresses, both IPv4 and IPv6, for all active adapters.

Quote:

My script will give the following output as an example: 192.168.30.1192.168.30.2

First of all, you need to change your script to append a separator after each ip address or after each.
like: 192.168.30.1-192.168.30.2-
Then it will be easy to split the script output into ip addresses.

If you want to use those ip in the script you may want to store them in a resizeable list.

Here is some help :)

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq.Expressions;
using System.Management;
using System.Threading;

/// <summary>
/// A Helper class which provides convenient methods to set/get network configuration.
/// </summary>
public static class WmiHelper
{
    /// <summary>
    /// Enable DHCP on the NIC (Network Interface Card).
    /// </summary>
    /// <param name="nicName">Name of the NIC.</param>
    public static void SetDhcp(string nicName)
    {
        var mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
        var moc = mc.GetInstances();

        foreach (ManagementObject mo in moc)
        {
            // Make sure this is a IP enabled device. Not something like memory card or VM Ware
            if ((bool)mo["IPEnabled"])
            {
                if (mo["Caption"].Equals(nicName))
                {
                    ManagementBaseObject newDns = mo.GetMethodParameters("SetDNSServerSearchOrder");
                    newDns["DNSServerSearchOrder"] = null;
                    ManagementBaseObject enableDhcp = mo.InvokeMethod("EnableDHCP", null, null);
                    ManagementBaseObject setDns = mo.InvokeMethod("SetDNSServerSearchOrder", newDns, null);
                }
            }
        }
    }

    /// <summary>
    /// Set IP for the specified network card name
    /// EnableStatic method of the Win32_NetworkAdapterConfiguration class:
    /// https://msdn.microsoft.com/en-us/library/aa390383(v=vs.85).aspx
    /// </summary>
    /// <param name="nicName">Caption of the network card</param>
    /// <param name="ipAddresses">Comma delimited string containing one or more IP</param>
    /// <param name="subnetMask">Subnet mask</param>
    /// <param name="gateway">Gateway IP</param>
    /// <param name="dnsSearchOrder">Comma delimited DNS IP</param>
    /// <returns>A string with an error message, empty on success.</returns>
    public static string SetIp(
        string nicName,
        string ipAddresses,
        string subnetMask,
        string gateway,
        string dnsSearchOrder)
    {
        try
        {
            ////return "Success TESTING";

            if (string.IsNullOrEmpty(ipAddresses) || string.IsNullOrEmpty(subnetMask))
            {
                return "Error: IP address or subnet mask can not be empty.";
            }

            var mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
            var moc = mc.GetInstances();

            foreach (ManagementObject mo in moc)
            {
                // Make sure this is a IP enabled device. Not something like memory card or VM Ware
                ////if ((bool)mo["IPEnabled"])
                {
                    if (mo["Caption"].Equals(nicName))
                    {
                        ManagementBaseObject setIp = null;
                        int retries = 0;

                        for (int retry = 0; retry < 5; retry++)
                        {
                            mo["IPEnabled"] = false;

                            if (!string.IsNullOrEmpty(gateway))
                            {
                                ManagementBaseObject newGate = mo.GetMethodParameters("SetGateways");
                                newGate["DefaultIPGateway"] = new[] { gateway };
                                newGate["GatewayCostMetric"] = new[] { 1 };
                                ManagementBaseObject setGateways = mo.InvokeMethod("SetGateways", newGate, null);
                            }

                            if (!string.IsNullOrEmpty(dnsSearchOrder))
                            {
                                ManagementBaseObject newDns = mo.GetMethodParameters("SetDNSServerSearchOrder");
                                newDns["DNSServerSearchOrder"] = dnsSearchOrder.Split(',');
                                ManagementBaseObject setDns = mo.InvokeMethod("SetDNSServerSearchOrder", newDns, null);
                            }

                            ManagementBaseObject newIp = mo.GetMethodParameters("EnableStatic");
                            newIp["IPAddress"] = ipAddresses.Split(',');
                            newIp["SubnetMask"] = subnetMask.Split(',');
                            mo["IPEnabled"] = true;
                            setIp = mo.InvokeMethod("EnableStatic", newIp, null);
                            Thread.Sleep(100);

                            var ip = ipAddresses.Split(',')[0];
                            var ipCheck = ((string[])mo["IPAddress"])[0];

                            if (ip == ipCheck)
                            {
                                // Success.
                                break;
                            }
                            else
                            {
                                retries++;
                            }
                        }

                        if (setIp == null)
                        {
                            return "Error: SetIp() failed";
                        }

                        var result = setIp.Properties["ReturnValue"];
                        Debug.Print("WmiHelper.SetIp() result = " + result.Value);

                        switch (Convert.ToUInt32(result.Value))
                        {
                            case 0:
                                if (retries > 0)
                                {
                                    return "Success after " + retries + " retries";
                                }

                                Debug.Print("Success !");
                                return "Success";
                            case 1:
                                return "Success but reboot required";

                            case 64:
                                return "Not supported on your Plattform";

                            case 66:
                                return "invalid Subnetmask " + subnetMask;

                            case 68:
                                return "invalid parameter";

                            case 70:
                                return "invalid IP-Address " + ipAddresses;

                            case 71:
                                return "invalid gateway IP address " + gateway;

                            case 80:
                                return "Unable to configure TCP/IP service";

                            case 81:
                                return "Unable to configure DHCP service";

                            case 84:
                                return "IP not enabled on adapter";

                            case 90:
                                return "Parameter out of bounds";

                            case 91:
                                return "Access denied";

                            case 92:
                                return "Out of memory";

                            case 100:
                                return "DHCP not enabled on adapter";

                            case 2147786788:
                                return "Write lock not enabled !";

                            default:
                                return "Error " + result.Value;
                        }

                        break;
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Debug.Print(ex.Message);
        }

        // Ok.
        return "Success";
    }

    /// <summary>
    /// Returns the network card configuration of the specified NIC
    /// </summary>
    /// <param name="nicName">Name of the NIC</param>
    /// <param name="ipAdresses">Array of IP</param>
    /// <param name="subnets">Array of subnet masks</param>
    /// <param name="gateways">Array of gateways</param>
    /// <param name="dnses">Array of DNS IPs</param>
    /// <param name="dhcp">The dhcp.</param>
    public static void GetIp(
        string nicName,
        out string[] ipAdresses,
        out string[] subnets,
        out string[] gateways,
        out string[] dnses,
        out bool dhcp)
    {
        ipAdresses = null;
        subnets = null;
        gateways = null;
        dnses = null;
        dhcp = false;

        var mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
        var moc = mc.GetInstances();
        Debug.Print("nicName = " + nicName);

        foreach (var mo in moc)
        {
            // Make sure this is a IP enabled device. Not something like memory card or VM Ware
            //if ((bool)mo["ipEnabled"])
            {
                string nicNameWmi = mo["Caption"].ToString();
                Debug.Print("nicNameWmi = " + nicNameWmi);

                //if (mo["Caption"].Equals(nicName))
                if (nicNameWmi.Contains(nicName))
                {
                    ////foreach (var property in mo.Properties)
                    ////{
                    ////    Debug.Print(property.Name);
                    ////}

                    ipAdresses = (string[])mo["IPAddress"];
                    subnets = (string[])mo["IPSubnet"];
                    gateways = (string[])mo["DefaultIPGateway"];
                    dnses = (string[])mo["DNSServerSearchOrder"];
                    dhcp = (bool)mo["DHCPEnabled"];
                    ////Debug.Print("DHCPEnabled = " + dhcp);
                    break;
                }
            }
        }
    }

    /// <summary>
    /// Returns the list of Network Interfaces installed
    /// </summary>
    /// <returns>Array list of string</returns>
    public static List<string> GetNicNames()
    {
        var nicNames = new List<string>();
        var mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
        var moc = mc.GetInstances();

        foreach (var mo in moc)
        {
            if ((bool)mo["ipEnabled"])
            {
                nicNames.Add(mo["Caption"].ToString());
            }
        }

        return nicNames;
    }
}

这篇关于C＃将首选和备用dns地址分成变量的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！