From 0745983093568027ff931672d9db021e3e120b5b Mon Sep 17 00:00:00 2001 From: Rich Lander Date: Tue, 17 Oct 2017 14:13:24 -0700 Subject: [PATCH] Merge latest from net471 into master * Regenerated readme, made changes to build readme (#520) * Replaced asset IDs with xrefs (#521) * Replaced asset IDs with xrefs * Formatting changes * .NET 4.7.1 Publishing Changes (#510) * Updates for Known Issues * Updates for Known Issues * Updates for Known Issues * Added API diffss for 4.7.1 * Added updates to 4.7.1 change list * Updates for readme, changelist and known issues * Fixed as per comments from rpetrusha --- .../ASPNET-accessibility-improvement.md | 2 +- Documentation/compatibility/README.md | 12 +- ...g-not-usable-in-Partial-Trust-scenarios.md | 2 +- ...ase-doesnt-propagate-OnStart-exceptions.md | 1 - .../winforms-accessibility-changes-471.md | 31 +- ...ager.DefaultHashAlgorithm-is-now-SHA256.md | 2 +- .../wpf-accessibility-improvements.MD | 2 +- ...s Working After Prolonged Use of Popups.md | 4 +- ...eferenceException in ProcessInputReport.md | 4 +- ... AccessViolation in GetPenEventMultiple.md | 4 +- ...tion when displaying a checked MenuItem.md | 4 +- releases/net471/README.md | 11 +- releases/net471/dotnet471-api-changes.md | 461 ++++++++++++++++++ releases/net471/dotnet471-changes.md | 12 +- releases/net471/dotnet471-known-issues.md | 8 +- 15 files changed, 516 insertions(+), 44 deletions(-) create mode 100644 releases/net471/dotnet471-api-changes.md diff --git a/Documentation/compatibility/ASPNET-accessibility-improvement.md b/Documentation/compatibility/ASPNET-accessibility-improvement.md index 13d1317..33c60eb 100644 --- a/Documentation/compatibility/ASPNET-accessibility-improvement.md +++ b/Documentation/compatibility/ASPNET-accessibility-improvement.md @@ -1,4 +1,4 @@ -## ASP.NET Accessibility Improvement in .NET 4.7.1 +## ASP.NET Accessibility Improvements in .NET 4.7.1 ### Scope Minor diff --git a/Documentation/compatibility/README.md b/Documentation/compatibility/README.md index 734c53c..4d7fefc 100644 --- a/Documentation/compatibility/README.md +++ b/Documentation/compatibility/README.md @@ -16,20 +16,28 @@ Please help us improve the [.NET Framework Application Compatibility documents]( ## .NET Framework 4.7.1 - [Accessibility improvements in Windows Forms controls](winforms-accessibility-changes-471.md) -- [ASP.NET Accessibility Improvement in .NET 4.7.1](ASPNET Accessibility Improvement.md) -- [ASP.NET Accessibility Improvement in .NET 4.7.1](ASPNET-accessibility-improvement.md) +- [Accessibility improvements in Windows Workflow Foundation (WF) workflow designer](workflow-designer-accessibility.md) +- [Accessibility improvements in WPF](wpf-accessibility-improvements.MD) +- [ASP.NET Accessibility Improvements in .NET 4.7.1](ASPNET-accessibility-improvement.md) +- [Chained Popups with StaysOpen=False ](wpf-chained-popups-with-StaysOpen-false.md) - [Default SignedXML and SignedXMS algorithms changed to SHA256](Change-SignedXML-and-SignedCMS-default-algorithms-to-SHA256.md) +- [Selector SelectionChanged event and SelectedValue property](wpf-selector-selectionchanged-and-selectedvalue.md) - [SerialPort background thread exceptions](SerialPort-background-thread-exceptions.md) +- [ServiceBase doesn't propagate OnStart exceptions](ServiceBase-doesnt-propagate-OnStart-exceptions.md) +- [TabControl SelectionChanged event and SelectedContent property](wpf-tabcontrol-selectionchanged-and-selectedcontent.md) +- [The default hash algorithm for WPF PackageDigitalSignatureManager is now SHA256](wpf-PackageDigitalSignatureManager.DefaultHashAlgorithm-is-now-SHA256.md) - [WCF AddressHeaderCollection now throws an ArgumentException if an addressHeader element is null](WCF-AddressHeaderCollection-now-throws-an-ArgumentException-if-an-addressHeader-element-is-null.md) - [WCF MsmqSecureHashAlgorithm default value is now SHA256](WCF-MsmqSecureHashAlgorithm-default-value-is-now-SHA256.md) - [WCF PipeConnection.GetHashAlgorithm now uses SHA256](WCF-PipeConnection.GetHashAlgorithm-now-uses-SHA256.md) ## .NET Framework 4.7 +- [Crash in Selector when removing an item from a custom INCC collection](wpf-selector-crash-when-removing-item-from-custom-collection.md) - [CspParameters.ParentWindowHandle now expects HWND value](cspparameters_parentwindowhandle-now-expects-hwnd-value.md) - [Default value of ServicePointManager.SecurityProtocol is SecurityProtocolType.System.Default](servicepointmanager.securityprotocol-defaults-to-securityprotocoltype.systemdefault.md) - [Incorrect code generation when passing and comparing UInt16 values](incorrect-code-generation-when-passing-and-comparing-uint16-values.md) - [NullReferenceException in exception handling code from ImageSourceConverter.ConvertFrom](wpf-nullreferenceexception-in-exception-handling-code-from-imagesourceconverter_convertfrom.md) +- [Resizing a Grid can hang](wpf-hang-when-resizing-a-grid.md) - [Serialization of control characters with DataContractJsonSerializer is now compatible with ECMAScript V6 and V8](serialization-of-control-characters-with-datacontractjsonserializer-is-now-compatible-with-ecmascript-v6-and-v8.md) - [SslStream supports TLS Alerts](sslstream-support-for-tls-alerts.md) - [Throttle concurrent requests per session](throttle-concurrent-requests-per-session.md) diff --git a/Documentation/compatibility/RSACng-and-DSACng-not-usable-in-Partial-Trust-scenarios.md b/Documentation/compatibility/RSACng-and-DSACng-not-usable-in-Partial-Trust-scenarios.md index 135713b..9f4979b 100644 --- a/Documentation/compatibility/RSACng-and-DSACng-not-usable-in-Partial-Trust-scenarios.md +++ b/Documentation/compatibility/RSACng-and-DSACng-not-usable-in-Partial-Trust-scenarios.md @@ -13,7 +13,7 @@ Edge NotPlanned ### Change Description -CngLightup (used in several higher-level crypto apis, such as `T:System.Security.Cryptography.Xml.EncryptedXml`) and `T:System.Security.Cryptography.RSACng` in some cases rely on full trust. These include P/Invokes without asserting `F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode` permissions, and code paths where `T:System.Security.Cryptography.CngKey` has permission demands for `F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode`. Starting with the .NET Framework 4.6.2, CngLightup was used to switch to `T:System.Security.Cryptography.RSACng` wherever possible. As a result, partial trust apps that successfully used `T:System.Security.Cryptography.Xml.EncryptedXml` began to fail and throw `T:System.Security.SecurityException` exceptions. +CngLightup (used in several higher-level crypto apis, such as ) and in some cases rely on full trust. These include P/Invokes without asserting permissions, and code paths where has permission demands for . Starting with the .NET Framework 4.6.2, CngLightup was used to switch to wherever possible. As a result, partial trust apps that successfully used began to fail and throw exceptions. This change adds the required asserts so that all functions using CngLightup have the required permissions. diff --git a/Documentation/compatibility/ServiceBase-doesnt-propagate-OnStart-exceptions.md b/Documentation/compatibility/ServiceBase-doesnt-propagate-OnStart-exceptions.md index 16a391e..90dadd9 100644 --- a/Documentation/compatibility/ServiceBase-doesnt-propagate-OnStart-exceptions.md +++ b/Documentation/compatibility/ServiceBase-doesnt-propagate-OnStart-exceptions.md @@ -5,7 +5,6 @@ Minor ### Version Introduced - 4.7.1 ### Source Analyzer Status diff --git a/Documentation/compatibility/winforms-accessibility-changes-471.md b/Documentation/compatibility/winforms-accessibility-changes-471.md index f434514..7af4cd2 100644 --- a/Documentation/compatibility/winforms-accessibility-changes-471.md +++ b/Documentation/compatibility/winforms-accessibility-changes-471.md @@ -30,22 +30,22 @@ In order for the application to benefit from these changes, it must run on the . - It is recompiled to target the .NET Framework 4.7.1. These accessibility changes are enabled by default on Windows Forms applications that target the .NET Framework 4.7.1 or later. -- It opts out of the legacy accessibility behaviors by adding the following [AppContext Switch](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/runtime/appcontextswitchoverrides-element) to the `` section of the app.config file and setting it to `false`, as the following example shows. +- It opts out of the legacy accessibility behaviors by adding the following [AppContext switch](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/runtime/appcontextswitchoverrides-element) to the `` section of the app.config file and setting it to `false`, as the following example shows. -```xml - - - - - - - - - - -``` + ```xml + + + + + + + + + + + ``` -Applications that target the .NET Framework 4.7.1 or later and want to preserve the legacy accessibility behavior can opt in to the use of legacy accessibility features by explicitly setting this AppContext switch to ```true```. +Applications that target the .NET Framework 4.7.1 or later and want to preserve the legacy accessibility behavior can opt in to the use of legacy accessibility features by explicitly setting this AppContext switch to `true`. For an overview of UI automation, see the [UI Automation Overview](https://docs.microsoft.com/dotnet/framework/ui-automation/ui-automation-overview). @@ -53,7 +53,8 @@ For an overview of UI automation, see the [UI Automation Overview](https://docs. Accessibility clients can take advantage of new WinForms accessibility functionality by using common, publicly described invocation patterns. These patterns are not WinForms-specific. For instance, accessibility clients can call the QueryInterface method on the IAccessible interface (MAAS) to obtain an IServiceProvider interface. If this interface is available, clients can use its QueryService method to request an IAccessibleEx interface. For more information, see [Using IAccessibleEx from a Client](https://msdn.microsoft.com/en-us/library/windows/desktop/dd561924(v=vs.85).aspx). Starting with the .NET Framework 4.7.1, IServiceProvider and [IAccessibleEx]( https://msdn.microsoft.com/en-us/library/windows/desktop/dd561898(v=vs.85).aspx) (where applicable) are available for WinForms accessibility objects. -The .NET Framework 4.7.1 adds support for the fillowing UI automation patterns and properties: +The .NET Framework 4.7.1 adds support for the following UI automation patterns and properties: + - The `T:System.Windows.Forms.ToolStripSplitButton` and `T:System.Windows.Forms.ComboBox` controls support the [Expand/Collapse pattern](https://docs.microsoft.com/dotnet/framework/ui-automation/implementing-the-ui-automation-expandcollapse-control-pattern). - The `T:System.Windows.Forms.ToolStripMenuItem` control has a [ControlType](https://docs.microsoft.com/dotnet/framework/ui-automation/ui-automation-support-for-the-menubar-control-type) property value . - The `T:System.Windows.Forms.ToolStripItem` control supports the [Name](https://docs.microsoft.com/dotnet/api/system.windows.automation.automationelement.nameproperty) property and [Expand/Collapse pattern](https://docs.microsoft.com/dotnet/framework/ui-automation/implementing-the-ui-automation-expandcollapse-control-pattern). diff --git a/Documentation/compatibility/wpf-PackageDigitalSignatureManager.DefaultHashAlgorithm-is-now-SHA256.md b/Documentation/compatibility/wpf-PackageDigitalSignatureManager.DefaultHashAlgorithm-is-now-SHA256.md index eb9638a..acbd99b 100644 --- a/Documentation/compatibility/wpf-PackageDigitalSignatureManager.DefaultHashAlgorithm-is-now-SHA256.md +++ b/Documentation/compatibility/wpf-PackageDigitalSignatureManager.DefaultHashAlgorithm-is-now-SHA256.md @@ -4,7 +4,7 @@ Edge ### Version Introduced -.NET 4.7.1 +4.7.1 ### Source Analyzer Status NotPlanned diff --git a/Documentation/compatibility/wpf-accessibility-improvements.MD b/Documentation/compatibility/wpf-accessibility-improvements.MD index 0d7d838..2b330a4 100644 --- a/Documentation/compatibility/wpf-accessibility-improvements.MD +++ b/Documentation/compatibility/wpf-accessibility-improvements.MD @@ -1,4 +1,4 @@ -## 195: Accessibility improvements in WPF +## Accessibility improvements in WPF ### Scope Major diff --git a/releases/net471/KnownIssues/479874-WPF Touch Stops Working After Prolonged Use of Popups.md b/releases/net471/KnownIssues/479874-WPF Touch Stops Working After Prolonged Use of Popups.md index 1d0e734..808d031 100644 --- a/releases/net471/KnownIssues/479874-WPF Touch Stops Working After Prolonged Use of Popups.md +++ b/releases/net471/KnownIssues/479874-WPF Touch Stops Working After Prolonged Use of Popups.md @@ -7,6 +7,4 @@ On a touch or stylus-enabled machine, WPF applications may see a loss of touch o A change to disposal of HwndSource in .NET 4.7 caused Popups to not correctly cleanup touch resources. This eventually can lead to loss of touch/stylus interaction. ### Resolution -The fix for this is expected in future servicing update for Windows 10. - -### More information \ No newline at end of file +This issue is fixed for all supported OS platforms prior to Windows 10 Fall Creators Update. The fix for Windows 10 Fall Creators Update is expected in a future servicing update. \ No newline at end of file diff --git a/releases/net471/KnownIssues/481090-WPF Touch generates NullReferenceException in ProcessInputReport.md b/releases/net471/KnownIssues/481090-WPF Touch generates NullReferenceException in ProcessInputReport.md index 96145f2..ea53d00 100644 --- a/releases/net471/KnownIssues/481090-WPF Touch generates NullReferenceException in ProcessInputReport.md +++ b/releases/net471/KnownIssues/481090-WPF Touch generates NullReferenceException in ProcessInputReport.md @@ -7,6 +7,4 @@ WPF throws a NullReferenceException in WispLogic.ProcessInputReport and the appl In WPF applications running on touch or stylus enabled machines, specific hardware and timing issues can cause touch messages to arrive without associated StylusDevices. When this occurs WPF tries to access this null StylusDevice, causing the error. ### Resolution -The fix for this is expected in future servicing update for Windows 10. - -### More information \ No newline at end of file +This issue is fixed for all supported OS platforms prior to Windows 10 Fall Creators Update. The fix for Windows 10 Fall Creators Update is expected in a future servicing update. \ No newline at end of file diff --git a/releases/net471/KnownIssues/489937-WPF Touch and Stylus AccessViolation in GetPenEventMultiple.md b/releases/net471/KnownIssues/489937-WPF Touch and Stylus AccessViolation in GetPenEventMultiple.md index f1c26b7..9696123 100644 --- a/releases/net471/KnownIssues/489937-WPF Touch and Stylus AccessViolation in GetPenEventMultiple.md +++ b/releases/net471/KnownIssues/489937-WPF Touch and Stylus AccessViolation in GetPenEventMultiple.md @@ -7,6 +7,4 @@ On a touch or stylus-enabled machine, WPF applications may sometimes corrupt mem This is due to the release of a COM object that is later used in the WPF touch stack. ### Resolution -The fix for this is expected in future servicing update for Windows 10. - -### More information \ No newline at end of file +This issue is fixed for all supported OS platforms prior to Windows 10 Fall Creators Update. The fix for Windows 10 Fall Creators Update is expected in a future servicing update. \ No newline at end of file diff --git a/releases/net471/KnownIssues/493108-WPF InvalidCastException when displaying a checked MenuItem.md b/releases/net471/KnownIssues/493108-WPF InvalidCastException when displaying a checked MenuItem.md index 77cf474..2d9995e 100644 --- a/releases/net471/KnownIssues/493108-WPF InvalidCastException when displaying a checked MenuItem.md +++ b/releases/net471/KnownIssues/493108-WPF InvalidCastException when displaying a checked MenuItem.md @@ -30,6 +30,4 @@ the reference resolves to the ribbon library's resource. This effectively sets of Path.Data to an object of type Style. The next measure pass then encounters the exception. ### Resolution -The fix for this is expected in a future servicing update for Windows 10. - -### More information +This issue is fixed for all supported OS platforms prior to Windows 10 Fall Creators Update. The fix for Windows 10 Fall Creators Update is expected in a future servicing update. diff --git a/releases/net471/README.md b/releases/net471/README.md index 0d963a4..8ed6f45 100644 --- a/releases/net471/README.md +++ b/releases/net471/README.md @@ -1,12 +1,13 @@ # .NET Framework 4.7.1 Release Notes -> These release notes are current for .NET Framework 4.7.1 build 2539, released 2017-09-13. +You can learn about the changes made in the .NET Framework 4.7.1. -You can learn about the changes made in the .NET Framework 4.7.1, as of build 2539. - -- [Download](https://github.com/Microsoft/dotnet-framework-earlyaccess) -- [Announcement blog post](https://blogs.msdn.microsoft.com/dotnet/2017/08/07/welcome-to-the-net-framework-4-7-1-early-access/) +- [Download](http://go.microsoft.com/fwlink/?LinkId=852095) +- [.NET Framework 4.7.1 Announcement blog post](http://go.microsoft.com/fwlink/?LinkId=852091) - [Release notes](dotnet471-changes.md) +- [Application compatibility](http://go.microsoft.com/fwlink/?LinkId=852106) +- [API changes](dotnet471-api-changes.md) +- [Reference Source](http://go.microsoft.com/fwlink/?LinkId=852103) - [Known issues](dotnet471-known-issues.md) ## Release Notes by Product Area diff --git a/releases/net471/dotnet471-api-changes.md b/releases/net471/dotnet471-api-changes.md new file mode 100644 index 0000000..e866400 --- /dev/null +++ b/releases/net471/dotnet471-api-changes.md @@ -0,0 +1,461 @@ +```diff + namespace System { ++ public static class StringNormalizationExtensions { ++ public static bool IsNormalized(this string value); ++ public static bool IsNormalized(this string value, NormalizationForm normalizationForm); ++ public static string Normalize(this string value); ++ public static string Normalize(this string value, NormalizationForm normalizationForm); ++ } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple { ++ public class Tuple : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)] +- public struct ValueTuple : IComparable, IComparable, IEquatable, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)] ++ public struct ValueTuple : IComparable, IComparable, IEquatable, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } +- public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITupleInternal where TRest : struct { ++ public struct ValueTuple : IComparable, IComparable>, IEquatable>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal where TRest : struct { ++ object System.Runtime.CompilerServices.ITuple.this[int index] { get; } ++ int System.Runtime.CompilerServices.ITuple.Length { get; } + } + } + namespace System.Configuration { ++ public abstract class ConfigurationBuilder : ProviderBase { ++ protected ConfigurationBuilder(); ++ public virtual ConfigurationSection ProcessConfigurationSection(ConfigurationSection configSection); ++ public virtual XmlNode ProcessRawXml(XmlNode rawXml); ++ } ++ public class ConfigurationBuilderCollection : ProviderCollection { ++ public ConfigurationBuilderCollection(); ++ public new ConfigurationBuilder this[string name] { get; } ++ public override void Add(ProviderBase builder); ++ } ++ public class ConfigurationBuilderSettings : ConfigurationElement { ++ public ConfigurationBuilderSettings(); ++ public ProviderSettingsCollection Builders { get; } ++ protected internal override ConfigurationPropertyCollection Properties { get; } ++ } ++ public sealed class ConfigurationBuildersSection : ConfigurationSection { ++ public ConfigurationBuildersSection(); ++ public ProviderSettingsCollection Builders { get; } ++ public ConfigurationBuilder GetBuilderFromName(string builderName); ++ } + public sealed class SectionInformation { ++ public ConfigurationBuilder ConfigurationBuilder { get; } + } + } + namespace System.Configuration.Internal { +- public class DelegatingConfigHost : IInternalConfigHost { ++ public class DelegatingConfigHost : IInternalConfigHost, IInternalConfigurationBuilderHost { ++ protected IInternalConfigurationBuilderHost ConfigBuilderHost { get; } ++ public virtual ConfigurationSection ProcessConfigurationSection(ConfigurationSection configSection, ConfigurationBuilder builder); ++ public virtual XmlNode ProcessRawXml(XmlNode rawXml, ConfigurationBuilder builder); + } ++ public interface IInternalConfigurationBuilderHost { ++ ConfigurationSection ProcessConfigurationSection(ConfigurationSection configSection, ConfigurationBuilder builder); ++ XmlNode ProcessRawXml(XmlNode rawXml, ConfigurationBuilder builder); ++ } + } + namespace System.Data.Common { ++ public abstract class DbColumn { ++ protected DbColumn(); ++ public Nullable AllowDBNull { get; protected set; } ++ public string BaseCatalogName { get; protected set; } ++ public string BaseColumnName { get; protected set; } ++ public string BaseSchemaName { get; protected set; } ++ public string BaseServerName { get; protected set; } ++ public string BaseTableName { get; protected set; } ++ public string ColumnName { get; protected set; } ++ public Nullable ColumnOrdinal { get; protected set; } ++ public Nullable ColumnSize { get; protected set; } ++ public Type DataType { get; protected set; } ++ public string DataTypeName { get; protected set; } ++ public Nullable IsAliased { get; protected set; } ++ public Nullable IsAutoIncrement { get; protected set; } ++ public Nullable IsExpression { get; protected set; } ++ public Nullable IsHidden { get; protected set; } ++ public Nullable IsIdentity { get; protected set; } ++ public Nullable IsKey { get; protected set; } ++ public Nullable IsLong { get; protected set; } ++ public Nullable IsReadOnly { get; protected set; } ++ public Nullable IsUnique { get; protected set; } ++ public virtual object this[string property] { get; } ++ public Nullable NumericPrecision { get; protected set; } ++ public Nullable NumericScale { get; protected set; } ++ public string UdtAssemblyQualifiedName { get; protected set; } ++ } ++ public static class DbDataReaderExtensions { ++ public static bool CanGetColumnSchema(this DbDataReader reader); ++ public static ReadOnlyCollection GetColumnSchema(this DbDataReader reader); ++ } ++ public interface IDbColumnSchemaGenerator { ++ ReadOnlyCollection GetColumnSchema(); ++ } + } + namespace System.Diagnostics { ++ public static class StackFrameExtensions { ++ public static IntPtr GetNativeImageBase(this StackFrame stackFrame); ++ public static IntPtr GetNativeIP(this StackFrame stackFrame); ++ public static bool HasILOffset(this StackFrame stackFrame); ++ public static bool HasMethod(this StackFrame stackFrame); ++ public static bool HasNativeImage(this StackFrame stackFrame); ++ public static bool HasSource(this StackFrame stackFrame); ++ } + } + namespace System.Diagnostics.Tracing { ++ public class EventCounter { ++ public EventCounter(string name, EventSource eventSource); ++ public void WriteMetric(float value); ++ } + } + namespace System.Globalization { ++ public static class GlobalizationExtensions { ++ public static StringComparer GetStringComparer(this CompareInfo compareInfo, CompareOptions options); ++ } + } + namespace System.Linq { + public static class Enumerable { ++ public static IEnumerable Append(this IEnumerable source, TSource element); ++ public static IEnumerable Prepend(this IEnumerable source, TSource element); + } + } + namespace System.Linq.Expressions { + public sealed class Expression : LambdaExpression { ++ public new TDelegate Compile(bool preferInterpretation); + } + public abstract class LambdaExpression : Expression { ++ public Delegate Compile(bool preferInterpretation); + } + } + namespace System.Messaging { + public enum HashAlgorithm { ++ Sha256 = 32780, ++ Sha384 = 32781, ++ Sha512 = 32782, + } + } + namespace System.Net.Http { + public class HttpClientHandler : HttpMessageHandler { ++ public bool CheckCertificateRevocationList { get; set; } ++ public X509CertificateCollection ClientCertificates { get; } ++ public ICredentials DefaultProxyCredentials { get; set; } ++ public int MaxConnectionsPerServer { get; set; } ++ public int MaxResponseHeadersLength { get; set; } ++ public IDictionary Properties { get; } ++ public Func ServerCertificateCustomValidationCallback { get; set; } ++ public SslProtocols SslProtocols { get; set; } + } + } + namespace System.Net.Sockets { ++ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] ++ public struct SocketReceiveFromResult { ++ public int ReceivedBytes; ++ public EndPoint RemoteEndPoint; ++ } ++ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] ++ public struct SocketReceiveMessageFromResult { ++ public IPPacketInformation PacketInformation; ++ public int ReceivedBytes; ++ public EndPoint RemoteEndPoint; ++ public SocketFlags SocketFlags; ++ } ++ public static class SocketTaskExtensions { ++ public static Task AcceptAsync(this Socket socket); ++ public static Task AcceptAsync(this Socket socket, Socket acceptSocket); ++ public static Task ConnectAsync(this Socket socket, EndPoint remoteEP); ++ public static Task ConnectAsync(this Socket socket, IPAddress address, int port); ++ public static Task ConnectAsync(this Socket socket, IPAddress[] addresses, int port); ++ public static Task ConnectAsync(this Socket socket, string host, int port); ++ public static Task ReceiveAsync(this Socket socket, ArraySegment buffer, SocketFlags socketFlags); ++ public static Task ReceiveAsync(this Socket socket, IList> buffers, SocketFlags socketFlags); ++ public static Task ReceiveFromAsync(this Socket socket, ArraySegment buffer, SocketFlags socketFlags, EndPoint remoteEndPoint); ++ public static Task ReceiveMessageFromAsync(this Socket socket, ArraySegment buffer, SocketFlags socketFlags, EndPoint remoteEndPoint); ++ public static Task SendAsync(this Socket socket, ArraySegment buffer, SocketFlags socketFlags); ++ public static Task SendAsync(this Socket socket, IList> buffers, SocketFlags socketFlags); ++ public static Task SendToAsync(this Socket socket, ArraySegment buffer, SocketFlags socketFlags, EndPoint remoteEP); ++ } + } + namespace System.Runtime.CompilerServices { ++ public sealed class IsByRefLikeAttribute : Attribute { ++ public IsByRefLikeAttribute(); ++ } ++ public sealed class IsReadOnlyAttribute : Attribute { ++ public IsReadOnlyAttribute(); ++ } ++ public interface ITuple { ++ object this[int index] { get; } ++ int Length { get; } ++ } ++ public static class RuntimeFeature { ++ public const string PortablePdb = "PortablePdb"; ++ public static bool IsSupported(string feature); ++ } + } + namespace System.Runtime.InteropServices { ++ public enum Architecture { ++ Arm = 2, ++ Arm64 = 3, ++ X64 = 1, ++ X86 = 0, ++ } ++ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] ++ public struct OSPlatform : IEquatable { ++ public static OSPlatform Linux { get; } ++ public static OSPlatform OSX { get; } ++ public static OSPlatform Windows { get; } ++ public static OSPlatform Create(string osPlatform); ++ public override bool Equals(object obj); ++ public bool Equals(OSPlatform other); ++ public override int GetHashCode(); ++ public static bool operator ==(OSPlatform left, OSPlatform right); ++ public static bool operator !=(OSPlatform left, OSPlatform right); ++ public override string ToString(); ++ } ++ public static class RuntimeInformation { ++ public static string FrameworkDescription { get; } ++ public static Architecture OSArchitecture { get; } ++ public static string OSDescription { get; } ++ public static Architecture ProcessArchitecture { get; } ++ public static bool IsOSPlatform(OSPlatform osPlatform); ++ } + } + namespace System.Runtime.Serialization { ++ public static class DataContractSerializerExtensions { ++ public static ISerializationSurrogateProvider GetSerializationSurrogateProvider(this DataContractSerializer serializer); ++ public static void SetSerializationSurrogateProvider(this DataContractSerializer serializer, ISerializationSurrogateProvider provider); ++ } ++ public interface ISerializationSurrogateProvider { ++ object GetDeserializedObject(object obj, Type targetType); ++ object GetObjectToSerialize(object obj, Type targetType); ++ Type GetSurrogateType(Type type); ++ } + } + namespace System.Security { ++ public static class SecureStringMarshal { ++ public static IntPtr SecureStringToCoTaskMemAnsi(SecureString s); ++ public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s); ++ public static IntPtr SecureStringToGlobalAllocAnsi(SecureString s); ++ public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s); ++ } + } + namespace System.Security.Cryptography { ++ public sealed class IncrementalHash : IDisposable { ++ public HashAlgorithmName AlgorithmName { get; } ++ public void AppendData(byte[] data); ++ public void AppendData(byte[] data, int offset, int count); ++ public static IncrementalHash CreateHash(HashAlgorithmName hashAlgorithm); ++ public static IncrementalHash CreateHMAC(HashAlgorithmName hashAlgorithm, byte[] key); ++ public void Dispose(); ++ public byte[] GetHashAndReset(); ++ } + } + namespace System.ServiceModel.Channels { + public class NamedPipeTransportBindingElement : ConnectionOrientedTransportBindingElement { ++ public Collection AllowedSecurityIdentifiers { get; } + } + } + namespace System.Text.RegularExpressions { + public class Regex : ISerializable { ++ protected IDictionary CapNames { get; set; } ++ protected IDictionary Caps { get; set; } + } + } + namespace System.Threading { ++ public sealed class PreAllocatedOverlapped : IDeferredDisposable, IDisposable { ++ public PreAllocatedOverlapped(IOCompletionCallback callback, object state, object pinData); ++ public void Dispose(); ++ } ++ public sealed class ThreadPoolBoundHandle : IDisposable { ++ public SafeHandle Handle { get; } ++ public unsafe NativeOverlapped* AllocateNativeOverlapped(IOCompletionCallback callback, object state, object pinData); ++ public unsafe NativeOverlapped* AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated); ++ public static ThreadPoolBoundHandle BindHandle(SafeHandle handle); ++ public void Dispose(); ++ public unsafe void FreeNativeOverlapped(NativeOverlapped* overlapped); ++ public unsafe static object GetNativeOverlappedState(NativeOverlapped* overlapped); ++ } + } + namespace System.Web { + public class HttpApplication : IComponent, IDisposable, IHttpAsyncHandler, IHttpHandler, IRequestCompletedNotifier, ISyncContext { ++ public void OnExecuteRequestStep(Action callback); + } + public sealed class HttpCookie { ++ public static bool TryParse(string input, out HttpCookie result); + } + } + namespace System.Web.Configuration { + public enum FormsAuthPasswordFormat { ++ SHA256 = 3, ++ SHA384 = 4, ++ SHA512 = 5, + } + } + namespace System.Windows { + public static class BaseCompatibilityPreferences { ++ public enum HandleDispatcherRequestProcessingFailureOptions { ++ Continue = 0, ++ Reset = 2, ++ Throw = 1, ++ } ++ public static BaseCompatibilityPreferences.HandleDispatcherRequestProcessingFailureOptions HandleDispatcherRequestProcessingFailure { get; set; } + } + public static class DependencyPropertyHelper { ++ public static bool IsTemplatedValueDynamic(DependencyObject elementInTemplate, DependencyProperty dependencyProperty); + } + public class ResourceDictionary : ICollection, IDictionary, IEnumerable, INameScope, ISupportInitialize, IUriContext { ++ public bool InvalidatesImplicitDataTemplateResources { get; set; } + } + } + namespace System.Windows.Automation { + public static class AutomationElementIdentifiers { ++ public static readonly AutomationEvent LiveRegionChangedEvent; ++ public static readonly AutomationProperty LiveSettingProperty; + } ++ public enum AutomationLiveSetting { ++ Assertive = 2, ++ Off = 0, ++ Polite = 1, ++ } + public static class AutomationProperties { ++ public static readonly DependencyProperty LiveSettingProperty; ++ public static AutomationLiveSetting GetLiveSetting(DependencyObject element); ++ public static void SetLiveSetting(DependencyObject element, AutomationLiveSetting value); + } + } + namespace System.Windows.Automation.Peers { + public enum AutomationEvents { ++ LiveRegionChanged = 18, + } + public abstract class AutomationPeer : DispatcherObject { ++ public AutomationLiveSetting GetLiveSetting(); ++ protected virtual AutomationLiveSetting GetLiveSettingCore(); + } + public class ContentElementAutomationPeer : AutomationPeer { ++ protected override AutomationLiveSetting GetLiveSettingCore(); + } + public class ExpanderAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider { ++ protected override List GetChildrenCore(); ++ protected override bool HasKeyboardFocusCore(); + } + public abstract class ItemAutomationPeer : AutomationPeer, IVirtualizedItemProvider { ++ protected override AutomationLiveSetting GetLiveSettingCore(); + } + public class UIElement3DAutomationPeer : AutomationPeer { ++ protected override AutomationLiveSetting GetLiveSettingCore(); + } + public class UIElementAutomationPeer : AutomationPeer { ++ protected override AutomationLiveSetting GetLiveSettingCore(); + } + } + namespace System.Windows.Controls { + public class Expander : HeaderedContentControl { ++ public override void OnApplyTemplate(); + } + } + namespace System.Windows.Diagnostics { + public static class VisualDiagnostics { ++ public static void DisableVisualTreeChanged(); ++ public static void EnableVisualTreeChanged(); + } + } + namespace System.Windows.Forms { + public class DomainUpDown : UpDownBase { + public class DomainUpDownAccessibleObject : Control.ControlAccessibleObject { ++ public override string Name { get; set; } + } + } + public class MonthCalendar : Control { ++ protected override AccessibleObject CreateAccessibilityInstance(); + } + public class ToolStripDropDownButton : ToolStripDropDownItem { ++ protected override AccessibleObject CreateAccessibilityInstance(); + } + } + namespace System.Xml.XmlConfiguration { + public sealed class XmlReaderSection : ConfigurationSection { ++ public string CollapseWhiteSpaceIntoEmptyStringString { get; set; } + } + } + namespace System.Xml.XPath { ++ public static class XDocumentExtensions { ++ public static IXPathNavigable ToXPathNavigable(this XNode node); ++ } + } +``` diff --git a/releases/net471/dotnet471-changes.md b/releases/net471/dotnet471-changes.md index 2902190..f28058c 100644 --- a/releases/net471/dotnet471-changes.md +++ b/releases/net471/dotnet471-changes.md @@ -1,9 +1,5 @@ # .NET Framework 4.7.1 Release Notes -> These release notes are current for .NET Framework 4.7.1 build 2539, released 2017-09-13. - -You can learn about the changes made in the .NET Framework 4.7.1, as of build 2539. - .NET Framework release notes describe product improvements grouped by product area. Each change includes a Microsoft-internal VSTS bug ID, the primary binary that was updated and whether the change was a bug or a feature. ## ASP.NET @@ -45,6 +41,7 @@ You can learn about the changes made in the .NET Framework 4.7.1, as of build 25 * Added an attribute System.Runtime.CompilerServices.IsRefLikeAttribute [429642, mscorlib.dll, Feature] * Enabled interop between StorageFile / StorageFolder and .NET types for filesystem access [433898, mscorlib.dll, Feature] * System.Runtime.CompilerServices.RuntimeFeature.IsSupported allows to check whether the runtime supports displaying source line information for stack frames in assemblies built with portable symbols (PDBs). This is common for libraries that are built targeting .Net standard. [436315, mscorlib.dll, Feature] +* During the .NET Standard 2.0 work a type was missed because of a mismatch between the contracts we have in the full .NET Framework and the ones we shipped as part of .NET Standard 1.*. [468256, System.Net.NetworkInformation.dll, Bug] ## CLR @@ -71,6 +68,7 @@ You can learn about the changes made in the .NET Framework 4.7.1, as of build 25 * Fixed infinite loop in the jit which happens in certain cases where cgt.un is used to implement a null check. [453201, clrjit.dll, Bug] * Fixed a silent bad codegen problem in JIT that results in incorrect results from XslCompiledTransform. [461649, clrjit.dll, Bug] * Fixed potential crash during CLR shutdown [437163, clr.dll, Bug] +* Fixed a codegen bug in the code that deals with intrinsics implemented by user calls. [499714, clrjit.dll, Bug] ## Compiler and Managed Languages @@ -139,6 +137,8 @@ You can learn about the changes made in the .NET Framework 4.7.1, as of build 25 ``` +* Fixed an issue where screen readers would consider the arrows in the workflow designer navigation breadcrumbs as part of the list. [408282, System.Activities.Presentation.dll, Bug] +* Fixed an issue where screen readers would read non-descriptive names of edit boxes in the workflow designer properties window. [459631, System.Activities.Presentation.dll, Bug] ## WPF @@ -172,3 +172,7 @@ You can learn about the changes made in the .NET Framework 4.7.1, as of build 25 * Added ability to tell whether a property value inside a template is a dynamic resource reference. [406807, PresentationFramework.dll, Feature] * Provided source info for elements in template created by XamlReader.Load [406808, PresentationFramework.dll, Feature] * Enabled VisualTree notifications for debugging [406811, PresentationFramework.dll, Feature] +* A WPF app that implements an event handler for the Selector.SelectionChanged event should see the new values for the SelectedIndex, SelectedItem and SelectedValue properties. This worked correctly in all cases except for one: when the selection change was caused by changing SelectedValue and the handler queried the SelectedValue property, it saw the old value. This has been fixed. [96884, PresentationFramework,dll, Bug] +* A WPF app with an event handler for the TabControl.SelectionChanged sees the wrong (old) value for TabControl.SelectedContent. Also, if the selection change occurs while keyboard focus is in the content area, the focus should remain in the content area (provided the new selected content has a focusable element). This has been fixed. [208019, PresentationFramework,dll, Bug] +* Fixed an issue for touch or stylus-enabled machines, where repeated use of popups in WPF applications can cause loss of touch and stylus support. [479874, PresentationCore.dll, Bug] +* Fixed an issue for touch or stylus-enabled machines, where WPF applications may throw a NullReferenceException in WispLogic.ProcessInputReport. [481090, PresentationCore.dll, Bug] diff --git a/releases/net471/dotnet471-known-issues.md b/releases/net471/dotnet471-known-issues.md index 3afe4a7..4fd16ff 100644 --- a/releases/net471/dotnet471-known-issues.md +++ b/releases/net471/dotnet471-known-issues.md @@ -1,4 +1,10 @@ .NET Framework 4.7.1 Known Issues ================================= + +This document lists the known issues that you may experience after you install the Microsoft .NET Framework 4.7.1. -There are no known issues as of build 2539. +## Product issues for the .NET Framework 4.7.1 +- [479874 - WPF Touch Stops Working After Rapid/Prolonged Use Of Popups](https://github.com/Microsoft/dotnet/blob/net471/releases/net471/KnownIssues/479874-WPF%20Touch%20Stops%20Working%20After%20Prolonged%20Use%20of%20Popups.md) +- [481090 - WPF Touch generates a NullReferenceException in WispLogic.ProcessInputReport](https://github.com/Microsoft/dotnet/blob/net471/releases/net471/KnownIssues/481090-WPF%20Touch%20generates%20NullReferenceException%20in%20ProcessInputReport.md) +- [489937 - WPF Touch/Stylus Generates AccessViolations and Heap Corruption in GetPenEventMultiple](https://github.com/Microsoft/dotnet/blob/net471/releases/net471/KnownIssues/489937-WPF%20Touch%20and%20Stylus%20AccessViolation%20in%20GetPenEventMultiple.md) +- [493108 - WPF InvalidCastException when displaying a checked MenuItem](https://github.com/Microsoft/dotnet/blob/net471/releases/net471/KnownIssues/493108-WPF%20InvalidCastException%20when%20displaying%20a%20checked%20MenuItem.md)