大网数据广告活动
Hyper-V与虚拟化

Querying networking objects

· 52CE 我爱测

The following C# sample retrieves and displays physical and virtual network information for the specified switch.

The following C# sample retrieves and displays physical and virtual network information for the specified switch. This code is taken from the Hyper-V networking sample.

The command-line syntax to run this sample is:

NetworkingSamples.exe EnumerateSwitch SwitchName

where SwitchName is the name of the switch to display the information for. The switch name is contained in the Msvm_VirtualEthernetSwitch.ElementName property.

namespace Microsoft.Samples.HyperV.Networking
{
    using System;
    using System.Management;
    using System.Globalization;
    using System.Collections.Generic;
    using Microsoft.Samples.HyperV.Common;

    static class EnumerateSwitchSample
    {
        /// <summary>
        /// The type of network connection for a switch.
        /// </summary>
        enum SwitchConnectionType
        {
            Private,
            Internal,
            ExternalOnly,
            External
        }

        /// <summary>
        /// The type of connection for a single port.
        /// </summary>
        enum PortConnectionType
        {
            Nothing,
            Internal,
            External,
            VirtualMachine
        }

        /// <summary>
        /// Container for information about a port.
        /// </summary>
        struct PortInfo
        {
            public PortConnectionType Type;
            public string ConnectedName;
            public List<NetworkingUtilities.PortFeatureType> FeatureList;
        }

        /// <summary>
        /// Container for information about the switch.
        /// </summary>
        struct SwitchInfo
        {
            public string Name;
            public SwitchConnectionType Type;
            public List<PortInfo> PortList;
            public List<NetworkingUtilities.SwitchFeatureType> SwitchFeatureList;
        }
        
        /// <summary>
        /// Enumerates information about a switch and outputs it to the console. The information 
        /// enumerated includes: the connection type of the switch, the connected virtual machines,
        /// and the features of the switch's ports.
        /// </summary>
        /// <param name="switchName">The name of the switch to enumerate.</param>
        static void
        EnumerateSwitch(
            string switchName)
        {
            ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
            
            //
            // Initialize our SwitchInfo structure to hold information about the switch.
            //
            SwitchInfo ethernetSwitchInfo = new SwitchInfo();
            ethernetSwitchInfo.Name = switchName;
            ethernetSwitchInfo.Type = SwitchConnectionType.Private;
            ethernetSwitchInfo.PortList = new List<PortInfo>();
            ethernetSwitchInfo.SwitchFeatureList = new List<NetworkingUtilities.SwitchFeatureType>();

            using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
            {
                //
                // Enumerate the switch's ports.
                //
                using (ManagementObjectCollection portCollection = ethernetSwitch.GetRelated("Msvm_EthernetSwitchPort",
                    "Msvm_SystemDevice",
                    null, null, null, null, false, null))
                {
                    foreach (ManagementObject port in portCollection)
                    using (port)
                    {
                        //
                        // Initialize a PortInfo structure to hold information about this port.
                        //
                        PortInfo portInfo = new PortInfo();
                        portInfo.Type = PortConnectionType.Nothing;
                        portInfo.FeatureList = new List<NetworkingUtilities.PortFeatureType>();

                        //
                        // The port's connection settings are stored on its related 
                        // Msvm_EthernetPortAllocationSettingData object.
                        //
                        using (ManagementObject portSettings = WmiUtilities.GetFirstObjectFromCollection(
                            port.GetRelated("Msvm_EthernetPortAllocationSettingData",
                                "Msvm_ElementSettingData",
                                null, null, null, null, false, null)))
                        {
                            //
                            // Determine the port's connection type.
                            //
                            portInfo.Type = DeterminePortType(portSettings);

                            if (portInfo.Type == PortConnectionType.VirtualMachine)
                            {
                                // Get the name of the connected virtual machine.
                                using (ManagementObject virtualMachineSettings = WmiUtilities.GetFirstObjectFromCollection(
                                    portSettings.GetRelated("Msvm_VirtualSystemSettingData",
                                        "Msvm_VirtualSystemSettingDataComponent",
                                        null, null, null, null, false, null)))
                                {
                                    portInfo.ConnectedName = (string)virtualMachineSettings["ElementName"];
                                }
                            }
                            else if (portInfo.Type == PortConnectionType.External)
                            {
                                // Get the name of the external connection.
                                using (ManagementObject externalAdapter = new ManagementObject(
                                    ((string[])portSettings["HostResource"])[0]))
                                {
                                    portInfo.ConnectedName = (string)externalAdapter["ElementName"];
                                }
                            }

                            //
                            // Now determine which advanced properties are configured for this port. 
                            // Each Feature has its own class definition and is related to the portSettings
                            // through the Msvm_EthernetPortSettingDataComponent association.
                            //
                            using (ManagementObjectCollection portFeatureCollection =
                                    portSettings.GetRelated("Msvm_EthernetSwitchPortFeatureSettingData",
                                        "Msvm_EthernetPortSettingDataComponent",
                                        null, null, null, null, false, null))
                            {
                                foreach (ManagementObject portFeature in portFeatureCollection)
                                    using (portFeature)
                                    {
                                        portInfo.FeatureList.Add(DeterminePortFeatureType(portFeature));
                                    }
                            }
                        }

                        ethernetSwitchInfo.PortList.Add(portInfo);
                    }
                }

                //
                // Then enumerate the switch's features.
                //
                using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection(
                    ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData",
                        "Msvm_SettingsDefineState",
                        null, null, null, null, false, null)))
                using (ManagementObjectCollection switchFeatures = ethernetSwitchSetting.GetRelated(
                    "Msvm_EthernetSwitchFeatureSettingData",
                    "Msvm_VirtualEthernetSwitchSettingDataComponent",
                    null, null, null, null, false, null))
                foreach (ManagementObject switchFeature in switchFeatures)
                using (switchFeature)
                {
                    ethernetSwitchInfo.SwitchFeatureList.Add(DetermineSwitchFeatureType(switchFeature));
                }
            }

