Network List Manager

The Wi-Fi Framework's wclNetworkListManager class gives your application full access to the Windows Network List Manager. Enumerate all networks, check internet connectivity, read network categories, change network names, and receive real-time notifications when network connections change - all through a simple event-driven API.

Network The Microsoft Windows networking environment allows multihomed computers to connect to several networks simultaneously. There may be multiple wireless networks available, along with LAN and dial-up connections. An application often needs to know if the machine has LAN or internet connectivity and take actions depending on that.

In Windows, a "network" is a logical representation of a physical network segment to which the computer is attached. It is not simply a network adapter or a Wi-Fi SSID; rather, it is a combination of the network's identity, the set of interfaces connected to it, and the associated security and sharing settings. Windows groups one or more network interfaces into a single network entity whenever those interfaces share the same network identity. This grouping enables consistent behavior - for example, the same Windows Firewall profile (Domain, Private, or Public) applies to all adapters connected to that network, and the same network-aware services (such as file sharing or media streaming) are enabled or disabled according to the network's category.

The Wi-Fi Framework allows your application to know what kind of network connection a PC has and to be notified about network connectivity changes. The Network List Manager can provide a wealth of information about the network. It is easy to discover every connection and every network attached to a machine. Some of the information, such as the network identifier, is read-only. However, you can change other information, such as the network name or network type. It identifies available networks and returns network attribute data to the application.

Behind the scenes, the Network List Manager relies on the Windows Network Location Awareness (NLA) service. NLA constantly monitors the state of all network interfaces and determines the network signature - a set of attributes that uniquely identifies a network. The most significant part of this signature is typically the MAC address of the default gateway (for IPv4) or the router advertisement prefix (for IPv6), combined with the DNS suffix and other DHCP-supplied information. When an interface first connects, Windows calculates this signature and stores it in a local network profile. If a later connection yields the same signature, the system recognizes that it is the same network and reuses the existing profile, preserving the name, category, and other custom properties. This mechanism allows your application to remember user preferences for a given network even as the physical adapter or IP address changes.

Network The Network List Manager interacts with the system to identify and retrieve properties of each network that the PC connects to. Each network is uniquely identified with a network signature based on the uniquely identifiable properties of that network. When an application registers for the Network List Manager notifications, the application receives notifications about the availability of new network connections or changes to existing network connections. Applications can adjust their logic depending on which network they are connected to, on which network connection they are connected to, or what the network properties are. With this information, applications can fine-tune their actions based on the current network conditions.

One of the most important pieces of information a network carries is its category: public, private, or domain-authenticated. This category directly controls the Windows Firewall profile applied to all adapters on that network and determines whether network discovery and file sharing are turned on by default. A domain network is detected when the machine authenticates against a domain controller reachable over that network; otherwise the user or an application can set the network to private (trusted, home or work environment) or public (untrusted, such as a coffee-shop hotspot). The Network List Manager exposes this category and lets you change it programmatically, so you can, for example, automatically mark a corporate Wi-Fi network as private after checking additional network properties.

The Network List Manager allows you to enumerate all networks available on your device. You can get information about each network. The network connection status indicates whether the network is connected. The internet connection status indicates if the network is connected to the Internet. You can also get the network name, description, category, and other information. If needed, you can change the network name, description, and category.

Beyond the simple connected/disconnected state, the Network Connectivity Status Indicator (NCSI), which feeds into the Network List Manager, performs active probes to determine the level of Internet connectivity. A network can report "local access" (the interface has an IP address and can reach the local subnet), "Internet access" (the machine can successfully reach a Microsoft-owned web service), or "captive portal" (internet connectivity is blocked until a sign-in page is acknowledged). These granular states are invaluable for applications that must decide whether to initiate cloud synchronization, start a VoIP call, or warn the user about restricted connectivity.

How To Work With the Network List Manager

When a network connection changed, the Network List Manager calls events to notify your application about the network connection changes. Refer to the NetworkListManager sample application to find out how to use the wclNetworkListManager class to work with network connections.

The wclNetworkListManager class also allows you to get information about the network adapters installed on your PC. It provides such details as adapter ID, friendly name, state, IP addresses, etc. By combining adapter information with the network-to-adapter associations that the Network List Manager maintains, you can, for example, discover which physical or virtual NICs carry traffic for a particular network, detect the primary Internet-facing interface, or react when a specific VPN adapter connects and creates a new network entry.


Step 1 - Opening the Network List Manager

Before any network operation, create a wclNetworkListManager instance and call its Open method. This activates the underlying NLA service and wires up all event handlers. Once opened, the AfterOpen event fires, confirming the manager is ready. When finished, call Close to release resources gracefully.



procedure TfmMain.btOpenClick(Sender: TObject);
begin
	ShowError(wclNetworkListManager.Open);
end;

procedure TfmMain.btCloseClick(Sender: TObject);
begin
	ShowError(wclNetworkListManager.Close);
end;

procedure TfmMain.wclNetworkListManagerAfterOpen(Sender: TObject);
begin
	lbEvents.Items.Add('AfterOpen');
end;

procedure TfmMain.wclNetworkListManagerBeforeClose(Sender: TObject);
begin
	lbEvents.Items.Add('BeforeClose');
end;

procedure TfmMain.FormDestroy(Sender: TObject);
begin
	wclNetworkListManager.Close;
end;
                        

void __fastcall TfmMain::btOpenClick(TObject *Sender)
{
	ShowError(wclNetworkListManager->Open());
}

void __fastcall TfmMain::btCloseClick(TObject *Sender)
{
	ShowError(wclNetworkListManager->Close());
}

void __fastcall TfmMain::wclNetworkListManagerAfterOpen(TObject *Sender)
{
	lbEvents->Items->Add("AfterOpen");
}

void __fastcall TfmMain::wclNetworkListManagerBeforeClose(TObject *Sender)
{
	lbEvents->Items->Add("BeforeClose");
}

void __fastcall TfmMain::FormDestroy(TObject *Sender)
{
	wclNetworkListManager->Close();
}
                        

private void main_Load(object sender, EventArgs e)
{
	wclNetworkListManager = new wclNetworkListManager();
	wclNetworkListManager.AfterOpen += new EventHandler(wclNetworkListManager_AfterOpen);
	wclNetworkListManager.BeforeClose += new EventHandler(wclNetworkListManager_BeforeClose);
	// ... other event hooks ...
}

private void btOpen_Click(object sender, EventArgs e)
{
	ShowError(wclNetworkListManager.Open());
}

private void btClose_Click(object sender, EventArgs e)
{
	ShowError(wclNetworkListManager.Close());
}

void wclNetworkListManager_AfterOpen(object sender, EventArgs e)
{
	lbEvents.Items.Add("AfterOpen");
}

void wclNetworkListManager_BeforeClose(object sender, EventArgs e)
{
	lbEvents.Items.Add("BeforeClose");
}

private void main_FormClosed(object sender, FormClosedEventArgs e)
{
	wclNetworkListManager.Close();
}
                        

Private Sub fmMain_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
	wclNetworkListManager = New wclWiFi.wclNetworkListManager()
End Sub

Private Sub btOpen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btOpen.Click
	ShowError(wclNetworkListManager.Open())
End Sub

Private Sub btClose_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btClose.Click
	ShowError(wclNetworkListManager.Close())
End Sub

Private Sub wclNetworkListManager_AfterOpen(ByVal sender As Object, ByVal e As System.EventArgs) Handles wclNetworkListManager.AfterOpen
	lbEvents.Items.Add("AfterOpen")
End Sub

Private Sub wclNetworkListManager_BeforeClose(ByVal sender As Object, ByVal e As System.EventArgs) Handles wclNetworkListManager.BeforeClose
	lbEvents.Items.Add("BeforeClose")
End Sub

