C# 使用DataContractSerializer和DataProtectionProvider序列化和加密对象

我正在尝试将一个对象序列化为内存流，然后对该流进行加密，然后将其写入文件。无法找出错误，内存流在“解密”后为空

    public static async Task SerializeToFileEncrypt<T>(T o, StorageFile file)
    {
            DataContractSerializer dsc = new DataContractSerializer(typeof(T));                
            MemoryStream memoryStream = new MemoryStream();
            dsc.WriteObject(memoryStream, o);
            DataProtectionProvider provider = new DataProtectionProvider("Local=User");
            var raStream = await file.OpenAsync(FileAccessMode.ReadWrite);
            using(var filestream = raStream.GetOutputStreamAt(0))
            {
                await provider.ProtectStreamAsync(memoryStream.AsInputStream(), filestream);
                await filestream.FlushAsync();                        
            }
    }

    public static async Task<T> DeserializeFromFileDecrypt<T>(StorageFile file)
    {
        DataContractSerializer dsc = new DataContractSerializer(typeof(T));
        MemoryStream memoryStream = new MemoryStream();
        DataProtectionProvider provider = new DataProtectionProvider();
        await provider.UnprotectStreamAsync((await file.OpenStreamForReadAsync()).AsInputStream(), memoryStream.AsOutputStream());
        return (T) dsc.ReadObject(memoryStream);
    }

publicstaticasync任务SerializeToFileEncrypt（to，StorageFile）
{
DataContractSerializer dsc=新的DataContractSerializer（类型（T））；
MemoryStream MemoryStream=新的MemoryStream（）；
dsc.WriteObject（memoryStream，o）；
DataProtectionProvider provider=新的DataProtectionProvider（“本地=用户”）；
var raStream=await file.OpenAsync（FileAccessMode.ReadWrite）；
使用（var filestream=raStream.GetOutputStreamAt（0））
{
等待provider.ProtectStreamAsync（memoryStream.AsInputStream（），filestream）；
等待filestream.FlushAsync（）；
}
}
公共静态异步任务反序列化FromFileDecrypt（StorageFile）
{
DataContractSerializer dsc=新的DataContractSerializer（类型（T））；
MemoryStream MemoryStream=新的MemoryStream（）；
DataProtectionProvider=新的DataProtectionProvider（）；
wait provider.UnprotectStreamAsync（（wait file.OpenStreamForReadAsync（））.AsInputStream（）、memoryStream.AsOutputStream（））；
返回（T）dsc.ReadObject（memoryStream）；
}

在完成对

内存流的写入后，您需要移动到
内存流的开头。否则就没有什么可读的了，因为你已经被定位在最后了

这应该起作用：

public static async Task SerializeToFileEncrypt<T>(T o, StorageFile file)
{
        DataContractSerializer dsc = new DataContractSerializer(typeof(T));                
        MemoryStream memoryStream = new MemoryStream();
        dsc.WriteObject(memoryStream, o);
        memoryStream.Seek(0, SeekOrigin.Begin); // move to the beginning of the stream
        DataProtectionProvider provider = new DataProtectionProvider("Local=User");
        var raStream = await file.OpenAsync(FileAccessMode.ReadWrite);
        using(var filestream = raStream.GetOutputStreamAt(0))
        {
            await provider.ProtectStreamAsync(memoryStream.AsInputStream(), filestream);
            await filestream.FlushAsync();                        
        }
}

public static async Task<T> DeserializeFromFileDecrypt<T>(StorageFile file)
{
    DataContractSerializer dsc = new DataContractSerializer(typeof(T));
    MemoryStream memoryStream = new MemoryStream();
    DataProtectionProvider provider = new DataProtectionProvider();
    await provider.UnprotectStreamAsync((await file.OpenStreamForReadAsync()).AsInputStream(), memoryStream.AsOutputStream());
    memoryStream.Seek(0, SeekOrigin.Begin); // move to the beginning of the stream
    return (T) dsc.ReadObject(memoryStream);
}

publicstaticasync任务SerializeToFileEncrypt（to，StorageFile）
{
DataContractSerializer dsc=新的DataContractSerializer（类型（T））；
MemoryStream MemoryStream=新的MemoryStream（）；
dsc.WriteObject（memoryStream，o）；
memoryStream.Seek（0，SeekOrigin.Begin）；//移动到流的开头
DataProtectionProvider provider=新的DataProtectionProvider（“本地=用户”）；
var raStream=await file.OpenAsync（FileAccessMode.ReadWrite）；
使用（var filestream=raStream.GetOutputStreamAt（0））
{
等待provider.ProtectStreamAsync（memoryStream.AsInputStream（），filestream）；
等待filestream.FlushAsync（）；
}
}
公共静态异步任务反序列化FromFileDecrypt（StorageFile）
{
DataContractSerializer dsc=新的DataContractSerializer（类型（T））；
MemoryStream MemoryStream=新的MemoryStream（）；
DataProtectionProvider=新的DataProtectionProvider（）；
wait provider.UnprotectStreamAsync（（wait file.OpenStreamForReadAsync（））.AsInputStream（）、memoryStream.AsOutputStream（））；
memoryStream.Seek（0，SeekOrigin.Begin）；//移动到流的开头
返回（T）dsc.ReadObject（memoryStream）；
}
除了上次发布的答案之外，您还需要将raStream包装在using语句中，因为它是一个IDisposable对象。否则，如果某些代码稍后再次尝试打开该文件，它将失败并拒绝访问，因为该文件仍由随机访问流打开

public static async Task SerializeToFileEncrypt<T>(T o, StorageFile file)
        {
            DataContractSerializer dsc = new DataContractSerializer(typeof(T));
            MemoryStream memoryStream = new MemoryStream();
            dsc.WriteObject(memoryStream, o);
            memoryStream.Seek(0, SeekOrigin.Begin); // move to the beginning of the stream
            DataProtectionProvider provider = new DataProtectionProvider("Local=User");
            using (var raStream = await file.OpenAsync(FileAccessMode.ReadWrite))
            {
                using (var filestream = raStream.GetOutputStreamAt(0))
                {
                    await provider.ProtectStreamAsync(memoryStream.AsInputStream(), filestream);
                    await filestream.FlushAsync();
                }
            }
        }

publicstaticasync任务SerializeToFileEncrypt（to，StorageFile）
{
DataContractSerializer dsc=新的DataContractSerializer（类型（T））；
MemoryStream MemoryStream=新的MemoryStream（）；
dsc.WriteObject（memoryStream，o）；
memoryStream.Seek（0，SeekOrigin.Begin）；//移动到流的开头
DataProtectionProvider provider=新的DataProtectionProvider（“本地=用户”）；
使用（var raStream=await file.OpenAsync（FileAccessMode.ReadWrite））
{
使用（var filestream=raStream.GetOutputStreamAt（0））
{
等待provider.ProtectStreamAsync（memoryStream.AsInputStream（），filestream）；
等待filestream.FlushAsync（）；
}
}
}