anchor.diff:      let errorsChanged = Event<_,_>()
   
       static let proxyFactory = ProxyGenerator()
  -    static let proxyOptions = ProxyGenerationOptions(hook = {
  +    static let proxyOptions = ProxyGenerationOptions {
           new IProxyGenerationHook with
  -            member __.ShouldInterceptMethod(_, methodInfo) = 
  -                match methodInfo with 
  -                | Abstract & PropertySetter _ | Abstract & PropertyGetter _ -> true 
  +            member __.ShouldInterceptMethod(type', method') = 
  +                match method' with 
  +                | Virtual & PropertySetter propertyName when type'.GetProperty(propertyName).GetGetMethod() <> null -> true
  +                | Virtual & PropertyGetter propertyName when type'.GetProperty(propertyName).GetSetMethod() <> null -> true 
                   | _ -> false 
               member __.NonProxyableMemberNotification(_, _) = ()          
               member __.MethodsInspected() = ()          
  -    })
  +    }
   
       static member Create<'T when 'T :> Model and 'T : not struct>([<ParamArray>] constructorArguments)  = 
  -        let interceptors : IInterceptor[] = [| AbstractProperties() |]
  +        let interceptors : IInterceptor[] = [| PropertyInterceptor() |]
           proxyFactory.CreateClassProxy(typeof<'T>, proxyOptions, constructorArguments, interceptors) |> unbox<'T>    
   
       interface INotifyPropertyChanged with
  
positive.code:         | _ -> None
  
      let (|Abstract|_|) (m : MethodInfo) = if m.IsAbstract then Some() else None
  
  open MethodInfo
  
  
negative.code:         errors.[propertyName] <- messages
          errorsChanged.Trigger(this, DataErrorsChangedEventArgs propertyName)
  
  and internal PropertyInterceptor() =
      let data = Dictionary()
  
      interface IInterceptor with
          member this.Intercept invocation = 
              match invocation.Method with 
                  | Abstract & PropertySetter propertyName -> 
                      let _, prevValue = data.TryGetValue propertyName
                      data.[propertyName] <- invocation.Arguments.[0]
                      if invocation.Arguments.[0] <> prevValue
                      then 
                          let model: Model = invocation.InvocationTarget |> unbox
                          model.NotifyPropertyChanged propertyName
                          model.SetErrors(propertyName, Array.empty)
  
                  | Abstract & PropertyGetter propertyName ->
                      match data.TryGetValue propertyName with 
                      | true, value -> invocation.ReturnValue <- value 
                      | false, _ -> 
                          let returnType = invocation.Method.ReturnType
                          if returnType.IsValueType then 
                              invocation.ReturnValue <- Activator.CreateInstance returnType
                  | Virtual & PropertySetter propertyName -> 
                      let prevValue = invocation.TargetType.GetProperty(propertyName).GetValue(invocation.InvocationTarget)
                      invocation.Proceed()
                      if invocation.Arguments.[0] <> prevValue
                      then 
                          let model: Model = invocation.InvocationTarget |> unbox
                          model.NotifyPropertyChanged propertyName
                          model.SetErrors(propertyName, Array.empty)
                  | _ -> 
                      invocation.Proceed()
  
  [<RequireQualifiedAccess>]
  module Mvc = 
  