SupportClass.cs
上传用户:zhangkuixh
上传日期:2013-09-30
资源大小:5473k
文件大小:20k
源码类别:

搜索引擎

开发平台:

C#

  1. /*
  2.  * Copyright 2004 The Apache Software Foundation
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. using System;
  17. /// <summary>
  18. /// This interface should be implemented by any class whose instances are intended 
  19. /// to be executed by a thread.
  20. /// </summary>
  21. public interface IThreadRunnable
  22. {
  23. /// <summary>
  24. /// This method has to be implemented in order that starting of the thread causes the object's 
  25. /// run method to be called in that separately executing thread.
  26. /// </summary>
  27. void Run();
  28. }
  29. /// <summary>
  30. /// Contains conversion support elements such as classes, interfaces and static methods.
  31. /// </summary>
  32. public class SupportClass
  33. {
  34.     /// <summary>
  35.     /// Support class used to handle threads
  36.     /// </summary>
  37.     public class ThreadClass : IThreadRunnable
  38.     {
  39.         /// <summary>
  40.         /// The instance of System.Threading.Thread
  41.         /// </summary>
  42.         private System.Threading.Thread threadField;
  43.       
  44.         /// <summary>
  45.         /// Initializes a new instance of the ThreadClass class
  46.         /// </summary>
  47.         public ThreadClass()
  48.         {
  49.             threadField = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
  50.         }
  51.  
  52.         /// <summary>
  53.         /// Initializes a new instance of the Thread class.
  54.         /// </summary>
  55.         /// <param name="Name">The name of the thread</param>
  56.         public ThreadClass(System.String Name)
  57.         {
  58.             threadField = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
  59.             this.Name = Name;
  60.         }
  61.       
  62.         /// <summary>
  63.         /// Initializes a new instance of the Thread class.
  64.         /// </summary>
  65.         /// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
  66.         public ThreadClass(System.Threading.ThreadStart Start)
  67.         {
  68.             threadField = new System.Threading.Thread(Start);
  69.         }
  70.  
  71.         /// <summary>
  72.         /// Initializes a new instance of the Thread class.
  73.         /// </summary>
  74.         /// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
  75.         /// <param name="Name">The name of the thread</param>
  76.         public ThreadClass(System.Threading.ThreadStart Start, System.String Name)
  77.         {
  78.             threadField = new System.Threading.Thread(Start);
  79.             this.Name = Name;
  80.         }
  81.       
  82.         /// <summary>
  83.         /// This method has no functionality unless the method is overridden
  84.         /// </summary>
  85.         public virtual void Run()
  86.         {
  87.         }
  88.       
  89.         /// <summary>
  90.         /// Causes the operating system to change the state of the current thread instance to ThreadState.Running
  91.         /// </summary>
  92.         public virtual void Start()
  93.         {
  94.             threadField.Start();
  95.         }
  96.       
  97.         /// <summary>
  98.         /// Interrupts a thread that is in the WaitSleepJoin thread state
  99.         /// </summary>
  100.         public virtual void Interrupt()
  101.         {
  102.             threadField.Interrupt();
  103.         }
  104.       
  105.         /// <summary>
  106.         /// Gets the current thread instance
  107.         /// </summary>
  108.         public System.Threading.Thread Instance
  109.         {
  110.             get
  111.             {
  112.                 return threadField;
  113.             }
  114.             set
  115.             {
  116.                 threadField = value;
  117.             }
  118.         }
  119.       
  120.         /// <summary>
  121.         /// Gets or sets the name of the thread
  122.         /// </summary>
  123.         public System.String Name
  124.         {
  125.             get
  126.             {
  127.                 return threadField.Name;
  128.             }
  129.             set
  130.             {
  131.                 if (threadField.Name == null)
  132.                     threadField.Name = value; 
  133.             }
  134.         }
  135.       
  136.         /// <summary>
  137.         /// Gets or sets a value indicating the scheduling priority of a thread
  138.         /// </summary>
  139.         public System.Threading.ThreadPriority Priority
  140.         {
  141.             get
  142.             {
  143.                 return threadField.Priority;
  144.             }
  145.             set
  146.             {
  147.                 threadField.Priority = value;
  148.             }
  149.         }
  150.       
  151.         /// <summary>
  152.         /// Gets a value indicating the execution status of the current thread
  153.         /// </summary>
  154.         public bool IsAlive
  155.         {
  156.             get
  157.             {
  158.                 return threadField.IsAlive;
  159.             }
  160.         }
  161.       
  162.         /// <summary>
  163.         /// Gets or sets a value indicating whether or not a thread is a background thread.
  164.         /// </summary>
  165.         public bool IsBackground
  166.         {
  167.             get
  168.             {
  169.                 return threadField.IsBackground;
  170.             } 
  171.             set
  172.             {
  173.                 threadField.IsBackground = value;
  174.             }
  175.         }
  176.       
  177.         /// <summary>
  178.         /// Blocks the calling thread until a thread terminates
  179.         /// </summary>
  180.         public void Join()
  181.         {
  182.             threadField.Join();
  183.         }
  184.       
  185.         /// <summary>
  186.         /// Blocks the calling thread until a thread terminates or the specified time elapses
  187.         /// </summary>
  188.         /// <param name="MiliSeconds">Time of wait in milliseconds</param>
  189.         public void Join(long MiliSeconds)
  190.         {
  191.             lock(this)
  192.             {
  193.                 threadField.Join(new System.TimeSpan(MiliSeconds * 10000));
  194.             }
  195.         }
  196.       
  197.         /// <summary>
  198.         /// Blocks the calling thread until a thread terminates or the specified time elapses
  199.         /// </summary>
  200.         /// <param name="MiliSeconds">Time of wait in milliseconds</param>
  201.         /// <param name="NanoSeconds">Time of wait in nanoseconds</param>
  202.         public void Join(long MiliSeconds, int NanoSeconds)
  203.         {
  204.             lock(this)
  205.             {
  206.                 threadField.Join(new System.TimeSpan(MiliSeconds * 10000 + NanoSeconds * 100));
  207.             }
  208.         }
  209.       
  210.         /// <summary>
  211.         /// Resumes a thread that has been suspended
  212.         /// </summary>
  213.         public void Resume()
  214.         {
  215.             threadField.Resume();
  216.         }
  217.       
  218.         /// <summary>
  219.         /// Raises a ThreadAbortException in the thread on which it is invoked, 
  220.         /// to begin the process of terminating the thread. Calling this method 
  221.         /// usually terminates the thread
  222.         /// </summary>
  223.         public void Abort()
  224.         {
  225.             threadField.Abort();
  226.         }
  227.       
  228.         /// <summary>
  229.         /// Raises a ThreadAbortException in the thread on which it is invoked, 
  230.         /// to begin the process of terminating the thread while also providing
  231.         /// exception information about the thread termination. 
  232.         /// Calling this method usually terminates the thread.
  233.         /// </summary>
  234.         /// <param name="stateInfo">An object that contains application-specific information, such as state, which can be used by the thread being aborted</param>
  235.         public void Abort(System.Object stateInfo)
  236.         {
  237.             lock(this)
  238.             {
  239.                 threadField.Abort(stateInfo);
  240.             }
  241.         }
  242.       
  243.         /// <summary>
  244.         /// Suspends the thread, if the thread is already suspended it has no effect
  245.         /// </summary>
  246.         public void Suspend()
  247.         {
  248.             threadField.Suspend();
  249.         }
  250.       
  251.         /// <summary>
  252.         /// Obtain a String that represents the current Object
  253.         /// </summary>
  254.         /// <returns>A String that represents the current Object</returns>
  255.         public override System.String ToString()
  256.         {
  257.             return "Thread[" + Name + "," + Priority.ToString() + "," + "" + "]";
  258.         }
  259.      
  260.         /// <summary>
  261.         /// Gets the currently running thread
  262.         /// </summary>
  263.         /// <returns>The currently running thread</returns>
  264.         public static ThreadClass Current()
  265.         {
  266.             ThreadClass CurrentThread = new ThreadClass();
  267.             CurrentThread.Instance = System.Threading.Thread.CurrentThread;
  268.             return CurrentThread;
  269.         }
  270.     }
  271.     /// <summary>
  272.     /// A simple class for number conversions.
  273.     /// </summary>
  274.     public class Number
  275.     {
  276.         /// <summary>
  277.         /// Min radix value.
  278.         /// </summary>
  279.         public const int MIN_RADIX = 2;
  280.         /// <summary>
  281.         /// Max radix value.
  282.         /// </summary>
  283.         public const int MAX_RADIX = 36;
  284.         private const System.String digits = "0123456789abcdefghijklmnopqrstuvwxyz";
  285.         public static System.String ToString(float f)
  286.         {
  287.             if (((float)(int)f) == f)
  288.             {
  289.                 return ((int)f).ToString() + ".0";
  290.             }
  291.             else
  292.             {
  293.                 return f.ToString(System.Globalization.NumberFormatInfo.InvariantInfo);
  294.             }
  295.         }
  296.         /// <summary>
  297.         /// Converts a number to System.String in the specified radix.
  298.         /// </summary>
  299.         /// <param name="i">A number to be converted.</param>
  300.         /// <param name="radix">A radix.</param>
  301.         /// <returns>A System.String representation of the number in the specified redix.</returns>
  302.         public static System.String ToString(long i, int radix)
  303.         {
  304.             if (radix < MIN_RADIX || radix > MAX_RADIX)
  305.                 radix = 10;
  306.             char[] buf = new char[65];
  307.             int charPos = 64;
  308.             bool negative = (i < 0);
  309.             if (!negative) 
  310.             {
  311.                 i = -i;
  312.             }
  313.             while (i <= -radix) 
  314.             {
  315.                 buf[charPos--] = digits[(int)(-(i % radix))];
  316.                 i = i / radix;
  317.             }
  318.             buf[charPos] = digits[(int)(-i)];
  319.             if (negative) 
  320.             {
  321.                 buf[--charPos] = '-';
  322.             }
  323.             return new System.String(buf, charPos, (65 - charPos)); 
  324.         }
  325.         /// <summary>
  326.         /// Parses a number in the specified radix.
  327.         /// </summary>
  328.         /// <param name="s">An input System.String.</param>
  329.         /// <param name="radix">A radix.</param>
  330.         /// <returns>The parsed number in the specified radix.</returns>
  331.         public static long Parse(System.String s, int radix)
  332.         {
  333.             if (s == null) 
  334.             {
  335.                 throw new ArgumentException("null");
  336.             }
  337.             if (radix < MIN_RADIX) 
  338.             {
  339.                 throw new NotSupportedException("radix " + radix +
  340.                     " less than Number.MIN_RADIX");
  341.             }
  342.             if (radix > MAX_RADIX) 
  343.             {
  344.                 throw new NotSupportedException("radix " + radix +
  345.                     " greater than Number.MAX_RADIX");
  346.             }
  347.             long result = 0;
  348.             long mult = 1;
  349.             s = s.ToLower();
  350.             for (int i = s.Length - 1; i >= 0; i--)
  351.             {
  352.                 int weight = digits.IndexOf(s[i]);
  353.                 if (weight == -1)
  354.                     throw new FormatException("Invalid number for the specified radix");
  355.                 result += (weight * mult);
  356.                 mult *= radix;
  357.             }
  358.             return result;
  359.         }
  360.         /// <summary>
  361.         /// Performs an unsigned bitwise right shift with the specified number
  362.         /// </summary>
  363.         /// <param name="number">Number to operate on</param>
  364.         /// <param name="bits">Ammount of bits to shift</param>
  365.         /// <returns>The resulting number from the shift operation</returns>
  366.         public static int URShift(int number, int bits)
  367.         {
  368.             if (number >= 0)
  369.                 return number >> bits;
  370.             else
  371.                 return (number >> bits) + (2 << ~bits);
  372.         }
  373.         /// <summary>
  374.         /// Returns the index of the first bit that is set to true that occurs 
  375.         /// on or after the specified starting index. If no such bit exists 
  376.         /// then -1 is returned.
  377.         /// </summary>
  378.         /// <param name="bits">The BitArray object.</param>
  379.         /// <param name="fromIndex">The index to start checking from (inclusive).</param>
  380.         /// <returns>The index of the next set bit.</returns>
  381.         public static int NextSetBit(System.Collections.BitArray bits, int fromIndex)
  382.         {
  383.             for (int i = fromIndex; i < bits.Length; i++)
  384.             {
  385.                 if (bits[i] == true)
  386.                 {
  387.                     return i;
  388.                 }
  389.             }
  390.             return -1;
  391.         }
  392.     }
  393.     /// <summary>
  394.     /// Mimics Java's Character class.
  395.     /// </summary>
  396.     public class Character
  397.     {
  398.         private const char charNull= '';
  399.         private const char charZero = '0';
  400.         private const char charA = 'a';
  401.         /// <summary>
  402.         /// </summary>
  403.         public static int MAX_RADIX
  404.         {
  405.             get
  406.             {
  407.                 return 36;
  408.             }
  409.         }
  410.         /// <summary>
  411.         /// </summary>
  412.         public static int MIN_RADIX
  413.         {
  414.             get
  415.             {
  416.                 return 2;
  417.             }
  418.         }
  419.         /// <summary>
  420.         /// 
  421.         /// </summary>
  422.         /// <param name="digit"></param>
  423.         /// <param name="radix"></param>
  424.         /// <returns></returns>
  425.         public static char ForDigit(int digit, int radix)
  426.         {
  427.             // if radix or digit is out of range,
  428.             // return the null character.
  429.             if (radix < Character.MIN_RADIX)
  430.                 return charNull;
  431.             if (radix > Character.MAX_RADIX)
  432.                 return charNull;
  433.             if (digit < 0)
  434.                 return charNull;
  435.             if (digit >= radix)
  436.                 return charNull;
  437.             // if digit is less than 10,
  438.             // return '0' plus digit
  439.             if (digit < 10)
  440.                 return (char) ( (int) charZero + digit);
  441.             // otherwise, return 'a' plus digit.
  442.             return (char) ((int) charA + digit - 10);
  443.         }
  444.     }
  445.     /// <summary>
  446.     /// 
  447.     /// </summary>
  448.     public class Date
  449.     {
  450.         /// <summary>
  451.         /// 
  452.         /// </summary>
  453.         /// <param name="dateTime"></param>
  454.         /// <returns></returns>
  455.         static public long GetTime(DateTime dateTime)
  456.         {
  457.             TimeSpan ts = dateTime.Subtract(new DateTime(1970, 1, 1));
  458.             ts = ts.Subtract(TimeZone.CurrentTimeZone.GetUtcOffset(dateTime));
  459.             return ts.Ticks / TimeSpan.TicksPerMillisecond;
  460.         }
  461.     }
  462.     /// <summary>
  463.     /// 
  464.     /// </summary>
  465.     public class Single
  466.     {
  467.         /// <summary>
  468.         /// 
  469.         /// </summary>
  470.         /// <param name="s"></param>
  471.         /// <param name="style"></param>
  472.         /// <param name="provider"></param>
  473.         /// <returns></returns>
  474.         public static System.Single Parse(System.String s, System.Globalization.NumberStyles style, System.IFormatProvider provider)
  475.         {
  476.             try
  477.             {
  478.                 if (s.EndsWith("f") || s.EndsWith("F"))
  479.                     return System.Single.Parse(s.Substring(0, s.Length - 1), style, provider);
  480.                 else
  481.                     return System.Single.Parse(s, style, provider);
  482.             }
  483.             catch (System.FormatException fex)
  484.             {
  485.                 throw fex;
  486.             }
  487.         }
  488.         /// <summary>
  489.         /// 
  490.         /// </summary>
  491.         /// <param name="s"></param>
  492.         /// <param name="provider"></param>
  493.         /// <returns></returns>
  494.         public static System.Single Parse(System.String s, System.IFormatProvider provider)
  495.         {
  496.             try
  497.             {
  498.                 if (s.EndsWith("f") || s.EndsWith("F"))
  499.                     return System.Single.Parse(s.Substring(0, s.Length - 1), provider);
  500.                 else
  501.                     return System.Single.Parse(s, provider);
  502.             }
  503.             catch (System.FormatException fex)
  504.             {
  505.                 throw fex;
  506.             }
  507.         }
  508.         /// <summary>
  509.         /// 
  510.         /// </summary>
  511.         /// <param name="s"></param>
  512.         /// <param name="style"></param>
  513.         /// <returns></returns>
  514.         public static System.Single Parse(System.String s, System.Globalization.NumberStyles style)
  515.         {
  516.             try
  517.             {
  518.                 if (s.EndsWith("f") || s.EndsWith("F"))
  519.                     return System.Single.Parse(s.Substring(0, s.Length - 1), style);
  520.                 else
  521.                     return System.Single.Parse(s, style);
  522.             }
  523.             catch(System.FormatException fex)
  524.             {
  525.                 throw fex;
  526.             }
  527.         }
  528.         /// <summary>
  529.         /// 
  530.         /// </summary>
  531.         /// <param name="s"></param>
  532.         /// <returns></returns>
  533.         public static System.Single Parse(System.String s)
  534.         {
  535.             try
  536.             {
  537.                 if (s.EndsWith("f") || s.EndsWith("F"))
  538.                     return System.Single.Parse(s.Substring(0, s.Length - 1));
  539.                 else
  540.                     return System.Single.Parse(s);
  541.             }
  542.             catch(System.FormatException fex)
  543.             {
  544.                 throw fex;
  545.             }
  546.         }
  547.     }
  548.     /// <summary>
  549.     /// 
  550.     /// </summary>
  551.     public class AppSettings
  552.     {
  553.         /// <summary>
  554.         /// 
  555.         /// </summary>
  556.         /// <param name="key"></param>
  557.         /// <param name="defValue"></param>
  558.         /// <returns></returns>
  559.         public static int Get(System.String key, int defValue)
  560.         {
  561.             System.String theValue = System.Configuration.ConfigurationSettings.AppSettings.Get(key);
  562.             if (theValue == null)
  563.             {
  564.                 return defValue;
  565.             }
  566.             return System.Convert.ToInt16(theValue.Trim());
  567.         }
  568.         /// <summary>
  569.         /// 
  570.         /// </summary>
  571.         /// <param name="key"></param>
  572.         /// <param name="defValue"></param>
  573.         /// <returns></returns>
  574.         public static long Get(System.String key, long defValue)
  575.         {
  576.             System.String theValue = System.Configuration.ConfigurationSettings.AppSettings.Get(key);
  577.             if (theValue == null)
  578.             {
  579.                 return defValue;
  580.             }
  581.             return System.Convert.ToInt32(theValue.Trim());
  582.         }
  583.         /// <summary>
  584.         /// 
  585.         /// </summary>
  586.         /// <param name="key"></param>
  587.         /// <param name="defValue"></param>
  588.         /// <returns></returns>
  589.         public static System.String Get(System.String key, System.String defValue)
  590.         {
  591.             System.String theValue = System.Configuration.ConfigurationSettings.AppSettings.Get(key);
  592.             if (theValue == null)
  593.             {
  594.                 return defValue;
  595.             }
  596.             return theValue;
  597.         }
  598.     }
  599.     public static System.Collections.SortedList TailMap(System.Collections.SortedList list, System.Object limit)
  600.     {
  601.         System.Collections.Comparer comparer = System.Collections.Comparer.Default;
  602.         System.Collections.SortedList newList = new System.Collections.SortedList();
  603.         if (list != null)
  604.         {
  605.             if (list.Count > 0)
  606.             {
  607.                 int index = 0;
  608.                 while (comparer.Compare(list.GetKey(index), limit) < 0)
  609.                     index++;
  610.                 for (; index < list.Count; index++)
  611.                     newList.Add(list.GetKey(index), list[list.GetKey(index)]);
  612.             }
  613.         }
  614.         return newList;
  615.     }
  616. }