using System;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.ComponentModel;
using System.Runtime.Remoting;
using System.Threading;

public class ExtendedSqlDataAdapter : IDbDataAdapter, IDataAdapter
{
    SqlDataAdapter _adapter;
    int _fillTimeout;

    public ExtendedSqlDataAdapter()
    {
        _fillTimeout = 0;
        _adapter = new SqlDataAdapter();
        InitializeEvents();
    }

    public ExtendedSqlDataAdapter(SqlCommand selectCommand)
    {
        _adapter = new SqlDataAdapter(selectCommand);
        InitializeEvents();
    }

    public ExtendedSqlDataAdapter(string selectCommandText, SqlConnection selectConnection)
    {
        _adapter = new SqlDataAdapter(selectCommandText, selectConnection);
        InitializeEvents();
    }

    public ExtendedSqlDataAdapter(string selectCommandText, string selectConnectionString)
    {
        _adapter = new SqlDataAdapter(selectCommandText, selectConnectionString);
        InitializeEvents();
    }

    private void InitializeEvents()
    {
        _adapter.Disposed += new EventHandler(BubbleDisposed);
        _adapter.FillError += new FillErrorEventHandler(BubbleFillError);
        _adapter.RowUpdated += new SqlRowUpdatedEventHandler(BubbleRowUpdated);
        _adapter.RowUpdating += new SqlRowUpdatingEventHandler(BubbleRowUpdating);
    }

    public bool AcceptChangesDuringFill
    {
        get { return _adapter.AcceptChangesDuringFill; }
        set { _adapter.AcceptChangesDuringFill = value; }
    }

    public bool AcceptChangesDuringUpdate
    {
        get { return _adapter.AcceptChangesDuringUpdate; }
        set { _adapter.AcceptChangesDuringUpdate = value; }
    }

    public IContainer Container
    {
        get { return _adapter.Container; }
    }

    public bool ContinueUpdateOnError
    {
        get { return _adapter.ContinueUpdateOnError; }
        set { _adapter.ContinueUpdateOnError = value; }
    }

    public ObjRef CreateObjRef(Type requestedType)
    {
        return _adapter.CreateObjRef(requestedType);
    }

    public IDbCommand DeleteCommand
    {
        get { return _adapter.DeleteCommand; }
        set { _adapter.DeleteCommand = (SqlCommand)value; }
    }

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

    public event EventHandler Disposed;

    private void BubbleDisposed(Object sender, EventArgs e)
    {
        if (this.Disposed != null)
            this.Disposed(sender, e);
    }

    public new bool Equals(object obj)
    {
        return _adapter.Equals(obj);
    }

    public int FillTimeout
    {
        get { return _fillTimeout; }
        set { _fillTimeout = value; }
    }

    public int Fill(DataSet dataSet)
    {
        if (_fillTimeout == 0)
        {
            return _adapter.Fill(dataSet);
        }
        else
        {
            int rows = 0;
            Thread fillThread = new Thread(delegate() { rows = _adapter.Fill(dataSet); });
            fillThread.Start();
            if (fillThread.Join(_fillTimeout * 1000))
            {
                return rows;
            }
            else
            {
                try
                {
                    fillThread.Abort();
                }
                catch (ThreadAbortException)
                {
                    Thread.ResetAbort();
                }
                throw new TimeoutException();
            }
        }
    }

    public int Fill(DataTable dataTable)
    {
        if (_fillTimeout == 0)
        {
            return _adapter.Fill(dataTable);
        }
        else
        {
            int rows = 0;
            Thread fillThread = new Thread(delegate() { rows = _adapter.Fill(dataTable); });
            fillThread.Start();
            if (fillThread.Join(_fillTimeout * 1000))
            {
                return rows;
            }
            else
            {
                try
                {
                    fillThread.Abort();
                }
                catch (ThreadAbortException)
                {
                    Thread.ResetAbort();
                }
                throw new TimeoutException();
            }
        }
    }

    public int Fill(DataSet dataSet, string srcTable)
    {
        if (_fillTimeout == 0)
        {
            return _adapter.Fill(dataSet, srcTable);
        }
        else
        {
            int rows = 0;
            Thread fillThread = new Thread(delegate() { rows = _adapter.Fill(dataSet, srcTable); });
            fillThread.Start();
            if (fillThread.Join(_fillTimeout * 1000))
            {
                return rows;
            }
            else
            {
                try
                {
                    fillThread.Abort();
                }
                catch (ThreadAbortException)
                {
                    Thread.ResetAbort();
                }
                throw new TimeoutException();
            }
        }
    }        

