C# 学习笔记——数学计算，日期，字符串

一.数学计算 Math

 

namespace System

{

    public static class Math

    {

        public const double E = 271828;

        public const double PI = 314159;

       

        //绝对值

        public static decimal Abs(decimal value);

        public static double Abs(double value);

        public static float Abs(float value);

        public static int Abs(int value);

        public static long Abs(long value);

        public static sbyte Abs(sbyte value);

        public static short Abs(short value);

 

        public static double Sqrt(double d);

        public static double Pow(double x, double y);      //返回指定数字的指定次幂。x^y

 

        public static double Sin(double a);

        public static double Cos(double d);

        public static double Tan(double a);

        public static double Exp(double d);

       

        public static double Acos(double d);

        public static double Asin(double d);

        public static double Atan(double d);

        public static double Atan2(double y, double x);

 

        public static double Cosh(double value);

        public static double Sinh(double value);

        public static double Tanh(double value);

 

        public static double Log(double d);     //返回指定数字在使用指定底时的对数。

        public static double Log(double a, double newBase);          //返回指定数字的自然对数（底为 e）。

        public static double Log10(double d); //返回指定数字以 10 为底的对数。

 

        //返回大于或等于指定的十进制数的最小整数值。

        public static decimal Ceiling(decimal d);

        public static double Ceiling(double a);

 

        //返回小于或等于指定数的最大整数。

        public static decimal Floor(decimal d);

        public static double Floor(double d);

 

        //将小数值舍入到最接近的整数值。Round的舍入方法为“四舍六入无成双”。

        public static decimal Round(decimal d);

        public static double Round(double a);

        public static decimal Round(decimal d, int decimals);

        public static decimal Round(decimal d, MidpointRounding mode);

        public static double Round(double value, int digits);

        public static double Round(double value, MidpointRounding mode);

        public static decimal Round(decimal d, int decimals, MidpointRounding mode);

        public static double Round(double value, int digits, MidpointRounding mode);

 

        public static long BigMul(int a, int b);  //生成两个 32 位数字的完整乘积。

        public static double IEEERemainder(double x, double y); //返回一指定数字被另一指定数字相除的余数。

 

        //计算两个号整数的商，并通过输出参数返回余数。

        public static int DivRem(int a, int b, out int result);

        public static long DivRem(long a, long b, out long result);

 

        public static byte Max(byte val1, byte val2);

        public static decimal Max(decimal val1, decimal val2);

        public static double Max(double val1, double val2);

        public static float Max(float val1, float val2);

        public static int Max(int val1, int val2);

        public static long Max(long val1, long val2);

        public static sbyte Max(sbyte val1, sbyte val2);

        public static short Max(short val1, short val2);

        public static uint Max(uint val1, uint val2);

        public static ulong Max(ulong val1, ulong val2);

        public static ushort Max(ushort val1, ushort val2);

 

        public static byte Min(byte val1, byte val2);

        public static decimal Min(decimal val1, decimal val2);

        public static double Min(double val1, double val2);

        public static float Min(float val1, float val2);

        public static int Min(int val1, int val2);

        public static long Min(long val1, long val2);

        public static sbyte Min(sbyte val1, sbyte val2);

        public static short Min(short val1, short val2);

        public static uint Min(uint val1, uint val2);

        public static ulong Min(ulong val1, ulong val2);

        public static ushort Min(ushort val1, ushort val2);

 

        //返回表示数字符号的值。

        public static int Sign(decimal value);

        public static int Sign(double value);

        public static int Sign(float value);

        public static int Sign(int value);

        public static int Sign(long value);

        public static int Sign(sbyte value);

        public static int Sign(short value);

 

        //计算指定数的整数部分。

        public static decimal Truncate(decimal d);

        public static double Truncate(double d);

    }

}

 

 

 

二. 随机数 Random

Random类提供了产生伪随机数的方法。随机数的生成是从种子值开始的。如果使用同一种子，就会产生相同的数字系列。产生不同序列的一种方法是使种子值与时间相关，从而对于Random的每个新实例都会产生不同的系列。默认情况下，Random类的无参数构造函数使用系统时钟生成其种子值。

 

Random myRandom=new Random();

 

 

namespace System

{

    public class Random

    {

        public Random();        //使用与时间相关的默认种子值，初始化 Random 类的新实例。

        public Random(int Seed);   //使用指定的种子值初始化 Random 类的新实例。

 

