From ce2de8c728af1d22b4d47283a75ea1ec2fe13625 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20S=C3=A1nchez=20L=C3=B3pez?= <1175054+carlossanlop@users.noreply.github.com> Date: Fri, 14 Mar 2025 22:28:34 +0000 Subject: [PATCH 1/5] feed --- NuGet.config | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/NuGet.config b/NuGet.config index 5689322ede..c279dc499e 100644 --- a/NuGet.config +++ b/NuGet.config @@ -22,8 +22,8 @@ - - + + From dcf6b27a300c226efd093707cdf492dc2773e4aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20S=C3=A1nchez=20L=C3=B3pez?= <1175054+carlossanlop@users.noreply.github.com> Date: Fri, 14 Mar 2025 22:28:40 +0000 Subject: [PATCH 2/5] System.Memory 4.6.1 --- .../4.6.1/System.Memory.4.6.1.csproj | 16 + .../4.6.1/lib/netstandard2.0/System.Memory.cs | 941 ++++++++++++++++++ .../system.memory/4.6.1/system.memory.nuspec | 23 + 3 files changed, 980 insertions(+) create mode 100644 src/referencePackages/src/system.memory/4.6.1/System.Memory.4.6.1.csproj create mode 100644 src/referencePackages/src/system.memory/4.6.1/lib/netstandard2.0/System.Memory.cs create mode 100644 src/referencePackages/src/system.memory/4.6.1/system.memory.nuspec diff --git a/src/referencePackages/src/system.memory/4.6.1/System.Memory.4.6.1.csproj b/src/referencePackages/src/system.memory/4.6.1/System.Memory.4.6.1.csproj new file mode 100644 index 0000000000..f0214e30cf --- /dev/null +++ b/src/referencePackages/src/system.memory/4.6.1/System.Memory.4.6.1.csproj @@ -0,0 +1,16 @@ + + + + netstandard2.0 + 4.6.1 + System.Memory + Open + + + + + + + + + diff --git a/src/referencePackages/src/system.memory/4.6.1/lib/netstandard2.0/System.Memory.cs b/src/referencePackages/src/system.memory/4.6.1/lib/netstandard2.0/System.Memory.cs new file mode 100644 index 0000000000..f89c2fb498 --- /dev/null +++ b/src/referencePackages/src/system.memory/4.6.1/lib/netstandard2.0/System.Memory.cs @@ -0,0 +1,941 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Memory")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Memory")] +[assembly: System.Reflection.AssemblyFileVersion("4.600.125.15403")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.1+ab95a1f103b49919ba02577a99f3173405bb50ca")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Memory")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.0.3.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System +{ + public static partial class MemoryExtensions + { + public static ReadOnlyMemory AsMemory(this string text, int start, int length) { throw null; } + + public static ReadOnlyMemory AsMemory(this string text, int start) { throw null; } + + public static ReadOnlyMemory AsMemory(this string text) { throw null; } + + public static Memory AsMemory(this T[] array, int start, int length) { throw null; } + + public static Memory AsMemory(this T[] array, int start) { throw null; } + + public static Memory AsMemory(this T[] array) { throw null; } + + public static Memory AsMemory(this ArraySegment segment, int start, int length) { throw null; } + + public static Memory AsMemory(this ArraySegment segment, int start) { throw null; } + + public static Memory AsMemory(this ArraySegment segment) { throw null; } + + public static ReadOnlySpan AsSpan(this string text, int start, int length) { throw null; } + + public static ReadOnlySpan AsSpan(this string text, int start) { throw null; } + + public static ReadOnlySpan AsSpan(this string text) { throw null; } + + public static Span AsSpan(this T[] array, int start, int length) { throw null; } + + public static Span AsSpan(this T[] array, int start) { throw null; } + + public static Span AsSpan(this T[] array) { throw null; } + + public static Span AsSpan(this ArraySegment segment, int start, int length) { throw null; } + + public static Span AsSpan(this ArraySegment segment, int start) { throw null; } + + public static Span AsSpan(this ArraySegment segment) { throw null; } + + public static int BinarySearch(this ReadOnlySpan span, IComparable comparable) { throw null; } + + public static int BinarySearch(this Span span, IComparable comparable) { throw null; } + + public static int BinarySearch(this ReadOnlySpan span, T value, TComparer comparer) + where TComparer : Collections.Generic.IComparer { throw null; } + + public static int BinarySearch(this ReadOnlySpan span, TComparable comparable) + where TComparable : IComparable { throw null; } + + public static int BinarySearch(this Span span, T value, TComparer comparer) + where TComparer : Collections.Generic.IComparer { throw null; } + + public static int BinarySearch(this Span span, TComparable comparable) + where TComparable : IComparable { throw null; } + + public static int CompareTo(this ReadOnlySpan span, ReadOnlySpan other, StringComparison comparisonType) { throw null; } + + public static bool Contains(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static void CopyTo(this T[] source, Memory destination) { } + + public static void CopyTo(this T[] source, Span destination) { } + + public static bool EndsWith(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static bool EndsWith(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static bool EndsWith(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static bool Equals(this ReadOnlySpan span, ReadOnlySpan other, StringComparison comparisonType) { throw null; } + + public static int IndexOf(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static int IndexOf(this ReadOnlySpan span, T value) + where T : IEquatable { throw null; } + + public static int IndexOf(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int IndexOf(this Span span, T value) + where T : IEquatable { throw null; } + + public static int IndexOf(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this ReadOnlySpan span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this ReadOnlySpan span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this ReadOnlySpan span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this Span span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this Span span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this Span span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static bool IsWhiteSpace(this ReadOnlySpan span) { throw null; } + + public static int LastIndexOf(this ReadOnlySpan span, T value) + where T : IEquatable { throw null; } + + public static int LastIndexOf(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int LastIndexOf(this Span span, T value) + where T : IEquatable { throw null; } + + public static int LastIndexOf(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this ReadOnlySpan span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this ReadOnlySpan span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this ReadOnlySpan span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this Span span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this Span span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this Span span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static bool Overlaps(this ReadOnlySpan span, ReadOnlySpan other, out int elementOffset) { throw null; } + + public static bool Overlaps(this ReadOnlySpan span, ReadOnlySpan other) { throw null; } + + public static bool Overlaps(this Span span, ReadOnlySpan other, out int elementOffset) { throw null; } + + public static bool Overlaps(this Span span, ReadOnlySpan other) { throw null; } + + public static void Reverse(this Span span) { } + + public static int SequenceCompareTo(this ReadOnlySpan span, ReadOnlySpan other) + where T : IComparable { throw null; } + + public static int SequenceCompareTo(this Span span, ReadOnlySpan other) + where T : IComparable { throw null; } + + public static bool SequenceEqual(this ReadOnlySpan span, ReadOnlySpan other) + where T : IEquatable { throw null; } + + public static bool SequenceEqual(this Span span, ReadOnlySpan other) + where T : IEquatable { throw null; } + + public static bool StartsWith(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static bool StartsWith(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static bool StartsWith(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int ToLower(this ReadOnlySpan source, Span destination, Globalization.CultureInfo culture) { throw null; } + + public static int ToLowerInvariant(this ReadOnlySpan source, Span destination) { throw null; } + + public static int ToUpper(this ReadOnlySpan source, Span destination, Globalization.CultureInfo culture) { throw null; } + + public static int ToUpperInvariant(this ReadOnlySpan source, Span destination) { throw null; } + + public static ReadOnlySpan Trim(this ReadOnlySpan span, char trimChar) { throw null; } + + public static ReadOnlySpan Trim(this ReadOnlySpan span, ReadOnlySpan trimChars) { throw null; } + + public static ReadOnlySpan Trim(this ReadOnlySpan span) { throw null; } + + public static ReadOnlySpan TrimEnd(this ReadOnlySpan span, char trimChar) { throw null; } + + public static ReadOnlySpan TrimEnd(this ReadOnlySpan span, ReadOnlySpan trimChars) { throw null; } + + public static ReadOnlySpan TrimEnd(this ReadOnlySpan span) { throw null; } + + public static ReadOnlySpan TrimStart(this ReadOnlySpan span, char trimChar) { throw null; } + + public static ReadOnlySpan TrimStart(this ReadOnlySpan span, ReadOnlySpan trimChars) { throw null; } + + public static ReadOnlySpan TrimStart(this ReadOnlySpan span) { throw null; } + } + + public readonly partial struct Memory + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public Memory(T[] array, int start, int length) { } + + public Memory(T[] array) { } + + public static Memory Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public int Length { get { throw null; } } + + public Span Span { get { throw null; } } + + public readonly void CopyTo(Memory destination) { } + + public readonly bool Equals(Memory other) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static implicit operator Memory(T[] array) { throw null; } + + public static implicit operator Memory(ArraySegment segment) { throw null; } + + public static implicit operator ReadOnlyMemory(Memory memory) { throw null; } + + public readonly Buffers.MemoryHandle Pin() { throw null; } + + public readonly Memory Slice(int start, int length) { throw null; } + + public readonly Memory Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Memory destination) { throw null; } + } + + public readonly partial struct ReadOnlyMemory + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ReadOnlyMemory(T[] array, int start, int length) { } + + public ReadOnlyMemory(T[] array) { } + + public static ReadOnlyMemory Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public int Length { get { throw null; } } + + public ReadOnlySpan Span { get { throw null; } } + + public readonly void CopyTo(Memory destination) { } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(ReadOnlyMemory other) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static implicit operator ReadOnlyMemory(T[] array) { throw null; } + + public static implicit operator ReadOnlyMemory(ArraySegment segment) { throw null; } + + public readonly Buffers.MemoryHandle Pin() { throw null; } + + public readonly ReadOnlyMemory Slice(int start, int length) { throw null; } + + public readonly ReadOnlyMemory Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Memory destination) { throw null; } + } + + public readonly ref partial struct ReadOnlySpan + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ReadOnlySpan(T[] array, int start, int length) { } + + public ReadOnlySpan(T[] array) { } + + [CLSCompliant(false)] + public unsafe ReadOnlySpan(void* pointer, int length) { } + + public static ReadOnlySpan Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public ref readonly T this[int index] { get { throw null; } } + + public int Length { get { throw null; } } + + public readonly void CopyTo(Span destination) { } + + [Obsolete("Equals() on ReadOnlySpan will always throw an exception. Use == instead.")] + public override readonly bool Equals(object obj) { throw null; } + + public readonly Enumerator GetEnumerator() { throw null; } + + [Obsolete("GetHashCode() on ReadOnlySpan will always throw an exception.")] + public override readonly int GetHashCode() { throw null; } + + public readonly ref readonly T GetPinnableReference() { throw null; } + + public static bool operator ==(ReadOnlySpan left, ReadOnlySpan right) { throw null; } + + public static implicit operator ReadOnlySpan(T[] array) { throw null; } + + public static implicit operator ReadOnlySpan(ArraySegment segment) { throw null; } + + public static bool operator !=(ReadOnlySpan left, ReadOnlySpan right) { throw null; } + + public readonly ReadOnlySpan Slice(int start, int length) { throw null; } + + public readonly ReadOnlySpan Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Span destination) { throw null; } + + public ref partial struct Enumerator + { + private ReadOnlySpan _span; + private object _dummy; + private int _dummyPrimitive; + public ref readonly T Current { get { throw null; } } + + public bool MoveNext() { throw null; } + } + } + + public readonly partial struct SequencePosition : IEquatable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public SequencePosition(object @object, int integer) { } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(SequencePosition other) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public readonly int GetInteger() { throw null; } + + public readonly object GetObject() { throw null; } + } + + public readonly ref partial struct Span + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public Span(T[] array, int start, int length) { } + + public Span(T[] array) { } + + [CLSCompliant(false)] + public unsafe Span(void* pointer, int length) { } + + public static Span Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public ref T this[int index] { get { throw null; } } + + public int Length { get { throw null; } } + + public readonly void Clear() { } + + public readonly void CopyTo(Span destination) { } + + [Obsolete("Equals() on Span will always throw an exception. Use == instead.")] + public override readonly bool Equals(object obj) { throw null; } + + public readonly void Fill(T value) { } + + public readonly Enumerator GetEnumerator() { throw null; } + + [Obsolete("GetHashCode() on Span will always throw an exception.")] + public override readonly int GetHashCode() { throw null; } + + public readonly ref T GetPinnableReference() { throw null; } + + public static bool operator ==(Span left, Span right) { throw null; } + + public static implicit operator Span(T[] array) { throw null; } + + public static implicit operator Span(ArraySegment segment) { throw null; } + + public static implicit operator ReadOnlySpan(Span span) { throw null; } + + public static bool operator !=(Span left, Span right) { throw null; } + + public readonly Span Slice(int start, int length) { throw null; } + + public readonly Span Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Span destination) { throw null; } + + public ref partial struct Enumerator + { + private Span _span; + private object _dummy; + private int _dummyPrimitive; + public ref T Current { get { throw null; } } + + public bool MoveNext() { throw null; } + } + } +} + +namespace System.Buffers +{ + public static partial class BuffersExtensions + { + public static void CopyTo(this in ReadOnlySequence source, Span destination) { } + + public static SequencePosition? PositionOf(this in ReadOnlySequence source, T value) + where T : IEquatable { throw null; } + + public static T[] ToArray(this in ReadOnlySequence sequence) { throw null; } + + public static void Write(this IBufferWriter writer, ReadOnlySpan value) { } + } + + public partial interface IBufferWriter + { + void Advance(int count); + Memory GetMemory(int sizeHint = 0); + Span GetSpan(int sizeHint = 0); + } + + public partial interface IMemoryOwner : IDisposable + { + Memory Memory { get; } + } + + public partial interface IPinnable + { + MemoryHandle Pin(int elementIndex); + void Unpin(); + } + + public partial struct MemoryHandle : IDisposable + { + private object _dummy; + private int _dummyPrimitive; + [CLSCompliant(false)] + public unsafe MemoryHandle(void* pointer, Runtime.InteropServices.GCHandle handle = default, IPinnable pinnable = null) { } + + [CLSCompliant(false)] + public unsafe void* Pointer { get { throw null; } } + + public void Dispose() { } + } + + public abstract partial class MemoryManager : IMemoryOwner, IDisposable, IPinnable + { + public virtual Memory Memory { get { throw null; } } + + protected Memory CreateMemory(int start, int length) { throw null; } + + protected Memory CreateMemory(int length) { throw null; } + + protected abstract void Dispose(bool disposing); + public abstract Span GetSpan(); + public abstract MemoryHandle Pin(int elementIndex = 0); + void IDisposable.Dispose() { } + + protected internal virtual bool TryGetArray(out ArraySegment segment) { throw null; } + + public abstract void Unpin(); + } + + public abstract partial class MemoryPool : IDisposable + { + public abstract int MaxBufferSize { get; } + + public static MemoryPool Shared { get { throw null; } } + + public void Dispose() { } + + protected abstract void Dispose(bool disposing); + public abstract IMemoryOwner Rent(int minBufferSize = -1); + } + + public enum OperationStatus + { + Done = 0, + DestinationTooSmall = 1, + NeedMoreData = 2, + InvalidData = 3 + } + + public abstract partial class ReadOnlySequenceSegment + { + public ReadOnlyMemory Memory { get { throw null; } protected set { } } + + public ReadOnlySequenceSegment Next { get { throw null; } protected set { } } + + public long RunningIndex { get { throw null; } protected set { } } + } + + public readonly partial struct ReadOnlySequence + { + public static readonly ReadOnlySequence Empty; + public ReadOnlySequence(T[] array, int start, int length) { } + + public ReadOnlySequence(T[] array) { } + + public ReadOnlySequence(ReadOnlySequenceSegment startSegment, int startIndex, ReadOnlySequenceSegment endSegment, int endIndex) { } + + public ReadOnlySequence(ReadOnlyMemory memory) { } + + public SequencePosition End { get { throw null; } } + + public ReadOnlyMemory First { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public bool IsSingleSegment { get { throw null; } } + + public long Length { get { throw null; } } + + public SequencePosition Start { get { throw null; } } + + public readonly Enumerator GetEnumerator() { throw null; } + + public readonly SequencePosition GetPosition(long offset, SequencePosition origin) { throw null; } + + public readonly SequencePosition GetPosition(long offset) { throw null; } + + public readonly ReadOnlySequence Slice(int start, int length) { throw null; } + + public readonly ReadOnlySequence Slice(int start, SequencePosition end) { throw null; } + + public readonly ReadOnlySequence Slice(long start, long length) { throw null; } + + public readonly ReadOnlySequence Slice(long start, SequencePosition end) { throw null; } + + public readonly ReadOnlySequence Slice(long start) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start, int length) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start, long length) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start, SequencePosition end) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start) { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryGet(ref SequencePosition position, out ReadOnlyMemory memory, bool advance = true) { throw null; } + + public partial struct Enumerator + { + private ReadOnlySequence _sequence; + private ReadOnlyMemory _currentMemory; + private int _dummyPrimitive; + public Enumerator(in ReadOnlySequence sequence) { } + + public ReadOnlyMemory Current { get { throw null; } } + + public bool MoveNext() { throw null; } + } + } + + public readonly partial struct StandardFormat : IEquatable + { + private readonly int _dummyPrimitive; + public const byte MaxPrecision = 99; + public const byte NoPrecision = 255; + public StandardFormat(char symbol, byte precision = 255) { } + + public bool HasPrecision { get { throw null; } } + + public bool IsDefault { get { throw null; } } + + public byte Precision { get { throw null; } } + + public char Symbol { get { throw null; } } + + public readonly bool Equals(StandardFormat other) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static bool operator ==(StandardFormat left, StandardFormat right) { throw null; } + + public static implicit operator StandardFormat(char symbol) { throw null; } + + public static bool operator !=(StandardFormat left, StandardFormat right) { throw null; } + + public static StandardFormat Parse(ReadOnlySpan format) { throw null; } + + public static StandardFormat Parse(string format) { throw null; } + + public override readonly string ToString() { throw null; } + } +} + +namespace System.Buffers.Binary +{ + public static partial class BinaryPrimitives + { + public static short ReadInt16BigEndian(ReadOnlySpan source) { throw null; } + + public static short ReadInt16LittleEndian(ReadOnlySpan source) { throw null; } + + public static int ReadInt32BigEndian(ReadOnlySpan source) { throw null; } + + public static int ReadInt32LittleEndian(ReadOnlySpan source) { throw null; } + + public static long ReadInt64BigEndian(ReadOnlySpan source) { throw null; } + + public static long ReadInt64LittleEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ushort ReadUInt16BigEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ushort ReadUInt16LittleEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static uint ReadUInt32BigEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static uint ReadUInt32LittleEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ulong ReadUInt64BigEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ulong ReadUInt64LittleEndian(ReadOnlySpan source) { throw null; } + + public static byte ReverseEndianness(byte value) { throw null; } + + public static short ReverseEndianness(short value) { throw null; } + + public static int ReverseEndianness(int value) { throw null; } + + public static long ReverseEndianness(long value) { throw null; } + + [CLSCompliant(false)] + public static sbyte ReverseEndianness(sbyte value) { throw null; } + + [CLSCompliant(false)] + public static ushort ReverseEndianness(ushort value) { throw null; } + + [CLSCompliant(false)] + public static uint ReverseEndianness(uint value) { throw null; } + + [CLSCompliant(false)] + public static ulong ReverseEndianness(ulong value) { throw null; } + + public static bool TryReadInt16BigEndian(ReadOnlySpan source, out short value) { throw null; } + + public static bool TryReadInt16LittleEndian(ReadOnlySpan source, out short value) { throw null; } + + public static bool TryReadInt32BigEndian(ReadOnlySpan source, out int value) { throw null; } + + public static bool TryReadInt32LittleEndian(ReadOnlySpan source, out int value) { throw null; } + + public static bool TryReadInt64BigEndian(ReadOnlySpan source, out long value) { throw null; } + + public static bool TryReadInt64LittleEndian(ReadOnlySpan source, out long value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt16BigEndian(ReadOnlySpan source, out ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt16LittleEndian(ReadOnlySpan source, out ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt32BigEndian(ReadOnlySpan source, out uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt32LittleEndian(ReadOnlySpan source, out uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt64BigEndian(ReadOnlySpan source, out ulong value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt64LittleEndian(ReadOnlySpan source, out ulong value) { throw null; } + + public static bool TryWriteInt16BigEndian(Span destination, short value) { throw null; } + + public static bool TryWriteInt16LittleEndian(Span destination, short value) { throw null; } + + public static bool TryWriteInt32BigEndian(Span destination, int value) { throw null; } + + public static bool TryWriteInt32LittleEndian(Span destination, int value) { throw null; } + + public static bool TryWriteInt64BigEndian(Span destination, long value) { throw null; } + + public static bool TryWriteInt64LittleEndian(Span destination, long value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt16BigEndian(Span destination, ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt16LittleEndian(Span destination, ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt32BigEndian(Span destination, uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt32LittleEndian(Span destination, uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt64BigEndian(Span destination, ulong value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt64LittleEndian(Span destination, ulong value) { throw null; } + + public static void WriteInt16BigEndian(Span destination, short value) { } + + public static void WriteInt16LittleEndian(Span destination, short value) { } + + public static void WriteInt32BigEndian(Span destination, int value) { } + + public static void WriteInt32LittleEndian(Span destination, int value) { } + + public static void WriteInt64BigEndian(Span destination, long value) { } + + public static void WriteInt64LittleEndian(Span destination, long value) { } + + [CLSCompliant(false)] + public static void WriteUInt16BigEndian(Span destination, ushort value) { } + + [CLSCompliant(false)] + public static void WriteUInt16LittleEndian(Span destination, ushort value) { } + + [CLSCompliant(false)] + public static void WriteUInt32BigEndian(Span destination, uint value) { } + + [CLSCompliant(false)] + public static void WriteUInt32LittleEndian(Span destination, uint value) { } + + [CLSCompliant(false)] + public static void WriteUInt64BigEndian(Span destination, ulong value) { } + + [CLSCompliant(false)] + public static void WriteUInt64LittleEndian(Span destination, ulong value) { } + } +} + +namespace System.Buffers.Text +{ + public static partial class Base64 + { + public static OperationStatus DecodeFromUtf8(ReadOnlySpan utf8, Span bytes, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; } + + public static OperationStatus DecodeFromUtf8InPlace(Span buffer, out int bytesWritten) { throw null; } + + public static OperationStatus EncodeToUtf8(ReadOnlySpan bytes, Span utf8, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; } + + public static OperationStatus EncodeToUtf8InPlace(Span buffer, int dataLength, out int bytesWritten) { throw null; } + + public static int GetMaxDecodedFromUtf8Length(int length) { throw null; } + + public static int GetMaxEncodedToUtf8Length(int length) { throw null; } + } + + public static partial class Utf8Formatter + { + public static bool TryFormat(bool value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(byte value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(DateTime value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(DateTimeOffset value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(decimal value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(double value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(Guid value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(short value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(int value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(long value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(sbyte value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(float value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(TimeSpan value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(ushort value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(uint value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(ulong value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + } + + public static partial class Utf8Parser + { + public static bool TryParse(ReadOnlySpan source, out bool value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out byte value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out DateTime value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out decimal value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out double value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out Guid value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out short value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out int value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out long value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out sbyte value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out float value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out TimeSpan value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out ushort value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out uint value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out ulong value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + } +} + +namespace System.Runtime.InteropServices +{ + public static partial class MemoryMarshal + { + public static ReadOnlySpan AsBytes(ReadOnlySpan span) + where T : struct { throw null; } + + public static Span AsBytes(Span span) + where T : struct { throw null; } + + public static Memory AsMemory(ReadOnlyMemory memory) { throw null; } + + public static ReadOnlySpan Cast(ReadOnlySpan span) + where TFrom : struct where TTo : struct { throw null; } + + public static Span Cast(Span span) + where TFrom : struct where TTo : struct { throw null; } + + public static Memory CreateFromPinnedArray(T[] array, int start, int length) { throw null; } + + public static ref T GetReference(ReadOnlySpan span) { throw null; } + + public static ref T GetReference(Span span) { throw null; } + + public static T Read(ReadOnlySpan source) + where T : struct { throw null; } + + public static Collections.Generic.IEnumerable ToEnumerable(ReadOnlyMemory memory) { throw null; } + + public static bool TryGetArray(ReadOnlyMemory memory, out ArraySegment segment) { throw null; } + + public static bool TryGetMemoryManager(ReadOnlyMemory memory, out TManager manager, out int start, out int length) + where TManager : Buffers.MemoryManager { throw null; } + + public static bool TryGetMemoryManager(ReadOnlyMemory memory, out TManager manager) + where TManager : Buffers.MemoryManager { throw null; } + + public static bool TryGetString(ReadOnlyMemory memory, out string text, out int start, out int length) { throw null; } + + public static bool TryRead(ReadOnlySpan source, out T value) + where T : struct { throw null; } + + public static bool TryWrite(Span destination, ref T value) + where T : struct { throw null; } + + public static void Write(Span destination, ref T value) + where T : struct { } + } + + public static partial class SequenceMarshal + { + public static bool TryGetArray(Buffers.ReadOnlySequence sequence, out ArraySegment segment) { throw null; } + + public static bool TryGetReadOnlyMemory(Buffers.ReadOnlySequence sequence, out ReadOnlyMemory memory) { throw null; } + + public static bool TryGetReadOnlySequenceSegment(Buffers.ReadOnlySequence sequence, out Buffers.ReadOnlySequenceSegment startSegment, out int startIndex, out Buffers.ReadOnlySequenceSegment endSegment, out int endIndex) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.memory/4.6.1/system.memory.nuspec b/src/referencePackages/src/system.memory/4.6.1/system.memory.nuspec new file mode 100644 index 0000000000..09bf1c90d1 --- /dev/null +++ b/src/referencePackages/src/system.memory/4.6.1/system.memory.nuspec @@ -0,0 +1,23 @@ + + + + System.Memory + 4.6.1 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Memory + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + + \ No newline at end of file From 58922b204a5d9d6844ad92009452208ca92da227 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20S=C3=A1nchez=20L=C3=B3pez?= <1175054+carlossanlop@users.noreply.github.com> Date: Fri, 14 Mar 2025 22:28:52 +0000 Subject: [PATCH 3/5] System.Net.WebSockets.WebSocketProtocol 5.1.1 --- ....WebSockets.WebSocketProtocol.5.1.1.csproj | 18 ++++++++++ ...System.Net.WebSockets.WebSocketProtocol.cs | 34 +++++++++++++++++++ ...System.Net.WebSockets.WebSocketProtocol.cs | 34 +++++++++++++++++++ ...em.net.websockets.websocketprotocol.nuspec | 26 ++++++++++++++ 4 files changed, 112 insertions(+) create mode 100644 src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/System.Net.WebSockets.WebSocketProtocol.5.1.1.csproj create mode 100644 src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs create mode 100644 src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs create mode 100644 src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/system.net.websockets.websocketprotocol.nuspec diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/System.Net.WebSockets.WebSocketProtocol.5.1.1.csproj b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/System.Net.WebSockets.WebSocketProtocol.5.1.1.csproj new file mode 100644 index 0000000000..aa764568f9 --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/System.Net.WebSockets.WebSocketProtocol.5.1.1.csproj @@ -0,0 +1,18 @@ + + + + net6.0;netstandard2.0 + 5.1.1 + System.Net.WebSockets.WebSocketProtocol + Open + + + + + + + + + + + diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs new file mode 100644 index 0000000000..cce1a7f16a --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyFileVersion("5.100.125.15403")] +[assembly: System.Reflection.AssemblyInformationalVersion("5.1.1+ab95a1f103b49919ba02577a99f3173405bb50ca")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("5.1.1.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Net.WebSockets +{ + public static partial class WebSocketProtocol + { + public static WebSocket CreateFromStream(IO.Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs new file mode 100644 index 0000000000..51c490df24 --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyFileVersion("5.100.125.15403")] +[assembly: System.Reflection.AssemblyInformationalVersion("5.1.1+ab95a1f103b49919ba02577a99f3173405bb50ca")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("5.1.1.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Net.WebSockets +{ + public static partial class WebSocketProtocol + { + public static WebSocket CreateFromStream(IO.Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/system.net.websockets.websocketprotocol.nuspec b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/system.net.websockets.websocketprotocol.nuspec new file mode 100644 index 0000000000..b0de26f4dd --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.1/system.net.websockets.websocketprotocol.nuspec @@ -0,0 +1,26 @@ + + + + System.Net.WebSockets.WebSocketProtocol + 5.1.1 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Net.WebSockets.WebSocketProtocol + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + + + + + \ No newline at end of file From 05063d06f5271a10489614bc178ca288ac59ac3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20S=C3=A1nchez=20L=C3=B3pez?= <1175054+carlossanlop@users.noreply.github.com> Date: Fri, 14 Mar 2025 22:29:08 +0000 Subject: [PATCH 4/5] System.Runtime.CompilerServices.Unsafe 6.1.1 --- .../6.1.1/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs | 2 +- .../netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs | 2 +- .../6.1.1/system.runtime.compilerservices.unsafe.nuspec | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs index 46e0e21851..22d1833234 100644 --- a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs +++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs @@ -10,7 +10,7 @@ [assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.Default | System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] [assembly: System.Reflection.AssemblyDescription("System.Runtime.CompilerServices.Unsafe")] -[assembly: System.Reflection.AssemblyFileVersion("6.100.125.11301")] +[assembly: System.Reflection.AssemblyFileVersion("6.100.125.10404")] [assembly: System.Reflection.AssemblyInformationalVersion("6.1.1")] [assembly: System.Reflection.AssemblyTitle("System.Runtime.CompilerServices.Unsafe")] [assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs index 46e0e21851..22d1833234 100644 --- a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs +++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs @@ -10,7 +10,7 @@ [assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.Default | System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] [assembly: System.Reflection.AssemblyDescription("System.Runtime.CompilerServices.Unsafe")] -[assembly: System.Reflection.AssemblyFileVersion("6.100.125.11301")] +[assembly: System.Reflection.AssemblyFileVersion("6.100.125.10404")] [assembly: System.Reflection.AssemblyInformationalVersion("6.1.1")] [assembly: System.Reflection.AssemblyTitle("System.Runtime.CompilerServices.Unsafe")] [assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/system.runtime.compilerservices.unsafe.nuspec b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/system.runtime.compilerservices.unsafe.nuspec index e8563bdca0..f8457600a6 100644 --- a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/system.runtime.compilerservices.unsafe.nuspec +++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.1/system.runtime.compilerservices.unsafe.nuspec @@ -11,7 +11,7 @@ Provides the System.Runtime.CompilerServices.Unsafe class, which provides generic, low-level functionality for manipulating pointers. © Microsoft Corporation. All rights reserved. true - + From d53bf37645f03165d25a50b017e069c128796470 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20S=C3=A1nchez=20L=C3=B3pez?= <1175054+carlossanlop@users.noreply.github.com> Date: Fri, 14 Mar 2025 22:29:18 +0000 Subject: [PATCH 5/5] System.Threading.Tasks.Extensions 4.6.1 --- ...em.Threading.Tasks.Extensions.4.6.1.csproj | 14 + .../System.Threading.Tasks.Extensions.cs | 268 ++++++++++++++++++ .../system.threading.tasks.extensions.nuspec | 21 ++ 3 files changed, 303 insertions(+) create mode 100644 src/referencePackages/src/system.threading.tasks.extensions/4.6.1/System.Threading.Tasks.Extensions.4.6.1.csproj create mode 100644 src/referencePackages/src/system.threading.tasks.extensions/4.6.1/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs create mode 100644 src/referencePackages/src/system.threading.tasks.extensions/4.6.1/system.threading.tasks.extensions.nuspec diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/System.Threading.Tasks.Extensions.4.6.1.csproj b/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/System.Threading.Tasks.Extensions.4.6.1.csproj new file mode 100644 index 0000000000..ef450a9314 --- /dev/null +++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/System.Threading.Tasks.Extensions.4.6.1.csproj @@ -0,0 +1,14 @@ + + + + netstandard2.0 + 4.6.1 + System.Threading.Tasks.Extensions + Open + + + + + + + diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs b/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs new file mode 100644 index 0000000000..3d84c226b0 --- /dev/null +++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs @@ -0,0 +1,268 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Threading.Tasks.Extensions")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Threading.Tasks.Extensions")] +[assembly: System.Reflection.AssemblyFileVersion("4.600.125.15403")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.1+ab95a1f103b49919ba02577a99f3173405bb50ca")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Threading.Tasks.Extensions")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.2.2.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Runtime.CompilerServices +{ + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false, AllowMultiple = false)] + public sealed partial class AsyncMethodBuilderAttribute : Attribute + { + public AsyncMethodBuilderAttribute(Type builderType) { } + + public Type BuilderType { get { throw null; } } + } + + public partial struct AsyncValueTaskMethodBuilder + { + private int _dummyPrimitive; + public Threading.Tasks.ValueTask Task { get { throw null; } } + + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public static AsyncValueTaskMethodBuilder Create() { throw null; } + + public void SetException(Exception exception) { } + + public void SetResult() { } + + public void SetStateMachine(IAsyncStateMachine stateMachine) { } + + public void Start(ref TStateMachine stateMachine) + where TStateMachine : IAsyncStateMachine { } + } + + public partial struct AsyncValueTaskMethodBuilder + { + private AsyncTaskMethodBuilder _methodBuilder; + private TResult _result; + private int _dummyPrimitive; + public Threading.Tasks.ValueTask Task { get { throw null; } } + + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public static AsyncValueTaskMethodBuilder Create() { throw null; } + + public void SetException(Exception exception) { } + + public void SetResult(TResult result) { } + + public void SetStateMachine(IAsyncStateMachine stateMachine) { } + + public void Start(ref TStateMachine stateMachine) + where TStateMachine : IAsyncStateMachine { } + } + + public readonly partial struct ConfiguredValueTaskAwaitable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public readonly ConfiguredValueTaskAwaiter GetAwaiter() { throw null; } + + public readonly partial struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly void GetResult() { } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } + } + + public readonly partial struct ConfiguredValueTaskAwaitable + { + private readonly Threading.Tasks.ValueTask _value; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public readonly ConfiguredValueTaskAwaiter GetAwaiter() { throw null; } + + public readonly partial struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly Threading.Tasks.ValueTask _value; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly TResult GetResult() { throw null; } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } + } + + public readonly partial struct ValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly void GetResult() { } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } + + public readonly partial struct ValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly Threading.Tasks.ValueTask _value; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly TResult GetResult() { throw null; } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } +} + +namespace System.Threading.Tasks +{ + [Runtime.CompilerServices.AsyncMethodBuilder(typeof(Runtime.CompilerServices.AsyncValueTaskMethodBuilder))] + public readonly partial struct ValueTask : IEquatable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ValueTask(Sources.IValueTaskSource source, short token) { } + + public ValueTask(Task task) { } + + public bool IsCanceled { get { throw null; } } + + public bool IsCompleted { get { throw null; } } + + public bool IsCompletedSuccessfully { get { throw null; } } + + public bool IsFaulted { get { throw null; } } + + public readonly Task AsTask() { throw null; } + + public readonly Runtime.CompilerServices.ConfiguredValueTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(ValueTask other) { throw null; } + + public readonly Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter() { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static bool operator ==(ValueTask left, ValueTask right) { throw null; } + + public static bool operator !=(ValueTask left, ValueTask right) { throw null; } + + public readonly ValueTask Preserve() { throw null; } + } + + [Runtime.CompilerServices.AsyncMethodBuilder(typeof(Runtime.CompilerServices.AsyncValueTaskMethodBuilder<>))] + public readonly partial struct ValueTask : IEquatable> + { + private readonly TResult _result; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ValueTask(TResult result) { } + + public ValueTask(Sources.IValueTaskSource source, short token) { } + + public ValueTask(Task task) { } + + public bool IsCanceled { get { throw null; } } + + public bool IsCompleted { get { throw null; } } + + public bool IsCompletedSuccessfully { get { throw null; } } + + public bool IsFaulted { get { throw null; } } + + public TResult Result { get { throw null; } } + + public readonly Task AsTask() { throw null; } + + public readonly Runtime.CompilerServices.ConfiguredValueTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(ValueTask other) { throw null; } + + public readonly Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter() { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static bool operator ==(ValueTask left, ValueTask right) { throw null; } + + public static bool operator !=(ValueTask left, ValueTask right) { throw null; } + + public readonly ValueTask Preserve() { throw null; } + + public override readonly string ToString() { throw null; } + } +} + +namespace System.Threading.Tasks.Sources +{ + public partial interface IValueTaskSource + { + void GetResult(short token); + ValueTaskSourceStatus GetStatus(short token); + void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags); + } + + public partial interface IValueTaskSource + { + TResult GetResult(short token); + ValueTaskSourceStatus GetStatus(short token); + void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags); + } + + [Flags] + public enum ValueTaskSourceOnCompletedFlags + { + None = 0, + UseSchedulingContext = 1, + FlowExecutionContext = 2 + } + + public enum ValueTaskSourceStatus + { + Pending = 0, + Succeeded = 1, + Faulted = 2, + Canceled = 3 + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/system.threading.tasks.extensions.nuspec b/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/system.threading.tasks.extensions.nuspec new file mode 100644 index 0000000000..8ba024f182 --- /dev/null +++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.1/system.threading.tasks.extensions.nuspec @@ -0,0 +1,21 @@ + + + + System.Threading.Tasks.Extensions + 4.6.1 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Threading.Tasks.Extensions + © Microsoft Corporation. All rights reserved. + true + + + + + + + + \ No newline at end of file