DBTool for Oracle - Part 1

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.ComponentModel;
using Harlinn.Common;
using Harlinn.DBTool.DataSources.Oracle.DB;
using Harlinn.DBTool.Common;

namespace Harlinn.DBTool.DataSources.Oracle
{
    public class DBOracleTableIndexColumns : DBOracleElement, IDBIndexColumns
    {
        private static readonly log4net.ILog sfLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        private static void LogException(Exception exc, System.Reflection.MethodBase method)
        {
            Logger.LogException(sfLog, exc, method);
        }

        bool refreshed;

        public DBOracleTableIndexColumns()
        {
            
        }
        public DBOracleTableIndexColumns(DBOracleTableIndex parent)
            : base(parent, "Columns")
        {
            
        }

        [Browsable(false)]
        public DBOracleTableIndex Index
        {
            get
            {
                DBOracleTableIndex result = (DBOracleTableIndex)Parent;
                return result;
            }
        }

        [Browsable(false)]
        public DBOracleTableIndexColumn this[string name]
        {
            get
            {
                if (!refreshed)
                {
                    Refresh();
                }
                DBOracleTableIndexColumn result = GetChildByName<DBOracleTableIndexColumn>(name);
                return result;
            }
        }

        [Browsable(false)]
        public DBOracleTableIndexColumn this[int index]
        {
            get
            {
                if (!refreshed)
                {
                    Refresh();
                }
                DBOracleTableIndexColumn result = (DBOracleTableIndexColumn)Children[index];
                return result;
            }
        }


        public override DBOracleElementType ElementType
        {
            get 
            {
                return DBOracleElementType.UserTableIndexColumns;
            }
        }

        public override void Refresh()
        {
            try
            {
                base.Refresh();

                DBOracleTableIndex index = (DBOracleTableIndex)Parent;


                IndexColumnsReader reader = new IndexColumnsReader(index.TableOwner, index.TableName,index.IndexName);
                using (reader)
                {
                    while (reader.Read())
                    {

                        DBOracleTableIndexColumn dbElement = new DBOracleTableIndexColumn(this, reader);
                        Children.Add(dbElement);
                    }
                }
                refreshed = true;
            }
            catch (Exception exc)
            {
                LogException(exc, MethodBase.GetCurrentMethod());
                throw;
            }
        }


        public int IndexOf(IDBIndexColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            return Children.IndexOf((DBOracleTableIndexColumn)item);
        }

        public void Insert(int index, IDBIndexColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            Children.Insert(index, (DBOracleTableIndexColumn)item);
        }

        public void RemoveAt(int index)
        {
            if (!refreshed)
            {
                Refresh();
            }
            Children.RemoveAt(index);
        }

        IDBIndexColumn IList<IDBIndexColumn>.this[int index]
        {
            get
            {
                if (!refreshed)
                {
                    Refresh();
                }
                return (DBOracleTableIndexColumn)Children[index];
            }
            set
            {
                if (!refreshed)
                {
                    Refresh();
                }
                Children[index] = (DBOracleTableIndexColumn)value;
            }
        }

        public void Add(IDBIndexColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            Children.Add((DBOracleTableIndexColumn)item);
        }

        public bool Contains(IDBIndexColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            return Children.Contains((DBOracleTableIndexColumn)item);
        }

        public void CopyTo(IDBIndexColumn[] array, int arrayIndex)
        {
            if (!refreshed)
            {
                Refresh();
            }
            for (int i = 0; i < Children.Count; i++)
            {
                if (array.Length > i + arrayIndex)
                {
                    array[i + arrayIndex] = (DBOracleTableIndexColumn)Children[i];
                }
                else
                {
                    break;
                }
            }
        }

        public int Count
        {
            get 
            {
                if (!refreshed)
                {
                    Refresh();
                }
                return Children.Count;
            }
        }

        public bool IsReadOnly
        {
            get 
            {
                if (!refreshed)
                {
                    Refresh();
                }
                return ((IList<NodeBase>)Children).IsReadOnly;
            }
        }

        public bool Remove(IDBIndexColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            return Children.Remove((DBOracleTableIndexColumn)item);
        }


        private class InterfaceEnumerator : IEnumerator<IDBIndexColumn>
        {
            IEnumerator<NodeBase> enumerator;

            public InterfaceEnumerator(IEnumerator<NodeBase> enumerator)
            {
                if (enumerator == null)
                {
                    throw new ArgumentNullException("enumerator");
                }
                this.enumerator = enumerator;
            }

            public IDBIndexColumn Current
            {
                get
                {
                    return (IDBIndexColumn)enumerator.Current;
                }
            }

            public void Dispose()
            {
                enumerator.Dispose();
            }

            object System.Collections.IEnumerator.Current
            {
                get
                {
                    return (object)enumerator.Current;
                }
            }

            public bool MoveNext()
            {
                return enumerator.MoveNext();
            }

            public void Reset()
            {
                enumerator.Reset();
            }
        }

        public IEnumerator<IDBIndexColumn> GetEnumerator()
        {
            if (!refreshed)
            {
                Refresh();
            }
            return new InterfaceEnumerator(Children.GetEnumerator());
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            if (!refreshed)
            {
                Refresh();
            }
            return ((System.Collections.IEnumerable)Children).GetEnumerator();
        }
    }
}