// 聲明應(yīng)用用到的命名空間
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Dynamic;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Threading.Tasks;
using System.IO;

// 定義作用域，將代碼組織成包
namespace Learning
{
    // 每個(gè) .cs 文件至少需要包含一個(gè)和文件名相同的類
    // 你可以不這么干，但是這樣不好。
    public class LearnCSharp
    {
        // 如果你以前用過(guò) Java 或 C++ 的話，可以直接跳到后文“有趣的特性”
        public static void Syntax()
        {
            // 使用 Console.WriteLine 打印信息
            Console.WriteLine("Hello World");
            Console.WriteLine(
                "Integer: " + 10 +
                " Double: " + 3.14 +
                " Boolean: " + true);

            // 使用 Console.Write 打印，不帶換行符號(hào)
            Console.Write("Hello ");
            Console.Write("World");

            ///////////////////////////////////////////////////
            // 類型和變量
            //
            // 使用 <type> <name>定義變量
            ///////////////////////////////////////////////////

            // Sbyte - 有符號(hào) 8-bit 整數(shù)
            // (-128 <= sbyte <= 127)
            sbyte fooSbyte = 100;

            // Byte - 無(wú)符號(hào) 8-bit 整數(shù)
            // (0 <= byte <= 255)
            byte fooByte = 100;

            // Short - 16-bit 整數(shù)
            // 有符號(hào) - (-32,768 <= short <= 32,767)
            // 無(wú)符號(hào) - (0 <= ushort <= 65,535)
            short fooShort = 10000;
            ushort fooUshort = 10000;

            // Integer - 32-bit 整數(shù)
            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)

            // Long -  64-bit 整數(shù)
            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
            // 數(shù)字默認(rèn)為 int 或 uint （取決于尺寸）
            // 使用 L 標(biāo)明變量值類型為long 或 ulong

            // Double - 雙精度 64-bit IEEE 754 浮點(diǎn)數(shù)
            double fooDouble = 123.4; // 精度: 15-16 位

            // Float - 單精度 32-bit IEEE 754 浮點(diǎn)數(shù)
            float fooFloat = 234.5f; // 精度: 7 位
            // 使用 f 標(biāo)明變量值類型為float

            // Decimal - 128-bits 數(shù)據(jù)類型，比其他浮點(diǎn)類型精度更高，適合財(cái)務(wù)、金融
            decimal fooDecimal = 150.3m;

            // 布爾值 - true & false
            bool fooBoolean = true; // 或 false

            // Char - 單個(gè) 16-bit Unicode 字符
            char fooChar = 'A';

            // Strings -- 和前面的基本類型不同，字符串不是值，而是引用。這意味著你可以將字符串設(shè)為null。
            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
            Console.WriteLine(fooString);

            // 你可以通過(guò)索引訪問(wèn)字符串的每個(gè)字符：
            char charFromString = fooString[1]; // => 'e'
            // 字符串不可修改: fooString[1] = 'X' 是行不通的。

            // 根據(jù)當(dāng)前的locale設(shè)定比較字符串，大小寫(xiě)不敏感
            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);

            // 基于sprintf的字符串格式化
            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);

            // 日期和格式
            DateTime fooDate = DateTime.Now;
            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));

            // 使用 @ 符號(hào)可以創(chuàng)建跨行的字符串。使用 "" 來(lái)表示 "
            string bazString = @"Here's some stuff
