Cách lập trình tập hợp cho dữ liệu đã duyệt trong C#?

[OWickedFox]

Chào các anh chị, các bạn,

Hiện tôi đang làm một chương trình mô phỏng theo TotalCommander nhưng code trên C#. Tôi đang phân vân về việc xây dựng một cơ chế có thể lưu lại 'history of folder-path' mà tôi đã duyệt qua.

Ví dụ tôi muốn tập hợp này gồm 32 chỗ chứa, mỗi lần duyệt qua một đường dẫn thư mục (nếu OK) thì tập hợp này sẽ add đường dẫn vừa duyệt. Đến một lúc nào đó khi tôi duyệt hết 32 lần thì tập hợp này sẽ tự remove phần tử đầu tiên và sẽ add tiếp một phần tử mới vào cuối tập hợp khi duyệt tiếp (con trỏ luôn trỏ tới phần tử cuối trong tập hợp).

Chương trình của tôi sẽ có 2 nút 'Next' và 'Previous' để thao tác với tập hợp này (2 nút này sẽ ẩn hiện ứng với vị trí đang trỏ tới trong tập hợp).

Các anh chị, các bạn có thể đề xuất cho tôi một hướng làm được không? Nếu anh chị, các bạn không chê cười và muốn góp sức thực hiện project này có thể cho tôi địa chị mail và tôi sẽ invite các anh chị vào SVN host project này tại Assembla.com

Cám ơn rất nhiều

[anhtuyenbk]

Bạn nghiên cứu lớp List<>
nó có đủ các phương thức như add, insert, delete... để giúp bạn làm cái tập hợp đó dễ dàng
Ví dụ

List<string> list = new List<string> ();list.Add("1");list.Add("2");list.Add("3");list.Add("4");........

[OWickedFox]

Bạn nghiên cứu lớp List<>
nó có đủ các phương thức như add, insert, delete... để giúp bạn làm cái tập hợp đó dễ dàng
Ví dụ

List<string> list = new List<string> ();list.Add("1");list.Add("2");list.Add("3");list.Add("4");........

Cám ơn bạn rất nhiều, mình đã tìm hiểu kể cả Stack và Queue trước đó rồi. Lớp List<T> mình muốn tập hợp của mình có một Capacity nhất định = 32, trong khi List sẽ tự tăng không gian chứa có nghĩa nó cũng không tự remove phần tử đầu tiên.

Theo ý mình nên viết một tập hợp gần như LinkedList và Queue. Cũng đang tìm tòi nhiều...

Nếu bài viết của mình có khó hiểu thì xin các bạn hãy liên tưởng tới cách hoạt động của 2 nút 'Next' và 'Previous' trên trình duyệt web.

Cám ơn

[OWickedFox]

Phù, rốt cuộc cũng có thể làm được một số yêu cầu về cái tập hợp này. Sau đây mình xin phép được share code nếu có bạn nào cần.

Trước hết tập hợp này gần giống như Queue, vì nó sẽ có một không gian chứa nhất định và không tự gia tăng kích thước khi đầy.