Private Sub fmMain_FormClosed(ByVal sender As System.Object, ByVal e As System.Windows.Forms.FormClosedEventArgs) Handles MyBase.FormClosed
	wclNetworkListManager.Close()
End Sub
                        

BOOL CNetworkListManagerDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	// ... icon and control setup ...

	__hook(&CwclNetworkListManager::AfterOpen, &FManager, &CNetworkListManagerDlg::AfterOpen);
	__hook(&CwclNetworkListManager::BeforeClose, &FManager, &CNetworkListManagerDlg::BeforeClose);
	// ... other event hooks ...

	return TRUE;
}

void CNetworkListManagerDlg::OnBnClickedButtonOpen()
{
	ShowError(FManager.Open());
}

void CNetworkListManagerDlg::OnBnClickedButtonClose()
{
	ShowError(FManager.Close());
}

void CNetworkListManagerDlg::AfterOpen(void* Sender)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("AfterOpen"));
}

void CNetworkListManagerDlg::BeforeClose(void* Sender)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("BeforeClose"));
}

void CNetworkListManagerDlg::OnDestroy()
{
	CDialog::OnDestroy();

	FManager.Close();
	__unhook(&FManager);
}


Step 2 - Checking Basic Connectivity

Once the manager is open, you can instantly query whether the machine has any network connectivity at all, whether it can reach the Internet, and the detailed connectivity flags (which indicate per-protocol capabilities such as IPv4 Internet, IPv6 local network, etc.). These three methods provide a quick health check without enumerating individual networks.



procedure TfmMain.btIsConnectedClick(Sender: TObject);
var
	Connected: Boolean;
begin
	if not ShowError(wclNetworkListManager.GetConnected(Connected)) then begin
		if Connected then
			ShowInfo('Connected')
		else
			ShowInfo('NOT Connected');
	end;
end;

procedure TfmMain.btIsInternetClick(Sender: TObject);
var
	Connected: Boolean;
begin
	if not ShowError(wclNetworkListManager.GetConnectedToInternet(Connected)) then begin
		if Connected then
			ShowInfo('Connected')
		else
			ShowInfo('NOT Connected');
	end;
end;

procedure TfmMain.btGetConnectivityClick(Sender: TObject);
var
	Connectivity: TwclNlmConnectivityFlags;
begin
	if not ShowError(wclNetworkListManager.GetConnectivity(Connectivity)) then
		ShowInfo('Connectivity: ' + DecodeFlags(Connectivity));
end;
                        

void __fastcall TfmMain::btIsConnectedClick(TObject *Sender)
{
	bool Connected = false;
	if (!ShowError(wclNetworkListManager->GetConnected(Connected)))
	{
		if (Connected)
			ShowInfo("Connected");
		else
			ShowInfo("NOT Connected");
	}
}

void __fastcall TfmMain::btIsInternetClick(TObject *Sender)
{
	bool Connected;
	if (!ShowError(wclNetworkListManager->GetConnectedToInternet(Connected)))
	{
		if (Connected)
			ShowInfo("Connected");
		else
			ShowInfo("NOT Connected");
	}
}

void __fastcall TfmMain::btGetConnectivityClick(TObject *Sender)
{
	TwclNlmConnectivityFlags Connectivity;
	if (!ShowError(wclNetworkListManager->GetConnectivity(Connectivity)))
		ShowInfo("Connectivity: " + DecodeFlags(Connectivity));
}
                        

private void btIsConnected_Click(object sender, EventArgs e)
{
	bool Connected;
	if (!ShowError(wclNetworkListManager.GetConnected(out Connected)))
	{
		if (Connected)
			MessageBox.Show("Connected");
		else
			MessageBox.Show("NOT Connected");
	}
}

private void btIsConnectedToInternet_Click(object sender, EventArgs e)
{
	bool Connected;
	if (!ShowError(wclNetworkListManager.GetConnectedToInternet(out Connected)))
	{
		if (Connected)
			MessageBox.Show("Connected");
		else
			MessageBox.Show("NOT Connected");
	}
}

private void btConnectivity_Click(object sender, EventArgs e)
{
	wclNlmConnectivity Connectivity;
	if (!ShowError(wclNetworkListManager.GetConnectivity(out Connectivity)))
		MessageBox.Show("Connectivity: " + Connectivity.ToString());
}
                        

Private Sub btIsConnected_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btIsConnected.Click
	Dim Connected As Boolean
	If Not ShowError(wclNetworkListManager.GetConnected(Connected)) Then
		If Connected Then
			MessageBox.Show("Connected")
		Else
			MessageBox.Show("NOT Connected")
		End If
	End If
End Sub

Private Sub btIsConnectedToInternet_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btIsConnectedToInternet.Click
	Dim Connected As Boolean
	If Not ShowError(wclNetworkListManager.GetConnectedToInternet(Connected)) Then
		If Connected Then
			MessageBox.Show("Connected")
		Else
			MessageBox.Show("NOT Connected")
		End If
	End If
End Sub

Private Sub btConnectivity_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btConnectivity.Click
	Dim Connectivity As wclWiFi.wclNlmConnectivity
	If Not ShowError(wclNetworkListManager.GetConnectivity(Connectivity)) Then
		MessageBox.Show("Connectivity: " + Connectivity.ToString())
	End If
End Sub
                        

void CNetworkListManagerDlg::OnBnClickedButtonIsConnected()
{
	bool Connected;
	if (!ShowError(FManager.GetConnected(Connected)))
	{
		if (Connected)
			AfxMessageBox(_T("Connected"));
		else
			AfxMessageBox(_T("NOT Connected"));
	}
}

void CNetworkListManagerDlg::OnBnClickedButtonIsInternet()
{
	bool Connected;
	if (!ShowError(FManager.GetConnectedToInternet(Connected)))
	{
		if (Connected)
			AfxMessageBox(_T("Connected"));
		else
			AfxMessageBox(_T("NOT Connected"));
	}
}

void CNetworkListManagerDlg::OnBnClickedButtonConnectivity()
{
	wclNlmConnectivityFlags Connectivity;
	if (!ShowError(FManager.GetConnectivity(Connectivity)))
		AfxMessageBox(_T("Connectivity: ") + DecodeFlags(Connectivity));
}


Step 3 - Enumerating All Networks

To discover every network known to the system, call GetNetworks with an enumeration flag that filters by connection state: nlmConnected, nlmDisconnected, or nlmAll. Each returned wclNlmNetwork object exposes a rich set of properties: the network ID (GUID), category, connectivity flags, description, domain type, user-visible name, creation and connection timestamps, and boolean connected / internet-connected states.



procedure TfmMain.btEnumNetworksClick(Sender: TObject);
var
	Flag: TwclNlmEnumNetwork;
	Networks: TwclNlmNetworks;
	i: Integer;
	Network: TwclNlmNetwork;
	Id: TGUID;
	Category: TwclNlmNetworkCategory;
	Connectivity: TwclNlmConnectivityFlags;
	Description, AName: string;
	Domain: TwclNlmDomainType;
	CreationDateTime, ConnectedDateTime: TDateTime;
	Connected: Boolean;
begin
	Flag := TwclNlmEnumNetwork(cbNetworkType.ItemIndex);
	if not ShowError(wclNetworkListManager.GetNetworks(Flag, Networks)) then begin
		try
			for i := 0 to Length(Networks) - 1 do begin
				Network := Networks[i];

				Network.GetNetworkId(Id);
				Network.GetCategory(Category);
				Network.GetConnectivity(Connectivity);
				Network.GetDescription(Description);
				Network.GetDomainType(Domain);
				Network.GetName(AName);
				Network.GetTimeCreatedAndConnected(CreationDateTime, ConnectedDateTime);
				Network.GetConnected(Connected);
				Network.GetConnectedToInternet(Connected);
			end;
		finally
			for i := 0 to Length(Networks) - 1 do
				Networks[i].Free;
			Networks := nil;
		end;
	end;