            //
            // Now that we have enumerated all of the switch's ports, we can determine the 
            // switch's connection type.
            //
            ethernetSwitchInfo.Type = DetermineSwitchConnectionType(ethernetSwitchInfo.PortList);

            //
            // We now have all of the information we need - output it to the console.
            //
            OutputSwitchInfo(ethernetSwitchInfo);
        }

        /// <summary>
        /// Determine the connection type of the port.
        /// </summary>
        /// <param name="portSettings">The port configuration object.</param>
        /// <returns>The port's connection type.</returns>
        static PortConnectionType
        DeterminePortType(
            ManagementObject portSettings)
        {
            string[] hostResource = (string[])portSettings["HostResource"];

            if (hostResource != null && hostResource.Length > 0)
            {
                ManagementPath hostResourcePath = new ManagementPath(hostResource[0]);

                if (string.Equals(hostResourcePath.ClassName, "Msvm_ComputerSystem",
                    StringComparison.OrdinalIgnoreCase))
                {
                    //
                    // The port is connected to the host computer system, which means that this 
                    // is an internal connection.
                    //
                    return PortConnectionType.Internal;
                }
                else if (string.Equals(hostResourcePath.ClassName, "Msvm_ExternalEthernetPort",
                         StringComparison.OrdinalIgnoreCase))
                {
                    //
                    // The port is connected to an external Ethernet adapter.
                    //
                    return PortConnectionType.External;
                }
            }

            //
            // If it wasn't connected to the internal or external network, determine if it 
            // is connected to a virtual machine.
            //
            string parent = (string)portSettings["Parent"];

            if (!string.IsNullOrEmpty(parent))
            {
                ManagementPath parentPath = new ManagementPath(parent);

                if (string.Equals(parentPath.ClassName, "Msvm_SyntheticEthernetPortSettingData",
                    StringComparison.OrdinalIgnoreCase) ||
                    string.Equals(parentPath.ClassName, "Msvm_EmulatedEthernetPortSettingData",
                    StringComparison.OrdinalIgnoreCase))
                {
                    return PortConnectionType.VirtualMachine;
                }
            }

            //
            // This port is not connected to anything.
            //
            return PortConnectionType.Nothing;
        }

        /// <summary>
        /// Determines the type of the port feature.
        /// </summary>
        /// <param name="portFeature">The port feature.</param>
        /// <returns>The feature's type.</returns>
        static NetworkingUtilities.PortFeatureType
        DeterminePortFeatureType(
            ManagementObject portFeature)
        {
            NetworkingUtilities.PortFeatureType type = NetworkingUtilities.PortFeatureType.Unknown;

            string portFeatureClass = portFeature.Path.ClassName;
            switch (portFeatureClass)
            {
                case "Msvm_EthernetSwitchPortOffloadSettingData":
                    type = NetworkingUtilities.PortFeatureType.Offload;
                    break;

                case "Msvm_EthernetSwitchPortVlanSettingData":
                    type = NetworkingUtilities.PortFeatureType.Vlan;
                    break;

                case "Msvm_EthernetSwitchPortAclSettingData":
                    type = NetworkingUtilities.PortFeatureType.Acl;
                    break;

                case "Msvm_EthernetSwitchPortBandwidthSettingData":
                    type = NetworkingUtilities.PortFeatureType.Bandwidth;
                    break;

                case "Msvm_EthernetSwitchPortSecuritySettingData":
                    type = NetworkingUtilities.PortFeatureType.Security;
                    break;
                    
                case "Msvm_EthernetSwitchPortProfileSettingData":
                    type = NetworkingUtilities.PortFeatureType.Profile;
                    break;
            }

            return type;
        }

        /// <summary>
        /// Determines the type of the switch feature.
        /// </summary>
        /// <param name="switchFeature">The switch feature.</param>
        /// <returns>The feature's type.</returns>
        static NetworkingUtilities.SwitchFeatureType
        DetermineSwitchFeatureType(
            ManagementObject switchFeature)
        {
            NetworkingUtilities.SwitchFeatureType type = NetworkingUtilities.SwitchFeatureType.Unknown;

            string switchFeatureClass = switchFeature.Path.ClassName;
            switch (switchFeatureClass)
            {
                case "Msvm_VirtualEthernetSwitchBandwidthSettingData":
                    type = NetworkingUtilities.SwitchFeatureType.Bandwidth;
                    break;
            }

            return type;
        }

        /// <summary>
        /// Determines the switch's connection type based upon the connection types of its ports.
        /// </summary>
        /// <param name="switchPorts">The switch's ports.</param>
        /// <returns>The switch's connection type.</returns>
        static SwitchConnectionType
        DetermineSwitchConnectionType(
            List<PortInfo> switchPorts)
        {
            SwitchConnectionType type = SwitchConnectionType.Private;

            bool internallyConnected = false;
            bool externallyConnected = false;

            //
            // Loop through the switch's ports to see if there are any internal and/or external
            // connections.
            //
            foreach (PortInfo portInfo in switchPorts)
            {
                if (portInfo.Type == PortConnectionType.Internal)
                {
                    internallyConnected = true;
                }
                else if (portInfo.Type == PortConnectionType.External)
                {
                    externallyConnected = true;
                }
            }

            //
            // Based on the internal and/or external connections of our ports, we can determine
            // the switch's connection type.
            //
            if (internallyConnected && externallyConnected)
            {
                type = SwitchConnectionType.External;
            }
            else if (internallyConnected)
            {
                type = SwitchConnectionType.Internal;
            }
            else if (externallyConnected)
            {
                type = SwitchConnectionType.ExternalOnly;
            }

            return type;
        }

        /// <summary>
        /// Outputs the information gathered on the switch to the console.
        /// </summary>
        /// <param name="switchInfo">The information gathered on the switch.</param>
        static void
        OutputSwitchInfo(
            SwitchInfo switchInfo)
        {
            Console.WriteLine("Successfully enumerated the ports and port features of the switch '{0}'\n",
                switchInfo.Name);
            Console.WriteLine("The switch's connection type is:");
            Console.WriteLine("    {0}\n", switchInfo.Type);

            //
            // If the switch is connected to an external network, output the name of the network.
            //
            if (switchInfo.Type == SwitchConnectionType.External ||
                switchInfo.Type == SwitchConnectionType.ExternalOnly)
            {
                Console.WriteLine("The switch is connected to the following network:");
                foreach (PortInfo portInfo in switchInfo.PortList)
                {
                    if (portInfo.Type == PortConnectionType.External)
                    {
                        Console.WriteLine("    {0}", portInfo.ConnectedName);
                    }
                }
                Console.WriteLine();
            }

            //
            // Output the virtual machines that are currently connected to this switch.
            //
            Console.WriteLine("The switch is connected to the following virtual machines:");
            
            bool atLeastOneVirtualMachine = false;
            foreach (string virtualMachineName in GetConnectedVirtualMachineList(switchInfo.PortList))
            {
                atLeastOneVirtualMachine = true;
                Console.WriteLine("    {0}", virtualMachineName);
            }

            if (!atLeastOneVirtualMachine)
            {
                Console.WriteLine("    The switch is not connected to any virtual machines");
            }

            Console.WriteLine();

            //
            // Output the advanced features that have been configured for the switch.
            //
            Console.WriteLine("The switch has the following advanced features: ");

            if (switchInfo.SwitchFeatureList.Count > 0)
            {
                foreach (NetworkingUtilities.SwitchFeatureType featureType in switchInfo.SwitchFeatureList)
                {
                    Console.WriteLine("    {0}", featureType.ToString());
                }
            }
            else
            {
                Console.WriteLine("    The switch has no advanced features");
            }

            Console.WriteLine();

            //
            // Now output information about features for each port.
            //
            Console.WriteLine("The switch is connected to {0} ports.", switchInfo.PortList.Count);

            if (switchInfo.PortList.Count > 0)
            {
                Console.WriteLine("Outputting port features for each port:\n");

                int count = 1;
                foreach (PortInfo portInfo in switchInfo.PortList)
                {
                    switch (portInfo.Type)
                    {
                        case PortConnectionType.VirtualMachine:
                            Console.WriteLine("    Port {0} connected to virtual machine '{1}' has the following features:",
                                count, portInfo.ConnectedName);
                            break;

                        case PortConnectionType.External:
                            Console.WriteLine("    Port {0} connected to the external network '{1}' has the following features:",
                                count, portInfo.ConnectedName);
                            break;

                        case PortConnectionType.Internal:
                            Console.WriteLine("    Port {0} connected to the internal network has the following features:",
                                count);
                            break;

                        case PortConnectionType.Nothing:
                            Console.WriteLine("    Port {0} not connected to anything has the following features:",
                                count);
                            break;
                    }

                    if (portInfo.FeatureList.Count > 0)
                    {
                        foreach (NetworkingUtilities.PortFeatureType featureType in portInfo.FeatureList)
                        {
                            Console.WriteLine("       {0}", featureType.ToString());
                        }
                    }
                    else
                    {
                        Console.WriteLine("       The port has no advanced features");
                    }

                    count++;
                    Console.WriteLine();
                }
            }
        }

        /// <summary>
        /// Helper method called by OutputSwitchInfo in order to build up a sorted list of virtual
        /// machine names that the switch is connected to.
        /// </summary>
        /// <param name="portList">The ports of the switch.</param>
        /// <returns>The sorted list of virtual machines which are connected to the switch.</returns>
        static IEnumerable<string>
        GetConnectedVirtualMachineList(
            List<PortInfo> portList)
        {
            //
            // The SortedSet class will both sort the list of virtual machine names and 
            // ignore any duplicates.
            //
            SortedSet<string> virtualMachineNames = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (PortInfo portInfo in portList)
            {
                if (portInfo.Type == PortConnectionType.VirtualMachine &&
                    !string.IsNullOrEmpty(portInfo.ConnectedName))
                {
                    virtualMachineNames.Add(portInfo.ConnectedName);
                }
            }

            return virtualMachineNames;
        }

        /// <summary>
        /// Entry point for the EnumerateSwitch sample.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        internal static void
        ExecuteSample(
            string[] args)
        {
            if (args.Length == 0 || args[0] == "/?")
            {
                Console.WriteLine("Usage: EnumerateSwitch SwitchName\n");
                Console.WriteLine("Example: EnumerateSwitch MySwitch");
                return;
            }

            try
            {
                EnumerateSwitch(args[0]);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed to enumerate the switch. Error message details:\n");
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Source: Microsoft Learn / Windows Win32 documentation by Microsoft and contributors. Documentation licensed CC BY 4.0. Code samples are covered by the MIT License. Converted from Markdown, with links normalized and embedded media omitted.

资料来源与适用范围

资料来源
Microsoft Learn / Windows Win32 documentation
适用范围
Windows Win32 API · Source date 05/31/2018
内容语言
中文;命令、路径和错误标识保留技术原文
本地收录日期
2026-11-15
授权说明
CC BY 4.0 (documentation), MIT (code samples)

正文与所需资源由本站本地存储。查看来源及更新记录 ↗

请按适用版本和实际日志确认原因;本站没有对每一种系统或设备逐项执行文中的操作。