public SocketServer(int port, ErrorLogger errorLog, FileLogger debugLog)
            : base(errorLog, debugLog)
        {
            try
            {
                this.encoding = Encoding.ASCII;
                this.port = port;
                this.clients = new List<SocketClient>();

                this.listenerLoopThread = new Thread(this.ListenerLoop);
                this.listenerLoopThread.IsBackground = true;
                this.listenerLoopThread.Start();

                this.clientsLoopThread = new Thread(this.ClientsLoop);
                this.clientsLoopThread.IsBackground = true;
                this.clientsLoopThread.Start();

                this.Store("Host.Version", AssemblyInfo.SarVersion);
                this.Store("Host.Port", this.port.ToString());
                this.Store("Host.Clients", this.clients.Count.ToString());
                this.Store("Host.Application.Product", AssemblyInfo.Product);
                this.Store("Host.Application.Version", AssemblyInfo.Version);
            }
            catch (Exception ex)
            {
                this.Log(ex);
            }
        }

 public FileReverseReader(string path)
 {
     disposed = false;
     file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
     encoding = FindEncoding(file);
     SetupCharacterStartDetector();
 }

        protected void Arrange()
        {
            var random = new Random();
            _subsystemName = random.Next().ToString(CultureInfo.InvariantCulture);
            _operationTimeout = TimeSpan.FromSeconds(30);
            _encoding = Encoding.UTF8;
            _disconnectedRegister = new List<EventArgs>();
            _errorOccurredRegister = new List<ExceptionEventArgs>();
            _channelDataEventArgs = new ChannelDataEventArgs(
                (uint)random.Next(0, int.MaxValue),
                new[] { (byte)random.Next(byte.MinValue, byte.MaxValue) });

            _sessionMock = new Mock<ISession>(MockBehavior.Strict);
            _channelMock = new Mock<IChannelSession>(MockBehavior.Strict);

            _sequence = new MockSequence();
            _sessionMock.InSequence(_sequence).Setup(p => p.CreateChannelSession()).Returns(_channelMock.Object);
            _channelMock.InSequence(_sequence).Setup(p => p.Open());
            _channelMock.InSequence(_sequence).Setup(p => p.SendSubsystemRequest(_subsystemName)).Returns(true);

            _subsystemSession = new SubsystemSessionStub(
                _sessionMock.Object,
                _subsystemName,
                _operationTimeout,
                _encoding);
            _subsystemSession.Disconnected += (sender, args) => _disconnectedRegister.Add(args);
            _subsystemSession.ErrorOccurred += (sender, args) => _errorOccurredRegister.Add(args);
            _subsystemSession.Connect();
        }

 public EdifactWriter(Stream stream, Encoding encoding, EdifactCharacterSet edifactCharacterSet, char replacementCharacter, bool normalize = true)
     : base(stream, encoding)
 {
     this._fallbackChar = replacementCharacter;
     this._edifactCharacterSet = edifactCharacterSet;
     this._normalize = normalize;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DownloadSecondaryServerVisitor"/> class.
        /// </summary>
        /// <param name="encoding">The encoding used to read and write strings.</param>
        public DownloadSecondaryServerVisitor(Encoding encoding)
        {
            // You should use an IoC container to do this.
            TcpReaderFactory = new TcpReaderFactory();

            CurrentEncoding = encoding;
        }

 public SftpOpenDirRequest(uint protocolVersion, uint requestId, string path, Encoding encoding, Action<SftpHandleResponse> handleAction, Action<SftpStatusResponse> statusAction)
     : base(protocolVersion, requestId, statusAction)
 {
     this.Path = path;
     this.Encoding = encoding;
     this.SetAction(handleAction);
 }

 /// <summary>
 ///     获取远程信息
 /// </summary>
 /// <param name="url">请求地址</param>
 /// <param name="encoding">请求编码</param>
 /// <param name="wc">客户端</param>
 public static string Get(string url, Encoding encoding = null, WebClient wc = null)
 {
     if (string.IsNullOrWhiteSpace(url)) { return string.Empty; }
     url = url.Replace("\\", "/");
     if (encoding == null) encoding = Encoding.UTF8;
     var isNew = wc == null;
     if (wc == null)
     {
         wc = new WebClient();
         wc.Proxy = null;
         wc.Headers.Add("Accept", "*/*");
         wc.Headers.Add("Referer", url);
         wc.Headers.Add("Cookie", "bid=\"YObnALe98pw\";");
         wc.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.5 Safari/537.31");
     }
     string strResult = null;
     try
     {
         var data = wc.DownloadData(url);
         strResult = encoding.GetString(data);
     }
     catch { return string.Empty; }
     finally
     {
         if (!isNew) Cookies(wc);
         if (isNew) wc.Dispose();
     }
     return strResult;
 }

 private static void RunTests(Encoding enc, params string[] pathElements)
 {
     var engine = new FileHelperEngine<CustomersVerticalBar>();
     engine.Encoding = enc;
     Assert.AreEqual(enc, engine.Encoding);
     CoreRunTest(engine, pathElements);
 }

        private static void RunAsyncConstructor(Encoding enc, params string[] pathElements)
        {
            var asyncEngine = new FileHelperAsyncEngine<CustomersVerticalBar>(enc);
            Assert.AreEqual(enc, asyncEngine.Encoding);

            CoreRunAsync(asyncEngine, pathElements);
        }

        public SourceText CreateText(Stream stream, Encoding defaultEncoding, CancellationToken cancellationToken = default(CancellationToken))
        {
            // this API is for a case where user wants us to figure out encoding from the given stream.
            // if defaultEncoding is given, we will use it if we couldn't figure out encoding used in the stream ourselves.
            Debug.Assert(stream != null);
            Debug.Assert(stream.CanSeek);
            Debug.Assert(stream.CanRead);

            if (defaultEncoding == null)
            {
                // Try UTF-8
                try
                {
                    return CreateTextInternal(stream, s_throwingUtf8Encoding, cancellationToken);
                }
                catch (DecoderFallbackException)
                {
                    // Try Encoding.Default
                    defaultEncoding = Encoding.Default;
                }
            }

            try
            {
                return CreateTextInternal(stream, defaultEncoding, cancellationToken);
            }
            catch (DecoderFallbackException)
            {
                return null;
            }
        }

        public CommonVolumeDescriptor(byte[] src, int offset, Encoding enc)
            : base(src, offset)
        {
            CharacterEncoding = enc;

            SystemIdentifier = IsoUtilities.ReadChars(src, offset + 8, 32, CharacterEncoding);
            VolumeIdentifier = IsoUtilities.ReadChars(src, offset + 40, 32, CharacterEncoding);
            VolumeSpaceSize = IsoUtilities.ToUInt32FromBoth(src, offset + 80);
            VolumeSetSize = IsoUtilities.ToUInt16FromBoth(src, offset + 120);
            VolumeSequenceNumber = IsoUtilities.ToUInt16FromBoth(src, offset + 124);
            LogicalBlockSize = IsoUtilities.ToUInt16FromBoth(src, offset + 128);
            PathTableSize = IsoUtilities.ToUInt32FromBoth(src, offset + 132);
            TypeLPathTableLocation = Utilities.ToUInt32LittleEndian(src, offset + 140);
            OptionalTypeLPathTableLocation = Utilities.ToUInt32LittleEndian(src, offset + 144);
            TypeMPathTableLocation = Utilities.BitSwap(Utilities.ToUInt32LittleEndian(src, offset + 148));
            OptionalTypeMPathTableLocation = Utilities.BitSwap(Utilities.ToUInt32LittleEndian(src, offset + 152));
            DirectoryRecord.ReadFrom(src, offset + 156, CharacterEncoding, out RootDirectory);
            VolumeSetIdentifier = IsoUtilities.ReadChars(src, offset + 190, 318 - 190, CharacterEncoding);
            PublisherIdentifier = IsoUtilities.ReadChars(src, offset + 318, 446 - 318, CharacterEncoding);
            DataPreparerIdentifier = IsoUtilities.ReadChars(src, offset + 446, 574 - 446, CharacterEncoding);
            ApplicationIdentifier = IsoUtilities.ReadChars(src, offset + 574, 702 - 574, CharacterEncoding);
            CopyrightFileIdentifier = IsoUtilities.ReadChars(src, offset + 702, 739 - 702, CharacterEncoding);
            AbstractFileIdentifier = IsoUtilities.ReadChars(src, offset + 739, 776 - 739, CharacterEncoding);
            BibliographicFileIdentifier = IsoUtilities.ReadChars(src, offset + 776, 813 - 776, CharacterEncoding);
            CreationDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 813);
            ModificationDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 830);
            ExpirationDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 847);
            EffectiveDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 864);
            FileStructureVersion = src[offset + 881];
        }

 /// <summary>
 /// 新しいこのクラスのインスタンスを構築します。
 /// </summary>
 /// <param name="sourcePath">比較元ファイルパス</param>
 /// <param name="destinationPath">比較先ファイルパス</param>
 /// <param name="encode">ファイルのエンコード</param>
 public TextFileMarger(string sourcePath, string destinationPath, Encoding encode)
      : base()
 {
     SourcePath = sourcePath;
     DestinationPath = destinationPath;
     Encoding = encode;
 }

 private static void TestSingleEncoding(string text, int bufferSize, Encoding encoding)
 {
     DisposeCheckingMemoryStream stream = new DisposeCheckingMemoryStream(encoding.GetBytes(text));
     var reader = new ReverseLineReader(() => stream, encoding, bufferSize);
     AssertLines(new LineReader(() => new StringReader(text)).Reverse(), reader);
     Assert.IsTrue(stream.Disposed);
 }

 /// <include file='doc\XmlParserContext.uex' path='docs/doc[@for="XmlParserContext.XmlParserContext3"]/*' />
 public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, String docTypeName,
                   String pubId, String sysId, String internalSubset, String baseURI,
                   String xmlLang, XmlSpace xmlSpace, Encoding enc)
 {
     
     if (nsMgr != null) {
         if (nt == null) {
             _nt = nsMgr.NameTable;
         }
         else {
             if ( (object)nt != (object)  nsMgr.NameTable ) {
                 throw new XmlException(Res.Xml_NotSameNametable);
             }
             _nt = nt;
         }
     }
     else {
         _nt = nt;
     }
     
     _nsMgr              = nsMgr;
     _docTypeName        = (null == docTypeName ? String.Empty : docTypeName);
     _pubId              = (null == pubId ? String.Empty : pubId);
     _sysId              = (null == sysId ? String.Empty : sysId);
     _internalSubset     = (null == internalSubset ? String.Empty : internalSubset);
     _baseURI            = (null == baseURI ? String.Empty : baseURI);
     _xmlLang            = (null == xmlLang ? String.Empty : xmlLang);
     _xmlSpace           = xmlSpace;
     _encoding           = enc;
     
 }

 public StructureSegment(byte[] pBuffer, int pStart, int pLength, byte locale)
 {
     mBuffer = new byte[pLength];
     try
     {
         switch (locale)
         {
             case MapleLocale.KOREA:
             case MapleLocale.KOREA_TEST:
                 encoding = Encoding.GetEncoding(51949); // EUC_KR
                 break;
             case MapleLocale.JAPAN:
                 encoding = Encoding.GetEncoding(50222); // Shift_JIS
                 break;
             case MapleLocale.CHINA:
                 encoding = Encoding.GetEncoding(54936); // GB18030
                 break;
             case MapleLocale.TESPIA:
                 encoding = Encoding.Default;
                 break;
             case MapleLocale.TAIWAN:
                 encoding = Encoding.GetEncoding("BIG5-HKSCS");
                 break;
             default:
                 encoding = Encoding.UTF8;
                 break;
         }
     }
     catch
     {
         encoding = Encoding.UTF8;
     }
     Buffer.BlockCopy(pBuffer, pStart, mBuffer, 0, pLength);
 }

        public void AddFile(string directory, FtpItem item, string text, Encoding encoding)
        {
            var uri = GetUri(directory, item.Name);
            var data = encoding.GetBytes(text);

            item.Length = data.Length;

            if (_dict.ContainsKey(uri))
            {
                _dict[uri] = data;
            }
            else
            {
                _dict.Add(uri, data);
            }

            if (_uri_ftpitem.ContainsKey(uri))
            {
                _uri_ftpitem[uri] = item;
            }
            else
            {
                _uri_ftpitem.Add(uri, item);
            }
        }

 private void CheckOutput(IProjectFile projectFile, Encoding encoding)
 {
     Assert.IsNotNull(projectFile, "projectFile == null");
     this.ExecuteWithGold(
         projectFile.Location.Name,
         sw =>
         {
             using (var sr = new StreamReader(projectFile.Location.OpenFileForReadingExclusive(), encoding, true))
             {
                 var lexer = this.CreateLexer(projectFile, sr);
                 int position = 0;
                 lexer.Start();
                 while (lexer.TokenType != null)
                 {
                     Assert.AreEqual(
                         lexer.TokenStart,
                         position,
                         "Token start error. Expected: {0}, actual: {1}",
                         position,
                         lexer.TokenStart);
                     position = lexer.TokenEnd;
                     this.WriteToken(sw, lexer);
                     lexer.Advance();
                 }
                 Assert.AreEqual(lexer.Buffer.Length, position, "position == lexer.Buffer.Length");
             }
         });
 }

        public static BinaryWriter GetBinaryWriter(this byte[] data, Encoding encoding = null)
        {
            Contract.Requires(data != null);
            Contract.Ensures(Contract.Result<BinaryWriter>() != null);

            return new BinaryWriter(new MemoryStream(data), encoding ?? Encoding.UTF8);
        }

 public void LoadFrom( string filepath, Encoding encoding )
 {
     //todo thread this operation may take a lot of time and make it look cool when it loads
     listText.Clear();
     InsertRange( 0, File.ReadLines( filepath, encoding ) );
     modified = false;
 }

        /// <summary>
        /// 使用Get方法获取字符串结果（加入Cookie）
        /// </summary>
        /// <param name="url"></param>
        /// <param name="cookieContainer"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static string HttpGet(string url, CookieContainer cookieContainer = null, Encoding encoding = null, int timeOut = App.AppRequestTimeOut)
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "GET";
            request.Timeout = timeOut;

            if (cookieContainer != null)
            {
                request.CookieContainer = cookieContainer;
            }

            HttpWebResponse response = (HttpWebResponse)request.GetResponse();

            if (cookieContainer != null)
            {
                response.Cookies = cookieContainer.GetCookies(response.ResponseUri);
            }

            using (Stream responseStream = response.GetResponseStream())
            {
                using (StreamReader myStreamReader = new StreamReader(responseStream, encoding ?? Encoding.GetEncoding("utf-8")))
                {
                    string retString = myStreamReader.ReadToEnd();
                    return retString;
                }
            }
        }