ASP.NET

Excel.Application WRExcel = null;
            Excel.Workbooks WRwbs = null;


            Excel._Workbook WRwb = null;
            Excel.Sheets WRss = null;

            Excel._Worksheet WRws = null;
            object objOpt = System.Reflection.Missing.Value;

            if (System.IO.File.Exists("C:\\Excel1.xls"))
            {
                //Delete The Existing Excel Sheet
                System.IO.File.Delete("C:\\Excel1.xls");
            }
            //create Excel spreadsheet

            WRExcel = new Excel.Application();

            WRwb = WRExcel.Workbooks.Add(objOpt); // My Error Occurs Here

            WRss = (Excel.Sheets)WRwb.Worksheets;

            WRws = (Excel._Worksheet)(WRss.get_Item(1));

            //create Excel column headings

            WRws.Cells[1, 1] = "Part Number.";

            WRws.Cells[1, 2] = "Kit Part.";

            WRws.Cells[1, 3] = "Description";

            WRws.Cells[1, 4] = "Reason For Reject";


            WRws.Cells[2, 1] = RowNo.Trim();

            WRws.Cells[2, 2] = ColumnNo.Trim();

            WRws.Cells[2, 3] = ErrorMsg.Trim();

            WRws.Cells[2, 4] = Filename;
            
            //save workbook

            WRwb.SaveAs("C:\\Excel1.xls", objOpt, objOpt, objOpt, objOpt, Opt,                 Excel.XlSaveAsAccessMode.xlNoChange, objOpt, objOpt, objOpt, objOpt, objOpt);

            //close workbook

            WRwbs.Close();

<asp:DropDownList ID="ddlFirms" runat="server" AutoPostBack="True" 
    AppendDataBoundItems="True" DataSourceID="SqlDataSource_Firms1" DataTextField="Firm" 
    DataValueField="FirmID" 
    onselectedindexchanged="ddlFirms_SelectedIndexChanged">
    <asp:ListItem Value="">- select -</asp:ListItem>
</asp:DropDownList>
<asp:SqlDataSource ID="SqlDataSource_Firms1" runat="server" 
    ConnectionString="<%$ ConnectionStrings:MyConnectionString1 %>" 
    SelectCommand="SELECT * FROM [Firms] ORDER BY [Firm]"></asp:SqlDataSource>


<asp:DropDownList ID="ddlClinics" runat="server" 
    AppendDataBoundItems="True" DataSourceID="SqlDataSource_Clinics1" DataTextField="Clinic" 
    DataValueField="ClinicID">
    <asp:ListItem Value="">- select -</asp:ListItem>
</asp:DropDownList>
<asp:SqlDataSource ID="SqlDataSource_Clinics1" runat="server" 
    ConnectionString="<%$ ConnectionStrings:MyConnectionString1 %>" 
    SelectCommand="SELECT * FROM [Clinics] WHERE ([FirmID] = @FirmID) ORDER BY [Clinic]">
    <SelectParameters>
        <asp:ControlParameter ControlID="ddlFirms" Name="FirmID" 
            PropertyName="SelectedValue" Type="Int32" />
    </SelectParameters>
</asp:SqlDataSource>

protected void ddlFirms_SelectedIndexChanged(object sender, EventArgs e)
{
    //this is to clear the list in ddlClinics before it is repopulated with the relevant list for the selected
    //item in ddlFirms
    ddlClinics.Items.Clear();
    //without this line the initial value was not added
    ddlClinics.Items.Add("- select -");
}

<asp:SqlDataSource ID="SqlDataSource_RTTest" runat="server" 
    ConnectionString="<%$ ConnectionStrings:MyConnectionString1 %>" 
    SelectCommand="SELECT * FROM [RTNumbers] WHERE ([RTID] = @RTID)">
    <SelectParameters>
        <asp:ControlParameter ControlID="HiddenField1" Name="RTID" PropertyName="Value" 
            Type="Int32" />
    </SelectParameters>
</asp:SqlDataSource>
<asp:HiddenField ID="HiddenField1" runat="server" />


