String

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. }