end;
                        

void __fastcall TfmMain::btEnumNetworksClick(TObject *Sender)
{
	TwclNlmEnumNetwork Flag = (TwclNlmEnumNetwork)cbNetworkType->ItemIndex;
	TwclNlmNetworks Networks;
	int Res = wclNetworkListManager->GetNetworks(Flag, Networks);
	__try
	{
		if (!ShowError(Res))
		{
			for (int i = 0; i < Networks.Length; i++)
			{
				TwclNlmNetwork* Network = Networks[i];

				GUID Id;
				Network->GetNetworkId(Id);

				TwclNlmNetworkCategory Category;
				Network->GetCategory(Category);

				TwclNlmConnectivityFlags Connectivity;
				Network->GetConnectivity(Connectivity);

				String Description;
				Network->GetDescription(Description);

				TwclNlmDomainType Domain;
				Network->GetDomainType(Domain);

				String AName;
				Network->GetName(AName);

				TDateTime CreationDateTime, ConnectedDateTime;
				Network->GetTimeCreatedAndConnected(CreationDateTime, ConnectedDateTime);

				bool Connected;
				Network->GetConnected(Connected);
				Network->GetConnectedToInternet(Connected);
			}
		}
	}
	__finally
	{
		for (int i = 0; i < Networks.Length; i++)
			Networks[i]->Free();
		Networks.Length = 0;
	}
}
                        

private void btEnumNetworks_Click(object sender, EventArgs e)
{
	wclNlmEnumNetwork Flag = (wclNlmEnumNetwork)cbNetworkType.SelectedIndex;
	wclNlmNetwork[] Networks;
	Int32 Res = wclNetworkListManager.GetNetworks(Flag, out Networks);
	try
	{
		if (!ShowError(Res))
		{
			for (int i = 0; i < Networks.Length; i++)
			{
				wclNlmNetwork Network = Networks[i];

				Guid Id;
				Network.GetNetworkId(out Id);

				wclNlmNetworkCategory Category;
				Network.GetCategory(out Category);

				wclNlmConnectivity Connectivity;
				Network.GetConnectivity(out Connectivity);

				String Description;
				Network.GetDescription(out Description);

				wclNlmDomainType Domain;
				Network.GetDomainType(out Domain);

				String AName;
				Network.GetName(out AName);

				DateTime CreationDateTime, ConnectedDateTime;
				Network.GetTimeCreatedAndConnected(out CreationDateTime, out ConnectedDateTime);

				bool Connected;
				Network.GetConnected(out Connected);
				Network.GetConnectedToInternet(out Connected);
			}
		}
	}
	finally
	{
		Networks = null;
	}
}
                        

Private Sub btEnumNetworks_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btEnumNetworks.Click
	Dim Flag As wclWiFi.wclNlmEnumNetwork = CType(cbNetworkType.SelectedIndex, wclWiFi.wclNlmEnumNetwork)
	Dim Networks() As wclWiFi.wclNlmNetwork = Nothing
	Dim Res As Int32 = wclNetworkListManager.GetNetworks(Flag, Networks)
	Try
		If Not ShowError(Res) Then
			Dim i As Integer
			For i = 0 To Networks.Length - 1
				Dim Network As wclWiFi.wclNlmNetwork = Networks(i)

				Dim Id As Guid
				Network.GetNetworkId(Id)

				Dim Category As wclWiFi.wclNlmNetworkCategory
				Network.GetCategory(Category)

				Dim Connectivity As wclWiFi.wclNlmConnectivity
				Network.GetConnectivity(Connectivity)

				Dim Description As String = ""
				Network.GetDescription(Description)

				Dim Domain As wclWiFi.wclNlmDomainType
				Network.GetDomainType(Domain)

				Dim AName As String = ""
				Network.GetName(AName)

				Dim CreationDateTime, ConnectedDateTime As DateTime
				Network.GetTimeCreatedAndConnected(CreationDateTime, ConnectedDateTime)

				Dim Connected As Boolean
				Network.GetConnected(Connected)
				Network.GetConnectedToInternet(Connected)
			Next i
		End If
	Finally
		Networks = Nothing
	End Try
End Sub
                        

void CNetworkListManagerDlg::OnBnClickedButtonEnumNetworks()
{
	wclNlmEnumNetwork Flag = (wclNlmEnumNetwork)cbNetworkType.GetCurSel();
	wclNlmNetworks Networks;
	int Res = FManager.GetNetworks(Flag, Networks);
	if (!ShowError(Res))
	{
		for (size_t i = 0; i < Networks.size(); i++)
		{
			CwclNlmNetwork* Network = Networks[i];

			GUID Id;
			Network->GetNetworkId(Id);

			wclNlmNetworkCategory Category;
			Network->GetCategory(Category);

			wclNlmConnectivityFlags Connectivity;
			Network->GetConnectivity(Connectivity);

			tstring d;
			Network->GetDescription(d);

			wclNlmDomainType Domain;
			Network->GetDomainType(Domain);

			Network->GetName(d);

			SYSTEMTIME CreationDateTime, ConnectedDateTime;
			Network->GetTimeCreatedAndConnected(CreationDateTime, ConnectedDateTime);

			bool Connected;
			Network->GetConnected(Connected);
			Network->GetConnectedToInternet(Connected);
		}
	}

	for (size_t i = 0; i < Networks.size(); i++)
		delete Networks[i];
	Networks.clear();
}


Step 4 - Modifying Network Properties

Once you have a wclNlmNetwork object (obtained either from GetNetworks or by looking up a specific network ID via GetNetwork), you can change its name, description, and category. Changing the category to nlmCategoryPrivate or nlmCategoryPublic directly affects the Windows Firewall profile. Administrator rights are required for all three write operations.



procedure TfmMain.btSetNameClick(Sender: TObject);
var
	Network: TwclNlmNetwork;
begin
	if lvNetworks.Selected = nil then
		ShowWarning('Select network')
	else begin
		if not ShowError(wclNetworkListManager.GetNetwork(StringToGUID(lvNetworks.Selected.Caption), Network)) then begin
			if ShowError(Network.SetName(edNewNameOrDescription.Text)) then
				ShowWarning('Admin privilegies required');
			Network.Free;
		end;
	end;
end;

procedure TfmMain.btSetCategoryClick(Sender: TObject);
var
	Network: TwclNlmNetwork;
begin
	if lvNetworks.Selected = nil then
		ShowWarning('Select network')
	else begin
		if not ShowError(wclNetworkListManager.GetNetwork(StringToGUID(lvNetworks.Selected.Caption), Network)) then begin
			if ShowError(Network.SetCategory(TwclNlmNetworkCategory(cbCategory.ItemIndex))) then
				ShowWarning('Admin privilegies required');
			Network.Free;
		end;
	end;
end;
                        

void __fastcall TfmMain::btSetNameClick(TObject *Sender)
{
	if (!lvNetworks->Selected)
		ShowWarning("Select network");
	else
	{
		TwclNlmNetwork* Network;
		int Res = wclNetworkListManager->GetNetwork(Sysutils::StringToGUID(lvNetworks->Selected->Caption), Network);
		if (!ShowError(Res))
		{
			if (ShowError(Network->SetName(edNewNameOrDescription->Text)))
				ShowWarning("Admin privilegies required");
			Network->Free();
		}
	}
}

void __fastcall TfmMain::btSetCategoryClick(TObject *Sender)
{
	if (!lvNetworks->Selected)
		ShowWarning("Select network");
	else
	{
		TwclNlmNetwork* Network;
		int Res = wclNetworkListManager->GetNetwork(Sysutils::StringToGUID(lvNetworks->Selected->Caption), Network);
		if (!ShowError(Res))
		{
			if (ShowError(Network->SetCategory((TwclNlmNetworkCategory)cbCategory->ItemIndex)))
				ShowWarning("Admin privilegies required");
			Network->Free();
		}
	}
}
                        

