Business entity with INotifyPropertyChanged implemented is causing WCF Test Client to throw "Object reference not set to an instance of an Object" exception

Thanks Todd, here is the code in the base class BOBase.
 [DataContract]
    public class BOBase : INotifyPropertyChanged
    {
        private List<string> _changedFields = new List<string>();

        [DataMember]
        public List<string> ChangedFields
        {
            get { return _changedFields; }
        }

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

       
        public enum BusinessObjectSource
        {
            AddedNotInDb = 0,
            FromDb = 1,
        }
       
        public enum BusinessObjectStatus
        {
            Deleted = 0,
            Modified = 1,
            Unchanged = 2
        }
        BusinessObjectStatus _objectStatus;
        BusinessObjectSource _objectSource;

        public BOBase()
        {
            _objectSource = BusinessObjectSource.AddedNotInDb;
            _objectStatus = BusinessObjectStatus.Unchanged;
        }

        [DataMember]
        public bool IsNew
        {
            get { return _objectSource == BusinessObjectSource.AddedNotInDb; }
            set { _objectSource = BusinessObjectSource.AddedNotInDb; }
        }
        [DataMember]
        public bool IsPhantom
        {
            get
            {
                return _objectSource == BusinessObjectSource.AddedNotInDb &&
                       _objectStatus == BusinessObjectStatus.Deleted;
            }
            set { }
        }

       
        [DataMember]
        public bool IsModified
        {
            get
            {
                return
              _objectSource == BusinessObjectSource.FromDb &&
              _objectStatus == BusinessObjectStatus.Modified;
            }
            set{}
        }
        [DataMember]
        public bool IsDeleted
        {
            get
            {
                return
              _objectSource == BusinessObjectSource.FromDb &&
              _objectStatus == BusinessObjectStatus.Deleted;
            }
            set{}
        }
        [DataMember]
        public bool IsUnchanged
        {
            get
            {
                return
              _objectSource == BusinessObjectSource.FromDb &&
              _objectStatus == BusinessObjectStatus.Unchanged;
            }
            set{}
        }

     
        public virtual void Delete()
        {
            _objectStatus = BusinessObjectStatus.Deleted;
        }

        protected void SetNewPropertyValue<T>(string name, BusinessObjectField<T> theField, T newValue)
        {        
            if (!theField.Value.Equals(newValue))
            {
                theField.Value = newValue;
                FirePropertyChanged(name);                
                _changedFields.Add(name);
            }
        }

        protected void FirePropertyChanged(string p)
        {
            _objectStatus = BusinessObjectStatus.Modified;

            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(p));

        }
       

        /// <summary>
        /// Call AcceptChange on all fields that support an AcceptChange method
        /// </summary>
        public virtual void AcceptChanges()
        {
            Type t = GetType();
            System.Reflection.FieldInfo[] fields = t.GetFields(System.Reflection.BindingFlags.Instance
                        | System.Reflection.BindingFlags.Public
                        | System.Reflection.BindingFlags.NonPublic
                        );

            foreach (System.Reflection.FieldInfo field in fields)
            {
                // Get object reference for the field.  Then we can call the property
                IBOField fieldValue = field.GetValue(this) as IBOField;
                if (fieldValue != null)
                    fieldValue.AcceptChange();
            }

            _objectSource = BusinessObjectSource.FromDb;
            _objectStatus = BusinessObjectStatus.Unchanged;

            _changedFields.Clear();
        }


     
    }

It appears to be failing on the following line of the class DisplayDiscipline.

 _theDiscipline.Deleted = value;

which is in the setter of the property Deleted....

       
       [DataMember]
        public Boolean Deleted
        {
            get { return _theDiscipline.Deleted; }
            set
            {
                _theDiscipline.Deleted = value;
                FirePropertyChanged("Deleted");
            }
        }


I have instantiated _theDiscipline in the constructor so it should not be null at this point.

public DisplayDiscipline()
        {          
            _id = new BusinessObjectField<Guid>(Guid.NewGuid());
             _theDiscipline = new Discipline();
        }


I think the FirePropertyChanged method has nothing to do with the problem, sorry for the misdirection.

Is there something I am missing in terms of where I should be instantiating the object _theDiscipline?

So DisplayDiscipline has a Discipline instance in it. And it's created in DisplayDiscipline's constructor. Then, later on, from DisplayDiscipline, it tries to set the Deleted property. Is this right? Looks reasonable enough.

Is the Deleted property doing anything that could cause this? Is it anything but a simple property setter?
You can always throw an Assert in, just above "_theDiscipline.Deleted = value;" to test _theDiscipline for null.

Without error handling, it's quite easy to assume that the failing line is causing the error, and miss the fact that it's actually failing several levels down into that call. You need to really be careful when evaluating the call stack.

Finally, rather than going through the underlying variables for properties, I generally like to go through ther accessors so that I can debug problems like this. So, let's say you have the line "_theDiscipline = new Discipline();", yet somehow later on that variable is null. How do you know if it's being set elsewhere? You don't, unless everything goes through "This.Discipline = new Discipline();". Now you can instrument that setter and breakpoint or log all sets to see if you're forgetting about something else that's messing with the value after your constructor's initialized it.

Yes The setter tries to set the Discipline.Deleted property to the value of the setting property.

ie. _theDiscipline.Deleted = value;

I like your suggestion about using the accessors instead of using the underlying fields to change the value of a property, I will give it a try, at least I will be more sure of the source of any errors.

I think the issue may be arising from the fact that WCF will not run any constructor or method code when it serialises out to the client.

I have tried adding an OnDeserialised method to the DisplayDiscipline class which instantiates the Discipline class in the same way that the constructor would have, but still no luck.

I am now wondering whether the WCF Test Client is the right tool to test the operation of my service i nthese circumstances.

What I will do now is creating my own proxy in a class library project that calls the service directly and see if this works.

Do you have any other suggestions?

I think you are on the right path.

http://mehranikoo.net/CS/archive/2007/11/09/DataContractConstructorsInWCF.aspx

Here's a small excerpt:

>>Something that you need to be aware of is that the parameter-less constructor for the data contract is only called when the object is instantiated by your code. So for example, when you call a WCF service and the service returns a data contract, WCF runtime on the client side does not call the parameter-less constructor, which makes sense as the returned message includes all the state you need and there is no point in running the constructor. If you need to perform an operation when the message is received by the client, you can use OnDeserializingAttribute or OnDeserializedAttribute defined in System.Runtime.Serialization namespace.