Generic Programming & Collection
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Generic Programming & Collection

on

  • 627 views

Coba tok

Coba tok

Statistics

Views

Total Views
627
Views on SlideShare
627
Embed Views
0

Actions

Likes
0
Downloads
7
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Generic Programming & Collection Presentation 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