C#学习日记 列表List<T>

using System;
using System.Collections.Generic;

namespace Sample
{
	public class MainEntryPoint
	{
		static int Main(string[] args)
		{
			//各种在列表里添加元素的方法
			var july = new Racer(3, "July", "Wu", "China", 14);
			var john = new Racer(5, "John", "Wu", "China", 14);
			var mario = new Racer(16, "Mario", "Andretti", "USA", 12);
			var racers = new List<Racer>(20){july, john, mario};
			racers.Add(new Racer(14, "Niki", "Lauda", "Austria", 25));
			racers.AddRange(new Racer[]
				{
					new Racer(12, "Jochen", "Rindt","Austria", 6),
					new Racer(22, "Ayrton", "Senna", "Brazil", 41),
				}
				);
			racers.Insert(3,new Racer(14,"Joyn","Wu","China",3));

			//ForEach方法括号中应该放方法地址或者lambda表达式
			//public delegate void Action<T>(T obj)没有返回值 参数是T类型的lambda

			//racers.ForEach(r => Console.WriteLine("{0:A}",r));
			/*for(int i = 0; i < racers.Count; i++)
			{
				Console.WriteLine("{0:W}",racers[i]);
			}*/

			//两种移除的方法 第一种是根据索引的位置 一种是根据元素对象 第二种实际上还是第一种因为第二种会先用IndexOf（）方法寻找元素的索引
			
			/*racers.RemoveAt(3);
			if(!racers.Remove(july))
				Console.WriteLine("object not found in collection.");
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:F}", r);
			}*/
			
			//运用自己写的类寻找符合国家相同的第一个元素的索引
			//这个类中有一个参数存储国家信息
			//还有一个方法匹配该对象的国家是否一致的方法返回布尔类型

			/*int index1 = racers.FindIndex((new FindCountry("China")).FindCountryPredicate);
			Console.WriteLine(index1);

			//也可以写lambda表带式进行匹配
			//public delegate bool Predicate<T>(T obj)返回值为布尔类型 参数为T类型
			int index2 = racers.FindIndex(r => r.Country == "China");
			int index3 = racers.FindIndex(r => r.LastName == "Wu");
			Console.WriteLine(index2);
			Console.WriteLine(index3);
			
			//找到符合条件的所有项 返回一个集合
			//前面的方法都是返回匹配的第一项就不再搜索了

			List<Racer> bigWinners = racers.FindAll(r => r.Wins > 20);
			foreach(Racer r in bigWinners)
			{
				Console.WriteLine("{0:A}",r);
			}*/

			//实现了IComparebale<Racer>接口 会自动的调用CompareTo（）方法进行排序
			/*racers.Sort();
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:A}",r);
			}
			Console.WriteLine("-------------------");

			//public delegate int Comparison<T>(T x, T y)返回值是int 有两个类型为T的参数

			racers.Sort((r1, r2) => r1.Wins.CompareTo(r2.Wins));
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:W}",r);
			}

			//Sort（）方法里传递一个实现了IComparer接口的类的实例
			//根据传递进来的比较类型 进行比较 排序

			Console.WriteLine("-------------------");
			racers.Sort(new RacerComparer(RacerComparer.CompareType.Country));
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:A}",r);
			}
			Console.WriteLine("-------------------");*/

			//一个集合往另一个集合进行转换
			//public sealed delegate Toutput Convert<Tinput, Toutput>(Tinput from);

			List<Person> persons = racers.ConvertAll<Person>(r => new Person(r.FirstName+" "+r.LastName));
			foreach(Person p in persons)
			{
				Console.WriteLine(p);
			}
			return 0;
		}
	}
	[Serializable]
	public class Person
	{
		private string name;
		public Person(string name)
		{
			this.name = name;
		}
		public override string ToString()
		{
			return name;
		}
	}
	[Serializable]
	public class Racer : IComparable<Racer>,IFormattable
	{
		public int Id{ get; private set;}
		public string FirstName{ get; set;}
		public string LastName{ get; set;}
		public string Country{ get; set;}
		public int Wins{ get; set;}
		public Racer(int id, string firstName,string lastName, string country)
			:this(id,firstName,lastName,country,0)
		{
		}
		public Racer(int id, string firstName, string lastName, string country, int wins)
		{
			this.Id = id;
			this.FirstName = firstName;
			this.LastName = lastName;
			this.Country = country;
			this.Wins = wins;
		}
		public override string ToString()
		{
			return String.Format("{0} {1}",FirstName,LastName);
		}
		public string ToString(string format,IFormatProvider formatProvider)
		{
			if(format == null) format = "N";
			switch(format)
			{
				case "N":
					return ToString();
				case "F":
					return FirstName;
				case "L":
					return LastName;
				case "W":
					return String.Format("{0},Wins:{1}",ToString(),Wins);
				case "C":
					return String.Format("{0},Country:{1}",ToString(),Country);
				case "A":
					return String.Format("{0},Country:{1},Wins:{2}",ToString(),Country,Wins);
				default:
					throw new FormatException(String.Format(formatProvider,"Format {0} is not supported",format));
			}
		}
		public string ToString(string format)
		{
			return ToString(format, null);
		}
		public int CompareTo(Racer other)
		{
			int complare = LastName.CompareTo(other.LastName);
			if(complare == 0)
				complare = FirstName.CompareTo(other.FirstName);
			return complare;
		}
	}
	public class FindCountry
	{
		private string country;
		public FindCountry(string country)
		{
			this.country = country;
		}
		public bool FindCountryPredicate(Racer r)
		{
			//Contract.Requires<ArgumentNullException>(r != null);//异常我还没有学到估计是如果r为null就抛这个异常的意思
			return r.Country == country;
		}
	}
	public class RacerComparer : IComparer<Racer>
	{
		public enum CompareType
		{
			FirstName,
			LastName,
			Country,
			Wins
		}
		private CompareType compareType;
		public RacerComparer(RacerComparer.CompareType type)
		{
			this.compareType = type;
		}
		public int Compare(Racer r1, Racer r2)
		{
			if(r1 == null && r2 == null) return 0;
			if(r1 == null)return -1;
			if(r2 == null)return 1;
			int result;
			switch(compareType)
			{
				case CompareType.FirstName:
					return r1.FirstName.CompareTo(r2.FirstName);
				case CompareType.LastName:
					return r1.LastName.CompareTo(r2.LastName);
				case CompareType.Country:
					result = r1.Country.CompareTo(r2.Country);
					if(result == 0)
						result = r1.LastName.CompareTo(r2.LastName);
					if(result == 0)
						result = r1.FirstName.CompareTo(r2.FirstName);
					return result;
				case CompareType.Wins:
					return r1.Wins.CompareTo(r2.Wins);
				default : 
					throw new ArgumentException("Invalid Compare Type");
			}
		}
	}
}