Ejemplo n.º 1
0
 /// <summary>
 /// Determinate how to load a PersistenceItem.
 /// Subclass should override this method to meet its needs.
 /// </summary>
 /// <param name="item"></param>
 /// <returns></returns>
 /// /// <see cref="Biu.Serialization.PersistenceDecision"/>
 /// <see cref="Biu.Serialization.PersistentItem"/>
 public virtual PersistenceDecision MakeLoadingDecision(PersistentItem item)
 {
     return(new PersistenceDecision()
     {
         Key = this.Keys.FirstOrDefault(),
         Formatter = this.Formatters.FirstOrDefault()
     });
 }
Ejemplo n.º 2
0
        public override PersistentResult Save(Stream stream, Func <PersistentItem, string> nameItemFile = null)
        {
            SHA256Managed sha256 = null;
            var           result = new PersistentResult();

            try
            {
                var partitions = this.Plan.Partition(stream);
                for (int i = 0; i < partitions.Count(); i++)
                {
                    var par      = partitions.ElementAt(i);
                    var decision = this.Plan.MakeSavingDecision(par);
                    var item     = new PersistentItem()
                    {
                        ItemType     = par.ItemType,
                        StoredType   = decision.StoredType,
                        Significance = decision.Significance,
                        Order        = i
                    };

                    item.File = null == nameItemFile ? null : nameItemFile(item);
                    item.CreateMemoryStream();

                    if (null == decision.Key)
                    {
                        item.IsEncrypted = false;

                        var buff = new byte[this.BufferSize];

                        int nRemaining = (int)par.Size;
                        int nRead      = 0;
                        do
                        {
                            nRead       = stream.Read(buff, 0, Math.Min(this.BufferSize, nRemaining));
                            nRemaining -= nRead;
                            if (0 != nRead)
                            {
                                item.Stream.Write(buff, 0, nRead);
                            }
                        } while (0 != nRemaining);

                        if (null == sha256)
                        {
                            sha256 = new SHA256Managed();
                        }

                        long nPos = item.Stream.Position;
                        item.Stream.Seek(0L, SeekOrigin.Begin);
                        item.Hash = sha256.ComputeHash(item.Stream);
                        item.Stream.Seek(nPos, SeekOrigin.Begin);
                    }
                    else
                    {
                        item.IsEncrypted = true;

                        byte[] hash = null;
                        this.Transform.EncryptStream(stream, item.Stream, decision.Key, (uint)par.Size, ref hash);
                        item.Hash = hash;
                    }

                    item.EnsureData();
                    if (null != decision.Formatter)
                    {
                        decision.Formatter.Serialize(item);
                    }

                    if (decision.CloseStreamWhenDone)
                    {
                        item.CloseStream();
                    }

                    result.Items.Add(item);
                }

                result.IsSucceeded = true;
            }
            catch
            {
                throw;
            }
            finally
            {
                if (null != sha256)
                {
                    sha256.Dispose();
                    sha256 = null;
                }
            }

            return(result);
        }