Q:

How to update ViewModel from a class reference exposed as a Property in the Model

I have three C# classes A, B and C where

A is a ViewModel
B is a Model
C is a state class (containing some state information about a device, like e.g. IsConnected)

They are connected such that B has a property of type C. C contains almost 30 properties representing the device state.
I have decided to let B update A via INotifyPropertyChanged, and now I am looking for a way for A to be informed when properties in C changes.
What's the easiest way of achieving this?
Update: 
This code will do the trick.
class Gun : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public GunState GunState { get; private set; }

    public Gun()
    {
        GunState = new GunState();
        GunState.PropertyChanged += GunStateOnPropertyChanged;
    }

    private void GunStateOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs)
    {
        NotifyPropertyChanged(propertyChangedEventArgs.PropertyName);
    }

    protected virtual void NotifyPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

class GunState : INotifyPropertyChanged
{
    private bool _isLoaded;
    public event PropertyChangedEventHandler PropertyChanged;

    public bool IsLoaded
    {
        get { return _isLoaded; }
        private set
        {
            if (_isLoaded != value)
            {
                _isLoaded = value;
                NotifyPropertyChanged("IsLoaded");
            }
        }
    }

    public void SimulateLoadGun(bool isLoaded)
    {
        IsLoaded = isLoaded;
    }

    protected virtual void NotifyPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }

}

class GunViewModel : INotifyPropertyChanged
{
    private readonly Gun _gun;

    public GunViewModel()
    {
        _gun = new Gun();
        _gun.PropertyChanged += OnGunOnPropertyChanged;
    }

    public string IsLoaded
    {
        get { return _gun.GunState.IsLoaded ? "Gun is loaded!" : "Gun is not loaded."; }
    }

    private void OnGunOnPropertyChanged(object sender, PropertyChangedEventArgs args)
    {
        NotifyPropertyChanged(args.PropertyName);
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void NotifyPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }

    public void LoadGun()
    {
        _gun.GunState.SimulateLoadGun(!_gun.GunState.IsLoaded);
    }
}

XAML: 
<Window x:Class="ModelViewModelInteraction.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="clr-namespace:ModelViewModelInteraction"

        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <vm:GunViewModel x:Name="_model" />
    </Window.DataContext>

    <Grid>
        <Label Content="{Binding IsLoaded}" Margin="0,0,313,262" />
        <Button Content="Load gun" Click="Button_Click_1" Margin="73,83,283,59" />
    </Grid>
</Window>

XAML.cs
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        _viewModel = new GunViewModel();
        DataContext = _viewModel;
    }

    private GunViewModel _viewModel;

    private void Button_Click_1(object sender, RoutedEventArgs e)
    {
        _viewModel.LoadGun();
    }
}

A:

I would follow the Law of Demeter; A shouldn't need knowledge of what's going on in C. Rather, A should watch for notifications from B when relevant properties in C change.
For example, your model, B could have its own IsConnected property, and you could continue using INotifyPropertyChanged mechanisms.

