private async Task PollNetworkUtilizationAsync()
            {
                var utilizationTable = _canQueryAdapterUtilization
                                           ? "Win32_PerfRawData_Tcpip_NetworkAdapter"
                                           : "Win32_PerfRawData_Tcpip_NetworkInterface";

                var query = $@"
                    SELECT Name,
                           Timestamp_Sys100NS,
                           BytesReceivedPersec,
                           BytesSentPersec,
                           PacketsReceivedPersec,
                           PacketsSentPersec
                      FROM {utilizationTable}";

                var queryTime    = DateTime.UtcNow.ToEpochTime();
                var combinedUtil = new Interface.InterfaceUtilization
                {
                    DateEpoch = queryTime,
                    InAvgBps  = 0,
                    OutAvgBps = 0
                };

                using (var q = Wmi.Query(Endpoint, query))
                {
                    foreach (var data in await q.GetDynamicResultAsync().ConfigureAwait(false))
                    {
                        var perfData = new PerfRawData(this, data);
                        var name     = perfData.Identifier;
                        var iface    = Interfaces.Find(i => name == GetCounterName(i.Name));
                        if (iface == null)
                        {
                            continue;
                        }

                        iface.InBps  = (float)perfData.GetCalculatedValue("BytesReceivedPersec", 10000000);
                        iface.OutBps = (float)perfData.GetCalculatedValue("BytesSentPersec", 10000000);
                        iface.InPps  = (float)perfData.GetCalculatedValue("PacketsReceivedPersec", 10000000);
                        iface.OutPps = (float)perfData.GetCalculatedValue("PacketsSentPersec", 10000000);

                        var util = new Interface.InterfaceUtilization
                        {
                            DateEpoch = queryTime,
                            InAvgBps  = iface.InBps,
                            OutAvgBps = iface.OutBps
                        };

                        var netData = NetHistory.GetOrAdd(iface.Name, k => new List <Interface.InterfaceUtilization>(1024));
                        UpdateHistoryStorage(netData, util);

                        if (PrimaryInterfaces.Contains(iface))
                        {
                            combinedUtil.InAvgBps  += util.InAvgBps;
                            combinedUtil.OutAvgBps += util.OutAvgBps;
                        }
                    }
                }

                UpdateHistoryStorage(CombinedNetHistory, combinedUtil);
            }
 internal List <Interface.InterfaceUtilization> GetInterfaceUtilizationHistory(Interface iface)
 {
     if (iface != null &&
         Interfaces.Find(x => x == iface) != null &&
         NetHistory.ContainsKey(iface.Name))
     {
         return(NetHistory[iface.Name]);
     }
     else
     {
         return(new List <Interface.InterfaceUtilization>(0));
     }
 }
            internal List <Interface.InterfaceUtilization> GetInterfaceUtilizationHistory(Interface iface)
            {
                List <Interface.InterfaceUtilization> result;

                if (iface != null &&
                    Interfaces.Find(x => x == iface) != null &&
                    NetHistory.ContainsKey(iface.Name))
                {
                    result = NetHistory[iface.Name];
                }
                else
                {
                    result = new List <Interface.InterfaceUtilization>(0);
                }
                return(result);
            }
            private async Task GetAllInterfacesAsync()
            {
                const string query = @"
SELECT Name,
       PNPDeviceID,
       DeviceID,       
       NetConnectionID,
       Description,
       MACAddress,
       Speed,
       InterfaceIndex
  FROM Win32_NetworkAdapter
 WHERE NetConnectionStatus = 2"; //connected adapters.
                //'AND PhysicalAdapter = True' causes exceptions with old windows versions.

                var indexMap = new Dictionary <uint, Interface>();

                using (var q = Wmi.Query(Endpoint, query))
                {
                    foreach (var data in await q.GetDynamicResultAsync().ConfigureAwait(false))
                    {
                        string id = $"{data.DeviceID}";
                        var    i  = Interfaces.Find(x => x.Id == id) ?? new Interface();
                        indexMap[data.InterfaceIndex] = i;

                        i.Id       = id;
                        i.Alias    = "!alias";
                        i.Caption  = data.NetConnectionID;
                        i.FullName = data.Description;
                        i.NodeId   = Id;
                        i.LastSync = DateTime.UtcNow;
                        i.Name     = await GetRealAdapterName(data.PNPDeviceID).ConfigureAwait(false);

                        i.PhysicalAddress = data.MACAddress;
                        i.Speed           = data.Speed;
                        i.Status          = NodeStatus.Active;
                        i.TypeDescription = "";
                        i.IPs             = new List <IPNet>();
                        i.TeamMembers     = new List <string>();

                        if (i.Node == null)
                        {
                            i.Node = this;
                            Interfaces.Add(i);
                        }
                    }
                }

                if (_canQueryTeamingInformation)
                {
                    const string teamsQuery            = "SELECT InstanceID, Name FROM MSFT_NetLbfoTeam";
                    var          teamNamesToInterfaces = new Dictionary <string, Interface>();

                    using (var q = Wmi.Query(Endpoint, teamsQuery, @"root\standardcimv2"))
                    {
                        foreach (var data in await q.GetDynamicResultAsync().ConfigureAwait(false))
                        {
                            var teamInterface = Interfaces.Find(x => x.Caption == data.Name);

                            if (teamInterface == null)
                            {
                                continue;
                            }

                            teamNamesToInterfaces.Add(data.Name, teamInterface);
                        }
                    }

                    const string teamMembersQuery = "SELECT InstanceID, Name, Team FROM MSFT_NetLbfoTeamMember";
                    using (var q = Wmi.Query(Endpoint, teamMembersQuery, @"root\standardcimv2"))
                    {
                        foreach (var data in await q.GetDynamicResultAsync().ConfigureAwait(false))
                        {
                            var teamName = data.Team;

                            if (teamNamesToInterfaces.TryGetValue(teamName, out Interface teamInterface))
                            {
                                var adapterName     = data.Name;
                                var memberInterface = Interfaces.Find(x => x.Name == adapterName);

                                if (memberInterface == null)
                                {
                                    continue;
                                }

                                teamInterface.TeamMembers.Add(memberInterface.Id);
                            }
                        }
                    }
                }

                const string ipQuery = @"
SELECT InterfaceIndex, IPAddress, IPSubnet, DHCPEnabled
  FROM WIn32_NetworkAdapterConfiguration 
 WHERE IPEnabled = 'True'";

                using (var q = Wmi.Query(Endpoint, ipQuery))
                {
                    foreach (var data in await q.GetDynamicResultAsync().ConfigureAwait(false))
                    {
                        if (indexMap.TryGetValue(data.InterfaceIndex, out Interface i))
                        {
                            i.DHCPEnabled = data.DHCPEnabled;
                            var ips     = data.IPAddress as string[];
                            var subnets = data.IPSubnet as string[];

                            if (ips == null ||
                                subnets == null)
                            {
                                continue;
                            }

                            for (var j = 0; j < (ips?.Length).GetValueOrDefault(0); j++)
                            {
                                if (int.TryParse(subnets[j], out int cidr) && IPNet.TryParse(ips[j], cidr, out IPNet net))
                                {
                                    i.IPs.Add(net);
                                }
                                else if (IPNet.TryParse(ips[j], subnets[j], out net))
                                {
                                    i.IPs.Add(net);
                                }
                            }
                        }
                    }
                }
            }