        public virtual int Next();      //返回非负随机数。

        public virtual int Next(int maxValue);          //返回一个小于所指定最大值的非负随机数。

        public virtual int Next(int minValue, int maxValue);   //返回一个指定范围内的随机数。

        public virtual void NextBytes(byte buffer);          //

        public virtual double NextDouble();    //

        protected virtual double Sample();      //返回一个介于 00 和 10 之间的随机数。

    }

}

 

三.时间DateTime

DateTime 值类型表示值范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和（公元）。

时间值以 100 纳秒为单位（该单位称为计时周期）进行计量，而特定日期（C.E.）在 GregorianCalendar 日历中（不包括闰秒将添加的时钟周期) 。

例如，计时周期值 31241376000000000L 表示 0100 年 1 月 1 日（星期五）午夜 12:00:00。 DateTime 值始终在显式或默认日历的上下文中表示。

 

 

namespace System

{

   

    public struct DateTime : IComparable, IFormattable, IConvertible, ISerializable, IComparable<DateTime>, IEquatable<DateTime>

    {

        public static readonly DateTime MaxValue;

        public static readonly DateTime MinValue;

 

        public DateTime(long ticks);                // 实例初始化为指定的刻度数。

        public DateTime(long ticks, DateTimeKind kind);       //实例初始化为指定的计时周期数以及协调世界时 (UTC) 或本地时间。

        public DateTime(int year, int month, int day);     //实例初始化为指定的年、月、日、时、分、秒、毫秒。

        public DateTime(int year, int month, int day, Calendar calendar);

        public DateTime(int year, int month, int day, int hour, int minute, int second);

        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond);

        public DateTime(int year, int month, int day, int hour, int minute, int second, Calendar calendar);     //实例初始化为指定日历的指定年、月、日、时、分、秒、毫秒和协调世界时 (UTC) 或本地时间。

