博客园_msn㊣Microshaoft.comnaIBnaiM nOracle (大舌头) I Love download EditPlus.v3.12(602)!

OpenXML Word docx 添加水印 PowerTools

2011-11-24T17:06:00Z


/*
    Microshaoft 本文代码改自
    http://powertools.codeplex.com/
    http://powertools.codeplex.com/releases/view/74771#DownloadId=291022
    文本水印、透明度、旋转
    使用本文代码替代 Classes\WatermarkAccessor.cs 文件中的代码
    Classes 目录下供 34个文件清单如下:
    Classes\BackgroundAccessor.cs
    Classes\ChartsheetAccessor.cs
    Classes\CommentAccessor.cs
    Classes\CommentMerger.cs
    Classes\ContentFormatAccessor.cs
    Classes\ContentStyleAccessor.cs
    Classes\CustomXmlAccessor.cs
    Classes\DigitalSignatureAccessor.cs
    Classes\DocumentBuilder.cs
    Classes\DocumentComparer.cs
    Classes\FooterAccessor.cs
    Classes\HeaderAccessor.cs
    Classes\HtmlConverter.cs
    Classes\IndexAccessor.cs
    Classes\ListItemRetriever.cs
    Classes\MarkupSimplifier.cs
    Classes\PictureAccessor.cs
    Classes\PowerToolsExtensions.cs
    Classes\PtOpenXmlDocument.cs
    Classes\PtOpenXmlUtil.cs
    Classes\PtUtil.cs
    Classes\ReferenceAdder.cs
    Classes\RevisionAccepter.cs
    Classes\SettingAccessor.cs
    Classes\SpreadsheetDocumentManager.cs
    Classes\SpreadSheetStyleAccessor.cs
    Classes\SpreadSheetTableAccessor.cs
    Classes\StyleAccessor.cs
    Classes\TextReplacer.cs
    Classes\ThemeAccessor.cs
    Classes\WatermarkAccessor.cs
    Classes\WordprocessingDocumentManager.cs
    Classes\WorksheetAccessor.cs
    %windir%\Microsoft.NET\Framework\v4.0.30319\csc.exe /out:OpenXmlWordAddWaterMark.exe *.cs /r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\v3.0\WindowsBase.dll","C:\Program Files (x86)\Open XML SDK\V2.0\lib\DocumentFormat.OpenXml.dll"
*/
namespace Microshaoft
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Text;
    using OpenXmlPowerTools;
    class Class1
    {
        static void Main(string[] args)
        {
            // "position:absolute;margin-left:0;margin-top:0;width:527.85pt;height:131.95pt;rotation:315;z-index:-251656192;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin";
            WmlDocument wmlDoc = new WmlDocument(@"d:\a.docx");
            OpenXmlPowerToolsDocument doc = WatermarkAccessor.InsertWatermark
                                        (
                                            wmlDoc
                                            , "测试123abcABC@Microshaoft"
                                            , 527
                                            , 200
                                            , 110
                                            , "楷体"
                                            , 10
                                            , "red"
                                            , 10
                                        );
            doc.SaveAs(@"d:\a1.docx");
        }
    }
}
namespace OpenXmlPowerTools
{
    /***************************************************************************
    Copyright (c) Microsoft Corporation 2011.
    This code is licensed using the Microsoft Public License (Ms-PL).  The text of the license can be found here:
    http://www.microsoft.com/resources/sharedsource/licensingbasics/publiclicense.mspx
    ***************************************************************************/
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Linq;
    using System.Xml.Linq;
    using DocumentFormat.OpenXml.Packaging;
    using System.Drawing;
    /// <summary>
    /// Provides access to watermark operations
    /// </summary>
    public class WatermarkAccessor
    {
        private static XNamespace ns;
        private static XNamespace officens;
        private static XNamespace vmlns;
        private static XNamespace relationshipsns;
        private static string diagonalWatermarkStyle = "position:absolute;margin-left:0;margin-top:0;width:527.85pt;height:131.95pt;rotation:315;z-index:-251656192;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin";
        private static string fontFamilySizeStyle = "font-family:&quot;Calibri&quot;;font-size:1pt";
        private static string fillColor = "black";
        private static int opacity = 50;
        //private static string defaultWatermarkStyle = "position:absolute;margin-left:0;margin-top:0;width:468pt;height:117pt;z-index:-251652096;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin";
        static WatermarkAccessor()
        {
            ns = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
            officens = "urn:schemas-microsoft-com:office:office";
            vmlns = "urn:schemas-microsoft-com:vml";
            relationshipsns = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
        }
        /// <summary>
        /// Inserts a watermark text inside a document
        /// </summary>
        /// <param name="watermarkText">text to show in the watermark</param>
        /// <param name="diagonalOrientation">specify that the text orientation will be in a diagonal way</param>
        public static OpenXmlPowerToolsDocument InsertWatermark
                                                    (
                                                        WmlDocument doc
                                                        , string watermarkText
                                                        , int width
                                                        , int height
                                                        , int rotation
                                                        , string fontFamilyName
                                                        , int fontSize
                                                        , string fillColor
                                                        , int opacityPercent
                                                        //, bool diagonalOrientation
                                                    )
        {
            // "position:absolute;margin-left:0;margin-top:0;width:527.85pt;height:131.95pt;rotation:315;z-index:-251656192;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin";
            diagonalWatermarkStyle = string.Format
                                                (
                                                    @"
                                                        position:absolute;
                                                        margin-left:0;
                                                        margin-top:0;
                                                        width:{0}pt;
                                                        height:{1}pt;
                                                        rotation:{2};
                                                        z-index:-251656192;
                                                        mso-position-horizontal:center;
                                                        mso-position-horizontal-relative:margin;
                                                        mso-position-vertical:center;
                                                        mso-position-vertical-relative:margin
                                                    "
                                                    , width
                                                    , height
                                                    , rotation
                                                );
            fontFamilySizeStyle = string.Format
                                            (
                                                @"
                                                    font-family:&quot;{0}&quot;
                                                    ;
                                                    font-size:{1}pt
                                                "
                                                , fontFamilyName
                                                , fontSize
                                            );
            opacity = opacityPercent;
            //diagonalWatermarkStyle="position:absolute;margin-left:0;margin-top:0;width:527.85pt;height:131.95pt;rotation:315;z-index:-251656192;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin";
            //defaultWatermarkStyle =  "position:absolute;margin-left:0;margin-top:0;width:468pt;        height:117pt;                    z-index:-251652096;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin";
            using (OpenXmlMemoryStreamDocument streamDoc = new OpenXmlMemoryStreamDocument(doc))
            {
                using (WordprocessingDocument document = streamDoc.GetWordprocessingDocument())
                {
                    Collection<XDocument> headers = new Collection<XDocument>();
                    if (HeaderAccessor.GetHeaderReference(document, HeaderType.First, 0) == null)
                        headers.Add(HeaderAccessor.AddNewHeader(document, HeaderType.First));
                    else
                        headers.Add(HeaderAccessor.GetHeader(document, HeaderType.First, 0));
                    if (HeaderAccessor.GetHeaderReference(document, HeaderType.Even, 0) == null)
                        headers.Add(HeaderAccessor.AddNewHeader(document, HeaderType.Even));
                    else
                        headers.Add(HeaderAccessor.GetHeader(document, HeaderType.Even, 0));
                    if (HeaderAccessor.GetHeaderReference(document, HeaderType.Default, 0) == null)
                        headers.Add(HeaderAccessor.AddNewHeader(document, HeaderType.Default));
                    else
                        headers.Add(HeaderAccessor.GetHeader(document, HeaderType.Default, 0));
                    foreach (XDocument header in headers)
                    {
                        var runElement = header.Descendants(ns + "r").FirstOrDefault();
                        if (runElement == null)
                        {
                            header.Root.Add(
                                new XElement(ns + "sdt",
                                    new XElement(ns + "sdtContent",
                                        new XElement(ns + "p",
                                            new XElement(ns + "pPr",
                                                new XElement(ns + "pStyle",
                                                    new XAttribute(ns + "val", "Header")
                                                )
                                            ),
                                            runElement = new XElement(ns + "r")
                                        )
                                    )
                                )
                            );
                        }
                        runElement.AddBeforeSelf(CreateWatermarkVml(watermarkText));
                    }
                    HeaderAccessor.GetHeaderPart(document, HeaderType.First, 0).PutXDocument();
                    HeaderAccessor.GetHeaderPart(document, HeaderType.Even, 0).PutXDocument();
                    HeaderAccessor.GetHeaderPart(document, HeaderType.Default, 0).PutXDocument();
                }
                return streamDoc.GetModifiedDocument();
            }
        }
        /// <summary>
        /// Creates the markup for watermark displaying
        /// </summary>
        /// <param name="watermarkText">Text to include in markup</param>
        /// <param name="diagonalOrientation">Orientation of text</param>
        /// <returns>Watermark markup</returns>
        private static XElement CreateWatermarkVml(string watermarkText)
        {
                return new XElement(ns + "r",
                    new XElement(ns + "pict",
                        new XElement(vmlns + "shapetype",
                            new XAttribute("id", "_x0000_t136"),
                            new XAttribute("coordsize", "21600,21600"),
                            new XAttribute(officens + "spt", "136"),
                            new XAttribute("adj", "10800"),
                            new XAttribute("path", "m@7,l@8,m@5,21600l@6,21600e"),
                            new XElement(vmlns + "formulas",
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "sum #0 0 10800")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "prod #0 2 1")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "sum 21600 0 @1")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "sum 0 0 @2")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "sum 21600 0 @3")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "if @0 @3 0")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "if @0 21600 @1")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "if @0 0 @2")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "if @0 @4 21600")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "mid @5 @6")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "mid @8 @5")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "mid @7 @8")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "mid @6 @7")
                                ),
                                new XElement(vmlns + "f",
                                    new XAttribute("eqn", "sum @6 0 @5")
                                )
                            ),
                            new XElement(vmlns + "path",
                                new XAttribute("textpathok", "t"),
                                new XAttribute(officens + "connecttype", "custom"),
                                new XAttribute(officens + "connectlocs", "@9,0;@10,10800;@11,21600;@12,10800"),
                                new XAttribute(officens + "connectangles", "270,180,90,0")
                            ),
                            new XElement(vmlns + "textpath",
                                new XAttribute("on", "t"),
                                new XAttribute("fitshape", "t")
                            ),
                            new XElement(vmlns + "handles",
                                new XElement(vmlns + "h",
                                    new XAttribute("position", "#0,bottomRight"),
                                    new XAttribute("xrange", "6629,14971")
                                )
                            ),
                            new XElement(officens + "lock",
                                new XAttribute(vmlns + "ext", "edit"),
                                new XAttribute("text", "t"),
                                new XAttribute("shapetype", "t")
                            )
                        ),
                        new XElement(vmlns + "shape",
                            new XAttribute("id", "PowerPlusWaterMarkObject98078923"),
                            new XAttribute(officens + "spid", "_x0000_s2055"),
                            new XAttribute("type", "#_x0000_t136"),
                            //new XAttribute("style", diagonalOrientation ? diagonalWatermarkStyle : defaultWatermarkStyle),
                            new XAttribute("style", diagonalWatermarkStyle),
                            new XAttribute(officens + "allowincell", "f"),
                            new XAttribute("fillcolor", fillColor),
                            new XAttribute("stroked", "f"),
                            new XElement(vmlns + "fill",
                                new XAttribute("opacity", opacity/100.0)
                            ),
                            new XElement(vmlns + "textpath",
                                new XAttribute("style", fontFamilySizeStyle),
                                new XAttribute("string", watermarkText)
                            )
                        )
                    )
                );
        }
        /// <summary>
        /// Gets the text related to watermark from a document
        /// </summary>
        /// <returns>Watermark text</returns>
        public static string GetWatermarkText(WmlDocument doc)
        {
            IEnumerable<XElement> watermarkDescription = GetWatermark(doc);
            if (watermarkDescription != null)
                return
                    watermarkDescription
                    .Descendants(vmlns + "shape")
                    .Descendants(vmlns + "textpath")
                    .First()
                    .Attribute("string")
                    .Value;
            else
                return string.Empty;
        }
        /// <summary>
        /// Gets the document structure related to watermark description
        /// </summary>
        /// <returns>Document structure related to watermark description</returns>
        public static IEnumerable<XElement> GetWatermark(WmlDocument doc)
        {
            using (OpenXmlMemoryStreamDocument streamDoc = new OpenXmlMemoryStreamDocument(doc))
            using (WordprocessingDocument document = streamDoc.GetWordprocessingDocument())
            {
                //  to get the watermark text, we have to look inside the document
                //  get the default header reference and get the header reference id part
                XElement defaultHeaderReference = HeaderAccessor.GetHeaderReference(document, HeaderType.Default, 0);
                if (defaultHeaderReference != null)
                {
                    string headerReferenceId = defaultHeaderReference.Attribute(relationshipsns + "id").Value;
                    OpenXmlPart headerPart = document.MainDocumentPart.GetPartById(headerReferenceId);
                    if (headerPart != null)
                    {
                        XDocument headerPartXml = headerPart.GetXDocument();
                        return headerPartXml.Descendants(ns + "pict");
                    }
                }
                return null;
            }
        }
    }
}

本文链接

DES, TripleDES and BlowFish in Silverlight

2011-11-10T17:47:00Z


/*
DES, TripleDES and BlowFish in Silverlight
*/
namespace BroccoliProducts
{
    using System;
    using System.Collections.Generic;
    #if DEBUG
    using System.Diagnostics;
    #endif // #if DEBUG
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Security.Cryptography;
    /// <summary>
    /// Declaration of DESCrytography class
    /// </summary>
    public static class DESCrytography
    {
        /////////////////////////////////////////////////////////////
        // Nested classes
        /// <summary>
        /// Declaration of BLOCK8BYTE class
        /// </summary>
        internal class BLOCK8BYTE
        {
            /////////////////////////////////////////////////////////
            // Constants
            public const int BYTE_LENGTH = 8;
            /////////////////////////////////////////////////////////
            // Attributes
            internal byte[] m_data = new byte[BYTE_LENGTH];
            /////////////////////////////////////////////////////////
            // Operations
            public void Reset()
            {
                // Reset bytes
                Array.Clear(m_data, 0, BYTE_LENGTH);
            }
            public void Set(BLOCK8BYTE Source)
            {
                // Copy source data to this
                this.Set(Source.m_data,0);
            }
            public void Set(byte[] buffer, int iOffset)
            {
                // Set contents by copying array
                Array.Copy(buffer, iOffset, m_data, 0, BYTE_LENGTH);
            }
            public void Xor(BLOCK8BYTE A, BLOCK8BYTE B)
            {
                // Set byte to A ^ B
                for (int iOffset = 0; iOffset < BYTE_LENGTH; iOffset++)
                    m_data[iOffset] = Convert.ToByte( A.m_data[iOffset] ^ B.m_data[iOffset] );
            }
            public void SetBit(int iByteOffset, int iBitOffset, bool bFlag)
            {
                // Compose mask
                byte mask = Convert.ToByte(1 << iBitOffset);
                if (((m_data[iByteOffset] & mask) == mask) != bFlag)
                    m_data[iByteOffset] ^= mask;
            }
            public bool GetBit(int iByteOffset, int iBitOffset)
            {
                // call sibling function
                return ((this.m_data[iByteOffset] >> iBitOffset) & 0x01) == 0x01;
            }
            public void ShiftLeftWrapped( BLOCK8BYTE S, int iBitShift )
            {
                // this shift is only applied to the first 32 bits, and parity bit is ignored
                // Declaration of local variables
                int iByteOffset = 0;
                bool bBit = false;
                // Copy byte and shift regardless
                for (iByteOffset = 0; iByteOffset < 4; iByteOffset++)
                    m_data[iByteOffset] = Convert.ToByte((S.m_data[iByteOffset] << iBitShift) & 0xFF);
                // if shifting by 1...
                if (iBitShift == 1)
                {
                    // repair bits on right of BYTE
                    for (iByteOffset = 0; iByteOffset < 3; iByteOffset++)
                    {
                        // get repairing bit offsets
                        bBit = S.GetBit( iByteOffset + 1, 7 );
                        this.SetBit(iByteOffset, 1, bBit);
                    }
                    // wrap around the final bit
                    this.SetBit(3,1,S.GetBit(0,7));
                }
                else if (iBitShift == 2)
                {
                    // repair bits on right of BYTE
                    for (iByteOffset = 0; iByteOffset < 3; iByteOffset++)
                    {
                        // get repairing bit offsets
                        bBit = S.GetBit(iByteOffset + 1, 7);
                        this.SetBit(iByteOffset, 2, bBit);
                        bBit = S.GetBit(iByteOffset + 1, 6);
                        this.SetBit(iByteOffset, 1, bBit);
                    }
                    // wrap around the final bit
                    this.SetBit(3, 2, S.GetBit(0, 7));
                    this.SetBit(3, 1, S.GetBit(0, 6));
                }
#if DEBUG
                else
                    Debug.Assert(false);
#endif // #if DEBUG
            }
        }
        /// <summary>
        /// Declaration of KEY_SET class
        /// </summary>
        internal class KEY_SET
        {
            /////////////////////////////////////////////////////////
            // Constants
            public const int KEY_COUNT = 17;
            /////////////////////////////////////////////////////////
            // Attributes
            internal BLOCK8BYTE[] m_array;
            /////////////////////////////////////////////////////////
            // Construction
            internal KEY_SET()
            {
                // Create array
                m_array = new BLOCK8BYTE[KEY_COUNT];
                for (int i1 = 0; i1 < KEY_COUNT; i1++)
                    m_array[i1] = new BLOCK8BYTE();
            }
            /////////////////////////////////////////////////////////
            // Operations
            public BLOCK8BYTE GetAt(int iArrayOffset)
            {
                return m_array[iArrayOffset];
            }
        }
        /// <summary>
        /// Declaration of WORKING_SET class
        /// </summary>
        internal class WORKING_SET
        {
            /////////////////////////////////////////////////////////
            // Attributes
            internal BLOCK8BYTE IP = new BLOCK8BYTE();
            internal BLOCK8BYTE[] Ln = new BLOCK8BYTE[17];
            internal BLOCK8BYTE[] Rn = new BLOCK8BYTE[17];
            internal BLOCK8BYTE RnExpand = new BLOCK8BYTE();
            internal BLOCK8BYTE XorBlock = new BLOCK8BYTE();
            internal BLOCK8BYTE SBoxValues = new BLOCK8BYTE();
            internal BLOCK8BYTE f = new BLOCK8BYTE();
            internal BLOCK8BYTE X = new BLOCK8BYTE();
            internal BLOCK8BYTE DataBlockIn = new BLOCK8BYTE();
            internal BLOCK8BYTE DataBlockOut = new BLOCK8BYTE();
            internal BLOCK8BYTE DecryptXorBlock = new BLOCK8BYTE();
            /////////////////////////////////////////////////////////
            // Construction
            internal WORKING_SET()
            {
                // Build the arrays
                for (int i1 = 0; i1 < 17; i1++)
                {
                    Ln[i1] = new BLOCK8BYTE();
                    Rn[i1] = new BLOCK8BYTE();
                }
            }
            /////////////////////////////////////////////////////////
            // Operations
            internal void Scrub()
            {
                // Scrub data
                IP.Reset();
                for (int i1 = 0; i1 < 17; i1++)
                {
                    Ln[i1].Reset();
                    Rn[i1].Reset();
                }
                RnExpand.Reset();
                XorBlock.Reset();
                SBoxValues.Reset();
                f.Reset();
                X.Reset();
                DataBlockIn.Reset();
                DataBlockOut.Reset();
                DecryptXorBlock.Reset();
            }
        }
        /////////////////////////////////////////////////////////////
        // Constants
        public const int KEY_BYTE_LENGTH = 8;
        public const int BITS_PER_BYTE = 8;
        /////////////////////////////////////////////////////////////
        #region DES Tables
        /* PERMUTED CHOICE 1 (PCl) */
        private static byte[] bytePC1 = {    
            57,    49,    41,    33,    25,    17,     9,
            1,    58,    50,    42,    34,    26,    18,
            10,     2,    59,    51,    43,    35,    27,
            19,    11,     3,    60,    52,    44,    36,
            63,    55,    47,    39,    31,    23,    15,
            7,    62,    54,    46,    38,    30,    22,
            14,     6,    61,    53,    45,    37,    29,
            21,    13,     5,    28,    20,    12,     4,
        };
        /* PERMUTED CHOICE 2 (PC2) */
        private static byte[] bytePC2 = {    
            14,    17,    11,    24,     1,     5, 
            3,    28,    15,     6,    21,    10, 
            23,    19,    12,     4,    26,     8, 
            16,     7,    27,    20,    13,     2, 
            41,    52,    31,    37,    47,    55, 
            30,    40,    51,    45,    33,    48, 
            44,    49,    39,    56,    34,    53, 
            46,    42,    50,    36,    29,    32, 
        };
        /* INITIAL PERMUTATION (IP) */
        private static byte[] byteIP =    {    
            58,    50,    42,    34,    26,    18,    10,     2,    
            60,    52,    44,    36,    28,    20,    12,     4,    
            62,    54,    46,    38,    30,    22,    14,     6,    
            64,    56,    48,    40,    32,    24,    16,     8,    
            57,    49,    41,    33,    25,    17,     9,     1,    
            59,    51,    43,    35,    27,    19,    11,     3,    
            61,    53,    45,    37,    29,    21,    13,     5,    
            63,    55,    47,    39,    31,    23,    15,     7
        };
        /* REVERSE FINAL PERMUTATION (IP-1) */
        private static byte[] byteRFP =    {     
            40,  8,   48,    16,    56,   24,    64,   32,
            39,  7,   47,    15,    55,   23,    63,   31,
            38,  6,   46,    14,    54,   22,    62,   30,
            37,  5,   45,    13,    53,   21,    61,   29,
            36,  4,   44,    12,    52,   20,    60,   28,
            35,  3,   43,    11,    51,   19,    59,   27,
            34,  2,   42,    10,    50,   18,    58,   26,
            33,  1,   41,     9,    49,   17,    57,   25,
        };
        /* E BIT-SELECTION TABLE */
        private static byte[] byteE = {    
            32,     1,     2,     3,     4,     5,    
            4,     5,     6,     7,     8,     9,    
            8,     9,    10,    11,    12,    13,    
            12,    13,    14,    15,    16,    17,    
            16,    17,    18,    19,    20,    21,    
            20,    21,    22,    23,    24,    25,    
            24,    25,    26,    27,    28,    29,    
            28,    29,    30,    31,    32,     1
        };
        /* PERMUTATION FUNCTION P */
        private static byte[] byteP = {    
            16,     7,    20,    21,    
            29,    12,    28,    17,    
            1,    15,    23,    26,    
            5,    18,    31,    10,    
            2,     8,    24,    14,    
            32,    27,     3,     9,    
            19,    13,    30,     6,    
            22,    11,     4,    25
        };
        // Schedule of left shifts for C and D blocks
        private static byte[] byteShifts = { 1,    1,    2,    2,    2,    2,    2,    2,    1,    2,    2,    2,    2,    2,    2,    1 };
        // S-Boxes
        private static byte[,] byteSBox = new byte[,] {
            {14,  4, 13,  1,     2,    15,    11,     8, 3, 10,  6, 12,     5,     9,     0,     7},
            { 0, 15,  7,  4,    14,     2,    13,     1, 10,  6, 12, 11,     9,     5,     3,     8},
            { 4,  1, 14,  8,    13,     6,     2,    11,    15, 12,  9,  7,     3,    10,     5,     0},    
            {15, 12,  8,  2, 4,     9,     1,     7,      5, 11,  3, 14,    10,     0,     6,    13},
            {15, 1,     8,    14,     6,    11,     3,     4,     9, 7,     2,    13,    12,     0,     5,    10},    
            {3,    13,     4,     7,    15,     2,     8,    14,    12, 0,     1,    10,     6,     9,    11,     5},    
            {0,    14,     7,    11,    10,     4,    13,     1,    5, 8,    12,     6,     9,     3,     2,    15},    
            {13, 8,    10,     1,     3,    15,     4,     2,    11, 6,     7,    12,     0,     5,    14,     9},
            {10,     0,     9,    14,     6,     3,    15,     5,     1,    13,    12,     7,    11,     4,     2,     8},    
            {13,     7,     0,     9,     3,     4,     6,    10,     2,     8,     5,    14,    12,    11,    15,     1},    
            {13,     6,     4,     9,     8,    15,     3,     0,    11,     1,     2,    12,     5,    10,    14,     7},    
            {1,    10,    13,     0,     6,     9,     8,     7,     4,    15,    14,     3,    11,     5,     2,    12},    
            {7,    13,    14,     3,     0,     6,     9,    10,     1,     2,     8,     5,    11,    12,     4,    15},    
            {13,     8,    11,     5,     6,    15,     0,     3,     4,     7,     2,    12,     1,    10,    14,     9},    
            {10,     6,     9,     0,    12,    11,     7,    13,    15,     1,     3,    14,     5,     2,     8,     4},    
            {3,    15,     0,     6,    10,     1,    13,     8,    9,     4,     5,    11,    12,     7,     2,    14},    
            {2,    12,     4,     1,     7,    10,    11,    6,    8,     5,     3,    15,    13,     0,    14,     9},    
            {14,    11,     2,    12,     4,     7,    13,     1,    5,     0,    15,    10,     3,     9,     8,     6},    
            {4,     2,     1,    11,    10,    13,     7,     8,15,     9,    12,     5,     6,     3,     0,    14},    
            {11,     8,    12,     7,     1,    14,     2,    13,    6,    15,     0,     9,    10,     4,     5,     3},    
            {12,     1,    10,    15,     9,     2,     6,     8,0,    13,     3,     4,    14,     7,     5,    11},    
            {10,    15,     4,     2,     7,    12,     9,     5,6,     1,    13,    14,     0,    11,     3,     8},    
            {9,    14,    15,     5,     2,     8,    12,     3,7,     0,     4,    10,     1,    13,    11,     6},    
            {4,     3,     2,    12,     9,     5,    15,    10,11,    14,     1,     7,     6,     0,     8,    13},    
            {4,    11,     2,    14,    15,     0,     8,    13,    3,    12,     9,     7,     5,    10,     6,     1},    
            {13,     0,    11,     7,     4,     9,     1,    10,14,     3,     5,    12,     2,    15,     8,     6},    
            {1,     4,    11,    13,    12,     3,     7,    14,10,    15,     6,     8,     0,     5,     9,     2},    
            {6,    11,    13,     8,     1,     4,    10,     7,9,     5,     0,    15,    14,     2,     3,    12},    
            {13,     2,     8,     4,     6,    15,    11,     1,10,     9,     3,    14,     5,     0,    12,     7},    
            {1,    15,    13,     8,    10,     3,     7,     4,    12,     5,     6,    11,     0,    14,     9,     2},    
            {7,    11,     4,     1,     9,    12,    14,     2,0,     6,    10,    13,    15,     3,     5,     8},    
            {2,     1,    14,     7,     4,    10,     8,    13,15,    12,     9,     0,     3,     5,     6,    11}
        };
        #endregion DES Tables
        /////////////////////////////////////////////////////////////
        #region Static Operations - DES
        public static bool IsValidDESKey(byte[] Key)
        {
            // Shortcuts
            if (Key == null)
                return false;
            if (Key.Length != KEY_BYTE_LENGTH)
                return false;
            if (!IsStrongDESKey(Key))
                return false;
            // Make sure end bits have odd parity
            for (int iByteOffset = 0; iByteOffset < KEY_BYTE_LENGTH; iByteOffset++)
            {
                // Add bits for this byte
                int iTotalBits = 0;
                byte Mask = 1;
                for (int iBitOffset = 0; iBitOffset < BITS_PER_BYTE; iBitOffset++)
                {
                    if ((Key[iByteOffset] & Mask) != 0)
                        iTotalBits++;
                    Mask <<= 1;
                }
                // If the total bits is not odd...
                if ((iTotalBits % 2) != 1)
                    return false;
            }
            // Return success
            return true;
        }
        public static bool IsStrongDESKey(byte[] Key)
        {
            // Compare by large integer
            UInt64 uiKey = BitConverter.ToUInt64(Key,0);
            // Find weak keys...
            if(
                (uiKey == 0x0000000000000000) ||
                (uiKey == 0x00000000FFFFFFFF) ||
                (uiKey == 0xE0E0E0E0F1F1F1F1) ||
                (uiKey == 0x1F1F1F1F0E0E0E0E)
            )
                return false;
            // Find semi-weak keys...
            if(
                (uiKey == 0x011F011F010E010E) ||
                (uiKey == 0x1F011F010E010E01) ||
                (uiKey == 0x01E001E001F101F1) ||
                (uiKey == 0xE001E001F101F101) ||
                (uiKey == 0x01FE01FE01FE01FE) ||
                (uiKey == 0xFE01FE01FE01FE01) ||
                (uiKey == 0x1FE01FE00EF10EF1) ||
                (uiKey == 0xE01FE01FF10EF10E) ||
                (uiKey == 0x1FFE1FFE0EFE0EFE) ||
                (uiKey == 0xFE1FFE1FFE0EFE0E) ||
                (uiKey == 0xE0FEE0FEF1FEF1FE) ||
                (uiKey == 0xFEE0FEE0FEF1FEF1)
            )
                return false;
            // Return success
            return true;
        }
        public static byte[] CreateDesKey(Random rnd)
        {
            // Declare return variable
            byte[] Ftmp = new byte[KEY_BYTE_LENGTH];
            // Fill with random data
            rnd.NextBytes(Ftmp);
            // Make the key good
            Ftmp = MakeGoodDesKey(Ftmp);
#if DEBUG
            Debug.Assert(IsValidDESKey(Ftmp));
#endif // #if DEBUG
            // Call sibling function
            return Ftmp;
        }
        public static byte[] MakeGoodDesKey(byte[] KeyIn)
        {
#if DEBUG
            Debug.Assert(KeyIn != null);
            Debug.Assert(KeyIn.Length == KEY_BYTE_LENGTH);
#endif // #if DEBUG
            // Declare return variable
            byte[] Ftmp = new byte[KEY_BYTE_LENGTH];
            // Loop until key is good
            int iInc = 0;
            while (true)
            {
                // Start with the key data
                Array.Copy(KeyIn, Ftmp, KEY_BYTE_LENGTH);
                // Add the increment
                _incKey(Ftmp, iInc);
                // Make sure end bits have odd parity
                _modifyKeyParity(Ftmp);
                // If key is valid...
                if (IsValidDESKey(Ftmp))
                    break;
                // Move on
                iInc++;
            } // while-loop
            // Return variable
            return Ftmp;
        }
        public static void DES(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt)
        {
            // Shortcuts
            if (!IsValidDESKey(Key))
                throw new Exception("Invalid DES key.");
            // Create the output buffer
            _createBufferOut(bufferIn.Length, ref bufferOut, bEncrypt);
            // Expand the keys into Kn
            KEY_SET[] Kn = new KEY_SET[1] {
                _expandKey(Key, 0)
            };
            // Apply DES keys
            _desAlgorithm(bufferIn, ref bufferOut, Kn, bEncrypt);
            // If decrypting...
            if (!bEncrypt)
                _removePadding(ref bufferOut);
        }
        #endregion Static Operations - DES
        /////////////////////////////////////////////////////////////
        #region Static Operations - TripleDES
        public static bool IsValidTripleDESKey(byte[] Key)
        {
            // Shortcuts
            if (Key == null)
                return false;
            if (Key.Length != (3*KEY_BYTE_LENGTH))
                return false;
            // Check each part of the key
            byte[] SubKey = new byte[KEY_BYTE_LENGTH];
            for( int iKeyLoop=0; iKeyLoop<3; iKeyLoop++ )
            {
                // Get sub-key
                Array.Copy( Key, iKeyLoop*8, SubKey, 0, KEY_BYTE_LENGTH );
                // Check this DES key
                if(!IsValidDESKey(SubKey))
                    return false;
            }
            // Keys must not be equal
            bool bAEqualsB = true;
            bool bAEqualsC = true;
            bool bBEqualsC = true;
            for (int iByteOffset = 0; iByteOffset < KEY_BYTE_LENGTH; iByteOffset++)
            {
                if (Key[iByteOffset] != Key[iByteOffset + KEY_BYTE_LENGTH])
                    bAEqualsB = false;
                if (Key[iByteOffset] != Key[iByteOffset + KEY_BYTE_LENGTH + KEY_BYTE_LENGTH])
                    bAEqualsC = false;
                if (Key[iByteOffset + KEY_BYTE_LENGTH] != Key[iByteOffset + KEY_BYTE_LENGTH + KEY_BYTE_LENGTH])
                    bBEqualsC = false;
            }
            if ((bAEqualsB) || (bAEqualsC) || (bBEqualsC))
                return false;
            // Return success
            return true;
        }
        public static byte[] CreateTripleDesKey(Random rnd)
        {
            // Declare return variable
            byte[] Ftmp = new byte[KEY_BYTE_LENGTH * 3];
            // Fill with random data
            rnd.NextBytes(Ftmp);
            // Make the key good
            Ftmp = MakeGoodTripleDesKey(Ftmp);
            // Check key is valid
#if DEBUG
            Debug.Assert(IsValidTripleDESKey(Ftmp));
#endif // #if DEBUG
            // Call sibling function
            return Ftmp;
        }
        public static byte[] MakeGoodTripleDesKey(byte[] KeyIn)
        {
            // Declare return variable
            byte[] Ftmp = new byte[KEY_BYTE_LENGTH * 3];
            // Declaration of local variables
            int iKey = 0;
            byte[] SubKey = new byte[KEY_BYTE_LENGTH];
            // Loop through key modifications
            int iInc = 0;
            while (true)
            {
                // Start with the key
                Array.Copy(KeyIn, Ftmp, KEY_BYTE_LENGTH * 3);
                // Make sure each part of the key is valid
                for (iKey = 0; iKey < 3; iKey++)
                {
                    // Get the sub-key
                    Array.Copy(Ftmp, iKey * KEY_BYTE_LENGTH, SubKey, 0, KEY_BYTE_LENGTH);
                    // Increment sub-key
                    _incKey(SubKey, iInc * (iKey + 1));
                    // Make the parity valid
                    _modifyKeyParity(SubKey);
                    // Return to the Ftmp
                    Array.Copy(SubKey, 0, Ftmp, iKey * KEY_BYTE_LENGTH, KEY_BYTE_LENGTH);
                }
                // Check the key
                if (IsValidTripleDESKey(Ftmp))
                    break;
                // Move on
                iInc++;
            } // while-loop
            // Return variable
            return Ftmp;
        }
        public static void TripleDES(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt)
        {
            // Shortcuts
            if (!IsValidTripleDESKey(Key))
                throw new Exception("Invalid DES key.");
            // Create the output buffer
            _createBufferOut(bufferIn.Length, ref bufferOut, bEncrypt);
            // Expand the keys into Kn
            KEY_SET[] Kn = new KEY_SET[3] {
                _expandKey(Key, 0),
                _expandKey(Key, 8),
                _expandKey(Key, 16)
            };
            // Apply DES keys
            _desAlgorithm(bufferIn, ref bufferOut, Kn, bEncrypt);
            // If decrypting...
            if (!bEncrypt)
                _removePadding(ref bufferOut);
        }
        #endregion Static Operations - TripleDES
        /////////////////////////////////////////////////////////////
        #region Static Operations
        private static void _incKey(byte[] Key, int iInc)
        {
#if DEBUG
            Debug.Assert(Key.Length == KEY_BYTE_LENGTH);
#endif // #if DEBUG
            // shortcuts
            if (iInc == 0)
                return;
            // Add the increment                
            int iCarry = iInc;
            for (int iByteOffset = 0; iByteOffset < KEY_BYTE_LENGTH; iByteOffset++)
            {
                int iTemp = Key[iByteOffset] + iCarry;
                iCarry = iTemp >> 8;
                Key[iByteOffset] = Convert.ToByte(iTemp & 0xFF);
                if (iCarry == 0)
                    break;
            }
        }
        private static void _modifyKeyParity(byte[] Key)
        {
#if DEBUG
            Debug.Assert(Key.Length == KEY_BYTE_LENGTH);
#endif // #if DEBUG
            // Make sure end bits have odd parity
            for (int iByteOffset = 0; iByteOffset < KEY_BYTE_LENGTH; iByteOffset++)
            {
                // Add bits for this byte
                int iTotalBits = 0;
                byte Mask = 1;
                for (int iBitOffset = 0; iBitOffset < BITS_PER_BYTE; iBitOffset++)
                {
                    if ((Key[iByteOffset] & Mask) != 0)
                        iTotalBits++;
                    Mask <<= 1;
                }
                // If the total bits is not odd...
                if ((iTotalBits % 2) != 1)
                {
                    // Flip the first bit to retain odd parity
                    Key[iByteOffset] ^= 0x01;
                }
            }
        }
        private static KEY_SET _expandKey(byte[] Key, int iOffset)
        {
            //
            // Expand an 8 byte DES key into a set of permuted keys
            //
            // Declare return variable
            KEY_SET Ftmp = new KEY_SET();
            // Declaration of local variables
            int iTableOffset, iArrayOffset, iPermOffset, iByteOffset, iBitOffset;
            bool bBit;
            // Put key into an 8-bit block
            BLOCK8BYTE K = new BLOCK8BYTE();
            K.Set(Key, iOffset);
            // Permutate Kp with PC1
            BLOCK8BYTE Kp = new BLOCK8BYTE();
            for (iArrayOffset = 0; iArrayOffset < bytePC1.Length; iArrayOffset++)
            {
                // Get permute offset
                iPermOffset = bytePC1[iArrayOffset];
                iPermOffset--;
                // Get and set bit
                Kp.SetBit(
                    _bitAddressToByteOffset(iArrayOffset, 7), 
                    _bitAddressToBitOffset(iArrayOffset, 7), 
                    K.GetBit(
                        _bitAddressToByteOffset(iPermOffset, 8), 
                        _bitAddressToBitOffset(iPermOffset, 8)
                    )
                );
            }
            // Create 17 blocks of C and D from Kp
            BLOCK8BYTE[] KpCn = new BLOCK8BYTE[17];
            BLOCK8BYTE[] KpDn = new BLOCK8BYTE[17];
            for (iArrayOffset = 0; iArrayOffset < 17; iArrayOffset++)
            {
                KpCn[iArrayOffset] = new BLOCK8BYTE();
                KpDn[iArrayOffset] = new BLOCK8BYTE();
            }
            for (iArrayOffset = 0; iArrayOffset < 32; iArrayOffset++)
            {
                // Set bit in KpCn
                iByteOffset = _bitAddressToByteOffset(iArrayOffset, 8);
                iBitOffset = _bitAddressToBitOffset(iArrayOffset, 8);
                bBit = Kp.GetBit(iByteOffset, iBitOffset);
                KpCn[0].SetBit(iByteOffset, iBitOffset, bBit);
                // Set bit in KpDn
                bBit = Kp.GetBit(iByteOffset + 4, iBitOffset);
                KpDn[0].SetBit(iByteOffset, iBitOffset, bBit);
            }
            for (iArrayOffset = 1; iArrayOffset < 17; iArrayOffset++)
            {
                // Shift left wrapped
                KpCn[iArrayOffset].ShiftLeftWrapped(KpCn[iArrayOffset - 1], byteShifts[iArrayOffset - 1]);
                KpDn[iArrayOffset].ShiftLeftWrapped(KpDn[iArrayOffset - 1], byteShifts[iArrayOffset - 1]);
            }
            // Create 17 keys Kn
            for (iArrayOffset = 0; iArrayOffset < 17; iArrayOffset++)
            {
                // Loop through the bits
                for (iTableOffset = 0; iTableOffset < 48; iTableOffset++)
                {
                    // Get address if bit
                    iPermOffset = bytePC2[iTableOffset];
                    iPermOffset--;
                    // Convert to byte and bit offsets
                    iByteOffset = _bitAddressToByteOffset(iPermOffset, 7);
                    iBitOffset = _bitAddressToBitOffset(iPermOffset, 7);
                    // Get bit
                    if (iByteOffset < 4)
                        bBit = KpCn[iArrayOffset].GetBit(iByteOffset, iBitOffset);
                    else
                        bBit = KpDn[iArrayOffset].GetBit(iByteOffset - 4, iBitOffset);
                    // Set bit
                    iByteOffset = _bitAddressToByteOffset(iTableOffset, 6);
                    iBitOffset = _bitAddressToBitOffset(iTableOffset, 6);
                    Ftmp.GetAt(iArrayOffset).SetBit(iByteOffset, iBitOffset, bBit);
                }
            }
            // Return variable
            return Ftmp;
        }
        private static void _createBufferOut( int iBufferInLength, ref byte[] bufferOut, bool bEncrypt )
        {
            //
            // Create a buffer for the output, which may be trimmed later
            //
            // If encrypting...
            int iOutputLength;
            if (bEncrypt)
            {
                if ((iBufferInLength % KEY_BYTE_LENGTH) != 0)
                    iOutputLength = ((iBufferInLength / KEY_BYTE_LENGTH) + 1) * KEY_BYTE_LENGTH;
                else
                    iOutputLength = iBufferInLength + KEY_BYTE_LENGTH;
            }
            else
            {
                if (iBufferInLength < 8)
                    throw new Exception("DES cypher-text must be at least 8 bytes.");
                if ((iBufferInLength % 8) != 0)
                    throw new Exception("DES cypher-text must be a factor of 8 bytes in length.");
                iOutputLength = iBufferInLength;
            }
            // Create buffer
            if ((bufferOut == null) || (bufferOut.Length != iOutputLength))
                bufferOut = new byte[iOutputLength];
            else
                Array.Clear(bufferOut, 0, bufferOut.Length);
        }
        private static void _removePadding(ref byte[] bufferOut)
        {
            //
            // Remove the padding after decrypting
            //
            // Get the padding...
            byte Padding = bufferOut[bufferOut.Length - 1];
            if ((Padding == 0) || (Padding > 8))
                throw new Exception("Invalid padding on DES data.");
            // Confirm padding
            bool bPaddingOk = true;
            for (int iByteOffset = 1; iByteOffset < Padding; iByteOffset++)
            {
                if (bufferOut[bufferOut.Length - 1 - iByteOffset] != Padding)
                {
                    bPaddingOk = false;
                    break;
                }
            }
            if (bPaddingOk)
            {
                // Chop off the padding
                Array.Resize(ref bufferOut, bufferOut.Length - Padding);
            }
            else
                throw new Exception("Invalid padding on DES data.");
        }
        private static void _desAlgorithm(byte[] bufferIn, ref byte[] bufferOut, KEY_SET[] KeySets, bool bEncrypt)
        {
            //
            // Apply the DES algorithm to each block
            //
            // Declare a workset set of variables
            WORKING_SET workingSet = new WORKING_SET();
            // encode/decode blocks
            int iBufferPos = 0;
            while (true)
            {
                // Check buffer position
                if (bEncrypt)
                {
                    // If end of buffer...
                    if (iBufferPos >= bufferOut.Length)
                        break;
                    // Calulate remaining bytes
                    int iRemainder = (bufferIn.Length - iBufferPos);
                    if (iRemainder >= 8)
                        workingSet.DataBlockIn.Set(bufferIn, iBufferPos);
                    else
                    {
                        // Copy part-block
                        workingSet.DataBlockIn.Reset();
                        if (iRemainder > 0)
                            Array.Copy(bufferIn, iBufferPos, workingSet.DataBlockIn.m_data, 0, iRemainder);
                        // Get the padding byte
                        byte Padding = Convert.ToByte(KEY_BYTE_LENGTH - iRemainder);
                        // Add padding to block
                        for (int iByteOffset = iRemainder; iByteOffset < KEY_BYTE_LENGTH; iByteOffset++)
                            workingSet.DataBlockIn.m_data[iByteOffset] = Padding;
                    }
                }
                else
                {
                    // If end of buffer...
                    if (iBufferPos >= bufferIn.Length)
                        break;
                    // Get the next block
                    workingSet.DataBlockIn.Set(bufferIn, iBufferPos);
                }
                // if encrypting and not the first block...
                if ((bEncrypt) && (iBufferPos > 0))
                {
                    // Apply succession => XOR M with previous block
                    workingSet.DataBlockIn.Xor(workingSet.DataBlockOut, workingSet.DataBlockIn);
                }
                // Apply the algorithm
                workingSet.DataBlockOut.Set(workingSet.DataBlockIn);
                _lowLevel_desAlgorithm(workingSet, KeySets, bEncrypt);
                // If decrypting...
                if (!bEncrypt)
                {
                    // Retain the succession
                    if (iBufferPos > 0)
                        workingSet.DataBlockOut.Xor(workingSet.DecryptXorBlock, workingSet.DataBlockOut);
                    // Retain the last block
                    workingSet.DecryptXorBlock.Set(workingSet.DataBlockIn);
                }
                // Update buffer out
                Array.Copy(workingSet.DataBlockOut.m_data, 0, bufferOut, iBufferPos, 8);
                // Move on
                iBufferPos += 8;
            }
            // Scrub the working set
            workingSet.Scrub();
        }
        private static void _lowLevel_desAlgorithm(WORKING_SET workingSet, KEY_SET[] KeySets, bool bEncrypt)
        {
            //
            // Apply 1 or 3 keys to a block of data
            //
            // Declaration of local variables
            int iTableOffset;
            int iArrayOffset;
            int iPermOffset;
            int iByteOffset;
            int iBitOffset;
            // Loop through keys
            for (int iKeySetOffset = 0; iKeySetOffset < KeySets.Length; iKeySetOffset++)
            {
                // Permute with byteIP
                workingSet.IP.Reset();
                for (iTableOffset = 0; iTableOffset < byteIP.Length; iTableOffset++)
                {
                    // Get perm offset
                    iPermOffset = byteIP[iTableOffset];
                    iPermOffset--;
                    // Get and set bit
                    workingSet.IP.SetBit(
                        _bitAddressToByteOffset(iTableOffset, 8),
                        _bitAddressToBitOffset(iTableOffset, 8),
                        workingSet.DataBlockOut.GetBit(
                            _bitAddressToByteOffset(iPermOffset, 8),
                            _bitAddressToBitOffset(iPermOffset, 8)
                        )
                    );
                }
                // Create Ln[0] and Rn[0]
                workingSet.Ln[0].Reset();
                workingSet.Rn[0].Reset();
                for (iArrayOffset = 0; iArrayOffset < 32; iArrayOffset++)
                {
                    iByteOffset = _bitAddressToByteOffset(iArrayOffset, 8);
                    iBitOffset = _bitAddressToBitOffset(iArrayOffset, 8);
                    workingSet.Ln[0].SetBit(iByteOffset, iBitOffset, workingSet.IP.GetBit(iByteOffset, iBitOffset));
                    workingSet.Rn[0].SetBit(iByteOffset, iBitOffset, workingSet.IP.GetBit(iByteOffset + 4, iBitOffset));
                }
                // Loop through 17 interations
                for (int iBlockOffset = 1; iBlockOffset < 17; iBlockOffset++)
                {
                    // Get the array offset
                    int iKeyOffset;
                    if (bEncrypt != (iKeySetOffset == 1))
                        iKeyOffset = iBlockOffset;
                    else
                        iKeyOffset = 17 - iBlockOffset;
                    // Set Ln[N] = Rn[N-1]
                    workingSet.Ln[iBlockOffset].Set(workingSet.Rn[iBlockOffset - 1]);
                    // Set Rn[N] = Ln[0] + f(R[N-1],K[N])
                    for (iTableOffset = 0; iTableOffset < byteE.Length; iTableOffset++)
                    {
                        // Get perm offset
                        iPermOffset = byteE[iTableOffset];
                        iPermOffset--;
                        // Get and set bit
                        workingSet.RnExpand.SetBit(
                            _bitAddressToByteOffset(iTableOffset, 6),
                            _bitAddressToBitOffset(iTableOffset, 6),
                            workingSet.Rn[iBlockOffset - 1].GetBit(
                                _bitAddressToByteOffset(iPermOffset, 8),
                                _bitAddressToBitOffset(iPermOffset, 8)
                            )
                        );
                    }
                    // XOR expanded block with K-block
                    if (bEncrypt != (iKeySetOffset == 1))
                        workingSet.XorBlock.Xor(workingSet.RnExpand, KeySets[iKeySetOffset].GetAt(iKeyOffset));
                    else
                        workingSet.XorBlock.Xor(workingSet.RnExpand, KeySets[KeySets.Length - 1 - iKeySetOffset].GetAt(iKeyOffset));
                    // Set S-Box values
                    workingSet.SBoxValues.Reset();
                    for (iTableOffset = 0; iTableOffset < 8; iTableOffset++)
                    {
                        // Calculate m and n
                        int m = ((workingSet.XorBlock.GetBit(iTableOffset, 7) ? 1 : 0) << 1) | (workingSet.XorBlock.GetBit(iTableOffset, 2) ? 1 : 0);
                        int n = (workingSet.XorBlock.m_data[iTableOffset] >> 3) & 0x0F;
                        // Get s-box value
                        iPermOffset = byteSBox[(iTableOffset * 4) + m, n];
                        workingSet.SBoxValues.m_data[iTableOffset] = (byte)(iPermOffset << 4);
                    }
                    // Permute with P -> f
                    workingSet.f.Reset();
                    for (iTableOffset = 0; iTableOffset < byteP.Length; iTableOffset++)
                    {
                        // Get perm offset
                        iPermOffset = byteP[iTableOffset];
                        iPermOffset--;
                        // Get and set bit
                        workingSet.f.SetBit(
                            _bitAddressToByteOffset(iTableOffset, 4),
                            _bitAddressToBitOffset(iTableOffset, 4),
                            workingSet.SBoxValues.GetBit(
                                _bitAddressToByteOffset(iPermOffset, 4),
                                _bitAddressToBitOffset(iPermOffset, 4)
                            )
                        );
                    }
                    // Rn[N] = Ln[N-1] ^ f
                    workingSet.Rn[iBlockOffset].Reset();
                    for (iTableOffset = 0; iTableOffset < 8; iTableOffset++)
                    {
                        // Get Ln[N-1] -> A
                        byte A = workingSet.Ln[iBlockOffset - 1].m_data[(iTableOffset >> 1)];
                        if ((iTableOffset % 2) == 0)
                            A >>= 4;
                        else
                            A &= 0x0F;
                        // Get f -> B
                        byte B = Convert.ToByte(workingSet.f.m_data[iTableOffset] >> 4);
                        // Update Rn[N]
                        if ((iTableOffset % 2) == 0)
                            workingSet.Rn[iBlockOffset].m_data[iTableOffset >> 1] |= Convert.ToByte((A ^ B) << 4);
                        else
                            workingSet.Rn[iBlockOffset].m_data[iTableOffset >> 1] |= Convert.ToByte(A ^ B);
                    }
                }
                // X = R16 L16
                workingSet.X.Reset();
                for (iTableOffset = 0; iTableOffset < 4; iTableOffset++)
                {
                    workingSet.X.m_data[iTableOffset] = workingSet.Rn[16].m_data[iTableOffset];
                    workingSet.X.m_data[iTableOffset + 4] = workingSet.Ln[16].m_data[iTableOffset];
                }
                // C = X perm IP
                workingSet.DataBlockOut.Reset();
                for (iTableOffset = 0; iTableOffset < byteRFP.Length; iTableOffset++)
                {
                    // Get perm offset
                    iPermOffset = byteRFP[iTableOffset];
                    iPermOffset--;
                    // Get and set bit
                    workingSet.DataBlockOut.SetBit(
                        _bitAddressToByteOffset(iTableOffset, 8),
                        _bitAddressToBitOffset(iTableOffset, 8),
                        workingSet.X.GetBit(
                            _bitAddressToByteOffset(iPermOffset, 8),
                            _bitAddressToBitOffset(iPermOffset, 8)
                        )
                    );
                }
            } // key loop
        }
        #endregion Static Operations
        /////////////////////////////////////////////////////////////
        // Helper Operations
        private static int _bitAddressToByteOffset(int iTableAddress, int iTableWidth)
        {
            int iFtmp = iTableAddress / iTableWidth;
            return iFtmp;
        }
        private static int _bitAddressToBitOffset(int iTableAddress, int iTableWidth)
        {
            int iFtmp = BITS_PER_BYTE - 1 - (iTableAddress % iTableWidth);
            return iFtmp;
        }
        /////////////////////////////////////////////////////////////
        #region Debug Operations
#if DEBUG
#if !SILVERLIGHT
        private static void MicrosoftDESEncrypt(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt, bool bDESMode)
        {
            // Declaration of key and IV
            byte[] bufferTemp = new byte[1024];
            byte[] IV;
            if(bDESMode)
                IV = new byte[8];
            else
                IV = new byte[8*3];
            // Declare a crypto object
            ICryptoTransform crypto;
            if (bDESMode)
            {
                DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                des.Padding = PaddingMode.PKCS7;
                if (bEncrypt)
                    crypto = des.CreateEncryptor(Key, IV);
                else
                    crypto = des.CreateDecryptor(Key, IV);
            }
            else
            {
                TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider();
                tripleDes.Padding = PaddingMode.PKCS7;
                if (bEncrypt)
                    crypto = tripleDes.CreateEncryptor(Key, IV);
                else
                    crypto = tripleDes.CreateDecryptor(Key, IV);
            }            
            //  a memory stream for the cyrpto
            using(MemoryStream ms = new MemoryStream())
            {
                // Create a CryptoStream using the memory stream
                using (CryptoStream encStream = new CryptoStream(ms, crypto, CryptoStreamMode.Write))
                {
                    // Encrypt/decrypt and flush
                    encStream.Write(bufferIn, 0, bufferIn.Length);
                    encStream.Flush();
                    encStream.FlushFinalBlock();
                    encStream.Close();
                    // Get the data into a buffer
                    bufferOut = ms.ToArray();
                }
            }
        }
#endif // #if !SILVERLIGHT
#endif // #if DEBUG
#if DEBUG
#if !SILVERLIGHT
        public static void _assertBufferMatch(byte[] A, byte[] B)
        {
            // Compare outputs
            Debug.Assert(A.Length == B.Length);
            for (int iOffset = 0; iOffset < A.Length; iOffset++)
                Debug.Assert(A[iOffset] == B[iOffset]);
        }
#endif // #if !SILVERLIGHT
#endif // #if DEBUG
#if DEBUG
#if !SILVERLIGHT
        public static void Test()
        {
            //
            // This function encrypts and encrypts data using our DES algorithm, and 
            // ensures the results are the same as the Microsoft algorithm with default padding settings.
            //
            // Declaration of local variables
            Random rnd = new Random(1);
            byte[] DesKey, Des3Key;
            byte[] plainText = null, cypherText = null, plainText2 = null, msCypherText = null, msPlainText2 = null;
            // Compare the DES algorithm with the Microsoft algorithm
            for (int iTest = 0; iTest < 100*1000; iTest++)
            {
                // Dump progress
                if ((iTest % 200) == 0)
                    Trace.TraceInformation("Test {0}", iTest);
                // Generate test data
                DesKey = DESCrytography.CreateDesKey(rnd);
                Des3Key = DESCrytography.CreateTripleDesKey(rnd);
                int iLength = rnd.Next(0, 256);
                if ((plainText == null) || (plainText.Length != iLength))
                    plainText = new byte[iLength];
                rnd.NextBytes(plainText);
                // DES Test
                {
                    // Encrypt using our algorithm
                    DESCrytography.DES(plainText, ref cypherText, DesKey, true);
                    // Decrypt using our algorithm
                    DESCrytography.DES(cypherText, ref plainText2, DesKey, false);
                    // Compare outputs
                    _assertBufferMatch(plainText,plainText2);
                    // Encrypt using Microsoft algorithm
                    MicrosoftDESEncrypt(plainText, ref msCypherText, DesKey, true, true);
                    // Decrypt using Microsoft algorithm
                    MicrosoftDESEncrypt(msCypherText, ref msPlainText2, DesKey, false, true);
                    // Compare outputs
                    _assertBufferMatch(plainText, msPlainText2);
                    // Make sure Microsoft and our algorithms are the same
                    _assertBufferMatch(cypherText, msCypherText);
                }
                // TripleDES Test
                {
                    // Encrypt using our algorithm
                    DESCrytography.TripleDES(plainText, ref cypherText, Des3Key, true);
                    // Decrypt using our algorithm
                    DESCrytography.TripleDES(cypherText, ref plainText2, Des3Key, false);
                    // Compare outputs
                    _assertBufferMatch(plainText, plainText2);
                    // Encrypt using Microsoft algorithm
                    MicrosoftDESEncrypt(plainText, ref msCypherText, Des3Key, true, false);
                    // Decrypt using Microsoft algorithm
                    MicrosoftDESEncrypt(msCypherText, ref msPlainText2, Des3Key, false, false);
                    // Compare outputs
                    _assertBufferMatch(plainText, msPlainText2);
                    // Make sure Microsoft and our algorithms are the same
                    _assertBufferMatch(cypherText, msCypherText);
                }
            } // for-loop
        }
#endif // #if !SILVERLIGHT
#endif // #if DEBUG
        #endregion Debug Operations
    }
}
namespace BroccoliProducts
{
    using System;
    using System.Collections.Generic;
    #if DEBUG
    using System.Diagnostics;
    #endif // #if DEBUG
    using System.IO;
    using System.Linq;
    using System.Runtime.InteropServices;
    using System.Security.Cryptography;
    using System.Text;
    /// <summary>
    /// Declaration of BlowFishCrytography class
    /// </summary>
    public static class BlowFishCrytography
    {
        /////////////////////////////////////////////////////////////
        // Constants
        public const int BLOWFISH_BLOCK_LENGTH = 8;
        public const int MIN_KEY_BYTE_LENGTH = 4;
        public const int MAX_KEY_BYTE_LENGTH = 56;
        /////////////////////////////////////////////////////////////
        #region BlowFish Tables
        private const int PTABLE_LENGTH    = 18;    
        private const int STABLE_LENGTH0 = 4;
        private const int STABLE_LENGTH1 = 256;
        private static uint[] BLOWFISH_PTABLE = 
        {
            0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
            0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
            0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b
        };
        private static uint[] BLOWFISH_SBOX0 = 
        {
            0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
            0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
            0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658,
            0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
            0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e,
            0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
            0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6,
            0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
            0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c,
            0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
            0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1,
            0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
            0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a,
            0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
            0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176,
            0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
            0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706,
            0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
            0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b,
            0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
            0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c,
            0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
            0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a,
            0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
            0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760,
            0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
            0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8,
            0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
            0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33,
            0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
            0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0,
            0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
            0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777,
            0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
            0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705,
            0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
            0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e,
            0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
            0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9,
            0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
            0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f,
            0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
            0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
        };
        private static uint[] BLOWFISH_SBOX1 = 
        {
            0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d,
            0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
            0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65,
            0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
            0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9,
            0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
            0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d,
            0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
            0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc,
            0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
            0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908,
            0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
            0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124,
            0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
            0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908,
            0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
            0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b,
            0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
            0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa,
            0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
            0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d,
            0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
            0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5,
            0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
            0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96,
            0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
            0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca,
            0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
            0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77,
            0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
            0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054,
            0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
            0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea,
            0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
            0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646,
            0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
            0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea,
            0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
            0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e,
            0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
            0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd,
            0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
            0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
        };
        private static uint[] BLOWFISH_SBOX2 = 
        {
            0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7,
            0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
            0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af,
            0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
            0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4,
            0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
            0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec,
            0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
            0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332,
            0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
            0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58,
            0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
            0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22,
            0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
            0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60,
            0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
            0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99,
            0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
            0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74,
            0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
            0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3,
            0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
            0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
            0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
            0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa,
            0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
            0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086,
            0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
            0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24,
            0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
            0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84,
            0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
            0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
            0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
            0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe,
            0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
            0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0,
            0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
            0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188,
            0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
            0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8,
            0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
            0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
        };
        private static uint[] BLOWFISH_SBOX3 = 
        {
            0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742,
            0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
            0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79,
            0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
            0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a,
            0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
            0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1,
            0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
            0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797,
            0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
            0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6,
            0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
            0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba,
            0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
            0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5,
            0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
            0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce,
            0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
            0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd,
            0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
            0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb,
            0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
            0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc,
            0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
            0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc,
            0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
            0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a,
            0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
            0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a,
            0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
            0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b,
            0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
            0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e,
            0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
            0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623,
            0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
            0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a,
            0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
            0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3,
            0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
            0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c,
            0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
            0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
        };
        private static uint[][] BLOWFISH_STABLE = { BLOWFISH_SBOX0, BLOWFISH_SBOX1, BLOWFISH_SBOX2, BLOWFISH_SBOX3 };
        #endregion BlowFish Tables
        /////////////////////////////////////////////////////////////
        // Structures
        [StructLayout(LayoutKind.Explicit)]
        struct DWORD_SPLITTER
        {
            /////////////////////////////////////////////////////////
            // Attributes
            [FieldOffset(0)]
            public uint dw;
            [FieldOffset(0)]
            public UInt16 highWord;
            [FieldOffset(2)]
            public UInt16 lowWord;
            [FieldOffset(0)]
            public byte byte3;
            [FieldOffset(1)]
            public byte byte2;
            [FieldOffset(2)]
            public byte byte1;
            [FieldOffset(3)]
            public byte byte0;
            /////////////////////////////////////////////////////////
            // Operations
            public void FromBuffer( byte[] buffer, int iOffset )
            {
                byte0 = buffer[iOffset];
                byte1 = buffer[iOffset+1];
                byte2 = buffer[iOffset+2];
                byte3 = buffer[iOffset+3];
            }
            public void ToBuffer( byte[] buffer, int iOffset )
            {
                buffer[iOffset] = byte0;
                buffer[iOffset+1] = byte1;
                buffer[iOffset+2] = byte2;
                buffer[iOffset+3] = byte3;
            }
        }
        /////////////////////////////////////////////////////////////
        // Operations
        public static bool IsValidBlowFishKey(byte[] Key)
        {
            // Check buffer
            if (Key == null)
                return false;
            if( (Key.Length < MIN_KEY_BYTE_LENGTH) || (Key.Length > MAX_KEY_BYTE_LENGTH) )
                return false;
            if((Key.Length % 4)!=0)
                return false;
            // Return success
            return true;
        }
        public static byte[] CreateBlowFishKey(Random rnd,int iKeyLength)
        {
            // Shortcuts
            if (
                (iKeyLength < MIN_KEY_BYTE_LENGTH) 
                || 
                (iKeyLength > MAX_KEY_BYTE_LENGTH)
                ||
                ((iKeyLength % 4) != 0)
            )
                throw new Exception("Invalid BlowFish key length.");
            // Declare return variable
            byte[] Ftmp = new byte[iKeyLength];
            // Populate the key
            rnd.NextBytes(Ftmp);
            // Return success
            return Ftmp;
        }
        public static void BlowFishWithPadding(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt)
        {
            //
            // Use the same padding that .Net uses for the DES crypto-provider
            //
            // If encrypting...
            if (bEncrypt)
            {
                // Create the buffer out
                int iBufferOut = ((bufferIn.Length / BLOWFISH_BLOCK_LENGTH) + 1) * BLOWFISH_BLOCK_LENGTH;
                _softCreateBuffer(ref bufferOut, iBufferOut);
                Array.Copy(bufferIn, bufferOut, bufferIn.Length);
                // Add the padding
                int iPadding = bufferOut.Length - bufferIn.Length;
#if DEBUG
                Debug.Assert(iPadding > 0);
                Debug.Assert(iPadding <= 8);
#endif // #if DEBUG
                byte Padding = Convert.ToByte(iPadding);
                for (int i1 = 0; i1 < iPadding; i1++)
                    bufferOut[bufferIn.Length + i1] = Padding;
            }
            else
            {
                // Create the buffer out
                int iBufferOut = bufferIn.Length;
                _softCreateBuffer(ref bufferOut, iBufferOut);
                Array.Copy(bufferIn, bufferOut, bufferIn.Length);
            }
            // Call sibling function
            _blowFish(bufferOut, Key, bEncrypt);
            // If decrypting...
            if (!bEncrypt)
            {
                // Get the padding byte
                byte Padding = bufferOut[bufferOut.Length - 1];
                if ((Padding < 1) || (Padding > 8))
                    throw new Exception("Invalid padding in BlowFish cypher-text.");
                for (byte A = 0; A < Padding; A++)
                {
                    if(bufferOut[bufferOut.Length - 1 - A] != Padding)
                        throw new Exception("Invalid padding in BlowFish cypher-text.");
                }
                // Trim off the extra
                Array.Resize(ref bufferOut, bufferOut.Length - Padding);
            }
        }
        public static void BlowFish(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt)
        {
            // Shortcuts
            if(bufferIn == null)
                throw new Exception("Invalid data into BlowFish algorithm");
            if(bufferIn.Length==0)
                throw new Exception("Missing data in BlowFish algorithm");
            if((bufferIn.Length % BLOWFISH_BLOCK_LENGTH)!=0)
                throw new Exception("Invalid length of data into BlowFish algorithm");
            // check key
            if(!IsValidBlowFishKey(Key))
                throw new Exception("BlowFish key is invalid");
            // Create the buffer-out
            _softCreateBuffer(ref bufferOut, bufferIn.Length);
            Array.Copy(bufferIn, bufferOut, bufferIn.Length);
            // Call sibling function to apply algorithm
            _blowFish(bufferOut, Key, bEncrypt);
        }
        public static void _blowFish(byte[] buffer, byte[] Key, bool bEncrypt)
        {
#if DEBUG
            Debug.Assert(buffer != null);
            Debug.Assert(buffer.Length > 0);
            Debug.Assert((buffer.Length % BLOWFISH_BLOCK_LENGTH) == 0);
            Debug.Assert(IsValidBlowFishKey(Key));
#endif // #if DEBUG
            // Declaration of local variables
            DWORD_SPLITTER xl = new DWORD_SPLITTER();
            DWORD_SPLITTER xr = new DWORD_SPLITTER();
            byte[] PreviousBlock = new byte[8];
            // Create tables
            uint[] PTable;
            uint[,] STable;
            _createTables(Key, out PTable, out STable);
            // If encrypting...
            if (bEncrypt)
            {
                // loop through the buffer
                int iBufferPos = 0;
                while (iBufferPos < buffer.Length)
                {
                    // If not the first block, xor with previous
                    if (iBufferPos > 0)
                        _xor(buffer, iBufferPos, PreviousBlock, 0, 8);
                    // encipher 8 byte chunk                    
                    xl.FromBuffer(buffer, iBufferPos);
                    xr.FromBuffer(buffer, iBufferPos + 4);
                    _encipher8ByteChunk(ref xl, ref xr, PTable, STable, true);
                    xl.ToBuffer(buffer, iBufferPos);
                    xr.ToBuffer(buffer, iBufferPos + 4);
                    // Retain this as previous block
                    Array.Copy(buffer, iBufferPos, PreviousBlock, 0, 8);
                    // move on
                    iBufferPos += BLOWFISH_BLOCK_LENGTH;
                }
            }
            else
            {
                // loop through the buffer
                int iBufferPos = 0;
                byte[] CurrentBlock = new byte[8];
                while (iBufferPos < buffer.Length)
                {
                    // Retain the current raw block
                    Array.Copy(buffer, iBufferPos, CurrentBlock, 0, 8);
                    // encipher 8 byte chunk                    
                    xl.FromBuffer(buffer, iBufferPos);
                    xr.FromBuffer(buffer, iBufferPos + 4);
                    _encipher8ByteChunk(ref xl, ref xr, PTable, STable, false);
                    xl.ToBuffer(buffer, iBufferPos);
                    xr.ToBuffer(buffer, iBufferPos + 4);
                    // If not the first block...
                    if(iBufferPos > 0)
                        _xor(buffer, iBufferPos, PreviousBlock, 0, 8);
                    // Retain the previous block
                    Array.Copy(CurrentBlock, 0, PreviousBlock, 0, 8);
                    // move on
                    iBufferPos += BLOWFISH_BLOCK_LENGTH;
                }
            }
        }
        private static void _xor(byte[] TargetBuffer, int iTargetPos, byte[] OperatorBuffer, int iOperatorPos, int iLength)
        {
            // Loop through length
            for (int i1 = 0; i1 < iLength; i1++)
                TargetBuffer[iTargetPos + i1] ^= OperatorBuffer[iOperatorPos + i1];
        }
        private static void _softCreateBuffer(ref byte[] buffer, int iLength)
        {
            // Create or extend buffer
            if (buffer == null)
                buffer = new byte[iLength];
            else
                Array.Resize(ref buffer, iLength);
        }
        private static void _createTables(byte[] Key, out uint[] PTable, out uint[,] STable)
        {
            // declaration of local variables
            int i1, i2;
            // Stuff the P and S tables
            PTable = new uint[BLOWFISH_PTABLE.Length];
            for (i1 = 0; i1 < PTABLE_LENGTH; i1++)
            {
                PTable[i1] = BLOWFISH_PTABLE[i1];
            }
            STable = new uint[STABLE_LENGTH0,STABLE_LENGTH1];
            for (i1 = 0; i1 < 4; i1++)
            {
                for (i2 = 0; i2 < 256; i2++)
                    STable[i1, i2] = BLOWFISH_STABLE[i1][i2];
            }
            // update the P-Table
            int iKeyPos = 0;
            DWORD_SPLITTER dw = new DWORD_SPLITTER();
            for( i1=0; i1 < PTABLE_LENGTH; ++i1 ) 
            {
                // compose word
                dw.dw = 0;
                dw.byte0 = Key[iKeyPos];
                dw.byte1 = Key[(iKeyPos + 1) % Key.Length];
                dw.byte2 = Key[(iKeyPos + 2) % Key.Length];
                dw.byte3 = Key[(iKeyPos + 3) % Key.Length];
                uint data = dw.dw;
                // update P-Table
                PTable[i1] = PTable[i1] ^ data;
                // increment position
                iKeyPos = (iKeyPos + 4) % Key.Length;
            }
            // encipher P-Table values
            DWORD_SPLITTER Left = new DWORD_SPLITTER();
            DWORD_SPLITTER Right = new DWORD_SPLITTER();
            for( i1=0; i1<PTABLE_LENGTH; i1+=2 )
            {
                // encipher
                _encipher8ByteChunk(ref Left, ref Right, PTable, STable, true);
                // update P-Table
                PTable[i1] = Left.dw;
                PTable[i1 + 1] = Right.dw;
            }
            // encipher the S-Table values
            for( i1=0; i1<4; ++i1 )
            {
                for( i2=0; i2<256; i2+=2 ) 
                {
                    // encipher
                    _encipher8ByteChunk(ref Left, ref Right, PTable, STable, true);
                    // update S-Table
                    STable[i1,i2] = Left.dw;
                    STable[i1,i2 + 1] = Right.dw;
                }
            }
        }
        private static void _encipher8ByteChunk(ref DWORD_SPLITTER xl, ref DWORD_SPLITTER xr, uint[] PTable, uint[,] STable, bool bEncrypt)
        {
            // If encrypting...
            if(bEncrypt)
            {
                xl.dw ^= PTable[0];
                xr.dw ^= _f(xl,STable) ^ PTable[1];        xl.dw ^= _f(xr, STable) ^ PTable[2];
                xr.dw ^= _f(xl,STable) ^ PTable[3];        xl.dw ^= _f(xr, STable) ^ PTable[4];
                xr.dw ^= _f(xl,STable) ^ PTable[5];        xl.dw ^= _f(xr, STable) ^ PTable[6];    
                xr.dw ^= _f(xl,STable) ^ PTable[7];        xl.dw ^= _f(xr, STable) ^ PTable[8];
                xr.dw ^= _f(xl,STable) ^ PTable[9];        xl.dw ^= _f(xr, STable) ^ PTable[10];
                xr.dw ^= _f(xl,STable) ^ PTable[11];    xl.dw ^= _f(xr, STable) ^ PTable[12];
                xr.dw ^= _f(xl,STable) ^ PTable[13];    xl.dw ^= _f(xr, STable) ^ PTable[14];
                xr.dw ^= _f(xl,STable) ^ PTable[15];    xl.dw ^= _f(xr, STable) ^ PTable[16];
                xr.dw ^= PTable[17];
            }
            else
            {
                xl.dw ^= PTable[17];
                xr.dw ^= _f(xl,STable) ^ PTable[16];    xl.dw ^= _f(xr, STable) ^ PTable[15];
                xr.dw ^= _f(xl,STable) ^ PTable[14];    xl.dw ^= _f(xr, STable) ^ PTable[13];
                xr.dw ^= _f(xl,STable) ^ PTable[12];    xl.dw ^= _f(xr, STable) ^ PTable[11];
                xr.dw ^= _f(xl,STable) ^ PTable[10];    xl.dw ^= _f(xr, STable) ^ PTable[9];
                xr.dw ^= _f(xl,STable) ^ PTable[8];        xl.dw ^= _f(xr, STable) ^ PTable[7];
                xr.dw ^= _f(xl,STable) ^ PTable[6];        xl.dw ^= _f(xr, STable) ^ PTable[5];
                xr.dw ^= _f(xl,STable) ^ PTable[4];        xl.dw ^= _f(xr, STable) ^ PTable[3];
                xr.dw ^= _f(xl,STable) ^ PTable[2];        xl.dw ^= _f(xr, STable) ^ PTable[1];
                xr.dw ^= PTable[0];
            }
            // Swap over xl and xr
            uint dwTemp = xl.dw;
            xl.dw = xr.dw;
            xr.dw = dwTemp;
        }
        private static uint _f(DWORD_SPLITTER x, uint[,] STable)
        {
            return (((STable[0, x.byte0] + STable[1, x.byte1]) ^ STable[2, x.byte2]) + STable[3, x.byte3]);
        }
        /////////////////////////////////////////////////////////////
        // Operations - Debug
#region Test Vectors
#if DEBUG
        // Test Keys
        private static ulong[] TestKeys = {
            0x0000000000000000,
            0xFFFFFFFFFFFFFFFF,
            0x3000000000000000,
            0x1111111111111111,
            0x0123456789ABCDEF,
            0x1111111111111111,
            0x0000000000000000,
            0xFEDCBA9876543210,
            0x7CA110454A1A6E57,
            0x0131D9619DC1376E,
            0x07A1133E4A0B2686,
            0x3849674C2602319E,
            0x04B915BA43FEB5B6,
            0x0113B970FD34F2CE,
            0x0170F175468FB5E6,
            0x43297FAD38E373FE,
            0x07A7137045DA2A16,
            0x04689104C2FD3B2F,
            0x37D06BB516CB7546,
            0x1F08260D1AC2465E,
            0x584023641ABA6176,
            0x025816164629B007,
            0x49793EBC79B3258F,
            0x4FB05E1515AB73A7,
            0x49E95D6D4CA229BF,
            0x018310DC409B26D6,
            0x1C587F1C13924FEF,
            0x0101010101010101,
            0x1F1F1F1F0E0E0E0E,
            0xE0FEE0FEF1FEF1FE,
            0x0000000000000000,
            0xFFFFFFFFFFFFFFFF,
            0x0123456789ABCDEF,
            0xFEDCBA9876543210
        };
        private static ulong[] TestPlainText = {
            0x0000000000000000,
            0xFFFFFFFFFFFFFFFF,
            0x1000000000000001,
            0x1111111111111111,
            0x1111111111111111,
            0x0123456789ABCDEF,
            0x0000000000000000,
            0x0123456789ABCDEF,
            0x01A1D6D039776742,
            0x5CD54CA83DEF57DA,
            0x0248D43806F67172,
            0x51454B582DDF440A,
            0x42FD443059577FA2,
            0x059B5E0851CF143A,
            0x0756D8E0774761D2,
            0x762514B829BF486A,
            0x3BDD119049372802,
            0x26955F6835AF609A,
            0x164D5E404F275232,
            0x6B056E18759F5CCA,
            0x004BD6EF09176062,
            0x480D39006EE762F2,
            0x437540C8698F3CFA,
            0x072D43A077075292,
            0x02FE55778117F12A,
            0x1D9D5C5018F728C2,
            0x305532286D6F295A,
            0x0123456789ABCDEF,
            0x0123456789ABCDEF,
            0x0123456789ABCDEF,
            0xFFFFFFFFFFFFFFFF,
            0x0000000000000000,
            0x0000000000000000,
            0xFFFFFFFFFFFFFFFF 
        };
        private static ulong[] TestCypherText = {
            0x4EF997456198DD78,
            0x51866FD5B85ECB8A,
            0x7D856F9A613063F2,
            0x2466DD878B963C9D,
            0x61F9C3802281B096,
            0x7D0CC630AFDA1EC7,
            0x4EF997456198DD78,
            0x0ACEAB0FC6A0A28D,
            0x59C68245EB05282B,
            0xB1B8CC0B250F09A0,
            0x1730E5778BEA1DA4,
            0xA25E7856CF2651EB,
            0x353882B109CE8F1A,
            0x48F4D0884C379918,
            0x432193B78951FC98,
            0x13F04154D69D1AE5,
            0x2EEDDA93FFD39C79,
            0xD887E0393C2DA6E3,
            0x5F99D04F5B163969,
            0x4A057A3B24D3977B,
            0x452031C1E4FADA8E,
            0x7555AE39F59B87BD,
            0x53C55F9CB49FC019,
            0x7A8E7BFA937E89A3,
            0xCF9C5D7A4986ADB5,
            0xD1ABB290658BC778,
            0x55CB3774D13EF201,
            0xFA34EC4847B268B2,
            0xA790795108EA3CAE,
            0xC39E072D9FAC631D,
            0x014933E0CDAFF6E4,
            0xF21E9A77B71C49BC,
            0x245946885754369A,
            0x6B5C5A9C5D9E0A5A 
        };
#endif // #if DEBUG
    #endregion Test Vectors
#if DEBUG
#if !SILVERLIGHT
        public static void _assertBufferMatch(byte[] A, byte[] B)
        {
            // Compare outputs
            Debug.Assert(A.Length == B.Length);
            for (int iOffset = 0; iOffset < A.Length; iOffset++)
                Debug.Assert(A[iOffset] == B[iOffset]);
        }
#endif // #if !SILVERLIGHT
#endif // #if DEBUG
#if DEBUG
        public static void Test()
        {
            // Declaration of local variables
            Random rnd = new Random(1);
            byte[] Key = null;
            byte[] bufferIn = null;
            byte[] bufferOut = null;
            byte[] bufferReturned = null;
            // Loop through the test vectors
            for (int iTest = 0; iTest < TestKeys.Length; iTest++)
            {
                // Load the key and plain-text
                Key = BitConverter.GetBytes(TestKeys[iTest]).Reverse().ToArray();
                bufferIn = BitConverter.GetBytes(TestPlainText[iTest]).Reverse().ToArray();
                // Encrypt with BlowFish
                BlowFishCrytography.BlowFish(bufferIn, ref bufferOut, Key, true);
                // Compare with expected result
                byte[] expectedBufferOut = BitConverter.GetBytes(TestCypherText[iTest]).Reverse().ToArray();
                _assertBufferMatch(expectedBufferOut,bufferOut);
            }
            // Loop through decrypt-encrypt tests
            for (int iTest = 0; iTest < 100*1000; iTest++)
            {
                // Dump progress
                if ((iTest % 100) == 0)
                    Trace.TraceInformation("Test {0}", iTest);
                // Load the key and plain-text
                Key = CreateBlowFishKey(rnd, MAX_KEY_BYTE_LENGTH);
                // Create a buffer of data
                int iLength = rnd.Next(1, 10*1024);
                _softCreateBuffer(ref bufferIn, iLength);
                rnd.NextBytes(bufferIn);
                // Encrypt with BlowFish
                BlowFishCrytography.BlowFishWithPadding(bufferIn, ref bufferOut, Key, true);
                // Decrypt with BlowFish
                BlowFishCrytography.BlowFishWithPadding(bufferOut, ref bufferReturned, Key, false);
                // Compare buffers
                _assertBufferMatch(bufferIn, bufferReturned);
            }
        }
#endif // #if DEBUG
    }
}

本文链接

HMAC MD5 http://hmacmd5.codeplex.com HMAC-MD5 for .NET 4.0, SL4 and WP7 Silverlight Windows Phone

2011-11-10T17:28:00Z


//-----------------------------------------------------------------------
// <copyright file="MD5.cs" company="Microsoft Corporation">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <author>Reid Borsuk and Jenny Zheng</author>
//-----------------------------------------------------------------------
namespace xBrainLab.Security.Cryptography
{
    using System;
    using System.Text;

    ////  **************************************************************
    ////  * Raw implementation of the MD5 hash algorithm
    ////  * from RFC 1321.
    ////  *
    ////  * Written By: Reid Borsuk and Jenny Zheng
    ////  * Copyright (c) Microsoft Corporation.  All rights reserved.
    ////  **************************************************************

    /// <summary>
    /// Simple struct for the (a,b,c,d) which is used to compute the mesage digest.    
    /// </summary>
    struct ABCDStruct
    {
        public uint A;
        public uint B;
        public uint C;
        public uint D;
    }

    /// <summary>
    /// Raw implementation of the MD5 hash algorithm rom RFC 1321.
    /// </summary>
    public sealed class MD5
    {
        //// Prevent CSC from adding a default public constructor
        private MD5() { }

        public static byte[] GetHash(string input, Encoding encoding)
        {
            if (null == input)
            {
                throw new System.ArgumentNullException("input", "Unable to calculate hash over null input data");
            }
            if (null == encoding)
            {
                throw new System.ArgumentNullException("encoding", "Unable to calculate hash over a string without a default encoding. Consider using the GetHash(string) overload to use UTF8 Encoding");
            }
            byte[] target = encoding.GetBytes(input);
            return GetHash(target);
        }

        public static byte[] GetHash(string input)
        {
            return GetHash(input, new UTF8Encoding());
        }

        public static string GetHashString(byte[] input)
        {
            if (null == input)
            {
                throw new System.ArgumentNullException("input", "Unable to calculate hash over null input data");
            }
            string retval = BitConverter.ToString(GetHash(input));
            retval = retval.Replace("-", string.Empty);
            return retval;
        }

        public static string GetHashString(string input, Encoding encoding)
        {
            if (null == input)
            {
                throw new System.ArgumentNullException("input", "Unable to calculate hash over null input data");
            }
            if (null == encoding)
            {
                throw new System.ArgumentNullException("encoding", "Unable to calculate hash over a string without a default encoding. Consider using the GetHashString(string) overload to use UTF8 Encoding");
            }
            byte[] target = encoding.GetBytes(input);
            return GetHashString(target);
        }

        public static string GetHashString(string input)
        {
            return GetHashString(input, new UTF8Encoding());
        }

        public static byte[] GetHash(byte[] input)
        {
            if (null == input)
            {
                throw new System.ArgumentNullException("input", "Unable to calculate hash over null input data");
            }

            //// Intitial values defined in RFC 1321
            ABCDStruct abcd = new ABCDStruct();
            abcd.A = 0x67452301;
            abcd.B = 0xefcdab89;
            abcd.C = 0x98badcfe;
            abcd.D = 0x10325476;

            //// We pass in the input array by block, the final block of data must be handled specialy for padding & length embeding
            int startIndex = 0;
            while (startIndex <= input.Length - 64)
            {
                MD5.GetHashBlock(input, ref abcd, startIndex);
                startIndex += 64;
            }
            ////  The final data block. 
            return MD5.GetHashFinalBlock(input, startIndex, input.Length - startIndex, abcd, (Int64)input.Length * 8);
        }

        internal static byte[] GetHashFinalBlock(byte[] input, int ibStart, int cbSize, ABCDStruct ABCD, Int64 len)
        {
            byte[] working = new byte[64];
            byte[] length = BitConverter.GetBytes(len);

            //// Padding is a single bit 1, followed by the number of 0s required to make size congruent to 448 modulo 512. Step 1 of RFC 1321  
            //// The CLR ensures that our buffer is 0-assigned, we don't need to explicitly set it. This is why it ends up being quicker to just
            //// use a temporary array rather then doing in-place assignment (5% for small inputs)
            Array.Copy(input, ibStart, working, 0, cbSize);
            working[cbSize] = 0x80;

            //// We have enough room to store the length in this chunk
            if (cbSize < 56)
            {
                Array.Copy(length, 0, working, 56, 8);
                GetHashBlock(working, ref ABCD, 0);
            }
            else  //// We need an aditional chunk to store the length
            {
                GetHashBlock(working, ref ABCD, 0);
                //// Create an entirely new chunk due to the 0-assigned trick mentioned above, to avoid an extra function call clearing the array
                working = new byte[64];
                Array.Copy(length, 0, working, 56, 8);
                GetHashBlock(working, ref ABCD, 0);
            }
            byte[] output = new byte[16];
            Array.Copy(BitConverter.GetBytes(ABCD.A), 0, output, 0, 4);
            Array.Copy(BitConverter.GetBytes(ABCD.B), 0, output, 4, 4);
            Array.Copy(BitConverter.GetBytes(ABCD.C), 0, output, 8, 4);
            Array.Copy(BitConverter.GetBytes(ABCD.D), 0, output, 12, 4);
            return output;
        }

        ////  Performs a single block transform of MD5 for a given set of ABCD inputs
        /* If implementing your own hashing framework, be sure to set the initial ABCD correctly according to RFC 1321:
        //    A = 0x67452301;
        //    B = 0xefcdab89;
        //    C = 0x98badcfe;
        //    D = 0x10325476;
        */
        internal static void GetHashBlock(byte[] input, ref ABCDStruct ABCDValue, int ibStart)
        {
            uint[] temp = Converter(input, ibStart);
            uint a = ABCDValue.A;
            uint b = ABCDValue.B;
            uint c = ABCDValue.C;
            uint d = ABCDValue.D;

            a = r1(a, b, c, d, temp[0], 7, 0xd76aa478);
            d = r1(d, a, b, c, temp[1], 12, 0xe8c7b756);
            c = r1(c, d, a, b, temp[2], 17, 0x242070db);
            b = r1(b, c, d, a, temp[3], 22, 0xc1bdceee);
            a = r1(a, b, c, d, temp[4], 7, 0xf57c0faf);
            d = r1(d, a, b, c, temp[5], 12, 0x4787c62a);
            c = r1(c, d, a, b, temp[6], 17, 0xa8304613);
            b = r1(b, c, d, a, temp[7], 22, 0xfd469501);
            a = r1(a, b, c, d, temp[8], 7, 0x698098d8);
            d = r1(d, a, b, c, temp[9], 12, 0x8b44f7af);
            c = r1(c, d, a, b, temp[10], 17, 0xffff5bb1);
            b = r1(b, c, d, a, temp[11], 22, 0x895cd7be);
            a = r1(a, b, c, d, temp[12], 7, 0x6b901122);
            d = r1(d, a, b, c, temp[13], 12, 0xfd987193);
            c = r1(c, d, a, b, temp[14], 17, 0xa679438e);
            b = r1(b, c, d, a, temp[15], 22, 0x49b40821);

            a = r2(a, b, c, d, temp[1], 5, 0xf61e2562);
            d = r2(d, a, b, c, temp[6], 9, 0xc040b340);
            c = r2(c, d, a, b, temp[11], 14, 0x265e5a51);
            b = r2(b, c, d, a, temp[0], 20, 0xe9b6c7aa);
            a = r2(a, b, c, d, temp[5], 5, 0xd62f105d);
            d = r2(d, a, b, c, temp[10], 9, 0x02441453);
            c = r2(c, d, a, b, temp[15], 14, 0xd8a1e681);
            b = r2(b, c, d, a, temp[4], 20, 0xe7d3fbc8);
            a = r2(a, b, c, d, temp[9], 5, 0x21e1cde6);
            d = r2(d, a, b, c, temp[14], 9, 0xc33707d6);
            c = r2(c, d, a, b, temp[3], 14, 0xf4d50d87);
            b = r2(b, c, d, a, temp[8], 20, 0x455a14ed);
            a = r2(a, b, c, d, temp[13], 5, 0xa9e3e905);
            d = r2(d, a, b, c, temp[2], 9, 0xfcefa3f8);
            c = r2(c, d, a, b, temp[7], 14, 0x676f02d9);
            b = r2(b, c, d, a, temp[12], 20, 0x8d2a4c8a);

            a = r3(a, b, c, d, temp[5], 4, 0xfffa3942);
            d = r3(d, a, b, c, temp[8], 11, 0x8771f681);
            c = r3(c, d, a, b, temp[11], 16, 0x6d9d6122);
            b = r3(b, c, d, a, temp[14], 23, 0xfde5380c);
            a = r3(a, b, c, d, temp[1], 4, 0xa4beea44);
            d = r3(d, a, b, c, temp[4], 11, 0x4bdecfa9);
            c = r3(c, d, a, b, temp[7], 16, 0xf6bb4b60);
            b = r3(b, c, d, a, temp[10], 23, 0xbebfbc70);
            a = r3(a, b, c, d, temp[13], 4, 0x289b7ec6);
            d = r3(d, a, b, c, temp[0], 11, 0xeaa127fa);
            c = r3(c, d, a, b, temp[3], 16, 0xd4ef3085);
            b = r3(b, c, d, a, temp[6], 23, 0x04881d05);
            a = r3(a, b, c, d, temp[9], 4, 0xd9d4d039);
            d = r3(d, a, b, c, temp[12], 11, 0xe6db99e5);
            c = r3(c, d, a, b, temp[15], 16, 0x1fa27cf8);
            b = r3(b, c, d, a, temp[2], 23, 0xc4ac5665);

            a = r4(a, b, c, d, temp[0], 6, 0xf4292244);
            d = r4(d, a, b, c, temp[7], 10, 0x432aff97);
            c = r4(c, d, a, b, temp[14], 15, 0xab9423a7);
            b = r4(b, c, d, a, temp[5], 21, 0xfc93a039);
            a = r4(a, b, c, d, temp[12], 6, 0x655b59c3);
            d = r4(d, a, b, c, temp[3], 10, 0x8f0ccc92);
            c = r4(c, d, a, b, temp[10], 15, 0xffeff47d);
            b = r4(b, c, d, a, temp[1], 21, 0x85845dd1);
            a = r4(a, b, c, d, temp[8], 6, 0x6fa87e4f);
            d = r4(d, a, b, c, temp[15], 10, 0xfe2ce6e0);
            c = r4(c, d, a, b, temp[6], 15, 0xa3014314);
            b = r4(b, c, d, a, temp[13], 21, 0x4e0811a1);
            a = r4(a, b, c, d, temp[4], 6, 0xf7537e82);
            d = r4(d, a, b, c, temp[11], 10, 0xbd3af235);
            c = r4(c, d, a, b, temp[2], 15, 0x2ad7d2bb);
            b = r4(b, c, d, a, temp[9], 21, 0xeb86d391);

            ABCDValue.A = unchecked(a + ABCDValue.A);
            ABCDValue.B = unchecked(b + ABCDValue.B);
            ABCDValue.C = unchecked(c + ABCDValue.C);
            ABCDValue.D = unchecked(d + ABCDValue.D);
            return;
        }

        //// Manually unrolling these equations nets us a 20% performance improvement
        private static uint r1(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            ////                   (b + LSR((a + F(b, c, d) + x + t), s))
            //// F(x, y, z)        ((x & y) | ((x ^ 0xFFFFFFFF) & z))
            return unchecked(b + LSR((a + ((b & c) | ((b ^ 0xFFFFFFFF) & d)) + x + t), s));
        }

        private static uint r2(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            ////                   (b + LSR((a + G(b, c, d) + x + t), s))
            //// G(x, y, z)        ((x & z) | (y & (z ^ 0xFFFFFFFF)))
            return unchecked(b + LSR((a + ((b & d) | (c & (d ^ 0xFFFFFFFF))) + x + t), s));
        }

        private static uint r3(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            ////                   (b + LSR((a + H(b, c, d) + k + i), s))
            //// H(x, y, z)        (x ^ y ^ z)
            return unchecked(b + LSR((a + (b ^ c ^ d) + x + t), s));
        }

        private static uint r4(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            ////                   (b + LSR((a + I(b, c, d) + k + i), s))
            //// I(x, y, z)        (y ^ (x | (z ^ 0xFFFFFFFF)))
            return unchecked(b + LSR((a + (c ^ (b | (d ^ 0xFFFFFFFF))) + x + t), s));
        }

        ////  Implementation of left rotate
        ////  s is an int instead of a uint becuase the CLR requires the argument passed to >>/<< is of 
        ////  type int. Doing the demoting inside this function would add overhead.
        private static uint LSR(uint i, int s)
        {
            return ((i << s) | (i >> (32 - s)));
        }

        //// Convert input array into array of UInts
        private static uint[] Converter(byte[] input, int ibStart)
        {
            if (null == input)
            {
                throw new System.ArgumentNullException("input", "Unable convert null array to array of uInts");
            }

            uint[] result = new uint[16];
            for (int i = 0; i < 16; i++)
            {
                result[i] = (uint)input[ibStart + i * 4];
                result[i] += (uint)input[ibStart + i * 4 + 1] << 8;
                result[i] += (uint)input[ibStart + i * 4 + 2] << 16;
                result[i] += (uint)input[ibStart + i * 4 + 3] << 24;
            }

            return result;
        }
    }
}
//-----------------------------------------------------------------------
// <copyright file="HMACMD5.cs" company="xBrainLab">
//     Copyright (c) 2011 xBrainLab. All rights reserved.
// </copyright>
// <author>Sebastien Warin</author>
//-----------------------------------------------------------------------
namespace xBrainLab.Security.Cryptography
{
    using System;
    using System.Text;

    /// <summary>
    /// Computes a Hash-based Message Authentication Code (HMAC) using the <see cref="T:xBrainLab.Security.Cryptography.MD5" /> hash function
    /// </summary>
    public sealed class HMACMD5
    {
        private const int BLOCK_SIZE = 64;

        private byte[] m_Key = null;
        private byte[] m_inner = null;
        private byte[] m_outer = null;
        
        /// <summary>
        /// Initializes a new instance of the <see cref="HMACMD5"/> class using the supplied key with UT8 encoding.
        /// </summary>
        /// <param name="key">The key.</param>
        public HMACMD5(string key)
            : this(key, Encoding.UTF8)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HMACMD5"/> class using the supplied key with supplied encoding.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="encoding">The encoding used to read the key.</param>
        public HMACMD5(string key, Encoding encoding)
            : this(encoding.GetBytes(key))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HMACMD5"/> class the supplied key.
        /// </summary>
        /// <param name="key">The key.</param>
        public HMACMD5(byte[] key)
        {
            this.InitializeKey(key);
        }

        /// <summary>
        /// Gets or sets the key.
        /// </summary>
        /// <value>
        /// The key.
        /// </value>
        public byte[] Key
        {
            get 
            {
                return this.m_Key;
            }
            set
            {
                this.InitializeKey(value);
            }
        }

        /// <summary>
        /// Computes the hash value for the specified string (UTF8 default encoding).
        /// </summary>
        /// <param name="buffer">The input to compute the hash code for. </param>
        /// <returns>The computed hash code</returns>
        public byte[] ComputeHash(string buffer)
        {
            return this.ComputeHash(buffer, Encoding.UTF8);
        }

        /// <summary>
        /// Computes the hash value for the specified string.
        /// </summary>
        /// <param name="buffer">The input to compute the hash code for.</param>
        /// <param name="encoding">The encoding.</param>
        /// <returns>
        /// The computed hash code
        /// </returns>
        public byte[] ComputeHash(string buffer, Encoding encoding)
        {
            return this.ComputeHash(encoding.GetBytes(buffer));
        }

        /// <summary>
        /// Computes the hash value for the specified byte array.
        /// </summary>
        /// <param name="buffer">The input to compute the hash code for.</param>
        /// <returns>
        /// The computed hash code
        /// </returns>
        public byte[] ComputeHash(byte[] buffer)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer", "The input cannot be null.");
            }

            return MD5.GetHash(this.Combine(this.m_outer, MD5.GetHash(this.Combine(this.m_inner, buffer))));
        }

        /// <summary>
        /// Computes the hash for the specified string (UTF8 default encoding) to base64 string.
        /// </summary>
        /// <param name="buffer">The input to compute the hash code for.</param>
        /// <returns>The computed hash code in base64 string</returns>
        public string ComputeHashToBase64String(string buffer)
        {
            return Convert.ToBase64String(this.ComputeHash(buffer, Encoding.UTF8));
        }

        /// <summary>
        /// Computes the hash for the specified string to base64 string.
        /// </summary>
        /// <param name="buffer">The input to compute the hash code for.</param>
        /// <param name="encoding">The encoding.</param>
        /// <returns>
        /// The computed hash code in base64 string
        /// </returns>
        public string ComputeHashToBase64String(string buffer, Encoding encoding)
        {
            return Convert.ToBase64String(this.ComputeHash(buffer, encoding));
        }

        /// <summary>
        /// Initializes the key.
        /// </summary>
        /// <param name="key">The key.</param>
        private void InitializeKey(byte[] key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key", "The Key cannot be null.");
            }

            if (key.Length > BLOCK_SIZE)
            {
                this.m_Key = MD5.GetHash(key);
            }
            else
            {
                this.m_Key = key;
            }

            this.UpdateIOPadBuffers();
        }

        /// <summary>
        /// Updates the IO pad buffers.
        /// </summary>
        private void UpdateIOPadBuffers()
        {
            if (this.m_inner == null)
            {
                this.m_inner = new byte[BLOCK_SIZE];
            }

            if (this.m_outer == null)
            {
                this.m_outer = new byte[BLOCK_SIZE];
            }

            for (int i = 0; i < BLOCK_SIZE; i++)
            {
                this.m_inner[i] = 54;
                this.m_outer[i] = 92;
            }

            for (int i = 0; i < this.Key.Length; i++)
            {
                byte[] s1 = this.m_inner;
                int s2 = i;
                s1[s2] ^= this.Key[i];
                byte[] s3 = this.m_outer;
                int s4 = i;
                s3[s4] ^= this.Key[i];
            }
        }

        /// <summary>
        /// Combines two array (a1 and a2).
        /// </summary>
        /// <param name="a1">The Array 1.</param>
        /// <param name="a2">The Array 2.</param>
        /// <returns>Combinaison of a1 and a2</returns>
        private byte[] Combine(byte[] a1, byte[] a2)
        {
            byte[] final = new byte[a1.Length + a2.Length];
            for (int i = 0; i < a1.Length; i++)
            {
                final[i] = a1[i];
            }

            for (int i = 0; i < a2.Length; i++)
            {
                final[i + a1.Length] = a2[i];
            }

            return final;
        }
    }
}

本文链接

Anti Inject XSS JavaScript/HTML/LDAP/XML/CSS Encode Inject

2011-09-10T13:19:00Z


namespace ConsoleApplication
{
    using System;
    using Microsoft.Security.Application;
    /// <summary>
    /// Class1 的摘要说明。
    /// </summary>
    public class Class1
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        //[STAThread]
        static void Main(string[] args)
        {
            //
            // TODO: 在此处添加代码以启动应用程序
            //
            string s = "alert('asdasdsa')";
            string ss = Encoder.JavaScriptEncode(s, false);
            Console.WriteLine(ss);
            Console.WriteLine(Environment.Version.ToString());
        }
    }
}
//Microsoft Web Protection Library
//http://wpl.codeplex.com/
namespace Microsoft.Security.Application.CodeCharts
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Lower.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides safe character positions for the lower section of the UTF code tables.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    /// <summary>
    /// Provides safe character positions for the lower section of the UTF code tables.
    /// </summary>
    internal static class Lower
    {
        /// <summary>
        /// Determines if the specified flag is set.
        /// </summary>
        /// <param name="flags">The value to check.</param>
        /// <param name="flagToCheck">The flag to check for.</param>
        /// <returns>true if the flag is set, otherwise false.</returns>
        public static bool IsFlagSet(LowerCodeCharts flags, LowerCodeCharts flagToCheck)
        {
            return (flags & flagToCheck) != 0;
        }
        /// <summary>
        /// Provides the safe characters for the Basic Latin code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable BasicLatin()
        {
            for (int i = 0x0020; i <= 0x007E; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Latin 1 Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Latin1Supplement()
        {
            for (int i = 0x00A1; i <= 0x00FF; i++)
            {
                if (i == 0x00AD)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Latin Extended A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable LatinExtendedA()
        {
            for (int i = 0x0100; i <= 0x17F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Latin Extended B code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable LatinExtendedB()
        {
            for (int i = 0x0180; i <= 0x024F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the IPA Extensions code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable IpaExtensions()
        {
            for (int i = 0x0250; i <= 0x2AF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Spacing Modifiers code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SpacingModifierLetters()
        {
            for (int i = 0x02B0; i <= 0x2FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Combining Diacritical Marks code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CombiningDiacriticalMarks()
        {
            for (int i = 0x0300; i <= 0x36F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Greek and Coptic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable GreekAndCoptic()
        {
            for (int i = 0x0370; i <= 0x03FF; i++)
            {
                if (i == 0x378 ||
                    i == 0x379 ||
                    (i >= 0x37F && i <= 0x383) ||
                    i == 0x38B ||
                    i == 0x38D ||
                    i == 0x3A2)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Cyrillic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Cyrillic()
        {
            for (int i = 0x0400; i <= 0x04FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Cyrillic Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CyrillicSupplement()
        {
            for (int i = 0x0500; i <= 0x0525; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Armenian code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>        
        public static IEnumerable Armenian()
        {
            for (int i = 0x0531; i <= 0x058A; i++)
            {
                if (i == 0x0557 ||
                    i == 0x0558 ||
                    i == 0x0560 ||
                    i == 0x0588)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hebrew code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Hebrew()
        {
            for (int i = 0x0591; i <= 0x05F4; i++)
            {
                if ((i >= 0x05C8 && i <= 0x05CF) ||
                    (i >= 0x05EB && i <= 0x05EF))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Arabic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Arabic()
        {
            for (int i = 0x0600; i <= 0x06FF; i++)
            {
                if (i == 0x0604 ||
                    i == 0x0605 ||
                    i == 0x061C ||
                    i == 0x061d ||
                    i == 0x0620 ||
                    i == 0x065F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Syriac code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Syriac()
        {
            for (int i = 0x0700; i <= 0x074F; i++)
            {
                if (i == 0x070E ||
                    i == 0x074B ||
                    i == 0x074C)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Arabic Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable ArabicSupplement()
        {
            for (int i = 0x0750; i <= 0x077F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Thaana code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Thaana()
        {
            for (int i = 0x0780; i <= 0x07B1; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Nko code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Nko()
        {
            for (int i = 0x07C0; i <= 0x07FA; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Samaritan code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Samaritan()
        {
            for (int i = 0x0800; i <= 0x083E; i++)
            {
                if (i == 0x082E ||
                    i == 0x082F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Devenagari code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Devanagari()
        {
            for (int i = 0x0900; i <= 0x097F; i++)
            {
                if (i == 0x093A ||
                    i == 0x093B ||
                    i == 0x094F ||
                    i == 0x0956 ||
                    i == 0x0957 ||
                    (i >= 0x0973 && i <= 0x0978))
                {
                    continue;
                }
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Bengali code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Bengali()
        {
            for (int i = 0x0981; i <= 0x09FB; i++)
            {
                if (i == 0x0984 ||
                    i == 0x098D || 
                    i == 0x098E ||
                    i == 0x0991 ||
                    i == 0x0992 ||
                    i == 0x09A9 || 
                    i == 0x09B1 ||
                    i == 0x09B3 ||
                    i == 0x09B4 ||
                    i == 0x09B5 ||
                    i == 0x09BA ||
                    i == 0x09BB ||
                    i == 0x09C5 ||
                    i == 0x09C6 ||
                    i == 0x09C9 ||
                    i == 0x09CA ||
                    (i >= 0x09CF && i <= 0x09D6) ||
                    (i >= 0x09D8 && i <= 0x09DB) ||
                    i == 0x09DE ||
                    i == 0x09E4 ||
                    i == 0x09E5)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Gurmukhi code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Gurmukhi()
        {
            for (int i = 0x0A01; i <= 0x0A75; i++)
            {
                if (i == 0x0A04 ||
                    (i >= 0x0A0B && i <= 0x0A0E) ||
                    i == 0x0A11 ||
                    i == 0x0A12 ||
                    i == 0x0A29 ||
                    i == 0x0A31 ||
                    i == 0x0A34 ||
                    i == 0x0A37 ||
                    i == 0x0A3A ||
                    i == 0x0A3B ||
                    i == 0x0A3D ||
                    (i >= 0x0A43 && i <= 0x0A46) ||
                    i == 0x0A49 ||
                    i == 0x0A4A ||
                    (i >= 0x0A4E && i <= 0x0A50) ||
                    (i >= 0x0A52 && i <= 0x0A58) ||
                    i == 0x0A5D ||
                    (i >= 0x0A5F && i <= 0x0A65))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Gujarati code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Gujarati()
        {
            for (int i = 0x0A81; i <= 0x0AF1; i++)
            {
                if (i == 0x0A84 ||
                    i == 0x0A8E ||
                    i == 0x0A92 ||
                    i == 0x0AA9 ||
                    i == 0x0AB1 ||
                    i == 0x0AB4 ||
                    i == 0x0ABA ||
                    i == 0x0ABB ||
                    i == 0x0AC6 ||
                    i == 0x0ACA ||
                    i == 0x0ACE ||
                    i == 0x0ACF ||
                    (i >= 0xAD1 && i <= 0x0ADF) ||
                    i == 0x0AE4 ||
                    i == 0x0AE5 ||
                    i == 0x0AF0)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Oriya code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Oriya()
        {
            for (int i = 0x0B01; i <= 0x0B71; i++)
            {
                if (i == 0x0B04 ||
                    i == 0x0B0D ||
                    i == 0x0B0E ||
                    i == 0x0B11 ||
                    i == 0x0B12 ||
                    i == 0x0B29 ||
                    i == 0x0B31 ||
                    i == 0x0B34 ||
                    i == 0x0B3A ||
                    i == 0x0B3B ||
                    i == 0x0B45 ||
                    i == 0x0B46 ||
                    i == 0x0B49 ||
                    i == 0x0B4A ||
                    (i >= 0x0B4E && i <= 0x0B55) ||
                    (i >= 0x0B58 && i <= 0x0B5B) ||
                    i == 0x0B5E ||
                    i == 0x0B64 ||
                    i == 0x0B65)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Tamil code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Tamil()
        {
            for (int i = 0x0B82; i <= 0x0BFA; i++)
            {
                if (i == 0x0B84 ||
                    i == 0x0B8B ||
                    i == 0x0B8C ||
                    i == 0x0B8D ||
                    i == 0x0B91 ||
                    i == 0x0B96 ||
                    i == 0x0B97 ||
                    i == 0x0B98 ||
                    i == 0x0B9B ||
                    i == 0x0B9D ||
                    i == 0x0BA0 ||
                    i == 0x0BA1 ||
                    i == 0x0BA2 ||
                    i == 0x0BA5 ||
                    i == 0x0BA6 ||
                    i == 0x0BA7 ||
                    i == 0x0BAB ||
                    i == 0x0BAC ||
                    i == 0x0BAD ||
                    (i >= 0x0BBA && i <= 0x0BBD) ||
                    i == 0x0BC3 ||
                    i == 0x0BC4 ||
                    i == 0x0BC5 ||
                    i == 0x0BC9 ||
                    i == 0x0BCE ||
                    i == 0x0BCF ||
                    (i >= 0x0BD1 && i <= 0x0BD6) ||                    
                    (i >= 0x0BD8 && i <= 0x0BE5))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Telugu code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Telugu()
        {
            for (int i = 0x0C01; i <= 0x0C7F; i++)
            {
                if (i == 0x0C04 ||
                    i == 0x0C0D ||
                    i == 0x0C11 ||
                    i == 0x0C29 ||
                    i == 0x0C34 ||
                    i == 0x0C3A ||
                    i == 0x0C3B ||
                    i == 0x0C3C ||
                    i == 0x0C45 ||
                    i == 0x0C49 ||
                    (i >= 0x0C4E && i <= 0x0C54) ||
                    i == 0x0C57 ||
                    (i >= 0x0C5A && i <= 0x0C5F) ||
                    i == 0x0C64 ||
                    i == 0x0C65 ||
                    (i >= 0x0C70 && i <= 0x0C77))
                {
                    continue;
                }
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Kannada code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>        
        public static IEnumerable Kannada()
        {
            for (int i = 0x0C82; i <= 0x0CF2; i++)
            {
                if (i == 0x0C84 ||
                    i == 0x0C8D || 
                    i == 0x0C91 ||
                    i == 0x0CA9 ||
                    i == 0x0CB4 ||
                    i == 0x0CBA ||
                    i == 0x0CBB ||
                    i == 0x0CC5 ||
                    i == 0x0CC9 || 
                    (i >= 0x0CCE && i <= 0x0CD4) ||
                    (i >= 0x0CD7 && i <= 0x0CDD) ||
                    i == 0x0CDF ||
                    i == 0x0CE4 ||
                    i == 0x0CE5 ||
                    i == 0x0CF0)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Malayalam code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Malayalam()
        {
            for (int i = 0x0D02; i <= 0x0D7F; i++)
            {
                if (i == 0x0D04 ||
                    i == 0x0D0D ||
                    i == 0x0D11 ||
                    i == 0x0D29 ||
                    i == 0x0D3A ||
                    i == 0x0D3B ||
                    i == 0x0D3C ||
                    i == 0x0D45 ||
                    i == 0x0D49 ||
                    (i >= 0x0D4E && i <= 0x0D56) ||
                    (i >= 0x0D58 && i <= 0x0D5F) ||
                    i == 0x0D64 ||
                    i == 0x0D65 ||
                    i == 0x0D76 ||
                    i == 0x0D77 ||
                    i == 0x0D78)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Sinhala code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Sinhala()
        {
            for (int i = 0x0D82; i <= 0x0DF4; i++)
            {
                if (i == 0x0D84 ||
                    i == 0x0D97 ||
                    i == 0X0D98 ||
                    i == 0x0D99 ||
                    i == 0x0DB2 ||
                    i == 0x0DBC ||
                    i == 0x0DBE ||
                    i == 0x0DBF ||
                    i == 0x0DC7 ||
                    i == 0x0DC8 ||
                    i == 0x0DC9 ||
                    (i >= 0x0DCB && i <= 0x0DCE) ||
                    i == 0x0DD5 ||
                    i == 0x0DD7 ||
                    (i >= 0x0DE0 && i <= 0x0DF1))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Thai code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Thai()
        {
            for (int i = 0x0E01; i <= 0x0E5B; i++)
            {
                if (i >= 0x0E3B && i <= 0x0E3E)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Lao code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Lao()
        {
            for (int i = 0x0E81; i <= 0x0EDD; i++)
            {
                if (i == 0x0E83 ||
                    i == 0x0E85 ||
                    i == 0x0E86 ||
                    i == 0x0E89 ||
                    i == 0x0E8B ||
                    i == 0x0E8C ||
                    (i >= 0x0E8E && i <= 0x0E93) ||
                    i == 0x0E98 ||
                    i == 0x0EA0 ||
                    i == 0x0EA4 ||
                    i == 0x0EA6 ||
                    i == 0x0EA8 ||
                    i == 0x0EA9 ||
                    i == 0x0EAC ||
                    i == 0x0EBA ||
                    i == 0x0EBE ||
                    i == 0x0EBF ||
                    i == 0x0EC5 ||
                    i == 0x0EC7 ||
                    i == 0x0ECE ||
                    i == 0x0ECF ||
                    i == 0x0EDA ||
                    i == 0x0EDB)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Tibetan code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Tibetan()
        {
            for (int i = 0x0F00; i <= 0x0FD8; i++)
            {
                if (i == 0x0F48 ||
                    (i >= 0x0F6D && i <= 0x0F70) ||
                    (i >= 0x0F8C && i <= 0x0F8F) ||
                    i == 0x0F98 ||
                    i == 0x0FBD ||
                    i == 0x0FCD)
                {
                    continue;
                }
                yield return i;
            }
        }
    }
}
namespace Microsoft.Security.Application.CodeCharts
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="LowerMiddle.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides safe character positions for the lower middle section of the UTF code tables.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    /// <summary>
    /// Provides safe character positions for the lower middle section of the UTF code tables.
    /// </summary>
    internal static class LowerMiddle
    {
        /// <summary>
        /// Determines if the specified flag is set.
        /// </summary>
        /// <param name="flags">The value to check.</param>
        /// <param name="flagToCheck">The flag to check for.</param>
        /// <returns>true if the flag is set, otherwise false.</returns>
        public static bool IsFlagSet(LowerMidCodeCharts flags, LowerMidCodeCharts flagToCheck)
        {
            return (flags & flagToCheck) != 0;
        }
        /// <summary>
        /// Provides the safe characters for the Myanmar code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Myanmar()
        {
            for (int i = 0x1000; i <= 0x109F; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Georgian code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>        
        public static IEnumerable Georgian()
        {
            for (int i = 0x10A0; i <= 0x10FC; i++)
            {
                if (i >= 0x10C6 && i <= 0x10CF)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hangul Jamo code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable HangulJamo()
        {
            for (int i = 0x1100; i <= 0x11FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Ethiopic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable Ethiopic()
        {
            for (int i = 0x1200; i <= 0x137C; i++)
            {
                if (i == 0x1249 ||
                    i == 0x124E ||
                    i == 0x124F ||
                    i == 0x1257 ||
                    i == 0x1259 ||
                    i == 0x125E ||
                    i == 0x125F ||
                    i == 0x1289 ||
                    i == 0x128E ||
                    i == 0x128F ||
                    i == 0x12B1 ||
                    i == 0x12B6 ||
                    i == 0x12B7 ||
                    i == 0x12BF ||
                    i == 0x12C1 ||
                    i == 0x12C6 ||
                    i == 0x12C7 ||
                    i == 0x12D7 ||
                    i == 0x1311 ||
                    i == 0x1316 ||
                    i == 0x1317 ||
                    (i >= 0x135B && i <= 0x135E))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Ethiopic Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable EthiopicSupplement()
        {
            for (int i = 0x1380; i <= 0x1399; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Cherokee code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable Cherokee()
        {
            for (int i = 0x13A0; i <= 0x13F4; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Unified Canadian Aboriginal Syllabic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable UnifiedCanadianAboriginalSyllabics()
        {
            for (int i = 0x1400; i <= 0x167F; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Ogham code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Ogham()
        {
            for (int i = 0x1680; i <= 0x169C; i++)
            {
                yield return i;
            }              
        }
        /// <summary>
        /// Provides the safe characters for the Runic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Runic()
        {
            for (int i = 0x16A0; i <= 0x16F0; i++)
            {
                yield return i;
            }              
        }
        /// <summary>
        /// Provides the safe characters for the Tagalog code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Tagalog()
        {
            for (int i = 0x1700; i <= 0x1714; i++)
            {
                if (i == 0x170D)
                {
                    continue;
                }
                yield return i;
            }               
        }
        /// <summary>
        /// Provides the safe characters for the Hanunoo code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Hanunoo()
        {
            for (int i = 0x1720; i <= 0x1736; i++)
            {
                yield return i;
            }             
        }
        /// <summary>
        /// Provides the safe characters for the Buhid code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Buhid()
        {
            for (int i = 0x1740; i <= 0x1753; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Tagbanwa code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Tagbanwa()
        {
            for (int i = 0x1760; i <= 0x1773; i++)
            {
                if (i == 0x176D ||
                    i == 0x1771)
                {
                    continue;
                }
                yield return i;
            }                         
        }
        /// <summary>
        /// Provides the safe characters for the Khmer code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Khmer()
        {
            for (int i = 0x1780; i <= 0x17F9; i++)
            {
                if (i == 0x17DE ||
                    i == 0x17DF ||
                    (i >= 0x17EA && i <= 0x17EF))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Mongolian code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns> 
        public static IEnumerable Mongolian()
        {
            for (int i = 0x1800; i <= 0x18AA; i++)
            {
                if (i == 0x180F ||
                    (i >= 0x181A && i <= 0x181F) ||
                    (i >= 0x1878 && i <= 0x187F))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Unified Canadian Aboriginal Syllabic Extended code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable UnifiedCanadianAboriginalSyllabicsExtended()
        {
            for (int i = 0x18B0; i <= 0x18F5; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Limbu code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable Limbu()
        {
            for (int i = 0x1900; i <= 0x194F; i++)
            {
                if (i == 0x191D ||
                    i == 0x191E ||
                    i == 0x191F ||
                    (i >= 0x192C && i <= 0x192F) ||
                    (i >= 0x193C && i <= 0x193F) ||
                    i == 0x1941 ||
                    i == 0x1942 ||
                    i == 0x1943)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Tai Le code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable TaiLe()
        {
            for (int i = 0x1950; i <= 0x1974; i++)
            {
                if (i == 0x196E ||
                    i == 0x196F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the New Tai Lue code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>          
        public static IEnumerable NewTaiLue()
        {
            for (int i = 0x1980; i <= 0x19DF; i++)
            {
                if ((i >= 0x19AC && i <= 0x19AF) ||
                    (i >= 0x19CA && i <= 0x19CF) ||
                    (i >= 0x19DB && i <= 0x19DD))
                {
                    continue;
                }
                yield return i;            
            }
        }
        /// <summary>
        /// Provides the safe characters for the Khmer Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable KhmerSymbols()
        {
            for (int i = 0x19E0; i <= 0x19FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Khmer Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable Buginese()
        {
            for (int i = 0x1A00; i <= 0x1A1F; i++)
            {
                if (i == 0x1A1C ||
                    i == 0x1A1D)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Tai Tham code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable TaiTham()
        {
            for (int i = 0x1A20; i <= 0x1AAD; i++)
            {
                if (i == 0x1A5F ||
                    i == 0x1A7D ||
                    i == 0x1A7E ||
                    (i >= 0x1A8A && i <= 0x1A8F) ||
                    (i >= 0x1A9A && i <= 0x1A9F))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Balinese code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable Balinese()
        {
            for (int i = 0x1B00; i <= 0x1B7C; i++)
            {
                if (i >= 0x1B4C && i <= 0x1B4F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Sudanese code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable Sudanese()
        {
            for (int i = 0x1B80; i <= 0x1BB9; i++)
            {
                if (i >= 0x1BAB && i <= 0x1BAD)
                {
                    continue;
                }
                yield return i;                
            }
        }
        /// <summary>
        /// Provides the safe characters for the Lepcha code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>   
        public static IEnumerable Lepcha()
        {
            for (int i = 0x1C00; i <= 0x1C4F; i++)
            {
                if ((i >= 0x1C38 && i <= 0x1C3A) ||
                    (i >= 0x1C4A && i <= 0x1C4C))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Ol Chiki code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable OlChiki()
        {
            for (int i = 0x1C50; i <= 0x1C7F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Vedic Extensions code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable VedicExtensions()
        {
            for (int i = 0x1CD0; i <= 0x1CF2; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Phonetic Extensions code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable PhoneticExtensions()
        {
            for (int i = 0x1D00; i <= 0x1D7F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Phonetic Extensions Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable PhoneticExtensionsSupplement()
        {
            for (int i = 0x1D80; i <= 0x1DBF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Combining Diacritical Marks Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable CombiningDiacriticalMarksSupplement()
        {
            for (int i = 0x1DC0; i <= 0x1DFF; i++)
            {
                if (i >= 0x1DE7 && i <= 0x1DFC)
                {
                    continue;
                }
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Latin Extended Addition code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>  
        public static IEnumerable LatinExtendedAdditional()
        {
            for (int i = 0x1E00; i <= 0x1EFF; i++)
            {
                yield return i;
            }
        }
    }
}
namespace Microsoft.Security.Application.CodeCharts
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Middle.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides safe character positions for the lower middle section of the UTF code tables.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    /// <summary>
    /// Provides safe character positions for the middle section of the UTF code tables.
    /// </summary>
    internal static class Middle
    {
        /// <summary>
        /// Determines if the specified flag is set.
        /// </summary>
        /// <param name="flags">The value to check.</param>
        /// <param name="flagToCheck">The flag to check for.</param>
        /// <returns>true if the flag is set, otherwise false.</returns>
        public static bool IsFlagSet(MidCodeCharts flags, MidCodeCharts flagToCheck)
        {
            return (flags & flagToCheck) != 0;
        }
        /// <summary>
        /// Provides the safe characters for the Greek Extended code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable GreekExtended()
        {
            for (int i = 0x1F00; i <= 0x1FFE; i++)
            {
                if (i == 0x1F16 ||
                    i == 0x1F17 ||
                    i == 0x1F1E ||
                    i == 0x1F1F ||
                    i == 0x1F46 ||
                    i == 0x1F47 ||
                    i == 0x1F4E ||
                    i == 0x1F4F ||
                    i == 0x1F58 ||
                    i == 0x1F5A ||
                    i == 0x1F5C ||
                    i == 0x1F5E ||
                    i == 0x1F7E ||
                    i == 0x1F7F ||
                    i == 0x1FB5 ||
                    i == 0x1FC5 ||
                    i == 0x1FD4 ||
                    i == 0x1FD5 ||
                    i == 0x1FDC ||
                    i == 0x1FF0 ||
                    i == 0x1FF1 ||
                    i == 0x1FF5)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the General Punctuation code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable GeneralPunctuation()
        {
            for (int i = 0x2000; i <= 0x206F; i++)
            {
                if (i >= 0x2065 && i <= 0x2069)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Superscripts and subscripts code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SuperscriptsAndSubscripts()
        {
            for (int i = 0x2070; i <= 0x2094; i++)
            {
                if (i == 0x2072 ||
                    i == 0x2073 ||
                    i == 0x208F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Currency Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CurrencySymbols()
        {
            for (int i = 0x20A0; i <= 0x20B8; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Combining Diacritrical Marks for Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CombiningDiacriticalMarksForSymbols()
        {
            for (int i = 0x20D0; i <= 0x20F0; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Letterlike Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable LetterlikeSymbols()
        {
            for (int i = 0x2100; i <= 0x214F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Number Forms code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable NumberForms()
        {
            for (int i = 0x2150; i <= 0x2189; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Arrows code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Arrows()
        {
            for (int i = 0x2190; i <= 0x21FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Mathematical Operators code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MathematicalOperators()
        {
            for (int i = 0x2200; i <= 0x22FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Miscellaneous Technical code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MiscellaneousTechnical()
        {
            for (int i = 0x2300; i <= 0x23E8; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Control Pictures code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable ControlPictures()
        {
            for (int i = 0x2400; i <= 0x2426; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the OCR code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable OpticalCharacterRecognition()
        {
            for (int i = 0x2440; i <= 0x244A; i++)
            {
                yield return i;
            }        
        }
        /// <summary>
        /// Provides the safe characters for the Enclosed Alphanumerics code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable EnclosedAlphanumerics()
        {
            for (int i = 0x2460; i <= 0x24FF; i++)
            {
                yield return i;
            }                
        }
        /// <summary>
        /// Provides the safe characters for the Box Drawing code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable BoxDrawing()
        {
            for (int i = 0x2500; i <= 0x257F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Block Elements code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable BlockElements()
        {
            for (int i = 0x2580; i <= 0x259F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Geometric Shapes code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable GeometricShapes()
        {
            for (int i = 0x25A0; i <= 0x25FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Miscellaneous Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MiscellaneousSymbols()
        {
            for (int i = 0x2600; i <= 0x26FF; i++)
            {
                if (i == 0x26CE || 
                    i == 0x26E2 ||
                    (i >= 0x26E4 && i <= 0x26E7))
                {
                    continue;
                }
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Dingbats code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Dingbats()
        {
            for (int i = 0x2701; i <= 0x27BE; i++)
            {
                if (i == 0x2705 ||
                    i == 0x270A ||
                    i == 0x270B ||
                    i == 0x2728 ||
                    i == 0x274C ||
                    i == 0x274E ||
                    i == 0x2753 ||
                    i == 0x2754 ||
                    i == 0x2755 ||
                    i == 0x275F ||
                    i == 0x2760 ||
                    i == 0x2795 ||
                    i == 0x2796 ||
                    i == 0x2797 ||
                    i == 0x27B0)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Miscellaneous Mathematical Symbols A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MiscellaneousMathematicalSymbolsA()
        {
            for (int i = 0x27C0; i <= 0x27EF; i++)
            {
                if (i == 0x27CB ||
                    i == 0x27CD ||
                    i == 0x27CE ||
                    i == 0x27CF)
                {
                    continue;
                }
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Supplemental Arrows A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SupplementalArrowsA()
        {
            for (int i = 0x27F0; i <= 0x27FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Braille Patterns code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable BraillePatterns()
        {
            for (int i = 0x2800; i <= 0x28FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Supplemental Arrows B code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SupplementalArrowsB()
        {
            for (int i = 0x2900; i <= 0x297F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Miscellaneous Mathematical Symbols B code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MiscellaneousMathematicalSymbolsB()
        {
            for (int i = 0x2980; i <= 0x29FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Supplemental Mathematical Operators code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SupplementalMathematicalOperators()
        {
            for (int i = 0x2A00; i <= 0x2AFF; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Miscellaneous Symbols and Arrows code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MiscellaneousSymbolsAndArrows()
        {
            for (int i = 0x2B00; i <= 0x2B59; i++)
            {
                if (i == 0x2B4D || 
                    i == 0x2B4E ||
                    i == 0x2B4F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Glagolitic code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Glagolitic()
        {
            for (int i = 0x2C00; i <= 0x2C5E; i++)
            {
                if (i == 0x2C2F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Latin Extended C code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable LatinExtendedC()
        {
            for (int i = 0x2C60; i <= 0x2C7F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Coptic table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Coptic()
        {
            for (int i = 0x2C80; i <= 0x2CFF; i++)
            {
                if (i >= 0x2CF2 && i <= 0x2CF8)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Georgian Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable GeorgianSupplement()
        {
            for (int i = 0x2D00; i <= 0x2D25; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Tifinagh code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Tifinagh()
        {
            for (int i = 0x2D30; i <= 0x2D6F; i++)
            {
                if (i >= 0x2D66 && i <= 0x2D6E)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Ethiopic Extended code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable EthiopicExtended()
        {
            for (int i = 0x2D80; i <= 0x2DDE; i++)
            {
                if ((i >= 0x2D97 && i <= 0x2D9F) ||
                    i == 0x2DA7 ||
                    i == 0x2DAF ||
                    i == 0x2DB7 ||
                    i == 0x2DBF ||
                    i == 0x2DC7 ||
                    i == 0x2DCF ||
                    i == 0x2DD7 ||
                    i == 0x2DDF)
                {
                    continue;
                }
                yield return i;
            }
        }
    }
}
namespace Microsoft.Security.Application.CodeCharts
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Upper.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides safe character positions for the upper section of the UTF code tables.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    /// <summary>
    /// Provides safe character positions for the upper section of the UTF code tables.
    /// </summary>
    internal static class Upper
    {
        /// <summary>
        /// Determines if the specified flag is set.
        /// </summary>
        /// <param name="flags">The value to check.</param>
        /// <param name="flagToCheck">The flag to check for.</param>
        /// <returns>true if the flag is set, otherwise false.</returns>
        public static bool IsFlagSet(UpperCodeCharts flags, UpperCodeCharts flagToCheck)
        {
            return (flags & flagToCheck) != 0;
        }
        /// <summary>
        /// Provides the safe characters for the Devanagari Extended code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable DevanagariExtended()
        {
            for (int i = 0xA8E0; i <= 0xA8FB; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Kayah Li code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable KayahLi()
        {
            for (int i = 0xA900; i <= 0xA92F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Rejang code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Rejang()
        {
            for (int i = 0xA930; i <= 0xA953; i++)
            {
                yield return i;
            }
            yield return 0xA95F;
        }
        /// <summary>
        /// Provides the safe characters for the Hangul Jamo Extended A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable HangulJamoExtendedA()
        {
            for (int i = 0xA960; i <= 0xA97C; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Javanese code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Javanese()
        {
            for (int i = 0xA980; i <= 0xA9DF; i++)
            {
                if (i == 0xA9CE ||
                    (i >= 0xA9DA && i <= 0xA9DD))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Cham code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Cham()
        {
            for (int i = 0xAA00; i <= 0xAA5F; i++)
            {
                if ((i >= 0xAA37 && i <= 0xAA3F) ||
                    i == 0xAA4E ||
                    i == 0xAA4F ||
                    i == 0xAA5A ||
                    i == 0xAA5B)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Myanmar Extended A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MyanmarExtendedA()
        {
            for (int i = 0xAA60; i <= 0xAA7B; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Myanmar Extended A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable TaiViet()
        {
            for (int i = 0xAA80; i <= 0xAAC2; i++)
            {
                yield return i;
            }
            for (int i = 0xAADB; i <= 0xAADF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Meetei Mayek code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable MeeteiMayek()
        {
            for (int i = 0xABC0; i <= 0xABF9; i++)
            {
                if (i == 0xABEE ||
                    i == 0xABEF)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hangul Syllables code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable HangulSyllables()
        {
            for (int i = 0xAC00; i <= 0xD7A3; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hangul Jamo Extended B code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable HangulJamoExtendedB()
        {
            for (int i = 0xD7B0; i <= 0xD7FB; i++)
            {
                if (i == 0xD7C7 ||
                    i == 0xD7C8 ||
                    i == 0xD7C9 ||
                    i == 0xD7CA)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Compatibility Ideographs code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkCompatibilityIdeographs()
        {
            for (int i = 0xF900; i <= 0xFAD9; i++)
            {
                if (i == 0xFA2E ||
                    i == 0xFA2F ||
                    i == 0xFA6E ||
                    i == 0xFA6F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Alphabetic Presentation Forms code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable AlphabeticPresentationForms()
        {
            for (int i = 0xFB00; i <= 0xFB4F; i++)
            {
                if ((i >= 0xFB07 && i <= 0xFB12) ||
                    (i >= 0xFB18 && i <= 0xFB1C) ||
                    i == 0xFB37 ||
                    i == 0xFB3D ||
                    i == 0xFB3F ||
                    i == 0xFB42 ||
                    i == 0xFB45)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Arabic Presentation Forms A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable ArabicPresentationFormsA()
        {
            for (int i = 0xFB50; i <= 0xFDFD; i++)
            {
                if ((i >= 0xFBB2 && i <= 0xFBD2) || 
                    (i >= 0xFD40 && i <= 0xFD4F) ||
                    i == 0xFD90 ||
                    i == 0xFD91 ||
                    (i >= 0xFDC8 && i <= 0xFDEF))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Variation Selectors code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable VariationSelectors()
        {
            for (int i = 0xFE00; i <= 0xFE0F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Vertical Forms code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable VerticalForms()
        {
            for (int i = 0xFE10; i <= 0xFE19; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Combining Half Marks code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CombiningHalfMarks()
        {
            for (int i = 0xFE20; i <= 0xFE26; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Compatibility Forms code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkCompatibilityForms()
        {
            for (int i = 0xFE30; i <= 0xFE4F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Small Form Variants code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SmallFormVariants()
        {
            for (int i = 0xFE50; i <= 0xFE6B; i++)
            {
                if (i == 0xFE53 || i == 0xFE67)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Arabic Presentation Forms B code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable ArabicPresentationFormsB()
        {
            for (int i = 0xFE70; i <= 0xFEFC; i++)
            {
                if (i == 0xFE75)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Half Width and Full Width Forms code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable HalfWidthAndFullWidthForms()
        {
            for (int i = 0xFF01; i <= 0xFFEE; i++)
            {
                if (i == 0xFFBF ||
                    i == 0xFFC0 ||
                    i == 0xFFC1 ||
                    i == 0xFFC8 ||
                    i == 0xFFC9 ||
                    i == 0xFFD0 ||
                    i == 0xFFD1 ||
                    i == 0xFFD8 ||
                    i == 0xFFD9 ||
                    i == 0xFFDD ||
                    i == 0xFFDE ||
                    i == 0xFFDF ||
                    i == 0xFFE7)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Specials code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Specials()
        {
            for (int i = 0xFFF9; i <= 0xFFFD; i++)
            {
                yield return i;
            }
        }
    }
}
namespace Microsoft.Security.Application.CodeCharts
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="UpperMiddle.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides safe character positions for the upper middle section of the UTF code tables.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    /// <summary>
    /// Provides safe character positions for the upper middle section of the UTF code tables.
    /// </summary>
    internal static class UpperMiddle
    {
        /// <summary>
        /// Determines if the specified flag is set.
        /// </summary>
        /// <param name="flags">The value to check.</param>
        /// <param name="flagToCheck">The flag to check for.</param>
        /// <returns>true if the flag is set, otherwise false.</returns>
        public static bool IsFlagSet(UpperMidCodeCharts flags, UpperMidCodeCharts flagToCheck)
        {
            return (flags & flagToCheck) != 0;
        }
        /// <summary>
        /// Provides the safe characters for the Cyrillic Extended A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CyrillicExtendedA()
        {
            for (int i = 0x2DE0; i <= 0x2DFF; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Cyrillic Extended A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SupplementalPunctuation()
        {
            for (int i = 0x2E00; i <= 0x2E31; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Radicals Supplement code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkRadicalsSupplement()
        {
            for (int i = 0x2E80; i <= 0x2EF3; i++)
            {
                if (i == 0x2E9A)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Kangxi Radicals code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable KangxiRadicals()
        {
            for (int i = 0x2F00; i <= 0x2FD5; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Ideographic Description Characters code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable IdeographicDescriptionCharacters()
        {
            for (int i = 0x2FF0; i <= 0x2FFB; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the CJK Symbols and Punctuation code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkSymbolsAndPunctuation()
        {
            for (int i = 0x3000; i <= 0x303F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hiragana code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Hiragana()
        {
            for (int i = 0x3041; i <= 0x309F; i++)
            {
                if (i == 0x3097 ||
                    i == 0x3098)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hiragana code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Katakana()
        {
            for (int i = 0x30A0; i <= 0x30FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Bopomofo code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Bopomofo()
        {
            for (int i = 0x3105; i <= 0x312D; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Hangul Compatibility Jamo code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable HangulCompatibilityJamo()
        {
            for (int i = 0x3131; i <= 0x318E; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Kanbun code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Kanbun()
        {
            for (int i = 0x3190; i <= 0x319F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Bopomofo Extended code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable BopomofoExtended()
        {
            for (int i = 0x31A0; i <= 0x31B7; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Strokes code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkStrokes()
        {
            for (int i = 0x31C0; i <= 0x31E3; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Katakana Phonetic Extensions code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable KatakanaPhoneticExtensions()
        {
            for (int i = 0x31F0; i <= 0x31FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Enclosed CJK Letters and Months code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable EnclosedCjkLettersAndMonths()
        {
            for (int i = 0x3200; i <= 0x32FE; i++)
            {
                if (i == 0x321F)
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Compatibility code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkCompatibility()
        {
            for (int i = 0x3300; i <= 0x33FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Unified Ideographs Extension A code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkUnifiedIdeographsExtensionA()
        {
            for (int i = 0x3400; i <= 0x4DB5; i++)
            {
                yield return i;
            }            
        }
        /// <summary>
        /// Provides the safe characters for the Yijing Hexagram Symbols code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable YijingHexagramSymbols()
        {
            for (int i = 0x4DC0; i <= 0x4DFF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the CJK Unified Ideographs code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CjkUnifiedIdeographs()
        {
            for (int i = 0x4E00; i <= 0x9FCB; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Yi Syllables code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable YiSyllables()
        {
            for (int i = 0xA000; i <= 0xA48C; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Yi Radicals code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable YiRadicals()
        {
            for (int i = 0xA490; i <= 0xA4C6; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Lisu code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Lisu()
        {
            for (int i = 0xA4D0; i <= 0xA4FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Vai code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Vai()
        {
            for (int i = 0xA500; i <= 0xA62B; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Cyrillic Extended B code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CyrillicExtendedB()
        {
            for (int i = 0xA640; i <= 0xA697; i++)
            {
                if (i == 0xA660 ||
                    i == 0xA661 ||
                    (i >= 0xA674 && i <= 0xA67b))
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Bamum code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Bamum()
        {
            for (int i = 0xA6A0; i <= 0xA6F7; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Modifier Tone Letters code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable ModifierToneLetters()
        {
            for (int i = 0xA700; i <= 0xA71F; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Latin Extended D code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable LatinExtendedD()
        {
            for (int i = 0xA720; i <= 0xA78C; i++)
            {
                yield return i;
            }
            for (int i = 0xA7FB; i <= 0xA7FF; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Syloti Nagri code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable SylotiNagri()
        {
            for (int i = 0xA800; i <= 0xA82B; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Common Indic Number Forms code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable CommonIndicNumberForms()
        {
            for (int i = 0xA830; i <= 0xA839; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Phags-pa code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Phagspa()
        {
            for (int i = 0xA840; i <= 0xA877; i++)
            {
                yield return i;
            }
        }
        /// <summary>
        /// Provides the safe characters for the Saurashtra code table.
        /// </summary>
        /// <returns>The safe characters for the code table.</returns>
        public static IEnumerable Saurashtra()
        {
            for (int i = 0xA880; i <= 0xA8D9; i++)
            {
                if (i >= 0xA8C5 && i <= 0xA8CD)
                {
                    continue;
                }
                yield return i;
            }
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="CodeCharts.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Enumerations for the various printable code tables within the Unicode UTF space.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System;
    /// <summary>
    /// Values for the lowest section of the UTF8 Unicode code tables, from U0000 to U0FFF.
    /// </summary>
    [Flags]
    public enum LowerCodeCharts : long
    {
        /// <summary>
        /// No code charts from the lower region of the Unicode tables are safe-listed.
        /// </summary>
        None                                        = 0,
        /// <summary>
        /// The Basic Latin code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0000.pdf</remarks>
        BasicLatin                                  = 1 << 0x00,
        /// <summary>
        /// The C1 Controls and Latin-1 Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0080.pdf</remarks>
        C1ControlsAndLatin1Supplement               = 1 << 0x01,
        /// <summary>
        /// The Latin Extended-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0100.pdf</remarks>
        LatinExtendedA                              = 1 << 0x02,
        /// <summary>
        /// The Latin Extended-B code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0180.pdf</remarks>
        LatinExtendedB                              = 1 << 0x03,
        /// <summary>
        /// The IPA Extensions code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0250.pdf</remarks>
        IpaExtensions                               = 1 << 0x04,
        /// <summary>
        /// The Spacing Modifier Letters code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U02B0.pdf</remarks>
        SpacingModifierLetters                      = 1 << 0x05,
        /// <summary>
        /// The Combining Diacritical Marks code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0300.pdf</remarks>
        CombiningDiacriticalMarks                   = 1 << 0x06,        
        /// <summary>
        /// The Greek and Coptic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0370.pdf</remarks>
        GreekAndCoptic                              = 1 << 0x07,
        /// <summary>
        /// The Cyrillic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0400.pdf</remarks>
        Cyrillic                                    = 1 << 0x08,
        /// <summary>
        /// The Cyrillic Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0500.pdf</remarks>
        CyrillicSupplement                          = 1 << 0x09,
        /// <summary>
        /// The Armenian code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0530.pdf</remarks>
        Armenian                                    = 1 << 0x0A,
        /// <summary>
        /// The Hebrew code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0590.pdf</remarks>
        Hebrew                                      = 1 << 0x0B,
        /// <summary>
        /// The Arabic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0600.pdf</remarks>
        Arabic                                      = 1 << 0x0C,
        /// <summary>
        /// The Syriac code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0700.pdf</remarks>
        Syriac                                      = 1 << 0x0D,
        /// <summary>
        /// The Arabic Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0750.pdf</remarks>
        ArabicSupplement                            = 1 << 0x0E,
        /// <summary>
        /// The Thaana code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0780.pdf</remarks>
        Thaana                                      = 1 << 0x0F,
        /// <summary>
        /// The Nko code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U07C0.pdf</remarks>
        Nko                                         = 1 << 0x10,
        /// <summary>
        /// The Samaritan code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0800.pdf</remarks>
        Samaritan                                   = 1 << 0x11,
        /// <summary>
        /// The Devanagari code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0900.pdf</remarks>
        Devanagari                                  = 1 << 0x12,
        /// <summary>
        /// The Bengali code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0980.pdf</remarks>
        Bengali                                     = 1 << 0x13,
        /// <summary>
        /// The Gurmukhi code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0A00.pdf</remarks>
        Gurmukhi                                    = 1 << 0x14,
        /// <summary>
        /// The Gujarati code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0A80.pdf</remarks>
        Gujarati                                    = 1 << 0x15,
        /// <summary>
        /// The Oriya code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0B00.pdf</remarks>
        Oriya                                       = 1 << 0x16,
        /// <summary>
        /// The Tamil code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0B80.pdf</remarks>
        Tamil                                       = 1 << 0x17,
        /// <summary>
        /// The Telugu code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0C00.pdf</remarks>
        Telugu                                      = 1 << 0x18,
        /// <summary>
        /// The Kannada code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0C80.pdf</remarks>
        Kannada                                     = 1 << 0x19,
        /// <summary>
        /// The Malayalam code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0D00.pdf</remarks>
        Malayalam                                   = 1 << 0x1A,
        /// <summary>
        /// The Sinhala code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0D80.pdf</remarks>
        Sinhala                                     = 1 << 0x1B,
        /// <summary>
        /// The Thai code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0E00.pdf</remarks>
        Thai                                        = 1 << 0x1C,
        /// <summary>
        /// The Lao code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0E80.pdf</remarks>
        Lao                                         = 1 << 0x1D,
        /// <summary>
        /// The Tibetan code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U0F00.pdf</remarks>
        Tibetan                                     = 1 << 0x1E,
        /// <summary>
        /// The default code tables marked as safe on initialisation.
        /// </summary>
        Default = BasicLatin | C1ControlsAndLatin1Supplement | LatinExtendedA | LatinExtendedB | SpacingModifierLetters | IpaExtensions | CombiningDiacriticalMarks
    }
    /// <summary>
    /// Values for the lower-mid section of the UTF8 Unicode code tables, from U1000 to U1EFF.
    /// </summary>
    [Flags]
    public enum LowerMidCodeCharts : long
    {
        /// <summary>
        /// No code charts from the lower-mid region of the Unicode tables are safe-listed.
        /// </summary>
        None                                        = 0,
        /// <summary>
        /// The Myanmar code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1000.pdf</remarks>
        Myanmar                                      = 1 << 0x00,
        /// <summary>
        /// The Georgian code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U10A0.pdf</remarks>
        Georgian                                    = 1 << 0x01,
        /// <summary>
        /// The Hangul Jamo code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1100.pdf</remarks>
        HangulJamo                                  = 1 << 0x02,
        /// <summary>
        /// The Ethiopic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1200.pdf</remarks>
        Ethiopic                                    = 1 << 0x03,
        /// <summary>
        /// The Ethiopic supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1380.pdf</remarks>
        EthiopicSupplement                          = 1 << 0x04,
        /// <summary>
        /// The Cherokee code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U13A0.pdf</remarks>
        Cherokee                                    = 1 << 0x05,
        /// <summary>
        /// The Unified Canadian Aboriginal Syllabics code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1400.pdf</remarks>
        UnifiedCanadianAboriginalSyllabics          = 1 << 0x06,
        /// <summary>
        /// The Ogham code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1680.pdf</remarks>
        Ogham                                       = 1 << 0x07,
        /// <summary>
        /// The Runic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U16A0.pdf</remarks>
        Runic                                       = 1 << 0x08,
        /// <summary>
        /// The Tagalog code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1700.pdf</remarks>
        Tagalog                                     = 1 << 0x09,
        /// <summary>
        /// The Hanunoo code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1720.pdf</remarks>
        Hanunoo                                     = 1 << 0x0A,
        /// <summary>
        /// The Buhid code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1740.pdf</remarks>
        Buhid                                       = 1 << 0x0B,
        /// <summary>
        /// The Tagbanwa code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1760.pdf</remarks>
        Tagbanwa                                    = 1 << 0x0C,
        /// <summary>
        /// The Khmer code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1780.pdf</remarks>
        Khmer                                       = 1 << 0x0D,
        /// <summary>
        /// The Mongolian code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1800.pdf</remarks>
        Mongolian                                   = 1 << 0x0E,
        /// <summary>
        /// The Unified Canadian Aboriginal Syllabics Extended code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U18B0.pdf</remarks>
        UnifiedCanadianAboriginalSyllabicsExtended  = 1 << 0x0F,
        /// <summary>
        /// The Limbu code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1900.pdf</remarks>
        Limbu                                       = 1 << 0x10,
        /// <summary>
        /// The Tai Le code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1950.pdf</remarks>
        TaiLe                                       = 1 << 0x11,
        /// <summary>
        /// The New Tai Lue code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1980.pdf</remarks>
        NewTaiLue                                   = 1 << 0x12,
        /// <summary>
        /// The Khmer Symbols code table
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U19E0.pdf</remarks>
        KhmerSymbols                                = 1 << 0x13,
        /// <summary>
        /// The Buginese code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1A00.pdf</remarks>
        Buginese                                    = 1 << 0x14,
        /// <summary>
        /// The Tai Tham code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1A20.pdf</remarks>
        TaiTham                                     = 1 << 0x15,
        /// <summary>
        /// The Balinese code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1B00.pdf</remarks>
        Balinese                                    = 1 << 0x16,
        /// <summary>
        /// The Sudanese code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1B80.pdf</remarks>
        Sudanese                                    = 1 << 0x17,
        /// <summary>
        /// The Lepcha code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1C00.pdf</remarks>
        Lepcha                                      = 1 << 0x18,
        /// <summary>
        /// The Ol Chiki code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1C50.pdf</remarks>
        OlChiki                                     = 1 << 0x19,
        /// <summary>
        /// The Vedic Extensions code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1CD0.pdf</remarks>
        VedicExtensions                             = 1 << 0x1A,
        /// <summary>
        /// The Phonetic Extensions code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1D00.pdf</remarks>
        PhoneticExtensions                          = 1 << 0x1B,
        /// <summary>
        /// The Phonetic Extensions Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1D80.pdf</remarks>
        PhoneticExtensionsSupplement                = 1 << 0x1C,        
        /// <summary>
        /// The Combining Diacritical Marks Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1DC0.pdf</remarks>        
        CombiningDiacriticalMarksSupplement         = 1 << 0x1D,
        /// <summary>
        /// The Latin Extended Additional code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1E00.pdf</remarks>
        LatinExtendedAdditional                     = 1 << 0x0E
    }
    /// <summary>
    /// Values for the middle section of the UTF8 Unicode code tables, from U1F00 to U2DDF
    /// </summary>
    [Flags]
    public enum MidCodeCharts : long
    {
        /// <summary>
        /// No code charts from the lower region of the Unicode tables are safe-listed.
        /// </summary>
        None                                        = 0,
        /// <summary>
        /// The Greek Extended code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U1F00.pdf</remarks>
        GreekExtended                               = 1 << 0x00,
        /// <summary>
        /// The General Punctuation code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2000.pdf</remarks>
        GeneralPunctuation                          = 1 << 0x01,
        /// <summary>
        /// The Superscripts and Subscripts code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2070.pdf</remarks>
        SuperscriptsAndSubscripts                   = 1 << 0x02,
        /// <summary>
        /// The Currency Symbols code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U20A0.pdf</remarks>
        CurrencySymbols                             = 1 << 0x03,
        /// <summary>
        /// The Combining Diacritical Marks for Symbols code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U20D0.pdf</remarks>
        CombiningDiacriticalMarksForSymbols         = 1 << 0x04,
        /// <summary>
        /// The Letterlike Symbols code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2100.pdf</remarks>
        LetterlikeSymbols                           = 1 << 0x05,
        /// <summary>
        /// The Number Forms code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2150.pdf</remarks>
        NumberForms                                 = 1 << 0x06,
        /// <summary>
        /// The Arrows code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2190.pdf</remarks>
        Arrows                                      = 1 << 0x07,
        /// <summary>
        /// The Mathematical Operators code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2200.pdf</remarks>
        MathematicalOperators                       = 1 << 0x08,
        /// <summary>
        /// The Miscellaneous Technical code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2300.pdf</remarks>
        MiscellaneousTechnical                      = 1 << 0x09,
        /// <summary>
        /// The Control Pictures code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2400.pdf</remarks>
        ControlPictures                             = 1 << 0x0A,
        /// <summary>
        /// The Optical Character Recognition table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2440.pdf</remarks>
        OpticalCharacterRecognition                 = 1 << 0x0B,
        /// <summary>
        /// The Enclosed Alphanumeric code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2460.pdf</remarks>
        EnclosedAlphanumerics                       = 1 << 0x0C,
        /// <summary>
        /// The Box Drawing code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2500.pdf</remarks>
        BoxDrawing                                  = 1 << 0x0D,
        /// <summary>
        /// The Block Elements code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2580.pdf</remarks>
        BlockElements                               = 1 << 0x0E,
        /// <summary>
        /// The Geometric Shapes code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U25A0.pdf</remarks>
        GeometricShapes                             = 1 << 0x0F,
        /// <summary>
        /// The Miscellaneous Symbols code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2600.pdf</remarks>
        MiscellaneousSymbols                        = 1 << 0x10,
        /// <summary>
        /// The Dingbats code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2700.pdf</remarks>
        Dingbats                                    = 1 << 0x11,
        /// <summary>
        /// The Miscellaneous Mathematical Symbols-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U27C0.pdf</remarks>
        MiscellaneousMathematicalSymbolsA           = 1 << 0x12,
        /// <summary>
        /// The Supplemental Arrows-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U27F0.pdf</remarks>
        SupplementalArrowsA                         = 1 << 0x13,
        /// <summary>
        /// The Braille Patterns code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2800.pdf</remarks>
        BraillePatterns                             = 1 << 0x14,
        /// <summary>
        /// The Supplemental Arrows-B code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2900.pdf</remarks>
        SupplementalArrowsB                         = 1 << 0x15,
        /// <summary>
        /// The Miscellaneous Mathematical Symbols-B code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2980.pdf</remarks>                
        MiscellaneousMathematicalSymbolsB           = 1 << 0x16,
        /// <summary>
        /// The Supplemental Mathematical Operators code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2A00.pdf</remarks>
        SupplementalMathematicalOperators           = 1 << 0x17,
        /// <summary>
        /// The Miscellaneous Symbols and Arrows code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2B00.pdf</remarks>        
        MiscellaneousSymbolsAndArrows               = 1 << 0x18,
        /// <summary>
        /// The Glagolitic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2C00.pdf</remarks>
        Glagolitic                                  = 1 << 0x19,
        /// <summary>
        /// The Latin Extended-C code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2C60.pdf</remarks>        
        LatinExtendedC                              = 1 << 0x1A,
        /// <summary>
        /// The Coptic code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2C80.pdf</remarks>
        Coptic                                      = 1 << 0x1B,
        /// <summary>
        /// The Georgian Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2D00.pdf</remarks>
        GeorgianSupplement                          = 1 << 0x1C,
        /// <summary>
        /// The Tifinagh code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2D30.pdf</remarks>
        Tifinagh                                    = 1 << 0x1D,
        /// <summary>
        /// The Ethiopic Extended code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2D80.pdf</remarks>
        EthiopicExtended                            = 1 << 0x0E,    
    }
    /// <summary>
    /// Values for the upper middle section of the UTF8 Unicode code tables, from U2DE0 to UA8DF
    /// </summary>
    [Flags]
    public enum UpperMidCodeCharts : long
    {
        /// <summary>
        /// No code charts from the lower region of the Unicode tables are safe-listed.
        /// </summary>
        None                                        = 0,                  
        /// <summary>
        /// The Cyrillic Extended-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2DE0.pdf</remarks>
        CyrillicExtendedA                           = 1 << 0x00,
        /// <summary>
        /// The Supplemental Punctuation code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2E00.pdf</remarks>
        SupplementalPunctuation                     = 1 << 0x01,
        /// <summary>
        /// The CJK Radicials Supplement code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2E80.pdf</remarks>
        CjkRadicalsSupplement                       = 1 << 0x02,
        /// <summary>
        /// The Kangxi Radicials code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2F00.pdf</remarks>
        KangxiRadicals                              = 1 << 0x03,
        /// <summary>
        /// The Ideographic Description Characters code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U2FF0.pdf</remarks>
        IdeographicDescriptionCharacters            = 1 << 0x04,
        /// <summary>
        /// The CJK Symbols and Punctuation code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3000.pdf</remarks>
        CjkSymbolsAndPunctuation                    = 1 << 0x05,
        /// <summary>
        /// The Hiragana code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3040.pdf</remarks>
        Hiragana                                    = 1 << 0x06,
        /// <summary>
        /// The Katakana code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U30A0.pdf</remarks>
        Katakana                                    = 1 << 0x07,
        /// <summary>
        /// The Bopomofo code table.
        /// <seealso cref="BopomofoExtended"/>
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3100.pdf</remarks>
        Bopomofo                                    = 1 << 0x08,
        /// <summary>
        /// The Hangul Compatbility Jamo code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3130.pdf</remarks>
        HangulCompatibilityJamo                     = 1 << 0x09,
        /// <summary>
        /// The Kanbun code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3190.pdf</remarks>
        Kanbun                                      = 1 << 0x0A,
        /// <summary>
        /// The Bopomofu Extended code table.
        /// <seealso cref="Bopomofo"/>
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U31A0.pdf</remarks>
        BopomofoExtended                            = 1 << 0x0B,
        /// <summary>
        /// The CJK Strokes code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U31C0.pdf</remarks>
        CjkStrokes                                  = 1 << 0x0C,
        /// <summary>
        /// The Katakana Phonetic Extensoins code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U31F0.pdf</remarks>
        KatakanaPhoneticExtensions                  = 1 << 0x0D,
        /// <summary>
        /// The Enclosed CJK Letters and Months code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3200.pdf</remarks>
        EnclosedCjkLettersAndMonths                 = 1 << 0x0E,
        /// <summary>
        /// The CJK Compatibility code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3300.pdf</remarks>
        CjkCompatibility                            = 1 << 0x0F,
        /// <summary>
        /// The CJK Unified Ideographs Extension A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U3400.pdf</remarks>
        CjkUnifiedIdeographsExtensionA              = 1 << 0x10,
        /// <summary>
        /// The Yijing Hexagram Symbols code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U4DC0.pdf</remarks>
        YijingHexagramSymbols                       = 1 << 0x11,
        /// <summary>
        /// The CJK Unified Ideographs code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/U4E00.pdf</remarks>
        CjkUnifiedIdeographs                        = 1 << 0x12,
        /// <summary>
        /// The Yi Syllables code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA000.pdf</remarks>
        YiSyllables                                 = 1 << 0x13,
        /// <summary>
        /// The Yi Radicals code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA490.pdf</remarks>
        YiRadicals                                  = 1 << 0x14,
        /// <summary>
        /// The Lisu code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA4D0.pdf</remarks>        
        Lisu                                        = 1 << 0x15,
        /// <summary>
        /// The Vai code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA500.pdf</remarks>
        Vai                                         = 1 << 0x16,
        /// <summary>
        /// The Cyrillic Extended-B code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA640.pdf</remarks>
        CyrillicExtendedB                           = 1 << 0x17,
        /// <summary>
        /// The Bamum code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA6A0.pdf</remarks>
        Bamum                                       = 1 << 0x18,
        /// <summary>
        /// The Modifier Tone Letters code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA700.pdf</remarks>
        ModifierToneLetters                         = 1 << 0x19,
        /// <summary>
        /// The Latin Extended-D code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA720.pdf</remarks>
        LatinExtendedD                              = 1 << 0x1A,
        /// <summary>
        /// The Syloti Nagri code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA800.pdf</remarks>
        SylotiNagri                                 = 1 << 0x1B,
        /// <summary>
        /// The Common Indic Number Forms code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA830.pdf</remarks>
        CommonIndicNumberForms                      = 1 << 0x1C,
        /// <summary>
        /// The Phags-pa code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA840.pdf</remarks>
        Phagspa                                     = 1 << 0x1D,
        /// <summary>
        /// The Saurashtra code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA880.pdf</remarks>
        Saurashtra                                  = 1 << 0x1E,
    }
    /// <summary>
    /// Values for the upper section of the UTF8 Unicode code tables, from UA8E0 to UFFFD
    /// </summary>
    [Flags]
    public enum UpperCodeCharts
    {
        /// <summary>
        /// No code charts from the upper region of the Unicode tables are safe-listed.
        /// </summary>
        None                                        = 0,
        /// <summary>
        /// The Devanagari Extended code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA8E0.pdf</remarks>
        DevanagariExtended                          = 1 << 0x00,
        /// <summary>
        /// The Kayah Li code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA900.pdf</remarks>
        KayahLi                                     = 1 << 0x01,
        /// <summary>
        /// The Rejang code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA930.pdf</remarks>
        Rejang                                      = 1 << 0x02,
        /// <summary>
        /// The Hangul Jamo Extended-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA960.pdf</remarks>
        HangulJamoExtendedA                         = 1 << 0x03,
        /// <summary>
        /// The Javanese code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UA980.pdf</remarks>
        Javanese                                    = 1 << 0x04,
        /// <summary>
        /// The Cham code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UAA00.pdf</remarks>
        Cham                                        = 1 << 0x05,
        /// <summary>
        /// The Myanmar Extended-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UAA60.pdf</remarks>
        MyanmarExtendedA                            = 1 << 0x06,
        /// <summary>
        /// The Tai Viet code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UAA80.pdf</remarks>
        TaiViet                                     = 1 << 0x07,
        /// <summary>
        /// The Meetei Mayek code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UABC0.pdf</remarks>
        MeeteiMayek                                 = 1 << 0x08,
        /// <summary>
        /// The Hangul Syllables code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UAC00.pdf</remarks>
        HangulSyllables                             = 1 << 0x09,
        /// <summary>
        /// The Hangul Jamo Extended-B code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UD7B0.pdf</remarks>
        HangulJamoExtendedB                         = 1 << 0x0A,
        /// <summary>
        /// The CJK Compatibility Ideographs code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UF900.pdf</remarks>
        CjkCompatibilityIdeographs                  = 1 << 0x0B,
        /// <summary>
        /// The Alphabetic Presentation Forms code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFB00.pdf</remarks>
        AlphabeticPresentationForms                 = 1 << 0x0C,
        /// <summary>
        /// The Arabic Presentation Forms-A code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFB50.pdf</remarks>
        ArabicPresentationFormsA                    = 1 << 0x0D,
        /// <summary>
        /// The Variation Selectors code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFE00.pdf</remarks>
        VariationSelectors                          = 1 << 0x0E,
        /// <summary>
        /// The Vertical Forms code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFE10.pdf</remarks>
        VerticalForms                               = 1 << 0x0F,
        /// <summary>
        /// The Combining Half Marks code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFE20.pdf</remarks>
        CombiningHalfMarks                          = 1 << 0x10,
        /// <summary>
        /// The CJK Compatibility Forms code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFE30.pdf</remarks>
        CjkCompatibilityForms                       = 1 << 0x11,
        /// <summary>
        /// The Small Form Variants code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFE50.pdf</remarks>
        SmallFormVariants                           = 1 << 0x12,
        /// <summary>
        /// The Arabic Presentation Forms-B code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFE70.pdf</remarks>
        ArabicPresentationFormsB                    = 1 << 0x13,
        /// <summary>
        /// The half width and full width Forms code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFF00.pdf</remarks>
        HalfWidthAndFullWidthForms                  = 1 << 0x14,
        /// <summary>
        /// The Specials code table.
        /// </summary>
        /// <remarks>http://www.unicode.org/charts/PDF/UFFF0.pdf</remarks>
        Specials                                    = 1 << 0x15,
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="CssEncoder.cs" company="Microsoft Corporation">
//   Copyright (c) 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides CSS Encoding methods.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    using System.Threading;
    /// <summary>
    /// Provides CSS Encoding methods.
    /// </summary>
    internal static class CssEncoder
    {
        /// <summary>
        /// A lock object to use when performing safe listing.
        /// </summary>
        private static readonly ReaderWriterLockSlim SyncLock = new ReaderWriterLockSlim();
        /// <summary>
        /// The values to output for each character.
        /// </summary>
        private static char[][] characterValues;
        /// <summary>
        /// Encodes according to the CSS encoding rules.
        /// </summary>
        /// <param name="input">The string to encode.</param>
        /// <returns>The encoded string.</returns>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        internal static string Encode(string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                return input;
            }
            if (characterValues == null)
            {
                InitialiseSafeList();
            }
            // Setup a new character array for output.
            char[] inputAsArray = input.ToCharArray();
            int outputLength = 0;
            int inputLength = inputAsArray.Length;
            char[] encodedInput = new char[inputLength * 7]; // Worse case scenario - CSS encoding wants \XXXXXX for encoded characters.
            SyncLock.EnterReadLock();
            try
            {
                for (int i = 0; i < inputLength; i++)
                {
                    char currentCharacter = inputAsArray[i];
                    int currentCodePoint = inputAsArray[i];
                    // Check for invalid values
                    if (currentCodePoint == 0xFFFE ||
                        currentCodePoint == 0xFFFF)
                    {
                        throw new InvalidUnicodeValueException(currentCodePoint);
                    }
                    else if (char.IsHighSurrogate(currentCharacter))
                    {
                        if (i + 1 == inputLength)
                        {
                            throw new InvalidSurrogatePairException(currentCharacter, '\0');
                        }
                        // Now peak ahead and check if the following character is a low surrogate.
                        char nextCharacter = inputAsArray[i + 1];
                        char nextCodePoint = inputAsArray[i + 1];
                        if (!char.IsLowSurrogate(nextCharacter))
                        {
                            throw new InvalidSurrogatePairException(currentCharacter, nextCharacter);
                        }
                        // Look-ahead was good, so skip.
                        i++;
                        // Calculate the combined code point
                        long combinedCodePoint =
                            0x10000 + ((currentCodePoint - 0xD800) * 0x400) + (nextCodePoint - 0xDC00);
                        char[] encodedCharacter = SafeList.SlashThenSixDigitHexValueGenerator(combinedCodePoint);
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                    }
                    else if (char.IsLowSurrogate(currentCharacter))
                    {
                        throw new InvalidSurrogatePairException('\0', currentCharacter);
                    }
                    else if (currentCodePoint > characterValues.Length - 1)
                    {
                        char[] encodedCharacter = SafeList.SlashThenSixDigitHexValueGenerator(currentCodePoint);
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }                        
                    }
                    else if (characterValues[currentCodePoint] != null)
                    {
                        // character needs to be encoded
                        char[] encodedCharacter = characterValues[currentCodePoint];
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                    }
                    else
                    {
                        // character does not need encoding
                        encodedInput[outputLength++] = currentCharacter;
                    }
                }
            }
            finally
            {
                SyncLock.ExitReadLock();
            }
            return new string(encodedInput, 0, outputLength);
        }
        /// <summary>
        /// Initializes the HTML safe list.
        /// </summary>
        private static void InitialiseSafeList()
        {
            SyncLock.EnterWriteLock();
            try
            {
                if (characterValues == null)
                {
                    characterValues = SafeList.Generate(0xFF, SafeList.SlashThenSixDigitHexValueGenerator);
                    SafeList.PunchSafeList(ref characterValues, CssSafeList());
                }
            }
            finally
            {
                SyncLock.ExitWriteLock();
            }
        }
        /// <summary>
        /// Provides the safe characters for CS encoding.
        /// </summary>
        /// <returns>The safe characters for CSS encoding.</returns>
        /// <remarks>See http://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet </remarks>
        private static IEnumerable CssSafeList()
        {
            for (int i = '0'; i <= '9'; i++)
            {
                yield return i;
            }
            for (int i = 'A'; i <= 'Z'; i++)
            {
                yield return i;
            }
            for (int i = 'a'; i <= 'z'; i++)
            {
                yield return i;
            }
            // Extended higher ASCII, Ç to É
            for (int i = 0x80; i <= 0x90; i++)
            {
                yield return i;
            }
            // Extended higher ASCII, ô to Ü
            for (int i = 0x93; i <= 0x9A; i++)
            {
                yield return i;
            }
            // Extended higher ASCII, á to Ñ
            for (int i = 0xA0; i <= 0xA5; i++)
            {
                yield return i;
            }
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Encoder.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Performs encoding of input strings to provide protection against
//   Cross-Site Scripting (XSS) attacks and LDAP injection attacks in
//   various contexts.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System;
    using System.Globalization;
    using System.Text;
    /// <summary>
    /// Performs encoding of input strings to provide protection against
    /// Cross-Site Scripting (XSS) attacks and LDAP injection attacks in 
    /// various contexts.
    /// </summary>
    /// <remarks>
    /// This encoding library uses the Principle of Inclusions, 
    /// sometimes referred to as "safe-listing" to provide protection 
    /// against injection attacks.  With safe-listing protection, 
    /// algorithms look for valid inputs and automatically treat 
    /// everything outside that set as a potential attack.  This library 
    /// can be used as a defense in depth approach with other mitigation 
    /// techniques. It is suitable for applications with high security 
    /// requirements.
    /// </remarks>
    public static class Encoder
    {
        /// <summary>
        /// Empty string for Visual Basic Script context
        /// </summary>
        private const string VbScriptEmptyString = "\"\"";
        /// <summary>
        /// Empty string for Java Script context
        /// </summary>
        private const string JavaScriptEmptyString = "''";
        /// <summary>
        /// Initializes character Html encoding array
        /// </summary>
        private static readonly char[][] SafeListCodes = InitializeSafeList();
        /// <summary>
        /// Encodes input strings for use as a value  in Lightweight Directory Access Protocol (LDAP) filter queries.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>Encoded string for use as a value in LDAP filter queries.</returns>
        /// <remarks>This method encodes all but known safe characters defined in the safe list.
        /// <newpara/>
        /// RFC 4515 defines the format in which special characters need to be 
        /// escaped to be used inside a search filter. Special characters need to be 
        /// encoded in \XX format where XX is the hex representation of the character.
        /// <newpara/>
        /// The following examples illustrate the use of the escaping mechanism.
        /// <list type="table">
        /// <item><term>Parens R Us (for all your parenthetical needs)</term><description>Parens R Us \28for all your parenthetical needs\29</description></item>
        /// <item><term>*</term><description>\2A</description></item>
        /// <item><term>C:\MyFile</term><description>C:\5CMyFile</description></item>
        /// <item><term>NULLNULLNULLEOT (binary)</term><description>\00\00\00\04</description></item>
        /// <item><term>Lučić</term><description>Lu\C4\8Di\C4\87</description></item>
        /// </list>
        /// </remarks>
        public static string LdapFilterEncode(string input)
        {
            return LdapEncoder.FilterEncode(input);
        }
        /// <summary>
        /// Encodes input strings for use as a value in Lightweight Directory Access Protocol (LDAP) DNs.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>Encoded string for use as a value in LDAP DNs.</returns>
        /// <remarks>This method encodes all but known safe characters defined in the safe list.
        /// <newpara/>
        /// RFC 2253 defines the format in which special characters need to be 
        /// escaped to be used inside a search filter. Special characters need to be 
        /// encoded in #XX format where XX is the hex representation of the character or a 
        /// specific \ escape format.
        /// <newpara/>
        /// The following examples illustrate the use of the escaping mechanism.
        /// <list type="table">
        /// <item><term>, + \ " \ &lt; &gt;</term><description>\, \+ \" \\ \&lt; \&gt;</description></item>
        /// <item><term> hello</term><description>\ hello</description></item>
        /// <item><term>hello </term><description>hello \ </description></item>
        /// <item><term>#hello</term><description>\#hello</description></item>
        /// <item><term>Lučić</term><description>Lu#C4#8Di#C4#87</description></item>
        /// </list>
        /// </remarks>
        public static string LdapDistinguishedNameEncode(string input)
        {
            return LdapDistinguishedNameEncode(input, true, true);
        }
        /// <summary>
        /// Encodes input strings for use as a value in Lightweight Directory Access Protocol (LDAP) DNs.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="useInitialCharacterRules">Value indicating whether the special case rules for encoding of spaces and octothorpes at the start of a string are used.</param>
        /// <param name="useFinalCharacterRule">Value indicating whether the special case for encoding of final character spaces is used.</param>
        /// <returns>Encoded string for use as a value in LDAP DNs.</returns>\
        /// <remarks>This method encodes all but known safe characters defined in the safe list.
        /// <newpara/>
        /// RFC 2253 defines the format in which special characters need to be 
        /// escaped to be used inside a search filter. Special characters need to be 
        /// encoded in #XX format where XX is the hex representation of the character or a 
        /// specific \ escape format.
        /// <newpara/>
        /// The following examples illustrate the use of the escaping mechanism.
        /// <list type="table">
        /// <item><term>, + \ " \ &lt; &gt;</term><description>\, \+ \" \\ \&lt; \&gt;</description></item>
        /// <item><term> hello</term><description>\ hello</description></item>
        /// <item><term>hello </term><description>hello\ </description></item>
        /// <item><term>#hello</term><description>\#hello</description></item>
        /// <item><term>Lučić</term><description>Lu#C4#8Di#C4#87</description></item>
        /// </list>
        /// If useInitialCharacterRules is set to false then escaping of the initial space or octothorpe characters is not performed;
        /// <list type="table">
        /// <item><term>, + \ " \ &lt; &gt;</term><description>\, \+ \" \\ \&lt; \&gt;</description></item>
        /// <item><term> hello</term><description> hello</description></item>
        /// <item><term>hello </term><description>hello\ </description></item>
        /// <item><term>#hello</term><description>#hello</description></item>
        /// <item><term>Lučić</term><description>Lu#C4#8Di#C4#87</description></item>
        /// </list>
        /// If useFinalCharacterRule is set to false then escaping of a space at the end of a string is not performed;
        /// <list type="table">
        /// <item><term>, + \ " \ &lt; &gt;</term><description>\, \+ \" \\ \&lt; \&gt;</description></item>
        /// <item><term> hello</term><description> hello</description></item>
        /// <item><term>hello </term><description>hello </description></item>
        /// <item><term>#hello</term><description>#hello</description></item>
        /// <item><term>Lučić</term><description>Lu#C4#8Di#C4#87</description></item>
        /// </list>
        /// </remarks>
        public static string LdapDistinguishedNameEncode(string input, bool useInitialCharacterRules, bool useFinalCharacterRule)
        {
            return LdapEncoder.DistinguishedNameEncode(input, useInitialCharacterRules, useFinalCharacterRule);
        }
        /// <summary>
        /// Encodes input strings to be used as a value in Lightweight Directory Access Protocol (LDAP) search queries.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>Encoded string for use in LDAP search queries.</returns>
        /// <remarks>This method encodes all but known safe characters defined in the safe list.
        /// <newpara/>
        /// RFC 4515 defines the format in which special characters need to be 
        /// escaped to be used inside a search filter. Special characters need to be 
        /// encoded in \XX format where XX is the hex representation of the character.
        /// <newpara/>
        /// The following examples illustrate the use of the escaping mechanism.
        /// <list type="table">
        /// <item><term>Parens R Us (for all your parenthetical needs)</term><description>Parens R Us \28for all your parenthetical needs\29</description></item>
        /// <item><term>*</term><description>\2A</description></item>
        /// <item><term>C:\MyFile</term><description>C:\5CMyFile</description></item>
        /// <item><term>NULLNULLNULLEOT (binary)</term><description>\00\00\00\04</description></item>
        /// <item><term>Lučić</term><description>Lu\C4\8Di\C4\87</description></item>
        /// </list>
        /// </remarks>
        [Obsolete("This method has been deprecated. Please use Encoder.LdapFilterEncode() instead.")]
        public static string LdapEncode(string input)
        {
            return LdapFilterEncode(input);
        }
        /// <summary>
        /// Encodes input strings used in Cascading Style Sheet (CSS) elements values.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>Encoded string for use in CSS element values.</returns>
        /// <remarks>This method encodes all but known safe characters defined in the safe list.
        /// <newpara/>
        /// The CSS character escape sequence consists of a backslash character (\) followed by 
        /// between one and six hexadecimal digits that represent a character code from the 
        /// ISO 10646 standard (which is equivalent to Unicode, for all intents and purposes). Any 
        /// character other than a hexadecimal digit will terminate the escape sequence. If a 
        /// character following the escape sequence is also a valid hexadecimal digit then it must 
        /// either include six digits in the escape, or use a whitespace character to terminate the 
        /// escape. This encoder enforces the six digit rule.
        /// For example \000020 denotes a space.
        /// </remarks>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        public static string CssEncode(string input)
        {
            return CssEncoder.Encode(input);
        }
        /// <summary>
        /// Encodes input strings for use in HTML.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in HTML.
        /// </returns>
        /// <remarks>
        /// All characters not safe listed are encoded to their Unicode decimal value, using &amp;#DECIMAL; notation.
        /// The default safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>'</term><description>Apostrophe</description></item>
        /// <item><term> </term><description>Space</description></item>
        /// </list>
        /// The safe list may be adjusted using <see cref="UnicodeCharacterEncoder.MarkAsSafe"/>.
        /// <newpara/>
        /// Example inputs and their related encoded outputs:
        /// <list type="table">
        /// <item><term>&lt;script&gt;alert('XSS Attack!');&lt;/script&gt;</term><description>&amp;lt;script&amp;gt;alert('XSS Attack!');&amp;lt;/script&amp;gt;</description></item>
        /// <item><term>user@contoso.com</term><description>user@contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross Site Scripting Library</description></item>
        /// <item><term>"Anti-Cross Site Scripting Library"</term><description>&amp;quote;Anti-Cross Site Scripting Library&amp;quote;</description></item>
        /// </list>
        /// </remarks>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        public static string HtmlEncode(string input)
        {
            return HtmlEncode(input, false);
        }
        /// <summary>
        /// Encodes input strings for use in HTML.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="useNamedEntities">Value indicating if the HTML 4.0 named entities should be used.</param>
        /// <returns>
        /// Encoded string for use in HTML.
        /// </returns>
        /// <remarks>
        /// All characters not safe listed are encoded to their Unicode decimal value, using &amp;#DECIMAL; notation.
        /// If you choose to use named entities then if a character is an HTML4.0 named entity the named entity will be used.
        /// The default safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>'</term><description>Apostrophe</description></item>
        /// <item><term> </term><description>Space</description></item>
        /// </list>
        /// The safe list may be adjusted using <see cref="UnicodeCharacterEncoder.MarkAsSafe"/>.
        /// <newpara/>
        /// Example inputs and their related encoded outputs:
        /// <list type="table">
        /// <item><term>&lt;script&gt;alert('XSS Attack!');&lt;/script&gt;</term><description>&amp;lt;script&amp;gt;alert('XSS Attack!');&amp;lt;/script&amp;gt;</description></item>
        /// <item><term>user@contoso.com</term><description>user@contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross Site Scripting Library</description></item>
        /// <item><term>"Anti-Cross Site Scripting Library"</term><description>&amp;quote;Anti-Cross Site Scripting Library&amp;quote;</description></item>
        /// </list>
        /// </remarks>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        public static string HtmlEncode(string input, bool useNamedEntities)
        {
            return UnicodeCharacterEncoder.HtmlEncode(input, useNamedEntities);
        }
        /// <summary>
        /// Encodes an input string for use in an HTML attribute.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>The input string encoded for use in an HTML attribute.</returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are encoded using  &amp;#DECIMAL; notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// </list>
        /// The safe list may be adjusted using <see cref="UnicodeCharacterEncoder.MarkAsSafe"/>.
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>alert(&amp;#39;XSS&amp;#32;Attack!&amp;#39;);</description></item>
        /// <item><term>user@contoso.com</term><description>user@contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross&amp;#32;Site&amp;#32;Scripting&amp;#32;Library</description></item>
        /// </list>
        /// </remarks>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        public static string HtmlAttributeEncode(string input)
        {
            return UnicodeCharacterEncoder.HtmlAttributeEncode(input);
        }
        /// <summary>
        /// Encodes input strings for use in universal resource locators (URLs).
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in URLs.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are encoded using %SINGLE_BYTE_HEX 
        /// and %DOUBLE_BYTE_HEX notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>~</term><description>Tilde</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>alert%28%27XSS%20Attack%21%27%29%3b</description></item>
        /// <item><term>user@contoso.com</term><description>user%40contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross%20Site%20Scripting%20Library</description></item>
        /// </list>
        /// </remarks>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "As this is meant as a replacement for HttpUility.Encode we must keep the same return type.")]
        public static string UrlEncode(string input)
        {
            return UrlEncode(input, Encoding.UTF8);
        }
        /// <summary>
        /// Encodes input strings for use in application/x-www-form-urlencoded form submissions.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in URLs.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are encoded using %SINGLE_BYTE_HEX 
        /// and %DOUBLE_BYTE_HEX notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>~</term><description>Tilde</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>alert%28%27XSS+Attack%21%27%29%3b</description></item>
        /// <item><term>user@contoso.com</term><description>user%40contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross+Site+Scripting+Library</description></item>
        /// </list>
        /// </remarks>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "This does not return a URL so the return type can be a string.")]
        public static string HtmlFormUrlEncode(string input)
        {
            return HtmlFormUrlEncode(input, Encoding.UTF8);
        }
        /// <summary>
        /// Encodes input strings for use in universal resource locators (URLs).
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="codePage">Codepage number of the input.</param>
        /// <returns>
        /// Encoded string for use in URLs.
        /// </returns>
        /// <remarks>
        /// This function encodes the output as per the encoding parameter (codepage) passed to it. It encodes 
        /// all but known safe characters.  Characters are encoded using %SINGLE_BYTE_HEX and %DOUBLE_BYTE_HEX notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>~</term><description>Tilde</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSSあAttack!');</term><description>alert%28%27XSS%82%a0Attack%21%27%29%3b</description></item>
        /// <item><term>user@contoso.com</term><description>user%40contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross%20Site%20Scripting%20Library</description></item>
        /// </list>
        /// </remarks>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "This does not return a URL so the return type can be a string.")]
        public static string UrlEncode(string input, int codePage)
        {
            return UrlEncode(input, Encoding.GetEncoding(codePage));
        }
        /// <summary>
        /// Encodes input strings for use in application/x-www-form-urlencoded form submissions.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="codePage">Codepage number of the input.</param>
        /// <returns>
        /// Encoded string for use in URLs.
        /// </returns>
        /// <remarks>
        /// This function encodes the output as per the encoding parameter (codepage) passed to it. It encodes 
        /// all but known safe characters.  Characters are encoded using %SINGLE_BYTE_HEX and %DOUBLE_BYTE_HEX notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>~</term><description>Tilde</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSSあAttack!');</term><description>alert%28%27XSS%82%a0Attack%21%27%29%3b</description></item>
        /// <item><term>user@contoso.com</term><description>user%40contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross+Site+Scripting+Library</description></item>
        /// </list>
        /// </remarks>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "This not not return a URL, so the return type can be a string.")]
        public static string HtmlFormUrlEncode(string input, int codePage)
        {
            return HtmlFormUrlEncode(input, Encoding.GetEncoding(codePage));
        }
        /// <summary>
        /// Encodes input strings for use in universal resource locators (URLs).
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="inputEncoding">Input encoding type.</param>
        /// <returns>
        /// Encoded string for use in URLs.
        /// </returns>
        /// <remarks>
        /// This function encodes the output as per the encoding parameter (codepage) passed to it. It encodes 
        /// all but known safe characters.  Characters are encoded using %SINGLE_BYTE_HEX and %DOUBLE_BYTE_HEX notation.
        /// If the inputEncoding is null then UTF-8 is assumed by default.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>~</term><description>Tilde</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSSあAttack!');</term><description>alert%28%27XSS%82%a0Attack%21%27%29%3b</description></item>
        /// <item><term>user@contoso.com</term><description>user%40contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross%20Site%20Scripting%20Library</description></item>
        /// </list>
        /// </remarks>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "This does not return a URL so the return type can be a string.")]
        public static string UrlEncode(string input, Encoding inputEncoding)
        {
            // Assuming the default to be UTF-8
            if (inputEncoding == null)
            {
                inputEncoding = Encoding.UTF8;
            }
            return HtmlParameterEncoder.QueryStringParameterEncode(input, inputEncoding);
        }
        /// <summary>
        /// Encodes input strings for use in application/x-www-form-urlencoded form submissions.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="inputEncoding">Input encoding type.</param>
        /// <returns>
        /// Encoded string for use in URLs.
        /// </returns>
        /// <remarks>
        /// This function encodes the output as per the encoding parameter (codepage) passed to it. It encodes 
        /// all but known safe characters.  Characters are encoded using %SINGLE_BYTE_HEX and %DOUBLE_BYTE_HEX notation.
        /// If the inputEncoding is null then UTF-8 is assumed by default.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term>~</term><description>Tilde</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSSあAttack!');</term><description>alert%28%27XSS%82%a0Attack%21%27%29%3b</description></item>
        /// <item><term>user@contoso.com</term><description>user%40contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross+Site+Scripting+Library</description></item>
        /// </list>
        /// </remarks>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "This does not return a URL so the return type can be a string.")]
        public static string HtmlFormUrlEncode(string input, Encoding inputEncoding)
        {
            // Assuming the default to be UTF-8
            if (inputEncoding == null)
            {
                inputEncoding = Encoding.UTF8;
            }
            return HtmlParameterEncoder.FormStringParameterEncode(input, inputEncoding);
        }
        /// <summary>
        /// Encodes input strings for use in XML.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in XML.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters. Characters are encoded using &amp;#DECIMAL; notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term> </term><description>Space</description></item>
        /// </list>
        /// The safe list may be adjusted using <see cref="UnicodeCharacterEncoder.MarkAsSafe"/>.
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>alert(&amp;apos;XSS Attack!&amp;apos;);</description></item>
        /// <item><term>user@contoso.com</term><description>user@contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross Site Scripting Library</description></item>
        /// </list>
        /// </remarks>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        public static string XmlEncode(string input)
        {
            return UnicodeCharacterEncoder.XmlEncode(input);
        }
        /// <summary>
        /// Encodes input strings for use in XML attributes.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in XML attributes.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are encoded using &amp;#DECIMAL; notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// </list>
        /// The safe list may be adjusted using <see cref="UnicodeCharacterEncoder.MarkAsSafe"/>.
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>alert(&amp;apos;XSS Attack!&amp;apos);</description></item>
        /// <item><term>user@contoso.com</term><description>user@contoso.com</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>Anti-Cross&amp;#32;Site&amp;#32;Scripting&amp;#32;Library</description></item>
        /// </list>
        /// </remarks>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        public static string XmlAttributeEncode(string input)
        {
            // HtmlEncodeAttribute will handle input
            return UnicodeCharacterEncoder.XmlAttributeEncode(input);
        }
        /// <summary>
        /// Encodes input strings for use in JavaScript.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in JavaScript.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are encoded using \xSINGLE_BYTE_HEX and \uDOUBLE_BYTE_HEX notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term> </term><description>Space</description></item>
        /// <item><term> </term><description>Other International character ranges</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>'alert\x28\x27XSS Attack\x21\x27\x29\x3b'</description></item>
        /// <item><term>user@contoso.com</term><description>'user\x40contoso.com'</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>'Anti-Cross Site Scripting Library'</description></item>
        /// </list>
        /// </remarks>
        public static string JavaScriptEncode(string input)
        {
            return JavaScriptEncode(input, true);
        }
        /// <summary>
        /// Encodes input strings for use in JavaScript.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <param name="emitQuotes">value indicating whether or not to emit quotes. true = emit quote. false = no quote.</param>
        /// <returns>
        /// Encoded string for use in JavaScript and does not return the output with en quotes.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are encoded using \xSINGLE_BYTE_HEX and \uDOUBLE_BYTE_HEX notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term> </term><description>Space</description></item>
        /// <item><term> </term><description>Other International character ranges</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>'alert\x28\x27XSS Attack\x21\x27\x29\x3b'</description></item>
        /// <item><term>user@contoso.com</term><description>'user\x40contoso.com'</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>'Anti-Cross Site Scripting Library'</description></item>
        /// </list>
        /// </remarks>
        public static string JavaScriptEncode(string input, bool emitQuotes)
        {
            // Input validation: empty or null string condition
            if (string.IsNullOrEmpty(input))
            {
                return emitQuotes ? JavaScriptEmptyString : string.Empty;
            }
            // Use a new char array.
            int outputLength = 0;
            int inputLength = input.Length;
            char[] returnMe = new char[inputLength * 8]; // worst case length scenario
            // First step is to start the encoding with an apostrophe if flag is true.
            if (emitQuotes)
            {
                returnMe[outputLength++] = '\'';
            }
            for (int i = 0; i < inputLength; i++)
            {
                int currentCharacterAsInteger = input[i];
                char currentCharacter = input[i];
                if (SafeListCodes[currentCharacterAsInteger] != null || currentCharacterAsInteger == 92 || (currentCharacterAsInteger >= 123 && currentCharacterAsInteger <= 127))
                {
                    // character needs to be encoded
                    if (currentCharacterAsInteger >= 127)
                    {
                        returnMe[outputLength++] = '\\';
                        returnMe[outputLength++] = 'u';
                        string hex = ((int)currentCharacter).ToString("x", CultureInfo.InvariantCulture).PadLeft(4, '0');
                        returnMe[outputLength++] = hex[0];
                        returnMe[outputLength++] = hex[1];
                        returnMe[outputLength++] = hex[2];
                        returnMe[outputLength++] = hex[3];
                    }
                    else
                    {
                        returnMe[outputLength++] = '\\';
                        returnMe[outputLength++] = 'x';
                        string hex = ((int)currentCharacter).ToString("x", CultureInfo.InvariantCulture).PadLeft(2, '0');
                        returnMe[outputLength++] = hex[0];
                        returnMe[outputLength++] = hex[1];
                    }
                }
                else
                {
                    // character does not need encoding
                    returnMe[outputLength++] = input[i];
                }
            }
            // Last step is to end the encoding with an apostrophe if flag is true.
            if (emitQuotes)
            {
                returnMe[outputLength++] = '\'';
            }
            return new string(returnMe, 0, outputLength);
        }
        /// <summary>
        /// Encodes input strings for use in Visual Basic Script.
        /// </summary>
        /// <param name="input">String to be encoded.</param>
        /// <returns>
        /// Encoded string for use in Visual Basic Script.
        /// </returns>
        /// <remarks>
        /// This function encodes all but known safe characters.  Characters are 
        /// encoded using &chrw(DECIMAL) notation.
        /// <newpara/>
        /// Safe characters include:
        /// <list type="table">
        /// <item><term>a-z</term><description>Lower case alphabet</description></item>
        /// <item><term>A-Z</term><description>Upper case alphabet</description></item>
        /// <item><term>0-9</term><description>Numbers</description></item>
        /// <item><term>,</term><description>Comma</description></item>
        /// <item><term>.</term><description>Period</description></item>
        /// <item><term>-</term><description>Dash</description></item>
        /// <item><term>_</term><description>Underscore</description></item>
        /// <item><term> </term><description>Space</description></item>
        /// </list>
        /// <newpara/>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>alert('XSS Attack!');</term><description>"alert"&chrw(40)&chrw(39)&"XSS Attack"&chrw(33)&chrw(39)&chrw(41)&chrw(59)</description></item>
        /// <item><term>user@contoso.com</term><description>"user"&chrw(64)&"contoso.com"</description></item>
        /// <item><term>Anti-Cross Site Scripting Library</term><description>"Anti-Cross Site Scripting Library"</description></item>
        /// </list></remarks>
        public static string VisualBasicScriptEncode(string input)
        {
            // Input validation: empty or null string condition
            if (string.IsNullOrEmpty(input))
            {
                return VbScriptEmptyString;
            }
            // Use a new char array.
            int outputLength = 0;
            int inputLength = input.Length;
            char[] encodedInput = new char[inputLength * 12]; // worst case length scenario
            // flag to surround double quotes around safe characters
            bool isInQuotes = false;
            for (int i = 0; i < inputLength; i++)
            {
                int currentCharacterAsInteger = input[i];
                char currentCharacter = input[i];
                if (SafeListCodes[currentCharacterAsInteger] != null)
                {
                    // character needs to be encoded
                    // surround in quotes
                    if (isInQuotes)
                    {
                        // get out of quotes
                        encodedInput[outputLength++] = '"';
                        isInQuotes = false;
                    }
                    // adding "encoded" characters
                    string temp = "&chrw(" + ((uint)currentCharacter) + ")";
                    foreach (char ch in temp)
                    {
                        encodedInput[outputLength++] = ch;
                    }
                }
                else
                {
                    // character does not need encoding
                    // surround in quotes
                    if (!isInQuotes)
                    {
                        // add quotes to start
                        encodedInput[outputLength++] = '&';
                        encodedInput[outputLength++] = '"';
                        isInQuotes = true;
                    }
                    encodedInput[outputLength++] = input[i];
                }
            }
            // if we're inside of quotes, close them
            if (isInQuotes)
            {
                encodedInput[outputLength++] = '"';
            }
            // finally strip extraneous "&" from beginning of the string, if necessary and RETURN
            if (encodedInput.Length > 0 && encodedInput[0] == '&')
            {
                return new string(encodedInput, 1, outputLength - 1);
            }
            return new string(encodedInput, 0, outputLength);
        }
        /// <summary>
        /// Initializes the safe list.
        /// </summary>
        /// <returns>A two dimensional character array containing characters and their encoded values.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is necessary complexity.")]
        private static char[][] InitializeSafeList()
        {
            char[][] allCharacters = new char[65536][];
            for (int i = 0; i < allCharacters.Length; i++)
            {
                if (
                    (i >= 97 && i <= 122) ||        // a-z
                    (i >= 65 && i <= 90) ||         // A-Z
                    (i >= 48 && i <= 57) ||         // 0-9
                    i == 32 ||                      // space
                    i == 46 ||                      // .
                    i == 44 ||                      // ,
                    i == 45 ||                      // -
                    i == 95 ||                      // _
                    (i >= 256 && i <= 591) ||       // Latin,Extended-A,Latin Extended-B        
                    (i >= 880 && i <= 2047) ||      // Greek and Coptic,Cyrillic,Cyrillic Supplement,Armenian,Hebrew,Arabic,Syriac,Arabic,Supplement,Thaana,NKo
                    (i >= 2304 && i <= 6319) ||     // Devanagari,Bengali,Gurmukhi,Gujarati,Oriya,Tamil,Telugu,Kannada,Malayalam,Sinhala,Thai,Lao,Tibetan,Myanmar,eorgian,Hangul Jamo,Ethiopic,Ethiopic Supplement,Cherokee,Unified Canadian Aboriginal Syllabics,Ogham,Runic,Tagalog,Hanunoo,Buhid,Tagbanwa,Khmer,Mongolian   
                    (i >= 6400 && i <= 6687) ||     // Limbu, Tai Le, New Tai Lue, Khmer, Symbols, Buginese
                    (i >= 6912 && i <= 7039) ||     // Balinese         
                    (i >= 7680 && i <= 8191) ||     // Latin Extended Additional, Greek Extended        
                    (i >= 11264 && i <= 11743) ||   // Glagolitic, Latin Extended-C, Coptic, Georgian Supplement, Tifinagh, Ethiopic Extended    
                    (i >= 12352 && i <= 12591) ||   // Hiragana, Katakana, Bopomofo       
                    (i >= 12688 && i <= 12735) ||   // Kanbun, Bopomofo Extended        
                    (i >= 12784 && i <= 12799) ||   // Katakana, Phonetic Extensions         
                    (i >= 19968 && i <= 40899) ||   // Mixed japanese/chinese/korean
                    (i >= 40960 && i <= 42191) ||   // Yi Syllables, Yi Radicals        
                    (i >= 42784 && i <= 43055) ||   // Latin Extended-D, Syloti, Nagri        
                    (i >= 43072 && i <= 43135) ||   // Phags-pa         
                    (i >= 44032 && i <= 55215) /* Hangul Syllables */)
                {
                    allCharacters[i] = null;
                }
                else
                {
                    string integerStringValue = i.ToString(CultureInfo.InvariantCulture);
                    int integerStringLength = integerStringValue.Length;
                    char[] thisChar = new char[integerStringLength];
                    for (int j = 0; j < integerStringLength; j++)
                    {
                        thisChar[j] = integerStringValue[j];
                    }
                    allCharacters[i] = thisChar;
                }
            }
            return allCharacters;
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="HtmlParameterEncoder.cs" company="Microsoft Corporation">
//   Copyright (c) 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides HTML Parameter Encoding methods.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System;
    using System.Collections;
    using System.Text;
    using System.Threading;
    /// <summary>
    /// The type of space encoding to use.
    /// </summary>
    internal enum EncodingType
    {
        /// <summary>
        /// Encode spaces for use in query strings
        /// </summary>
        QueryString = 1,
        /// <summary>
        /// Encode spaces for use in form data
        /// </summary>
        HtmlForm = 2
    }
    /// <summary>
    /// Provides Html Parameter Encoding methods.
    /// </summary>
    internal static class HtmlParameterEncoder
    {
        /// <summary>
        /// A lock object to use when performing safe listing.
        /// </summary>
        private static readonly ReaderWriterLockSlim SyncLock = new ReaderWriterLockSlim();
        /// <summary>
        /// The value to use when encoding a space for query strings.
        /// </summary>
        private static readonly char[] QueryStringSpace = "%20".ToCharArray();
        /// <summary>
        /// The value to use when encoding a space for form data.
        /// </summary>
        private static readonly char[] FormStringSpace = "+".ToCharArray();
        /// <summary>
        /// The values to output for each character.
        /// </summary>
        private static char[][] characterValues;
        /// <summary>
        /// Encodes a string for query string encoding and returns the encoded string.
        /// </summary>
        /// <param name="s">The text to URL-encode.</param>
        /// <param name="encoding">The encoding for the text parameter.</param>
        /// <returns>The URL-encoded text.</returns>
        /// <remarks>URL encoding ensures that all browsers will correctly transmit text in URL strings. 
        /// Characters such as a question mark (?), ampersand (&amp;), slash mark (/), and spaces might be truncated or corrupted by some browsers. 
        /// As a result, these characters must be encoded in &lt;a&gt; tags or in query strings where the strings can be re-sent by a browser 
        /// in a request string.</remarks>
        /// <exception cref="ArgumentNullException">Thrown if the encoding is null.</exception>
        internal static string QueryStringParameterEncode(string s, Encoding encoding)
        {
            return FormQueryEncode(s, encoding, EncodingType.QueryString);
        }
        /// <summary>
        /// Encodes a string for form URL encoding and returns the encoded string.
        /// </summary>
        /// <param name="s">The text to URL-encode.</param>
        /// <param name="encoding">The encoding for the text parameter.</param>
        /// <returns>The URL-encoded text.</returns>
        /// <remarks>URL encoding ensures that all browsers will correctly transmit text in URL strings. 
        /// Characters such as a question mark (?), ampersand (&amp;), slash mark (/), and spaces might be truncated or corrupted by some browsers. 
        /// As a result, these characters must be encoded in &lt;a&gt; tags or in query strings where the strings can be re-sent by a browser 
        /// in a request string.</remarks>
        /// <exception cref="ArgumentNullException">Thrown if the encoding is null.</exception>
        internal static string FormStringParameterEncode(string s, Encoding encoding)
        {
            return FormQueryEncode(s, encoding, EncodingType.HtmlForm);
        }
        /// <summary>
        /// Encodes a string for Query String or Form Data encoding.
        /// </summary>
        /// <param name="s">The text to URL-encode.</param>
        /// <param name="encoding">The encoding for the text parameter.</param>
        /// <param name="encodingType">The encoding type to use.</param>
        /// <returns>The encoded text.</returns>
        private static string FormQueryEncode(string s, Encoding encoding, EncodingType encodingType)
        {
            if (string.IsNullOrEmpty(s))
            {
                return s;
            }
            if (encoding == null)
            {
                throw new ArgumentNullException("encoding");
            }
            if (characterValues == null)
            {
                InitialiseSafeList();
            }
            // RFC 3986 states strings must be converted to their UTF8 value before URL encoding.
            // See http://tools.ietf.org/html/rfc3986
            // Conversion to char[] keeps null characters inline.
            byte[] utf8Bytes = encoding.GetBytes(s.ToCharArray());
            char[] encodedInput = new char[utf8Bytes.Length * 3]; // Each byte can potentially be encoded as %xx
            int outputLength = 0;
            for (int characterPosition = 0; characterPosition < utf8Bytes.Length; characterPosition++)
            {
                byte currentCharacter = utf8Bytes[characterPosition];
                if (currentCharacter == 0x00 || currentCharacter == 0x20 || currentCharacter > characterValues.Length || characterValues[currentCharacter] != null)
                {                
                    // character needs to be encoded
                    char[] encodedCharacter;
                    if (currentCharacter == 0x20)
                    {
                        switch (encodingType)
                        {
                            case EncodingType.QueryString:
                                encodedCharacter = QueryStringSpace;
                                break;
                            // Special case for Html Form data, from http://www.w3.org/TR/html401/appendix/notes.html#non-ascii-chars
                            case EncodingType.HtmlForm:
                                encodedCharacter = FormStringSpace;
                                break;
                            default:
                                throw new ArgumentOutOfRangeException("encodingType");
                        }
                    }
                    else
                    {
                        encodedCharacter = characterValues[currentCharacter];
                    }
                    for (int j = 0; j < encodedCharacter.Length; j++)
                    {
                        encodedInput[outputLength++] = encodedCharacter[j];
                    }
                }
                else
                {
                    // character does not need encoding
                    encodedInput[outputLength++] = (char)currentCharacter;
                }
            }
            return new string(encodedInput, 0, outputLength);
        }
        /// <summary>
        /// Initializes the HTML safe list.
        /// </summary>
        private static void InitialiseSafeList()
        {
            SyncLock.EnterWriteLock();
            try
            {
                characterValues = SafeList.Generate(255, SafeList.PercentThenHexValueGenerator);
                SafeList.PunchSafeList(ref characterValues, UrlParameterSafeList());
            }
            finally
            {
                SyncLock.ExitWriteLock();
            }
        }
        /// <summary>
        /// Provides the safe characters for URL parameter encoding.
        /// </summary>
        /// <returns>The safe characters for URL parameter encoding.</returns>
        private static IEnumerable UrlParameterSafeList()
        {
            // Hyphen
            yield return 0x2D;
            // Full stop/period
            yield return 0x2E;
            // Digits
            for (int i = 0x30; i <= 0x39; i++)
            {
                yield return i;
            }  
            // Upper case alphabet
            for (int i = 0x41; i <= 0x5A; i++)
            {
                yield return i;
            }
            // Underscore
            yield return 0x5F;
            // Lower case alphabet
            for (int i = 0x61; i <= 0x7A; i++)
            {
                yield return i;
            }
            // Tilde
            yield return 0x7E;
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="InvalidSurrogatePairException.cs" company="Microsoft Corporation">
//   Copyright (c) 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Thrown when a bad surrogate pair is encountered.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System;
    using System.Globalization;
    /// <summary>
    /// Thrown when a bad surrogate pair is encountered.
    /// </summary>
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Microsoft.Usage",
        "CA2237:MarkISerializableTypesWithSerializable",
        Justification = "The exception does not leave the application domain and serialization breaks medium trust.")]
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Microsoft.Design",
        "CA1032:ImplementStandardExceptionConstructors",
        Justification = "The exception does not leave the application domain and serialization breaks medium trust.")]
    public class InvalidSurrogatePairException : Exception
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidSurrogatePairException"/> class.
        /// </summary>
        public InvalidSurrogatePairException()
        {
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidSurrogatePairException"/> class.
        /// </summary>
        /// <param name="message">The message.</param>
        public InvalidSurrogatePairException(string message)
            : base(message)
        {
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidSurrogatePairException"/> class.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="inner">The inner exception.</param>
        public InvalidSurrogatePairException(string message, Exception inner)
            : base(message, inner)
        {
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidSurrogatePairException"/> class.
        /// </summary>
        /// <param name="highSurrogate">The high surrogate value which caused the error.</param>
        /// <param name="lowSurrogate">The low surrogate value which caused the error.</param>
        public InvalidSurrogatePairException(char highSurrogate, char lowSurrogate)
        {
            this.HighSurrogate = highSurrogate;
            this.LowSurrogate = lowSurrogate;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidSurrogatePairException"/> class.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="highSurrogate">The high surrogate value which caused the error.</param>
        /// <param name="lowSurrogate">The low surrogate value which caused the error.</param>
        public InvalidSurrogatePairException(string message, char highSurrogate, char lowSurrogate)
            : base(message)
        {
            this.HighSurrogate = highSurrogate;
            this.LowSurrogate = lowSurrogate;
        }
        /// <summary>
        /// Gets or sets the high surrogate value.
        /// </summary>
        /// <value>The high surrogate.</value>
        public char HighSurrogate
        {
            get;
            protected set;
        }
        /// <summary>
        /// Gets or sets the low surrogate value.
        /// </summary>
        /// <value>The low surrogate.</value>
        public char LowSurrogate
        {
            get;
            protected set;
        }
        /// <summary>
        /// Gets a message that describes the current exception.
        /// </summary>
        /// <returns>The error message that explains the reason for the exception, or an empty string("").</returns>
        public override string Message
        {
            get
            {
                if (this.HighSurrogate == 0 && this.LowSurrogate == 0)
                {
                    return base.Message;
                }
                string surrogatePair = string.Format(
                    CultureInfo.CurrentUICulture,
                    "Surrogate Pair =     {0:x4}:{1:x4}", 
                    Convert.ToInt32(this.HighSurrogate), 
                    Convert.ToInt32(this.LowSurrogate));
                return surrogatePair + Environment.NewLine + "Message: " + base.Message;
            }
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="InvalidUnicodeValueException.cs" company="Microsoft Corporation">
//   Copyright (c) 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Thrown when a invalid Unicode valid is encountered.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System;
    using System.Globalization;
    /// <summary>
    /// Thrown when a invalid Unicode valid is encountered.
    /// </summary>
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Microsoft.Usage",
        "CA2237:MarkISerializableTypesWithSerializable",
        Justification = "The exception does not leave the application domain and serialization breaks medium trust.")]
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Microsoft.Design",
        "CA1032:ImplementStandardExceptionConstructors",
        Justification = "The exception does not leave the application domain and serialization breaks medium trust.")]
    public class InvalidUnicodeValueException : Exception
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidUnicodeValueException"/> class.
        /// </summary>
        public InvalidUnicodeValueException()
        {
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidUnicodeValueException"/> class.
        /// </summary>
        /// <param name="message">The message.</param>
        public InvalidUnicodeValueException(string message)
            : base(message)
        {
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidUnicodeValueException"/> class.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="inner">The inner exception.</param>
        public InvalidUnicodeValueException(string message, Exception inner)
            : base(message, inner)
        {
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidUnicodeValueException"/> class.
        /// </summary>
        /// <param name="value">The invalid value.</param>
        public InvalidUnicodeValueException(int value)
        {
            this.Value = value;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidUnicodeValueException"/> class.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="value">The invalid value.</param>
        public InvalidUnicodeValueException(string message, int value)
            : base(message)
        {
            this.Value = value;
        }
        /// <summary>
        /// Gets or sets the the invalid value.
        /// </summary>
        /// <value>The invalid value.</value>
        public int Value
        {
            get;
            protected set;
        }
        /// <summary>
        /// Gets a message that describes the current exception.
        /// </summary>
        /// <returns>The error message that explains the reason for the exception, or an empty string("").</returns>
        public override string Message
        {
            get
            {
                if (this.Value == 0)
                {
                    return base.Message;
                }
                return string.Format(CultureInfo.CurrentUICulture, "Value : {0:x4}", this.Value) + Environment.NewLine + "Message: " + base.Message;
            }
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="LdapEncoder.cs" company="Microsoft Corporation">
//   Copyright (c) 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides LDAP Encoding methods.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    using System.Text;
    using System.Threading;
    /// <summary>
    /// Provides LDAP Encoding methods.
    /// </summary>
    internal static class LdapEncoder
    {
        /// <summary>
        /// A lock object to use when performing filter safe listing initialization.
        /// </summary>
        private static readonly ReaderWriterLockSlim FilterSafeListSyncLock = new ReaderWriterLockSlim();
        /// <summary>
        /// A lock object to use when performing DN safe listing initialization.
        /// </summary>
        private static readonly ReaderWriterLockSlim DistinguishedNameSafeListSyncLock = new ReaderWriterLockSlim();
        /// <summary>
        /// The values to output for each character when filter encoding.
        /// </summary>
        private static char[][] filterCharacterValues;
        /// <summary>
        /// The values to output for each character when DN encoding.
        /// </summary>
        private static char[][] distinguishedNameCharacterValues;
        /// <summary>
        /// Encodes the input string for use in LDAP filters.
        /// </summary>
        /// <param name="input">The string to encode.</param>
        /// <returns>An encoded version of the input string suitable for use in LDAP filters.</returns>
        internal static string FilterEncode(string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                return input;
            }
            if (filterCharacterValues == null)
            {
                InitialiseFilterSafeList();
            }
            // RFC 4515 states strings must be converted to their UTF8 value before search filter encoding.
            // See http://tools.ietf.org/html/rfc4515
            // Conversion to char[] keeps null characters inline.
            byte[] utf8Bytes = Encoding.UTF8.GetBytes(input.ToCharArray());
            char[] encodedInput = new char[utf8Bytes.Length * 3]; // Each byte can potentially be encoded as %xx
            int outputLength = 0;
            FilterSafeListSyncLock.EnterReadLock();
            try
            {
                for (int characterPosition = 0; characterPosition < utf8Bytes.Length; characterPosition++)
                {
                    byte currentCharacter = utf8Bytes[characterPosition];
                    if (filterCharacterValues[currentCharacter] != null)
                    {
                        // Character needs encoding.
                        char[] encodedCharacter = filterCharacterValues[currentCharacter];
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                    }
                    else
                    {
                        // Character does not need encoding.
                        encodedInput[outputLength++] = (char)currentCharacter;
                    }
                }
            }
            finally
            {
                FilterSafeListSyncLock.ExitReadLock();
            }
            return new string(encodedInput, 0, outputLength);
        }
        /// <summary>
        /// Encodes the input string for use in LDAP DNs.
        /// </summary>
        /// <param name="input">The string to encode.</param>
        /// <param name="useInitialCharacterRules">Value indicating whether the special case rules for encoding of spaces and octothorpes at the start of a string are used.</param>
        /// <param name="useFinalCharacterRule">Value indicating whether the special case for encoding of final character spaces is used.</param>
        /// <returns>An encoded version of the input string suitable for use in LDAP DNs.</returns>
        internal static string DistinguishedNameEncode(string input, bool useInitialCharacterRules, bool useFinalCharacterRule)
        {
            if (string.IsNullOrEmpty(input))
            {
                return input;
            }
            if (distinguishedNameCharacterValues == null)
            {
                InitialiseDistinguishedNameSafeList();
            }
            byte[] utf8Bytes = Encoding.UTF8.GetBytes(input.ToCharArray());
            char[] encodedInput = new char[utf8Bytes.Length * 3]; // Each byte can potentially be encoded as #xx
            int outputLength = 0;
            DistinguishedNameSafeListSyncLock.EnterReadLock();
            try
            {
                for (int characterPosition = 0; characterPosition < utf8Bytes.Length; characterPosition++)
                {
                    byte currentCharacter = utf8Bytes[characterPosition];
                    if (characterPosition == 0 && currentCharacter == ' ' && useInitialCharacterRules)
                    {
                        // rfc2253 states spaces at the start of a string must be escaped
                        encodedInput[outputLength++] = '\\';
                        encodedInput[outputLength++] = ' ';
                    }
                    else if (characterPosition == 0 && currentCharacter == '#' && useInitialCharacterRules)
                    {
                        // rfc2253 states hashes at the start of a string must be escaped
                        encodedInput[outputLength++] = '\\';
                        encodedInput[outputLength++] = '#';
                    }
                    else if (characterPosition == (utf8Bytes.Length - 1) && currentCharacter == ' ' &&
                             useFinalCharacterRule)
                    {
                        // rfc2253 states spaces at the end of a string must be escaped
                        encodedInput[outputLength++] = '\\';
                        encodedInput[outputLength++] = ' ';
                    }
                    else if (distinguishedNameCharacterValues[currentCharacter] != null)
                    {
                        // Character needs encoding.
                        char[] encodedCharacter = distinguishedNameCharacterValues[currentCharacter];
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                    }
                    else
                    {
                        // Character does not need encoding.
                        encodedInput[outputLength++] = (char)currentCharacter;
                    }
                }
            }
            finally
            {
                DistinguishedNameSafeListSyncLock.ExitReadLock();
            }
            return new string(encodedInput, 0, outputLength);
        }
        /// <summary>
        /// Initializes the LDAP filter safe lists.
        /// </summary>
        private static void InitialiseFilterSafeList()
        {
            FilterSafeListSyncLock.EnterWriteLock();
            try
            {
                if (filterCharacterValues == null)
                {
                    filterCharacterValues = SafeList.Generate(255, SafeList.SlashThenHexValueGenerator);
                    SafeList.PunchSafeList(ref filterCharacterValues, FilterEncodingSafeList());
                }
            }
            finally
            {
                FilterSafeListSyncLock.ExitWriteLock();
            }
        }
        /// <summary>
        /// Provides the safe characters for LDAP filter encoding.
        /// </summary>
        /// <returns>The safe characters for LDAP filter encoding.</returns>
        /// <remarks>See http://tools.ietf.org/html/rfc4515/</remarks>
        private static IEnumerable FilterEncodingSafeList()
        {
            for (int i = 0x20; i <= 0x7E; i++)
            {
                // Escape dangerous filter characters
                // See http://projects.webappsec.org/LDAP-Injection
                if (i == '(' ||
                    i == ')' ||
                    i == '*' ||
                    i == '/' ||
                    i == '\\')
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Initializes the LDAP DN safe lists.
        /// </summary>
        private static void InitialiseDistinguishedNameSafeList()
        {
            DistinguishedNameSafeListSyncLock.EnterWriteLock();
            try
            {
                if (distinguishedNameCharacterValues == null)
                {
                    distinguishedNameCharacterValues = SafeList.Generate(255, SafeList.HashThenHexValueGenerator);
                    SafeList.PunchSafeList(ref distinguishedNameCharacterValues, DistinguishedNameSafeList());
                    // Now mark up the specially listed characters from http://www.ietf.org/rfc/rfc2253.txt
                    EscapeDistinguisedNameCharacter(',');
                    EscapeDistinguisedNameCharacter('+');
                    EscapeDistinguisedNameCharacter('"');
                    EscapeDistinguisedNameCharacter('\\');
                    EscapeDistinguisedNameCharacter('<');
                    EscapeDistinguisedNameCharacter('>');
                    EscapeDistinguisedNameCharacter(';');
                }
            }
            finally
            {
                DistinguishedNameSafeListSyncLock.ExitWriteLock();
            }
        }
        /// <summary>
        /// Provides the safe characters for LDAP filter encoding.
        /// </summary>
        /// <returns>The safe characters for LDAP filter encoding.</returns>
        /// <remarks>See http://www.ietf.org/rfc/rfc2253.txt </remarks>
        private static IEnumerable DistinguishedNameSafeList()
        {
            for (int i = 0x20; i <= 0x7E; i++)
            {
                // RFC mandated escapes.
                if (i == ',' ||
                    i == '+' ||
                    i == '"' ||
                    i == '\\' ||
                    i == '<' ||
                    i == '>')
                {
                    continue;
                }
                // Safety escapes
                // See http://projects.webappsec.org/LDAP-Injection
                if (i == '&' ||
                    i == '!' ||
                    i == '|' ||
                    i == '=' ||
                    i == '-' ||
                    i == '\'' ||
                    i == ';')
                {
                    continue;
                }
                yield return i;
            }
        }
        /// <summary>
        /// Escapes a special DN character.
        /// </summary>
        /// <param name="c">The character to escape.</param>
        private static void EscapeDistinguisedNameCharacter(char c)
        {
            distinguishedNameCharacterValues[c] = new[] { '\\', c };
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="SafeList.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides safe list utility functions.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Collections;
    using System.Globalization;
    /// <summary>
    /// Provides safe list utility functions.
    /// </summary>
    internal static class SafeList
    {
        /// <summary>
        /// Generates a safe character array representing the specified value.
        /// </summary>
        /// <returns>A safe character array representing the specified value.</returns>
        /// <param name="value">The value to generate a safe representation for.</param>
        internal delegate char[] GenerateSafeValue(int value);
        /// <summary>
        /// Generates a new safe list of the specified size, using the specified function to produce safe values.
        /// </summary>
        /// <param name="length">The length of the safe list to generate.</param>
        /// <param name="generateSafeValue">The <see cref="GenerateSafeValue"/> function to use.</param>
        /// <returns>A new safe list.</returns>
        internal static char[][] Generate(int length, GenerateSafeValue generateSafeValue)
        {
            char[][] allCharacters = new char[length + 1][];
            for (int i = 0; i <= length; i++)
            {
                allCharacters[i] = generateSafeValue(i);
            }
            return allCharacters;
        }
        /// <summary>
        /// Marks characters from the specified languages as safe.
        /// </summary>
        /// <param name="safeList">The safe list to punch holes in.</param>
        /// <param name="lowerCodeCharts">The combination of lower code charts to use.</param>
        /// <param name="lowerMidCodeCharts">The combination of lower mid code charts to use.</param>
        /// <param name="midCodeCharts">The combination of mid code charts to use.</param>
        /// <param name="upperMidCodeCharts">The combination of upper mid code charts to use.</param>
        /// <param name="upperCodeCharts">The combination of upper code charts to use.</param>
        internal static void PunchUnicodeThrough(
            ref char[][] safeList,
            LowerCodeCharts lowerCodeCharts, 
            LowerMidCodeCharts lowerMidCodeCharts, 
            MidCodeCharts midCodeCharts, 
            UpperMidCodeCharts upperMidCodeCharts, 
            UpperCodeCharts upperCodeCharts)
        {
            if (lowerCodeCharts != LowerCodeCharts.None)
            {
                PunchCodeCharts(ref safeList, lowerCodeCharts);
            }
            if (lowerMidCodeCharts != LowerMidCodeCharts.None)
            {
                PunchCodeCharts(ref safeList, lowerMidCodeCharts);
            }
            if (midCodeCharts != MidCodeCharts.None)
            {
                PunchCodeCharts(ref safeList, midCodeCharts);
            }
            if (upperMidCodeCharts != UpperMidCodeCharts.None)
            {
                PunchCodeCharts(ref safeList, upperMidCodeCharts);
            }
            if (upperCodeCharts != UpperCodeCharts.None)
            {
                PunchCodeCharts(ref safeList, upperCodeCharts);
            }
        }
        /// <summary>
        /// Punches holes as necessary.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="whiteListedCharacters">The list of character positions to punch.</param>
        internal static void PunchSafeList(ref char[][] safeList, IEnumerable whiteListedCharacters)
        {
            PunchHolesIfNeeded(ref safeList, true, whiteListedCharacters);
        }
        /// <summary>
        /// Generates a hash prefixed character array representing the specified value.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>#1</description></item>
        /// <item><term>10</term><description>#10</description></item>
        /// <item><term>100</term><description>#100</description></item>
        /// </list>
        /// </remarks>
        internal static char[] HashThenValueGenerator(int value)
        {
            return StringToCharArrayWithHashPrefix(value.ToString(CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a hash prefixed character array representing the specified value in hexadecimal.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>#1</description></item>
        /// <item><term>10</term><description>#0a</description></item>
        /// <item><term>100</term><description>#64</description></item>
        /// </list>
        /// </remarks>
        internal static char[] HashThenHexValueGenerator(int value)
        {
            return StringToCharArrayWithHashPrefix(value.ToString("x2", CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a percent prefixed character array representing the specified value in hexadecimal.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>%01</description></item>
        /// <item><term>10</term><description>%0a</description></item>
        /// <item><term>100</term><description>%64</description></item>
        /// </list>
        /// </remarks>
        internal static char[] PercentThenHexValueGenerator(int value)
        {
            return StringToCharArrayWithPercentPrefix(value.ToString("x2", CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a slash prefixed character array representing the specified value in hexadecimal.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>\01</description></item>
        /// <item><term>10</term><description>\0a</description></item>
        /// <item><term>100</term><description>\64</description></item>
        /// </list>
        /// </remarks>
        internal static char[] SlashThenHexValueGenerator(int value)
        {
            return StringToCharArrayWithSlashPrefix(value.ToString("x2", CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a slash prefixed character array representing the specified value in hexadecimal.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>\000001</description></item>
        /// <item><term>10</term><description>\000000A</description></item>
        /// <item><term>100</term><description>\000064</description></item>
        /// </list>
        /// </remarks>
        internal static char[] SlashThenSixDigitHexValueGenerator(long value)
        {
            return StringToCharArrayWithSlashPrefix(value.ToString("X6", CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a slash prefixed character array representing the specified value in hexadecimal.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>\000001</description></item>
        /// <item><term>10</term><description>\000000A</description></item>
        /// <item><term>100</term><description>\000064</description></item>
        /// </list>
        /// </remarks>
        internal static char[] SlashThenSixDigitHexValueGenerator(int value)
        {
            return StringToCharArrayWithSlashPrefix(value.ToString("X6", CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a hash prefixed character array representing the specified value.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>#1</description></item>
        /// <item><term>10</term><description>#10</description></item>
        /// <item><term>100</term><description>#100</description></item>
        /// </list>
        /// </remarks>
        internal static char[] HashThenValueGenerator(long value)
        {
            return StringToCharArrayWithHashPrefix(value.ToString(CultureInfo.InvariantCulture));
        }
        /// <summary>
        /// Generates a hash prefixed character array from the specified string.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>#1</description></item>
        /// <item><term>10</term><description>#10</description></item>
        /// <item><term>100</term><description>#100</description></item>
        /// </list>
        /// </remarks>
        private static char[] StringToCharArrayWithHashPrefix(string value)
        {
            return StringToCharArrayWithPrefix(value, '#');            
        }
        /// <summary>
        /// Generates a percent prefixed character array from the specified string.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>%1</description></item>
        /// <item><term>10</term><description>%10</description></item>
        /// <item><term>100</term><description>%100</description></item>
        /// </list>
        /// </remarks>
        private static char[] StringToCharArrayWithPercentPrefix(string value)
        {
            return StringToCharArrayWithPrefix(value, '%');            
        }
        /// <summary>
        /// Generates a slash prefixed character array from the specified string.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <returns>A character array representing the specified value.</returns>
        /// <remarks>
        /// Example inputs and encoded outputs:
        /// <list type="table">
        /// <item><term>1</term><description>\1</description></item>
        /// <item><term>10</term><description>\10</description></item>
        /// <item><term>100</term><description>\100</description></item>
        /// </list>
        /// </remarks>
        private static char[] StringToCharArrayWithSlashPrefix(string value)
        {
            return StringToCharArrayWithPrefix(value, '\\');
        }
        /// <summary>
        /// Generates a prefixed character array from the specified string and prefix.
        /// </summary>
        /// <param name="value">The source value.</param>
        /// <param name="prefix">The prefix to use.</param>
        /// <returns>A prefixed character array representing the specified value.</returns>
        private static char[] StringToCharArrayWithPrefix(string value, char prefix)
        {
            int valueAsStringLength = value.Length;
            char[] valueAsCharArray = new char[valueAsStringLength + 1];
            valueAsCharArray[0] = prefix;
            for (int j = 0; j < valueAsStringLength; j++)
            {
                valueAsCharArray[j + 1] = value[j];
            }
            return valueAsCharArray;
        }
        /// <summary>
        /// Punch appropriate holes for the selected code charts.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="codeCharts">The code charts to punch.</param>
        private static void PunchCodeCharts(ref char[][] safeList, LowerCodeCharts codeCharts)
        {
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.BasicLatin), CodeCharts.Lower.BasicLatin());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.C1ControlsAndLatin1Supplement), CodeCharts.Lower.Latin1Supplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.LatinExtendedA), CodeCharts.Lower.LatinExtendedA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.LatinExtendedB), CodeCharts.Lower.LatinExtendedB());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.IpaExtensions), CodeCharts.Lower.IpaExtensions());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.SpacingModifierLetters), CodeCharts.Lower.SpacingModifierLetters());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.CombiningDiacriticalMarks), CodeCharts.Lower.CombiningDiacriticalMarks());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.GreekAndCoptic), CodeCharts.Lower.GreekAndCoptic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Cyrillic), CodeCharts.Lower.Cyrillic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.CyrillicSupplement), CodeCharts.Lower.CyrillicSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Armenian), CodeCharts.Lower.Armenian());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Hebrew), CodeCharts.Lower.Hebrew());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Arabic), CodeCharts.Lower.Arabic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Syriac), CodeCharts.Lower.Syriac());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.ArabicSupplement), CodeCharts.Lower.ArabicSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Thaana), CodeCharts.Lower.Thaana());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Nko), CodeCharts.Lower.Nko());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Samaritan), CodeCharts.Lower.Samaritan());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Devanagari), CodeCharts.Lower.Devanagari());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Bengali), CodeCharts.Lower.Bengali());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Gurmukhi), CodeCharts.Lower.Gurmukhi());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Gujarati), CodeCharts.Lower.Gujarati());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Oriya), CodeCharts.Lower.Oriya());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Tamil), CodeCharts.Lower.Tamil());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Telugu), CodeCharts.Lower.Telugu());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Kannada), CodeCharts.Lower.Kannada());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Malayalam), CodeCharts.Lower.Malayalam());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Sinhala), CodeCharts.Lower.Sinhala());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Thai), CodeCharts.Lower.Thai());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Lao), CodeCharts.Lower.Lao());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Lower.IsFlagSet(codeCharts, LowerCodeCharts.Tibetan), CodeCharts.Lower.Tibetan());
        }
        /// <summary>
        /// Punch appropriate holes for the selected code charts.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="codeCharts">The code charts to punch.</param>
        private static void PunchCodeCharts(ref char[][] safeList, LowerMidCodeCharts codeCharts)
        {
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Myanmar), CodeCharts.LowerMiddle.Myanmar());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Georgian), CodeCharts.LowerMiddle.Georgian());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.HangulJamo), CodeCharts.LowerMiddle.HangulJamo());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Ethiopic), CodeCharts.LowerMiddle.Ethiopic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.EthiopicSupplement), CodeCharts.LowerMiddle.EthiopicSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Cherokee), CodeCharts.LowerMiddle.Cherokee());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.UnifiedCanadianAboriginalSyllabics), CodeCharts.LowerMiddle.UnifiedCanadianAboriginalSyllabics());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Ogham), CodeCharts.LowerMiddle.Ogham());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Runic), CodeCharts.LowerMiddle.Runic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Tagalog), CodeCharts.LowerMiddle.Tagalog());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Hanunoo), CodeCharts.LowerMiddle.Hanunoo());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Buhid), CodeCharts.LowerMiddle.Buhid());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Tagbanwa), CodeCharts.LowerMiddle.Tagbanwa());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Khmer), CodeCharts.LowerMiddle.Khmer());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Mongolian), CodeCharts.LowerMiddle.Mongolian());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.UnifiedCanadianAboriginalSyllabicsExtended), CodeCharts.LowerMiddle.UnifiedCanadianAboriginalSyllabicsExtended());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Limbu), CodeCharts.LowerMiddle.Limbu());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.TaiLe), CodeCharts.LowerMiddle.TaiLe());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.NewTaiLue), CodeCharts.LowerMiddle.NewTaiLue());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.KhmerSymbols), CodeCharts.LowerMiddle.KhmerSymbols());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Buginese), CodeCharts.LowerMiddle.Buginese());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.TaiTham), CodeCharts.LowerMiddle.TaiTham());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Balinese), CodeCharts.LowerMiddle.Balinese());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Sudanese), CodeCharts.LowerMiddle.Sudanese());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.Lepcha), CodeCharts.LowerMiddle.Lepcha());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.OlChiki), CodeCharts.LowerMiddle.OlChiki());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.VedicExtensions), CodeCharts.LowerMiddle.VedicExtensions());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.PhoneticExtensions), CodeCharts.LowerMiddle.PhoneticExtensions());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.PhoneticExtensionsSupplement), CodeCharts.LowerMiddle.PhoneticExtensionsSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.CombiningDiacriticalMarksSupplement), CodeCharts.LowerMiddle.CombiningDiacriticalMarksSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.LowerMiddle.IsFlagSet(codeCharts, LowerMidCodeCharts.LatinExtendedAdditional), CodeCharts.LowerMiddle.LatinExtendedAdditional());
        }
        /// <summary>
        /// Punch appropriate holes for the selected code charts.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="codeCharts">The code charts to punch.</param>
        private static void PunchCodeCharts(ref char[][] safeList, MidCodeCharts codeCharts)
        {
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.GreekExtended), CodeCharts.Middle.GreekExtended());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.GeneralPunctuation), CodeCharts.Middle.GeneralPunctuation());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.SuperscriptsAndSubscripts), CodeCharts.Middle.SuperscriptsAndSubscripts());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.CurrencySymbols), CodeCharts.Middle.CurrencySymbols());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.CombiningDiacriticalMarksForSymbols), CodeCharts.Middle.CombiningDiacriticalMarksForSymbols());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.LetterlikeSymbols), CodeCharts.Middle.LetterlikeSymbols());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.NumberForms), CodeCharts.Middle.NumberForms());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.Arrows), CodeCharts.Middle.Arrows());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.MathematicalOperators), CodeCharts.Middle.MathematicalOperators());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousTechnical), CodeCharts.Middle.MiscellaneousTechnical());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.ControlPictures), CodeCharts.Middle.ControlPictures());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.OpticalCharacterRecognition), CodeCharts.Middle.OpticalCharacterRecognition());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.EnclosedAlphanumerics), CodeCharts.Middle.EnclosedAlphanumerics());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.BoxDrawing), CodeCharts.Middle.BoxDrawing());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.BlockElements), CodeCharts.Middle.BlockElements());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.GeometricShapes), CodeCharts.Middle.GeometricShapes());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousSymbols), CodeCharts.Middle.MiscellaneousSymbols());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.Dingbats), CodeCharts.Middle.Dingbats());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousMathematicalSymbolsA), CodeCharts.Middle.MiscellaneousMathematicalSymbolsA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.SupplementalArrowsA), CodeCharts.Middle.SupplementalArrowsA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.BraillePatterns), CodeCharts.Middle.BraillePatterns());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.SupplementalArrowsB), CodeCharts.Middle.SupplementalArrowsB());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousMathematicalSymbolsB), CodeCharts.Middle.MiscellaneousMathematicalSymbolsB());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.SupplementalMathematicalOperators), CodeCharts.Middle.SupplementalMathematicalOperators());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousSymbolsAndArrows), CodeCharts.Middle.MiscellaneousSymbolsAndArrows());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.Glagolitic), CodeCharts.Middle.Glagolitic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.LatinExtendedC), CodeCharts.Middle.LatinExtendedC());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.Coptic), CodeCharts.Middle.Coptic());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.GeorgianSupplement), CodeCharts.Middle.GeorgianSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.Tifinagh), CodeCharts.Middle.Tifinagh());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Middle.IsFlagSet(codeCharts, MidCodeCharts.EthiopicExtended), CodeCharts.Middle.EthiopicExtended());
        }
        /// <summary>
        /// Punch appropriate holes for the selected code charts.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="codeCharts">The code charts to punch.</param>
        private static void PunchCodeCharts(ref char[][] safeList, UpperMidCodeCharts codeCharts)
        {
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CyrillicExtendedA), CodeCharts.UpperMiddle.CyrillicExtendedA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.SupplementalPunctuation), CodeCharts.UpperMiddle.SupplementalPunctuation());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CjkRadicalsSupplement), CodeCharts.UpperMiddle.CjkRadicalsSupplement());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.KangxiRadicals), CodeCharts.UpperMiddle.KangxiRadicals());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.IdeographicDescriptionCharacters), CodeCharts.UpperMiddle.IdeographicDescriptionCharacters());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CjkSymbolsAndPunctuation), CodeCharts.UpperMiddle.CjkSymbolsAndPunctuation());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Hiragana), CodeCharts.UpperMiddle.Hiragana());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Katakana), CodeCharts.UpperMiddle.Katakana());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Bopomofo), CodeCharts.UpperMiddle.Bopomofo());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.HangulCompatibilityJamo), CodeCharts.UpperMiddle.HangulCompatibilityJamo());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Kanbun), CodeCharts.UpperMiddle.Kanbun());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.BopomofoExtended), CodeCharts.UpperMiddle.BopomofoExtended());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CjkStrokes), CodeCharts.UpperMiddle.CjkStrokes());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.KatakanaPhoneticExtensions), CodeCharts.UpperMiddle.KatakanaPhoneticExtensions());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.EnclosedCjkLettersAndMonths), CodeCharts.UpperMiddle.EnclosedCjkLettersAndMonths());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CjkCompatibility), CodeCharts.UpperMiddle.CjkCompatibility());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CjkUnifiedIdeographsExtensionA), CodeCharts.UpperMiddle.CjkUnifiedIdeographsExtensionA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.YijingHexagramSymbols), CodeCharts.UpperMiddle.YijingHexagramSymbols());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CjkUnifiedIdeographs), CodeCharts.UpperMiddle.CjkUnifiedIdeographs());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.YiSyllables), CodeCharts.UpperMiddle.YiSyllables());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.YiRadicals), CodeCharts.UpperMiddle.YiRadicals());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Lisu), CodeCharts.UpperMiddle.Lisu());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Vai), CodeCharts.UpperMiddle.Vai());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CyrillicExtendedB), CodeCharts.UpperMiddle.CyrillicExtendedB());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Bamum), CodeCharts.UpperMiddle.Bamum());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.ModifierToneLetters), CodeCharts.UpperMiddle.ModifierToneLetters());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.LatinExtendedD), CodeCharts.UpperMiddle.LatinExtendedD());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.SylotiNagri), CodeCharts.UpperMiddle.SylotiNagri());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.CommonIndicNumberForms), CodeCharts.UpperMiddle.CommonIndicNumberForms());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Phagspa), CodeCharts.UpperMiddle.Phagspa());
            PunchHolesIfNeeded(ref safeList, CodeCharts.UpperMiddle.IsFlagSet(codeCharts, UpperMidCodeCharts.Saurashtra), CodeCharts.UpperMiddle.Saurashtra());
        }
        /// <summary>
        /// Punch appropriate holes for the selected code charts.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="codeCharts">The code charts to punch.</param>
        private static void PunchCodeCharts(ref char[][] safeList, UpperCodeCharts codeCharts)
        {
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.DevanagariExtended), CodeCharts.Upper.DevanagariExtended());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.KayahLi), CodeCharts.Upper.KayahLi());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.Rejang), CodeCharts.Upper.Rejang());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.HangulJamoExtendedA), CodeCharts.Upper.HangulJamoExtendedA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.Javanese), CodeCharts.Upper.Javanese());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.Cham), CodeCharts.Upper.Cham());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.MyanmarExtendedA), CodeCharts.Upper.MyanmarExtendedA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.TaiViet), CodeCharts.Upper.TaiViet());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.MeeteiMayek), CodeCharts.Upper.MeeteiMayek());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.HangulSyllables), CodeCharts.Upper.HangulSyllables());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.HangulJamoExtendedB), CodeCharts.Upper.HangulJamoExtendedB());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.CjkCompatibilityIdeographs), CodeCharts.Upper.CjkCompatibilityIdeographs());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.AlphabeticPresentationForms), CodeCharts.Upper.AlphabeticPresentationForms());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.ArabicPresentationFormsA), CodeCharts.Upper.ArabicPresentationFormsA());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.VariationSelectors), CodeCharts.Upper.VariationSelectors());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.VerticalForms), CodeCharts.Upper.VerticalForms());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.CombiningHalfMarks), CodeCharts.Upper.CombiningHalfMarks());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.CjkCompatibilityForms), CodeCharts.Upper.CjkCompatibilityForms());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.SmallFormVariants), CodeCharts.Upper.SmallFormVariants());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.ArabicPresentationFormsB), CodeCharts.Upper.ArabicPresentationFormsB());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.HalfWidthAndFullWidthForms), CodeCharts.Upper.HalfWidthAndFullWidthForms());
            PunchHolesIfNeeded(ref safeList, CodeCharts.Upper.IsFlagSet(codeCharts, UpperCodeCharts.Specials), CodeCharts.Upper.Specials());
        }
        /// <summary>
        /// Punches holes as necessary.
        /// </summary>
        /// <param name="safeList">The safe list to punch through.</param>
        /// <param name="isNeeded">Value indicating whether the holes should be punched.</param>
        /// <param name="whiteListedCharacters">The list of character positions to punch.</param>
        private static void PunchHolesIfNeeded(ref char[][] safeList, bool isNeeded, IEnumerable whiteListedCharacters)
        {
            if (!isNeeded)
            {
                return;
            }
            foreach (int offset in whiteListedCharacters)
            {
                safeList[offset] = null;
            }
        }
    }
}
namespace Microsoft.Security.Application
{
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="UnicodeCharacterEncoder.cs" company="Microsoft Corporation">
//   Copyright (c) 2008, 2009, 2010 All Rights Reserved, Microsoft Corporation
//
//   This source is subject to the Microsoft Permissive License.
//   Please see the License.txt file for more information.
//   All other rights reserved.
//
//   THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY 
//   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
// </copyright>
// <summary>
//   Provides HTML Encoding methods.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
    using System.Threading;
    /// <summary>
    /// Provides HTML encoding methods.
    /// </summary>
    public static class UnicodeCharacterEncoder
    {
        /// <summary>
        /// A lock object to use when performing safe listing.
        /// </summary>
        private static readonly ReaderWriterLockSlim SyncLock = new ReaderWriterLockSlim();
        /// <summary>
        /// The HTML escaped value for a space, used in attribute encoding.
        /// </summary>
        private static readonly char[] UnicodeSpace = " ".ToCharArray();
        /// <summary>
        /// The Unicode value for an apostrophe, used in attribute encoding.
        /// </summary>
        private static readonly char[] UnicodeApostrophe = "'".ToCharArray();
        /// <summary>
        /// The XML named entity for an apostrophe, used in XML encoding.
        /// </summary>
        private static readonly char[] XmlApostrophe = "&apos;".ToCharArray();
        /// <summary>
        /// The current lower code chart settings.
        /// </summary>
        private static LowerCodeCharts currentLowerCodeChartSettings = LowerCodeCharts.None;
        /// <summary>
        /// The current lower middle code chart settings.
        /// </summary>
        private static LowerMidCodeCharts currentLowerMidCodeChartSettings = LowerMidCodeCharts.None;
        /// <summary>
        /// The current middle code chart settings.
        /// </summary>
        private static MidCodeCharts currentMidCodeChartSettings = MidCodeCharts.None;
        /// <summary>
        /// The current upper middle code chart settings.
        /// </summary>
        private static UpperMidCodeCharts currentUpperMidCodeChartSettings = UpperMidCodeCharts.None;
        /// <summary>
        /// The current upper code chart settings.
        /// </summary>
        private static UpperCodeCharts currentUpperCodeChartSettings = UpperCodeCharts.None;
        /// <summary>
        /// The values to output for each character.
        /// </summary>
        private static char[][] characterValues;
        /// <summary>
        /// The values to output for HTML named entities.
        /// </summary>
        private static char[][] namedEntities;
        /// <summary>
        /// Provides method specific encoding of characters.
        /// </summary>
        /// <param name="input">The character to encode</param>
        /// <param name="output">The encoded character, if it has been encoded.</param>
        /// <returns>True if the character has been encoded, otherwise false.</returns>
        private delegate bool MethodSpecificEncoder(char input, out char[] output);
        /// <summary>
        /// Marks characters from the specified languages as safe.
        /// </summary>
        /// <param name="lowerCodeCharts">The combination of lower code charts to use.</param>
        /// <param name="lowerMidCodeCharts">The combination of lower mid code charts to use.</param>
        /// <param name="midCodeCharts">The combination of mid code charts to use.</param>
        /// <param name="upperMidCodeCharts">The combination of upper mid code charts to use.</param>
        /// <param name="upperCodeCharts">The combination of upper code charts to use.</param>
        /// <remarks>The safe list affects all HTML and XML encoding functions.</remarks>
        public static void MarkAsSafe(
            LowerCodeCharts lowerCodeCharts,
            LowerMidCodeCharts lowerMidCodeCharts,
            MidCodeCharts midCodeCharts,
            UpperMidCodeCharts upperMidCodeCharts,
            UpperCodeCharts upperCodeCharts)
        {
            if (lowerCodeCharts == currentLowerCodeChartSettings &&
                lowerMidCodeCharts == currentLowerMidCodeChartSettings &&
                midCodeCharts == currentMidCodeChartSettings &&
                upperMidCodeCharts == currentUpperMidCodeChartSettings &&
                upperCodeCharts == currentUpperCodeChartSettings)
            {
                return;
            }
            SyncLock.EnterWriteLock();
            try
            {
                if (characterValues == null)
                {
                    characterValues = SafeList.Generate(65536, SafeList.HashThenValueGenerator);
                }
                SafeList.PunchUnicodeThrough(
                    ref characterValues,
                    lowerCodeCharts,
                    lowerMidCodeCharts,
                    midCodeCharts,
                    upperMidCodeCharts,
                    upperCodeCharts);
                ApplyHtmlSpecificValues();
                currentLowerCodeChartSettings = lowerCodeCharts;
                currentLowerMidCodeChartSettings = lowerMidCodeCharts;
                currentMidCodeChartSettings = midCodeCharts;
                currentUpperMidCodeChartSettings = upperMidCodeCharts;
                currentUpperCodeChartSettings = upperCodeCharts;
            }
            finally
            {
                SyncLock.ExitWriteLock();
            }
        }
        /// <summary>
        /// Encodes input strings for use in XML.
        /// </summary>
        /// <param name="input">String to be encoded</param>
        /// <returns>
        /// Encoded string for use in XML.
        /// </returns>
        internal static string XmlEncode(string input)
        {
            return HtmlEncode(input, false, XmlTweak);
        }
        /// <summary>
        /// Encodes input strings for use in XML.
        /// </summary>
        /// <param name="input">String to be encoded</param>
        /// <returns>
        /// Encoded string for use in XML.
        /// </returns>
        internal static string XmlAttributeEncode(string input)
        {
            return HtmlEncode(input, false, XmlAttributeTweak);
        }
        /// <summary>
        /// Encodes input strings for use in HTML attributes.
        /// </summary>
        /// <param name="input">String to be encoded</param>
        /// <returns>
        /// Encoded string for use in HTML attributes.
        /// </returns>
        internal static string HtmlAttributeEncode(string input)
        {
            return HtmlEncode(input, false, HtmlAttributeTweak);
        }
        /// <summary>
        /// Encodes input strings for use in HTML.
        /// </summary>
        /// <param name="input">String to be encoded</param>
        /// <param name="useNamedEntities">Value indicating if the HTML 4.0 named entities should be used.</param>
        /// <returns>
        /// Encoded string for use in HTML.
        /// </returns>
        internal static string HtmlEncode(string input, bool useNamedEntities)
        {
            return HtmlEncode(input, useNamedEntities, null);
        }
        /// <summary>
        /// HTML Attribute Encoding specific tweaks.
        /// </summary>
        /// <param name="input">The character to potentially encode.</param>
        /// <param name="output">The encoded character, if any.</param>
        /// <returns>True if encoding took place, otherwise false.</returns>
        private static bool HtmlAttributeTweak(char input, out char[] output)
        {
            if (input == '\'')
            {
                output = UnicodeApostrophe;
                return true;
            }
            if (input == ' ')
            {
                output = UnicodeSpace;
                return true;
            }
            output = null;
            return false;
        }
        /// <summary>
        /// XML specific tweaks.
        /// </summary>
        /// <param name="input">The character to potentially encode.</param>
        /// <param name="output">The encoded character, if any.</param>
        /// <returns>True if encoding took place, otherwise false.</returns>
        private static bool XmlTweak(char input, out char[] output)
        {
            if (input == '\'')
            {
                output = XmlApostrophe;
                return true;
            }
            output = null;
            return false;
        }
        /// <summary>
        /// XML Attribute Encoding specific tweaks.
        /// </summary>
        /// <param name="input">The character to potentially encode.</param>
        /// <param name="output">The encoded character, if any.</param>
        /// <returns>True if encoding took place, otherwise false.</returns>
        private static bool XmlAttributeTweak(char input, out char[] output)
        {
            if (input == '\'')
            {
                output = XmlApostrophe;
                return true;
            }
            if (input == ' ')
            {
                output = UnicodeSpace;
                return true;
            }
            output = null;
            return false;
        }
        /// <summary>
        /// Encodes input strings for use in HTML.
        /// </summary>
        /// <param name="input">String to be encoded</param>
        /// <param name="useNamedEntities">Value indicating if the HTML 4.0 named entities should be used.</param>
        /// <param name="encoderTweak">A <see cref="MethodSpecificEncoder"/> function, if needed.</param>
        /// <returns>
        /// Encoded string for use in HTML.
        /// </returns>
        /// <exception cref="InvalidUnicodeValueException">Thrown if a character with an invalid Unicode value is encountered within the input string.</exception>
        /// <exception cref="InvalidSurrogatePairException">Thrown if a high surrogate code point is encoded without a following low surrogate code point, or a 
        /// low surrogate code point is encounter without having been preceded by a high surrogate code point.</exception>
        private static string HtmlEncode(string input, bool useNamedEntities, MethodSpecificEncoder encoderTweak)
        {
            if (string.IsNullOrEmpty(input))
            {
                return input;
            }
            if (characterValues == null)
            {
                InitialiseSafeList();
            }
            if (useNamedEntities && namedEntities == null)
            {
                InitialiseNamedEntityList();
            }
            // Setup a new character array for output.
            char[] inputAsArray = input.ToCharArray();
            int outputLength = 0;
            int inputLength = inputAsArray.Length;
            char[] encodedInput = new char[inputLength * 10]; // Worse case scenario - the longest entity name, thetasym is 10 characters, including the & and ;.
            SyncLock.EnterReadLock();
            try
            {
                for (int i = 0; i < inputLength; i++)
                {
                    char currentCharacter = inputAsArray[i];
                    int currentCodePoint = inputAsArray[i];
                    char[] tweekedValue;
                    // Check for invalid values
                    if (currentCodePoint == 0xFFFE ||
                        currentCodePoint == 0xFFFF)
                    {
                        throw new InvalidUnicodeValueException(currentCodePoint);
                    }
                    else if (char.IsHighSurrogate(currentCharacter)) 
                    {
                        if (i + 1 == inputLength)
                        {
                            throw new InvalidSurrogatePairException(currentCharacter, '\0');                            
                        }
                        // Now peak ahead and check if the following character is a low surrogate.
                        char nextCharacter = inputAsArray[i + 1];
                        char nextCodePoint = inputAsArray[i + 1];
                        if (!char.IsLowSurrogate(nextCharacter))
                        {
                            throw new InvalidSurrogatePairException(currentCharacter, nextCharacter);
                        }
                        // Look-ahead was good, so skip.
                        i++;
                        // Calculate the combined code point
                        long combinedCodePoint =
                            0x10000 + ((currentCodePoint - 0xD800) * 0x400) + (nextCodePoint - 0xDC00);
                        char[] encodedCharacter = SafeList.HashThenValueGenerator(combinedCodePoint);
                        encodedInput[outputLength++] = '&';
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                        encodedInput[outputLength++] = ';';
                    }
                    else if (char.IsLowSurrogate(currentCharacter))
                    {
                        throw new InvalidSurrogatePairException('\0', currentCharacter);    
                    }
                    else if (encoderTweak != null && encoderTweak(currentCharacter, out tweekedValue))
                    {
                        for (int j = 0; j < tweekedValue.Length; j++)
                        {
                            encodedInput[outputLength++] = tweekedValue[j];
                        }
                    }
                    else if (useNamedEntities && namedEntities[currentCodePoint] != null)
                    {
                        char[] encodedCharacter = namedEntities[currentCodePoint];
                        encodedInput[outputLength++] = '&';
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                        encodedInput[outputLength++] = ';';
                    }
                    else if (characterValues[currentCodePoint] != null)
                    {
                        // character needs to be encoded
                        char[] encodedCharacter = characterValues[currentCodePoint];
                        encodedInput[outputLength++] = '&';
                        for (int j = 0; j < encodedCharacter.Length; j++)
                        {
                            encodedInput[outputLength++] = encodedCharacter[j];
                        }
                        encodedInput[outputLength++] = ';';
                    }
                    else
                    {
                        // character does not need encoding
                        encodedInput[outputLength++] = currentCharacter;
                    }
                }
            }
            finally
            {
                SyncLock.ExitReadLock();
            }
            return new string(encodedInput, 0, outputLength);
        }
        /// <summary>
        /// Initializes the HTML safe list.
        /// </summary>
        private static void InitialiseSafeList()
        {
            SyncLock.EnterWriteLock();
            try
            {
                if (characterValues == null)
                {
                    characterValues = SafeList.Generate(0xFFFF, SafeList.HashThenValueGenerator);
                    SafeList.PunchUnicodeThrough(
                        ref characterValues,
                        LowerCodeCharts.Default,
                        LowerMidCodeCharts.None,
                        MidCodeCharts.None,
                        UpperMidCodeCharts.None,
                        UpperCodeCharts.None);
                    ApplyHtmlSpecificValues();
                }
            }
            finally
            {
                SyncLock.ExitWriteLock();
            }
        }
        /// <summary>
        /// Applies Html specific values to the internal value list.
        /// </summary>
        private static void ApplyHtmlSpecificValues()
        {
            characterValues['<'] = "lt".ToCharArray();
            characterValues['>'] = "gt".ToCharArray();
            characterValues['&'] = "amp".ToCharArray();
            characterValues['"'] = "quot".ToCharArray();
        }
        /// <summary>
        /// Initialises the HTML named entities list.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Maintainability", 
            "CA1505:AvoidUnmaintainableCode", 
            Justification = "Splitting or initialising via lookups has too large a performance increase.")]
        private static void InitialiseNamedEntityList()
        {
            namedEntities = new char[65536][];
            namedEntities[160] = "nbsp".ToCharArray();
            namedEntities[161] = "iexcl".ToCharArray();
            namedEntities[162] = "cent".ToCharArray();
            namedEntities[163] = "pound".ToCharArray();
            namedEntities[164] = "curren".ToCharArray();
            namedEntities[165] = "yen".ToCharArray();
            namedEntities[166] = "brvbar".ToCharArray();
            namedEntities[167] = "sect".ToCharArray();
            namedEntities[168] = "uml".ToCharArray();
            namedEntities[169] = "copy".ToCharArray();
            namedEntities[170] = "ordf".ToCharArray();
            namedEntities[171] = "laquo".ToCharArray();
            namedEntities[172] = "not".ToCharArray();
            namedEntities[173] = "shy".ToCharArray();
            namedEntities[174] = "reg".ToCharArray();
            namedEntities[175] = "macr".ToCharArray();
            namedEntities[176] = "deg".ToCharArray();
            namedEntities[177] = "plusmn".ToCharArray();
            namedEntities[178] = "sup2".ToCharArray();
            namedEntities[179] = "sup3".ToCharArray();
            namedEntities[180] = "acute".ToCharArray();
            namedEntities[181] = "micro".ToCharArray();
            namedEntities[182] = "para".ToCharArray();
            namedEntities[183] = "middot".ToCharArray();
            namedEntities[184] = "cedil".ToCharArray();
            namedEntities[185] = "sup1".ToCharArray();
            namedEntities[186] = "ordm".ToCharArray();
            namedEntities[187] = "raquo".ToCharArray();
            namedEntities[188] = "frac14".ToCharArray();
            namedEntities[189] = "frac12".ToCharArray();
            namedEntities[190] = "frac34".ToCharArray();
            namedEntities[191] = "iquest".ToCharArray();
            namedEntities[192] = "Agrave".ToCharArray();
            namedEntities[193] = "Aacute".ToCharArray();
            namedEntities[194] = "Acirc".ToCharArray();
            namedEntities[195] = "Atilde".ToCharArray();
            namedEntities[196] = "Auml".ToCharArray();
            namedEntities[197] = "Aring".ToCharArray();
            namedEntities[198] = "AElig".ToCharArray();
            namedEntities[199] = "Ccedil".ToCharArray();
            namedEntities[200] = "Egrave".ToCharArray();
            namedEntities[201] = "Eacute".ToCharArray();
            namedEntities[202] = "Ecirc".ToCharArray();
            namedEntities[203] = "Euml".ToCharArray();
            namedEntities[204] = "Igrave".ToCharArray();
            namedEntities[205] = "Iacute".ToCharArray();
            namedEntities[206] = "Icirc".ToCharArray();
            namedEntities[207] = "Iuml".ToCharArray();
            namedEntities[208] = "ETH".ToCharArray();
            namedEntities[209] = "Ntilde".ToCharArray();
            namedEntities[210] = "Ograve".ToCharArray();
            namedEntities[211] = "Oacute".ToCharArray();
            namedEntities[212] = "Ocirc".ToCharArray();
            namedEntities[213] = "Otilde".ToCharArray();
            namedEntities[214] = "Ouml".ToCharArray();
            namedEntities[215] = "times".ToCharArray();
            namedEntities[216] = "Oslash".ToCharArray();
            namedEntities[217] = "Ugrave".ToCharArray();
            namedEntities[218] = "Uacute".ToCharArray();
            namedEntities[219] = "Ucirc".ToCharArray();
            namedEntities[220] = "Uuml".ToCharArray();
            namedEntities[221] = "Yacute".ToCharArray();
            namedEntities[222] = "THORN".ToCharArray();
            namedEntities[223] = "szlig".ToCharArray();
            namedEntities[224] = "agrave".ToCharArray();
            namedEntities[225] = "aacute".ToCharArray();
            namedEntities[226] = "acirc".ToCharArray();
            namedEntities[227] = "atilde".ToCharArray();
            namedEntities[228] = "auml".ToCharArray();
            namedEntities[229] = "aring".ToCharArray();
            namedEntities[230] = "aelig".ToCharArray();
            namedEntities[231] = "ccedil".ToCharArray();
            namedEntities[232] = "egrave".ToCharArray();
            namedEntities[233] = "eacute".ToCharArray();
            namedEntities[234] = "ecirc".ToCharArray();
            namedEntities[235] = "euml".ToCharArray();
            namedEntities[236] = "igrave".ToCharArray();
            namedEntities[237] = "iacute".ToCharArray();
            namedEntities[238] = "icirc".ToCharArray();
            namedEntities[239] = "iuml".ToCharArray();
            namedEntities[240] = "eth".ToCharArray();
            namedEntities[241] = "ntilde".ToCharArray();
            namedEntities[242] = "ograve".ToCharArray();
            namedEntities[243] = "oacute".ToCharArray();
            namedEntities[244] = "ocirc".ToCharArray();
            namedEntities[245] = "otilde".ToCharArray();
            namedEntities[246] = "ouml".ToCharArray();
            namedEntities[247] = "divide".ToCharArray();
            namedEntities[248] = "oslash".ToCharArray();
            namedEntities[249] = "ugrave".ToCharArray();
            namedEntities[250] = "uacute".ToCharArray();
            namedEntities[251] = "ucirc".ToCharArray();
            namedEntities[252] = "uuml".ToCharArray();
            namedEntities[253] = "yacute".ToCharArray();
            namedEntities[254] = "thorn".ToCharArray();
            namedEntities[255] = "yuml".ToCharArray();
            namedEntities[338] = "OElig".ToCharArray();
            namedEntities[339] = "oelig".ToCharArray();
            namedEntities[352] = "Scaron".ToCharArray();
            namedEntities[353] = "scaron".ToCharArray();
            namedEntities[376] = "Yuml".ToCharArray();
            namedEntities[402] = "fnof".ToCharArray();
            namedEntities[710] = "circ".ToCharArray();
            namedEntities[732] = "tilde".ToCharArray();
            namedEntities[913] = "Alpha".ToCharArray();
            namedEntities[914] = "Beta".ToCharArray();
            namedEntities[915] = "Gamma".ToCharArray();
            namedEntities[916] = "Delta".ToCharArray();
            namedEntities[917] = "Epsilon".ToCharArray();
            namedEntities[918] = "Zeta".ToCharArray();
            namedEntities[919] = "Eta".ToCharArray();
            namedEntities[920] = "Theta".ToCharArray();
            namedEntities[921] = "Iota".ToCharArray();
            namedEntities[922] = "Kappa".ToCharArray();
            namedEntities[923] = "Lambda".ToCharArray();
            namedEntities[924] = "Mu".ToCharArray();
            namedEntities[925] = "Nu".ToCharArray();
            namedEntities[926] = "Xi".ToCharArray();
            namedEntities[927] = "Omicron".ToCharArray();
            namedEntities[928] = "Pi".ToCharArray();
            namedEntities[929] = "Rho".ToCharArray();
            namedEntities[931] = "Sigma".ToCharArray();
            namedEntities[932] = "Tau".ToCharArray();
            namedEntities[933] = "Upsilon".ToCharArray();
            namedEntities[934] = "Phi".ToCharArray();
            namedEntities[935] = "Chi".ToCharArray();
            namedEntities[936] = "Psi".ToCharArray();
            namedEntities[937] = "Omega".ToCharArray();
            namedEntities[945] = "alpha".ToCharArray();
            namedEntities[946] = "beta".ToCharArray();
            namedEntities[947] = "gamma".ToCharArray();
            namedEntities[948] = "delta".ToCharArray();
            namedEntities[949] = "epsilon".ToCharArray();
            namedEntities[950] = "zeta".ToCharArray();
            namedEntities[951] = "eta".ToCharArray();
            namedEntities[952] = "theta".ToCharArray();
            namedEntities[953] = "iota".ToCharArray();
            namedEntities[954] = "kappa".ToCharArray();
            namedEntities[955] = "lambda".ToCharArray();
            namedEntities[956] = "mu".ToCharArray();
            namedEntities[957] = "nu".ToCharArray();
            namedEntities[958] = "xi".ToCharArray();
            namedEntities[959] = "omicron".ToCharArray();
            namedEntities[960] = "pi".ToCharArray();
            namedEntities[961] = "rho".ToCharArray();
            namedEntities[962] = "sigmaf".ToCharArray();
            namedEntities[963] = "sigma".ToCharArray();
            namedEntities[964] = "tau".ToCharArray();
            namedEntities[965] = "upsilon".ToCharArray();
            namedEntities[966] = "phi".ToCharArray();
            namedEntities[967] = "chi".ToCharArray();
            namedEntities[968] = "psi".ToCharArray();
            namedEntities[969] = "omega".ToCharArray();
            namedEntities[977] = "thetasym".ToCharArray();
            namedEntities[978] = "upsih".ToCharArray();
            namedEntities[982] = "piv".ToCharArray();
            namedEntities[0x2002] = "ensp".ToCharArray();
            namedEntities[0x2003] = "emsp".ToCharArray();
            namedEntities[0x2009] = "thinsp".ToCharArray();
            namedEntities[0x200C] = "zwnj".ToCharArray();
            namedEntities[0x200D] = "zwj".ToCharArray();
            namedEntities[0x200E] = "lrm".ToCharArray();
            namedEntities[0x200F] = "rlm".ToCharArray();
            namedEntities[0x2013] = "ndash".ToCharArray();
            namedEntities[0x2014] = "mdash".ToCharArray();
            namedEntities[0x2018] = "lsquo".ToCharArray();
            namedEntities[0x2019] = "rsquo".ToCharArray();
            namedEntities[0x201A] = "sbquo".ToCharArray();
            namedEntities[0x201C] = "ldquo".ToCharArray();
            namedEntities[0x201D] = "rdquo".ToCharArray();
            namedEntities[0x201E] = "bdquo".ToCharArray();
            namedEntities[0x2020] = "dagger".ToCharArray();
            namedEntities[0x2021] = "Dagger".ToCharArray();
            namedEntities[0x2022] = "bull".ToCharArray();
            namedEntities[0x2026] = "hellip".ToCharArray();
            namedEntities[0x2030] = "permil".ToCharArray();
            namedEntities[0x2032] = "prime".ToCharArray();
            namedEntities[0x2033] = "Prime".ToCharArray();
            namedEntities[0x2039] = "lsaquo".ToCharArray();
            namedEntities[0x203A] = "rsaquo".ToCharArray();
            namedEntities[0x203E] = "oline".ToCharArray();
            namedEntities[0x2044] = "frasl".ToCharArray();
            namedEntities[0x20AC] = "euro".ToCharArray();
            namedEntities[0x2111] = "image".ToCharArray();
            namedEntities[0x2118] = "weierp".ToCharArray();
            namedEntities[0x211C] = "real".ToCharArray();
            namedEntities[0x2122] = "trade".ToCharArray();
            namedEntities[0x2135] = "alefsym".ToCharArray();
            namedEntities[0x2190] = "larr".ToCharArray();
            namedEntities[0x2191] = "uarr".ToCharArray();
            namedEntities[0x2192] = "rarr".ToCharArray();
            namedEntities[0x2193] = "darr".ToCharArray();
            namedEntities[0x2194] = "harr".ToCharArray();
            namedEntities[0x21B5] = "crarr".ToCharArray();
            namedEntities[0x21D0] = "lArr".ToCharArray();
            namedEntities[0x21D1] = "uArr".ToCharArray();
            namedEntities[0x21D2] = "rArr".ToCharArray();
            namedEntities[0x21D3] = "dArr".ToCharArray();
            namedEntities[0x21D4] = "hArr".ToCharArray();
            namedEntities[0x2200] = "forall".ToCharArray();
            namedEntities[0x2202] = "part".ToCharArray();
            namedEntities[0x2203] = "exist".ToCharArray();
            namedEntities[0x2205] = "empty".ToCharArray();
            namedEntities[0x2207] = "nabla".ToCharArray();
            namedEntities[0x2208] = "isin".ToCharArray();
            namedEntities[0x2209] = "notin".ToCharArray();
            namedEntities[0x220B] = "ni".ToCharArray();
            namedEntities[0x220F] = "prod".ToCharArray();
            namedEntities[0x2211] = "sum".ToCharArray();
            namedEntities[0x2212] = "minus".ToCharArray();
            namedEntities[0x2217] = "lowast".ToCharArray();
            namedEntities[0x221A] = "radic".ToCharArray();
            namedEntities[0x221D] = "prop".ToCharArray();
            namedEntities[0x221E] = "infin".ToCharArray();
            namedEntities[0x2220] = "ang".ToCharArray();
            namedEntities[0x2227] = "and".ToCharArray();
            namedEntities[0x2228] = "or".ToCharArray();
            namedEntities[0x2229] = "cap".ToCharArray();
            namedEntities[0x222A] = "cup".ToCharArray();
            namedEntities[0x222B] = "int".ToCharArray();
            namedEntities[0x2234] = "there4".ToCharArray();
            namedEntities[0x223C] = "sim".ToCharArray();
            namedEntities[0x2245] = "cong".ToCharArray();
            namedEntities[0x2248] = "asymp".ToCharArray();
            namedEntities[0x2260] = "ne".ToCharArray();
            namedEntities[0x2261] = "equiv".ToCharArray();
            namedEntities[0x2264] = "le".ToCharArray();
            namedEntities[0x2265] = "ge".ToCharArray();
            namedEntities[0x2282] = "sub".ToCharArray();
            namedEntities[0x2283] = "sup".ToCharArray();
            namedEntities[0x2284] = "nsub".ToCharArray();
            namedEntities[0x2286] = "sube".ToCharArray();
            namedEntities[0x2287] = "supe".ToCharArray();
            namedEntities[0x2295] = "oplus".ToCharArray();
            namedEntities[0x2297] = "otimes".ToCharArray();
            namedEntities[0x22A5] = "perp".ToCharArray();
            namedEntities[0x22C5] = "sdot".ToCharArray();
            namedEntities[0x2308] = "lceil".ToCharArray();
            namedEntities[0x2309] = "rceil".ToCharArray();
            namedEntities[0x230A] = "lfloor".ToCharArray();
            namedEntities[0x230B] = "rfloor".ToCharArray();
            namedEntities[0x2329] = "lang".ToCharArray();
            namedEntities[0x232A] = "rang".ToCharArray();
            namedEntities[0x25CA] = "loz".ToCharArray();
            namedEntities[0x2660] = "spades".ToCharArray();
            namedEntities[0x2663] = "clubs".ToCharArray();
            namedEntities[0x2665] = "hearts".ToCharArray();
            namedEntities[0x2666] = "diams".ToCharArray();
        }
    }
}
//namespace Microsoft.Security.Application
//{
//    using System;
//    using System.Collections.Generic;
//    using System.Linq;
//    using System.Text;
//    using System.Web.Mvc;
//    ///---------------------------------------------------------------------
//    /// <summary>
//    ///     Represents support for creating input and output HTML controls 
//    ///     with attributes and text encoded using Anti-XSS library 
//    ///     encoding methods.
//    /// </summary>
//    /// <remarks>
//    ///     This class provides a set of helper methods whose purpose is to 
//    ///     help you create HTML controls programmatically. These methods 
//    ///     generate HTML controls using the Principle of Inclusions, 
//    ///     sometimes referred to as "safe listing" to provide protection 
//    ///     against injection attacks.  With safe listing protection, 
//    ///     algorithms look for valid inputs and automatically treat 
//    ///     everything outside that set as a potential attack.  This library
//    ///     can be used as a defense in depth approach with other mitigation 
//    ///     techniques. It is suitable for applications with high security 
//    ///     requirements.
//    /// </remarks>
//    ///---------------------------------------------------------------------
//    ///
//    public static class MvcExtensions
//    {
//        /// <summary>
//        /// Returns a string of HTML with span element.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the span element</param>
//        /// <returns>HTML of span element</returns>
//        /// <remarks>
//        /// This method creates a span element with encoded text that is safe to
//        /// display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeLabel(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with span element.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the span element</param>
//        /// <param name="value">Inner text using Object.ToString</param>
//        /// <returns>HTML of span element</returns>
//        /// <remarks>
//        /// This method creates a span element with encoded text that is safe to
//        /// display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeLabel(this HtmlHelper helper, String name, Object value)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with span element.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the span element</param>
//        /// <param name="value">Inner text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of span element</returns>
//        /// <remarks>
//        /// This method creates a span element with encoded text that is safe to
//        /// display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeLabel(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of text type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type text with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeTextbox(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of text type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type text with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeTextbox(this HtmlHelper helper, String name, Object value)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of text type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type text with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeTextbox(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of check type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type check with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeCheckbox(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of check type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type check with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeCheckbox(this HtmlHelper helper, String name, Object value)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of check type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type check with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeCheckbox(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of radio type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type radio with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeRadioButton(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of radio type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type radio with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeRadioButton(this HtmlHelper helper, String name, Object value)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of radio type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type radio with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeRadioButton(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of button type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type button with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeButton(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of button type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type button with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeButton(this HtmlHelper helper, String name, Object value)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of button type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type button with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeButton(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of password type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type password with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafePassword(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of password type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type password with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafePassword(this HtmlHelper helper, String name, Object value)
//        {
//            return "";
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of password type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type password with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafePassword(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of hidden type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type hidden with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeHidden(this HtmlHelper helper, String name)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of hidden type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type hidden with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeHidden(this HtmlHelper helper, String name, Object value)
//        {
//            throw new NotImplementedException();
//        }
//        /// <summary>
//        /// Returns a string of HTML with input element of hidden type.
//        /// </summary>
//        /// <param name="helper">HtmlHelper class</param>
//        /// <param name="name">ID of the input element</param>
//        /// <param name="value">Element text using Object.ToString</param>
//        /// <param name="htmlAttributes">Additional attributes of the element</param>
//        /// <returns>HTML of input element</returns>
//        /// <remarks>
//        /// This method creates a Input element of type hidden with encoded text that 
//        /// is safe to display. Text and attributes are encoded using Anti-XSS Library's
//        /// HtmlEncode and HtmlAttributeEncode method respectively.
//        /// </remarks>
//        public static string SafeHidden(this HtmlHelper helper, String name, Object value, IDictionary<String, Object> htmlAttributes)
//        {
//            throw new NotImplementedException();
//        }
//    }
//}

本文链接

冻结锁定固定行列表头抬头 html table jquery 全兼容常见浏览器

2011-08-10T03:17:00Z


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title> new document </title>
    <META NAME="Generator" CONTENT="EditPlus,Microshaoft">
    <META NAME="Author" CONTENT="EditPlus,Microshaoft">
    <META NAME="Keywords" CONTENT="EditPlus,Microshaoft">
    <META NAME="Description" CONTENT="EditPlus,Microshaoft">
<script type="text/javascript" src="http://code.jquery.com/jquery-1.6.1.min.js"></script>
<script type="text/javascript">
<!--
    function FixTable(TableID, FixColumnNumber, width, height) {
    /// <summary>
    ///     锁定表头和列
    ///     <para> sorex.cnblogs.com </para>
    /// </summary>
    /// <param name="TableID" type="String">
    ///     要锁定的Table的ID
    /// </param>
    /// <param name="FixColumnNumber" type="Number">
    ///     要锁定列的个数
    /// </param>
    /// <param name="width" type="Number">
    ///     显示的宽度
    /// </param>
    /// <param name="height" type="Number">
    ///     显示的高度
    /// </param>
    if ($("#" + TableID + "_tableLayout").length != 0) {
        $("#" + TableID + "_tableLayout").before($("#" + TableID));
        $("#" + TableID + "_tableLayout").empty();
    }
    else {
        $("#" + TableID).after("<div id='" + TableID + "_tableLayout' style='overflow:hidden;height:" + height + "px; width:" + width + "px;'></div>");
    }
    $('<div id="' + TableID + '_tableFix"></div>'
    + '<div id="' + TableID + '_tableHead"></div>'
    + '<div id="' + TableID + '_tableColumn"></div>'
    + '<div id="' + TableID + '_tableData"></div>').appendTo("#" + TableID + "_tableLayout");
    var oldtable = $("#" + TableID);
    var tableFixClone = oldtable.clone(true);
    tableFixClone.attr("id", TableID + "_tableFixClone");
    $("#" + TableID + "_tableFix").append(tableFixClone);
    var tableHeadClone = oldtable.clone(true);
    tableHeadClone.attr("id", TableID + "_tableHeadClone");
    $("#" + TableID + "_tableHead").append(tableHeadClone);
    var tableColumnClone = oldtable.clone(true);
    tableColumnClone.attr("id", TableID + "_tableColumnClone");
    $("#" + TableID + "_tableColumn").append(tableColumnClone);
    $("#" + TableID + "_tableData").append(oldtable);
    $("#" + TableID + "_tableLayout table").each(function () {
        $(this).css("margin", "0");
    });
    var HeadHeight = $("#" + TableID + "_tableHead thead").height();
    HeadHeight += 2;
    $("#" + TableID + "_tableHead").css("height", HeadHeight);
    $("#" + TableID + "_tableFix").css("height", HeadHeight);
    var ColumnsWidth = 0;
    var ColumnsNumber = 0;
    $("#" + TableID + "_tableColumn tr:last td:lt(" + FixColumnNumber + ")").each(function () {
        ColumnsWidth += $(this).outerWidth(true);
        ColumnsNumber++;
    });
    ColumnsWidth += 2;
    if ($.browser.msie) {
        switch ($.browser.version) {
            case "7.0":
                if (ColumnsNumber >= 3) ColumnsWidth--;
                break;
            case "8.0":
                if (ColumnsNumber >= 2) ColumnsWidth--;
                break;
        }
    }
    $("#" + TableID + "_tableColumn").css("width", ColumnsWidth);
    $("#" + TableID + "_tableFix").css("width", ColumnsWidth);
    $("#" + TableID + "_tableData").scroll(function () {
        $("#" + TableID + "_tableHead").scrollLeft($("#" + TableID + "_tableData").scrollLeft());
        $("#" + TableID + "_tableColumn").scrollTop($("#" + TableID + "_tableData").scrollTop());
    });
    $("#" + TableID + "_tableFix").css({ "overflow": "hidden", "position": "relative", "z-index": "50", "background-color": "Silver" });
    $("#" + TableID + "_tableHead").css({ "overflow": "hidden", "width": width - 17, "position": "relative", "z-index": "45", "background-color": "Silver" });
    $("#" + TableID + "_tableColumn").css({ "overflow": "hidden", "height": height - 17, "position": "relative", "z-index": "40", "background-color": "Silver" });
    $("#" + TableID + "_tableData").css({ "overflow": "scroll", "width": width, "height": height, "position": "relative", "z-index": "35" });
    if ($("#" + TableID + "_tableHead").width() > $("#" + TableID + "_tableFix table").width()) {
        $("#" + TableID + "_tableHead").css("width", $("#" + TableID + "_tableFix table").width());
        $("#" + TableID + "_tableData").css("width", $("#" + TableID + "_tableFix table").width() + 17);
    }
    if ($("#" + TableID + "_tableColumn").height() > $("#" + TableID + "_tableColumn table").height()) {
        $("#" + TableID + "_tableColumn").css("height", $("#" + TableID + "_tableColumn table").height());
        $("#" + TableID + "_tableData").css("height", $("#" + TableID + "_tableColumn table").height() + 17);
    }
    $("#" + TableID + "_tableFix").offset($("#" + TableID + "_tableLayout").offset());
    $("#" + TableID + "_tableHead").offset($("#" + TableID + "_tableLayout").offset());
    $("#" + TableID + "_tableColumn").offset($("#" + TableID + "_tableLayout").offset());
    $("#" + TableID + "_tableData").offset($("#" + TableID + "_tableLayout").offset());
}
$(document).ready(function () {
            FixTable("MyTable", 2, 600, 400);
        });
//-->
</script>
</head>
<body>
鸣谢原文转自
<br>
<a href="http://www.cnblogs.com/sorex/archive/2011/06/30/2093499.html">http://www.cnblogs.com/sorex/archive/2011/06/30/2093499.html</a>
<br>
<table
    style="border-bottom-color: black; border-top-color: black; width: 1000px; color: #000000; border-right-color: black; font-size: medium; border-left-color: black"
    id="MyTable"
    border="1"
    cellspacing="0"
    cellpadding="0"
>
<thead>
    <tr>
        <th style="text-align: center; width: 80px" rowspan="3">
            姓名
        </th>
        <th style="text-align: center; width: 80px" rowspan="3">
            班级
        </th>
        <th style="text-align: center" colspan="10">
            成绩
        </th>
    </tr>
    <tr>
        <th style="text-align: center" colspan="3">
            主科
        </th>
        <th style="text-align: center" colspan="3">
            文科
        </th>
        <th style="text-align: center" colspan="3">
            理科
        </th>
        <th style="text-align: center; width: 80px" rowspan="2">
            总分
        </th>
        </tr>
    <tr>
        <th style="text-align: center; width: 80px">
            语文
        </th>
        <th style="text-align: center; width: 80px">
            数学
        </th>
        <th style="text-align: center; width: 80px">
            英语
        </th>
        <th style="text-align: center; width: 80px">
            政治
        </th>
        <th style="text-align: center; width: 80px">
            历史
        </th>
        <th style="text-align: center; width: 80px">
            地理
        </th>
        <th style="text-align: center; width: 80px">
            物理
        </th>
        <th style="text-align: center; width: 80px">
            化学
        </th>
        <th style="text-align: center; width: 80px">
            生物
        </th>
    </tr>
    <!--
        <tr>
        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            姓名
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            班级
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            语文
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            数学
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            英语
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            政治
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            历史
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            地理
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            物理
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            化学
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            生物
                        </th>
                        <th style="width: 80px; text-align: center;" _mce_style="width: 80px; text-align: center;">
                            总分
                        </th>
                    
        </tr>
    -->
</thead>
    <tbody>
    <!-- 数据行 -->
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
                <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
        <tr>
            <td>
                学生32
            </td>
            <td>
                班级1
            </td>
            <td>
                29
            </td>
            <td>
                25
            </td>
            <td>
                146
            </td>
            <td>
                28
            </td>
            <td>
                79
            </td>
            <td>
                73
            </td>
            <td>
                47
            </td>
            <td>
                8
            </td>
            <td>
                91
            </td>
            <td>
                526
            </td>
        </tr>
    </tbody>
</table>
</body>
</html>

本文链接

CryptographyHelper, Symmetric Algorithm, Asymmetric Algorithm, Hash Algorithm, Keyed Hash Algorithm, RSA, X509

2011-07-14T16:02:00Z


/*
makecert.exe -n "CN=Microshaoft X509 Test - A" -sky exchange -pe -sv a.pvk a.cer
pvk2pfx.exe -pvk a.pvk -spc a.cer -pfx a.pfx -f -po 123
makecert.exe -n "CN=Microshaoft X509 Test - B" -sky exchange -pe -sv b.pvk b.cer
pvk2pfx.exe -pvk b.pvk -spc b.cer -pfx b.pfx -f -po abc
*/
namespace Test
{
    using System;
    using System.IO;
    using System.Text;
    using System.Threading;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates;
    using Microshaoft;
    class Class1
    {
        static void Main()
        {
            //=======================================
            UTF8Encoding e = new UTF8Encoding();
            string s;
            byte[] data = e.GetBytes
                                (
@"测试@microshaoft.com测试@microshaoft.com测试@microshaoft.com
测试@microshaoft.com测试@microshaoft.com测试@microshaoft.com");
            byte[] encryptedData;
            // Hybird
            Console.WriteLine("Hybird(X509+3DES):=====================");
            X509Certificate2 cerA = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.cer");
            X509Certificate2 pfxA = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.pfx", "123");
            X509Certificate2 cerB = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\b.cer");
            Secret secret = CryptographyHelper.HybridEncrypt
                                                    (
                                                        pfxA
                                                        , cerA
                                                        , cerB
                                                        , HashSignatureMode.SHA1
                                                        , false
                                                        , data
                                                    );
            X509Certificate2 pfxB = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\b.pfx", "abc");
            data = CryptographyHelper.HybridDecrypt(pfxB, secret);
            s = e.GetString(data);
            Console.WriteLine("Hybird decrypted plain text:");
            Console.WriteLine(s);
            //100 字节以内
            s = "测试@microshaoft.com测试@microshaoft.com测试@microshaoft.com测试";
            data = e.GetBytes(s);
            // X509
            Console.WriteLine("\nX509 加解密 只能处理100字节以内的加解密:=====================");
            X509Certificate2[] certs = X509CertificateHelper.LoadCertificatesFromStore
                                                                        (
                                                                            StoreName.My
                                                                            , StoreLocation.CurrentUser
                                                                            , "Microshaoft X509 Test"
                                                                            , X509FindType.FindBySubjectName
                                                                        );
            X509Certificate2 cert = null;
            if (certs != null)
            {
                foreach (X509Certificate2 c in certs)
                {
                    Console.WriteLine(c.Subject);
                    cert = c;
                }
            }
            X509Certificate2 cer = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.cer");
            X509Certificate2 pfx = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.pfx", "123");
            encryptedData = CryptographyHelper.X509CertificateEncrypt(cer, data, false);
            encryptedData = CryptographyHelper.X509CertificateDecrypt(pfx, encryptedData, false);
            s = e.GetString(encryptedData);
            Console.WriteLine("X509 decrypted plain text: {0}", s);
            //RSA
            Console.WriteLine("\nRSA 加解密 只能处理100字节以内的加解密:=====================");
            // RSA 非证书 只能处理100字节以内的加解密
            s = "测试@microshaoft.com测试@microshaoft.com测试@microshaoft.com测试";
            data = e.GetBytes(s);
            RSACryptoServiceProvider x = new RSACryptoServiceProvider();
            string privateKey = x.ToXmlString(true);
            Console.WriteLine("RSA Private Key: {0}", privateKey);
            string publicKey = x.ToXmlString(false);
            Console.WriteLine("RSA Public Key: {0}", publicKey);
            //公钥加密
            encryptedData = CryptographyHelper.RSAEncrypt(publicKey, data, false);
            //私钥解密
            data = CryptographyHelper.RSADecrypt(privateKey, encryptedData, false);
            Console.WriteLine("RSA Decrypted plaintext: {0}", e.GetString(data));
            //私钥签名
            byte[] signature = CryptographyHelper.RSASignSHA1(privateKey, data);
            //公钥验签
            Console.WriteLine(CryptographyHelper.RSAVerifySHA1(publicKey, data, signature));
            //TripleDES
            Console.WriteLine("\nTripleDES:===============");
            string key = "000111222333444555666777888999aaabbbcccdddeeefff";//48
            key = "0123456789abcdef01111111111111111111111111111110";
            string iv = "0123456789abcdef";//16
            iv = "0000000000000000";
            data = e.GetBytes("测试@microshaoft.com");
            SymmetricAlgorithm symmetricAlgorithm = new TripleDESCryptoServiceProvider();
            symmetricAlgorithm.Key = CryptographyHelper.HexStringToBytesArray(key);
            symmetricAlgorithm.IV = CryptographyHelper.HexStringToBytesArray(iv);
            data = CryptographyHelper.SymmetricAlgorithmEncrypt
                                            (
                                                symmetricAlgorithm
                                                , data 
                                            );
            //"测试@microshaoft.com"
            //3des: "A668632B4AA1EB8C1B25F7E66128846D28CEB416AC7B7B21"
            //篡改: "B668632B4AA1EB8C1B25F7E66128846D28CEB416AC7B7B21"
            data = CryptographyHelper.SymmetricAlgorithmDecrypt
                                            (
                                                symmetricAlgorithm, 
                                                data
                                            );
            Console.WriteLine("3DES Decrypted plaintext: {0}", e.GetString(data));
            Console.WriteLine("X509 并发测试");
            Console.ReadLine();
            encryptorPrivateKeyPfxProvider = encryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            encryptorPublicKeyCerProvider = encryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            decryptorPublicKeyCerProvider = decryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            decryptorPrivateKeyPfxProvider = decryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            for (int i = 0; i < 1000; i++)
            {
                ThreadStart ts = new ThreadStart(Run);
                Thread t = new Thread(ts);
                t.Name = _ThreadID.ToString();
                _ThreadID++;
                t.Start();
                //Run();
            }
            Console.WriteLine(Environment.Version.ToString());
        }
        private static volatile int _ThreadID = 0;
        private static object _syncLockObject = new object();
        private static X509Certificate2 encryptorPrivateKeyPfx = new X509Certificate2(@"a.pfx", "123");
        private static X509Certificate2 encryptorPublicKeyCer = new X509Certificate2(@"a.cer");
        private static X509Certificate2 decryptorPublicKeyCer = new X509Certificate2(@"b.cer");
        private static X509Certificate2 decryptorPrivateKeyPfx = new X509Certificate2(@"b.pfx", "abc");
        private static RSACryptoServiceProvider encryptorPrivateKeyPfxProvider = null;
        private static RSACryptoServiceProvider encryptorPublicKeyCerProvider = null;
        private static RSACryptoServiceProvider decryptorPublicKeyCerProvider = null;
        private static RSACryptoServiceProvider decryptorPrivateKeyPfxProvider = null;
        static void Run()
        {
            ///            X509Certificate2 cerA = null;// = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.cer");
            ///            X509Certificate2 pfxA = null;// = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.pfx", "123");
            ///            X509Certificate2 cerB = null;// = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\b.cer");
            ///            X509Certificate2 pfxB = null;// = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\b.pfx", "abc");
            //lock (_syncLockObject)
            {
                try
                {
                    //Thread.Sleep(50);
                    ///                        cerA = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.cer");
                    ///                        pfxA = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\a.pfx", "123");
                    ///                        cerB = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\b.cer");
                    ///                        pfxB = new X509Certificate2(@"C:\Users\xiyueyu\Desktop\b.pfx", "abc");
                    UTF8Encoding e = new UTF8Encoding();
                    string s;
                    byte[] data = e.GetBytes
                                        (
@"并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com
并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com
并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com
并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com
并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com
并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com
并发测试@microshaoft.com并发测试@microshaoft.com并发测试@microshaoft.com");
                    //byte[] encryptedData;
                    // Hybird
                    //Console.WriteLine("Hybird(X509+3DES):=====================");
                    Secret secret = CryptographyHelper.HybridEncrypt
                                                        (
                                                            encryptorPrivateKeyPfxProvider
                                                            , encryptorPublicKeyCer
                                                            , decryptorPublicKeyCerProvider
                                                            , HashSignatureMode.SHA1
                                                            , false
                                                            , data
                                                        );
                    data = CryptographyHelper.HybridDecrypt
                                                (
                                                    decryptorPrivateKeyPfxProvider
                                                    , encryptorPublicKeyCerProvider
                                                    , secret
                                                );
                    s = e.GetString(data);
                    Console.WriteLine("Hybird decrypted plain text: {0}", Thread.CurrentThread.Name);
                    Console.WriteLine(s);
                }
                catch (Exception e)
                {
                    //    Thread.Sleep(1200);
                    Console.WriteLine("exception sleep: {0}", e.ToString());
                    Console.WriteLine("exception sleep: {0}", Thread.CurrentThread.Name);
                    //    Run();
                }
                finally
                {
                    ///                    cerA.Reset();
                    ///                    pfxA.Reset();
                    ///                    cerB.Reset();
                    ///                    cerB.Reset();
                }
            }
        }
    }
}
namespace Microshaoft
{
    using System;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates;
    public static class X509CertificateHelper
    {
        public static X509Certificate2[] LoadCertificatesFromStore
                                            (
                                                StoreName storeName
                                                , StoreLocation storeLocation
                                                , string findValue
                                                , X509FindType findType
                                            )
        {
            X509Certificate2[] certs = null;
            X509Store store = new X509Store(storeName, storeLocation);
            store.Open(OpenFlags.ReadOnly);
            try
            {
                X509Certificate2Collection matches = store.Certificates.Find(findType, findValue, false);
                certs = new X509Certificate2[matches.Count];
                matches.CopyTo(certs, 0);
            }
            finally
            {
                store.Close();
            }
            return certs;
        }
    }
}
namespace Microshaoft
{
    using System;
    using System.IO;
    using System.Text;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates;
    public class Secret
    {
        public byte[] EncryptorSharedEncryptedOnceKey;
        public byte[] EncryptorSharedEncryptedOnceIV;
        public byte[] EncryptorHashSignature;
        public byte[] EncryptorPublicKeyCerRawData;
        public byte[] EncryptedData;
        public HashSignatureMode SignHashMode;
        public bool DoOAEPadding;
    }
    public enum HashSignatureMode
    {
        MD5
        , SHA1
    }
    public static class CryptographyHelper
    {
        public static byte[] HybridDecrypt
                                    (
                                        X509Certificate2 decryptorPrivateKeyPfx
                                        , Secret data
                                    )
        {
            X509Certificate2 encryptorPublicKeyCer = null;
            try
            {
                RSACryptoServiceProvider decryptorPrivateKeyPfxProvider = decryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
                encryptorPublicKeyCer = new X509Certificate2(data.EncryptorPublicKeyCerRawData);
                RSACryptoServiceProvider encryptorPublicKeyCerProvider = encryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
                return HybridDecrypt
                                    (
                                        decryptorPrivateKeyPfxProvider
                                        , encryptorPublicKeyCerProvider
                                        , data
                                    );
            }
            catch
            {
                return null;
            }
            finally
            {
                if (encryptorPublicKeyCer != null)
                {
                    encryptorPublicKeyCer.Reset();
                }
            }
        }
        public static byte[] HybridDecrypt
                                    (
                                        RSACryptoServiceProvider decryptorPrivateKeyPfxProvider
                                        , RSACryptoServiceProvider encryptorPublicKeyCerProvider
                                        , Secret data
                                    )
        {
            byte[] buffer = null;
            HashAlgorithm hashAlgorithm;
            if (data.SignHashMode == HashSignatureMode.SHA1)
            {
                hashAlgorithm = new SHA1CryptoServiceProvider();
            }
            else //(hashSignatureMode == HashSignatureMode.MD5)
            {
                hashAlgorithm = new MD5CryptoServiceProvider();
            }
            using (MemoryStream stream = new MemoryStream())
            {
                buffer = data.EncryptorSharedEncryptedOnceIV;
                stream.Write(buffer, 0, buffer.Length);
                buffer = data.EncryptorSharedEncryptedOnceKey;
                stream.Write(buffer, 0, buffer.Length);
                buffer = data.EncryptedData;
                stream.Position = 0;
                buffer = hashAlgorithm.ComputeHash(stream);
                stream.Close();
            }
            //X509Certificate2 encryptorPublicKeyCer = new X509Certificate2(data.EncryptorPublicKeyCerRawData);
            //RSACryptoServiceProvider encryptorPublicKeyCerProvider = encryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            if (encryptorPublicKeyCerProvider.VerifyHash
                                                (
                                                    buffer
                                                    , Enum.GetName
                                                                (
                                                                    data.SignHashMode.GetType()
                                                                    , data.SignHashMode
                                                                )
                                                    , data.EncryptorHashSignature
                                                )
                )
            {
                //decryptorPrivateKeyPfxProvider = decryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
                using (TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider())
                {
                    buffer = data.EncryptorSharedEncryptedOnceIV;
                    buffer = decryptorPrivateKeyPfxProvider.Decrypt(buffer, data.DoOAEPadding);
                    des.IV = buffer;
                    buffer = data.EncryptorSharedEncryptedOnceKey;
                    buffer = decryptorPrivateKeyPfxProvider.Decrypt(buffer, data.DoOAEPadding);
                    des.Key = buffer;
                    buffer = data.EncryptedData;
                    buffer = des.CreateDecryptor().TransformFinalBlock(buffer, 0, buffer.Length);
                }
            }
            else
            {
                buffer = null;
            }
            return buffer;
        }
        public static Secret HybridEncrypt
                                    (
                                        byte[] encryptorPrivateKeyPfxRawData
                                        , byte[] encryptorPublicKeyCerRawData
                                        , byte[] decryptorPublicKeyCerRawData
                                        , HashSignatureMode hashSignatureMode
                                        , bool DoOAEPadding
                                        , byte[] data
                                    )
        {
            X509Certificate2 encryptorPrivateKeyPfx = null;
            X509Certificate2 encryptorPublicKeyCer = null;
            X509Certificate2 decryptorPublicKeyCer = null;
            try
            {
                encryptorPrivateKeyPfx = null;
                encryptorPublicKeyCer = null;
                decryptorPublicKeyCer = null;
                return HybridEncrypt
                        (
                            encryptorPrivateKeyPfx
                            , encryptorPublicKeyCer
                            , decryptorPublicKeyCer
                            , hashSignatureMode
                            , DoOAEPadding
                            , data
                        );
            }
            catch
            {
                return null;
            }
            finally
            {
                if (encryptorPrivateKeyPfx != null)
                {
                    encryptorPrivateKeyPfx.Reset();
                }
                if (encryptorPublicKeyCer != null)
                {
                    encryptorPublicKeyCer.Reset();
                }
                if (decryptorPublicKeyCer != null)
                {
                    decryptorPublicKeyCer.Reset();
                }
            }
        }
        public static Secret HybridEncrypt
                                    (
                                        string encryptorPrivateKeyPfxFileName
                                        , string encryptorPublicKeyCerFileName
                                        , string decryptorPublicKeyCerFileName
                                        , HashSignatureMode hashSignatureMode
                                        , bool DoOAEPadding
                                        , byte[] data
                                    )
        {
            X509Certificate2 encryptorPrivateKeyPfx = null;
            X509Certificate2 encryptorPublicKeyCer = null;
            X509Certificate2 decryptorPublicKeyCer = null;
            try
            {
                encryptorPrivateKeyPfx = new X509Certificate2(encryptorPrivateKeyPfxFileName);
                encryptorPublicKeyCer = new X509Certificate2(encryptorPublicKeyCerFileName);
                decryptorPublicKeyCer = new X509Certificate2(decryptorPublicKeyCerFileName);
                return HybridEncrypt
                        (
                            encryptorPrivateKeyPfx
                            , encryptorPublicKeyCer
                            , decryptorPublicKeyCer
                            , hashSignatureMode
                            , DoOAEPadding
                            , data
                        );
            }
            catch
            {
                return null;
            }
            finally
            {
                if (encryptorPrivateKeyPfx != null)
                {
                    encryptorPrivateKeyPfx.Reset();
                }
                if (encryptorPublicKeyCer != null)
                {
                    encryptorPublicKeyCer.Reset();
                }
                if (decryptorPublicKeyCer != null)
                {
                    decryptorPublicKeyCer.Reset();
                }
            }
        }
        public static Secret HybridEncrypt
                                    (
                                        X509Certificate2 encryptorPrivateKeyPfx
                                        , X509Certificate2 encryptorPublicKeyCer
                                        , X509Certificate2 decryptorPublicKeyCer
                                        , HashSignatureMode signHashMode
                                        , bool DoOAEPadding
                                        , byte[] data
                                    )
        {
            RSACryptoServiceProvider encryptorPrivateKeyPfxProvider = encryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            RSACryptoServiceProvider decryptorPublicKeyCerProvider = decryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            return HybridEncrypt
                        (
                            encryptorPrivateKeyPfxProvider
                            , encryptorPublicKeyCer
                            , decryptorPublicKeyCerProvider
                            , signHashMode
                            , DoOAEPadding
                            , data
                        );
        }
        public static Secret HybridEncrypt
                                    (
                                        RSACryptoServiceProvider encryptorPrivateKeyPfxProvider
                                        , X509Certificate2 encryptorPublicKeyCer
                                        , RSACryptoServiceProvider decryptorPublicKeyCerProvider
                                        , HashSignatureMode signHashMode
                                        , bool DoOAEPadding
                                        , byte[] data
                                    )
        {
            Secret secret = new Secret();
            using (TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider())
            {
                provider.GenerateIV();
                secret.EncryptorSharedEncryptedOnceIV = provider.IV;
                provider.GenerateKey();
                secret.EncryptorSharedEncryptedOnceKey = provider.Key;
                secret.EncryptedData = provider.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
            }
            secret.EncryptorSharedEncryptedOnceIV = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceIV, DoOAEPadding);
            secret.EncryptorSharedEncryptedOnceKey = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceKey, DoOAEPadding);
            HashAlgorithm hashAlgorithm;
            if (signHashMode == HashSignatureMode.SHA1)
            {
                hashAlgorithm = new SHA1CryptoServiceProvider();
            }
            else //(hashSignatureMode == HashSignatureMode.MD5)
            {
                hashAlgorithm = new MD5CryptoServiceProvider();
            }
            MemoryStream stream = new MemoryStream();
            byte[] buffer = secret.EncryptorSharedEncryptedOnceIV;
            stream.Write(buffer, 0, buffer.Length);
            buffer = secret.EncryptorSharedEncryptedOnceKey;
            stream.Write(buffer, 0, buffer.Length);
            buffer = secret.EncryptedData;
            stream.Position = 0;
            buffer = hashAlgorithm.ComputeHash(stream);
            stream.Close();
            stream.Dispose();
            secret.EncryptorHashSignature = encryptorPrivateKeyPfxProvider.SignHash
                                                                                (
                                                                                    buffer
                                                                                    , Enum.GetName
                                                                                                (
                                                                                                    signHashMode.GetType()
                                                                                                    , signHashMode
                                                                                                )
                                                                                );
            secret.EncryptorPublicKeyCerRawData = encryptorPublicKeyCer.RawData;
            secret.SignHashMode = signHashMode;
            secret.DoOAEPadding = DoOAEPadding;
            return secret;
        }
        public static string GenerateTripleDESHexStringKey()
        {
            TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
            des.GenerateKey();
            return BytesArrayToHexString(des.Key);
        }
        public static string GenerateTripleDESHexStringIV()
        {
            TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
            des.GenerateIV();
            return BytesArrayToHexString(des.IV);
        }
       public static byte[] SymmetricAlgorithmEncrypt
                               (
                                    SymmetricAlgorithm algorithm
                                    , byte[] data
                                )
        {
            return algorithm.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
        }
        public static byte[] SymmetricAlgorithmEncrypt
                                       (
                                            SymmetricAlgorithm algorithm
                                            , string text
                                            , Encoding e
                                        )
        {
            return SymmetricAlgorithmEncrypt
                            (
                                algorithm
                                , e.GetBytes(text)
                            );
        }
        public static byte[] SymmetricAlgorithmDecrypt
                                        (
                                            SymmetricAlgorithm algorithm
                                            , byte[] data
                                         )
        {
            return algorithm.CreateDecryptor().TransformFinalBlock(data, 0, data.Length);
        }
        public static string SymmetricAlgorithmDecrypt
                                        (
                                            SymmetricAlgorithm algorithm
                                            , byte[] data
                                            , Encoding e //原文的encoding
                                        )
        {
            return e.GetString
                        (
                            SymmetricAlgorithmDecrypt
                                                (
                                                    algorithm
                                                    , data
                                                )
                        );
        }
        public static byte[] ComputeHash
                                    (
                                        HashAlgorithm algorithm
                                        , byte[] data
                                    )
        {
            return algorithm.ComputeHash(data);
        }
        public static byte[] ComputeHash
                                    (
                                        HashAlgorithm algorithm
                                        , string text
                                        , Encoding e
                                    )
        {
            return ComputeHash(algorithm, e.GetBytes(text));
        }
        public static byte[] ComputeKeyedHash
                                    (
                                        KeyedHashAlgorithm algorithm
                                        , byte[] data
                                    )
        {
            return ComputeHash(algorithm, data);
        }
        public static byte[] ComputeKeyedHash
                                    (
                                        KeyedHashAlgorithm algorithm
                                        , string text
                                        , Encoding e
                                    )
        {
            return ComputeHash(algorithm, text, e);
        }
                public static byte[] RSASignSHA1
                                (
                                    string privateKeyXml
                                    , byte[] data
                                )
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(privateKeyXml);
            return RSASignSHA1
                        (
                            provider
                            , data
                        );
        }
        public static byte[] RSASignSHA1
                                (
                                    RSACryptoServiceProvider provider
                                    , byte[] data
                                )
        {
            HashAlgorithm hashAlgorithm = new SHA1CryptoServiceProvider();
            return provider.SignHash
                                (
                                    ComputeHash(hashAlgorithm, data)
                                    , "SHA1"
                                );
        }
        public static bool RSAVerifySHA1
                                (
                                    string publicKeyXml
                                    , byte[] data
                                    , byte[] signature
                                )
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(publicKeyXml);
            return RSAVerifySHA1
                            (
                                provider
                                , data
                                , signature
                            );
        }
        public static bool RSAVerifySHA1
                                (
                                    RSACryptoServiceProvider provider
                                    , byte[] data
                                    , byte[] signature
                                )
        {
            HashAlgorithm hashAlgorithm = new SHA1CryptoServiceProvider();
            return provider.VerifyHash
                                (
                                    ComputeHash(hashAlgorithm, data)
                                    , "SHA1"
                                    , signature
                                );
        }
        public static byte[] RSASignMD5
                                (
                                    string privateKeyXml
                                    , byte[] data
                                )
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(privateKeyXml);
            return RSASignMD5
                        (
                            provider
                            , data
                        );
        }
        public static byte[] RSASignMD5
                                (
                                    RSACryptoServiceProvider provider
                                    , byte[] data
                                )
        {
            HashAlgorithm hashAlgorithm = new MD5CryptoServiceProvider();
            return provider.SignHash
                        (
                            ComputeHash(hashAlgorithm, data)
                            , "MD5"
                        );
        }
        public static bool RSAVerifyMD5
                                (
                                    string publicKeyXml
                                    , byte[] data
                                    , byte[] signature
                                )
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(publicKeyXml);
            return RSAVerifyMD5
                            (
                                provider
                                , data
                                , signature
                            );
        }
        public static bool RSAVerifyMD5
                                (
                                    RSACryptoServiceProvider provider
                                    , byte[] data
                                    , byte[] signature
                                )
        {
            HashAlgorithm hashAlgorithm = new MD5CryptoServiceProvider();
            return provider.VerifyHash
                                (
                                    ComputeHash(hashAlgorithm, data)
                                    , "MD5"
                                    , signature
                                );
        }
        public static byte[] RSAEncrypt
                                (
                                    string publicKeyXml
                                    , byte[] data
                                    , bool DoOAEPPadding
                                )
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(publicKeyXml);
            return RSAEncrypt
                        (
                            provider
                            , data
                            , DoOAEPPadding
                        );
        }
        public static byte[] RSAEncrypt
                        (
                            RSACryptoServiceProvider provider
                            , byte[] data
                            , bool DoOAEPPadding
                        )
        {
            return provider.Encrypt(data, DoOAEPPadding);
        }
        public static byte[] RSADecrypt
                                (
                                    string privateKeyXml
                                    , byte[] data
                                    , bool DoOAEPPadding
                                )
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(privateKeyXml);
            return RSADecrypt
                        (
                            provider
                            , data
                            , DoOAEPPadding
                        );
        }
        public static byte[] RSADecrypt
                                (
                                    RSACryptoServiceProvider provider
                                    , byte[] data
                                    , bool DoOAEPPadding
                                )
        {
            return provider.Decrypt(data, DoOAEPPadding);
        }
        public static byte[] X509CertificateEncrypt
                                    (
                                        X509Certificate2 publicKeyCer
                                        , byte[] data
                                        , bool DoOAEPadding
                                    )
        {
            RSACryptoServiceProvider provider = publicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            return RSAEncrypt
                        (
                            provider
                            , data
                            , DoOAEPadding
                        );
        }
        public static byte[] X509CertificateDecrypt
                                    (
                                        X509Certificate2 privateKeyPfx
                                        , byte[] data
                                        , bool DoOAEPadding
                                    )
        {
            RSACryptoServiceProvider provider = privateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            return RSADecrypt
                        (
                            provider
                            , data
                            , DoOAEPadding
                        );
        }
        public static byte[] X509CertificateSignSHA1
                                    (
                                        X509Certificate2 privateKeyPfx
                                        , byte[] data
                                    )
        {
            RSACryptoServiceProvider provider = privateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            return RSASignSHA1
                        (
                            provider
                            , data
                        );
        }
        public static byte[] X509CertificateSignMD5
                                    (
                                        X509Certificate2 privateKeyPfx
                                        , byte[] data
                                    )
        {
            RSACryptoServiceProvider provider = privateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            return RSASignMD5(provider, data);
        }
        public static bool X509CertificateVerifySHA1
                                    (
                                        X509Certificate2 publicKeyCer
                                        , byte[] data
                                        , byte[] signature
                                    )
        {
            RSACryptoServiceProvider provider = publicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            return RSAVerifySHA1
                        (
                            provider
                            , data
                            , signature
                        );
        }
        public static bool X509CertificateVerifyMD5
                                    (
                                        X509Certificate2 publicKeyCer
                                        , byte[] data
                                        , byte[] signature
                                    )
        {
            RSACryptoServiceProvider provider = publicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
            return RSAVerifyMD5
                        (
                            provider
                            , data
                            , signature
                        );
        }
        public static string BytesArrayToHexString(byte[] data)
        {
            return BitConverter.ToString(data).Replace("-", "");
        }
        public static byte[] HexStringToBytesArray(string text)
        {
            text = text.Replace(" ", "");
            int l = text.Length;
            byte[] buffer = new byte[l / 2];
            for (int i = 0; i < l; i += 2)
            {
                buffer[i / 2] = Convert.ToByte(text.Substring(i, 2), 16);
            }
            return buffer;
        }
    }
}

本文链接

ALTER INDEX Rebuild Reorganize 索引重建重组碎片率

2011-07-12T14:42:00Z


alter procedure zsp_IndexesReorganizeRebuildSQL
      @ReorganizePercent int = 10
    , @RebuildPercent int = 15
    , @Rows int = 10000
    , @Online bit = 1
    , @FillFactor int = 85
    , @IndexType varchar(max) = '1,2' --聚集,非聚集
as
--exec zsp_IndexesReorganizeRebuildSQL 0,0, 0, 1,0,0
begin
    --Microshaoft
    declare @Text varchar(max)
    declare @Table TABLE(id int,F int)
    set @Text = @IndexType
    set @Text = replace(@Text, ' ', '')
    declare @Separator char(1) = ','
    DECLARE @SeparatorLen int
    SET @SeparatorLen = LEN(@Separator + '$') - 2
    set @Text = replace(@Text, ' ', '')
    declare @i int
    set @i = 1
    WHILE CHARINDEX(@Separator, @Text) > 0
    BEGIN
        declare @v varchar(100)
        set @v = (LEFT(@Text, CHARINDEX(@Separator, @Text) - 1))
        INSERT @Table (id, F)
        select
            @i
            , @v
        where
            rtrim(ltrim(@v)) != ''
            and not exists
                        (
                            select
                                1
                            from
                                @Table
                            where
                                F = @v
                        )
        if @@rowcount > 0
        begin
            set @i = @i + 1
        end
        SET @Text = STUFF(@Text ,1, CHARINDEX(@Separator, @Text) + @SeparatorLen, '')
    END
    INSERT @Table (id, F)
    select
        @i
        , @Text
    where
        rtrim(ltrim(@Text)) != ''
        and not exists
                (
                    select
                        1
                    from
                        @Table
                    where
                        F = @Text
                )
    SELECT
            t.name as TableName
            , ix.Name as IndexName
            ,
                case
                    when
                        ix.type in (0)
                            then
                                'Heap'
                    when
                        ix.type in (1)
                            then
                                'Clustered'
                    when
                        ix.type in (2)
                            then
                                'Non-Clustered'
                    when
                        ix.type in (3)
                            then
                                'XML'
                    when
                        ix.type in (4)
                            then
                                'Spatial'
                    else
                                'Unknown'
                end as IndexType
            , avg_fragmentation_in_percent
            , RANK() OVER(ORDER BY avg_fragmentation_in_percent DESC) as Rank_avg_fragmentation_in_percent
            , ix.fill_factor
            ,
                'ALTER INDEX ['
            +
                ix.name
            +
                '] ON ['
            +
                s.name
            +
                '].['
            +
                t.name
            +
                '] '
            +
                CASE
                    WHEN
                        ps.avg_fragmentation_in_percent >= @RebuildPercent
                            THEN
                                'REBUILD'
                    ELSE
                                'REORGANIZE'
                END
            +
                CASE
                    WHEN
                        pc.partition_count > 1
                            THEN
                                ' PARTITION = ' + CAST(ps.partition_number AS varchar)
                    ELSE
                        ''
                END
            +
                --Microshaoft
                ' WITH (ONLINE = '
            +
                CASE
                    WHEN
                        @Online = 1
                            THEN
                                ' on'
                    ELSE
                                ' off'
                END
            +
                CASE
                    WHEN
                        @FillFactor > 0 and @FillFactor < 100
                            THEN
                                ', PAD_INDEX = on, FILLFACTOR = '
                                + cast(@FillFactor as varchar)
                    ELSE
                                ', PAD_INDEX = on'
                END
            +
                ')' as [SQL]
    FROM
        sys.indexes AS ix with(nolock)
            INNER JOIN
                sys.tables t with(nolock)
                    ON
                        t.object_id = ix.object_id
            INNER JOIN
                sys.schemas s
                    ON
                        t.schema_id = s.schema_id
            INNER JOIN
                    (
                        SELECT
                            object_id
                            , index_id
                            , avg_fragmentation_in_percent
                            , partition_number
                        FROM
                            sys.dm_db_index_physical_stats(DB_ID(), NULL, NULL, NULL, NULL) --with(nolock)
                    ) ps
                    ON
                        t.object_id = ps.object_id
                        AND ix.index_id = ps.index_id
            INNER JOIN
                    (
                        SELECT
                            object_id
                            , index_id
                            , COUNT(DISTINCT partition_number) AS partition_count
                        FROM
                            sys.partitions with(nolock)
                        GROUP BY
                            object_id
                            , index_id
                    ) pc
                    ON
                        t.object_id = pc.object_id
                        AND ix.index_id = pc.index_id
    WHERE
        ix.Type in
                (
                    select
                            F
                    from
                        @Table
                )
        and
        ps.avg_fragmentation_in_percent >= @ReorganizePercent
        AND ix.name IS NOT NULL
        --引用 上面语句是网上的,加了行数判断,也可以用页数量判断
        and exists
                (
                    select
                        *
                    from
                        sys.partitions with(nolock)
                    where
                        object_id = t.object_id
                        and [rows] >= @Rows
                            /*
                                引用
                                控制一下记录行数,因为小表的rebuild等会根据很多参数标准来判断是否要去重建。
                                网上搜索的判断因子:
                                生成查询计划的阀值
                                缓存机制,缓存的筛选,LRU算法
                                预读机制
                                checkpoint减少回滚距离
                                智能join判断
                                重编译
                            */
                )
    --Microshaoft
    order by
        ix.Type
        , TableName
        , avg_fragmentation_in_percent desc
end

本文链接

ConcurrentAsyncQueue

2011-06-18T03:27:00Z


//AsyncQueue.cs
//#define c4 //C# 4.0+
#define c4
namespace Microshaoft
{
    using System;
    using System.Threading;
    using System.Diagnostics;
    using System.Collections.Generic;
#if c4
    using System.Collections.Concurrent;
#endif
    using Microshaoft;
    public class ConcurrentAsyncQueue<T>
                        where T : class
    {
        public delegate void QueueEventHandler(T element);
        public event QueueEventHandler OnDequeue;
        public delegate void QueueLogEventHandler(string logMessage);
        //public event QueueLogEventHandler OnQueueLog;
        public event QueueLogEventHandler OnQueueRunningThreadStart;
        public event QueueLogEventHandler OnQueueRunningThreadEnd;
        public event QueueLogEventHandler OnDequeueThreadStart;
        public event QueueLogEventHandler OnDequeueThreadEnd;
        public event QueueLogEventHandler OnDequeueAllThreadsEnd;
        public delegate void ExceptionEventHandler(Exception exception);
        public event ExceptionEventHandler OnException;
#if c2
        private Queue<T> _queue = new Queue<T>();
#elif c4
        private ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();
#endif
        private object _syncQueueLockObject = new object();
        //private object _syncQueueRunningLockObject = new object();
        private long _isQueueRunning = 0;
        private long _concurrentDequeueThreadsCount = 0; //Microshaoft 用于控制并发线程数
        private PerformanceCounter _enqueuePerformanceCounter;
        private PerformanceCounter _dequeuePerformanceCounter;
        private PerformanceCounter _dequeueProcessedPerformanceCounter;
        private PerformanceCounter _queueLengthPerformanceCounter;
        private PerformanceCounter _dequeueThreadStartPerformanceCounter;
        private PerformanceCounter _dequeueThreadEndPerformanceCounter;
        private PerformanceCounter _dequeueThreadsCountPerformanceCounter;
        private PerformanceCounter _queueRunningThreadStartPerformanceCounter;
        private PerformanceCounter _queueRunningThreadEndPerformanceCounter;
        private PerformanceCounter _queueRunningThreadsCountPerformanceCounter;
        private bool _isAttachedPerformanceCounters = false;
        public void AttachPerformanceCounters(string instanceNamePrefix)
        {
            string category = "Microshaoft AsyncConurrentQueue Counters";
            string counter = string.Empty;
            Process process = Process.GetCurrentProcess();
            //int processID = 0;//process.Id;
            string processName = process.ProcessName;
            //string processStartTime = "";//process.StartTime;
            string instanceName = string.Empty;
            instanceName = string.Format
                                    (
                                        "{0}-{1}"
                                        , instanceNamePrefix
                                        , processName
                                        //, processID
                                        //, processStartTime.ToString("yyyy-MM-dd HH:mm:ss.fff")
                                    );
            CounterCreationDataCollection ccdc = new CounterCreationDataCollection();
            if (PerformanceCounterCategory.Exists(category))
            {
                PerformanceCounterCategory.Delete(category);
            }
            CounterCreationData ccd = null;
            counter = "EnqueueCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueLengthCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueProcessedCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueThreadStartCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueThreadEndCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueThreadsCountCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueRunningThreadStartCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueRunningThreadEndCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueRunningThreadsCountCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            PerformanceCounterCategory.Create
                                            (
                                                category,
                                                string.Format("{0} Category Help.", category),
                                                PerformanceCounterCategoryType.MultiInstance,
                                                ccdc
                                            );
            counter = "EnqueueCounter";
            _enqueuePerformanceCounter = new PerformanceCounter();
            _enqueuePerformanceCounter.CategoryName = category;
            _enqueuePerformanceCounter.CounterName = counter;
            _enqueuePerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _enqueuePerformanceCounter.InstanceName = instanceName;
            _enqueuePerformanceCounter.ReadOnly = false;
            _enqueuePerformanceCounter.RawValue = 0;
            counter = "DequeueCounter";
            _dequeuePerformanceCounter = new PerformanceCounter();
            _dequeuePerformanceCounter.CategoryName = category;
            _dequeuePerformanceCounter.CounterName = counter;
            _dequeuePerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeuePerformanceCounter.InstanceName = instanceName;
            _dequeuePerformanceCounter.ReadOnly = false;
            _dequeuePerformanceCounter.RawValue = 0;
            counter = "DequeueProcessedCounter";
            _dequeueProcessedPerformanceCounter = new PerformanceCounter();
            _dequeueProcessedPerformanceCounter.CategoryName = category;
            _dequeueProcessedPerformanceCounter.CounterName = counter;
            _dequeueProcessedPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueProcessedPerformanceCounter.InstanceName = instanceName;
            _dequeueProcessedPerformanceCounter.ReadOnly = false;
            _dequeueProcessedPerformanceCounter.RawValue = 0;
            counter = "QueueLengthCounter";
            _queueLengthPerformanceCounter = new PerformanceCounter();
            _queueLengthPerformanceCounter.CategoryName = category;
            _queueLengthPerformanceCounter.CounterName = counter;
            _queueLengthPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueLengthPerformanceCounter.InstanceName = instanceName;
            _queueLengthPerformanceCounter.ReadOnly = false;
            _queueLengthPerformanceCounter.RawValue = 0;
            counter = "DequeueThreadStartCounter";
            _dequeueThreadStartPerformanceCounter = new PerformanceCounter();
            _dequeueThreadStartPerformanceCounter.CategoryName = category;
            _dequeueThreadStartPerformanceCounter.CounterName = counter;
            _dequeueThreadStartPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueThreadStartPerformanceCounter.InstanceName = instanceName;
            _dequeueThreadStartPerformanceCounter.ReadOnly = false;
            _dequeueThreadStartPerformanceCounter.RawValue = 0;
            counter = "DequeueThreadEndCounter";
            _dequeueThreadEndPerformanceCounter = new PerformanceCounter();
            _dequeueThreadEndPerformanceCounter.CategoryName = category;
            _dequeueThreadEndPerformanceCounter.CounterName = counter;
            _dequeueThreadEndPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueThreadEndPerformanceCounter.InstanceName = instanceName;
            _dequeueThreadEndPerformanceCounter.ReadOnly = false;
            _dequeueThreadEndPerformanceCounter.RawValue = 0;
            counter = "DequeueThreadsCountCounter";
            _dequeueThreadsCountPerformanceCounter = new PerformanceCounter();
            _dequeueThreadsCountPerformanceCounter.CategoryName = category;
            _dequeueThreadsCountPerformanceCounter.CounterName = counter;
            _dequeueThreadsCountPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueThreadsCountPerformanceCounter.InstanceName = instanceName;
            _dequeueThreadsCountPerformanceCounter.ReadOnly = false;
            _dequeueThreadsCountPerformanceCounter.RawValue = 0;
            counter = "QueueRunningThreadStartCounter";
            _queueRunningThreadStartPerformanceCounter = new PerformanceCounter();
            _queueRunningThreadStartPerformanceCounter.CategoryName = category;
            _queueRunningThreadStartPerformanceCounter.CounterName = counter;
            _queueRunningThreadStartPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueRunningThreadStartPerformanceCounter.InstanceName = instanceName;
            _queueRunningThreadStartPerformanceCounter.ReadOnly = false;
            _queueRunningThreadStartPerformanceCounter.RawValue = 0;
            counter = "QueueRunningThreadEndCounter";
            _queueRunningThreadEndPerformanceCounter = new PerformanceCounter();
            _queueRunningThreadEndPerformanceCounter.CategoryName = category;
            _queueRunningThreadEndPerformanceCounter.CounterName = counter;
            _queueRunningThreadEndPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueRunningThreadEndPerformanceCounter.InstanceName = instanceName;
            _queueRunningThreadEndPerformanceCounter.ReadOnly = false;
            _queueRunningThreadEndPerformanceCounter.RawValue = 0;
            counter = "QueueRunningThreadsCountCounter";
            _queueRunningThreadsCountPerformanceCounter = new PerformanceCounter();
            _queueRunningThreadsCountPerformanceCounter.CategoryName = category;
            _queueRunningThreadsCountPerformanceCounter.CounterName = counter;
            _queueRunningThreadsCountPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueRunningThreadsCountPerformanceCounter.InstanceName = instanceName;
            _queueRunningThreadsCountPerformanceCounter.ReadOnly = false;
            _queueRunningThreadsCountPerformanceCounter.RawValue = 0;
            _isAttachedPerformanceCounters = true;
        }
        private int _maxConcurrentDequeueThreadsCount = 1; //Microshaoft 允许并发出列处理线程数为 1
        public int MaxConcurrentDequeueThreadsCount
        {
            set
            {
                _maxConcurrentDequeueThreadsCount = value;
            }
            get
            {
                return _maxConcurrentDequeueThreadsCount;
            }
        }
        //Microshaoft 服务启动后可立即开启新的线程调用此方法(死循环)
        private void QueueRun() //Microshaoft ThreadStart
        {
            if (Interlocked.Read(ref _concurrentDequeueThreadsCount) < _maxConcurrentDequeueThreadsCount)
            {
                if (Interlocked.CompareExchange(ref _isQueueRunning, 0, 1) == 0)
                {
                    ThreadStart ts = new ThreadStart(QueueRunThreadProcess);
                    Thread t = new Thread(ts);
                    t.Name = "QueueRunningThreadProcess";
                    t.Start();
                }
            }
        }
        public int Count
        {
            get
            {
                return _queue.Count;
            }
        }
        public long ConcurrentThreadsCount
        {
            get
            {
                return _concurrentDequeueThreadsCount;
            }
        }
        private void QueueRunThreadProcess()
        {
            if (_isAttachedPerformanceCounters)
            {
                _queueRunningThreadStartPerformanceCounter.Increment();
                _queueRunningThreadsCountPerformanceCounter.Increment();
            }
            if (OnQueueRunningThreadStart != null)
            {
                OnQueueRunningThreadStart
                    (
                        string.Format
                                (
                                    "{0} Threads Count {1},Queue Count {2},Current Thread: {3}({4}) at {5}"
                                    , "Queue Running Start ..."
                                    , _concurrentDequeueThreadsCount
                                    , _queue.Count
                                    , Thread.CurrentThread.Name
                                    , Thread.CurrentThread.ManagedThreadId
                                    , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                )
                    );
            }
#if c2
            while ((_queue.Count > 0)) //Microshaoft 死循环
#elif c4
            while (!_queue.IsEmpty) //Microshaoft 死循环
#endif
            {
                int threadID = -1;
                {
                    int r = (int) Interlocked.Read(ref _concurrentDequeueThreadsCount);
                    if (r < _maxConcurrentDequeueThreadsCount)
                    {
                        //if (_queue.Count > 0)
                        {
                            r = (int) Interlocked.Increment(ref _concurrentDequeueThreadsCount);
                            threadID = (int) _concurrentDequeueThreadsCount;
                            //ThreadProcessState tps = new ThreadProcessState();
                            //tps.element = element;
                            //tps.Sender = this;
                            Thread t = new Thread(new ThreadStart(DequeueThreadProcess));
                            t.TrySetApartmentState(ApartmentState.STA);
                            t.Name = string.Format("ConcurrentDequeueProcessThread[{0}]", threadID);
                            t.Start();
                        }
///                        else
///                        {
///                            break;
///                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }
            //Interlocked.CompareExchange(ref _queueRuning, 0, 1);
            if (OnQueueRunningThreadEnd != null)
            {
                int r = (int) Interlocked.Read(ref _concurrentDequeueThreadsCount);
                OnQueueRunningThreadEnd
                            (
                                string.Format
                                        (
                                            "{0} Threads Count {1}, Queue Count {2}, Current Thread: {3}({4}) at {5}"
                                            , "Queue Running Stop ..."
                                            , r
                                            , _queue.Count
                                            , Thread.CurrentThread.Name
                                            , Thread.CurrentThread.ManagedThreadId
                                            , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                        )
                            );
            }
            if (_isAttachedPerformanceCounters)
            {
                _queueRunningThreadEndPerformanceCounter.Increment();
                _queueRunningThreadsCountPerformanceCounter.Decrement();
            }
            Interlocked.Exchange(ref _isQueueRunning, 0);
        }
        public void Enqueue(T element)
        {
            try
            {
#if c2
                lock (_syncQueueLockObject) //还算并发吗?
#endif
                {
                    _queue.Enqueue(element);
                }
                if (_isAttachedPerformanceCounters)
                {
                    _enqueuePerformanceCounter.Increment();
                    _queueLengthPerformanceCounter.Increment();
                }
            }
            catch (Exception e)
            {
                if (OnException != null)
                {
                    OnException(e);
                }
            }
            //int r = Interlocked.CompareExchange(ref _queueRuning, 1, 0))
            //if (r == 1)
            //{
            QueueRun();
            //}
        }
        private void DequeueThreadProcess()
        {
            if (_isAttachedPerformanceCounters)
            {
                _dequeueThreadStartPerformanceCounter.Increment();
                _dequeueThreadsCountPerformanceCounter.Increment();
            }
            if (OnDequeueThreadStart != null)
            {
                int r = (int) Interlocked.Read(ref _concurrentDequeueThreadsCount);
                OnDequeueThreadStart
                                (
                                    string.Format
                                            (
                                                "{0} Threads Count {1},Queue Count {2},Current Thread: {3} at {4}"
                                                , "Threads ++ !"
                                                , r
                                                , _queue.Count
                                                , Thread.CurrentThread.Name
                                                , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                            )
                                );
            }
            bool queueWasNotEmpty = false;
            try
            {
#if c2
                while (true)
#elif c4
                while (!_queue.IsEmpty)
#endif
                {
                    T element = null;
#if c2
                    lock (_syncQueueLockObject)
                    {
                        if (_queue.Count > 0)
                        {
                            element = _queue.Dequeue();
                        }
                        else
                        {
                            //避免QueueRun 死循环
                            break;
                        }
                    }
#elif c4
                    if (_queue.TryDequeue(out element))
                    {
#elif c2
                        if (element != null)
                        {
#endif
                            if (!queueWasNotEmpty)
                            {
                                queueWasNotEmpty = true;
                            }
                            if (_isAttachedPerformanceCounters)
                            {
                                _dequeuePerformanceCounter.Increment();
                                _queueLengthPerformanceCounter.Decrement();
                            }
                            if (OnDequeue != null)
                            {
                                OnDequeue(element);
                            }
                            if (_isAttachedPerformanceCounters)
                            {
                                _dequeueProcessedPerformanceCounter.Increment();
                            }
#if c2
                        }
#elif c4
                    }
                }
#endif
            }
            catch (Exception e)
            {
                if (OnException != null)
                {
                    OnException(e);
                }
            }
            finally
            {
                int r = (int) Interlocked.Decrement(ref _concurrentDequeueThreadsCount);
                if (OnDequeueThreadEnd != null)
                {
                    OnDequeueThreadEnd
                                (
                                    string.Format
                                            (
                                                "{0} Threads Count {1},Queue Count {2},Current Thread: {3} at {4}"
                                                , "Threads--"
                                                , r
                                                , _queue.Count
                                                , Thread.CurrentThread.Name
                                                , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                            )
                                );
                }
                if (r == 0)
                {
                    if (OnDequeueAllThreadsEnd != null)
                    {
                        OnDequeueAllThreadsEnd
                                    (
                                        string.Format
                                                (
                                                    "{0} Threads Count {1},Queue Count {2},Current Thread: {3} at {4}"
                                                    , "All Threads End"
                                                    , r
                                                    , _queue.Count
                                                    , Thread.CurrentThread.Name
                                                    , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                                )
                                    );
                    }
                }
                if (_isAttachedPerformanceCounters)
                {
                    _dequeueThreadEndPerformanceCounter.Increment();
                    _dequeueThreadsCountPerformanceCounter.Decrement();
                }
                if (queueWasNotEmpty)
                {
                    QueueRun(); //死循环???
                }
            }
        }
    }
}
namespace Microshaoft
{
    using System;
    using System.Diagnostics;
    public static class PerformanceCounterHelper
    {
        public static CounterCreationData GetCounterCreationData(string counterName, PerformanceCounterType performanceCounterType)
        {
            CounterCreationData ccd = new CounterCreationData();
            ccd.CounterName = counterName;
            ccd.CounterHelp = string.Format("{0} Help", counterName);
            ccd.CounterType = performanceCounterType;
            return ccd;
        }
    }
}

本文链接

Proxy Concurrent AsyncQueue WebService Invoker

2011-06-16T15:53:00Z


//AsyncQueue.cs
//#define c4 //C# 4.0+
#define c4
namespace Microshaoft
{
    using System;
    using System.Threading;
    using System.Diagnostics;
    using System.Collections.Generic;
#if c4
    using System.Collections.Concurrent;
#endif
    using Microshaoft;
    public class AsyncQueue<T>
                        where T : class
    {
        public delegate void QueueEventHandler(T element);
        public event QueueEventHandler OnDequeue;
        public delegate void QueueLogEventHandler(string logMessage);
        //public event QueueLogEventHandler OnQueueLog;
        public event QueueLogEventHandler OnQueueRunningThreadStart;
        public event QueueLogEventHandler OnQueueRunningThreadEnd;
        public event QueueLogEventHandler OnDequeueThreadStart;
        public event QueueLogEventHandler OnDequeueThreadEnd;
        public event QueueLogEventHandler OnDequeueAllThreadsEnd;
        public delegate void ExceptionEventHandler(Exception exception);
        public event ExceptionEventHandler OnException;
#if c2
        private Queue<T> _queue = new Queue<T>();
#elif c4
        private ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();
#endif
        private object _syncQueueLockObject = new object();
        //private object _syncQueueRunningLockObject = new object();
        private long _isQueueRunning = 0;
        private long _concurrentDequeueThreadsCount = 0; //Microshaoft 用于控制并发线程数
        private PerformanceCounter _enqueuePerformanceCounter;
        private PerformanceCounter _dequeuePerformanceCounter;
        private PerformanceCounter _dequeueProcessedPerformanceCounter;
        private PerformanceCounter _queueLengthPerformanceCounter;
        private PerformanceCounter _dequeueThreadStartPerformanceCounter;
        private PerformanceCounter _dequeueThreadEndPerformanceCounter;
        private PerformanceCounter _dequeueThreadsCountPerformanceCounter;
        private PerformanceCounter _queueRunningThreadStartPerformanceCounter;
        private PerformanceCounter _queueRunningThreadEndPerformanceCounter;
        private PerformanceCounter _queueRunningThreadsCountPerformanceCounter;
        private bool _isAttachedPerformanceCounters = false;
        public void AttachPerformanceCounters(string instanceNamePrefix)
        {
            string category = "Microshaoft AsyncConurrentQueue Counters";
            string counter = string.Empty;
            Process process = Process.GetCurrentProcess();
            //int processID = 0;//process.Id;
            string processName = process.ProcessName;
            //string processStartTime = "";//process.StartTime;
            string instanceName = string.Empty;
            instanceName = string.Format
                                    (
                                        "{0}-{1}"
                                        , instanceNamePrefix
                                        , processName
                                        //, processID
                                        //, processStartTime.ToString("yyyy-MM-dd HH:mm:ss.fff")
                                    );
            CounterCreationDataCollection ccdc = new CounterCreationDataCollection();
            if (PerformanceCounterCategory.Exists(category))
            {
                PerformanceCounterCategory.Delete(category);
            }
            CounterCreationData ccd = null;
            counter = "EnqueueCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueLengthCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueProcessedCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueThreadStartCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueThreadEndCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "DequeueThreadsCountCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueRunningThreadStartCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueRunningThreadEndCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            counter = "QueueRunningThreadsCountCounter";
            ccd = PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64);
            ccdc.Add(PerformanceCounterHelper.GetCounterCreationData(counter, PerformanceCounterType.NumberOfItems64));
            PerformanceCounterCategory.Create
                                            (
                                                category,
                                                string.Format("{0} Category Help.", category),
                                                PerformanceCounterCategoryType.MultiInstance,
                                                ccdc
                                            );
            counter = "EnqueueCounter";
            _enqueuePerformanceCounter = new PerformanceCounter();
            _enqueuePerformanceCounter.CategoryName = category;
            _enqueuePerformanceCounter.CounterName = counter;
            _enqueuePerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _enqueuePerformanceCounter.InstanceName = instanceName;
            _enqueuePerformanceCounter.ReadOnly = false;
            _enqueuePerformanceCounter.RawValue = 0;
            counter = "DequeueCounter";
            _dequeuePerformanceCounter = new PerformanceCounter();
            _dequeuePerformanceCounter.CategoryName = category;
            _dequeuePerformanceCounter.CounterName = counter;
            _dequeuePerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeuePerformanceCounter.InstanceName = instanceName;
            _dequeuePerformanceCounter.ReadOnly = false;
            _dequeuePerformanceCounter.RawValue = 0;
            counter = "DequeueProcessedCounter";
            _dequeueProcessedPerformanceCounter = new PerformanceCounter();
            _dequeueProcessedPerformanceCounter.CategoryName = category;
            _dequeueProcessedPerformanceCounter.CounterName = counter;
            _dequeueProcessedPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueProcessedPerformanceCounter.InstanceName = instanceName;
            _dequeueProcessedPerformanceCounter.ReadOnly = false;
            _dequeueProcessedPerformanceCounter.RawValue = 0;
            counter = "QueueLengthCounter";
            _queueLengthPerformanceCounter = new PerformanceCounter();
            _queueLengthPerformanceCounter.CategoryName = category;
            _queueLengthPerformanceCounter.CounterName = counter;
            _queueLengthPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueLengthPerformanceCounter.InstanceName = instanceName;
            _queueLengthPerformanceCounter.ReadOnly = false;
            _queueLengthPerformanceCounter.RawValue = 0;
            counter = "DequeueThreadStartCounter";
            _dequeueThreadStartPerformanceCounter = new PerformanceCounter();
            _dequeueThreadStartPerformanceCounter.CategoryName = category;
            _dequeueThreadStartPerformanceCounter.CounterName = counter;
            _dequeueThreadStartPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueThreadStartPerformanceCounter.InstanceName = instanceName;
            _dequeueThreadStartPerformanceCounter.ReadOnly = false;
            _dequeueThreadStartPerformanceCounter.RawValue = 0;
            counter = "DequeueThreadEndCounter";
            _dequeueThreadEndPerformanceCounter = new PerformanceCounter();
            _dequeueThreadEndPerformanceCounter.CategoryName = category;
            _dequeueThreadEndPerformanceCounter.CounterName = counter;
            _dequeueThreadEndPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueThreadEndPerformanceCounter.InstanceName = instanceName;
            _dequeueThreadEndPerformanceCounter.ReadOnly = false;
            _dequeueThreadEndPerformanceCounter.RawValue = 0;
            counter = "DequeueThreadsCountCounter";
            _dequeueThreadsCountPerformanceCounter = new PerformanceCounter();
            _dequeueThreadsCountPerformanceCounter.CategoryName = category;
            _dequeueThreadsCountPerformanceCounter.CounterName = counter;
            _dequeueThreadsCountPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _dequeueThreadsCountPerformanceCounter.InstanceName = instanceName;
            _dequeueThreadsCountPerformanceCounter.ReadOnly = false;
            _dequeueThreadsCountPerformanceCounter.RawValue = 0;
            counter = "QueueRunningThreadStartCounter";
            _queueRunningThreadStartPerformanceCounter = new PerformanceCounter();
            _queueRunningThreadStartPerformanceCounter.CategoryName = category;
            _queueRunningThreadStartPerformanceCounter.CounterName = counter;
            _queueRunningThreadStartPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueRunningThreadStartPerformanceCounter.InstanceName = instanceName;
            _queueRunningThreadStartPerformanceCounter.ReadOnly = false;
            _queueRunningThreadStartPerformanceCounter.RawValue = 0;
            counter = "QueueRunningThreadEndCounter";
            _queueRunningThreadEndPerformanceCounter = new PerformanceCounter();
            _queueRunningThreadEndPerformanceCounter.CategoryName = category;
            _queueRunningThreadEndPerformanceCounter.CounterName = counter;
            _queueRunningThreadEndPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueRunningThreadEndPerformanceCounter.InstanceName = instanceName;
            _queueRunningThreadEndPerformanceCounter.ReadOnly = false;
            _queueRunningThreadEndPerformanceCounter.RawValue = 0;
            counter = "QueueRunningThreadsCountCounter";
            _queueRunningThreadsCountPerformanceCounter = new PerformanceCounter();
            _queueRunningThreadsCountPerformanceCounter.CategoryName = category;
            _queueRunningThreadsCountPerformanceCounter.CounterName = counter;
            _queueRunningThreadsCountPerformanceCounter.InstanceLifetime = PerformanceCounterInstanceLifetime.Process;
            _queueRunningThreadsCountPerformanceCounter.InstanceName = instanceName;
            _queueRunningThreadsCountPerformanceCounter.ReadOnly = false;
            _queueRunningThreadsCountPerformanceCounter.RawValue = 0;
            _isAttachedPerformanceCounters = true;
        }
        private int _maxConcurrentThreadsCount = 1; //Microshaoft 允许并发出列处理线程数为 1
        public int MaxConcurrentThreadsCount
        {
            set
            {
                _maxConcurrentThreadsCount = value;
            }
            get
            {
                return _maxConcurrentThreadsCount;
            }
        }
        //Microshaoft 服务启动后可立即开启新的线程调用此方法(死循环)
        private void QueueRun() //Microshaoft ThreadStart
        {
            if (Interlocked.Read(ref _concurrentDequeueThreadsCount) < _maxConcurrentThreadsCount)
            {
                if (Interlocked.CompareExchange(ref _isQueueRunning, 0, 1) == 0)
                {
                    ThreadStart ts = new ThreadStart(QueueRunThreadProcess);
                    Thread t = new Thread(ts);
                    t.Name = "QueueRunningThreadProcess";
                    t.Start();
                }
            }
        }
        public int Count
        {
            get
            {
                return _queue.Count;
            }
        }
        public long ConcurrentThreadsCount
        {
            get
            {
                return _concurrentDequeueThreadsCount;
            }
        }
        private void QueueRunThreadProcess()
        {
            if (_isAttachedPerformanceCounters)
            {
                _queueRunningThreadStartPerformanceCounter.Increment();
                _queueRunningThreadsCountPerformanceCounter.Increment();
            }
            if (OnQueueRunningThreadStart != null)
            {
                OnQueueRunningThreadStart
                    (
                        string.Format
                                (
                                    "{0} Threads Count {1},Queue Count {2},Current Thread: {3}({4}) at {5}"
                                    , "Queue Running Start ..."
                                    , _concurrentDequeueThreadsCount
                                    , _queue.Count
                                    , Thread.CurrentThread.Name
                                    , Thread.CurrentThread.ManagedThreadId
                                    , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                )
                    );
            }
#if c2
            while ((_queue.Count > 0)) //Microshaoft 死循环
#elif c4
            while (!_queue.IsEmpty) //Microshaoft 死循环
#endif
            {
                int threadID = -1;
                {
                    int r = (int) Interlocked.Read(ref _concurrentDequeueThreadsCount);
                    if (r < _maxConcurrentThreadsCount)
                    {
                        //if (_queue.Count > 0)
                        {
                            r = (int) Interlocked.Increment(ref _concurrentDequeueThreadsCount);
                            threadID = (int) _concurrentDequeueThreadsCount;
                            //ThreadProcessState tps = new ThreadProcessState();
                            //tps.element = element;
                            //tps.Sender = this;
                            Thread t = new Thread(new ThreadStart(DequeueThreadProcess));
                            t.TrySetApartmentState(ApartmentState.STA);
                            t.Name = string.Format("ConcurrentDequeueProcessThread[{0}]", threadID);
                            t.Start();
                        }
///                        else
///                        {
///                            break;
///                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }
            //Interlocked.CompareExchange(ref _queueRuning, 0, 1);
            if (OnQueueRunningThreadEnd != null)
            {
                int r = (int) Interlocked.Read(ref _concurrentDequeueThreadsCount);
                OnQueueRunningThreadEnd
                            (
                                string.Format
                                        (
                                            "{0} Threads Count {1}, Queue Count {2}, Current Thread: {3}({4}) at {5}"
                                            , "Queue Running Stop ..."
                                            , r
                                            , _queue.Count
                                            , Thread.CurrentThread.Name
                                            , Thread.CurrentThread.ManagedThreadId
                                            , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                        )
                            );
            }
            if (_isAttachedPerformanceCounters)
            {
                _queueRunningThreadEndPerformanceCounter.Increment();
                _queueRunningThreadsCountPerformanceCounter.Decrement();
            }
            Interlocked.Exchange(ref _isQueueRunning, 0);
        }
        public void Enqueue(T element)
        {
            try
            {
#if c2
                lock (_syncQueueLockObject) //还算并发吗?
#endif
                {
                    _queue.Enqueue(element);
                }
                if (_isAttachedPerformanceCounters)
                {
                    _enqueuePerformanceCounter.Increment();
                    _queueLengthPerformanceCounter.Increment();
                }
            }
            catch (Exception e)
            {
                if (OnException != null)
                {
                    OnException(e);
                }
            }
            //int r = Interlocked.CompareExchange(ref _queueRuning, 1, 0))
            //if (r == 1)
            //{
            QueueRun();
            //}
        }
        private void DequeueThreadProcess()
        {
            if (_isAttachedPerformanceCounters)
            {
                _dequeueThreadStartPerformanceCounter.Increment();
                _dequeueThreadsCountPerformanceCounter.Increment();
            }
            if (OnDequeueThreadStart != null)
            {
                int r = (int) Interlocked.Read(ref _concurrentDequeueThreadsCount);
                OnDequeueThreadStart
                                (
                                    string.Format
                                            (
                                                "{0} Threads Count {1},Queue Count {2},Current Thread: {3} at {4}"
                                                , "Threads ++ !"
                                                , r
                                                , _queue.Count
                                                , Thread.CurrentThread.Name
                                                , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                            )
                                );
            }
            bool queueWasNotEmpty = false;
            try
            {
#if c2
                while (true)
#elif c4
                while (!_queue.IsEmpty)
#endif
                {
                    T element = null;
#if c2
                    lock (_syncQueueLockObject)
                    {
                        if (_queue.Count > 0)
                        {
                            element = _queue.Dequeue();
                        }
                        else
                        {
                            //避免QueueRun 死循环
                            break;
                        }
                    }
#elif c4
                    if (_queue.TryDequeue(out element))
                    {
#elif c2
                        if (element != null)
                        {
#endif
                            if (!queueWasNotEmpty)
                            {
                                queueWasNotEmpty = true;
                            }
                            if (_isAttachedPerformanceCounters)
                            {
                                _dequeuePerformanceCounter.Increment();
                                _queueLengthPerformanceCounter.Decrement();
                            }
                            if (OnDequeue != null)
                            {
                                OnDequeue(element);
                            }
                            if (_isAttachedPerformanceCounters)
                            {
                                _dequeueProcessedPerformanceCounter.Increment();
                            }
#if c2
                        }
#elif c4
                    }
                }
#endif
            }
            catch (Exception e)
            {
                if (OnException != null)
                {
                    OnException(e);
                }
            }
            finally
            {
                int r = (int) Interlocked.Decrement(ref _concurrentDequeueThreadsCount);
                if (OnDequeueThreadEnd != null)
                {
                    OnDequeueThreadEnd
                                (
                                    string.Format
                                            (
                                                "{0} Threads Count {1},Queue Count {2},Current Thread: {3} at {4}"
                                                , "Threads--"
                                                , r
                                                , _queue.Count
                                                , Thread.CurrentThread.Name
                                                , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                            )
                                );
                }
                if (r == 0)
                {
                    if (OnDequeueAllThreadsEnd != null)
                    {
                        OnDequeueAllThreadsEnd
                                    (
                                        string.Format
                                                (
                                                    "{0} Threads Count {1},Queue Count {2},Current Thread: {3} at {4}"
                                                    , "All Threads End"
                                                    , r
                                                    , _queue.Count
                                                    , Thread.CurrentThread.Name
                                                    , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff")
                                                )
                                    );
                    }
                }
                if (_isAttachedPerformanceCounters)
                {
                    _dequeueThreadEndPerformanceCounter.Increment();
                    _dequeueThreadsCountPerformanceCounter.Decrement();
                }
                if (queueWasNotEmpty)
                {
                    QueueRun(); //死循环???
                }
            }
        }
    }
}
namespace Microshaoft
{
    using System;
    using System.Diagnostics;
    public static class PerformanceCounterHelper
    {
        public static CounterCreationData GetCounterCreationData(string counterName, PerformanceCounterType performanceCounterType)
        {
            CounterCreationData ccd = new CounterCreationData();
            ccd.CounterName = counterName;
            ccd.CounterHelp = string.Format("{0} Help", counterName);
            ccd.CounterType = performanceCounterType;
            return ccd;
        }
    }
}
namespace Microshaoft
{
    using System;
    using System.Threading;
    using System.Data;
    using System.Data.SqlClient;
    using System.Net;
    using Microshaoft.AsynQueue.Server;
    //using Microshaoft.RemotingObjects.Share;
    using Proxy;
    //using System.Windows.Forms;
    //using System.Drawing;
    public class AsyncQueueProcessor
    {
        private AsyncQueue<HelloWorldRequest> _queue;
        public AsyncQueue<HelloWorldRequest> Queue
        {
            get
            {
                return _queue;
            }
        }
        public AsyncQueueProcessor(AsyncQueue<HelloWorldRequest> queue)
        {
            _service.Url = ServiceHost._proxyServiceUrl;
            _queue = queue;
            _queue.OnDequeue += new AsyncQueue<HelloWorldRequest>.QueueEventHandler(_queue_OnDequeue);
            _queue.OnDequeueThreadStart += new AsyncQueue<HelloWorldRequest>.QueueLogEventHandler(_queue_OnQueueLog);
            _queue.OnDequeueAllThreadsEnd += new AsyncQueue<HelloWorldRequest>.QueueLogEventHandler(_queue_OnQueueLog);
            _queue.OnDequeueThreadEnd += new AsyncQueue<HelloWorldRequest>.QueueLogEventHandler(_queue_OnQueueLog);
            //_queue.OnQueueRunningThreadStart += new AsyncQueue<HelloWorldRequest>.QueueLogEventHandler(_queue_OnQueueLog);
            //_queue.OnQueueRunningThreadEnd += new AsyncQueue<HelloWorldRequest>.QueueLogEventHandler(_queue_OnQueueLog);
            _queue.OnException += new AsyncQueue<HelloWorldRequest>.ExceptionEventHandler(_queue_OnException);
            //_queue.MaxConcurrentThreadsCount = 100;
        }
        public void Enqueue(HelloWorldRequest item)
        {
            _queue.Enqueue(item);
        }
        void _queue_OnQueueLog(string logMessage)
        {
            Console.WriteLine(logMessage);
        }
        private Service1Class _service = new Service1Class();
        void _queue_OnDequeue(HelloWorldRequest item)
        {
            string s = _service.HelloWorld(item);
            Console.WriteLine(s);
        }
        void _queue_OnException(Exception e)
        {
            //Console.WriteLine(e.ToString());
        }
    }
}
//Server.cs
namespace Microshaoft.AsynQueue.Server
{
    using System;
    using System.Threading;
    using System.Collections;
    using System.Configuration;
    //using System.Runtime.Remoting;
    //using System.Runtime.Remoting.Channels;
    //using System.Runtime.Remoting.Channels.Tcp;
    //using System.Runtime.Serialization.Formatters;
    using System.ServiceProcess;
    using System.ComponentModel;
    using System.Configuration.Install;
    using System.Security.Principal;
    using System.Net;
    //using Microshaoft.RemotingObjects;
    //using Microshaoft.RemotingObjects.Share;
    using Microshaoft.Win32;
    using Microshaoft;
    using Proxy;
    //using eHome.UserProfile;
    public class ServiceHost : ServiceBase
    {
        ///// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        //[STAThread]
        public static int _servicePointManagerDefaultConnectionLimit = 99; //int.Parse(ConfigurationManager.AppSettings["ConcurrentHttpConnectionsLimit"]);
        public static int _concurrentRequestsLimit = 88; //int.Parse(ConfigurationManager.AppSettings["ConcurrentRequestsLimit"]);
        public static int _outerLoops = 50; //int.Parse(ConfigurationManager.AppSettings["OuterLoops"]);
        public static int _innerLoops = 1000; //int.Parse(ConfigurationManager.AppSettings["InnerLoops"]);
        public static string _proxyServiceUrl = "http://local.v40.asp.net/smsplatform/test.asmx";//ConfigurationManager.AppSettings["ProxyServiceUrl"];
        public static readonly string serviceName = "AsyncConcurrentQueueService";
        private static AsyncQueueProcessor _asyncQueueProcessor;
        public static AsyncQueueProcessor AsyncQueueProcessor
        {
            get
            {
                return _asyncQueueProcessor;
            }
        }
        static void Main(string[] args)
        {
            //Microshaoft
            //Microshaoft TODO: 在此处添加代码以启动应用程序
            //Microshaoft 
            ServiceHost service = new ServiceHost();
            int l = 0;
            bool needFreeConsole = false;
            if (args != null)
            {
                l = args.Length;
            }
            if (l > 0)
            {
                if (args[0].ToLower() == "/console")
                {
                    needFreeConsole = true;
                    NativeMethods.AllocConsole();
                    Console.Title = "Server ...";
                    Console.WriteLine("Alloc Console ...");
                    Console.WriteLine("Current User Identity: {0}", WindowsIdentity.GetCurrent().Name);
                    Console.WriteLine(".Net Framework version: {0}", Environment.Version.ToString());
                    Console.Title = "Server"; //不能以服务运行
                    Console.WriteLine("Console");
                    service.OnStart(null);
                    string input = string.Empty;
                    while ("q" != (input = Console.ReadLine()))
                    {
                        Run();
                    }
                    Console.ReadLine();
                    return;
                }
            }
            Console.WriteLine("Service");
            ServiceBase.Run(service);
            if (needFreeConsole)
            {
                Console.WriteLine("Free Console ...");
                NativeMethods.FreeConsole();
            }
        }
        public static void Run()
        {
            ServicePointManager.DefaultConnectionLimit = _servicePointManagerDefaultConnectionLimit;
            //Microshaoft 以下是耗时的主程序
            for (int i = 0; i < _outerLoops; i++)
            {
                Thread x = new Thread(new ThreadStart(ThreadProcess));
                x.Start();
            }
        }
        public static void ThreadProcess()
        {
            for (int i = 0; i < _innerLoops; i++)
            {
                HelloWorldRequest request = new HelloWorldRequest();
                AsyncQueueProcessor.Enqueue(request);
             }
        }
        public ServiceHost()
        {
            CanPauseAndContinue = true;
            ServiceName = ServiceHost.serviceName;
        }
        protected override void OnStart(string[] args)
        {
            Console.WriteLine(Environment.Version.ToString());
            AsyncQueue<HelloWorldRequest> queue = new AsyncQueue<HelloWorldRequest>();
            queue.AttachPerformanceCounters("HelloWorldRequestQueue");
            _asyncQueueProcessor = new AsyncQueueProcessor(queue);
            queue.MaxConcurrentThreadsCount = _concurrentRequestsLimit;
            Console.WriteLine("Server . , Press Enter key to exit.");
        }
    }
    [RunInstallerAttribute(true)]
    public class ProjectInstaller : Installer
    {
        private ServiceInstaller serviceInstaller;
        private ServiceProcessInstaller processInstaller;
        public ProjectInstaller()
        {
            processInstaller = new ServiceProcessInstaller();
            serviceInstaller = new ServiceInstaller();
            // Service will run under system account
            processInstaller.Account = ServiceAccount.LocalSystem;
            // Service will have Start Type of Manual
            serviceInstaller.StartType = ServiceStartMode.Manual;
            serviceInstaller.ServiceName = ServiceHost.serviceName;
            Installers.Add(serviceInstaller);
            Installers.Add(processInstaller);
        }
    }
}
namespace Microshaoft.Win32
{
    using System.Runtime.InteropServices;
    public class NativeMethods
    {
        /// <summary>
        /// 启动控制台
        /// </summary>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        public static extern bool AllocConsole();
        /// <summary>
        /// 释放控制台
        /// </summary>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        public static extern bool FreeConsole();
    }
}
namespace Proxy
{
    //------------------------------------------------------------------------------
    // <auto-generated>
    //     此代码由工具生成。
    //     运行时版本:4.0.30319.225
    //
    //     对此文件的更改可能会导致不正确的行为，并且如果
    //     重新生成代码，这些更改将会丢失。
    // </auto-generated>
    //------------------------------------------------------------------------------
    using System;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Web.Services;
    using System.Web.Services.Protocols;
    using System.Xml.Serialization;
    // 
    // This source code was auto-generated by wsdl, Version=4.0.30319.1.
    // 
    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Web.Services.WebServiceBindingAttribute(Name="Service1ClassSoap", Namespace="http://www.microshaoft.com/")]
    public partial class Service1Class : System.Web.Services.Protocols.SoapHttpClientProtocol {
        private System.Threading.SendOrPostCallback HelloWorldOperationCompleted;
        /// <remarks/>
        public Service1Class() {
            this.Url = "http://local.v40.asp.net/smsplatform/test.asmx";
        }
        /// <remarks/>
        public event HelloWorldCompletedEventHandler HelloWorldCompleted;
        /// <remarks/>
        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://www.microshaoft.com/HelloWorld", RequestNamespace="http://www.microshaoft.com/", ResponseNamespace="http://www.microshaoft.com/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
        public string HelloWorld(HelloWorldRequest request) {
            object[] results = this.Invoke("HelloWorld", new object[] {
                        request});
            return ((string)(results[0]));
        }
        /// <remarks/>
        public System.IAsyncResult BeginHelloWorld(HelloWorldRequest request, System.AsyncCallback callback, object asyncState) {
            return this.BeginInvoke("HelloWorld", new object[] {
                        request}, callback, asyncState);
        }
        /// <remarks/>
        public string EndHelloWorld(System.IAsyncResult asyncResult) {
            object[] results = this.EndInvoke(asyncResult);
            return ((string)(results[0]));
        }
        /// <remarks/>
        public void HelloWorldAsync(HelloWorldRequest request) {
            this.HelloWorldAsync(request, null);
        }
        /// <remarks/>
        public void HelloWorldAsync(HelloWorldRequest request, object userState) {
            if ((this.HelloWorldOperationCompleted == null)) {
                this.HelloWorldOperationCompleted = new System.Threading.SendOrPostCallback(this.OnHelloWorldOperationCompleted);
            }
            this.InvokeAsync("HelloWorld", new object[] {
                        request}, this.HelloWorldOperationCompleted, userState);
        }
        private void OnHelloWorldOperationCompleted(object arg) {
            if ((this.HelloWorldCompleted != null)) {
                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
                this.HelloWorldCompleted(this, new HelloWorldCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
            }
        }
        /// <remarks/>
        public new void CancelAsync(object userState) {
            base.CancelAsync(userState);
        }
    }
    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://www.microshaoft.com/")]
    public partial class HelloWorldRequest {
    }
    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")]
    public delegate void HelloWorldCompletedEventHandler(object sender, HelloWorldCompletedEventArgs e);
    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    public partial class HelloWorldCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
        private object[] results;
        internal HelloWorldCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
                base(exception, cancelled, userState) {
            this.results = results;
        }
        /// <remarks/>
        public string Result {
            get {
                this.RaiseExceptionIfNecessary();
                return ((string)(this.results[0]));
            }
        }
    }
}

本文链接

高考语文古诗给力绝对对不起老师古诗背窜了

2011-06-12T02:34:00Z

砍头不要紧爱情价更高欲穷千里目粒粒皆辛苦

1.少小离家老大回,安能辨我是雄雌。(苦命的人儿,这些年你都经历了什么?)

2.红酥手,黄藤酒,两个黄鹂鸣翠柳。长亭外,古道边,一行白鹭上青天。(如此意境,只有汉语做得到)

3.夜深忽梦少年事,惟梦闲人不梦君。(跟此人有仇啊?)

4.借问酒家何处有,姑苏城外寒山寺。(不许瞎说!)

5.洛阳亲友如相问,轻舟已过万重山,(欠人钱了?跑得够快的啊!)

6.爷娘闻女来,举身赴清池；阿姊闻妹来,自挂东南枝。小弟闻姊来,琵琶声停欲语迟。(这位姑娘,你人品真差)

7.在天愿作比翼鸟,大难临头各自飞。(你俩真配)

8.美人卷珠帘,万径人踪灭。两岸猿声啼不住,惊起蛙声一片。(这还是美人吗?!)

9.劝君更尽一杯酒,从此萧郎是路人。(这么绝情?)

10.一朝被蛇咬,处处闻啼鸟。(这个很内涵)

11.遥想公谨当年,小乔初嫁了,使我不得开心颜!(爱人结婚了,新郎不是你)

12.垂死病中惊坐起,笑问客从何处来(装病?回光返照?)

13.车辚辚,马萧萧,二月春风似剪刀。(贾府组织春游?)

14.满堂花醉三千客,更无一人是知音。(天才都是孤独的)

15.垂死病中惊坐起,夜深还过女嫱来。(死性不改)

16.踏破铁鞋无觅处,那人却在灯火阑珊处。(你该庆幸还是郁闷?)

17.问君能有几多愁,别是一番滋味在心头。(这究竟是不是原配啊?)

18.飞流直下三千尺,不及汪伦送我情。(汪伦跳崖了?)

19.醒时同交欢,儿女忽成行。(因果关系)

20.路漫漫其修远兮,壮士一去兮不复返!(工整啊)

21.江州司马青衫湿,宣城太守知不知。(有JQ)

22.后宫佳丽三千人,铁杵磨成绣花针。(写实派)

23.天苍苍,野茫茫,一树梨花压海棠。(春光乍泄)

24.问世间情为何物,两岸猿声啼不住。(悲情的猿)

25.春宵一刻值千金,绝知此事要躬行。(干巴爹 vs 压灭跌)

26.床前明月光,对影成三人。(只可意会不可以言传)

27.天子呼来不上船,芙蓉帐暖度春宵。(好大的胆子)

28.桃花潭水深千尺,温泉水滑洗凝脂。(姑娘小心溺水)

29.人生得意须尽欢,从此君王不早朝。(你个昏君!)

30.朕与先生解战袍,芙蓉帐暖度春宵。(腐!!)

1、穷则独善其身，某同学对：富则妻妾成群

2、西塞山前白鹭飞，某同学对：东村河边爬乌龟

3、床前明月光，某同学对：李白睡得香

4、路上行人欲断魂，某同学对：半夜三更鬼叫门

5、老吾老以及人之老，某同学对：妻吾妻以及人之妻

6、三个臭皮匠，某同学对：臭味都一样

7、两情若是长久时，某同学对：该是两人成婚时

8、问君能有几多愁，某同学对：恰似一壶二锅头

9、不为五斗米折腰，某同学对：给我六斗就可以

10、天若有情天亦老，某同学对：人若有情死得早

11、葡萄美酒夜光杯，某同学对：金钱美女一大堆

12、想当年，金戈铁马…，某同学对：看今朝，死缠烂打…

13、洛阳亲友如相问，某同学对：请你不要告诉他

14、书到用时方恨少，某同学对：钱到月底不够花

15、清水出芙蓉，某同学对：乱世出佳人

16、最绝的是这个：“日照香炉生紫烟，李白来到洗手间，小李飞刀一瞬间，李白变成小太监！

本文链接

博客园_msn㊣Microshaoft.comnaIBnaiM nOracle (大舌头) I Love download EditPlus.v3.12(602)!

OpenXML Word docx 添加水印 PowerTools

DES, TripleDES and BlowFish in Silverlight

HMAC MD5 http://hmacmd5.codeplex.com HMAC-MD5 for .NET 4.0, SL4 and WP7 Silverlight Windows Phone

Anti Inject XSS JavaScript/HTML/LDAP/XML/CSS Encode Inject

冻结 锁定 固定 行 列 表头 抬头 html table jquery 全兼容常见浏览器

CryptographyHelper, Symmetric Algorithm, Asymmetric Algorithm, Hash Algorithm, Keyed Hash Algorithm, RSA, X509

ALTER INDEX Rebuild Reorganize 索引 重建 重组 碎片率

ConcurrentAsyncQueue

Proxy Concurrent AsyncQueue WebService Invoker

高考语文 古诗给力绝对 对不起老师 古诗背窜了

冻结锁定固定行列表头抬头 html table jquery 全兼容常见浏览器

ALTER INDEX Rebuild Reorganize 索引重建重组碎片率

高考语文古诗给力绝对对不起老师古诗背窜了