Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Data / System / NewXml / XmlBoundElement.cs / 1 / XmlBoundElement.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml {
using System;
using System.IO;
using System.Collections;
using System.Data;
using System.Diagnostics;
internal enum ElementState {
None,
Defoliated,
WeakFoliation,
StrongFoliation,
Foliating,
Defoliating,
}
internal sealed class XmlBoundElement: XmlElement {
private DataRow row;
private ElementState state;
internal XmlBoundElement( string prefix, string localName, string namespaceURI, XmlDocument doc )
: base( prefix, localName, namespaceURI, doc ) {
state = ElementState.None;
}
public override XmlAttributeCollection Attributes {
get {
AutoFoliate();
return base.Attributes;
}
}
public override bool HasAttributes {
get { return Attributes.Count > 0; }
}
public override XmlNode FirstChild {
get {
AutoFoliate();
return base.FirstChild;
}
}
internal XmlNode SafeFirstChild { get { return base.FirstChild; } }
public override XmlNode LastChild {
get {
AutoFoliate();
return base.LastChild;
}
}
public override XmlNode PreviousSibling {
get {
XmlNode prev = base.PreviousSibling;
if ( prev == null ) {
XmlBoundElement parent = ParentNode as XmlBoundElement;
if ( parent != null ) {
parent.AutoFoliate();
return base.PreviousSibling;
}
}
return prev;
}
}
internal XmlNode SafePreviousSibling { get { return base.PreviousSibling; } }
public override XmlNode NextSibling {
get {
XmlNode next = base.NextSibling;
if ( next == null ) {
XmlBoundElement parent = ParentNode as XmlBoundElement;
if ( parent != null ) {
parent.AutoFoliate();
return base.NextSibling;
}
}
return next;
}
}
internal XmlNode SafeNextSibling { get { return base.NextSibling; } }
public override bool HasChildNodes {
get {
AutoFoliate();
return base.HasChildNodes;
}
}
public override XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) {
AutoFoliate();
return base.InsertBefore( newChild, refChild );
}
public override XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) {
AutoFoliate();
return base.InsertAfter( newChild, refChild );
}
public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) {
AutoFoliate();
return base.ReplaceChild( newChild, oldChild );
}
public override XmlNode AppendChild(XmlNode newChild) {
AutoFoliate();
return base.AppendChild( newChild );
}
internal void RemoveAllChildren() {
XmlNode child = FirstChild;
XmlNode sibling = null;
while ( child != null ) {
sibling = child.NextSibling;
RemoveChild( child );
child = sibling;
}
}
public override string InnerXml {
get {
return base.InnerXml;
}
set {
RemoveAllChildren();
XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
bool bOrigIgnoreXmlEvents = doc.IgnoreXmlEvents;
bool bOrigIgnoreDataSetEvents = doc.IgnoreDataSetEvents;
doc.IgnoreXmlEvents = true;
doc.IgnoreDataSetEvents = true;
base.InnerXml = value;
doc.SyncTree( this );
doc.IgnoreDataSetEvents = bOrigIgnoreDataSetEvents;
doc.IgnoreXmlEvents = bOrigIgnoreXmlEvents;
}
}
internal DataRow Row {
get { return row;}
set { row = value;}
}
internal bool IsFoliated {
get {
while ( state == ElementState.Foliating || state == ElementState.Defoliating )
System.Threading.Thread.Sleep(0);
//has to be sure that we are either foliated or defoliated when ask for IsFoliated.
return state != ElementState.Defoliated;
}
}
internal ElementState ElementState {
get { return state;}
set { state = value;}
}
internal void Foliate( ElementState newState ) {
XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
if ( doc != null )
doc.Foliate( this, newState );
}
// Foliate the node as a side effect of user calling functions on this node (like NextSibling) OR as a side effect of DataDocNav using nodes to do editing
private void AutoFoliate() {
XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
if ( doc != null )
doc.Foliate( this, doc.AutoFoliationState );
}
public override XmlNode CloneNode(bool deep) {
XmlDataDocument doc = (XmlDataDocument)(this.OwnerDocument);
ElementState oldAutoFoliationState = doc.AutoFoliationState;
doc.AutoFoliationState = ElementState.WeakFoliation;
XmlElement element;
try {
Foliate( ElementState.WeakFoliation );
element = (XmlElement)(base.CloneNode( deep ));
// Clone should create a XmlBoundElement node
Debug.Assert( element is XmlBoundElement );
}
finally {
doc.AutoFoliationState = oldAutoFoliationState;
}
return element;
}
public override void WriteContentTo( XmlWriter w ) {
DataPointer dp = new DataPointer( (XmlDataDocument)OwnerDocument, this );
try {
dp.AddPointer();
WriteBoundElementContentTo( dp, w );
}
finally {
dp.SetNoLongerUse();
}
}
public override void WriteTo( XmlWriter w ) {
DataPointer dp = new DataPointer( (XmlDataDocument)OwnerDocument, this );
try {
dp.AddPointer();
WriteRootBoundElementTo( dp, w );
}
finally {
dp.SetNoLongerUse();
}
}
private void WriteRootBoundElementTo(DataPointer dp, XmlWriter w) {
Debug.Assert( dp.NodeType == XmlNodeType.Element );
XmlDataDocument doc = (XmlDataDocument)OwnerDocument;
w.WriteStartElement( dp.Prefix, dp.LocalName, dp.NamespaceURI );
int cAttr = dp.AttributeCount;
bool bHasXSI = false;
if ( cAttr > 0 ) {
for ( int iAttr = 0; iAttr < cAttr; iAttr++ ) {
dp.MoveToAttribute( iAttr );
if ( dp.Prefix == "xmlns" && dp.LocalName == XmlDataDocument.XSI )
bHasXSI = true;
WriteTo( dp, w );
dp.MoveToOwnerElement();
}
}
if ( !bHasXSI && doc.bLoadFromDataSet && doc.bHasXSINIL )
w.WriteAttributeString( "xmlns", "xsi", "http://www.w3.org/2000/xmlns/", Keywords.XSINS );
WriteBoundElementContentTo( dp, w );
// Force long end tag when the elem is not empty, even if there are no children.
if ( dp.IsEmptyElement )
w.WriteEndElement();
else
w.WriteFullEndElement();
}
private static void WriteBoundElementTo( DataPointer dp, XmlWriter w ) {
Debug.Assert( dp.NodeType == XmlNodeType.Element );
w.WriteStartElement( dp.Prefix, dp.LocalName, dp.NamespaceURI );
int cAttr = dp.AttributeCount;
if ( cAttr > 0 ) {
for ( int iAttr = 0; iAttr < cAttr; iAttr++ ) {
dp.MoveToAttribute( iAttr );
WriteTo( dp, w );
dp.MoveToOwnerElement();
}
}
WriteBoundElementContentTo( dp, w );
// Force long end tag when the elem is not empty, even if there are no children.
if ( dp.IsEmptyElement )
w.WriteEndElement();
else
w.WriteFullEndElement();
}
private static void WriteBoundElementContentTo( DataPointer dp, XmlWriter w ) {
if ( !dp.IsEmptyElement && dp.MoveToFirstChild() ) {
do {
WriteTo( dp, w );
}
while ( dp.MoveToNextSibling() );
dp.MoveToParent();
}
}
private static void WriteTo( DataPointer dp, XmlWriter w ) {
switch ( dp.NodeType ) {
case XmlNodeType.Attribute:
if ( !dp.IsDefault ) {
w.WriteStartAttribute( dp.Prefix, dp.LocalName, dp.NamespaceURI );
if ( dp.MoveToFirstChild() ) {
do {
WriteTo( dp, w );
}
while ( dp.MoveToNextSibling() );
dp.MoveToParent();
}
w.WriteEndAttribute();
}
break;
case XmlNodeType.Element:
WriteBoundElementTo( dp, w );
break;
case XmlNodeType.Text:
w.WriteString(dp.Value);
break;
default:
Debug.Assert( ((IXmlDataVirtualNode)dp).IsOnColumn( null ) );
if ( dp.GetNode() != null )
dp.GetNode().WriteTo( w );
break;
}
}
public override XmlNodeList GetElementsByTagName(string name) {
// Retrieving nodes from the returned nodelist may cause foliation which causes new nodes to be created,
// so the System.Xml iterator will throw if this happens during iteration. To avoid this, foliate everything
// before iteration, so iteration will not cause foliation (and as a result of this, creation of new nodes).
XmlNodeList tempNodeList = base.GetElementsByTagName(name);
int tempint = tempNodeList.Count;
return tempNodeList;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml {
using System;
using System.IO;
using System.Collections;
using System.Data;
using System.Diagnostics;
internal enum ElementState {
None,
Defoliated,
WeakFoliation,
StrongFoliation,
Foliating,
Defoliating,
}
internal sealed class XmlBoundElement: XmlElement {
private DataRow row;
private ElementState state;
internal XmlBoundElement( string prefix, string localName, string namespaceURI, XmlDocument doc )
: base( prefix, localName, namespaceURI, doc ) {
state = ElementState.None;
}
public override XmlAttributeCollection Attributes {
get {
AutoFoliate();
return base.Attributes;
}
}
public override bool HasAttributes {
get { return Attributes.Count > 0; }
}
public override XmlNode FirstChild {
get {
AutoFoliate();
return base.FirstChild;
}
}
internal XmlNode SafeFirstChild { get { return base.FirstChild; } }
public override XmlNode LastChild {
get {
AutoFoliate();
return base.LastChild;
}
}
public override XmlNode PreviousSibling {
get {
XmlNode prev = base.PreviousSibling;
if ( prev == null ) {
XmlBoundElement parent = ParentNode as XmlBoundElement;
if ( parent != null ) {
parent.AutoFoliate();
return base.PreviousSibling;
}
}
return prev;
}
}
internal XmlNode SafePreviousSibling { get { return base.PreviousSibling; } }
public override XmlNode NextSibling {
get {
XmlNode next = base.NextSibling;
if ( next == null ) {
XmlBoundElement parent = ParentNode as XmlBoundElement;
if ( parent != null ) {
parent.AutoFoliate();
return base.NextSibling;
}
}
return next;
}
}
internal XmlNode SafeNextSibling { get { return base.NextSibling; } }
public override bool HasChildNodes {
get {
AutoFoliate();
return base.HasChildNodes;
}
}
public override XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) {
AutoFoliate();
return base.InsertBefore( newChild, refChild );
}
public override XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) {
AutoFoliate();
return base.InsertAfter( newChild, refChild );
}
public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) {
AutoFoliate();
return base.ReplaceChild( newChild, oldChild );
}
public override XmlNode AppendChild(XmlNode newChild) {
AutoFoliate();
return base.AppendChild( newChild );
}
internal void RemoveAllChildren() {
XmlNode child = FirstChild;
XmlNode sibling = null;
while ( child != null ) {
sibling = child.NextSibling;
RemoveChild( child );
child = sibling;
}
}
public override string InnerXml {
get {
return base.InnerXml;
}
set {
RemoveAllChildren();
XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
bool bOrigIgnoreXmlEvents = doc.IgnoreXmlEvents;
bool bOrigIgnoreDataSetEvents = doc.IgnoreDataSetEvents;
doc.IgnoreXmlEvents = true;
doc.IgnoreDataSetEvents = true;
base.InnerXml = value;
doc.SyncTree( this );
doc.IgnoreDataSetEvents = bOrigIgnoreDataSetEvents;
doc.IgnoreXmlEvents = bOrigIgnoreXmlEvents;
}
}
internal DataRow Row {
get { return row;}
set { row = value;}
}
internal bool IsFoliated {
get {
while ( state == ElementState.Foliating || state == ElementState.Defoliating )
System.Threading.Thread.Sleep(0);
//has to be sure that we are either foliated or defoliated when ask for IsFoliated.
return state != ElementState.Defoliated;
}
}
internal ElementState ElementState {
get { return state;}
set { state = value;}
}
internal void Foliate( ElementState newState ) {
XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
if ( doc != null )
doc.Foliate( this, newState );
}
// Foliate the node as a side effect of user calling functions on this node (like NextSibling) OR as a side effect of DataDocNav using nodes to do editing
private void AutoFoliate() {
XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
if ( doc != null )
doc.Foliate( this, doc.AutoFoliationState );
}
public override XmlNode CloneNode(bool deep) {
XmlDataDocument doc = (XmlDataDocument)(this.OwnerDocument);
ElementState oldAutoFoliationState = doc.AutoFoliationState;
doc.AutoFoliationState = ElementState.WeakFoliation;
XmlElement element;
try {
Foliate( ElementState.WeakFoliation );
element = (XmlElement)(base.CloneNode( deep ));
// Clone should create a XmlBoundElement node
Debug.Assert( element is XmlBoundElement );
}
finally {
doc.AutoFoliationState = oldAutoFoliationState;
}
return element;
}
public override void WriteContentTo( XmlWriter w ) {
DataPointer dp = new DataPointer( (XmlDataDocument)OwnerDocument, this );
try {
dp.AddPointer();
WriteBoundElementContentTo( dp, w );
}
finally {
dp.SetNoLongerUse();
}
}
public override void WriteTo( XmlWriter w ) {
DataPointer dp = new DataPointer( (XmlDataDocument)OwnerDocument, this );
try {
dp.AddPointer();
WriteRootBoundElementTo( dp, w );
}
finally {
dp.SetNoLongerUse();
}
}
private void WriteRootBoundElementTo(DataPointer dp, XmlWriter w) {
Debug.Assert( dp.NodeType == XmlNodeType.Element );
XmlDataDocument doc = (XmlDataDocument)OwnerDocument;
w.WriteStartElement( dp.Prefix, dp.LocalName, dp.NamespaceURI );
int cAttr = dp.AttributeCount;
bool bHasXSI = false;
if ( cAttr > 0 ) {
for ( int iAttr = 0; iAttr < cAttr; iAttr++ ) {
dp.MoveToAttribute( iAttr );
if ( dp.Prefix == "xmlns" && dp.LocalName == XmlDataDocument.XSI )
bHasXSI = true;
WriteTo( dp, w );
dp.MoveToOwnerElement();
}
}
if ( !bHasXSI && doc.bLoadFromDataSet && doc.bHasXSINIL )
w.WriteAttributeString( "xmlns", "xsi", "http://www.w3.org/2000/xmlns/", Keywords.XSINS );
WriteBoundElementContentTo( dp, w );
// Force long end tag when the elem is not empty, even if there are no children.
if ( dp.IsEmptyElement )
w.WriteEndElement();
else
w.WriteFullEndElement();
}
private static void WriteBoundElementTo( DataPointer dp, XmlWriter w ) {
Debug.Assert( dp.NodeType == XmlNodeType.Element );
w.WriteStartElement( dp.Prefix, dp.LocalName, dp.NamespaceURI );
int cAttr = dp.AttributeCount;
if ( cAttr > 0 ) {
for ( int iAttr = 0; iAttr < cAttr; iAttr++ ) {
dp.MoveToAttribute( iAttr );
WriteTo( dp, w );
dp.MoveToOwnerElement();
}
}
WriteBoundElementContentTo( dp, w );
// Force long end tag when the elem is not empty, even if there are no children.
if ( dp.IsEmptyElement )
w.WriteEndElement();
else
w.WriteFullEndElement();
}
private static void WriteBoundElementContentTo( DataPointer dp, XmlWriter w ) {
if ( !dp.IsEmptyElement && dp.MoveToFirstChild() ) {
do {
WriteTo( dp, w );
}
while ( dp.MoveToNextSibling() );
dp.MoveToParent();
}
}
private static void WriteTo( DataPointer dp, XmlWriter w ) {
switch ( dp.NodeType ) {
case XmlNodeType.Attribute:
if ( !dp.IsDefault ) {
w.WriteStartAttribute( dp.Prefix, dp.LocalName, dp.NamespaceURI );
if ( dp.MoveToFirstChild() ) {
do {
WriteTo( dp, w );
}
while ( dp.MoveToNextSibling() );
dp.MoveToParent();
}
w.WriteEndAttribute();
}
break;
case XmlNodeType.Element:
WriteBoundElementTo( dp, w );
break;
case XmlNodeType.Text:
w.WriteString(dp.Value);
break;
default:
Debug.Assert( ((IXmlDataVirtualNode)dp).IsOnColumn( null ) );
if ( dp.GetNode() != null )
dp.GetNode().WriteTo( w );
break;
}
}
public override XmlNodeList GetElementsByTagName(string name) {
// Retrieving nodes from the returned nodelist may cause foliation which causes new nodes to be created,
// so the System.Xml iterator will throw if this happens during iteration. To avoid this, foliate everything
// before iteration, so iteration will not cause foliation (and as a result of this, creation of new nodes).
XmlNodeList tempNodeList = base.GetElementsByTagName(name);
int tempint = tempNodeList.Count;
return tempNodeList;
}
}
}
// 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
- BamlTreeNode.cs
- MouseBinding.cs
- OleAutBinder.cs
- TaskHelper.cs
- IgnoreFlushAndCloseStream.cs
- SimpleApplicationHost.cs
- SqlServer2KCompatibilityAnnotation.cs
- XmlTextReader.cs
- WebPartEditVerb.cs
- XmlAutoDetectWriter.cs
- EventEntry.cs
- SqlBuilder.cs
- ServiceContractGenerationContext.cs
- DetailsViewRowCollection.cs
- ComPlusServiceLoader.cs
- DataGridTextBox.cs
- TypedTableBase.cs
- NumberSubstitution.cs
- StrokeNodeData.cs
- MissingMemberException.cs
- Encoder.cs
- ObjectDataSourceDisposingEventArgs.cs
- ColumnMapVisitor.cs
- DependencyPropertyConverter.cs
- XpsFontSerializationService.cs
- IsolatedStorageException.cs
- GlobalEventManager.cs
- ColumnHeader.cs
- SettingsPropertyValueCollection.cs
- GeneratedCodeAttribute.cs
- PropertyChange.cs
- SiteMapPathDesigner.cs
- StandardCommands.cs
- DelegateSerializationHolder.cs
- EventLogLink.cs
- ValidatedControlConverter.cs
- CalendarAutoFormat.cs
- PolicyException.cs
- TypedTableBaseExtensions.cs
- shaperfactory.cs
- ShortcutKeysEditor.cs
- PagesChangedEventArgs.cs
- ElementsClipboardData.cs
- InstanceLockedException.cs
- ExpressionConverter.cs
- AnnotationObservableCollection.cs
- DescriptionAttribute.cs
- TypeUsageBuilder.cs
- HtmlWindow.cs
- CodeExpressionCollection.cs
- XmlILStorageConverter.cs
- ObjectDataSource.cs
- FilteredDataSetHelper.cs
- XmlSchemaFacet.cs
- SkewTransform.cs
- GroupBox.cs
- BypassElementCollection.cs
- Underline.cs
- CrossContextChannel.cs
- Walker.cs
- ObjectQuery.cs
- InputLangChangeRequestEvent.cs
- XmlCustomFormatter.cs
- TextEditorCharacters.cs
- securitymgrsite.cs
- Statements.cs
- StateBag.cs
- EnumType.cs
- QilTypeChecker.cs
- InheritablePropertyChangeInfo.cs
- PerspectiveCamera.cs
- CompressedStack.cs
- WeakReference.cs
- WebException.cs
- PreProcessor.cs
- SafeProcessHandle.cs
- TakeQueryOptionExpression.cs
- HtmlElementCollection.cs
- RangeBase.cs
- DbParameterCollectionHelper.cs
- SqlClientWrapperSmiStreamChars.cs
- FactoryRecord.cs
- ScrollChrome.cs
- PerfCounterSection.cs
- PerformanceCounterPermission.cs
- ISFTagAndGuidCache.cs
- BrowsableAttribute.cs
- NetworkStream.cs
- CorrelationQuery.cs
- UrlPath.cs
- WebPartEditorOkVerb.cs
- SecurityUtils.cs
- EntityViewGenerationAttribute.cs
- XmlnsDefinitionAttribute.cs
- WindowsGraphicsWrapper.cs
- _NestedSingleAsyncResult.cs
- TargetFrameworkUtil.cs
- ArgIterator.cs
- DropSource.cs
- Drawing.cs