Từ 1 tới 4 trên tổng số 4 kết quả

Đề tài: Bài 5: Chapter 4 Collections and Generics

  1. #1
    Ngày gia nhập
    04 2009
    Nơi ở
    Hà Nội
    Bài viết
    692

    Lightbulb Bài 5: Chapter 4 Collections and Generics

    Chương này các bạn sẽ được tập trung vào các vấn đề về lưu trữ thông tin, không phải là database đâu nhé! Các thông tin này như là: messages, phone book, email inbox, an audio player.. vào thành nhóm để quản lý cho dễ.
    Các bạn sẽ hiểu collections (Bộ sưu tập) hay Generics ( Không biết dịch sao nữa, các bạn học sẽ hiểu).
    Lời khuyên cho các bạn khi đọc bài này là phải có chút kiến thức về Array ( Mảng ) và 1 chút về cấu trúc dữ liệu giải thuật lưu trữ kiểu Stack(LIFO: Last in First Out: Vào sau ra trước) và Queue(FIFO: First in First out: Vào trước ra trước).
    Các nội dung chủ yếu sẽ nói về việc lưu trữ các phần tử, add thêm, gỡ bỏ, sắp xếp.

    Chapter 4
    Collections and Generics

    Developers often need to store groups of related objects. For example, an e-mail inbox would contain a group of messages, a phone book would contain a group of phone numbers, and an audio player would contain a group of songs.
    The .NET Framework provides the System.Collections namespace to allow developers to manage groups of objects. Different collections exist to provide performance benefits in different scenarios, flexible sorting capabilities, support for different types, and dictionaries that pair keys and values.
    Exam objectives in this chapter:
    • Manage a group of associated data in a .NET Framework application by using collections.
    • Improve type safety and application performance in a .NET Framework applica-
    tion by using generic collections.
    • Manage data in a .NET Framework application by using specialized collections.


    Lesson 1: Collections and Dictionaries

    The System.Collections and System.Collections.Specialized namespaces contain a number of classes to meet varying requirements for storing groups of related objects. To use them most efficiently, you need to understand the benefits of each class. This lesson describes each collection and dictionary type and shows you how to use them.
    After this lesson, you will be able to:
    • Use collections and choose the best collection class for different requirements
    • Use dictionaries and choose the best dictionary class for different requirements
    Estimated lesson time: 30 minutes

    Collections
    A collection is any class that allows for gathering items into lists and for iterating through those items. The .NET Framework includes the following collection classes:
    • ArrayList A simple collection that can store any type of object. ArrayList instances expand to any required capacity.
    • Queue A first-in, first-out (FIFO) collection. You might use a Queue on a messaging server to store messages temporarily before processing or to track customer orders that need to be processed on a first-come, first-serve basis.
    • Stack A last-in, first-out (LIFO) collection. You might use a Stack to track changes so that the most recent change can be undone.
    • StringCollection Like ArrayList, except values are strongly typed as strings, and StringCollection does not support sorting.
    • BitArray A collection of boolean values.

    Visual C# Code:
    1. // C#
    2. ArrayList al = new ArrayList();
    3. al.Add("Hello");
    4. al.Add("World");
    5. al.Add(5);
    6. al.Add(new FileStream("delemete", FileMode.Create));
    7. Console.WriteLine("The array has " + al.Count + " items:");
    8.     Console.WriteLine(s.ToString());
    This console application displays the following:
    Code:
    The array has 4 items:
    Hello
    World
    5
    System.IO.FileStream
    In practice, you generally add items of a single type to an ArrayList. This allows you to call the Sort method to sort the objects using their IComparable implementation. You can also use the Remove method to remove an object you previously added and use the Insert method to add an element at the specified location in the zero-based index.
    The following code sample demonstrates this:

    Visual C# Code:
    1. // C#
    2. ArrayList al = new ArrayList();
    3. al.Add("Hello");
    4. al.Add("World");
    5. al.Add("this");
    6. al.Add("is");
    7. al.Add("a");
    8. al.Add("test");
    9. al.Remove("test");
    10. al.Insert(4, "not");
    11. al.Sort();
    12.     Console.WriteLine(s.ToString());
    This code sample results in the following display. Notice that the items are sorted alphabetically (using the string IComparable implementation) and “test” has been removed:
    Code:
    A
    Hello
    is 
    not
    this
    World
    IMPORTANT Using StringCollection
    You could also use StringCollection in place of ArrayList in the previous example. However, StringCollection does not support sorting, described next. The primary advantage of StringCollection is that it’s strongly typed for string values.
    You can also create your own custom IComparer implementations to control sort order. While the IComparable.CompareTo method controls the default sort order for a class, IComparer.Compare can be used to provide custom sort orders. For example,consider the following simple class, which only implements IComparer:

    Visual C# Code:
    1. // C#
    2. public class reverseSort : IComparer
    3. {
    4.     int IComparer.Compare(Object x, Object y)
    5.     {
    6.         return ((new CaseInsensitiveComparer()).Compare(y, x));
    7.     }
    8. }
    Given that class, you could pass an instance of the class to the ArrayList.Sort method.The following code sample demonstrates this and also demonstrates using the ArrayList.AddRange method, which adds each element of an array as a separate element to the instance of ArrayList:

    Visual C# Code:
    1. // C#
    2. ArrayList al = new ArrayList();
    3. al.AddRange(new string[] {"Hello", "world", "this", "is", "a", "test"});
    4. al.Sort(new reverseSort());
    5.     Console.WriteLine(s.ToString());
    This code displays the following:
    Code:
    world
    this
    test
    is
    Hello
    A
    You can also call the ArrayList.Reverse method to reverse the current order of items in the ArrayList.
    To locate a specific element, call the ArrayList.BinarySearch method and pass an instance of the object you are searching for. BinarySearch returns the zero-based index.

    Diễn giải:
    Việc sử dụng ArrayList sẽ rất tiện lợi cho các bạn, việc cần làm của bạn là add và remove nếu cần thiết vì với cách khai báo mảng bình thường thì số lượng phần tử là cố định.Việc sử dụng ArrayList tựa như dùng với cấu trúc động. Các phương thức bạn có thể xem trong MSDN. Hãy tập code các ví dụ trong đó, sẽ giúp các bạn linh hoạt khi sử dụng ArrayList.
    -- Vocabulary –
    1. gathering : Sự tụ họp,cuộc hội họp.
    2. except : Trừ ra, loại ra, phản đối, chống lại.
    3. efficiently : Có hiệu quả, hiệu nghiệm.

    Queue and Stack
    The Queue and Stack classes (in the System.Collections namespace) store objects thatcan be retrieved and removed in a single step. Queue uses a FIFO sequence, while Stack uses a LIFO sequence. The Queue class uses the Enqueue and Dequeue methods to add and remove objects, while the Stack class uses Push and Pop. The following code demonstrates the differences between the two classes:

    Visual C# Code:
    1. // C#
    2. Queue q = new Queue();
    3. q.Enqueue("Hello");
    4. q.Enqueue("world");
    5. q.Enqueue("just testing");
    6. Console.WriteLine("Queue demonstration:");
    7. for (int i = 1; i <= 3; i++)
    8.     Console.WriteLine(q.Dequeue().ToString());
    9. Stack s = new Stack();
    10. s.Push("Hello");
    11. s.Push("world");
    12. s.Push("just testing");
    13. Console.WriteLine("Stack demonstration:");
    14. for (int i = 1; i <= 3; i++)
    15.     Console.WriteLine(s.Pop().ToString());

    The application produces the following output:
    Code:
    Queue demonstration:
    Hello
    world
    just testing
    Stack demonstration:
    just testing
    world
    Hello
    You can also use Queue.Peek and Stack.Peek to access an object without removing it from the stack. Use Queue.Clear and Stack.Clear to remove all objects from the stack.

    BitArray and BitVector32
    BitArray is an array of boolean values, where each item in the array is either true or false. While BitArray can grow to any size, BitVector32 (a structure) is limited to exactly 32 bits. If you need to store boolean values, use BitVector32 anytime you require 32 or fewer items, and use BitArray for anything larger.
    Dictionaries Dictionaries map keys to values. For example, you might map an employee ID numberto the object that represents the employee, or you might map a product ID to the object that represents the product. The .NET Framework includes the following dictionary classes:
    • Hashtable A dictionary of name/value pairs that can be retrieved by name or Index
    • SortedList A dictionary that is sorted automatically by the key
    • StringDictionary A hashtable with name/value pairs implemented as strongly typed strings
    • ListDictionary A dictionary optimized for a small list of objects with fewer than 10 items.
    • HybridDictionary A dictionary that uses a ListDictionary for storage when the number of items is small and automatically switches to a Hashtable as the list grows
    • NameValueCollection A dictionary of name/value pairs of strings that allows retrieval by name or index SortedList (in the System.Collections namespace) is a dictionary that consists of key/value pairs. Both the key and the value can be any object. SortedList is sorted automatically by the key. For example, the following code sample creates a SortedList instance with three key/value pairs. It then displays the definitions for Queue, SortedList, and Stack, in that order:

    Visual C# Code:
    1. // C#
    2. SortedList sl = new SortedList();
    3. sl.Add("Stack", "Represents a LIFO collection of objects.");
    4. sl.Add("Queue", "Represents a FIFO collection of objects.");
    5. sl.Add("SortedList", "Represents a collection of key/value pairs.");
    6. foreach (DictionaryEntry de in sl)
    7.     Console.WriteLine(de.Value);

    Notice that SortedList is an array of DictionaryEntry objects. As the previous code sample demonstrates, you can access the objects you originally added to the SortedList using the DictionaryEntry.Value property. You can access the key using the DictionaryEntry.Key property.
    You can also access values directly by accessing the SortedList as a collection. The following code sample (which builds upon the previous code sample) displays the definitionfor Queue twice. Queue is the first entry in the zero-based index because the SortedList instance automatically sorted the keys alphabetically:

    Visual C# Code:
    1. // C#
    2. Console.WriteLine(sl["Queue"]);
    3. Console.WriteLine(sl.GetByIndex(0));

    The ListDictionary class (in the System.Collections.Specialized namespace) also providessimilar functionality, and is optimized to perform best with lists of fewer than 10 items. HybridDictionary (also in the System.Collections.Specialized namespace) provides the same performance as ListDictionary with small lists, but it scales better when the list is expanded.
    While SortedList can take an object of any type as its value (but only strings as keys), the StringDictionary class (in the System.Collections.Specialized namespace) provides similar functionality, without the automatic sorting, and requires both the keys and the values to be strings.
    NameValueCollection also provides similar functionality, but it allows you to use either a string or an integer index for the key. In addition, you can store multiple string values for a single key. The following code sample demonstrates this by displaying two definitions for the terms stack and queue:


    Visual C# Code:
    1. // C#
    2. NameValueCollection sl = new NameValueCollection();
    3. sl.Add("Stack", "Represents a LIFO collection of objects.");
    4. sl.Add("Stack", "A pile of pancakes.");
    5. sl.Add("Queue", "Represents a FIFO collection of objects.");
    6. sl.Add("Queue", "In England, a line.");
    7. sl.Add("SortedList", "Represents a collection of key/value pairs.");
    8. foreach (string s in sl.GetValues(0))
    9.     Console.WriteLine(s);
    10. foreach (string s in sl.GetValues("Queue"))
    11.     Console.WriteLine(s);
    --Vocabulary –
    4. switches : Sự chuyển đổi, công tắc
    5. retrieval : Sự lấy lại, thu hồi.
    6. similar functionality : Các hàm có chức năng tương tự.
    7. terms : Điều khiển, điều khoản.

    Tóm lại:
    Bài học ngày hum nay của chúng ta không khó! Các vốn từ vựng các bạn đều gặp ở các bài trước, đặc biệt ở bài 1 mình đã nêu ra rất nhiều. Các bạn hãy đọc và xem giáo trình để làm các Lab bài tập ở sau mỗi bài học nhé! Vậy mấu chốt là gì? Các bạn phải hiểu được thế nào là Collection và có bao nhiêu cách triển khai nó, áp dụng trong hoàn cảnh nào. Ở các bài kế tiếp các bạn sẽ được tìm hiểu chi tiết hơn.
    Mình có 1 bài tập nhỏ dành cho các bạn: Hãy viết chương trình chuyển đổi từ hệ số 10 sang hệ số 2 dùng Stack. Bài này không khó, các bạn chỉ cần hiểu cách thức chuyển từ hệ số 10 sang hệ số 2 và cơ chế của Stack (LIFO) mà áp dụng. Tuyệt đối không được sử dụng các chức năng chuyển đổi sẵn có của .net..
    Hỏi một câu thì chỉ dốt trong chốc lát.Nhưng nếu không hỏi thì bạn sẽ dốt suốt đời.

    Seeing much, suffering much, and studying much, are the three pillars of learning.
    Website:www.vinilearning.com

  2. #2
    Ngày gia nhập
    12 2009
    Nơi ở
    Hà Nội
    Bài viết
    535

    Thank bác. Bài viết rất hay.
    Trong namespace System.Collection còn có cấu trúc hashtable cũng lưu trữ các cặp key-value cũng như sortedlist. Các bạn xem thêm namespace System.Collection.Generic. Có rất nhiều kiểu dữ liệu hay. Chắc anh snake_programmer sẽ post ở phần tiếp.

  3. #3
    Ngày gia nhập
    12 2009
    Nơi ở
    Cần Thơ
    Bài viết
    47

    Thanks Bác, tôi theo dõi bài viết của bác từ đầu tới giờ , và nhận thấy bài viết của bác rất hay.
    Chúc bác vạn sự thành công

  4. #4
    Ngày gia nhập
    04 2009
    Nơi ở
    Hà Nội
    Bài viết
    692

    Trong bài học trước các bạn đã được làm quen với Collection và Dictionaries. Ở bài học này chúng ta sẽ đi tìm hiểu về Generic Collections. Như các bạn biết, kiểu Generic là kiểu chung chung, có nghĩa là ở bài học này chúng ta sẽ tạo ra Collection không chỉ của riêng 1 kiểu nào đó, mà chúng ta sẽ học cách tạo ra Collection chung rồi ứng với từng thể hiện, ta sẽ truyền vào cho nó.
    Bài học này không có nhiều từ mới, các bạn hãy nắm bắt tốt kiến thức của bài học.

    Lesson 2: Generic Collections

    Collections like ArrayList, Queue, and Stack use the Object base class to allow them to
    work with any type. However, accessing the collection usually requires you to cast
    from the base Object type to the correct type. Not only does this make development
    tedious and more error-prone, but it hurts performance.
    Using generics, you can create strongly typed collections for any class, including cus-
    tom classes. This simplifies development within the Visual Studio editor, helps ensure
    appropriate use of types, and can improve performance by reducing the need to cast.
    After this lesson, you will be able to:
    • Explain why you should use generic collections
    • Use the SortedList generic collection
    • Use generics with custom classes
    • Use the Queue and Stack collection generically
    • Use the generic List collection
    Estimated lesson time: 30 minutes

    Generics Overview
    Many of the collections in the .NET Framework support adding objects of any type,
    such as ArrayList. Others, like StringCollection, are strongly typed. Strongly typed
    classes are easier to develop with because the Visual Studio designer can list and
    validatemembers automatically. In addition, you do not need to cast classes to more
    specific types, and you are protected from casting to an inappropriate type.
    Generics provide many of the benefits of strongly typed collections, but they can work
    with any type that meets the requirements. In addition, using generics can improve per-
    formance by reducing the number of casting operations required. Table 4-1 lists the most
    useful generic collection classes and the corresponding nongeneric collection type.

    --Vocabulary—
    1. benefits: Lợi ích.
    2. inappropriate :Không thích hợp, thích đáng.
    3. requirements : Nhu cầu, đòi hỏi.

    Table 4-1 Generic Collection Classes
    Generic Class Comparable Nongeneric Classes
    List<T> ArrayList, StringCollection
    Dictionary<T,U> Hashtable, ListDictionary, HybridDictionary,
    OrderedDictionary, NameValueCollection, StringDictionary
    Queue<T> Queue
    Stack<T> Stack
    SortedList<T,U> SortedList
    Collection<T> CollectionBase

    ReadOnlyCollection<T> ReadOnlyCollectionBase
    Generic SortedList<T,U> Collection

    The following code sample creates a generic SortedList<T,U> using strings as the keys
    and integers as the values. As you type this code into the Visual Studio editor, notice
    that it prompts you to enter string and integer parameters for the SortedList.Add
    method as if SortedList.Add were strongly typed:

    Visual C# Code:
    1. // C#
    2. SortedList<string, int> sl = new SortedList<string,int>();
    3. sl.Add("One", 1);
    4. sl.Add("Two", 2);
    5. sl.Add("Three", 3);
    6. foreach (int i in sl.Values)
    7.     Console.WriteLine(i.ToString());

    In Visual Basic, specify the type arguments for the generic class using the constructor
    parameters by specifying the Of keyword. In C#, specify the type arguments using
    angle brackets before the constructor parameters.

    Using Generics with Custom Classes
    You can use generics with custom classes as well. Consider the following class declaration:

    Visual C# Code:
    1. // C#
    2. public class person
    3. {
    4.     string firstName;
    5.     string lastName;
    6.     public person(string _firstName, string _lastName)
    7.     {
    8.         firstName = _firstName;
    9.         lastName = _lastName;
    10.     }
    11.     override public string ToString()
    12.     {
    13.         return firstName + " " + lastName;
    14.     }
    15. }

    You can use the SortedList<T,U> generic class with the custom class exactly as you
    would use it with an integer, as the following code sample demonstrates:

    Visual C# Code:
    1. // C#
    2. SortedList<string, person> sl = new SortedList<string,person>();
    3. sl.Add("One", new person("Mark", "Hanson"));
    4. sl.Add("Two", new person("Kim", "Akers"));
    5. sl.Add("Three", new person("Zsolt", "Ambrus"));
    6. foreach (person p in sl.Values)
    7.     Console.WriteLine(p.ToString());

    Generic Queue<T> and Stack<T> Collections
    Similarly, the following code sample demonstrates using the generic versions of both
    Queue and Stack with the person class:

    Visual C# Code:
    1. // C#
    2. Queue<person> q = new Queue<person>();
    3. q.Enqueue(new person("Mark", "Hanson"));
    4. q.Enqueue(new person("Kim", "Akers"));
    5. q.Enqueue(new person("Zsolt", "Ambrus"));
    6. Console.WriteLine("Queue demonstration:");
    7. for (int i = 1; i <= 3; i++)
    8.     Console.WriteLine(q.Dequeue().ToString());
    9. Stack<person> s = new Stack<person>();
    10. s.Push(new person("Mark", "Hanson"));
    11. s.Push(new person("Kim", "Akers"));
    12. s.Push(new person("Zsolt", "Ambrus"));
    13. Console.WriteLine("Stack demonstration:");
    14. for (int i = 1; i <= 3; i++)
    15.     Console.WriteLine(s.Pop().ToString());

    Generic List<T> Collection
    Some aspects of generic collections might require specific interfaces to be imple-
    mented by the type you specify. For example, calling List.Sort without any parameters
    requires the type to support the IComparable interface. The following code sample
    expands the person class to support the IComparable interface and the required
    CompareTo method and allows it to be sorted in a List<T> generic collection using the
    person’s first and last name:

    Visual C# Code:
    1. // C#
    2. public class person : IComparable
    3. {
    4.     string firstName;
    5.     string lastName;
    6.     public int CompareTo(object obj)
    7.     {
    8.         person otherPerson = (person)obj;
    9.         if (this.lastName != otherPerson.lastName)
    10.             return this.lastName.CompareTo(otherPerson.lastName);
    11.         else
    12.             return this.firstName.CompareTo(otherPerson.firstName);
    13.     }
    14.     public person(string _firstName, string _lastName)
    15.     {
    16.         firstName = _firstName;
    17.         lastName = _lastName;
    18.     }
    19.     override public string ToString()
    20.     {
    21.         return firstName + " " + lastName;
    22.     }
    23. }

    After adding the IComparable interface to the person class, you now can sort it in a
    generic List<T>, as the following code sample demonstrates:

    Visual C# Code:
    1. // C#
    2. List<person> l = new List<person>();
    3. l.Add(new person("Mark", "Hanson"));
    4. l.Add(new person("Kim", "Akers"));
    5. l.Add(new person("Zsolt", "Ambrus"));
    6. l.Sort();
    7. foreach (person p in l)
    8.     Console.WriteLine(p.ToString());
    With the IComparable interface implemented, you could also use the person class as
    the key in a generic SortedList<T,U> or SortedDictionary<T,U> class.

    Cuối cùng là các bạn hãy làm các bài Lab trong giáo trình nhé!
    Hỏi một câu thì chỉ dốt trong chốc lát.Nhưng nếu không hỏi thì bạn sẽ dốt suốt đời.

    Seeing much, suffering much, and studying much, are the three pillars of learning.
    Website:www.vinilearning.com

