public static MetadataArtifactLoader Create( string path, MetadataArtifactLoader.ExtensionCheck extensionCheck, string validExtension, ICollection <string> uriRegistry) { return(MetadataArtifactLoader.Create(path, extensionCheck, validExtension, uriRegistry, (MetadataArtifactAssemblyResolver) new DefaultAssemblyResolver())); }
public MetadataArtifactLoader GetArtifactLoader( DbConnectionOptions effectiveConnectionOptions) { string connectionOption = effectiveConnectionOptions["metadata"]; if (string.IsNullOrEmpty(connectionOption)) { return(MetadataArtifactLoader.Create(new List <MetadataArtifactLoader>())); } List <MetadataArtifactLoader> metadataArtifactLoaderList = this._artifactLoaderCache.Evaluate(connectionOption); return(MetadataArtifactLoader.Create(MetadataCache.ShouldRecalculateMetadataArtifactLoader((IEnumerable <MetadataArtifactLoader>)metadataArtifactLoaderList) ? MetadataCache.SplitPaths(connectionOption) : metadataArtifactLoaderList)); }
public static MetadataArtifactLoader CreateCompositeFromXmlReaders( IEnumerable <XmlReader> xmlReaders) { List <MetadataArtifactLoader> allCollections = new List <MetadataArtifactLoader>(); foreach (XmlReader xmlReader in xmlReaders) { if (xmlReader == null) { throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(xmlReaders))); } allCollections.Add((MetadataArtifactLoader) new MetadataArtifactLoaderXmlReaderWrapper(xmlReader)); } return(MetadataArtifactLoader.Create(allCollections)); }
public MetadataArtifactLoader GetArtifactLoader(DbConnectionOptions effectiveConnectionOptions) { DebugCheck.NotNull(effectiveConnectionOptions); var paths = effectiveConnectionOptions[EntityConnectionStringBuilder.MetadataParameterName]; if (!string.IsNullOrEmpty(paths)) { var loaders = _artifactLoaderCache.Evaluate(paths); return(MetadataArtifactLoader.Create( ShouldRecalculateMetadataArtifactLoader(loaders) ? SplitPaths(paths) : loaders)); } return(MetadataArtifactLoader.Create(new List <MetadataArtifactLoader>())); }
internal static MetadataArtifactLoader CreateCompositeFromFilePaths( IEnumerable <string> filePaths, string validExtension, MetadataArtifactAssemblyResolver resolver) { MetadataArtifactLoader.ExtensionCheck extensionCheck = !string.IsNullOrEmpty(validExtension) ? MetadataArtifactLoader.ExtensionCheck.Specific : MetadataArtifactLoader.ExtensionCheck.All; List <MetadataArtifactLoader> allCollections = new List <MetadataArtifactLoader>(); HashSet <string> stringSet = new HashSet <string>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); foreach (string filePath in filePaths) { if (string.IsNullOrEmpty(filePath)) { throw new MetadataException(Strings.NotValidInputPath, (Exception) new ArgumentException(Strings.ADP_CollectionParameterElementIsNullOrEmpty((object)nameof(filePaths)))); } string path = filePath.Trim(); if (path.Length > 0) { allCollections.Add(MetadataArtifactLoader.Create(path, extensionCheck, validExtension, (ICollection <string>)stringSet, resolver)); } } return(MetadataArtifactLoader.Create(allCollections)); }
//For MetadataArtifactLoader.Create method call. But the path is not created in this method. internal static List <MetadataArtifactLoader> SplitPaths(string paths) { DebugCheck.NotEmpty(paths); string[] results; // This is the registry of all URIs in the global collection. var uriRegistry = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var 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. // var dataDirPaths = new List <string>(); var indexStart = paths.IndexOf(s_dataDirectory, StringComparison.OrdinalIgnoreCase); while (indexStart != -1) { var prevSeparatorIndex = indexStart == 0 ? -1 : paths.LastIndexOf( s_metadataPathSeparator, indexStart - 1, // start looking here StringComparison.Ordinal ); var 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. // var indexEnd = paths.IndexOf( s_metadataPathSeparator, indexStart + 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(s_dataDirectory, StringComparison.OrdinalIgnoreCase); } // Split the string on the separator and remove all spaces around each parameter value results = paths.Split(new[] { 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 (var 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); }
private static List <MetadataArtifactLoader> SplitPaths(string paths) { HashSet <string> stringSet = new HashSet <string>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); List <string> stringList = new List <string>(); int num1 = paths.IndexOf("|datadirectory|", StringComparison.OrdinalIgnoreCase); int startIndex; while (true) { int num2; switch (num1) { case -1: goto label_7; case 0: num2 = -1; break; default: num2 = paths.LastIndexOf("|", num1 - 1, StringComparison.Ordinal); break; } startIndex = num2 + 1; int num3 = paths.IndexOf("|", num1 + "|datadirectory|".Length, StringComparison.Ordinal); if (num3 != -1) { stringList.Add(paths.Substring(startIndex, num3 - startIndex)); paths = paths.Remove(startIndex, num3 - startIndex); num1 = paths.IndexOf("|datadirectory|", StringComparison.OrdinalIgnoreCase); } else { break; } } stringList.Add(paths.Substring(startIndex)); paths = paths.Remove(startIndex); label_7: string[] strArray = paths.Split(new string[1] { "|" }, StringSplitOptions.RemoveEmptyEntries); if (stringList.Count > 0) { stringList.AddRange((IEnumerable <string>)strArray); strArray = stringList.ToArray(); } List <MetadataArtifactLoader> metadataArtifactLoaderList1 = new List <MetadataArtifactLoader>(); List <MetadataArtifactLoader> metadataArtifactLoaderList2 = new List <MetadataArtifactLoader>(); List <MetadataArtifactLoader> metadataArtifactLoaderList3 = new List <MetadataArtifactLoader>(); List <MetadataArtifactLoader> metadataArtifactLoaderList4 = new List <MetadataArtifactLoader>(); for (int index = 0; index < strArray.Length; ++index) { strArray[index] = strArray[index].Trim(); if (strArray[index].Length > 0) { MetadataArtifactLoader metadataArtifactLoader = MetadataArtifactLoader.Create(strArray[index], MetadataArtifactLoader.ExtensionCheck.All, (string)null, (ICollection <string>)stringSet); if (strArray[index].EndsWith(".csdl", StringComparison.OrdinalIgnoreCase)) { metadataArtifactLoaderList1.Add(metadataArtifactLoader); } else if (strArray[index].EndsWith(".msl", StringComparison.OrdinalIgnoreCase)) { metadataArtifactLoaderList2.Add(metadataArtifactLoader); } else if (strArray[index].EndsWith(".ssdl", StringComparison.OrdinalIgnoreCase)) { metadataArtifactLoaderList3.Add(metadataArtifactLoader); } else { metadataArtifactLoaderList4.Add(metadataArtifactLoader); } } } metadataArtifactLoaderList4.AddRange((IEnumerable <MetadataArtifactLoader>)metadataArtifactLoaderList3); metadataArtifactLoaderList4.AddRange((IEnumerable <MetadataArtifactLoader>)metadataArtifactLoaderList2); metadataArtifactLoaderList4.AddRange((IEnumerable <MetadataArtifactLoader>)metadataArtifactLoaderList1); return(metadataArtifactLoaderList4); }