程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 在X分鐘內學會C#的入門簡明教程

在X分鐘內學會C#的入門簡明教程

編輯:關於JAVA

在X分鐘內學會C#的入門簡明教程。本站提示廣大學習愛好者:(在X分鐘內學會C#的入門簡明教程)文章只能為提供參考,不一定能成為您想要的結果。以下是在X分鐘內學會C#的入門簡明教程正文


可以依據履行時光打印sql語句,打印的sql語句是帶參數的,可以拷貝到查詢剖析器甚麼的直接運轉


package mybatis;

import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Properties;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;

@Intercepts({
  @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }),
  @Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class,
    RowBounds.class, ResultHandler.class }) })
public class MybatisInterceptor implements Interceptor {

 private Properties properties;

 public Object intercept(Invocation invocation) throws Throwable {
  MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
  Object parameter = null;
  if (invocation.getArgs().length > 1) {
   parameter = invocation.getArgs()[1];
  }
  String sqlId = mappedStatement.getId();
  BoundSql boundSql = mappedStatement.getBoundSql(parameter);
  Configuration configuration = mappedStatement.getConfiguration();
  Object returnValue = null;
  long start = System.currentTimeMillis();
  returnValue = invocation.proceed();
  long end = System.currentTimeMillis();
  long time = (end - start);
  if (time > 1) {
   String sql = getSql(configuration, boundSql, sqlId, time);
   System.err.println(sql);
  }
  return returnValue;
 }

 public static String getSql(Configuration configuration, BoundSql boundSql, String sqlId, long time) {
  String sql = showSql(configuration, boundSql);
  StringBuilder str = new StringBuilder(100);
  str.append(sqlId);
  str.append(":");
  str.append(sql);
  str.append(":");
  str.append(time);
  str.append("ms");
  return str.toString();
 }

 private static String getParameterValue(Object obj) {
  String value = null;
  if (obj instanceof String) {
   value = "'" + obj.toString() + "'";
  } else if (obj instanceof Date) {
   DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
   value = "'" + formatter.format(new Date()) + "'";
  } else {
   if (obj != null) {
    value = obj.toString();
   } else {
    value = "";
   }

  }
  return value;
 }