        public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);

        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar);

        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind);

        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind);

        //参数：

        //ticks：以 100 纳秒为单位表示的日期和时间。

        //kind：枚举值之一，该值指示 ticks 是指定了本地时间、协调世界时 (UTC)，还是两者皆未指定。

        //calendar：用于解释 year、month 和 day 的日历。

        //year：年（1 到 calendar 中的年数）。

        //month：月（1 到 calendar 中的月数）。

        //day：日（1 到 month 中的天数）。

        //hour：小时（0 到 23）。

        //minute：分（0 到 59）。

        //second：秒（0 到 59）。

        //millisecond：毫秒（0 到 999）。

 

 

        //使用符号操作DateTime值对象。

        public static TimeSpan operator -(DateTime d1, DateTime d2); //时刻相减得到时间间隔。

        public static DateTime operator -(DateTime d, TimeSpan t);       //时刻减去时间间隔得到时刻。

        public static DateTime operator +(DateTime d, TimeSpan t);      //时刻加上时间间隔得到时刻。

        public static bool operator <(DateTime t1, DateTime t2);

        public static bool operator <=(DateTime t1, DateTime t2);

        public static bool operator ==(DateTime d1, DateTime d2);

        public static bool operator !=(DateTime d1, DateTime d2);

        public static bool operator >(DateTime t1, DateTime t2);

        public static bool operator >=(DateTime t1, DateTime t2);

       

        //DateTime的属性。DateTime所有类型均为只读属性。

        public static DateTime Now { get; }

        public static DateTime Today { get; } //获取当前日期。返回值的日期部分与当天日期相同，时间组成部分设置为 00：00：00。

        public static DateTime UtcNow { get; }       //获取此计算机上的当前日期和时间，表示为协调世界时 (UTC)。返回值为当前 UTC 日期和时间。

       

        public int DayOfYear { get; }      //获取此实例所表示的日期是该年中的第几天。

        public DayOfWeek DayOfWeek { get; }     //获取此实例所表示的日期是星期几。

       

        public DateTimeKind Kind { get; }     //获取一个值，该值指示由此实例表示的时间是基于本地时间、协调世界时 (UTC)，还是两者皆否。返回结果是System.DateTimeKind 值之一。默认值为 System.DateTimeKind.Unspecified。

       

        public long Ticks { get; }     //获取表示此实例的日期和时间的计时周期数。

 

        public int Year { get; }         //获取此实例所表示日期的年份部分。年份（1 ～ 9999）。

        public int Month { get; }      //获取此实例所表示日期的月份部分。月份（1 ～ 12）。

        public int Day { get; } //获取此实例所表示的日期为该月中的第几天。日组（1 ～ 31）。

        public int Hour { get; }         //获取此实例所表示日期的小时部分。小时（ 0 ～ 23）。

        public int Minute { get; }     //获取此实例所表示日期的分钟部分。分钟（0 ～ 59）。

        public int Second { get; }     //获取此实例所表示日期的秒部分。秒数（0 ～ 59）。

        public int Millisecond { get; }       // 获取此实例所表示日期的毫秒部分。毫秒（0 ～ 999）。

 

        public DateTime Date { get; }     //获取此实例的日期部分。得到DateTime对象的日期与当前实例相同，时间值设置为午夜 12：00：00 (00：00：00)。

        public TimeSpan TimeOfDay { get; } /获取此实例的当天的时间。表示当天自午夜以来已经过时间的部分。

 

        public static int DaysInMonth(int year, int month);     //返回指定月的天数。

        public static bool IsLeapYear(int year);       //判断年份是否为闰年。

        public bool IsDaylightSavingTime();   //判断时间是否在当前时区的夏时制范围内。

 

        //当前DateTime值对象加上一段时间。

        public DateTime Add(TimeSpan value);

        public DateTime AddDays(double value);

        public DateTime AddHours(double value);

        public DateTime AddMilliseconds(double value);

        public DateTime AddMinutes(double value);

        public DateTime AddMonths(int months);

        public DateTime AddSeconds(double value);

        public DateTime AddTicks(long value);

        public DateTime AddYears(int value);

        //对时间作减法。

        public TimeSpan Subtract(DateTime value);

        public DateTime Subtract(TimeSpan value);

 

        //比较时间。

        public static int Compare(DateTime t1, DateTime t2);         //比较t1，t2。返回值小于0，则t1早于t2；等于0，t1=t2；大于0，t1晚于t2。

        public int CompareTo(DateTime value);     //将实例值与参数值比较。返回值小于0，则实例早于参数；等于0，实例=参数；大于0，实例晚于参数。

        public int CompareTo(object value);

 

        //时间是否相等。

        public bool Equals(DateTime value);

        public override bool Equals(object value);

        public static bool Equals(DateTime t1, DateTime t2);

 

        public string[] GetDateTimeFormats();         //将此实例的值转换为标准 System.DateTime 格式说明符支持的所有字符串表示形式。

        public string[] GetDateTimeFormats(char format);

        public string[] GetDateTimeFormats(IFormatProvider provider);

        public string[] GetDateTimeFormats(char format, IFormatProvider provider);

       

        public override int GetHashCode();

        public TypeCode GetTypeCode();

 

        public static DateTime SpecifyKind(DateTime value, DateTimeKind kind);       //创建新的DateTime对象，该对象与参数有相同的刻度数，但是根据指定的 DateTimeKind值的指示，指定为本地时间或协调世界时 (UTC)，或者两者皆否。

       

        public static DateTime FromBinary(long dateData);   //反序列化一个 64 位二进制值，并重新创建序列化的 System.DateTime 初始对象。

        public static DateTime FromFileTime(long fileTime); //将指定的 Windows 文件时间转换为等效的本地时间。

        public static DateTime FromFileTimeUtc(long fileTime);    //将指定的 Windows 文件时间转换为等效的 UTC 时间。

        public static DateTime FromOADate(double d); //返回与指定的 OLE 自动化日期等效的 System.DateTime。

       

        public long ToBinary();

        public long ToFileTime();

        public long ToFileTimeUtc();

        public DateTime ToLocalTime();

        public double ToOADate();

 

        public override string ToString();

        public string ToString(string format);

        public string ToString(IFormatProvider provider);

        public string ToString(string format, IFormatProvider provider);

       

        public string ToLongDateString();

        public string ToLongTimeString();

        public string ToShortDateString();

        public string ToShortTimeString();

        public DateTime ToUniversalTime();

 

        public static DateTime Parse(string s);          //将日期和时间的指导字符串表示形式转换为契等效的DateTime。

        public static DateTime Parse(string s, IFormatProvider provider);

        public static DateTime Parse(string s, IFormatProvider provider, DateTimeStyles styles);

        public static DateTime ParseExact(string s, string format, IFormatProvider provider);

        public static DateTime ParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style);

        public static DateTime ParseExact(string s, string formats, IFormatProvider provider, DateTimeStyles style);

 

        public static bool TryParse(string s, out DateTime result);    //将日期和时间的指定字符串表示形式转换为其等效的DateTime。

        public static bool TryParse(string s, IFormatProvider provider, DateTimeStyles styles, out DateTime result);

        public static bool TryParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style, out DateTime result);

        public static bool TryParseExact(string s, string formats, IFormatProvider provider, DateTimeStyles style, out DateTime result);

    }

}

 

 

 

 

