mcs/class/referencesource/mscorlib/system/throwhelper.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6
   7 namespace System {
   8     // This file defines an internal class used to throw exceptions in BCL code.
   9     // The main purpose is to reduce code size.
  10     //
  11     // The old way to throw an exception generates quite a lot IL code and assembly code.
  12     // Following is an example:
  13     //     C# source
  14     //          throw new ArgumentNullException("key", Environment.GetResourceString("ArgumentNull_Key"));
  15     //     IL code:
  16     //          IL_0003:  ldstr      "key"
  17     //          IL_0008:  ldstr      "ArgumentNull_Key"
  18     //          IL_000d:  call       string System.Environment::GetResourceString(string)
  19     //          IL_0012:  newobj     instance void System.ArgumentNullException::.ctor(string,string)
  20     //          IL_0017:  throw
  21     //    which is 21bytes in IL.
  22     //
  23     // So we want to get rid of the ldstr and call to Environment.GetResource in IL.
  24     // In order to do that, I created two enums: ExceptionResource, ExceptionArgument to represent the
  25     // argument name and resource name in a small integer. The source code will be changed to
  26     //    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key, ExceptionResource.ArgumentNull_Key);
  27     //
  28     // The IL code will be 7 bytes.
  29     //    IL_0008:  ldc.i4.4
  30     //    IL_0009:  ldc.i4.4
  31     //    IL_000a:  call       void System.ThrowHelper::ThrowArgumentNullException(valuetype System.ExceptionArgument)
  32     //    IL_000f:  ldarg.0
  33     //
  34     // This will also reduce the Jitted code size a lot.
  35     //
  36     // It is very important we do this for generic classes because we can easily generate the same code
  37     // multiple times for different instantiation.
  38     //
  39     // <
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49     using System.Runtime.CompilerServices;
  50     using System.Runtime.Serialization;
  51     using System.Diagnostics.Contracts;
  52     using System.Collections.Generic;
  53
  54     [Pure]
  55 #if MONO
  56     [System.Diagnostics.StackTraceHidden]
  57 #endif
  58     internal static partial class ThrowHelper {
  59 #if !MONO
  60         internal static void ThrowArgumentOutOfRangeException() {
  61             ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
  62         }
  63 #endif
  64
  65         internal static void ThrowWrongKeyTypeArgumentException(object key, Type targetType) {
  66             throw new ArgumentException(Environment.GetResourceString("Arg_WrongType", key, targetType), "key");
  67         }
  68
  69         internal static void ThrowWrongValueTypeArgumentException(object value, Type targetType) {
  70             throw new ArgumentException(Environment.GetResourceString("Arg_WrongType", value, targetType), "value");
  71         }
  72
  73         internal static void ThrowKeyNotFoundException() {
  74             throw new System.Collections.Generic.KeyNotFoundException();
  75         }
  76
  77         internal static void ThrowArgumentException(ExceptionResource resource) {
  78             throw new ArgumentException(Environment.GetResourceString(GetResourceName(resource)));
  79         }
  80
  81         internal static void ThrowArgumentException(ExceptionResource resource, ExceptionArgument argument) {
  82             throw new ArgumentException(Environment.GetResourceString(GetResourceName(resource)), GetArgumentName(argument));
  83         }
  84
  85 #if !MONO
  86         internal static void ThrowArgumentNullException(ExceptionArgument argument) {
  87             throw new ArgumentNullException(GetArgumentName(argument));
  88         }
  89
  90         internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument) {
  91             throw new ArgumentOutOfRangeException(GetArgumentName(argument));
  92         }
  93 #endif
  94
  95         internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) {
  96
  97             if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) {
  98                 // Dev11 474369 quirk: Mango had an empty message string:
  99                 throw new ArgumentOutOfRangeException(GetArgumentName(argument), String.Empty);
 100             } else {
 101                 throw new ArgumentOutOfRangeException(GetArgumentName(argument),
 102                                                       Environment.GetResourceString(GetResourceName(resource)));
 103             }
 104         }
 105
 106         internal static void ThrowInvalidOperationException(ExceptionResource resource) {
 107             throw new InvalidOperationException(Environment.GetResourceString(GetResourceName(resource)));
 108         }
 109
 110         internal static void ThrowSerializationException(ExceptionResource resource) {
 111             throw new SerializationException(Environment.GetResourceString(GetResourceName(resource)));
 112         }
 113
 114         internal static void  ThrowSecurityException(ExceptionResource resource) {
 115             throw new System.Security.SecurityException(Environment.GetResourceString(GetResourceName(resource)));
 116         }
 117
 118         internal static void ThrowNotSupportedException(ExceptionResource resource) {
 119             throw new NotSupportedException(Environment.GetResourceString(GetResourceName(resource)));
 120         }
 121
 122         internal static void ThrowUnauthorizedAccessException(ExceptionResource resource) {
 123             throw new UnauthorizedAccessException(Environment.GetResourceString(GetResourceName(resource)));
 124         }
 125
 126         internal static void ThrowObjectDisposedException(string objectName, ExceptionResource resource) {
 127             throw new ObjectDisposedException(objectName, Environment.GetResourceString(GetResourceName(resource)));
 128         }
 129
 130 #if MONO
 131         internal static void ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion()
 132         {
 133             throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
 134         }
 135
 136         internal static void ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen()
 137         {
 138             throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
 139         }
 140
 141         internal static void ThrowInvalidOperationException_InvalidOperation_EnumNotStarted()
 142         {
 143             throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
 144         }
 145
 146         internal static void ThrowInvalidOperationException_InvalidOperation_EnumEnded()
 147         {
 148             throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
 149         }
 150
 151         private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, string resource)
 152         {
 153             return new ArgumentOutOfRangeException(GetArgumentName(argument), resource);
 154         }
 155
 156         internal static void ThrowArgumentOutOfRange_IndexException()
 157         {
 158             throw GetArgumentOutOfRangeException(ExceptionArgument.index,
 159                                                     SR.ArgumentOutOfRange_Index);
 160         }
 161
 162         internal static void ThrowIndexArgumentOutOfRange_NeedNonNegNumException()
 163         {
 164             throw GetArgumentOutOfRangeException(ExceptionArgument.index,
 165                                                     SR.ArgumentOutOfRange_NeedNonNegNum);
 166         }
 167
 168         internal static void ThrowArgumentException_Argument_InvalidArrayType()
 169         {
 170             throw new ArgumentException(SR.Argument_InvalidArrayType);
 171         }
 172
 173         private static ArgumentException GetAddingDuplicateWithKeyArgumentException(object key)
 174         {
 175             return new ArgumentException(SR.Format(SR.Argument_AddingDuplicate, key));
 176         }
 177         internal static void ThrowAddingDuplicateWithKeyArgumentException(object key)
 178         {
 179             throw GetAddingDuplicateWithKeyArgumentException(key);
 180         }
 181
 182         private static KeyNotFoundException GetKeyNotFoundException(object key)
 183         {
 184             throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString()));
 185         }
 186         internal static void ThrowKeyNotFoundException(object key)
 187         {
 188             throw GetKeyNotFoundException(key);
 189         }
 190 #endif
 191
 192         // Allow nulls for reference types and Nullable<U>, but not for value types.
 193         internal static void IfNullAndNullsAreIllegalThenThrow<T>(object value, ExceptionArgument argName) {
 194             // Note that default(T) is not equal to null for value types except when T is Nullable<U>.
 195             if (value == null && !(default(T) == null))
 196                 ThrowHelper.ThrowArgumentNullException(argName);
 197         }
 198
 199         //
 200         // This function will convert an ExceptionArgument enum value to the argument name string.
 201         //
 202         internal static string GetArgumentName(ExceptionArgument argument) {
 203             string argumentName = null;
 204
 205             switch (argument) {
 206                 case ExceptionArgument.array:
 207                     argumentName = "array";
 208                     break;
 209
 210                 case ExceptionArgument.arrayIndex:
 211                     argumentName = "arrayIndex";
 212                     break;
 213
 214                 case ExceptionArgument.capacity:
 215                     argumentName = "capacity";
 216                     break;
 217
 218                 case ExceptionArgument.collection:
 219                     argumentName = "collection";
 220                     break;
 221
 222                 case ExceptionArgument.list:
 223                     argumentName = "list";
 224                     break;
 225
 226                 case ExceptionArgument.converter:
 227                     argumentName = "converter";
 228                     break;
 229
 230                 case ExceptionArgument.count:
 231                     argumentName = "count";
 232                     break;
 233
 234                 case ExceptionArgument.dictionary:
 235                     argumentName = "dictionary";
 236                     break;
 237
 238                 case ExceptionArgument.dictionaryCreationThreshold:
 239                     argumentName = "dictionaryCreationThreshold";
 240                     break;
 241
 242                 case ExceptionArgument.index:
 243                     argumentName = "index";
 244                     break;
 245
 246                 case ExceptionArgument.info:
 247                     argumentName = "info";
 248                     break;
 249
 250                 case ExceptionArgument.key:
 251                     argumentName = "key";
 252                     break;
 253
 254                 case ExceptionArgument.match:
 255                     argumentName = "match";
 256                     break;
 257
 258                 case ExceptionArgument.obj:
 259                     argumentName = "obj";
 260                     break;
 261
 262                 case ExceptionArgument.queue:
 263                     argumentName = "queue";
 264                     break;
 265
 266                 case ExceptionArgument.stack:
 267                     argumentName = "stack";
 268                     break;
 269
 270                 case ExceptionArgument.startIndex:
 271                     argumentName = "startIndex";
 272                     break;
 273
 274                 case ExceptionArgument.value:
 275                     argumentName = "value";
 276                     break;
 277
 278                 case ExceptionArgument.name:
 279                     argumentName = "name";
 280                     break;
 281
 282                 case ExceptionArgument.mode:
 283                     argumentName = "mode";
 284                     break;
 285
 286                 case ExceptionArgument.item:
 287                     argumentName = "item";
 288                     break;
 289
 290                 case ExceptionArgument.options:
 291                     argumentName = "options";
 292                     break;
 293
 294                 case ExceptionArgument.view:
 295                     argumentName = "view";
 296                     break;
 297
 298                case ExceptionArgument.sourceBytesToCopy:
 299                     argumentName = "sourceBytesToCopy";
 300                     break;
 301
 302                 default:
 303                     Contract.Assert(false, "The enum value is not defined, please checked ExceptionArgumentName Enum.");
 304                     return string.Empty;
 305             }
 306
 307             return argumentName;
 308         }
 309
 310         //
 311         // This function will convert an ExceptionResource enum value to the resource string.
 312         //
 313         internal static string GetResourceName(ExceptionResource resource) {
 314             string resourceName = null;
 315
 316             switch (resource) {
 317                 case ExceptionResource.Argument_ImplementIComparable:
 318                     resourceName = "Argument_ImplementIComparable";
 319                     break;
 320
 321                 case ExceptionResource.Argument_AddingDuplicate:
 322                     resourceName = "Argument_AddingDuplicate";
 323                     break;
 324
 325                 case ExceptionResource.ArgumentOutOfRange_BiggerThanCollection:
 326                     resourceName = "ArgumentOutOfRange_BiggerThanCollection";
 327                     break;
 328
 329                 case ExceptionResource.ArgumentOutOfRange_Count:
 330                     resourceName = "ArgumentOutOfRange_Count";
 331                     break;
 332
 333                 case ExceptionResource.ArgumentOutOfRange_Index:
 334                     resourceName = "ArgumentOutOfRange_Index";
 335                     break;
 336
 337                 case ExceptionResource.ArgumentOutOfRange_InvalidThreshold:
 338                     resourceName = "ArgumentOutOfRange_InvalidThreshold";
 339                     break;
 340
 341                 case ExceptionResource.ArgumentOutOfRange_ListInsert:
 342                     resourceName = "ArgumentOutOfRange_ListInsert";
 343                     break;
 344
 345                 case ExceptionResource.ArgumentOutOfRange_NeedNonNegNum:
 346                     resourceName = "ArgumentOutOfRange_NeedNonNegNum";
 347                     break;
 348
 349                 case ExceptionResource.ArgumentOutOfRange_SmallCapacity:
 350                     resourceName = "ArgumentOutOfRange_SmallCapacity";
 351                     break;
 352
 353                 case ExceptionResource.Arg_ArrayPlusOffTooSmall:
 354                     resourceName = "Arg_ArrayPlusOffTooSmall";
 355                     break;
 356
 357                 case ExceptionResource.Arg_RankMultiDimNotSupported:
 358                     resourceName = "Arg_RankMultiDimNotSupported";
 359                     break;
 360
 361                 case ExceptionResource.Arg_NonZeroLowerBound:
 362                     resourceName = "Arg_NonZeroLowerBound";
 363                     break;
 364
 365                 case ExceptionResource.Argument_InvalidArrayType:
 366                     resourceName = "Argument_InvalidArrayType";
 367                     break;
 368
 369                 case ExceptionResource.Argument_InvalidOffLen:
 370                     resourceName = "Argument_InvalidOffLen";
 371                     break;
 372
 373                 case ExceptionResource.Argument_ItemNotExist:
 374                     resourceName = "Argument_ItemNotExist";
 375                     break;
 376
 377                 case ExceptionResource.InvalidOperation_CannotRemoveFromStackOrQueue:
 378                     resourceName = "InvalidOperation_CannotRemoveFromStackOrQueue";
 379                     break;
 380
 381                 case ExceptionResource.InvalidOperation_EmptyQueue:
 382                     resourceName = "InvalidOperation_EmptyQueue";
 383                     break;
 384
 385                 case ExceptionResource.InvalidOperation_EnumOpCantHappen:
 386                     resourceName = "InvalidOperation_EnumOpCantHappen";
 387                     break;
 388
 389                 case ExceptionResource.InvalidOperation_EnumFailedVersion:
 390                     resourceName = "InvalidOperation_EnumFailedVersion";
 391                     break;
 392
 393                 case ExceptionResource.InvalidOperation_EmptyStack:
 394                     resourceName = "InvalidOperation_EmptyStack";
 395                     break;
 396
 397                 case ExceptionResource.InvalidOperation_EnumNotStarted:
 398                     resourceName = "InvalidOperation_EnumNotStarted";
 399                     break;
 400
 401                 case ExceptionResource.InvalidOperation_EnumEnded:
 402                     resourceName = "InvalidOperation_EnumEnded";
 403                     break;
 404
 405                 case ExceptionResource.NotSupported_KeyCollectionSet:
 406                     resourceName = "NotSupported_KeyCollectionSet";
 407                     break;
 408
 409                 case ExceptionResource.NotSupported_ReadOnlyCollection:
 410                     resourceName = "NotSupported_ReadOnlyCollection";
 411                     break;
 412
 413                 case ExceptionResource.NotSupported_ValueCollectionSet:
 414                     resourceName = "NotSupported_ValueCollectionSet";
 415                     break;
 416
 417
 418                 case ExceptionResource.NotSupported_SortedListNestedWrite:
 419                     resourceName = "NotSupported_SortedListNestedWrite";
 420                     break;
 421
 422
 423                 case ExceptionResource.Serialization_InvalidOnDeser:
 424                     resourceName = "Serialization_InvalidOnDeser";
 425                     break;
 426
 427                 case ExceptionResource.Serialization_MissingKeys:
 428                     resourceName = "Serialization_MissingKeys";
 429                     break;
 430
 431                 case ExceptionResource.Serialization_NullKey:
 432                     resourceName = "Serialization_NullKey";
 433                     break;
 434
 435                 case ExceptionResource.Argument_InvalidType:
 436                     resourceName = "Argument_InvalidType";
 437                     break;
 438
 439                 case ExceptionResource.Argument_InvalidArgumentForComparison:
 440                     resourceName = "Argument_InvalidArgumentForComparison";
 441                     break;
 442
 443                 case ExceptionResource.InvalidOperation_NoValue:
 444                     resourceName = "InvalidOperation_NoValue";
 445                     break;
 446
 447                 case ExceptionResource.InvalidOperation_RegRemoveSubKey:
 448                     resourceName = "InvalidOperation_RegRemoveSubKey";
 449                     break;
 450
 451                 case ExceptionResource.Arg_RegSubKeyAbsent:
 452                     resourceName = "Arg_RegSubKeyAbsent";
 453                     break;
 454
 455                 case ExceptionResource.Arg_RegSubKeyValueAbsent:
 456                     resourceName = "Arg_RegSubKeyValueAbsent";
 457                     break;
 458
 459                 case ExceptionResource.Arg_RegKeyDelHive:
 460                     resourceName = "Arg_RegKeyDelHive";
 461                     break;
 462
 463                 case ExceptionResource.Security_RegistryPermission:
 464                     resourceName = "Security_RegistryPermission";
 465                     break;
 466
 467                 case ExceptionResource.Arg_RegSetStrArrNull:
 468                     resourceName = "Arg_RegSetStrArrNull";
 469                     break;
 470
 471                 case ExceptionResource.Arg_RegSetMismatchedKind:
 472                     resourceName = "Arg_RegSetMismatchedKind";
 473                     break;
 474
 475                 case ExceptionResource.UnauthorizedAccess_RegistryNoWrite:
 476                     resourceName = "UnauthorizedAccess_RegistryNoWrite";
 477                     break;
 478
 479                 case ExceptionResource.ObjectDisposed_RegKeyClosed:
 480                     resourceName = "ObjectDisposed_RegKeyClosed";
 481                     break;
 482
 483                 case ExceptionResource.Arg_RegKeyStrLenBug:
 484                     resourceName = "Arg_RegKeyStrLenBug";
 485                     break;
 486
 487                 case ExceptionResource.Argument_InvalidRegistryKeyPermissionCheck:
 488                     resourceName = "Argument_InvalidRegistryKeyPermissionCheck";
 489                     break;
 490
 491                 case ExceptionResource.NotSupported_InComparableType:
 492                     resourceName = "NotSupported_InComparableType";
 493                     break;
 494
 495                 case ExceptionResource.Argument_InvalidRegistryOptionsCheck:
 496                     resourceName = "Argument_InvalidRegistryOptionsCheck";
 497                     break;
 498
 499                 case ExceptionResource.Argument_InvalidRegistryViewCheck:
 500                     resourceName = "Argument_InvalidRegistryViewCheck";
 501                     break;
 502
 503                 default:
 504                     Contract.Assert( false, "The enum value is not defined, please checked ExceptionArgumentName Enum.");
 505                     return string.Empty;
 506             }
 507
 508             return resourceName;
 509         }
 510
 511     }
 512
 513     //
 514     // The convention for this enum is using the argument name as the enum name
 515     //
 516     internal enum ExceptionArgument {
 517         obj,
 518         dictionary,
 519         dictionaryCreationThreshold,
 520         array,
 521         info,
 522         key,
 523         collection,
 524         list,
 525         match,
 526         converter,
 527         queue,
 528         stack,
 529         capacity,
 530         index,
 531         startIndex,
 532         value,
 533         count,
 534         arrayIndex,
 535         name,
 536         mode,
 537         item,
 538         options,
 539         view,
 540         sourceBytesToCopy,
 541 #if MONO
 542         start,
 543         pointer,
 544         ownedMemory,
 545         text,
 546         length,
 547         comparer,
 548         comparable,
 549         exceptions,
 550         exception
 551 #endif
 552     }
 553
 554     //
 555     // The convention for this enum is using the resource name as the enum name
 556     //
 557     internal enum ExceptionResource {
 558         Argument_ImplementIComparable,
 559         Argument_InvalidType,
 560         Argument_InvalidArgumentForComparison,
 561         Argument_InvalidRegistryKeyPermissionCheck,
 562         ArgumentOutOfRange_NeedNonNegNum,
 563
 564         Arg_ArrayPlusOffTooSmall,
 565         Arg_NonZeroLowerBound,
 566         Arg_RankMultiDimNotSupported,
 567         Arg_RegKeyDelHive,
 568         Arg_RegKeyStrLenBug,
 569         Arg_RegSetStrArrNull,
 570         Arg_RegSetMismatchedKind,
 571         Arg_RegSubKeyAbsent,
 572         Arg_RegSubKeyValueAbsent,
 573
 574         Argument_AddingDuplicate,
 575         Serialization_InvalidOnDeser,
 576         Serialization_MissingKeys,
 577         Serialization_NullKey,
 578         Argument_InvalidArrayType,
 579         NotSupported_KeyCollectionSet,
 580         NotSupported_ValueCollectionSet,
 581         ArgumentOutOfRange_SmallCapacity,
 582         ArgumentOutOfRange_Index,
 583         Argument_InvalidOffLen,
 584         Argument_ItemNotExist,
 585         ArgumentOutOfRange_Count,
 586         ArgumentOutOfRange_InvalidThreshold,
 587         ArgumentOutOfRange_ListInsert,
 588         NotSupported_ReadOnlyCollection,
 589         InvalidOperation_CannotRemoveFromStackOrQueue,
 590         InvalidOperation_EmptyQueue,
 591         InvalidOperation_EnumOpCantHappen,
 592         InvalidOperation_EnumFailedVersion,
 593         InvalidOperation_EmptyStack,
 594         ArgumentOutOfRange_BiggerThanCollection,
 595         InvalidOperation_EnumNotStarted,
 596         InvalidOperation_EnumEnded,
 597         NotSupported_SortedListNestedWrite,
 598         InvalidOperation_NoValue,
 599         InvalidOperation_RegRemoveSubKey,
 600         Security_RegistryPermission,
 601         UnauthorizedAccess_RegistryNoWrite,
 602         ObjectDisposed_RegKeyClosed,
 603         NotSupported_InComparableType,
 604         Argument_InvalidRegistryOptionsCheck,
 605         Argument_InvalidRegistryViewCheck,
 606         TaskT_TransitionToFinal_AlreadyCompleted,
 607         TaskCompletionSourceT_TrySetException_NullException,
 608         TaskCompletionSourceT_TrySetException_NoExceptions,
 609     }
 610 }
 611