public static void Sort <T>(T[] array, int index, int length, System.Collections.Generic.IComparer <T>?comparer) { if (array == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array); } if (index < 0) { ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException(); } if (length < 0) { ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(); } if (array.Length - index < length) { ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen); } if (length > 1) { #if CORECLR if (comparer == null || comparer == Comparer <T> .Default) { if (TrySZSort(array, null, index, index + length - 1)) { return; } } #endif ArraySortHelper <T> .Default.Sort(array, index, length, comparer); } }
/// <summary> /// Creates a new <see cref="Utf8String"/> instance, allowing the provided delegate to populate the /// instance data of the returned object. Please see remarks for important safety information about /// this method. /// </summary> /// <typeparam name="TState">Type of the state object provided to <paramref name="action"/>.</typeparam> /// <param name="length">The length, in bytes, of the <see cref="Utf8String"/> instance to create.</param> /// <param name="state">The state object to provide to <paramref name="action"/>.</param> /// <param name="action">The callback which will be invoked to populate the returned <see cref="Utf8String"/>.</param> /// <remarks> /// This factory method can be used as an optimization to skip the validation step that /// <see cref="Create{TState}(int, TState, SpanAction{byte, TState})"/> normally performs. The contract /// of this method requires that <paramref name="action"/> populate the buffer with well-formed UTF-8 /// data, as <see cref="Utf8String"/> contractually guarantees that it contains only well-formed UTF-8 data, /// and runtime instability could occur if a caller violates this guarantee. /// </remarks> public static Utf8String UnsafeCreateWithoutValidation <TState>(int length, TState state, SpanAction <byte, TState> action) { if (length < 0) { ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(); } if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } if (length == 0) { return(Empty); // special-case empty input } // Create and populate the Utf8String instance. // Can't use FastAllocateSkipZeroInit here because we're handing the raw buffer to user code. Utf8String newString = FastAllocate(length); action(newString.DangerousGetMutableSpan(), state); // The line below is removed entirely in release builds. Debug.Assert(Utf8Utility.IsWellFormedUtf8(newString.AsBytes()), "Callback populated the buffer with ill-formed UTF-8 data."); return(newString); }
/// <summary> /// Creates a new <see cref="Utf8String"/> instance, allowing the provided delegate to populate the /// instance data of the returned object. /// </summary> /// <typeparam name="TState">Type of the state object provided to <paramref name="action"/>.</typeparam> /// <param name="length">The length, in bytes, of the <see cref="Utf8String"/> instance to create.</param> /// <param name="state">The state object to provide to <paramref name="action"/>.</param> /// <param name="action">The callback which will be invoked to populate the returned <see cref="Utf8String"/>.</param> /// <remarks> /// The runtime will perform UTF-8 validation over the contents provided by the <paramref name="action"/> delegate. /// If an invalid UTF-8 subsequence is detected, the invalid subsequence is replaced with <see cref="Rune.ReplacementChar"/> /// in the returned <see cref="Utf8String"/> instance. This could result in the returned <see cref="Utf8String"/> instance /// having a different byte length than specified by the <paramref name="length"/> parameter. /// </remarks> public static Utf8String CreateRelaxed <TState>(int length, TState state, SpanAction <byte, TState> action) { if (length < 0) { ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(); } if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } if (length == 0) { return(Empty); // special-case empty input } // Create and populate the Utf8String instance. // Can't use FastAllocateSkipZeroInit here because we're handing the raw buffer to user code. Utf8String newString = FastAllocate(length); action(newString.DangerousGetMutableSpan(), state); // Now perform validation and fixup. return(Utf8Utility.ValidateAndFixupUtf8String(newString)); }
/// <summary> /// Creates a new <see cref="Utf8String"/> instance, allowing the provided delegate to populate the /// instance data of the returned object. /// </summary> /// <typeparam name="TState">Type of the state object provided to <paramref name="action"/>.</typeparam> /// <param name="length">The length, in bytes, of the <see cref="Utf8String"/> instance to create.</param> /// <param name="state">The state object to provide to <paramref name="action"/>.</param> /// <param name="action">The callback which will be invoked to populate the returned <see cref="Utf8String"/>.</param> /// <exception cref="ArgumentException"> /// Thrown if <paramref name="action"/> populates the buffer with ill-formed UTF-8 data. /// </exception> /// <remarks> /// The runtime will perform UTF-8 validation over the contents provided by the <paramref name="action"/> delegate. /// If an invalid UTF-8 subsequence is detected, an exception is thrown. /// </remarks> public static Utf8String Create <TState>(int length, TState state, SpanAction <byte, TState> action) { if (length < 0) { ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(); } if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } if (length == 0) { return(Empty); // special-case empty input } // Create and populate the Utf8String instance. // Can't use FastAllocateSkipZeroInit here because we're handing the raw buffer to user code. Utf8String newString = FastAllocate(length); action(newString.DangerousGetMutableSpan(), state); // Now perform validation. if (!Utf8Utility.IsWellFormedUtf8(newString.AsBytes())) { throw new ArgumentException( message: SR.Utf8String_CallbackProvidedMalformedData, paramName: nameof(action)); } return(newString); }
// Create instance will create an array public static unsafe Array CreateInstance(Type elementType, int length) { if (elementType is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.elementType); } if (length < 0) { ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(); } RuntimeType?t = elementType.UnderlyingSystemType as RuntimeType; if (t == null) { ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_MustBeType, ExceptionArgument.elementType); } return(InternalCreate((void *)t.TypeHandle.Value, 1, &length, null)); }
public static int BinarySearch <T>(T[] array, int index, int length, T value, System.Collections.Generic.IComparer <T>?comparer) { if (array == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array); } if (index < 0) { ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException(); } if (length < 0) { ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(); } if (array.Length - index < length) { ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen); } return(ArraySortHelper <T> .Default.BinarySearch(array, index, length, value, comparer)); }