private void btSetName_Click(object sender, EventArgs e)
{
	if (lvNetworks.SelectedItems.Count == 0)
	{
		MessageBox.Show("Select network");
		return;
	}

	wclNlmNetwork Network;
	int Res = wclNetworkListManager.GetNetwork(new Guid(lvNetworks.SelectedItems[0].SubItems[0].Text), out Network);
	if (!ShowError(Res))
	{
		if (ShowError(Network.SetName(edNewNameOrDescription.Text)))
			MessageBox.Show("Admin privilegies required");
		Network = null;
	}
}

private void btSetCategory_Click(object sender, EventArgs e)
{
	if (lvNetworks.SelectedItems.Count == 0)
	{
		MessageBox.Show("Select network");
		return;
	}

	wclNlmNetwork Network;
	int Res = wclNetworkListManager.GetNetwork(new Guid(lvNetworks.SelectedItems[0].SubItems[0].Text), out Network);
	if (!ShowError(Res))
	{
		if (ShowError(Network.SetCategory((wclNlmNetworkCategory)cbCategory.SelectedIndex)))
			MessageBox.Show("Admin privilegies required");
		Network = null;
	}
}
                        

Private Sub btSetName_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btSetName.Click
	If lvNetworks.SelectedItems.Count = 0 Then
		MessageBox.Show("Select network")
		Return
	End If

	Dim Network As wclWiFi.wclNlmNetwork = Nothing
	Dim Res As Integer = wclNetworkListManager.GetNetwork(New Guid(lvNetworks.SelectedItems(0).SubItems(0).Text), Network)
	If Not ShowError(Res) Then
		If ShowError(Network.SetName(edNewNameOrDescription.Text)) Then
			MessageBox.Show("Admin privilegies required")
		Network = Nothing
	End If
End Sub

Private Sub btSetCategory_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btSetCategory.Click
	If lvNetworks.SelectedItems.Count = 0 Then
		MessageBox.Show("Select network")
		Return
	End If

	Dim Network As wclWiFi.wclNlmNetwork = Nothing
	Dim Res As Integer = wclNetworkListManager.GetNetwork(New Guid(lvNetworks.SelectedItems(0).SubItems(0).Text), Network)
	If Not ShowError(Res) Then
		If ShowError(Network.SetCategory(CType(cbCategory.SelectedIndex, wclWiFi.wclNlmNetworkCategory))) Then
			MessageBox.Show("Admin privilegies required")
		Network = Nothing
	End If
End Sub
                        

void CNetworkListManagerDlg::OnBnClickedButtonSetName()
{
	POSITION Pos = lvNetworks.GetFirstSelectedItemPosition();
	if (!Pos)
		AfxMessageBox(_T("Select network"));
	else
	{
		int Item = lvNetworks.GetNextSelectedItem(Pos);
		CwclNlmNetwork* Network;
		int Res = FManager.GetNetwork(StringToGuid(lvNetworks.GetItemText(Item, 0)), Network);
		if (!ShowError(Res))
		{
			CString str;
			edNewNameOrDescription.GetWindowText(str);
			ShowError(Network->SetName(tstring(str)));
			delete Network;
		}
	}
}

void CNetworkListManagerDlg::OnBnClickedButtonSetCategory()
{
	POSITION Pos = lvNetworks.GetFirstSelectedItemPosition();
	if (!Pos)
		AfxMessageBox(_T("Select network"));
	else
	{
		int Item = lvNetworks.GetNextSelectedItem(Pos);
		CwclNlmNetwork* Network;
		int Res = FManager.GetNetwork(StringToGuid(lvNetworks.GetItemText(Item, 0)), Network);
		if (!ShowError(Res))
		{
			if (ShowError(Network->SetCategory((wclNlmNetworkCategory)cbCategory.GetCurSel())))
				AfxMessageBox(_T("Admin privilegies required"));
			delete Network;
		}
	}
}


Step 5 - Enumerating Network Connections

The GetConnections method returns all active network connections on the machine. Each wclNlmConnection provides the associated adapter ID, connection ID, connectivity flags, domain type, and boolean connected/internet states. You can also call GetConnections on an individual wclNlmNetwork to see which adapters belong to that specific network.



procedure TfmMain.btGetMachineConnectionsClick(Sender: TObject);
var
	Connections: TwclNlmConnections;
begin
	if not ShowError(wclNetworkListManager.GetConnections(Connections)) then
		ShowConnections(Connections);
end;

// Inside ShowConnections, iterate each wclNlmConnection:
for i := 0 to Length(Connections) - 1 do
begin
	Connection := Connections[i];
	Connection.GetAdapterId(Id);
	Connection.GetConnected(Connected);
	Connection.GetConnectedToInternet(Connected);
	Connection.GetConnectivity(Connectivity);
	Connection.GetDomainType(Domain);
	Connection.GetId(Id);
end;
                        

void __fastcall TfmMain::btGetMachineConnectionsClick(TObject *Sender)
{
	TwclNlmConnections Connections;
	if (!ShowError(wclNetworkListManager->GetConnections(Connections)))
	{
		try
		{
			ShowConnections(Connections);
		}
		__finally
		{
			Connections.Length = 0;
		}
	}
}

// Inside ShowConnections:
for (int i = 0; i < Connections.Length; i++)
{
	TwclNlmConnection* Connection = Connections[i];

	GUID Id;
	Connection->GetAdapterId(Id);
	bool Connected;
	Connection->GetConnected(Connected);
	Connection->GetConnectedToInternet(Connected);
	TwclNlmConnectivityFlags Connectivity;
	Connection->GetConnectivity(Connectivity);
	TwclNlmDomainType Domain;
	Connection->GetDomainType(Domain);
	Connection->GetId(Id);
}
                        

private void btGetMachineConnections_Click(object sender, EventArgs e)
{
	wclNlmConnection[] Connections;
	if (!ShowError(wclNetworkListManager.GetConnections(out Connections)))
		ShowConnections(ref Connections);
}

// Inside ShowConnections:
for (int i = 0; i < Connections.Length; i++)
{
	wclNlmConnection Connection = Connections[i];

	Guid Id;
	Connection.GetAdapterId(out Id);
	bool Connected;
	Connection.GetConnected(out Connected);
	Connection.GetConnectedToInternet(out Connected);
	wclNlmConnectivity Connectivity;
	Connection.GetConnectivity(out Connectivity);
	wclNlmDomainType Domain;
	Connection.GetDomainType(out Domain);
	Connection.GetId(out Id);
}
                        

Private Sub btGetMachineConnections_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btGetMachineConnections.Click
	Dim Connections() As wclWiFi.wclNlmConnection = Nothing
	If Not ShowError(wclNetworkListManager.GetConnections(Connections)) Then
		ShowConnections(Connections)
	End If
End Sub

' Inside ShowConnections:
For i = 0 To Connections.Length - 1
	Dim Connection As wclWiFi.wclNlmConnection = Connections(i)

	Dim Id As Guid
	Connection.GetAdapterId(Id)
	Dim Connected As Boolean
	Connection.GetConnected(Connected)
	Connection.GetConnectedToInternet(Connected)
	Dim Connectivity As wclWiFi.wclNlmConnectivity
	Connection.GetConnectivity(Connectivity)
	Dim Domain As wclWiFi.wclNlmDomainType
	Connection.GetDomainType(Domain)
	Connection.GetId(Id)
Next i
                        

void CNetworkListManagerDlg::OnBnClickedButtonGetMachineConnections()
{
	wclNlmConnections Connections;
	if (!ShowError(FManager.GetConnections(Connections)))
		ShowConnections(Connections);
}

