private MetadataWorkspace GetMetadataWorkspace()
{
MetadataWorkspace metadataWorkspace = System.Data.Mapping.MetadataWorkspaceUtilities.CreateMetadataWorkspace(this.ContextType);
metadataWorkspace.LoadFromAssembly(this.ContextType.Assembly);
return(metadataWorkspace);
}
// <summary>
// Performs o-space loading for the type and returns false if the type is not in the model.
// </summary>
internal bool TryUpdateEntitySetMappingsForType(Type entityType)
{
Debug.Assert(
entityType == ObjectContextTypeCache.GetObjectType(entityType), "Proxy type should have been converted to real type");
if (_entitySetMappingsCache.ContainsKey(entityType))
{
return(true);
}
// We didn't find the type on first look, but this could be because the o-space loading
// has not happened. So we try that, update our cached mappings, and try again.
var typeToLoad = entityType;
do
{
_workspace.LoadFromAssembly(typeToLoad.Assembly());
typeToLoad = typeToLoad.BaseType();
}while (typeToLoad != null &&
typeToLoad != typeof(Object));
lock (_entitySetMappingsUpdateLock)
{
if (_entitySetMappingsCache.ContainsKey(entityType))
{
return(true);
}
UpdateEntitySetMappings();
}
return(_entitySetMappingsCache.ContainsKey(entityType));
}
public static StructuralType GetEdmType(MetadataWorkspace workspace, Type clrType)
{
if (workspace == null)
{
throw new ArgumentNullException("workspace");
}
if (clrType == null)
{
throw new ArgumentNullException("clrType");
}
if (clrType.IsPrimitive || clrType == typeof(object))
{
return(null);
}
EdmType edmType = null;
do
{
if (!workspace.TryGetType(clrType.Name, clrType.Namespace, DataSpace.OSpace, out edmType))
{
workspace.LoadFromAssembly(clrType.Assembly);
workspace.TryGetType(clrType.Name, clrType.Namespace, DataSpace.OSpace, out edmType);
}
}while (edmType == null && (clrType = clrType.BaseType) != typeof(object) && clrType != null);
StructuralType result = null;
if (edmType != null && (edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType || edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType))
{
workspace.TryGetEdmSpaceType((StructuralType)edmType, out result);
}
return(result);
}
/// <summary>
/// Generates metadata for given item collection.
/// Fetches CLR models from given assembly.
/// </summary>
/// <param name="metadataWorkspace">The metadata workspace.</param>
/// <param name="modelAssembly">The model assembly.</param>
/// <param name="connectionString">The connection string.</param>
/// <returns></returns>
public static Metadata Generate(MetadataWorkspace metadataWorkspace, Assembly modelAssembly, string connectionString) {
metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
metadataWorkspace.LoadFromAssembly(modelAssembly);
var itemCollection = metadataWorkspace.GetItemCollection(DataSpace.CSpace);
var objectItemCollection = (ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace);
return Generate(metadataWorkspace, itemCollection, objectItemCollection, modelAssembly, connectionString);
}
partial void OnContextCreated()
{
try
{
MetadataWorkspace.LoadFromAssembly(Assembly.GetAssembly(typeof(BsoArchiveEntities)));
}
catch (Exception ex) { }
SavingChanges += new EventHandler(Entities_SavingChanges);
}
public static void InitializeMetadataWorkspace(TestContext testContext)
{
StringReader sr = new StringReader(testCsdl);
XmlReader reader = XmlReader.Create(sr);
metadataWorkspace = new MetadataWorkspace();
EdmItemCollection edmItemCollection = new EdmItemCollection(new XmlReader[] { reader });
metadataWorkspace.RegisterItemCollection(edmItemCollection);
metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
metadataWorkspace.LoadFromAssembly(Assembly.GetExecutingAssembly());
}
public static void InitializeMetadataWorkspace(TestContext testContext)
{
StringReader sr = new StringReader(testCsdl);
XmlReader reader = XmlReader.Create(sr);
metadataWorkspace = new MetadataWorkspace();
EdmItemCollection edmItemCollection = new EdmItemCollection(new XmlReader[] { reader });
metadataWorkspace.RegisterItemCollection(edmItemCollection);
metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
metadataWorkspace.LoadFromAssembly(Assembly.GetExecutingAssembly());
}
private static StructuralType GetEdmType(MetadataWorkspace workspace)
{
StructuralType objectSpaceType;
workspace.LoadFromAssembly(typeof(T).Assembly);
if (!workspace.TryGetItem <StructuralType>(typeof(T).FullName, DataSpace.OSpace, out objectSpaceType))
{
//throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Messages.UnableToFindMetadataForType, typeof(T)));
}
StructuralType edmSpaceType = workspace.GetEdmSpaceType(objectSpaceType);
return(edmSpaceType);
}
public void LoadFromAssembly_checks_only_given_assembly_for_views()
{
var mockCache = new Mock <IViewAssemblyCache>();
var workspace = new MetadataWorkspace(
() => new EdmItemCollection(Enumerable.Empty <XmlReader>()),
() => null,
() => null,
() => new ObjectItemCollection(mockCache.Object));
workspace.LoadFromAssembly(typeof(object).Assembly);
mockCache.Verify(m => m.CheckAssembly(typeof(object).Assembly, false), Times.Once());
}
/// <summary>
/// Retrieves the <see cref="System.Data.Entity.Core.Metadata.Edm.StructuralType"/> corresponding to the given CLR type (where the
/// type is an entity or complex type).
/// </summary>
/// <remarks>
/// If no mapping exists for <paramref name="clrType"/>, but one does exist for one of its base
/// types, we will return the mapping for the base type.
/// </remarks>
/// <param name="workspace">The <see cref="System.Data.Entity.Core.Metadata.Edm.MetadataWorkspace"/></param>
/// <param name="clrType">The CLR type</param>
/// <returns>The <see cref="System.Data.Entity.Core.Metadata.Edm.StructuralType"/> corresponding to that CLR type, or <c>null</c> if the Type
/// is not mapped.</returns>
public static StructuralType GetEdmType(MetadataWorkspace workspace, Type clrType)
{
if (workspace == null)
{
throw Error.ArgumentNull("workspace");
}
if (clrType == null)
{
throw Error.ArgumentNull("clrType");
}
if (clrType.IsPrimitive || clrType == typeof(object))
{
// want to avoid loading searching system assemblies for
// types we know aren't entity or complex types
return(null);
}
// We first locate the EdmType in "OSpace", which matches the name and namespace of the CLR type
EdmType edmType;
do
{
if (workspace.TryGetType(clrType.Name, clrType.Namespace, DataSpace.OSpace, out edmType))
{
continue;
}
// If EF could not find this type, it could be because it is not loaded into
// its current workspace. In this case, we explicitly load the assembly containing
// the CLR type and try again.
workspace.LoadFromAssembly(clrType.Assembly);
workspace.TryGetType(clrType.Name, clrType.Namespace, DataSpace.OSpace, out edmType);
} while (edmType == null && (clrType = clrType.BaseType) != typeof(object) && clrType != null);
// Next we locate the StructuralType from the EdmType.
// This 2-step process is necessary when the types CLR namespace does not match Edm namespace.
// Look at the EdmEntityTypeAttribute on the generated entity classes to see this Edm namespace.
StructuralType structuralType = null;
if (edmType != null &&
(edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType || edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType))
{
workspace.TryGetEdmSpaceType((StructuralType)edmType, out structuralType);
}
return(structuralType);
}
/// <summary>
/// Retrieves the <see cref="StructuralType"/> corresponding to the given CLR type (where the
/// type is an entity or complex type).
/// </summary>
/// <remarks>
/// If no mapping exists for <paramref name="clrType"/>, but one does exist for one of its base
/// types, we will return the mapping for the base type.
/// </remarks>
/// <param name="workspace">The <see cref="MetadataWorkspace"/></param>
/// <param name="clrType">The CLR type</param>
/// <returns>The <see cref="StructuralType"/> corresponding to that CLR type, or <c>null</c> if the Type
/// is not mapped.</returns>
public static StructuralType GetEdmType(MetadataWorkspace workspace, Type clrType)
{
if (workspace == null)
{
throw new ArgumentNullException("workspace");
}
if (clrType == null)
{
throw new ArgumentNullException("clrType");
}
if (clrType.IsPrimitive || clrType == typeof(object))
{
// want to avoid loading searching system assemblies for
// types we know aren't entity or complex types
return null;
}
// We first locate the EdmType in "OSpace", which matches the name and namespace of the CLR type
EdmType edmType = null;
do
{
if (!workspace.TryGetType(clrType.Name, clrType.Namespace, DataSpace.OSpace, out edmType))
{
// If EF could not find this type, it could be because it is not loaded into
// its current workspace. In this case, we explicitly load the assembly containing
// the CLR type and try again.
workspace.LoadFromAssembly(clrType.Assembly);
workspace.TryGetType(clrType.Name, clrType.Namespace, DataSpace.OSpace, out edmType);
}
}
while (edmType == null && (clrType = clrType.BaseType) != typeof(object) && clrType != null);
// Next we locate the StructuralType from the EdmType.
// This 2-step process is necessary when the types CLR namespace does not match Edm namespace.
// Look at the EdmEntityTypeAttribute on the generated entity classes to see this Edm namespace.
StructuralType structuralType = null;
if (edmType != null &&
(edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType || edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType))
{
workspace.TryGetEdmSpaceType((StructuralType)edmType, out structuralType);
}
return structuralType;
}
public static Metadata Generate(Assembly modelAssembly, string modelName)
{
var conceptualResource = modelAssembly.GetManifestResourceStream(modelName + ".csdl");
Debug.Assert(conceptualResource != null, "conceptualResource != null");
var conceptualReader = XmlReader.Create(conceptualResource);
var itemCollection = new EdmItemCollection(new[] { conceptualReader });
var objectItemCollection = new ObjectItemCollection();
var metadataWorkspace = new MetadataWorkspace(
() => itemCollection,
() => null,
() => null,
() => objectItemCollection
);
metadataWorkspace.LoadFromAssembly(modelAssembly);
return(Generate(metadataWorkspace, itemCollection, objectItemCollection, modelAssembly, modelName));
}
public static EntityType GetCSpacetype(Type currentType, MetadataWorkspace mdw)
{
mdw.LoadFromAssembly(currentType.Assembly);
EntityType ospaceEntityType = null;
StructuralType cspaceEntityType = null;
if (mdw.TryGetItem <EntityType>(
currentType.FullName, DataSpace.OSpace, out ospaceEntityType))
{
if (mdw.TryGetEdmSpaceType(ospaceEntityType,
out cspaceEntityType))
{
return(cspaceEntityType as EntityType);
}
}
return(null);
}
private static XDocument UpdateCSpaceOSpaceMapping(XDocument xDoc, Assembly assembly, String resourcePrefix)
{
String[] res;
if (resourcePrefix == "")
{
res = new string[] { "res://*/" };
}
else
{
var pre = "res://*/" + resourcePrefix;
res = new String[] { pre + ".csdl", pre + ".msl", pre + ".ssdl" };
}
var metadataWs = new MetadataWorkspace(
res,
new Assembly[] { assembly });
// force an OSpace load - UGH - this was hard to find.... need to create the object item collection before loading assembly
metadataWs.RegisterItemCollection(new ObjectItemCollection());
metadataWs.LoadFromAssembly(assembly);
return(UpdateCSpaceOSpaceMappingCore(xDoc, metadataWs));
}
public void LoadFromAssembly_checks_only_given_assembly_for_views()
{
var mockCache = new Mock<IViewAssemblyCache>();
var workspace = new MetadataWorkspace(
() => new EdmItemCollection(Enumerable.Empty<XmlReader>()),
() => null,
() => null,
() => new ObjectItemCollection(mockCache.Object));
workspace.LoadFromAssembly(typeof(object).Assembly);
mockCache.Verify(m => m.CheckAssembly(typeof(object).Assembly, false), Times.Once());
}
public void O_space_types_are_discovered_when_using_attribute_based_mapping()
{
var edmItemCollection = new EdmItemCollection(
new[]
{
XDocument.Load(
typeof(AttributeBasedOCLoading).Assembly.GetManifestResourceStream(
"System.Data.Entity.TestModels.TemplateModels.Schemas.MonsterModel.csdl")).CreateReader()
});
var storeItemCollection = new StoreItemCollection(
new[]
{
XDocument.Load(
typeof(AttributeBasedOCLoading).Assembly.GetManifestResourceStream(
"System.Data.Entity.TestModels.TemplateModels.Schemas.MonsterModel.ssdl")).CreateReader()
});
var storageMappingItemCollection = LoadMsl(
edmItemCollection, storeItemCollection, XDocument.Load(
typeof(AttributeBasedOCLoading).Assembly.GetManifestResourceStream(
"System.Data.Entity.TestModels.TemplateModels.Schemas.MonsterModel.msl")));
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
var assembly = BuildEntitiesAssembly(ObjectLayer);
workspace.LoadFromAssembly(assembly);
var oSpaceItems = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
// Sanity checks that types/relationships were actually found
// Entity types
var entityTypes = oSpaceItems
.OfType<EdmType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.EntityType)
.ToList();
Assert.Equal(
new[]
{
"BackOrderLine2Mm", "BackOrderLineMm", "BarcodeDetailMm", "BarcodeMm", "ComplaintMm", "ComputerDetailMm",
"ComputerMm", "CustomerInfoMm", "CustomerMm", "DiscontinuedProductMm", "DriverMm", "IncorrectScanMm",
"LastLoginMm", "LicenseMm", "LoginMm", "MessageMm", "OrderLineMm", "OrderMm", "OrderNoteMm",
"OrderQualityCheckMm", "PageViewMm", "PasswordResetMm", "ProductDetailMm", "ProductMm", "ProductPageViewMm",
"ProductPhotoMm", "ProductReviewMm", "ProductWebFeatureMm", "ResolutionMm", "RSATokenMm", "SmartCardMm",
"SupplierInfoMm", "SupplierLogoMm", "SupplierMm", "SuspiciousActivityMm"
},
entityTypes.Select(i => i.Name).OrderBy(n => n));
Assert.True(entityTypes.All(e => e.NamespaceName == "BuildMonsterModel"));
Assert.True(entityTypes.All(e => oSpaceItems.GetClrType((StructuralType)e).Assembly == assembly));
// Complex types
var complexTypes = oSpaceItems
.OfType<EdmType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.ComplexType)
.ToList();
Assert.Equal(
new[] { "AuditInfoMm", "ConcurrencyInfoMm", "ContactDetailsMm", "DimensionsMm", "PhoneMm" },
complexTypes.Select(i => i.Name).OrderBy(n => n));
Assert.True(complexTypes.All(e => e.NamespaceName == "BuildMonsterModel"));
Assert.True(complexTypes.All(e => oSpaceItems.GetClrType((StructuralType)e).Assembly == assembly));
// Enum types
var enumTypes = oSpaceItems
.OfType<EdmType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.EnumType)
.ToList();
Assert.Equal(
new[] { "LicenseStateMm", "PhoneTypeMm" },
enumTypes.Select(i => i.Name).OrderBy(n => n));
Assert.True(enumTypes.All(e => e.NamespaceName == "BuildMonsterModel"));
Assert.True(enumTypes.All(e => oSpaceItems.GetClrType((EnumType)e).Assembly == assembly));
// Associations
var associations = oSpaceItems
.OfType<AssociationType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.AssociationType)
.ToList();
Assert.Equal(
new[]
{
"Barcode_BarcodeDetail", "Barcode_IncorrectScanActual", "Barcode_IncorrectScanExpected", "Complaint_Resolution",
"Computer_ComputerDetail", "Customer_Complaints", "Customer_CustomerInfo", "Customer_Logins", "Customer_Orders",
"DiscontinuedProduct_Replacement", "Driver_License", "Husband_Wife", "LastLogin_SmartCard", "Login_LastLogin",
"Login_Orders", "Login_PageViews", "Login_PasswordResets", "Login_ReceivedMessages", "Login_RSAToken",
"Login_SentMessages", "Login_SmartCard", "Login_SuspiciousActivity", "Order_OrderLines", "Order_OrderNotes",
"Order_QualityCheck", "Product_Barcodes", "Product_OrderLines", "Product_ProductDetail", "Product_ProductPageViews",
"Product_ProductPhoto", "Product_ProductReview", "Products_Suppliers", "ProductWebFeature_ProductPhoto",
"ProductWebFeature_ProductReview", "Supplier_BackOrderLines", "Supplier_SupplierInfo", "Supplier_SupplierLogo"
},
associations.Select(i => i.Name).OrderBy(n => n));
Assert.True(associations.All(e => e.NamespaceName == "MonsterNamespace"));
}
private static void LoadAssemblyIntoWorkspace(MetadataWorkspace workspace, Assembly assembly)
{
workspace.LoadFromAssembly(assembly);
}
public static EntityType GetCSpacetype(Type currentType, MetadataWorkspace mdw)
{
mdw.LoadFromAssembly(currentType.Assembly);
EntityType ospaceEntityType = null;
StructuralType cspaceEntityType = null;
if (mdw.TryGetItem<EntityType>(
currentType.FullName, DataSpace.OSpace, out ospaceEntityType))
{
if (mdw.TryGetEdmSpaceType(ospaceEntityType,
out cspaceEntityType))
return cspaceEntityType as EntityType;
}
return null;
}
private bool SetEntityConnection(List<string> metadataPaths, EntityConnectionStringBuilder connStrBuilder)
{
// It's possible the metadata was specified in the original connection string, but we filtered out everything due to not being able to resolve it to anything.
// In that case, warnings have already been displayed to indicate which paths were removed, so no need to display another message.
if (metadataPaths.Count > 0)
{
try
{
// Get the connection first, because it might be needed to gather provider services information
DbConnection dbConnection = GetDbConnection(connStrBuilder);
MetadataWorkspace metadataWorkspace = new MetadataWorkspace(metadataPaths, _assemblies);
// Ensure that we have all of the item collections registered. If some of them are missing this will cause problems eventually if we need to
// execute a query to get detailed schema information, but that will be handled later. For now just register everything to prevent errors in the
// stack that would not be understood by the user in the designer at this point.
ItemCollection edmItemCollection;
ItemCollection storeItemCollection;
ItemCollection csItemCollection;
if (!metadataWorkspace.TryGetItemCollection(DataSpace.CSpace, out edmItemCollection))
{
edmItemCollection = new EdmItemCollection();
metadataWorkspace.RegisterItemCollection(edmItemCollection);
}
if (!metadataWorkspace.TryGetItemCollection(DataSpace.SSpace, out storeItemCollection))
{
return false;
}
if (!metadataWorkspace.TryGetItemCollection(DataSpace.CSSpace, out csItemCollection))
{
Debug.Assert(edmItemCollection != null && storeItemCollection != null, "edm and store ItemCollection should be populated already");
metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(edmItemCollection as EdmItemCollection, storeItemCollection as StoreItemCollection));
}
// Create an ObjectItemCollection beforehand so that we can load objects by-convention
metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
// Load OSpace metadata from all of the assemblies we know about
foreach (Assembly assembly in _assemblies)
{
metadataWorkspace.LoadFromAssembly(assembly);
}
if (dbConnection != null)
{
_entityConnection = new EntityConnection(metadataWorkspace, dbConnection);
return true;
}
// else the DbConnection could not be created and the error should have already been displayed
}
catch (Exception ex)
{
StringBuilder exceptionMessage = new StringBuilder();
exceptionMessage.AppendLine(Strings.Error_MetadataLoadError);
exceptionMessage.AppendLine();
exceptionMessage.Append(ex.Message);
ShowError(exceptionMessage.ToString());
}
}
return false;
}
private static void LoadAssemblyIntoWorkspace(MetadataWorkspace workspace, Assembly assembly)
{
workspace.LoadFromAssembly(assembly);
}