diff --git a/.openpublishing.redirection.csharp.json b/.openpublishing.redirection.csharp.json index b8ab932227e71..66c242752746e 100644 --- a/.openpublishing.redirection.csharp.json +++ b/.openpublishing.redirection.csharp.json @@ -1328,7 +1328,7 @@ }, { "source_path_from_root": "/docs/csharp/programming-guide/concepts/attributes/index.md", - "redirect_url": "/dotnet/csharp/advanced-concepts/reflection-and-attributes" + "redirect_url": "/dotnet/csharp/advanced-topics/reflection-and-attributes/" }, { "source_path_from_root": "/docs/csharp/programming-guide/concepts/attributes/attributeusage.md", @@ -1340,15 +1340,15 @@ }, { "source_path_from_root": "/docs/csharp/programming-guide/concepts/attributes/creating-custom-attributes.md", - "redirect_url": "/dotnet/csharp/advanced-concepts/reflection-and-attributes/creating-custom-attributes" + "redirect_url": "/dotnet/csharp/advanced-topics/reflection-and-attributes/creating-custom-attributes" }, { "source_path_from_root": "/docs/csharp/programming-guide/concepts/attributes/accessing-attributes-by-using-reflection.md", - "redirect_url": "/dotnet/csharp/advanced-concepts/reflection-and-attributes/accessing-attributes-by-using-reflection" + "redirect_url": "/dotnet/csharp/advanced-topics/reflection-and-attributes/accessing-attributes-by-using-reflection" }, { "source_path_from_root": "/docs/csharp/programming-guide/concepts/attributes/how-to-create-a-c-cpp-union-by-using-attributes.md", - "redirect_url": "/dotnet/csharp/advanced-concepts/reflection-and-attributes/how-to-create-a-c-cpp-union-by-using-attributes" + "redirect_url": "/dotnet/csharp/advanced-topics/reflection-and-attributes/how-to-create-a-c-cpp-union-by-using-attributes" }, { "source_path_from_root": "/docs/csharp/programming-guide/concepts/caller-information.md", diff --git a/docs/azure/includes/dotnet-all.md b/docs/azure/includes/dotnet-all.md index 2bd2ef0060c8b..f3ede936c9a48 100644 --- a/docs/azure/includes/dotnet-all.md +++ b/docs/azure/includes/dotnet-all.md @@ -249,7 +249,7 @@ | Azure.Communication.Administration | NuGet [1.0.0-beta.3](https://www.nuget.org/packages/Azure.Communication.Administration/1.0.0-beta.3) | | | | Azure.Communication.Calling | NuGet [1.0.0-beta.36](https://www.nuget.org/packages/Azure.Communication.Calling/1.0.0-beta.36) | | | | Azure.Communication.CallingServer | NuGet [1.0.0-beta.3](https://www.nuget.org/packages/Azure.Communication.CallingServer/1.0.0-beta.3) | | | -| Azure.Communication.Email | NuGet [1.0.0-beta.3](https://www.nuget.org/packages/Azure.Communication.Email/1.0.0-beta.3) | | | +| Azure.Communication.Email | NuGet [1.0.0-beta.4](https://www.nuget.org/packages/Azure.Communication.Email/1.0.0-beta.4) | | | | Azure.Core.Expressions.DataFactory | NuGet [1.0.0-beta.1](https://www.nuget.org/packages/Azure.Core.Expressions.DataFactory/1.0.0-beta.1) | | | | Azure.Quantum.Jobs | NuGet [1.0.0-beta.3](https://www.nuget.org/packages/Azure.Quantum.Jobs/1.0.0-beta.3) | | | | Azure.Storage.DataMovement.Blobs | NuGet [12.0.0-beta.1](https://www.nuget.org/packages/Azure.Storage.DataMovement.Blobs/12.0.0-beta.1) | | | @@ -508,7 +508,7 @@ | Extensions - Caching Cosmos | NuGet [1.4.0](https://www.nuget.org/packages/Microsoft.Extensions.Caching.Cosmos/1.4.0) | | GitHub [1.4.0](https://github.com/Azure/Microsoft.Extensions.Caching.Cosmos/tree/v1.0.0-preview4) | | Functions extension for Application Insights | NuGet [1.0.0-preview4](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.ApplicationInsights/1.0.0-preview4) | | | | Functions extension for Authentication Events | NuGet [1.0.0-beta.3](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents/1.0.0-beta.3) | | | -| Functions extension for Azure SQL and SQL Server | NuGet [1.0.122-preview](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.Sql/1.0.122-preview) | | | +| Functions extension for Azure SQL and SQL Server | NuGet [3.0.143-preview](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.Sql/3.0.143-preview) | | | | Functions extension for Durable Task Framework - isolated worker | NuGet [1.0.0](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.DurableTask/1.0.0) | | | | Functions extension for Storage Timers | NuGet [1.0.0-beta.1](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.Timers.Storage/1.0.0-beta.1) | | | | Microsoft.Azure.Cosmos.Templates | NuGet [1.0.0](https://www.nuget.org/packages/Microsoft.Azure.Cosmos.Templates/1.0.0) | | | @@ -528,7 +528,7 @@ | Microsoft.Azure.Functions.Worker.Extensions.SendGrid | NuGet [3.0.3](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.SendGrid/3.0.3) | | | | Microsoft.Azure.Functions.Worker.Extensions.ServiceBus | NuGet [5.7.0](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.ServiceBus/5.7.0) | | | | Microsoft.Azure.Functions.Worker.Extensions.SignalRService | NuGet [1.7.0](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.SignalRService/1.7.0) | | | -| Microsoft.Azure.Functions.Worker.Extensions.Sql | NuGet [1.0.122-preview](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Sql/1.0.122-preview) | | | +| Microsoft.Azure.Functions.Worker.Extensions.Sql | NuGet [3.0.143-preview](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Sql/3.0.143-preview) | | | | Microsoft.Azure.Functions.Worker.Extensions.Storage | NuGet [5.0.1](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Storage/5.0.1)
NuGet [5.1.0-preview1](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Storage/5.1.0-preview1) | | | | Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs | NuGet [5.0.1](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs/5.0.1)
NuGet [5.1.0-preview1](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs/5.1.0-preview1) | | | | Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues | NuGet [5.0.0](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues/5.0.0) | | | diff --git a/docs/breadcrumb/toc.yml b/docs/breadcrumb/toc.yml index 2b9483b7fdcbb..882de221edb10 100644 --- a/docs/breadcrumb/toc.yml +++ b/docs/breadcrumb/toc.yml @@ -288,7 +288,7 @@ items: topicHref: /dotnet/csharp/asynchronous-programming/index - name: Advanced concepts tocHref: /dotnet/csharp/advanced-topics - topicHref: /dotnet/csharp/advanced-topics/index + topicHref: /dotnet/csharp/advanced-topics/reflection-and-attributes/index - name: Tutorials tocHref: /dotnet/csharp/tutorials/ diff --git a/docs/core/compatibility/8.0.md b/docs/core/compatibility/8.0.md index c3394c5ea4191..43c7795345a84 100644 --- a/docs/core/compatibility/8.0.md +++ b/docs/core/compatibility/8.0.md @@ -59,12 +59,13 @@ If you're migrating an app to .NET 8, the breaking changes listed here might aff ## Windows Forms -| Title | Type of change | Introduced | -| ------------------------------------------------------------------------------------------------------ | ------------------- | ---------- | -| [Anchor layout changes](windows-forms/8.0/anchor-layout.md) | Behavioral change | Preview 1 | -| [ExceptionCollection ctor throws ArgumentException](windows-forms/8.0/exceptioncollection.md) | Behavioral change | Preview 1 | -| [Forms scale according to AutoScaleMode](windows-forms/8.0/top-level-window-scaling.md) | Behavioral change | Preview 1 | -| [ImageList.ColorDepth default is Depth32Bit](windows-forms/8.0/imagelist-colordepth.md) | Behavioral change | Preview 1 | -| [TableLayoutStyleCollection throws ArgumentException](windows-forms/8.0/tablelayoutstylecollection.md) | Behavioral change | Preview 1 | -| [Top-level forms scale minimum and maximum size to DPI](windows-forms/8.0/forms-scale-size-to-dpi.md) | Behavioral change | Preview 1 | -| [WFDEV002 obsoletion is now an error](windows-forms/8.0/domainupdownaccessibleobject.md) | Source incompatible | Preview 1 | +| Title | Type of change | Introduced | +| -------------------------------------------------------------------------------------------------------- | ------------------- | ---------- | +| [Anchor layout changes](windows-forms/8.0/anchor-layout.md) | Behavioral change | Preview 1 | +| [DefaultValueAttribute removed from some properties](windows-forms/8.0/defaultvalueattribute-removal.md) | Behavioral change | Preview 2 | +| [ExceptionCollection ctor throws ArgumentException](windows-forms/8.0/exceptioncollection.md) | Behavioral change | Preview 1 | +| [Forms scale according to AutoScaleMode](windows-forms/8.0/top-level-window-scaling.md) | Behavioral change | Preview 1 | +| [ImageList.ColorDepth default is Depth32Bit](windows-forms/8.0/imagelist-colordepth.md) | Behavioral change | Preview 1 | +| [TableLayoutStyleCollection throws ArgumentException](windows-forms/8.0/tablelayoutstylecollection.md) | Behavioral change | Preview 1 | +| [Top-level forms scale minimum and maximum size to DPI](windows-forms/8.0/forms-scale-size-to-dpi.md) | Behavioral change | Preview 1 | +| [WFDEV002 obsoletion is now an error](windows-forms/8.0/domainupdownaccessibleobject.md) | Source incompatible | Preview 1 | diff --git a/docs/core/compatibility/toc.yml b/docs/core/compatibility/toc.yml index 0054301790146..f0c1a3c8c2015 100644 --- a/docs/core/compatibility/toc.yml +++ b/docs/core/compatibility/toc.yml @@ -56,6 +56,8 @@ items: items: - name: Anchor layout changes href: windows-forms/8.0/anchor-layout.md + - name: DefaultValueAttribute removed from some properties + href: windows-forms/8.0/defaultvalueattribute-removal.md - name: ExceptionCollection ctor throws ArgumentException href: windows-forms/8.0/exceptioncollection.md - name: Forms scale according to AutoScaleMode @@ -1422,6 +1424,8 @@ items: items: - name: Anchor layout changes href: windows-forms/8.0/anchor-layout.md + - name: DefaultValueAttribute removed from some properties + href: windows-forms/8.0/defaultvalueattribute-removal.md - name: ExceptionCollection ctor throws ArgumentException href: windows-forms/8.0/exceptioncollection.md - name: Forms scale according to AutoScaleMode diff --git a/docs/core/compatibility/windows-forms/8.0/defaultvalueattribute-removal.md b/docs/core/compatibility/windows-forms/8.0/defaultvalueattribute-removal.md new file mode 100644 index 0000000000000..e3b693ae34200 --- /dev/null +++ b/docs/core/compatibility/windows-forms/8.0/defaultvalueattribute-removal.md @@ -0,0 +1,43 @@ +--- +title: "Breaking change: DefaultValueAttribute removed from some properties" +description: Learn about the breaking change in .NET 8 for Windows Forms where DefaultValueAttribute was removed from properties whose default values must be dynamically calculated. +ms.date: 03/13/2023 +--- +# DefaultValueAttribute removed from some properties + + has been removed from control properties that are dependent on the default font height. + +## Version introduced + +.NET 8 + +## Previous behavior + +The affected properties were decorated with , and default values were hardcoded according to an assumed application-wide font. + +## New behavior + +Starting in .NET 8, the attribute is removed from certain properties. Design-time default values are calculated at startup based on the current font metrics. + +## Change category + +This change is a [*behavioral change*](../../categories.md#behavioral-change). + +## Reason for change + +The attribute is designed to define constant default values used by the Windows Forms designer. In the past, this attribute was used to specify defaults on certain properties that depend on the current font height. A new default font was introduced in .NET Core 3.1, but the attribute values weren't updated accordingly. Moreover, there's now an API to modify application font. Thus, it makes sense to use dynamic default values instead of constant ones. + +The designer provides methods to specify dynamic default values, however, for properties decorated with , it always uses the constant default value instead. The methods for specifying dynamic defaults preserve the design-time functionality provided by the attribute. + +## Recommended action + + is intended for internal use in design-time scenarios. You shouldn't use it in other scenarios. + +## Affected APIs + +The following table lists the affected properties. + +| Property | Change version | +|-|-|-| +| | Preview 2 | +| | Preview 2 | diff --git a/docs/core/extensions/httpclient-http3.md b/docs/core/extensions/httpclient-http3.md index 61a3fbec55474..63b58ec11401c 100644 --- a/docs/core/extensions/httpclient-http3.md +++ b/docs/core/extensions/httpclient-http3.md @@ -8,7 +8,7 @@ ms.date: 7/28/2022 # Use HTTP/3 with HttpClient -[HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html) is the third and recently standardized major version of HTTP. HTTP/3 uses the same semantics as HTTP/1.1 and HTTP/2: the same request methods, status codes, and message fields apply to all versions. The differences are in the underlying transport. Both HTTP/1.1 and HTTP/2 use TCP as their transport. HTTP/3 uses a new transport technology developed alongside HTTP/3 called [QUIC](https://www.rfc-editor.org/rfc/rfc9000.html). +[HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html) is the third and recently standardized major version of HTTP. HTTP/3 uses the same semantics as HTTP/1.1 and HTTP/2: the same request methods, status codes, and message fields apply to all versions. The differences are in the underlying transport. Both HTTP/1.1 and HTTP/2 use TCP as their transport. HTTP/3 uses a transport technology developed alongside HTTP/3 called [QUIC](https://www.rfc-editor.org/rfc/rfc9000.html). HTTP/3 and QUIC have a number of benefits compared to HTTP/1.1 and HTTP/2: @@ -90,5 +90,6 @@ Cloudflare hosts a site for HTTP/3 which can be used to test the client against - - [HTTP/3 support in Kestrel][http3Kestrel] +- [QUIC support in .NET](../../fundamentals/networking/quic/quic-overview.md) [http3Kestrel]: /aspnet/core/fundamentals/servers/kestrel/http3 diff --git a/docs/csharp/language-reference/compiler-messages/cs0592.md b/docs/csharp/language-reference/compiler-messages/cs0592.md index a91b7387e9ddf..34238f23b0392 100644 --- a/docs/csharp/language-reference/compiler-messages/cs0592.md +++ b/docs/csharp/language-reference/compiler-messages/cs0592.md @@ -39,4 +39,4 @@ public class A ## See also -- [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes) +- [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes) diff --git a/docs/csharp/language-reference/operators/member-access-operators.md b/docs/csharp/language-reference/operators/member-access-operators.md index 4d64e5a319a02..fc92500f5d78b 100644 --- a/docs/csharp/language-reference/operators/member-access-operators.md +++ b/docs/csharp/language-reference/operators/member-access-operators.md @@ -94,7 +94,7 @@ For more information about indexers, see [Indexers](../../programming-guide/inde For information about pointer element access, see the [Pointer element access operator []](pointer-related-operators.md#pointer-element-access-operator-) section of the [Pointer related operators](pointer-related-operators.md) article. -You also use square brackets to specify [attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes): +You also use square brackets to specify [attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes): ```csharp [System.Diagnostics.Conditional("DEBUG")] diff --git a/docs/csharp/language-reference/operators/nameof.md b/docs/csharp/language-reference/operators/nameof.md index faf2da6e96e08..ef2331cfafe2a 100644 --- a/docs/csharp/language-reference/operators/nameof.md +++ b/docs/csharp/language-reference/operators/nameof.md @@ -24,7 +24,7 @@ You can use a `nameof` expression to make the argument-checking code more mainta [!code-csharp[nameof and argument check](snippets/shared/NameOfOperator.cs#ExceptionMessage)] -Beginning with C# 11, you can use a `nameof` expression with a method parameter inside an [attribute](/dotnet/csharp/advanced-concepts/reflection-and-attributes) on a method or its parameter. The following code shows how to do that for an attribute on a method, a local function, and the parameter of a lambda expression: +Beginning with C# 11, you can use a `nameof` expression with a method parameter inside an [attribute](/dotnet/csharp/advanced-topics/reflection-and-attributes) on a method or its parameter. The following code shows how to do that for an attribute on a method, a local function, and the parameter of a lambda expression: :::code language="csharp" source="snippets/shared/NameOfOperator.cs" id="SnippetNameOfParameter"::: diff --git a/docs/csharp/misc/cs0182.md b/docs/csharp/misc/cs0182.md index c2a5d210a9ea2..6ad21962308c1 100644 --- a/docs/csharp/misc/cs0182.md +++ b/docs/csharp/misc/cs0182.md @@ -24,7 +24,7 @@ Certain restrictions apply to what kinds of arguments may be used with attribute - [decimal](../language-reference/builtin-types/floating-point-numeric-types.md) -For more information, see [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes). +For more information, see [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes). ## Example diff --git a/docs/csharp/misc/cs0643.md b/docs/csharp/misc/cs0643.md index 9214cac8d6da6..c360f7212d871 100644 --- a/docs/csharp/misc/cs0643.md +++ b/docs/csharp/misc/cs0643.md @@ -12,7 +12,7 @@ ms.assetid: beae30ff-15c2-413f-8f5c-504cdba2e57a 'arg' duplicate named attribute argument - A parameter, `arg`, on a user-defined attribute was specified twice. For more information, see [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes). + A parameter, `arg`, on a user-defined attribute was specified twice. For more information, see [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes). ## Example diff --git a/docs/csharp/misc/cs0655.md b/docs/csharp/misc/cs0655.md index 61ef17396d66b..045c807c265ea 100644 --- a/docs/csharp/misc/cs0655.md +++ b/docs/csharp/misc/cs0655.md @@ -12,7 +12,7 @@ ms.assetid: 8ce340e2-eeeb-476a-8609-ab4bbaf10c44 'parameter' is not a valid named attribute argument because it is not a valid attribute parameter type - See [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes) for a discussion of valid parameter types for an attribute. + See [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes) for a discussion of valid parameter types for an attribute. ## Example diff --git a/docs/csharp/misc/cs0657.md b/docs/csharp/misc/cs0657.md index 884f7b680f49c..5e8fa8db48d07 100644 --- a/docs/csharp/misc/cs0657.md +++ b/docs/csharp/misc/cs0657.md @@ -12,7 +12,7 @@ ms.assetid: d12d2efc-f44e-40e6-b825-5a66ead0c08e 'attribute modifier' is not a valid attribute location for this declaration. Valid attribute locations for this declaration are 'locations'. All attributes in this block will be ignored. - The compiler found an attribute modifier in an invalid location. See [Attribute Targets](/dotnet/csharp/advanced-concepts/reflection-and-attributes#attribute-targets) for more information. + The compiler found an attribute modifier in an invalid location. See [Attribute Targets](/dotnet/csharp/advanced-topics/reflection-and-attributes#attribute-targets) for more information. The following sample generates CS0657: diff --git a/docs/csharp/misc/cs0658.md b/docs/csharp/misc/cs0658.md index 8992bfcef866b..ef34d72c2451c 100644 --- a/docs/csharp/misc/cs0658.md +++ b/docs/csharp/misc/cs0658.md @@ -12,7 +12,7 @@ ms.assetid: 0309074c-741a-492c-9370-73b4bbfd3c1a 'attribute modifier' is not a recognized attribute location. All attributes in this block will be ignored. - An invalid attribute modifier was specified. See [Attribute Targets](/dotnet/csharp/advanced-concepts/reflection-and-attributes#attribute-targets) for more information. + An invalid attribute modifier was specified. See [Attribute Targets](/dotnet/csharp/advanced-topics/reflection-and-attributes#attribute-targets) for more information. The following sample generates CS0658: diff --git a/docs/csharp/misc/cs1730.md b/docs/csharp/misc/cs1730.md index 19935192966cb..d206795dcf0a7 100644 --- a/docs/csharp/misc/cs1730.md +++ b/docs/csharp/misc/cs1730.md @@ -32,4 +32,4 @@ class Test ## See also -- [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes) +- [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes) diff --git a/docs/csharp/programming-guide/concepts/index.md b/docs/csharp/programming-guide/concepts/index.md index 689677d92fbda..28bcf71aab39b 100644 --- a/docs/csharp/programming-guide/concepts/index.md +++ b/docs/csharp/programming-guide/concepts/index.md @@ -12,7 +12,7 @@ This section explains programming concepts in the C# language. |Title|Description| |-----------|-----------------| |[Assemblies in .NET](../../../standard/assembly/index.md)|Describes how to create and use assemblies.| -|[Attributes (C#)](/dotnet/csharp/advanced-concepts/reflection-and-attributes)|Discusses how to provide additional information about programming elements such as types, fields, methods, and properties by using attributes.| +|[Attributes (C#)](/dotnet/csharp/advanced-topics/reflection-and-attributes)|Discusses how to provide additional information about programming elements such as types, fields, methods, and properties by using attributes.| |[Collections (C#)](./collections.md)|Describes some of the types of collections provided by .NET. Demonstrates how to use simple collections and collections of key/value pairs.| |[Covariance and Contravariance (C#)](./covariance-contravariance/index.md)|Shows how to enable implicit conversion of generic type parameters in interfaces and delegates.| |[Expression Trees (C#)](../../advanced-topics/expression-trees/index.md)|Explains how you can use expression trees to enable dynamic modification of executable code.| diff --git a/docs/csharp/programming-guide/index.md b/docs/csharp/programming-guide/index.md index 62d464d562bb4..07bfe7cf8b7a7 100644 --- a/docs/csharp/programming-guide/index.md +++ b/docs/csharp/programming-guide/index.md @@ -71,7 +71,7 @@ This section provides detailed information on key C# language features and featu [Assemblies in .NET](../../standard/assembly/index.md) - [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes) + [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes) [Collections](./concepts/collections.md) diff --git a/docs/csharp/tour-of-csharp/features.md b/docs/csharp/tour-of-csharp/features.md index 18c0ae637688c..3048c067398c5 100644 --- a/docs/csharp/tour-of-csharp/features.md +++ b/docs/csharp/tour-of-csharp/features.md @@ -94,7 +94,7 @@ This small sample shows the major features for asynchronous programming: ## Attributes -Types, members, and other entities in a C# program support modifiers that control certain aspects of their behavior. For example, the accessibility of a method is controlled using the `public`, `protected`, `internal`, and `private` modifiers. C# generalizes this capability such that user-defined types of declarative information can be attached to program entities and retrieved at run-time. Programs specify this declarative information by defining and using [***attributes***](/dotnet/csharp/advanced-concepts/reflection-and-attributes). +Types, members, and other entities in a C# program support modifiers that control certain aspects of their behavior. For example, the accessibility of a method is controlled using the `public`, `protected`, `internal`, and `private` modifiers. C# generalizes this capability such that user-defined types of declarative information can be attached to program entities and retrieved at run-time. Programs specify this declarative information by defining and using [***attributes***](/dotnet/csharp/advanced-topics/reflection-and-attributes). The following example declares a `HelpAttribute` attribute that can be placed on program entities to provide links to their associated documentation. diff --git a/docs/csharp/whats-new/csharp-11.md b/docs/csharp/whats-new/csharp-11.md index 17a9190226422..aad4e77bb9626 100644 --- a/docs/csharp/whats-new/csharp-11.md +++ b/docs/csharp/whats-new/csharp-11.md @@ -166,7 +166,7 @@ You've been able to test if a `string` had a specific constant value using patte ## Extended nameof scope -Type parameter names and parameter names are now in scope when used in a `nameof` expression in an [attribute declaration](/dotnet/csharp/advanced-concepts/reflection-and-attributes#using-attributes) on that method. This feature means you can use the `nameof` operator to specify the name of a method parameter in an attribute on the method or parameter declaration. This feature is most often useful to add attributes for [nullable analysis](../language-reference/attributes/nullable-analysis.md). +Type parameter names and parameter names are now in scope when used in a `nameof` expression in an [attribute declaration](/dotnet/csharp/advanced-topics/reflection-and-attributes#using-attributes) on that method. This feature means you can use the `nameof` operator to specify the name of a method parameter in an attribute on the method or parameter declaration. This feature is most often useful to add attributes for [nullable analysis](../language-reference/attributes/nullable-analysis.md). ## UTF-8 string literals diff --git a/docs/csharp/whats-new/csharp-version-history.md b/docs/csharp/whats-new/csharp-version-history.md index 34c9630034dd5..bbfd897e9ac5d 100644 --- a/docs/csharp/whats-new/csharp-version-history.md +++ b/docs/csharp/whats-new/csharp-version-history.md @@ -375,6 +375,6 @@ The major features of C# 1.0 included: - [Delegates](../delegates-overview.md) - [Operators and expressions](../language-reference/operators/index.md) - [Statements](../programming-guide/statements-expressions-operators/statements.md) -- [Attributes](/dotnet/csharp/advanced-concepts/reflection-and-attributes) +- [Attributes](/dotnet/csharp/advanced-topics/reflection-and-attributes) _Article_ [_originally published on the NDepend blog_](https://blog.ndepend.com/c-versions-look-language-history/)_, courtesy of Erik Dietrich and Patrick Smacchia._ diff --git a/docs/framework/debug-trace-profile/index.md b/docs/framework/debug-trace-profile/index.md index 4a297cabab167..ffb77c4711a62 100644 --- a/docs/framework/debug-trace-profile/index.md +++ b/docs/framework/debug-trace-profile/index.md @@ -15,36 +15,39 @@ helpviewer_keywords: - "application development [.NET Framework], profiling" ms.assetid: 4a04863e-2475-46f4-bc3f-3c11510c2a4b --- -# Debugging, Tracing, and Profiling +# Debugging, tracing, and profiling To debug a .NET Framework application, the compiler and runtime environment must be configured to enable a debugger to attach to the application and to produce both symbols and line maps, if possible, for the application and its corresponding Microsoft intermediate language (MSIL). After a managed application has been debugged, it can be profiled to boost performance. Profiling evaluates and describes the lines of source code that generate the most frequently executed code, and how much time it takes to execute them. .NET Framework applications are easily debugged by using Visual Studio, which handles many of the configuration details. If Visual Studio is not installed, you can examine and improve the performance of .NET Framework applications by using the debugging classes in the .NET Framework namespace. This namespace includes the , , and classes for tracing execution flow, and the , , and classes for profiling code. -## In This Section +## In this section - [Enabling JIT-Attach Debugging](enabling-jit-attach-debugging.md) - Shows how to configure the registry to JIT-attach a debug engine to a .NET Framework application. +[Enabling JIT-Attach Debugging](enabling-jit-attach-debugging.md)\ +Shows how to configure the registry to JIT-attach a debug engine to a .NET Framework application. - [Making an Image Easier to Debug](making-an-image-easier-to-debug.md) - Shows how to turn JIT tracking on and optimization off to make an assembly easier to debug. +[Making an Image Easier to Debug](making-an-image-easier-to-debug.md)\ +Shows how to turn JIT tracking on and optimization off to make an assembly easier to debug. - [Tracing and Instrumenting Applications](tracing-and-instrumenting-applications.md) - Describes how to monitor the execution of your application while it is running, and how to instrument it to display how well it is performing or whether something has gone wrong. +[Tracing and Instrumenting Applications](tracing-and-instrumenting-applications.md)\ +Describes how to monitor the execution of your application while it is running, and how to instrument it to display how well it is performing or whether something has gone wrong. - [Diagnosing Errors with Managed Debugging Assistants](diagnosing-errors-with-managed-debugging-assistants.md) - Describes managed debugging assistants (MDAs), which are debugging aids that work in conjunction with the common language runtime (CLR) to provide information on runtime state. +[Diagnosing Errors with Managed Debugging Assistants](diagnosing-errors-with-managed-debugging-assistants.md)\ +Describes managed debugging assistants (MDAs), which are debugging aids that work in conjunction with the common language runtime (CLR) to provide information on runtime state. - [Enhancing Debugging with the Debugger Display Attributes](enhancing-debugging-with-the-debugger-display-attributes.md) - Describes how the developer of a type can specify what that type will look like when it is displayed in a debugger. - - [Performance Counters](performance-counters.md) - Describes the counters that you can use to track the performance of an application. +[Enhancing Debugging with the Debugger Display Attributes](enhancing-debugging-with-the-debugger-display-attributes.md)\ +Describes how the developer of a type can specify what that type will look like when it is displayed in a debugger. + +[Runtime Profiling](runtime-profiling.md)\ +Learn how to gather information about application performance. + +[Performance Counters](performance-counters.md)\ +Describes the counters that you can use to track the performance of an application. -## Related Sections +## Related sections - [Debug ASP.NET or ASP.NET Core apps in Visual Studio](/visualstudio/debugger/how-to-enable-debugging-for-aspnet-applications) - Provides prerequisites and instructions for how to debug an ASP.NET application during development or after deployment. +[Debug ASP.NET or ASP.NET Core apps in Visual Studio](/visualstudio/debugger/how-to-enable-debugging-for-aspnet-applications) +Provides prerequisites and instructions for how to debug an ASP.NET application during development or after deployment. - [Development Guide](../development-guide.md) - Provides a guide to all key technology areas and tasks for application development, including creating, configuring, debugging, securing, and deploying your application, and information about dynamic programming, interoperability, extensibility, memory management, and threading. +[Development Guide](../development-guide.md) +Provides a guide to all key technology areas and tasks for application development, including creating, configuring, debugging, securing, and deploying your application, and information about dynamic programming, interoperability, extensibility, memory management, and threading. diff --git a/docs/framework/migration-guide/reference-assemblies.md b/docs/framework/migration-guide/reference-assemblies.md index c784f85f08105..64689ec37d7a0 100644 --- a/docs/framework/migration-guide/reference-assemblies.md +++ b/docs/framework/migration-guide/reference-assemblies.md @@ -51,3 +51,6 @@ After adding the **Microsoft.NETFramework.ReferenceAssemblies** NuGet package to 01. Run _msbuild /t:restore_. - If your project is an SDK-style project, you don't need to do anything. The NuGet restore action is automatically run when the project is built. + +> [!IMPORTANT] +> Using reference assemblies makes it possible to build projects that target unsupported versions of .NET Framework from the command line. However, you still can't load these projects in newer versions of Visual Studio. To continue building these apps in Visual Studio, the only workaround is to use [an older version of Visual Studio](https://visualstudio.microsoft.com/vs/older-downloads/). diff --git a/docs/fundamentals/networking/quic/quic-overview.md b/docs/fundamentals/networking/quic/quic-overview.md new file mode 100644 index 0000000000000..937c716f8d61f --- /dev/null +++ b/docs/fundamentals/networking/quic/quic-overview.md @@ -0,0 +1,321 @@ +--- +title: QUIC support in .NET +description: Learn about the support for QUIC protocol in .NET. +ms.date: 03/15/2023 +helpviewer_keywords: + - "protocols, QUIC" + - "sending data, QUIC" + - "QUIC" + - "receiving data, QUIC" + - "application protocols, QUIC" + - "Internet, QUIC" +--- +# QUIC protocol + +QUIC is a network transport layer protocol standardized in [RFC 9000](https://www.rfc-editor.org/rfc/rfc9000). It uses UDP as an underlying protocol and it's inherently secure as it mandates TLS 1.3 usage. For more information, see [RFC 9001](https://www.rfc-editor.org/rfc/rfc9001). Another interesting difference from well-known transport protocols such as TCP and UDP is that it has stream multiplexing built-in on the transport layer. This allows having multiple, concurrent, independent data streams that don't affect each other. + +QUIC itself doesn't define any semantics for the exchanged data as it's a transport protocol. It's rather used in application layer protocols, for example in [HTTP/3](https://www.rfc-editor.org/rfc/rfc9114) or in [SMB over QUIC](/windows-server/storage/file-server/smb-over-quic). It can also be used for any custom-defined protocol. + +The protocol offers many advantages over TCP with TLS, here are a few: + +- Faster connection establishment as it doesn't require as many round trips as TCP with TLS on top. +- Avoidance of head-of-line blocking problem where one lost packet doesn't block data of all the other streams. + +On the other hand, there are potential disadvantages to consider when using QUIC. As a newer protocol, its adoption is still growing and limited. Apart from that, QUIC traffic may be even blocked by some networking components. + +## QUIC in .NET + +The QUIC implementation was introduced in .NET 5 as the `System.Net.Quic` library. However, up until .NET 7.0 the library was strictly internal and served only as an implementation of HTTP/3. With .NET 7, the library was made public thus exposing its APIs. + +> [!NOTE] +> In .NET 7.0, the APIs are published as [preview features](https://github.com/dotnet/designs/blob/main/accepted/2021/preview-features/preview-features.md). + +From the implementation perspective, `System.Net.Quic` depends on [MsQuic](https://github.com/microsoft/msquic), the native implementation of QUIC protocol. As a result, `System.Net.Quic` platform support and dependencies are inherited from `MsQuic` and documented in [HTTP/3 Platform dependencies](../../../core/extensions/httpclient-http3.md#platform-dependencies). In short, the `MsQuic` library is shipped as part of .NET for Windows. But for Linux, `libmsquic` must be manually installed via an appropriate package manager. For the other platforms, it's still possible to build `MsQuic` manually, whether against SChannel or OpenSSL, and use it with `System.Net.Quic`. However, these scenarios are not part of our testing matrix and unforeseen problems might occur. + +## API overview + + brings three major classes that enable the usage of QUIC protocol: + +- - server side class for accepting incoming connections. +- - QUIC connection, corresponding to [RFC 9000 Section 5](https://www.rfc-editor.org/rfc/rfc9000#section-5). +- - QUIC stream, corresponding to [RFC 9000 Section 2](https://www.rfc-editor.org/rfc/rfc9000#section-2). + +But before using these classes, your code should check whether QUIC is currently supported, as `libmsquic` might be missing, or TLS 1.3 might not be supported. For that, both `QuicListener` and `QuicConnection` expose a static property `IsSupported`: + +```csharp +if (QuicListener.IsSupported) +{ + // Use QuicListener +} +else +{ + // Fallback/Error +} + +if (QuicConnection.IsSupported) +{ + // Use QuicConnection +} +else +{ + // Fallback/Error +} +``` + +These properties will report the same value, but that might change in the future. It's recommended to check for server-scenarios and for the client ones. + +### `QuicListener` + + represents a server side class that accepts incoming connections from the clients. The listener is constructed and started with a static method . The method accepts an instance of class with all the settings necessary to start the listener and accept incoming connections. After that, listener is ready to hand out connections via . Connections returned by this method are always fully connected, meaning that the TLS handshake is finished and the connection is ready to be used. Finally, to stop listening and release all resources, must be called. + +Consider the following `QuicListener` example code: + +```csharp +using System.Net.Quic; + +// First, check if QUIC is supported. +if (!QuicListener.IsSupported) +{ + Console.WriteLine("QUIC is not supported, check for presence of libmsquic and support of TLS 1.3."); + return; +} + +// Share configuration for each incoming connection. +// This represents the minimal configuration necessary. +var serverConnectionOptions = new QuicServerConnectionOptions +{ + // Used to abort stream if it's not properly closed by the user. + // See https://www.rfc-editor.org/rfc/rfc9000#section-20.2 + DefaultStreamErrorCode = 0x0A, // Protocol-dependent error code. + + // Used to close the connection if it's not done by the user. + // See https://www.rfc-editor.org/rfc/rfc9000#section-20.2 + DefaultCloseErrorCode = 0x0B, // Protocol-dependent error code. + + // Same options as for server side SslStream. + ServerAuthenticationOptions = new SslServerAuthenticationOptions + { + // List of supported application protocols, must be the same or subset of QuicListenerOptions.ApplicationProtocols. + ApplicationProtocols = new List() { "protocol-name" }, + // Server certificate, it can also be provided via ServerCertificateContext or ServerCertificateSelectionCallback. + ServerCertificate = serverCertificate + } +}; + +// Initialize, configure the listener and start listening. +var listener = await QuicListener.ListenAsync(new QuicListenerOptions +{ + // Listening endpoint, port 0 means any port. + ListenEndPoint = new IPEndPoint(IPAddress.Loopback, 0), + // List of all supported application protocols by this listener. + ApplicationProtocols = new List() { "protocol-name" }, + // Callback to provide options for the incoming connections, it gets called once per each connection. + ConnectionOptionsCallback = (_, _, _) => ValueTask.FromResult(serverConnectionOptions) +}); + +// Accept and process the connections. +while (isRunning) +{ + // Accept will propagate any exceptions that occurred during the connection establishment, + // including exceptions thrown from ConnectionOptionsCallback, caused by invalid QuicServerConnectionOptions or TLS handshake failures. + var connection = await listener.AcceptConnectionAsync(); + + // Process the connection... +} + +// When finished, dispose the listener. +await listener.DisposeAsync(); +``` + +For more information about how the `QuicListener` was designed, see the [API proposal](https://github.com/dotnet/runtime/issues/67560). + +### `QuicConnection` + + is a class used for both server and client side QUIC connections. Server side connections are created internally by the listener and handed out via . Client side connections must be opened and connected to the server. As with the listener, there's a static method that instantiates and connects the connection. It accepts an instance of , an analogous class to . After that, the work with the connection doesn't differ between client and server. It can open outgoing streams and accept incoming ones. It also provides properties with information about the connection, like , , or . + +When the work with the connection is done, it needs to be closed and disposed. QUIC protocol mandates using an application layer code for immediate closure, see [RFC 9000 Section 10.2](https://www.rfc-editor.org/rfc/rfc9000#section-10.2). For that, with application layer code can be called or if not, will use the code provided in . Either way, must be called at the end of the work with the connection to fully release all the associated resources. + +Consider the following `QuicConnection` example code: + +```csharp +using System.Net.Quic; + +// First, check if QUIC is supported. +if (!QuicConnection.IsSupported) +{ + Console.WriteLine("QUIC is not supported, check for presence of libmsquic and support of TLS 1.3."); + return; +} + +// This represents the minimal configuration necessary to open a connection. +var clientConnectionOptions = new QuicClientConnectionOptions +{ + // End point of the server to connect to. + RemoteEndPoint = listener.LocalEndPoint, + + // Used to abort stream if it's not properly closed by the user. + // See https://www.rfc-editor.org/rfc/rfc9000#section-20.2 + DefaultStreamErrorCode = 0x0A, // Protocol-dependent error code. + + // Used to close the connection if it's not done by the user. + // See https://www.rfc-editor.org/rfc/rfc9000#section-20.2 + DefaultCloseErrorCode = 0x0B, // Protocol-dependent error code. + + // Optionally set limits for inbound streams. + MaxInboundUnidirectionalStreams = 10, + MaxInboundBidirectionalStreams = 100, + + // Same options as for client side SslStream. + ClientAuthenticationOptions = new SslClientAuthenticationOptions + { + // List of supported application protocols. + ApplicationProtocols = new List() { "protocol-name" } + } +}; + +// Initialize, configure and connect to the server. +var connection = await QuicConnection.ConnectAsync(clientConnectionOptions); + +Console.WriteLine($"Connected {connection.LocalEndPoint} --> {connection.RemoteEndPoint}"); + +// Open a bidirectional (can both read and write) outbound stream. +var outgoingStream = await connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional); + +// Work with the outgoing stream ... + +// To accept any stream on a client connection, at least one of MaxInboundBidirectionalStreams or MaxInboundUnidirectionalStreams of QuicConnectionOptions must be set. +while (isRunning) +{ + // Accept an inbound stream. + var incomingStream = await connection.AcceptInboundStreamAsync(); + + // Work with the incoming stream ... +} + +// Close the connection with the custom code. +await connection.CloseAsync(0x0C); + +// Dispose the connection. +await connection.DisposeAsync(); +``` + +or more information about how the `QuicConnection` was designed, see the [API proposal](https://github.com/dotnet/runtime/issues/68902). + +### `QuicStream` + + is the actual type that is used to send and receive data in QUIC protocol. It derives from ordinary and can be used as such, but it also offers several features that are specific to QUIC protocol. Firstly, a QUIC stream can either be unidirectional or bidirectional, see [RFC 9000 Section 2.1](https://www.rfc-editor.org/rfc/rfc9000#section-2.1). A bidirectional stream is able to send and receive data on both sides, whereas unidirectional stream can only write from the initiating side and read on the accepting one. Each peer can limit how many concurrent stream of each type is willing to accept, see and . + +Another particularity of QUIC stream is ability to explicitly close the writing side in the middle of work with the stream, see or overload with `completeWrites` argument. Closing of the writing side lets the peer know that no more data will arrive, yet the peer still can continue sending (in case of a bidirectional stream). This is useful in scenarios like HTTP request/response exchange when the client sends the request and closes the writing side to let the server know that this is the end of the request content. Server is still able to send the response after that, but knows that no more data will arrive from the client. And for erroneous cases, either writing or reading side of the stream can be aborted, see . The behavior of the individual methods for each stream type is summarized in the following table (note that both client and server can open and accept streams): + +| Method | Peer opening stream | Peer accepting stream | +| --- | --- | --- | +| `CanRead` | _bidirectional_: `true`
_unidirectional_: `false` | `true` | +| `CanWrite` | `true` | _bidirectional_: `true`
_unidirectional_: `false` | +| `ReadAsync` | _bidirectional_: reads data
_unidirectional_: `InvalidOperationException` | reads data | +| `WriteAsync` | sends data => peer read returns the data | _bidirectional_: sends data => peer read returns the data
_unidirectional_: `InvalidOperationException` | +| `CompleteWrites` | closes writing side => peer read returns 0 | _bidirectional_: closes writing side => peer read returns 0
_unidirectional_: no-op | +| `Abort(QuicAbortDirection.Read)` | _bidirectional_: [STOP_SENDING](https://www.rfc-editor.org/rfc/rfc9000#section-19.5) => peer write throws `QuicException(QuicError.OperationAborted)`
_unidirectional_: no-op | [STOP_SENDING](https://www.rfc-editor.org/rfc/rfc9000#section-19.5) => peer write throws `QuicException(QuicError.OperationAborted)`| +| `Abort(QuicAbortDirection.Write)` | [RESET_STREAM](https://www.rfc-editor.org/rfc/rfc9000#section-19.4) => peer read throws `QuicException(QuicError.OperationAborted)` | _bidirectional_: [RESET_STREAM](https://www.rfc-editor.org/rfc/rfc9000#section-19.4) => peer read throws `QuicException(QuicError.OperationAborted)`
_unidirectional_: no-op | + +On top of these methods, `QuicStream` offers two specialized properties to get notified whenever either reading or writing side of the stream has been closed: and . Both return a `Task` that completes with its corresponding side getting closed, whether it be success or abort, in which case the `Task` will contain appropriate exception. These properties are useful when the user code needs to know about stream side getting closed without issuing call to `ReadAsync` or `WriteAsync`. + +Finally, when the work with the stream is done, it needs to be disposed with . The dispose will make sure that both reading and/or writing side - depending on the stream type - is closed. If stream hasn't been properly read till the end, dispose will issue an equivalent of `Abort(QuicAbortDirection.Read)`. However, if stream writing side hasn't been closed, it will be gracefully closed as it would be with `CompleteWrites`. The reason for this difference is to make sure that scenarios working with an ordinary `Stream` behave as expected and lead to a successful path. Consider the following example: + +```csharp +// Work done with all different types of streams. +async Task WorkWithStreamAsync(Stream stream) +{ + // This will dispose the stream at the end of the scope. + await using (stream) + { + // Simple echo, read data and send them back. + byte[] buffer = new byte[1024]; + int count = 0; + // The loop stops when read returns 0 bytes as is common for all streams. + while ((count = await stream.ReadAsync(buffer)) > 0) + { + await stream.WriteAsync(buffer.AsMemory(0, count)); + } + } +} + +// Open a QuicStream and pass to the common method. +var quicStream = await connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional); +await WorkWithStreamAsync(quicStream); +``` + +The sample usage of `QuicStream` in client scenario: + +```csharp +// Consider connection from the connection example, open a bidirectional stream. +await using var stream = await connection.OpenStreamAsync(QuicStreamType.Bidirectional, cancellationToken); + +// Send some data. +await stream.WriteAsync(data, cancellationToken); +await stream.WriteAsync(data, cancellationToken); + +// End the writing-side together with the last data. +await stream.WriteAsync(data, endStream: true, cancellationToken); +// Or separately. +stream.CompleteWrites(); + +// Read data until the end of stream. +while (await stream.ReadAsync(buffer, cancellationToken) > 0) +{ + // Handle buffer data... +} + +// DisposeAsync called by await using at the top. +``` + +And the sample usage of `QuicStream` in server scenario: + +```csharp +// Consider connection from the connection example, accept a stream. +await using var stream = await connection.AcceptStreamAsync(cancellationToken); + +if (stream.Type != QuicStreamType.Bidirectional) +{ + Console.WriteLine($"Expected bidirectional stream, got {stream.Type}"); + return; +} + +// Read the data. +while (stream.ReadAsync(buffer, cancellationToken) > 0) +{ + // Handle buffer data... + + // Client completed the writes, the loop might be exited now without another ReadAsync. + if (stream.ReadsCompleted.IsCompleted) + { + break; + } +} + +// Listen for Abort(QuicAbortDirection.Read) from the client. +var writesClosedTask = WritesClosedAsync(stream); +async ValueTask WritesClosedAsync(QuicStream stream) +{ + try + { + await stream.WritesClosed; + } + catch (Exception ex) + { + // Handle peer aborting our writing side ... + } +} + +// DisposeAsync called by await using at the top. +``` + +For more information about how the `QuicsStream` was designed, see the [API proposal](https://github.com/dotnet/runtime/issues/69675). + +## See also + +- [Networking in .NET](../overview.md) +- [HTTP/3 with HttpClient](../../../core/extensions/httpclient-http3.md) +- +- +- +- diff --git a/docs/fundamentals/toc.yml b/docs/fundamentals/toc.yml index b4fd66a9d981c..0fcb2aab0ccb5 100644 --- a/docs/fundamentals/toc.yml +++ b/docs/fundamentals/toc.yml @@ -849,6 +849,10 @@ items: href: ../core/extensions/sslstream-troubleshooting.md - name: Migrate from .NET Framework to .NET href: ../core/extensions/sslstream-migration-from-framework.md + - name: QUIC + items: + - name: QUIC support + href: networking/quic/quic-overview.md - name: File globbing href: ../core/extensions/file-globbing.md - name: Primitives library diff --git a/docs/navigate/migration-guide/toc.yml b/docs/navigate/migration-guide/toc.yml index 63de47c9dd6e7..7b0d201ca273b 100644 --- a/docs/navigate/migration-guide/toc.yml +++ b/docs/navigate/migration-guide/toc.yml @@ -9,7 +9,7 @@ items: items: - name: Versioning info for .NET SDK, MSBuild, and Visual Studio href: ../../core/porting/versioning-sdk-msbuild-vs.md - - name: Choose between .NET 5 and .NET Framework for server apps + - name: Choose between .NET and .NET Framework for server apps href: ../../standard/choosing-core-framework-server.md - name: .NET Upgrade Assistant tool items: diff --git a/docs/standard/attributes/applying-attributes.md b/docs/standard/attributes/applying-attributes.md index 73f66ec5fbeeb..be26015075566 100644 --- a/docs/standard/attributes/applying-attributes.md +++ b/docs/standard/attributes/applying-attributes.md @@ -52,5 +52,5 @@ Use the following process to apply an attribute to an element of your code. - [Attributes](index.md) - [Retrieving Information Stored in Attributes](retrieving-information-stored-in-attributes.md) - [Concepts](/cpp/windows/attributed-programming-concepts) -- [Attributes (C#)](/dotnet/csharp/advanced-concepts/reflection-and-attributes) +- [Attributes (C#)](/dotnet/csharp/advanced-topics/reflection-and-attributes) - [Attributes overview (Visual Basic)](../../visual-basic/programming-guide/concepts/attributes/index.md) diff --git a/docs/standard/serialization/system-text-json/snippets/system-text-json-how-to/csharp/SerializeCustomEncoding.cs b/docs/standard/serialization/system-text-json/snippets/system-text-json-how-to/csharp/SerializeCustomEncoding.cs index 1019a2e30474e..8658d2115aa6d 100644 --- a/docs/standard/serialization/system-text-json/snippets/system-text-json-how-to/csharp/SerializeCustomEncoding.cs +++ b/docs/standard/serialization/system-text-json/snippets/system-text-json-how-to/csharp/SerializeCustomEncoding.cs @@ -26,12 +26,12 @@ public static void Run() Console.WriteLine("Serialize language sets unescaped"); // - options = new JsonSerializerOptions + var options1 = new JsonSerializerOptions { Encoder = JavaScriptEncoder.Create(UnicodeRanges.BasicLatin, UnicodeRanges.Cyrillic), WriteIndented = true }; - jsonString = JsonSerializer.Serialize(weatherForecast, options); + jsonString = JsonSerializer.Serialize(weatherForecast, options1); // Console.WriteLine(jsonString); Console.WriteLine(); @@ -41,24 +41,24 @@ public static void Run() var encoderSettings = new TextEncoderSettings(); encoderSettings.AllowCharacters('\u0436', '\u0430'); encoderSettings.AllowRange(UnicodeRanges.BasicLatin); - options = new JsonSerializerOptions + var options2 = new JsonSerializerOptions { Encoder = JavaScriptEncoder.Create(encoderSettings), WriteIndented = true }; - jsonString = JsonSerializer.Serialize(weatherForecast, options); + jsonString = JsonSerializer.Serialize(weatherForecast, options2); // Console.WriteLine(jsonString); Console.WriteLine(); Console.WriteLine("Serialize using unsafe relaxed encoder"); // - options = new JsonSerializerOptions + var options3 = new JsonSerializerOptions { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping, WriteIndented = true }; - jsonString = JsonSerializer.Serialize(weatherForecast, options); + jsonString = JsonSerializer.Serialize(weatherForecast, options3); // Console.WriteLine(jsonString); }