// Inside ShowConnections:
for (size_t i = 0; i < Connections.size(); i++)
{
	CwclNlmConnection* Connection = Connections[i];

	GUID Id;
	Connection->GetAdapterId(Id);
	bool Connected;
	Connection->GetConnected(Connected);
	Connection->GetConnectedToInternet(Connected);
	wclNlmConnectivityFlags Connectivity;
	Connection->GetConnectivity(Connectivity);
	wclNlmDomainType Domain;
	Connection->GetDomainType(Domain);
	Connection->GetId(Id);
}


Step 6 - Handling Network Events

The wclNetworkListManager fires seven notification events that allow your application to react in real time to changes in network state. Hook these events before calling Open to ensure no notification is missed.



// Global connectivity changed
procedure TfmMain.wclNetworkListManagerConnectivityChanged(Sender: TObject;
	const Connectivity: TwclNlmConnectivityFlags);
begin
	lbEvents.Items.Add('Connectivity changed: ' + DecodeFlags(Connectivity));
end;

// A new network appeared
procedure TfmMain.wclNetworkListManagerNetworkAdded(Sender: TObject; const NetworkId: TGUID);
begin
	lbEvents.Items.Add('Network added: ' + GUIDToString(NetworkId));
end;

// A specific network's connectivity changed
procedure TfmMain.wclNetworkListManagerNetworkConnectivityChanged(Sender: TObject; const NetworkId: TGUID;
	const Connectivity: TwclNlmConnectivityFlags);
begin
	lbEvents.Items.Add('Network ' + GUIDToString(NetworkId) +
		' connectivity changed: ' + DecodeFlags(Connectivity));
end;

// A network was removed
procedure TfmMain.wclNetworkListManagerNetworkDeleted(Sender: TObject;
	const NetworkId: TGUID);
begin
	lbEvents.Items.Add('Network deleted: ' + GUIDToString(NetworkId));
end;

// A network's properties changed (name, description, icon, category)
procedure TfmMain.wclNetworkListManagerNetworkPropertyChanged(Sender: TObject; const NetworkId: TGUID;
	const Change: TwclNlmNetworkPropertyChangeFlags);
begin
	lbEvents.Items.Add('Network ' + GUIDToString(NetworkId) +
		' property changed: ' + DecodeFlags(Change));
end;

// A connection's connectivity changed
procedure TfmMain.wclNetworkListManagerConnectionConnectivityChanged(Sender: TObject; const ConnectionId: TGUID;
	const Connectivity: TwclNlmConnectivityFlags);
begin
	lbEvents.Items.Add('Connection: ' + GUIDToString(ConnectionId) +
		' connectivity changed: ' + DecodeFlags(Connectivity));
end;

// A connection's property changed
procedure TfmMain.wclNetworkListManagerConnectionPropertyChanged(Sender: TObject; const ConnectionId: TGUID;
	const Prop: TwclNlmConnectionProperty);
begin
	lbEvents.Items.Add('Connection: ' + GUIDToString(ConnectionId) +
		' property changed: ' + GetEnumName(Prop));
end;
                        

void __fastcall TfmMain::wclNetworkListManagerConnectivityChanged(TObject *Sender,
	const TwclNlmConnectivityFlags Connectivity)
{
	lbEvents->Items->Add("Connectivity changed: " + DecodeFlags(Connectivity));
}

void __fastcall TfmMain::wclNetworkListManagerNetworkAdded(TObject *Sender,
	const TGUID &NetworkId)
{
	lbEvents->Items->Add("Network added: " + Sysutils::GUIDToString(NetworkId));
}

void __fastcall TfmMain::wclNetworkListManagerNetworkConnectivityChanged(TObject *Sender, const TGUID &NetworkId,
	const TwclNlmConnectivityFlags Connectivity)
{
	lbEvents->Items->Add("Network " + Sysutils::GUIDToString(NetworkId) +
		" connectivity changed: " + DecodeFlags(Connectivity));
}

void __fastcall TfmMain::wclNetworkListManagerNetworkDeleted(TObject *Sender, const TGUID &NetworkId)
{
	lbEvents->Items->Add("Network deleted: " + Sysutils::GUIDToString(NetworkId));
}

void __fastcall TfmMain::wclNetworkListManagerNetworkPropertyChanged(TObject *Sender, const TGUID &NetworkId,
	const TwclNlmNetworkPropertyChangeFlags Change)
{
	lbEvents->Items->Add("Network " + Sysutils::GUIDToString(NetworkId) +
		" property changed: " + DecodeFlags(Change));
}

void __fastcall TfmMain::wclNetworkListManagerConnectionConnectivityChanged(TObject *Sender, const TGUID &ConnectionId,
	const TwclNlmConnectivityFlags Connectivity)
{
	lbEvents->Items->Add("Connection: " + Sysutils::GUIDToString(ConnectionId) +
		" connectivity changed: " + DecodeFlags(Connectivity));
}

void __fastcall TfmMain::wclNetworkListManagerConnectionPropertyChanged(TObject *Sender, const TGUID &ConnectionId,
	const TwclNlmConnectionProperty Prop)
{
	lbEvents->Items->Add("Connection: " + Sysutils::GUIDToString(ConnectionId) +
		" property changed: " + GetEnumName(Prop));
}
                        

void wclNetworkListManager_OnConnectivityChanged(object Sender, wclNlmConnectivity Connectivity)
{
	lbEvents.Items.Add("Connectivity changed: " + Connectivity.ToString());
}

void wclNetworkListManager_OnNetworkAdded(object Sender, Guid NetworkId)
{
	lbEvents.Items.Add("Network added: " + NetworkId.ToString());
}

void wclNetworkListManager_OnNetworkConnectivityChanged(object Sender,
	Guid NetworkId, wclNlmConnectivity Connectivity)
{
	lbEvents.Items.Add("Network " + NetworkId.ToString() +
		" connectivity changed: " + Connectivity.ToString());
}

void wclNetworkListManager_OnNetworkDeleted(object Sender, Guid NetworkId)
{
	lbEvents.Items.Add("Network deleted: " + NetworkId.ToString());
}

void wclNetworkListManager_OnNetworkPropertyChanged(object Sender,
	Guid NetworkId, wclNlmNetworkPropertyChange Change)
{
	lbEvents.Items.Add("Network " + NetworkId.ToString() +
		" property changed: " + Change.ToString());
}

void wclNetworkListManager_OnConnectionConnectivityChanged(object Sender,
	Guid ConnectionId, wclNlmConnectivity Connectivity)
{
	lbEvents.Items.Add("Connection: " + ConnectionId.ToString() +
		" connectivity changed: " + Connectivity.ToString());
}

void wclNetworkListManager_OnConnectionPropertyChanged(object Sender,
	Guid ConnectionId, wclNlmConnectionProperty Prop)
{
	lbEvents.Items.Add("Connection: " + ConnectionId.ToString() +
		" property changed: " + Prop.ToString());
}
                        

Private Sub wclNetworkListManager_OnConnectivityChanged(ByVal Sender As Object,
	ByVal Connectivity As wclWiFi.wclNlmConnectivity) Handles wclNetworkListManager.OnConnectivityChanged
	lbEvents.Items.Add("Connectivity changed: " + Connectivity.ToString())
End Sub

Private Sub wclNetworkListManager_OnNetworkAdded(ByVal Sender As Object,
	ByVal NetworkId As System.Guid) Handles wclNetworkListManager.OnNetworkAdded
	lbEvents.Items.Add("Network added: " + NetworkId.ToString())
End Sub

Private Sub wclNetworkListManager_OnNetworkConnectivityChanged(ByVal Sender As Object,
	ByVal NetworkId As System.Guid, ByVal Connectivity As wclWiFi.wclNlmConnectivity) Handles wclNetworkListManager.OnNetworkConnectivityChanged
	lbEvents.Items.Add("Network " + NetworkId.ToString() + " connectivity changed: " + Connectivity.ToString())
End Sub

