mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
731 lines
27 KiB
C#
731 lines
27 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="XmlDataSource.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.Caching;
|
|
using System.Web.Hosting;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
using System.Xml;
|
|
using System.Xml.Xsl;
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Represents an XML file as both an IDataSource and an IHierarchicalDataSource.
|
|
/// The XML data is retrieved either from a file specified by the DataFile property
|
|
/// or by inline XML content in the Data property.
|
|
/// </devdoc>
|
|
[
|
|
DefaultEvent("Transforming"),
|
|
DefaultProperty("DataFile"),
|
|
Designer("System.Web.UI.Design.WebControls.XmlDataSourceDesigner, " + AssemblyRef.SystemDesign),
|
|
ParseChildren(true),
|
|
PersistChildren(false),
|
|
ToolboxBitmap(typeof(XmlDataSource)),
|
|
WebSysDescription(SR.XmlDataSource_Description),
|
|
WebSysDisplayName(SR.XmlDataSource_DisplayName)
|
|
]
|
|
public class XmlDataSource : HierarchicalDataSourceControl, IDataSource, IListSource {
|
|
|
|
private static readonly object EventTransforming = new object();
|
|
private const string DefaultViewName = "DefaultView";
|
|
|
|
private DataSourceCache _cache;
|
|
private bool _cacheLookupDone;
|
|
private bool _disallowChanges;
|
|
private XsltArgumentList _transformArgumentList;
|
|
private ICollection _viewNames;
|
|
private XmlDocument _xmlDocument;
|
|
private string _writeableDataFile;
|
|
|
|
private string _data;
|
|
private string _dataFile;
|
|
private string _transform;
|
|
private string _transformFile;
|
|
private string _xPath;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Specifies the cache settings for this data source.
|
|
/// </devdoc>
|
|
private DataSourceCache Cache {
|
|
get {
|
|
if (_cache == null) {
|
|
_cache = new DataSourceCache();
|
|
_cache.Enabled = true;
|
|
}
|
|
return _cache;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The duration, in seconds, of the expiration. The expiration policy is specified by the CacheExpirationPolicy property.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(DataSourceCache.Infinite),
|
|
TypeConverterAttribute(typeof(DataSourceCacheDurationConverter)),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_Duration),
|
|
]
|
|
public virtual int CacheDuration {
|
|
get {
|
|
return Cache.Duration;
|
|
}
|
|
set {
|
|
Cache.Duration = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The expiration policy of the cache. The duration for the expiration is specified by the CacheDuration property.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(DataSourceCacheExpiry.Absolute),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_ExpirationPolicy),
|
|
]
|
|
public virtual DataSourceCacheExpiry CacheExpirationPolicy {
|
|
get {
|
|
return Cache.ExpirationPolicy;
|
|
}
|
|
set {
|
|
Cache.ExpirationPolicy = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Indicates an arbitrary cache key to make this cache entry depend on. This allows
|
|
/// the user to further customize when this cache entry will expire.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_KeyDependency),
|
|
]
|
|
public virtual string CacheKeyDependency {
|
|
get {
|
|
return Cache.KeyDependency;
|
|
}
|
|
set {
|
|
Cache.KeyDependency = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.XmlDataSource_CacheKeyContext),
|
|
]
|
|
public virtual string CacheKeyContext {
|
|
get {
|
|
return (string)ViewState["CacheKeyContext "] ?? String.Empty;
|
|
}
|
|
set {
|
|
ViewState["CacheKeyContext "] = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Inline XML content.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.ComponentModel.Design.MultilineStringEditor," + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
TypeConverter("System.ComponentModel.MultilineStringConverter," + AssemblyRef.System),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.XmlDataSource_Data),
|
|
]
|
|
public virtual string Data {
|
|
get {
|
|
if (_data == null) {
|
|
return String.Empty;
|
|
}
|
|
return _data;
|
|
}
|
|
set {
|
|
if (value != null) {
|
|
value = value.Trim();
|
|
}
|
|
if (Data != value) {
|
|
if (_disallowChanges) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_CannotChangeWhileLoading, "Data", ID));
|
|
}
|
|
_data = value;
|
|
_xmlDocument = null;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Path to an XML file.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.XmlDataFileEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.XmlDataSource_DataFile),
|
|
]
|
|
public virtual string DataFile {
|
|
get {
|
|
if (_dataFile == null) {
|
|
return String.Empty;
|
|
}
|
|
return _dataFile;
|
|
}
|
|
set {
|
|
if (DataFile != value) {
|
|
if (_disallowChanges) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_CannotChangeWhileLoading, "DataFile", ID));
|
|
}
|
|
_dataFile = value;
|
|
_xmlDocument = null;
|
|
_writeableDataFile = null;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Whether caching is enabled for this data source.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_Enabled),
|
|
]
|
|
public virtual bool EnableCaching {
|
|
get {
|
|
return Cache.Enabled;
|
|
}
|
|
set {
|
|
Cache.Enabled = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Indicates whether the XML data can be modified.
|
|
/// This is also used by XmlDataSourceView to determine whether CanDelete/Insert/Update are true.
|
|
/// </devdoc>
|
|
internal bool IsModifiable {
|
|
get {
|
|
return (String.IsNullOrEmpty(TransformFile) &&
|
|
String.IsNullOrEmpty(Transform) &&
|
|
!String.IsNullOrEmpty(WriteableDataFile));
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Inline XSL transform.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.ComponentModel.Design.MultilineStringEditor," + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
TypeConverter("System.ComponentModel.MultilineStringConverter," + AssemblyRef.System),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.XmlDataSource_Transform),
|
|
]
|
|
public virtual string Transform {
|
|
get {
|
|
if (_transform == null) {
|
|
return String.Empty;
|
|
}
|
|
return _transform;
|
|
}
|
|
set {
|
|
if (value != null) {
|
|
value = value.Trim();
|
|
}
|
|
if (Transform != value) {
|
|
if (_disallowChanges) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_CannotChangeWhileLoading, "Transform", ID));
|
|
}
|
|
_transform = value;
|
|
_xmlDocument = null;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Arguments for the XSL transform.
|
|
/// This should be populated in the Transforming event.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
]
|
|
public virtual XsltArgumentList TransformArgumentList {
|
|
get {
|
|
return _transformArgumentList;
|
|
}
|
|
set {
|
|
_transformArgumentList = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Path to an XSL transform file.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.XslTransformFileEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.XmlDataSource_TransformFile),
|
|
]
|
|
public virtual string TransformFile {
|
|
get {
|
|
if (_transformFile == null) {
|
|
return String.Empty;
|
|
}
|
|
return _transformFile;
|
|
}
|
|
set {
|
|
if (TransformFile != value) {
|
|
if (_disallowChanges) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_CannotChangeWhileLoading, "TransformFile", ID));
|
|
}
|
|
_transformFile = value;
|
|
_xmlDocument = null;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets a physical path of the data file that can be written to.
|
|
/// The value is null if the path is not a writable path.
|
|
/// </devdoc>
|
|
private string WriteableDataFile {
|
|
get {
|
|
if (_writeableDataFile == null) {
|
|
_writeableDataFile = GetWriteableDataFile();
|
|
}
|
|
return _writeableDataFile;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Specifies an initial XPath that is applied to the XML data.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.XmlDataSource_XPath),
|
|
]
|
|
public virtual string XPath {
|
|
get {
|
|
if (_xPath == null) {
|
|
return String.Empty;
|
|
}
|
|
return _xPath;
|
|
}
|
|
set {
|
|
if (XPath != value) {
|
|
if (_disallowChanges) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_CannotChangeWhileLoading, "XPath", ID));
|
|
}
|
|
_xPath = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raised before the XSL transform is applied.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.XmlDataSource_Transforming),
|
|
]
|
|
public event EventHandler Transforming {
|
|
add {
|
|
Events.AddHandler(EventTransforming, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventTransforming, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates a unique cache key for this data source's data.
|
|
/// </devdoc>
|
|
// Made internal for unit testing
|
|
[SuppressMessage("Microsoft.Usage", "CA2303:FlagTypeGetHashCode", Justification = "This is specifically on XmlDataSource type which is not a com interop type.")]
|
|
internal string CreateCacheKey()
|
|
{
|
|
StringBuilder sb = new StringBuilder(CacheInternal.PrefixDataSourceControl, 1024);
|
|
sb.Append(GetType().GetHashCode().ToString(CultureInfo.InvariantCulture));
|
|
|
|
sb.Append(CacheDuration.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(':');
|
|
sb.Append(((int)CacheExpirationPolicy).ToString(CultureInfo.InvariantCulture));
|
|
|
|
bool includeUniqueID = false;
|
|
|
|
if (!String.IsNullOrEmpty(CacheKeyContext)) {
|
|
sb.Append(':');
|
|
sb.Append(CacheKeyContext);
|
|
}
|
|
|
|
if (DataFile.Length > 0) {
|
|
sb.Append(':');
|
|
sb.Append(DataFile);
|
|
}
|
|
else {
|
|
if (Data.Length > 0) {
|
|
includeUniqueID = true;
|
|
}
|
|
}
|
|
|
|
if (TransformFile.Length > 0) {
|
|
sb.Append(':');
|
|
sb.Append(TransformFile);
|
|
}
|
|
else {
|
|
if (Transform.Length > 0) {
|
|
includeUniqueID = true;
|
|
}
|
|
}
|
|
|
|
if (includeUniqueID) {
|
|
// If we don't have any paths, use the Page
|
|
if (Page != null) {
|
|
sb.Append(':');
|
|
sb.Append(Page.GetType().AssemblyQualifiedName);
|
|
}
|
|
sb.Append(':');
|
|
string uniqueID = UniqueID;
|
|
if (String.IsNullOrEmpty(uniqueID)) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_NeedUniqueIDForCache));
|
|
}
|
|
sb.Append(uniqueID);
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns a HierarchicalDataSourceView based on an XPath specified by viewPath.
|
|
/// </devdoc>
|
|
protected override HierarchicalDataSourceView GetHierarchicalView(string viewPath) {
|
|
return new XmlHierarchicalDataSourceView(this, viewPath);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets an XmlReader representing XML or XSL content, and optionally a cache
|
|
/// dependency for that content.
|
|
/// Supported paths are: Relative paths, physical paths, UNC paths, and HTTP URLs
|
|
/// If a path is not provided, the content parameter is assumed to contain the
|
|
/// actual content.
|
|
/// If there is no data, null is returned.
|
|
/// This method is fully compatible with Virtual Path Providers.
|
|
/// </devdoc>
|
|
private XmlReader GetReader(string path, string content, out CacheDependency cacheDependency) {
|
|
// If a filename is specified, load from file. Otherwise load from inner content.
|
|
if (path.Length != 0) {
|
|
// First try to detect if it is an HTTP URL
|
|
Uri uri;
|
|
bool success = Uri.TryCreate(path, UriKind.Absolute, out uri);
|
|
if (success) {
|
|
if (uri.Scheme == Uri.UriSchemeHttp) {
|
|
// Check for Web permissions for the URL we want
|
|
if (!HttpRuntime.HasWebPermission(uri)) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_NoWebPermission, uri.PathAndQuery, ID));
|
|
}
|
|
// Dependencies are not supported with HTTP URLs
|
|
cacheDependency = null;
|
|
// If it is an HTTP URL and we have permissions, get a reader
|
|
return XmlUtils.CreateXmlReader(path);
|
|
}
|
|
}
|
|
|
|
// Now see what kind of file-based path it is
|
|
VirtualPath virtualPath;
|
|
string physicalPath;
|
|
ResolvePhysicalOrVirtualPath(path, out virtualPath, out physicalPath);
|
|
|
|
if (virtualPath != null && DesignMode) {
|
|
// This exception should never be thrown - the designer always maps paths
|
|
// before using the runtime control.
|
|
throw new NotSupportedException(SR.GetString(SR.XmlDataSource_DesignTimeRelativePathsNotSupported, ID));
|
|
}
|
|
|
|
Stream dataStream = OpenFileAndGetDependency(virtualPath, physicalPath, out cacheDependency);
|
|
return XmlUtils.CreateXmlReader(dataStream);
|
|
}
|
|
else {
|
|
// Dependencies are not supported with inline content
|
|
cacheDependency = null;
|
|
content = content.Trim();
|
|
if (content.Length == 0) {
|
|
return null;
|
|
}
|
|
else {
|
|
return XmlUtils.CreateXmlReader(new StringReader(content));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets a path to a writeable file where we can save data to.
|
|
/// The return value is null if a writeable path cannot be found.
|
|
/// </devdoc>
|
|
private string GetWriteableDataFile() {
|
|
if (DataFile.Length != 0) {
|
|
// First try to detect if it is an HTTP URL
|
|
Uri uri;
|
|
bool success = Uri.TryCreate(DataFile, UriKind.Absolute, out uri);
|
|
if (success) {
|
|
if (uri.Scheme == Uri.UriSchemeHttp) {
|
|
// Cannot write to HTTP URLs
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (HostingEnvironment.UsingMapPathBasedVirtualPathProvider) {
|
|
// Now see what kind of file-based path it is
|
|
VirtualPath virtualPath;
|
|
string physicalPath;
|
|
ResolvePhysicalOrVirtualPath(DataFile, out virtualPath, out physicalPath);
|
|
if (physicalPath == null) {
|
|
physicalPath = virtualPath.MapPathInternal(this.TemplateControlVirtualDirectory, true /*allowCrossAppMapping*/);
|
|
}
|
|
return physicalPath;
|
|
}
|
|
else {
|
|
// File is coming from a custom virtual path provider, and there is no support for writing
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
// Data is specified using Data property, so it is not writeable
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns the XmlDocument representing the XML data.
|
|
/// If necessary, the XML data will be reloaded along with the transform, if available.
|
|
/// </devdoc>
|
|
public XmlDocument GetXmlDocument() {
|
|
|
|
string cacheKey = null;
|
|
|
|
if (!_cacheLookupDone && Cache.Enabled) {
|
|
// If caching is enabled, attempt to load from cache.
|
|
cacheKey = CreateCacheKey();
|
|
_xmlDocument = Cache.LoadDataFromCache(cacheKey) as XmlDocument;
|
|
|
|
_cacheLookupDone = true;
|
|
}
|
|
|
|
if (_xmlDocument == null) {
|
|
|
|
// Load up the data
|
|
_xmlDocument = new XmlDocument();
|
|
CacheDependency transformCacheDependency;
|
|
CacheDependency dataCacheDependency;
|
|
|
|
PopulateXmlDocument(_xmlDocument, out dataCacheDependency, out transformCacheDependency);
|
|
|
|
if (cacheKey != null) {
|
|
Debug.Assert(Cache.Enabled);
|
|
|
|
// If caching is enabled, save the XmlDocument to cache.
|
|
CacheDependency fileDependency;
|
|
if (dataCacheDependency != null) {
|
|
if (transformCacheDependency != null) {
|
|
// We have both a data file as well as a transform file dependency
|
|
AggregateCacheDependency aggregateDependency = new AggregateCacheDependency();
|
|
aggregateDependency.Add(dataCacheDependency, transformCacheDependency);
|
|
fileDependency = aggregateDependency;
|
|
}
|
|
else {
|
|
// We only have a data file dependency
|
|
fileDependency = dataCacheDependency;
|
|
}
|
|
}
|
|
else {
|
|
// We have at most only a transform file dependency (or no dependency at all)
|
|
fileDependency = transformCacheDependency;
|
|
}
|
|
|
|
Cache.SaveDataToCache(cacheKey, _xmlDocument, fileDependency);
|
|
}
|
|
}
|
|
|
|
return _xmlDocument;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Populates an XmlDocument with the appropriate XML data, including applying transforms.
|
|
/// </devdoc>
|
|
[SuppressMessage("Microsoft.Security", "MSEC1204:UseSecureXmlResolver", Justification = "Legacy code that trusts our developer input. Optional safer codepath available via appSettings/aspnet:RestrictXmlControls configuration.")]
|
|
private void PopulateXmlDocument(XmlDocument document, out CacheDependency dataCacheDependency, out CacheDependency transformCacheDependency) {
|
|
XmlReader transformReader = null;
|
|
XmlReader dataReader = null;
|
|
XmlReader tempDataReader = null;
|
|
|
|
try {
|
|
// Don't allow changes to the XmlDataSource while we are loading the document
|
|
_disallowChanges = true;
|
|
|
|
// Check if transform is specified.
|
|
// If there is a transform, load the data, then the transform, and get an XmlReader from the transformation.
|
|
transformReader = GetReader(TransformFile, Transform, out transformCacheDependency);
|
|
if (transformReader != null) {
|
|
tempDataReader = GetReader(DataFile, Data, out dataCacheDependency);
|
|
|
|
// Now load the transform and transform the document data
|
|
#pragma warning disable 0618 // To avoid deprecation warning
|
|
XslTransform transform = XmlUtils.CreateXslTransform(transformReader, null);
|
|
#pragma warning restore 0618
|
|
if (transform != null) {
|
|
OnTransforming(EventArgs.Empty);
|
|
|
|
XmlDocument tempDocument = new XmlDocument();
|
|
tempDocument.Load(tempDataReader);
|
|
// The XmlResolver cast on the third parameter is required to eliminate an ambiguity
|
|
// from the compiler.
|
|
dataReader = transform.Transform(tempDocument, _transformArgumentList, (XmlResolver)null);
|
|
document.Load(dataReader);
|
|
}
|
|
else {
|
|
// XslCompiledTransform for some reason wants to completely re-create an internal XmlReader
|
|
// from scratch. In doing so, it does not respect all the settings of XmlTextReader. Be 100%
|
|
// sure that this XmlReader we are using here uses settings of XmlReader and not those
|
|
// introduced by XmlTextReader.
|
|
XslCompiledTransform compiledTransform = XmlUtils.CreateXslCompiledTransform(transformReader);
|
|
|
|
OnTransforming(EventArgs.Empty);
|
|
|
|
using (MemoryStream ms = new MemoryStream()) {
|
|
XmlWriter writer = XmlWriter.Create(ms);
|
|
compiledTransform.Transform(tempDataReader, _transformArgumentList, writer, null);
|
|
document.Load(XmlUtils.CreateXmlReader(ms));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
dataReader = GetReader(DataFile, Data, out dataCacheDependency);
|
|
document.Load(dataReader);
|
|
}
|
|
}
|
|
finally {
|
|
_disallowChanges = false;
|
|
|
|
if (dataReader != null) {
|
|
dataReader.Close();
|
|
}
|
|
if (tempDataReader != null) {
|
|
tempDataReader.Close();
|
|
}
|
|
if (transformReader != null) {
|
|
transformReader.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Called right before the XSLT transform is applied.
|
|
/// This allows a developer to supply an XsltArgumentList in the TransformArgumentList property.
|
|
/// </devdoc>
|
|
protected virtual void OnTransforming(EventArgs e) {
|
|
EventHandler handler = (EventHandler)Events[EventTransforming];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Saves the XML data to disk.
|
|
/// </devdoc>
|
|
public void Save() {
|
|
if (!IsModifiable) {
|
|
throw new InvalidOperationException(SR.GetString(SR.XmlDataSource_SaveNotAllowed, ID));
|
|
}
|
|
|
|
string writeableDataFile = WriteableDataFile;
|
|
Debug.Assert(!String.IsNullOrEmpty(writeableDataFile), "Did not expect WriteableDataFile to be empty in Save()");
|
|
|
|
// Check for write permissions
|
|
HttpRuntime.CheckFilePermission(writeableDataFile, true);
|
|
|
|
// Save the document
|
|
GetXmlDocument().Save(writeableDataFile);
|
|
}
|
|
|
|
|
|
#region Implementation of IDataSource
|
|
event EventHandler IDataSource.DataSourceChanged {
|
|
add {
|
|
((IHierarchicalDataSource)this).DataSourceChanged += value;
|
|
}
|
|
remove {
|
|
((IHierarchicalDataSource)this).DataSourceChanged -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
DataSourceView IDataSource.GetView(string viewName) {
|
|
if (viewName.Length == 0) {
|
|
viewName = DefaultViewName;
|
|
}
|
|
return new XmlDataSourceView(this, viewName);
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
ICollection IDataSource.GetViewNames() {
|
|
if (_viewNames == null) {
|
|
_viewNames = new string[1] { DefaultViewName };
|
|
}
|
|
return _viewNames;
|
|
}
|
|
#endregion
|
|
|
|
#region Implementation of IListSource
|
|
/// <internalonly/>
|
|
bool IListSource.ContainsListCollection {
|
|
get {
|
|
if (DesignMode) {
|
|
return false;
|
|
}
|
|
return ListSourceHelper.ContainsListCollection(this);
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
IList IListSource.GetList() {
|
|
if (DesignMode) {
|
|
return null;
|
|
}
|
|
return ListSourceHelper.GetList(this);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|