override public void SetCapacity(int capacity) {
     SqlChars[] newValues = new SqlChars[capacity];
     if (null != values) {
         Array.Copy(values, 0, newValues, 0, Math.Min(capacity, values.Length));
     }
     values = newValues;
 }

 public static void FillMatch(object obj, out int index, out int length, out SqlChars value)
     {
     Match match = (Match)obj;
     index = match.Index;
     length = match.Length;
     value = new SqlChars(match.Value);
     }

 public static SqlChars ConvertToPinyin(SqlChars input)
 {
     if (input.IsNull)
         return input;
     var str = new string(input.Value);
     return new SqlChars(StringConverter.GetChineseSpell(str));
 }

 public static SqlChars RegexGroup( SqlChars input, SqlString pattern, SqlString name )
 {
     Regex regex = new Regex( pattern.Value, Options );
       Match match = regex.Match( new string( input.Value ) );
       return match.Success ?
         new SqlChars( match.Groups[name.Value].Value ) : SqlChars.Null;
 }

    public static SqlString RegexReplace(SqlChars input, SqlString pattern, SqlChars replacement)
    {
        Regex regex = new Regex(pattern.Value, Options);

        return regex.Replace(new string(input.Value),new string(replacement.Value));
        ///return regex.IsMatch(new string(input.Value)); ///The SQL datatype here is a BIT
    }

 public static void FillMatchRow( object data,
    out SqlInt32 index, out SqlChars text )
 {
     MatchNode node = (MatchNode)data;
       index = new SqlInt32( node.Index );
       text = new SqlChars( node.Value.ToCharArray( ) );
 }

		public void SqlCharsItem ()
		{
			SqlChars chars = new SqlChars ();
			try {
				Assert.AreEqual (chars [0], 0, "#1 Should throw SqlNullValueException");
				Assert.Fail ("Should throw SqlNullValueException");
			} catch (Exception ex) {
				Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "Should throw SqlNullValueException");
			}
			char [] b = null;
			chars = new SqlChars (b);
			try {
				Assert.AreEqual (chars [0], 0, "#2 Should throw SqlNullValueException");
				Assert.Fail ("Should throw SqlNullValueException");
			} catch (Exception ex) {
				Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "Should throw SqlNullValueException");
			}
			b = new char [10];
			chars = new SqlChars (b);
			Assert.AreEqual (chars [0], 0, "");
			try {
				Assert.AreEqual (chars [-1], 0, "");
				Assert.Fail ("Should throw ArgumentOutOfRangeException");
			} catch (Exception ex) {
				Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "Should throw ArgumentOutOfRangeException");
			}
			try {
				Assert.AreEqual (chars [10], 0, "");
				Assert.Fail ("Should throw ArgumentOutOfRangeException");
			} catch (Exception ex) {
				Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "Should throw ArgumentOutOfRangeException");
			}
		}

 internal static SqlString TrimEnd(SqlString src, SqlChars des)
 {
     if (IsAllNull(des)) return src;
     if (IsAllNull(src)) return SqlString.Null;
     string _s = src.Value;
     return new SqlString(_s.TrimEnd(des.Value));
 }

 public static void FillRow(Object obj, out SqlDateTime timeWritten, out SqlChars message, out SqlChars category, out long instanceId)
 {
     EventLogEntry eventLogEntry = (EventLogEntry)obj;
     timeWritten = new SqlDateTime(eventLogEntry.TimeWritten);
     message = new SqlChars(eventLogEntry.Message);
     category = new SqlChars(eventLogEntry.Category);
     instanceId = eventLogEntry.InstanceId;
 }

 public static void FillGroupRow( object data,
    out SqlInt32 index, out SqlChars group, out SqlChars text )
 {
     GroupNode node = (GroupNode)data;
       index = new SqlInt32( node.Index );
       group = new SqlChars( node.Name.ToCharArray( ) );
       text = new SqlChars( node.Value.ToCharArray( ) );
 }

 /// <summary>
 /// FillRow method to populate the output table
 /// </summary>
 /// <param name=”obj”>RegExRow passed as object</param>
 /// <param name=”rowId”>ID or the returned row</param>
 /// <param name=”matchId”>ID of returned Match</param>
 /// <param name=”groupID”>ID of group in the Match</param>
 /// <param name=”value”>Value of the Group</param>
 public static void FillRegExRow( Object obj, out int rowId, out int matchId, out int groupID, out SqlChars value )
 {
     RegExRow r = (RegExRow)obj;
     rowId = r.RowId;
     matchId = r.MatchId;
     groupID = r.GroupID;
     value = new SqlChars( r.Value );
 }

 public static void FillAdjustedPrice(Object obj, out SqlInt32 itemId, out SqlMoney adjustedPrice, out SqlMoney averagePrice, out SqlChars itemName)
 {
     CCPDatum Item = (CCPDatum)obj;
     itemId = new SqlInt32(Item.item_id);
     adjustedPrice = new SqlMoney(Item.adjustedPrice);
     averagePrice = Item.averagePrice.HasValue ? new SqlMoney(Item.averagePrice.Value) : SqlMoney.Null;
     itemName = new SqlChars(Item.item_name);
 }

    public static SqlChars ConvertToTraditionalChinese(SqlChars input)
    {
        if (input.IsNull)
            return input;

        var str = new string(input.Value);
        // 在此处放置代码
        return new SqlChars(Strings.StrConv(str, VbStrConv.TraditionalChinese, 0));
    }

    public static SqlChars ConvertToProperCase(SqlChars input)
    {
        if (input.IsNull)
            return input;

        var str = new string(input.Value);
        // 在此处放置代码
        return new SqlChars(Strings.StrConv(str, VbStrConv.ProperCase, 0));
    }

 internal static SqlString TrimStartAndEnd(SqlString src, SqlChars startDes, SqlChars endDes)
 {
     if (IsAllNull(startDes, endDes)) return src;
     if (IsAllNull(src)) return SqlString.Null;
     string _s = src.Value;
     if (!endDes.IsNull) _s = _s.TrimEnd(endDes.Value);
     if (!startDes.IsNull) _s = _s.TrimStart(startDes.Value);
     return new SqlString(_s);
 }

 /// <summary>
 /// 把每个值进行累加
 /// </summary>
 /// <param name="value"></param>
 public void Accumulate(SqlChars value, SqlString connector)
 {
     if (value.IsNull)
         return;
     if (splitterLength == 0)
         splitterLength = (connector.IsNull ? "," : connector.Value).Length;
     // 在此处放置代码
     result.Append(value.Value).Append(connector.IsNull ? "," : connector.Value);
 }

 public static SqlString RegexReplaceRecursive(SqlChars input, SqlString pattern, SqlChars replacement)
 {
     string output = new string( input.Value );
     Regex regex = new Regex(pattern.Value, Options);
     while (regex.IsMatch( output ))
     {
         output = regex.Replace(output, new string(replacement.Value));
     }
     return output;
 }

 public static SqlBoolean ContainsAny(SqlChars input, string search)
 {
     string strTemp = new string(input.Value);
     foreach (string item in search.Split(','))
     {
         if (strTemp.Contains(item))
         {
             return true;
         }
     }
     return false;
 }

    public static SqlString ToSafeFileNameWith(SqlString text, SqlChars substitution)
    {
        if (text.IsNull || String.IsNullOrWhiteSpace(text.Value)) return SqlString.Null;

        var textValue = text.Value.Trim();

        var substitutionChar = substitution.Value[0];

        var fileName = Path.GetInvalidFileNameChars().Aggregate(textValue, (current, c) => current.Replace(c, substitutionChar));

        return new SqlString(fileName, text.LCID);
    }

    public static SqlChars PadRight(SqlChars input, SqlInt32 totalWidth, char paddingChar)
    {
        if (input.IsNull)
            return input;

        if (paddingChar == (char)0)
            return input;

        if (totalWidth.IsNull || totalWidth < 0)
            totalWidth = 0;

        // 在此处放置代码
        return new SqlChars(new string(input.Value).PadRight(totalWidth.Value, paddingChar));
    }