Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / Xml / System / Xml / Xslt / XslTransform.cs / 1 / XslTransform.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Xsl {
#if ! HIDE_XSL
using System.Reflection;
using System.Diagnostics;
using System.IO;
using System.Xml.XPath;
using System.Xml.Xsl.XsltOld;
using MS.Internal.Xml.XPath;
using MS.Internal.Xml.Cache;
using System.Collections.Generic;
using System.Xml.Xsl.XsltOld.Debugger;
using System.Security.Policy;
using System.Security.Permissions;
[Obsolete("This class has been deprecated. Please use System.Xml.Xsl.XslCompiledTransform instead. http://go.microsoft.com/fwlink/?linkid=14202")]
public sealed class XslTransform {
private XmlResolver _XmlResolver = new XmlUrlResolver();
//
// Compiled stylesheet state
//
private Stylesheet _CompiledStylesheet;
private List _QueryStore;
private RootAction _RootAction;
private IXsltDebugger debugger;
public XslTransform() {}
public XmlResolver XmlResolver {
set { _XmlResolver = value; }
}
public void Load(XmlReader stylesheet) {
Load(stylesheet, new XmlUrlResolver());
}
public void Load(XmlReader stylesheet, XmlResolver resolver) {
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver);
}
public void Load(IXPathNavigable stylesheet) {
Load(stylesheet, new XmlUrlResolver());
}
public void Load(IXPathNavigable stylesheet, XmlResolver resolver) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(stylesheet.CreateNavigator(), resolver);
}
public void Load(XPathNavigator stylesheet) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(stylesheet, new XmlUrlResolver());
}
public void Load(XPathNavigator stylesheet, XmlResolver resolver) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(stylesheet, resolver, /*evidence:*/null);
}
public void Load(string url) {
Load(url, new XmlUrlResolver());
}
public void Load(string url, XmlResolver resolver) {
XmlTextReaderImpl tr = new XmlTextReaderImpl(url); {
tr.XmlResolver = resolver;
}
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(tr.BaseURI); // We should ask BaseURI before we start reading because it's changing with each node
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver, evidence);
}
public void Load(IXPathNavigable stylesheet, XmlResolver resolver, Evidence evidence) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(stylesheet.CreateNavigator(), resolver, evidence);
}
public void Load(XmlReader stylesheet, XmlResolver resolver, Evidence evidence) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver, evidence);
}
public void Load(XPathNavigator stylesheet, XmlResolver resolver, Evidence evidence) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
if (resolver == null) {
resolver = new XmlNullResolver();
}
if (evidence == null) {
evidence = new Evidence();
}
else {
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
}
Compile(stylesheet, resolver, evidence);
}
// ------------------------------------ Transform() ------------------------------------ //
private void CheckCommand() {
if (_CompiledStylesheet == null) {
throw new InvalidOperationException(Res.GetString(Res.Xslt_NoStylesheetLoaded));
}
}
public XmlReader Transform(XPathNavigator input, XsltArgumentList args, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
return processor.StartReader();
}
public XmlReader Transform(XPathNavigator input, XsltArgumentList args) {
return Transform(input, args, _XmlResolver);
}
public void Transform(XPathNavigator input, XsltArgumentList args, XmlWriter output, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public void Transform(XPathNavigator input, XsltArgumentList args, XmlWriter output) {
Transform(input, args, output, _XmlResolver);
}
public void Transform(XPathNavigator input, XsltArgumentList args, Stream output, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public void Transform(XPathNavigator input, XsltArgumentList args, Stream output) {
Transform(input, args, output, _XmlResolver);
}
public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output) {
CheckCommand();
Processor processor = new Processor(input, args, _XmlResolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public XmlReader Transform(IXPathNavigable input, XsltArgumentList args, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
return Transform(input.CreateNavigator(), args, resolver);
}
public XmlReader Transform(IXPathNavigable input, XsltArgumentList args) {
if (input == null) {
throw new ArgumentNullException("input");
}
return Transform(input.CreateNavigator(), args, _XmlResolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, TextWriter output, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, resolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, TextWriter output) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, _XmlResolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, Stream output, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, resolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, Stream output) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, _XmlResolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, resolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, _XmlResolver);
}
public void Transform(String inputfile, String outputfile, XmlResolver resolver) {
FileStream fs = null;
try {
// We should read doc before creating output file in case they are the same
XPathDocument doc = new XPathDocument(inputfile);
fs = new FileStream(outputfile, FileMode.Create, FileAccess.ReadWrite);
Transform(doc, /*args:*/null, fs, resolver);
}
finally {
if (fs != null) {
fs.Close();
}
}
}
public void Transform(String inputfile, String outputfile) {
Transform(inputfile, outputfile, _XmlResolver);
}
// Implementation
private void Compile(XPathNavigator stylesheet, XmlResolver resolver, Evidence evidence) {
Debug.Assert(stylesheet != null);
Debug.Assert(resolver != null);
Compiler compiler = (Debugger == null) ? new Compiler() : new DbgCompiler(this.Debugger);
NavigatorInput input = new NavigatorInput(stylesheet);
compiler.Compile(input, resolver, evidence);
Debug.Assert(compiler.CompiledStylesheet != null);
Debug.Assert(compiler.QueryStore != null);
Debug.Assert(compiler.QueryStore != null);
_CompiledStylesheet = compiler.CompiledStylesheet;
_QueryStore = compiler.QueryStore;
_RootAction = compiler.RootAction;
}
internal IXsltDebugger Debugger {
get { return this.debugger; }
}
#if false
internal XslTransform(IXsltDebugger debugger) {
this.debugger = debugger;
}
#endif
internal XslTransform(object debugger) {
if (debugger != null) {
this.debugger = new DebuggerAddapter(debugger);
}
}
private class DebuggerAddapter : IXsltDebugger {
private object unknownDebugger;
private MethodInfo getBltIn;
private MethodInfo onCompile;
private MethodInfo onExecute;
public DebuggerAddapter(object unknownDebugger) {
this.unknownDebugger = unknownDebugger;
BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
Type unknownType = unknownDebugger.GetType();
getBltIn = unknownType.GetMethod("GetBuiltInTemplatesUri", flags);
onCompile = unknownType.GetMethod("OnInstructionCompile" , flags);
onExecute = unknownType.GetMethod("OnInstructionExecute" , flags);
}
// ------------------ IXsltDebugger ---------------
public string GetBuiltInTemplatesUri() {
if (getBltIn == null) {
return null;
}
return (string) getBltIn.Invoke(unknownDebugger, new object[] {});
}
public void OnInstructionCompile(XPathNavigator styleSheetNavigator) {
if (onCompile != null) {
onCompile.Invoke(unknownDebugger, new object[] { styleSheetNavigator });
}
}
public void OnInstructionExecute(IXsltProcessor xsltProcessor) {
if (onExecute != null) {
onExecute.Invoke(unknownDebugger, new object[] { xsltProcessor });
}
}
}
}
#endif // ! HIDE_XSL
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Xsl {
#if ! HIDE_XSL
using System.Reflection;
using System.Diagnostics;
using System.IO;
using System.Xml.XPath;
using System.Xml.Xsl.XsltOld;
using MS.Internal.Xml.XPath;
using MS.Internal.Xml.Cache;
using System.Collections.Generic;
using System.Xml.Xsl.XsltOld.Debugger;
using System.Security.Policy;
using System.Security.Permissions;
[Obsolete("This class has been deprecated. Please use System.Xml.Xsl.XslCompiledTransform instead. http://go.microsoft.com/fwlink/?linkid=14202")]
public sealed class XslTransform {
private XmlResolver _XmlResolver = new XmlUrlResolver();
//
// Compiled stylesheet state
//
private Stylesheet _CompiledStylesheet;
private List _QueryStore;
private RootAction _RootAction;
private IXsltDebugger debugger;
public XslTransform() {}
public XmlResolver XmlResolver {
set { _XmlResolver = value; }
}
public void Load(XmlReader stylesheet) {
Load(stylesheet, new XmlUrlResolver());
}
public void Load(XmlReader stylesheet, XmlResolver resolver) {
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver);
}
public void Load(IXPathNavigable stylesheet) {
Load(stylesheet, new XmlUrlResolver());
}
public void Load(IXPathNavigable stylesheet, XmlResolver resolver) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(stylesheet.CreateNavigator(), resolver);
}
public void Load(XPathNavigator stylesheet) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(stylesheet, new XmlUrlResolver());
}
public void Load(XPathNavigator stylesheet, XmlResolver resolver) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(stylesheet, resolver, /*evidence:*/null);
}
public void Load(string url) {
Load(url, new XmlUrlResolver());
}
public void Load(string url, XmlResolver resolver) {
XmlTextReaderImpl tr = new XmlTextReaderImpl(url); {
tr.XmlResolver = resolver;
}
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(tr.BaseURI); // We should ask BaseURI before we start reading because it's changing with each node
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver, evidence);
}
public void Load(IXPathNavigable stylesheet, XmlResolver resolver, Evidence evidence) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(stylesheet.CreateNavigator(), resolver, evidence);
}
public void Load(XmlReader stylesheet, XmlResolver resolver, Evidence evidence) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver, evidence);
}
public void Load(XPathNavigator stylesheet, XmlResolver resolver, Evidence evidence) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
if (resolver == null) {
resolver = new XmlNullResolver();
}
if (evidence == null) {
evidence = new Evidence();
}
else {
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
}
Compile(stylesheet, resolver, evidence);
}
// ------------------------------------ Transform() ------------------------------------ //
private void CheckCommand() {
if (_CompiledStylesheet == null) {
throw new InvalidOperationException(Res.GetString(Res.Xslt_NoStylesheetLoaded));
}
}
public XmlReader Transform(XPathNavigator input, XsltArgumentList args, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
return processor.StartReader();
}
public XmlReader Transform(XPathNavigator input, XsltArgumentList args) {
return Transform(input, args, _XmlResolver);
}
public void Transform(XPathNavigator input, XsltArgumentList args, XmlWriter output, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public void Transform(XPathNavigator input, XsltArgumentList args, XmlWriter output) {
Transform(input, args, output, _XmlResolver);
}
public void Transform(XPathNavigator input, XsltArgumentList args, Stream output, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public void Transform(XPathNavigator input, XsltArgumentList args, Stream output) {
Transform(input, args, output, _XmlResolver);
}
public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output, XmlResolver resolver) {
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output) {
CheckCommand();
Processor processor = new Processor(input, args, _XmlResolver, _CompiledStylesheet, _QueryStore, _RootAction, debugger);
processor.Execute(output);
}
public XmlReader Transform(IXPathNavigable input, XsltArgumentList args, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
return Transform(input.CreateNavigator(), args, resolver);
}
public XmlReader Transform(IXPathNavigable input, XsltArgumentList args) {
if (input == null) {
throw new ArgumentNullException("input");
}
return Transform(input.CreateNavigator(), args, _XmlResolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, TextWriter output, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, resolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, TextWriter output) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, _XmlResolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, Stream output, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, resolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, Stream output) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, _XmlResolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output, XmlResolver resolver) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, resolver);
}
public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output) {
if (input == null) {
throw new ArgumentNullException("input");
}
Transform(input.CreateNavigator(), args, output, _XmlResolver);
}
public void Transform(String inputfile, String outputfile, XmlResolver resolver) {
FileStream fs = null;
try {
// We should read doc before creating output file in case they are the same
XPathDocument doc = new XPathDocument(inputfile);
fs = new FileStream(outputfile, FileMode.Create, FileAccess.ReadWrite);
Transform(doc, /*args:*/null, fs, resolver);
}
finally {
if (fs != null) {
fs.Close();
}
}
}
public void Transform(String inputfile, String outputfile) {
Transform(inputfile, outputfile, _XmlResolver);
}
// Implementation
private void Compile(XPathNavigator stylesheet, XmlResolver resolver, Evidence evidence) {
Debug.Assert(stylesheet != null);
Debug.Assert(resolver != null);
Compiler compiler = (Debugger == null) ? new Compiler() : new DbgCompiler(this.Debugger);
NavigatorInput input = new NavigatorInput(stylesheet);
compiler.Compile(input, resolver, evidence);
Debug.Assert(compiler.CompiledStylesheet != null);
Debug.Assert(compiler.QueryStore != null);
Debug.Assert(compiler.QueryStore != null);
_CompiledStylesheet = compiler.CompiledStylesheet;
_QueryStore = compiler.QueryStore;
_RootAction = compiler.RootAction;
}
internal IXsltDebugger Debugger {
get { return this.debugger; }
}
#if false
internal XslTransform(IXsltDebugger debugger) {
this.debugger = debugger;
}
#endif
internal XslTransform(object debugger) {
if (debugger != null) {
this.debugger = new DebuggerAddapter(debugger);
}
}
private class DebuggerAddapter : IXsltDebugger {
private object unknownDebugger;
private MethodInfo getBltIn;
private MethodInfo onCompile;
private MethodInfo onExecute;
public DebuggerAddapter(object unknownDebugger) {
this.unknownDebugger = unknownDebugger;
BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
Type unknownType = unknownDebugger.GetType();
getBltIn = unknownType.GetMethod("GetBuiltInTemplatesUri", flags);
onCompile = unknownType.GetMethod("OnInstructionCompile" , flags);
onExecute = unknownType.GetMethod("OnInstructionExecute" , flags);
}
// ------------------ IXsltDebugger ---------------
public string GetBuiltInTemplatesUri() {
if (getBltIn == null) {
return null;
}
return (string) getBltIn.Invoke(unknownDebugger, new object[] {});
}
public void OnInstructionCompile(XPathNavigator styleSheetNavigator) {
if (onCompile != null) {
onCompile.Invoke(unknownDebugger, new object[] { styleSheetNavigator });
}
}
public void OnInstructionExecute(IXsltProcessor xsltProcessor) {
if (onExecute != null) {
onExecute.Invoke(unknownDebugger, new object[] { xsltProcessor });
}
}
}
}
#endif // ! HIDE_XSL
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MessageDesigner.cs
- AutoGeneratedFieldProperties.cs
- DispatcherOperation.cs
- SmiMetaDataProperty.cs
- DependencyObjectType.cs
- HttpCacheVary.cs
- GroupBoxDesigner.cs
- CustomCredentialPolicy.cs
- DispatchWrapper.cs
- GraphicsState.cs
- DataGridViewCheckBoxColumn.cs
- figurelength.cs
- PropertyCondition.cs
- ExtendedTransformFactory.cs
- TabRenderer.cs
- XsltLoader.cs
- BitmapImage.cs
- basecomparevalidator.cs
- BridgeDataReader.cs
- Row.cs
- ProxySimple.cs
- PackageDocument.cs
- App.cs
- CodeThrowExceptionStatement.cs
- NetworkInformationException.cs
- GroupAggregateExpr.cs
- ListViewCommandEventArgs.cs
- CodeTypeDeclarationCollection.cs
- PropertyConverter.cs
- WebPartCloseVerb.cs
- ContentIterators.cs
- ZoneButton.cs
- SecurityPermission.cs
- TextEditorMouse.cs
- GetPageCompletedEventArgs.cs
- MobileUITypeEditor.cs
- DocumentSchemaValidator.cs
- BufferModesCollection.cs
- UnknownWrapper.cs
- ItemCheckEvent.cs
- PersonalizationStateQuery.cs
- DataTableReaderListener.cs
- UTF7Encoding.cs
- SignatureDescription.cs
- Decimal.cs
- log.cs
- DataTable.cs
- ResourceExpression.cs
- BinaryConverter.cs
- LoginName.cs
- Geometry3D.cs
- VectorKeyFrameCollection.cs
- QilIterator.cs
- ListControlConvertEventArgs.cs
- AnimationLayer.cs
- SqlFunctions.cs
- FormViewRow.cs
- DesigntimeLicenseContextSerializer.cs
- HtmlHead.cs
- Int64Converter.cs
- DataProtection.cs
- QuaternionAnimationBase.cs
- VectorAnimation.cs
- MaskedTextBoxTextEditorDropDown.cs
- ConstructorNeedsTagAttribute.cs
- XamlPointCollectionSerializer.cs
- DataGridViewRowPostPaintEventArgs.cs
- ComplexObject.cs
- DiscardableAttribute.cs
- ProxyFragment.cs
- FacetDescription.cs
- NamedPipeWorkerProcess.cs
- NativeCppClassAttribute.cs
- MonthCalendar.cs
- EntityContainerEntitySet.cs
- TrackingProfile.cs
- ApplicationBuildProvider.cs
- DataGridViewAddColumnDialog.cs
- SimpleHandlerFactory.cs
- BitmapMetadata.cs
- BehaviorEditorPart.cs
- DoubleLinkListEnumerator.cs
- FlowDocumentPageViewerAutomationPeer.cs
- MultiSelector.cs
- HttpEncoderUtility.cs
- SafeNativeMethods.cs
- PropertyGrid.cs
- Internal.cs
- Utils.cs
- CodeBinaryOperatorExpression.cs
- recordstate.cs
- SqlBulkCopyColumnMapping.cs
- sortedlist.cs
- HtmlInputSubmit.cs
- SendSecurityHeader.cs
- VisualTreeUtils.cs
- XmlDataSourceView.cs
- LocalValueEnumerator.cs
- CounterSampleCalculator.cs
- RuntimeConfigurationRecord.cs