Code:
/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / Designer / System / data / design / DesignDataSource.cs / 2 / DesignDataSource.cs
//#define LoadByDataSourceOptimizedXmlSerializer //#define perfcounter //------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All Rights Reserved. // Information Contained Herein is Proprietary and Confidential. // //----------------------------------------------------------------------------- namespace System.Data.Design{ using System; using System.Collections; using System.Collections.Specialized; using System.ComponentModel; using System.ComponentModel.Design; using System.Design; using System.Diagnostics; using System.Data; using System.Data.OleDb; using System.Data.Common; using System.IO; using System.Globalization; using System.Runtime.Serialization.Formatters.Binary; using System.Reflection; using System.Xml; using System.Windows.Forms; using System.CodeDom; using System.CodeDom.Compiler; using System.Threading; ////// DataSource is the so-called design time data source class intended to be used /// by DataSourceDesigner, DataSourceCodeGeneration, DataService and other Data /// specific tasks. /// DataSource is defined as Component because we want to use it as the root component in /// the DataSource designer /// [ DataSourceXmlClass(SchemaName.DataSourceRoot) ] internal class DesignDataSource : DataSourceComponent, IDataSourceNamedObject, IDataSourceCommandTarget { private DataSet dataSet; private DesignTableCollection designTables; private DesignRelationCollection designRelations; private DesignConnectionCollection designConnections; private int defaultConnectionIndex; private SourceCollection sources; private TypeAttributes modifier = TypeAttributes.Public; private SchemaSerializationMode schemaSerializationMode = SchemaSerializationMode.IncludeSchema; #if LoadByDataSourceOptimizedXmlSerializer private DataSourceOptimizedXmlSerializer serializer; #else private DataSourceXmlSerializer serializer; #endif private StringCollection namingPropNames = new StringCollection(); internal static string EXTPROPNAME_USER_DATASETNAME = "Generator_UserDSName"; internal static string EXTPROPNAME_GENERATOR_DATASETNAME = "Generator_DataSetName"; private const string EXTPROPNAME_ENABLE_TABLEADAPTERMANAGER = "EnableTableAdapterManager"; private string functionsComponentName = null; private string userFunctionsComponentName = null; private string generatorFunctionsComponentClassName = null; ////// This event encapsulates all data change events including property change events and collection change events. /// ////// /// internal DataSet DataSet{ get{ if (dataSet == null) { dataSet = new DataSet(); dataSet.Locale = System.Globalization.CultureInfo.InvariantCulture; // VS Whidbey Bug 194886 dataSet.EnforceConstraints = false; } return dataSet; } } ////// // NOTE: as we save DefaultConnection as an Index, any ConnectionEditor should maintain it if it modified the DesignConnection collection // except operation only adds a new connection to the end of the collection. [ DisplayName ("DefaultConnection"), ] public DesignConnection DefaultConnection { get { if (DesignConnections.Count > 0) { if (defaultConnectionIndex >= 0 && defaultConnectionIndex < DesignConnections.Count) { return ((IList)DesignConnections)[defaultConnectionIndex] as DesignConnection; } } return null; } } ////// [ DisplayName("Connections"), DataSourceXmlSubItem(Name="Connections", ItemType=typeof(DesignConnection)), Browsable(false) ] public DesignConnectionCollection DesignConnections { get{ if (designConnections == null){ designConnections = new DesignConnectionCollection(this); } return designConnections; } } ////// [Browsable(false)] public DesignRelationCollection DesignRelations { get{ if (designRelations == null){ designRelations = new DesignRelationCollection(this); } return designRelations; } } ////// [ DataSourceXmlSubItem(Name="Tables", ItemType=typeof(DesignConnection)), Browsable(false), ] public DesignTableCollection DesignTables { get{ if (designTables == null){ designTables = new DesignTableCollection(this); } return designTables; } } [DefaultValue(true)] public bool EnableTableAdapterManager { get { bool result = false; Boolean.TryParse(this.DataSet.ExtendedProperties[EXTPROPNAME_ENABLE_TABLEADAPTERMANAGER] as string, out result); return result; } set { this.DataSet.ExtendedProperties[EXTPROPNAME_ENABLE_TABLEADAPTERMANAGER] = value.ToString(); } } ////// Dataset class modifier /// [ DefaultValue(TypeAttributes.Public), DataSourceXmlAttribute() ] public TypeAttributes Modifier { get { return modifier; } set { modifier = value; } } [ MergableProperty(false), DefaultValue("") ] public string Name { get { return this.DataSet.DataSetName; } set { this.DataSet.DataSetName = value; } } [Browsable(false)] public string PublicTypeName { get { return "DataSet"; } } ////// [ DataSourceXmlSubItem(typeof(Source)), Browsable(false), ] public SourceCollection Sources{ get{ if (sources == null){ sources = new SourceCollection(this); } return sources; } } [DataSourceXmlAttribute()] public SchemaSerializationMode SchemaSerializationMode { get { return schemaSerializationMode; } set { schemaSerializationMode = value; } } internal string UserDataSetName { get { return this.DataSet.ExtendedProperties[EXTPROPNAME_USER_DATASETNAME] as string; } set { this.DataSet.ExtendedProperties[EXTPROPNAME_USER_DATASETNAME] = value; } } internal string GeneratorDataSetName { get { return this.DataSet.ExtendedProperties[EXTPROPNAME_GENERATOR_DATASETNAME] as string; } set { this.DataSet.ExtendedProperties[EXTPROPNAME_GENERATOR_DATASETNAME] = value; } } [DataSourceXmlAttribute(), Browsable(false), DefaultValue(null)] public string FunctionsComponentName { get { return this.functionsComponentName; } set { this.functionsComponentName = value; } } [DataSourceXmlAttribute(), Browsable(false), DefaultValue(null)] public string UserFunctionsComponentName { get { return this.userFunctionsComponentName; } set { this.userFunctionsComponentName = value; } } [DataSourceXmlAttribute(), Browsable (false), DefaultValue(null)] public string GeneratorFunctionsComponentClassName { get { return this.generatorFunctionsComponentClassName; } set { this.generatorFunctionsComponentClassName = value; } } internal override StringCollection NamingPropertyNames { get { return namingPropNames; } } void IDataSourceCommandTarget.AddChild(object child, bool fixName) { Type childType = child.GetType(); Debug.Assert(((IDataSourceCommandTarget)this).CanAddChildOfType(childType), "We can't add this type of child"); if (typeof(DesignTable).IsAssignableFrom(childType)) { DesignTables.Add((DesignTable)child); } else if (typeof(DesignRelation).IsAssignableFrom(childType)) { DesignRelations.Add((DesignRelation) child); } else if (typeof(IDesignConnection).IsAssignableFrom(childType)) { DesignConnections.Add( (IDesignConnection) child); } else if (typeof(Source).IsAssignableFrom(childType)) { Sources.Add((Source) child); } } bool IDataSourceCommandTarget.CanAddChildOfType(Type childType) { return (typeof(DesignTable).IsAssignableFrom(childType) || typeof(IDesignConnection).IsAssignableFrom(childType) || typeof(Source).IsAssignableFrom(childType) || (typeof(DesignRelation).IsAssignableFrom(childType) && ((ICollection)this.DesignTables).Count > 0) ); } bool IDataSourceCommandTarget.CanInsertChildOfType(Type childType, object refChild) { if (typeof(Source).IsAssignableFrom(childType)) { return (refChild is Source); } else if (typeof(IDesignConnection).IsAssignableFrom(childType)) { return (refChild is IDesignConnection); } if (typeof(DesignTable).IsAssignableFrom(childType)) { return true; } return false; } bool IDataSourceCommandTarget.CanRemoveChildren(ICollection children) { foreach (object child in children) { if (!CanRemoveChild(child)) { return false; } } return true; } private bool CanRemoveChild(object child) { bool canRemove = false; Type childType = child.GetType(); if (typeof(DesignTable).IsAssignableFrom(childType)) { canRemove = DesignTables.Contains((DesignTable) child); } else if (typeof(DesignRelation).IsAssignableFrom(childType)) { canRemove = DesignRelations.Contains((DesignRelation) child); } else if (typeof(IDesignConnection).IsAssignableFrom(childType)) { canRemove = DesignConnections.Contains((IDesignConnection) child); } else if (typeof(Source).IsAssignableFrom(childType)) { canRemove = Sources.Contains((Source) child); } return canRemove; } internal ArrayList GetRelatedRelations(ICollection tableList) { ArrayList relatedRelations = new ArrayList(); foreach (DesignRelation relation in DesignRelations) { DesignTable parent = relation.ParentDesignTable; DesignTable child = relation.ChildDesignTable; foreach (object t in tableList) { if (parent == t || child == t) { relatedRelations.Add(relation); break; } } } return relatedRelations; } void IDataSourceCommandTarget.InsertChild(object child, object refChild) { Debug.Assert(((IDataSourceCommandTarget)this).CanInsertChildOfType(child.GetType(), refChild)); if (child is DesignTable) { DesignTables.InsertBefore(child, refChild); } else if (child is DesignRelation) { DesignRelations.InsertBefore(child, refChild); } else if (child is Source) { Sources.InsertBefore(child, refChild); } else if (child is IDesignConnection) { DesignConnections.InsertBefore(child, refChild); } } object IDataSourceCommandTarget.GetObject(int index, bool getSiblingIfOutOfRange) { throw new NotImplementedException(); } int IDataSourceCommandTarget.IndexOf(object child) { throw new NotImplementedException(); } ////// public void ReadXmlSchema(Stream stream){ DataSourceXmlTextReader xmlReader = new DataSourceXmlTextReader(this, stream); ReadXmlSchema(xmlReader); } ////// ReadXmlSchema, the DesignTables will be created /// public void ReadXmlSchema(TextReader textReader){ DataSourceXmlTextReader xmlReader = new DataSourceXmlTextReader(this, textReader); ReadXmlSchema(xmlReader); } private void ReadXmlSchema(DataSourceXmlTextReader xmlReader) { designConnections = new DesignConnectionCollection(this); designTables = new DesignTableCollection(this); designRelations = new DesignRelationCollection(this); sources = new SourceCollection(this); #if LoadByDataSourceOptimizedXmlSerializer serializer = new DataSourceOptimizedXmlSerializer(); dataSet = new DataSet(); // Let dataSet to read the sceham and create the dataSet // during read, we save the appInfo dataSourceXmlNode // dataSet.ReadXmlSchema(xmlReader); // Create designTables foreach (DataTable dataTable in dataSet.Tables) { designTables.Add(new DesignTable(dataTable, TableType.DataTable)); } // Now read back the datasource extra info from dataSourceXmlNode // if (appinfoDataSourceXmlElement != null){ serializer.DeserializeDataSource(this, appinfoDataSourceXmlElement); appinfoDataSourceXmlElement = null; appinfoXmlDoc = null; } #else serializer = new DataSourceXmlSerializer(); // we create a temporary dataSet here to load our RadTable, and create another DataSet to load schema // later we merge them together with the name of table... // This hacks a little bit, because when we load our own data fromtree, we will load it into // the current dataSet, and newDataSet will contains real DataTables. Right now, that's only for RadTable, // where we merge them with name. dataSet = new DataSet(); dataSet.Locale = System.Globalization.CultureInfo.InvariantCulture; DataSet newDataSet = new DataSet(); newDataSet.Locale = System.Globalization.CultureInfo.InvariantCulture; newDataSet.ReadXmlSchema(xmlReader); dataSet = newDataSet; #endif foreach (DataTable dataTable in dataSet.Tables) { DesignTable table = designTables[dataTable.TableName]; #if !LoadByDataSourceOptimizedXmlSerializer if (table == null) { designTables.Add(new DesignTable(dataTable, TableType.DataTable)); } else { table.DataTable = dataTable; } #endif foreach (Constraint constraint in dataTable.Constraints) { ForeignKeyConstraint relationConstraint = constraint as ForeignKeyConstraint; if (relationConstraint != null) { designRelations.Add(new DesignRelation(relationConstraint)); } } } foreach (DataRelation dataRelation in dataSet.Relations) { DesignRelation relation = designRelations[dataRelation.ChildKeyConstraint]; if (relation != null) { relation.DataRelation = dataRelation; } else { designRelations.Add(new DesignRelation(dataRelation)); } } // we need connect sources to connections foreach (Source source in Sources) { SetConnectionProperty(source); } foreach (DesignTable table in this.DesignTables) { SetConnectionProperty(table.MainSource); foreach (Source function in table.Sources) { SetConnectionProperty(function); } } serializer.InitializeObjects(); } private void SetConnectionProperty( Source source ) { DbSource dbSource = source as DbSource; if( dbSource == null ) { return; } string connectionRef = dbSource.ConnectionRef; if (connectionRef == null || connectionRef.Length == 0) { // } else { IDesignConnection connection = this.DesignConnections.Get(connectionRef); if (connection == null) { // } else { dbSource.Connection = connection; } } } #if LoadByDataSourceOptimizedXmlSerializer XmlDocument appinfoXmlDoc; XmlElement appinfoDataSourceXmlElement; /// /// internal void ReadDataSourceExtraInformation(XmlTextReader xmlTextReader) { appinfoXmlDoc = new XmlDocument(); appinfoDataSourceXmlElement = appinfoXmlDoc.ReadNode(xmlTextReader) as XmlElement; appinfoXmlDoc.AppendChild(appinfoDataSourceXmlElement); } #else ////// internal void ReadDataSourceExtraInformation(XmlTextReader xmlTextReader) { XmlDocument xdoc = new XmlDocument(); XmlNode schNode = xdoc.ReadNode(xmlTextReader); xdoc.AppendChild(schNode); Debug.Assert(serializer != null, "This function should only be called by DataSetXmlTextReader"); if (serializer != null) { serializer.DeserializeBody((XmlElement)schNode, this); } } #endif void IDataSourceCommandTarget.RemoveChildren(ICollection children) { // we should remove table later than Relations, // if there is a dataRelation on the table, we won't be able to remove the table until we remove the relation SortedList tableList = new SortedList(); foreach (object child in children) { if (child is DesignTable){ Debug.Assert(this.DesignTables.Contains((DesignTable) child), "Try to remove designTable that not in the collection"); // Use nagative index value as key, so the sorted order // is the reverse order of the index, then we can remove tables // in reverse order. // tableList.Add(-DesignTables.IndexOf((DesignTable) child), child); } else { RemoveChild(child); } } // we should remove relations connecting to this table at first... ArrayList relatedRelations = GetRelatedRelations(children); foreach (DesignRelation relatedRelation in relatedRelations) { RemoveChild(relatedRelation); } // To keep the order when undo, we either need to keep the remove as a group undo unit // or need to remove the children in the revers order // We should not rely the given children's order, which is defined by UI. // foreach (object child in tableList.Values) { if (child is DesignTable) { RemoveChild(child); } } } private void RemoveChild(object child) { Debug.Assert(CanRemoveChild(child), "Invalid child"); Type childType = child.GetType(); if (typeof(DesignTable).IsAssignableFrom(childType)) { DesignTables.Remove((DesignTable) child); } else if (typeof(DesignRelation).IsAssignableFrom(childType)) { DesignRelations.Remove((DesignRelation) child); } else if (typeof(IDesignConnection).IsAssignableFrom(childType)) { DesignConnections.Remove((IDesignConnection) child); } else if (typeof(Source).IsAssignableFrom(childType)) { Sources.Remove((Source) child); } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SecurityPermission.cs
- StandardOleMarshalObject.cs
- ClientScriptManager.cs
- PrintPageEvent.cs
- EtwTrackingBehavior.cs
- XamlWriter.cs
- MonitoringDescriptionAttribute.cs
- PropertyPathWorker.cs
- StrokeNodeEnumerator.cs
- httpstaticobjectscollection.cs
- DependencyObjectType.cs
- WorkflowInlining.cs
- ExtentCqlBlock.cs
- SmiGettersStream.cs
- RadialGradientBrush.cs
- ApplicationSecurityInfo.cs
- DataGridViewAutoSizeModeEventArgs.cs
- TableMethodGenerator.cs
- RegistrationProxy.cs
- PrtCap_Public_Simple.cs
- RegistryKey.cs
- EntityTransaction.cs
- BuildProviderUtils.cs
- WebPartDisplayModeEventArgs.cs
- regiisutil.cs
- SocketStream.cs
- PublisherIdentityPermission.cs
- MaterialGroup.cs
- TabControlEvent.cs
- CompiledAction.cs
- DataGridViewRowStateChangedEventArgs.cs
- AuthenticationModuleElement.cs
- MethodBody.cs
- ScopeCompiler.cs
- ObjectTag.cs
- DecimalConverter.cs
- IpcChannel.cs
- ParseHttpDate.cs
- FileCodeGroup.cs
- ThrowHelper.cs
- HtmlWindowCollection.cs
- WebRequest.cs
- NamedPipeAppDomainProtocolHandler.cs
- XmlILModule.cs
- ConnectionPointCookie.cs
- ipaddressinformationcollection.cs
- SubclassTypeValidatorAttribute.cs
- Base64Decoder.cs
- SqlCachedBuffer.cs
- AssociationTypeEmitter.cs
- ReferenceEqualityComparer.cs
- ImageSource.cs
- COSERVERINFO.cs
- Publisher.cs
- ZipIORawDataFileBlock.cs
- UrlMappingsSection.cs
- XmlCustomFormatter.cs
- QueryReaderSettings.cs
- EpmSyndicationContentDeSerializer.cs
- SocketException.cs
- ProxyWebPartManager.cs
- SqlAliaser.cs
- TimeIntervalCollection.cs
- CapabilitiesAssignment.cs
- LZCodec.cs
- CqlParserHelpers.cs
- PartialCachingAttribute.cs
- DefaultObjectMappingItemCollection.cs
- FrameworkName.cs
- RefreshPropertiesAttribute.cs
- DefaultHttpHandler.cs
- DbLambda.cs
- WebPartChrome.cs
- SafeHandles.cs
- TraceSwitch.cs
- StructuralCache.cs
- DataGridViewCellValidatingEventArgs.cs
- TextSelection.cs
- mediaeventargs.cs
- DataGridDetailsPresenterAutomationPeer.cs
- StylusPointPropertyInfoDefaults.cs
- DbConnectionStringBuilder.cs
- BufferModeSettings.cs
- BookmarkTable.cs
- FullTrustAssembly.cs
- Brush.cs
- ProviderMetadataCachedInformation.cs
- GridView.cs
- ProgramPublisher.cs
- TimeoutHelper.cs
- HttpListenerPrefixCollection.cs
- MenuTracker.cs
- StrongNameKeyPair.cs
- SchemaNotation.cs
- GenerateHelper.cs
- DurableTimerExtension.cs
- MbpInfo.cs
- x509store.cs
- BuildResult.cs
- Operand.cs