Private Sub wclNetworkListManager_OnNetworkDeleted(ByVal Sender As Object,
	ByVal NetworkId As System.Guid) Handles wclNetworkListManager.OnNetworkDeleted
	lbEvents.Items.Add("Network deleted: " + NetworkId.ToString())
End Sub

Private Sub wclNetworkListManager_OnNetworkPropertyChanged(ByVal Sender As Object,
	ByVal NetworkId As System.Guid, ByVal Change As wclWiFi.wclNlmNetworkPropertyChange) Handles wclNetworkListManager.OnNetworkPropertyChanged
	lbEvents.Items.Add("Network " + NetworkId.ToString() + " property changed: " + Change.ToString())
End Sub

Private Sub wclNetworkListManager_OnConnectionConnectivityChanged(ByVal Sender As Object,
	ByVal ConnectionId As System.Guid, ByVal Connectivity As wclWiFi.wclNlmConnectivity) Handles wclNetworkListManager.OnConnectionConnectivityChanged
	lbEvents.Items.Add("Connection: " + ConnectionId.ToString() + " connectivity changed: " + Connectivity.ToString())
End Sub

Private Sub wclNetworkListManager_OnConnectionPropertyChanged(ByVal Sender As Object,
	ByVal ConnectionId As System.Guid, ByVal Prop As wclWiFi.wclNlmConnectionProperty) Handles wclNetworkListManager.OnConnectionPropertyChanged
	lbEvents.Items.Add("Connection: " + ConnectionId.ToString() + " property changed: " + Prop.ToString())
End Sub
                        

void CNetworkListManagerDlg::ConnectivityChanged(void* Sender,
	const wclNlmConnectivityFlags& Connectivity)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Connectivity changed: ") + DecodeFlags(Connectivity));
}

void CNetworkListManagerDlg::NetworkAdded(void* Sender, const GUID& NetworkId)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Network added: ") + GuidToString(NetworkId));
}

void CNetworkListManagerDlg::NetworkConnectivityChanged(void* Sender,
	const GUID& NetworkId, const wclNlmConnectivityFlags& Connectivity)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Network ") + GuidToString(NetworkId) +
		_T(" connectivity changed: ") + DecodeFlags(Connectivity));
}

void CNetworkListManagerDlg::NetworkDeleted(void* Sender, const GUID& NetworkId)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Network deleted: ") + GuidToString(NetworkId));
}

void CNetworkListManagerDlg::NetworkPropertyChanged(void* Sender,
    const GUID& NetworkId, const wclNlmNetworkPropertyChangeFlags& Change)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Network ") + GuidToString(NetworkId) +
		_T(" property changed: ") + DecodeFlags(Change));
}

void CNetworkListManagerDlg::ConnectionConnectivityChanged(void* Sender,
	const GUID& ConnectionId, const wclNlmConnectivityFlags& Connectivity)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Connection ") + GuidToString(ConnectionId) +
		_T(" connectivity changed: ") + DecodeFlags(Connectivity));
}

void CNetworkListManagerDlg::ConnectionPropertyChanged(void* Sender,
	const GUID& ConnectionId, const wclNlmConnectionProperty Prop)
{
	lbEvents.InsertString(lbEvents.GetCount(), _T("Connection ") + GuidToString(ConnectionId) +
		_T(" property changed: ") + GetEnumName(Prop));
}


Step 7 - Enumerating Network Adapters

The EnumAdapters method returns a list of all physical and virtual network interfaces installed on the machine. Each wclNetworkAdapter record provides the adapter ID, friendly name, description, MAC address, list of IP addresses, DNS suffix, MTU, a set of capability flags, and the current interface status (Up, Down, Testing, etc.).



procedure TfmMain.btEnumAdaptersClick(Sender: TObject);
var
	Adapters: TwclNetworkAdapters;
	Column: TListColumn;
	i: Integer;
	j: Integer;
	Item: TListItem;
	Str: string;
begin
	if not ShowError(wclNetworkListManager.EnumAdapters(Adapters)) then begin
		lvConnections.Items.Clear;

		lvConnections.Columns.Clear;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'Id';
		Column.Width := 150;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'Friendly name';
		Column.Width := 150;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'Description';
		Column.Width := 150;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'MAC';
		Column.Width := 100;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'IPs';
		Column.Width := 200;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'DNS suffix';
		Column.Width := 100;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'MTU';
		Column.Width := 80;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'Flags';
		Column.Width := 150;
		Column := lvConnections.Columns.Add;
		Column.Caption := 'Status';
		Column.Width := 150;

		if Length(Adapters) > 0 then begin
			for i := 0 to Length(Adapters) - 1 do begin
				Item := lvConnections.Items.Add;
				Item.Caption := Adapters[i].Id;
				Item.SubItems.Add(Adapters[i].FriendlyName);
				Item.SubItems.Add(Adapters[i].Description);
				Item.SubItems.Add(Adapters[i].Mac);

				Str := '';
				if Length(Adapters[i].IPs) > 0 then begin
					for j := 0 to Length(Adapters[i].IPs) - 1 do
						AddFlag(Str, Adapters[i].IPs[j]);
				end;
				Str := '[' + Str + ']';
				Item.SubItems.Add(Str);

				Item.SubItems.Add(Adapters[i].DnsSuffix);
				Item.SubItems.Add(IntToStr(Adapters[i].Mtu));

				Str := '';
				if afDdnsEnabled in Adapters[i].Flags then
					AddFlag(Str, 'afDdnsEnabled');
				if afRegisterSuffix in Adapters[i].Flags then
					AddFlag(Str, 'afRegisterSuffix');
				if afDhcpEnabled in Adapters[i].Flags then
					AddFlag(Str, 'afDhcpEnabled');
				if afReceiveOnly in Adapters[i].Flags then
					AddFlag(Str, 'afReceiveOnly');
				if afNoMulticast in Adapters[i].Flags then
					AddFlag(Str, 'afNoMulticast');
				if afIpv6OtherStatefulConfig in Adapters[i].Flags then
					AddFlag(Str, 'afIpv6OtherStatefulConfig');
				if afNetbiosOverTcpIpEnabled in Adapters[i].Flags then
					AddFlag(Str, 'afNetbiosOverTcpIpEnabled');
				if afIpv4Enabled in Adapters[i].Flags then
					AddFlag(Str, 'afIpv4Enabled');
				if afIpv6Enabled in Adapters[i].Flags then
					AddFlag(Str, 'afIpv6Enabled');
				if afIpv6ManageAddressConfig in Adapters[i].Flags then
					AddFlag(Str, 'afIpv6ManageAddressConfig');
				Str := '[' + Str + ']';
				Item.SubItems.Add(Str);
        
				case Adapters[i].Status of
					isUp: Item.SubItems.Add('Up');
					isDown: Item.SubItems.Add('Down');
					isTesting: Item.SubItems.Add('Testring');
					isDormant: Item.SubItems.Add('Dormant');
					isNotPresent: Item.SubItems.Add('Not present');
					isLowerLayerDown: Item.SubItems.Add('Low Layer Down');
					else Item.SubItems.Add('Unknown');
				end;
			end;
		end;
	end;
end;
                        

