hulihui

基于GZipStream的多文件压缩组件TGZipCompressBar实现

(原创文章，转载请注明来源：http://blog.csdn.net/hulihui)

做分布式数据处理系统，经常要把下一级的数据库文件压缩后上报，做解压缩后导入。笔者使用Delphi时，用其Zlib单元实现的压缩组件HZlibBackup可以满足应用需求。在.NET 2.0引入压缩类后，使用GZipStream也可以定制自己的压缩组件。

最初，笔者在章立民先生的书《Visual C# 2005文件IO与数据存取秘诀》中学习该组件用法，简单的太简单（一个文件）、复杂又过于复杂（类似WinZip），不满足笔者的多文件压缩、功能简单的需求。于是，Google了相关技术文章“ How to compress folders and multiple files with GZipStream”。该文的技术要点是：

创建自己的GZip压缩文件格式；
将每个待压缩文件保存到一个大的临时合并文件中；
应用GZipStream压缩临时合并文件；
解压缩的过程是上述逆步骤。

借用上述思路并适当改进后，笔者实现了一个多文件压缩组件TGZipCompressBar，主要思路如下：

压缩文件格式由三部分组成：文件头+{文件项+压缩文件}。文件头中保存：文件个数、文件项长度、压缩文件长,目的是解压缩时可以快速读取压缩文件的长度信息。文件项（TGZipFileEntry类）包括文件基本信息，如：文件名、长度、压缩长度、文件三个日期，文件日期用于解压缩后恢复其实际日期；
压缩文件时，先空出文件头部分，接着保存文件项部分、保存压缩文件部分，反复直到全部文件压缩完毕。此时，已经获得全部文件压缩后的长度数据。最后，将实际的文件头数据重写到压缩文件流的头部；
解压缩关键，必须先读出待解当前文件的压缩数据到MemoryStream，然后由GZipStream做解压缩。这个操作不能像压缩时，可以边读源文件边做压缩（似乎GZipStream底层实现不支持一块一块地读压缩后字节到输出流中）。因此，解压缩比压缩操作时间长点；
文件个数、文件项用简单的XOR做加密处理；
系统由三个类组成：压缩组件（TGZipCompressBar，继承笔者的TSmartProgressBar）、文件项（TGZipFileEntry）、简单加密类（TCipher），其中基类可以选择.NET的自带组件ProgressBar。

    实际测试表明，针对未做过压缩的文件，GZipStream的效率可以到40%左右，压缩速度也可以接受。而对于已经做了压缩处理的文件，GZipStream则效果极差，可能比原文件大50%左右！

    显然，进一步完善后可以实现WinRar的部分功能：1）解压缩指定文件；2）删除指定压缩文件；3）添加文件到压缩包；3）整个压缩文件加密；4）异步压缩处理；5）解压缩时保持文件夹；等等。

    TGZipCompressBar实现的窗体演示图如下，exe程序见本站资源：基于GZip的多文件压缩组件TGZipCompressBar

 
  using System;
using System.IO;
using System.Text;
using System.IO.Compression;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.Windows.Forms;
using System.ComponentModel;
using System.Drawing;

namespace CSUST.Data
{
    public class TGZipCompressBar : TSmartProgressBar
    {
        private const string m_FileExtensionName = ".gcf";  // gzip compress file
        private const int m_MaxFileTotalLength = 1024 * 1024 * 1024;  // 1G
        private const int m_ReadBufferSize = 8 * 1024;  // 8K

        private string m_GZipFileName = string.Empty;
        private string m_FolderDecompressTo = string.Empty;

        private List<TGZipFileEntry> m_FileEntryList = new List<TGZipFileEntry>();
        private List<TGZipFileEntry> m_PacketEntryList = new List<TGZipFileEntry>();

        private byte[] m_ReadBuffer = new byte[m_ReadBufferSize];

        private int m_NowMaxBarValue = 0;

        public TGZipCompressBar()
        {
        }

        public TGZipCompressBar(string gzipFileName)
        {
            this.Visible = false;
            this.GZipFileName = gzipFileName;
        }

        public TGZipCompressBar(string gzipFileName, string decompressFolder)
        {
            this.Visible = false;
            this.GZipFileName = gzipFileName;
            this.FolderDecompressTo = decompressFolder;
        }

        /// <summary>
        /// 按MS的模板, 只需要重载 Dispose 方法
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            try
            {
                if (disposing)
                {
                    m_ReadBuffer = null;

                    m_FileEntryList.Clear();
                    m_FileEntryList = null;
                    m_PacketEntryList.Clear();
                    m_PacketEntryList = null;
                }
            }
            finally
            {
                base.Dispose(disposing);
            }
        }

        [Description("Set/Get GZip filename with extension .gcf")]
        public string GZipFileName
        {
            get
            {
                return m_GZipFileName;
            }
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    this.m_GZipFileName = value;
                    this.m_PacketEntryList.Clear();
                }
                else
                {
                    if (!this.IsValidFileName(value))
                    {
                        MessageBox.Show("GZip filename or it's path contains invalid char.");
                    }
                    else if (Path.GetExtension(value).ToUpper() != m_FileExtensionName.ToUpper())
                    {
                        MessageBox.Show("GZip filename must has extension " + m_FileExtensionName + ".");
                    }
                    else
                    {
                        this.m_PacketEntryList.Clear();
                        this.m_GZipFileName = value;
                    }
                }
            }
        }

        [Description("Set/Get folder to decompress files")]
        public string FolderDecompressTo
        {
            get
            {
                return m_FolderDecompressTo;
            }
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    m_FolderDecompressTo = value;
                }
                else
                {
                    if (!Directory.Exists(value))
                    {
                        MessageBox.Show("Decompress folder: " + value + " does not exists.");
                    }
                    else
                    {
                        if (value.EndsWith(@"/"))
                        {
                            m_FolderDecompressTo = value;
                        }
                        else
                        {
                            m_FolderDecompressTo = value + @"/";
                        }
                    }
                }
            }
        }

        [Description("Get the default gzip file extension name.")]
        public string DefaultFileExtentionName
        {
            get { return m_FileExtensionName; }
        }

        /// <summary>
        /// Add a file to compress list.
        /// </summary>
        public bool AppendFile(string fileName)
        {
            if (string.IsNullOrEmpty(fileName) || !File.Exists(fileName))
            {
                MessageBox.Show("GZipFileName is empty or does not exist.");
                return false;
            }

            TGZipFileEntry addFileInfo = new TGZipFileEntry(fileName);
            long totalLength = addFileInfo.OriginalLength;

            foreach (TGZipFileEntry fileEntry in m_FileEntryList)
            {
                if (fileEntry.FileName.ToUpper() == addFileInfo.FileName.ToUpper())
                {
                    MessageBox.Show("File: " + fileEntry.FileName + " has exists.");
                    return false;
                }
                totalLength += fileEntry.OriginalLength;
            }

            if (totalLength > m_MaxFileTotalLength)
            {
                MessageBox.Show("Total files length is over " + (m_MaxFileTotalLength / (1024 * 1024)).ToString() + "M.");
                return false;
            }

            m_FileEntryList.Add(addFileInfo);
            return true;
        }

        /// <summary>
        /// Clear all add files for compress.
        /// </summary>
        public void ClearFiles()
        {
            this.m_FileEntryList.Clear();
            this.m_PacketEntryList.Clear();
            this.SetStartPosition();
        }

        /// <summary>
        /// Compress files with gzip algorithm.
        /// </summary>
        public bool Compress()
        {
            return this.Compressing();
        }

        /// <summary>
        /// Decompress files from gzip file.
        /// </summary>

        public bool Decompress()
        {
            return this.Decompressing();
        }

        /// <summary>
        /// If the gzipfile contains an assigned filename."
        /// </summary>
        public bool ContainsFile(string fileName)
        {
            if (!this.GetPacketEntryList())
            {
                return false;
            }

            string realFileName = Path.GetFileName(fileName.Trim());
            foreach (TGZipFileEntry fileEntry in m_PacketEntryList)
            {
                if (fileEntry.FileName.ToUpper() == realFileName.ToUpper())
                {
                    return true;
                }
            }
            return false;
        }
        
        /// <summary>
        /// string format: filename|fileLength|gzippedLength|lastModifiedDate|lastAccessDate|creationgDate|fullFileName
        /// </summary>
        public string GetFileEntryStringByFileName(string fileName)
        {
            if (!this.GetPacketEntryList())
            {
                return null;
            }

            string realFileName = Path.GetFileName(fileName.Trim());
            foreach (TGZipFileEntry fileEntry in m_PacketEntryList)
            {
                if (fileEntry.FileName.ToUpper() == fileName.ToUpper())
                {
                    return fileEntry.FormattedStr;
                }
            }
            return null;
        }

        /// <summary>
        /// string format: filename|fileLength|gzippedLength|lastModifiedDate|lastAccessDate|creationgDate|fullFileName
        /// </summary>
        public List<string> GetFileEntryStringList()
        {
            if (!this.GetPacketEntryList())
            {
                return null;
            }

            List<string> fileInfoList = new List<string>();

            foreach (TGZipFileEntry fileEntry in m_PacketEntryList)
            {
                fileInfoList.Add(fileEntry.FormattedStr);
            }
            return fileInfoList;
        }

        private bool Compressing()
        {
            bool opSuccess = false;

            if (m_FileEntryList.Count == 0)
            {
                MessageBox.Show("There has no compress file.");
                return opSuccess;
            }

            if (string.IsNullOrEmpty(m_GZipFileName))
            {
                MessageBox.Show("GZipFileName is empty or not set.");
                return opSuccess;
            }

            this.SetApplicationCursor(Cursors.WaitCursor);

            try
            {
                using (FileStream outStream = new FileStream(m_GZipFileName, FileMode.Create, FileAccess.Write, FileShare.None))
                {
                    this.m_PacketEntryList.Clear();
                    this.WriteHeaderEmptyInfo(outStream);  // 写文件长度字节, 压缩结束后再填实际数据
                    this.SetProgressBarMaxValue(false);
                    this.ShowBeginStep();

                    foreach (TGZipFileEntry fileEntry in m_FileEntryList)
                    {
                        this.SetProgressBarNowMaxValue(fileEntry, false);

                        fileEntry.WriteEntryInfo(outStream);
                        this.ShowProgressStep();
                        this.CompressFile(fileEntry, outStream);
                        this.m_PacketEntryList.Add(fileEntry);
                    }

                    this.WriteHeaderLengthInfo(outStream);  // 再填文件头, 此时有各块的长度信息
                }
                opSuccess = true;
            }
            catch (Exception err)
            {
                throw new Exception(err.Message);
            }
            finally
            {
                this.ShowFinalStep();
                this.SetApplicationCursor(Cursors.Default);
            }
            return opSuccess;
        }

        private bool Decompressing()
        {
            bool opSuccess = false;

            if (string.IsNullOrEmpty(m_FolderDecompressTo))
            {
                MessageBox.Show("Decompress folder is empty.");
                return opSuccess;
            }

            if (string.IsNullOrEmpty(m_GZipFileName))
            {
                MessageBox.Show("GZipFileName is empty or does not exist.");
                return opSuccess;
            }

            this.SetApplicationCursor(Cursors.WaitCursor);

            try
            {
                using (FileStream srcStream = new FileStream(m_GZipFileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    this.m_PacketEntryList.Clear();
                    this.ReadHeaderLengthInfo(srcStream);  // 获得各块的长度信息, 缺少文件项中的文件名、日期等信息
                    this.SetProgressBarMaxValue(true);
                    this.ShowBeginStep();

                    foreach (TGZipFileEntry fileEntry in m_PacketEntryList)
                    {
                        this.SetProgressBarNowMaxValue(fileEntry, true);

                        fileEntry.ReadEntryInfo(srcStream);  // 读当前项的日期、文件名信息
                        this.ShowProgressStep();
                        this.DecompressFile(srcStream, fileEntry);
                        fileEntry.ResetFileDateTime(m_FolderDecompressTo);
                    }
                }
                opSuccess = true;
            }
            catch (Exception err)
            {
                throw new Exception(err.Message);
            }
            finally
            {
                this.ShowFinalStep();
                this.SetApplicationCursor(Cursors.Default);
            }

            return opSuccess;
        }

        /// <summary>
        /// Compress one file.
        /// </summary>
        private void CompressFile(TGZipFileEntry fileEntry, Stream outStream)
        {
            long preStreamPosition = outStream.Position;

            using (FileStream srcStream = new FileStream(fileEntry.FileFullName, FileMode.Open, FileAccess.Read, FileShare.Read))
            using (GZipStream zipStream = new GZipStream(outStream, CompressionMode.Compress, true))
            {
                this.ShowProgressStep();

                int readCount = m_ReadBufferSize;
                while (readCount == m_ReadBufferSize)
                {
                    readCount = srcStream.Read(m_ReadBuffer, 0, m_ReadBufferSize);
                    zipStream.Write(m_ReadBuffer, 0, readCount);

                    this.ShowProgressStep();
                }
            }

            fileEntry.GZipFileLength =  (int)(outStream.Position - preStreamPosition);  // 写入的长度
        }

        /// <summary>
        /// Deompress one file.
        /// </summary>
        private void DecompressFile(Stream srcStream, TGZipFileEntry fileEntry)
        {
            using (FileStream outStream = new FileStream(this.m_FolderDecompressTo + fileEntry.FileName , FileMode.Create, FileAccess.Write, FileShare.None))
            using (MemoryStream memStream = new MemoryStream())
            using (GZipStream zipStream = new GZipStream(memStream, CompressionMode.Decompress, true))
            {
                int gzipFileLength = fileEntry.GZipFileLength;
                int readCount;
                while (gzipFileLength > 0)
                {
                    int maxCount = Math.Min(gzipFileLength, m_ReadBufferSize);
                    
                    readCount = srcStream.Read(m_ReadBuffer, 0, maxCount);
                    memStream.Write(m_ReadBuffer, 0, readCount);

                    gzipFileLength -= readCount;

                    this.ShowProgressStep();
                }

                memStream.Position = 0;
                readCount = m_ReadBufferSize;
                while (readCount == m_ReadBufferSize)
                {
                    readCount = zipStream.Read(m_ReadBuffer, 0, m_ReadBufferSize);
                    outStream.Write(m_ReadBuffer, 0, readCount);

                    this.ShowProgressStep();
                }
            }
            this.ShowProgressStep();
        }

        /// <summary>
        /// 写空头字节, 用于占位置
        /// </summary>
        private void WriteHeaderEmptyInfo(Stream outStream)
        {
            int headerSize = 1 + m_FileEntryList.Count * 3;  // 前4个字节是文件数, 每个文件3部分, 分别是: 原文件长、压缩后长、文件项长
            byte[] headerBytes = new byte[4 * headerSize];
            outStream.Write(headerBytes, 0, headerBytes.Length);
        }

        /// <summary>
        /// 写实际的文件数、文件长度、项长度字节
        /// </summary>
        private void WriteHeaderLengthInfo(Stream outStream)
        {
            byte[] fileCountBytes = BitConverter.GetBytes((int)m_PacketEntryList.Count);
            TCipher.EncryptBytes(fileCountBytes);

            outStream.Position = 0;
            outStream.Write(fileCountBytes, 0, fileCountBytes.Length);

            foreach (TGZipFileEntry entry in m_PacketEntryList)
            {
                entry.WriteLengthInfo(outStream);
            }
        }

        private void ReadHeaderLengthInfo(Stream srcStream)
        {
            byte[] fileCountBytes = new byte[4];
            srcStream.Read(fileCountBytes, 0, fileCountBytes.Length);
            TCipher.EncryptBytes(fileCountBytes);

            int fileCount = BitConverter.ToInt32(fileCountBytes, 0);

            for (int k = 1; k <= fileCount; k++)
            {
                TGZipFileEntry entry = new TGZipFileEntry();
                entry.ReadLengthInfo(srcStream);
                m_PacketEntryList.Add(entry);
            }
        }

        private bool GetPacketEntryList()
        {
            if (m_PacketEntryList.Count > 0)
            {
                return true;
            }

            if (string.IsNullOrEmpty(m_GZipFileName) || !File.Exists(m_GZipFileName))
            {
                MessageBox.Show("GZipFileName is empty or does not exist.");
                return false;
            }

            bool opSuccess = false;
            this.SetApplicationCursor(Cursors.WaitCursor);

            try
            {
                using (FileStream srcStream = new FileStream(m_GZipFileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    this.ReadHeaderLengthInfo(srcStream);
                    foreach (TGZipFileEntry fileEntry in m_PacketEntryList)
                    {
                        fileEntry.ReadEntryInfo(srcStream);
                        srcStream.Position += fileEntry.GZipFileLength;
                    }
                }
                opSuccess = true;
            }
            catch (Exception err)
            {
                throw new Exception(err.Message);
            }
            finally
            {
                this.SetApplicationCursor(Cursors.Default);
            }
            return opSuccess;
        }

        private int GetFileMaxStepLength(TGZipFileEntry fileEntry, bool decompress)
        {
            int maxLength = Math.Max(fileEntry.OriginalLength, fileEntry.GZipFileLength);
            int stepValue = 0;

            if (decompress)
            {
                stepValue++;  // 取文件项
                stepValue += 2 * (maxLength / m_ReadBufferSize);  // 产生压缩流
                stepValue++;  // 关闭文件
            }
            else
            {
                stepValue++;  // 打开源文件
                stepValue++;  // 写文件信息项
                stepValue += maxLength / m_ReadBufferSize;  // 压缩
            }

            return stepValue;
        }

        private void SetProgressBarMaxValue(bool decompress)
        {
            this.SetStartPosition();
            m_NowMaxBarValue = 0;

            int maxBarValue = 1;  // 打开/建立文件
            if (decompress)
            {
                foreach (TGZipFileEntry fileEntry in m_PacketEntryList)
                {
                    maxBarValue += this.GetFileMaxStepLength(fileEntry, decompress);  // 加每个文件的步长
                }
            }
            else
            {
                foreach (TGZipFileEntry fileEntry in m_FileEntryList)
                {
                    maxBarValue += this.GetFileMaxStepLength(fileEntry, decompress);  // 加每个文件的步长
                }
            }
            maxBarValue += 1;  // 最后收尾
            this.Maximum = maxBarValue;
        }

        private void SetProgressBarNowMaxValue(TGZipFileEntry fileEntry, bool decompress)
        {
            m_NowMaxBarValue += this.GetFileMaxStepLength(fileEntry, decompress);
        }

        /// <summary>
        /// 设置当前控件及其全部父控件的光标
        /// </summary>
        private void SetApplicationCursor(Cursor cursor)
        {
            this.Cursor = cursor;
            Control parent = this.Parent;
            while (parent != null)
            {
                parent.Cursor = cursor;
                parent = parent.Parent;
            }
        }

        private void SetStartPosition()
        {
            this.Value = 0;
            this.Refresh();
        }

        private void ShowBeginStep()
        {
            this.Value += 1;
            this.Refresh();
        }

        private void ShowProgressStep()
        {
            if (this.Value + 1 < m_NowMaxBarValue)
            {
                this.Value += 1;
            }
        }

        private void ShowFinalStep()
        {
            while (this.Value + 1 < this.Maximum)
            {
                this.Value += 1;
            }
            this.Value = this.Maximum;
            this.Refresh();
        }

        private bool IsValidFileName(string fileName)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                return false;
            }
            else
            {
                string realName = Path.GetFileName(fileName);
                string pathName = Path.GetDirectoryName(fileName);

                char[] errChars = Path.GetInvalidPathChars();
                if (realName.IndexOfAny(errChars) >= 0)
                {
                    return false;
                }

                errChars = Path.GetInvalidPathChars();
                if (pathName.IndexOfAny(errChars) >= 0)
                {
                    return false;
                }
            }
            return true;
        }

    }

    /// <summary>
    /// File entry class.
    /// </summary>
    public class TGZipFileEntry
    {
        private int m_OriginalLength;
        private int m_GZipFileLength;
        private int m_FileEntryLength;

        private string m_FileFullName;

        private DateTime m_CreationTime;
        private DateTime m_LastAccessTime;
        private DateTime m_LastWriteTime;

        public TGZipFileEntry() { }

        public TGZipFileEntry(string fileName)
        {
            FileInfo fileInfo = new FileInfo(fileName);

            m_OriginalLength = (int)fileInfo.Length;
            m_FileFullName = fileInfo.FullName;
            m_CreationTime = fileInfo.CreationTime;
            m_LastAccessTime = fileInfo.LastAccessTime;
            m_LastWriteTime = fileInfo.LastWriteTime;
        }

        public int OriginalLength
        {
            get { return m_OriginalLength; }
            set { m_OriginalLength = value; }
        }

        public int GZipFileLength
        {
            get { return m_GZipFileLength; }
            set { m_GZipFileLength = value; }
        }

        public int FileEntryLength
        {
            get { return m_FileEntryLength; }
            set { m_FileEntryLength = value; }
        }

        public void WriteLengthInfo(Stream outStream)
        {
            byte[] bytes1 = BitConverter.GetBytes(m_OriginalLength);
            byte[] bytes2 = BitConverter.GetBytes(m_GZipFileLength);
            byte[] bytes3 = BitConverter.GetBytes(m_FileEntryLength);

            TCipher.EncryptBytes(bytes1);
            TCipher.EncryptBytes(bytes2);
            TCipher.EncryptBytes(bytes3);

            outStream.Write(bytes1, 0, bytes1.Length);
            outStream.Write(bytes2, 0, bytes2.Length);
            outStream.Write(bytes3, 0, bytes3.Length);
        }

        public void ReadLengthInfo(Stream srcStream)
        {
            byte[] bytes1 = new byte[4];
            byte[] bytes2 = new byte[4];
            byte[] bytes3 = new byte[4];

            srcStream.Read(bytes1, 0, bytes1.Length);
            srcStream.Read(bytes2, 0, bytes2.Length);
            srcStream.Read(bytes3, 0, bytes3.Length);

            TCipher.EncryptBytes(bytes1);
            TCipher.EncryptBytes(bytes2);
            TCipher.EncryptBytes(bytes3);

            m_OriginalLength = BitConverter.ToInt32(bytes1, 0);
            m_GZipFileLength = BitConverter.ToInt32(bytes2, 0);
            m_FileEntryLength = BitConverter.ToInt32(bytes3, 0);
        }

        public void WriteEntryInfo(Stream outStream)
        {
            byte[] entryBytes = this.GetFileEntryByes();
            TCipher.EncryptBytes(entryBytes);
            outStream.Write(entryBytes, 0, entryBytes.Length);  // 文件项内容

            m_FileEntryLength = entryBytes.Length;
        }

        public void ReadEntryInfo(Stream srcStream)
        {
            byte[] entryBytes = new byte[m_FileEntryLength];
            srcStream.Read(entryBytes, 0, entryBytes.Length);  // FileEntry 字节
            TCipher.EncryptBytes(entryBytes);

            string entryStr = Encoding.Default.GetString(entryBytes);  // 不能用 ASCII, 要处理汉字
            string[] strArray = entryStr.Split('|');

            long lastWriteTimeticks = long.Parse(strArray[3]);
            long lastAccessTimeticks = long.Parse(strArray[4]);
            long lastCreateTimeticks = long.Parse(strArray[5]);

            m_LastWriteTime = new DateTime(lastWriteTimeticks);
            m_LastAccessTime = new DateTime(lastAccessTimeticks);
            m_CreationTime = new DateTime(lastCreateTimeticks);

            m_FileFullName = strArray[6];
        }

        public void ResetFileDateTime(string folderCompressTo)
        {
            string fileName = folderCompressTo + Path.GetFileName(m_FileFullName);

            File.SetLastAccessTime(fileName, m_LastAccessTime);
            File.SetCreationTime(fileName, m_CreationTime);
            File.SetLastWriteTime(fileName, m_LastWriteTime);
        }

        public string FormattedStr
        {
            get
            {
                StringBuilder sb = new StringBuilder();

                sb.Append(Path.GetFileName(m_FileFullName));
                sb.Append("|" + m_OriginalLength.ToString());
                sb.Append("|" + m_GZipFileLength.ToString());
                sb.Append("|" + m_LastWriteTime.ToString("yyyy-MM-dd hh:mm:ss"));
                sb.Append("|" + m_LastAccessTime.ToString("yyyy-MM-dd hh:mm:ss"));
                sb.Append("|" + m_CreationTime.ToString("yyyy-MM-dd hh:mm:ss"));
                sb.Append("|" + m_FileFullName);

                return sb.ToString();
            }
        }

        public string FileName
        {
            get { return Path.GetFileName(m_FileFullName); }
        }

        public string FileFullName
        {
            get { return m_FileFullName; }
        }

        private byte[] GetFileEntryByes()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(Path.GetFileName(m_FileFullName));
            sb.Append("|" + m_OriginalLength.ToString());
            sb.Append("|" + m_GZipFileLength.ToString());
            sb.Append("|" + m_LastWriteTime.Ticks.ToString());
            sb.Append("|" + m_LastAccessTime.Ticks.ToString());
            sb.Append("|" + m_CreationTime.Ticks.ToString());
            sb.Append("|" + m_FileFullName);

            string str = sb.ToString();
            return Encoding.Default.GetBytes(str);  // 不能用 ASCII, 要处理汉字
        }
    }

    /// <summary>
    /// 简单加密类
    /// </summary>
    public class TCipher
    {
        private static readonly byte[] m_XORVector = new byte[] { 8, 3, 6, 1, 0, 9 };

        public static void EncryptBytes(byte[] byteArray)
        {
            int k = 0;
            for (int i = 0; i < byteArray.Length; i++)
            {
                byteArray[i] ^= m_XORVector[k];
                k++;
                k = k % m_XORVector.Length;
            }
        }
    }
}

 
 

