C# 字符串操作，可空类型，文档注释，嵌套类型

字符串

字符串是Unicode字符串数组，且是不可变的

这种操作不会影响到原来的字符串，它会新添加一个副本。

有关Split的操作

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Diagnostics;
namespace ConsoleApp2
{

    class Program
    {

        static void Main(string[] args)
        {
            string s1 = "hi there! this, is: a string.";
            char[] delimiter = { ' ', '!', ',', '.',':' };
            string[] words = s1.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
            foreach (string s in words)
            {
                Console.WriteLine(s);
            }
        }
    }
}

StringBuilder类

StringBuilder类可以帮助你动态，有效的产生字符串，并且避免创建许多副本

StringBuilder类是BCL的成员，位于Syste.Text命名空间中，是Unicode的可变数组

创建了StringBuilder对象之后，类分配一个比当前字符串长度更长的缓冲区，只有缓冲区能容纳对字符串的改变就不会分配内存

如果大于当前的缓存，就会分配更大的缓冲区，把字符串复制其中，和原来的缓冲区区一样。

把字符串解析为数据值

所有的预定义的简单类型都有一个叫做Parse的静态方法，它接受一个表示这个类型的字符串值，并且把它转化为类型的实际值

每一个具有Parse方法的内置类型都有一个TryParse方法

TryParse方法接受两个参数并且返回一个bool值

第一个是希望转化的字符串

第二个是指向目标变量的引用的out参数

如果TryParse成功，返回true，否则返回false

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Diagnostics;
namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            string parseResultSummary;
            string stringFirst = "";
            int intFirst;
            bool success = int.TryParse(stringFirst, out intFirst);
            parseResultSummary = success ? "was successfully pared" : "was not successfully parsed";
            Console.WriteLine("String {0} {1}",stringFirst,parseResultSummary);
            string stringSecond = "vt750";
            int intSecond;
            success = int.TryParse(stringSecond, out intSecond);
            parseResultSummary = success ? "was successfully parsed" : "was not successfully parsed";
            Console.WriteLine("String {0} {1}", stringSecond, parseResultSummary);
        }
    }
}

可空类型

可空类型总是基于另外一个叫做基础类型的已经被声明的类型

• 可以从任何值类型创建可空类型，包括预定义的简单类型
• 不能从引用类型或其它可空类型创建可空类型
• 不能再代码中显示声明可空类型，只能声明可空类型的变量

要创建可空类型的变量，只需要在变量声明中的基础类型的名字后面加一个问号

使用可空类型必须确保变量不是null的，尝试读取一个null的变量会产生异常

• 使用方式一样
• 要检测可空类型是否有值，可以将它和null比较或检查他的hasValue属性

使用空接合运算符

由两个连续的问号组成

使用可空用户自定义类型

struct MyStruct{
        public int x;
        public int y;
        public MyStruct(int xVal,int yVal)
        {
            x = xVal;
            y = yVal;
        }
}

static void Main(string[] args)
{
            MyStruct? mSNull = new MyStruct(, );
            Console.WriteLine(mSNull.Value.x);
}

Nullable<T>

Main方法

前两种形式在程序终止后都不返回值给执行环境，后面的两种返回int，0通常表示成功。

参数 可以有0个或多个，即使没有参数，args参数也不会是null，而是是一个没有元素的数组

文档注释

嵌套类型

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Diagnostics;
namespace ConsoleApp2
{
    class MyClass
    {
        class MyCounter
        {
            public int Count { get; private set; }
            public static MyCounter operator ++(MyCounter current)
            {
                current.Count++;
                return current;
            }
        }
        private MyCounter counter;//嵌套类类型的字段
        public MyClass() { counter = new MyCounter(); }//构造函数
        public int Incr() { return (counter++).Count; }//构造函数
        public int GetValue() { return counter.Count; }//获取计数值
    }
    class Program
    {
        static void Main()
        {
            MyClass mc = new MyClass();
            mc.Incr(); mc.Incr(); mc.Incr();
            mc.Incr(); mc.Incr(); mc.Incr();
            Console.WriteLine(mc.GetValue());
        }
    }
}

• 嵌套类型的成员对封闭类型的成员总是有完全访问权限
• 封闭类型的成员
  • 　　总是可以访问嵌套类型本身
  • 　　只能访问声明了有访问权限的嵌套类型成员

嵌套类型的可见性还会影响基类成员的继承，如果封闭类型是一个派生类，嵌套类型就可以统一使用相同的名字来隐藏成员。可以在嵌套类型的声明上使用new修饰符来显式隐藏。

嵌套类型中的this引用指的是嵌套类型的对象。如果嵌套类型的对象需要访问封闭类型，它必须持有封闭类型的引用。以下代码表示。把封闭对象提供的this引用作为参数传给嵌套类型的构造函数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Diagnostics;
namespace ConsoleApp2
{
    class SomeClass//封闭类
    {
        int Field1 = , Field2 = ;//封闭类的字段
        MyNested mn = null;//嵌套类的引用
        public void PrintMyMembers()
        {
            mn.PrintOuterMembers();//调用嵌套类中的方法
        }
        public SomeClass()//构造函数
        {
            mn = new MyNested(this);//创建嵌套类实例 this给封闭类型传递引用
        }

        class MyNested//嵌套类声明
        {
            SomeClass sc = null;//封闭类的引用
            public MyNested(SomeClass SC)//嵌套类的构造函数
            {
                sc = SC;//存储嵌套类的引用
            }
            public void PrintOuterMembers()
            {
                Console.WriteLine("Field1 : {0}",sc.Field1);//封闭字段
                Console.WriteLine("Field2 : {0}",sc.Field2);//封闭字段
            }
        }
    }
    class Program
    {
        static void Main()
        {
            SomeClass MySC = new SomeClass();
            MySC.PrintMyMembers();
        }
    }
}