String

最新推荐文章于 2021-02-04 17:48:34 发布
最新推荐文章于 2021-02-04 17:48:34 发布
阅读量839 收藏
点赞数
分类专栏： CSharp源代码 文章标签： string path null byte object date
  1. // ==++==
  2. // 
  3. //   
  4. //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.
  5. //   
  6. //    The use and distribution terms for this software are contained in the file
  7. //    named license.txt, which can be found in the root of this distribution.
  8. //    By using this software in any fashion, you are agreeing to be bound by the
  9. //    terms of this license.
  10. //   
  11. //    You must not remove this notice, or any other, from this software.
  12. //   
  13. // 
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  String
  18. **
  19. **                                        
  20. **
  21. ** Purpose: Contains headers for the String class.  Actual implementations
  22. ** are in String.cpp
  23. **
  24. ** Date:  March 15, 1998
  25. **
  26. ===========================================================*/
  27. namespace System {
  28.     using System.Text;
  29.     using System;
  30.     using System.Globalization;
  31.     using System.Threading;
  32.     using System.Collections;
  33.     using System.Runtime.CompilerServices;
  34.     using va_list = System.ArgIterator;
  35.     using __UnmanagedMemoryStream = System.IO.__UnmanagedMemoryStream;
  36.     //
  37.     // For Information on these methods, please see COMString.cpp
  38.     //
  39.     // The String class represents a static string of characters.  Many of
  40.     // the String methods perform some type of transformation on the current
  41.     // instance and return the result as a new String. All comparison methods are
  42.     // implemented as a part of String.  As with arrays, character positions
  43.     // (indices) are zero-based.
  44.     //
  45.     // When passing a null string into a constructor in VJ and VC, the null should be
  46.     // explicitly type cast to a String.
  47.     // For Example:
  48.     // String s = new String((String)null);
  49.     // Text.Out.WriteLine(s);
  50.     //
  51.     /// <include file='doc/String.uex' path='docs/doc[@for="String"]/*' />
  52.     [Serializable] public sealed class String : IComparable, ICloneable, IConvertible, IEnumerable {
  53.         
  54.         //
  55.         //NOTE NOTE NOTE NOTE
  56.         //These fields map directly onto the fields in an EE StringObject.  See object.h for the layout.
  57.         //
  58.         [NonSerialized]private int  m_arrayLength;
  59.         [NonSerialized]private int  m_stringLength;
  60.         [NonSerialized]private char m_firstChar;
  62.         //private static readonly char FmtMsgMarkerChar='%';
  63.         //private static readonly char FmtMsgFmtCodeChar='!';
  64.         //These are defined in Com99/src/vm/COMStringCommon.h and must be kept in sync.
  65.         private const int TrimHead = 0;
  66.         private const int TrimTail = 1;
  67.         private const int TrimBoth = 2;
  68.     
  69.         // The Empty constant holds the empty string value.
  70.         //We need to call the String constructor so that the compiler doesn't mark this as a literal.
  71.         //Marking this as a literal would mean that it doesn't show up as a field which we can access 
  72.         //from native.
  73.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Empty"]/*' />
  74.         public static readonly String Empty = "";
  75.     
  76.         //
  77.         //Native Static Methods
  78.         //
  79.     
  80.         // Joins an array of strings together as one string with a separator between each original string.
  81.         //
  82.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Join"]/*' />
  83.         public static String Join (String separator, String[] value) {
  84.             if (value==null) {
  85.                 throw new ArgumentNullException("value");
  86.             }
  87.             return Join(separator, value, 0, value.Length);
  88.         }
  89.     
  90.         // Joins an array of strings together as one string with a separator between each original string.
  91.         //
  92.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Join1"]/*' />
  93.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  94.         public static extern String Join (String separator, String[] value, int startIndex, int count);
  95.     
  96.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  97.         internal static extern int nativeCompareOrdinal(String strA, String strB, bool bIgnoreCase);
  99.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  100.         internal static extern int nativeCompareOrdinalEx(String strA, int indexA, String strB, int indexB, int count);
  101.         //This will not work in case-insensitive mode for any character greater than 0x80.  
  102.         //We'll throw an ArgumentException.
  103.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  104.         unsafe internal static extern int nativeCompareOrdinalWC(String strA, char *strBChars, bool bIgnoreCase, out bool success);
  107.         //
  108.         // This is a helper method for the security team.  They need to uppercase some strings (guaranteed to be less 
  109.         // than 0x80) before security is fully initialized.  Without security initialized, we can't grab resources (the nlp's)
  110.         // from the assembly.  This provides a workaround for that problem and should NOT be used anywhere else.
  111.         //
  112.         internal static String SmallCharToUpper(String strA) {
  113.             String newString = FastAllocateString(strA.Length);
  114.             nativeSmallCharToUpper(strA, newString);
  115.             return newString;
  116.         }
  118.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  119.         private static extern void nativeSmallCharToUpper(String strIn, String strOut);
  121.         // This is a helper method for the security team.  They need to construct strings from a char[]
  122.         // within their homebrew XML parser.  They guarantee that the char[] they pass in isn't null and
  123.         // that the provided indices are valid so we just stuff real fast.
  124.         internal static String CreateFromCharArray( char[] array, int start, int count )
  125.         {
  126.             String newString = FastAllocateString( count );
  127.             FillStringArray( newString, 0, array, start, count );
  128.             return newString;
  129.         }
  131.         //
  132.         //
  133.         // NATIVE INSTANCE METHODS
  134.         //
  135.         //
  136.     
  137.         //
  138.         // Search/Query methods
  139.         //
  140.     
  141.         // Determines whether two strings match.
  142.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Equals"]/*' />
  143.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  144.         public extern override bool Equals(Object obj);
  145.     
  146.         // Determines whether two strings match.
  147.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Equals1"]/*' />
  148.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  149.         public extern bool Equals(String value);
  150.     
  151.         // Determines whether two Strings match.
  152.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Equals2"]/*' />
  153.         public static bool Equals(String a, String b) {
  154.             if ((Object)a==(Object)b) {
  155.                 return true;
  156.             }
  157.     
  158.             if ((Object)a==null || (Object)b==null) {
  159.                 return false;
  160.             }
  161.     
  162.             return a.Equals(b);
  163.         }
  165.         /// <include file='doc/String.uex' path='docs/doc[@for="String.operatorEQ"]/*' />
  166.         public static bool operator == (String a, String b) {
  167.            return String.Equals(a, b);
  168.         }
  170.         /// <include file='doc/String.uex' path='docs/doc[@for="String.operatorNE"]/*' />
  171.         public static bool operator != (String a, String b) {
  172.            return !String.Equals(a, b);
  173.         }
  175.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  176.         internal extern char InternalGetChar(int index);
  177.     
  178.         // Gets the character at a specified position.
  179.         //
  180.         /// <include file='doc/String.uex' path='docs/doc[@for="String.this"]/*' />
  181.         [System.Runtime.CompilerServices.IndexerName("Chars")]
  182.         public char this[int index] {
  183.             get { return InternalGetChar(index); }
  184.         }
  186.         // Converts a substring of this string to an array of characters.  Copies the
  187.         // characters of this string beginning at position startIndex and ending at
  188.         // startIndex + length - 1 to the character array buffer, beginning
  189.         // at bufferStartIndex.
  190.         //
  191.         /// <include file='doc/String.uex' path='docs/doc[@for="String.CopyTo"]/*' />
  192.         public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
  193.         {
  194.             if (destination == null) 
  195.                 throw new ArgumentNullException("destination");
  196.             if (count < 0)
  197.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NegativeCount"));
  198.             if (sourceIndex < 0)
  199.                 throw new ArgumentOutOfRangeException("sourceIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  200.             if (count > Length - sourceIndex)
  201.                 throw new ArgumentOutOfRangeException("sourceIndex", Environment.GetResourceString("ArgumentOutOfRange_IndexCount"));
  202.             if (destinationIndex > destination.Length-count || destinationIndex < 0)
  203.                 throw new ArgumentOutOfRangeException("destinationIndex", Environment.GetResourceString("ArgumentOutOfRange_IndexCount"));
  204.             InternalCopyTo(sourceIndex, destination, destinationIndex, count);
  205.         }
  207.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  208.         internal extern void InternalCopyTo(int sourceIndex, char[] destination, int destinationIndex, int count);
  209.     
  210.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  211.         internal extern void CopyToByteArray(int sourceIndex, byte[] destination, int destinationIndex, int charCount);
  212.     
  213.         // Returns the entire string as an array of characters.
  214.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToCharArray"]/*' />
  215.         public char[] ToCharArray() {
  216.             return ToCharArray(0,Length);
  217.         }
  218.     
  219.         // Returns a substring of this string as an array of characters.
  220.         //
  221.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToCharArray1"]/*' />
  222.         public char[] ToCharArray(int startIndex, int length)
  223.         {
  224.             // Range check everything.
  225.             if (startIndex < 0 || startIndex > Length || startIndex > Length - length)
  226.                 throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  227.             if (length < 0)
  228.                 throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  230.             char[] chars = new char[length];
  231.             InternalCopyTo(startIndex, chars, 0, length);
  232.             return chars;
  233.         }
  234.     
  235.         // Gets a hash code for this string.  If strings A and B are such that A.Equals(B), then
  236.         // they will return the same hash code.
  237.         /// <include file='doc/String.uex' path='docs/doc[@for="String.GetHashCode"]/*' />
  238.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  239.         public extern override int GetHashCode();
  240.     
  241.         // Gets the length of this string
  242.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Length"]/*' />
  243.         public int Length {
  244.             get { return InternalLength(); }
  245.         }
  246.     
  247.         /// This is a EE implemented function so that the JIT can recognise is specially
  248.         /// and eliminate checks on character fetchs.
  249.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  250.         private extern int InternalLength();
  251.     
  252.         ///<internalonly/>
  253.         internal int ArrayLength {
  254.             get { return (m_arrayLength); }
  255.         }
  257.         // Used by StringBuilder
  258.         internal int Capacity {
  259.             get { return (m_arrayLength - 1); }
  260.         }
  262.         // Creates an array of strings by splitting this string at each
  263.         // occurence of a separator.  The separator is searched for, and if found,
  264.         // the substring preceding the occurence is stored as the first element in
  265.         // the array of strings.  We then continue in this manner by searching
  266.         // the substring that follows the occurence.  On the other hand, if the separator
  267.         // is not found, the array of strings will contain this instance as its only element.
  268.         // If the separator is null
  269.         // whitespace (i.e., Character.IsWhitespace) is used as the separator.
  270.         //
  271.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Split"]/*' />
  272.         public String [] Split(params char [] separator) {
  273.             return Split(separator, Int32.MaxValue);
  274.         }
  275.     
  276.         // Creates an array of strings by splitting this string at each
  277.         // occurence of a separator.  The separator is searched for, and if found,
  278.         // the substring preceding the occurence is stored as the first element in
  279.         // the array of strings.  We then continue in this manner by searching
  280.         // the substring that follows the occurence.  On the other hand, if the separator
  281.         // is not found, the array of strings will contain this instance as its only element.
  282.         // If the spearator is the empty string (i.e., String.Empty), then
  283.         // whitespace (i.e., Character.IsWhitespace) is used as the separator.
  284.         // If there are more than count different strings, the last n-(count-1)
  285.         // elements are concatenated and added as the last String.
  286.         //
  287.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Split1"]/*' />
  288.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  289.         public extern String[] Split(char[] separator, int count);
  290.     
  291.     
  292.         // Returns a substring of this string.
  293.         //
  294.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Substring"]/*' />
  295.         public String Substring (int startIndex) {
  296.             return this.Substring (startIndex, Length-startIndex);
  297.         }
  298.     
  299.         // Returns a substring of this string.
  300.         //
  301.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Substring1"]/*' />
  302.         public String Substring (int startIndex, int length) {
  303.             
  304.             int thisLength = Length;
  305.             
  306.             //Bounds Checking.
  307.             if (startIndex<0) {
  308.                 throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_StartIndex"));
  309.             }
  311.             if (length<0) {
  312.                 throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_NegativeLength"));
  313.             } 
  315.             if (startIndex > thisLength-length) {
  316.                 throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_IndexLength"));
  317.             }
  319.             String s = FastAllocateString(length);
  320.             FillSubstring(s, 0, this, startIndex, length);
  322.             return s;
  323.         }
  324.     
  325.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  326.         internal extern String TrimHelper(char[] trimChars, int trimType);
  327.     
  328.         //This should really live on System.Globalization.CharacterInfo.  However,
  329.         //Trim gets called by security while resgen is running, so we can't run
  330.         //CharacterInfo's class initializer (which goes to native and looks for a 
  331.         //resource table that hasn't yet been attached to the assembly when resgen
  332.         //runs.  
  333.         internal static readonly char[] WhitespaceChars =   
  334.             { (char) 0x9, (char) 0xA, (char) 0xB, (char) 0xC, (char) 0xD, (char) 0x20, (char) 0xA0,
  335.               (char) 0x2000, (char) 0x2001, (char) 0x2002, (char) 0x2003, (char) 0x2004, (char) 0x2005,
  336.               (char) 0x2006, (char) 0x2007, (char) 0x2008, (char) 0x2009, (char) 0x200A, (char) 0x200B,
  337.               (char) 0x3000, (char) 0xFEFF };
  338.     
  339.         // Removes a string of characters from the ends of this string.
  340.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Trim"]/*' />
  341.         public String Trim(params char[] trimChars) {
  342.             if (null==trimChars || trimChars.Length == 0) {
  343.                 trimChars=WhitespaceChars;
  344.             }
  345.             return TrimHelper(trimChars,TrimBoth);
  346.         }
  347.     
  348.         // Removes a string of characters from the beginning of this string.
  349.         /// <include file='doc/String.uex' path='docs/doc[@for="String.TrimStart"]/*' />
  350.         public String TrimStart(params char[] trimChars) {
  351.             if (null==trimChars || trimChars.Length == 0) {
  352.                 trimChars=WhitespaceChars;
  353.             }
  354.             return TrimHelper(trimChars,TrimHead);
  355.         }
  356.     
  357.     
  358.         // Removes a string of characters from the end of this string.
  359.         /// <include file='doc/String.uex' path='docs/doc[@for="String.TrimEnd"]/*' />
  360.         public String TrimEnd(params char[] trimChars) {
  361.             if (null==trimChars || trimChars.Length == 0) {
  362.                 trimChars=WhitespaceChars;
  363.             }
  364.             return TrimHelper(trimChars,TrimTail);
  365.         }
  366.     
  367.     
  368.         // Creates a new string with the characters copied in from ptr. If
  369.         // ptr is null, a string initialized to ";<;No Object>;"; (i.e.,
  370.         // String.NullString) is created.
  371.         //
  372.         // Issue: This method is only accessible from VC.
  373.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String"]/*' />
  374.         [CLSCompliant(false), MethodImplAttribute(MethodImplOptions.InternalCall)]
  375.         unsafe public extern String(char *value);
  376.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String1"]/*' />
  377.         [CLSCompliant(false), MethodImplAttribute(MethodImplOptions.InternalCall)]
  378.         unsafe public extern String(char *value, int startIndex, int length);
  379.     
  380.        /// <include file='doc/String.uex' path='docs/doc[@for="String.String2"]/*' />
  381.         [CLSCompliant(false), MethodImplAttribute(MethodImplOptions.InternalCall)]
  382.        unsafe public extern String(sbyte *value);
  383.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String3"]/*' />
  384.         [CLSCompliant(false), MethodImplAttribute(MethodImplOptions.InternalCall)]
  385.         unsafe public extern String(sbyte *value, int startIndex, int length);
  387.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String4"]/*' />
  388.         [CLSCompliant(false), MethodImplAttribute(MethodImplOptions.InternalCall)]
  389.         unsafe public extern String(sbyte *value, int startIndex, int length, Encoding enc);
  390.                 
  391.         unsafe static private String CreateString(sbyte *value, int startIndex, int length, Encoding enc) {
  392.             if (enc == null)
  393.                 return new String(value, startIndex, length); // default to ANSI
  394.             if (length < 0)
  395.                 throw new ArgumentOutOfRangeException("length",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  396.             byte [] b = new byte[length];
  397.             __UnmanagedMemoryStream.memcpy((byte*)value, startIndex, b, 0, length);
  398.             return enc.GetString(b);
  399.         }
  401.         // For ASCIIEncoding::GetString()
  402.         unsafe static internal String CreateStringFromASCII(byte[] bytes, int startIndex, int length) {
  403.             BCLDebug.Assert(bytes != null, "need a byte[].");
  404.             BCLDebug.Assert(startIndex >= 0 && (startIndex < bytes.Length || bytes.Length == 0), "startIndex >= 0 && startIndex < bytes.Length");
  405.             BCLDebug.Assert(length >= 0 && length <= bytes.Length - startIndex, "length >= 0 && length <= bytes.Length - startIndex");
  406.             if (length == 0)
  407.                 return String.Empty;
  408.             String s = FastAllocateString(length);
  409.             fixed(char* pChars = &s.m_firstChar) {
  410.                 for(int i=0; i<length; i++) 
  411.                     pChars[i] = (char) (bytes[i+startIndex] & 0x7f);
  412.             }
  413.             return s;
  414.         }
  415.     
  416.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  417.         private extern static String FastAllocateString(int length);
  419.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  420.         private extern static void FillString(String dest, int destPos, String src);
  422.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  423.         private extern static void FillStringChecked(String dest, int destPos, String src);
  425.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  426.         private extern static void FillStringEx(String dest, int destPos, String src,int srcLength);
  428.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  429.         private extern static void FillStringArray(String dest, int stringStart, char[] array, int charStart, int count);
  431.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  432.         private extern static void FillSubstring(String dest, int destPos, String src, int startPos, int count);
  435.     
  436.         // Creates a new string from the characters in a subarray.  The new string will
  437.         // be created from the characters in value between startIndex and
  438.         // startIndex + length - 1.
  439.         //
  440.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String7"]/*' />
  441.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  442.         public extern String(char [] value, int startIndex, int length);
  443.     
  444.         // Creates a new string from the characters in a subarray.  The new string will be
  445.         // created from the characters in value.
  446.         //
  447.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String5"]/*' />
  448.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  449.         public extern String(char [] value);
  450.     
  451.         /// <include file='doc/String.uex' path='docs/doc[@for="String.String6"]/*' />
  452.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  453.         public extern String(char c, int count);
  455.     
  456.         //
  457.         //
  458.         // INSTANCE METHODS
  459.         //
  460.         //
  461.     
  462.         // Provides a culture-correct string comparison. StrA is compared to StrB
  463.         // to determine whether it is lexicographically less, equal, or greater, and then returns
  464.         // either a negative integer, 0, or a positive integer; respectively.
  465.         //
  466.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Compare"]/*' />
  467.         public static int Compare(String strA, String strB) {
  468.             return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.None);
  469.         }
  470.     
  471.         // Provides a culture-correct string comparison. strA is compared to strB
  472.         // to determine whether it is lexicographically less, equal, or greater, and then a
  473.         // negative integer, 0, or a positive integer is returned; respectively.
  474.         // The case-sensitive option is set by ignoreCase
  475.         //
  476.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Compare1"]/*' />
  477.         public static int Compare(String strA, String strB, bool ignoreCase) {
  478.             if (ignoreCase) {
  479.                 return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase);
  480.             }
  481.             return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.None);
  482.         }
  483.     
  484.         // Provides a culture-correct string comparison. strA is compared to strB
  485.         // to determine whether it is lexicographically less, equal, or greater, and then a
  486.         // negative integer, 0, or a positive integer is returned; respectively.
  487.         // The case-sensitive option is set by ignoreCase, and the culture is set
  488.         // by culture
  489.         //
  490.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Compare2"]/*' />
  491.         public static int Compare(String strA, String strB, bool ignoreCase, CultureInfo culture) {
  492.             if (culture==null) {
  493.                 throw new ArgumentNullException("culture");
  494.             }
  495.     
  496.             if (ignoreCase) {
  497.                 return culture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase);
  498.             }
  499.             return culture.CompareInfo.Compare(strA, strB, CompareOptions.None);
  500.         }
  501.     
  502.         // Determines whether two string regions match.  The substring of strA beginning
  503.         // at indexA of length count is compared with the substring of strB
  504.         // beginning at indexB of the same length.
  505.         //
  506.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Compare3"]/*' />
  507.         public static int Compare(String strA, int indexA, String strB, int indexB, int length) {
  508.             int lengthA = length;
  509.             int lengthB = length;
  511.             if (strA!=null) {
  512.                 if (strA.Length - indexA < lengthA) {
  513.                   lengthA = (strA.Length - indexA);
  514.                 }
  515.             }
  517.             if (strB!=null) {
  518.                 if (strB.Length - indexB < lengthB) {
  519.                     lengthB = (strB.Length - indexB);
  520.                 }
  521.             }
  522.             return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None);
  523.         }
  524.     
  525.     
  526.         // Determines whether two string regions match.  The substring of strA beginning
  527.         // at indexA of length count is compared with the substring of strB
  528.         // beginning at indexB of the same length.  Case sensitivity is determined by the ignoreCase boolean.
  529.         //
  530.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Compare4"]/*' />
  531.         public static int Compare(String strA, int indexA, String strB, int indexB, int length, bool ignoreCase) {
  532.             int lengthA = length;
  533.             int lengthB = length;
  535.             if (strA!=null) {
  536.                 if (strA.Length - indexA < lengthA) {
  537.                   lengthA = (strA.Length - indexA);
  538.                 }
  539.             }
  541.             if (strB!=null) {
  542.                 if (strB.Length - indexB < lengthB) {
  543.                     lengthB = (strB.Length - indexB);
  544.                 }
  545.             }
  547.             if (ignoreCase) {
  548.                 return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase);
  549.             }
  550.             return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None);
  551.         }
  552.     
  553.         // Determines whether two string regions match.  The substring of strA beginning
  554.         // at indexA of length length is compared with the substring of strB
  555.         // beginning at indexB of the same length.  Case sensitivity is determined by the ignoreCase boolean,
  556.         // and the culture is set by culture.
  557.         //
  558.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Compare5"]/*' />
  559.         public static int Compare(String strA, int indexA, String strB, int indexB, int length, bool ignoreCase, CultureInfo culture) {
  560.             if (culture==null) {
  561.                 throw new ArgumentNullException("culture");
  562.             }
  564.             int lengthA = length;
  565.             int lengthB = length;
  567.             if (strA!=null) {
  568.                 if (strA.Length - indexA < lengthA) {
  569.                   lengthA = (strA.Length - indexA);
  570.                 }
  571.             }
  573.             if (strB!=null) {
  574.                 if (strB.Length - indexB < lengthB) {
  575.                     lengthB = (strB.Length - indexB);
  576.                 }
  577.             }
  578.     
  579.             if (ignoreCase) {
  580.                 return culture.CompareInfo.Compare(strA,indexA,lengthA, strB, indexB, lengthB,CompareOptions.IgnoreCase);
  581.             } else {
  582.                 return culture.CompareInfo.Compare(strA,indexA,lengthA, strB, indexB, lengthB,CompareOptions.None);
  583.             }
  584.         }
  585.     
  586.         // Compares this object to another object, returning an integer that
  587.         // indicates the relationship. This method returns a value less than 0 if this is less than value, 0
  588.         // if this is equal to value, or a value greater than 0
  589.         // if this is greater than value.  Strings are considered to be
  590.         // greater than all non-String objects.  Note that this means sorted 
  591.         // arrays would contain nulls, other objects, then Strings in that order.
  592.         //
  593.         /// <include file='doc/String.uex' path='docs/doc[@for="String.CompareTo"]/*' />
  594.         public int CompareTo(Object value) {
  595.             if (value == null) {
  596.                 return 1;
  597.             }
  598.             
  599.             if (!(value is String)) {
  600.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeString"));
  601.             }
  603.             return String.Compare(this,(String)value);
  604.         }
  605.     
  606.         // Determines the sorting relation of StrB to the current instance.
  607.         //
  608.         /// <include file='doc/String.uex' path='docs/doc[@for="String.CompareTo1"]/*' />
  609.         public int CompareTo(String strB) {
  610.             if (strB==null) {
  611.                 return 1;
  612.             }
  613.             return CultureInfo.CurrentCulture.CompareInfo.Compare(this, strB, 0);
  614.         }
  615.     
  616.         // Compares strA and strB using an ordinal (code-point) comparison.
  617.         //
  618.         /// <include file='doc/String.uex' path='docs/doc[@for="String.CompareOrdinal"]/*' />
  619.         public static int CompareOrdinal(String strA, String strB) {
  620.             if (strA == null || strB == null) {
  621.                 if ((Object)strA==(Object)strB) { //they're both null;
  622.                     return 0;
  623.                 }
  624.                 return (strA==null)? -1 : 1; //-1 if A is null, 1 if B is null.
  625.             }
  626.             
  627.             return nativeCompareOrdinal(strA, strB, false);
  628.         }
  629.     
  630.         // Compares strA and strB using an ordinal (code-point) comparison.
  631.         //
  632.         /// <include file='doc/String.uex' path='docs/doc[@for="String.CompareOrdinal1"]/*' />
  633.         public static int CompareOrdinal(String strA, int indexA, String strB, int indexB, int length) {
  634.             if (strA == null || strB == null) {
  635.                 if ((Object)strA==(Object)strB) { //they're both null;
  636.                     return 0;
  637.                 }
  638.     
  639.                 return (strA==null)? -1 : 1; //-1 if A is null, 1 if B is null.
  640.             }
  641.     
  642.             return nativeCompareOrdinalEx(strA, indexA, strB, indexB, length);
  643.         }
  644.     
  645.     
  646.         // Determines whether a specified string is a suffix of the the current instance.
  647.         //
  648.         // The case-sensitive and culture-sensitive option is set by options,
  649.         // and the default culture is used.
  650.         //
  651.         /// <include file='doc/String.uex' path='docs/doc[@for="String.EndsWith"]/*' />
  652.         public bool EndsWith(String value) {
  653.             if (null==value) {
  654.                 throw new ArgumentNullException("value");
  655.             }
  656.             int valueLen = value.Length;
  657.             int thisLen = this.Length;
  658.             if (valueLen>thisLen) {
  659.                 return false;
  660.             }
  661.             return (0==Compare(this, thisLen-valueLen, value, 0, valueLen));
  662.         }
  664.         internal bool EndsWith(char value) {
  665.             int thisLen = this.Length;
  666.             if (thisLen != 0) {
  667.                 if (this[thisLen - 1] == value)
  668.                     return true;
  669.             }
  670.             return false;
  671.         }
  672.     
  673.     
  674.         // Returns the index of the first occurance of value in the current instance.
  675.         // The search starts at startIndex and runs thorough the next count characters.
  676.         //
  677.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOf"]/*' />
  678.         public int IndexOf(char value) {
  679.             return IndexOf(value, 0, this.Length);
  680.         }
  681.     
  682.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOf1"]/*' />
  683.         public int IndexOf(char value, int startIndex) {
  684.             return IndexOf(value, startIndex, this.Length - startIndex);
  685.         }
  686.     
  687.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOf2"]/*' />
  688.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  689.         public extern int IndexOf(char value, int startIndex, int count);
  690.     
  691.         // Returns the index of the first occurance of any character in value in the current instance.
  692.         // The search starts at startIndex and runs to endIndex-1. [startIndex,endIndex).
  693.         //
  694.         
  695.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOfAny1"]/*' />
  696.         public int IndexOfAny(char [] anyOf) {
  697.             return IndexOfAny(anyOf,0, this.Length);
  698.         }
  699.     
  700.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOfAny2"]/*' />
  701.         public int IndexOfAny(char [] anyOf, int startIndex) {
  702.             return IndexOfAny(anyOf, startIndex, this.Length - startIndex);
  703.         }
  704.     
  705.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOfAny3"]/*' />
  706.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  707.         public extern int IndexOfAny(char [] anyOf, int startIndex, int count);
  708.     
  709.     
  710.         // Determines the position within this string of the first occurence of the specified
  711.         // string, according to the specified search criteria.  The search begins at
  712.         // the first character of this string, it is case-sensitive and culture-sensitive,
  713.         // and the default culture is used.
  714.         //
  715.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOf6"]/*' />
  716.         public int IndexOf(String value) {
  717.             return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this,value);
  718.         }
  719.     
  720.         // Determines the position within this string of the first occurence of the specified
  721.         // string, according to the specified search criteria.  The search begins at
  722.         // startIndex, it is case-sensitive and culture-sensitve, and the default culture is used.
  723.         //
  724.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOf7"]/*' />
  725.         public int IndexOf(String value, int startIndex){
  726.             return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this,value,startIndex);
  727.         }
  728.     
  729.         // Determines the position within this string of the first occurence of the specified
  730.         // string, according to the specified search criteria.  The search begins at
  731.         // startIndex, ends at endIndex and the default culture is used.
  732.         //
  733.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IndexOf8"]/*' />
  734.         public int IndexOf(String value, int startIndex, int count){
  735.             if (startIndex + count > this.Length) {
  736.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  737.             }
  738.             return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.None);
  739.         }
  740.     
  741.     
  742.         // Returns the index of the last occurance of value in the current instance.
  743.         // The search starts at startIndex and runs to endIndex. [startIndex,endIndex].
  744.         // The character at position startIndex is included in the search.  startIndex is the larger
  745.         // index within the string.
  746.         //
  747.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOf"]/*' />
  748.         public int LastIndexOf(char value) {
  749.             return LastIndexOf(value, this.Length-1, this.Length);
  750.         }
  751.     
  752.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOf1"]/*' />
  753.         public int LastIndexOf(char value, int startIndex){
  754.             return LastIndexOf(value,startIndex,startIndex + 1);
  755.         }
  756.     
  757.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOf2"]/*' />
  758.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  759.         public extern int LastIndexOf(char value, int startIndex, int count);
  760.     
  761.         // Returns the index of the last occurance of any character in value in the current instance.
  762.         // The search starts at startIndex and runs to endIndex. [startIndex,endIndex].
  763.         // The character at position startIndex is included in the search.  startIndex is the larger
  764.         // index within the string.
  765.         //
  766.         
  767.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOfAny1"]/*' />
  768.         public int LastIndexOfAny(char [] anyOf) {
  769.             return LastIndexOfAny(anyOf,this.Length-1,this.Length);
  770.         }
  771.     
  772.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOfAny2"]/*' />
  773.         public int LastIndexOfAny(char [] anyOf, int startIndex) {
  774.             return LastIndexOfAny(anyOf,startIndex,startIndex + 1);
  775.         }
  776.     
  777.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOfAny3"]/*' />
  778.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  779.         public extern int LastIndexOfAny(char [] anyOf, int startIndex, int count);
  780.     
  781.     
  782.         // Returns the index of the last occurance of any character in value in the current instance.
  783.         // The search starts at startIndex and runs to endIndex. [startIndex,endIndex].
  784.         // The character at position startIndex is included in the search.  startIndex is the larger
  785.         // index within the string.
  786.         //
  787.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOf6"]/*' />
  788.         public int LastIndexOf(String value) {
  789.             return LastIndexOf(value, this.Length-1,this.Length);
  790.         }
  791.     
  792.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOf7"]/*' />
  793.         public int LastIndexOf(String value, int startIndex) {
  794.             return LastIndexOf(value, startIndex, startIndex + 1);
  795.         }
  796.     
  797.         /// <include file='doc/String.uex' path='docs/doc[@for="String.LastIndexOf8"]/*' />
  798.         public int LastIndexOf(String value, int startIndex, int count) {
  799.             if (count<0) {
  800.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
  801.             }
  802.             return CultureInfo.CurrentCulture.CompareInfo.LastIndexOf(this, value, startIndex, count, CompareOptions.None);
  803.         }
  804.     
  805.     
  806.         //
  807.         //
  808.         /// <include file='doc/String.uex' path='docs/doc[@for="String.PadLeft"]/*' />
  809.         public String PadLeft(int totalWidth) {
  810.             return PadHelper(totalWidth, ' ', false);
  811.         }
  812.     
  813.         /// <include file='doc/String.uex' path='docs/doc[@for="String.PadLeft1"]/*' />
  814.         public String PadLeft(int totalWidth, char paddingChar) {
  815.             return PadHelper(totalWidth, paddingChar, false);
  816.         }
  817.         
  818.         /// <include file='doc/String.uex' path='docs/doc[@for="String.PadRight"]/*' />
  819.         public String PadRight(int totalWidth) {
  820.             return PadHelper(totalWidth, ' ', true);
  821.         }
  822.     
  823.         /// <include file='doc/String.uex' path='docs/doc[@for="String.PadRight1"]/*' />
  824.         public String PadRight(int totalWidth, char paddingChar) {
  825.             return PadHelper(totalWidth, paddingChar, true);
  826.         }
  827.     
  828.     
  829.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  830.         private extern String PadHelper(int totalWidth, char paddingChar, bool isRightPadded);
  831.     
  832.         // Determines whether a specified string is a prefix of the current instance
  833.         //
  834.         /// <include file='doc/String.uex' path='docs/doc[@for="String.StartsWith"]/*' />
  835.         public bool StartsWith(String value) {
  836.             if (null==value) {
  837.                 throw new ArgumentNullException("value");
  838.             }
  839.             if (this.Length<value.Length) {
  840.                 return false;
  841.             }
  842.             return (0==Compare(this,0, value,0, value.Length));
  843.         }
  844.     
  845.         // Creates a copy of this string in lower case.
  846.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToLower"]/*' />
  847.         public String ToLower() {
  848.             return this.ToLower(CultureInfo.CurrentCulture);
  849.         }
  850.     
  851.         // Creates a copy of this string in lower case.  The culture is set by culture.
  852.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToLower1"]/*' />
  853.         public String ToLower(CultureInfo culture) {
  854.             if (culture==null) {
  855.                 throw new ArgumentNullException("culture");
  856.             }
  857.             return culture.TextInfo.ToLower(this);
  858.         }
  859.     
  860.         // Creates a copy of this string in upper case.
  861.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToUpper"]/*' />
  862.         public String ToUpper() {
  863.             return this.ToUpper(CultureInfo.CurrentCulture);
  864.         }
  865.     
  866.         // Creates a copy of this string in upper case.  The culture is set by culture.
  867.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToUpper1"]/*' />
  868.         public String ToUpper(CultureInfo culture) {
  869.             if (culture==null) {
  870.                 throw new ArgumentNullException("culture");
  871.             }
  872.             return culture.TextInfo.ToUpper(this);
  873.         }
  874.     
  875.         // Returns this string.
  876.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToString"]/*' />
  877.         public override String ToString() {
  878.             return this;
  879.         }
  881.         /// <include file='doc/String.uex' path='docs/doc[@for="String.ToString1"]/*' />
  882.         public String ToString(IFormatProvider provider) {
  883.             return this;
  884.         }
  885.     
  886.         // Method required for the ICloneable interface.
  887.         // There's no point in cloning a string since they're immutable, so we simply return this.
  888.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Clone"]/*' />
  889.         public Object Clone() {
  890.             return this;
  891.         }
  892.     
  893.     
  894.         // Trims the whitespace from both ends of the string.  Whitespace is defined by
  895.         // CharacterInfo.WhitespaceChars.
  896.         //
  897.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Trim1"]/*' />
  898.         public String Trim() {
  899.             return this.Trim(WhitespaceChars);
  900.         }
  901.     
  902.         //
  903.         //
  904.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Insert"]/*' />
  905.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  906.         public extern String Insert(int startIndex, String value);
  907.     
  908.         // Replaces all instances of oldChar with newChar.
  909.         //
  910.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Replace"]/*' />
  911.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  912.         public extern String Replace (char oldChar, char newChar);
  914.     // This method contains the same functionality as StringBuilder Replace. The only difference is that
  915.     // a new String has to be allocated since Strings are immutable
  916.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Replace1"]/*' />
  917.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  918.         public extern String Replace (String oldValue, String newValue);
  919.     
  920.         //
  921.         //
  922.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Remove"]/*' />
  923.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  924.         public extern String Remove(int startIndex, int count);
  925.     
  926.     
  927.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Format"]/*' />
  928.         public static String Format(String format, Object arg0) {
  929.             return Format(null, format, new Object[] {arg0});
  930.         }
  931.     
  932.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Format1"]/*' />
  933.         public static String Format(String format, Object arg0, Object arg1) {
  934.             return Format(null, format, new Object[] {arg0, arg1});
  935.         }
  936.     
  937.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Format2"]/*' />
  938.         public static String Format(String format, Object arg0, Object arg1, Object arg2) {
  939.             return Format(null, format, new Object[] {arg0, arg1, arg2});
  940.         }
  944.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Format3"]/*' />
  945.         public static String Format(String format, params Object[] args) {
  946.             return Format(null, format, args);
  947.         }
  948.     
  949.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Format4"]/*' />
  950.         public static String Format( IFormatProvider provider, String format, params Object[] args) {
  951.             if (format == null || args == null) 
  952.                 throw new ArgumentNullException((format==null)?"format":"args");
  953.             StringBuilder sb = new StringBuilder(format.Length + args.Length * 8);
  954.             sb.AppendFormat(provider,format,args);
  955.             return sb.ToString();
  956.         }
  957.     
  958.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Copy"]/*' />
  959.         public static String Copy (String str) {
  960.             if (str==null) {
  961.                 throw new ArgumentNullException("str");
  962.             }
  964.             int length = str.Length;
  966.             String result = FastAllocateString(length);
  967.             FillString(result, 0, str);
  968.             return result;
  969.         }
  971.         // Used by StringBuilder to avoid data corruption
  972.         internal static String InternalCopy (String str) {
  973.             int length = str.Length;
  974.             String result = FastAllocateString(length);
  975.             FillStringEx(result, 0, str, length); // The underlying's String can changed length is StringBuilder
  976.             return result;
  977.         }
  979.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat"]/*' />
  980.         public static String Concat(Object arg0) {
  981.             if (arg0==null) {
  982.                 return String.Empty;
  983.             }
  984.             return arg0.ToString();
  985.         }
  986.     
  987.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat1"]/*' />
  988.         public static String Concat(Object arg0, Object arg1) {
  989.             if (arg0==null) {
  990.                 arg0 = String.Empty;
  991.             }
  992.     
  993.             if (arg1==null) {
  994.                 arg1 = String.Empty;
  995.             }
  996.             return Concat(arg0.ToString(), arg1.ToString());
  997.         }
  998.     
  999.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat2"]/*' />
  1000.         public static String Concat(Object arg0, Object arg1, Object arg2) {
  1001.             if (arg0==null) {
  1002.                 arg0 = String.Empty;
  1003.             }
  1004.     
  1005.             if (arg1==null) {
  1006.                 arg1 = String.Empty;
  1007.             }
  1008.     
  1009.             if (arg2==null) {
  1010.                 arg2 = String.Empty;
  1011.             }
  1012.     
  1013.             return Concat(arg0.ToString(), arg1.ToString(), arg2.ToString());
  1014.         }
  1016.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat3"]/*' />
  1017.         [CLSCompliant(false)] 
  1018.         public static String Concat(Object arg0, Object arg1, Object arg2, Object arg3, __arglist) 
  1019.         {
  1020.             Object[]   objArgs;
  1021.             int        argCount;
  1022.             
  1023.             ArgIterator args = new ArgIterator(__arglist);
  1025.             //+4 to account for the 4 hard-coded arguments at the beginning of the list.
  1026.             argCount = args.GetRemainingCount() + 4;
  1027.     
  1028.             objArgs = new Object[argCount];
  1029.             
  1030.             //Handle the hard-coded arguments
  1031.             objArgs[0] = arg0;
  1032.             objArgs[1] = arg1;
  1033.             objArgs[2] = arg2;
  1034.             objArgs[3] = arg3;
  1035.             
  1036.             //Walk all of the args in the variable part of the argument list.
  1037.             for (int i=4; i<argCount; i++) {
  1038.                 objArgs[i] = TypedReference.ToObject(args.GetNextArg());
  1039.             }
  1041.             return Concat(objArgs);
  1042.         }
  1045.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat4"]/*' />
  1046.         public static String Concat(params Object[] args) {
  1047.             if (args==null) {
  1048.                 throw new ArgumentNullException("args");
  1049.             }
  1050.     
  1051.             String[] sArgs = new String[args.Length];
  1052.             int totalLength=0;
  1053.             
  1054.             for (int i=0; i<args.Length; i++) {
  1055.                 sArgs[i] = ((args[i]==null)?(String.Empty):(args[i].ToString()));
  1056.                 totalLength += sArgs[i].Length;
  1057.             }
  1058.             return ConcatArray(sArgs, totalLength);
  1059.         }
  1062.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat5"]/*' />
  1063.         public static String Concat(String str0, String str1) {
  1064.             if (str0 == null) {
  1065.                 if (str1==null) {
  1066.                     return String.Empty;
  1067.                 }
  1068.                 return str1;
  1069.             }
  1071.             if (str1==null) {
  1072.                 return str0;
  1073.             }
  1075.             int str0Length = str0.Length;
  1076.             
  1077.             String result = FastAllocateString(str0Length + str1.Length);
  1078.             
  1079.             FillStringChecked(result, 0,        str0);
  1080.             FillStringChecked(result, str0Length, str1);
  1081.             
  1082.             return result;
  1083.         }
  1085.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat6"]/*' />
  1086.         public static String Concat(String str0, String str1, String str2) {
  1087.             if (str0==null && str1==null && str2==null) {
  1088.                 return String.Empty;
  1089.             }
  1091.             if (str0==null) {
  1092.                 str0 = String.Empty;
  1093.             }
  1095.             if (str1==null) {
  1096.                 str1 = String.Empty;
  1097.             }
  1099.             if (str2 == null) {
  1100.                 str2 = String.Empty;
  1101.             }
  1103.             int totalLength = str0.Length + str1.Length + str2.Length;
  1105.             String result = FastAllocateString(totalLength);
  1106.             FillStringChecked(result, 0, str0);
  1107.             FillStringChecked(result, str0.Length, str1);
  1108.             FillStringChecked(result, str0.Length + str1.Length, str2);
  1110.             return result;
  1111.         }
  1113.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat7"]/*' />
  1114.         public static String Concat(String str0, String str1, String str2, String str3) {
  1115.             if (str0==null && str1==null && str2==null && str3==null) {
  1116.                 return String.Empty;
  1117.             }
  1119.             if (str0==null) {
  1120.                 str0 = String.Empty;
  1121.             }
  1123.             if (str1==null) {
  1124.                 str1 = String.Empty;
  1125.             }
  1127.             if (str2 == null) {
  1128.                 str2 = String.Empty;
  1129.             }
  1130.             
  1131.             if (str3 == null) {
  1132.                 str3 = String.Empty;
  1133.             }
  1135.             int totalLength = str0.Length + str1.Length + str2.Length + str3.Length;
  1137.             String result = FastAllocateString(totalLength);
  1138.             FillStringChecked(result, 0, str0);
  1139.             FillStringChecked(result, str0.Length, str1);
  1140.             FillStringChecked(result, str0.Length + str1.Length, str2);
  1141.             FillStringChecked(result, str0.Length + str1.Length + str2.Length, str3);
  1143.             return result;
  1144.         }
  1146.         private static String ConcatArray(String[] values, int totalLength) {
  1147.             String result =  FastAllocateString(totalLength);
  1148.             int currPos=0;
  1150.             for (int i=0; i<values.Length; i++) {
  1151.                 BCLDebug.Assert((currPos + values[i].Length <= totalLength), 
  1152.                                 "[String.ConcatArray](currPos + values[i].Length <= totalLength)");
  1154.                 FillStringChecked(result, currPos, values[i]);
  1155.                 currPos+=values[i].Length;
  1156.             }
  1158.             return result;
  1159.         }
  1161.         private static String[] CopyArrayOnNull(String[] values, out int totalLength) {
  1162.             totalLength = 0;
  1163.             
  1164.             String[] outValues = new String[values.Length];
  1165.             
  1166.             for (int i=0; i<values.Length; i++) {
  1167.                 outValues[i] = ((values[i]==null)?String.Empty:values[i]);
  1168.                 totalLength += outValues[i].Length;
  1169.             }
  1170.             return outValues;
  1171.         }
  1173.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Concat8"]/*' />
  1174.         public static String Concat(params String[] values) {
  1175.             int totalLength=0;
  1177.             if (values==null) {
  1178.                 throw new ArgumentNullException("values");
  1179.             }
  1181.             for (int i=0; i<values.Length; i++) {
  1182.                 if (values[i]==null) {
  1183.                     values = CopyArrayOnNull(values, out totalLength);
  1184.                     break;
  1185.                 } else {
  1186.                     totalLength += values[i].Length;
  1187.                 }
  1188.             }
  1189.             
  1190.             return ConcatArray(values, totalLength);
  1191.         }
  1193.         /// <include file='doc/String.uex' path='docs/doc[@for="String.Intern"]/*' />
  1194.         public static String Intern(String str) {
  1195.             if (str==null) {
  1196.                 throw new ArgumentNullException("str");
  1197.             }
  1198.             return Thread.GetDomain().GetOrInternString(str);
  1199.         }
  1201.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IsInterned"]/*' />
  1202.         public static String IsInterned(String str) {
  1203.             if (str==null) {
  1204.                 throw new ArgumentNullException("str");
  1205.             }
  1206.             return Thread.GetDomain().IsStringInterned(str);
  1207.         }
  1210.         //
  1211.         // IValue implementation
  1212.         // 
  1213.         
  1214.         /// <include file='doc/String.uex' path='docs/doc[@for="String.GetTypeCode"]/*' />
  1215.         public TypeCode GetTypeCode() {
  1216.             return TypeCode.String;
  1217.         }
  1219.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToBoolean"]/*' />
  1220.         /// <internalonly/>
  1221.         bool IConvertible.ToBoolean(IFormatProvider provider) {
  1222.             return Convert.ToBoolean(this, provider);
  1223.         }
  1225.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToChar"]/*' />
  1226.         /// <internalonly/>
  1227.         char IConvertible.ToChar(IFormatProvider provider) {
  1228.             return Convert.ToChar(this, provider);
  1229.         }
  1231.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToSByte"]/*' />
  1232.         /// <internalonly/>
  1233.         [CLSCompliant(false)]
  1234.         sbyte IConvertible.ToSByte(IFormatProvider provider) {
  1235.             return Convert.ToSByte(this, provider);
  1236.         }
  1238.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToByte"]/*' />
  1239.         /// <internalonly/>
  1240.         byte IConvertible.ToByte(IFormatProvider provider) {
  1241.             return Convert.ToByte(this, provider);
  1242.         }
  1244.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToInt16"]/*' />
  1245.         /// <internalonly/>
  1246.         short IConvertible.ToInt16(IFormatProvider provider) {
  1247.             return Convert.ToInt16(this, provider);
  1248.         }
  1250.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToUInt16"]/*' />
  1251.         /// <internalonly/>
  1252.         [CLSCompliant(false)]
  1253.         ushort IConvertible.ToUInt16(IFormatProvider provider) {
  1254.             return Convert.ToUInt16(this, provider);
  1255.         }
  1257.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToInt32"]/*' />
  1258.         /// <internalonly/>
  1259.         int IConvertible.ToInt32(IFormatProvider provider) {
  1260.             return Convert.ToInt32(this, provider);
  1261.         }
  1263.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToUInt32"]/*' />
  1264.         /// <internalonly/>
  1265.         [CLSCompliant(false)]
  1266.         uint IConvertible.ToUInt32(IFormatProvider provider) {
  1267.             return Convert.ToUInt32(this, provider);
  1268.         }
  1270.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToInt64"]/*' />
  1271.         /// <internalonly/>
  1272.         long IConvertible.ToInt64(IFormatProvider provider) {
  1273.             return Convert.ToInt64(this, provider);
  1274.         }
  1276.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToUInt64"]/*' />
  1277.         /// <internalonly/>
  1278.         [CLSCompliant(false)]
  1279.         ulong IConvertible.ToUInt64(IFormatProvider provider) {
  1280.             return Convert.ToUInt64(this, provider);
  1281.         }
  1283.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToSingle"]/*' />
  1284.         /// <internalonly/>
  1285.         float IConvertible.ToSingle(IFormatProvider provider) {
  1286.             return Convert.ToSingle(this, provider);
  1287.         }
  1289.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToDouble"]/*' />
  1290.         /// <internalonly/>
  1291.         double IConvertible.ToDouble(IFormatProvider provider) {
  1292.             return Convert.ToDouble(this, provider);
  1293.         }
  1295.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToDecimal"]/*' />
  1296.         /// <internalonly/>
  1297.         Decimal IConvertible.ToDecimal(IFormatProvider provider) {
  1298.             return Convert.ToDecimal(this, provider);
  1299.         }
  1301.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToDateTime"]/*' />
  1302.         /// <internalonly/>
  1303.         DateTime IConvertible.ToDateTime(IFormatProvider provider) {
  1304.             return Convert.ToDateTime(this, provider);
  1305.         }
  1307.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IConvertible.ToType"]/*' />
  1308.         /// <internalonly/>
  1309.         Object IConvertible.ToType(Type type, IFormatProvider provider) {
  1310.             return Convert.DefaultToType((IConvertible)this, type, provider);
  1311.         }
  1313.         // Is this a string that can be compared quickly (that is it has only characters > 0x80 
  1314.         // and not a - or '
  1315.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1316.         internal extern bool IsFastSort();
  1317.         
  1318.         ///<internalonly/>
  1319.         unsafe internal void SetChar(int index, char value)
  1320.         {
  1321. #if _DEBUG
  1322.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1323. #endif
  1325.             //Bounds check and then set the actual bit.
  1326.             if ((UInt32)index >= (UInt32)Length)
  1327.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  1329.             fixed (char *p = this.m_firstChar) {
  1330.                 // Set the character.
  1331.                 p[index] = value;
  1332.             }
  1333.         }
  1335. #if _DEBUG
  1336.         // Only used in debug build. Insure that the HighChar state information for a string is not set as known
  1337.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1338.         private extern bool ValidModifiableString();
  1339. #endif
  1341.         ///<internalonly/>
  1342.         unsafe internal void AppendInPlace(char value,int currentLength)
  1343.         {
  1344.             BCLDebug.Assert(currentLength < m_arrayLength, "[String.AppendInPlace(char)currentLength < m_arrayLength");
  1345. #if _DEBUG
  1346.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1347. #endif
  1349.             fixed (char *p = this.m_firstChar)
  1350.             {
  1351.                 // Append the character.
  1352.                 p[currentLength] = value;
  1353.                 p[++currentLength] = '/0';
  1354.                 m_stringLength = currentLength;
  1355.             }
  1356.         }
  1359.         ///<internalonly/>
  1360.         unsafe internal void AppendInPlace(char value, int repeatCount, int currentLength)
  1361.         {
  1362.             BCLDebug.Assert(currentLength+repeatCount < m_arrayLength, "[String.AppendInPlace]currentLength+repeatCount < m_arrayLength");
  1363. #if _DEBUG
  1364.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1365. #endif
  1366.             
  1367.             int newLength = currentLength + repeatCount;
  1370.             fixed (char *p = this.m_firstChar)
  1371.             {
  1372.                 int i;
  1373.                 for (i=currentLength; i<newLength; i++) {
  1374.                     p[i] = value;
  1375.                 }
  1376.                 p[i] = '/0';
  1377.             }
  1378.             this.m_stringLength = newLength; 
  1379.         }
  1381.         ///<internalonly/>
  1382.        internal unsafe void AppendInPlace(String value, int currentLength) {
  1383.             BCLDebug.Assert(value!=null, "[String.AppendInPlace]value!=null");
  1384.             BCLDebug.Assert(value.Length + currentLength < this.m_arrayLength, "[String.AppendInPlace]Length is wrong.");
  1385. #if _DEBUG
  1386.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1387. #endif
  1388.             
  1389.             FillString(this, currentLength, value);
  1390.             SetLength(currentLength + value.Length);
  1391.             NullTerminate();    
  1392.         }
  1393.         
  1394.         internal void AppendInPlace(String value, int startIndex, int count, int currentLength) {
  1395.             BCLDebug.Assert(value!=null, "[String.AppendInPlace]value!=null");
  1396.             BCLDebug.Assert(count + currentLength < this.m_arrayLength, "[String.AppendInPlace]count + currentLength < this.m_arrayLength");
  1397.             BCLDebug.Assert(count>=0, "[String.AppendInPlace]count>=0");
  1398.             BCLDebug.Assert(startIndex>=0, "[String.AppendInPlace]startIndex>=0");
  1399.             BCLDebug.Assert(startIndex <= (value.Length - count), "[String.AppendInPlace]startIndex <= (value.Length - count)");
  1400. #if _DEBUG
  1401.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1402. #endif
  1403.             
  1404.             FillSubstring(this, currentLength, value, startIndex, count);
  1405.             SetLength(currentLength + count);
  1406.             NullTerminate();
  1407.         }
  1409.         internal unsafe void AppendInPlace(char *value, int count,int currentLength) {
  1410.             BCLDebug.Assert(value!=null, "[String.AppendInPlace]value!=null");
  1411.             BCLDebug.Assert(count + currentLength < this.m_arrayLength, "[String.AppendInPlace]count + currentLength < this.m_arrayLength");
  1412.             BCLDebug.Assert(count>=0, "[String.AppendInPlace]count>=0");
  1413. #if _DEBUG
  1414.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1415. #endif
  1416.             fixed(char *p = this.m_firstChar) {
  1417.                 int i;
  1418.                 for (i=0; i<count; i++) {
  1419.                     p[currentLength+i] = value[i];
  1420.                 }
  1421.             }
  1422.             SetLength(currentLength + count);
  1423.             NullTerminate();
  1424.         }
  1427.         ///<internalonly/>
  1428.         internal unsafe void AppendInPlace(char[] value, int start, int count, int currentLength) {
  1429.             BCLDebug.Assert(value!=null, "[String.AppendInPlace]value!=null");
  1430.             BCLDebug.Assert(count + currentLength < this.m_arrayLength, "[String.AppendInPlace]Length is wrong.");
  1431.             BCLDebug.Assert(value.Length-count>=start, "[String.AppendInPlace]value.Length-count>=start");
  1432. #if _DEBUG
  1433.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1434. #endif
  1436.             FillStringArray(this, currentLength, value, start, count);
  1437.             this.m_stringLength = (currentLength + count); 
  1438.             this.NullTerminate();
  1439.         }
  1442.         ///<internalonly/>
  1443.         unsafe internal void ReplaceCharInPlace(char oldChar, char newChar, int startIndex, int count,int currentLength) {
  1444.             BCLDebug.Assert(startIndex>=0, "[String.ReplaceCharInPlace]startIndex>0");
  1445.             BCLDebug.Assert(startIndex<=currentLength, "[String.ReplaceCharInPlace]startIndex>=Length");
  1446.             BCLDebug.Assert((startIndex<=currentLength-count), "[String.ReplaceCharInPlace]count>0 && startIndex<=currentLength-count");
  1447. #if _DEBUG
  1448.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1449. #endif
  1451.             int endIndex = startIndex+count;
  1453.             fixed (char *p = this.m_firstChar) {
  1454.                 for (int i=startIndex;i<endIndex; i++) {
  1455.                     if (p[i]==oldChar) {
  1456.                         p[i]=newChar;
  1457.                     }
  1458.                 }
  1459.             }
  1460.         }
  1463.         ///<internalonly/>
  1464.         internal static String GetStringForStringBuilder(String value, int capacity) {
  1465.             BCLDebug.Assert(value!=null, "[String.GetStringForStringBuilder]value!=null");
  1466.             BCLDebug.Assert(capacity>=value.Length,  "[String.GetStringForStringBuilder]capacity>=value.Length");
  1467.             
  1468.             String newStr = FastAllocateString(capacity);
  1469.             if (value.Length==0) {
  1470.                 newStr.m_stringLength=0;
  1471.                 newStr.m_firstChar='/0';
  1472.                 return newStr;
  1473.             }
  1474.             FillString(newStr, 0, value);
  1475.             newStr.m_stringLength = value.m_stringLength;
  1476.             return newStr;
  1477.         }
  1479.         ///<internalonly/>
  1480.         private unsafe void NullTerminate() {
  1481.             fixed(char *p = this.m_firstChar) {
  1482.                 p[m_stringLength] = '/0';
  1483.             }
  1484.         }
  1486.         ///<internalonly/>
  1487.         unsafe internal void ClearPostNullChar() {
  1488.             int newLength = Length+1;
  1489.             if (newLength<m_arrayLength) {
  1490.                 fixed(char *p = this.m_firstChar) {
  1491.                     p[newLength] = '/0';
  1492.                 }
  1493.             }
  1494.         }
  1496.         ///<internalonly/>
  1497.         internal void SetLength(int newLength) {
  1498.             BCLDebug.Assert(newLength <= m_arrayLength, "newLength<=m_arrayLength");
  1499.             m_stringLength = newLength;
  1500.         }
  1502.         
  1504.         /// <include file='doc/String.uex' path='docs/doc[@for="String.GetEnumerator"]/*' />
  1505.         public CharEnumerator GetEnumerator() {
  1506.             BCLDebug.Perf(false, "Avoid using String's CharEnumerator until C# special cases foreach on String - use the indexed property on String instead.");
  1507.             return new CharEnumerator(this);
  1508.         }
  1510.         /// <include file='doc/String.uex' path='docs/doc[@for="String.IEnumerable.GetEnumerator"]/*' />
  1511.         /// <internalonly/>
  1512.         IEnumerator IEnumerable.GetEnumerator() {
  1513.             BCLDebug.Perf(false, "Avoid using String's CharEnumerator until C# special cases foreach on String - use the indexed property on String instead.");
  1514.             return new CharEnumerator(this);
  1515.         }
  1517.         //
  1518.         // This is just designed to prevent compiler warnings.
  1519.         // This field is used from native, but we need to prevent the compiler warnings.
  1520.         //
  1521. #if _DEBUG
  1522.         private void DontTouchThis() {
  1523.             m_arrayLength = 0;
  1524.             m_stringLength = 0;
  1525.             m_firstChar = m_firstChar;
  1526.         }
  1527. #endif
  1529.         internal unsafe void InternalSetCharNoBoundsCheck(int index, char value) {
  1530.             fixed (char *p = this.m_firstChar) {
  1531.                 p[index] = value;
  1532.             }
  1533.         }
  1535.          // Copies the source String (byte buffer) to the destination IntPtr memory allocated with len bytes.
  1536.         internal unsafe static void InternalCopy(String src, IntPtr dest,int len)
  1537.         {
  1538.             if (len == 0)
  1539.                 return;
  1540.             fixed(char* charPtr = &src.m_firstChar) {
  1541.                 byte* srcPtr = (byte*) charPtr;
  1542.                 byte* dstPtr = (byte*) dest.ToPointer();
  1543.                 System.IO.__UnmanagedMemoryStream.memcpyimpl(srcPtr, dstPtr, len);
  1544.             }
  1545.         }
  1547.         // memcopies characters inside a String. 
  1548.         internal unsafe static void InternalMemCpy(String src, int srcOffset, String dst, int destOffset, int len)
  1549.         { 
  1550.             if (len == 0)
  1551.                 return;
  1552.             fixed(char* srcPtr = &src.m_firstChar) {
  1553.                 fixed(char* dstPtr = &dst.m_firstChar) {
  1554.                     System.IO.__UnmanagedMemoryStream.memcpyimpl((byte*)(srcPtr + srcOffset), (byte*)(dstPtr + destOffset), len);
  1555.                 }
  1556.             }
  1557.         }
  1559.       
  1561.         internal unsafe static void revmemcpyimpl(byte* src, byte* dest, int len) {
  1562.             if (len == 0)
  1563.                 return;
  1565.             dest += len;
  1566.             src += len;
  1567.             
  1568.             if (((long)src & 3) != 0)
  1569.             {
  1570.                 do{
  1571.                     dest--;
  1572.                     src--;
  1573.                     len--;
  1574.                     *dest = *src;
  1575.                 } while (len > 0 && ((long)src & 3) != 0);
  1576.             }
  1577.             
  1578.             if (len >= 16){
  1579.                 len -= 16;
  1580.                 do{
  1581.                     dest -= (byte*)16;
  1582.                     src -= (byte*)16;
  1583.                     ((int*)dest)[3] = ((int*)src)[3];
  1584.                     ((int*)dest)[2] = ((int*)src)[2];
  1585.                     ((int*)dest)[1] = ((int*)src)[1];
  1586.                     ((int*)dest)[0] = ((int*)src)[0];
  1587.                     
  1588.                 } while ((len -= 16) >= 0);
  1589.             }
  1590.             if ((len & 8) > 0) {
  1591.                 dest -= (byte*)8;
  1592.                 src -= (byte*)8;
  1593.                 ((int*)dest)[1] = ((int*)src)[1];
  1594.                 ((int*)dest)[0] = ((int*)src)[0];
  1595.             }
  1596.             if ((len & 4) > 0) {
  1597.                 dest -= (byte*)4;
  1598.                 src -= (byte*)4;
  1599.                 ((int*)dest)[0] = ((int*)src)[0];
  1600.             }
  1601.             if ((len & 2) != 0) {
  1602.                 dest -= (byte*)2;
  1603.                 src -= (byte*)2;
  1604.                 ((short*)dest)[0] = ((short*)src)[0];
  1605.             }
  1606.             if ((len & 1) != 0) {
  1607.                 dest--;
  1608.                 src--;
  1609.                 *dest = *src;
  1610.             }
  1611.         }        
  1616.         // Copies the source String (byte buffer) to the destination IntPtr memory allocated with len bytes.
  1617.         internal unsafe static void InternalCopy(String src, byte[] dest,int len)
  1618.         {
  1619.             if (len == 0)
  1620.                 return;
  1621.             fixed(char* charPtr = &src.m_firstChar) {
  1622.                 fixed(byte* destPtr = dest) {
  1623.                     byte* srcPtr = (byte*) charPtr;
  1624.                     System.IO.__UnmanagedMemoryStream.memcpyimpl(srcPtr, destPtr, len);
  1625.                 }
  1626.             }
  1627.         }
  1629.         internal unsafe void InsertInPlace(int index, String value, int repeatCount, int currentLength, int requiredLength) {
  1630.             BCLDebug.Assert(requiredLength  < m_arrayLength, "[String.InsertString] requiredLength  < m_arrayLength");
  1631.             BCLDebug.Assert(index + value.Length * repeatCount < m_arrayLength, "[String.InsertString] index + value.Length * repeatCount < m_arrayLength");
  1632. #if _DEBUG
  1633.             BCLDebug.Assert(ValidModifiableString(), "Modifiable string must not have highChars flags set");
  1634. #endif
  1635.               //Copy the old characters over to make room and then insert the new characters.
  1636.             fixed(char* srcPtr = this.m_firstChar) {
  1637.                 fixed(char* valuePtr = &value.m_firstChar) {
  1638.                    revmemcpyimpl((byte*)(srcPtr + index),(byte*)(srcPtr + index + value.Length * repeatCount), (currentLength - index) * sizeof(char));
  1639.                    for (int i=0; i<repeatCount; i++) {
  1640.                         System.IO.__UnmanagedMemoryStream.memcpyimpl((byte*)valuePtr, (byte*)(srcPtr + index + i * value.Length), value.Length * sizeof(char));
  1641.                    }
  1642.                 }
  1643.                 srcPtr[requiredLength] = '/0';
  1644.             }
  1645.             this.m_stringLength = requiredLength; 
  1646.         }
  1649.     }
  1650. }
 
