16 KiB
16 KiB
namespace System.Activities.Presentation {
public static class WorkflowDesignerColors {
+ public const string ActivityDesignerSelectedTitleForegroundColorKey = "ActivityDesignerSelectedTitleForegroundColorKey";
+ public const string FlowchartConnectorColorKey = "FlowchartConnectorColorKey";
+ public const string PropertyToolBarHightlightedButtonForegroundColorKey = "PropertyToolBarHightlightedButtonForegroundColor";
+ public const string WorkflowViewElementSelectedCaptionColorKey = "WorkflowViewElementSelectedCaptionBrushColorKey";
+ public static Color ActivityDesignerSelectedTitleForegroundColor { get; }
+ public static Color ContextMenuItemTextHoverQuirkedColor { get; }
+ public static Color FlowchartConnectorColor { get; }
+ public static Color PropertyToolBarHightlightedButtonForegroundColor { get; }
+ public static Color WorkflowViewElementSelectedCaptionColor { get; }
}
}
namespace System.Collections.Concurrent {
public class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+ public TValue AddOrUpdate<TArg>(TKey key, Func<TKey, TArg, TValue> addValueFactory, Func<TKey, TValue, TArg, TValue> updateValueFactory, TArg factoryArgument);
+ public TValue GetOrAdd<TArg>(TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument);
}
}
namespace System.Collections.Generic {
public class HashSet<T> : ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISerializable, ISet<T> {
+ public HashSet(int capacity);
+ public HashSet(int capacity, IEqualityComparer<T> comparer);
+ public bool TryGetValue(T equalValue, out T actualValue);
}
public class SortedSet<T> : ICollection, ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISerializable, ISet<T> {
+ public bool TryGetValue(T equalValue, out T actualValue);
}
}
namespace System.Data.SqlClient {
+ public abstract class SqlAuthenticationInitializer {
+ protected SqlAuthenticationInitializer();
+ public abstract void Initialize();
+ }
public enum SqlAuthenticationMethod {
+ ActiveDirectoryInteractive = 4,
}
+ public class SqlAuthenticationParameters {
+ protected SqlAuthenticationParameters(SqlAuthenticationMethod authenticationMethod, string serverName, string databaseName, string resource, string authority, string userId, string password, Guid connectionId);
+ public SqlAuthenticationMethod AuthenticationMethod { get; }
+ public string Authority { get; }
+ public Guid ConnectionId { get; }
+ public string DatabaseName { get; }
+ public string Password { get; }
+ public string Resource { get; }
+ public string ServerName { get; }
+ public string UserId { get; }
+ }
+ public abstract class SqlAuthenticationProvider {
+ protected SqlAuthenticationProvider();
+ public abstract Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenticationParameters parameters);
+ public virtual void BeforeLoad(SqlAuthenticationMethod authenticationMethod);
+ public virtual void BeforeUnload(SqlAuthenticationMethod authenticationMethod);
+ public static SqlAuthenticationProvider GetProvider(SqlAuthenticationMethod authenticationMethod);
+ public abstract bool IsSupported(SqlAuthenticationMethod authenticationMethod);
+ public static bool SetProvider(SqlAuthenticationMethod authenticationMethod, SqlAuthenticationProvider provider);
+ }
+ public class SqlAuthenticationToken {
+ public SqlAuthenticationToken(string accessToken, DateTimeOffset expiresOn);
+ public string AccessToken { get; }
+ public DateTimeOffset ExpiresOn { get; }
+ }
+ public class SqlClientLogger {
+ public SqlClientLogger();
+ public bool IsLoggingEnabled { get; }
+ public bool LogAssert(bool value, string type, string method, string message);
+ public void LogError(string type, string method, string message);
+ public void LogInfo(string type, string method, string message);
+ }
public class SqlColumnEncryptionCertificateStoreProvider : SqlColumnEncryptionKeyStoreProvider {
+ public override byte[] SignColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations);
+ public override bool VerifyColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations, byte[] signature);
}
public class SqlColumnEncryptionCngProvider : SqlColumnEncryptionKeyStoreProvider {
+ public override byte[] SignColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations);
+ public override bool VerifyColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations, byte[] signature);
}
public class SqlColumnEncryptionCspProvider : SqlColumnEncryptionKeyStoreProvider {
+ public override byte[] SignColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations);
+ public override bool VerifyColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations, byte[] signature);
}
+ public abstract class SqlColumnEncryptionEnclaveProvider {
+ protected SqlColumnEncryptionEnclaveProvider();
+ public abstract void CreateEnclaveSession(byte[] enclaveAttestationInfo, ECDiffieHellmanCng clientDiffieHellmanKey, string attestationUrl, string servername, out SqlEnclaveSession sqlEnclaveSession, out long counter);
+ public abstract SqlEnclaveAttestationParameters GetAttestationParameters();
+ public abstract void GetEnclaveSession(string serverName, string attestationUrl, out SqlEnclaveSession sqlEnclaveSession, out long counter);
+ public abstract void InvalidateEnclaveSession(string serverName, string enclaveAttestationUrl, SqlEnclaveSession enclaveSession);
+ }
public abstract class SqlColumnEncryptionKeyStoreProvider {
+ public virtual byte[] SignColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations);
+ public virtual bool VerifyColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations, byte[] signature);
}
public sealed class SqlConnectionStringBuilder : DbConnectionStringBuilder {
+ public string EnclaveAttestationUrl { get; set; }
}
+ public class SqlEnclaveAttestationParameters {
+ public SqlEnclaveAttestationParameters(int protocol, byte[] input, ECDiffieHellmanCng clientDiffieHellmanKey);
+ public ECDiffieHellmanCng ClientDiffieHellmanKey { get; }
+ public int Protocol { get; }
+ public byte[] GetInput();
+ }
+ public class SqlEnclaveSession {
+ public SqlEnclaveSession(byte[] sessionKey, long sessionId);
+ public long SessionId { get; }
+ public byte[] GetSessionKey();
+ }
}
namespace System.IO.Compression {
public class ZipArchiveEntry {
+ public int ExternalAttributes { get; set; }
}
}
namespace System.Linq {
public static class Enumerable {
+ public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source);
+ public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);
}
}
namespace System.Net.Http {
public class HttpClientHandler : HttpMessageHandler {
+ public static Func<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, bool> DangerousAcceptAnyServerCertificateValidator { get; }
}
}
namespace System.Security.Cryptography {
public class CryptoStream : Stream, IDisposable {
+ public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode mode, bool leaveOpen);
}
public abstract class DSA : AsymmetricAlgorithm {
+ public static DSA Create(DSAParameters parameters);
+ public static DSA Create(int keySizeInBits);
}
public class Rfc2898DeriveBytes : DeriveBytes {
+ public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations, HashAlgorithmName hashAlgorithm);
+ public Rfc2898DeriveBytes(string password, byte[] salt, int iterations, HashAlgorithmName hashAlgorithm);
+ public Rfc2898DeriveBytes(string password, int saltSize, int iterations, HashAlgorithmName hashAlgorithm);
}
public abstract class RSA : AsymmetricAlgorithm {
+ public static RSA Create(int keySizeInBits);
+ public static RSA Create(RSAParameters parameters);
}
}
namespace System.Security.Cryptography.Pkcs {
public sealed class SignerInfo {
+ public Oid SignatureAlgorithm { get; }
+ public byte[] GetSignature();
}
}
namespace System.Security.Cryptography.X509Certificates {
+ public sealed class CertificateRequest {
+ public CertificateRequest(string subjectName, ECDsa key, HashAlgorithmName hashAlgorithm);
+ public CertificateRequest(string subjectName, RSA key, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding);
+ public CertificateRequest(X500DistinguishedName subjectName, ECDsa key, HashAlgorithmName hashAlgorithm);
+ public CertificateRequest(X500DistinguishedName subjectName, PublicKey publicKey, HashAlgorithmName hashAlgorithm);
+ public CertificateRequest(X500DistinguishedName subjectName, RSA key, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding);
+ public Collection<X509Extension> CertificateExtensions { get; }
+ public HashAlgorithmName HashAlgorithm { get; }
+ public PublicKey PublicKey { get; }
+ public X500DistinguishedName SubjectName { get; }
+ public X509Certificate2 Create(X500DistinguishedName issuerName, X509SignatureGenerator generator, DateTimeOffset notBefore, DateTimeOffset notAfter, byte[] serialNumber);
+ public X509Certificate2 Create(X509Certificate2 issuerCertificate, DateTimeOffset notBefore, DateTimeOffset notAfter, byte[] serialNumber);
+ public X509Certificate2 CreateSelfSigned(DateTimeOffset notBefore, DateTimeOffset notAfter);
+ public byte[] CreateSigningRequest();
+ public byte[] CreateSigningRequest(X509SignatureGenerator signatureGenerator);
+ }
public static class DSACertificateExtensions {
+ public static X509Certificate2 CopyWithPrivateKey(this X509Certificate2 certificate, DSA privateKey);
}
public static class ECDsaCertificateExtensions {
+ public static X509Certificate2 CopyWithPrivateKey(this X509Certificate2 certificate, ECDsa privateKey);
}
public static class RSACertificateExtensions {
+ public static X509Certificate2 CopyWithPrivateKey(this X509Certificate2 certificate, RSA privateKey);
}
+ public sealed class SubjectAlternativeNameBuilder {
+ public SubjectAlternativeNameBuilder();
+ public void AddDnsName(string dnsName);
+ public void AddEmailAddress(string emailAddress);
+ public void AddIpAddress(IPAddress ipAddress);
+ public void AddUri(Uri uri);
+ public void AddUserPrincipalName(string upn);
+ public X509Extension Build(bool critical=false);
+ }
public enum X509KeyStorageFlags {
+ EphemeralKeySet = 32,
}
+ public abstract class X509SignatureGenerator {
+ protected X509SignatureGenerator();
+ public PublicKey PublicKey { get; }
+ protected abstract PublicKey BuildPublicKey();
+ public static X509SignatureGenerator CreateForECDsa(ECDsa key);
+ public static X509SignatureGenerator CreateForRSA(RSA key, RSASignaturePadding signaturePadding);
+ public abstract byte[] GetSignatureAlgorithmIdentifier(HashAlgorithmName hashAlgorithm);
+ public abstract byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm);
+ }
}
namespace System.Web {
public sealed class HttpCookie {
+ public SameSiteMode SameSite { get; set; }
}
public sealed class HttpRuntime {
+ public static IServiceProvider WebObjectActivator { get; set; }
}
+ public enum SameSiteMode {
+ Lax = 1,
+ None = 0,
+ Strict = 2,
+ }
}
namespace System.Web.Configuration {
public sealed class FormsAuthenticationConfiguration : ConfigurationElement {
+ public SameSiteMode CookieSameSite { get; set; }
}
public sealed class HttpCookiesSection : ConfigurationSection {
+ public SameSiteMode SameSite { get; set; }
}
public sealed class SessionStateSection : ConfigurationSection {
+ public SameSiteMode CookieSameSite { get; set; }
}
}
namespace System.Web.Security {
public sealed class FormsAuthentication {
+ public static SameSiteMode CookieSameSite { get; }
}
}
namespace System.Windows.Diagnostics {
public static class ResourceDictionaryDiagnostics {
+ public static IEnumerable<Application> GetApplicationOwners(ResourceDictionary dictionary);
+ public static IEnumerable<FrameworkContentElement> GetFrameworkContentElementOwners(ResourceDictionary dictionary);
+ public static IEnumerable<FrameworkElement> GetFrameworkElementOwners(ResourceDictionary dictionary);
+ public static IEnumerable<ResourceDictionary> GetResourceDictionariesForSource(Uri uri);
+ public static event EventHandler<StaticResourceResolvedEventArgs> StaticResourceResolved;
}
+ public class StaticResourceResolvedEventArgs : EventArgs {
+ public ResourceDictionary ResourceDictionary { get; private set; }
+ public object ResourceKey { get; private set; }
+ public object TargetObject { get; private set; }
+ public object TargetProperty { get; private set; }
+ }
}
namespace System.Windows.Forms {
public class DataGridView : Control, ISupportInitialize {
+ protected bool ProcessF3Key(Keys keyData);
}
public class DataGridViewComboBoxCell : DataGridViewCell {
+ protected class DataGridViewComboBoxCellAccessibleObject : DataGridViewCell.DataGridViewCellAccessibleObject {
+ public DataGridViewComboBoxCellAccessibleObject(DataGridViewCell owner);
+ }
+ protected override AccessibleObject CreateAccessibilityInstance();
}
public class DataGridViewComboBoxEditingControl : ComboBox, IDataGridViewEditingControl {
+ protected override AccessibleObject CreateAccessibilityInstance();
}
public class DataGridViewTextBoxCell : DataGridViewCell {
+ protected class DataGridViewTextBoxCellAccessibleObject : DataGridViewCell.DataGridViewCellAccessibleObject {
+ public DataGridViewTextBoxCellAccessibleObject(DataGridViewCell owner);
+ }
+ protected override AccessibleObject CreateAccessibilityInstance();
}
public class DataGridViewTextBoxEditingControl : TextBox, IDataGridViewEditingControl {
+ protected override AccessibleObject CreateAccessibilityInstance();
}
public class SystemInformation {
+ public static int GetHorizontalScrollBarArrowWidthForDpi(int dpi);
}
}
namespace Microsoft.Build.Tasks.Windows {
public sealed class GenerateTemporaryTargetAssembly : Task {
+ public bool GenerateTemporaryTargetAssemblyDebuggingInformation { get; set; }
}
}
namespace Microsoft.Win32.SafeHandles {
public abstract class SafeNCryptHandle : SafeHandleZeroOrMinusOneIsInvalid {
+ protected SafeNCryptHandle(IntPtr handle, SafeHandle parentHandle);
}
public sealed class SafeNCryptKeyHandle : SafeNCryptHandle {
+ public SafeNCryptKeyHandle(IntPtr handle, SafeHandle parentHandle);
}
}