void __fastcall TfmMain::btEnumAdaptersClick(TObject *Sender)
{
	TwclNetworkAdapters Adapters;
	if (!ShowError(wclNetworkListManager->EnumAdapters(Adapters)))
	{
		lvConnections->Items->Clear();

		lvConnections->Columns->Clear();
		TListColumn* Column = lvConnections->Columns->Add();
		Column->Caption = "Id";
		Column->Width = 150;
		Column = lvConnections->Columns->Add();
		Column->Caption = "Friendly name";
		Column->Width = 150;
		Column = lvConnections->Columns->Add();
		Column->Caption = "Description";
		Column->Width = 150;
		Column = lvConnections->Columns->Add();
		Column->Caption = "MAC";
		Column->Width = 100;
		Column = lvConnections->Columns->Add();
		Column->Caption = "IPs";
		Column->Width = 200;
		Column = lvConnections->Columns->Add();
		Column->Caption = "DNS suffix";
		Column->Width = 100;
		Column = lvConnections->Columns->Add();
		Column->Caption = "MTU";
		Column->Width = 80;
		Column = lvConnections->Columns->Add();
		Column->Caption = "Flags";
		Column->Width = 150;
		Column = lvConnections->Columns->Add();
		Column->Caption = "Status";
		Column->Width = 150;

		if (Adapters.Length > 0)
		{
			for (int i = 0; i < Adapters.Length; i++)
			{
				TListItem* Item = lvConnections->Items->Add();
				Item->Caption = Adapters[i].Id;
				Item->SubItems->Add(Adapters[i].FriendlyName);
				Item->SubItems->Add(Adapters[i].Description);
				Item->SubItems->Add(Adapters[i].Mac);

				String Str = "";
				if (Adapters[i].IPs.Length > 0)
				{
					for (int j = 0; j < Adapters[i].IPs.Length; j++)
						AddFlag(Str, Adapters[i].IPs[j]);
				}
				Str = "[" + Str + "]";
				Item->SubItems->Add(Str);

				Item->SubItems->Add(Adapters[i].DnsSuffix);
				Item->SubItems->Add(IntToStr(Adapters[i].Mtu));

				Str = "";
				if (Adapters[i].Flags.Contains(afDdnsEnabled))
					AddFlag(Str, "afDdnsEnabled");
				if (Adapters[i].Flags.Contains(afRegisterSuffix))
					AddFlag(Str, "afRegisterSuffix");
				if (Adapters[i].Flags.Contains(afDhcpEnabled))
					AddFlag(Str, "afDhcpEnabled");
				if (Adapters[i].Flags.Contains(afReceiveOnly))
					AddFlag(Str, "afReceiveOnly");
				if (Adapters[i].Flags.Contains(afNoMulticast))
					AddFlag(Str, "afNoMulticast");
				if (Adapters[i].Flags.Contains(afIpv6OtherStatefulConfig))
					AddFlag(Str, "afIpv6OtherStatefulConfig");
				if (Adapters[i].Flags.Contains(afNetbiosOverTcpIpEnabled))
					AddFlag(Str, "afNetbiosOverTcpIpEnabled");
				if (Adapters[i].Flags.Contains(afIpv4Enabled))
					AddFlag(Str, "afIpv4Enabled");
				if (Adapters[i].Flags.Contains(afIpv6Enabled))
					AddFlag(Str, "afIpv6Enabled");
				if (Adapters[i].Flags.Contains(afIpv6ManageAddressConfig))
					AddFlag(Str, "afIpv6ManageAddressConfig");
				Str = "[" + Str + "]";
				Item->SubItems->Add(Str);

				switch (Adapters[i].Status)
				{
					case isUp:
						Item->SubItems->Add("Up");
						break;
					case isDown:
						Item->SubItems->Add("Down");
						break;
					case isTesting:
						Item->SubItems->Add("Testring");
						break;
					case isDormant:
						Item->SubItems->Add("Dormant");
						break;
					case isNotPresent:
						Item->SubItems->Add("Not present");
						break;
					case isLowerLayerDown:
						Item->SubItems->Add("Low Layer Down");
						break;
					default:
						Item->SubItems->Add("Unknown");
						break;
				}
			}
		}
	}
}
                        

private void btEnumAdapters_Click(object sender, EventArgs e)
{
	wclNetworkAdapter[] Adapters;
	if (!ShowError(wclNetworkListManager.EnumAdapters(out Adapters)))
	{
		lvConnections.Items.Clear();

		lvConnections.Columns.Clear();
		lvConnections.Columns.Add("Id", 150);
		lvConnections.Columns.Add("Friendly name", 150);
		lvConnections.Columns.Add("Description", 150);
		lvConnections.Columns.Add("MAC", 100);
		lvConnections.Columns.Add("IPs", 200);
		lvConnections.Columns.Add("DNS suffix", 100);
		lvConnections.Columns.Add("MTU", 80);
		lvConnections.Columns.Add("Flags", 150);
		lvConnections.Columns.Add("Status", 150);

		if (Adapters != null && Adapters.Length > 0)
		{
			foreach (wclNetworkAdapter Adapter in Adapters)
			{
				ListViewItem Item = lvConnections.Items.Add(Adapter.Id);
				Item.SubItems.Add(Adapter.FriendlyName);
				Item.SubItems.Add(Adapter.Description);
				Item.SubItems.Add(Adapter.Mac);

				String Str = "";
				if (Adapter.IPs != null && Adapter.IPs.Length > 0)
				{
					foreach (String IP in Adapter.IPs)
						AddFlag(ref Str, IP);
				}
				Str = "[" + Str + "]";
				Item.SubItems.Add(Str);

				Item.SubItems.Add(Adapter.DnsSuffix);
				Item.SubItems.Add(Adapter.Mtu.ToString());

				Str = "";
				if ((Adapter.Flags & wclNetworkAdapterFlag.afDdnsEnabled) != 0)
					AddFlag(ref Str, "afDdnsEnabled");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afRegisterSuffix) != 0)
					AddFlag(ref Str, "afRegisterSuffix");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afDhcpEnabled) != 0)
					AddFlag(ref Str, "afDhcpEnabled");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afReceiveOnly) != 0)
					AddFlag(ref Str, "afReceiveOnly");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afNoMulticast) != 0)
					AddFlag(ref Str, "afNoMulticast");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afIpv6OtherStatefulConfig) != 0)
					AddFlag(ref Str, "afIpv6OtherStatefulConfig");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afNetbiosOverTcpIpEnabled) != 0)
					AddFlag(ref Str, "afNetbiosOverTcpIpEnabled");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afIpv4Enabled) != 0)
					AddFlag(ref Str, "afIpv4Enabled");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afIpv6Enabled) != 0)
					AddFlag(ref Str, "afIpv6Enabled");
				if ((Adapter.Flags & wclNetworkAdapterFlag.afIpv6ManageAddressConfig) != 0)
					AddFlag(ref Str, "afIpv6ManageAddressConfig");
				Str = "[" + Str + "]";
				Item.SubItems.Add(Str);

				switch (Adapter.Status)
				{
					case wclNetworkInterfaceStatus.isUp:
						Item.SubItems.Add("Up");
						break;
					case wclNetworkInterfaceStatus.isDown:
						Item.SubItems.Add("Down");
						break;
					case wclNetworkInterfaceStatus.isTesting:
						Item.SubItems.Add("Testring");
						break;
					case wclNetworkInterfaceStatus.isDormant:
						Item.SubItems.Add("Dormant");
						break;
					case wclNetworkInterfaceStatus.isNotPresent:
						Item.SubItems.Add("Not present");
						break;
					case wclNetworkInterfaceStatus.isLowerLayerDown:
						Item.SubItems.Add("Low Layer Down");
						break;
					default:
						Item.SubItems.Add("Unknown");
						break;
				}
			}
		}
	}
}
                        

