C#个人总结，第6章：数组

1. 简单数组

（1）如果需要使用同一类型的多个对象,就可以使用数组。数组是一种数据结构,它可以包含同一类型的多个元素。

1.1 数组的声明

（1）在声明数组时,应先定义数组中元素的类型：int[ ] myArray；

1.2 数组的初始化

（1）myArray=new int [4];或者 int[ ] myArray = new int [4];

1.3 访问数组元素

（1）数组只支持有整型参数的索引器。

1.4 使用引用类型

（1）代码

namespace study6_1_4

{

    public class Person

    {

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public override string ToString()

        {

            return String.Format("{0}  {1}",FirstName,LastName);

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            Person[] myPerson = new Person[2];

            myPerson[0] = new Person { FirstName = "AY", LastName = "Senna" };

            myPerson[1] = new Person { FirstName = "MC", LastName = "SC" };

            foreach (var a in myPerson)

            {

                Console.WriteLine(a.ToString());

            }

        }

    }

}

（2）结果

2. 多维数组

（1）多维数纽用两个或多个整数来索引。

（2）在C#中声明这个二维数组,需要在方括号中加上一个逗号。

3. 锯齿数组

（1）int[] [] jagged= new int[3][]；

4. Array类

（1）用方括号声明数组是C#中使用Array类的表示法。

4.1 创建数组

（1）代码:

namespace study6_4_1

{

    class Program

    {

        static void Main(string[] args)

        {

            Array intArray1 = Array.CreateInstance(typeof(int), 5);

            for (int i = 0; i < 5; i++)

            {

                intArray1.SetValue(33, i);

            }

            for (int i = 0; i < 5; i++)

            {

                Console.WriteLine(intArray1.GetValue(i));

            }

        }

    }

}

结果：

4.2 复制数组

（1）Person[] beatles={new Person{FirstName="John",LastName="Lennon"},

                                   new Person{FirstName="Paul",LastName="McCartney"}};

      Person[] beatlesClone=(Person[])beatles.Clone（）;

（2）除了使用Clone（）方法之外,还可以使用Array.Copy（）方法创建浅表副本。

4.3 排序

（1）Sort（）方法。

5. 数组作为参数

5.1 数组协变

（1）数组支持协变。这表示数组可以声明为基类,其派生类型的元素可以赋予数组元素。

5.2 ArraySegment<T>

（1）结构ArraySegment<T>表示数组的一段。ArraySegment<T>可以只传递一个参数,而不是用3个参数传递:数

组、偏移量和元素个数.

（2）代码：

namespace study6_5

{

    class Program

    {

        static int SumOfSegments(ArraySegment<int>[] segments)

        {

            int sum = 0;

            foreach(var segment in segments)

            {

                for (int i = segment.Offset; i < segment.Offset + segment.Count; i++)

                {

                    sum += segment.Array[i];

                }

            }

            return sum;

        }

        static void Main(string[] args)

        {

            int[] ar1 = { 1, 4, 5, 11, 13, 18 };

            int[] ar2 = { 3, 4, 5, 18, 21, 27, 33 };

            var segments = new ArraySegment<int>[2]

            {

                new ArraySegment<int>(ar1,0,3),

                new ArraySegment<int>(ar2,3,3)

            };

            var sum = SumOfSegments(segments);

            Console.WriteLine(sum);

        }

    }

}

结果：

6. 枚举

6.1 IEnumerator接口

（1）foreach语句使用IEnunmtor接口的方法和属性,迭代集合中的所有元素。为此,IEnunmtoF定义了Current属性,来返回光标所在的元素,该接口的MoveNext（）方法移动到集合的下一个元素上,如果有这个元素,该方法就返回true。如果集合不再有更多的元素,该方法就返回false。这个接口的泛型版本IEnumerator<T>派生自接口IDisposable,因此定义了Dispose（）方法,来清理枚举器占用的资源。

6.2 foreach语句

（1）C#的foreach语句不会解析为IL代码中的foreach语句。C#编译器会把foreach语句转换为IEnmmble接口的方法和属性。下面是一条简单的foreach语句,它迭代Person数组中的所有元素,并逐个显示它们:foreach (var p in persons)

                               {

                                    Console.WriteLine(p);

                               }

（2）foreach语句会解析为下面的代码段。首先,调用GetEnumerator()方法,获得数组的一个枚举器。在while循环中——只要MoveNext（）返回true——就用Current属性访问数组中的元素:IEnumerator<Person> enumerator= persons.GetEnulnerator();

    while (enumerator.MoveNext())

    {

           Person p = enumerator.Current;

           Console.WriteLine(p);

    }

6.3 yield语句

（1）yield return语句返回集合的一个元素,并移动到下一个元素上。yield break可停止迭代。

（2）代码：

namespace study6_6_3

{

    public class HelloCo
4000
llection

    {

        public IEnumerator<string> GetEnumerator()

        {

            yield return "Hello";

            yield return "World";

        }

    }

    class Program

    {

        static  public void Helloword()

        {

            var helloCollection = new HelloCollection();

            foreach (var s in helloCollection)

            {

                Console.WriteLine(s);

            }

        }

        static void Main(string[] args)

        {

            Helloword();

        }

    }

}

结果：

6.3.1 迭代集合的不同方式

（1）代码：

namespace study6_6_3_2

{      

    public class MusicTitles

    {

        string[] names ={

                           "Tubular Bells","Hergest Ridge","Ommadawn","Platinum"

                       };

        public IEnumerator<string> GetEnumerator()

        {

            for (int i = 0; i < 4; i++)

            {

                yield return names[i];

            }

        }

        public IEnumerable<string> Reverse()

        {

            for (int i = 3; i >= 0; i--)

            {

                yield return names[i];

            }

        }

        public IEnumerable<string> Subset(int index,int length)

        {

            for(int i=index;i<index+length;i++)

            {

                yield return names[i];

            }

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            var titles = new MusicTitles();

            foreach(var title in titles)

            {

                Console.WriteLine(titles);

            }

            Console.WriteLine();

            Console.WriteLine("reverse");

            foreach(var title in titles.Reverse())

            {

                Console.WriteLine(title);

            }

            Console.WriteLine();

            Console.WriteLine("subset");

            foreach(var title in titles.Subset(2,2))

            {

                Console.WriteLine(title);

            }

        }

    }

}

结果：

6.3.2 用yield return返回枚举器

7. 元组

（1）数组合并了相同类型的对象,而元组合并了不同类型的对象。

（2）.NET定义了8个泛型Tuple类和一个静态Tuple类,它们用作元组的工厂。