如何序列化和反序列化词典<；字符串，对象>；在WinRT中（C#和XAML中的Metro应用程序）？

这几天来我一直在努力解决这个愚蠢的问题，这让我头痛不已。如果有人有一个有效的例子，我会非常高兴，因为到目前为止我发现的那些例子都不起作用：（ 我可以序列化基本类型，但不能序列化对象。对于DataContractAttribute等，我非常困惑。我得到的错误是：

{“Type”序列化ListWinrt.DataModel.LocalStorage+Cat的数据 合同名称 'LocalStorage.Cat:http://schemas.datacontract.org/2004/07/SerializeListWinRT.DataModel' 不期望。请考虑使用DATACONTracTracever或添加任何 已知类型列表中静态未知的类型-例如， 通过使用KnownTypeAttribute属性或将其添加到 传递给DataContractSerializer的已知类型列表。“}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用Windows.Storage；
使用System.IO；
使用System.Runtime.Serialization；
使用Windows.Storage.Streams；
命名空间序列化ListWinrt.DataModel
{
类本地存储
{
[DataContractAttribute]
公猫
{
[DataMember（）]
公共字符串名称{get；set；}
}
静态专用字典_data=new Dictionary（）；
private const string filename=“items.xml”；
静态公共字典数据
{
获取{return_data；}
}
静态公共T GetItem（字符串键）
{
T结果=默认值（T）；
如果（_data.ContainsKey（键））
{
结果=（T）u数据[键]；
}
返回结果；
}
静态公共bool ContainsItem（字符串键）
{
返回_data.ContainsKey（键）；
}
静态异步公共任务保存（）
{
等待Windows.System.Threading.ThreadPool.RunAsync（（发送方）=>
{
LocalStorage.SaveAsync（）.Wait（）；
}，Windows.System.Threading.worktempriority.Normal）；
}
静态异步公共任务还原（）
{
等待Windows.System.Threading.ThreadPool.RunAsync（（发送方）=>
{
LocalStorage.RestoreAsync（）.Wait（）；
}，Windows.System.Threading.worktempriority.Normal）；
}
静态异步专用任务SaveAsync（）
{
_data.Add（“cat”，新的cat{Name=“Myname is”}）；
_data.Add（“dog”，新的Cat{Name=“Myname is”}）；
StorageFile sessionFile=await ApplicationData.Current.LocalFolder.CreateFileAsync（文件名，CreationCollisionOption.ReplaceExisting）；
irandomaccesstream sessionRandomAccess=wait sessionFile.OpenAsync（FileAccessMode.ReadWrite）；
IOOutputStream sessionOutputStream=sessionRandomAccess.GetOutputStreamAt（0）；
DataContractSerializer sessionSerializer=新的DataContractSerializer（typeof（Dictionary））；
sessionSerializer.WriteObject（sessionOutputStream.AsStreamForWrite（），_数据）；
等待sessionOutputStream.FlushAsync（）；
}
静态异步专用任务RestoreAsync（）
{
StorageFile sessionFile=await ApplicationData.Current.LocalFolder.CreateFileAsync（文件名，CreationCollisionOption.OpenIfExists）；
if（sessionFile==null）
{
返回；
}
IIInputStream sessionInputStream=等待sessionFile.OpenReadAsync（）；
DataContractSerializer sessionSerializer=新的DataContractSerializer（typeof（Dictionary））；
_数据=（字典）sessionSerializer.ReadObject（sessionInputStream.AsStreamForRead（））；
}
}
}

我是如何解决问题的：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Storage;
using System.IO;
using System.Runtime.Serialization;
using Windows.Storage.Streams;


namespace SerializeListWinRT.DataModel
{
    class LocalStorage
    {   
        [KnownType(typeof(SerializeListWinRT.Cat))]
        [DataContractAttribute]
        public class Cat
        {
            [DataMember()]
            public String Name { get; set; }
        }


    static private Dictionary<string, object> _data = new Dictionary<string, object>();
    private const string filename = "ngt.xml";

    static public Dictionary<string, object> Data
    {
        get { return _data; }

    }

    static public T GetItem<T>(string key)
    {
        T result = default(T);

        if (_data.ContainsKey(key))
        {
            result = (T)_data[key];
        }

        return result;
    }

    static public bool ContainsItem(string key)
    {
        return _data.ContainsKey(key);
    }

    static async public Task Save<T>()
    {
        await Windows.System.Threading.ThreadPool.RunAsync((sender) =>
        {
            LocalStorage.SaveAsync<T>().Wait();
        }, Windows.System.Threading.WorkItemPriority.Normal);
    }

    static async public Task Restore<T>()
    {
        await Windows.System.Threading.ThreadPool.RunAsync((sender) =>
        {
            LocalStorage.RestoreAsync<T>().Wait();
        }, Windows.System.Threading.WorkItemPriority.Normal);
    }

    static async private Task SaveAsync<T>()
    {
        _data.Add("cat", new Cat { Name = "Myname is" });
        _data.Add("dog", new Cat { Name = "Myname is" });

        StorageFile sessionFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
        IRandomAccessStream sessionRandomAccess = await sessionFile.OpenAsync(FileAccessMode.ReadWrite);
        IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
        DataContractSerializer sessionSerializer = new DataContractSerializer(typeof(Dictionary<string, object>), new Type[] { typeof(T) });
        sessionSerializer.WriteObject(sessionOutputStream.AsStreamForWrite(), _data);
        await sessionOutputStream.FlushAsync();
    }

