add api diff for preview2 (#6068)

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2.md

@@ -0,0 +1,18 @@
+# API Difference 6.0.0-preview.1 vs 6.0.0-preview.2
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System](6.0-preview2_System.md)
+* [System.CodeDom.Compiler](6.0-preview2_System.CodeDom.Compiler.md)
+* [System.Collections.Concurrent](6.0-preview2_System.Collections.Concurrent.md)
+* [System.Collections.Generic](6.0-preview2_System.Collections.Generic.md)
+* [System.Diagnostics](6.0-preview2_System.Diagnostics.md)
+* [System.Linq](6.0-preview2_System.Linq.md)
+* [System.Net.Sockets](6.0-preview2_System.Net.Sockets.md)
+* [System.Numerics](6.0-preview2_System.Numerics.md)
+* [System.Reflection.Metadata](6.0-preview2_System.Reflection.Metadata.md)
+* [System.Runtime.InteropServices](6.0-preview2_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics.Arm](6.0-preview2_System.Runtime.Intrinsics.Arm.md)
+* [System.Text.Json.Serialization](6.0-preview2_System.Text.Json.Serialization.md)
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.CodeDom.Compiler.md

@@ -0,0 +1,24 @@
+# System.CodeDom.Compiler
+
+``` diff
+ namespace System.CodeDom.Compiler {
+     public class IndentedTextWriter : TextWriter {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync();
++        protected virtual Task OutputTabsAsync();
++        public override Task WriteAsync(char value);
++        public override Task WriteAsync(char[] buffer, int index, int count);
++        public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override Task WriteAsync(string value);
++        public override Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
++        public override Task WriteLineAsync();
++        public override Task WriteLineAsync(char value);
++        public override Task WriteLineAsync(char[] buffer, int index, int count);
++        public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override Task WriteLineAsync(string value);
++        public override Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
++        public Task WriteLineNoTabsAsync(string s);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Collections.Concurrent.md

@@ -0,0 +1,10 @@
+# System.Collections.Concurrent
+
+``` diff
+ namespace System.Collections.Concurrent {
+     public class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
++        public IEqualityComparer<TKey> Comparer { get; }
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Collections.Generic.md

@@ -0,0 +1,46 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
++    public class PriorityQueue<TElement, TPriority> {
++        public PriorityQueue();
++        public PriorityQueue(IComparer<TPriority> comparer);
++        public PriorityQueue(IEnumerable<ValueTuple<TElement, TPriority>> items);
++        public PriorityQueue(IEnumerable<ValueTuple<TElement, TPriority>> items, IComparer<TPriority> comparer);
++        public PriorityQueue(int initialCapacity);
++        public PriorityQueue(int initialCapacity, IComparer<TPriority> comparer);
++        public IComparer<TPriority> Comparer { get; }
++        public int Count { get; }
++        public PriorityQueue<TElement, TPriority>.UnorderedItemsCollection UnorderedItems { get; }
++        public void Clear();
++        public TElement Dequeue();
++        public void Enqueue(TElement element, TPriority priority);
++        public TElement EnqueueDequeue(TElement element, TPriority priority);
++        public void EnqueueRange(IEnumerable<ValueTuple<TElement, TPriority>> items);
++        public void EnqueueRange(IEnumerable<TElement> elements, TPriority priority);
++        public int EnsureCapacity(int capacity);
++        public TElement Peek();
++        public void TrimExcess();
++        public bool TryDequeue(out TElement element, out TPriority priority);
++        public bool TryPeek(out TElement element, out TPriority priority);
++        public sealed class UnorderedItemsCollection : ICollection, IEnumerable, IEnumerable<ValueTuple<TElement, TPriority>>, IReadOnlyCollection<ValueTuple<TElement, TPriority>> {
++            public int Count { get; }
++            bool System.Collections.ICollection.IsSynchronized { get; }
++            object System.Collections.ICollection.SyncRoot { get; }
++            public PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator GetEnumerator();
++            IEnumerator<ValueTuple<TElement, TPriority>> System.Collections.Generic.IEnumerable<(TElementElement,TPriorityPriority)>.GetEnumerator();
++            void System.Collections.ICollection.CopyTo(Array array, int index);
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++            public struct Enumerator : IDisposable, IEnumerator, IEnumerator<ValueTuple<TElement, TPriority>> {
++                public (TElement Element, TPriority Priority) Current { get; }
++                (TElement Element, TPriority Priority) System.Collections.Generic.IEnumerator<(TElementElement,TPriorityPriority)>.Current { get; }
++                object System.Collections.IEnumerator.Current { get; }
++                public void Dispose();
++                public bool MoveNext();
++                void System.Collections.IEnumerator.Reset();
++            }
++        }
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Diagnostics.md

@@ -0,0 +1,19 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public class Activity : IDisposable {
++        public ActivityStatusCode Status { get; }
++        public string StatusDescription { get; }
++        public static Func<ActivityTraceId> TraceIdGenerator { get; set; }
++        public object GetTagItem(string key);
++        public Activity SetStatus(ActivityStatusCode code, string description = null);
+     }
++    public enum ActivityStatusCode {
++        Error = 2,
++        Ok = 1,
++        Unset = 0,
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Linq.md

@@ -0,0 +1,14 @@
+# System.Linq
+
+``` diff
+ namespace System.Linq {
+     public static class Enumerable {
++        public static IEnumerable<TSource[]> Chunk<TSource>(this IEnumerable<TSource> source, int size);
++        public static bool TryGetNonEnumeratedCount<TSource>(this IEnumerable<TSource> source, out int count);
+     }
+     public static class Queryable {
++        public static IQueryable<TSource[]> Chunk<TSource>(this IQueryable<TSource> source, int size);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Net.Sockets.md

@@ -0,0 +1,13 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public class Socket : IDisposable {
++        public ValueTask<SocketReceiveFromResult> ReceiveFromAsync(Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint, CancellationToken cancellationToken = default(CancellationToken));
++        public int ReceiveMessageFrom(Span<byte> buffer, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation);
++        public ValueTask<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint, CancellationToken cancellationToken = default(CancellationToken));
++        public ValueTask<int> SendToAsync(ReadOnlyMemory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Numerics.md

@@ -0,0 +1,16 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public static class BitOperations {
++        public static bool IsPow2(int value);
++        public static bool IsPow2(long value);
++        public static bool IsPow2(uint value);
++        public static bool IsPow2(ulong value);
+     }
+     public static class Vector {
++        public static Vector<TTo> As<TFrom, TTo>(this Vector<TFrom> vector) where TFrom : struct where TTo : struct;
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Reflection.Metadata.md

@@ -0,0 +1,10 @@
+# System.Reflection.Metadata
+
+``` diff
+ namespace System.Reflection.Metadata {
+     public static class AssemblyExtensions {
++        public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Runtime.InteropServices.md

@@ -0,0 +1,11 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+     public static class MemoryMarshal {
++        public unsafe static ReadOnlySpan<byte> CreateReadOnlySpanFromNullTerminated(byte* value);
++        public unsafe static ReadOnlySpan<char> CreateReadOnlySpanFromNullTerminated(char* value);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Runtime.Intrinsics.Arm.md

@@ -0,0 +1,13 @@
+# System.Runtime.Intrinsics.Arm
+
+``` diff
+ namespace System.Runtime.Intrinsics.Arm {
+     public abstract class ArmBase {
+         public abstract class Arm64 {
++            public static long MultiplyHigh(long left, long right);
++            public static ulong MultiplyHigh(ulong left, ulong right);
+         }
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.Text.Json.Serialization.md

@@ -0,0 +1,10 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
+     public abstract class ReferenceHandler {
++        public static ReferenceHandler IgnoreCycles { get; }
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/.Net/6.0-preview2_System.md

@@ -0,0 +1,19 @@
+# System
+
+``` diff
+ namespace System {
+     public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, ISerializable {
++        public static IntPtr Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider provider = null);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out IntPtr result);
++        public static bool TryParse(ReadOnlySpan<char> s, out IntPtr result);
+     }
+     public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, IFormattable, ISerializable {
++        public static UIntPtr Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider provider = null);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UIntPtr result);
++        public static bool TryParse(ReadOnlySpan<char> s, out UIntPtr result);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2.md

@@ -0,0 +1,19 @@
+# API Difference 6.0.0-preview.1 vs 6.0.0-preview.2
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Builder](6.0-preview2_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components](6.0-preview2_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.Lifetime](6.0-preview2_Microsoft.AspNetCore.Components.Lifetime.md)
+* [Microsoft.AspNetCore.Components.Rendering](6.0-preview2_Microsoft.AspNetCore.Components.Rendering.md)
+* [Microsoft.AspNetCore.Components.RenderTree](6.0-preview2_Microsoft.AspNetCore.Components.RenderTree.md)
+* [Microsoft.AspNetCore.Http](6.0-preview2_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.Metadata](6.0-preview2_Microsoft.AspNetCore.Http.Metadata.md)
+* [Microsoft.AspNetCore.Mvc](6.0-preview2_Microsoft.AspNetCore.Mvc.md)
+* [Microsoft.AspNetCore.Mvc.Routing](6.0-preview2_Microsoft.AspNetCore.Mvc.Routing.md)
+* [Microsoft.AspNetCore.Mvc.TagHelpers](6.0-preview2_Microsoft.AspNetCore.Mvc.TagHelpers.md)
+* [Microsoft.AspNetCore.Routing](6.0-preview2_Microsoft.AspNetCore.Routing.md)
+* [Microsoft.Extensions.DependencyInjection](6.0-preview2_Microsoft.Extensions.DependencyInjection.md)
+* [System.Security.AccessControl](6.0-preview2_System.Security.AccessControl.md)
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Builder.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
++    public sealed class MapActionEndpointConventionBuilder : IEndpointConventionBuilder {
++        public void Add(Action<EndpointBuilder> convention);
++    }
++    public static class MapActionEndpointRouteBuilderExtensions {
++        public static MapActionEndpointConventionBuilder MapAction(this IEndpointRouteBuilder endpoints, Delegate action);
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Components.Lifetime.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Components.Lifetime
+
+``` diff
++namespace Microsoft.AspNetCore.Components.Lifetime {
++    public class ComponentApplicationLifetime {
++        public ComponentApplicationLifetime(ILogger<ComponentApplicationLifetime> logger);
++        public ComponentApplicationState State { get; }
++        public Task PersistStateAsync(IComponentApplicationStateStore store, Renderer renderer);
++        public Task RestoreStateAsync(IComponentApplicationStateStore store);
++    }
++    public interface IComponentApplicationStateStore {
++        Task<IDictionary<string, byte[]>> GetPersistedStateAsync();
++        Task PersistStateAsync(IReadOnlyDictionary<string, byte[]> state);
++    }
++}
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Components.RenderTree.md

@@ -0,0 +1,15 @@
+# Microsoft.AspNetCore.Components.RenderTree
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.RenderTree {
+     public abstract class Renderer : IAsyncDisposable, IDisposable {
++        public Type GetEventArgsType(ulong eventHandlerId);
+     }
+     public sealed class WebEventDescriptor {
+-        public string EventArgsType { get; set; }
+
++        public string EventName { get; set; }
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Components.Rendering.md

@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.Components.Rendering
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Rendering {
+     public sealed class RenderTreeBuilder : IDisposable {
++        public void Dispose();
+-        void System.IDisposable.Dispose();
+
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Components.md

@@ -0,0 +1,19 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
++    public sealed class CascadingTypeParameterAttribute : Attribute {
++        public CascadingTypeParameterAttribute(string name);
++        public string Name { get; }
++    }
++    public class ComponentApplicationState {
++        public event ComponentApplicationState.OnPersistingCallback OnPersisting;
++        public void PersistAsJson<TValue>(string key, TValue instance);
++        public void PersistState(string key, byte[] value);
++        public bool TryRedeemFromJson<TValue>(string key, out TValue instance);
++        public bool TryRedeemPersistedState(string key, out byte[] value);
++        public delegate Task OnPersistingCallback();
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Http.Metadata.md

@@ -0,0 +1,23 @@
+# Microsoft.AspNetCore.Http.Metadata
+
+``` diff
++namespace Microsoft.AspNetCore.Http.Metadata {
++    public interface IFromBodyMetadata {
++        bool AllowEmpty { get; }
++    }
++    public interface IFromFormMetadata {
++        string Name { get; }
++    }
++    public interface IFromHeaderMetadata {
++        string Name { get; }
++    }
++    public interface IFromQueryMetadata {
++        string Name { get; }
++    }
++    public interface IFromRouteMetadata {
++        string Name { get; }
++    }
++    public interface IFromServiceMetadata
++}
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Http.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
++    public interface IResult {
++        Task ExecuteAsync(HttpContext httpContext);
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Mvc.Routing.md

@@ -0,0 +1,18 @@
+# Microsoft.AspNetCore.Mvc.Routing
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.Routing {
+-    public abstract class HttpMethodAttribute : Attribute, IActionHttpMethodProvider, IRouteTemplateProvider {
++    public abstract class HttpMethodAttribute : Attribute, IActionHttpMethodProvider, IHttpMethodMetadata, IRouteNameMetadata, IRouteOrderMetadata, IRoutePatternMetadata, IRouteTemplateProvider {
++        bool Microsoft.AspNetCore.Routing.IHttpMethodMetadata.AcceptCorsPreflight { get; }
++        IReadOnlyList<string> Microsoft.AspNetCore.Routing.IHttpMethodMetadata.HttpMethods { get; }
+     }
+-    public interface IRouteTemplateProvider {
++    public interface IRouteTemplateProvider : IRouteNameMetadata, IRouteOrderMetadata, IRoutePatternMetadata {
++        string Microsoft.AspNetCore.Routing.IRouteNameMetadata.RouteName { get; }
++        int? Microsoft.AspNetCore.Routing.IRouteOrderMetadata.RouteOrder { get; }
++        string Microsoft.AspNetCore.Routing.IRoutePatternMetadata.RoutePattern { get; }
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Mvc.TagHelpers.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Mvc.TagHelpers
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.TagHelpers {
++    public class PersistComponentStateTagHelper : TagHelper {
++        public PersistComponentStateTagHelper();
++        public PersistenceMode? PersistenceMode { get; set; }
++        public ViewContext ViewContext { get; set; }
++        public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output);
++    }
++    public enum PersistenceMode {
++        Server = 0,
++        WebAssembly = 1,
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Mvc.md

@@ -0,0 +1,39 @@
+# Microsoft.AspNetCore.Mvc
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc {
+-    public sealed class AcceptVerbsAttribute : Attribute, IActionHttpMethodProvider, IRouteTemplateProvider {
++    public sealed class AcceptVerbsAttribute : Attribute, IActionHttpMethodProvider, IHttpMethodMetadata, IRouteNameMetadata, IRouteOrderMetadata, IRoutePatternMetadata, IRouteTemplateProvider {
++        bool Microsoft.AspNetCore.Routing.IHttpMethodMetadata.AcceptCorsPreflight { get; }
++        IReadOnlyList<string> Microsoft.AspNetCore.Routing.IHttpMethodMetadata.HttpMethods { get; }
+     }
+-    public class FromBodyAttribute : Attribute, IBindingSourceMetadata, IConfigureEmptyBodyBehavior {
++    public class FromBodyAttribute : Attribute, IBindingSourceMetadata, IConfigureEmptyBodyBehavior, IFromBodyMetadata {
++        bool Microsoft.AspNetCore.Http.Metadata.IFromBodyMetadata.AllowEmpty { get; }
+     }
+-    public class FromFormAttribute : Attribute, IBindingSourceMetadata, IModelNameProvider
++    public class FromFormAttribute : Attribute, IBindingSourceMetadata, IFromFormMetadata, IModelNameProvider
+-    public class FromHeaderAttribute : Attribute, IBindingSourceMetadata, IModelNameProvider
++    public class FromHeaderAttribute : Attribute, IBindingSourceMetadata, IFromHeaderMetadata, IModelNameProvider
+-    public class FromQueryAttribute : Attribute, IBindingSourceMetadata, IModelNameProvider
++    public class FromQueryAttribute : Attribute, IBindingSourceMetadata, IFromQueryMetadata, IModelNameProvider
+-    public class FromRouteAttribute : Attribute, IBindingSourceMetadata, IModelNameProvider
++    public class FromRouteAttribute : Attribute, IBindingSourceMetadata, IFromRouteMetadata, IModelNameProvider
+-    public class FromServicesAttribute : Attribute, IBindingSourceMetadata
++    public class FromServicesAttribute : Attribute, IBindingSourceMetadata, IFromServiceMetadata
+     public class JsonOptions {
++        public bool AllowInputFormatterExceptionMessages { get; set; }
+     }
+-    public class JsonResult : ActionResult, IActionResult, IStatusCodeActionResult {
++    public class JsonResult : ActionResult, IActionResult, IResult, IStatusCodeActionResult {
++        Task Microsoft.AspNetCore.Http.IResult.ExecuteAsync(HttpContext httpContext);
+     }
+-    public class RouteAttribute : Attribute, IRouteTemplateProvider
++    public class RouteAttribute : Attribute, IRouteNameMetadata, IRouteOrderMetadata, IRoutePatternMetadata, IRouteTemplateProvider
+-    public class StatusCodeResult : ActionResult, IActionResult, IClientErrorActionResult, IStatusCodeActionResult {
++    public class StatusCodeResult : ActionResult, IActionResult, IClientErrorActionResult, IResult, IStatusCodeActionResult {
++        Task Microsoft.AspNetCore.Http.IResult.ExecuteAsync(HttpContext httpContext);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.AspNetCore.Routing.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Routing
+
+``` diff
+ namespace Microsoft.AspNetCore.Routing {
++    public interface IRouteOrderMetadata {
++        int? RouteOrder { get; }
++    }
++    public interface IRoutePatternMetadata {
++        string RoutePattern { get; }
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_Microsoft.Extensions.DependencyInjection.md

@@ -0,0 +1,10 @@
+# Microsoft.Extensions.DependencyInjection
+
+``` diff
+ namespace Microsoft.Extensions.DependencyInjection {
++    public static class OptionsBuilderExtensions {
++        public static OptionsBuilder<TOptions> ValidateOnStart<TOptions>(this OptionsBuilder<TOptions> optionsBuilder) where TOptions : class;
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/Asp.Net/6.0-preview2_System.Security.AccessControl.md

@@ -0,0 +1,13 @@
+# System.Security.AccessControl
+
+``` diff
+ namespace System.Security.AccessControl {
+-    public class AccessRule<T> : AccessRule where T : struct, ValueType
++    public class AccessRule<T> : AccessRule where T : struct
+-    public class AuditRule<T> : AuditRule where T : struct, ValueType
++    public class AuditRule<T> : AuditRule where T : struct
+-    public abstract class ObjectSecurity<T> : NativeObjectSecurity where T : struct, ValueType
++    public abstract class ObjectSecurity<T> : NativeObjectSecurity where T : struct
+ }
+```
+

release-notes/6.0/preview/api-diff/preview2/README.md

@@ -0,0 +1,6 @@
+# .NET 6.0 Preview 1 API Changes
+
+The following API changes were made in .NET 6.0 Preview 2:
+
+- [.NET](./.Net/6.0-preview2.md)
+- [ASP.NET](./Asp.Net/6.0-preview2.md)