四. 字符串String

C#字符串是uniode字符的有序集合，Unicode使用UTF-16进行编码，编码的每个元素的数值都用一个System.Char对象表示。

C#使用string关键字声明的一个字符数组。字符串是使用引号声明的。

例：string s = "Hello World";

 

字符串中可以包含转义符，如"\n"，"\t"。如果希望包含反斜杠，则用"\\"表示。

带@符号（原义字符串）时，字符串构造函数将忽略转义符和分行符。在原义字符串中，用""（连个双引号）表示一个双引号。

例：

string s1="\\Hello"; 表示\Hello

string s2=@"\\Hello"; 表示\\Hellp

string s3=@"\\""Hello"; 表示\\"Hello

 

String对象是不可变的。一旦创建了该对象，就不能修改该对象的值。

 

namespace System

{

 

    public sealed class String : IComparable, ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, IEnumerable, IEquatable<string>

    {

        public static readonly string Empty;    //表示空字符串。此字段为只读。

 

        public String(char* value);

        public String(char[] value);

        public String(sbyte* value);

        public String(char c, int count);

        public String(char* value, int startIndex, int length);

        public String(char[] value, int startIndex, int length);

        public String(sbyte* value, int startIndex, int length);

        public String(sbyte* value, int startIndex, int length, Encoding enc);

 

        public static bool operator !=(string a, string b);   //确定两个指定的字符串是否具有不同的值。

        public static bool operator ==(string a, string b);  ////确定两个指定的字符串是否具有相同的值。

 

        public int Length { get; }     //获取字符长度。

 

        public char this[int index] { get; }         //获取当前 String 对象中位于指定字符位置的字符。

 

        public object Clone(); //返回对此 String 实例的引用。

 

        public static int Compare(string strA, string strB);

        public static int Compare(string strA, string strB, bool ignoreCase);

        public static int Compare(string strA, string strB, StringComparison comparisonType);

        public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo culture);

        public static int Compare(string strA, string strB, CultureInfo culture, CompareOptions options);

        public static int Compare(string strA, int indexA, string strB, int indexB, int length);