Các đề tài tương tự

  1. So sánh Generics giữa C# và Java?
    Gửi bởi hatnang trong diễn đàn Thắc mắc lập trình Java
    Trả lời: 4
    Bài viết cuối: 19-09-2013, 11:22 AM
  2. Tài liệu lập trình C sharp | C# ebooks collections
    Gửi bởi tieubavuong trong diễn đàn Công cụ, ebooks C#, ASP.NET, và Windows Mobile
    Trả lời: 6
    Bài viết cuối: 04-03-2011, 09:17 AM
  3. Bài 2: Chapter 1 - Framework Fundamentals
    Gửi bởi snake_programmer trong diễn đàn English for IT | Tiếng anh cho dân CNTT
    Trả lời: 12
    Bài viết cuối: 02-03-2011, 11:42 PM
  4. Bài 3: Chapter 2 Input/Output
    Gửi bởi snake_programmer trong diễn đàn English for IT | Tiếng anh cho dân CNTT
    Trả lời: 6
    Bài viết cuối: 11-01-2011, 09:34 PM
  5. C/C++/VC++ ebooks collections (English only)
    Gửi bởi tieubavuong trong diễn đàn Tài liệu, ebooks và công cụ
    Trả lời: 0
    Bài viết cuối: 22-03-2009, 08:03 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn