Esempio n. 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        public static void Dump(this FixedMemoryBlock memory)
        {
            string fileName = memory.Name + "_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss") + ".dmp";

            fileName = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(typeof(MarshalFixedMemoryBlock).Assembly.Location), fileName);
            Dump(memory, fileName);
        }
Esempio n. 2
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="memory"></param>
 /// <param name="fileName"></param>
 public static void Dump(this FixedMemoryBlock memory, string fileName)
 {
     using (var stream = System.IO.File.Open(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
     {
         stream.Write(memory.Buffers, 0, memory.Buffers.Length);
         stream.Flush();
     }
 }
Esempio n. 3
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="target"></param>
 /// <param name="sourceStart"></param>
 /// <param name="targetStart"></param>
 /// <param name="len"></param>
 public void CopyTo(FixedMemoryBlock target, long sourceStart, long targetStart, long len)
 {
     if (target == null)
     {
         return;
     }
     Array.Copy(mBuffers, sourceStart, target.mBuffers, targetStart, len);
 }
Esempio n. 4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        /// <param name="offset"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static List <string> ToStringList(this FixedMemoryBlock memory, long offset, Encoding encoding)
        {
            List <string> re = new List <string>();

            memory.Position = offset;
            while (memory.Position < memory.Length)
            {
                re.Add(memory.ReadString(encoding));
            }
            return(re);
        }
Esempio n. 5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        /// <returns></returns>
        public static List <DateTime> ToDatetimeList(this FixedMemoryBlock memory)
        {
            List <DateTime> re = new List <DateTime>((int)(memory.Length / 8));

            memory.Position = 0;
            while (memory.Position < memory.Length)
            {
                re.Add(memory.ReadDateTime());
            }
            return(re);
        }
Esempio n. 6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        /// <returns></returns>
        public static List <short> ToShortList(this FixedMemoryBlock memory)
        {
            List <short> re = new List <short>((int)(memory.Length / 2));

            memory.Position = 0;
            while (memory.Position < memory.Length)
            {
                re.Add(memory.ReadShort());
            }
            return(re);
        }
Esempio n. 7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        /// <returns></returns>
        public static List <double> ToFloatList(this FixedMemoryBlock memory)
        {
            List <double> re = new List <double>((int)(memory.Length / 4));

            memory.Position = 0;
            while (memory.Position < memory.Length)
            {
                re.Add(memory.ReadFloat());
            }
            return(re);
        }
Esempio n. 8
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        /// <returns></returns>
        public static List <long> ToLongList(this FixedMemoryBlock memory)
        {
            List <long> re = new List <long>((int)(memory.AllocSize / 8));

            memory.Position = 0;
            while (memory.Position < memory.AllocSize)
            {
                re.Add(memory.ReadLong());
            }
            return(re);
        }
Esempio n. 9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memory"></param>
        /// <param name="stream"></param>
        public static void RecordToLog(this FixedMemoryBlock memory, Stream stream)
        {
            int ls     = 1024 * 1024 * 128;
            int stmp   = 0;
            int ltmp   = (int)memory.AllocSize;
            var source = memory.Handles;

            var bvals = ArrayPool <byte> .Shared.Rent(ls);

            Array.Clear(bvals, 0, bvals.Length);
            while (ltmp > 0)
            {
                int ctmp = Math.Min(bvals.Length, ltmp);

                Array.Copy(memory.Buffers, stmp, bvals, 0, ctmp);
                // Marshal.Copy(source + stmp, bvals, 0, ctmp);
                stream.Write(bvals, 0, ctmp);
                stmp += ctmp;
                ltmp -= ctmp;
            }
            ArrayPool <byte> .Shared.Return(bvals);

            // stream.Flush();
        }
Esempio n. 10
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="memory"></param>
 public static void MakeMemoryNoBusy(this FixedMemoryBlock memory)
 {
     //LoggerService.Service.Info("FixedMemoryBlock", memory.Name+ " is ready !");
     memory.DecRef();
     //memory.StartMemory[0] = 0;
 }
Esempio n. 11
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="memory"></param>
 public static void MakeMemoryBusy(this FixedMemoryBlock memory)
 {
     //LoggerService.Service.Info("FixedMemoryBlock", memory.Name + " is busy.....");
     memory.IncRef();
     //memory.StartMemory[0] = 1;
 }
Esempio n. 12
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="memory"></param>
 /// <param name="stream"></param>
 public static void Dump(this FixedMemoryBlock memory, Stream stream)
 {
     stream.Write(memory.Buffers, 0, memory.Buffers.Length);
 }