    public int Fill(int startRecord, int maxRecords, params DataTable[] dataTables)
    {
        if (_fillTimeout == 0)
        {
            return _adapter.Fill(startRecord, maxRecords, dataTables);
        }
        else
        {
            int rows = 0;
            Thread fillThread = new Thread(delegate() { rows = _adapter.Fill(startRecord, maxRecords, dataTables); });
            fillThread.Start();
            if (fillThread.Join(_fillTimeout * 1000))
            {
                return rows;
            }
            else
            {
                try
                {
                    fillThread.Abort();
                }
                catch (ThreadAbortException)
                {
                    Thread.ResetAbort();
                }
                throw new TimeoutException();
            }
        }
    }

    public int Fill(DataSet dataSet, int startRecord, int maxRecords, string srcTable)
    {
        if (_fillTimeout == 0)
        {
            return _adapter.Fill(dataSet, startRecord, maxRecords, srcTable);
        }
        else
        {
            int rows = 0;
            Thread fillThread = new Thread(delegate() { rows = _adapter.Fill(dataSet, startRecord, maxRecords, srcTable); });
            fillThread.Start();
            if (fillThread.Join(_fillTimeout * 1000))
            {
                return rows;
            }
            else
            {
                try
                {
                    fillThread.Abort();
                }
                catch (ThreadAbortException)
                {
                    Thread.ResetAbort();
                }
                throw new TimeoutException();
            }
        }
    }

    public event EventHandler FillError;

    private void BubbleFillError(Object sender, EventArgs e)
    {
        if (this.FillError != null)
            this.FillError(sender, e);
    }

    public LoadOption FillLoadOption
    {
        get { return _adapter.FillLoadOption; }
        set { _adapter.FillLoadOption = value; }
    }

    public DataTable[] FillSchema(DataSet dataSet, SchemaType schemaType)
    {
        return FillSchema(dataSet, schemaType);
    }

    public DataTable FillSchema(DataTable dataTable, SchemaType schemaType)
    {
        return FillSchema(dataTable, schemaType);
    }

    public DataTable[] FillSchema(DataSet dataSet, SchemaType schemaType, string srcTable)
    {
        return FillSchema(dataSet, schemaType, srcTable);
    }

    public IDataParameter[] GetFillParameters()
    {
        return _adapter.GetFillParameters();
    }

    public object GetLifetimeService()
    {
        return GetLifetimeService();
    }

    public object InitializeLifetimeService()
    {
        return InitializeLifetimeService();
    }

    public IDbCommand InsertCommand
    {
        get { return _adapter.InsertCommand; }
        set { _adapter.InsertCommand = (SqlCommand)value; }
    }

    public MissingMappingAction MissingMappingAction
    {
        get { return _adapter.MissingMappingAction; }
        set { _adapter.MissingMappingAction = value; }
    }

    public MissingSchemaAction MissingSchemaAction
    {
        get { return _adapter.MissingSchemaAction; }
        set { _adapter.MissingSchemaAction = value; }
    }

    public bool ReturnProviderSpecificTypes
    {
        get { return _adapter.ReturnProviderSpecificTypes; }
        set { _adapter.ReturnProviderSpecificTypes = value; }
    }

    public event EventHandler RowUpdated;

    private void BubbleRowUpdated(Object sender, EventArgs e)
    {
        if (this.RowUpdated != null)
            this.RowUpdated(sender, e);
    }

    public event EventHandler RowUpdating;

    private void BubbleRowUpdating(Object sender, EventArgs e)
    {
        if (this.RowUpdating != null)
            this.RowUpdating(sender, e);
    }

    public IDbCommand SelectCommand
    {
        get { return _adapter.SelectCommand; }
        set { _adapter.SelectCommand = (SqlCommand)value; }
    }

    public ISite Site
    {
        get { return _adapter.Site; }
        set { _adapter.Site = value; }
    }

    public ITableMappingCollection TableMappings
    {
        get { return _adapter.TableMappings; }
    }

    public new string ToString()
    {
        return _adapter.ToString();
    }

    public int Update(DataRow[] dataRows)
    {
        return _adapter.Update(dataRows);
    }

    public int Update(DataSet dataSet)
    {
        return _adapter.Update(dataSet);
    }

    public int Update(DataTable dataTable)
    {
        return _adapter.Update(dataTable);
    }

    public int Update(DataSet dataSet, string srcTable)
    {
        return _adapter.Update(dataSet, srcTable);
    }

    public int UpdateBatchSize
    {
        get { return _adapter.UpdateBatchSize; }
        set { _adapter.UpdateBatchSize = value; }
    }

    public IDbCommand UpdateCommand
    {
        get { return _adapter.UpdateCommand; }
        set { _adapter.UpdateCommand = (SqlCommand)value; }
    }
}