C# 应用程序数据复合值的大小

我正在将我发布的应用程序移植到Windows Phone中，以赢得8分。在尝试写入

IsolatedStorage

等效的

ApplicationDataContainer

时，我遇到了一个异常。例外情况是

错误：状态管理器设置的大小已超过限制

我不确定这是否是使用

ApplicationDataContainer

的正确方法

public void WriteToIsolatedStorage()
    {
        try
        {

            ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
            ApplicationDataCompositeValue composite = new ApplicationDataCompositeValue();

            if (localSettings.Containers.ContainsKey("LoveCycleSetting"))
            {
                localSettings.DeleteContainer("LoveCycleSetting");
            }

            composite["GetWeekStart"] = m_bWeekStart;

            composite["iHistCount"] = m_iHistCount;

            composite["dtHistory"] = this.DateTimeToString(m_dtHistory);

            composite["avgCycleTime"] = m_iAvgCycleTime;
       }
    }

异常发生在最后一行的第二行。m_dtHistory是一个大小为400的字符串数组。那么

ApplicationDataCompositeValue

是否具有固定大小？还是必须将m_dtHistory数组写入文件？因为在WindowsPhone中，我可以直接将数组写入隔离存储设置中

如果有人能在这方面指导我或提供链接，那将非常有帮助

---

Alfah

我在某个地方读到过，但丢失了大小为64KB的参考资料

是的，具有讽刺意味的是，设置存储在手机上比WinRT更容易。您可以直接序列化到一个文件。下面是我所做的（部分复制自

suspendionmanager.cs

中已有的代码），它适用于值和引用类型

    internal static async Task<bool> SaveSetting(string Key, Object value)
    {
        var ms = new MemoryStream();
        DataContractSerializer serializer = new DataContractSerializer(value.GetType());
        serializer.WriteObject(ms, value);
        await ms.FlushAsync();

        // Uncomment this to preview the contents being written
        /*char[] buffer = new char[ms.Length];
        ms.Seek(0, SeekOrigin.Begin);
        var sr = new StreamReader(ms);
        sr.Read(buffer, 0, (int)ms.Length);*/

        ms.Seek(0, SeekOrigin.Begin);
        StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(Key, CreationCollisionOption.ReplaceExisting);
        using (Stream fileStream = await file.OpenStreamForWriteAsync())
        {
            await ms.CopyToAsync(fileStream);
            await fileStream.FlushAsync();
        }
        return true;
    }

    // Necessary to pass back both the result and status from an async function since you  can't pass by ref
    internal class ReadResults
    {
        public bool Success { get; set; }
        public Object Result { get; set; }
    }
    internal async static Task<ReadResults> ReadSetting<type>(string Key, Type t)
    {
        var rr = new ReadResults();

        try
        {
            var ms = new MemoryStream();
            DataContractSerializer serializer = new DataContractSerializer(t);

            StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(Key);
            using (IInputStream inStream = await file.OpenSequentialReadAsync())
            {
                rr.Result = (type)serializer.ReadObject(inStream.AsStreamForRead());
            }
            rr.Success = true;  
        }
        catch (FileNotFoundException)
        {
            rr.Success = false;
        }
        return rr;
    }

内部静态异步任务保存设置（字符串键、对象值）
{
var ms=新内存流（）；
DataContractSerializer serializer=新的DataContractSerializer（value.GetType（））；
serializer.WriteObject（ms，value）；
等待FlushAsync女士（）；
//取消对此的注释以预览正在编写的内容
/*char[]buffer=新字符[ms.Length]；
Seek女士（0，SeekOrigin.Begin）；
var sr=新的StreamReader（毫秒）；
sr.Read（缓冲区，0，（int）ms.Length）*/
Seek女士（0，SeekOrigin.Begin）；
StorageFile file=wait ApplicationData.Current.LocalFolder.CreateFileAsync（Key，CreationCollisionOption.ReplaceExisting）；
使用（Stream fileStream=await file.OpenStreamForWriteAsync（））
{
等待ms.CopyToAsync（文件流）；
等待fileStream.FlushAsync（）；
}
返回true；
}
//必须从异步函数传回结果和状态，因为不能按ref传递
内部类读取结果
{
公共bool成功{get；set；}
公共对象结果{get；set；}
}
内部异步静态任务读取设置（字符串键，类型t）
{
var rr=new ReadResults（）；
尝试
{
var ms=新内存流（）；
DataContractSerializer serializer=新的DataContractSerializer（t）；
StorageFile file=Wait ApplicationData.Current.LocalFolder.GetFileAsync（键）；
使用（IInputStream inStream=wait file.OpenSequentialReadAsync（））
{
rr.Result=（类型）serializer.ReadObject（inStream.AsStreamForRead（））；
}
成功=真；
}
捕获（FileNotFoundException）
{
rr.成功=错误；
}
返回rr；
}

每个设置的名称长度最多为255个字符。每个设置的大小最多可达8K字节，每个组合设置的大小最多可达64K字节

公共静态void存储配置（字符串内容）
{
IEnumerable strs=拆分（内容，2000年）；
int i=1；
foreach（strs中的var s）
{
AppLocalSettings.Values[“test”+（i++）]=s；
}
AppLocalSettings.Values[“test_count”]=i-1+”；
}
公共静态字符串ReadConfig（）
{
字符串s=“”；
int count=Convert.ToInt32（AppLocalSettings.Values[“test_count”]）；
对于（int i=1；i此错误的德语版本的值可能是HRESULT 0x80073DC8“Die Gröe des Einstellungswerts des Zuhat den Grenzwertüberschritten”，我认为他是对的，所有值的总和为64 KB。但单个值的最大值可能要小得多。
    public static void StoreConfig(string content)
    {
        IEnumerable<string> strs = Split(content, 2000);
        int i = 1;
        foreach(var s in strs)
        {
            AppLocalSettings.Values["test" + (i++)] = s;
        }

        AppLocalSettings.Values["test_count"] =  i-1 +"";
    }

    public static string ReadConfig()
    {
        string s = "";
        int count = Convert.ToInt32(AppLocalSettings.Values["test_count"]);
        for(int i = 1; i<=count; i++)
        {
            s += Convert.ToString(AppLocalSettings.Values["test" + (i)]);
        }
        return s;
    }