Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Metadata / MetadataArtifactLoader.cs / 1305376 / MetadataArtifactLoader.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Data.Mapping;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.Data.Entity;
using System.Data.Metadata;
using System.Runtime.Versioning;
namespace System.Data.Metadata.Edm
{
///
/// This is the base class for the resource metadata artifact loader; derived
/// classes enacpsulate a single resource as well as collections of resources,
/// along the lines of the Composite pattern.
///
internal abstract class MetadataArtifactLoader
{
protected readonly static string resPathPrefix = @"res://";
protected readonly static string resPathSeparator = @"/";
protected readonly static string altPathSeparator = @"\";
protected readonly static string wildcard = @"*";
///
/// Read-only access to the resource/file path
///
public abstract string Path{ get; }
public abstract void CollectFilePermissionPaths(List paths, DataSpace spaceToGet);
///
/// This enum is used to indicate the level of extension check to be perfoemed
/// on a metadata URI.
///
public enum ExtensionCheck
{
///
/// Do not perform any extension check
///
None = 0,
///
/// Check the extension against a specific value
///
Specific,
///
/// Check the extension against the set of acceptable extensions
///
All
}
[ResourceExposure(ResourceScope.Machine)] //Exposes the file name which is a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the path is not created in this method.
public static MetadataArtifactLoader Create(string path,
ExtensionCheck extensionCheck,
string validExtension,
ICollection uriRegistry)
{
return Create(path, extensionCheck, validExtension, uriRegistry, new DefaultAssemblyResolver());
}
///
/// Factory method to create an artifact loader. This is where an appropriate
/// subclass of MetadataArtifactLoader is created, depending on the kind of
/// resource it will encapsulate.
///
/// The path to the resource(s) to be loaded
/// Any URI extension checks to perform
/// A specific extension for an artifact resource
/// The global registry of URIs
///
/// A concrete instance of an artifact loader.
[ResourceExposure(ResourceScope.Machine)] //Exposes the file name which is a Machine resource
[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 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);
}
///
/// Factory method to create an aggregating artifact loader, one that encapsulates
/// multiple collections.
///
/// The list of collections to be aggregated
/// A concrete instance of an artifact loader.
public static MetadataArtifactLoader Create(List allCollections)
{
return new MetadataArtifactLoaderComposite(allCollections);
}
///
/// Helper method that wraps a list of file paths in MetadataArtifactLoader instances.
///
/// The list of file paths to wrap
/// An acceptable extension for the file
/// An instance of MetadataArtifactLoader
[ResourceExposure(ResourceScope.Machine)] //Exposes the file names which are a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For CreateCompositeFromFilePaths method call. But the path is not created in this method.
public static MetadataArtifactLoader CreateCompositeFromFilePaths(IEnumerable filePaths, string validExtension)
{
Debug.Assert(!string.IsNullOrEmpty(validExtension));
return CreateCompositeFromFilePaths(filePaths, validExtension, new DefaultAssemblyResolver());
}
[ResourceExposure(ResourceScope.Machine)] //Exposes the file names which are a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the paths are not created in this method.
internal static MetadataArtifactLoader CreateCompositeFromFilePaths(IEnumerable filePaths, string validExtension, MetadataArtifactAssemblyResolver resolver)
{
ExtensionCheck extensionCheck;
if (string.IsNullOrEmpty(validExtension))
{
extensionCheck = ExtensionCheck.All;
}
else
{
extensionCheck = ExtensionCheck.Specific;
}
List loaders = new List();
// The following set is used to remove duplicate paths from the incoming array
HashSet uriRegistry = new HashSet(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);
}
///
/// Helper method that wraps a collection of XmlReader objects in MetadataArtifactLoader
/// instances.
///
/// The collection of XmlReader objects to wrap
/// An instance of MetadataArtifactLoader
public static MetadataArtifactLoader CreateCompositeFromXmlReaders(IEnumerable xmlReaders)
{
List loaders = new List();
foreach (XmlReader reader in xmlReaders)
{
if (reader == null)
{
throw EntityUtil.CollectionParameterElementIsNull("xmlReaders");
}
loaders.Add(new MetadataArtifactLoaderXmlReaderWrapper(reader));
}
return MetadataArtifactLoader.Create(loaders);
}
///
/// If the path doesn't have the right extension, throw
///
/// The path to the resource
///
internal static void CheckArtifactExtension(string path, string validExtension)
{
Debug.Assert(!string.IsNullOrEmpty(path));
Debug.Assert(!string.IsNullOrEmpty(validExtension));
string extension = GetExtension(path);
if (!extension.Equals(validExtension, StringComparison.OrdinalIgnoreCase))
{
throw EntityUtil.Metadata(Strings.InvalidFileExtension(path, extension, validExtension));
}
}
///
/// Get paths to all artifacts, in the original, unexpanded form
///
/// A List of strings identifying paths to all resources
public virtual List GetOriginalPaths()
{
return new List(new string[] { Path });
}
///
/// Get paths to artifacts for a specific DataSpace, in the original, unexpanded
/// form
///
/// The DataSpace for the artifacts of interest
/// A List of strings identifying paths to all artifacts for a specific DataSpace
public virtual List GetOriginalPaths(DataSpace spaceToGet)
{
List list = new List();
if (MetadataArtifactLoader.IsArtifactOfDataSpace(Path, spaceToGet))
{
list.Add(Path);
}
return list;
}
public virtual bool IsComposite
{
get
{
return false;
}
}
///
/// Get paths to all artifacts
///
/// A List of strings identifying paths to all resources
public abstract List GetPaths();
///
/// Get paths to artifacts for a specific DataSpace.
///
/// The DataSpace for the artifacts of interest
/// A List of strings identifying paths to all artifacts for a specific DataSpace
public abstract List GetPaths(DataSpace spaceToGet);
public List GetReaders()
{
return GetReaders(null);
}
///
/// Get XmlReaders for all resources
///
/// A List of XmlReaders for all resources
public abstract List GetReaders(Dictionary sourceDictionary);
///
/// Get XmlReaders for a specific DataSpace.
///
/// The DataSpace for the artifacts of interest
/// A List of XmlReader object
public abstract List CreateReaders(DataSpace spaceToGet);
///
/// Helper method to determine whether a given path to a resource
/// starts with the "res://" prefix.
///
/// The resource path to test.
/// true if the path represents a resource location
internal static bool PathStartsWithResPrefix(string path)
{
return path.StartsWith(MetadataArtifactLoader.resPathPrefix, StringComparison.OrdinalIgnoreCase);
}
///
/// Helper method to determine whether a resource identifies a C-Space
/// artifact.
///
/// The resource path
/// true if the resource identifies a C-Space artifact
protected static bool IsCSpaceArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return string.Compare(extn, XmlConstants.CSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0;
}
return false;
}
///
/// Helper method to determine whether a resource identifies an S-Space
/// artifact.
///
/// The resource path
/// true if the resource identifies an S-Space artifact
protected static bool IsSSpaceArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return string.Compare(extn, XmlConstants.SSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0;
}
return false;
}
///
/// Helper method to determine whether a resource identifies a CS-Space
/// artifact.
///
/// The resource path
/// true if the resource identifies a CS-Space artifact
protected static bool IsCSSpaceArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return string.Compare(extn, XmlConstants.CSSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0;
}
return false;
}
// don't use Path.GetExtension because it is ok for the resource
// name to have characters in it that would be illegal in a path (ie '<' is illegal in a path)
// and when they do, Path.GetExtension throws and ArgumentException
private static string GetExtension(string resource)
{
if(String.IsNullOrEmpty(resource))
return string.Empty;
int pos = resource.LastIndexOf('.');
if (pos < 0)
return string.Empty;
return resource.Substring(pos);
}
///
/// Helper method to determine whether a resource identifies a valid artifact.
///
/// The resource path
/// true if the resource identifies a valid artifact
internal static bool IsValidArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return (
string.Compare(extn, XmlConstants.CSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(extn, XmlConstants.SSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(extn, XmlConstants.CSSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0
);
}
return false;
}
///
/// 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.
///
/// A URI to an artifact resource
/// A DataSpace enum value
/// true if the resource identifies an artifact of the specified DataSpace
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;
}
///
/// Normalize a file path:
/// 1. Add backslashes if given a drive letter.
/// 2. Resolve the '~' macro in a Web/ASP.NET environment.
/// 3. Expand the |DataDirectory| macro, if found in the argument.
/// 4. Convert relative paths into absolute paths.
///
/// the path to normalize
/// The normalized file path
[ResourceExposure(ResourceScope.Machine)] //Exposes the file name which is a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For Path.GetFullPath method call. But the path is not created in this method.
static internal string NormalizeFilePaths(string path)
{
bool getFullPath = true; // used to determine whether we need to invoke GetFullPath()
if (!String.IsNullOrEmpty(path))
{
path = path.Trim();
// If the path starts with a '~' character, try to resolve it as a Web/ASP.NET
// application path.
//
if (path.StartsWith(EdmConstants.WebHomeSymbol, StringComparison.Ordinal))
{
AspProxy aspProxy = new AspProxy();
path = aspProxy.MapWebPath(path);
getFullPath = false;
}
if (path.Length == 2 && path[1] == System.IO.Path.VolumeSeparatorChar)
{
path = path + System.IO.Path.DirectorySeparatorChar;
}
else
{
// See if the path contains the |DataDirectory| macro that we need to
// expand. Note that ExpandDataDirectory() won't process the path unless
// it begins with the macro.
//
string datadir = null; // this is what the macro expands to
string fullPath = System.Data.Common.DbConnectionOptions.ExpandDataDirectory(
System.Data.EntityClient.EntityConnectionStringBuilder.MetadataParameterName, // keyword ("Metadata")
path, // value
ref datadir // the expanded macro
);
// ExpandDataDirectory() returns null if it doesn't find the macro in its
// argument.
//
if (fullPath != null)
{
path = fullPath;
getFullPath = false;
}
}
}
try
{
if (getFullPath)
{
path = System.IO.Path.GetFullPath(path);
}
}
catch (ArgumentException e)
{
throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath, e);
}
catch (NotSupportedException e)
{
throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath, e);
}
catch (PathTooLongException)
{
throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath);
}
return path;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Data.Mapping;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.Data.Entity;
using System.Data.Metadata;
using System.Runtime.Versioning;
namespace System.Data.Metadata.Edm
{
///
/// This is the base class for the resource metadata artifact loader; derived
/// classes enacpsulate a single resource as well as collections of resources,
/// along the lines of the Composite pattern.
///
internal abstract class MetadataArtifactLoader
{
protected readonly static string resPathPrefix = @"res://";
protected readonly static string resPathSeparator = @"/";
protected readonly static string altPathSeparator = @"\";
protected readonly static string wildcard = @"*";
///
/// Read-only access to the resource/file path
///
public abstract string Path{ get; }
public abstract void CollectFilePermissionPaths(List paths, DataSpace spaceToGet);
///
/// This enum is used to indicate the level of extension check to be perfoemed
/// on a metadata URI.
///
public enum ExtensionCheck
{
///
/// Do not perform any extension check
///
None = 0,
///
/// Check the extension against a specific value
///
Specific,
///
/// Check the extension against the set of acceptable extensions
///
All
}
[ResourceExposure(ResourceScope.Machine)] //Exposes the file name which is a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the path is not created in this method.
public static MetadataArtifactLoader Create(string path,
ExtensionCheck extensionCheck,
string validExtension,
ICollection uriRegistry)
{
return Create(path, extensionCheck, validExtension, uriRegistry, new DefaultAssemblyResolver());
}
///
/// Factory method to create an artifact loader. This is where an appropriate
/// subclass of MetadataArtifactLoader is created, depending on the kind of
/// resource it will encapsulate.
///
/// The path to the resource(s) to be loaded
/// Any URI extension checks to perform
/// A specific extension for an artifact resource
/// The global registry of URIs
///
/// A concrete instance of an artifact loader.
[ResourceExposure(ResourceScope.Machine)] //Exposes the file name which is a Machine resource
[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 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);
}
///
/// Factory method to create an aggregating artifact loader, one that encapsulates
/// multiple collections.
///
/// The list of collections to be aggregated
/// A concrete instance of an artifact loader.
public static MetadataArtifactLoader Create(List allCollections)
{
return new MetadataArtifactLoaderComposite(allCollections);
}
///
/// Helper method that wraps a list of file paths in MetadataArtifactLoader instances.
///
/// The list of file paths to wrap
/// An acceptable extension for the file
/// An instance of MetadataArtifactLoader
[ResourceExposure(ResourceScope.Machine)] //Exposes the file names which are a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For CreateCompositeFromFilePaths method call. But the path is not created in this method.
public static MetadataArtifactLoader CreateCompositeFromFilePaths(IEnumerable filePaths, string validExtension)
{
Debug.Assert(!string.IsNullOrEmpty(validExtension));
return CreateCompositeFromFilePaths(filePaths, validExtension, new DefaultAssemblyResolver());
}
[ResourceExposure(ResourceScope.Machine)] //Exposes the file names which are a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the paths are not created in this method.
internal static MetadataArtifactLoader CreateCompositeFromFilePaths(IEnumerable filePaths, string validExtension, MetadataArtifactAssemblyResolver resolver)
{
ExtensionCheck extensionCheck;
if (string.IsNullOrEmpty(validExtension))
{
extensionCheck = ExtensionCheck.All;
}
else
{
extensionCheck = ExtensionCheck.Specific;
}
List loaders = new List();
// The following set is used to remove duplicate paths from the incoming array
HashSet uriRegistry = new HashSet(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);
}
///
/// Helper method that wraps a collection of XmlReader objects in MetadataArtifactLoader
/// instances.
///
/// The collection of XmlReader objects to wrap
/// An instance of MetadataArtifactLoader
public static MetadataArtifactLoader CreateCompositeFromXmlReaders(IEnumerable xmlReaders)
{
List loaders = new List();
foreach (XmlReader reader in xmlReaders)
{
if (reader == null)
{
throw EntityUtil.CollectionParameterElementIsNull("xmlReaders");
}
loaders.Add(new MetadataArtifactLoaderXmlReaderWrapper(reader));
}
return MetadataArtifactLoader.Create(loaders);
}
///
/// If the path doesn't have the right extension, throw
///
/// The path to the resource
///
internal static void CheckArtifactExtension(string path, string validExtension)
{
Debug.Assert(!string.IsNullOrEmpty(path));
Debug.Assert(!string.IsNullOrEmpty(validExtension));
string extension = GetExtension(path);
if (!extension.Equals(validExtension, StringComparison.OrdinalIgnoreCase))
{
throw EntityUtil.Metadata(Strings.InvalidFileExtension(path, extension, validExtension));
}
}
///
/// Get paths to all artifacts, in the original, unexpanded form
///
/// A List of strings identifying paths to all resources
public virtual List GetOriginalPaths()
{
return new List(new string[] { Path });
}
///
/// Get paths to artifacts for a specific DataSpace, in the original, unexpanded
/// form
///
/// The DataSpace for the artifacts of interest
/// A List of strings identifying paths to all artifacts for a specific DataSpace
public virtual List GetOriginalPaths(DataSpace spaceToGet)
{
List list = new List();
if (MetadataArtifactLoader.IsArtifactOfDataSpace(Path, spaceToGet))
{
list.Add(Path);
}
return list;
}
public virtual bool IsComposite
{
get
{
return false;
}
}
///
/// Get paths to all artifacts
///
/// A List of strings identifying paths to all resources
public abstract List GetPaths();
///
/// Get paths to artifacts for a specific DataSpace.
///
/// The DataSpace for the artifacts of interest
/// A List of strings identifying paths to all artifacts for a specific DataSpace
public abstract List GetPaths(DataSpace spaceToGet);
public List GetReaders()
{
return GetReaders(null);
}
///
/// Get XmlReaders for all resources
///
/// A List of XmlReaders for all resources
public abstract List GetReaders(Dictionary sourceDictionary);
///
/// Get XmlReaders for a specific DataSpace.
///
/// The DataSpace for the artifacts of interest
/// A List of XmlReader object
public abstract List CreateReaders(DataSpace spaceToGet);
///
/// Helper method to determine whether a given path to a resource
/// starts with the "res://" prefix.
///
/// The resource path to test.
/// true if the path represents a resource location
internal static bool PathStartsWithResPrefix(string path)
{
return path.StartsWith(MetadataArtifactLoader.resPathPrefix, StringComparison.OrdinalIgnoreCase);
}
///
/// Helper method to determine whether a resource identifies a C-Space
/// artifact.
///
/// The resource path
/// true if the resource identifies a C-Space artifact
protected static bool IsCSpaceArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return string.Compare(extn, XmlConstants.CSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0;
}
return false;
}
///
/// Helper method to determine whether a resource identifies an S-Space
/// artifact.
///
/// The resource path
/// true if the resource identifies an S-Space artifact
protected static bool IsSSpaceArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return string.Compare(extn, XmlConstants.SSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0;
}
return false;
}
///
/// Helper method to determine whether a resource identifies a CS-Space
/// artifact.
///
/// The resource path
/// true if the resource identifies a CS-Space artifact
protected static bool IsCSSpaceArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return string.Compare(extn, XmlConstants.CSSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0;
}
return false;
}
// don't use Path.GetExtension because it is ok for the resource
// name to have characters in it that would be illegal in a path (ie '<' is illegal in a path)
// and when they do, Path.GetExtension throws and ArgumentException
private static string GetExtension(string resource)
{
if(String.IsNullOrEmpty(resource))
return string.Empty;
int pos = resource.LastIndexOf('.');
if (pos < 0)
return string.Empty;
return resource.Substring(pos);
}
///
/// Helper method to determine whether a resource identifies a valid artifact.
///
/// The resource path
/// true if the resource identifies a valid artifact
internal static bool IsValidArtifact(string resource)
{
Debug.Assert(!string.IsNullOrEmpty(resource));
string extn = GetExtension(resource);
if (!string.IsNullOrEmpty(extn))
{
return (
string.Compare(extn, XmlConstants.CSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(extn, XmlConstants.SSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(extn, XmlConstants.CSSpaceSchemaExtension, StringComparison.OrdinalIgnoreCase) == 0
);
}
return false;
}
///
/// 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.
///
/// A URI to an artifact resource
/// A DataSpace enum value
/// true if the resource identifies an artifact of the specified DataSpace
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;
}
///
/// Normalize a file path:
/// 1. Add backslashes if given a drive letter.
/// 2. Resolve the '~' macro in a Web/ASP.NET environment.
/// 3. Expand the |DataDirectory| macro, if found in the argument.
/// 4. Convert relative paths into absolute paths.
///
/// the path to normalize
/// The normalized file path
[ResourceExposure(ResourceScope.Machine)] //Exposes the file name which is a Machine resource
[ResourceConsumption(ResourceScope.Machine)] //For Path.GetFullPath method call. But the path is not created in this method.
static internal string NormalizeFilePaths(string path)
{
bool getFullPath = true; // used to determine whether we need to invoke GetFullPath()
if (!String.IsNullOrEmpty(path))
{
path = path.Trim();
// If the path starts with a '~' character, try to resolve it as a Web/ASP.NET
// application path.
//
if (path.StartsWith(EdmConstants.WebHomeSymbol, StringComparison.Ordinal))
{
AspProxy aspProxy = new AspProxy();
path = aspProxy.MapWebPath(path);
getFullPath = false;
}
if (path.Length == 2 && path[1] == System.IO.Path.VolumeSeparatorChar)
{
path = path + System.IO.Path.DirectorySeparatorChar;
}
else
{
// See if the path contains the |DataDirectory| macro that we need to
// expand. Note that ExpandDataDirectory() won't process the path unless
// it begins with the macro.
//
string datadir = null; // this is what the macro expands to
string fullPath = System.Data.Common.DbConnectionOptions.ExpandDataDirectory(
System.Data.EntityClient.EntityConnectionStringBuilder.MetadataParameterName, // keyword ("Metadata")
path, // value
ref datadir // the expanded macro
);
// ExpandDataDirectory() returns null if it doesn't find the macro in its
// argument.
//
if (fullPath != null)
{
path = fullPath;
getFullPath = false;
}
}
}
try
{
if (getFullPath)
{
path = System.IO.Path.GetFullPath(path);
}
}
catch (ArgumentException e)
{
throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath, e);
}
catch (NotSupportedException e)
{
throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath, e);
}
catch (PathTooLongException)
{
throw EntityUtil.Metadata(System.Data.Entity.Strings.NotValidInputPath);
}
return path;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CounterSampleCalculator.cs
- WorkflowServiceNamespace.cs
- ToolBarPanel.cs
- CustomWebEventKey.cs
- WebPartManager.cs
- TraceContextRecord.cs
- Util.cs
- RemoteWebConfigurationHostStream.cs
- RootBrowserWindowAutomationPeer.cs
- TimeSpanFormat.cs
- TypeUtil.cs
- TemplateColumn.cs
- SignedXml.cs
- PolicyVersionConverter.cs
- TemplateControlBuildProvider.cs
- ApplicationDirectory.cs
- ActivityBindForm.Designer.cs
- RootProfilePropertySettingsCollection.cs
- DoubleLink.cs
- DataBindingCollection.cs
- XmlArrayItemAttributes.cs
- ExtenderProvidedPropertyAttribute.cs
- IsolatedStoragePermission.cs
- Size3D.cs
- TouchEventArgs.cs
- DtdParser.cs
- SQLUtility.cs
- TextInfo.cs
- TargetInvocationException.cs
- SharedUtils.cs
- WebPartUtil.cs
- RangeBaseAutomationPeer.cs
- ConnectionsZone.cs
- RedistVersionInfo.cs
- ControlPaint.cs
- LinearKeyFrames.cs
- MimeFormImporter.cs
- ConnectionPointCookie.cs
- GroupByExpressionRewriter.cs
- XmlDataContract.cs
- NamespaceEmitter.cs
- XmlNamespaceMapping.cs
- FormViewPagerRow.cs
- BuildProvider.cs
- ProfileSettingsCollection.cs
- DictionarySectionHandler.cs
- RequestQueryProcessor.cs
- WindowsListViewItemStartMenu.cs
- DataGridAddNewRow.cs
- SafeCryptHandles.cs
- HybridObjectCache.cs
- Graph.cs
- DataGridLinkButton.cs
- WorkflowMarkupSerializerMapping.cs
- basevalidator.cs
- ObjectAnimationUsingKeyFrames.cs
- MSG.cs
- ScriptRegistrationManager.cs
- NamespaceQuery.cs
- ManagementNamedValueCollection.cs
- FamilyMapCollection.cs
- DateTimeConstantAttribute.cs
- EntityConnectionStringBuilder.cs
- HuffmanTree.cs
- Single.cs
- ToolStripPanelCell.cs
- ExceptionUtil.cs
- ClientSponsor.cs
- MultiAsyncResult.cs
- FamilyCollection.cs
- PreviewPrintController.cs
- TypeDelegator.cs
- ValueQuery.cs
- EventLogEntryCollection.cs
- QuaternionRotation3D.cs
- MultipleViewPatternIdentifiers.cs
- LambdaCompiler.Logical.cs
- oledbconnectionstring.cs
- Triplet.cs
- MonthChangedEventArgs.cs
- ToolBarTray.cs
- SpeechAudioFormatInfo.cs
- XmlSchemaDocumentation.cs
- AlgoModule.cs
- Paragraph.cs
- CompleteWizardStep.cs
- TextTreeRootNode.cs
- BamlRecordHelper.cs
- Activity.cs
- KeyValueConfigurationCollection.cs
- HttpProfileBase.cs
- FilterException.cs
- TypedTableBaseExtensions.cs
- EventWaitHandle.cs
- DynamicPropertyHolder.cs
- UnicodeEncoding.cs
- DataGridCell.cs
- CodeSnippetStatement.cs
- WebPartVerb.cs
- TextTreeTextElementNode.cs