Your SlideShare is downloading. ×
Generic Programming & Collection
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Generic Programming & Collection


Published on

Coba tok

Coba tok

Published in: Technology

  • Be the first to comment

  • Be the first to like this

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1. GENERIC programming & COLLECTION
    Adhatus Solichah A.
  • 2. Course Structure
    Interfaces of the System.Collections
    Generic methods, class, base class, interface
  • 3. System.Array
    The most primitive container construct
    Provides services, e.g. reversing, sorting, clearing, and enumerating
    Has fixed upper limit
    it does not automatically resize itself as we add or clear items
  • 4. System.Collections
    contain types in a more flexible container
    The System.Collections namespace defines a number of interfaces
  • 5. Interfaces of System.Collections
  • 6. System.Collections Interface Hierarchy
  • 7. ICollection
    The most primitive interface of System.Collections
    ICollection extends IEnumerable
    Provide small set of member to determine:
    the number of items in the container,
    thethread safety of the container,
    the ability to copy the contents into a System.Array type.
    public interface ICollection : IEnumerable
    int Count { get; }
    bool IsSynchronized { get; }
    object SyncRoot { get; }
    void CopyTo(Array array, int index);
  • 8. IDictionary
    public interface IDictionary :
    ICollection, IEnumerable
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    object this[object key] { get; set; }
    ICollection Keys { get; }
    ICollection Values { get; }
    void Add(object key, object value);
    void Clear();
    bool Contains(object key);
    IDictionaryEnumerator GetEnumerator();
    void Remove(object key);
    collection that maintains a set of name/value pairs
    IDictionary interface defines a Keys and Values property as well as Add(), Remove(), and Contains() methods.
  • 9. IDictionaryEnumerator
    IDictionaryEnumerator is simply a strongly typed enumerator, given that it extends IEnumerator
    IDictionaryEnumeratorallows to enumerate over items in the dictionary viathe generalized Entry property
    Ability to traverse the name/value pairs using the Key/Value properties. (sorting)
    public interface IDictionaryEnumerator : IEnumerator
    DictionaryEntry Entry { get; }
    object Key { get; }
    object Value { get; }
  • 10. IList
    provides the ability to insert, remove,and index items into (or out of) a container
    public interface IList :
    ICollection, IEnumerable
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    object this[ int index ] { get; set; }
    int Add(object value);
    void Clear();
    bool Contains(object value);
    int IndexOf(object value);
    void Insert(int index, object value);
    void Remove(object value);
    void RemoveAt(int index);
  • 11. Classes of System.Collections
  • 12. Working with the ArrayList Type
    making use of the AddRange() method to populate ArrayList
    Insert() allows to plug a new item into theArrayList at a specified index. (zero based index)
    the call to the ToArray() methodreturns an array of System.Object typesbased on the contents of the original ArrayList.
  • 13. Working with the Queue Type
    Queues are containers that ensure items are accessed using a first-in, first-out manner
  • 14. Working with the Stack Type
    represents a collection that maintains items using a last-in, first-out manner.
    Stack defines a member named Push() and Pop()
  • 15. Boxing & Unboxing
    Value type  Ref type
    Ref type  Value type
    // Make a short value type.
    short s = 25;
    // Box the value into an object reference.
    object objShort = s;
    // Unbox the reference back into a corresponding short.
    short anotherShort = (short)objShort;
  • 16. Boxing & Unboxing
    A new object must be allocated on the managed heap.
    The value of the stack-based data must be transferred into that memory location.
    When unboxed, the value stored on the heap-based object must be transferred back to the stack.
    The now unused object on the heap will (eventually) be garbage collected.
  • 17. System.Collections.Generic
    Contains numerous class and interface types that allow you to contain subitems in a variety of containers
    generic interfaces mimic the corresponding nongeneric types in the System.Collections
  • 18. ::Non-generic::
    class Bucket{
    public string items;
    class Bucket<T>{
    public T item;
    public void Add(T value);
    public T GetItem();
  • 19. Classes of System.Collections.Generic
  • 20. Limitations of Custom Generic Collections
    Possible Constraints for Generic Type Parameters
  • 21. Creating Generic Base Classes
    generic classes can be the base class to other classes
    // Assume you have created a custom
    // generic list class.
    public class MyList<T>
    private List<T> listOfData = new List<T>();
    // Concrete types must specify the typeparameter when deriving from a
    // generic base class.
    public class MyStringList : MyList<string>
    public class MyStringList<T> : MyList<T>
  • 22. Creating Generic Interfaces
    public interface IBinaryOperations<T> where T : struct
    T Add(T arg1, T arg2);
    T Subtract(T arg1, T arg2);
    T Multiply(T arg1, T arg2);
    T Divide(T arg1, T arg2);
  • 23. Next.......
    Delegate, Events and Lambdas