    static async private Task RestoreAsync<T>()
    {
        StorageFile sessionFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists);
        if (sessionFile == null)
        {
            return;
        }
        IInputStream sessionInputStream = await sessionFile.OpenReadAsync();
        DataContractSerializer sessionSerializer = new DataContractSerializer(typeof(Dictionary<string, object>), new Type[] { typeof(T) });
        _data = (Dictionary<string, object>)sessionSerializer.ReadObject(sessionInputStream.AsStreamForRead());
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用Windows.Storage；
使用System.IO；
使用System.Runtime.Serialization；
使用Windows.Storage.Streams；
命名空间序列化ListWinrt.DataModel
{
类本地存储
{   
[KnownType（typeof（SerializeListWinRT.Cat））]
[DataContractAttribute]
公猫
{
[DataMember（）]
公共字符串名称{get；set；}
}
静态专用字典_data=new Dictionary（）；
私有常量字符串filename=“ngt.xml”；
静态公共字典数据
{
获取{return_data；}
}
静态公共T GetItem（字符串键）
{
T结果=默认值（T）；
如果（_data.ContainsKey（键））
{
结果=（T）u数据[键]；
}
返回结果；
}
静态公共bool ContainsItem（字符串键）
{
返回_data.ContainsKey（键）；
}
静态异步公共任务保存（）
{
等待Windows.System.Threading.ThreadPool.RunAsync（（发送方）=>
{
LocalStorage.SaveAsync（）.Wait（）；
}，Windows.System.Threading.worktempriority.Normal）；
}
静态异步公共任务还原（）
{
等待Windows.System.Threading.ThreadPool.RunAsync（（发送方）=>
{
LocalStorage.RestoreAsync（）.Wait（）；
}，Windows.System.Threading.worktempriority.Normal）；
}
静态异步专用任务SaveAsync（）
{
_data.Add（“cat”，新的cat{Name=“Myname is”}）；
_data.Add（“dog”，新的Cat{Name=“Myname is”}）；
StorageFile sessionFile=await ApplicationData.Current.LocalFolder.CreateFileAsync（文件名，CreationCollisionOption.ReplaceExisting）；
irandomaccesstream sessionRandomAccess=wait sessionFile.OpenAsync（FileAccessMode.ReadWrite）；
IOOutputStream sessionOutputStream=sessionRandomAccess.GetOutputStreamAt（0）；
DataContractSerializer sessionSerializer=新的DataContractSerializer（typeof（Dictionary），新类型[]{typeof（T）}）；
sessionSerializer.WriteObject（sessionOutputStream.AsStreamForWri
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Storage;
using System.IO;
using System.Runtime.Serialization;
using Windows.Storage.Streams;


namespace SerializeListWinRT.DataModel
{
    class LocalStorage
    {   
        [KnownType(typeof(SerializeListWinRT.Cat))]
        [DataContractAttribute]
        public class Cat
        {
            [DataMember()]
            public String Name { get; set; }
        }


    static private Dictionary<string, object> _data = new Dictionary<string, object>();
    private const string filename = "ngt.xml";

    static public Dictionary<string, object> Data
    {
        get { return _data; }

    }

    static public T GetItem<T>(string key)
    {
        T result = default(T);

        if (_data.ContainsKey(key))
        {
            result = (T)_data[key];
        }

        return result;
    }

    static public bool ContainsItem(string key)
    {
        return _data.ContainsKey(key);
    }

    static async public Task Save<T>()
    {
        await Windows.System.Threading.ThreadPool.RunAsync((sender) =>
        {
            LocalStorage.SaveAsync<T>().Wait();
        }, Windows.System.Threading.WorkItemPriority.Normal);
    }

    static async public Task Restore<T>()
    {
        await Windows.System.Threading.ThreadPool.RunAsync((sender) =>
        {
            LocalStorage.RestoreAsync<T>().Wait();
        }, Windows.System.Threading.WorkItemPriority.Normal);
    }

    static async private Task SaveAsync<T>()
    {
        _data.Add("cat", new Cat { Name = "Myname is" });
        _data.Add("dog", new Cat { Name = "Myname is" });

        StorageFile sessionFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
        IRandomAccessStream sessionRandomAccess = await sessionFile.OpenAsync(FileAccessMode.ReadWrite);
        IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
        DataContractSerializer sessionSerializer = new DataContractSerializer(typeof(Dictionary<string, object>), new Type[] { typeof(T) });
        sessionSerializer.WriteObject(sessionOutputStream.AsStreamForWrite(), _data);
        await sessionOutputStream.FlushAsync();
    }

    static async private Task RestoreAsync<T>()
    {
        StorageFile sessionFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists);
        if (sessionFile == null)
        {
            return;
        }
        IInputStream sessionInputStream = await sessionFile.OpenReadAsync();
        DataContractSerializer sessionSerializer = new DataContractSerializer(typeof(Dictionary<string, object>), new Type[] { typeof(T) });
        _data = (Dictionary<string, object>)sessionSerializer.ReadObject(sessionInputStream.AsStreamForRead());
    }
}

    [KnownType(typeof(SerializeListWinRT.Cat))]