StringAPI.java
12-23
Java String 类型 API 测试代码 1.String和char[]之间的转换 toCharArray(); 2.String和byte[]之间的转换 getBytes() Arrays工具类 ： Arrays.toString(names) String类 String replace(char oldChar, ...
delphi 自带 StringReplace 慢， 替换 StringReplace ，高效率，秒杀 原版
09-19
delphi 自带 StringReplace 慢， 替换 StringReplace ，高效率，秒杀 原版
System.String 类的实现代码
永遠的東大 不老的傳說
01-06 2144
// ==++==// //   //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.//   //    The use and distribution terms for this software are contained in the file//    named license.txt, whic
Java基础第七天--Scanner类，String类
u013905744的专栏
03-21 677
API常见对象 String StringBuffer/StringBuilder 字符串缓冲区类 基本数据类型封装类  （如Interger） Math System Runtime Date,DateFormat,Calendar 1. Scanner类：在JDK5以后，用于帮助我们接收键盘录入的数据    Scanner sc = new Scanner(System.in
Js String对象api函数解析
liaohenggang的博客
06-12 525
文章目录String.anchor()函数String.big()函数String.blink()函数String.blod()函数String.charAt()函数String.charCodeAt()函数String.codePointAt()函数String.concat()函数String.endsWith()函数String.fixed()函数String.fontcolor()函数St...
string.CompareOrdinal（效率高），checked(检查溢出)
m0_38110784的博客
03-07 1055
几种比较方法的效率 int num = 10000000; string str1 = "abcdaefvff"; string str2 = "abcdsafsafed"; Stopwatch stopwatch = new Stopwatch(); stopwatch...
Lua之string
qq_22530263的博客
02-04 6539
本文章会慢慢补充整理 文章参考： Lua的string和string库总结：https://www.cnblogs.com/zrtqsk/p/4372889.html lua官方string文档：http://www.lua.org/manual/5.3/manual.html#6.4 Lua的string和string库总结 　　Lua有7种数据类型，分别是nil、boolean、number、string、table、function、userdata。这里我总结一下Lua的string类型.
string类的常用函数（总结）
热门推荐
laity__c的博客
10-07 2万+
string类常用成员函数 (1)求长度 int length(); int size(); //求长度 (2)比较2个字符串 strcmp(s1,s2) == 0 直接用运算符 < > = = != <= >= (3)字符串复制 strcpy(s1,s2); s2->s1 可直接用运算符 = (4)字符串连接 strcat(s1,s2); s1 + s2 -> s1 直接用运算符 + 进行连接 (5)空串判断 bool empty(); //判断是
C语言头文件 STRING.H
06-13
C语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING.HC语言头文件 STRING....
c++中double与string相互转换算法
04-16
本文将详细讨论如何在C++中将`double`类型的数值转换为`std::string`字符串，以及如何将`std::string`转换回`double`。我们将基于提供的`stringtodouble`工程文件进行讨论。 首先，让我们探讨`double`转`string`的...
string_view-standalone:将C ++ 17'string_view'的自定义实现反向移植到c ++ 11
05-06
string_view独立 什么是string_view Standalone？ C ++ 17引入了轻量级的，没有所有权的字符串，称为标准的string_view 。 与std::string不同， std::string为大多数字符串操作（例如substr ）执行内存分配和复制...
javascript 数组总结
weixin_30739595的博客
02-08 421
刚刚结束春节假期，这个春节想了很多，关于未来长远的发展方向也大致明确了。。。 言归正传，下面来总结一下js中数组的用法，以后发现有其他用法也会更新这篇文章。 一：定义 使用Array构造函数 let test1 = new Array();// [] let test2 = new Array(3);// [undefined, undefined] // 使用Array.of方...
javascript数组常用的操作方法
ONEGISER的博客
01-06 527
排序(代码参见) 字符串 //字符串数组 const strArr = ["2020年", "2019年", "2021年", "2018年"]; const newAscStrArr = JSON.parse(JSON.stringify(strArr)).sort((a, b) => { return a.localeCompare(b); }); //升序 console.log(newAscStrArr);//["2018年","2019年","2020年",.
工业自动化领域中步科触摸屏与台达VFD-M变频器通讯实现电机控制功能 - 电机控制
07-29
内容概要：本文档详细介绍了使用步科触摸屏和台达VFD-M变频器实现电机控制功能的技术细节。主要内容涵盖所需的硬件配置（如步科T070触摸屏和支持485功能的USB转485转换头），以及具体的功能实现方法，包括正反转控制、点动停止、频率设定、运行频率读取、电流电压和运行状态的监控。此外，还强调了通讯协议的重要性及其具体实施步骤。 适用人群：从事工业自动化领域的工程师和技术人员，特别是那些负责电机控制系统设计和维护的专业人士。 使用场景及目标：适用于需要集成步科触摸屏与台达VFD-M变频器进行电机控制的应用场合，旨在帮助技术人员掌握正确的硬件选型、安装配置及编程技巧，从而确保系统的稳定性和可靠性。 其他说明：文中提到的操作流程和注意事项有助于避免常见的错误并提高工作效率。同时，提供了详细的通讯说明，确保不同设备之间的兼容性和数据传输的准确性。
langchain4j-community-core-1.0.0-beta4.jar中文-英文对照文档.zip
07-29
1、压缩文件中包含： 中文-英文对照文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
介电弹性体PID DEA模型的参数配置、控制策略与MatlabSimulink建模研究 实战版
07-29
内容概要：本文详细探讨了介电弹性体（DEA）PID控制模型的参数配置、控制策略及其在Matlab/Simulink环境中的建模方法。首先介绍了DEA的基本特性如迟滞和非线性响应，并给出了具体的机械系统参数（如刚度、质量和阻尼）。接着讨论了PID控制器的设计，包括基础的位置式PID实现以及针对实际应用需要加入的抗饱和和滤波措施。对于存在输入延迟的情况，提出了使用Smith预估器的方法，并指出其对模型精度的要求。面对突加负载等扰动，推荐采用串级控制提高系统的稳定性。最后强调了利用Automated PID Tuning工具进行参数调整时应注意的问题。 适合人群：从事智能材料控制系统研究的科研人员和技术开发者。 使用场景及目标：适用于希望深入了解并优化介电弹性体驱动器性能的研究者，在理论学习的基础上掌握具体的操作技能，从而更好地应对实际工程中的挑战。 其他说明：文中提供了详细的MATLAB代码片段用于指导读者构建自己的DEA控制模型，同时分享了许多实践经验，帮助避免常见的错误。
pso_uav.zip
07-29
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
计算机网络试卷(最终).doc
最新发布
07-30
计算机网络试卷(最终).doc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值