on a new line! ""Wow!"", the masses cried";

            // 使用const或read-only定義常量，常量在編譯期演算
            const int HOURS_I_WORK_PER_WEEK = 9001;

            ///////////////////////////////////////////////////
            // 數(shù)據(jù)結(jié)構(gòu)
            ///////////////////////////////////////////////////

            // 數(shù)組 - 從0開(kāi)始計(jì)數(shù)，聲明數(shù)組時(shí)需要確定數(shù)組長(zhǎng)度。
            // 聲明數(shù)組的格式如下：
            // <datatype>[] <var name> = new <datatype>[<array size>];
            int[] intArray = new int[10];

            // 聲明并初始化數(shù)組的其他方式：
            int[] y = { 9000, 1000, 1337 };

            // 訪問(wèn)數(shù)組的元素
            Console.WriteLine("intArray @ 0: " + intArray[0]);
            // 數(shù)組可以修改
            intArray[1] = 1;

            // 列表
            // 列表比數(shù)組更常用，因?yàn)榱斜砀`活。
            // 聲明列表的格式如下：
            // List<datatype> <var name> = new List<datatype>();
            List<int> intList = new List<int>();
            List<string> stringList = new List<string>();
            List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
            // <>用于泛型 - 參考下文

            // 列表無(wú)默認(rèn)值，訪問(wèn)列表元素時(shí)必須首先添加元素
            intList.Add(1);
            Console.WriteLine("intList @ 0: " + intList[0]);

            // 其他數(shù)據(jù)結(jié)構(gòu)：
            // 堆棧/隊(duì)列
            // 字典 (哈希表的實(shí)現(xiàn))
            // 哈希集合
            // 只讀集合
            // 元組 (.Net 4+)

            ///////////////////////////////////////
            // 操作符
            ///////////////////////////////////////
            Console.WriteLine("\n->Operators");

            int i1 = 1, i2 = 2; // 多重聲明的簡(jiǎn)寫(xiě)形式

            // 直截了當(dāng)?shù)乃阈g(shù)
            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3

            // 取余
            Console.WriteLine("11%3 = " + (11 % 3)); // => 2

            // 比較操作符
            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true

            // 位操作符
            /*
            ~       取反
            <<      左移（有符號(hào)）
            >>      右移（有符號(hào)）
            &       與
            ^       按位異或
            |       或
            */

            // 自增、自減
            int i = 0;
            Console.WriteLine("\n->Inc/Dec-rementation");
            Console.WriteLine(i++); //i = 1. 事后自增
            Console.WriteLine(++i); //i = 2. 事先自增
            Console.WriteLine(i--); //i = 1. 事后自減
            Console.WriteLine(--i); //i = 0. 事先自減

            ///////////////////////////////////////
            // 控制結(jié)構(gòu)
            ///////////////////////////////////////
            Console.WriteLine("\n->Control Structures");

            // 類似C的if語(yǔ)句
            int j = 10;
            if (j == 10)
            {
                Console.WriteLine("I get printed");
            }
            else if (j > 10)
            {
                Console.WriteLine("I don't");
            }
            else
            {
                Console.WriteLine("I also don't");
            }

            // 三元表達(dá)式
            // 簡(jiǎn)單的 if/else 語(yǔ)句可以寫(xiě)成：
            // <condition> ? <true> : <false>
            string isTrue = (true) ? "True" : "False";

            // While 循環(huán)
            int fooWhile = 0;
            while (fooWhile < 100)
            {
                //迭代 100 次, fooWhile 0->99
                fooWhile++;
            }

            // Do While 循環(huán)
            int fooDoWhile = 0;
            do
            {
                //迭代 100 次, fooDoWhile 0->99
                fooDoWhile++;
            } while (fooDoWhile < 100);

            //for 循環(huán)
            //for 循環(huán)結(jié)構(gòu) => for(<初始條件>; <條件>; <步>)
            for (int fooFor = 0; fooFor < 10; fooFor++)
            {
                //迭代10次, fooFor 0->9
            }

            // foreach循環(huán)
            // foreach 循環(huán)結(jié)構(gòu) => foreach(<迭代器類型> <迭代器> in <可枚舉結(jié)構(gòu)>)
            // foreach 循環(huán)適用于任何實(shí)現(xiàn)了 IEnumerable 或 IEnumerable 的對(duì)象。
            // .Net 框架下的集合類型(數(shù)組, 列表, 字典...)都實(shí)現(xiàn)了這些接口。
            // 下面的代碼中，ToCharArray()可以刪除，因?yàn)樽址瑯訉?shí)現(xiàn)了IEnumerable。
            foreach (char character in "Hello World".ToCharArray())
            {
                //迭代字符串中的所有字符
            }

            // Switch 語(yǔ)句
            // switch 適用于 byte、short、char和int 數(shù)據(jù)類型。
            // 同樣適用于可枚舉的類型，包括字符串類,
            // 以及一些封裝了原始值的類：Character、Byte、Short和Integer。
            int month = 3;
            string monthString;
            switch (month)
            {
                case 1:
                    monthString = "January";
                    break;
                case 2:
                    monthString = "February";
                    break;
                case 3:
                    monthString = "March";
                    break;
                // 你可以一次匹配多個(gè)case語(yǔ)句
                // 但是你在添加case語(yǔ)句后需要使用break
                // （否則你需要顯式地使用goto case x語(yǔ)句）
                case 6:
                case 7:
                case 8:
                    monthString = "Summer time!!";
                    break;
                default:
                    monthString = "Some other month";
                    break;
            }

            ///////////////////////////////////////
            // 轉(zhuǎn)換字符串為整數(shù)，轉(zhuǎn)換失敗會(huì)拋出異常：
            ///////////////////////////////////////

            // Converting data

            // 轉(zhuǎn)換字符串為整數(shù)，轉(zhuǎn)換失敗會(huì)拋出異常：
            int.Parse("123");//返回整數(shù)類型的"123"

            // TryParse會(huì)嘗試轉(zhuǎn)換類型，失敗時(shí)會(huì)返回缺省類型，例如 0
            int tryInt;
            if (int.TryParse("123", out tryInt)) // Funciton is boolean
                Console.WriteLine(tryInt);       // 123

            // 轉(zhuǎn)換整數(shù)為字符串
            // Convert類提供了一系列便利轉(zhuǎn)換的方法
            Convert.ToString(123);
            // or
            tryInt.ToString();
        }

        ///////////////////////////////////////
        // 類
        ///////////////////////////////////////
        public static void Classes()
        {
            // 參看文件尾部的對(duì)象聲明

            // 使用new初始化對(duì)象
            Bicycle trek = new Bicycle();

            // 調(diào)用對(duì)象的方法
            trek.SpeedUp(3); // 你應(yīng)該一直使用setter和getter方法
            trek.Cadence = 100;

            // 查看對(duì)象的信息.
            Console.WriteLine("trek info: " + trek.Info());

            // 實(shí)例化一個(gè)新的Penny Farthing
            PennyFarthing funbike = new PennyFarthing(1, 10);
            Console.WriteLine("funbike info: " + funbike.Info());

            Console.Read();
        } // 結(jié)束main方法

        // 終端程序 終端程序必須有一個(gè)main方法作為入口
        public static void Main(string[] args)
        {
            OtherInterestingFeatures();
        }

        //
        // 有趣的特性
        //

        // 默認(rèn)方法簽名

        public // 可見(jiàn)性
        static // 允許直接調(diào)用類，無(wú)需先創(chuàng)建實(shí)例
        int // 返回值
        MethodSignatures(
            int maxCount, // 第一個(gè)變量，類型為整型
            int count = 0, // 如果沒(méi)有傳入值，則缺省值為0
            int another = 3,
            params string[] otherParams // 捕獲其他參數(shù)
        )
        {
            return -1;
        }

        // 方法可以重名，只要簽名不一樣
        public static void MethodSignature(string maxCount)
        {
        }

        // 泛型
        // TKey和TValue類由用用戶調(diào)用函數(shù)時(shí)指定。
        // 以下函數(shù)模擬了Python的SetDefault
        public static TValue SetDefault<TKey, TValue>(
            IDictionary<TKey, TValue> dictionary,
            TKey key,
            TValue defaultItem)
        {
            TValue result;
            if (!dictionary.TryGetValue(key, out result))
                return dictionary[key] = defaultItem;
            return result;
        }

        // 你可以限定傳入值的范圍
        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
        {
            // 我們可以進(jìn)行迭代，因?yàn)門(mén)是可枚舉的
            foreach (var item in toPrint)
                // ittm為整數(shù)
                Console.WriteLine(item.ToString());
        }

        public static void OtherInterestingFeatures()
        {
            // 可選參數(shù)
            MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
            MethodSignatures(3, another: 3); // 顯式指定參數(shù)，忽略可選參數(shù)

            // 擴(kuò)展方法
            int i = 3;
            i.Print(); // 參見(jiàn)下面的定義

            // 可為null的類型 對(duì)數(shù)據(jù)庫(kù)交互、返回值很有用，
            // 任何值類型 (i.e. 不為類) 添加后綴?后會(huì)變?yōu)榭蔀閚ull的類型
            // <類型>? <變量名> = <值>
            int? nullable = null; // Nullable<int> 的簡(jiǎn)寫(xiě)形式
            Console.WriteLine("Nullable variable: " + nullable);
            bool hasValue = nullable.HasValue; // 不為null時(shí)返回真

            // ?? 是用于指定默認(rèn)值的語(yǔ)法糖
            // 以防變量為null的情況
            int notNullable = nullable ?? 0; // 0

            //變量類型推斷
            // 你可以讓編譯器推斷變量類型:
            var magic = "magic is a string, at compile time, so you still get type safety";
            // magic = 9; // 不工作，因?yàn)閙agic是字符串，而不是整數(shù)。

            // 泛型
            //
            var phonebook = new Dictionary<string, string>() {
                {"Sarah", "212 555 5555"} // 在電話簿中加入新條目
            };

            // 調(diào)用上面定義為泛型的SETDEFAULT
            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // 沒(méi)有電話
            // 你不用指定TKey、TValue，因?yàn)樗鼈儠?huì)被隱式地推導(dǎo)出來(lái)
            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555

            // lambda表達(dá)式 - 允許你用一行代碼搞定函數(shù)
            Func<int, int> square = (x) => x * x; // 最后一項(xiàng)為返回值
            Console.WriteLine(square(3)); // 9

            // 可拋棄的資源管理 - 讓你很容易地處理未管理的資源。大多數(shù)訪問(wèn)未管理資源 (文件操作符、設(shè)備上下文, etc.)的對(duì)象， 都實(shí)現(xiàn)了IDisposable接口。
            // using語(yǔ)句會(huì)為你清理IDisposable對(duì)象。
            using (StreamWriter writer = new StreamWriter("log.txt"))
            {
                writer.WriteLine("這里沒(méi)有什么可疑的東西");
                // 在作用域的結(jié)尾，資源會(huì)被回收
                // （即使有異常拋出，也一樣會(huì)回收）
            }

            // 并行框架
            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
            var websites = new string[] {
                "http://www.google.com", "http://www.reddit.com",
                "http://www.shaunmccarthy.com"
            };
            var responses = new Dictionary<string, string>();

            // 為每個(gè)請(qǐng)求新開(kāi)一個(gè)線程，在運(yùn)行下一步前合并結(jié)果
            Parallel.ForEach(websites,
                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
                website =>
            {
                // Do something that takes a long time on the file
                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
                {
                    responses[website] = r.ContentType;
                }
            });

            // 直到所有的請(qǐng)求完成后才會(huì)運(yùn)行下面的代碼
            foreach (var key in responses.Keys)
                Console.WriteLine("{0}:{1}", key, responses[key]);

            // 動(dòng)態(tài)對(duì)象 (配合其他語(yǔ)言使用很方便)
            dynamic student = new ExpandoObject();
            student.FirstName = "First Name"; // 不需要先定義類！

            // 你甚至可以添加方法（接受一個(gè)字符串，輸出一個(gè)字符串）
            student.Introduce = new Func<string, string>(
                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
            Console.WriteLine(student.Introduce("Beth"));

            // IQUERYABLE<T> - 幾乎所有的集合都實(shí)現(xiàn)了它，帶給你 Map / Filter / Reduce 風(fēng)格的方法
            var bikes = new List<Bicycle>();
            bikes.Sort(); // Sorts the array
            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // 根據(jù)車輪數(shù)排序
            var result = bikes
                .Where(b => b.Wheels > 3) // 篩選 - 可以連鎖使用 （返回IQueryable)
                .Where(b => b.IsBroken && b.HasTassles)
                .Select(b => b.ToString()); // Map - 這里我們使用了select，所以結(jié)果是IQueryable<string

            var sum = bikes.Sum(b => b.Wheels); // Reduce - 計(jì)算集合中的輪子總數(shù)

            // 創(chuàng)建一個(gè)包含基于自行車的一些參數(shù)生成的隱式對(duì)象的列表
            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
            // 很難演示，但是編譯器在代碼編譯完成前就能推導(dǎo)出以上對(duì)象的類型
            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
                Console.WriteLine(bikeSummary.Name);

            // ASPARALLEL
            // 特性 —— 組合了linq和并行操作
            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
            // 以上代碼并發(fā)地運(yùn)行。會(huì)自動(dòng)新開(kāi)線程，分別計(jì)算結(jié)果。適用于多核、大數(shù)據(jù)量的場(chǎng)景。

            // LINQ - 將IQueryable<T>映射到存儲(chǔ)，延緩執(zhí)行，例如 LinqToSql 映射數(shù)據(jù)庫(kù), LinqToXml 映射XML文檔。
            var db = new BikeRespository();

            // 執(zhí)行被延遲了，這對(duì)于查詢數(shù)據(jù)庫(kù)來(lái)說(shuō)很好
            var filter = db.Bikes.Where(b => b.HasTassles); // 不運(yùn)行查詢
            if (42 > 6) // 你可以不斷地增加篩選，包括有條件的篩選，例如用于“高級(jí)搜索”功能
                filter = filter.Where(b => b.IsBroken); // 不運(yùn)行查詢

            var query = filter
                .OrderBy(b => b.Wheels)
                .ThenBy(b => b.Name)
                .Select(b => b.Name); // 仍然不運(yùn)行查詢

            // 現(xiàn)在運(yùn)行查詢，運(yùn)行查詢的時(shí)候會(huì)打開(kāi)一個(gè)讀取器，所以你迭代的是一個(gè)副本
            foreach (string bike in query)
                Console.WriteLine(result);

        }

    } // 結(jié)束LearnCSharp類

    // 你可以在同一個(gè) .cs 文件中包含其他類

    public static class Extensions
    {
        // 擴(kuò)展函數(shù)
        public static void Print(this object obj)
        {
            Console.WriteLine(obj.ToString());
        }
    }

    // 聲明類的語(yǔ)法：
    // <public/private/protected/internal> class <類名>{
    //    //數(shù)據(jù)字段, 構(gòu)造器, 內(nèi)部函數(shù).
    /     // 在Java中函數(shù)被稱為方法。
    // }

    public class Bicycle
    {
        // 自行車的字段、變量
        public int Cadence // Public: 任何地方都可以訪問(wèn)
        {
            get // get - 定義獲取屬性的方法
            {
                return _cadence;
            }
            set // set - 定義設(shè)置屬性的方法
            {
                _cadence = value; // value是被傳遞給setter的值
            }
        }
        private int _cadence;

        protected virtual int Gear // 類和子類可以訪問(wèn)
        {
            get; // 創(chuàng)建一個(gè)自動(dòng)屬性，無(wú)需成員字段
            set;
        }

        internal int Wheels // Internal:在同一程序集內(nèi)可以訪問(wèn)
        {
            get;
            private set; // 可以給get/set方法添加修飾符
        }

        int _speed; // 默認(rèn)為private: 只可以在這個(gè)類內(nèi)訪問(wèn)，你也可以使用`private`關(guān)鍵詞
        public string Name { get; set; }

        //enum類型包含一組常量，它將名稱映射到值（除非特別說(shuō)明，是一個(gè)整型）。
        //enmu元素的類型可以是byte、sbyte、short、ushort、int、uint、long、ulong。enum不能包含相同的值。
        public enum BikeBrand
        {
            AIST,
            BMC,
            Electra = 42, //你可以顯式地賦值
            Gitane // 43
        }
        // 我們?cè)贐icycle類中定義的這個(gè)類型，所以它是一個(gè)內(nèi)嵌類型。這個(gè)類以外的代碼應(yīng)當(dāng)使用Bicycle.Brand來(lái)引用。

        public BikeBrand Brand; // 聲明一個(gè)enum類型之后，我們可以聲明這個(gè)類型的字段

        // 靜態(tài)方法
        // 靜態(tài)方法的類型為自身，不屬于特定的對(duì)象。你無(wú)需引用對(duì)象就可以訪問(wèn)他們。
        static public int BicyclesCreated = 0;

        // 只讀值
        // 只讀值在運(yùn)行時(shí)確定，它們只能在聲明或構(gòu)造器內(nèi)被賦值。
        readonly bool _hasCardsInSpokes = false; // read-only private

        // 構(gòu)造器是創(chuàng)建類的一種方式。
        // 下面是一個(gè)默認(rèn)的構(gòu)造器。
        public Bicycle()
        {
            this.Gear = 1; // 你可以使用關(guān)鍵詞this訪問(wèn)對(duì)象的成員
            Cadence = 50;  // 不過(guò)你并不總是需要它
            _speed = 5;
            Name = "Bontrager";
            Brand = BikeBrand.AIST;
            BicyclesCreated++;
        }

        // 另一個(gè)構(gòu)造器的例子（包含參數(shù)）
        public Bicycle(int startCadence, int startSpeed, int startGear,
                       string name, bool hasCardsInSpokes, BikeBrand brand)
            : base() // 首先調(diào)用base
        {
            Gear = startGear;
            Cadence = startCadence;
            _speed = startSpeed;
            Name = name;
            _hasCardsInSpokes = hasCardsInSpokes;
            Brand = brand;
        }

        // 構(gòu)造器可以連鎖使用
        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
            this(startCadence, startSpeed, 0, "big wheels", true, brand)
        {
        }

        // 函數(shù)語(yǔ)法:
        // <public/private/protected> <返回值> <函數(shù)名稱>(<參數(shù)>)

        // 類可以為字段實(shí)現(xiàn) getters 和 setters 方法 for their fields，或者可以實(shí)現(xiàn)屬性（C#推薦使用這個(gè)）。

        // 方法的參數(shù)可以有默認(rèn)值。在有默認(rèn)值的情況下，調(diào)用方法的時(shí)候可以省略相應(yīng)的參數(shù)。
        public void SpeedUp(int increment = 1)
        {
            _speed += increment;
        }

        public void SlowDown(int decrement = 1)
        {
            _speed -= decrement;
        }

        // 屬性可以訪問(wèn)和設(shè)置值。當(dāng)只需要訪問(wèn)數(shù)據(jù)的時(shí)候，考慮使用屬性。屬性可以定義get和set，或者是同時(shí)定義兩者。
        private bool _hasTassles; // private variable
        public bool HasTassles // public accessor
        {
            get { return _hasTassles; }
            set { _hasTassles = value; }
        }

        // 你可以在一行之內(nèi)定義自動(dòng)屬性，這個(gè)語(yǔ)法自動(dòng)創(chuàng)建后備字段。你可以給getter或setter設(shè)置訪問(wèn)修飾符，以便限制它們的訪問(wèn)。
        public bool IsBroken { get; private set; }

        // 屬性的實(shí)現(xiàn)可以是自動(dòng)的
        public int FrameSize
        {
            get;
            // 你可以給get或set指定訪問(wèn)修飾符
            // 以下代碼意味著只有Bicycle類可以調(diào)用Framesize的set
            private set;
        }

        //顯示對(duì)象屬性的方法
        public virtual string Info()
        {
            return "Gear: " + Gear +
                    " Cadence: " + Cadence +
                    " Speed: " + _speed +
                    " Name: " + Name +
                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
                    "\n------------------------------\n"
                    ;
        }

        // 方法可以是靜態(tài)的。通常用于輔助方法。
        public static bool DidWeCreateEnoughBycles()
        {
            // 在靜態(tài)方法中，你只能引用類的靜態(tài)成員
            return BicyclesCreated > 9000;
        } // 如果你的類只需要靜態(tài)成員，考慮將整個(gè)類作為靜態(tài)類。

    } // Bicycle類結(jié)束

    // PennyFarthing是Bicycle的一個(gè)子類
    class PennyFarthing : Bicycle
    {
        // (Penny Farthings是一種前輪很大的自行車。沒(méi)有齒輪。）

        // 調(diào)用父構(gòu)造器
        public PennyFarthing(int startCadence, int startSpeed) :
            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
        {
        }

        protected override int Gear
        {
            get
            {
                return 0;
            }
            set
            {
                throw new ArgumentException("你不可能在PennyFarthing上切換齒輪");
            }
        }

        public override string Info()
        {
            string result = "PennyFarthing bicycle ";
            result += base.ToString(); // 調(diào)用父方法
            return result;
        }
    }

    // 接口只包含成員的簽名，而沒(méi)有實(shí)現(xiàn)。
    interface IJumpable
    {
        void Jump(int meters); // 所有接口成員是隱式地公開(kāi)的
    }

    interface IBreakable
    {
        bool Broken { get; } // 接口可以包含屬性、方法和事件
    }

    // 類只能繼承一個(gè)類，但是可以實(shí)現(xiàn)任意數(shù)量的接口
    class MountainBike : Bicycle, IJumpable, IBreakable
    {
        int damage = 0;

        public void Jump(int meters)
        {
            damage += meters;
        }

        public bool Broken
        {
            get
            {
                return damage > 100;
            }
        }
    }

    /// <summary>
    /// 連接數(shù)據(jù)庫(kù)，一個(gè) LinqToSql的示例。EntityFramework Code First 很棒 (類似 Ruby的 ActiveRecord, 不過(guò)是雙向的)
    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
    /// </summary>
    public class BikeRespository : DbSet
    {
        public BikeRespository()
            : base()
        {
        }

        public DbSet<Bicycle> Bikes { get; set; }
    }
} // 結(jié)束 Namespace