AccessDataSource.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / AccessDataSource.cs / 1305376 / AccessDataSource.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.Collections; 
    using System.ComponentModel;
    using System.Data;
    using System.Data.Common;
    using System.Data.OleDb; 
    using System.Diagnostics;
    using System.Drawing; 
    using System.Drawing.Design; 
    using System.IO;
    using System.Text; 
    using System.Web.Caching;
    using System.Web.UI;

 
    /// 
    /// Allows a user to create a declarative connection to an Access database in a .aspx page. 
    ///  
    [
    Designer("System.Web.UI.Design.WebControls.AccessDataSourceDesigner, " + AssemblyRef.SystemDesign), 
    ToolboxBitmap(typeof(AccessDataSource)),
    WebSysDescription(SR.AccessDataSource_Description),
    WebSysDisplayName(SR.AccessDataSource_DisplayName)
    ] 
    public class AccessDataSource : SqlDataSource {
 
        private const string OleDbProviderName = "System.Data.OleDb"; 
        private const string JetProvider = "Microsoft.Jet.OLEDB.4.0";
        private const string Access2007Provider = "Microsoft.ACE.OLEDB.12.0"; 
        private const string Access2007FileExtension = ".accdb";

        private FileDataSourceCache _cache;
        private string _connectionString; 
        private string _dataFile;
        private string _physicalDataFile; 
 

 
        /// 
        /// Creates a new instance of AccessDataSource.
        /// 
        public AccessDataSource() : base() { 
        }
 
 
        /// 
        /// Creates a new instance of AccessDataSource with a specified connection string and select command. 
        /// 
        public AccessDataSource(string dataFile, string selectCommand) : base() {
            if (String.IsNullOrEmpty(dataFile)) {
                throw new ArgumentNullException("dataFile"); 
            }
            DataFile = dataFile; 
            SelectCommand = selectCommand; 
        }
 
        /// 
        /// Specifies the cache settings for this data source. For the cache to
        /// work, the DataSourceMode must be set to DataSet.
        ///  
        internal override DataSourceCache Cache {
            get { 
                if (_cache == null) { 
                    _cache = new FileDataSourceCache();
                } 
                return _cache;
            }
        }
 
        /// 
        /// Gets the connection string for the AccessDataSource. This property is auto-generated and cannot be set. 
        ///  
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public override string ConnectionString {
            get { 
                if (_connectionString == null) {
                    _connectionString = CreateConnectionString(); 
                } 
                return _connectionString;
            } 
            set {
                throw new InvalidOperationException(SR.GetString(SR.AccessDataSource_CannotSetConnectionString));
            }
        } 

        ///  
        /// The name of an Access database file. 
        /// This property is not stored in ViewState.
        ///  
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.MdbDataFileEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        UrlProperty(), 
        WebCategory("Data"),
        WebSysDescription(SR.AccessDataSource_DataFile), 
        ] 
        public string DataFile {
            get { 
                return (_dataFile == null) ? String.Empty : _dataFile;
            }
            set {
                if (DataFile != value) { 
                    _dataFile = value;
                    _connectionString = null; 
                    _physicalDataFile = null; 
                    RaiseDataSourceChangedEvent(EventArgs.Empty);
                } 
            }
        }

        ///  
        /// Gets the file data source cache object.
        ///  
        private FileDataSourceCache FileDataSourceCache { 
            get {
                FileDataSourceCache fileCache = Cache as FileDataSourceCache; 
                Debug.Assert(fileCache != null, "Cache object should be a FileDataSourceCache");
                return fileCache;
            }
        } 

        ///  
        /// Gets the Physical path of the data file. 
        /// 
        private string PhysicalDataFile { 
            get {
                if (_physicalDataFile == null) {
                    _physicalDataFile = GetPhysicalDataFilePath();
                } 
                return _physicalDataFile;
            } 
        } 

        internal string NativeProvider { 
            get {
                if (IsAccess2007) {
                    return Access2007Provider;
                } 
                return JetProvider;
            } 
        } 

        internal virtual bool IsAccess2007 { 
            get {
                // Access 2007 changed the file format so we have to pick the right provider based on extension.
                return Path.GetExtension(PhysicalDataFile) == Access2007FileExtension;
            } 
        }
 
        ///  
        /// Gets/sets the ADO.net managed provider name. This property is restricted to the OLE DB provider and cannot be set.
        ///  
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ] 
        public override string ProviderName {
            get { 
                return OleDbProviderName; 
            }
            set { 
                throw new InvalidOperationException(SR.GetString(SR.AccessDataSource_CannotSetProvider, ID));
            }
        }
 
        /// 
        /// A semi-colon delimited string indicating which databases to use for the dependency in the format "database1:table1;database2:table2". 
        ///  
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public override string SqlCacheDependency {
            get { 
                throw new NotSupportedException(SR.GetString(SR.AccessDataSource_SqlCacheDependencyNotSupported, ID));
            } 
            set { 
                throw new NotSupportedException(SR.GetString(SR.AccessDataSource_SqlCacheDependencyNotSupported, ID));
            } 
        }

        private void AddCacheFileDependency() {
            FileDataSourceCache.FileDependencies.Clear(); 
            string filename = PhysicalDataFile;
            if (filename.Length > 0) { 
                FileDataSourceCache.FileDependencies.Add(filename); 
            }
        } 

        /// 
        /// Creates a connection string for an Access database connection.
        /// The JET or ACE provider is used based on the DataFile extension, and the filename, username, password, and 
        /// share mode are are set.
        ///  
        private string CreateConnectionString() { 
            return "Provider=" + NativeProvider + "; Data Source=" + PhysicalDataFile;
        } 

        /// 
        /// Creates a new AccessDataSourceView.
        ///  
        protected override SqlDataSourceView CreateDataSourceView(string viewName) {
            return new AccessDataSourceView(this, viewName, Context); 
        } 

        protected override DbProviderFactory GetDbProviderFactory() { 
            return OleDbFactory.Instance;
        }

        ///  
        /// Gets the appropriate mapped path for the DataFile.
        ///  
        private string GetPhysicalDataFilePath() { 
            string filename = DataFile;
            if (filename.Length == 0) { 
                return null;
            }
            if (!System.Web.Util.UrlPath.IsAbsolutePhysicalPath(filename)) {
                // Root relative path 
                if (DesignMode) {
                    // This exception should never be thrown - the designer always maps paths 
                    // before using the runtime control. 
                    throw new NotSupportedException(SR.GetString(SR.AccessDataSource_DesignTimeRelativePathsNotSupported, ID));
                } 
                filename = Context.Request.MapPath(filename, AppRelativeTemplateSourceDirectory, true);
            }

            HttpRuntime.CheckFilePermission(filename, true); 

            // We also need to check for path discovery permissions for the 
            // file since the page developer will be able to see the physical 
            // path in the ConnectionString property.
            if (!HttpRuntime.HasPathDiscoveryPermission(filename)) { 
                throw new HttpException(SR.GetString(SR.AccessDataSource_NoPathDiscoveryPermission, HttpRuntime.GetSafePath(filename), ID));
            }
            return filename;
        } 

        ///  
        /// Saves data to the cache. 
        /// 
        internal override void SaveDataToCache(int startRowIndex, int maximumRows, object data, CacheDependency dependency) { 
            AddCacheFileDependency();
            base.SaveDataToCache(startRowIndex, maximumRows, data, dependency);
        }
 
        /*internal override void SaveTotalRowCountToCache(int totalRowCount) {
            AddCacheFileDependency(); 
            base.SaveTotalRowCountToCache(totalRowCount); 
        }*/
    } 
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
AccessDataSource.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