<asp:DetailsView ID="DetailsView2" runat="server" 
    AutoGenerateInsertButton="True" AutoGenerateRows="False" DataKeyNames="RTID" 
    DataSourceID="SqlDataSource_RTTest" Height="50px" Width="125px">
    <EmptyDataTemplate>
        <asp:LinkButton ID="FormViewInsert" runat="server" 
            onclick="DetailsView2_Click">Insert a new RT record</asp:LinkButton>
    </EmptyDataTemplate>
    <Fields>
        <asp:TemplateField HeaderText="Firm" SortExpression="FirmID">
            <InsertItemTemplate>
                <asp:DropDownList ID="ddlFirms_DetailsView" runat="server" AutoPostBack="True"
                    AppendDataBoundItems="True" DataSourceID="SqlDataSource_Firms2" 
                    DataTextField="Firm" DataValueField="FirmID" 
                    SelectedValue='<%# DataBinder.Eval(Container.DataItem,"FirmID")%>' Enabled="True"
                        OnSelectedIndexChanged="ddlFirms_DetailsView_SelectedIndexChanged">
                    <asp:ListItem Value="">- select -</asp:ListItem>
                </asp:DropDownList> 
                <asp:SqlDataSource ID="SqlDataSource_Firms2" runat="server" 
                    ConnectionString="<%$ ConnectionStrings:MyConnectionString1 %>" 
                    SelectCommand="SELECT * FROM [Firms] ORDER BY [Firm]">
                </asp:SqlDataSource>

            </InsertItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label3" runat="server" Text='<%# Bind("FirmID") %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Clinic" SortExpression="ClinicID">
            <InsertItemTemplate>
                <asp:DropDownList ID="ddlClinics_DetailsView " runat="server"
                    AppendDataBoundItems="True" DataSourceID="SqlDataSource_Clinics2" 
                    DataTextField="Clinic" DataValueField="ClinicID" 
                    SelectedValue='<%# DataBinder.Eval(Container.DataItem,"ClinicID")%>' 
                    Enabled="True" AutoPostBack="False">
                    <asp:ListItem Value="">- select -</asp:ListItem>
                </asp:DropDownList> 
                <asp:SqlDataSource ID="SqlDataSource_Clinics2" runat="server" 
                    ConnectionString="<%$ ConnectionStrings:MyConnectionString1 %>" 
                            
                    SelectCommand="SELECT * FROM [Clinics] WHERE ([FirmID] = @FirmID) ORDER BY [Clinic]">
                    <SelectParameters>
                        <asp:ControlParameter ControlID="ddlFirms2" Name="FirmID" 
                            PropertyName="SelectedValue" Type="Int32" />
                    </SelectParameters>
                </asp:SqlDataSource>

            </InsertItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label4" runat="server" Text='<%# Bind("ClinicID") %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
    </Fields>
</asp:DetailsView>

protected void ddlFirms_DetailsView_SelectedIndexChanged(object sender, EventArgs e)
{
    DropDownList ddlClinics = (DropDownList)DetailsView2.FindControl("ddlClinics_DetailsView");

    //this line causes the following error: "has a SelectedValue which is invalid because it does not exist in the list of items."
    ddlClinics.Items.Clear();

    ddlClinics.Items.Add("- select -");
}

