1 //------------------------------------------------------------------------------ 2 // <copyright file="EntityUtil.cs" company="Microsoft"> 3 // Copyright (c) Microsoft Corporation. All rights reserved. 4 // </copyright> 5 // <owner current="true" primary="true">Microsoft</owner> 6 //------------------------------------------------------------------------------ 7 8 namespace System.Data { 9 10 using System; 11 using System.Collections; 12 using System.Collections.Generic; 13 using System.Data.Common; 14 using System.Data.Entity; 15 using System.Data.Mapping; 16 using System.Data.Metadata.Edm; 17 using System.Data.Objects; 18 using System.Data.Objects.Internal; 19 using System.Data.SqlTypes; 20 using System.Diagnostics; 21 using System.Diagnostics.CodeAnalysis; 22 using System.Globalization; 23 using System.IO; 24 using System.Linq; 25 using System.Reflection; 26 using System.Runtime.Versioning; 27 using System.Security.Permissions; 28 using System.Text; 29 30 internal static class EntityUtil { 31 32 internal const int AssemblyQualifiedNameIndex = 3; 33 internal const int InvariantNameIndex = 2; 34 35 internal const string Parameter = "Parameter"; 36 37 internal const CompareOptions StringCompareOptions = CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase; 38 39 internal static bool? ThreeValuedNot(bool? operand) { 40 // three-valued logic 'not' (T = true, F = false, U = unknown) 41 // !T = F 42 // !F = T 43 // !U = U 44 return operand.HasValue ? !operand.Value : (bool?)null; 45 } 46 internal static bool? ThreeValuedAnd(bool? left, bool? right) { 47 // three-valued logic 'and' (T = true, F = false, U = unknown) 48 // 49 // T & T = T 50 // T & F = F 51 // F & F = F 52 // F & T = F 53 // F & U = F 54 // U & F = F 55 // T & U = U 56 // U & T = U 57 // U & U = U 58 bool? result; 59 if (left.HasValue && right.HasValue) { 60 result = left.Value && right.Value; 61 } 62 else if (!left.HasValue && !right.HasValue) { 63 result = null; // unknown 64 } 65 else if (left.HasValue) { 66 result = left.Value ? 67 (bool?)null :// unknown 68 false; 69 } 70 else { 71 result = right.Value ? 72 (bool?)null : 73 false; 74 } 75 return result; 76 } 77 78 internal static bool? ThreeValuedOr(bool? left, bool? right) { 79 // three-valued logic 'or' (T = true, F = false, U = unknown) 80 // 81 // T | T = T 82 // T | F = T 83 // F | F = F 84 // F | T = T 85 // F | U = U 86 // U | F = U 87 // T | U = T 88 // U | T = T 89 // U | U = U 90 bool? result; 91 if (left.HasValue && right.HasValue) { 92 result = left.Value || right.Value; 93 } 94 else if (!left.HasValue && !right.HasValue) { 95 result = null; // unknown 96 } 97 else if (left.HasValue) { 98 result = left.Value ? 99 true : 100 (bool?)null; // unknown 101 } 102 else { 103 result = right.Value ? 104 true : 105 (bool?)null; // unknown 106 } 107 return result; 108 } 109 110 /// <summary> 111 /// Zips two enumerables together (e.g., given {1, 3, 5} and {2, 4, 6} returns {{1, 2}, {3, 4}, {5, 6}}) 112 /// </summary> Zip(this IEnumerable<T1> first, IEnumerable<T2> second)113 internal static IEnumerable<KeyValuePair<T1, T2>> Zip<T1, T2>(this IEnumerable<T1> first, IEnumerable<T2> second) 114 { 115 if (null == first || null == second) { yield break; } 116 using (IEnumerator<T1> firstEnumerator = first.GetEnumerator()) 117 using (IEnumerator<T2> secondEnumerator = second.GetEnumerator()) 118 { 119 while (firstEnumerator.MoveNext() && secondEnumerator.MoveNext()) 120 { 121 yield return new KeyValuePair<T1, T2>(firstEnumerator.Current, secondEnumerator.Current); 122 } 123 } 124 } 125 126 /// <summary> 127 /// Returns true if the type implements ICollection<> 128 /// </summary> IsAnICollection(Type type)129 internal static bool IsAnICollection(Type type) 130 { 131 return typeof(ICollection<>).IsAssignableFrom(type.GetGenericTypeDefinition()) || 132 type.GetInterface(typeof(ICollection<>).FullName) != null; 133 134 } 135 136 /// <summary> 137 /// Given a type that represents a collection, determine if the type implements ICollection<>, and if 138 /// so return the element type of the collection. Currently, if the collection implements ICollection<> 139 /// multiple times with different types, then we will return false since this is not supported. 140 /// </summary> 141 /// <param name="collectionType">the collection type to examine</param> 142 /// <param name="elementType">the type of element</param> 143 /// <returns>true if the collection implement ICollection<> false otherwise</returns> TryGetICollectionElementType(Type collectionType, out Type elementType)144 internal static bool TryGetICollectionElementType(Type collectionType, out Type elementType) 145 { 146 elementType = null; 147 // We have to check if the type actually is the interface, or if it implements the interface: 148 try 149 { 150 Type collectionInterface = 151 (collectionType.IsGenericType && typeof(ICollection<>).IsAssignableFrom(collectionType.GetGenericTypeDefinition())) ? 152 collectionType : 153 collectionType.GetInterface(typeof(ICollection<>).FullName); 154 155 // We need to make sure the type is fully specified otherwise we won't be able to add element to it. 156 if (collectionInterface != null && !collectionInterface.ContainsGenericParameters) 157 { 158 elementType = collectionInterface.GetGenericArguments()[0]; 159 return true; 160 } 161 162 } 163 catch (AmbiguousMatchException) 164 { 165 // Thrown if collection type implements ICollection<> more than once 166 } 167 return false; 168 } 169 170 /// <summary> 171 /// Helper method to determine the element type of the collection contained by the given property. 172 /// If an unambiguous element type cannot be found, then an InvalidOperationException is thrown. 173 /// </summary> GetCollectionElementType(Type propertyType)174 internal static Type GetCollectionElementType(Type propertyType) 175 { 176 Type elementType; 177 if (!EntityUtil.TryGetICollectionElementType(propertyType, out elementType)) 178 { 179 throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.PocoEntityWrapper_UnexpectedTypeForNavigationProperty( 180 propertyType.FullName, 181 typeof(ICollection<>))); 182 } 183 return elementType; 184 } 185 186 /// <summary> 187 /// This is used when we need to determine a concrete collection type given some type that may be 188 /// abstract or an interface. 189 /// </summary> 190 /// <remarks> 191 /// The rules are: 192 /// If the collection is defined as a concrete type with a publicly accessible parameterless constructor, then create an instance of that type 193 /// Else, if HashSet<T> can be assigned to the type, then use HashSet<T> 194 /// Else, if List<T> can be assigned to the type, then use List<T> 195 /// Else, throw a nice exception. 196 /// </remarks> 197 /// <param name="requestedType">The type of collection that was requested</param> 198 /// <returns>The type to instantiate, or null if we cannot find a supported type to instantiate</returns> DetermineCollectionType(Type requestedType)199 internal static Type DetermineCollectionType(Type requestedType) 200 { 201 const BindingFlags constructorBinding = BindingFlags.Public | BindingFlags.Instance | BindingFlags.CreateInstance; 202 203 var elementType = EntityUtil.GetCollectionElementType(requestedType); 204 205 if (requestedType.IsArray) 206 { 207 throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectQuery_UnableToMaterializeArray( 208 requestedType, typeof(List<>).MakeGenericType(elementType))); 209 } 210 211 if (!requestedType.IsAbstract && 212 requestedType.GetConstructor(constructorBinding, null, System.Type.EmptyTypes, null) != null) 213 { 214 return requestedType; 215 } 216 217 var hashSetOfT = typeof(HashSet<>).MakeGenericType(elementType); 218 if (requestedType.IsAssignableFrom(hashSetOfT)) 219 { 220 return hashSetOfT; 221 } 222 223 var listOfT = typeof(List<>).MakeGenericType(elementType); 224 if (requestedType.IsAssignableFrom(listOfT)) 225 { 226 return listOfT; 227 } 228 229 return null; 230 } 231 232 /// <summary> 233 /// Returns the Type object that should be used to identify the type in the o-space 234 /// metadata. This is normally just the type that is passed in, but if the type 235 /// is a proxy that we have generated, then its base type is returned instead. 236 /// This ensures that both proxy entities and normal entities are treated as the 237 /// same kind of entity in the metadata and places where the metadata is used. 238 /// </summary> GetEntityIdentityType(Type entityType)239 internal static Type GetEntityIdentityType(Type entityType) 240 { 241 return EntityProxyFactory.IsProxyType(entityType) ? entityType.BaseType : entityType; 242 } 243 244 /// <summary> 245 /// Provides a standard helper method for quoting identifiers 246 /// </summary> 247 /// <param name="identifier">Identifier to be quoted. Does not validate that this identifier is valid.</param> 248 /// <returns>Quoted string</returns> QuoteIdentifier(string identifier)249 internal static string QuoteIdentifier(string identifier) 250 { 251 Debug.Assert(identifier != null, "identifier should not be null"); 252 return "[" + identifier.Replace("]", "]]") + "]"; 253 } 254 255 // The class contains functions that take the proper informational variables and then construct 256 // the appropriate exception with an error string obtained from the resource file. 257 // The exception is then returned to the caller, so that the caller may then throw from its 258 // location so that the catcher of the exception will have the appropriate call stack. 259 // This class is used so that there will be compile time checking of error messages. 260 Argument(string error)261 static internal ArgumentException Argument(string error) { 262 return new ArgumentException(error); 263 } Argument(string error, Exception inner)264 static internal ArgumentException Argument(string error, Exception inner) { 265 return new ArgumentException(error, inner); 266 } Argument(string error, string parameter)267 static internal ArgumentException Argument(string error, string parameter) { 268 return new ArgumentException(error, parameter); 269 } Argument(string error, string parameter, Exception inner)270 static internal ArgumentException Argument(string error, string parameter, Exception inner) { 271 return new ArgumentException(error, parameter, inner); 272 } ArgumentNull(string parameter)273 static internal ArgumentNullException ArgumentNull(string parameter) { 274 return new ArgumentNullException(parameter); 275 } ArgumentOutOfRange(string parameterName)276 static internal ArgumentOutOfRangeException ArgumentOutOfRange(string parameterName) { 277 return new ArgumentOutOfRangeException(parameterName); 278 } ArgumentOutOfRange(string message, string parameterName)279 static internal ArgumentOutOfRangeException ArgumentOutOfRange(string message, string parameterName) { 280 return new ArgumentOutOfRangeException(parameterName, message); 281 } CommandExecution(string message)282 static internal EntityCommandExecutionException CommandExecution(string message) { 283 return new EntityCommandExecutionException(message); 284 } CommandExecution(string message, Exception innerException)285 static internal EntityCommandExecutionException CommandExecution(string message, Exception innerException) { 286 return new EntityCommandExecutionException(message, innerException); 287 } CommandCompilation(string message, Exception innerException)288 static internal EntityCommandCompilationException CommandCompilation(string message, Exception innerException) { 289 return new EntityCommandCompilationException(message, innerException); 290 } PropertyConstraint(string message, string propertyName)291 static internal PropertyConstraintException PropertyConstraint(string message, string propertyName) 292 { 293 return new PropertyConstraintException(message, propertyName); 294 } Constraint(string message)295 static internal ConstraintException Constraint(string message) 296 { 297 return new ConstraintException(message); 298 } IndexOutOfRange(string error)299 static internal IndexOutOfRangeException IndexOutOfRange(string error) 300 { 301 return new IndexOutOfRangeException(error); 302 } InvalidOperation(string error)303 static internal InvalidOperationException InvalidOperation(string error) { 304 return new InvalidOperationException(error); 305 } InvalidOperation(string error, Exception inner)306 static internal InvalidOperationException InvalidOperation(string error, Exception inner) { 307 return new InvalidOperationException(error, inner); 308 } InvalidStringArgument(string parameterName)309 static internal ArgumentException InvalidStringArgument(string parameterName) { 310 return Argument(System.Data.Entity.Strings.InvalidStringArgument(parameterName), parameterName); 311 } Mapping(string message)312 static internal MappingException Mapping(string message) 313 { 314 return new MappingException(message); 315 } Metadata(string message, Exception inner)316 static internal MetadataException Metadata(string message, Exception inner) 317 { 318 return new MetadataException(message, inner); 319 } Metadata(string message)320 static internal MetadataException Metadata(string message) 321 { 322 return new MetadataException(message); 323 } NotSupported()324 static internal NotSupportedException NotSupported() 325 { 326 return new NotSupportedException(); 327 } NotSupported(string error)328 static internal NotSupportedException NotSupported(string error) { 329 return new NotSupportedException(error); 330 } ObjectDisposed(string error)331 static internal ObjectDisposedException ObjectDisposed(string error) { 332 return new ObjectDisposedException(null, error); 333 } ObjectNotFound(string error)334 static internal ObjectNotFoundException ObjectNotFound(string error) { 335 return new ObjectNotFoundException(error); 336 } 337 338 // SSDL Generator 339 //static internal StrongTypingException StrongTyping(string error, Exception innerException) { 340 // StrongTypingException e = new StrongTypingException(error, innerException); 341 // TraceExceptionAsReturnValue(e); 342 // return e; 343 //} 344 #region Query Exceptions 345 /// <summary> 346 /// EntityException factory method 347 /// </summary> 348 /// <param name="message"></param> 349 /// <returns>EntityException</returns> EntitySqlError( string message )350 static internal EntitySqlException EntitySqlError( string message ) 351 { 352 return new EntitySqlException(message); 353 } 354 355 /// <summary> 356 /// EntityException factory method 357 /// </summary> 358 /// <param name="message"></param> 359 /// <param name="innerException"></param> 360 /// <returns></returns> EntitySqlError( string message, Exception innerException)361 static internal EntitySqlException EntitySqlError( string message, Exception innerException) 362 { 363 return new EntitySqlException(message, innerException); 364 } 365 366 /// <summary> 367 /// EntityException factory method 368 /// </summary> 369 /// <param name="errCtx"></param> 370 /// <param name="message"></param> 371 /// <returns>EntityException</returns> EntitySqlError( System.Data.Common.EntitySql.ErrorContext errCtx, string message )372 static internal EntitySqlException EntitySqlError( System.Data.Common.EntitySql.ErrorContext errCtx, string message ) 373 { 374 return EntitySqlException.Create(errCtx, message, null); 375 } 376 377 /// <summary> 378 /// EntityException factory method 379 /// </summary> 380 /// <param name="errCtx"></param> 381 /// <param name="message"></param> 382 /// <returns>EntityException</returns> EntitySqlError( System.Data.Common.EntitySql.ErrorContext errCtx, string message, Exception innerException )383 static internal EntitySqlException EntitySqlError( System.Data.Common.EntitySql.ErrorContext errCtx, string message, Exception innerException ) 384 { 385 return EntitySqlException.Create(errCtx, message, null); 386 } 387 388 /// <summary> 389 /// EntityException factory method 390 /// </summary> 391 /// <param name="queryText"></param> 392 /// <param name="errorMessage"></param> 393 /// <param name="errorPosition"></param> 394 /// <returns></returns> EntitySqlError( string queryText, string errorMessage, int errorPosition )395 static internal EntitySqlException EntitySqlError( string queryText, string errorMessage, int errorPosition ) 396 { 397 return EntitySqlException.Create(queryText, errorMessage, errorPosition, null, false, null); 398 } 399 400 /// <summary> 401 /// EntityException factory method. AdditionalErrorInformation will be used inlined if loadContextInfoFromResource is false. 402 /// </summary> 403 /// <param name="queryText"></param> 404 /// <param name="errorMessage"></param> 405 /// <param name="errorPosition"></param> 406 /// <param name="additionalErrorInformation"></param> 407 /// <param name="loadContextInfoFromResource"></param> 408 /// <returns></returns> EntitySqlError( string queryText, string errorMessage, int errorPosition, string additionalErrorInformation, bool loadContextInfoFromResource )409 static internal EntitySqlException EntitySqlError( string queryText, 410 string errorMessage, 411 int errorPosition, 412 string additionalErrorInformation, 413 bool loadContextInfoFromResource ) 414 { 415 return EntitySqlException.Create(queryText, 416 errorMessage, 417 errorPosition, 418 additionalErrorInformation, 419 loadContextInfoFromResource, 420 null); 421 } 422 #endregion 423 424 #region Bridge Errors CannotCloneStoreProvider()425 static internal ProviderIncompatibleException CannotCloneStoreProvider() { 426 return ProviderIncompatible(System.Data.Entity.Strings.EntityClient_CannotCloneStoreProvider); 427 } ClosedDataReaderError()428 static internal InvalidOperationException ClosedDataReaderError() { 429 return InvalidOperation(System.Data.Entity.Strings.ADP_ClosedDataReaderError); 430 } DataReaderClosed(string method)431 static internal InvalidOperationException DataReaderClosed(string method) { 432 return InvalidOperation(System.Data.Entity.Strings.ADP_DataReaderClosed(method)); 433 } ImplicitlyClosedDataReaderError()434 static internal InvalidOperationException ImplicitlyClosedDataReaderError() { 435 return InvalidOperation(System.Data.Entity.Strings.ADP_ImplicitlyClosedDataReaderError); 436 } InvalidBufferSizeOrIndex(int numBytes, int bufferIndex)437 static internal IndexOutOfRangeException InvalidBufferSizeOrIndex(int numBytes, int bufferIndex) { 438 return IndexOutOfRange(System.Data.Entity.Strings.ADP_InvalidBufferSizeOrIndex(numBytes.ToString(CultureInfo.InvariantCulture), bufferIndex.ToString(CultureInfo.InvariantCulture))); 439 } InvalidDataLength(long length)440 static internal IndexOutOfRangeException InvalidDataLength(long length) { 441 return IndexOutOfRange(System.Data.Entity.Strings.ADP_InvalidDataLength(length.ToString(CultureInfo.InvariantCulture))); 442 } InvalidDestinationBufferIndex(int maxLen, int dstOffset, string parameterName)443 static internal ArgumentOutOfRangeException InvalidDestinationBufferIndex(int maxLen, int dstOffset, string parameterName) { 444 return ArgumentOutOfRange(System.Data.Entity.Strings.ADP_InvalidDestinationBufferIndex(maxLen.ToString(CultureInfo.InvariantCulture), dstOffset.ToString(CultureInfo.InvariantCulture)), parameterName); 445 } InvalidSourceBufferIndex(int maxLen, long srcOffset, string parameterName)446 static internal ArgumentOutOfRangeException InvalidSourceBufferIndex(int maxLen, long srcOffset, string parameterName) { 447 return ArgumentOutOfRange(System.Data.Entity.Strings.ADP_InvalidSourceBufferIndex(maxLen.ToString(CultureInfo.InvariantCulture), srcOffset.ToString(CultureInfo.InvariantCulture)), parameterName); 448 } MustUseSequentialAccess()449 static internal InvalidOperationException MustUseSequentialAccess() { 450 return InvalidOperation(System.Data.Entity.Strings.ADP_MustUseSequentialAccess); 451 } NoData()452 static internal InvalidOperationException NoData() { 453 return InvalidOperation(System.Data.Entity.Strings.ADP_NoData); 454 } NonSequentialArrayOffsetAccess(long badIndex, long currIndex, string method)455 static internal InvalidOperationException NonSequentialArrayOffsetAccess(long badIndex, long currIndex, string method) { 456 return InvalidOperation(System.Data.Entity.Strings.ADP_NonSequentialChunkAccess(badIndex.ToString(CultureInfo.InvariantCulture), currIndex.ToString(CultureInfo.InvariantCulture), method)); 457 } NonSequentialColumnAccess(int badCol, int currCol)458 static internal InvalidOperationException NonSequentialColumnAccess(int badCol, int currCol) { 459 return InvalidOperation(System.Data.Entity.Strings.ADP_NonSequentialColumnAccess(badCol.ToString(CultureInfo.InvariantCulture), currCol.ToString(CultureInfo.InvariantCulture))); 460 } KeysRequiredForJoinOverNest(Query.InternalTrees.Op op)461 static internal NotSupportedException KeysRequiredForJoinOverNest(Query.InternalTrees.Op op) { 462 return NotSupported(System.Data.Entity.Strings.ADP_KeysRequiredForJoinOverNest(op.OpType.ToString())); 463 } KeysRequiredForNesting()464 static internal NotSupportedException KeysRequiredForNesting() { 465 return NotSupported(System.Data.Entity.Strings.ADP_KeysRequiredForNesting); 466 } NestingNotSupported(Query.InternalTrees.Op parentOp, Query.InternalTrees.Op childOp)467 static internal NotSupportedException NestingNotSupported(Query.InternalTrees.Op parentOp, Query.InternalTrees.Op childOp) { 468 return NotSupported(System.Data.Entity.Strings.ADP_NestingNotSupported(parentOp.OpType.ToString(), childOp.OpType.ToString())); 469 } ProviderDoesNotSupportCommandTrees()470 static internal NotSupportedException ProviderDoesNotSupportCommandTrees() { 471 return NotSupported(System.Data.Entity.Strings.ADP_ProviderDoesNotSupportCommandTrees); 472 } CommandExecutionDataReaderFieldCountForScalarType()473 static internal EntityCommandExecutionException CommandExecutionDataReaderFieldCountForScalarType() { 474 return CommandExecution(System.Data.Entity.Strings.ADP_InvalidDataReaderFieldCountForScalarType); 475 } CommandExecutionDataReaderMissingColumnForType(EdmMember member, EdmType currentType)476 static internal EntityCommandExecutionException CommandExecutionDataReaderMissingColumnForType(EdmMember member, EdmType currentType) { 477 return CommandExecution(System.Data.Entity.Strings.ADP_InvalidDataReaderMissingColumnForType( 478 currentType.FullName, member.Name)); 479 } CommandExecutionDataReaderMissinDiscriminatorColumn(string columnName, EdmFunction functionImport)480 static internal EntityCommandExecutionException CommandExecutionDataReaderMissinDiscriminatorColumn(string columnName, EdmFunction functionImport) { 481 return CommandExecution(System.Data.Entity.Strings.ADP_InvalidDataReaderMissingDiscriminatorColumn(columnName, functionImport.FullName)); 482 } 483 484 #endregion 485 486 #region EntityClient Errors ProviderIncompatible(string error)487 static internal ProviderIncompatibleException ProviderIncompatible(string error) { 488 return new ProviderIncompatibleException(error); 489 } ProviderIncompatible(string error, Exception innerException)490 static internal ProviderIncompatibleException ProviderIncompatible(string error, Exception innerException) { 491 return new ProviderIncompatibleException(error, innerException); 492 } Provider(string error)493 static internal EntityException Provider(string error) { 494 return new EntityException(error); 495 } Provider(Exception inner)496 static internal EntityException Provider(Exception inner) { 497 return new EntityException(System.Data.Entity.Strings.EntityClient_ProviderGeneralError, inner); 498 } Provider(string parameter, Exception inner)499 static internal EntityException Provider(string parameter, Exception inner) { 500 return new EntityException(System.Data.Entity.Strings.EntityClient_ProviderSpecificError(parameter), inner); 501 } ProviderExceptionWithMessage(string message, Exception inner)502 static internal EntityException ProviderExceptionWithMessage(string message, Exception inner) { 503 return new EntityException(message, inner); 504 } 505 #endregion //EntityClient Errors 506 507 #region SqlClient Errors 508 SqlTypesAssemblyNotFound()509 static internal InvalidOperationException SqlTypesAssemblyNotFound() 510 { 511 return InvalidOperation(System.Data.Entity.Strings.SqlProvider_SqlTypesAssemblyNotFound); 512 } 513 GeographyValueNotSqlCompatible()514 static internal ProviderIncompatibleException GeographyValueNotSqlCompatible() 515 { 516 return ProviderIncompatible(System.Data.Entity.Strings.SqlProvider_GeographyValueNotSqlCompatible); 517 } 518 GeometryValueNotSqlCompatible()519 static internal ProviderIncompatibleException GeometryValueNotSqlCompatible() 520 { 521 return ProviderIncompatible(System.Data.Entity.Strings.SqlProvider_GeometryValueNotSqlCompatible); 522 } 523 524 #endregion //SqlClient Errors 525 526 #region Metadata Errors InvalidSchemaEncountered(string errors)527 static internal MetadataException InvalidSchemaEncountered(string errors) { 528 // EntityRes.GetString implementation truncates the string arguments to a max length of 1024. 529 // Since csdl, ssdl, providermanifest can have bunch of errors in them and we want to 530 // show all of them, we are using String.Format to form the error message. 531 // Using CurrentCulture since that's what EntityRes.GetString uses. 532 return Metadata(String.Format(CultureInfo.CurrentCulture, EntityRes.GetString(EntityRes.InvalidSchemaEncountered), errors)); 533 } InvalidCollectionForMapping(DataSpace space)534 static internal MetadataException InvalidCollectionForMapping(DataSpace space) { 535 return Metadata(System.Data.Entity.Strings.InvalidCollectionForMapping(space.ToString())); 536 } 537 // MemberCollection.cs MemberInvalidIdentity(string identity, string parameter)538 static internal ArgumentException MemberInvalidIdentity(string identity, string parameter) { 539 return Argument(System.Data.Entity.Strings.MemberInvalidIdentity(identity), parameter); 540 } 541 // MetadataCollection.cs ArrayTooSmall(string parameter)542 static internal ArgumentException ArrayTooSmall(string parameter) { 543 return Argument(System.Data.Entity.Strings.ArrayTooSmall, parameter); 544 } ItemDuplicateIdentity(string identity, string parameter, Exception inner)545 static internal ArgumentException ItemDuplicateIdentity(string identity, string parameter, Exception inner) { 546 return Argument(System.Data.Entity.Strings.ItemDuplicateIdentity(identity), parameter, inner); 547 } ItemInvalidIdentity(string identity, string parameter)548 static internal ArgumentException ItemInvalidIdentity(string identity, string parameter) { 549 return Argument(System.Data.Entity.Strings.ItemInvalidIdentity(identity), parameter); 550 } MoreThanOneItemMatchesIdentity(string identity)551 static internal InvalidOperationException MoreThanOneItemMatchesIdentity(string identity) { 552 return InvalidOperation(System.Data.Entity.Strings.MoreThanOneItemMatchesIdentity(identity)); 553 } OperationOnReadOnlyCollection()554 static internal InvalidOperationException OperationOnReadOnlyCollection() { 555 return InvalidOperation(System.Data.Entity.Strings.OperationOnReadOnlyCollection); 556 } 557 // MetadataWorkspace.cs ItemCollectionAlreadyRegistered(DataSpace space)558 static internal InvalidOperationException ItemCollectionAlreadyRegistered(DataSpace space) { 559 return InvalidOperation(System.Data.Entity.Strings.ItemCollectionAlreadyRegistered(space.ToString())); 560 } NoCollectionForSpace(DataSpace space)561 static internal InvalidOperationException NoCollectionForSpace(DataSpace space) { 562 return InvalidOperation(System.Data.Entity.Strings.NoCollectionForSpace(space.ToString())); 563 } InvalidCollectionSpecified(DataSpace space)564 static internal InvalidOperationException InvalidCollectionSpecified(DataSpace space) { 565 return InvalidOperation(System.Data.Entity.Strings.InvalidCollectionSpecified(space)); 566 } DifferentSchemaVersionInCollection(string itemCollectionType, double versionToRegister, double currentSchemaVersion)567 static internal MetadataException DifferentSchemaVersionInCollection(string itemCollectionType, double versionToRegister, double currentSchemaVersion) 568 { 569 return Metadata(Strings.DifferentSchemaVersionInCollection(itemCollectionType, versionToRegister, currentSchemaVersion)); 570 } 571 // TypeUsage.cs NotBinaryTypeForTypeUsage()572 static internal ArgumentException NotBinaryTypeForTypeUsage() { 573 return Argument(System.Data.Entity.Strings.NotBinaryTypeForTypeUsage); 574 } NotDateTimeTypeForTypeUsage()575 static internal ArgumentException NotDateTimeTypeForTypeUsage() { 576 return Argument(System.Data.Entity.Strings.NotDateTimeTypeForTypeUsage); 577 } NotDateTimeOffsetTypeForTypeUsage()578 static internal ArgumentException NotDateTimeOffsetTypeForTypeUsage() 579 { 580 return Argument(System.Data.Entity.Strings.NotDateTimeOffsetTypeForTypeUsage); 581 } NotTimeTypeForTypeUsage()582 static internal ArgumentException NotTimeTypeForTypeUsage() 583 { 584 return Argument(System.Data.Entity.Strings.NotTimeTypeForTypeUsage); 585 } NotDecimalTypeForTypeUsage()586 static internal ArgumentException NotDecimalTypeForTypeUsage() { 587 return Argument(System.Data.Entity.Strings.NotDecimalTypeForTypeUsage); 588 } NotStringTypeForTypeUsage()589 static internal ArgumentException NotStringTypeForTypeUsage() { 590 return Argument(System.Data.Entity.Strings.NotStringTypeForTypeUsage); 591 } 592 // EntityContainer.cs InvalidEntitySetName(string name)593 static internal ArgumentException InvalidEntitySetName(string name) { 594 return Argument(System.Data.Entity.Strings.InvalidEntitySetName(name)); 595 } InvalidRelationshipSetName(string name)596 static internal ArgumentException InvalidRelationshipSetName(string name) { 597 return Argument(System.Data.Entity.Strings.InvalidRelationshipSetName(name)); 598 } InvalidEDMVersion(double edmVersion)599 static internal ArgumentException InvalidEDMVersion(double edmVersion) 600 { 601 return Argument(System.Data.Entity.Strings.InvalidEDMVersion(edmVersion.ToString(CultureInfo.CurrentCulture))); 602 } 603 604 // EntitySetBaseCollection.cs EntitySetInAnotherContainer(string parameter)605 static internal ArgumentException EntitySetInAnotherContainer(string parameter) { 606 return Argument(System.Data.Entity.Strings.EntitySetInAnotherContainer, parameter); 607 } 608 // util.cs OperationOnReadOnlyItem()609 static internal InvalidOperationException OperationOnReadOnlyItem() { 610 return InvalidOperation(System.Data.Entity.Strings.OperationOnReadOnlyItem); 611 } 612 //FacetDescription.cs MinAndMaxValueMustBeSameForConstantFacet(string facetName, string typeName)613 static internal ArgumentException MinAndMaxValueMustBeSameForConstantFacet(string facetName, string typeName) { 614 return Argument(System.Data.Entity.Strings.MinAndMaxValueMustBeSameForConstantFacet(facetName, typeName)); 615 } MissingDefaultValueForConstantFacet(string facetName, string typeName)616 static internal ArgumentException MissingDefaultValueForConstantFacet(string facetName, string typeName) { 617 return Argument(System.Data.Entity.Strings.MissingDefaultValueForConstantFacet(facetName, typeName)); 618 } BothMinAndMaxValueMustBeSpecifiedForNonConstantFacet(string facetName, string typeName)619 static internal ArgumentException BothMinAndMaxValueMustBeSpecifiedForNonConstantFacet(string facetName, string typeName) { 620 return Argument(System.Data.Entity.Strings.BothMinAndMaxValueMustBeSpecifiedForNonConstantFacet(facetName, typeName)); 621 } MinAndMaxValueMustBeDifferentForNonConstantFacet(string facetName, string typeName)622 static internal ArgumentException MinAndMaxValueMustBeDifferentForNonConstantFacet(string facetName, string typeName) { 623 return Argument(System.Data.Entity.Strings.MinAndMaxValueMustBeDifferentForNonConstantFacet(facetName, typeName)); 624 } MinAndMaxMustBePositive(string facetName, string typeName)625 static internal ArgumentException MinAndMaxMustBePositive(string facetName, string typeName) { 626 return Argument(System.Data.Entity.Strings.MinAndMaxMustBePositive(facetName, typeName)); 627 } MinMustBeLessThanMax(string minimumValue, string facetName, string typeName)628 static internal ArgumentException MinMustBeLessThanMax(string minimumValue, string facetName, string typeName) { 629 return Argument(System.Data.Entity.Strings.MinMustBeLessThanMax(minimumValue, facetName, typeName)); 630 } EntitySetNotInCSpace(string name)631 static internal ArgumentException EntitySetNotInCSpace(string name) { 632 return Argument(System.Data.Entity.Strings.EntitySetNotInCSPace(name)); 633 } 634 TypeNotInEntitySet(string entitySetName, string rootEntityTypeName, string entityTypeName)635 static internal ArgumentException TypeNotInEntitySet(string entitySetName, string rootEntityTypeName, string entityTypeName) { 636 return Argument(System.Data.Entity.Strings.TypeNotInEntitySet(entityTypeName, rootEntityTypeName, entitySetName)); 637 } 638 AssociationSetNotInCSpace(string name)639 static internal ArgumentException AssociationSetNotInCSpace(string name) { 640 return Argument(System.Data.Entity.Strings.EntitySetNotInCSPace(name)); 641 } 642 TypeNotInAssociationSet(string setName, string rootEntityTypeName, string typeName)643 static internal ArgumentException TypeNotInAssociationSet(string setName, string rootEntityTypeName, string typeName) { 644 return Argument(System.Data.Entity.Strings.TypeNotInAssociationSet(typeName, rootEntityTypeName, setName)); 645 } 646 #endregion //Metadata Errors 647 648 #region Internal Errors 649 650 // Internal error code to use with the InternalError exception. 651 // 652 // error numbers end up being hard coded in test cases; they can be removed, but should not be changed. 653 // reusing error numbers is probably OK, but not recommended. 654 // 655 // The acceptable range for this enum is 656 // 1000 - 1999 657 // 658 // The Range 10,000-15,000 is reserved for tools 659 // 660 /// You must never renumber these, because we rely upon them when 661 /// we get an exception report once we release the bits. 662 internal enum InternalErrorCode { 663 WrongNumberOfKeys = 1000, 664 UnknownColumnMapKind = 1001, 665 NestOverNest = 1002, 666 ColumnCountMismatch = 1003, 667 668 /// <summary> 669 /// Some assertion failed 670 /// </summary> 671 AssertionFailed = 1004, 672 673 UnknownVar = 1005, 674 WrongVarType = 1006, 675 ExtentWithoutEntity = 1007, 676 UnnestWithoutInput = 1008, 677 UnnestMultipleCollections = 1009, 678 CodeGen_NoSuchProperty = 1011, 679 JoinOverSingleStreamNest = 1012, 680 InvalidInternalTree = 1013, 681 NameValuePairNext = 1014, 682 InvalidParserState1 = 1015, 683 InvalidParserState2 = 1016, 684 /// <summary> 685 /// Thrown when SQL gen produces parameters for anything other than a 686 /// modification command tree. 687 /// </summary> 688 SqlGenParametersNotPermitted = 1017, 689 EntityKeyMissingKeyValue = 1018, 690 /// <summary> 691 /// Thrown when an invalid data request is presented to a PropagatorResult in 692 /// the update pipeline (confusing simple/complex values, missing key values, etc.). 693 /// </summary> 694 UpdatePipelineResultRequestInvalid = 1019, 695 InvalidStateEntry = 1020, 696 /// <summary> 697 /// Thrown when the update pipeline encounters an invalid PrimitiveTypeKind 698 /// during a cast. 699 /// </summary> 700 InvalidPrimitiveTypeKind = 1021, 701 /// <summary> 702 /// Thrown when an unknown node type is encountered in ELinq expression translation. 703 /// </summary> 704 UnknownLinqNodeType = 1023, 705 /// <summary> 706 /// Thrown by result assembly upon encountering a collection column that does not use any columns 707 /// nor has a descriminated nested collection. 708 /// </summary> 709 CollectionWithNoColumns = 1024, 710 /// <summary> 711 /// Thrown when a lambda expression argument has an unexpected node type. 712 /// </summary> 713 UnexpectedLinqLambdaExpressionFormat = 1025, 714 /// <summary> 715 /// Thrown when a CommandTree is defined on a stored procedure EntityCommand instance. 716 /// </summary> 717 CommandTreeOnStoredProcedureEntityCommand = 1026, 718 /// <summary> 719 /// Thrown when an operation in the BoolExpr library is exceeding anticipated complexity. 720 /// </summary> 721 BoolExprAssert = 1027, 722 // AttemptToGenerateDefinitionForFunctionWithoutDef = 1028, 723 /// <summary> 724 /// Thrown when type A is promotable to type B, but ranking algorithm fails to rank the promotion. 725 /// </summary> 726 FailedToGeneratePromotionRank = 1029, 727 } 728 InternalError(InternalErrorCode internalError)729 static internal Exception InternalError(InternalErrorCode internalError) { 730 return InvalidOperation(System.Data.Entity.Strings.ADP_InternalProviderError((int)internalError)); 731 } 732 InternalError(InternalErrorCode internalError, int location, object additionalInfo)733 static internal Exception InternalError(InternalErrorCode internalError, int location, object additionalInfo) { 734 StringBuilder sb = new StringBuilder(); 735 sb.AppendFormat("{0}, {1}", (int)internalError, location); 736 if (null != additionalInfo) { 737 sb.AppendFormat(", {0}", additionalInfo); 738 } 739 return InvalidOperation(System.Data.Entity.Strings.ADP_InternalProviderError(sb.ToString())); 740 } 741 InternalError(InternalErrorCode internalError, int location)742 static internal Exception InternalError(InternalErrorCode internalError, int location) { 743 return InternalError(internalError, location, null); 744 } 745 746 #endregion 747 748 #region ObjectStateManager errors OriginalValuesDoesNotExist()749 internal static InvalidOperationException OriginalValuesDoesNotExist() { 750 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_OriginalValuesDoesNotExist); 751 } 752 CurrentValuesDoesNotExist()753 internal static InvalidOperationException CurrentValuesDoesNotExist() { 754 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CurrentValuesDoesNotExist); 755 } 756 InvalidTypeForComplexTypeProperty(string argument)757 internal static ArgumentException InvalidTypeForComplexTypeProperty(string argument) { 758 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectStateEntry_InvalidTypeForComplexTypeProperty, argument); 759 } 760 ObjectStateEntryinInvalidState()761 internal static InvalidOperationException ObjectStateEntryinInvalidState() { 762 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_InvalidState); 763 } 764 CantModifyDetachedDeletedEntries()765 internal static InvalidOperationException CantModifyDetachedDeletedEntries() { 766 throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CantModifyDetachedDeletedEntries); 767 } 768 SetModifiedStates(string methodName)769 internal static InvalidOperationException SetModifiedStates(string methodName) 770 { 771 throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_SetModifiedStates(methodName)); 772 } 773 EntityCantHaveMultipleChangeTrackers()774 internal static InvalidOperationException EntityCantHaveMultipleChangeTrackers() { 775 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.Entity_EntityCantHaveMultipleChangeTrackers); 776 } 777 CantModifyRelationValues()778 internal static InvalidOperationException CantModifyRelationValues() { 779 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CantModifyRelationValues); 780 } 781 CantModifyRelationState()782 internal static InvalidOperationException CantModifyRelationState() { 783 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CantModifyRelationState); 784 } 785 CannotModifyKeyProperty(string fieldName)786 internal static InvalidOperationException CannotModifyKeyProperty(string fieldName) { 787 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CannotModifyKeyProperty(fieldName)); 788 } 789 CantSetEntityKey()790 internal static InvalidOperationException CantSetEntityKey() { 791 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CantSetEntityKey); 792 } 793 CannotAccessKeyEntryValues()794 internal static InvalidOperationException CannotAccessKeyEntryValues() { 795 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CannotAccessKeyEntryValues); 796 } 797 CannotModifyKeyEntryState()798 internal static InvalidOperationException CannotModifyKeyEntryState() { 799 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CannotModifyKeyEntryState); 800 } 801 802 CannotCallDeleteOnKeyEntry()803 internal static InvalidOperationException CannotCallDeleteOnKeyEntry() { 804 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_CannotDeleteOnKeyEntry); 805 } 806 InvalidModifiedPropertyName(string propertyName)807 internal static ArgumentException InvalidModifiedPropertyName(string propertyName) { 808 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectStateEntry_SetModifiedOnInvalidProperty(propertyName)); 809 } NoEntryExistForEntityKey()810 internal static InvalidOperationException NoEntryExistForEntityKey() { 811 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_NoEntryExistForEntityKey); 812 } DetachedObjectStateEntriesDoesNotExistInObjectStateManager()813 internal static ArgumentException DetachedObjectStateEntriesDoesNotExistInObjectStateManager() { 814 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectStateManager_DetachedObjectStateEntriesDoesNotExistInObjectStateManager); 815 } 816 ObjectStateManagerContainsThisEntityKey()817 internal static InvalidOperationException ObjectStateManagerContainsThisEntityKey() { 818 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_ObjectStateManagerContainsThisEntityKey); 819 } ObjectStateManagerDoesnotAllowToReAddUnchangedOrModifiedOrDeletedEntity(EntityState state)820 internal static InvalidOperationException ObjectStateManagerDoesnotAllowToReAddUnchangedOrModifiedOrDeletedEntity(EntityState state) { 821 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_DoesnotAllowToReAddUnchangedOrModifiedOrDeletedEntity(state)); 822 } CannotFixUpKeyToExistingValues()823 internal static InvalidOperationException CannotFixUpKeyToExistingValues() { 824 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_CannotFixUpKeyToExistingValues); 825 } KeyPropertyDoesntMatchValueInKey(bool forAttach)826 internal static InvalidOperationException KeyPropertyDoesntMatchValueInKey(bool forAttach) 827 { 828 if (forAttach) 829 { 830 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_KeyPropertyDoesntMatchValueInKeyForAttach); 831 } 832 else 833 { 834 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_KeyPropertyDoesntMatchValueInKey); 835 } 836 } 837 CheckValidStateForChangeEntityState(EntityState state)838 internal static void CheckValidStateForChangeEntityState(EntityState state) 839 { 840 switch(state) 841 { 842 case EntityState.Added: 843 case EntityState.Unchanged: 844 case EntityState.Modified: 845 case EntityState.Deleted: 846 case EntityState.Detached: 847 break; 848 default: 849 throw InvalidEntityStateArgument("state"); 850 } 851 } 852 CheckValidStateForChangeRelationshipState(EntityState state, string paramName)853 internal static void CheckValidStateForChangeRelationshipState(EntityState state, string paramName) 854 { 855 switch (state) 856 { 857 case EntityState.Added: 858 case EntityState.Unchanged: 859 case EntityState.Deleted: 860 case EntityState.Detached: 861 break; 862 default: 863 throw InvalidRelationshipStateArgument(paramName); 864 } 865 } 866 InvalidKey()867 internal static InvalidOperationException InvalidKey() { 868 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_InvalidKey); 869 } AcceptChangesEntityKeyIsNotValid()870 internal static InvalidOperationException AcceptChangesEntityKeyIsNotValid() { 871 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_AcceptChangesEntityKeyIsNotValid); 872 } EntityConflictsWithKeyEntry()873 internal static InvalidOperationException EntityConflictsWithKeyEntry() { 874 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_EntityConflictsWithKeyEntry); 875 } ObjectDoesNotHaveAKey(object entity)876 internal static InvalidOperationException ObjectDoesNotHaveAKey(object entity) { 877 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_GetEntityKeyRequiresObjectToHaveAKey(entity.GetType().FullName)); 878 } EntityValueChangedWithoutEntityValueChanging()879 internal static InvalidOperationException EntityValueChangedWithoutEntityValueChanging() { 880 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_EntityMemberChangedWithoutEntityMemberChanging); 881 } ChangedInDifferentStateFromChanging(EntityState currentState, EntityState previousState)882 internal static InvalidOperationException ChangedInDifferentStateFromChanging(EntityState currentState, EntityState previousState) { 883 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateEntry_ChangedInDifferentStateFromChanging(previousState, currentState)); 884 } ChangeOnUnmappedProperty(string entityPropertyName)885 internal static ArgumentException ChangeOnUnmappedProperty(string entityPropertyName) { 886 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectStateEntry_ChangeOnUnmappedProperty(entityPropertyName)); 887 } 888 ChangeOnUnmappedComplexProperty(string complexPropertyName)889 internal static ArgumentException ChangeOnUnmappedComplexProperty(string complexPropertyName) { 890 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectStateEntry_ChangeOnUnmappedComplexProperty(complexPropertyName)); 891 } 892 EntityTypeDoesNotMatchEntitySet(string entityType, string entitysetName, string argument)893 internal static ArgumentException EntityTypeDoesNotMatchEntitySet(string entityType, string entitysetName, string argument) { 894 return Argument(System.Data.Entity.Strings.ObjectStateManager_EntityTypeDoesnotMatchtoEntitySetType(entityType, entitysetName), argument); 895 } NoEntryExistsForObject(object entity)896 internal static InvalidOperationException NoEntryExistsForObject(object entity) 897 { 898 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_NoEntryExistsForObject(entity.GetType().FullName)); 899 } EntityNotTracked()900 internal static InvalidOperationException EntityNotTracked() 901 { 902 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectStateManager_EntityNotTracked); 903 } SetOriginalComplexProperties(string propertyName)904 internal static InvalidOperationException SetOriginalComplexProperties(string propertyName) 905 { 906 return InvalidOperation(Strings.ObjectStateEntry_SetOriginalComplexProperties(propertyName)); 907 } NullOriginalValueForNonNullableProperty(string propertyName, string clrMemberName, string clrTypeName)908 internal static InvalidOperationException NullOriginalValueForNonNullableProperty(string propertyName, string clrMemberName, string clrTypeName) 909 { 910 return InvalidOperation(Strings.ObjectStateEntry_NullOriginalValueForNonNullableProperty(propertyName, clrMemberName, clrTypeName)); 911 } SetOriginalPrimaryKey(string propertyName)912 internal static InvalidOperationException SetOriginalPrimaryKey(string propertyName) 913 { 914 return InvalidOperation(Strings.ObjectStateEntry_SetOriginalPrimaryKey(propertyName)); 915 } 916 917 #endregion 918 919 #region ObjectMaterializer errors 920 ThrowPropertyIsNotNullable(string propertyName)921 internal static void ThrowPropertyIsNotNullable(string propertyName) 922 { 923 if (String.IsNullOrEmpty(propertyName)) 924 { 925 926 throw EntityUtil.Constraint( 927 System.Data.Entity.Strings.Materializer_PropertyIsNotNullable); 928 } 929 else 930 { 931 throw EntityUtil.PropertyConstraint( 932 System.Data.Entity.Strings.Materializer_PropertyIsNotNullableWithName(propertyName), propertyName); 933 } 934 } 935 ThrowSetInvalidValue(object value, Type destinationType, string className, string propertyName)936 internal static void ThrowSetInvalidValue(object value, Type destinationType, string className, string propertyName) 937 { 938 if (null == value) 939 { 940 throw EntityUtil.Constraint( 941 System.Data.Entity.Strings.Materializer_SetInvalidValue( 942 (Nullable.GetUnderlyingType(destinationType) ?? destinationType).Name, 943 className, propertyName, "null")); 944 } 945 else 946 { 947 throw EntityUtil.InvalidOperation( 948 System.Data.Entity.Strings.Materializer_SetInvalidValue( 949 (Nullable.GetUnderlyingType(destinationType) ?? destinationType).Name, 950 className, propertyName, value.GetType().Name)); 951 } 952 } ValueInvalidCast(Type valueType, Type destinationType)953 internal static InvalidOperationException ValueInvalidCast(Type valueType, Type destinationType) 954 { 955 Debug.Assert(null != valueType, "null valueType"); 956 Debug.Assert(null != destinationType, "null destinationType"); 957 if (destinationType.IsValueType && destinationType.IsGenericType && (typeof(Nullable<>) == destinationType.GetGenericTypeDefinition())) 958 { 959 return EntityUtil.InvalidOperation( 960 System.Data.Entity.Strings.Materializer_InvalidCastNullable( 961 valueType, destinationType.GetGenericArguments()[0])); 962 } 963 else 964 { 965 return EntityUtil.InvalidOperation( 966 System.Data.Entity.Strings.Materializer_InvalidCastReference( 967 valueType, destinationType)); 968 } 969 } ValueNullReferenceCast(Type destinationType)970 internal static InvalidOperationException ValueNullReferenceCast(Type destinationType) 971 { 972 Debug.Assert(null != destinationType, "null value"); 973 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.Materializer_NullReferenceCast(destinationType.Name)); 974 } 975 RecyclingEntity(EntityKey key, Type newEntityType, Type existingEntityType)976 internal static NotSupportedException RecyclingEntity(EntityKey key, Type newEntityType, Type existingEntityType) { 977 return NotSupported(System.Data.Entity.Strings.Materializer_RecyclingEntity(System.Data.Common.TypeHelpers.GetFullName(key.EntityContainerName, key.EntitySetName), newEntityType.FullName, existingEntityType.FullName, key.ConcatKeyValue())); 978 } AddedEntityAlreadyExists(EntityKey key)979 internal static InvalidOperationException AddedEntityAlreadyExists(EntityKey key) { 980 return InvalidOperation(System.Data.Entity.Strings.Materializer_AddedEntityAlreadyExists(key.ConcatKeyValue())); 981 } CannotReEnumerateQueryResults()982 internal static InvalidOperationException CannotReEnumerateQueryResults() { 983 return InvalidOperation(System.Data.Entity.Strings.Materializer_CannotReEnumerateQueryResults); 984 } MaterializerUnsupportedType()985 internal static NotSupportedException MaterializerUnsupportedType() { 986 return NotSupported(System.Data.Entity.Strings.Materializer_UnsupportedType); 987 } 988 #endregion 989 990 #region ObjectView errors CannotReplacetheEntityorRow()991 internal static InvalidOperationException CannotReplacetheEntityorRow() { 992 return InvalidOperation(System.Data.Entity.Strings.ObjectView_CannotReplacetheEntityorRow); 993 } IndexBasedInsertIsNotSupported()994 internal static NotSupportedException IndexBasedInsertIsNotSupported() { 995 return NotSupported(System.Data.Entity.Strings.ObjectView_IndexBasedInsertIsNotSupported); 996 } WriteOperationNotAllowedOnReadOnlyBindingList()997 internal static InvalidOperationException WriteOperationNotAllowedOnReadOnlyBindingList() { 998 return InvalidOperation(System.Data.Entity.Strings.ObjectView_WriteOperationNotAllowedOnReadOnlyBindingList); 999 } AddNewOperationNotAllowedOnAbstractBindingList()1000 internal static InvalidOperationException AddNewOperationNotAllowedOnAbstractBindingList() { 1001 return InvalidOperation(System.Data.Entity.Strings.ObjectView_AddNewOperationNotAllowedOnAbstractBindingList); 1002 } IncompatibleArgument()1003 internal static ArgumentException IncompatibleArgument() { 1004 return Argument(System.Data.Entity.Strings.ObjectView_IncompatibleArgument); 1005 } CannotResolveTheEntitySetforGivenEntity(Type type)1006 internal static InvalidOperationException CannotResolveTheEntitySetforGivenEntity(Type type) { 1007 return InvalidOperation(System.Data.Entity.Strings.ObjectView_CannotResolveTheEntitySet(type.FullName)); 1008 } 1009 1010 1011 #endregion 1012 1013 1014 #region EntityCollection Errors NoRelationshipSetMatched(string relationshipName)1015 internal static InvalidOperationException NoRelationshipSetMatched(string relationshipName) { 1016 Debug.Assert(!String.IsNullOrEmpty(relationshipName), "empty relationshipName"); 1017 return InvalidOperation(System.Data.Entity.Strings.Collections_NoRelationshipSetMatched(relationshipName)); 1018 } ExpectedCollectionGotReference(string typeName, string roleName, string relationshipName)1019 internal static InvalidOperationException ExpectedCollectionGotReference(string typeName, string roleName, string relationshipName) { 1020 return InvalidOperation(System.Data.Entity.Strings.Collections_ExpectedCollectionGotReference(typeName, roleName, relationshipName)); 1021 } CannotFillTryDifferentMergeOption(string relationshipName, string roleName)1022 internal static InvalidOperationException CannotFillTryDifferentMergeOption(string relationshipName, string roleName) { 1023 return InvalidOperation(Strings.Collections_CannotFillTryDifferentMergeOption(relationshipName, roleName)); 1024 } CannotRemergeCollections()1025 internal static InvalidOperationException CannotRemergeCollections() { 1026 return InvalidOperation(System.Data.Entity.Strings.Collections_UnableToMergeCollections); 1027 } ExpectedReferenceGotCollection(string typeName, string roleName, string relationshipName)1028 internal static InvalidOperationException ExpectedReferenceGotCollection(string typeName, string roleName, string relationshipName) { 1029 return InvalidOperation(System.Data.Entity.Strings.EntityReference_ExpectedReferenceGotCollection(typeName, roleName, relationshipName)); 1030 } CannotAddMoreThanOneEntityToEntityReference(string roleName, string relationshipName)1031 internal static InvalidOperationException CannotAddMoreThanOneEntityToEntityReference(string roleName, string relationshipName) { 1032 return InvalidOperation(System.Data.Entity.Strings.EntityReference_CannotAddMoreThanOneEntityToEntityReference(roleName, relationshipName)); 1033 } CannotSetSpecialKeys()1034 internal static ArgumentException CannotSetSpecialKeys() { 1035 return Argument(System.Data.Entity.Strings.EntityReference_CannotSetSpecialKeys, "value"); 1036 } EntityKeyValueMismatch()1037 internal static InvalidOperationException EntityKeyValueMismatch() { 1038 return InvalidOperation(System.Data.Entity.Strings.EntityReference_EntityKeyValueMismatch); 1039 } RelatedEndNotAttachedToContext(string relatedEndType)1040 internal static InvalidOperationException RelatedEndNotAttachedToContext(string relatedEndType) { 1041 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_RelatedEndNotAttachedToContext(relatedEndType)); 1042 } CannotCreateRelationshipBetweenTrackedAndNoTrackedEntities(string roleName)1043 internal static InvalidOperationException CannotCreateRelationshipBetweenTrackedAndNoTrackedEntities(string roleName) { 1044 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_CannotCreateRelationshipBetweenTrackedAndNoTrackedEntities(roleName)); 1045 } CannotCreateRelationshipEntitiesInDifferentContexts()1046 internal static InvalidOperationException CannotCreateRelationshipEntitiesInDifferentContexts() { 1047 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_CannotCreateRelationshipEntitiesInDifferentContexts); 1048 } InvalidContainedTypeCollection(string entityType, string relatedEndType)1049 internal static InvalidOperationException InvalidContainedTypeCollection(string entityType, string relatedEndType) { 1050 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidContainedType_Collection(entityType, relatedEndType)); 1051 } InvalidContainedTypeReference(string entityType, string relatedEndType)1052 internal static InvalidOperationException InvalidContainedTypeReference(string entityType, string relatedEndType) { 1053 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidContainedType_Reference(entityType, relatedEndType)); 1054 } CannotAddToFixedSizeArray(object collectionType)1055 internal static InvalidOperationException CannotAddToFixedSizeArray(object collectionType) { 1056 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_CannotAddToFixedSizeArray(collectionType.GetType())); 1057 } CannotRemoveFromFixedSizeArray(object collectionType)1058 internal static InvalidOperationException CannotRemoveFromFixedSizeArray(object collectionType) { 1059 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_CannotRemoveFromFixedSizeArray(collectionType.GetType())); 1060 } OwnerIsNull()1061 internal static InvalidOperationException OwnerIsNull() { 1062 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_OwnerIsNull); 1063 } UnableToAddRelationshipWithDeletedEntity()1064 internal static InvalidOperationException UnableToAddRelationshipWithDeletedEntity() { 1065 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_UnableToAddRelationshipWithDeletedEntity); 1066 } ConflictingChangeOfRelationshipDetected()1067 internal static InvalidOperationException ConflictingChangeOfRelationshipDetected() { 1068 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_ConflictingChangeOfRelationshipDetected); 1069 } InvalidRelationshipFixupDetected(string propertyName, string entityType)1070 internal static InvalidOperationException InvalidRelationshipFixupDetected(string propertyName, string entityType) { 1071 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidRelationshipFixupDetected(propertyName, entityType)); 1072 } LessThanExpectedRelatedEntitiesFound()1073 internal static InvalidOperationException LessThanExpectedRelatedEntitiesFound() 1074 { 1075 return InvalidOperation(System.Data.Entity.Strings.EntityReference_LessThanExpectedRelatedEntitiesFound); 1076 } MoreThanExpectedRelatedEntitiesFound()1077 internal static InvalidOperationException MoreThanExpectedRelatedEntitiesFound() { 1078 return InvalidOperation(System.Data.Entity.Strings.EntityReference_MoreThanExpectedRelatedEntitiesFound); 1079 } CannotChangeReferentialConstraintProperty()1080 internal static InvalidOperationException CannotChangeReferentialConstraintProperty() { 1081 return InvalidOperation(System.Data.Entity.Strings.EntityReference_CannotChangeReferentialConstraintProperty); 1082 } RelatedEndNotFound()1083 internal static InvalidOperationException RelatedEndNotFound() { 1084 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_RelatedEndNotFound); 1085 } LoadCalledOnNonEmptyNoTrackedRelatedEnd()1086 internal static InvalidOperationException LoadCalledOnNonEmptyNoTrackedRelatedEnd() { 1087 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_LoadCalledOnNonEmptyNoTrackedRelatedEnd); 1088 } LoadCalledOnAlreadyLoadedNoTrackedRelatedEnd()1089 internal static InvalidOperationException LoadCalledOnAlreadyLoadedNoTrackedRelatedEnd() { 1090 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_LoadCalledOnAlreadyLoadedNoTrackedRelatedEnd); 1091 } MismatchedMergeOptionOnLoad(MergeOption mergeOption)1092 internal static InvalidOperationException MismatchedMergeOptionOnLoad(MergeOption mergeOption) { 1093 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_MismatchedMergeOptionOnLoad(mergeOption)); 1094 } EntitySetIsNotValidForRelationship(string entitySetContainerName, string entitySetName, string roleName, string associationSetContainerName, string associationSetName)1095 internal static InvalidOperationException EntitySetIsNotValidForRelationship(string entitySetContainerName, string entitySetName, string roleName, string associationSetContainerName, string associationSetName) { 1096 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_EntitySetIsNotValidForRelationship(entitySetContainerName, entitySetName, roleName, associationSetContainerName, associationSetName)); 1097 } UnableToRetrieveReferentialConstraintProperties()1098 internal static InvalidOperationException UnableToRetrieveReferentialConstraintProperties() { 1099 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_UnableToRetrieveReferentialConstraintProperties); 1100 } InconsistentReferentialConstraintProperties()1101 internal static InvalidOperationException InconsistentReferentialConstraintProperties() { 1102 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_InconsistentReferentialConstraintProperties); 1103 } CircularRelationshipsWithReferentialConstraints()1104 internal static InvalidOperationException CircularRelationshipsWithReferentialConstraints() { 1105 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_CircularRelationshipsWithReferentialConstraints); 1106 } UnableToFindRelationshipTypeInMetadata(string relationshipName, string parameterName)1107 internal static ArgumentException UnableToFindRelationshipTypeInMetadata(string relationshipName, string parameterName) { 1108 return Argument(System.Data.Entity.Strings.RelationshipManager_UnableToFindRelationshipTypeInMetadata(relationshipName), parameterName); 1109 } InvalidTargetRole(string relationshipName, string targetRoleName, string parameterName)1110 internal static ArgumentException InvalidTargetRole(string relationshipName, string targetRoleName, string parameterName) { 1111 return Argument(System.Data.Entity.Strings.RelationshipManager_InvalidTargetRole(relationshipName, targetRoleName), parameterName); 1112 } OwnerIsNotSourceType(string ownerType, string sourceRoleType, string sourceRoleName, string relationshipName)1113 internal static InvalidOperationException OwnerIsNotSourceType(string ownerType, string sourceRoleType, string sourceRoleName, string relationshipName) { 1114 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_OwnerIsNotSourceType(ownerType, sourceRoleType, sourceRoleName, relationshipName)); 1115 } UnexpectedNullContext()1116 internal static InvalidOperationException UnexpectedNullContext() { 1117 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_UnexpectedNullContext); 1118 } ReferenceAlreadyInitialized()1119 internal static InvalidOperationException ReferenceAlreadyInitialized() { 1120 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_ReferenceAlreadyInitialized(System.Data.Entity.Strings.RelationshipManager_InitializeIsForDeserialization)); 1121 } RelationshipManagerAttached()1122 internal static InvalidOperationException RelationshipManagerAttached() { 1123 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_RelationshipManagerAttached(System.Data.Entity.Strings.RelationshipManager_InitializeIsForDeserialization)); 1124 } CollectionAlreadyInitialized()1125 internal static InvalidOperationException CollectionAlreadyInitialized() { 1126 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_CollectionAlreadyInitialized(System.Data.Entity.Strings.RelationshipManager_CollectionInitializeIsForDeserialization)); 1127 } CollectionRelationshipManagerAttached()1128 internal static InvalidOperationException CollectionRelationshipManagerAttached() { 1129 return InvalidOperation(System.Data.Entity.Strings.RelationshipManager_CollectionRelationshipManagerAttached(System.Data.Entity.Strings.RelationshipManager_CollectionInitializeIsForDeserialization)); 1130 } CheckContextNull(ObjectContext context)1131 internal static void CheckContextNull(ObjectContext context) 1132 { 1133 if ((object)context == null) 1134 { 1135 throw EntityUtil.UnexpectedNullContext(); 1136 } 1137 } 1138 CheckArgumentMergeOption(MergeOption mergeOption)1139 internal static void CheckArgumentMergeOption(MergeOption mergeOption) { 1140 switch(mergeOption) { 1141 case MergeOption.NoTracking: 1142 case MergeOption.AppendOnly: 1143 case MergeOption.OverwriteChanges: 1144 case MergeOption.PreserveChanges: 1145 break; 1146 default: 1147 throw EntityUtil.InvalidMergeOption(mergeOption); 1148 } 1149 } CheckArgumentRefreshMode(RefreshMode refreshMode)1150 internal static void CheckArgumentRefreshMode(RefreshMode refreshMode) { 1151 switch(refreshMode) { 1152 case RefreshMode.ClientWins: 1153 case RefreshMode.StoreWins: 1154 break; 1155 default: 1156 throw EntityUtil.InvalidRefreshMode(refreshMode); 1157 } 1158 } InvalidEntityStateSource()1159 internal static InvalidOperationException InvalidEntityStateSource() { 1160 return InvalidOperation(System.Data.Entity.Strings.Collections_InvalidEntityStateSource); 1161 } InvalidEntityStateLoad(string relatedEndType)1162 internal static InvalidOperationException InvalidEntityStateLoad(string relatedEndType) { 1163 return InvalidOperation(System.Data.Entity.Strings.Collections_InvalidEntityStateLoad(relatedEndType)); 1164 } InvalidOwnerStateForAttach()1165 internal static InvalidOperationException InvalidOwnerStateForAttach() { 1166 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidOwnerStateForAttach); 1167 } InvalidNthElementNullForAttach(int index)1168 internal static InvalidOperationException InvalidNthElementNullForAttach(int index) { 1169 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidNthElementNullForAttach(index)); 1170 } InvalidNthElementContextForAttach(int index)1171 internal static InvalidOperationException InvalidNthElementContextForAttach(int index) { 1172 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidNthElementContextForAttach(index)); 1173 } InvalidNthElementStateForAttach(int index)1174 internal static InvalidOperationException InvalidNthElementStateForAttach(int index) { 1175 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidNthElementStateForAttach(index)); 1176 } InvalidEntityContextForAttach()1177 internal static InvalidOperationException InvalidEntityContextForAttach() { 1178 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidEntityContextForAttach); 1179 } InvalidEntityStateForAttach()1180 internal static InvalidOperationException InvalidEntityStateForAttach() { 1181 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_InvalidEntityStateForAttach); 1182 } UnableToAddToDisconnectedRelatedEnd()1183 internal static InvalidOperationException UnableToAddToDisconnectedRelatedEnd() { 1184 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_UnableToAddEntity); 1185 } UnableToRemoveFromDisconnectedRelatedEnd()1186 internal static InvalidOperationException UnableToRemoveFromDisconnectedRelatedEnd() { 1187 return InvalidOperation(System.Data.Entity.Strings.RelatedEnd_UnableToRemoveEntity); 1188 } ProxyMetadataIsUnavailable(Type type, Exception inner)1189 internal static InvalidOperationException ProxyMetadataIsUnavailable(Type type, Exception inner) { 1190 return InvalidOperation(System.Data.Entity.Strings.EntityProxyTypeInfo_ProxyMetadataIsUnavailable(type.FullName), inner); 1191 } DuplicateTypeForProxyType(Type type)1192 internal static InvalidOperationException DuplicateTypeForProxyType(Type type) { 1193 return InvalidOperation(System.Data.Entity.Strings.EntityProxyTypeInfo_DuplicateOSpaceType(type.FullName)); 1194 } 1195 #endregion 1196 1197 #region ObjectContext errors ClientEntityRemovedFromStore(string entitiesKeys)1198 internal static InvalidOperationException ClientEntityRemovedFromStore(string entitiesKeys) { 1199 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_ClientEntityRemovedFromStore(entitiesKeys)); 1200 } StoreEntityNotPresentInClient()1201 internal static InvalidOperationException StoreEntityNotPresentInClient() { 1202 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_StoreEntityNotPresentInClient); 1203 } ContextMetadataHasChanged()1204 internal static InvalidOperationException ContextMetadataHasChanged() { 1205 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_MetadataHasChanged); 1206 } InvalidConnection(bool isConnectionConstructor, Exception innerException)1207 internal static ArgumentException InvalidConnection(bool isConnectionConstructor, Exception innerException) 1208 { 1209 if (isConnectionConstructor) 1210 { 1211 return InvalidConnection("connection", innerException); 1212 } 1213 else 1214 { 1215 return InvalidConnectionString("connectionString", innerException); 1216 } 1217 } InvalidConnectionString(string parameter, Exception inner)1218 internal static ArgumentException InvalidConnectionString(string parameter, Exception inner) { 1219 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectContext_InvalidConnectionString, parameter, inner); 1220 } InvalidConnection(string parameter, Exception inner)1221 internal static ArgumentException InvalidConnection(string parameter, Exception inner) { 1222 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectContext_InvalidConnection, parameter, inner); 1223 } InvalidDataAdapter()1224 internal static InvalidOperationException InvalidDataAdapter() { 1225 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_InvalidDataAdapter); 1226 } InvalidDefaultContainerName(string parameter, string defaultContainerName)1227 internal static ArgumentException InvalidDefaultContainerName(string parameter, string defaultContainerName) { 1228 return EntityUtil.Argument(System.Data.Entity.Strings.ObjectContext_InvalidDefaultContainerName(defaultContainerName), parameter); 1229 } NthElementInAddedState(int i)1230 internal static InvalidOperationException NthElementInAddedState(int i) { 1231 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_NthElementInAddedState(i)); 1232 } NthElementIsDuplicate(int i)1233 internal static InvalidOperationException NthElementIsDuplicate(int i) { 1234 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_NthElementIsDuplicate(i)); 1235 } NthElementIsNull(int i)1236 internal static InvalidOperationException NthElementIsNull(int i) { 1237 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_NthElementIsNull(i)); 1238 } NthElementNotInObjectStateManager(int i)1239 internal static InvalidOperationException NthElementNotInObjectStateManager(int i) { 1240 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_NthElementNotInObjectStateManager(i)); 1241 } ObjectContextDisposed()1242 internal static ObjectDisposedException ObjectContextDisposed() { 1243 return EntityUtil.ObjectDisposed(System.Data.Entity.Strings.ObjectContext_ObjectDisposed); 1244 } ObjectNotFound()1245 internal static ObjectNotFoundException ObjectNotFound() { 1246 return EntityUtil.ObjectNotFound(System.Data.Entity.Strings.ObjectContext_ObjectNotFound); 1247 } InvalidEntityType(Type type)1248 internal static InvalidOperationException InvalidEntityType(Type type) { 1249 Debug.Assert(type != null, "The type cannot be null."); 1250 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_NoMappingForEntityType(type.FullName)); 1251 } CannotDeleteEntityNotInObjectStateManager()1252 internal static InvalidOperationException CannotDeleteEntityNotInObjectStateManager() { 1253 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_CannotDeleteEntityNotInObjectStateManager); 1254 } CannotDetachEntityNotInObjectStateManager()1255 internal static InvalidOperationException CannotDetachEntityNotInObjectStateManager() { 1256 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_CannotDetachEntityNotInObjectStateManager); 1257 } EntitySetNotFoundForName(string entitySetName)1258 internal static InvalidOperationException EntitySetNotFoundForName(string entitySetName) { 1259 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntitySetNotFoundForName(entitySetName)); 1260 } EntityContainterNotFoundForName(string entityContainerName)1261 internal static InvalidOperationException EntityContainterNotFoundForName(string entityContainerName) { 1262 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityContainerNotFoundForName(entityContainerName)); 1263 } InvalidCommandTimeout(string argument)1264 internal static ArgumentException InvalidCommandTimeout(string argument) { 1265 return Argument(System.Data.Entity.Strings.ObjectContext_InvalidCommandTimeout, argument); 1266 } EntityAlreadyExistsInObjectStateManager()1267 internal static InvalidOperationException EntityAlreadyExistsInObjectStateManager() { 1268 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityAlreadyExistsInObjectStateManager); 1269 } InvalidEntitySetInKey(string keyContainer, string keyEntitySet, string expectedContainer, string expectedEntitySet)1270 internal static InvalidOperationException InvalidEntitySetInKey(string keyContainer, string keyEntitySet, string expectedContainer, string expectedEntitySet) { 1271 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_InvalidEntitySetInKey(keyContainer, keyEntitySet, expectedContainer, expectedEntitySet)); 1272 } InvalidEntitySetInKeyFromName(string keyContainer, string keyEntitySet, string expectedContainer, string expectedEntitySet, string argument)1273 internal static InvalidOperationException InvalidEntitySetInKeyFromName(string keyContainer, string keyEntitySet, string expectedContainer, string expectedEntitySet, string argument) { 1274 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_InvalidEntitySetInKeyFromName(keyContainer, keyEntitySet, expectedContainer, expectedEntitySet, argument)); 1275 } CannotAttachEntityWithoutKey()1276 internal static InvalidOperationException CannotAttachEntityWithoutKey() { 1277 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_CannotAttachEntityWithoutKey); 1278 } CannotAttachEntityWithTemporaryKey()1279 internal static InvalidOperationException CannotAttachEntityWithTemporaryKey() { 1280 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_CannotAttachEntityWithTemporaryKey); 1281 } EntitySetNameOrEntityKeyRequired()1282 internal static InvalidOperationException EntitySetNameOrEntityKeyRequired() { 1283 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntitySetNameOrEntityKeyRequired); 1284 } ExecuteFunctionTypeMismatch(Type typeArgument, EdmType expectedElementType)1285 internal static InvalidOperationException ExecuteFunctionTypeMismatch(Type typeArgument, EdmType expectedElementType) { 1286 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_ExecuteFunctionTypeMismatch( 1287 typeArgument.FullName, 1288 expectedElementType.FullName)); 1289 } ExecuteFunctionCalledWithNonReaderFunction(EdmFunction functionImport)1290 internal static InvalidOperationException ExecuteFunctionCalledWithNonReaderFunction(EdmFunction functionImport) { 1291 // report ExecuteNonQuery return type if no explicit return type is given 1292 string message; 1293 if (null == functionImport.ReturnParameter) 1294 { 1295 message = System.Data.Entity.Strings.ObjectContext_ExecuteFunctionCalledWithNonQueryFunction( 1296 functionImport.Name); 1297 } 1298 else 1299 { 1300 message = System.Data.Entity.Strings.ObjectContext_ExecuteFunctionCalledWithScalarFunction( 1301 functionImport.ReturnParameter.TypeUsage.EdmType.FullName, functionImport.Name); 1302 } 1303 return InvalidOperation(message); 1304 } QualfiedEntitySetName(string parameterName)1305 internal static ArgumentException QualfiedEntitySetName(string parameterName) { 1306 return Argument(System.Data.Entity.Strings.ObjectContext_QualfiedEntitySetName, parameterName); 1307 } ContainerQualifiedEntitySetNameRequired(string argument)1308 internal static ArgumentException ContainerQualifiedEntitySetNameRequired(string argument) { 1309 return Argument(System.Data.Entity.Strings.ObjectContext_ContainerQualifiedEntitySetNameRequired, argument); 1310 } CannotSetDefaultContainerName()1311 internal static InvalidOperationException CannotSetDefaultContainerName() { 1312 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_CannotSetDefaultContainerName); 1313 } EntitiesHaveDifferentType(string originalEntityTypeName, string changedEntityTypeName)1314 internal static ArgumentException EntitiesHaveDifferentType(string originalEntityTypeName, string changedEntityTypeName) { 1315 return Argument(System.Data.Entity.Strings.ObjectContext_EntitiesHaveDifferentType(originalEntityTypeName, changedEntityTypeName)); 1316 } EntityMustBeUnchangedOrModified(EntityState state)1317 internal static InvalidOperationException EntityMustBeUnchangedOrModified(EntityState state) { 1318 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityMustBeUnchangedOrModified(state.ToString())); 1319 } EntityMustBeUnchangedOrModifiedOrDeleted(EntityState state)1320 internal static InvalidOperationException EntityMustBeUnchangedOrModifiedOrDeleted(EntityState state) { 1321 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityMustBeUnchangedOrModifiedOrDeleted(state.ToString())); 1322 } EntityNotTrackedOrHasTempKey()1323 internal static InvalidOperationException EntityNotTrackedOrHasTempKey() 1324 { 1325 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityNotTrackedOrHasTempKey); 1326 } 1327 AcceptAllChangesFailure(Exception e)1328 internal static InvalidOperationException AcceptAllChangesFailure(Exception e) { 1329 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_AcceptAllChangesFailure(e.Message)); 1330 } InvalidEntitySetOnEntity(string entitySetName, Type entityType, string parameter)1331 internal static ArgumentException InvalidEntitySetOnEntity(string entitySetName, Type entityType, string parameter) { 1332 return Argument(System.Data.Entity.Strings.ObjectContext_InvalidEntitySetOnEntity(entitySetName, entityType), parameter); 1333 } InvalidEntityTypeForObjectSet(string tEntityType, string entitySetType, string entitySetName, string parameter)1334 internal static ArgumentException InvalidEntityTypeForObjectSet(string tEntityType, string entitySetType, string entitySetName, string parameter) { 1335 return Argument(System.Data.Entity.Strings.ObjectContext_InvalidObjectSetTypeForEntitySet(tEntityType, entitySetType, entitySetName), parameter); 1336 } RequiredMetadataNotAvailable()1337 internal static InvalidOperationException RequiredMetadataNotAvailable() { 1338 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_RequiredMetadataNotAvailble); 1339 } 1340 MultipleEntitySetsFoundInSingleContainer(string entityTypeName, string entityContainerName, string exceptionParameterName)1341 internal static ArgumentException MultipleEntitySetsFoundInSingleContainer(string entityTypeName, string entityContainerName, string exceptionParameterName) { 1342 return Argument(System.Data.Entity.Strings.ObjectContext_MultipleEntitySetsFoundInSingleContainer(entityTypeName, entityContainerName), exceptionParameterName); 1343 } 1344 MultipleEntitySetsFoundInAllContainers(string entityTypeName, string exceptionParameterName)1345 internal static ArgumentException MultipleEntitySetsFoundInAllContainers(string entityTypeName, string exceptionParameterName) { 1346 return Argument(System.Data.Entity.Strings.ObjectContext_MultipleEntitySetsFoundInAllContainers(entityTypeName), exceptionParameterName); 1347 } 1348 NoEntitySetFoundForType(string entityTypeName, string exceptionParameterName)1349 internal static ArgumentException NoEntitySetFoundForType(string entityTypeName, string exceptionParameterName) { 1350 return Argument(System.Data.Entity.Strings.ObjectContext_NoEntitySetFoundForType(entityTypeName), exceptionParameterName); 1351 } EntityNotInObjectSet_Delete(string actualContainerName, string actualEntitySetName, string expectedContainerName, string expectedEntitySetName)1352 internal static InvalidOperationException EntityNotInObjectSet_Delete(string actualContainerName, string actualEntitySetName, string expectedContainerName, string expectedEntitySetName) { 1353 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityNotInObjectSet_Delete(actualContainerName, actualEntitySetName, expectedContainerName, expectedEntitySetName)); 1354 } 1355 EntityNotInObjectSet_Detach(string actualContainerName, string actualEntitySetName, string expectedContainerName, string expectedEntitySetName)1356 internal static InvalidOperationException EntityNotInObjectSet_Detach(string actualContainerName, string actualEntitySetName, string expectedContainerName, string expectedEntitySetName) { 1357 return InvalidOperation(System.Data.Entity.Strings.ObjectContext_EntityNotInObjectSet_Detach(actualContainerName, actualEntitySetName, expectedContainerName, expectedEntitySetName)); 1358 } 1359 InvalidRelationshipStateArgument(string paramName)1360 internal static ArgumentException InvalidRelationshipStateArgument(string paramName) 1361 { 1362 return new ArgumentException(Strings.ObjectContext_InvalidRelationshipState, paramName); 1363 } 1364 InvalidEntityStateArgument(string paramName)1365 internal static ArgumentException InvalidEntityStateArgument(string paramName) 1366 { 1367 return new ArgumentException(Strings.ObjectContext_InvalidEntityState, paramName); 1368 } 1369 1370 #endregion 1371 1372 #region Complex Types Errors 1373 // Complex types exceptions NullableComplexTypesNotSupported(string propertyName)1374 internal static InvalidOperationException NullableComplexTypesNotSupported(string propertyName) 1375 { 1376 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ComplexObject_NullableComplexTypesNotSupported(propertyName)); 1377 } ComplexObjectAlreadyAttachedToParent()1378 internal static InvalidOperationException ComplexObjectAlreadyAttachedToParent() 1379 { 1380 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.ComplexObject_ComplexObjectAlreadyAttachedToParent); 1381 } ComplexChangeRequestedOnScalarProperty(string propertyName)1382 internal static ArgumentException ComplexChangeRequestedOnScalarProperty(string propertyName) 1383 { 1384 return EntityUtil.Argument(System.Data.Entity.Strings.ComplexObject_ComplexChangeRequestedOnScalarProperty(propertyName)); 1385 } 1386 #endregion 1387 SpanPathSyntaxError()1388 internal static ArgumentException SpanPathSyntaxError() { 1389 return Argument(System.Data.Entity.Strings.ObjectQuery_Span_SpanPathSyntaxError); 1390 } 1391 1392 /// <summary> 1393 /// This is only used for Include path argument, thus the parameter name is hardcoded to "path" 1394 /// </summary> 1395 /// <returns></returns> ADP_InvalidMultipartNameDelimiterUsage()1396 static internal ArgumentException ADP_InvalidMultipartNameDelimiterUsage() 1397 { 1398 return Argument(System.Data.Entity.Strings.ADP_InvalidMultipartNameDelimiterUsage, "path"); 1399 } 1400 InvalidConnectionOptionValue(string key)1401 static internal Exception InvalidConnectionOptionValue(string key) 1402 { 1403 return Argument(System.Data.Entity.Strings.ADP_InvalidConnectionOptionValue(key)); 1404 } 1405 InvalidSizeValue(int value)1406 static internal ArgumentException InvalidSizeValue(int value) 1407 { 1408 return Argument(System.Data.Entity.Strings.ADP_InvalidSizeValue(value.ToString(CultureInfo.InvariantCulture))); 1409 } 1410 ConnectionStringSyntax(int index)1411 static internal ArgumentException ConnectionStringSyntax(int index) 1412 { 1413 return Argument(System.Data.Entity.Strings.ADP_ConnectionStringSyntax(index)); 1414 } 1415 DataRecordMustBeEntity()1416 internal static InvalidOperationException DataRecordMustBeEntity() { 1417 return InvalidOperation(System.Data.Entity.Strings.EntityKey_DataRecordMustBeEntity); 1418 } EntitySetDoesNotMatch(string argument, string entitySetName)1419 internal static ArgumentException EntitySetDoesNotMatch(string argument, string entitySetName) { 1420 return Argument(System.Data.Entity.Strings.EntityKey_EntitySetDoesNotMatch(entitySetName), argument); 1421 } EntityTypesDoNotMatch(string recordType, string entitySetType)1422 internal static InvalidOperationException EntityTypesDoNotMatch(string recordType, string entitySetType) { 1423 return InvalidOperation(System.Data.Entity.Strings.EntityKey_EntityTypesDoNotMatch(recordType, entitySetType)); 1424 } IncorrectNumberOfKeyValuePairs(string argument, string typeName, int expectedNumFields, int actualNumFields)1425 internal static ArgumentException IncorrectNumberOfKeyValuePairs(string argument, string typeName, int expectedNumFields, int actualNumFields) { 1426 return Argument(System.Data.Entity.Strings.EntityKey_IncorrectNumberOfKeyValuePairs(typeName, expectedNumFields, actualNumFields), argument); 1427 } IncorrectNumberOfKeyValuePairsInvalidOperation(string typeName, int expectedNumFields, int actualNumFields)1428 internal static InvalidOperationException IncorrectNumberOfKeyValuePairsInvalidOperation(string typeName, int expectedNumFields, int actualNumFields) 1429 { 1430 return InvalidOperation(System.Data.Entity.Strings.EntityKey_IncorrectNumberOfKeyValuePairs(typeName, expectedNumFields, actualNumFields)); 1431 } IncorrectValueType(string argument, string keyField, string expectedTypeName, string actualTypeName)1432 internal static ArgumentException IncorrectValueType(string argument, string keyField, string expectedTypeName, string actualTypeName) { 1433 return Argument(System.Data.Entity.Strings.EntityKey_IncorrectValueType(keyField, expectedTypeName, actualTypeName), argument); 1434 } IncorrectValueTypeInvalidOperation(string keyField, string expectedTypeName, string actualTypeName)1435 internal static InvalidOperationException IncorrectValueTypeInvalidOperation(string keyField, string expectedTypeName, string actualTypeName) { 1436 return InvalidOperation(System.Data.Entity.Strings.EntityKey_IncorrectValueType(keyField, expectedTypeName, actualTypeName)); 1437 } NoCorrespondingOSpaceTypeForEnumKeyField(string argument, string keyField, string cspaceTypeName)1438 internal static ArgumentException NoCorrespondingOSpaceTypeForEnumKeyField(string argument, string keyField, string cspaceTypeName) { 1439 return Argument(System.Data.Entity.Strings.EntityKey_NoCorrespondingOSpaceTypeForEnumKeyMember(keyField, cspaceTypeName), argument); 1440 } NoCorrespondingOSpaceTypeForEnumKeyFieldInvalidOperation(string keyField, string cspaceTypeName)1441 internal static InvalidOperationException NoCorrespondingOSpaceTypeForEnumKeyFieldInvalidOperation(string keyField, string cspaceTypeName) { 1442 return InvalidOperation(System.Data.Entity.Strings.EntityKey_NoCorrespondingOSpaceTypeForEnumKeyMember(keyField, cspaceTypeName)); 1443 } MissingKeyValue(string argument, string keyField, string typeName)1444 internal static ArgumentException MissingKeyValue(string argument, string keyField, string typeName) { 1445 return MissingKeyValue(argument, keyField, typeName, null); 1446 } MissingKeyValue(string argument, string keyField, string typeName, Exception inner)1447 internal static ArgumentException MissingKeyValue(string argument, string keyField, string typeName, Exception inner) { 1448 return Argument(System.Data.Entity.Strings.EntityKey_MissingKeyValue(keyField, typeName), argument); 1449 } NullKeyValue(string keyField, string typeName)1450 internal static InvalidOperationException NullKeyValue(string keyField, string typeName) 1451 { 1452 return InvalidOperation(System.Data.Entity.Strings.EntityKey_NullKeyValue(keyField, typeName)); 1453 } MissingKeyValueInvalidOperation(string keyField, string typeName)1454 internal static InvalidOperationException MissingKeyValueInvalidOperation(string keyField, string typeName) 1455 { 1456 return InvalidOperation(System.Data.Entity.Strings.EntityKey_MissingKeyValue(keyField, typeName)); 1457 } NoNullsAllowedInKeyValuePairs(string argument)1458 internal static ArgumentException NoNullsAllowedInKeyValuePairs(string argument) { 1459 return Argument(System.Data.Entity.Strings.EntityKey_NoNullsAllowedInKeyValuePairs, argument); 1460 } EntityKeyMustHaveValues(string argument)1461 internal static ArgumentException EntityKeyMustHaveValues(string argument) { 1462 return Argument(System.Data.Entity.Strings.EntityKey_EntityKeyMustHaveValues, argument); 1463 } InvalidQualifiedEntitySetName()1464 internal static ArgumentException InvalidQualifiedEntitySetName() { 1465 return Argument(System.Data.Entity.Strings.EntityKey_InvalidQualifiedEntitySetName, "qualifiedEntitySetName"); 1466 } EntityKeyInvalidName(string invalidName)1467 internal static ArgumentException EntityKeyInvalidName(string invalidName) { 1468 return Argument(System.Data.Entity.Strings.EntityKey_InvalidName(invalidName)); 1469 } MissingQualifiedEntitySetName()1470 internal static InvalidOperationException MissingQualifiedEntitySetName() { 1471 return InvalidOperation(System.Data.Entity.Strings.EntityKey_MissingEntitySetName); 1472 } CannotChangeEntityKey()1473 internal static InvalidOperationException CannotChangeEntityKey() { 1474 return InvalidOperation(System.Data.Entity.Strings.EntityKey_CannotChangeKey); 1475 } 1476 UnexpectedNullEntityKey()1477 internal static InvalidOperationException UnexpectedNullEntityKey() 1478 { 1479 return new InvalidOperationException(System.Data.Entity.Strings.EntityKey_UnexpectedNull); 1480 } EntityKeyDoesntMatchKeySetOnEntity(object entity)1481 internal static InvalidOperationException EntityKeyDoesntMatchKeySetOnEntity(object entity) 1482 { 1483 return new InvalidOperationException(System.Data.Entity.Strings.EntityKey_DoesntMatchKeyOnEntity(entity.GetType().FullName)); 1484 } CheckEntityKeyNull(EntityKey entityKey)1485 internal static void CheckEntityKeyNull(EntityKey entityKey) 1486 { 1487 if ((object)entityKey == null) 1488 { 1489 throw EntityUtil.UnexpectedNullEntityKey(); 1490 } 1491 } CheckEntityKeysMatch(IEntityWrapper wrappedEntity, EntityKey key)1492 internal static void CheckEntityKeysMatch(IEntityWrapper wrappedEntity, EntityKey key) 1493 { 1494 if (wrappedEntity.EntityKey != key) 1495 { 1496 throw EntityUtil.EntityKeyDoesntMatchKeySetOnEntity(wrappedEntity.Entity); 1497 } 1498 } UnexpectedNullRelationshipManager()1499 internal static InvalidOperationException UnexpectedNullRelationshipManager() 1500 { 1501 return new InvalidOperationException(System.Data.Entity.Strings.RelationshipManager_UnexpectedNull); 1502 } InvalidRelationshipManagerOwner()1503 internal static InvalidOperationException InvalidRelationshipManagerOwner() 1504 { 1505 return EntityUtil.InvalidOperation(System.Data.Entity.Strings.RelationshipManager_InvalidRelationshipManagerOwner); 1506 } 1507 ValidateEntitySetInKey(EntityKey key, EntitySet entitySet)1508 internal static void ValidateEntitySetInKey(EntityKey key, EntitySet entitySet) 1509 { 1510 ValidateEntitySetInKey(key, entitySet, null); 1511 } ValidateEntitySetInKey(EntityKey key, EntitySet entitySet, string argument)1512 internal static void ValidateEntitySetInKey(EntityKey key, EntitySet entitySet, string argument) 1513 { 1514 Debug.Assert(null != (object)key, "Null entity key"); 1515 Debug.Assert(null != entitySet, "Null entity set"); 1516 Debug.Assert(null != entitySet.EntityContainer, "Null entity container in the entity set"); 1517 1518 string containerName1 = key.EntityContainerName; 1519 string setName1 = key.EntitySetName; 1520 string containerName2 = entitySet.EntityContainer.Name; 1521 string setName2 = entitySet.Name; 1522 1523 if (!StringComparer.Ordinal.Equals(containerName1, containerName2) || 1524 !StringComparer.Ordinal.Equals(setName1, setName2)) 1525 { 1526 if (String.IsNullOrEmpty(argument)) 1527 { 1528 throw EntityUtil.InvalidEntitySetInKey( 1529 containerName1, setName1, 1530 containerName2, setName2); 1531 } 1532 else 1533 { 1534 throw EntityUtil.InvalidEntitySetInKeyFromName( 1535 containerName1, setName1, 1536 containerName2, setName2, argument); 1537 } 1538 } 1539 } 1540 1541 1542 1543 // IDataParameter.Direction InvalidMergeOption(MergeOption value)1544 static internal ArgumentOutOfRangeException InvalidMergeOption(MergeOption value) { 1545 #if DEBUG 1546 switch(value) { 1547 case MergeOption.NoTracking: 1548 case MergeOption.OverwriteChanges: 1549 case MergeOption.PreserveChanges: 1550 case MergeOption.AppendOnly: 1551 Debug.Assert(false, "valid MergeOption " + value.ToString()); 1552 break; 1553 } 1554 #endif 1555 return InvalidEnumerationValue(typeof(MergeOption), (int) value); 1556 } 1557 InvalidRefreshMode(RefreshMode value)1558 static internal ArgumentOutOfRangeException InvalidRefreshMode(RefreshMode value) { 1559 #if DEBUG 1560 switch(value) { 1561 case RefreshMode.ClientWins: 1562 case RefreshMode.StoreWins: 1563 Debug.Assert(false, "valid RefreshMode " + value.ToString()); 1564 break; 1565 } 1566 #endif 1567 return InvalidEnumerationValue(typeof(RefreshMode), (int) value); 1568 } 1569 1570 // 1571 // : IDataParameter 1572 // InvalidDataType(TypeCode typecode)1573 static internal ArgumentException InvalidDataType(TypeCode typecode) { 1574 return Argument(System.Data.Entity.Strings.ADP_InvalidDataType(typecode.ToString())); 1575 } 1576 UnknownDataTypeCode(Type dataType, TypeCode typeCode)1577 static internal ArgumentException UnknownDataTypeCode(Type dataType, TypeCode typeCode) { 1578 return Argument(System.Data.Entity.Strings.ADP_UnknownDataTypeCode(((int) typeCode).ToString(CultureInfo.InvariantCulture), dataType.FullName)); 1579 } 1580 InvalidParameterDirection(ParameterDirection value)1581 static internal ArgumentOutOfRangeException InvalidParameterDirection(ParameterDirection value) 1582 { 1583 #if DEBUG 1584 switch (value) 1585 { 1586 case ParameterDirection.Input: 1587 case ParameterDirection.Output: 1588 case ParameterDirection.InputOutput: 1589 case ParameterDirection.ReturnValue: 1590 Debug.Assert(false, "valid ParameterDirection " + value.ToString()); 1591 break; 1592 } 1593 #endif 1594 return InvalidEnumerationValue(typeof(ParameterDirection), (int)value); 1595 } InvalidDataRowVersion(DataRowVersion value)1596 static internal ArgumentOutOfRangeException InvalidDataRowVersion(DataRowVersion value) 1597 { 1598 #if DEBUG 1599 switch (value) 1600 { 1601 case DataRowVersion.Default: 1602 case DataRowVersion.Current: 1603 case DataRowVersion.Original: 1604 case DataRowVersion.Proposed: 1605 Debug.Assert(false, "valid DataRowVersion " + value.ToString()); 1606 break; 1607 } 1608 #endif 1609 1610 return InvalidEnumerationValue(typeof(DataRowVersion), (int)value); 1611 } 1612 // 1613 // UpdateException 1614 // ProcessStateEntries(IEnumerable<IEntityStateEntry> stateEntries)1615 static private IEnumerable<ObjectStateEntry> ProcessStateEntries(IEnumerable<IEntityStateEntry> stateEntries) 1616 { 1617 return stateEntries 1618 // In a future release, IEntityStateEntry will be public so we will be able to throw exceptions 1619 // with this more general type. For now we cast to ObjectStateEntry (the only implementation 1620 // of the internal interface). 1621 .Cast<ObjectStateEntry>() 1622 // Return distinct entries (no need to report an entry multiple times even if it contributes 1623 // to the exception in multiple ways) 1624 .Distinct(); 1625 } ValidateNecessaryModificationFunctionMapping( StorageModificationFunctionMapping mapping, string currentState, IEntityStateEntry stateEntry, string type, string typeName)1626 static internal void ValidateNecessaryModificationFunctionMapping( 1627 StorageModificationFunctionMapping mapping, string currentState, 1628 IEntityStateEntry stateEntry, string type, string typeName) 1629 { 1630 if (null == mapping) 1631 { 1632 throw EntityUtil.Update(Strings.Update_MissingFunctionMapping(currentState, type, typeName), 1633 null, 1634 new List<IEntityStateEntry>() { stateEntry }); 1635 } 1636 } Update(string message, Exception innerException, params IEntityStateEntry[] stateEntries)1637 static internal UpdateException Update(string message, Exception innerException, params IEntityStateEntry[] stateEntries) { 1638 return Update(message, innerException, (IEnumerable<IEntityStateEntry>)stateEntries); 1639 } Update(string message, Exception innerException, IEnumerable<IEntityStateEntry> stateEntries)1640 static internal UpdateException Update(string message, Exception innerException, IEnumerable<IEntityStateEntry> stateEntries) 1641 { 1642 return new UpdateException(message, innerException, ProcessStateEntries(stateEntries)); 1643 } UpdateConcurrency(long rowsAffected, Exception innerException, IEnumerable<IEntityStateEntry> stateEntries)1644 static internal OptimisticConcurrencyException UpdateConcurrency(long rowsAffected, Exception innerException, IEnumerable<IEntityStateEntry> stateEntries) 1645 { 1646 string message = System.Data.Entity.Strings.Update_ConcurrencyError(rowsAffected); 1647 return new OptimisticConcurrencyException(message, innerException, ProcessStateEntries(stateEntries)); 1648 } UpdateRelationshipCardinalityConstraintViolation(string relationshipSetName, int minimumCount, int? maximumCount, string entitySetName, int actualCount, string otherEndPluralName, IEntityStateEntry stateEntry)1649 static internal UpdateException UpdateRelationshipCardinalityConstraintViolation(string relationshipSetName, 1650 int minimumCount, int? maximumCount, string entitySetName, int actualCount, string otherEndPluralName, IEntityStateEntry stateEntry) { 1651 string minimumCountString = ConvertCardinalityToString(minimumCount); 1652 string maximumCountString = ConvertCardinalityToString(maximumCount); 1653 string actualCountString = ConvertCardinalityToString(actualCount); 1654 if (minimumCount == 1 && (minimumCountString == maximumCountString)) 1655 { 1656 // Just one acceptable value and itis value is 1 1657 return Update(System.Data.Entity.Strings.Update_RelationshipCardinalityConstraintViolationSingleValue( 1658 entitySetName, relationshipSetName, actualCountString, otherEndPluralName, 1659 minimumCountString), null, stateEntry); 1660 } 1661 else 1662 { 1663 // Range of acceptable values 1664 return Update(System.Data.Entity.Strings.Update_RelationshipCardinalityConstraintViolation( 1665 entitySetName, relationshipSetName, actualCountString, otherEndPluralName, 1666 minimumCountString, maximumCountString), null, stateEntry); 1667 } 1668 } UpdateEntityMissingConstraintViolation(string relationshipSetName, string endName, IEntityStateEntry stateEntry)1669 static internal UpdateException UpdateEntityMissingConstraintViolation(string relationshipSetName, string endName, IEntityStateEntry stateEntry) { 1670 string message = System.Data.Entity.Strings.Update_MissingRequiredEntity(relationshipSetName, stateEntry.State, endName); 1671 return Update(message, null, stateEntry); 1672 } ConvertCardinalityToString(int? cardinality)1673 static private string ConvertCardinalityToString(int? cardinality) { 1674 string result; 1675 if (!cardinality.HasValue) { // null indicates * (unlimited) 1676 result = "*"; 1677 } 1678 else { 1679 result = cardinality.Value.ToString(CultureInfo.CurrentCulture); 1680 } 1681 return result; 1682 } UpdateMissingEntity(string relationshipSetName, string entitySetName)1683 static internal UpdateException UpdateMissingEntity(string relationshipSetName, string entitySetName) { 1684 return Update(System.Data.Entity.Strings.Update_MissingEntity(relationshipSetName, entitySetName), null); 1685 } 1686 CollectionParameterElementIsNull(string parameterName)1687 static internal ArgumentException CollectionParameterElementIsNull(string parameterName) { 1688 return Argument(System.Data.Entity.Strings.ADP_CollectionParameterElementIsNull(parameterName)); 1689 } CollectionParameterElementIsNullOrEmpty(string parameterName)1690 static internal ArgumentException CollectionParameterElementIsNullOrEmpty(string parameterName) { 1691 return Argument(System.Data.Entity.Strings.ADP_CollectionParameterElementIsNullOrEmpty(parameterName)); 1692 } 1693 FunctionHasNoDefinition(EdmFunction function)1694 static internal InvalidOperationException FunctionHasNoDefinition(EdmFunction function) 1695 { 1696 return InvalidOperation(System.Data.Entity.Strings.Cqt_UDF_FunctionHasNoDefinition(function.Identity)); 1697 } 1698 FunctionDefinitionResultTypeMismatch(EdmFunction function, TypeUsage generatedDefinitionResultType)1699 static internal InvalidOperationException FunctionDefinitionResultTypeMismatch(EdmFunction function, TypeUsage generatedDefinitionResultType) 1700 { 1701 return InvalidOperation(System.Data.Entity.Strings.Cqt_UDF_FunctionDefinitionResultTypeMismatch( 1702 TypeHelpers.GetFullName(function.ReturnParameter.TypeUsage), 1703 function.FullName, 1704 TypeHelpers.GetFullName(generatedDefinitionResultType))); 1705 } 1706 EntityParameterCollectionInvalidIndex(int index, int count)1707 static internal Exception EntityParameterCollectionInvalidIndex(int index, int count) 1708 { 1709 return new IndexOutOfRangeException(System.Data.Entity.Strings.EntityParameterCollectionInvalidIndex(index.ToString(CultureInfo.InvariantCulture), count.ToString(CultureInfo.InvariantCulture))); 1710 } EntityParameterCollectionInvalidParameterName(string parameterName)1711 static internal Exception EntityParameterCollectionInvalidParameterName(string parameterName) 1712 { 1713 return new IndexOutOfRangeException(System.Data.Entity.Strings.EntityParameterCollectionInvalidParameterName(parameterName)); 1714 } EntityParameterNull(string parameter)1715 static internal Exception EntityParameterNull(string parameter) 1716 { 1717 return new ArgumentNullException(parameter, System.Data.Entity.Strings.EntityParameterNull); 1718 } InvalidEntityParameterType(object invalidValue)1719 static internal Exception InvalidEntityParameterType(object invalidValue) 1720 { 1721 return new InvalidCastException(System.Data.Entity.Strings.InvalidEntityParameterType(invalidValue.GetType().Name)); 1722 } EntityParameterCollectionRemoveInvalidObject()1723 static internal ArgumentException EntityParameterCollectionRemoveInvalidObject() 1724 { 1725 return new ArgumentException(System.Data.Entity.Strings.EntityParameterCollectionRemoveInvalidObject); 1726 } EntityParameterContainedByAnotherCollection()1727 static internal ArgumentException EntityParameterContainedByAnotherCollection() 1728 { 1729 return new ArgumentException(System.Data.Entity.Strings.EntityParameterContainedByAnotherCollection); 1730 } 1731 //////////////////////////////////////////////////////////////////////// 1732 //////////////////////////////////////////////////////////////////////// 1733 //////////////////////////////////////////////////////////////////////// 1734 // 1735 // Helper Functions 1736 // ThrowArgumentNullException(string parameterName)1737 internal static void ThrowArgumentNullException(string parameterName) 1738 { 1739 throw ArgumentNull(parameterName); 1740 } ThrowArgumentOutOfRangeException(string parameterName)1741 internal static void ThrowArgumentOutOfRangeException(string parameterName) 1742 { 1743 throw ArgumentOutOfRange(parameterName); 1744 } CheckArgumentOutOfRange(T[] values, int index, string parameterName)1745 internal static T CheckArgumentOutOfRange<T>(T[] values, int index, string parameterName) 1746 { 1747 Debug.Assert(null != values, "null values"); // use a different method if values can be null 1748 if (unchecked((uint)values.Length <= (uint)index)) 1749 { 1750 ThrowArgumentOutOfRangeException(parameterName); 1751 } 1752 return values[index]; 1753 } 1754 1755 static internal T CheckArgumentNull<T>(T value, string parameterName) where T : class 1756 { 1757 if (null == value) 1758 { 1759 ThrowArgumentNullException(parameterName); 1760 } 1761 return value; 1762 } 1763 1764 static internal IEnumerable<T> CheckArgumentContainsNull<T>(ref IEnumerable<T> enumerableArgument, string argumentName) where T : class 1765 { GetCheapestSafeEnumerableAsCollection(ref enumerableArgument)1766 GetCheapestSafeEnumerableAsCollection(ref enumerableArgument); 1767 foreach (T item in enumerableArgument) 1768 { 1769 if(item == null) 1770 { 1771 throw EntityUtil.Argument(Strings.CheckArgumentContainsNullFailed(argumentName)); 1772 } 1773 } 1774 return enumerableArgument; 1775 } 1776 CheckArgumentEmpty(ref IEnumerable<T> enumerableArgument, Func<string, string> errorMessage, string argumentName)1777 static internal IEnumerable<T> CheckArgumentEmpty<T>(ref IEnumerable<T> enumerableArgument, Func<string, string> errorMessage, string argumentName) 1778 { 1779 int count; 1780 GetCheapestSafeCountOfEnumerable(ref enumerableArgument, out count); 1781 if (count <= 0) 1782 { 1783 throw EntityUtil.Argument(errorMessage(argumentName)); 1784 } 1785 return enumerableArgument; 1786 } 1787 GetCheapestSafeCountOfEnumerable(ref IEnumerable<T> enumerable, out int count)1788 private static void GetCheapestSafeCountOfEnumerable<T>(ref IEnumerable<T> enumerable, out int count) 1789 { 1790 ICollection<T> collection = GetCheapestSafeEnumerableAsCollection(ref enumerable); 1791 count = collection.Count; 1792 } 1793 GetCheapestSafeEnumerableAsCollection(ref IEnumerable<T> enumerable)1794 private static ICollection<T> GetCheapestSafeEnumerableAsCollection<T>(ref IEnumerable<T> enumerable) 1795 { 1796 ICollection<T> collection = enumerable as ICollection<T>; 1797 if (collection != null) 1798 { 1799 // cheap way 1800 return collection; 1801 } 1802 1803 // expensive way, but we don't know if the enumeration is rewindable so... 1804 enumerable = new List<T>(enumerable); 1805 return enumerable as ICollection<T>; 1806 } 1807 1808 static internal T GenericCheckArgumentNull<T>(T value, string parameterName) where T: class 1809 { 1810 return CheckArgumentNull(value, parameterName); 1811 } 1812 1813 // EntityConnectionStringBuilder KeywordNotSupported(string keyword)1814 static internal ArgumentException KeywordNotSupported(string keyword) 1815 { 1816 return Argument(System.Data.Entity.Strings.EntityClient_KeywordNotSupported(keyword)); 1817 } 1818 ADP_KeywordNotSupported(string keyword)1819 static internal ArgumentException ADP_KeywordNotSupported(string keyword) 1820 { 1821 return Argument(System.Data.Entity.Strings.ADP_KeywordNotSupported(keyword)); 1822 } 1823 1824 // Invalid Enumeration 1825 InvalidEnumerationValue(Type type, int value)1826 static internal ArgumentOutOfRangeException InvalidEnumerationValue(Type type, int value) { 1827 return EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.ADP_InvalidEnumerationValue(type.Name, value.ToString(System.Globalization.CultureInfo.InvariantCulture)), type.Name); 1828 } 1829 1830 /// <summary> 1831 /// Given a provider factory, this returns the provider invariant name for the provider. 1832 /// </summary> 1833 [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")] TryGetProviderInvariantName(DbProviderFactory providerFactory, out string invariantName)1834 internal static bool TryGetProviderInvariantName(DbProviderFactory providerFactory, out string invariantName) 1835 { 1836 Debug.Assert(providerFactory != null); 1837 1838 var connectionProviderFactoryType = providerFactory.GetType(); 1839 var connectionProviderFactoryAssemblyName = new AssemblyName( 1840 connectionProviderFactoryType.Assembly.FullName); 1841 1842 foreach (DataRow row in DbProviderFactories.GetFactoryClasses().Rows) 1843 { 1844 var assemblyQualifiedTypeName = (string)row[AssemblyQualifiedNameIndex]; 1845 1846 AssemblyName rowProviderFactoryAssemblyName = null; 1847 1848 // parse the provider factory assembly qualified type name 1849 Type.GetType( 1850 assemblyQualifiedTypeName, 1851 a => 1852 { 1853 rowProviderFactoryAssemblyName = a; 1854 1855 return null; 1856 }, 1857 (_, __, ___) => null); 1858 1859 if (rowProviderFactoryAssemblyName != null) 1860 { 1861 if (string.Equals( 1862 connectionProviderFactoryAssemblyName.Name, 1863 rowProviderFactoryAssemblyName.Name, 1864 StringComparison.OrdinalIgnoreCase)) 1865 { 1866 try 1867 { 1868 var foundFactory = DbProviderFactories.GetFactory(row); 1869 1870 if (foundFactory.GetType().Equals(connectionProviderFactoryType)) 1871 { 1872 invariantName = (string)row[InvariantNameIndex]; 1873 return true; 1874 } 1875 } 1876 catch (Exception ex) 1877 { 1878 Debug.Fail("GetFactory failed with: " + ex); 1879 // Ignore bad providers. 1880 } 1881 } 1882 } 1883 } 1884 invariantName = null; 1885 return false; 1886 } 1887 AssemblyNamesMatch(string infoRowProviderAssemblyName, AssemblyName targetAssemblyName)1888 static internal bool AssemblyNamesMatch(string infoRowProviderAssemblyName, AssemblyName targetAssemblyName) 1889 { 1890 if (string.IsNullOrWhiteSpace(infoRowProviderAssemblyName)) 1891 { 1892 return false; 1893 } 1894 1895 AssemblyName assemblyName = null; 1896 try 1897 { 1898 assemblyName = new AssemblyName(infoRowProviderAssemblyName); 1899 } 1900 catch (Exception e) 1901 { 1902 // Ignore broken provider entries 1903 if (!IsCatchableExceptionType(e)) 1904 { 1905 throw; 1906 } 1907 return false; 1908 } 1909 1910 Debug.Assert(assemblyName != null, "assemblyName should not be null at this point"); 1911 1912 // Match the provider assembly details 1913 if (! string.Equals(targetAssemblyName.Name, assemblyName.Name, StringComparison.OrdinalIgnoreCase)) 1914 { 1915 return false; 1916 } 1917 1918 if (targetAssemblyName.Version == null || assemblyName.Version == null) 1919 { 1920 return false; 1921 } 1922 1923 if ((targetAssemblyName.Version.Major != assemblyName.Version.Major) || 1924 (targetAssemblyName.Version.Minor != assemblyName.Version.Minor)) 1925 { 1926 return false; 1927 } 1928 1929 var targetPublicKeyToken = targetAssemblyName.GetPublicKeyToken(); 1930 return (targetPublicKeyToken != null) 1931 && targetPublicKeyToken.SequenceEqual(assemblyName.GetPublicKeyToken()); 1932 } 1933 1934 // Invalid string argument CheckStringArgument(string value, string parameterName)1935 static internal void CheckStringArgument(string value, string parameterName) 1936 { 1937 // Throw ArgumentNullException when string is null 1938 CheckArgumentNull(value, parameterName); 1939 1940 // Throw ArgumentException when string is empty 1941 if (value.Length == 0) 1942 { 1943 throw InvalidStringArgument(parameterName); 1944 } 1945 } 1946 1947 // only StackOverflowException & ThreadAbortException are sealed classes 1948 static private readonly Type StackOverflowType = typeof(System.StackOverflowException); 1949 static private readonly Type OutOfMemoryType = typeof(System.OutOfMemoryException); 1950 static private readonly Type ThreadAbortType = typeof(System.Threading.ThreadAbortException); 1951 static private readonly Type NullReferenceType = typeof(System.NullReferenceException); 1952 static private readonly Type AccessViolationType = typeof(System.AccessViolationException); 1953 static private readonly Type SecurityType = typeof(System.Security.SecurityException); 1954 static private readonly Type CommandExecutionType = typeof(EntityCommandExecutionException); 1955 static private readonly Type CommandCompilationType = typeof(EntityCommandCompilationException); 1956 static private readonly Type QueryType = typeof(EntitySqlException); 1957 IsCatchableExceptionType(Exception e)1958 static internal bool IsCatchableExceptionType (Exception e) { 1959 // a 'catchable' exception is defined by what it is not. 1960 Debug.Assert(e != null, "Unexpected null exception!"); 1961 Type type = e.GetType(); 1962 1963 return ( (type != StackOverflowType) && 1964 (type != OutOfMemoryType) && 1965 (type != ThreadAbortType) && 1966 (type != NullReferenceType) && 1967 (type != AccessViolationType) && 1968 !SecurityType.IsAssignableFrom(type)); 1969 } 1970 IsCatchableEntityExceptionType(Exception e)1971 static internal bool IsCatchableEntityExceptionType(Exception e) 1972 { 1973 Debug.Assert(e != null, "Unexpected null exception!"); 1974 Type type = e.GetType(); 1975 1976 return IsCatchableExceptionType(e) && 1977 type != CommandExecutionType && 1978 type != CommandCompilationType && 1979 type != QueryType; 1980 } 1981 IsNull(object value)1982 static internal bool IsNull(object value) { 1983 if ((null == value) || (DBNull.Value == value)) { 1984 return true; 1985 } 1986 INullable nullable = (value as INullable); 1987 return ((null != nullable) && nullable.IsNull); 1988 } 1989 1990 /// <summary> 1991 /// Utility method to raise internal error when a throttling constraint is violated during 1992 /// Boolean expression analysis. An internal exception is thrown including the given message 1993 /// if the given condition is false. This allows us to give up on an unexpectedly difficult 1994 /// computation rather than risk hanging the user's machine. 1995 /// </summary> BoolExprAssert(bool condition, string message)1996 static internal void BoolExprAssert(bool condition, string message) 1997 { 1998 if (!condition) 1999 { 2000 throw InternalError(InternalErrorCode.BoolExprAssert, 0, message); 2001 } 2002 } 2003 GetTopProperty(Type t, string propertyName)2004 static internal PropertyInfo GetTopProperty(Type t, string propertyName) 2005 { 2006 return GetTopProperty(ref t, propertyName); 2007 } 2008 2009 /// <summary> 2010 /// Returns the PropertyInfo and Type where a given property is defined 2011 /// This is done by traversing the type hierarchy to find the type match. 2012 /// </summary> 2013 /// <param name="t"></param> 2014 /// <param name="propertyName"></param> 2015 /// <returns></returns> GetTopProperty(ref Type t, string propertyName)2016 static internal PropertyInfo GetTopProperty(ref Type t, string propertyName) 2017 { 2018 PropertyInfo propertyInfo = null; 2019 while (propertyInfo == null && t != null) 2020 { 2021 propertyInfo = t.GetProperty(propertyName, BindingFlags.Instance | 2022 BindingFlags.Public | 2023 BindingFlags.NonPublic | 2024 BindingFlags.DeclaredOnly); 2025 t = t.BaseType; 2026 } 2027 t = propertyInfo.DeclaringType; 2028 return propertyInfo; 2029 } 2030 SrcCompare(string strA, string strB)2031 static internal int SrcCompare(string strA, string strB) 2032 { 2033 return ((strA == strB) ? 0 : 1); 2034 } DstCompare(string strA, string strB)2035 static internal int DstCompare(string strA, string strB) 2036 { 2037 return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, EntityUtil.StringCompareOptions); 2038 } 2039 2040 internal static Dictionary<string,string> COMPILER_VERSION = new Dictionary<string, string>() { { "CompilerVersion", "V3.5" } }; //v3.5 required for compiling model files with partial methods. 2041 2042 [FileIOPermission(SecurityAction.Assert, AllFiles = FileIOPermissionAccess.PathDiscovery)] 2043 [Security.SecuritySafeCritical] 2044 [ResourceExposure(ResourceScope.Machine)] 2045 [ResourceConsumption(ResourceScope.Machine)] GetFullPath(string filename)2046 static internal string GetFullPath(string filename) 2047 { // MDAC 77686 2048 return Path.GetFullPath(filename); 2049 } 2050 #if false FieldCast(object value)2051 public static T FieldCast<T>(object value) { 2052 try { 2053 // will result in an InvalidCastException if !(value is T) 2054 // this pattern also supports handling System.Data.SqlTypes 2055 return (T)((DBNull.Value == value) ? null : value); 2056 } 2057 catch(NullReferenceException) { 2058 // (value == null) and (T is struct) and (T is not Nullable<>), convert to InvalidCastException 2059 return (T)(object)System.DBNull.Value; 2060 } 2061 } 2062 #endif 2063 GetTypesSpecial(Assembly assembly)2064 public static Type[] GetTypesSpecial(Assembly assembly) 2065 { 2066 return ReferenceEquals(assembly, typeof(ObjectContext).Assembly) 2067 ? new Type[0] 2068 : assembly.GetTypes(); 2069 } 2070 2071 /// <summary> 2072 /// This method uses the .net Fx target framework moniker (introduced in .net 4.0 Multitargeting feature) 2073 /// to provide a 'quirks' mode that serves as a compatibility flag for features that can be considered 2074 /// breaking changes from 4.0 to 4.5 which is a in-place upgrade to 4.0. For details see DevDiv2 bug#488375. 2075 /// </summary> 2076 static bool? useFx40CompatMode; 2077 static public bool UseFx40CompatMode 2078 { 2079 get 2080 { 2081 if (!useFx40CompatMode.HasValue) 2082 { 2083 string fxname = AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName; 2084 2085 if (string.IsNullOrWhiteSpace(fxname)) 2086 { 2087 Assembly entryAssembly = Assembly.GetEntryAssembly(); // entry assembly can be unmanaged. 2088 2089 if (entryAssembly != null) 2090 { 2091 TargetFrameworkAttribute fxAttrib = entryAssembly.GetCustomAttribute<TargetFrameworkAttribute>(); 2092 if (fxAttrib != null) 2093 { 2094 fxname = fxAttrib.FrameworkName; 2095 } 2096 } 2097 } 2098 2099 if (!string.IsNullOrWhiteSpace(fxname)) 2100 { 2101 try 2102 { 2103 FrameworkName compiledFxName = new FrameworkName(fxname); 2104 Version fxv45 = new Version(4, 5); 2105 2106 useFx40CompatMode = compiledFxName.Version < fxv45; 2107 } 2108 catch (System.ArgumentException) 2109 { 2110 } 2111 } 2112 2113 if (!useFx40CompatMode.HasValue) 2114 { 2115 useFx40CompatMode = true; 2116 } 2117 } 2118 2119 return useFx40CompatMode.Value; 2120 } 2121 } 2122 2123 } 2124 } 2125