你可能感兴趣的:(.net,加密,Google,null,byte,Delphi)

ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
Git常用命令－修改远程仓库地址猿大师 Linux Java git java
查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
【加密社】Solidity 中的事件机制及其应用加密社闲侃区块链智能合约区块链
加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
【无标题】达瓦达瓦 JhonKI 考研
博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
上图为是否色发 JhonKI 考研
博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
143234234123432 JhonKI 考研
博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
你可能遗漏的一些C#/.NET/.NET Core知识点追逐时光者 C#.NET DotNetGuide编程指南 c#.net .netcore microsoft
前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
第1步win10宿主机与虚拟机通过NAT共享上网互通学习3人组大数据大数据
VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Kafka是如何保证数据的安全性、可靠性和分区的喜欢猪猪 kafka 分布式
Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
光盘文件系统 (iso9660) 格式解析穷人小水滴光盘文件系统 iso9660 deno GNU/Linux javascript
越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
科幻游戏《外卖员模拟器》主要地理环境设定 (1) 穷人小水滴游戏科幻设计
游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
react-intl——react国际化使用方案苹果酱0567 面试题汇总与解析 java 开发语言中间件 spring boot 后端
国际化介绍i18n：internationalization国家化简称，首字母+首尾字母间隔的字母个数+尾字母，类似的还有k8s(Kubernetes)React-intl是React中最受欢迎的库。使用步骤安装#usenpmnpminstallreact-intl-D#useyarn项目入口文件配置//index.tsximportReactfrom"react";importReactDOMf
Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 error react mongodb 数据库
背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
C++ lambda闭包消除类成员变量 barbyQAQ c++c++java 算法
原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
tiff批量转png 诺有缸的高飞鸟 opencv 图像处理 python opencv 图像处理
目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
笋丁网页自动回复机器人V3.0.0免授权版源码希希分享软希网58soho_cn 源码资源笋丁网页自动回复机器人
笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
非对称加密算法原理与应用2——RSA私钥加密文件私语茶馆云部署与开发架构及产品灵感记录 RSA2048 私钥加密
作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
leetcode-617. 合并二叉树 manba_ leetcode hot100 leetcode 算法
题目描述给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为null的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意:合并过程必须从两个树的根节点开始。示例1：输入：root1=[1,3,2,
非对称加密算法————RSA理论及详情 hu19930613
转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
【加密算法基础——对称加密和非对称加密】 XWWW668899 网络安全服务器笔记
对称加密与非对称加密对称加密和非对称加密是两种基本的加密方法，各自有不同的特点和用途。以下是详细比较：1.对称加密特点密钥:使用相同的密钥进行加密和解密。发送方和接收方必须共享这个密钥。速度:通常速度较快，适合处理大量数据。实现:算法相对简单，计算效率高。常见算法AES(高级加密标准)DES(数据加密标准)3DES(三重数据加密标准)RC4(流密码)应用场景文件加密磁盘加密传输大量数据时的加密2.
思考成长丁昆朋
这篇文章是加紧赶出来“应付”日更，一方面不想要再晚睡了；另一方面不想失去日更达人的称号，只能坐下来匆忙写下一点文字。既然标题是成长，先来总结一下这段时间的收获：1、整理箱子站着可以看电脑，坐着反而是一种享受，减少了坐着腰酸背痛的现象；2、使用讯飞输入法大大增加自己的输出量；3、Anaconda+“pythontutor.com"+Google算是简单入门python；4、英语的阅读文章能力、听力提
LeetCode[Math] - #66 Plus One Cwind java LeetCode 题解 Algorithm Math
原题链接：#66 Plus One 要求：给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。注意： 1. 数字的较高位存在数组的头上，即num1表示数字1239 2. 每一位（数组中的每个元素）的取值范围为0~9 难度：简单分析：题目比较简单，只须从数组
JQuery中$.ajax()方法参数详解 AILIKES JavaScript jsonp jquery Ajax json
url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和 delete也可以使用，但仅部分浏览器支持。 timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
JConsole & JVisualVM远程监视Webphere服务器JVM Kai_Ge JVisualVM JConsole Webphere
JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。　　首先我们看WAS服务器端的配置. 　　1、登录was控制台https://10.4.119.18
自定义annotation 120153216 annotation
Java annotation 自定义注释@interface的用法一、什么是注释说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
CentOS 5/6.X 使用 EPEL YUM源 2002wmj centos
CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
在SQLSERVER中查找缺失和无用的索引SQL 357029540 SQL Server
--缺失的索引 SELECT avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement , last_user_seek ,
Spring3 MVC 笔记（二） —json+rest优化 7454103 Spring3 MVC
接上次的 spring mvc 注解的一些详细信息！其实也是一些个人的学习笔记呵呵！
替换“\”的时候报错Unexpected internal error near index 1 \ ^ adminjun java “\替换”
发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘... 在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常 public class Main { /*
POJ 1035 Spell checker(哈希表) aijuans 暴力求解--哈希表
/* 题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词要求按照输入时候的排名输出题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重 */ #include <iostream> //#define using namespace std; const int HASH =
通过原型实现javascript Array的去重、最大值和最小值 ayaoxinchao JavaScript array prototype
用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。实现代码如下： <script type="text/javascript"> Array.prototype.unique = function() { var a = {}; var le
UIWebView实现https双向认证请求 bewithme UIWebView https Objective-C
什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存) bijian1013 redis 数据库 NoSQL
3.事务处理 Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
各数据库分页sql备忘 bingyingao oracle sql 分页
ORACLE 下面这个效率很低 SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 下面这个效率很高 SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
【Scala七】Scala核心一：函数 bit1129 scala
1. 如果函数体只有一行代码，则可以不用写{},比如 def print(x: Int) = println(x) 一行上的多条语句用分号隔开，则只有第一句属于方法体，例如 def printWithValue(x: Int) : String= println(x); "ABC" 上面的代码报错，因为，printWithValue的方法
了解GHC的factorial编译过程 bookjovi haskell
GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
Java-Collections Framework学习与总结-LinkedHashMap BrokenDreams LinkedHashMap
前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。
读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory bylijinnan abstract
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * Abstract Factory Pattern * 抽象工厂模式的目的是： * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇” * 这些接口是相关或者相依赖的
压暗面部高光 cherishLC PS
方法一、压暗高光&重新着色当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。下面讲一下我今天处理高光区域的心得：皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。如果想简化步骤，可以只进行着色（参看下面的步骤1
Java VisualVM监控远程JVM crabdave visualvm
Java VisualVM监控远程JVM JDK1.6开始自带的VisualVM就是不错的监控工具. 这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面通过JMX连接远程机器, 需要经过下面的配置: 1. 修改远程机器JDK配置文件 (我这里远程机器是linux).
Saiku去掉登录模块 daizj saiku 登录 olap BI
1、修改applicationContext-saiku-webapp.xml <security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" /> <security:intercept-url pattern=&qu
浅析 Flex中的Focus dsjt html Flex Flash
关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 焦点、设置焦点、获得焦点、键盘事件一、无焦点的困扰——组件监听不到键盘事件原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
Yii全局函数使用 dcj3sjt126com yii
由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
设计模式之单例模式二（解决无序写入的问题） come_for_dream 单例模式 volatile 乱序执行双重检验锁
在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
程序员从初级到高级的蜕变 gcq511120594 框架工作 PHP android html5
软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。现在我们把淫浸代码时间超过3年的开发人员称为
Reverse Linked List hcx2013 list
Reverse a singly linked list. /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ p
Spring4.1新特性——数据库集成测试 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
C# Ajax上传图片同时生成微缩图(附Demo) liyonghui160com
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx） 2.C#位图处理 System.Drawing。 3.最新demo支持IE7,IE8,Fir
Java list三种遍历方法性能比较 pda158 java
从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： package com.hisense.tiger.list; import java.util.ArrayList; import java.util.Iterator;
300个涵盖IT各方面的免费资源（上）——商业与市场篇 shoothao seo 商业与市场 IT资源免费资源
A.网站模板+logo+服务器主机+发票生成 HTML5 UP:响应式的HTML5和CSS3网站模板。 Bootswatch:免费的Bootstrap主题。 Templated:收集了845个免费的CSS和HTML5网站模板。 Wordpress.org|Wordpress.com:可免费创建你的新网站。 Strikingly:关注领域中免费无限的移动优
localStorage、sessionStorage uule localStorage
W3School 例子 HTML5 提供了两种在客户端存储数据的新方法： localStorage - 没有时间限制的数据存储 sessionStorage - 针对一个 session 的数据存储之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不