// <summary>
// Compiles eSQL <paramref name="functionDefinition" /> and returns <see cref="DbLambda" />.
// Guarantees type match of lambda variables and <paramref name="functionParameters" />.
// Passes thru all excepions coming from <see cref="CqlQuery" />.
// </summary>
internal static DbLambda CompileFunctionDefinition(
string functionDefinition,
IList<FunctionParameter> functionParameters,
EdmItemCollection edmItemCollection)
{
DebugCheck.NotNull(functionParameters);
DebugCheck.NotNull(edmItemCollection);
var perspective = new ModelPerspective(
new MetadataWorkspace(
() => edmItemCollection,
() => null,
() => null));
// Since we compile lambda expression and generate variables from the function parameter definitions,
// the returned DbLambda will contain variable types that match function parameter types.
var functionBody = CqlQuery.CompileQueryCommandLambda(
functionDefinition,
perspective,
null /* use default parser options */,
null /* parameters */,
functionParameters.Select(pInfo => pInfo.TypeUsage.Variable(pInfo.Name)));
Debug.Assert(functionBody != null, "functionBody != null");
return functionBody;
}
public static StorageMappingItemCollection GetStorageMappingItemCollection(
this XDocument model, out DbProviderInfo providerInfo)
{
DebugCheck.NotNull(model);
var edmItemCollection
= new EdmItemCollection(
new[]
{
model.Descendants(EdmXNames.Csdl.SchemaNames).Single().CreateReader()
});
var ssdlSchemaElement = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single();
providerInfo = new DbProviderInfo(
ssdlSchemaElement.ProviderAttribute(),
ssdlSchemaElement.ProviderManifestTokenAttribute());
var storeItemCollection
= new StoreItemCollection(
new[]
{
ssdlSchemaElement.CreateReader()
});
return new StorageMappingItemCollection(
edmItemCollection,
storeItemCollection,
new[] { new XElement(model.Descendants(EdmXNames.Msl.MappingNames).Single()).CreateReader() });
}
public void Prepare_returns_a_new_instance()
{
var objectQueryExecutionPlanFactory = new ObjectQueryExecutionPlanFactory(
Common.Internal.Materialization.MockHelper.CreateTranslator<object>());
var metadataWorkspace = new MetadataWorkspace();
var edmItemCollection = new EdmItemCollection();
metadataWorkspace.RegisterItemCollection(edmItemCollection);
metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
var fakeSqlProviderManifest = new FakeSqlProviderServices().GetProviderManifest("2008");
var storeItemCollection = new StoreItemCollection(FakeSqlProviderFactory.Instance, fakeSqlProviderManifest, "2008");
metadataWorkspace.RegisterItemCollection(storeItemCollection);
metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(edmItemCollection, storeItemCollection, Enumerable.Empty<XmlReader>()));
var fakeSqlConnection = new FakeSqlConnection();
fakeSqlConnection.ConnectionString = "foo";
var entityConnection = new EntityConnection(metadataWorkspace, fakeSqlConnection, false);
var objectContext = new ObjectContext(entityConnection);
var dbExpression = new DbNullExpression(TypeUsage.Create(fakeSqlProviderManifest.GetStoreTypes().First()));
var dbQueryCommandTree = new DbQueryCommandTree(metadataWorkspace, DataSpace.CSpace,
dbExpression, validate: false);
var parameters = new List<Tuple<ObjectParameter, QueryParameterExpression>>();
var objectQueryExecutionPlan = objectQueryExecutionPlanFactory.Prepare(objectContext, dbQueryCommandTree, typeof(object),
MergeOption.NoTracking, new Span(), parameters, aliasGenerator: null);
Assert.NotNull(objectQueryExecutionPlan);
}
/// <summary>
/// Recursively generates <see cref="MemberPath" />s for the members of the types stored in the <paramref name="extent" />.
/// </summary>
internal static MemberProjectionIndex Create(EntitySetBase extent, EdmItemCollection edmItemCollection)
{
// We generate the indices for the projected slots as we traverse the metadata.
var index = new MemberProjectionIndex();
GatherPartialSignature(index, edmItemCollection, new MemberPath(extent), false); // need not only keys
return index;
}
internal static void LoadAssembly(
Assembly assembly, bool loadReferencedAssemblies,
KnownAssembliesSet knownAssemblies, EdmItemCollection edmItemCollection, Action<String> logLoadMessage, ref object loaderCookie,
out Dictionary<string, EdmType> typesInLoading, out List<EdmItemError> errors)
{
Debug.Assert(
loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>,
"This is a bad loader cookie");
typesInLoading = null;
errors = null;
using (var lockedAssemblyCache = AquireLockedAssemblyCache())
{
var loadingData = new ObjectItemLoadingSessionData(
knownAssemblies, lockedAssemblyCache, edmItemCollection, logLoadMessage, loaderCookie);
LoadAssembly(assembly, loadReferencedAssemblies, loadingData);
loaderCookie = loadingData.LoaderCookie;
// resolve references to top level types (base types, navigation properties returns and associations, and complex type properties)
loadingData.CompleteSession();
if (loadingData.EdmItemErrors.Count == 0)
{
// do the validation for the all the new types
// Now, perform validation on all the new types
var validator = new EdmValidator();
validator.SkipReadOnlyItems = true;
validator.Validate(loadingData.TypesInLoading.Values, loadingData.EdmItemErrors);
// Update the global cache if there are no errors
if (loadingData.EdmItemErrors.Count == 0)
{
if (ObjectItemAssemblyLoader.IsAttributeLoader(loadingData.ObjectItemAssemblyLoaderFactory))
{
// we only cache items from the attribute loader globally, the
// items loaded by convention will change depending on the cspace
// provided. cspace will have a cache of it's own for assemblies
UpdateCache(lockedAssemblyCache, loadingData.AssembliesLoaded);
}
else if (loadingData.EdmItemCollection != null
&&
ObjectItemAssemblyLoader.IsConventionLoader(loadingData.ObjectItemAssemblyLoaderFactory))
{
UpdateCache(loadingData.EdmItemCollection, loadingData.AssembliesLoaded);
}
}
}
if (loadingData.TypesInLoading.Count > 0)
{
foreach (var edmType in loadingData.TypesInLoading.Values)
{
edmType.SetReadOnly();
}
}
// Update the out parameters once you are done with loading
typesInLoading = loadingData.TypesInLoading;
errors = loadingData.EdmItemErrors;
}
}
public void Pregenerated_views_are_found_for_EDMX_model()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(PregenContextEdmx.Csdl).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(PregenContextEdmx.Ssdl).CreateReader() });
IList<EdmSchemaError> errors;
var storageMappingItemCollection = StorageMappingItemCollection.Create(
edmItemCollection,
storeItemCollection,
new[] { XDocument.Parse(PregenContextEdmx.Msl).CreateReader() },
null,
out errors);
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
using (var context = new PregenContextEdmx(workspace))
{
var _ = context.Blogs.ToString(); // Trigger view loading
Assert.True(PregenContextEdmxViews.View0Accessed);
Assert.True(PregenContextEdmxViews.View1Accessed);
}
}
public void Code_first_built_complex_types_matches_som_loaded_complex_types()
{
var context = new ShopContext_v1();
var compiledModel = context.InternalContext.CodeFirstModel;
var builder = compiledModel.CachedModelBuilder.Clone();
var databaseMapping
= builder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping;
var itemCollection = new EdmItemCollection(databaseMapping.Model);
var complexTypes = databaseMapping.Model.ComplexTypes.ToList();
var somComplexTypes = itemCollection.GetItems<ComplexType>();
Assert.Equal(complexTypes.Count(), somComplexTypes.Count());
foreach (var complexType in complexTypes)
{
var somComplexType = somComplexTypes.Single(e => e.Name == complexType.Name);
Assert.Equal(complexType.NamespaceName, somComplexType.NamespaceName);
Assert.Equal(complexType.Identity, somComplexType.Identity);
Assert.Equal(complexType.Abstract, somComplexType.Abstract);
Assert.Equal(complexType.FullName, somComplexType.FullName);
Assert.Equal(complexType.Members.Count, somComplexType.Members.Count);
}
}
/// <summary>
/// Creates the MetadataWorkspace for the given context type and base context type.
/// </summary>
/// <param name="contextType">The type of the context.</param>
/// <param name="baseContextType">The base context type (DbContext or ObjectContext).</param>
/// <returns>The generated <see cref="System.Data.Entity.Core.Metadata.Edm.MetadataWorkspace"/></returns>
public static MetadataWorkspace CreateMetadataWorkspaceFromResources(Type contextType, Type baseContextType)
{
// get the set of embedded mapping resources for the target assembly and create
// a metadata workspace info for each group
var metadataResourcePaths = FindMetadataResources(contextType.Assembly);
var workspaceInfos = GetMetadataWorkspaceInfos(metadataResourcePaths);
// Search for the correct EntityContainer by name and if found, create
// a comlete MetadataWorkspace and return it
foreach (var workspaceInfo in workspaceInfos) {
var edmItemCollection = new EdmItemCollection(workspaceInfo.Csdl);
var currentType = contextType;
while (currentType != baseContextType && currentType != typeof (object)) {
EntityContainer container;
if (edmItemCollection.TryGetEntityContainer(currentType.Name, out container)) {
var store = new StoreItemCollection(workspaceInfo.Ssdl);
var mapping = new StorageMappingItemCollection(edmItemCollection, store, workspaceInfo.Msl);
var workspace = new MetadataWorkspace();
workspace.RegisterItemCollection(edmItemCollection);
workspace.RegisterItemCollection(store);
workspace.RegisterItemCollection(mapping);
workspace.RegisterItemCollection(new ObjectItemCollection());
return workspace;
}
currentType = currentType.BaseType;
}
}
return null;
}
private MemberDomainMap(
Dictionary<MemberPath, CellConstantSet> domainMap,
Dictionary<MemberPath, CellConstantSet> nonConditionDomainMap, EdmItemCollection edmItemCollection)
{
m_conditionDomainMap = domainMap;
m_nonConditionDomainMap = nonConditionDomainMap;
m_edmItemCollection = edmItemCollection;
}
public bool HaveSeenInCompatibleContext(object loaderCookie, EdmItemCollection itemCollection)
{
// a new "context" is only when we have not seen this assembly with an itemCollection that is non-null
// and we now have a non-null itemCollection, and we are not already in AttributeLoader mode.
return SeenWithEdmItemCollection ||
itemCollection == null ||
ObjectItemAssemblyLoader.IsAttributeLoader(loaderCookie);
}
public void StorageMappingItemCollection_Create_factory_method_throws_for_null_storeItemCollection()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(Csdl).CreateReader() });
IList<EdmSchemaError> errors;
Assert.Equal("storeItemCollection",
Assert.Throws<ArgumentNullException>(
() => StorageMappingItemCollection.Create(edmItemCollection, null, null, null, out errors)).ParamName);
}
public void CompileFunctionDefinition_uses_the_given_item_collection()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(ProductModel.CsdlWithFunctions).CreateReader() });
Assert.Equal(
"ProductModel.F_NoBody()",
((DbFunctionExpression)ExternalCalls.CompileFunctionDefinition(
"ProductModel.F_NoBody()",
new List<FunctionParameter>(),
edmItemCollection).Body).Function.Identity);
}
/// <summary>
/// Constrcutor to create an instance of DefaultObjectMappingItemCollection.
/// To start with we will create a Schema under which maps will be created.
/// </summary>
/// <param name="edmCollection"></param>
/// <param name="objectCollection"></param>
public DefaultObjectMappingItemCollection(
EdmItemCollection edmCollection,
ObjectItemCollection objectCollection)
: base(DataSpace.OCSpace)
{
Contract.Requires(edmCollection != null);
Contract.Requires(objectCollection != null);
m_edmCollection = edmCollection;
m_objectCollection = objectCollection;
LoadPrimitiveMaps();
}
/// <summary>
/// Constructor to create an instance of DefaultObjectMappingItemCollection.
/// To start with we will create a Schema under which maps will be created.
/// </summary>
/// <param name="edmCollection"> </param>
/// <param name="objectCollection"> </param>
public DefaultObjectMappingItemCollection(
EdmItemCollection edmCollection,
ObjectItemCollection objectCollection)
: base(DataSpace.OCSpace)
{
DebugCheck.NotNull(edmCollection);
DebugCheck.NotNull(objectCollection);
m_edmCollection = edmCollection;
m_objectCollection = objectCollection;
LoadPrimitiveMaps();
}
internal bool TryGetKnownAssembly(
Assembly assembly, object loaderCookie, EdmItemCollection itemCollection, out KnownAssemblyEntry entry)
{
if (!_assemblies.TryGetValue(assembly, out entry))
{
return false;
}
if (!entry.HaveSeenInCompatibleContext(loaderCookie, itemCollection))
{
return false;
}
return true;
}
public static MetadataWorkspace ToMetadataWorkspace(this DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(databaseMapping);
var itemCollection = new EdmItemCollection(databaseMapping.Model);
var storeItemCollection = new StoreItemCollection(databaseMapping.Database);
var storageMappingItemCollection = databaseMapping.ToStorageMappingItemCollection(itemCollection, storeItemCollection);
var workspace = new MetadataWorkspace(
() => itemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
new CodeFirstOSpaceLoader().LoadTypes(itemCollection, (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace));
return workspace;
}
// <summary>
// Constructor to create an instance of DefaultObjectMappingItemCollection.
// To start with we will create a Schema under which maps will be created.
// </summary>
public DefaultObjectMappingItemCollection(
EdmItemCollection edmCollection,
ObjectItemCollection objectCollection)
: base(DataSpace.OCSpace)
{
DebugCheck.NotNull(edmCollection);
DebugCheck.NotNull(objectCollection);
_edmCollection = edmCollection;
_objectCollection = objectCollection;
var cspaceTypes = _edmCollection.GetPrimitiveTypes();
foreach (var type in cspaceTypes)
{
var ospaceType = _objectCollection.GetMappedPrimitiveType(type.PrimitiveTypeKind);
Debug.Assert(ospaceType != null, "all primitive type must have been loaded");
AddInternalMapping(new ObjectTypeMapping(ospaceType, type), _clrTypeIndexes, _edmTypeIndexes);
}
}
public void Can_initialize_from_edm_model_and_items_set_read_only_and_added_to_collection()
{
var context = new ShopContext_v1();
var compiledModel = context.InternalContext.CodeFirstModel;
var builder = compiledModel.CachedModelBuilder.Clone();
var databaseMapping
= builder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping;
var itemCollection = new EdmItemCollection(databaseMapping.Model);
Assert.Equal(3.0, itemCollection.EdmVersion);
foreach (var globalItem in databaseMapping.Model.GlobalItems)
{
Assert.True(itemCollection.Contains(globalItem));
Assert.True(globalItem.IsReadOnly);
}
}
protected override void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
{
Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping cannot be null!");
// at the entry point of visitor, we setup the versions
Debug.Assert(
m_MappingVersion == storageEntityContainerMapping.StorageMappingItemCollection.MappingVersion,
"the original version and the mapping collection version are not the same");
m_MappingVersion = storageEntityContainerMapping.StorageMappingItemCollection.MappingVersion;
m_EdmItemCollection = storageEntityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
int index;
if (!AddObjectToSeenListAndHashBuilder(storageEntityContainerMapping, out index))
{
// if this has been add to the seen list, then just
return;
}
if (m_itemsAlreadySeen.Count > 1)
{
// this means user try another visit over SECM, this is allowed but all the previous visit all lost due to clean
// user can visit different SECM objects by using the same visitor to load the SECM object
Clean();
Visit(storageEntityContainerMapping);
return;
}
AddObjectStartDumpToHashBuilder(storageEntityContainerMapping, index);
#region Inner data visit
AddObjectContentToHashBuilder(storageEntityContainerMapping.Identity);
AddV2ObjectContentToHashBuilder(storageEntityContainerMapping.GenerateUpdateViews, m_MappingVersion);
base.Visit(storageEntityContainerMapping);
#endregion
AddObjectEndDumpToHashBuilder();
}
public void LoadTypes(EdmItemCollection edmItemCollection, ObjectItemCollection objectItemCollection)
{
DebugCheck.NotNull(edmItemCollection);
DebugCheck.NotNull(objectItemCollection);
foreach (var cSpaceType in edmItemCollection.OfType<EdmType>().Where(
t => t.BuiltInTypeKind == BuiltInTypeKind.EntityType
|| t.BuiltInTypeKind == BuiltInTypeKind.EnumType
|| t.BuiltInTypeKind == BuiltInTypeKind.ComplexType))
{
var clrType = cSpaceType.GetClrType();
if (clrType != null)
{
var oSpaceType = _typeFactory.TryCreateType(clrType, cSpaceType);
if (oSpaceType != null)
{
Debug.Assert(!_typeFactory.CspaceToOspace.ContainsKey(cSpaceType));
_typeFactory.CspaceToOspace.Add(cSpaceType, oSpaceType);
}
}
else
{
Debug.Assert(!(cSpaceType is EntityType || cSpaceType is ComplexType || cSpaceType is EnumType));
}
}
_typeFactory.CreateRelationships(edmItemCollection);
foreach (var resolve in _typeFactory.ReferenceResolutions)
{
resolve();
}
foreach (var edmType in _typeFactory.LoadedTypes.Values)
{
edmType.SetReadOnly();
}
objectItemCollection.AddLoadedTypes(_typeFactory.LoadedTypes);
objectItemCollection.OSpaceTypesLoaded = true;
}
public void GetItemCollection_on_both_C_and_S_space_using_item_collections_with_inconsistent_versions_throws_MetadataException()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection =
new StoreItemCollection(
new[]
{
XDocument.Parse(string.Format(CultureInfo.InvariantCulture, SsdlTemplate, XmlConstants.TargetNamespace_2))
.CreateReader()
});
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => null);
workspace.GetItemCollection(DataSpace.CSpace); // this sets up the MetadataWorkspace's expected schema version as the csdl version i.e. 3.0
Assert.Equal(
Resources.Strings.DifferentSchemaVersionInCollection("StoreItemCollection", 2.0, 3.0),
Assert.Throws<MetadataException>(() => workspace.GetItemCollection(DataSpace.SSpace)).Message);
}
public void Three_delegates_constructor_uses_given_delegates_and_sets_up_default_o_space_and_oc_mapping()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(_ssdlV3).CreateReader() });
var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection);
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
Assert.Same(storeItemCollection, workspace.GetItemCollection(DataSpace.SSpace));
Assert.Same(storageMappingItemCollection, workspace.GetItemCollection(DataSpace.CSSpace));
var objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
var ocMappingCollection = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace);
Assert.Same(objectItemCollection, ocMappingCollection.ObjectItemCollection);
Assert.Same(edmItemCollection, ocMappingCollection.EdmItemCollection);
}
public void EdmItemCollectionExtensions_CsdlVersion_returns_correct_result_for_known_Csdl_versions()
{
const string csdlTemplate = @"<Schema xmlns=""{0}"" Namespace=""ExampleModel"" />";
var csdlVersions =
new[]
{
new Tuple<Version, string>(new Version(1, 0, 0, 0), "http://schemas.microsoft.com/ado/2006/04/edm"),
new Tuple<Version, string>(new Version(1, 1, 0, 0), "http://schemas.microsoft.com/ado/2007/05/edm"),
new Tuple<Version, string>(new Version(2, 0, 0, 0), "http://schemas.microsoft.com/ado/2008/09/edm"),
new Tuple<Version, string>(new Version(3, 0, 0, 0), "http://schemas.microsoft.com/ado/2009/11/edm"),
};
foreach (var csdlVersion in csdlVersions)
{
var edmItemCollection = new EdmItemCollection(
new[]
{
XDocument.Parse(string.Format(csdlTemplate, csdlVersion.Item2)).CreateReader()
});
Assert.Equal(csdlVersion.Item1, edmItemCollection.CsdlVersion());
}
}
// <summary>
// Infer a Storage-layer EntityType name from a Conceptual-layer EntityType
// 1. If this is a root type, then we will use the EntitySet name.
// 2. If this is a derived type, then we will return the name of the EntitySet
// appended to the name of the EntityType.
// * NOTE: This is better than pluralization because this scales well for international users
// </summary>
internal static string GetStorageEntityTypeName(EntityType entityType, EdmItemCollection edm)
{
var storageEntityTypeName = String.Empty;
// First get the EntitySet name. Unfortunately the Metadata APIs don't have the ability to
// get an EntitySet from an EntityType, so we have to incur this perf hit.
var rootOrSelf = entityType.GetRootOrSelf();
foreach (var entitySet in edm.GetAllEntitySets())
{
if (rootOrSelf == entitySet.ElementType)
{
storageEntityTypeName = entitySet.Name;
}
}
Debug.Assert(!String.IsNullOrEmpty(storageEntityTypeName), "We didn't find an EntitySet for the EntityType " + entityType.Name);
if (entityType.IsDerivedType())
{
storageEntityTypeName = String.Format(CultureInfo.CurrentCulture, "{0}_{1}", storageEntityTypeName, entityType.Name);
}
return storageEntityTypeName;
}
private static StorageMappingItemCollection ToStorageMappingItemCollection(
this DbDatabaseMapping databaseMapping, EdmItemCollection itemCollection,
StoreItemCollection storeItemCollection)
{
Contract.Requires(databaseMapping != null);
Contract.Requires(itemCollection != null);
Contract.Requires(storeItemCollection != null);
var stringBuilder = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
stringBuilder, new XmlWriterSettings
{
Indent = true
}))
{
new MslSerializer().Serialize(databaseMapping, xmlWriter);
}
using (var xmlReader = XmlReader.Create(new StringReader(stringBuilder.ToString())))
{
return new StorageMappingItemCollection(itemCollection, storeItemCollection, new[] { xmlReader });
}
}
public static StorageMappingItemCollection ToStorageMappingItemCollection(
this DbDatabaseMapping databaseMapping, EdmItemCollection itemCollection,
StoreItemCollection storeItemCollection)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(itemCollection);
DebugCheck.NotNull(storeItemCollection);
var stringBuilder = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
stringBuilder, new XmlWriterSettings
{
Indent = true
}))
{
new MslSerializer().Serialize(databaseMapping, xmlWriter);
}
using (var xmlReader = XmlReader.Create(new StringReader(stringBuilder.ToString())))
{
return new StorageMappingItemCollection(itemCollection, storeItemCollection, new[] { xmlReader });
}
}
internal static WorkflowApplication CreateDatabaseScriptGenerationWorkflow(
SynchronizationContext syncContext,
Project project,
string artifactPath,
FileInfo workflowFileInfo,
string templatePath,
EdmItemCollection edmItemCollection,
string existingSsdl,
string existingMsl,
string databaseSchemaName,
string databaseName,
string providerInvariantName,
string providerConnectionString,
string providerManifestToken,
Version targetVersion,
Action<WorkflowApplicationCompletedEventArgs> workflowCompletedHandler,
Func<WorkflowApplicationUnhandledExceptionEventArgs, UnhandledExceptionAction> unhandledExceptionHandler)
{
// Inputs are specific to the workflow. No need to provide a strongly typed bag here
// because the workflow has to define these.
var inputs = new Dictionary<string, object>
{
{ EdmConstants.csdlInputName, edmItemCollection },
{ EdmConstants.existingSsdlInputName, existingSsdl },
{ EdmConstants.existingMslInputName, existingMsl }
};
// Initialize the AssemblyLoader. This will cache project/website references and proffer assembly
// references to the XamlSchemaContext as well as the OutputGeneratorActivities
var assemblyLoader = new DatabaseGenerationAssemblyLoader(project, VsUtils.GetVisualStudioInstallDir());
// Parameters can be used throughout the workflow. These are more ubiquitous than inputs and
// so they do not need to be defined ahead of time in the workflow.
var edmWorkflowSymbolResolver = new EdmParameterBag(
syncContext, assemblyLoader, targetVersion, providerInvariantName, providerManifestToken, providerConnectionString,
databaseSchemaName, databaseName, templatePath, artifactPath);
// Deserialize the XAML file into a Activity
Activity modelFirstWorkflowElement;
using (var stream = workflowFileInfo.OpenRead())
{
using (
var xamlXmlReader = new XamlXmlReader(XmlReader.Create(stream), new DatabaseGenerationXamlSchemaContext(assemblyLoader))
)
{
modelFirstWorkflowElement = ActivityXamlServices.Load(xamlXmlReader);
}
}
// Create a WorkflowInstance from the WorkflowElement and pass in the inputs
var workflowInstance = new WorkflowApplication(modelFirstWorkflowElement, inputs);
// Attach a SymbolResolver for external parameters; this is like the ParameterBag
var symbolResolver = new SymbolResolver();
symbolResolver.Add(typeof(EdmParameterBag).Name, edmWorkflowSymbolResolver);
workflowInstance.Extensions.Add(symbolResolver);
workflowInstance.Completed = workflowCompletedHandler;
workflowInstance.OnUnhandledException = unhandledExceptionHandler;
return workflowInstance;
}
// <summary>
// Explicit loading means that the user specifically asked us to load this assembly.
// We won't do any filtering, they "know what they are doing"
// </summary>
internal void ExplicitLoadFromAssembly(Assembly assembly, EdmItemCollection edmItemCollection, Action <String> logLoadMessage)
{
LoadAssemblyFromCache(assembly, false /*loadAllReferencedAssemblies*/, edmItemCollection, logLoadMessage);
}
public IEnumerable<KnownAssemblyEntry> GetEntries(object loaderCookie, EdmItemCollection itemCollection)
{
return _assemblies.Values.Where(e => e.HaveSeenInCompatibleContext(loaderCookie, itemCollection));
}
internal bool Contains(Assembly assembly, object loaderCookie, EdmItemCollection itemCollection)
{
KnownAssemblyEntry entry;
return TryGetKnownAssembly(assembly, loaderCookie, itemCollection, out entry);
}
internal ObjectItemLoadingSessionData(
KnownAssembliesSet knownAssemblies, LockedAssemblyCache lockedAssemblyCache, EdmItemCollection edmItemCollection,
Action <String> logLoadMessage, object loaderCookie)
{
Debug.Assert(
loaderCookie == null || loaderCookie is Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>,
"This is a bad loader cookie");
_typesInLoading = new Dictionary <string, EdmType>(StringComparer.Ordinal);
_errors = new List <EdmItemError>();
_knownAssemblies = knownAssemblies;
_lockedAssemblyCache = lockedAssemblyCache;
_edmItemCollection = edmItemCollection;
_loadMessageLogger = new LoadMessageLogger(logLoadMessage);
_cspaceToOspace = new Dictionary <EdmType, EdmType>();
_loaderFactory = (Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>)loaderCookie;
_originalLoaderCookie = loaderCookie;
if (_loaderFactory == ObjectItemConventionAssemblyLoader.Create &&
_edmItemCollection != null)
{
foreach (var entry in _knownAssemblies.GetEntries(_loaderFactory, edmItemCollection))
{
foreach (var type in entry.CacheEntry.TypesInAssembly.OfType <EdmType>())
{
if (Helper.IsEntityType(type))
{
var entityType = (ClrEntityType)type;
_cspaceToOspace.Add(_edmItemCollection.GetItem <StructuralType>(entityType.CSpaceTypeName), entityType);
}
else if (Helper.IsComplexType(type))
{
var complexType = (ClrComplexType)type;
_cspaceToOspace.Add(_edmItemCollection.GetItem <StructuralType>(complexType.CSpaceTypeName), complexType);
}
else if (Helper.IsEnumType(type))
{
var enumType = (ClrEnumType)type;
_cspaceToOspace.Add(_edmItemCollection.GetItem <EnumType>(enumType.CSpaceTypeName), enumType);
}
else
{
Debug.Assert(Helper.IsAssociationType(type));
_cspaceToOspace.Add(_edmItemCollection.GetItem <StructuralType>(type.FullName), type);
}
}
}
}
}
private bool LoadAssemblyFromCache(
Assembly assembly, bool loadReferencedAssemblies, EdmItemCollection edmItemCollection, Action <String> logLoadMessage)
{
// Code First already did type loading
if (OSpaceTypesLoaded)
{
return(true);
}
// If all the containers (usually only one) have the UseClrTypes annotation then use the Code First loader even
// when using an EDMX.
if (edmItemCollection != null)
{
var containers = edmItemCollection.GetItems <EntityContainer>();
if (containers.Any() &&
containers.All(
c => c.Annotations.Any(
a => a.Name == XmlConstants.UseClrTypesAnnotationWithPrefix &&
((string)a.Value).ToUpperInvariant() == "TRUE")))
{
lock (LoadAssemblyLock)
{
if (!OSpaceTypesLoaded)
{
new CodeFirstOSpaceLoader().LoadTypes(edmItemCollection, this);
Debug.Assert(OSpaceTypesLoaded);
}
return(true);
}
}
}
// Check if its loaded in the cache - if the call is for loading referenced assemblies, make sure that all referenced
// assemblies are also loaded
KnownAssemblyEntry entry;
if (_knownAssemblies.TryGetKnownAssembly(assembly, _loaderCookie, edmItemCollection, out entry))
{
// Proceed if only we need to load the referenced assemblies and they are not loaded
if (loadReferencedAssemblies == false)
{
// don't say we loaded anything, unless we actually did before
return(entry.CacheEntry.TypesInAssembly.Count != 0);
}
else if (entry.ReferencedAssembliesAreLoaded)
{
// this assembly was part of a all hands reference search
return(true);
}
}
lock (LoadAssemblyLock)
{
// Check after acquiring the lock, since the known assemblies might have got modified
// Check if the assembly is already loaded. The reason we need to check if the assembly is already loaded, is that
if (_knownAssemblies.TryGetKnownAssembly(assembly, _loaderCookie, edmItemCollection, out entry))
{
// Proceed if only we need to load the referenced assemblies and they are not loaded
if (loadReferencedAssemblies == false ||
entry.ReferencedAssembliesAreLoaded)
{
return(true);
}
}
Dictionary <string, EdmType> typesInLoading;
List <EdmItemError> errors;
var knownAssemblies = new KnownAssembliesSet(_knownAssemblies);
// Load the assembly from the cache
AssemblyCache.LoadAssembly(
assembly, loadReferencedAssemblies, knownAssemblies, edmItemCollection, logLoadMessage,
ref _loaderCookie, out typesInLoading, out errors);
// Throw if we have encountered errors
if (errors.Count != 0)
{
throw EntityUtil.InvalidSchemaEncountered(Helper.CombineErrorMessage(errors));
}
// We can encounter new assemblies, but they may not have any time in them
if (typesInLoading.Count != 0)
{
// No errors, so go ahead and add the types and make them readonly
// The existence of the loading lock tells us whether we should be thread safe or not, if we need
// to be thread safe. We don't need to actually use the lock because the caller should have done
// it already.
// Recheck the assemblies added, another list is created just to match up the collection type
// taken in by AddRange()
AddLoadedTypes(typesInLoading);
}
// Update the value of known assemblies
_knownAssemblies = knownAssemblies;
return(typesInLoading.Count != 0);
}
}
public IEnumerable <KnownAssemblyEntry> GetEntries(object loaderCookie, EdmItemCollection itemCollection)
{
return(_assemblies.Values.Where(e => e.HaveSeenInCompatibleContext(loaderCookie, itemCollection)));
}
// <summary>
// Initializer that takes in a list of XmlReaders and creates metadata for mapping
// in all the files.
// </summary>
// <param name="edmCollection"> The edm metadata collection that this mapping is to use </param>
// <param name="storeCollection"> The store metadata collection that this mapping is to use </param>
// <param name="xmlReaders"> The XmlReaders to load mapping from </param>
// <param name="filePaths"> Mapping URIs </param>
private IList<EdmSchemaError> Init(
EdmItemCollection edmCollection,
StoreItemCollection storeCollection,
IEnumerable<XmlReader> xmlReaders,
IList<string> filePaths,
bool throwOnError)
{
DebugCheck.NotNull(xmlReaders);
DebugCheck.NotNull(edmCollection);
DebugCheck.NotNull(storeCollection);
_edmCollection = edmCollection;
_storeItemCollection = storeCollection;
Dictionary<EntitySetBase, GeneratedView> userDefinedQueryViewsDict;
Dictionary<OfTypeQVCacheKey, GeneratedView> userDefinedQueryViewsOfTypeDict;
m_viewDictionary = new ViewDictionary(this, out userDefinedQueryViewsDict, out userDefinedQueryViewsOfTypeDict);
var errors = new List<EdmSchemaError>();
if (_edmCollection.EdmVersion != XmlConstants.UndefinedVersion
&& _storeItemCollection.StoreSchemaVersion != XmlConstants.UndefinedVersion
&& _edmCollection.EdmVersion != _storeItemCollection.StoreSchemaVersion)
{
errors.Add(
new EdmSchemaError(
Strings.Mapping_DifferentEdmStoreVersion,
(int)MappingErrorCode.MappingDifferentEdmStoreVersion, EdmSchemaErrorSeverity.Error));
}
else
{
var expectedVersion = _edmCollection.EdmVersion != XmlConstants.UndefinedVersion
? _edmCollection.EdmVersion
: _storeItemCollection.StoreSchemaVersion;
errors.AddRange(
LoadItems(xmlReaders, filePaths, userDefinedQueryViewsDict, userDefinedQueryViewsOfTypeDict, expectedVersion));
}
Debug.Assert(errors != null);
if (errors.Count > 0 && throwOnError)
{
if (!MetadataHelper.CheckIfAllErrorsAreWarnings(errors))
{
// NOTE: not using Strings.InvalidSchemaEncountered because it will truncate the errors list.
throw new MappingException(
String.Format(
CultureInfo.CurrentCulture,
EntityRes.GetString(EntityRes.InvalidSchemaEncountered),
Helper.CombineErrorMessage(errors)));
}
}
return errors;
}
internal bool Contains(Assembly assembly, object loaderCookie, EdmItemCollection itemCollection)
{
KnownAssemblyEntry entry;
return(TryGetKnownAssembly(assembly, loaderCookie, itemCollection, out entry));
}
