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> /// API for checkin whether database exists or not. /// This will internally only check whether the file that the connection points to exists or not. /// Note: In case of SQLCE, timeout and storeItemCollection parameters are ignored. /// </summary> /// <param name="connection"> Connection </param> /// <param name="timeOut"> Timeout for internal commands. </param> /// <param name="storeItemCollection"> Item Collection. </param> /// <returns> Bool indicating whether database exists or not. </returns> protected override bool DbDatabaseExists(DbConnection connection, int? timeOut, StoreItemCollection storeItemCollection) { Check.NotNull(connection, "connection"); Check.NotNull(storeItemCollection, "storeItemCollection"); // Validate and cast the connection. ValidateConnection(connection); if (_isLocalProvider) { return CommonUtils.DatabaseExists(connection.DataSource); } else { Type rdpType; // If we are working with RDP, then we will need to invoke the APIs through reflection. var engine = RemoteProviderHelper.GetRemoteSqlCeEngine(connection.ConnectionString, out rdpType); Debug.Assert(engine != null); var mi = rdpType.GetMethod("FileExists", new[] { typeof(string), typeof(int?) }); Debug.Assert(mi != null); // We will pass 'timeout' to RDP, this will be used as timeout period for connecting and executing on TDSServer. return (bool)(mi.Invoke(engine, new object[] { connection.DataSource, timeOut })); } }
/// <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 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 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() }); }
/// <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; }
/// <summary> /// API for generating script for creating schema objects from the Store Item Collection. /// </summary> /// <param name="providerManifestToken"> Provider manifest </param> /// <param name="storeItemCollection"> Store items </param> /// <returns> T-SQL script for generating schema objects. </returns> protected override string DbCreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection) { Check.NotNull(providerManifestToken, "providerManifestToken"); Check.NotNull(storeItemCollection, "storeItemCollection"); // Call the helper for creating schema objects. return string.Concat(SqlDdlBuilder.CreateObjectsScript(storeItemCollection, true).ToArray()); }
//protected override string DbCreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection) //{ // throw new NotImplementedException(); //} protected override bool DbDatabaseExists(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection) { if (connection.Database == ":memory:") { return false; } return false; }
protected override void DbCreateDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection) { var sql = DdlBuilder.CreateObjectsScript(storeItemCollection); connection.Open(); using (var cmd = connection.CreateCommand()) { cmd.CommandText = sql; cmd.ExecuteNonQuery(); } }
public static string GenerateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection) { if (storeItemCollection == null) return string.Empty; var result = new StringBuilder(); result.Append(string.Join(Environment.NewLine, GenerateTables(storeItemCollection))); result.AppendLine(); result.Append(string.Join(Environment.NewLine, GenerateForeignKeys(storeItemCollection))); result.AppendLine(); return result.ToString(); }
/// <summary> /// API for deleting the database. /// In SQLCE case, this will translate to File.Delete() call. /// Note: Timeout and storeItemCollection parameters are ignored. /// </summary> /// <param name="connection"> </param> /// <param name="timeOut"> </param> /// <param name="storeItemCollection"> </param> protected override void DbDeleteDatabase(DbConnection connection, int? timeOut, StoreItemCollection storeItemCollection) { // Validate that connection is a SqlCeConnection. ValidateConnection(connection); // We don't support create/delete database operations inside a transaction as they can't be rolled back. if (InTransactionScope()) { throw ADP1.DeleteDatabaseNotAllowedWithinTransaction(); } // Throw an exception if connection is open. // We should not close the connection because user could have result sets/data readers associated with this connection. // Thus, it is users responsiblity to close the connection before calling delete database. // if (connection.State == ConnectionState.Open) { throw ADP1.DeleteDatabaseWithOpenConnection(); } if (_isLocalProvider) { CommonUtils.DeleteDatabase(connection.DataSource); } else { try { Type rdpType; // If we are working with RDP, then we will need to invoke the APIs through reflection. var engine = RemoteProviderHelper.GetRemoteSqlCeEngine(connection.ConnectionString, out rdpType); Debug.Assert(engine != null); // Invoke the required method on SqlCeEngine. var mi = rdpType.GetMethod("DeleteDatabaseWithError", new[] { typeof(string), typeof(int?) }); Debug.Assert(mi != null); // We will pass 'timeout' to RDP, this will be used as timeout period for connecting and executing on TDSServer. mi.Invoke(engine, new object[] { connection.DataSource, timeOut }); } catch (Exception e) { throw e.GetBaseException(); } } }
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; }
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(); } }
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(); } }
public static string DropObjects(StoreItemCollection itemCollection) { var builder = new SqlScripts(); foreach (var container in itemCollection.GetItems<EntityContainer>()) { var entitySets = container.BaseEntitySets.OfType<EntitySet>().OrderBy(s => s.Name); foreach (var associationSet in container.BaseEntitySets.OfType<AssociationSet>().OrderBy(s => s.Name)) { builder.AppendDropForeignKeys(associationSet); } foreach (var entitySet in container.BaseEntitySets.OfType<EntitySet>().OrderBy(s => s.Name)) { builder.AppendDropTable(entitySet); } } return builder.GetCommandText(); }
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 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 }); } }
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 }); } }
protected override string DbCreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection) { return ScriptBuilder.GenerateDatabaseScript(providerManifestToken, storeItemCollection); }
protected override void DbDeleteDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection) { base.DbDeleteDatabase(connection, commandTimeout, storeItemCollection); }
protected override string DbCreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection) { return DdlBuilder.CreateObjectsScript(storeItemCollection); }
private static Mock<MetadataWorkspace> CreateMetadataWorkspaceMock() { var storeItemCollection = new StoreItemCollection( GenericProviderFactory<DbProviderFactory>.Instance, new SqlProviderManifest("2008"), "System.Data.FakeSqlClient", "2008"); var metadataWorkspaceMock = new Mock<MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollection); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.CSpace)).Returns(true); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace)).Returns(true); return metadataWorkspaceMock; }
internal StorageMappingItemCollection( EdmItemCollection edmCollection, StoreItemCollection storeCollection, IEnumerable<XmlReader> xmlReaders, IList<string> filePaths) : base(DataSpace.CSSpace) { Init(edmCollection, storeCollection, xmlReaders, filePaths, true /*throwOnError*/); }
// <summary> // constructor that takes in a list of XmlReaders and creates metadata for mapping // in all the files. // </summary> // <param name="edmItemCollection"> The edm metadata collection that this mapping is to use </param> // <param name="storeItemCollection"> 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> // <param name="errors"> a list of errors for each file loaded </param> private StorageMappingItemCollection( EdmItemCollection edmItemCollection, StoreItemCollection storeItemCollection, IEnumerable<XmlReader> xmlReaders, IList<string> filePaths, out IList<EdmSchemaError> errors) : base(DataSpace.CSSpace) { DebugCheck.NotNull(edmItemCollection); DebugCheck.NotNull(storeItemCollection); DebugCheck.NotNull(xmlReaders); errors = Init(edmItemCollection, storeItemCollection, xmlReaders, filePaths, false /*throwOnError*/); }
public StorageMappingItemCollection( EdmItemCollection edmCollection, StoreItemCollection storeCollection, IEnumerable<XmlReader> xmlReaders) : base(DataSpace.CSSpace) { Check.NotNull(xmlReaders, "xmlReaders"); var composite = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); Init( edmCollection, storeCollection, composite.GetReaders(), // filter out duplicates composite.GetPaths(), true /* throwOnError*/); }
public StorageMappingItemCollection( EdmItemCollection edmCollection, StoreItemCollection storeCollection, params string[] filePaths) : base(DataSpace.CSSpace) { Check.NotNull(edmCollection, "edmCollection"); Check.NotNull(storeCollection, "storeCollection"); Check.NotNull(filePaths, "filePaths"); _edmCollection = edmCollection; _storeItemCollection = storeCollection; // Wrap the file paths in instances of the MetadataArtifactLoader class, which provides // an abstraction and a uniform interface over a diverse set of metadata artifacts. // MetadataArtifactLoader composite = null; List<XmlReader> readers = null; try { composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(filePaths, XmlConstants.CSSpaceSchemaExtension); readers = composite.CreateReaders(DataSpace.CSSpace); Init( edmCollection, storeCollection, readers, composite.GetPaths(DataSpace.CSSpace), true /*throwOnError*/); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } }
protected override bool DbDatabaseExists(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection) { throw new NotSupportedException("Checking database existence is not supported in NuoDB driver."); }
protected override void DbDeleteDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection) { throw new NotSupportedException("Deleting database is not supported in NuoDB driver."); }
// <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; }
/// <summary> /// Factory method that creates a <see cref="StorageMappingItemCollection" />. /// </summary> /// <param name="edmItemCollection"> /// The edm metadata collection to map. Must not be <c>null</c>. /// </param> /// <param name="storeItemCollection"> /// The store metadata collection to map. Must not be <c>null</c>. /// </param> /// <param name="xmlReaders"> /// MSL artifacts to load. Must not be <c>null</c>. /// </param> /// <param name="filePaths"> /// Paths to MSL artifacts. Used in error messages. Can be <c>null</c> in which case /// the base Uri of the XmlReader will be used as a path. /// </param> /// <param name="errors"> /// The collection of errors encountered while loading. /// </param> /// <returns> /// <see cref="EdmItemCollection" /> instance if no errors encountered. Otherwise <c>null</c>. /// </returns> public static StorageMappingItemCollection Create( EdmItemCollection edmItemCollection, StoreItemCollection storeItemCollection, IEnumerable<XmlReader> xmlReaders, IList<string> filePaths, out IList<EdmSchemaError> errors) { Check.NotNull(edmItemCollection, "edmItemCollection"); Check.NotNull(storeItemCollection, "storeItemCollection"); Check.NotNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentContainsNull(ref xmlReaders, "xmlReaders"); // filePaths is allowed to be null var storageMappingItemCollection = new StorageMappingItemCollection(edmItemCollection, storeItemCollection, xmlReaders, filePaths, out errors); return errors != null && errors.Count > 0 ? null : storageMappingItemCollection; }
private static StorageMappingItemCollection LoadMsl(EdmItemCollection edmItemCollection, StoreItemCollection storeItemCollection) { IList <EdmSchemaError> errors; return(StorageMappingItemCollection.Create( edmItemCollection, storeItemCollection, new[] { XDocument.Parse(Msl).CreateReader() }, null, out errors)); }