 public static String showSql(Configuration configuration, BoundSql boundSql) {
  Object parameterObject = boundSql.getParameterObject();
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
  if (parameterMappings.size() > 0 && parameterObject != null) {
   TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
   if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
    sql = sql.replaceFirst("\\?", getParameterValue(parameterObject));

   } else {
    MetaObject metaObject = configuration.newMetaObject(parameterObject);
    for (ParameterMapping parameterMapping : parameterMappings) {
     String propertyName = parameterMapping.getProperty();
     if (metaObject.hasGetter(propertyName)) {
      Object obj = metaObject.getValue(propertyName);
      sql = sql.replaceFirst("\\?", getParameterValue(obj));
     } else if (boundSql.hasAdditionalParameter(propertyName)) {
      Object obj = boundSql.getAdditionalParameter(propertyName);
      sql = sql.replaceFirst("\\?", getParameterValue(obj));
     }
    }
   }
  }
  return sql;
 }

 public Object plugin(Object target) {
  return Plugin.wrap(target, this);
 }

 public void setProperties(Properties properties0) {
  this.properties = properties0;
 }
}

        bool fooBoolean = true; // 或 false

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

            // Strings -- 和後面的根本類型分歧,字符串不是值,而是援用。這意味著你可以將字符串設為null。
            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
            Console.WriteLine(fooString);

            // 你可以經由過程索引拜訪字符串的每一個字符:
            char charFromString = fooString[1]; // => 'e'
            // 字符串弗成修正: fooString[1] = 'X' 是行欠亨的。

            // 依據以後的locale設定比擬字符串,年夜小寫不敏感
            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"));

            // 應用 @ 符號可以創立跨行的字符串。應用 "" 來表現 "
            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;

            ///////////////////////////////////////////////////
            // 數據構造
            ///////////////////////////////////////////////////

            // 數組 - 從0開端計數,聲明數組時須要肯定數組長度。
            // 聲明數組的格局以下:
            // <datatype>[] <var name> = new <datatype>[<array size>];
            int[] intArray = new int[10];

            // 聲明並初始化數組的其他方法:
            int[] y = { 9000, 1000, 1337 };

            // 拜訪數組的元素
            Console.WriteLine("intArray @ 0: " + intArray[0]);
            // 數組可以修正
            intArray[1] = 1;

            // 列表
            // 列表比數組更經常使用,由於列表更靈巧。
            // 聲明列表的格局以下:
            // 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
            // <>用於泛型 - 參考下文

            // 列表無默許值,拜訪列表元素時必需起首添加元素
            intList.Add(1);
            Console.WriteLine("intList @ 0: " + intList[0]);

            // 其他數據構造:
            // 客棧/隊列
            // 字典 (哈希表的完成)
            // 哈希聚集
            // 只讀聚集
            // 元組 (.Net 4+)

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

            int i1 = 1, i2 = 2; // 多重聲明的簡寫情勢

            // 直接了當的算術
            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

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

            // 自增、自減
            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. 事前自減

            ///////////////////////////////////////
            // 掌握構造
            ///////////////////////////////////////
            Console.WriteLine("\n->Control Structures");

            // 相似C的if語句
            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");
            }

            // 三元表達式
            // 簡略的 if/else 語句可以寫成:
            // <condition> ? <true> : <false>
            string isTrue = (true) ? "True" : "False";

            // While 輪回
            int fooWhile = 0;
            while (fooWhile < 100)
            {
                //迭代 100 次, fooWhile 0->99
                fooWhile++;
            }

            // Do While 輪回
            int fooDoWhile = 0;
            do
            {
                //迭代 100 次, fooDoWhile 0->99
                fooDoWhile++;
            } while (fooDoWhile < 100);

            //for 輪回
            //for 輪回構造 => for(<初始前提>; <前提>; <步>)
            for (int fooFor = 0; fooFor < 10; fooFor++)
            {
                //迭代10次, fooFor 0->9
            }

            // foreach輪回
            // foreach 輪回構造 => foreach(<迭代器類型> <迭代器> in <可列舉構造>)
            // foreach 輪回實用於任何完成了 IEnumerable 或 IEnumerable 的對象。
            // .Net 框架下的聚集類型(數組, 列表, 字典...)都完成了這些接口。
            // 上面的代碼中,ToCharArray()可以刪除,由於字符串異樣完成了IEnumerable。
            foreach (char character in "Hello World".ToCharArray())
            {
                //迭代字符串中的一切字符
            }

            // Switch 語句
            // switch 實用於 byte、short、char和int 數據類型。
            // 異樣實用於可列舉的類型,包含字符串類,
            // 和一些封裝了原始值的類: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;
                // 你可以一次婚配多個case語句
                // 然則你在添加case語句後須要應用break
                // (不然你須要顯式地應用goto case x語句)
                case 6:
                case 7:
                case 8:
                    monthString = "Summer time!!";
                    break;
                default:
                    monthString = "Some other month";
                    break;
            }

            ///////////////////////////////////////
            // 轉換字符串為整數,轉換掉敗會拋出異常:
            ///////////////////////////////////////

            // Converting data

            // 轉換字符串為整數,轉換掉敗會拋出異常:
            int.Parse("123");//前往整數類型的"123"

            // TryParse會測驗考試轉換類型,掉敗時會前往缺省類型,例如 0
            int tryInt;
            if (int.TryParse("123", out tryInt)) // Funciton is boolean
                Console.WriteLine(tryInt);       // 123

            // 轉換整數為字符串
            // Convert類供給了一系列方便轉換的辦法
            Convert.ToString(123);
            // or
            tryInt.ToString();
        }

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

            // 應用new初始化對象
            Bicycle trek = new Bicycle();

            // 挪用對象的辦法
            trek.SpeedUp(3); // 你應當一向應用setter和getter辦法
            trek.Cadence = 100;

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

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

            Console.Read();
        } // 停止main辦法

        // 終端法式 終端法式必需有一個main辦法作為進口
        public static void Main(string[] args)
        {
            OtherInterestingFeatures();
        }

        //
        // 風趣的特征
        //

        // 默許辦法簽名

        public // 可見性
        static // 許可直接挪用類,無需先創立實例
        int // 前往值
        MethodSignatures(
            int maxCount, // 第一個變量,類型為整型
            int count = 0, // 假如沒有傳入值,則缺省值為0
            int another = 3,
            params string[] otherParams // 捕捉其他參數
        )
        {
            return -1;
        }

        // 辦法可以重名,只需簽名紛歧樣
        public static void MethodSignature(string maxCount)
        {
        }

        // 泛型
        // TKey和TValue類由用用戶挪用函數時指定。
        // 以下函數模仿了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>
        {
            // 我們可以停止迭代,由於T是可列舉的
            foreach (var item in toPrint)
                // ittm為整數
                Console.WriteLine(item.ToString());
        }

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

            // 擴大辦法
            int i = 3;
            i.Print(); // 拜見上面的界說

            // 可為null的類型 對數據庫交互、前往值很有效,
            // 任何值類型 (i.e. 不為類) 添加後綴?後會變成可為null的類型
            // <類型>? <變量名> = <值>
            int? nullable = null; // Nullable<int> 的簡寫情勢
            Console.WriteLine("Nullable variable: " + nullable);
            bool hasValue = nullable.HasValue; // 不為null時前往真

            // ?? 是用於指定默許值的語法糖
            // 以防變量為null的情形
            int notNullable = nullable ?? 0; // 0

            //變量類型揣摸
            // 你可讓編譯器揣摸變量類型:
            var magic = "magic is a string, at compile time, so you still get type safety";
            // magic = 9; // 不任務,由於magic是字符串,而不是整數。

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

            // 挪用下面界說為泛型的SETDEFAULT
            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // 沒有德律風
            // 你不消指定TKey、TValue,由於它們會被隱式地推導出來
            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555

            // lambda表達式 - 許可你用一行代碼弄定函數
            Func<int, int> square = (x) => x * x; // 最初一項為前往值
            Console.WriteLine(square(3)); // 9

            // 可擯棄的資本治理 - 讓你很輕易地處置未治理的資本。年夜多半拜訪未治理資本 (文件操作符、裝備高低文, etc.)的對象, 都完成了IDisposable接口。
            // using語句會為你清算IDisposable對象。
            using (StreamWriter writer = new StreamWriter("log.txt"))
            {
                writer.WriteLine("這裡沒有甚麼可疑的器械");
                // 在感化域的開頭,資本會被收受接管
                // (即便有異常拋出,也一樣會收受接管)
            }

            // 並行框架
            // 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.谷歌.com", "http://www.reddit.com",
                "http://www.shaunmccarthy.com"
            };
            var responses = new Dictionary<string, string>();

            // 為每一個要求新開一個線程,在運轉下一步前歸並成果
            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;
                }
            });

            // 直到一切的要求完成後才會運轉上面的代碼
            foreach (var key in responses.Keys)
                Console.WriteLine("{0}:{1}", key, responses[key]);

            // 靜態對象 (合營其他說話應用很便利)
            dynamic student = new ExpandoObject();
            student.FirstName = "First Name"; // 不須要先界說類!

            // 你乃至可以添加辦法(接收一個字符串,輸入一個字符串)
            student.Introduce = new Func<string, string>(
                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
            Console.WriteLine(student.Introduce("Beth"));

            // IQUERYABLE<T> - 簡直一切的聚集都完成了它,帶給你 Map / Filter / Reduce 作風的辦法
            var bikes = new List<Bicycle>();
            bikes.Sort(); // Sorts the array
            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // 依據車輪數排序
            var result = bikes
                .Where(b => b.Wheels > 3) // 挑選 - 可以連鎖應用 (前往IQueryable)
                .Where(b => b.IsBroken && b.HasTassles)
                .Select(b => b.ToString()); // Map - 這裡我們應用了select,所以成果是IQueryable<string

            var sum = bikes.Sum(b => b.Wheels); // Reduce - 盤算聚集中的輪子總數

            // 創立一個包括基於自行車的一些參數生成的隱式對象的列表
            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
            // 很難演示,然則編譯器在代碼編譯完成前就可以推導出以上對象的類型
            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);
            // 以上代碼會並發地運轉。會主動新開線程,分離盤算成果。實用於多核、年夜數據量的場景。

            // LINQ - 將IQueryable<T>映照到存儲,延緩履行,例如 LinqToSql 映照數據庫, LinqToXml 映照XML文檔。
            var db = new BikeRespository();

            // 履行被延遲了,這關於查詢數據庫來講很好
            var filter = db.Bikes.Where(b => b.HasTassles); // 不運轉查詢
            if (42 > 6) // 你可以赓續地增長挑選,包含有前提的挑選,例如用於“高等搜刮”功效
                filter = filter.Where(b => b.IsBroken); // 不運轉查詢

            var query = filter
                .OrderBy(b => b.Wheels)
                .ThenBy(b => b.Name)
                .Select(b => b.Name); // 依然不運轉查詢

            // 如今運轉查詢,運轉查詢的時刻會翻開一個讀取器,所以你迭代的是一個正本
            foreach (string bike in query)
                Console.WriteLine(result);

 

        }

    } // 停止LearnCSharp類

    // 你可以在統一個 .cs 文件中包括其他類

    public static class Extensions
    {
        // 擴大函數
        public static void Print(this object obj)
        {
            Console.WriteLine(obj.ToString());
        }
    }

    // 聲明類的語法:
    // <public/private/protected/internal> class <類名>{
    //    //數據字段, 結構器, 外部函數.
    /     // 在Java中函數被稱為辦法。
    // }

    public class Bicycle
    {
        // 自行車的字段、變量
        public int Cadence // Public: 任何處所都可以拜訪
        {
            get // get - 界說獲得屬性的辦法
            {
                return _cadence;
            }
            set // set - 界說設置屬性的辦法
            {
                _cadence = value; // value是被傳遞給setter的值
            }
        }
        private int _cadence;

        protected virtual int Gear // 類和子類可以拜訪
        {
            get; // 創立一個主動屬性,無需成員字段
            set;
        }

        internal int Wheels // Internal:在統一法式集內可以拜訪
        {
            get;
            private set; // 可以給get/set辦法添加潤飾符
        }

        int _speed; // 默許為private: 只可以在這個類內拜訪,你也能夠應用`private`症結詞
        public string Name { get; set; }

        //enum類型包括一組常量,它將稱號映照到值(除非特殊解釋,是一個整型)。
        //enmu元素的類型可所以byte、sbyte、short、ushort、int、uint、long、ulong。enum不克不及包括雷同的值。
        public enum BikeBrand
        {
            AIST,
            BMC,
            Electra = 42, //你可以顯式地賦值
            Gitane // 43
        }
        // 我們在Bicycle類中界說的這個類型,所以它是一個內嵌類型。這個類之外的代碼應該應用Bicycle.Brand來援用。

        public BikeBrand Brand; // 聲明一個enum類型以後,我們可以聲明這個類型的字段

        // 靜態辦法
        // 靜態辦法的類型為本身,不屬於特定的對象。你無需援用對象便可以拜訪他們。
        static public int BicyclesCreated = 0;

        // 只讀值
        // 只讀值在運轉時肯定,它們只能在聲明或結構器內被賦值。
        readonly bool _hasCardsInSpokes = false; // read-only private

        // 結構器是創立類的一種方法。
        // 上面是一個默許的結構器。
        public Bicycle()
        {
            this.Gear = 1; // 你可使用症結詞this拜訪對象的成員
            Cadence = 50;  // 不外你其實不老是須要它
            _speed = 5;
            Name = "Bontrager";
            Brand = BikeBrand.AIST;
            BicyclesCreated++;
        }

        // 另外一個結構器的例子(包括參數)
        public Bicycle(int startCadence, int startSpeed, int startGear,
                       string name, bool hasCardsInSpokes, BikeBrand brand)
            : base() // 起首挪用base
        {
            Gear = startGear;
            Cadence = startCadence;
            _speed = startSpeed;
            Name = name;
            _hasCardsInSpokes = hasCardsInSpokes;
            Brand = brand;
        }

        // 結構器可以連鎖應用
        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
            this(startCadence, startSpeed, 0, "big wheels", true, brand)
        {
        }

        // 函數語法:
        // <public/private/protected> <前往值> <函數稱號>(<參數>)

        // 類可認為字段完成 getters 和 setters 辦法 for their fields,或許可以完成屬性(C#推舉應用這個)。

        // 辦法的參數可以有默許值。在有默許值的情形下,挪用辦法的時刻可以省略響應的參數。
        public void SpeedUp(int increment = 1)
        {
            _speed += increment;
        }

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

        // 屬性可以拜訪和設置值。當只須要拜訪數據的時刻,斟酌應用屬性。屬性可以界說get和set,或許是同時界說二者。
        private bool _hasTassles; // private variable
        public bool HasTassles // public accessor
        {
            get { return _hasTassles; }
            set { _hasTassles = value; }
        }

        // 你可以在一行以內界說主動屬性,這個語法會主動創立後備字段。你可以給getter或setter設置拜訪潤飾符,以便限制它們的拜訪。
        public bool IsBroken { get; private set; }

        // 屬性的完成可所以主動的
        public int FrameSize
        {
            get;
            // 你可以給get或set指定拜訪潤飾符
            // 以下代碼意味著只要Bicycle類可以挪用Framesize的set
            private set;
        }

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

        }

        // 辦法可所以靜態的。平日用於幫助辦法。
        public static bool DidWeCreateEnoughBycles()
        {
            // 在靜態辦法中,你只能援用類的靜態成員
            return BicyclesCreated > 9000;
        } // 假如你的類只須要靜態成員,斟酌將全部類作為靜態類。

    } // Bicycle類停止

    // PennyFarthing是Bicycle的一個子類
    class PennyFarthing : Bicycle
    {
        // (Penny Farthings是一種前輪很年夜的自行車。沒有齒輪。)

        // 挪用父結構器
        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(); // 挪用父辦法
            return result;
        }
    }

    // 接口只包括成員的簽名,而沒有完成。
    interface IJumpable
    {
        void Jump(int meters); // 一切接口成員是隱式地地下的
    }

    interface IBreakable
    {
        bool Broken { get; } // 接口可以包括屬性、辦法和事宜
    }

    // 類只能繼續一個類,然則可以完成隨意率性數目的接口
    class MountainBike : Bicycle, IJumpable, IBreakable
    {
        int damage = 0;

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

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

    /// <summary>
    /// 銜接數據庫,一個 LinqToSql的示例。EntityFramework Code First 很棒 (相似 Ruby的 ActiveRecord, 不外是雙向的)
    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
    /// </summary>
    public class BikeRespository : DbSet
    {
        public BikeRespository()
            : base()
        {
        }

        public DbSet<Bicycle> Bikes { get; set; }
    }
} // 停止 Namespace

留意,沒有觸及到的主題有:
1.Flags
2.Attributes
3.靜態屬性
4.Exceptions, Abstraction
6.ASP.NET (Web Forms/MVC/WebMatrix)
6.Winforms
7.Windows Presentation Foundation (WPF)

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved