C# MetadataWorkspace.GetItems方法代码示例

        /// <summary>
        /// 
        /// </summary>
        /// <param name="metadataWorkspace"></param>
        /// <param name="entityContainer">Code first or DB first entityContainer</param>
        protected MapperBase(MetadataWorkspace metadataWorkspace, EntityContainer entityContainer)
        {
            MetadataWorkspace = metadataWorkspace;
            EntityContainer = entityContainer;

            var relations = MetadataWorkspace.GetItems(DataSpace.CSpace).OfType<AssociationType>();

            foreach (var associationType in relations)
            {
                foreach (var referentialConstraint in associationType.ReferentialConstraints)
                {
                    for (int i = 0; i < referentialConstraint.ToProperties.Count; ++i)
                    {
                        _fks[referentialConstraint.ToProperties[i]] = referentialConstraint.FromProperties[i];
                    }
                }
            }
        }

		// refs:
		// * http://romiller.com/2014/04/08/ef6-1-mapping-between-types-tables/
		// * http://blogs.msdn.com/b/appfabriccat/archive/2010/10/22/metadataworkspace-reference-in-wcf-services.aspx
		// * http://msdn.microsoft.com/en-us/library/system.data.metadata.edm.dataspace.aspx - describes meaning of OSpace etc
		// * http://stackoverflow.com/questions/22999330/mapping-from-iedmentity-to-clr

		internal IList<EnumReference> FindEnumReferences(MetadataWorkspace metadataWorkspace)
		{
			// Get the part of the model that contains info about the actual CLR types
			var objectItemCollection = ((ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace));
			// OSpace = Object Space

			var entities = metadataWorkspace.GetItems<EntityType>(DataSpace.OSpace);

			// find and return all the references to enum types
			var references = new List<EnumReference>();
			foreach (var entityType in entities)
			{
				var mappingFragment = FindSchemaMappingFragment(metadataWorkspace, entityType);

				// child types in TPH don't get mappings
				if (mappingFragment == null)
				{
					continue;
				}

				references.AddRange(ProcessEdmProperties(entityType.Properties, mappingFragment, objectItemCollection));
			}
			return references;
		}

        internal RelPropertyHelper(MetadataWorkspace ws, HashSet<RelProperty> interestingRelProperties)
        {
            _relPropertyMap = new Dictionary<EntityTypeBase, List<RelProperty>>();
            _interestingRelProperties = interestingRelProperties;

            foreach (RelationshipType relationshipType in ws.GetItems<RelationshipType>(DataSpace.CSpace))
            {
                ProcessRelationship(relationshipType);
            }
        }

 private static Type GetClrType(MetadataWorkspace metadata, ObjectItemCollection objectItemCollection, EntityTypeBase type)
 {
     return metadata
            .GetItems<EntityType>(DataSpace.OSpace)
            .Select(objectItemCollection.GetClrType)
            .Single(e => e.Name == type.Name);
 }

		private static EntitySetMapping FindStorageMapping(MetadataWorkspace metadata, EntitySet conceptualEntitySet)
		{
			// Find the mapping between conceptual and storage model for this entity set
			var entityContainerMappings = metadata.GetItems<EntityContainerMapping>(DataSpace.CSSpace);
			// CSSpace = Conceptual model to Storage model mappings
			if (entityContainerMappings.Count() != 1)
			{
				throw new EnumGeneratorException(string.Format("{0} EntityContainerMappings found.", entityContainerMappings.Count()));
			}
			var containerMapping = entityContainerMappings.Single();
			var mappings = containerMapping.EntitySetMappings.Where(s => s.EntitySet == conceptualEntitySet).ToList();
			if (mappings.Count() != 1)
			{
				throw new EnumGeneratorException(string.Format(
					"{0} EntitySetMappings found for entitySet '{1}'.", mappings.Count(), conceptualEntitySet.Name));
			}
			var mapping = mappings.Single();
			return mapping;
		}

		private static EntityType FindObjectSpaceEntityMetadata(MetadataWorkspace metadata, EntityType entityType)
		{
			// Get the entity type from the model that maps to the CLR type
			var entityTypes = metadata
				.GetItems<EntityType>(DataSpace.OSpace) // OSpace = Object Space
				.Where(e => e == entityType)
				.ToList();
			if (entityTypes.Count() != 1)
			{
				throw new EnumGeneratorException(string.Format("{0} entities of type {1} found in mapping.", entityTypes.Count(),
					entityType));
			}
			var entityMetadata = entityTypes.Single();
			return entityMetadata;
		}

		private static EntitySet FindConceptualEntity(MetadataWorkspace metadata, EntityType entityType)
		{
			var entityMetadata = FindObjectSpaceEntityMetadata(metadata, entityType);

			// Get the entity set that uses this entity type
			var containers = metadata
				.GetItems<EntityContainer>(DataSpace.CSpace); // CSpace = Conceptual model
			if (containers.Count() != 1)
			{
				throw new EnumGeneratorException(string.Format("{0} EntityContainer's found.", containers.Count()));
			}
			var container = containers.Single();

			var entitySets = container
				.EntitySets
				.Where(s => s.ElementType.Name == entityMetadata.Name)
				// doesn't seem to be possible to get at the Object-Conceptual mappings from the public API so match on name.
				.ToList();

			// Child types in Table-per-Hierarchy don't have any mappings defined as they don't add any new tables, so skip them.
			if (!entitySets.Any())
			{
				return null;
			}

			if (entitySets.Count() != 1)
			{
				throw new EnumGeneratorException(string.Format(
					"{0} EntitySet's found for element type '{1}'.", entitySets.Count(), entityMetadata.Name));
			}
			var entitySet = entitySets.Single();

			return entitySet;
		}

 private static void ForceViewGeneration(MetadataWorkspace workspace)
 {
     ReadOnlyCollection<EntityContainer> containers = workspace.GetItems<EntityContainer>(DataSpace.SSpace);
     Debug.Assert(containers.Count != 0, "no s space containers found");
     Debug.Assert(containers[0].BaseEntitySets.Count != 0, "no entity sets in the sspace container");
     workspace.GetCqtView(containers[0].BaseEntitySets[0]);
 }

 /// <summary>
 /// Gets all entity sets that participate as members for the specified <paramref name="associationType"/>.
 /// </summary>
 /// <param name="workspace">Workspace with metadata.</param>
 /// <param name="associationType">Type of assocation to check.</param>
 /// <param name="member">Member of association to check.</param>
 /// <returns>
 /// All <see cref="EntitySet"/> instances that are are on the <paramref name="member"/> role for 
 /// some association of <paramref name="associationType"/>.
 /// </returns>
 private static IEnumerable<EntitySet> GetEntitySetsWithAssociationSets(
     MetadataWorkspace workspace,
     RelationshipType associationType,
     RelationshipEndMember member)
 {
     Debug.Assert(workspace != null, "workspace != null");
     Debug.Assert(associationType != null, "associationType != null");
     Debug.Assert(member != null, "member != null");
     foreach (EntityContainer container in workspace.GetItems<EntityContainer>(DataSpace.CSpace))
     {
         foreach (AssociationSet associationSet in container.BaseEntitySets.OfType<AssociationSet>())
         {
             if (associationSet.ElementType == associationType)
             {
                 foreach (AssociationSetEnd end in associationSet.AssociationSetEnds)
                 {
                     if (end.CorrespondingAssociationEndMember == member)
                     {
                         yield return end.EntitySet;
                     }
                 }
             }
         }
     }
 }

 /// <summary>
 /// Gets all <see cref="EntitySet"/> instance that may hold an entity of type <paramref name="type"/>.
 /// </summary>
 /// <param name="workspace">Workspace with metadata.</param>
 /// <param name="type">Entity type to get entity sets for.</param>
 /// <returns>An enumeration of <see cref="EntitySet"/> instances that can hold <paramref name="type"/>.</returns>
 private static IEnumerable<EntitySet> GetEntitySetsForType(MetadataWorkspace workspace, EntityType type)
 {
     Debug.Assert(type != null, "type != null");
     Debug.Assert(workspace != null, "workspace != null");
     foreach (EntityContainer container in workspace.GetItems<EntityContainer>(DataSpace.CSpace))
     {
         foreach (EntitySet entitySet in container.BaseEntitySets.OfType<EntitySet>())
         {
             if (IsAssignableFrom(entitySet.ElementType, type))
             {
                 yield return entitySet;
             }
         }
     }
 }