public static Attribute[] GetCustomAttributes(ParameterInfo element, bool inherit)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (element.Member == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParameterInfo"), "element");
}
Contract.EndContractBlock();
MemberInfo member = element.Member;
if (member.MemberType == MemberTypes.Method && inherit)
{
return(InternalParamGetCustomAttributes(element, null, inherit) as Attribute[]);
}
return(element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[]);
}
public Version(int major, int minor, int build)
{
if (major < 0)
{
throw new ArgumentOutOfRangeException(nameof(major), Environment.GetResourceString("ArgumentOutOfRange_Version"));
}
if (minor < 0)
{
throw new ArgumentOutOfRangeException(nameof(minor), Environment.GetResourceString("ArgumentOutOfRange_Version"));
}
if (build < 0)
{
throw new ArgumentOutOfRangeException(nameof(build), Environment.GetResourceString("ArgumentOutOfRange_Version"));
}
Contract.EndContractBlock();
_Major = major;
_Minor = minor;
_Build = build;
}
public static int Compare(String strA, int indexA, String strB, int indexB, int length, CultureInfo culture, CompareOptions options)
{
if (culture == null)
{
throw new ArgumentNullException(nameof(culture));
}
Contract.EndContractBlock();
int lengthA = length;
int lengthB = length;
if (strA != null)
{
lengthA = Math.Min(lengthA, strA.Length - indexA);
}
if (strB != null)
{
lengthB = Math.Min(lengthB, strB.Length - indexB);
}
return(culture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, options));
}
[System.Security.SecuritySafeCritical] // auto-generated
public static unsafe long ToInt64(byte[] value, int startIndex)
{
if (value == null)
{
ThrowValueArgumentNull();
}
if ((uint)startIndex >= value.Length)
{
ThrowStartIndexArgumentOutOfRange();
}
if (startIndex > value.Length - 8)
{
ThrowValueArgumentTooSmall();
}
Contract.EndContractBlock();
fixed(byte *pbyte = &value[startIndex])
{
if (startIndex % 8 == 0)
{
// data is aligned
return(*((long *)pbyte));
}
else if (IsLittleEndian)
{
int i1 = (*pbyte) | (*(pbyte + 1) << 8) | (*(pbyte + 2) << 16) | (*(pbyte + 3) << 24);
int i2 = (*(pbyte + 4)) | (*(pbyte + 5) << 8) | (*(pbyte + 6) << 16) | (*(pbyte + 7) << 24);
return((uint)i1 | ((long)i2 << 32));
}
else
{
int i1 = (*pbyte << 24) | (*(pbyte + 1) << 16) | (*(pbyte + 2) << 8) | (*(pbyte + 3));
int i2 = (*(pbyte + 4) << 24) | (*(pbyte + 5) << 16) | (*(pbyte + 6) << 8) | (*(pbyte + 7));
return((uint)i2 | ((long)i1 << 32));
}
}
}
[System.Security.SecuritySafeCritical] // auto-generated
protected unsafe Delegate(Type target, String method)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (target.IsGenericType && target.ContainsGenericParameters)
{
throw new ArgumentException(Environment.GetResourceString("Arg_UnboundGenParam"), nameof(target));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
Contract.EndContractBlock();
RuntimeType rtTarget = target as RuntimeType;
if (rtTarget == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), nameof(target));
}
// This API existed in v1/v1.1 and only expected to create open
// static delegates. Constrain the call to BindToMethodName to such
// and don't allow relaxed signature matching (which could make the
// choice of target method ambiguous) for backwards compatibility.
// The name matching was case insensitive (no idea why this is
// different from the constructor above) and we preserve that as
// well.
BindToMethodName(null, rtTarget, method,
DelegateBindingFlags.StaticMethodOnly |
DelegateBindingFlags.OpenDelegateOnly |
DelegateBindingFlags.CaselessMatching);
}
[System.Security.SecuritySafeCritical] // auto-generated
public static unsafe int ToInt32(byte[] value, int startIndex)
{
if (value == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
}
if ((uint)startIndex >= value.Length)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
}
if (startIndex > value.Length - 4)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
}
Contract.EndContractBlock();
fixed(byte *pbyte = &value[startIndex])
{
if (startIndex % 4 == 0) // data is aligned
{
return(*((int *)pbyte));
}
else
{
if (IsLittleEndian)
{
return((*pbyte) | (*(pbyte + 1) << 8) | (*(pbyte + 2) << 16) | (*(pbyte + 3) << 24));
}
else
{
return((*pbyte << 24) | (*(pbyte + 1) << 16) | (*(pbyte + 2) << 8) | (*(pbyte + 3)));
}
}
}
}
public static void SetCursorPosition(int left, int top)
{
// Note on argument checking - the upper bounds are NOT correct
// here! But it looks slightly expensive to compute them. Let
// Windows calculate them, then we'll give a nice error message.
if (left < 0 || left >= short.MaxValue)
{
throw new ArgumentOutOfRangeException("left", left, SR.ArgumentOutOfRange_ConsoleBufferBoundaries);
}
if (top < 0 || top >= short.MaxValue)
{
throw new ArgumentOutOfRangeException("top", top, SR.ArgumentOutOfRange_ConsoleBufferBoundaries);
}
Contract.EndContractBlock();
IntPtr hConsole = OutputHandle;
Interop.mincore.COORD coords = new Interop.mincore.COORD();
coords.X = (short)left;
coords.Y = (short)top;
if (!Interop.mincore.SetConsoleCursorPosition(hConsole, coords))
{
// Give a nice error message for out of range sizes
int errorCode = Marshal.GetLastWin32Error();
Interop.mincore.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
if (left < 0 || left >= csbi.dwSize.X)
{
throw new ArgumentOutOfRangeException("left", left, SR.ArgumentOutOfRange_ConsoleBufferBoundaries);
}
if (top < 0 || top >= csbi.dwSize.Y)
{
throw new ArgumentOutOfRangeException("top", top, SR.ArgumentOutOfRange_ConsoleBufferBoundaries);
}
throw Win32Marshal.GetExceptionForWin32Error(errorCode);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting)
{
if (generation < 0)
{
throw new ArgumentOutOfRangeException("generation", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
}
if ((mode < GCCollectionMode.Default) || (mode > GCCollectionMode.Optimized))
{
throw new ArgumentOutOfRangeException(Environment.GetResourceString("ArgumentOutOfRange_Enum"));
}
Contract.EndContractBlock();
int iInternalModes = 0;
if (mode == GCCollectionMode.Optimized)
{
iInternalModes |= (int)InternalGCCollectionMode.Optimized;
}
if (compacting)
{
iInternalModes |= (int)InternalGCCollectionMode.Compacting;
}
if (blocking)
{
iInternalModes |= (int)InternalGCCollectionMode.Blocking;
}
else if (!compacting)
{
iInternalModes |= (int)InternalGCCollectionMode.NonBlocking;
}
_Collect(generation, iInternalModes);
}
public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit)
{
// Returns true is a custom attribute subclass of attributeType class/interface with inheritance walk
if (element == null)
{
throw new ArgumentNullException("element");
}
if (attributeType == null)
{
throw new ArgumentNullException("attributeType");
}
if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
}
Contract.EndContractBlock();
MemberInfo member = element.Member;
switch (member.MemberType)
{
case MemberTypes.Method: // We need to climb up the member hierarchy
return(InternalParamIsDefined(element, attributeType, inherit));
case MemberTypes.Constructor:
return(element.IsDefined(attributeType, false));
case MemberTypes.Property:
return(element.IsDefined(attributeType, false));
default:
Contract.Assert(false, "Invalid type for ParameterInfo member in Attribute class");
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParamInfo"));
}
}
public static Decimal Round(Decimal d, int decimals, MidpointRounding mode)
{
if (decimals < 0 || decimals > 28)
{
throw new ArgumentOutOfRangeException(nameof(decimals), SR.ArgumentOutOfRange_DecimalRound);
}
if (mode < MidpointRounding.ToEven || mode > MidpointRounding.AwayFromZero)
{
throw new ArgumentException(SR.Format(SR.Argument_InvalidEnumValue, mode, "MidpointRounding"), nameof(mode));
}
Contract.EndContractBlock();
if (mode == MidpointRounding.ToEven)
{
Decimal result = new Decimal();
DecCalc.VarDecRound(ref d, decimals, ref result);
d = result;
}
else
{
DecCalc.InternalRoundFromZero(ref d, decimals);
}
return(d);
}
public ArraySegment(T[] array, int offset, int count)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset), SR.ArgumentOutOfRange_NeedNonNegNum);
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), SR.ArgumentOutOfRange_NeedNonNegNum);
}
if (array.Length - offset < count)
{
throw new ArgumentException(SR.Argument_InvalidOffLen);
}
Contract.EndContractBlock();
_array = array;
_offset = offset;
_count = count;
}
private static DateTimeStyles ValidateStyles(DateTimeStyles style, String parameterName)
{
if ((style & DateTimeFormatInfo.InvalidDateTimeStyles) != 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDateTimeStyles"), parameterName);
}
if (((style & (DateTimeStyles.AssumeLocal)) != 0) && ((style & (DateTimeStyles.AssumeUniversal)) != 0))
{
throw new ArgumentException(Environment.GetResourceString("Argument_ConflictingDateTimeStyles"), parameterName);
}
if ((style & DateTimeStyles.NoCurrentDateDefault) != 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_DateTimeOffsetInvalidDateTimeStyles"), parameterName);
}
Contract.EndContractBlock();
// RoundtripKind does not make sense for DateTimeOffset; ignore this flag for backward compatibility with DateTime
style &= ~DateTimeStyles.RoundtripKind;
// AssumeLocal is also ignored as that is what we do by default with DateTimeOffset.Parse
style &= ~DateTimeStyles.AssumeLocal;
return(style);
}
public static ObjectHandle CreateInstanceFrom(AppDomain domain,
string assemblyFile,
string typeName,
bool ignoreCase,
BindingFlags bindingAttr,
Binder binder,
object[] args,
CultureInfo culture,
object[] activationAttributes)
{
if (domain == null)
throw new ArgumentNullException("domain");
Contract.EndContractBlock();
return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile,
typeName,
ignoreCase,
bindingAttr,
binder,
args,
culture,
activationAttributes,
null);
}
public static String ExpandEnvironmentVariables(String name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
Contract.EndContractBlock();
if (name.Length == 0)
{
return(name);
}
if (AppDomain.IsAppXModel() && !AppDomain.IsAppXDesignMode())
{
// Environment variable accessors are not approved modern API.
// Behave as if no variables are defined in this case.
return(name);
}
int currentSize = 100;
StringBuilder blob = new StringBuilder(currentSize); // A somewhat reasonable default size
#if PLATFORM_UNIX // Win32Native.ExpandEnvironmentStrings isn't available
int lastPos = 0, pos;
while (lastPos < name.Length && (pos = name.IndexOf('%', lastPos + 1)) >= 0)
{
if (name[lastPos] == '%')
{
string key = name.Substring(lastPos + 1, pos - lastPos - 1);
string value = Environment.GetEnvironmentVariable(key);
if (value != null)
{
blob.Append(value);
lastPos = pos + 1;
continue;
}
}
blob.Append(name.Substring(lastPos, pos - lastPos));
lastPos = pos;
}
blob.Append(name.Substring(lastPos));
#else
int size;
blob.Length = 0;
size = Win32Native.ExpandEnvironmentStrings(name, blob, currentSize);
if (size == 0)
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
while (size > currentSize)
{
currentSize = size;
blob.Capacity = currentSize;
blob.Length = 0;
size = Win32Native.ExpandEnvironmentStrings(name, blob, currentSize);
if (size == 0)
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
}
#endif // PLATFORM_UNIX
return(blob.ToString());
}
public static bool Equals(String a, String b, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)a == (Object)b)
{
return(true);
}
if ((Object)a == null || (Object)b == null)
{
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
else
{
// If both strings are ASCII strings, we can take the fast path.
if (a.IsAscii() && b.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(a, b) == 0);
}
// Take the slow path.
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
#else
return(TextInfo.CompareOrdinalIgnoreCase(a, b) == 0);
#endif
}
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
}
public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (flds == null)
{
throw new ArgumentNullException("flds");
}
Contract.EndContractBlock();
if (flds.Length == 0)
{
throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError"));
}
IntPtr[] fields = new IntPtr[flds.Length];
// For proper handling of Nullable<T> don't change GetType() to something like 'IsAssignableFrom'
// Currently we can't make a TypedReference to fields of Nullable<T>, which is fine.
RuntimeType targetType = (RuntimeType)target.GetType();
for (int i = 0; i < flds.Length; i++)
{
RuntimeFieldInfo field = flds[i] as RuntimeFieldInfo;
if (field == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"));
}
if (field.IsInitOnly || field.IsStatic)
{
throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField"));
}
if (targetType != field.GetDeclaringTypeInternal() && !targetType.IsSubclassOf(field.GetDeclaringTypeInternal()))
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef"));
}
RuntimeType fieldType = (RuntimeType)field.FieldType;
if (fieldType.IsPrimitive)
{
throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve"));
}
if (i < (flds.Length - 1) && !fieldType.IsValueType)
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr"));
}
fields[i] = field.FieldHandle.Value;
targetType = fieldType;
}
#if MONO
return(MakeTypedReferenceInternal(target, flds));
#else
TypedReference result = new TypedReference();
// reference to TypedReference is banned, so have to pass result as pointer
unsafe
{
InternalMakeTypedReference(&result, target, fields, targetType);
}
return(result);
#endif
}
public Boolean StartsWith(String value, StringComparison comparisonType)
{
if ((Object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if (value.Length == 0)
{
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
if (this.Length < value.Length || m_firstChar != value.m_firstChar)
{
return(false);
}
return((value.Length == 1) ?
true : // First char is the same and thats all there is to compare
StartsWithOrdinalHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length < value.Length)
{
return(false);
}
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, value.Length, value, 0, value.Length) == 0);
#else
return(TextInfo.CompareOrdinalIgnoreCaseEx(this, 0, value, 0, value.Length, value.Length) == 0);
#endif
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
}
/// <summary>Gets a Task to represent the asynchronous operation.</summary>
/// <param name="source">The asynchronous operation.</param>
/// <param name="cancellationToken">The token used to request cancellation of the asynchronous operation.</param>
/// <param name="progress">The progress object used to receive progress updates.</param>
/// <returns>The Task representing the asynchronous operation.</returns>
public static Task <TResult> AsTask <TResult, TProgress>(this IAsyncOperationWithProgress <TResult, TProgress> source,
CancellationToken cancellationToken, IProgress <TProgress> progress)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
Contract.EndContractBlock();
// If source is actually a NetFx-to-WinRT adapter, unwrap it instead of creating a new Task:
var wrapper = source as TaskToAsyncOperationWithProgressAdapter <TResult, TProgress>;
if (wrapper != null && !wrapper.CompletedSynchronously)
{
Task <TResult> innerTask = wrapper.Task as Task <TResult>;
Debug.Assert(innerTask != null);
Debug.Assert(innerTask.Status != TaskStatus.Created); // Is WaitingForActivation a legal state at this moment?
if (!innerTask.IsCompleted)
{
// The race here is benign: If the task completes here, the concatinations are useless, but not damaging.
if (cancellationToken.CanBeCanceled && wrapper.CancelTokenSource != null)
{
ConcatenateCancelTokens(cancellationToken, wrapper.CancelTokenSource, innerTask);
}
if (progress != null)
{
ConcatenateProgress(source, progress);
}
}
return(innerTask);
}
// Fast path to return a completed Task if the operation has already completed
switch (source.Status)
{
case AsyncStatus.Completed:
return(Task.FromResult(source.GetResults()));
case AsyncStatus.Error:
return(Task.FromException <TResult>(source.ErrorCode.AttachRestrictedErrorInfo()));
case AsyncStatus.Canceled:
return(Task.FromCanceled <TResult>(cancellationToken.IsCancellationRequested ? cancellationToken : new CancellationToken(true)));
}
// Benign race: source may complete here. Things still work, just not taking the fast path.
// Forward progress reports:
if (progress != null)
{
ConcatenateProgress(source, progress);
}
// Source is not a NetFx-to-WinRT adapter, but a native future. Hook up the task:
var bridge = new AsyncInfoToTaskBridge <TResult>(cancellationToken);
try
{
source.Completed = new AsyncOperationWithProgressCompletedHandler <TResult, TProgress>(bridge.CompleteFromAsyncOperationWithProgress);
bridge.RegisterForCancellation(source);
}
catch
{
AsyncCausalitySupport.RemoveFromActiveTasks(bridge.Task);
}
return(bridge.Task);
}
internal static DelegateEntry GetDelegateSerializationInfo(
SerializationInfo info, Type delegateType, Object target, MethodInfo method, int targetIndex)
{
// Used for MulticastDelegate
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
Contract.EndContractBlock();
if (!method.IsPublic || (method.DeclaringType != null && !method.DeclaringType.IsVisible))
{
new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
}
Type c = delegateType.BaseType;
if (c == null || (c != typeof(Delegate) && c != typeof(MulticastDelegate)))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
if (method.DeclaringType == null)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalMethodSerialization"));
}
DelegateEntry de = new DelegateEntry(delegateType.FullName, delegateType.Module.Assembly.FullName, target,
method.ReflectedType.Module.Assembly.FullName, method.ReflectedType.FullName, method.Name);
if (info.MemberCount == 0)
{
info.SetType(typeof(DelegateSerializationHolder));
info.AddValue("Delegate", de, typeof(DelegateEntry));
}
// target can be an object so it needs to be added to the info, or else a fixup is needed
// when deserializing, and the fixup will occur too late. If it is added directly to the
// info then the rules of deserialization will guarantee that it will be available when
// needed
if (target != null)
{
String targetName = "target" + targetIndex;
info.AddValue(targetName, de.target);
de.target = targetName;
}
// Due to a number of additions (delegate signature binding relaxation, delegates with open this or closed over the
// first parameter and delegates over generic methods) we need to send a deal more information than previously. We can
// get this by serializing the target MethodInfo. We still need to send the same information as before though (the
// DelegateEntry above) for backwards compatibility. And we want to send the MethodInfo (which is serialized via an
// ISerializable holder) as a top-level child of the info for the same reason as the target above -- we wouldn't have an
// order of deserialization guarantee otherwise.
String methodInfoName = "method" + targetIndex;
info.AddValue(methodInfoName, method);
return(de);
}
public bool Equals(String value, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if ((Object)value == null)
{
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(this, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(this, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (this.Length != value.Length)
{
return(false);
}
return(EqualsHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
{
return(false);
}
// If both strings are ASCII strings, we can take the fast path.
if (this.IsAscii() && value.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(this, value) == 0);
}
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, this.Length, value, 0, value.Length) == 0);
#else
// Take the slow path.
return(TextInfo.CompareOrdinalIgnoreCase(this, value) == 0);
#endif
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
}
public static string Normalize(this string value, NormalizationForm normalizationForm)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
Contract.EndContractBlock();
// we depend on Win32 last error when calling NormalizeString
Interop.mincore.SetLastError(Interop.ERROR_SUCCESS);
// Guess our buffer size first
int iLength = Interop.mincore.NormalizeString((int)normalizationForm, value, value.Length, null, 0);
int lastError = Marshal.GetLastWin32Error();
// Could have an error (actually it'd be quite hard to have an error here)
if ((lastError != Interop.ERROR_SUCCESS && lastError != Interop.LAST_ERROR_TRASH_VALUE) ||
iLength < 0)
{
if (lastError == Interop.ERROR_INVALID_PARAMETER)
{
throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "value");
}
// We shouldn't really be able to get here..., guessing length is
// a trivial math function...
// Can't really be Out of Memory, but just in case:
if (lastError == Interop.ERROR_NOT_ENOUGH_MEMORY)
{
throw new OutOfMemoryException(SR.Arg_OutOfMemoryException);
}
// Who knows what happened? Not us!
throw new InvalidOperationException(SR.Format(SR.UnknownError_Num, lastError));
}
// Don't break for empty strings (only possible for D & KD and not really possible at that)
if (iLength == 0)
{
return(string.Empty);
}
// Someplace to stick our buffer
char[] cBuffer = null;
for (; ;)
{
// (re)allocation buffer and normalize string
cBuffer = new char[iLength];
// Reset last error
Interop.mincore.SetLastError(Interop.ERROR_SUCCESS);
iLength = Interop.mincore.NormalizeString((int)normalizationForm, value, value.Length, cBuffer, cBuffer.Length);
lastError = Marshal.GetLastWin32Error();
if (lastError == Interop.ERROR_SUCCESS || lastError == Interop.LAST_ERROR_TRASH_VALUE)
{
break;
}
// Could have an error (actually it'd be quite hard to have an error here)
switch (lastError)
{
// Do appropriate stuff for the individual errors:
case Interop.ERROR_INSUFFICIENT_BUFFER:
iLength = Math.Abs(iLength);
Debug.Assert(iLength > cBuffer.Length, "Buffer overflow should have iLength > cBuffer.Length");
continue;
case Interop.ERROR_INVALID_PARAMETER:
case Interop.ERROR_NO_UNICODE_TRANSLATION:
// Illegal code point or order found. Ie: FFFE or D800 D800, etc.
throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "value");
case Interop.ERROR_NOT_ENOUGH_MEMORY:
throw new OutOfMemoryException(SR.Arg_OutOfMemoryException);
default:
// We shouldn't get here...
throw new InvalidOperationException(SR.Format(SR.UnknownError_Num, lastError));
}
}
// Copy our buffer into our new string, which will be the appropriate size
return(new string(cBuffer, 0, iLength));
}
public static int Compare(String strA, String strB, StringComparison comparisonType)
{
// Single comparison to check if comparisonType is within [CurrentCulture .. OrdinalIgnoreCase]
if ((uint)(comparisonType - StringComparison.CurrentCulture) > (uint)(StringComparison.OrdinalIgnoreCase - StringComparison.CurrentCulture))
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if (object.ReferenceEquals(strA, strB))
{
return(0);
}
// They can't both be null at this point.
if (strA == null)
{
return(-1);
}
if (strB == null)
{
return(1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
// Most common case: first character is different.
// Returns false for empty strings.
if (strA.m_firstChar != strB.m_firstChar)
{
return(strA.m_firstChar - strB.m_firstChar);
}
return(CompareOrdinalHelper(strA, strB));
case StringComparison.OrdinalIgnoreCase:
// If both strings are ASCII strings, we can take the fast path.
if (strA.IsAscii() && strB.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(strA, strB));
}
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length));
#else
// Take the slow path.
return(TextInfo.CompareOrdinalIgnoreCase(strA, strB));
#endif
default:
throw new NotSupportedException(Environment.GetResourceString("NotSupported_StringComparison"));
}
}
public String ToString(IFormatProvider provider)
{
Contract.Ensures(Contract.Result <String>() != null);
Contract.EndContractBlock();
return(this);
}
// Returns this string.
public override String ToString()
{
Contract.Ensures(Contract.Result <String>() != null);
Contract.EndContractBlock();
return(this);
}
/*==================================NextBytes===================================
**Action: Fills the byte array with random bytes [0..0x7f]. The entire array is filled.
**Returns:Void
**Arugments: buffer -- the array to be filled.
**Exceptions: None
==============================================================================*/
public virtual void NextBytes(byte [] buffer){
if (buffer==null) throw new ArgumentNullException("buffer");
Contract.EndContractBlock();
for (int i=0; i<buffer.length; i++)="" {="" buffer[i]="(byte)(InternalSample()%(Byte.MaxValue+1));" }="" file="" provided="" for="" reference="" use="" only="" by="" microsoft="" corporation="" (c)="" 2007.="" =="++==" copyright="" corporation.="" all="" rights="" reserved.="" *="===========================================================" **="" class:="" random="" purpose:="" a="" number="" generator.="" namespace="" system="" using="" system;="" system.runtime;="" system.runtime.compilerservices;="" system.globalization;="" system.diagnostics.contracts;="" [system.runtime.interopservices.comvisible(true)]="" [serializable]="" public="" class="" private="" constants="" const="" int="" mbig="Int32.MaxValue;" mseed="161803398;" mz="0;" member="" variables="" inext;="" inextp;="" int[]="" seedarray="new" int[56];="" native="" declarations="" constructors="" random()="" :="" this(environment.tickcount)="" random(int="" seed)="" ii;="" mj,="" mk;="" initialize="" our="" seed="" array.="" this="" algorithm="" comes="" from="" numerical="" recipes="" in="" c="" (2nd="" ed.)="" subtraction="(Seed" ?="" int32.maxvalue="" math.abs(seed);="" mj="MSEED" -="" subtraction;="" seedarray[55]="mj;" mk="1;" (int="" i="1;" i<55;="" apparently="" the="" range="" [1..55]="" is="" special="" (knuth)="" and="" so="" we're="" wasting="" 0'th="" position.="" ii="(21*i)%55;" seedarray[ii]="mk;" if="" (mk<0)="" mk+="MBIG;" k="1;" k<5;="" k++)="" i<56;="" seedarray[i]="" (seedarray[i]<0)="" seedarray[i]+="MBIG;" inext="0;" inextp="21;" package="" methods="" **action:="" return="" new="" [0..1)="" reseed="" **returns:="" double="" **arguments:="" none="" **exceptions:="" #if="" !feature_coreclr="" [targetedpatchingoptout("performance="" critical="" to="" inline="" across="" ngen="" image="" boundaries")]="" #endif="" protected="" virtual="" sample()="" including="" division="" at="" end="" gives="" us="" significantly="" improved="" distribution.="" (internalsample()*(1.0="" mbig));="" internalsample()="" retval;="" locinext="inext;" locinextp="inextp;" (++locinext="">=56) locINext=1;
private DelegateSerializationHolder(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
Contract.EndContractBlock();
bool bNewWire = true;
try
{
m_delegateEntry = (DelegateEntry)info.GetValue("Delegate", typeof(DelegateEntry));
}
catch
{
// Old wire format
m_delegateEntry = OldDelegateWireFormat(info, context);
bNewWire = false;
}
if (bNewWire)
{
// retrieve the targets
DelegateEntry deiter = m_delegateEntry;
int count = 0;
while (deiter != null)
{
if (deiter.target != null)
{
string stringTarget = deiter.target as string; //need test to pass older wire format
if (stringTarget != null)
{
deiter.target = info.GetValue(stringTarget, typeof(Object));
}
}
count++;
deiter = deiter.delegateEntry;
}
// If the sender is as recent as us they'll have provided MethodInfos for each delegate. Look for these and pack
// them into an ordered array if present.
MethodInfo[] methods = new MethodInfo[count];
int i;
for (i = 0; i < count; i++)
{
String methodInfoName = "method" + i;
methods[i] = (MethodInfo)info.GetValueNoThrow(methodInfoName, typeof(MethodInfo));
if (methods[i] == null)
{
break;
}
}
// If we got the info then make the array available for deserialization.
if (i == count)
{
m_methods = methods;
}
}
}
// Method required for the ICloneable interface.
// There's no point in cloning a string since they're immutable, so we simply return this.
public Object Clone()
{
Contract.Ensures(Contract.Result <Object>() != null);
Contract.EndContractBlock();
return(this);
}
public static int Compare(String strA, int indexA, String strB, int indexB, int length, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if (strA == null || strB == null)
{
if (object.ReferenceEquals(strA, strB))
{
// They're both null
return(0);
}
return(strA == null ? -1 : 1);
}
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), Environment.GetResourceString("ArgumentOutOfRange_NegativeLength"));
}
if (indexA < 0 || indexB < 0)
{
string paramName = indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
if (strA.Length - indexA < 0 || strB.Length - indexB < 0)
{
string paramName = strA.Length - indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
if (length == 0 || (object.ReferenceEquals(strA, strB) && indexA == indexB))
{
return(0);
}
int lengthA = Math.Min(length, strA.Length - indexA);
int lengthB = Math.Min(length, strB.Length - indexB);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
return(CompareOrdinalHelper(strA, indexA, lengthA, strB, indexB, lengthB));
case StringComparison.OrdinalIgnoreCase:
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(strA, indexA, lengthA, strB, indexB, lengthB));
#else
return(TextInfo.CompareOrdinalIgnoreCaseEx(strA, indexA, strB, indexB, lengthA, lengthB));
#endif
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"));
}
}
[System.Security.SecurityCritical] // auto-generated_required
public static ObjectHandle CreateInstanceFrom (AppDomain domain, string assemblyFile, string typeName) {
if (domain == null)
throw new ArgumentNullException("domain");
Contract.EndContractBlock();
return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile, typeName);
}
private void CreateFromNameAndManifests(ApplicationIdentity applicationIdentity, string[] manifestPaths)
{
if (applicationIdentity == null)
{
throw new ArgumentNullException("applicationIdentity");
}
if (manifestPaths == null)
{
throw new ArgumentNullException("manifestPaths");
}
Contract.EndContractBlock();
_applicationIdentity = applicationIdentity;
// ISSUE - need validation on manifestPaths
IEnumDefinitionIdentity idenum = _applicationIdentity.Identity.EnumAppPath();
_manifests = new ArrayList(DefaultComponentCount);
_manifestPaths = new String[manifestPaths.Length];
IDefinitionIdentity[] asbId = new IDefinitionIdentity[1];
int i = 0;
while (idenum.Next(1, asbId) == 1)
{
ICMS cms = (ICMS)IsolationInterop.ParseManifest(manifestPaths[i], null, ref IsolationInterop.IID_ICMS);
if (IsolationInterop.IdentityAuthority.AreDefinitionsEqual(0, cms.Identity, asbId[0]))
{
_manifests.Add(cms);
_manifestPaths[i] = manifestPaths[i];
}
else
{
#if ISOLATION_IN_MSCORLIB
throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppIdMismatch"));
#else
throw new ArgumentException("Application Identity does not match identity in manifests");
#endif
}
i++;
}
if (i != manifestPaths.Length)
{
#if ISOLATION_IN_MSCORLIB
throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppId"));
#else
throw new ArgumentException("Application Identity does not have same number of components as manifest paths");
#endif
}
_manifests.TrimToSize();
if (_manifests.Count <= 1)
{
#if ISOLATION_IN_MSCORLIB
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidAppId"));
#else
throw new ArgumentException("Invalid identity: no deployment/app identity specified");
#endif
}
_definitionIdentities = null;
_actContext = null;
_form = ContextForm.Loose;
_appRunState = ApplicationStateDisposition.Undefined;
#if ISOLATION_IN_MSCORLIB
Contract.Assert(_manifests.Count == 2, "An application must have exactly 1 deployment component and 1 application component in Whidbey");
#endif
}