如何检查NetworkInterface对象的'OperationalStatus'属性中的更改？

Question

I want to mention that this property does NOT change internally so I can't use the code below. It changes from "Up" to "Down" or vice versa based on if theres a connection established on that NIC. So this property is changed external to the program.

If I have a static NetworkInterface Object, and I want to do something (say show a message box) when the OperationalStatus property of that object changes from up to down, how would I do so? My current idea is to have a timer check every few seconds for a change in the property but I'd much rather have a response for the situation ASAP. Also this seems sort of amateur.

Oh and I know this exists for property changes:

    private string _status;

    public string status
    {
        get { return _status; }
        set
        {
            if (value != _status)
            {
                _status = value;
                MessageBox.Show("VPN status changed to: ", _status);
            }
        }
    }

However since this property is changing externally from the program the set content won't ever be executed. Anyone know a good fix for this?

Also, I think INotifyPropertyChanged might be helpful here but I've never used it before and the examples I've seen so far are sort of difficult for me to wrap my head around. If this is the case, would you mind demonstrating using static NetworkInterface card; as the object? I'd appreciate that much more than a "marked as dupe" flag. Thank you!

Answer 1

I'm am not aware of a general mechanism to be informed of changes to the status of a NetworkInterface object. However, if you really only do care about the status changing from Up to Down and vice a versa, you can subscribe to the NetworkChange.NetworkAvailabilityChanged event, and rescan the network interfaces status when the event is raised.

It still requires examining all of the interfaces, but at least it happens only at a time when you know that at least one of them has changed. This is much better than some kind of polling approach.

Here is a short little WPF program that makes use of the event to maintain a list of known network interfaces, and to display in the window the interface name and its current operational status. Adapters that are new — that is, they were not known the previous time the event was raised — are shown with a green background, those which have had a change in the OperationalStatus property value are shown with a yellow background, and those which are no longer present are shown with a red background (until the next time the event is raised, at which time they are removed completely).

The main work is done in the MainViewModel class:

class MainModel : NotifyPropertyChangedBase
{
    private readonly Dictionary<string, NetworkInterfaceModel> _cache = new Dictionary<string, NetworkInterfaceModel>();

    private IReadOnlyList<NetworkInterfaceModel> _interfaces;
    public IReadOnlyList<NetworkInterfaceModel> Interfaces
    {
        get { return _interfaces; }
        private set { _UpdateField(ref _interfaces, value); }
    }

    public MainModel()
    {
        NetworkChange.NetworkAvailabilityChanged += _OnNetworkAvailabilityChanged;
        _RebuildInterfaceList();
    }

    private void _OnNetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
    {
        foreach (NetworkInterfaceModel model in _interfaces)
        {
            if (model.PostEventStatus == PostEventStatus.Removed)
            {
                _cache.Remove(model.Name);
            }
            else
            {
                // Assume removed, until proven otherwise while rebuilding list
                model.SetRemoved();
            }
        }

        _RebuildInterfaceList();
    }

    private void _RebuildInterfaceList()
    {
        foreach (NetworkInterface networkInterface in NetworkInterface.GetAllNetworkInterfaces())
        {
            NetworkInterfaceModel model;

            if (!_cache.TryGetValue(networkInterface.Name, out model))
            {
                model = new NetworkInterfaceModel(networkInterface);
                _cache.Add(model.Name, model);
            }
            else
            {
                model.Reset();
                model.OperationalStatus = networkInterface.OperationalStatus;
            }
        }

        Interfaces = Array.AsReadOnly(_cache.Values.OrderBy(m => m.Name).ToArray());
    }
}

The above contains the code that is the actual answer to your question, ie the subscription to and handling of the NetworkChange.NetworkAvailabilityChanged event. The rest of this program is just there to provide a way for that code to operate and do something useful.

The program uses a NetworkInterfaceModel class to track the status of each interface:

enum PostEventStatus
{
    Added,
    NoChange,
    Changed,
    Removed
}

class NetworkInterfaceModel : NotifyPropertyChangedBase
{
    private string _name;
    private OperationalStatus _status;
    private PostEventStatus _postEventStatus = PostEventStatus.Added;

    public NetworkInterfaceModel(NetworkInterface networkInterface)
    {
        _name = networkInterface.Name;
        _status = networkInterface.OperationalStatus;
    }

    public string Name
    {
        get { return _name; }
        set { _UpdateField(ref _name, value); }
    }

    public OperationalStatus OperationalStatus
    {
        get { return _status; }
        set { _UpdateField(ref _status, value, _OnOperationalStatusChanged); }
    }

    public PostEventStatus PostEventStatus
    {
        get { return _postEventStatus; }
        set { _UpdateField(ref _postEventStatus, value); }
    }

    public void Reset()
    {
        PostEventStatus = PostEventStatus.NoChange;
    }

    public void SetRemoved()
    {
        PostEventStatus = PostEventStatus.Removed;
    }

    private void _OnOperationalStatusChanged(OperationalStatus obj)
    {
        PostEventStatus = PostEventStatus.Changed;
    }
}

Both of these "model" classes rely on an inherited class that provides the base functionality for implementing INotifyPropertyChanged :

class NotifyPropertyChangedBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void _UpdateField<T>(ref T field, T newValue,
        Action<T> onChangedCallback = null,
        [CallerMemberName] string propertyName = null)
    {
        if (EqualityComparer<T>.Default.Equals(field, newValue))
        {
            return;
        }

        T oldValue = field;

        field = newValue;
        onChangedCallback?.Invoke(oldValue);
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

And of course, no WPF program is complete without the XAML describing the actual presentation of the data:

<Window x:Class="TestSO43419337OperationalStatusChange.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:p="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:l="clr-namespace:TestSO43419337OperationalStatusChange"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">

  <Window.DataContext>
    <l:MainModel/>
  </Window.DataContext>

  <Window.Resources>
    <DataTemplate DataType="{x:Type l:NetworkInterfaceModel}">
      <Border BorderBrush="Black" BorderThickness="1">
        <Border.Style>
          <p:Style TargetType="Border">
            <p:Style.Triggers>
              <DataTrigger Binding="{Binding PostEventStatus}" Value="{x:Static l:PostEventStatus.Added}">
                <Setter Property="Background" Value="LightGreen"/>
              </DataTrigger>
              <DataTrigger Binding="{Binding PostEventStatus}" Value="{x:Static l:PostEventStatus.Changed}">
                <Setter Property="Background" Value="Yellow"/>
              </DataTrigger>
              <DataTrigger Binding="{Binding PostEventStatus}" Value="{x:Static l:PostEventStatus.Removed}">
                <Setter Property="Background" Value="Red"/>
              </DataTrigger>
            </p:Style.Triggers>
          </p:Style>
        </Border.Style>
        <Grid Margin="3">
          <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition/>
          </Grid.RowDefinitions>
          <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition/>
          </Grid.ColumnDefinitions>
          <TextBlock Text="Name: " Grid.Row="0" Grid.Column="0"/>
          <TextBlock Text="{Binding Name}" Grid.Row="0" Grid.Column="1"/>
          <TextBlock Text="Operational Status: " Grid.Row="1" Grid.Column="0"/>
          <TextBlock Text="{Binding OperationalStatus}" Grid.Row="1" Grid.Column="1"/>
        </Grid>
      </Border>
    </DataTemplate>
  </Window.Resources>

  <Grid>
    <ListBox ItemsSource="{Binding Interfaces}" HorizontalContentAlignment="Stretch"/>
  </Grid>
</Window>