using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Standard
{
    internal static class Utility
    {
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        private static bool _MemCmp(IntPtr left, IntPtr right, long cb)
        {
            int num = 0;
            while ((long) num < cb - 8L)
            {
                long num2 = Marshal.ReadInt64(left, num);
                long num3 = Marshal.ReadInt64(right, num);
                if (num2 != num3)
                {
                    return false;
                }
                num += 8;
            }
            while ((long) num < cb)
            {
                byte b = Marshal.ReadByte(left, num);
                byte b2 = Marshal.ReadByte(right, num);
                if (b != b2)
                {
                    return false;
                }
                num++;
            }
            return true;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static int RGB(Color c)
        {
            return (int) c.R | (int) c.G << 8 | (int) c.B << 16;
        }

        public static Color ColorFromArgbDword(uint color)
        {
            return Color.FromArgb((byte) ((color & 4278190080u) >> 24), (byte) ((color & 16711680u) >> 16), (byte) ((color & 65280u) >> 8), (byte) (color & 255u));
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static int GET_X_LPARAM(IntPtr lParam)
        {
            return Utility.LOWORD(lParam.ToInt32());
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static int GET_Y_LPARAM(IntPtr lParam)
        {
            return Utility.HIWORD(lParam.ToInt32());
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static int HIWORD(int i)
        {
            return (int) ((short) (i >> 16));
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static int LOWORD(int i)
        {
            return (int) ((short) (i & 65535));
        }

        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool AreStreamsEqual(Stream left, Stream right)
        {
            if (left == null)
            {
                return right == null;
            }
            if (right == null)
            {
                return false;
            }
            if (!left.CanRead || !right.CanRead)
            {
                throw new NotSupportedException("The streams can't be read for comparison");
            }
            if (left.Length != right.Length)
            {
                return false;
            }
            int num = (int) left.Length;
            left.Position = 0L;
            right.Position = 0L;
            int i = 0;
            int num2 = 0;
            byte[] array = new byte[512];
            byte[] array2 = new byte[512];
            GCHandle gchandle = GCHandle.Alloc(array, GCHandleType.Pinned);
            IntPtr left2 = gchandle.AddrOfPinnedObject();
            GCHandle gchandle2 = GCHandle.Alloc(array2, GCHandleType.Pinned);
            IntPtr right2 = gchandle2.AddrOfPinnedObject();
            bool result;
            try
            {
                while (i < num)
                {
                    int num3 = left.Read(array, 0, array.Length);
                    int num4 = right.Read(array2, 0, array2.Length);
                    if (num3 != num4)
                    {
                        return false;
                    }
                    if (!Utility._MemCmp(left2, right2, (long) num3))
                    {
                        return false;
                    }
                    i += num3;
                    num2 += num4;
                }
                result = true;
            }
            finally
            {
                gchandle.Free();
                gchandle2.Free();
            }
            return result;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool GuidTryParse(string guidString, out Guid guid)
        {
            Verify.IsNeitherNullNorEmpty(guidString, "guidString");
            try
            {
                guid = new Guid(guidString);
                return true;
            }
            catch (FormatException)
            {
            }
            catch (OverflowException)
            {
            }
            guid = default(Guid);
            return false;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool IsFlagSet(int value, int mask)
        {
            return 0 != (value & mask);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool IsFlagSet(uint value, uint mask)
        {
            return 0u != (value & mask);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool IsFlagSet(long value, long mask)
        {
            return 0L != (value & mask);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool IsFlagSet(ulong value, ulong mask)
        {
            return 0UL != (value & mask);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool IsOSVistaOrNewer
        {
            get
            {
                return Utility._osVersion >= new Version(6, 0);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool IsOSWindows7OrNewer
        {
            get
            {
                return Utility._osVersion >= new Version(6, 1);
            }
        }

        public static bool IsPresentationFrameworkVersionLessThan4
        {
            get
            {
                return Utility._presentationFrameworkVersion < new Version(4, 0);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")]
        public static IntPtr GenerateHICON(ImageSource image, Size dimensions)
        {
            if (image == null)
            {
                return IntPtr.Zero;
            }
            BitmapFrame bitmapFrame = image as BitmapFrame;
            if (bitmapFrame != null)
            {
                bitmapFrame = Utility.GetBestMatch(bitmapFrame.Decoder.Frames, (int) dimensions.Width, (int) dimensions.Height);
            }
            else
            {
                Rect rectangle = new Rect(0.0, 0.0, dimensions.Width, dimensions.Height);
                double num = dimensions.Width / dimensions.Height;
                double num2 = image.Width / image.Height;
                if (image.Width <= dimensions.Width && image.Height <= dimensions.Height)
                {
                    rectangle = new Rect((dimensions.Width - image.Width) / 2.0, (dimensions.Height - image.Height) / 2.0, image.Width, image.Height);
                }
                else if (num > num2)
                {
                    double num3 = image.Width / image.Height * dimensions.Width;
                    rectangle = new Rect((dimensions.Width - num3) / 2.0, 0.0, num3, dimensions.Height);
                }
                else if (num < num2)
                {
                    double num4 = image.Height / image.Width * dimensions.Height;
                    rectangle = new Rect(0.0, (dimensions.Height - num4) / 2.0, dimensions.Width, num4);
                }
                DrawingVisual drawingVisual = new DrawingVisual();
                DrawingContext drawingContext = drawingVisual.RenderOpen();
                drawingContext.DrawImage(image, rectangle);
                drawingContext.Close();
                RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap((int) dimensions.Width, (int) dimensions.Height, 96.0, 96.0, PixelFormats.Pbgra32);
                renderTargetBitmap.Render(drawingVisual);
                bitmapFrame = BitmapFrame.Create(renderTargetBitmap);
            }
            IntPtr result;
            using (MemoryStream memoryStream = new MemoryStream())
            {
                new PngBitmapEncoder
                {
                    Frames =
                    {
                        bitmapFrame
                    }
                }.Save(memoryStream);
                using (ManagedIStream managedIStream = new ManagedIStream(memoryStream))
                {
                    IntPtr zero = IntPtr.Zero;
                    try
                    {
                        Status status = NativeMethods.GdipCreateBitmapFromStream(managedIStream, out zero);
                        if (status != Status.Ok)
                        {
                            result = IntPtr.Zero;
                        }
                        else
                        {
                            IntPtr intPtr;
                            status = NativeMethods.GdipCreateHICONFromBitmap(zero, out intPtr);
                            if (status != Status.Ok)
                            {
                                result = IntPtr.Zero;
                            }
                            else
                            {
                                result = intPtr;
                            }
                        }
                    }
                    finally
                    {
                        Utility.SafeDisposeImage(ref zero);
                    }
                }
            }
            return result;
        }

        public static BitmapFrame GetBestMatch(IList<BitmapFrame> frames, int width, int height)
        {
            return Utility._GetBestMatch(frames, Utility._GetBitDepth(), width, height);
        }

        private static int _MatchImage(BitmapFrame frame, int bitDepth, int width, int height, int bpp)
        {
            return 2 * Utility._WeightedAbs(bpp, bitDepth, false) + Utility._WeightedAbs(frame.PixelWidth, width, true) + Utility._WeightedAbs(frame.PixelHeight, height, true);
        }

        private static int _WeightedAbs(int valueHave, int valueWant, bool fPunish)
        {
            int num = valueHave - valueWant;
            if (num < 0)
            {
                num = (fPunish ? -2 : -1) * num;
            }
            return num;
        }

        private static BitmapFrame _GetBestMatch(IList<BitmapFrame> frames, int bitDepth, int width, int height)
        {
            int num = int.MaxValue;
            int num2 = 0;
            int index = 0;
            bool flag = frames[0].Decoder is IconBitmapDecoder;
            int num3 = 0;
            while (num3 < frames.Count && num != 0)
            {
                int num4 = flag ? frames[num3].Thumbnail.Format.BitsPerPixel : frames[num3].Format.BitsPerPixel;
                if (num4 == 0)
                {
                    num4 = 8;
                }
                int num5 = Utility._MatchImage(frames[num3], bitDepth, width, height, num4);
                if (num5 < num)
                {
                    index = num3;
                    num2 = num4;
                    num = num5;
                }
                else if (num5 == num && num2 < num4)
                {
                    index = num3;
                    num2 = num4;
                }
                num3++;
            }
            return frames[index];
        }

        private static int _GetBitDepth()
        {
            if (Utility.s_bitDepth == 0)
            {
                using (SafeDC desktop = SafeDC.GetDesktop())
                {
                    Utility.s_bitDepth = NativeMethods.GetDeviceCaps(desktop, DeviceCap.BITSPIXEL) * NativeMethods.GetDeviceCaps(desktop, DeviceCap.PLANES);
                }
            }
            return Utility.s_bitDepth;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeDeleteFile(string path)
        {
            if (!string.IsNullOrEmpty(path))
            {
                File.Delete(path);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeDeleteObject(ref IntPtr gdiObject)
        {
            IntPtr intPtr = gdiObject;
            gdiObject = IntPtr.Zero;
            if (IntPtr.Zero != intPtr)
            {
                NativeMethods.DeleteObject(intPtr);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeDestroyIcon(ref IntPtr hicon)
        {
            IntPtr intPtr = hicon;
            hicon = IntPtr.Zero;
            if (IntPtr.Zero != intPtr)
            {
                NativeMethods.DestroyIcon(intPtr);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeDestroyWindow(ref IntPtr hwnd)
        {
            IntPtr hwnd2 = hwnd;
            hwnd = IntPtr.Zero;
            if (NativeMethods.IsWindow(hwnd2))
            {
                NativeMethods.DestroyWindow(hwnd2);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeDispose<T>(ref T disposable) where T : IDisposable
        {
            IDisposable disposable2 = disposable;
            disposable = default(T);
            if (disposable2 != null)
            {
                disposable2.Dispose();
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeDisposeImage(ref IntPtr gdipImage)
        {
            IntPtr intPtr = gdipImage;
            gdipImage = IntPtr.Zero;
            if (IntPtr.Zero != intPtr)
            {
                NativeMethods.GdipDisposeImage(intPtr);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
        public static void SafeCoTaskMemFree(ref IntPtr ptr)
        {
            IntPtr intPtr = ptr;
            ptr = IntPtr.Zero;
            if (IntPtr.Zero != intPtr)
            {
                Marshal.FreeCoTaskMem(intPtr);
            }
        }

        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void SafeFreeHGlobal(ref IntPtr hglobal)
        {
            IntPtr intPtr = hglobal;
            hglobal = IntPtr.Zero;
            if (IntPtr.Zero != intPtr)
            {
                Marshal.FreeHGlobal(intPtr);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
        public static void SafeRelease<T>(ref T comObject) where T : class
        {
            T t = comObject;
            comObject = default(T);
            if (t != null)
            {
                Marshal.ReleaseComObject(t);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void GeneratePropertyString(StringBuilder source, string propertyName, string value)
        {
            if (source.Length != 0)
            {
                source.Append(' ');
            }
            source.Append(propertyName);
            source.Append(": ");
            if (string.IsNullOrEmpty(value))
            {
                source.Append("<null>");
                return;
            }
            source.Append('"');
            source.Append(value);
            source.Append('"');
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        [Obsolete]
        public static string GenerateToString<T>(T @object) where T : struct
        {
            StringBuilder stringBuilder = new StringBuilder();
            foreach (PropertyInfo propertyInfo in typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                if (stringBuilder.Length != 0)
                {
                    stringBuilder.Append(", ");
                }
                object value = propertyInfo.GetValue(@object, null);
                string format = (value == null) ? "{0}: <null>" : "{0}: \"{1}\"";
                stringBuilder.AppendFormat(format, propertyInfo.Name, value);
            }
            return stringBuilder.ToString();
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void CopyStream(Stream destination, Stream source)
        {
            destination.Position = 0L;
            if (source.CanSeek)
            {
                source.Position = 0L;
                destination.SetLength(source.Length);
            }
            byte[] array = new byte[4096];
            int num;
            do
            {
                num = source.Read(array, 0, array.Length);
                if (num != 0)
                {
                    destination.Write(array, 0, num);
                }
            }
            while (array.Length == num);
            destination.Position = 0L;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static string HashStreamMD5(Stream stm)
        {
            stm.Position = 0L;
            StringBuilder stringBuilder = new StringBuilder();
            using (MD5 md = MD5.Create())
            {
                foreach (byte b in md.ComputeHash(stm))
                {
                    stringBuilder.Append(b.ToString("x2", CultureInfo.InvariantCulture));
                }
            }
            return stringBuilder.ToString();
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static void EnsureDirectory(string path)
        {
            if (!Directory.Exists(Path.GetDirectoryName(path)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(path));
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static bool MemCmp(byte[] left, byte[] right, int cb)
        {
            GCHandle gchandle = GCHandle.Alloc(left, GCHandleType.Pinned);
            IntPtr left2 = gchandle.AddrOfPinnedObject();
            GCHandle gchandle2 = GCHandle.Alloc(right, GCHandleType.Pinned);
            IntPtr right2 = gchandle2.AddrOfPinnedObject();
            bool result = Utility._MemCmp(left2, right2, (long) cb);
            gchandle.Free();
            gchandle2.Free();
            return result;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static string UrlDecode(string url)
        {
            if (url == null)
            {
                return null;
            }
            Utility._UrlDecoder urlDecoder = new Utility._UrlDecoder(url.Length, Encoding.UTF8);
            int length = url.Length;
            for (int i = 0; i < length; i++)
            {
                char c = url[i];
                if (c == '+')
                {
                    urlDecoder.AddByte(32);
                }
                else
                {
                    if (c == '%' && i < length - 2)
                    {
                        if (url[i + 1] == 'u' && i < length - 5)
                        {
                            int num = Utility._HexToInt(url[i + 2]);
                            int num2 = Utility._HexToInt(url[i + 3]);
                            int num3 = Utility._HexToInt(url[i + 4]);
                            int num4 = Utility._HexToInt(url[i + 5]);
                            if (num >= 0 && num2 >= 0 && num3 >= 0 && num4 >= 0)
                            {
                                urlDecoder.AddChar((char) (num << 12 | num2 << 8 | num3 << 4 | num4));
                                i += 5;
                                goto IL_12D;
                            }
                        }
                        else
                        {
                            int num5 = Utility._HexToInt(url[i + 1]);
                            int num6 = Utility._HexToInt(url[i + 2]);
                            if (num5 >= 0 && num6 >= 0)
                            {
                                urlDecoder.AddByte((byte) (num5 << 4 | num6));
                                i += 2;
                                goto IL_12D;
                            }
                        }
                    }
                    if ((c & 'ﾀ') == '\0')
                    {
                        urlDecoder.AddByte((byte) c);
                    }
                    else
                    {
                        urlDecoder.AddChar(c);
                    }
                }
IL_12D:;
            }
            return urlDecoder.GetString();
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public static string UrlEncode(string url)
        {
            if (url == null)
            {
                return null;
            }
            byte[] array = Encoding.UTF8.GetBytes(url);
            bool flag = false;
            int num = 0;
            foreach (byte b in array)
            {
                if (b == 32)
                {
                    flag = true;
                }
                else if (!Utility._UrlEncodeIsSafe(b))
                {
                    num++;
                    flag = true;
                }
            }
            if (flag)
            {
                byte[] array3 = new byte[array.Length + num * 2];
                int num2 = 0;
                foreach (byte b2 in array)
                {
                    if (Utility._UrlEncodeIsSafe(b2))
                    {
                        array3[num2++] = b2;
                    }
                    else if (b2 == 32)
                    {
                        array3[num2++] = 43;
                    }
                    else
                    {
                        array3[num2++] = 37;
                        array3[num2++] = Utility._IntToHex(b2 >> 4 & 15);
                        array3[num2++] = Utility._IntToHex((int) (b2 & 15));
                    }
                }
                array = array3;
            }
            return Encoding.ASCII.GetString(array);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        private static bool _UrlEncodeIsSafe(byte b)
        {
            if (Utility._IsAsciiAlphaNumeric(b))
            {
                return true;
            }
            if (b != 33)
            {
                switch (b)
                {
                    case 39:
                    case 40:
                    case 41:
                    case 42:
                    case 45:
                    case 46:
                        return true;
                    case 43:
                    case 44:
                        break;
                    default:
                        if (b == 95)
                        {
                            return true;
                        }
                        break;
                }
                return false;
            }
            return true;
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        private static bool _IsAsciiAlphaNumeric(byte b)
        {
            return (b >= 97 && b <= 122) || (b >= 65 && b <= 90) || (b >= 48 && b <= 57);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        private static byte _IntToHex(int n)
        {
            if (n <= 9)
            {
                return (byte) (n + 48);
            }
            return (byte) (n - 10 + 65);
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        private static int _HexToInt(char h)
        {
            if (h >= '0' && h <= '9')
            {
                return (int) (h - '0');
            }
            if (h >= 'a' && h <= 'f')
            {
                return (int) (h - 'a' + '\n');
            }
            if (h >= 'A' && h <= 'F')
            {
                return (int) (h - 'A' + '\n');
            }
            return -1;
        }

        public static void AddDependencyPropertyChangeListener(object component, DependencyProperty property, EventHandler listener)
        {
            if (component == null)
            {
                return;
            }
            DependencyPropertyDescriptor dependencyPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(property, component.GetType());
            dependencyPropertyDescriptor.AddValueChanged(component, listener);
        }

        public static void RemoveDependencyPropertyChangeListener(object component, DependencyProperty property, EventHandler listener)
        {
            if (component == null)
            {
                return;
            }
            DependencyPropertyDescriptor dependencyPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(property, component.GetType());
            dependencyPropertyDescriptor.RemoveValueChanged(component, listener);
        }

        public static bool IsThicknessNonNegative(Thickness thickness)
        {
            return Utility.IsDoubleFiniteAndNonNegative(thickness.Top) && Utility.IsDoubleFiniteAndNonNegative(thickness.Left) && Utility.IsDoubleFiniteAndNonNegative(thickness.Bottom) && Utility.IsDoubleFiniteAndNonNegative(thickness.Right);
        }

        public static bool IsCornerRadiusValid(CornerRadius cornerRadius)
        {
            return Utility.IsDoubleFiniteAndNonNegative(cornerRadius.TopLeft) && Utility.IsDoubleFiniteAndNonNegative(cornerRadius.TopRight) && Utility.IsDoubleFiniteAndNonNegative(cornerRadius.BottomLeft) && Utility.IsDoubleFiniteAndNonNegative(cornerRadius.BottomRight);
        }

        public static bool IsDoubleFiniteAndNonNegative(double d)
        {
            return !double.IsNaN(d) && !double.IsInfinity(d) && d >= 0.0;
        }

        private static readonly Version _osVersion = Environment.OSVersion.Version;

        private static readonly Version _presentationFrameworkVersion = Assembly.GetAssembly(typeof(Window)).GetName().Version;

        private static int s_bitDepth;

        private class _UrlDecoder
        {
            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public _UrlDecoder(int size, Encoding encoding)
            {
                this._encoding = encoding;
                this._charBuffer = new char[size];
                this._byteBuffer = new byte[size];
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public void AddByte(byte b)
            {
                this._byteBuffer[this._byteCount++] = b;
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public void AddChar(char ch)
            {
                this._FlushBytes();
                this._charBuffer[this._charCount++] = ch;
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            private void _FlushBytes()
            {
                if (this._byteCount > 0)
                {
                    this._charCount += this._encoding.GetChars(this._byteBuffer, 0, this._byteCount, this._charBuffer, this._charCount);
                    this._byteCount = 0;
                }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public string GetString()
            {
                this._FlushBytes();
                if (this._charCount > 0)
                {
                    return new string(this._charBuffer, 0, this._charCount);
                }
                return "";
            }

            private readonly Encoding _encoding;

            private readonly char[] _charBuffer;

            private readonly byte[] _byteBuffer;

            private int _byteCount;

            private int _charCount;
        }
    }
}