protected override void OnInit(EventArgs e)
{
    base.OnInit(e);

    if (!IsPostBack)
    {
        DXExtensions.Data.DXObjectDataSource dxOdsAddress = new DXExtensions.Data.DXObjectDataSource();
        dxOdsAddress.PageSize = gvAddress.SettingsPager.PageSize;
        dxOdsAddress.KeyFeildName = gvAddress.KeyFieldName;
        dxOdsAddress.DataType = typeof(DomainModel.AddressEntities.Address);
        dxOdsAddress.Request_DataSource += new EventHandler<DXExtensions.Data.DXObjectDataSource.PagingEventArgs>(dxodsAddress_RequestDataSource);
        dxOdsAddress.Request_TotalRowsCount += new EventHandler(dxodsAddress_RequestTotalRowsCount);
        dxOdsAddress.Request_GroupInfo += new EventHandler<DXExtensions.Data.DXObjectDataSource.GroupingEventArgs>(dxodsAddress_RequestGroupInfo);
        Session["dxOdsAddress"] = dxOdsAddress;        
    }

    gvAddress.DataSource = Session["dxOdsAddress"] as DXExtensions.Data.DXObjectDataSource;
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using DevExpress.Data;

namespace DXExtensions.Data
{
    public class DXObjectDataSource : IListServer, ITypedList
    {
        #region New
                
        #region Exceptions

        public class DataSourceNotBindedException : Exception
        {
            public DataSourceNotBindedException()
                : base()
            {}
        }

        public class DataSourceSubcriberNotFoundException : Exception
        {
            public DataSourceSubcriberNotFoundException()
                : base()
            { }
        }

        public class TotalRowsCountNotBindedException : Exception 
        {
            public TotalRowsCountNotBindedException()
                : base()
            { }
        }

        public class TotalRowsCountSubscriberNotFoundException : Exception
        {
            public TotalRowsCountSubscriberNotFoundException()
                : base()
            { }
        }

        public class UnexpectedLogicWayException : Exception
        {
            public UnexpectedLogicWayException()
                : base()
            { }
        }

        #endregion

        #region PublicConnectors

        /// <summary>
        /// For paging with sorting
        /// </summary>
        public class PagingEventArgs : EventArgs
        {
            private int _StartRowIndex;
            public int StartRowIndex
            {
                get
                {
                    return _StartRowIndex;
                }
                set
                {
                    _StartRowIndex = value;
                }
            }

            private int _RowsCount;
            public int RowsCount
            {
                get
                {
                    return _RowsCount;
                }
                set
                {
                    _RowsCount = value;
                }
            }

            private ICollection<ServerModeOrderDescriptor> _SortInfo;
            public ICollection<ServerModeOrderDescriptor> SortInfo
            {
                get
                {
                    return _SortInfo;
                }
                set
                {
                    _SortInfo = value;
                }
            }
        }

        /// <summary>
        /// For grouping with pagind and sorting
        /// </summary>
        public class GroupingEventArgs : EventArgs
        {
            ListSourceGroupInfo _ParentGroupInfo;
            public ListSourceGroupInfo ParentGroupInfo
            {
                get
                {
                    return _ParentGroupInfo;
                }
                set
                {
                    _ParentGroupInfo = value;
                }
            }

            List<ListSourceGroupInfo> _GroupInfo;

            public List<ListSourceGroupInfo> GroupInfo
            {
                get
                {
                    return _GroupInfo;
                }
                set
                {
                    _GroupInfo = value;
                }
            }
        }

        /// <summary>
        /// Fires when data source needs a specific page from the database
        /// </summary>
        public event EventHandler<PagingEventArgs> Request_DataSource;

        /// <summary>
        /// Fires when data source needs the number of rows using external filters
        /// </summary>
        public event EventHandler Request_TotalRowsCount;

        /// <summary>
        /// Fires when data source needs group info
        /// </summary>
        public event EventHandler<GroupingEventArgs> Request_GroupInfo;

        /// <summary>
        /// Used when external filters changed
        /// </summary>
        public void RefreshForNewFilters()
        {
            _ActualizeDataSource_StartIndex = 0;
            _DataSource = null;
        } //надо избавиться от этого метода, но это проблематично пока используем внешние фильтры

        #endregion

        #region Propertyes
        
        private Type _DataType;
        /// <summary>
        /// The data type must be defined before binding
        /// </summary>
        public Type DataType
        {
            get
            {
                return _DataType;
            }
            set
            {
                _DataType = value;
            }
        }

        private IList _DataSource;
        /// <summary>
        /// Stores range of rows
        /// </summary>
        public IList DataSource
        {
            get
            {
                return _DataSource;
            }
            set
            {
                _DataSource = value;
            }
        }

        private Int32 _TotalRowsCount = -1;
        public Int32 TotalRowsCount
        {
            get
            {
                return _TotalRowsCount;
            }
            set
            {
                _TotalRowsCount = value;
            }
        }

        private Int32 _PageSize;
        /// <summary>
        /// The page size must be defined before binding
        /// </summary>
        public Int32 PageSize
        {
            get
            {
                return _PageSize;
            }
            set
            {
                _PageSize = value;
            }
        }
        
        private string _KeyFeildName;
        /// <summary>
        /// The key field name must be defined before binding
        /// </summary>
        public string KeyFeildName
        {
            get
            {
                return _KeyFeildName;
            }
            set
            {
                _KeyFeildName = value;
            }
        }

        /// <summary>
        /// Stores the previous collection sorting
        /// Need to understand that sort has changed
        /// </summary>
        private ICollection<ServerModeOrderDescriptor> _SortInfo;

        #endregion

        /// <summary>
        /// Required not to send a query to the first page when it is not necessary
        /// </summary>
        bool IsZeroIndexActual;

        /// <summary>
        /// Start row index for stored rows range
        /// </summary>
        private int _ActualizeDataSource_StartIndex;

        /// <summary>
        /// Checks stored rows range and if necessary request a new range of rows from database using Request_DataSource event
        /// </summary>
        /// <param name="index">row index</param>
        /// <returns>page size row index, not table row index</returns>
        protected int ActualizeDataSource(int index)
        {
            bool isDataSourceActual = true;
            if (_DataSource == null)
            {                
                isDataSourceActual = false;                
            }
            else
            {
                if ((index == 0) && (!IsZeroIndexActual))
                {
                    return 0;
                }
                else
                {
                    if ((index >= _ActualizeDataSource_StartIndex + _PageSize) || ((index < _ActualizeDataSource_StartIndex)))
                    {
                        isDataSourceActual = false;
                    }
                }
            }

            if (!isDataSourceActual)
            {
                _ActualizeDataSource_StartIndex = index;

                PagingEventArgs pea = new PagingEventArgs();
                pea.StartRowIndex = index;
                pea.RowsCount = _PageSize;
                pea.SortInfo = _SortInfo;                

                if (Request_DataSource != null)
                {
                    Request_DataSource(this, pea);
                    if (_DataSource == null)
                    {
                        throw new DataSourceNotBindedException();
                    }
                }
                else
                {
                    throw new DataSourceSubcriberNotFoundException();
                }
            }
            int ret = index - _ActualizeDataSource_StartIndex;
            if (ret < 0)
            {
                ret = 0;
            }
            return ret;
        }

        #endregion

        #region IList Enabled

        object IList.this[int index]
        {
            get
            {
                int actualRecordIndex = ActualizeDataSource(index);

                if (_DataSource != null)
                {
                    return _DataSource[actualRecordIndex];
                }
                return null;
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        #endregion

        #region ICollection Enabled

        int ICollection.Count
        {
            get
            {
                return _TotalRowsCount;
            }
        }

        #endregion

        #region ITypedList Enabled

        PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
        {
            IsZeroIndexActual = false; //true in Aplly

            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(_DataType);

            if (Request_TotalRowsCount != null)
            {
                Request_TotalRowsCount(this, new EventArgs());
                if (_TotalRowsCount < 0)
                {
                    throw new TotalRowsCountNotBindedException();
                }
            }
            else
            {
                throw new TotalRowsCountSubscriberNotFoundException();
            }
            return pdc;
        }

        #endregion

        #region DevExpress.Data.IListServer Enabled

        void IListServer.Apply
            (
                DevExpress.Data.Filtering.CriteriaOperator filterCriteria,
                ICollection<ServerModeOrderDescriptor> sortInfo,
                int groupCount,
                ICollection<ServerModeSummaryDescriptor> groupSummaryInfo,
                ICollection<ServerModeSummaryDescriptor> totalSummaryInfo
            )
        {
            if ((_SortInfo != sortInfo)) //new sort collection
            {
                _ActualizeDataSource_StartIndex = 0;
                _DataSource = null;
                _SortInfo = sortInfo;
            }

            IsZeroIndexActual = true; //Now when you request the index 0 should search the data for the first page
        }

        object IListServer.GetRowKey(int index)
        {
            int actualRecordIndex = ActualizeDataSource(index);
                        
            if (_DataSource != null)
            {
                System.Reflection.PropertyInfo pi = _DataType.GetProperty(KeyFeildName);
                System.Reflection.MethodInfo mi = pi.GetGetMethod();
                object recordObject = _DataSource[actualRecordIndex];
                object ret = mi.Invoke(recordObject, null);
                return ret;
            }
            else
            {
                throw new UnexpectedLogicWayException();
            }
        }

        List<ListSourceGroupInfo> IListServer.GetGroupInfo(DevExpress.Data.ListSourceGroupInfo groupInfo)
        {
            GroupingEventArgs gea = new GroupingEventArgs();
            gea.ParentGroupInfo = groupInfo;
            if (Request_GroupInfo != null)
            {
                Request_GroupInfo(this, gea);
                return gea.GroupInfo;
            }
            else
            {
                throw new NotImplementedException();
            }
        }
                
        #endregion

        #region Disabled
        
        #region IList Disabled

        int IList.Add(object value)
        {
            throw new NotImplementedException();
        }

        void IList.Clear()
        {
            throw new NotImplementedException();
        }

        bool IList.Contains(object value)
        {
            throw new NotImplementedException();
        }

        int IList.IndexOf(object value)
        {
            throw new NotImplementedException();
        }

        void IList.Insert(int index, object value)
        {
            throw new NotImplementedException();
        }

        bool IList.IsFixedSize
        {
            get { throw new NotImplementedException(); }
        }

        bool IList.IsReadOnly
        {
            get { throw new NotImplementedException(); }
        }

        void IList.Remove(object value)
        {
            throw new NotImplementedException();
        }

        void IList.RemoveAt(int index)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region ICollection Disabled

        void ICollection.CopyTo(Array array, int index)
        {
            throw new NotImplementedException();
        }

        bool ICollection.IsSynchronized
        {
            get { throw new NotImplementedException(); }
        }

        object ICollection.SyncRoot
        {
            get { throw new NotImplementedException(); }
        }

        #endregion

        #region IEnumerable Disabled

        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }

        #endregion

        #region ITypedList Disabled

        string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
        {
            return "";
        }

        #endregion
        
        #region DevExpress.Data.IListServer Disabled

        /// <summary>
        /// disabled
        /// </summary>
        event EventHandler<ServerModeExceptionThrownEventArgs> IListServer.ExceptionThrown
        {
            add { throw new NotImplementedException(); }
            remove { throw new NotImplementedException(); }
        }

        /// <summary>
        /// disabled
        /// </summary>
        event EventHandler<ServerModeInconsistencyDetectedEventArgs> IListServer.InconsistencyDetected
        {
            add { throw new NotImplementedException(); }
            remove { throw new NotImplementedException(); }
        }

        /// <summary>
        /// disabled
        /// </summary>
        IList IListServer.GetAllFilteredAndSortedRows()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        int IListServer.GetRowIndexByKey(object key)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        int IListServer.FindIncremental
            (
                DevExpress.Data.Filtering.CriteriaOperator expression,
                string value,
                int startIndex,
                bool searchUp,
                bool ignoreStartRow,
                bool allowLoop
            )
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        Dictionary<object, object> IListServer.GetTotalSummary()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        object[] IListServer.GetUniqueColumnValues(DevExpress.Data.Filtering.CriteriaOperator expression, int maxCount,
        bool includeFilteredOut)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        int IListServer.LocateByValue(DevExpress.Data.Filtering.CriteriaOperator expression, object value, int
            startIndex, bool searchUp)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        void IListServer.Refresh()
        {
            throw new NotImplementedException();
        }

        #endregion

        #endregion
    }
}