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<T1> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2, T3> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2, T3> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2, T3, T4> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2, T3, T4> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2, T3, T4, T5> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2, T3, T4, T5> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2, T3, T4, T5, T6> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2, T3, T4, T5, T6> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple, ITupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+ public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : 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<ValueTuple>, IEquatable<ValueTuple>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+ public struct ValueTuple : IComparable, IComparable<ValueTuple>, IEquatable<ValueTuple>, 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<T1> : IComparable, IComparable<ValueTuple<T1>>, IEquatable<ValueTuple<T1>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct ValueTuple<T1> : IComparable, IComparable<ValueTuple<T1>>, IEquatable<ValueTuple<T1>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2> : IComparable, IComparable<ValueTuple<T1, T2>>, IEquatable<ValueTuple<T1, T2>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ public struct ValueTuple<T1, T2> : IComparable, IComparable<ValueTuple<T1, T2>>, IEquatable<ValueTuple<T1, T2>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2, T3> : IComparable, IComparable<ValueTuple<T1, T2, T3>>, IEquatable<ValueTuple<T1, T2, T3>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ public struct ValueTuple<T1, T2, T3> : IComparable, IComparable<ValueTuple<T1, T2, T3>>, IEquatable<ValueTuple<T1, T2, T3>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2, T3, T4> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4>>, IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ public struct ValueTuple<T1, T2, T3, T4> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4>>, IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2, T3, T4, T5> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ public struct ValueTuple<T1, T2, T3, T4, T5> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2, T3, T4, T5, T6> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ public struct ValueTuple<T1, T2, T3, T4, T5, T6> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IStructuralComparable, IStructuralEquatable, ITupleInternal {
+ public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IStructuralComparable, IStructuralEquatable, ITuple, IValueTupleInternal {
+ object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+ int System.Runtime.CompilerServices.ITuple.Length { get; }
}
- public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IStructuralComparable, IStructuralEquatable, ITupleInternal where TRest : struct {
+ public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, 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<bool> 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<int> ColumnOrdinal { get; protected set; }
+ public Nullable<int> ColumnSize { get; protected set; }
+ public Type DataType { get; protected set; }
+ public string DataTypeName { get; protected set; }
+ public Nullable<bool> IsAliased { get; protected set; }
+ public Nullable<bool> IsAutoIncrement { get; protected set; }
+ public Nullable<bool> IsExpression { get; protected set; }
+ public Nullable<bool> IsHidden { get; protected set; }
+ public Nullable<bool> IsIdentity { get; protected set; }
+ public Nullable<bool> IsKey { get; protected set; }
+ public Nullable<bool> IsLong { get; protected set; }
+ public Nullable<bool> IsReadOnly { get; protected set; }
+ public Nullable<bool> IsUnique { get; protected set; }
+ public virtual object this[string property] { get; }
+ public Nullable<int> NumericPrecision { get; protected set; }
+ public Nullable<int> NumericScale { get; protected set; }
+ public string UdtAssemblyQualifiedName { get; protected set; }
+ }
+ public static class DbDataReaderExtensions {
+ public static bool CanGetColumnSchema(this DbDataReader reader);
+ public static ReadOnlyCollection<DbColumn> GetColumnSchema(this DbDataReader reader);
+ }
+ public interface IDbColumnSchemaGenerator {
+ ReadOnlyCollection<DbColumn> 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<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element);
+ public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element);
}
}
namespace System.Linq.Expressions {
public sealed class Expression<TDelegate> : 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<string, object> Properties { get; }
+ public Func<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, bool> 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<Socket> AcceptAsync(this Socket socket);
+ public static Task<Socket> 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<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
+ public static Task<int> ReceiveAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
+ public static Task<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
+ public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
+ public static Task<int> SendAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
+ public static Task<int> SendAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
+ public static Task<int> SendToAsync(this Socket socket, ArraySegment<byte> 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<OSPlatform> {
+ 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<SecurityIdentifier> 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<HttpContextBase, 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<AutomationPeer> 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);
+ }
}