public override string ToString() { Type type = this.GetType(); SampleDataSet sampleDataSet = SampleDataSet.SampleDataSetFromType(type); return(sampleDataSet == null ? type.Name : sampleDataSet.ClrNamespace + "." + type.Name); }
private void Refresh(SampleDataSet changedSampleData) { List <DocumentNode> list = (List <DocumentNode>)null; foreach (KeyValuePair <DocumentNode, ISchema> keyValuePair in this.schemaCache) { ClrObjectSchema clrObjectSchema = keyValuePair.Value as ClrObjectSchema; if (clrObjectSchema != null) { Type typeForDataSource = this.GetTypeForDataSource(keyValuePair.Key); if (typeForDataSource != (Type)null && clrObjectSchema.Root.Type != typeForDataSource) { if (list == null) { list = new List <DocumentNode>(); } list.Add(keyValuePair.Key); } } } if (list != null) { foreach (DocumentNode key in list) { this.schemaCache.Remove(key); } } this.designDataManager.Refresh(changedSampleData); if (this.ClrObjectSchemasInvalidated == null) { return; } this.ClrObjectSchemasInvalidated((object)this, EventArgs.Empty); }
public void AddCollection() { if (!this.schemaItem.Schema.DataSource.IsSampleDataSource) { return; } SampleDataSet sampleData = this.schemaItem.Schema.DataSource.SampleData; SampleCompositeType effectiveType = this.DataSchemaNode.EffectiveType; if (effectiveType == null) { return; } this.model.SelectionContext.Clear(); string uniquePropertyName = effectiveType.GetUniquePropertyName("Collection"); string uniqueTypeName = sampleData.GetUniqueTypeName(uniquePropertyName + "Item"); SampleCompositeType compositeType = sampleData.CreateCompositeType(uniqueTypeName); SampleCollectionType collectionType = sampleData.CreateCollectionType((SampleNonBasicType)compositeType); effectiveType.AddProperty(uniquePropertyName, (SampleType)collectionType); string schemaNodePath = DataSchemaItem.ProvideNodePathForPendingEdit(this, uniquePropertyName); this.model.RenameSampleDataSchemaItemUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.model.ExtendSelectionUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.IsExpanded = true; using (TemporaryCursor.SetWaitCursor()) sampleData.CommitChanges(this.ViewModel.DesignerContext.MessageDisplayService); }
public void MakeHierarchicalCollection() { if (!this.schemaItem.Schema.DataSource.IsSampleDataSource) { return; } SampleDataSet sampleData = this.schemaItem.Schema.DataSource.SampleData; SampleCompositeType effectiveType = this.DataSchemaNode.EffectiveType; if (effectiveType == null) { return; } this.model.SelectionContext.Clear(); SampleNonBasicType sampleNonBasicType = (SampleNonBasicType)this.DataSchemaNode.SampleType; string uniquePropertyName1 = effectiveType.GetUniquePropertyName(this.DataSchemaNode.PathName); SampleProperty hierarchicalProperty = effectiveType.AddProperty(uniquePropertyName1, (SampleType)sampleNonBasicType); SampleProperty sampleProperty = this.DataSchemaNode.EffectiveParentType.GetSampleProperty(this.DataSchemaNode.PathName); string uniquePropertyName2 = DataSchemaItem.GetUniquePropertyName(sampleProperty, hierarchicalProperty, uniquePropertyName1); string schemaNodePath = DataSchemaItem.ProvideNodePathForPendingEdit(this, uniquePropertyName2, sampleProperty, hierarchicalProperty); sampleProperty.Rename(uniquePropertyName2); hierarchicalProperty.Rename(uniquePropertyName2); this.model.RenameSampleDataSchemaItemUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.model.ExtendSelectionUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.IsExpanded = true; using (TemporaryCursor.SetWaitCursor()) sampleData.CommitChanges(this.ViewModel.DesignerContext.MessageDisplayService); }
public SampleImageConfiguration(SampleDataSet sampleData, string formatParameters) { this.projectContext = (IProjectContext)sampleData.ProjectContext; this.fallbackImageDirectory = sampleData.FallbackImageFolder; this.SetConfigurationValue(ConfigurationPlaceholder.ImageFolderBrowser, (object)formatParameters); this.index = -1; }
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { DataSchemaItem dataSchemaItem = values[0] as DataSchemaItem; bool flag = values.Length == 2 && (bool)values[1]; if (dataSchemaItem != null) { if (dataSchemaItem.IsHierarchicalCollection) { return((object)this.hierarchicalCollectionImage); } if (dataSchemaItem.DataSchemaNode.IsCollection) { if (!flag) { return((object)this.detailsCollectionImage); } return((object)this.masterCollectionImage); } if (dataSchemaItem.HasChildren) { return((object)this.compositeImage); } if (SampleDataSet.SampleDataTypeFromType(dataSchemaItem.DataSchemaNode.Type) is SampleCompositeType) { return((object)this.compositeImage); } } return((object)null); }
private IEnumerable <DataStoreReferenceEntry> FindDataStoreReferenceDictionary(SceneDocument document) { List <DataStoreReferenceEntry> list = (List <DataStoreReferenceEntry>)null; ResourceDictionaryContentProvider dictionaryContentProvider = this.GetResourceDictionaryContentProvider(document); if (dictionaryContentProvider != null) { foreach (DocumentNode documentNode1 in dictionaryContentProvider.Items) { DocumentCompositeNode documentCompositeNode = documentNode1 as DocumentCompositeNode; if (documentCompositeNode != null) { DocumentNode documentNode2 = documentCompositeNode.Properties[DictionaryEntryNode.ValueProperty]; if (documentNode2 != null) { SampleDataSet sampleDataSet = SampleDataSet.SampleDataSetFromType(documentNode2.Type.RuntimeType); if (sampleDataSet != null && sampleDataSet.Context == DataSetContext.DataStore) { if (list == null) { list = new List <DataStoreReferenceEntry>(); } DataStoreReferenceEntry storeReferenceEntry = new DataStoreReferenceEntry() { DataStore = sampleDataSet, DictionaryEntryNode = documentCompositeNode }; list.Add(storeReferenceEntry); } } } } } return((IEnumerable <DataStoreReferenceEntry>)list); }
private void SafelyRemoveSampleDataAndRootFolder(SampleDataSet dataSet, bool forceDeleteFiles) { dataSet.Close(); if (forceDeleteFiles) { SampleDataCollection.DeleteFolder(dataSet.SampleDataFolder, false); } else { SampleDataCollection.DeleteFolder(dataSet.AssetFilesFolder, true); SampleDataCollection.DeleteFolder(dataSet.SampleDataFolder, true); } this.OnSampleDataRemoving(dataSet); this.dataSets.Remove(dataSet); if (Enumerable.FirstOrDefault <SampleDataSet>(Enumerable.Where <SampleDataSet>((IEnumerable <SampleDataSet>) this.dataSets, (Func <SampleDataSet, bool>)(item => item.Context == dataSet.Context))) != null) { return; } string path = Path.Combine(Path.GetDirectoryName(this.projectContext.ProjectPath), dataSet.Context.DataRootFolder); IProject project = (IProject)this.projectContext.GetService(typeof(IProject)); IProjectItem projectItem = project.FindItem(DocumentReference.Create(path)); if (projectItem == null || Enumerable.FirstOrDefault <IProjectItem>(projectItem.Children) != null) { return; } project.RemoveItems(0 != 0, projectItem); SampleDataCollection.DeleteFolder(dataSet.Context.DataRootFolder, true); }
public IType GetSampleType(IXmlNamespace xmlNamespace, string typeName) { if (this.dataSets.Count == 0) { return((IType)null); } string clrNamespace; string assemblyName; if (!XamlParser.TryParseClrNamespaceUri(xmlNamespace.Value, out clrNamespace, out assemblyName)) { return((IType)null); } if (!clrNamespace.StartsWith(this.sampleDataClrNamespacePrefix, StringComparison.Ordinal) && !clrNamespace.StartsWith(this.dataStoreClrNamespacePrefix, StringComparison.Ordinal)) { return((IType)null); } SampleDataSet sampleDataSet1 = this.GetSampleDataSet(clrNamespace.Substring(this.sampleDataClrNamespacePrefix.Length), true); if (sampleDataSet1 != null) { return(sampleDataSet1.GetSampleType(xmlNamespace, typeName)); } SampleDataSet sampleDataSet2 = this.GetSampleDataSet(clrNamespace.Substring(this.dataStoreClrNamespacePrefix.Length), true); if (sampleDataSet2 != null) { return(sampleDataSet2.GetSampleType(xmlNamespace, typeName)); } return((IType)null); }
private void OnSampleDataRemoving(SampleDataSet dataSet) { if (this.SampleDataRemoving == null) { return; } this.SampleDataRemoving((object)this, new SampleDataEventArgs(dataSet)); }
private void SampleDataSet_TypesChanging(SampleDataSet sender, EventArgs e) { if (this.SampleTypesChanging == null) { return; } this.SampleTypesChanging(sender, e); }
private void OnSampleDataAdded(SampleDataSet dataSet) { if (this.SampleDataAdded == null) { return; } this.SampleDataAdded((object)this, new SampleDataEventArgs(dataSet)); }
public SampleCollectionType(string name, SampleType itemType, SampleDataSet declaringDataSet) : base(name, declaringDataSet) { this.itemSampleType = itemType; IType type = this.TypeResolver.ResolveType(PlatformTypes.Object); this.baseType = this.TypeResolver.GetType(this.TypeResolver.ResolveType(PlatformTypes.ObservableCollection).RuntimeType.MakeGenericType(type.RuntimeType)); this.DeclaringDataSet.ThrowIfRecursiveRootType(this.ItemSampleType); }
private string CreateNewProperty(SampleDataSet dataSet, string newProperyName) { string uniqueTypeName = dataSet.GetUniqueTypeName(newProperyName); SampleProperty sampleProperty = dataSet.RootType.AddProperty(uniqueTypeName, (SampleType)SampleBasicType.String); DocumentCompositeNode newRootNode = (DocumentCompositeNode)dataSet.RootNode.Clone(dataSet.RootNode.Context); newRootNode.Properties[(IPropertyId)sampleProperty] = (DocumentNode)newRootNode.Context.CreateNode(StringTable.DefaultValueDataStore); dataSet.CommitChanges(newRootNode, this.ObjectSet.ViewModel.DesignerContext.MessageDisplayService); return(uniqueTypeName); }
public SampleDataSet GetSampleDataSet(string name, bool onlyIfDataSetValid) { SampleDataSet sampleDataSet = Enumerable.FirstOrDefault <SampleDataSet>((IEnumerable <SampleDataSet>) this.dataSets, (Func <SampleDataSet, bool>)(ds => ds.Name == name)); if (sampleDataSet != null && onlyIfDataSetValid && !sampleDataSet.IsValid) { sampleDataSet = (SampleDataSet)null; } return(sampleDataSet); }
public override void OnViewNodeInvalidating(IInstanceBuilderContext context, ViewNode target, ViewNode child, ref bool doesInvalidRootsContainTarget, List <ViewNode> invalidRoots) { base.OnViewNodeInvalidating(context, target, child, ref doesInvalidRootsContainTarget, invalidRoots); DocumentCompositeNode fromXamlDocument = SampleDataSet.SampleDataSetFromType(target.DocumentNode.Type.RuntimeType).ValidRootNodeFromXamlDocument; if (fromXamlDocument == null || !this.IsSampleDataXamlContext(context, fromXamlDocument.DocumentRoot)) { return; } InstanceBuilderOperations.SetInvalid(context, target, ref doesInvalidRootsContainTarget, invalidRoots); }
public DataStorePropertyEntry(SampleDataSet dataStore, IProperty property, IList <DataStorePropertyEntry> properties) { this.dataStore = dataStore; this.property = property; this.stringValue = dataStore.RootNode.GetValue <string>((IPropertyId)this.property); this.type = DataStorePropertyEntry.DataStoreTypeFromSampleProperty(dataStore.RootType.GetSampleProperty(property.Name)); this.dirtyState = DataStorePropertyEntryDirtyStates.None; this.propertyName = property.Name; this.cacheValue = new Dictionary <DataStoreType, string>(); this.cacheValue[this.type] = this.stringValue; this.properties = properties; }
private SampleCodeGenerator(SampleDataSet dataSet, string sourceCodeFile, string language) { if (dataSet.Context == DataSetContext.SampleData) { this.codeSnippets = language == "VB" ? SampleCodeGenerator.SampleCodeSnippetFactory.VB : SampleCodeGenerator.SampleCodeSnippetFactory.CSharp; } else if (dataSet.Context == DataSetContext.DataStore) { this.codeSnippets = language == "VB" ? SampleCodeGenerator.SampleCodeSnippetFactory.DataStoreVB : SampleCodeGenerator.SampleCodeSnippetFactory.DataStoreCSharp; } this.dataSet = dataSet; this.sourceCodeFile = sourceCodeFile; }
public SampleDataSet CreateDefaultNewSampleDataSource(DataSetContext dataSetContext, string dataSourceName, bool enableAtRuntime) { SampleDataSet dataSet = (SampleDataSet)null; bool flag = false; try { dataSet = this.CreateSampleDataSet(dataSetContext, dataSourceName, enableAtRuntime); if (dataSet != null) { using (dataSet.DisableChangeTracking()) { if (dataSetContext.DataSetType == DataSetType.SampleDataSet) { string uniqueTypeName1 = dataSet.GetUniqueTypeName("Item"); SampleCompositeType compositeType = dataSet.CreateCompositeType(uniqueTypeName1); string uniquePropertyName1 = compositeType.GetUniquePropertyName("Property1"); compositeType.AddProperty(uniquePropertyName1, (SampleType)SampleBasicType.String); string uniquePropertyName2 = compositeType.GetUniquePropertyName("Property2"); compositeType.AddProperty(uniquePropertyName2, (SampleType)SampleBasicType.Boolean); string uniqueTypeName2 = dataSet.GetUniqueTypeName("ItemCollection"); SampleCollectionType collectionType = dataSet.CreateCollectionType(uniqueTypeName2, (SampleType)compositeType); string uniquePropertyName3 = dataSet.RootType.GetUniquePropertyName("Collection"); dataSet.RootType.AddProperty(uniquePropertyName3, (SampleType)collectionType); dataSet.AutoGenerateValues(); } else { string uniquePropertyName = dataSet.RootType.GetUniquePropertyName("Property1"); SampleProperty sampleProperty = dataSet.RootType.AddProperty(uniquePropertyName, (SampleType)SampleBasicType.String); using (SampleDataValueBuilder valueBuilder = dataSet.CreateValueBuilder()) { DocumentCompositeNode rootNode = valueBuilder.RootNode; valueBuilder.RootNode.Properties[(IPropertyId)sampleProperty] = valueBuilder.CreatePropertyValue(rootNode, "Property1", StringTable.DefaultValueDataStore); } dataSet.Save(); } } flag = dataSet.IsSaved; } } finally { if (!flag && dataSet != null) { this.SafelyRemoveSampleDataAndRootFolder(dataSet, true); dataSet = (SampleDataSet)null; } } return(dataSet); }
private static SampleCompositeType CalculateEffectiveType(Type type) { SampleNonBasicType sampleNonBasicType = SampleDataSet.SampleDataTypeFromType(type); if (sampleNonBasicType != null) { SampleCollectionType sampleCollectionType; while ((sampleCollectionType = sampleNonBasicType as SampleCollectionType) != null) { sampleNonBasicType = sampleCollectionType.ItemType as SampleNonBasicType; } } return(sampleNonBasicType as SampleCompositeType); }
public void DeleteSampleDataSet(SampleDataSet dataSet) { TypesChangedEventArgs e = new TypesChangedEventArgs((ICollection <TypeChangedInfo>) new List <TypeChangedInfo>() { new TypeChangedInfo(dataSet.RootType.RuntimeAssembly, ModificationType.Modified), new TypeChangedInfo(RuntimeGeneratedTypesHelper.BlendDefaultAssembly, ModificationType.Modified) }); this.OnSampleDataRemoving(dataSet); this.dataSets.Remove(dataSet); dataSet.RemoveFromProjectAndClose(); this.SafelyRemoveSampleDataAndRootFolder(dataSet, false); this.projectContext.OnTypesChanged(e); }
public SampleDataSet CreateSampleDataSet(DataSetContext dataSetContext, string name, bool enableAtRuntime) { string sampleDataSetName = this.GetUniqueSampleDataSetName(name); if (string.IsNullOrEmpty(sampleDataSetName)) { return((SampleDataSet)null); } SampleDataSet dataSet = this.InstantiateSampleDataSet(dataSetContext, sampleDataSetName, enableAtRuntime); this.dataSets.Add(dataSet); this.OnSampleDataAdded(dataSet); return(dataSet); }
private DataStoreReferenceEntry CreateNewDataStore(SceneEditTransaction transation) { SampleDataSet sampleDataSet = this.ProjectXamlContext.SampleData.CreateSampleDataSet(DataSetContext.DataStore, "DataStore", true); sampleDataSet.Save(); this.ObjectSet.ViewModel.DataPanelModel.AddDataStoreDataSource(sampleDataSet, true); transation.Update(); IEnumerable <DataStoreReferenceEntry> dataStoreDataSet = this.FindDataStoreDataSet((Predicate <SampleDataSet>)(dataSet => true)); if (dataStoreDataSet != null) { return(Enumerable.FirstOrDefault <DataStoreReferenceEntry>(dataStoreDataSet)); } return((DataStoreReferenceEntry)null); }
private void button_Click(object sender, RoutedEventArgs e) { ReportDocument report = new ReportDocument(); report.Load("..\\..\\SampleCrystalReport.rpt"); using (SampleModel db = new SampleModel()) { SampleDataSet dataset = new SampleDataSet(); System.Data.DataSet dsCopy = dataset.Copy(); SampleDataSetTableAdapters.batchTableAdapter adapter = new SampleDataSetTableAdapters.batchTableAdapter(); adapter.Fill(dataset.batch); report.SetDataSource(dataset); } crystalReportsViewer1.ViewerCore.ReportSource = report; }
public IType GetSampleType(Type type) { if (this.dataSets.Count == 0) { return((IType)null); } SampleNonBasicType sampleType = SampleDataSet.SampleDataTypeFromType(type); if (sampleType == null) { return((IType)null); } if (this.dataSets.Find((Predicate <SampleDataSet>)(s => s == sampleType.DeclaringDataSet)) == null) { return((IType)null); } return((IType)sampleType); }
private bool LoadSampleDataSetFromProjectInfo(SampleDataCollection.SampleDataSetProjectInfo sampleDataInfo) { if (sampleDataInfo.XsdItem == null || sampleDataInfo.XamlItem == null || (!Microsoft.Expression.Framework.Documents.PathHelper.FileExists(sampleDataInfo.XsdItem.DocumentReference.Path) || !Microsoft.Expression.Framework.Documents.PathHelper.FileExists(sampleDataInfo.XamlItem.DocumentReference.Path))) { return(false); } bool enableAtRuntime = !string.Equals(sampleDataInfo.XamlItem.Properties["BuildAction"], SampleDataSet.DesignTimeBuildType); SampleDataSet dataSet = this.InstantiateSampleDataSet(sampleDataInfo.DataSetContext, sampleDataInfo.Name, enableAtRuntime); dataSet.Load(); if (!dataSet.IsValid) { dataSet.Close(); return(false); } this.dataSets.Add(dataSet); this.OnSampleDataAdded(dataSet); return(true); }
private void ChangeEffectivePropertyIfValid(DataSchemaItem.ModifySamplePropertyOperation operation) { SampleCompositeType effectiveParentType = this.DataSchemaNode.EffectiveParentType; if (effectiveParentType == null) { return; } SampleDataSet declaringDataSet = effectiveParentType.DeclaringDataSet; SampleProperty sampleProperty = effectiveParentType.GetSampleProperty(this.DataSchemaNode.PathName); if (sampleProperty == null) { return; } operation(effectiveParentType, sampleProperty); using (TemporaryCursor.SetWaitCursor()) declaringDataSet.CommitChanges(this.ViewModel.DesignerContext.MessageDisplayService); }
public void Rebuild() { if (this.SceneNodeProperty == null) { return; } ProjectXamlContext projectXamlContext = this.ProjectXamlContext; if (this.ProjectXamlContext != null) { SampleDataCollection sampleData = projectXamlContext.SampleData; IEnumerable <DataStoreReferenceEntry> dataStoreDataSet = this.FindDataStoreDataSet((Predicate <SampleDataSet>)(dataSet => true)); HashSet <string> hashSet = new HashSet <string>(); List <DataStorePropertyEntry> list = new List <DataStorePropertyEntry>(); list.Add(new DataStorePropertyEntry((SampleDataSet)null, StringTable.CreateNewPropertyItem, true)); this.properties = list; if (dataStoreDataSet != null) { foreach (DataStoreReferenceEntry storeReferenceEntry in dataStoreDataSet) { SampleDataSet dataStore = storeReferenceEntry.DataStore; if (!hashSet.Contains(dataStore.Name)) { hashSet.Add(dataStore.Name); for (int index = 0; index < storeReferenceEntry.DataStore.RootType.Properties.Count; ++index) { list.Add(new DataStorePropertyEntry(storeReferenceEntry.DataStore, storeReferenceEntry.DataStore.RootType.Properties[index].Name, false)); } } } if (this.editingProperty != null) { this.editingProperty = Enumerable.FirstOrDefault <DataStorePropertyEntry>(Enumerable.Where <DataStorePropertyEntry>((IEnumerable <DataStorePropertyEntry>) this.properties, (Func <DataStorePropertyEntry, bool>)(entry => entry.Name == this.SelectedProperty.Name))); } } } if (this.Rebuilt == null) { return; } this.Rebuilt((object)this, (EventArgs)null); }
private static void PerformTestByTesterAndSample(Type testerType, SampleDataSet <Orders> sampleDataset, ResultGroup resultGroup, int testsToPerform) { for (var i = 1; i <= testsToPerform; i++) { // Create the new tester var ctor = testerType.GetConstructor(new[] { typeof(SampleDataSet <Orders>) }); var tester = (Tester <Orders>)ctor.Invoke(new object[] { sampleDataset }); // Run test Console.WriteLine(String.Format("Testing {0} [Sample Size: {1}]...", tester.Name, tester.SampleDataSet.Size)); tester.Test(); // Collect results resultGroup.Results.Add(tester.GetResult()); // Clean up any unused/unreferenced resources. tester.Dispose(); GC.Collect(); } }
public static ISampleTypeConfiguration CreateConfiguration(SampleDataSet sampleData, SampleBasicType type, string format, string formatParameters) { if (type == SampleBasicType.Boolean) { return((ISampleTypeConfiguration) new SampleBooleanConfiguration()); } if (type == SampleBasicType.Image) { return((ISampleTypeConfiguration) new SampleImageConfiguration(sampleData, formatParameters)); } if (type == SampleBasicType.Number) { return((ISampleTypeConfiguration) new SampleNumberConfiguration(formatParameters)); } if (type == SampleBasicType.String) { return((ISampleTypeConfiguration) new SampleStringConfiguration(format, formatParameters)); } return((ISampleTypeConfiguration)null); }
public override bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode) { bool flag = viewNode.Instance != null; base.Instantiate(context, viewNode); if (flag) { return(false); } SampleDataSet sampleDataSet = SampleDataSet.SampleDataSetFromType(viewNode.DocumentNode.Type.RuntimeType); if (sampleDataSet == null) { return(!flag); } DocumentCompositeNode documentCompositeNode = sampleDataSet != null ? sampleDataSet.ValidRootNodeFromXamlDocument : (DocumentCompositeNode)null; if (documentCompositeNode == null || !PlatformTypes.PlatformsCompatible((IPlatformMetadata)context.Platform.Metadata, documentCompositeNode.PlatformMetadata) || (this.IsSampleDataXamlContext(context, documentCompositeNode.DocumentRoot) || DesignDataHelper.GetDesignDataFile(viewNode.DocumentNode) != null)) { return(!flag); } using (StandaloneInstanceBuilderContext instanceBuilderContext = new StandaloneInstanceBuilderContext(context.DocumentContext, context)) { using (instanceBuilderContext.ChangeSerializationContext(context.SerializationContext)) { ViewNode viewNode1 = this.GetViewNode((IInstanceBuilderContext)instanceBuilderContext, (DocumentNode)documentCompositeNode); viewNode1.Instance = viewNode.Instance; this.Initialize((IInstanceBuilderContext)instanceBuilderContext, viewNode1, true); viewNode1.Instance = (object)null; viewNode.InstanceState = InstanceState.Valid; } } context.DocumentRootResolver.GetDocumentRoot(documentCompositeNode.DocumentRoot.DocumentContext.DocumentUrl); IProperty index = context.DocumentContext.TypeResolver.ResolveProperty(DesignTimeProperties.SampleDataTagProperty); ViewNode referenceSource = new ViewNode(context.ViewNodeManager, (DocumentNode)documentCompositeNode); viewNode.Properties[index] = referenceSource; context.ViewNodeManager.AddRelatedDocumentRoot(referenceSource, documentCompositeNode.DocumentRoot); return(!flag); }