亚洲精品亚洲人成在线观看麻豆,在线欧美视频一区,亚洲国产精品一区二区动图,色综合久久丁香婷婷

              當(dāng)前位置:首頁 > IT技術(shù) > Windows編程 > 正文

              深入理解C#中的泛型(一)
              2021-08-06 19:48:40

              為什么要有泛型?

              ? 請大家思考一個問題:由你來實現(xiàn)一個最簡單的冒泡排序算法。假設(shè)沒有使用泛型的經(jīng)驗。可能會毫不猶豫的寫出下面代碼:

              public class SortHelper
                  {
                      //參數(shù)為int數(shù)組的冒泡排序
                      public void BubbleSort(int[] array)
                      {
                          int length = array.Length;
              
                          for (int i = 0; i <= length - 2; i++)
                          {
                              for (int j = length - 1; j >= 1; j--)
                              {
                                  //對兩個元素進行交換
                                  if (array[j] < array[j - 1])
                                  {
                                      int temp = array[j];
                                      array[j] = array[j - 1];
                                      array[j - 1] = temp;
                                  }
                              }
                          }
                      }
                  }
              ? 如今通過對這個程序進行一個簡單的測試:
                    static void Main(string[] args)
                      {
                          #region  沒有泛型前的演示
                          SortHelper sorter = new SortHelper();
              
                          int[] arrayInt = { 8, 1, 4, 7, 3 };
              
                          //對int數(shù)組排序
                          sorter.BubbleSort(arrayInt);
              
                          foreach (int i in arrayInt)
                          {
                              Console.Write("{0} ", i);
                          }
              
                          Console.ReadLine();
                          #endregion
                      }
              ? 我們發(fā)現(xiàn)它執(zhí)行良好,欣喜的覺得這便是最好的解決方式了。直到不久后,須要對一個byte類型的數(shù)組進行排序。而上面的排序算法僅僅能接受一個int類型的數(shù)組。C#是一個強類型的語言。無法在一個接受int數(shù)組類型的地方傳入一個byte數(shù)組。只是沒關(guān)系,如今看來最快的解決方法是把代碼復(fù)制一遍,然后將方法的簽名改一下:
               public class SortHelper
                  {
                      //參數(shù)為byte數(shù)組的冒泡排序
                      public void BubbleSort(byte[] array)
                      {
                          int length = array.Length;
              
                          for (int i = 0; i <= length - 2; i++)
                          {
                              for (int j = length - 1; j >= 1; j--)
                              {
                                  //對兩個元素進行交換
                                  if (array[j] < array[j - 1])
                                  {
                                      byte temp = array[j];
                                      array[j] = array[j - 1];
                                      array[j - 1] = temp;
                                  }
                              }
                          }
                      }
                  }
              ? 好了,再一次解決這個問題??赏ㄟ^認證觀察我們發(fā)現(xiàn),這兩個方法除了傳入的參數(shù)類型不同外。方法的實現(xiàn)非常相似,是能夠進行進一步抽象的。于是我們思考,為什么在定義參數(shù)的時候不用一個占位符T取代呢?T是Type的縮寫。能夠代表不論什么類型,這樣就能夠屏蔽兩個方法簽名的差異: ? ?
                 public class SortHelper<T>
                  {
                      //參數(shù)為T的冒泡排序
                      public void BubbleSort(T[] array)
                      {
                          int length = array.Length;
              
                          for (int i = 0; i <= length - 2; i++)
                          {
                              for (int j = length - 1; j >= 1; j--)
                              {
                                  //對兩個元素進行交換
                                  if (array[j] < array[j - 1])
                                  {
                                      T temp = array[j];
                                      array[j] = array[j - 1];
                                      array[j - 1] = temp;
                                  }
                              }
                          }
                      }
              ? 通過代碼我們能夠發(fā)現(xiàn),使用泛型極大的降低了反復(fù)代碼,使代碼更加清爽。

              泛型類就類似于一個模板,能夠再須要時為這個模板傳入不論什么須要的類型。如今更專業(yè)些,為占位符T起一個正式的名稱。在.Net中叫做“類型參數(shù)”。

              類型參數(shù)約束

              ? 實際上,如果執(zhí)行上面的代碼就會發(fā)現(xiàn),它連編譯都通只是去,為什么呢?考慮這樣一個問題:如果我們自己定義一個類型。名字叫做Book,它包括兩個字段:一個是int類型的Price代表書的價格;一個是string類型的Title,代表書的標(biāo)題:

              public class Book 
                  {
                      //價格字段
                      private int price;
                      //標(biāo)題字段
                      private string title;
              
                      //構(gòu)造函數(shù)
                      public Book() { }
              
                      public Book(int price, string title)
                      {
                          this.price = price;
                          this.title = title;
                      }
              
                      //價格屬性
                      public int Price
                      {
                          get { return this.price; }
                      }
              
                      //標(biāo)題屬性
                      public string Titie
                      {
                          get { return this.title; }
                      }
                  }
              ? 如今創(chuàng)建一個Book類型的數(shù)組,然后使用上面定義的泛型類對它進行排序,代碼應(yīng)該像以下這樣:
                          Book[] bookArray = new Book[2];
              
                          Book book1 = new Book(30, "HTML5解析");
                          Book book2 = new Book(21, "JavaScript實戰(zhàn)");
              
                          bookArray[0] = book1;
                          bookArray[1] = book2;
              
                          SortHelper<Book> sorterGeneric = new SortHelper<Book>();
                          sorterGeneric.BubbleSort(bookArray);
              
                          foreach (Book b in bookArray)
                          {
                              Console.WriteLine("Price:{0}", b.Price);
                              Console.WriteLine("Title:{0}", b.Titie);
                          }
              ? 這時問題來了。既然是排序。就免不了比較大小,那么如今請問:book1和book2誰比較大?張三能夠說book1大,由于它的Price是30,;而李四能夠說book2大,由于它的Title是“J”開頭的,比book1的“H”靠后。說了半天,問題在于不確定按什么規(guī)則排序。
              ? 既然不知道,那我們就給Book定義一種排序規(guī)則(按價格排序),我們聲明一個用于比較的接口:
               public interface IComparable
                  {
                      int CompareTo(object obj);
                  }
              ? 讓Book類型實現(xiàn)這個接口:
              public class Book : IComparable
              ? ? {
              ? ? ? ? //CODE:上面的實現(xiàn)略
              ? ? ? ? public int CompareTo(object obj)
              ? ? ? ? {
              ? ? ? ? ? ? Book book2 = (Book)obj;
              ? ? ? ? ? ? return this.Price.CompareTo(book2.Price);
              ? ? ? ? }
              ? ? }
              ? 既然我們?nèi)缃褚呀?jīng)讓Book類實現(xiàn)了IComparable接口,那么泛型類應(yīng)該可以工作了吧?不行的,還要記得,泛型類是一個模板類。它對在運行時傳遞的類型參數(shù)是一無所知的。也不會做不論什么的推測。所以須要我們告訴泛型類SortHelper<T>,它所接受的T類型參數(shù)必須可以進行比較,也就是說必須實現(xiàn)IComparable接口。我們把對T進行約束這樣的行為稱:泛型參數(shù)約束。

              ? 為了要求類型參數(shù)T必須實現(xiàn)IComparable接口,須要像以下這樣又一次定義:

              public class SortHelper<T> where T : IComparable
                  {
                      //參數(shù)為T的冒泡排序
                      public void BubbleSort(T[] array)
                      {
                          int length = array.Length;
              
                          for (int i = 0; i <= length - 2; i++)
                          {
                              for (int j = length - 1; j >= 1; j--)
                              {
                                  //對兩個元素進行交換
                                  if (array[j].CompareTo(array[j - 1]) < 0)
                                  {
                                      T temp = array[j];
                                      array[j] = array[j - 1];
                                      array[j - 1] = temp;
                                  }
                              }
                          }
                      }
                  }
              ? 上面的定義說明了類型參數(shù)T必須實現(xiàn)IComparable接口。否則將無法通過編譯。由于如今T已經(jīng)實現(xiàn)了IComparable接口,而數(shù)組array中的成員是T的實例。所以當(dāng)在array[i]后面點擊小數(shù)點“.”時,VS能夠智能提醒出T是IComparable的成員,也就是CompareTo()方法。

              本文摘自 :https://blog.51cto.com/u

              開通會員,享受整站包年服務(wù)立即開通 >