// <summary> // Look up a type in the target data space based upon the fullName // </summary> // <param name="fullName"> fullName </param> // <param name="ignoreCase"> true for case-insensitive lookup </param> // <param name="typeUsage"> The type usage object to return </param> // <returns> True if the retrieval succeeded </returns> internal override bool TryGetTypeByName(string fullName, bool ignoreCase, out TypeUsage typeUsage) { typeUsage = null; Map map = null; // From ClrPerspective, we should not allow anything from SSpace. So make sure that the CSpace type does not // have the Target attribute if (MetadataWorkspace.TryGetMap(fullName, DataSpace.OSpace, ignoreCase, DataSpace.OCSpace, out map)) { // Check if it's primitive type, if so, then use the MetadataWorkspace to get the mapped primitive type if (map.EdmItem.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType) { // Reassign the variable with the provider primitive type, then create the type usage var primitiveType = MetadataWorkspace.GetMappedPrimitiveType( ((PrimitiveType)map.EdmItem).PrimitiveTypeKind, DataSpace.CSpace); if (primitiveType != null) { typeUsage = EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(primitiveType.PrimitiveTypeKind); } } else { Debug.Assert(((GlobalItem)map.EdmItem).DataSpace == DataSpace.CSpace); typeUsage = GetMappedTypeUsage(map); } } return(null != typeUsage); }
// <summary> // Given the type in the target space and the member name in the source space, // get the corresponding member in the target space // For e.g. consider a Conceptual Type Foo with a member bar and a CLR type // XFoo with a member YBar. If one has a reference to Foo one can // invoke GetMember(Foo,"YBar") to retrieve the member metadata for bar // </summary> // <param name="type"> The type in the target perspective </param> // <param name="memberName"> the name of the member in the source perspective </param> // <param name="ignoreCase"> true for case-insensitive lookup </param> // <param name="outMember"> returns the edmMember if a match is found </param> // <returns> true if a match is found, otherwise false </returns> internal override bool TryGetMember(StructuralType type, String memberName, bool ignoreCase, out EdmMember outMember) { outMember = null; Map map = null; if (MetadataWorkspace.TryGetMap(type, DataSpace.OCSpace, out map)) { var objectTypeMap = map as ObjectTypeMapping; if (objectTypeMap != null) { var objPropertyMapping = objectTypeMap.GetMemberMapForClrMember(memberName, ignoreCase); if (null != objPropertyMapping) { outMember = objPropertyMapping.EdmMember; return(true); } } } return(false); }
internal static bool TryDetermineCSpaceModelType(Type type, MetadataWorkspace workspace, out EdmType modelEdmType) { Debug.Assert(null != workspace); Type nonNullabelType = TypeSystem.GetNonNullableType(type); // make sure the workspace knows about T workspace.ImplicitLoadAssemblyForType(nonNullabelType, System.Reflection.Assembly.GetCallingAssembly()); ObjectItemCollection objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace); EdmType objectEdmType; if (objectItemCollection.TryGetItem <EdmType>(nonNullabelType.FullName, out objectEdmType)) { Map map; if (workspace.TryGetMap(objectEdmType, DataSpace.OCSpace, out map)) { ObjectTypeMapping objectMapping = (ObjectTypeMapping)map; modelEdmType = objectMapping.EdmType; return(true); } } modelEdmType = null; return(false); }