/// <summary> /// Checks for each property to be non-null and then adds it to the member collection /// </summary> /// <param name="members">members for this type</param> /// <param name="entityType">the membersCollection to which the members should be added</param> internal static void CheckAndAddMembers(IEnumerable <EdmMember> members, EntityType entityType) { foreach (EdmMember member in members) { // Check for each property to be non-null if (null == member) { throw EntityUtil.CollectionParameterElementIsNull("members"); } // Add the property to the member collection entityType.AddMember(member); } }
/// <summary> /// Helper method that wraps a collection of XmlReader objects in MetadataArtifactLoader /// instances. /// </summary> /// <param name="filePaths">The collection of XmlReader objects to wrap</param> /// <returns>An instance of MetadataArtifactLoader</returns> public static MetadataArtifactLoader CreateCompositeFromXmlReaders(IEnumerable <XmlReader> xmlReaders) { List <MetadataArtifactLoader> loaders = new List <MetadataArtifactLoader>(); foreach (XmlReader reader in xmlReaders) { if (reader == null) { throw EntityUtil.CollectionParameterElementIsNull("xmlReaders"); } loaders.Add(new MetadataArtifactLoaderXmlReaderWrapper(reader)); } return(MetadataArtifactLoader.Create(loaders)); }
/// <summary> /// The constructor for constructing the collection with the given items /// </summary> /// <param name="items">The items to populate the collection</param> internal MetadataCollection(IEnumerable <T> items) { _collectionData = new CollectionData(); if (items != null) { foreach (T item in items) { if (item == null) { throw EntityUtil.CollectionParameterElementIsNull("items"); } Debug.Assert(!String.IsNullOrEmpty(item.Identity), "Identity of the item must never be null or empty"); AddInternal(item); } } }
/// <summary> /// Checks for each key member to be non-null /// also check for it to be present in the members collection /// and then adds it to the KeyMembers collection. /// /// Throw if the key member is not already in the members /// collection. Cannot do much other than that as the /// Key members is just an Ienumerable of the names /// of the members. /// </summary> /// <param name="keyMembers">the list of keys (member names) to be added for the given type</param> internal void CheckAndAddKeyMembers(IEnumerable <String> keyMembers) { foreach (string keyMember in keyMembers) { // Check for each keymember to be non-null if (null == keyMember) { throw EntityUtil.CollectionParameterElementIsNull("keyMembers"); } // Check for whether the key exists in the members collection EdmMember member; if (!Members.TryGetValue(keyMember, false, out member)) { throw EntityUtil.Argument(System.Data.Entity.Strings.InvalidKeyMember(keyMember)); //--- to do, identify the right exception to throw here } // Add the key member to the key member collection AddKeyMember(member); } }
private static IEnumerable <EdmProperty> CheckProperties(IEnumerable <EdmProperty> properties) { if (null != properties) { int i = 0; foreach (EdmProperty prop in properties) { if (prop == null) { throw EntityUtil.CollectionParameterElementIsNull("properties"); } i++; } /* * if (i < 1) * { * throw EntityUtil.ArgumentOutOfRange("properties"); * } */ } return(properties); }
internal EdmFunction(string name, string namespaceName, DataSpace dataSpace, EdmFunctionPayload payload) : base(name, namespaceName, dataSpace) { //---- name of the 'schema' //---- this is used by the SQL Gen utility and update pipeline to support generation of the correct function name in the store _schemaName = payload.Schema; _fullName = this.NamespaceName + "." + this.Name; FunctionParameter[] returnParameters = payload.ReturnParameters; Debug.Assert(returnParameters.All((returnParameter) => returnParameter != null), "All return parameters must be non-null"); Debug.Assert(returnParameters.All((returnParameter) => returnParameter.Mode == ParameterMode.ReturnValue), "Return parameter in a function must have the ParameterMode equal to ReturnValue."); _returnParameters = new ReadOnlyMetadataCollection <FunctionParameter>( returnParameters .Select((returnParameter) => SafeLink <EdmFunction> .BindChild <FunctionParameter>(this, FunctionParameter.DeclaringFunctionLinker, returnParameter)) .ToList()); if (payload.IsAggregate.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.Aggregate, payload.IsAggregate.Value); } if (payload.IsBuiltIn.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.BuiltIn, payload.IsBuiltIn.Value); } if (payload.IsNiladic.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.NiladicFunction, payload.IsNiladic.Value); } if (payload.IsComposable.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsComposable, payload.IsComposable.Value); } if (payload.IsFromProviderManifest.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsFromProviderManifest, payload.IsFromProviderManifest.Value); } if (payload.IsCachedStoreFunction.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsCachedStoreFunction, payload.IsCachedStoreFunction.Value); } if (payload.IsFunctionImport.HasValue) { SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsFunctionImport, payload.IsFunctionImport.Value); } if (payload.ParameterTypeSemantics.HasValue) { _parameterTypeSemantics = payload.ParameterTypeSemantics.Value; } if (payload.StoreFunctionName != null) { _storeFunctionNameAttribute = payload.StoreFunctionName; } if (payload.EntitySets != null) { Debug.Assert(_returnParameters.Count == payload.EntitySets.Length, "The number of entity sets should match the number of return parameters"); _entitySets = new ReadOnlyMetadataCollection <EntitySet>(payload.EntitySets); } else { var list = new List <EntitySet>(); if (_returnParameters.Count != 0) { Debug.Assert(_returnParameters.Count == 1, "If there was more than one result set payload.EntitySets should not have been null"); list.Add(null); } _entitySets = new ReadOnlyMetadataCollection <EntitySet>(list); } if (payload.CommandText != null) { _commandTextAttribute = payload.CommandText; } if (payload.Parameters != null) { // validate the parameters foreach (FunctionParameter parameter in payload.Parameters) { if (parameter == null) { throw EntityUtil.CollectionParameterElementIsNull("parameters"); } Debug.Assert(parameter.Mode != ParameterMode.ReturnValue, "No function parameter can have ParameterMode equal to ReturnValue."); } // Populate the parameters _parameters = new SafeLinkCollection <EdmFunction, FunctionParameter>(this, FunctionParameter.DeclaringFunctionLinker, new MetadataCollection <FunctionParameter>(payload.Parameters)); } else { _parameters = new ReadOnlyMetadataCollection <FunctionParameter>(new MetadataCollection <FunctionParameter>()); } }