        public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase);

        public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType);

        public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, CultureInfo culture);

        public static int Compare(string strA, int indexA, string strB, int indexB, int length, CultureInfo culture, CompareOptions options);

        public static int CompareOrdinal(string strA, string strB);

        public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int length);

        public int CompareTo(object value);

        public int CompareTo(string strB);

 

        public override bool Equals(object obj);      //确定两个字符串是否具有相同的值。

        public bool Equals(string value);

        public static bool Equals(string a, string b);

        public bool Equals(string value, StringComparison comparisonType);

        public static bool Equals(string a, string b, StringComparison comparisonType);

 

        //连接String的一个或多个实例。

        public static string Concat(IEnumerable<string> values);

        public static string Concat<T>(IEnumerable<T> values);

        public static string Concat(object arg0);

        public static string Concat(params object[] args);

        public static string Concat(params string[] values);

        public static string Concat(object arg0, object arg1);

        public static string Concat(string str0, string str1);

        public static string Concat(object arg0, object arg1, object arg2);

        public static string Concat(string str0, string str1, string str2);

        public static string Concat(object arg0, object arg1, object arg2, object arg3);

        public static string Concat(string str0, string str1, string str2, string str3);

       

        public string Insert(int startIndex, string value);   //在字符串的指定索引位置插入指定的字符串。

        public bool Contains(string value);      //判断子串是否出现在字符串中。

        public static string Copy(string str);      //创建一个与源字符串具有相同值的String实例。

        public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count);   //将指定数目的字符串指定位置复制到Unicode字符数组中的指定位置。

 

        //将指定String中的每个格式项替换为相应对象值的文本等效项。

        public static string Format(string format, object arg0);

        public static string Format(string format, params object[] args);

        public static string Format(IFormatProvider provider, string format, params object[] args);

        public static string Format(string format, object arg0, object arg1);

        public static string Format(string format, object arg0, object arg1, object arg2);

 

        public CharEnumerator GetEnumerator();

        public override int GetHashCode();

        public TypeCode GetTypeCode();

 

        //查找字符或字符串在字符串中第一个匹配项的所有位置（索引从0开始）。

        public int IndexOf(char value);

        public int IndexOf(string value);

        public int IndexOf(char value, int startIndex);

        public int IndexOf(string value, int startIndex);

        public int IndexOf(string value, StringComparison comparisonType);

        public int IndexOf(char value, int startIndex, int count);

        public int IndexOf(string value, int startIndex, int count);

        public int IndexOf(string value, int startIndex, StringComparison comparisonType);

        public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType);

 

        //查找指定字符或字符串在字符串中的最后一个匹配的索引位置（从最后一个字符位置或者指定的字符位置开始，从后向前查找）。

        public int LastIndexOf(char value);

        public int LastIndexOf(string value);

        public int LastIndexOf(char value, int startIndex);

        public int LastIndexOf(string value, int startIndex);

        public int LastIndexOf(string value, StringComparison comparisonType);

        public int LastIndexOf(char value, int startIndex, int count);

        public int LastIndexOf(string value, int startIndex, int count);

        public int LastIndexOf(string value, int startIndex, StringComparison comparisonType);

        public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType);

        public int LastIndexOfAny(char[] anyOf);

        public int LastIndexOfAny(char[] anyOf, int startIndex);

        public int LastIndexOfAny(char[] anyOf, int startIndex, int count);

 

        public int IndexOfAny(char[] anyOf);

        public int IndexOfAny(char[] anyOf, int startIndex);

        public int IndexOfAny(char[] anyOf, int startIndex, int count);

 

        public static string Intern(string str);

        public static string IsInterned(string str);

        public bool IsNormalized();

        public bool IsNormalized(NormalizationForm normalizationForm);

        public static bool IsNullOrEmpty(string value);

        public static bool IsNullOrWhiteSpace(string value);

        public static string Join(string separator, IEnumerable<string> values);

        public static string Join<T>(string separator, IEnumerable<T> values);

        public static string Join(string separator, params object[] values);

        public static string Join(string separator, params string[] value);

        public static string Join(string separator, string[] value, int startIndex, int count);

 

        public string Normalize();

        public string Normalize(NormalizationForm normalizationForm);

 

        //右对齐此实例中的字符，在左边用空格或指定的字符填充以达到指定的总长度。

        public string PadLeft(int totalWidth);

        public string PadLeft(int totalWidth, char paddingChar);

 

        //左对齐此实例中的字符，在右边用空格或指定的字符填充以达到指定的总长度。

        public string PadRight(int totalWidth);

        public string PadRight(int totalWidth, char paddingChar);

 

        //删除字符串中从指定启始位置到最后索引位置的所有字符；或者从字符串指定索引位置开始删除指定数目的字符。

        public string Remove(int startIndex);

        public string Remove(int startIndex, int count);

 

        //将字符串中指定Unicode字符或子串的所有匹配项替换为其他指定的Unicode字符或子串。

        public string Replace(char oldChar, char newChar);

        public string Replace(string oldValue, string newValue);

 

        //返回字符串数组包含此实例中的子字符串（由指定字符串或Unicode字符数组的元素分隔）。

        public string[] Split(params char[] separator);

        public string[] Split(char[] separator, int count);

        public string[] Split(char[] separator, StringSplitOptions options);

        public string[] Split(string[] separator, StringSplitOptions options);

        public string[] Split(char[] separator, int count, StringSplitOptions options);

        public string[] Split(string[] separator, int count, StringSplitOptions options);

 

        //确定String实例的开头是否与指定的字符串匹配。

        public bool StartsWith(string value);

        public bool StartsWith(string value, StringComparison comparisonType);

        public bool StartsWith(string value, bool ignoreCase, CultureInfo culture);

 

        public bool EndsWith(string value);

        public bool EndsWith(string value, StringComparison comparisonType);

        public bool EndsWith(string value, bool ignoreCase, CultureInfo culture);

 

        //截取子字符串。

        public string Substring(int startIndex);

        public string Substring(int startIndex, int length);

       

        //将字符串复制到字符数组。

        public char[] ToCharArray();

        public char[] ToCharArray(int startIndex, int length);

       

 

        public string ToLower();      //字符串转换为小写。

        public string ToLower(CultureInfo culture);

        public string ToLowerInvariant();

       

        public string ToUpper();       //字符串转换为大写。

        public string ToUpper(CultureInfo culture);

        public string ToUpperInvariant();

 

        public string Trim();     //删除字符串前后所有的空格。

        public string Trim(params char[] trimChars);

        public string TrimEnd(params char[] trimChars);         //从当前String对象移除数组中指定的一组字符的所有尾部匹配项。

        public string TrimStart(params char[] trimChars);        ////从当前String对象移除数组中指定的一组字符的所有前导匹配项。

 

        public override string ToString();

        public string ToString(IFormatProvider provider);

    }

}

 

 

 

