public override void CollectFilePermissionPaths(List <string> paths, DataSpace spaceToGet) { if (!_alreadyLoaded && MetadataArtifactLoader.IsArtifactOfDataSpace(_path, spaceToGet)) { paths.Add(_path); } }
internal static MetadataArtifactLoader CreateResourceLoader(string path, ExtensionCheck extensionCheck, string validExtension, ICollection <string> uriRegistry, MetadataArtifactAssemblyResolver resolver) { Debug.Assert(path != null); Debug.Assert(MetadataArtifactLoader.PathStartsWithResPrefix(path)); // if the supplied path ends with a separator, or contains only one // segment (i.e., the name of an assembly, or the wildcard character), // create a composite loader that can extract resources from one or // more assemblies // bool createCompositeResLoader = false; string assemblyName = null; string resourceName = null; ParseResourcePath(path, out assemblyName, out resourceName); createCompositeResLoader = (assemblyName != null) && (resourceName == null || assemblyName.Trim() == wildcard); ValidateExtension(extensionCheck, validExtension, resourceName); if (createCompositeResLoader) { return(new MetadataArtifactLoaderCompositeResource(path, assemblyName, resourceName, uriRegistry, resolver)); } Debug.Assert(!string.IsNullOrEmpty(resourceName), "we should not get here is the resourceName is null"); Assembly assembly = ResolveAssemblyName(assemblyName, resolver); return(new MetadataArtifactLoaderResource(assembly, resourceName, uriRegistry)); }
internal void LoadEdmItemCollection(MetadataArtifactLoader loader) { Debug.Assert(loader != null, "loader is null"); List <XmlReader> readers = loader.CreateReaders(DataSpace.CSpace); try { EdmItemCollection itemCollection = new EdmItemCollection( readers, loader.GetPaths(DataSpace.CSpace) ); List <string> 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); } }
[ResourceConsumption(ResourceScope.Machine)] //For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method public EdmItemCollection(params string[] filePaths) : base(DataSpace.CSpace) { EntityUtil.CheckArgumentNull(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); this.Init(readers, composite.GetPaths(DataSpace.CSpace), true /*throwOnError*/); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } }
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); } List <string> 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()); } this.UpdateMetadataEntry(storageMappingItemCollection, filePermissions); }
/// <summary> /// Get paths to artifacts for a specific DataSpace, in the original, unexpanded /// form /// </summary> /// <param name="spaceToGet">The DataSpace for the artifacts of interest</param> /// <returns>A List of strings identifying paths to all artifacts for a specific DataSpace</returns> public virtual List <string> GetOriginalPaths(DataSpace spaceToGet) { List <string> list = new List <string>(); if (MetadataArtifactLoader.IsArtifactOfDataSpace(Path, spaceToGet)) { list.Add(Path); } return(list); }
/// <summary> /// Get paths to artifacts for a specific DataSpace. /// </summary> /// <param name="spaceToGet">The DataSpace for the artifacts of interest</param> /// <returns>A List of strings identifying paths to all artifacts for a specific DataSpace</returns> public override List <string> GetPaths(DataSpace spaceToGet) { List <string> list = new List <string>(); if (MetadataArtifactLoader.IsArtifactOfDataSpace(Path, spaceToGet)) { list.Add(Path); } return(list); }
/// <summary> /// Create and return an XmlReader around the resource represented by this instance /// if it is of the requested DataSpace type. /// </summary> /// <param name="spaceToGet">The DataSpace corresponding to the requested artifacts</param> /// <returns>A List of XmlReader objects</returns> public override List <XmlReader> CreateReaders(DataSpace spaceToGet) { List <XmlReader> list = new List <XmlReader>(); if (MetadataArtifactLoader.IsArtifactOfDataSpace(Path, spaceToGet)) { list.Add(_reader); } return(list); }
/// <summary> /// Create and return an XmlReader around the file represented by this instance /// if it is of the requested DataSpace type. /// </summary> /// <param name="spaceToGet">The DataSpace corresponding to the requested artifacts</param> /// <returns>A List of XmlReader objects</returns> public override List <XmlReader> CreateReaders(DataSpace spaceToGet) { List <XmlReader> list = new List <XmlReader>(); if (!_alreadyLoaded && MetadataArtifactLoader.IsArtifactOfDataSpace(_path, spaceToGet)) { XmlReader reader = CreateXmlReader(); list.Add(reader); } return(list); }
/// <summary> /// Retrieves an cache entry holding to edm metadata for a given cache key /// </summary> /// <param name="cacheKey">string containing all the files from which edm metadata is to be retrieved</param> /// <param name="composite">An instance of the composite MetadataArtifactLoader</param> /// <param name="entryToken">The metadata entry token for the returned entry</param> /// <returns>Returns the entry containing the edm metadata</returns> internal static EdmItemCollection GetOrCreateEdmItemCollection(string cacheKey, MetadataArtifactLoader loader, out object entryToken) { EdmMetadataEntry entry = GetCacheEntry <EdmMetadataEntry>(_edmLevelCache, cacheKey, _edmLevelLock, new EdmMetadataEntryConstructor(), out entryToken); // Load the edm item collection or if the collection is already loaded, check for security permission LoadItemCollection(new EdmItemCollectionLoader(loader), entry); return(entry.EdmItemCollection); }
/// <summary> /// Public constructor that loads the metadata files from the specified XmlReaders /// </summary> /// <param name="xmlReaders">XmlReader objects where the EDM schemas are loaded</param> public EdmItemCollection(IEnumerable <XmlReader> xmlReaders) : base(DataSpace.CSpace) { EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentContainsNull(ref xmlReaders, "xmlReaders"); MetadataArtifactLoader composite = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); this.Init(composite.GetReaders(), composite.GetPaths(), true /*throwOnError*/); }
/// <summary> /// Constructs a struct from which you can load edm item collection /// </summary> /// <param name="factory"></param> /// <param name="edmItemCollection"></param> internal StoreItemCollectionLoader(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { Debug.Assert(edmItemCollection != null, "EdmItemCollection must never be null"); Debug.Assert(loader != null, "loader must never be null"); //StoreItemCollection requires atleast one SSDL path. if ((loader.GetPaths(DataSpace.SSpace) == null) || (loader.GetPaths(DataSpace.SSpace).Count == 0)) { throw EntityUtil.Metadata(Strings.AtleastOneSSDLNeeded); } _edmItemCollection = edmItemCollection; _loader = loader; }
/// <summary> /// Retrieves an entry holding store metadata for a given cache key /// </summary> /// <param name="cacheKey">The connection string whose store metadata is to be retrieved</param> /// <param name="composite">An instance of the composite MetadataArtifactLoader</param> /// <param name="entryToken">The metadata entry token for the returned entry</param> /// <returns>the entry containing the information on how to load store metadata</returns> internal static StorageMappingItemCollection GetOrCreateStoreAndMappingItemCollections( string cacheKey, MetadataArtifactLoader loader, EdmItemCollection edmItemCollection, out object entryToken) { StoreMetadataEntry entry = GetCacheEntry <StoreMetadataEntry>(_storeLevelCache, cacheKey, _storeLevelLock, new StoreMetadataEntryConstructor(), out entryToken); // Load the store item collection or if the collection is already loaded, check for security permission LoadItemCollection(new StoreItemCollectionLoader(edmItemCollection, loader), entry); return(entry.StorageMappingItemCollection); }
/// <summary> /// Public constructor that loads the metadata files from the specified xmlReaders. /// Throws when encounter errors. /// </summary> /// <param name="xmlReaders">xmlReaders where the CDM schemas are loaded</param> public StoreItemCollection(IEnumerable <XmlReader> xmlReaders) : base(DataSpace.SSpace) { EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentEmpty(ref xmlReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "xmlReader"); MetadataArtifactLoader composite = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); this.Init(composite.GetReaders(), composite.GetPaths(), true, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); }
/// <summary> /// Helper method that wraps a collection of XmlReader objects in MetadataArtifactLoader /// instances. /// </summary> /// <param name="filePaths">The collection of XmlReader objects to wrap</param> /// <returns>An instance of MetadataArtifactLoader</returns> public static MetadataArtifactLoader CreateCompositeFromXmlReaders(IEnumerable <XmlReader> xmlReaders) { List <MetadataArtifactLoader> loaders = new List <MetadataArtifactLoader>(); foreach (XmlReader reader in xmlReaders) { if (reader == null) { throw EntityUtil.CollectionParameterElementIsNull("xmlReaders"); } loaders.Add(new MetadataArtifactLoaderXmlReaderWrapper(reader)); } return(MetadataArtifactLoader.Create(loaders)); }
[ResourceConsumption(ResourceScope.Machine)] //For CheckArtifactExtension method call. But the path is not created in this method. internal static MetadataArtifactLoader Create(string path, ExtensionCheck extensionCheck, string validExtension, ICollection <string> uriRegistry, MetadataArtifactAssemblyResolver resolver) { Debug.Assert(path != null); Debug.Assert(resolver != null); // res:// -based artifacts // if (MetadataArtifactLoader.PathStartsWithResPrefix(path)) { return(MetadataArtifactLoaderCompositeResource.CreateResourceLoader(path, extensionCheck, validExtension, uriRegistry, resolver)); } // Files and Folders // string normalizedPath = MetadataArtifactLoader.NormalizeFilePaths(path); if (Directory.Exists(normalizedPath)) { return(new MetadataArtifactLoaderCompositeFile(normalizedPath, uriRegistry)); } else if (File.Exists(normalizedPath)) { switch (extensionCheck) { case ExtensionCheck.Specific: CheckArtifactExtension(normalizedPath, validExtension); break; case ExtensionCheck.All: if (!MetadataArtifactLoader.IsValidArtifact(normalizedPath)) { throw EntityUtil.Metadata(Strings.InvalidMetadataPath); } break; } return(new MetadataArtifactLoaderFile(normalizedPath, uriRegistry)); } throw EntityUtil.Metadata(Strings.InvalidMetadataPath); }
/// <summary> /// This helper method accepts a resource URI and a value from the DataSpace enum /// and determines whether the resource identifies an artifact of that DataSpace. /// </summary> /// <param name="resource">A URI to an artifact resource</param> /// <param name="dataSpace">A DataSpace enum value</param> /// <returns>true if the resource identifies an artifact of the specified DataSpace</returns> protected static bool IsArtifactOfDataSpace(string resource, DataSpace dataSpace) { if (dataSpace == DataSpace.CSpace) { return(MetadataArtifactLoader.IsCSpaceArtifact(resource)); } if (dataSpace == DataSpace.SSpace) { return(MetadataArtifactLoader.IsSSpaceArtifact(resource)); } if (dataSpace == DataSpace.CSSpace) { return(MetadataArtifactLoader.IsCSSpaceArtifact(resource)); } Debug.Assert(false, "Invalid DataSpace specified."); return(false); }
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the paths are not created in this method. internal static MetadataArtifactLoader CreateCompositeFromFilePaths(IEnumerable <string> filePaths, string validExtension, MetadataArtifactAssemblyResolver resolver) { ExtensionCheck extensionCheck; if (string.IsNullOrEmpty(validExtension)) { extensionCheck = ExtensionCheck.All; } else { extensionCheck = ExtensionCheck.Specific; } List <MetadataArtifactLoader> loaders = new List <MetadataArtifactLoader>(); // The following set is used to remove duplicate paths from the incoming array HashSet <string> uriRegistry = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (string path in filePaths) { if (string.IsNullOrEmpty(path)) { throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath, EntityUtil.CollectionParameterElementIsNullOrEmpty("filePaths")); } string trimedPath = path.Trim(); if (trimedPath.Length > 0) { loaders.Add(MetadataArtifactLoader.Create( trimedPath, extensionCheck, validExtension, uriRegistry, resolver) ); } } return(MetadataArtifactLoader.Create(loaders)); }
private static void ValidateExtension(ExtensionCheck extensionCheck, string validExtension, string resourceName) { if (resourceName == null) { return; } // the supplied path represents a single resource // switch (extensionCheck) { case ExtensionCheck.Specific: MetadataArtifactLoader.CheckArtifactExtension(resourceName, validExtension); break; case ExtensionCheck.All: if (!MetadataArtifactLoader.IsValidArtifact(resourceName)) { throw EntityUtil.Metadata(Strings.InvalidMetadataPath); } break; } }
[ResourceConsumption(ResourceScope.Machine)] //For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method public StoreItemCollection(params string[] filePaths) : base(DataSpace.SSpace) { EntityUtil.CheckArgumentNull(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); IEnumerable <XmlReader> ieReaders = readers.AsEnumerable(); EntityUtil.CheckArgumentEmpty(ref ieReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths"); this.Init(readers, composite.GetPaths(DataSpace.SSpace), true, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } }
[ResourceConsumption(ResourceScope.Machine)] //For MetadataArtifactLoader.Create method call. But the path is not created in this method. internal static List <MetadataArtifactLoader> SplitPaths(string paths) { Debug.Assert(!string.IsNullOrEmpty(paths), "paths cannot be empty or null"); string[] results; // This is the registry of all URIs in the global collection. HashSet <string> uriRegistry = new HashSet <string>(StringComparer.OrdinalIgnoreCase); List <MetadataArtifactLoader> loaders = new List <MetadataArtifactLoader>(); // If the argument contains one or more occurrences of the macro '|DataDirectory|', we // pull those paths out so that we don't lose them in the string-splitting logic below. // Note that the macro '|DataDirectory|' cannot have any whitespace between the pipe // symbols and the macro name. Also note that the macro must appear at the beginning of // a path (else we will eventually fail with an invalid path exception, because in that // case the macro is not expanded). If a real/physical folder named 'DataDirectory' needs // to be included in the metadata path, whitespace should be used on either or both sides // of the name. // List <string> dataDirPaths = new List <string>(); int indexStart = paths.IndexOf(MetadataCache.s_dataDirectory, StringComparison.OrdinalIgnoreCase); while (indexStart != -1) { int prevSeparatorIndex = indexStart == 0 ? -1 : paths.LastIndexOf( MetadataCache.s_metadataPathSeparator, indexStart - 1, // start looking here StringComparison.Ordinal ); int macroPathBeginIndex = prevSeparatorIndex + 1; // The '|DataDirectory|' macro is composable, so identify the complete path, like // '|DataDirectory|\item1\item2'. If the macro appears anywhere other than at the // beginning, splice out the entire path, e.g. 'C:\item1\|DataDirectory|\item2'. In this // latter case the macro will not be expanded, and downstream code will throw an exception. // int indexEnd = paths.IndexOf(MetadataCache.s_metadataPathSeparator, indexStart + MetadataCache.s_dataDirectory.Length, StringComparison.Ordinal); if (indexEnd == -1) { dataDirPaths.Add(paths.Substring(macroPathBeginIndex)); paths = paths.Remove(macroPathBeginIndex); // update the concatenated list of paths break; } dataDirPaths.Add(paths.Substring(macroPathBeginIndex, indexEnd - macroPathBeginIndex)); // Update the concatenated list of paths by removing the one containing the macro. // paths = paths.Remove(macroPathBeginIndex, indexEnd - macroPathBeginIndex); indexStart = paths.IndexOf(MetadataCache.s_dataDirectory, StringComparison.OrdinalIgnoreCase); } // Split the string on the separator and remove all spaces around each parameter value results = paths.Split(new string[] { MetadataCache.s_metadataPathSeparator }, StringSplitOptions.RemoveEmptyEntries); // Now that the non-macro paths have been identified, merge the paths containing the macro // into the complete list. // if (dataDirPaths.Count > 0) { dataDirPaths.AddRange(results); results = dataDirPaths.ToArray(); } for (int i = 0; i < results.Length; i++) { // Trim out all the spaces for this parameter and add it only if it's not blank results[i] = results[i].Trim(); if (results[i].Length > 0) { loaders.Add(MetadataArtifactLoader.Create( results[i], MetadataArtifactLoader.ExtensionCheck.All, // validate the extension against all acceptable values null, uriRegistry )); } } return(loaders); }
public EdmItemCollectionLoader(MetadataArtifactLoader loader) { Debug.Assert(loader != null, "loader must never be null"); _loader = loader; }
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] //Fir SplitPaths call and we pick the file names from class variable. internal MetadataWorkspace GetMetadataWorkspace(bool initializeAllCollections) { Debug.Assert(_metadataWorkspace != null || _effectiveConnectionOptions != null, "The effective connection options is null, which should never be"); if (_metadataWorkspace == null || (initializeAllCollections && !_metadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace))) { // This lock is to ensure that the connection string and the metadata workspace are in a consistent state, that is, you // don't get a metadata workspace not matching what's described by the connection string lock (_connectionStringLock) { EdmItemCollection edmItemCollection = null; if (_metadataWorkspace == null) { MetadataWorkspace workspace = new MetadataWorkspace(); List<MetadataArtifactLoader> loaders = new List<MetadataArtifactLoader>(); string paths = _effectiveConnectionOptions[EntityConnectionStringBuilder.MetadataParameterName]; if (!string.IsNullOrEmpty(paths)) { loaders = MetadataCache.GetOrCreateMetdataArtifactLoader(paths); if(!ShouldRecalculateMetadataArtifactLoader(loaders)) { _artifactLoader = MetadataArtifactLoader.Create(loaders); } else { // the loaders contains folders that might get updated during runtime, so we have to recalculate the loaders again _artifactLoader = MetadataArtifactLoader.Create(MetadataCache.SplitPaths(paths)); } } else { _artifactLoader = MetadataArtifactLoader.Create(loaders); } edmItemCollection = LoadEdmItemCollection(workspace, _artifactLoader); _metadataWorkspace = workspace; } else { edmItemCollection = (EdmItemCollection)_metadataWorkspace.GetItemCollection(DataSpace.CSpace); } if (initializeAllCollections && !_metadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)) { LoadStoreItemCollections(_metadataWorkspace, _storeConnection, _providerFactory, _effectiveConnectionOptions, edmItemCollection, _artifactLoader); _artifactLoader = null; _initialized = true; } } } return _metadataWorkspace; }
private static EdmItemCollection LoadEdmItemCollection(MetadataWorkspace workspace, MetadataArtifactLoader artifactLoader) { // Build a string as the key and look up the MetadataCache for a match string edmCacheKey = CreateMetadataCacheKey(artifactLoader.GetOriginalPaths(DataSpace.CSpace), null, null); // Check the MetadataCache for an entry with this key object entryToken; EdmItemCollection edmItemCollection = MetadataCache.GetOrCreateEdmItemCollection(edmCacheKey, artifactLoader, out entryToken); workspace.RegisterItemCollection(edmItemCollection); // Adding the edm metadata entry token to the workspace, to make sure that this token remains alive till workspace is alive workspace.AddMetadataEntryToken(entryToken); return edmItemCollection; }
private void GenerateCodeCommon(MetadataArtifactLoader sourceLoader, List<MetadataArtifactLoader> loaders, LazyTextWriterCreator target, string sourceEdmSchemaFilePath, string targetFilePath, bool closeReaders, List<EdmSchemaError> errors) { MetadataArtifactLoaderComposite composite = new MetadataArtifactLoaderComposite(loaders); // create the schema manager from the xml readers Dictionary<MetadataArtifactLoader, XmlReader> readerSourceMap = new Dictionary<MetadataArtifactLoader, XmlReader>(); IList<Schema> schemas; List<XmlReader> readers = composite.GetReaders(readerSourceMap); try { IList<EdmSchemaError> schemaManagerErrors = SchemaManager.ParseAndValidate(readers, composite.GetPaths(), SchemaDataModelOption.EntityDataModel, EdmProviderManifest.Instance, out schemas); errors.AddRange(schemaManagerErrors); } finally { if (closeReaders) { MetadataUtil.DisposeXmlReaders(readers); } } ThrowOnAnyNonWarningErrors(errors); Debug.Assert(readerSourceMap.ContainsKey(sourceLoader), "the source loader didn't produce any of the xml readers..."); XmlReader sourceReader = readerSourceMap[sourceLoader]; // use the index of the "source" xml reader as the index of the "source" schema Debug.Assert(readers.Contains(sourceReader), "the source reader is not in the list of readers"); int index = readers.IndexOf(sourceReader); Debug.Assert(index >= 0, "couldn't find the source reader in the list of readers"); Debug.Assert(readers.Count == schemas.Count, "We have a different number of readers than schemas"); Schema sourceSchema = schemas[index]; Debug.Assert(sourceSchema != null, "sourceSchema is null"); // create the EdmItemCollection from the schemas EdmItemCollection itemCollection = new EdmItemCollection(schemas); if (EntityFrameworkVersionsUtil.ConvertToVersion(itemCollection.EdmVersion) >= EntityFrameworkVersions.Version2) { throw EDesignUtil.InvalidOperation(Strings.TargetEntityFrameworkVersionToNewForEntityClassGenerator); } // generate code ClientApiGenerator generator = new ClientApiGenerator(sourceSchema, itemCollection, this, errors); generator.GenerateCode(target, targetFilePath); }
private static void LoadStoreItemCollections(MetadataWorkspace workspace, DbConnection storeConnection, DbProviderFactory factory, DbConnectionOptions connectionOptions, EdmItemCollection edmItemCollection, MetadataArtifactLoader artifactLoader) { Debug.Assert(workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace), "C-Space must be loaded before loading S or C-S space"); // The provider connection string is optional; if it has not been specified, // we pick up the store's connection string. // string providerConnectionString = connectionOptions[EntityConnectionStringBuilder.ProviderConnectionStringParameterName]; if (string.IsNullOrEmpty(providerConnectionString) && (storeConnection != null)) { providerConnectionString = storeConnection.ConnectionString; } // Build a string as the key and look up the MetadataCache for a match string storeCacheKey = CreateMetadataCacheKey(artifactLoader.GetOriginalPaths(), connectionOptions[EntityConnectionStringBuilder.ProviderParameterName], providerConnectionString); // Load store metadata. object entryToken; StorageMappingItemCollection mappingCollection = MetadataCache.GetOrCreateStoreAndMappingItemCollections(storeCacheKey, artifactLoader, edmItemCollection, out entryToken); workspace.RegisterItemCollection(mappingCollection.StoreItemCollection); workspace.RegisterItemCollection(mappingCollection); // Adding the store metadata entry token to the workspace workspace.AddMetadataEntryToken(entryToken); }