C# StoreItemCollection.GetItems方法代码示例

        /// <summary>
        /// Helper function for generating the scripts for tables & constraints.
        /// </summary>
        /// <param name="itemCollection"></param>
        /// <returns></returns> 
        internal static List<string> CreateObjectsScript(StoreItemCollection itemCollection, bool returnWarnings)
        {
            var builder = new SqlDdlBuilder();

            // Iterate over the container.
            foreach (var container in itemCollection.GetItems<EntityContainer>())
            {
                // Generate create table statements.
                foreach (var set in container.BaseEntitySets)
                {
                    // If it is a type of entitySet, generate Create Table statements.
                    var entitySet = set as EntitySet;
                    if (entitySet != null)
                    {
                        builder.AppendCreateTable(entitySet);
                    }
                }

                // Generate Foreign Key constraints.
                foreach (var set in container.BaseEntitySets)
                {
                    // If it is association set, generate Foreign Key constraints.
                    var associationSet = set as AssociationSet;
                    if (associationSet != null)
                    {
                        builder.AppendCreateForeignKeys(associationSet);
                    }
                }
            }

            // Return the final command text.
            return builder.GetCommandText(returnWarnings);
        }

        public void ToStoreLegacyType_returns_legacy_type_for_EntityType()
        {
            const string ssdl =
                "<Schema Namespace='AdventureWorksModel.Store' Provider='System.Data.SqlClient' ProviderManifestToken='2008' xmlns='http://schemas.microsoft.com/ado/2009/11/edm/ssdl'>"
                +
                "  <EntityContainer Name='AdventureWorksModelStoreContainer'>" +
                "    <EntitySet Name='Entities' EntityType='AdventureWorksModel.Store.Entities' Schema='dbo' />" +
                "  </EntityContainer>" +
                "  <EntityType Name='Entities'>" +
                "    <Key>" +
                "      <PropertyRef Name='Id' />" +
                "    </Key>" +
                "    <Property Name='Id' Type='int' StoreGeneratedPattern='Identity' Nullable='false' />" +
                "    <Property Name='Name' Type='nvarchar(max)' Nullable='false' />" +
                "  </EntityType>" +
                "</Schema>";

            var storeItemCollection = Utils.CreateStoreItemCollection(ssdl);
            var legacyStoreItemCollection =
                new LegacyMetadata.StoreItemCollection(new[] { XmlReader.Create(new StringReader(ssdl)) });

            var entityTypeUsage =
                TypeUsage.CreateDefaultTypeUsage(storeItemCollection.GetItem<EntityType>("AdventureWorksModel.Store.Entities"));
            var legacyEntityTypeUsage =
                entityTypeUsage.ToLegacyStoreTypeUsage(legacyStoreItemCollection.GetItems<LegacyMetadata.EdmType>().ToArray());

            TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(legacyEntityTypeUsage, entityTypeUsage);
        }

        public EntityModelSchemaGenerator(StoreItemCollection storeItemCollection, string namespaceName, string modelEntityContainerName)
        {
            EDesignUtil.CheckArgumentNull(storeItemCollection, "storeItemCollection");
            EDesignUtil.CheckArgumentNull(namespaceName, "namespaceName");
            EDesignUtil.CheckArgumentNull(modelEntityContainerName, "modelEntityContainerName");

            var storeContainers = storeItemCollection.GetItems<EntityContainer>().ToArray();
            if (storeContainers.Length != 1)
            {
                throw EDesignUtil.SingleStoreEntityContainerExpected("storeItemCollection");
            }

            Initialize(
                storeContainers[0],
                storeItemCollection.GetItems<EdmFunction>().Where(f => f.IsFromProviderManifest == false &&
                                                                       f.IsComposableAttribute == true &&
                                                                       f.AggregateAttribute == false),
                namespaceName,
                modelEntityContainerName);
        }

 static IEnumerable<string> GenerateForeignKeys(StoreItemCollection storeItems)
 {
     foreach (var associationSet in storeItems.GetItems<EntityContainer>()[0].BaseEntitySets.OfType<AssociationSet>())
     {
         var result = new StringBuilder();
         ReferentialConstraint constraint = associationSet.ElementType.ReferentialConstraints.Single<ReferentialConstraint>();
         AssociationSetEnd end = associationSet.AssociationSetEnds[constraint.FromRole.Name];
         AssociationSetEnd end2 = associationSet.AssociationSetEnds[constraint.ToRole.Name];
         result.AppendFormat("ALTER TABLE {0}.{1} ADD FOREIGN KEY ({2}) REFERENCES {3}.{4}({5}){6};",
             SqlGenerator.QuoteIdentifier(MetadataHelpers.GetSchemaName(end2.EntitySet)),
             SqlGenerator.QuoteIdentifier(MetadataHelpers.GetTableName(end2.EntitySet)),
             string.Join(", ", constraint.ToProperties.Select(fk => SqlGenerator.QuoteIdentifier(fk.Name))),
             SqlGenerator.QuoteIdentifier(MetadataHelpers.GetSchemaName(end.EntitySet)),
             SqlGenerator.QuoteIdentifier(MetadataHelpers.GetTableName(end.EntitySet)),
             string.Join(", ", constraint.FromProperties.Select(pk => SqlGenerator.QuoteIdentifier(pk.Name))),
             end.CorrespondingAssociationEndMember.DeleteBehavior == OperationAction.Cascade ? " ON DELETE CASCADE" : string.Empty);
         yield return result.ToString();
     }
 }

        /// <summary>
        /// Main driver function.
        /// </summary>
        /// <param name="args"></param>
        public static void Generate(string outputFileName)
        {   
            //The following functions are omitted because they have counterparts in the BCL
            string[] omittedFunctions = new[]
            {
                "Sum", "Min", "Max", "Average", "Avg",
                "Count", "BigCount", 
                "Trim", "RTrim", "LTrim",
                "Concat", "Length", "Substring",
                "Replace", "IndexOf", "ToUpper", "ToLower",
                "Contains", "StartsWith", "EndsWith", "Year", "Month", "Day",
                "DayOfYear", "Hour", "Minute", "Second", "Millisecond", "CurrentDateTime", "CurrentDateTimeOffset",
                "CurrentUtcDateTime",
                "BitwiseAnd", "BitwiseOr", "BitwiseXor", "BitwiseNot",
                "Round", "Abs", "Power", "NewGuid",
                "Floor", "Ceiling",
            };

            //The following functions are omitted from SqlFunctions because they already exist in EntityFunctions
            string[] omittedSqlFunctions = new[]
            {
                "STDEV", "STDEVP", "VAR", "VARP", "COUNT_BIG",
                "Left", "Right", "Reverse", "GetTotalOffsetMinutes", 
                "TruncateTime", "CreateDateTime",
                "CreateDateTimeOffset", "CreateTime", "Add", "Diff",
                "Truncate", "SYSDATETIME", "SYSUTCDATETIME", "SYSDATETIMEOFFSET",
                "LEN", "LOWER", "UPPER", "NEWID", 
            };
                
            //Generate Sql Server function stubs
            String ssdl = @"<Schema Namespace='LinqFunctionStubsGenerator' Alias='Self' Provider='SampleEntityFrameworkProvider' ProviderManifestToken='2008' xmlns='http://schemas.microsoft.com/ado/2006/04/edm/ssdl'></Schema>";
            XmlReader[] xmlReaders = new XmlReader[1];
            xmlReaders[0] = XmlReader.Create(new StringReader(ssdl));

            StoreItemCollection storeItemCollection = new StoreItemCollection(xmlReaders);
            IEnumerable<EdmFunction> sqlFunctions = storeItemCollection.GetItems<EdmFunction>()
                .Where(f => f.NamespaceName == "SqlServer")
                .Where(f => !(omittedFunctions.Concat(omittedSqlFunctions)).Contains(f.Name, StringComparer.OrdinalIgnoreCase));

            FunctionStubFileWriter sqlStubsFileWriter = new FunctionStubFileWriter(sqlFunctions, GetFunctionNamingDictionary(), GetParameterNamingDictionary());
            sqlStubsFileWriter.GenerateToFile(outputFileName, "SampleEntityFrameworkProvider", "SampleSqlFunctions", "SqlServer", true);
        }

 static IEnumerable<string> GenerateTables(StoreItemCollection storeItems)
 {
     foreach (var entitySet in storeItems.GetItems<EntityContainer>()[0].BaseEntitySets.OfType<EntitySet>())
     {
         var result = new StringBuilder();
         var tableName = MetadataHelpers.GetTableName(entitySet);
         var schemaName = MetadataHelpers.GetSchemaName(entitySet);
         result.AppendFormat("CREATE TABLE {0}.{1} (", SqlGenerator.QuoteIdentifier(schemaName), SqlGenerator.QuoteIdentifier(tableName));
         result.AppendLine();
         result.Append("\t");
         result.Append(string.Join("," + Environment.NewLine + "\t", MetadataHelpers.GetProperties(entitySet.ElementType).Select(p => GenerateColumn(p))));
         result.Append(");");
         result.AppendLine();
         result.AppendFormat("ALTER TABLE {0}.{1} ADD PRIMARY KEY ({2});",
             SqlGenerator.QuoteIdentifier(schemaName),
             SqlGenerator.QuoteIdentifier(tableName),
             string.Join(", ", entitySet.ElementType.KeyMembers.Select(pk => SqlGenerator.QuoteIdentifier(pk.Name))));
         result.AppendLine();
         yield return result.ToString();
     }
 }

    protected override string DbCreateDatabaseScript(string providerManifestToken,
        StoreItemCollection storeItemCollection)
    {
      StringBuilder sql = new StringBuilder();

      sql.AppendLine("-- MySql script");
      sql.AppendLine("-- Created on " + DateTime.Now);

      if (serverVersion == null)
        serverVersion = new Version(providerManifestToken == null ? "5.5" : providerManifestToken);

      foreach (EntityContainer container in storeItemCollection.GetItems<EntityContainer>())
      {
        // now output the tables
        foreach (EntitySet es in container.BaseEntitySets.OfType<EntitySet>())
        {
          sql.Append(GetTableCreateScript(es));
        }

        // now output the foreign keys
        foreach (AssociationSet a in container.BaseEntitySets.OfType<AssociationSet>())
        {
          sql.Append(GetAssociationCreateScript(a.ElementType));
        }
      }

      return sql.ToString();
    }

            public EdmMapping(EntityModelSchemaGenerator mcGenerator, StoreItemCollection store)
            {
                DebugCheck.NotNull(mcGenerator);
                DebugCheck.NotNull(store);

                // Pull mapping xml out
                var mappingDoc = new XmlDocument();
                var mappingXml = new StringBuilder();

                using (var textWriter = new StringWriter(mappingXml))
                {
                    mcGenerator.WriteStorageMapping(new XmlTextWriter(textWriter));
                }

                mappingDoc.LoadXml(mappingXml.ToString());

                var entitySets = mcGenerator.EntityContainer.BaseEntitySets.OfType<EntitySet>();
                var associationSets = mcGenerator.EntityContainer.BaseEntitySets.OfType<AssociationSet>();
                var tableSets = store.GetItems<EntityContainer>().Single().BaseEntitySets.OfType<EntitySet>();

                this.EntityMappings = BuildEntityMappings(mappingDoc, entitySets, tableSets);
                this.ManyToManyMappings = BuildManyToManyMappings(mappingDoc, associationSets, tableSets);
            }

        public void ToLegacyStoreTypeUsage_returns_legacy_type_for_RowType()
        {
            const string ssdl =
                "<Schema Namespace='AdventureWorksModel.Store' Provider='System.Data.SqlClient' ProviderManifestToken='2008' xmlns='http://schemas.microsoft.com/ado/2009/11/edm/ssdl'>"
                +
                "  <Function Name='GetNames'>" +
                "    <ReturnType>" +
                "      <CollectionType>" +
                "        <RowType>" +
                "          <Property Name='FirstName' Type='nvarchar' Nullable='false' />" +
                "          <Property Name='LastName' Type='nvarchar' Nullable='false' />" +
                "        </RowType>" +
                "      </CollectionType>" +
                "    </ReturnType>" +
                "  </Function>" +
                "</Schema>";

            var storeItemCollection = Utils.CreateStoreItemCollection(ssdl);
            var legacyStoreItemCollection =
                new LegacyMetadata.StoreItemCollection(new[] { XmlReader.Create(new StringReader(ssdl)) });

            var rowTypeUsage =
                ((CollectionType)storeItemCollection
                                     .GetItems<EdmFunction>().Single(f => f.Name == "GetNames")
                                     .ReturnParameters[0].TypeUsage.EdmType).TypeUsage;

            var legacyRowTypeUsage =
                rowTypeUsage.ToLegacyStoreTypeUsage(
                    legacyStoreItemCollection.GetItems<LegacyMetadata.EdmType>().ToArray());

            TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(legacyRowTypeUsage, rowTypeUsage);
        }