五. StringBuilder

 

namespace System.Text

{

    public sealed class StringBuilder : ISerializable

    {

        public StringBuilder();

        public StringBuilder(int capacity);       //指定初始化容量。

        public StringBuilder(string value);

        public StringBuilder(int capacity, int maxCapacity);

        public StringBuilder(string value, int capacity);

        public StringBuilder(string value, int startIndex, int length, int capacity);

 

        public int Capacity { get; set; }

        public int Length { get; set; }

        public int MaxCapacity { get; }

 

        public char this[int index] { get; set; }

 

        //追加

        public StringBuilder Append(bool value);

        public StringBuilder Append(byte value);

        public StringBuilder Append(char value);

        public StringBuilder Append(char[] value);

        public StringBuilder Append(decimal value);

        public StringBuilder Append(double value);

        public StringBuilder Append(float value);

        public StringBuilder Append(int value);

        public StringBuilder Append(long value);

        public StringBuilder Append(object value);

        public StringBuilder Append(sbyte value);

        public StringBuilder Append(short value);

        public StringBuilder Append(string value);

        public StringBuilder Append(uint value);

        public StringBuilder Append(ulong value);

        public StringBuilder Append(ushort value);

        public StringBuilder Append(char value, int repeatCount); //实例追加repeatCount次的value字符。

        public StringBuilder Append(char[] value, int startIndex, int charCount);    //value为字符数组，

        public StringBuilder Append(string value, int startIndex, int count);    //在StringBuilder实例的结尾部分追加指定子字符串的副本。

 

        public StringBuilder AppendFormat(string format, object arg0);

        public StringBuilder AppendFormat(string format, params object args);

        public StringBuilder AppendFormat(IFormatProvider provider, string format, params object args);

        public StringBuilder AppendFormat(string format, object arg0, object arg1);

        public StringBuilder AppendFormat(string format, object arg0, object arg1, object arg2);

 

        public StringBuilder AppendLine();

        public StringBuilder AppendLine(string value);

 

        public StringBuilder Clear();

        public void CopyTo(int sourceIndex, char destination, int destinationIndex, int count);

        public int EnsureCapacity(int capacity);

        public bool Equals(StringBuilder sb);

 

        public StringBuilder Insert(int index, bool value);

        public StringBuilder Insert(int index, byte value);

        public StringBuilder Insert(int index, char value);

        public StringBuilder Insert(int index, char value);

        public StringBuilder Insert(int index, decimal value);

        public StringBuilder Insert(int index, double value);

        public StringBuilder Insert(int index, float value);

        public StringBuilder Insert(int index, int value);

        public StringBuilder Insert(int index, long value);

        public StringBuilder Insert(int index, object value);

        public StringBuilder Insert(int index, sbyte value);

        public StringBuilder Insert(int index, short value);

        public StringBuilder Insert(int index, string value);

        public StringBuilder Insert(int index, uint value);

        public StringBuilder Insert(int index, ulong value);

        public StringBuilder Insert(int index, ushort value);

        public StringBuilder Insert(int index, string value, int count);

        public StringBuilder Insert(int index, char value, int startIndex, int charCount);

 

        public StringBuilder Remove(int startIndex, int length);

 

        public StringBuilder Replace(char oldChar, char newChar);

        public StringBuilder Replace(string oldValue, string newValue);

        public StringBuilder Replace(char oldChar, char newChar, int startIndex, int count);

        public StringBuilder Replace(string oldValue, string newValue, int startIndex, int count);

 

        public override string ToString();

        public string ToString(int startIndex, int length);

 

    }

}