Generic Programming & Collection

  • 430 views
Uploaded on

Coba tok

Coba tok

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
430
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
7
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 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
    Boxing
    Value type  Ref type
    Implicit
    Unboxing
    Ref type  Value type
    Explicit
    // 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;
    }
    ::Generic::
    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>
    {}
    //or
    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