/// <summary>    ///     /// Represent a FIFO collection of object. It have a specified capacity and    /// will automatically remove its element when out of container-space.    ///     /// This class cannot be inherited.    ///     /// </summary>    ///     /// <typeparam name="T">Type-Generic</typeparam>    public sealed class HistoryQueue<T> : IEnumerable<T>    {        private T[] mContainerSpace;         private const int DEFAULT_CAPACITY = 5;         private int mSize;         private int iHead, iTail;         /// <summary>        ///         /// Constructor for a new <code>HistoryQueue<T></code>.        ///         /// </summary>        public HistoryQueue()        {            mContainerSpace = new T[DEFAULT_CAPACITY];             mSize = iHead = iTail = 0;        }         /// <summary>        ///         /// If the <code>HistoryQueue</code> is full, it will automatically remove the first element,        /// and then add the new element.        ///         /// </summary>        ///         /// <param name="element">New element</param>        public void Enqueue(T element)        {            // Size is full...            if (IsFull())            {                Dequeue(); // Removes the first element.                 NormalEnqueue(element); // Adds new element then.            }            else                NormalEnqueue(element);        }         /// <summary>        ///         /// Adds a new element to the last place of <code>HistoryQueue</code> normally.        ///         /// </summary>        ///         /// <param name="element">New element</param>        private void NormalEnqueue(T element)        {            mContainerSpace[iTail] = element;             iTail = (iTail + 1) % mContainerSpace.Length;             mSize++;        }         /// <summary>        ///         /// Removes element at the first place in <code>HistoryQueue</code>.        ///         /// </summary>        public void Dequeue()        {            // Queue is empty...            if (IsEmpty())                throw new InvalidOperationException("Cannot dequeue when there is no element in queue.");             mContainerSpace[iHead] = default(T);             iHead = (iHead + 1) % mContainerSpace.Length;             mSize--;        }         /// <summary>        ///         /// Clears all element in <code>HistoryQueue</code>.        ///         /// </summary>        public void Clear()        {            if (iHead < iTail)                Array.Clear(mContainerSpace, iHead, mSize);            else            {                Array.Clear(mContainerSpace, iHead, mContainerSpace.Length - iHead);                Array.Clear(mContainerSpace, 0, iTail);            }            mSize = iHead = iTail = 0;        }         /// <summary>        ///         /// Check if the <code>HistoryQueue</code> is full.        ///         /// </summary>        ///         /// <returns><code>true</code> if the <code>HistoryQueue</code> is full; otherwise <code>false</code>.</returns>        public bool IsFull()        {            return mSize == mContainerSpace.Length;        }         /// <summary>        ///         /// Check if the <code>HistoryQueue</code> is empty.        ///         /// </summary>        ///         /// <returns><code>true</code> if the <code>HistoryQueue</code> is full; otherwise <code>false</code>.</returns>        public bool IsEmpty()        {            return mSize == 0;        }...// Code for IEnumerator<T> comming soon...

Trước đây mình cũng đã làm việc nhiều với lập trình Generic bên Java và biết qua Interface là Iterator dùng để duyệt tập hợp. Mình cũng tìm hiểu được một Interface tương tự như trong C# đó là IEnumerator<T> mình cũng đã viết và demo thử cho HistoryQueue thành công, tuy nhiên mình cần sửa chữa lại một tí và sẽ post trong thời gian ngắn nhất (do mình muốn khi duyệt qua HistoryQueue thì duyệt từ cuối đến đầu theo yêu cầu bài toán của mình - con trỏ lun trỏ tới phần tử cuối).

[OWickedFox]

Chào các bạn,

Mình đã hoàn thành phần Enumerator cho duyệt dữ liệu, và test vấn đề của mình. Nhưng đã có một vài vấn đề nảy sinh như sau:

Trước hết minh xin tóm tắt lại
+ Mình muốn có một navigator giống như 2 nút Next và Previous trên trình duyệt web hoặc giống như cơ chế Undo và Redo, nhưng những Collection trong .NET theo mình nghĩ chưa hỗ trợ được cho bài toán của mình. Collection mình cần là sẽ Add phần tử vào đầu danh sách, khi đã đầy thì sẽ tự xóa phần tử ở cuối và add tiếp vào đầu.

+ Để làm một cơ chế Navigator thì phải cần tới 2 Collection như vậy. Khi muốn duyệt ngược (undo) về một phần tử thì sẽ Peek phần tử đầu trong danh sách 1 và add nó vào danh sách 2. Như vậy phương thức Peek sẽ lấy và remove phần tử đầu tiên trong collection. Khi muốn duyệt tới phần tử trước đó (redo) thì sẽ Peek phần tử đầu trong danh sách 2 và add nó lại vào danh sách 1. Và trong phương thức Peek của mình đã xảy ra một số vấn đề. Mình xin đưa code sau để các bạn tham khảo và nếu có thể phát hiện và giúp mình thì mình rất trân trọng.