Private Sub btEnumAdapters_Click(sender As System.Object, e As System.EventArgs) Handles btEnumAdapters.Click
	Dim Adapters As wclWiFi.wclNetworkAdapter() = Nothing
	If Not ShowError(wclNetworkListManager.EnumAdapters(Adapters)) Then
		lvConnections.Items.Clear()

		lvConnections.Columns.Clear()
		lvConnections.Columns.Add("Id", 150)
		lvConnections.Columns.Add("Friendly name", 150)
		lvConnections.Columns.Add("Description", 150)
		lvConnections.Columns.Add("MAC", 100)
		lvConnections.Columns.Add("IPs", 200)
		lvConnections.Columns.Add("DNS suffix", 100)
		lvConnections.Columns.Add("MTU", 80)
		lvConnections.Columns.Add("Flags", 150)
		lvConnections.Columns.Add("Status", 150)

		If Adapters IsNot Nothing AndAlso Adapters.Length > 0 Then
			For Each Adapter As wclWiFi.wclNetworkAdapter In Adapters
				Dim Item As ListViewItem = lvConnections.Items.Add(Adapter.Id)
				Item.SubItems.Add(Adapter.FriendlyName)
				Item.SubItems.Add(Adapter.Description)
				Item.SubItems.Add(Adapter.Mac)

				Dim Str As String = ""
				If Adapter.IPs IsNot Nothing AndAlso Adapter.IPs.Length > 0 Then
					For Each IP As String In Adapter.IPs
						AddFlag(Str, IP)
					Next
				End If
				Str = "[" + Str + "]"
				Item.SubItems.Add(Str)

				Item.SubItems.Add(Adapter.DnsSuffix)
				Item.SubItems.Add(Adapter.Mtu.ToString())

				Str = ""
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afDdnsEnabled) <> 0 Then AddFlag(Str, "afDdnsEnabled")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afRegisterSuffix) <> 0 Then AddFlag(Str, "afRegisterSuffix")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afDhcpEnabled) <> 0 Then AddFlag(Str, "afDhcpEnabled")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afReceiveOnly) <> 0 Then AddFlag(Str, "afReceiveOnly")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afNoMulticast) <> 0 Then AddFlag(Str, "afNoMulticast")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afIpv6OtherStatefulConfig) <> 0 Then AddFlag(Str, "afIpv6OtherStatefulConfig")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afNetbiosOverTcpIpEnabled) <> 0 Then AddFlag(Str, "afNetbiosOverTcpIpEnabled")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afIpv4Enabled) <> 0 Then AddFlag(Str, "afIpv4Enabled")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afIpv6Enabled) <> 0 Then AddFlag(Str, "afIpv6Enabled")
				If (Adapter.Flags And wclWiFi.wclNetworkAdapterFlag.afIpv6ManageAddressConfig) <> 0 Then AddFlag(Str, "afIpv6ManageAddressConfig")
				Str = "[" + Str + "]"
				Item.SubItems.Add(Str)

				Select Case Adapter.Status
					Case wclWiFi.wclNetworkInterfaceStatus.isUp
						Item.SubItems.Add("Up")
					Case wclWiFi.wclNetworkInterfaceStatus.isDown
						Item.SubItems.Add("Down")
					Case wclWiFi.wclNetworkInterfaceStatus.isTesting
						Item.SubItems.Add("Testring")
					Case wclWiFi.wclNetworkInterfaceStatus.isDormant
						Item.SubItems.Add("Dormant")
					Case wclWiFi.wclNetworkInterfaceStatus.isNotPresent
						Item.SubItems.Add("Not present")
					Case wclWiFi.wclNetworkInterfaceStatus.isLowerLayerDown
						Item.SubItems.Add("Low Layer Down")
					Case Else
						Item.SubItems.Add("Unknown")
				End Select
			Next
		End If
	End If
End Sub
                        

void CNetworkListManagerDlg::OnBnClickedButtonEnumAdapters()
{
	wclNetworkAdapters Adapters;
	if (!ShowError(FManager.EnumAdapters(Adapters)))
	{
		lvConnections.DeleteAllItems();
		while (lvConnections.DeleteColumn(0)) ;
		lvConnections.InsertColumn(0, _T("Id"), 0, 150);
		lvConnections.InsertColumn(1, _T("Friendly name"), 0, 150);
		lvConnections.InsertColumn(2, _T("Description"), 0, 150);
		lvConnections.InsertColumn(3, _T("MAC"), 0, 100);
		lvConnections.InsertColumn(4, _T("IPs"), 0, 200);
		lvConnections.InsertColumn(5, _T("DNS suffix"), 0, 100);
		lvConnections.InsertColumn(6, _T("MTU"), 0, 80);
		lvConnections.InsertColumn(7, _T("Flags"), 0, 150);
		lvConnections.InsertColumn(8, _T("Status"), 0, 150);

		if (Adapters.size() > 0)
		{
			for (size_t i = 0; i < Adapters.size(); i++)
			{
				lvConnections.InsertItem((int)i, Adapters[i].Id.c_str());
				lvConnections.SetItemText((int)i, 1, Adapters[i].FriendlyName.c_str());
				lvConnections.SetItemText((int)i, 2, Adapters[i].Description.c_str());
				lvConnections.SetItemText((int)i, 3, Adapters[i].Mac.c_str());

				CString Str = _T("");
				if (Adapters[i].IPs.size() > 0)
				{
					for (size_t j = 0; j < Adapters[i].IPs.size(); j++)
						AddFlag(Str, Adapters[i].IPs[j]);
				}
				Str = _T("[") + Str +  _T("]");
				lvConnections.SetItemText((int)i, 4, Str);

				lvConnections.SetItemText((int)i, 5, Adapters[i].DnsSuffix.c_str());

				Str.Format(_T("%d"), Adapters[i].Mtu);
				lvConnections.SetItemText((int)i, 6, Str);

				Str = _T("");
				if (Adapters[i].Flags.find(afDdnsEnabled) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afDdnsEnabled"));
				if (Adapters[i].Flags.find(afRegisterSuffix) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afRegisterSuffix"));
				if (Adapters[i].Flags.find(afDhcpEnabled) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afDhcpEnabled"));
				if (Adapters[i].Flags.find(afReceiveOnly) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afReceiveOnly"));
				if (Adapters[i].Flags.find(afNoMulticast) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afNoMulticast"));
				if (Adapters[i].Flags.find(afIpv6OtherStatefulConfig) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afIpv6OtherStatefulConfig"));
				if (Adapters[i].Flags.find(afNetbiosOverTcpIpEnabled) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afNetbiosOverTcpIpEnabled"));
				if (Adapters[i].Flags.find(afIpv4Enabled) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afIpv4Enabled"));
				if (Adapters[i].Flags.find(afIpv6Enabled) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afIpv6Enabled"));
				if (Adapters[i].Flags.find(afIpv6ManageAddressConfig) != Adapters[i].Flags.end())
					AddFlag(Str, _T("afIpv6ManageAddressConfig"));
				Str = _T("[") + Str + _T("]");
				lvConnections.SetItemText((int)i, 7, Str);

				switch (Adapters[i].Status)
				{
					case isUp:
						lvConnections.SetItemText((int)i, 8, _T("Up"));
						break;
					case isDown:
						lvConnections.SetItemText((int)i, 8, _T("Down"));
						break;
					case isTesting:
						lvConnections.SetItemText((int)i, 8, _T("Testring"));
						break;
					case isDormant:
						lvConnections.SetItemText((int)i, 8, _T("Dormant"));
						break;
					case isNotPresent:
						lvConnections.SetItemText((int)i, 8, _T("Not present"));
						break;
					case isLowerLayerDown:
						lvConnections.SetItemText((int)i, 8, _T("Low Layer Down"));
						break;
					default:
						lvConnections.SetItemText((int)i, 8, _T("Unknown"));
						break;
				}
			}
		}
	}
}

Frequently Asked Questions

What is the Network List Manager in Windows?
It is a Windows component that identifies and manages network connections, providing information about network identity, connectivity status, category (public, private, domain), and internet access. The Wi-Fi Framework wraps it in the wclNetworkListManager class.
How can I get network connectivity information programmatically?
Use the wclNetworkListManager class from the Wi-Fi Framework. It allows you to enumerate networks, read their names, descriptions, categories, and connectivity states, and receive events when networks change.
Can I change the network category (public/private) with the Wi-Fi Framework?
Yes, the Network List Manager API allows you to set the network category programmatically, which affects the Windows Firewall profile and network discovery settings.