Error Serializing Observable Collection

Question

I have an observable collection I am trying to serialize to disk. The error that is received is :

 Type 'VisuallySpeaking.Data.GrammarList' with data contract name
 'GrammarList:http://schemas.datacontract.org/2004/07/VisuallySpeaking.Data'
 is not expected. Consider using a DataContractResolver or add any
 types not known statically to the list of known types - for example,
 by using the KnownTypeAttribute attribute or by adding them to the
 list of known types passed to
 DataContractSerializer."}  System.Exception
 {System.Runtime.Serialization.SerializationException}

Here is my data object:

namespace VisuallySpeaking.Data
{

    [CollectionDataContract]
    public class GrammarList : ObservableCollection<GrammarDataObject>
{
    public GrammarList() : base()
    {
        Add(new GrammarDataObject("My Name", "My name is","Assets/SampleAssets/MyName.png"));
        Add(new GrammarDataObject("Where is", "Where is",""));
        Add(new GrammarDataObject("Dog", "I have a dog","/Assets/SampleAssets/westie.jpg"));
    }
  }

  [DataContract]
  public class GrammarDataObject :  VisuallySpeaking.Common.BindableBase
  {
      private string _Name;
      private string _SpeakingText;
      private string _ImagePath;


      public GrammarDataObject(string Name, string SpeakingText, string ImagePath)
      {
          this.Name = Name;
          this.SpeakingText = SpeakingText;
          this.ImagePath = ImagePath;
      }

      [DataMember]
      public string Name
      {
          get { return _Name; }
          set
          {
              if (this._Name != value)
              {
                  this._Name = value;
                  this.OnPropertyChanged("Name");
              }
          }
      }

      [DataMember]
      public string SpeakingText
      {
          get { return _SpeakingText; }
          set
          {
              if (this._SpeakingText != value)
              {
                  this._SpeakingText = value;
                  this.OnPropertyChanged("SpeakingText");
              }
          }
      }

      [DataMember]
      public string ImagePath
      {
          get { return _ImagePath; }
          set
          {
              if (this._ImagePath != value)
              {
                  this._ImagePath = value;
                  this.OnPropertyChanged("ImagePath");
              }
          }
      }
  }

Based on Fresh's comments, I have added BindableBase in here as well.

namespace VisuallySpeaking.Common
{
    /// <summary>
    /// Implementation of <see cref="INotifyPropertyChanged"/> to simplify models.
    /// </summary>
    [Windows.Foundation.Metadata.WebHostHidden]
    [DataContract(IsReference = true)]
    public abstract class BindableBase : INotifyPropertyChanged
    {
        /// <summary>
        /// Multicast event for property change notifications.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Checks if a property already matches a desired value.  Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners.  This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] String propertyName = null)
        {
            if (object.Equals(storage, value)) return false;

            storage = value;
            this.OnPropertyChanged(propertyName);
            return true;
        }

        /// <summary>
        /// Notifies listeners that a property value has changed.
        /// </summary>
        /// <param name="propertyName">Name of the property used to notify listeners.  This
        /// value is optional and can be provided automatically when invoked from compilers
        /// that support <see cref="CallerMemberNameAttribute"/>.</param>
        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            var eventHandler = this.PropertyChanged;
            if (eventHandler != null)
            {
                eventHandler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

I assume that I have somehow marked my GrammarList class incorrectly, but it escapes me as to how to resolve.

UPDATE: Following the error message (of course), I added the KnowTypeAttribute and it appeared to work:

[CollectionDataContract(Name = "GrammarList"),KnownType(typeof(GrammarList))]
public class GrammarList : ObservableCollection<GrammarDataObject>

Again, thanks to Fresh, I updated the CollectionDataContract with the Name="GrammarList", but now the issue comes when I rehydrate the XML file from disk. I get the following error message:

Expecting element 'GrammarList' from namespace 'http://schemas.datacontract.org/2004/07/VisuallySpeaking.Data'.. Encountered 'Element' with name 'GrammarDataObject', namespace 'http://schemas.datacontract.org/2004/07/VisuallySpeaking.Data'.

The serialized XML looks like this:

<?xml version="1.0"?>    
<GrammarDataObject xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/VisuallySpeaking.Data" i:type="GrammarList">        
    <GrammarDataObject xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Id="i1">    
         <ImagePath>Assets/SampleAssets/MyName.png</ImagePath>    
         <Name>My Name</Name>    
         <SpeakingText>My name is</SpeakingText>    
    </GrammarDataObject>


    <GrammarDataObject xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Id="i3">    
        <ImagePath/>  
        <Name>Where is</Name>    
        <SpeakingText>Where is</SpeakingText>    
     </GrammarDataObject>


    <GrammarDataObject xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Id="i4">    
        <ImagePath>/Assets/SampleAssets/westie.jpg</ImagePath>    
        <Name>Dog</Name>    
        <SpeakingText>I have a dog</SpeakingText>    
    </GrammarDataObject>    
</GrammarDataObject>

Why is the XML outer tags not listed as "GrammarList"? I would assume that is what the deserializer is looking for. When I manually edit the serialized xml to place GrammarList as the outside tags, it deserializes appropriately. I feel sure I am missing something again!

UPDATE AGAIN When I was serializing I had the following code:

DataContractSerializer serializer = new DataContractSerializer(typeof(GrammarDataObject));

I changed it to serialize to GrammarList and presto, fixed!!! thanks for the help Fresh.

DataContractSerializer serializer = new DataContractSerializer(typeof(GrammarList));

Answer 1

Looking at the XML output, it looks like the name of the collection is lost when its de-serialized.

Try setting the Name property on the CollectionDataContract i.e.

[CollectionDataContract(Name="GrammarList"),KnownType(typeof(GrammarList))]
public class GrammarList : ObservableCollection<GrammarDataObject>