Trước hết là về Code cho Collection:

using System;using System.Collections.Generic; namespace SharpCodeHunter.SharpCommander.Data{    /// <summary>    ///     /// An <code>Interface</code> to build a history-factory.    ///     /// </summary>    public interface IHistoryFactory<T>    {        /// <summary>        ///         /// Checks if there is more next element to point.        ///         /// </summary>        ///         /// <returns><c>true</c> if there is still more next element; otherwise <c>false</c>.</returns>        bool HasNext();                /// <summary>        ///         /// Moves to the next element.        ///         /// </summary>        ///         /// <returns>Next element.</returns>        T MoveNext();                /// <summary>        ///         /// Sets the pointer to its first initializing position.        ///         /// </summary>        void Reset();    }}

using System; namespace SharpCodeHunter.SharpCommander.Data{    /// <summary>    ///     /// Represents a FIFO collection of object. It has a specified capacity and    /// will automatically remove its element when out of container-space.    ///     /// This class cannot be inherited.    ///     /// </summary>    ///     /// <author>O'Wicked Fox</author>    ///     /// <typeparam name="T">Type-Generic</typeparam>    public sealed class HistoryQueue<T>    {        #region --- field(s) ---                private T[] mContainerSpace;         private const int DEFAULT_CAPACITY = 5;         private int mSize;         private int iHead, iTail;                #endregion                #region --- constructor(s) ---                /// <summary>        ///         /// Constructs a new <code>HistoryQueue<T></code>.        ///         /// </summary>        public HistoryQueue()        {            mContainerSpace = new T[DEFAULT_CAPACITY];             mSize = iHead = iTail = 0;        }                #endregion         #region --- method(s) ---         /// <summary>        ///         /// If the <c>HistoryQueue</c> is full, it will automatically dequeue the first element,        /// and then enqueue the new element.        ///         /// </summary>        ///         /// <param name="element">New element.</param>        public void Enqueue(T element)        {            // Size is full...            if (IsFull)            {                Dequeue(); // Dequeues the first element.                 NormalEnqueue(element); // Enqueues new element then.            }            else                NormalEnqueue(element);        }         /// <summary>        ///         /// Enqueues a new element to the tail-index of <c>HistoryQueue</c> normally.        ///         /// </summary>        ///         /// <param name="element">New element.</param>        private void NormalEnqueue(T element)        {            mContainerSpace[iTail] = element;             iTail = (iTail + 1) % mContainerSpace.Length;             mSize++;        }         /// <summary>        ///         /// Dequeues element at head-index in <c>HistoryQueue</c>.        ///         /// </summary>        ///         ///<returns></returns>        public void Dequeue()        {            // Queue is empty...            if (IsEmpty)                throw new InvalidOperationException("Cannot dequeue when there is no element in queue.");             // Dequeues at head-index.            mContainerSpace[iHead] = default(T);             iHead = (iHead + 1) % mContainerSpace.Length;             mSize--;        }                /// <summary>        ///         /// Dequeues element at tail-index in <c>HistoryQueue</c>.        ///         /// </summary>        ///         /// <returns></returns>        public T Peek()        {            // Queue is empty...            if (IsEmpty)                throw new InvalidOperationException("Cannot peek when there is no element in queue.");                        T peekingOne = default(T);                        // Dequeues at tail-index.//          if (iTail == 0)//          {//              iTail = mSize;////              T peekingOne = mContainerSpace[iTail -1];////              //mContainerSpace[iTail] = default(T);////              iTail = (iTail - 1) % mContainerSpace.Length;////              //mContainerSpace[iTail] = default(T);////              mSize--;////              return peekingOne;//          }//          else if (iTail < 0) {//              iTail = Math.Abs(1 - mSize);////              T peekingOne = mContainerSpace[iTail];////              iTail = (iTail) % mContainerSpace.Length;////              mSize--;////              return peekingOne;//          }                        if (iTail % mSize == 0)            {                if (iTail == 0)                {                    iTail = mSize - 1;                                        peekingOne = mContainerSpace[iTail];                                        mContainerSpace[iTail] = default(T);                                        iTail = iTail % mContainerSpace.Length;                                        mSize--;                }                else                {                    peekingOne = mContainerSpace[iTail - 1];                                        mContainerSpace[iTail] = default(T);                                        iTail = (iTail - 1) % mContainerSpace.Length;                                        mSize--;                }                                //return peekingOne;            }            else            {                if (iTail == mContainerSpace.Length)                {                    peekingOne = mContainerSpace[iTail - 1];                                        mContainerSpace[iTail - 1] = default(T);                                        iTail = mContainerSpace.Length;                                        mSize--;                }                else                {                    peekingOne = mContainerSpace[iTail - 1];                                        mContainerSpace[iTail - 1] = default(T);                    //mSize--;                                        //mContainerSpace[iTail] = default(T);                                        //iTail = mSize - iTail;                                        mSize--;                                        iTail = mContainerSpace.Length;                }            }                        return peekingOne;        }         /// <summary>        ///         /// Dismisses all element(s) in <c>HistoryQueue</c>.        ///         /// </summary>        public void Clear()        {            if (iHead < iTail)                Array.Clear(mContainerSpace, iHead, mSize);            else            {                Array.Clear(mContainerSpace, iHead, mContainerSpace.Length - iHead);                Array.Clear(mContainerSpace, 0, iTail);            }             mSize = iHead = iTail = 0;        }                /// <summary>        ///         /// Gets a Type-Generic object by its index.        ///         /// </summary>        ///         /// <param name="index">Type-Generic object's index number.</param>        ///         /// <returns>Type-Generic element.</returns>        internal T GetElement(int index)        {            return mContainerSpace[(iHead + index) % mContainerSpace.Length];        }         /// <summary>        ///         /// Enumerates each element in <c>HistoryQueue</c> from tail to head.        ///         /// </summary>        ///         /// <returns></returns>        public IHistoryFactory<T> Enumerate()        {            return new HistoryFactory((HistoryQueue<T>)this);        }         #endregion                #region --- property(es) ---                public int Count        {            get { return mSize; }        }                /// <summary>        ///         /// Checks if the <c>HistoryQueue</c> is full.        ///         /// </summary>        ///         /// <returns><code>true</code> if the <code>HistoryQueue</code> is full; otherwise <code>false</code>.</returns>        public bool IsFull        {            get { return mSize == mContainerSpace.Length; }        }         /// <summary>        ///         /// Checks if the <code>HistoryQueue</code> is empty.        ///         /// </summary>        ///         /// <returns><code>true</code> if the <code>HistoryQueue</code> is full; otherwise <code>false</code>.</returns>        public bool IsEmpty        {            get { return mSize == 0; }        }                #endregion                #region --- nested struct(s) ---                /// <summary>        ///         /// Represents a history engine.        ///         /// </summary>        public struct HistoryFactory : IHistoryFactory<T>, IDisposable        {            #region --- fiend(s) ---                        private HistoryQueue<T> mQueue;             private int mIndex;             private T mCurrent;             #endregion                        #region --- constructor(s) ---                        /// <summary>            ///             ///             ///             /// </summary>            ///             /// <param name="queue"></param>            internal HistoryFactory(HistoryQueue<T> queue)            {                mQueue = queue;                 mIndex = mQueue.mSize;                 mCurrent = default(T);            }                        #endregion             #region --- implements IHistoryIterator<T> ---             public bool HasNext()            {                if (mIndex == -2) return false;                 --mIndex;                 if (mIndex < 0)                {                    mIndex = -2;                    mCurrent = default(T);                    return false;                }                                return true;            }                        public T MoveNext()            {                mCurrent = mQueue.GetElement(mIndex);                                return mCurrent;            }                        public void Reset()            {                mIndex = -1;                 mCurrent = default(T);            }             public T Current            {                get                {                    if (mIndex < 0)                    {                        if (mIndex == -1)                            throw new InvalidOperationException("HistoryEnumerator is not started.");                        else                            throw new InvalidOperationException("HistoryEnumerator is ended.");                    }                     return mCurrent;                }            }                        #endregion             #region --- implements IDisposable ---             public void Dispose()            {                mIndex = -2;                 mCurrent = default(T);            }             #endregion        }                #endregion    }}

Code cho form Demo

using System;using System.Drawing;using System.Windows.Forms; using SharpCodeHunter.SharpCommander.Data; namespace SharpCodeHunter.SharpCommander.Test{    /// <summary>    /// Description of FormHistoryQueueDemo.    /// </summary>    public partial class FormHistoryQueueDemo : Form    {        HistoryQueue<string> queue = new HistoryQueue<string>();        HistoryQueue<string> temp = new HistoryQueue<string>();                public FormHistoryQueueDemo()        {            InitializeComponent();        }                void ButtonEnqueueClick(object sender, EventArgs e)        {            queue.Enqueue(textboxElement.Text);                        labelElement.Text = textboxElement.Text;                        textboxElement.Clear();            textboxElement.Focus();                        this.RefreshContainerSpace();        }                void ButtonExitClick(object sender, EventArgs e)        {            this.Close();                        this.RefreshContainerSpace();        }                void MenuitemDequeueClick(object sender, EventArgs e)        {            queue.Dequeue();                        this.RefreshContainerSpace();        }                void MenuitemClearAllClick(object sender, EventArgs e)        {            queue.Clear();                        this.RefreshContainerSpace();        }                private void RefreshContainerSpace() {            listviewContainerSpace.Clear();            listviewTemp.Clear();                        IHistoryFactory<string> history = queue.Enumerate();            while (history.HasNext()) {                ListViewItem item = new ListViewItem();                item.Text=history.MoveNext();                item.ImageIndex = 0;                                listviewContainerSpace.Items.Add(item);            }                        IHistoryFactory<string> temphistory = temp.Enumerate();            while (temphistory.HasNext()) {                ListViewItem item = new ListViewItem();                item.Text=temphistory.MoveNext();                item.ImageIndex = 0;                                listviewTemp.Items.Add(item);            }                        if (listviewContainerSpace.Items.Count == 0 && listviewTemp.Items.Count == 0) {                buttonPrevious.Enabled = false;                buttonNext.Enabled = false;            }            else if (listviewContainerSpace.Items.Count == 0 && listviewTemp.Items.Count > 0) {                buttonPrevious.Enabled = false;                buttonNext.Enabled = true;            }            else if (listviewContainerSpace.Items.Count > 0 && listviewTemp.Items.Count == 0) {                buttonNext.Enabled = false;                buttonPrevious.Enabled = true;            }            else {                buttonNext.Enabled = true;                buttonPrevious.Enabled = true;            }        }                void ButtonNextClick(object sender, EventArgs e)        {            string peeknext = temp.Peek();            queue.Enqueue(peeknext);                        this.RefreshContainerSpace();                        labelElement.Text = peeknext;        }                void ButtonPreviousClick(object sender, EventArgs e)        {            string peekpre = queue.Peek();            temp.Enqueue(peekpre);                        this.RefreshContainerSpace();                        labelElement.Text = peekpre;        }    }}

Các bạn có thể xây dự giao diện như hình sau:

Các bạn thử Enqueue khoãng 8 phần tử sẽ thấy lỗi khi duyệt do iTail chưa sử lý kỹ. Tôi cũng đang cố gắng.

[OWickedFox]

Chào các bạn, mình vừa tìm được 1 project có thể giúp mình làm được bài này rùi (codeproject). Các bạn có thể tham khảo link dưới đây:

http://www.codeproject.com/KB/cs/generic_undo_redo.aspx

Cũng có những điều hay đáng học trong bài viết này.

Cheer!