private static StorageMappingItemCollection LoadStoreCollection(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { StoreItemCollection storeItemCollection; var sSpaceXmlReaders = loader.CreateReaders(DataSpace.SSpace); try { storeItemCollection = new StoreItemCollection( sSpaceXmlReaders, loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders(sSpaceXmlReaders); } var csSpaceXmlReaders = loader.CreateReaders(DataSpace.CSSpace); try { return(new StorageMappingItemCollection( edmItemCollection, storeItemCollection, csSpaceXmlReaders, loader.GetPaths(DataSpace.CSSpace))); } finally { Helper.DisposeXmlReaders(csSpaceXmlReaders); } }
private static StorageMappingItemCollection LoadStoreCollection( EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { List <XmlReader> readers1 = loader.CreateReaders(DataSpace.SSpace); StoreItemCollection storeCollection; try { storeCollection = new StoreItemCollection((IEnumerable <XmlReader>)readers1, (IEnumerable <string>)loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)readers1); } List <XmlReader> readers2 = loader.CreateReaders(DataSpace.CSSpace); try { return(new StorageMappingItemCollection(edmItemCollection, storeCollection, (IEnumerable <XmlReader>)readers2, (IList <string>)loader.GetPaths(DataSpace.CSSpace))); } finally { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)readers2); } }
internal void LoadStoreCollection(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { StoreItemCollection storeItemCollection = null; IEnumerable <XmlReader> sSpaceXmlReaders = loader.CreateReaders(DataSpace.SSpace); try { // Load the store side, however, only do so if we don't already have one storeItemCollection = new StoreItemCollection( sSpaceXmlReaders, loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders(sSpaceXmlReaders); } // If this entry is getting re-used, make sure that the previous query cache manager gets // cleared up if (_queryCacheManager != null) { _queryCacheManager.Clear(); } // Update the query cache manager reference _queryCacheManager = storeItemCollection.QueryCacheManager; // With the store metadata in place, we can then load the mappings, however, only use it // if we don't already have one // StorageMappingItemCollection storageMappingItemCollection = null; IEnumerable <XmlReader> csSpaceXmlReaders = loader.CreateReaders(DataSpace.CSSpace); try { storageMappingItemCollection = new StorageMappingItemCollection( edmItemCollection, storeItemCollection, csSpaceXmlReaders, loader.GetPaths(DataSpace.CSSpace)); } finally { Helper.DisposeXmlReaders(csSpaceXmlReaders); } var permissionPaths = new List <string>(); loader.CollectFilePermissionPaths(permissionPaths, DataSpace.SSpace); loader.CollectFilePermissionPaths(permissionPaths, DataSpace.CSSpace); FileIOPermission filePermissions = null; if (permissionPaths.Count > 0) { filePermissions = new FileIOPermission(FileIOPermissionAccess.Read, permissionPaths.ToArray()); } UpdateMetadataEntry(storageMappingItemCollection, filePermissions); }
//For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method public EdmItemCollection(params string[] filePaths) : base(DataSpace.CSpace) { Check.NotNull(filePaths, "filePaths"); // Wrap the file paths in instances of the MetadataArtifactLoader class, which provides // an abstraction and a uniform interface over a diverse set of metadata artifacts. // MetadataArtifactLoader composite = null; List <XmlReader> readers = null; try { composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(filePaths, XmlConstants.CSpaceSchemaExtension); readers = composite.CreateReaders(DataSpace.CSpace); Init( readers, composite.GetPaths(DataSpace.CSpace), true /*throwOnError*/); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.StoreItemCollection" /> class using the specified file paths. /// </summary> /// <param name="filePaths">The file paths used to create metadata.</param> public StoreItemCollection(params string[] filePaths) : base(DataSpace.SSpace) { Check.NotNull <string[]>(filePaths, nameof(filePaths)); IEnumerable <string> enumerableArgument1 = (IEnumerable <string>)filePaths; EntityUtil.CheckArgumentEmpty <string>(ref enumerableArgument1, new Func <string, string>(Strings.StoreItemCollectionMustHaveOneArtifact), nameof(filePaths)); List <XmlReader> source = (List <XmlReader>)null; try { MetadataArtifactLoader compositeFromFilePaths = MetadataArtifactLoader.CreateCompositeFromFilePaths(enumerableArgument1, ".ssdl"); source = compositeFromFilePaths.CreateReaders(DataSpace.SSpace); IEnumerable <XmlReader> enumerableArgument2 = source.AsEnumerable <XmlReader>(); EntityUtil.CheckArgumentEmpty <XmlReader>(ref enumerableArgument2, new Func <string, string>(Strings.StoreItemCollectionMustHaveOneArtifact), nameof(filePaths)); this.Init((IEnumerable <XmlReader>)source, (IEnumerable <string>)compositeFromFilePaths.GetPaths(DataSpace.SSpace), true, (IDbDependencyResolver)null, out this._providerManifest, out this._providerFactory, out this._providerInvariantName, out this._providerManifestToken, out this._cachedCTypeFunction); } finally { if (source != null) { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)source); } } }
internal void LoadEdmItemCollection(MetadataArtifactLoader loader) { DebugCheck.NotNull(loader); var readers = loader.CreateReaders(DataSpace.CSpace); try { var itemCollection = new EdmItemCollection( readers, loader.GetPaths(DataSpace.CSpace) ); var permissionPaths = new List <string>(); loader.CollectFilePermissionPaths(permissionPaths, DataSpace.CSpace); FileIOPermission filePermissions = null; if (permissionPaths.Count > 0) { filePermissions = new FileIOPermission(FileIOPermissionAccess.Read, permissionPaths.ToArray()); } UpdateMetadataEntry(itemCollection, filePermissions); } finally { Helper.DisposeXmlReaders(readers); } }
private static EdmItemCollection LoadEdmItemCollection( MetadataArtifactLoader loader) { List <XmlReader> readers = loader.CreateReaders(DataSpace.CSpace); try { return(new EdmItemCollection((IEnumerable <XmlReader>)readers, (IEnumerable <string>)loader.GetPaths(DataSpace.CSpace), false)); } finally { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)readers); } }
private static EdmItemCollection LoadEdmItemCollection(MetadataArtifactLoader loader) { DebugCheck.NotNull(loader); var readers = loader.CreateReaders(DataSpace.CSpace); try { return(new EdmItemCollection(readers, loader.GetPaths(DataSpace.CSpace))); } finally { Helper.DisposeXmlReaders(readers); } }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmItemCollection" /> class by using the paths where the conceptual schema definition language (CSDL) files exist. /// </summary> /// <param name="filePaths">The paths where the conceptual schema definition language (CSDL) files exist.</param> public EdmItemCollection(params string[] filePaths) : base(DataSpace.CSpace) { Check.NotNull <string[]>(filePaths, nameof(filePaths)); List <XmlReader> xmlReaderList = (List <XmlReader>)null; try { MetadataArtifactLoader compositeFromFilePaths = MetadataArtifactLoader.CreateCompositeFromFilePaths((IEnumerable <string>)filePaths, ".csdl"); xmlReaderList = compositeFromFilePaths.CreateReaders(DataSpace.CSpace); this.Init((IEnumerable <XmlReader>)xmlReaderList, (IEnumerable <string>)compositeFromFilePaths.GetPaths(DataSpace.CSpace), true); } finally { if (xmlReaderList != null) { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)xmlReaderList); } } }
//For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method public StoreItemCollection(params string[] filePaths) : base(DataSpace.SSpace) { Check.NotNull(filePaths, "filePaths"); IEnumerable <string> enumerableFilePaths = filePaths; EntityUtil.CheckArgumentEmpty(ref enumerableFilePaths, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths"); // Wrap the file paths in instances of the MetadataArtifactLoader class, which provides // an abstraction and a uniform interface over a diverse set of metadata artifacts. // MetadataArtifactLoader composite = null; List <XmlReader> readers = null; try { composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(enumerableFilePaths, XmlConstants.SSpaceSchemaExtension); readers = composite.CreateReaders(DataSpace.SSpace); var ieReaders = readers.AsEnumerable(); EntityUtil.CheckArgumentEmpty(ref ieReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths"); Init( readers, composite.GetPaths(DataSpace.SSpace), /* throwOnError */ true, /* resolver */ null, out _providerManifest, out _providerFactory, out _providerInvariantName, out _providerManifestToken, out _cachedCTypeFunction); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } }
private static EdmItemCollection LoadEdmItemCollection(MetadataArtifactLoader loader) { DebugCheck.NotNull(loader); var readers = loader.CreateReaders(DataSpace.CSpace); try { return new EdmItemCollection(readers, loader.GetPaths(DataSpace.CSpace)); } finally { Helper.DisposeXmlReaders(readers); } }
private static StorageMappingItemCollection LoadStoreCollection(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { StoreItemCollection storeItemCollection; var sSpaceXmlReaders = loader.CreateReaders(DataSpace.SSpace); try { storeItemCollection = new StoreItemCollection( sSpaceXmlReaders, loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders(sSpaceXmlReaders); } var csSpaceXmlReaders = loader.CreateReaders(DataSpace.CSSpace); try { return new StorageMappingItemCollection( edmItemCollection, storeItemCollection, csSpaceXmlReaders, loader.GetPaths(DataSpace.CSSpace)); } finally { Helper.DisposeXmlReaders(csSpaceXmlReaders); } }