Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/AdministrationHelpers.cs

@@ -0,0 +1,31 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Reflection;
+    using System.ServiceModel.Channels;
+    using System.ServiceModel;
+
+
+    static class AdministrationHelpers
+    {
+        public static Type GetServiceModelBaseType(Type type)
+        {
+            Type baseType = type;
+            while (null != baseType)
+            {
+                if (baseType.IsPublic && baseType.Assembly == typeof(BindingElement).Assembly)
+                {
+                    break;
+                }
+
+                baseType = baseType.BaseType;
+            }
+
+            return baseType;
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/AdministrationStrings.cs

@@ -0,0 +1,287 @@
+//------------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------------------------
+namespace System.ServiceModel.Administration
+{
+    internal static class AdministrationStrings
+    {
+        internal const string AcknowledgementInterval = "AcknowledgementInterval";
+        internal const string Action = "Action";
+        internal const string Address = "Address";
+        internal const string AddressFilterMode = "AddressFilterMode";
+        internal const string AddressHeaders = "AddressHeaders";
+        internal const string AllowAnonymous = "AllowAnonymous";
+        internal const string AllowCookies = "AllowCookies";
+        internal const string AllowedImpersonationLevel = "AllowedImpersonationLevel";
+        internal const string AllowInsecureTransport = "AllowInsecureTransport";
+        internal const string AllowNtlm = "AllowNtlm";
+        internal const string AppDomainId = "AppDomainId";
+        internal const string AppDomainInfo = "AppDomainInfo";
+        internal const string AsyncPattern = "AsyncPattern";
+        internal const string AuditLogLocation = "AuditLogLocation";
+        internal const string AuthenticationMode = "AuthenticationMode";
+        internal const string AuthenticationScheme = "AuthenticationScheme";
+        internal const string AutoDisposeParameters = "AutoDisposeParameters";
+        internal const string AutomaticSessionShutdown = "AutomaticSessionShutdown";
+        internal const string BaseAddresses = "BaseAddresses";
+        internal const string Behaviors = "Behaviors";
+        internal const string Binding = "Binding";
+        internal const string BindingElements = "BindingElements";
+        internal const string BypassProxyOnLocal = "BypassProxyOnLocal";
+        internal const string CacheIssuedTokens = "CacheIssuedTokens";
+        internal const string CallbackContract = "CallbackContract";
+        internal const string Channel = "Channel";
+        internal const string ChannelInitializationTimeout = "ChannelInitializationTimeout";
+        internal const string ChannelPoolSettings = "ChannelPoolSettings";
+        internal const string Channels = "OutgoingChannels";
+        internal const string ClientBaseAddress = "ClientBaseAddress";
+        internal const string ClientCertificate = "ClientCertificate";
+        internal const string CloseTimeout = "CloseTimeout";
+        internal const string CompressionFormat = "CompressionFormat";
+        internal const string ConcurrencyMode = "ConcurrencyMode";
+        internal const string ConfigurationName = "ConfigurationName";
+        internal const string ConnectionBufferSize = "ConnectionBufferSize";
+        internal const string ConnectionPoolSettings = "ConnectionPoolSettings";
+        internal const string ContextMode = "ContextMode";
+        internal const string Contract = "Contract";
+        internal const string ContractName = "ContractName";
+        internal const string CounterInstanceName = "CounterInstanceName";
+        internal const string CustomChannelBinding = "CustomChannelBinding";
+        internal const string CustomDeadLetterQueue = "CustomDeadLetterQueue";
+        internal const string CustomServiceNames = "CustomServiceNames";
+        internal const string Custom = "Custom";
+        internal const string DeadLetterQueue = "DeadLetterQueue";
+        internal const string DecompressionEnabled = "DecompressionEnabled";
+        internal const string DefaultAlgorithmSuite = "DefaultAlgorithmSuite";
+        internal const string Description = "Description";
+        internal const string DetectReplays = "DetectReplays";
+        internal const string DistinguishedName = "DistinguishedName";
+        internal const string Durable = "Durable";
+        internal const string GenerateRequestSignatureConfirmation = "GenerateRequestSignatureConfirmation";
+        internal const string EnableKeyDerivation = "EnableKeyDerivation";
+        internal const string EnableUnsecuredResponse = "EnableUnsecuredResponse";
+        internal const string Endpoint = "Endpoint";
+        internal const string EndpointRefs = "EndpointRefs";
+        internal const string Endpoints = "Endpoints";
+        internal const string Encoding = "Encoding";
+        internal const string EnsureOrderedDispatch = "EnsureOrderedDispatch";
+        internal const string ExactlyOnce = "ExactlyOnce";
+        internal const string ExtendedProtectionPolicy = "ExtendedProtectionPolicy";
+        internal const string Extensions = "Extensions";
+        internal const string ExternalMetadataLocation = "ExternalMetadataLocation";
+        internal const string FlowControlEnabled = "FlowControlEnabled";
+        internal const string FullName = "FullName";
+        internal const string GetOperationCounterInstanceName = "GetOperationCounterInstanceName";
+        internal const string GetSupportedAttributes = "GetSupportedAttributes";
+        internal const string GroupName = "GroupName";
+        internal const string HostNameComparisonMode = "HostNameComparisonMode";
+        internal const string HttpDigest = "HttpDigest";
+        internal const string HttpGetEnabled = "HttpGetEnabled";
+        internal const string HttpGetUrl = "HttpGetUrl";
+        internal const string HttpHelpPageUrl = "HttpHelpPageUrl";
+        internal const string HttpHelpPageEnabled = "HttpHelpPageEnabled";
+        internal const string HttpsGetEnabled = "HttpsGetEnabled";
+        internal const string HttpsGetUrl = "HttpsGetUrl";
+        internal const string HttpsHelpPageUrl = "HttpsHelpPageUrl";
+        internal const string HttpsHelpPageEnabled = "HttpsHelpPageEnabled";
+        internal const string Identity = "AddressIdentity";
+        internal const string IdleTimeout = "IdleTimeout";
+        internal const string IgnoreExtensionDataObject = "IgnoreExtensionDataObject";
+        internal const string ImpersonateCallerForAllOperations = "ImpersonateCallerForAllOperations";
+        internal const string ImpersonateOnSerializingReply = "ImpersonateOnSerializingReply";
+        internal const string Impersonation = "Impersonation";
+        internal const string InactivityTimeout = "InactivityTimeout";
+        internal const string IncludeTimestamp = "IncludeTimestamp";
+        internal const string IncludeExceptionDetailInFaults = "IncludeExceptionDetailInFaults";
+        internal const string SupportFaults = "SupportFaults";
+        internal const string IndigoAppName = "ServiceModel";
+        internal const string IndigoNamespace = "root\\ServiceModel";
+        internal const string InitializeData = "initializeData";
+        internal const string InstanceContextMode = "InstanceContextMode";
+        internal const string IsCallback = "IsCallback";
+        internal const string IsDefault = "IsDefault";
+        internal const string IsInitiating = "IsInitiating";
+        internal const string IsOneWay = "IsOneWay";
+        internal const string IssuedCookieLifetime = "IssuedCookieLifetime";
+        internal const string IssuedTokenAuthentication = "IssuedTokenAuthentication";
+        internal const string IssuedToken = "IssuedToken";
+        internal const string IssuedTokenParameters = "IssuedTokenParameters";
+        internal const string IssuedTransitionTokenLifetime = "IssuedTransitionTokenLifetime";
+        internal const string IsTerminating = "IsTerminating";
+        internal const string KeepAliveEnabled = "KeepAliveEnabled";
+        internal const string KeyEntropyMode = "KeyEntropyMode";
+        internal const string LeaseTimeout = "LeaseTimeout";
+        internal const string ListenBacklog = "ListenBacklog";
+        internal const string ListenIPAddress = "ListenIPAddress";
+        internal const string ListenUri = "ListenUri";
+        internal const string LocalAddress = "LocalAddress";
+        internal const string Localhost = "localhost";
+        internal const string LocalServiceSecuritySettings = "LocalServiceSecuritySettings";
+        internal const string LogMalformedMessages = "LogMalformedMessages";
+        internal const string LogMessagesAtServiceLevel = "LogMessagesAtServiceLevel";
+        internal const string LogMessagesAtTransportLevel = "LogMessagesAtTransportLevel";
+        internal const string ManualAddressing = "ManualAddressing";
+        internal const string MaxArrayLength = "MaxArrayLength";
+        internal const string MaxBatchSize = "MaxBatchSize";
+        internal const string MaxBufferPoolSize = "MaxBufferPoolSize";
+        internal const string MaxBufferSize = "MaxBufferSize";
+        internal const string MaxBytesPerRead = "MaxBytesPerRead";
+        internal const string MaxCachedCookies = "MaxCachedCookies";
+        internal const string MaxClockSkew = "MaxClockSkew";
+        internal const string MaxConcurrentCalls = "MaxConcurrentCalls";
+        internal const string MaxConcurrentInstances = "MaxConcurrentInstances";
+        internal const string MaxConcurrentSessions = "MaxConcurrentSessions";
+        internal const string MaxPendingConnections = "MaxPendingConnections";
+        internal const string MaxDepth = "MaxDepth";
+        internal const string MaxPendingSessions = "MaxPendingSessions";
+        internal const string MaxAcceptedChannels = "MaxAcceptedChannels";
+        internal const string MaxItemsInObjectGraph = "MaxItemsInObjectGraph";
+        internal const string MaxReceivedMessageSize = "MaxReceivedMessageSize";
+        internal const string MaxNameTableCharCount = "MaxNameTableCharCount";
+        internal const string MaxOutboundChannelsPerEndpoint = "MaxOutboundChannelsPerEndpoint";
+        internal const string MaxOutboundConnectionsPerEndpoint = "MaxOutboundConnectionsPerEndpoint";
+        internal const string MaxOutputDelay = "MaxOutputDelay";
+        internal const string MaxPendingAccepts = "MaxPendingAccepts";
+        internal const string MaxPendingChannels = "MaxPendingChannels";
+        internal const string MaxReadPoolSize = "MaxReadPoolSize";
+        internal const string MaxPoolSize = "MaxPoolSize";
+        internal const string MaxRetryCount = "MaxRetryCount";
+        internal const string MaxRetryCycles = "MaxRetryCycles";
+        internal const string MaxSessionSize = "MaxSessionSize";
+        internal const string MaxStringContentLength = "MaxStringContentLength";
+        internal const string MaxStatefulNegotiations = "MaxStatefulNegotiations";
+        internal const string MaxTransferWindowSize = "MaxTransferWindowSize";
+        internal const string MaxWritePoolSize = "MaxWritePoolSize";
+        internal const string MessageAuthenticationAuditLevel = "MessageAuthenticationAuditLevel";
+        internal const string MessageLoggingTraceListeners = "MessageLoggingTraceListeners";
+        internal const string MessageProtectionOrder = "MessageProtectionOrder";
+        internal const string MessageSecurityVersion = "MessageSecurityVersion";
+        internal const string MessageVersion = "MessageVersion";
+        internal const string Metadata = "Metadata";
+        internal const string MetadataExporter = "MetadataExporter";
+        internal const string MetadataExportInfo = "MetadataExportInfo";
+        internal const string MethodSignature = "MethodSignature";
+        internal const string MsmqAuthenticationMode = "MsmqAuthenticationMode";
+        internal const string Name = "Name";
+        internal const string NamedPipeConnectionPoolSettings = "NamedPipeConnectionPoolSettings";
+        internal const string Namespace = "Namespace";
+        internal const string NegotiationTimeout = "NegotiationTimeout";
+        internal const string Opened = "Opened";
+        internal const string OpenTimeout = "OpenTimeout";
+        internal const string Operation = "Operation";
+        internal const string Operations = "Operations";
+        internal const string Ordered = "Ordered";
+        internal const string PacketRoutable = "PacketRoutable";
+        internal const string ParameterTypes = "ParameterTypes";
+        internal const string Password = "Password";
+        internal const string Peer = "Peer";
+        internal const string PeerSecurityMode = "Mode";
+        internal const string PeerSecuritySettings = "PeerSecuritySettings";
+        internal const string PeerTransportCredentialType = "CredentialType";
+        internal const string PeerTransportSecuritySettings = "PeerTransportSecuritySettings";
+        internal const string PeerResolver = "Resolver";
+        internal const string PerformanceCounters = "PerformanceCounters";
+        internal const string PolicyEnforcement = "PolicyEnforcement";
+        internal const string PolicyVersion = "PolicyVersion";
+        internal const string Port = "Port";
+        internal const string PortSharingEnabled = "PortSharingEnabled";
+        internal const string PrincipalPermissionMode = "PrincipalPermissionMode";
+        internal const string PrivacyNoticeVersion = "PrivacyNoticeVersion";
+        internal const string ProcessId = "ProcessId";
+        internal const string ProtectionLevel = "ProtectionLevel";
+        internal const string ProtectionScenario = "ProtectionScenario";
+        internal const string ProxyAddress = "ProxyAddress";
+        internal const string ProxyAuthenticationScheme = "ProxyAuthenticationScheme";
+        internal const string QueuedDeliveryRequirements = "QueuedDeliveryRequirements";
+        internal const string QueueTransferProtocol = "QueueTransferProtocol";
+        internal const string ReaderQuotas = "ReaderQuotas";
+        internal const string Realm = "Realm";
+        internal const string ReceiveContextEnabled = "ReceiveContextEnabled";
+        internal const string ReceiveErrorHandling = "ReceiveErrorHandling";
+        internal const string ReceiveRetryCount = "ReceiveRetryCount";
+        internal const string ReceiveTimeout = "ReceiveTimeout";
+        internal const string ReconnectTransportOnFailure = "ReconnectTransportOnFailure";
+        internal const string ReferralPolicy = "ReferralPolicy";
+        internal const string ReleaseInstanceMode = "ReleaseInstanceMode";
+        internal const string ReleaseServiceInstanceOnTransactionComplete = "ReleaseServiceInstanceOnTransactionComplete";
+        internal const string ReliableMessagingVersion = "ReliableMessagingVersion";
+        internal const string RemoteAddress = "RemoteAddress";
+        internal const string RemoteEndpoint = "RemoteEndpoint";
+        internal const string ReplayCacheSize = "ReplayCacheSize";
+        internal const string ReplayWindow = "ReplayWindow";
+        internal const string ReplyAction = "ReplyAction";
+        internal const string RequireClientCertificate = "RequireClientCertificate";
+        internal const string RequireOrderedDelivery = "RequireOrderedDelivery";
+        internal const string RequireSignatureConfirmation = "RequireSignatureConfirmation";
+        internal const string RequirementsMode = "RequirementsMode";
+        internal const string ResolverMode = "Mode";
+        internal const string RetryCycleDelay = "RetryCycleDelay";
+        internal const string ReturnType = "ReturnType";
+        internal const string RoleProvider = "RoleProvider";
+        internal const string Scheme = "Scheme";
+        internal const string SecureConversationAuthentication = "SecureConversationAuthentication";
+        internal const string SecurityHeaderLayout = "SecurityHeaderLayout";
+        internal const string Security = "Security";
+        internal const string SecurityMode = "SecurityMode";
+        internal const string SecurityStateEncoder = "SecurityStateEncoder";
+        internal const string SendTimeout = "SendTimeout";
+        internal const string SerializationFormat = "SerializationFormat";
+        internal const string Service = "Service";
+        internal const string ServiceAdmin = "ServiceAdmin";
+        internal const string ServiceAppDomain = "ServiceAppDomain";
+        internal const string ServiceAuthorizationAuditLevel = "ServiceAuthorizationAuditLevel";
+        internal const string ServiceAuthorizationManager = "ServiceAuthorizationManager";
+        internal const string ServiceCertificate = "ServiceCertificate";
+        internal const string ServiceConfigPath = "ServiceConfigPath";
+        internal const string ServiceModelTraceListeners = "ServiceModelTraceListeners";
+        internal const string ServiceToEndpointAssociation = "ServiceToEndpointAssociation";
+        internal const string ServiceType = "ServiceType";
+        internal const string SessionMode = "SessionMode";
+        internal const string SessionId = "SessionId";
+        internal const string SessionKeyRenewalInterval = "SessionKeyRenewalInterval";
+        internal const string SessionKeyRolloverInterval = "SessionKeyRolloverInterval";
+        internal const string Style = "Style";
+        internal const string SupportInteractive = "SupportInteractive";
+        internal const string SuppressAuditFailure = "SuppressAuditFailure";
+        internal const string TargetContract = "TargetContract";
+        internal const string TcpConnectionPoolSettings = "TcpConnectionPoolSettings";
+        internal const string TeredoEnabled = "TeredoEnabled";
+        internal const string TimestampValidityDuration = "TimestampValidityDuration";
+        internal const string TimeToLive = "TimeToLive";
+        internal const string TraceLevel = "TraceLevel";
+        internal const string TraceListener = "TraceListener";
+        internal const string TraceListenerArgument = "TraceListenerArgument";
+        internal const string TraceListenerArguments = "TraceListenerArguments";
+        internal const string Transport = "Transport";
+        internal const string TransactionAutoComplete = "TransactionAutoComplete";
+        internal const string TransactionAutoCompleteOnSessionClose = "TransactionAutoCompleteOnSessionClose";
+        internal const string TransactionFlowOption = "TransactionFlowOption";
+        internal const string TransactionIsolationLevel = "TransactionIsolationLevel";
+        internal const string TransactionProtocol = "TransactionProtocol";
+        internal const string TransactionFlow = "TransactionFlow";
+        internal const string AllowWildcardAction = "AllowWildcardAction";
+        internal const string TransactionScopeRequired = "TransactionScopeRequired";
+        internal const string TransactionTimeout = "TransactionTimeout";
+        internal const string TransferMode = "TransferMode";
+        internal const string Type = "Type";
+        internal const string UnsafeConnectionNtlmAuthentication = "UnsafeConnectionNtlmAuthentication";
+        internal const string Url = "Url";
+        internal const string Uri = "Uri";
+        internal const string Use = "Use";
+        internal const string UseActiveDirectory = "UseActiveDirectory";
+        internal const string UseDefaultWebProxy = "UseDefaultWebProxy";
+        internal const string UseMsmqTracing = "UseMsmqTracing";
+        internal const string UserName = "UserName";
+        internal const string UserNameAuthentication = "UserNameAuthentication";
+        internal const string UseSourceJournal = "UseSourceJournal";
+        internal const string UseSynchronizationContext = "UseSynchronizationContext";
+        internal const string ValidateMustUnderstand = "ValidateMustUnderstand";
+        internal const string ValidationMode = "ValidationMode";
+        internal const string ValidityDuration = "ValidityDuration";
+        internal const string Value = "Value";
+        internal const string VirtualPath = "VirtualPath";
+        internal const string WindowsAuthentication = "WindowsAuthentication";
+        internal const string Windows = "Windows";
+        internal const string XmlDictionaryReaderQuotas = "XmlDictionaryReaderQuotas";
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/AppDomainInfo.cs

@@ -0,0 +1,114 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Diagnostics;
+    using System.Runtime;
+
+    sealed class AppDomainInfo
+    {
+        static object syncRoot = new object();
+        
+        // Double-checked locking pattern requires volatile for read/write synchronization
+        static volatile AppDomainInfo singleton;
+        Guid instanceId;
+        string friendlyName;
+        bool isDefaultAppDomain;
+        string processName;
+        string machineName;
+        int processId;
+        int id;
+
+        AppDomainInfo(AppDomain appDomain)
+        {
+            // Assumption: Only one AppDomainInfo is created per AppDomain
+            Fx.Assert(null != appDomain, "");
+            this.instanceId = Guid.NewGuid();
+            this.friendlyName = appDomain.FriendlyName;
+            this.isDefaultAppDomain = appDomain.IsDefaultAppDomain();
+            Process process = Process.GetCurrentProcess();
+            this.processName = process.ProcessName;
+            this.machineName = Environment.MachineName;
+            this.processId = process.Id;
+            this.id = appDomain.Id;
+
+        }
+
+        public int Id
+        {
+            get
+            {
+                return this.id;
+            }
+        }
+
+        public Guid InstanceId
+        {
+            get
+            {
+                return this.instanceId;
+            }
+        }
+
+        public string MachineName
+        {
+            get
+            {
+                return this.machineName;
+            }
+        }
+
+        public string Name
+        {
+            get
+            {
+                return this.friendlyName;
+            }
+        }
+
+        public bool IsDefaultAppDomain
+        {
+            get
+            {
+                return this.isDefaultAppDomain;
+            }
+        }
+
+        public int ProcessId
+        {
+            get
+            {
+                return this.processId;
+            }
+        }
+
+        public string ProcessName
+        {
+            get
+            {
+                return this.processName;
+            }
+        }
+
+        internal static AppDomainInfo Current
+        {
+            get
+            {
+                if (null == singleton)
+                {
+                    lock (AppDomainInfo.syncRoot)
+                    {
+                        if (null == singleton)
+                        {
+                            singleton = new AppDomainInfo(AppDomain.CurrentDomain);
+                        }
+                    }
+                }
+                return singleton;
+            }
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/AppDomainInstanceProvider.cs

@@ -0,0 +1,205 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Reflection;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Diagnostics;
+    using System.ServiceModel.Activation;
+    using System.Security;
+    using System.Security.Permissions;
+
+    class AppDomainInstanceProvider : ProviderBase, IWmiProvider
+    {
+        void IWmiProvider.EnumInstances(IWmiInstances instances)
+        {
+            Fx.Assert(null != instances, "");
+            IWmiInstance instance = instances.NewInstance(null);
+            FillAppDomainInfo(instance);
+            instances.AddInstance(instance);
+        }
+
+        bool IWmiProvider.GetInstance(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            bool bFound = false;
+            if ((int)instance.GetProperty(AdministrationStrings.ProcessId) == AppDomainInfo.Current.ProcessId
+                && String.Equals((string)instance.GetProperty(AdministrationStrings.Name), AppDomainInfo.Current.Name, StringComparison.Ordinal))
+            {
+                FillAppDomainInfo(instance);
+                bFound = true;
+            }
+
+            return bFound;
+        }
+
+        internal static string GetReference()
+        {
+            return String.Format(CultureInfo.InvariantCulture, AdministrationStrings.AppDomainInfo +
+                                    "." +
+                                    AdministrationStrings.AppDomainId +
+                                    "={0}," +
+                                    AdministrationStrings.Name +
+                                    "='{1}'," +
+                                    AdministrationStrings.ProcessId +
+                                    "={2}",
+                               AppDomainInfo.Current.Id,
+                               AppDomainInfo.Current.Name,
+                               AppDomainInfo.Current.ProcessId);
+        }
+
+        internal static void FillAppDomainInfo(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            AppDomainInfo domainInfo = AppDomainInfo.Current;
+            instance.SetProperty(AdministrationStrings.Name, domainInfo.Name);
+            instance.SetProperty(AdministrationStrings.AppDomainId, domainInfo.Id);
+            instance.SetProperty(AdministrationStrings.PerformanceCounters, PerformanceCounters.Scope.ToString());
+            instance.SetProperty(AdministrationStrings.IsDefault, domainInfo.IsDefaultAppDomain);
+            instance.SetProperty(AdministrationStrings.ProcessId, domainInfo.ProcessId);
+            instance.SetProperty(AdministrationStrings.TraceLevel, DiagnosticUtility.Level.ToString());
+            instance.SetProperty(AdministrationStrings.LogMalformedMessages, MessageLogger.LogMalformedMessages);
+            instance.SetProperty(AdministrationStrings.LogMessagesAtServiceLevel, MessageLogger.LogMessagesAtServiceLevel);
+            instance.SetProperty(AdministrationStrings.LogMessagesAtTransportLevel, MessageLogger.LogMessagesAtTransportLevel);
+            instance.SetProperty(AdministrationStrings.ServiceConfigPath, AspNetEnvironment.Current.ConfigurationPath);
+            FillListenersInfo(instance);
+        }
+
+        static IWmiInstance[] CreateListenersInfo(TraceSource traceSource, IWmiInstance instance)
+        {
+            Fx.Assert(null != traceSource, "");
+            Fx.Assert(null != instance, "");
+
+            IWmiInstance[] traceListeners = new IWmiInstance[traceSource.Listeners.Count];
+
+            for (int i = 0; i < traceSource.Listeners.Count; i++)
+            {
+                TraceListener traceListener = traceSource.Listeners[i];
+                IWmiInstance traceListenerWmiInstance = instance.NewInstance(AdministrationStrings.TraceListener);
+                traceListenerWmiInstance.SetProperty(AdministrationStrings.Name, traceListener.Name);
+                List<IWmiInstance> traceListenerArguments = new List<IWmiInstance>(1);
+
+                Type type = traceListener.GetType();
+                string initializeData = (string)type.InvokeMember(AdministrationStrings.InitializeData, BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance, null, traceListener, null, CultureInfo.InvariantCulture);
+                string[] supportedAttributes = (string[])type.InvokeMember(AdministrationStrings.GetSupportedAttributes, BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, traceListener, null, CultureInfo.InvariantCulture);
+
+                IWmiInstance argumentWmiInstance = instance.NewInstance(AdministrationStrings.TraceListenerArgument);
+                argumentWmiInstance.SetProperty(AdministrationStrings.Name, AdministrationStrings.InitializeData);
+                argumentWmiInstance.SetProperty(AdministrationStrings.Value, initializeData);
+                traceListenerArguments.Add(argumentWmiInstance);
+
+                if (null != supportedAttributes)
+                {
+                    foreach (string attribute in supportedAttributes)
+                    {
+                        argumentWmiInstance = instance.NewInstance(AdministrationStrings.TraceListenerArgument);
+                        argumentWmiInstance.SetProperty(AdministrationStrings.Name, attribute);
+                        argumentWmiInstance.SetProperty(AdministrationStrings.Value, traceListener.Attributes[attribute]);
+                        traceListenerArguments.Add(argumentWmiInstance);
+                    }
+                }
+                traceListenerWmiInstance.SetProperty(AdministrationStrings.TraceListenerArguments, traceListenerArguments.ToArray());
+                traceListeners[i] = traceListenerWmiInstance;
+            }
+
+            return traceListeners;
+        }
+
+        static void FillListenersInfo(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            TraceSource traceSource = DiagnosticUtility.DiagnosticTrace == null ? null : DiagnosticUtility.DiagnosticTrace.TraceSource;
+            if (null != traceSource)
+            {
+                instance.SetProperty(AdministrationStrings.ServiceModelTraceListeners, CreateListenersInfo(traceSource, instance));
+            }
+            traceSource = MessageLogger.MessageTraceSource;
+            if (null != traceSource)
+            {
+                instance.SetProperty(AdministrationStrings.MessageLoggingTraceListeners, CreateListenersInfo(traceSource, instance));
+            }
+        }
+
+        [Fx.Tag.SecurityNote(Critical = "Critical because we are setting DiagnosticUtility.Level.",
+            Safe = "Demands UnmanagedCode permission to set the Trace level")]
+        [SecurityPermission(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+        [SecuritySafeCritical]
+        bool IWmiProvider.PutInstance(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            bool bFound = false;
+            if ((int)instance.GetProperty(AdministrationStrings.ProcessId) == AppDomainInfo.Current.ProcessId
+                && String.Equals((string)instance.GetProperty(AdministrationStrings.Name), AppDomainInfo.Current.Name, StringComparison.Ordinal))
+            {
+                try
+                {
+                    SourceLevels newLevel = (SourceLevels)Enum.Parse(typeof(SourceLevels), (string)instance.GetProperty(AdministrationStrings.TraceLevel));
+                    if (DiagnosticUtility.Level != newLevel)
+                    {
+                        if (DiagnosticUtility.ShouldTraceVerbose)
+                        {
+                            TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.WmiPut, SR.GetString(SR.TraceCodeWmiPut),
+                                new WmiPutTraceRecord("DiagnosticTrace.Level",
+                                DiagnosticUtility.Level,
+                                newLevel), instance, null);
+                        }
+                        DiagnosticUtility.Level = newLevel;
+                    }
+
+                    bool logMalformedMessages = (bool)instance.GetProperty(AdministrationStrings.LogMalformedMessages);
+                    if (MessageLogger.LogMalformedMessages != logMalformedMessages)
+                    {
+                        if (DiagnosticUtility.ShouldTraceVerbose)
+                        {
+                            TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.WmiPut, SR.GetString(SR.TraceCodeWmiPut),
+                                new WmiPutTraceRecord("MessageLogger.LogMalformedMessages",
+                                MessageLogger.LogMalformedMessages,
+                                logMalformedMessages), instance, null);
+                        }
+                        MessageLogger.LogMalformedMessages = logMalformedMessages;
+                    }
+
+                    bool logMessagesAtServiceLevel = (bool)instance.GetProperty(AdministrationStrings.LogMessagesAtServiceLevel);
+                    if (MessageLogger.LogMessagesAtServiceLevel != logMessagesAtServiceLevel)
+                    {
+                        if (DiagnosticUtility.ShouldTraceVerbose)
+                        {
+                            TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.WmiPut, SR.GetString(SR.TraceCodeWmiPut),
+                                new WmiPutTraceRecord("MessageLogger.LogMessagesAtServiceLevel",
+                                MessageLogger.LogMessagesAtServiceLevel,
+                                logMessagesAtServiceLevel), instance, null);
+                        }
+                        MessageLogger.LogMessagesAtServiceLevel = logMessagesAtServiceLevel;
+                    }
+
+                    bool logMessagesAtTransportLevel = (bool)instance.GetProperty(AdministrationStrings.LogMessagesAtTransportLevel);
+                    if (MessageLogger.LogMessagesAtTransportLevel != logMessagesAtTransportLevel)
+                    {
+                        if (DiagnosticUtility.ShouldTraceVerbose)
+                        {
+                            TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.WmiPut, SR.GetString(SR.TraceCodeWmiPut),
+                                new WmiPutTraceRecord("MessageLogger.LogMessagesAtTransportLevel",
+                                MessageLogger.LogMessagesAtTransportLevel,
+                                logMessagesAtTransportLevel), instance, null);
+                        }
+                        MessageLogger.LogMessagesAtTransportLevel = logMessagesAtTransportLevel;
+                    }
+                }
+                catch (ArgumentException)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemInvalidParameterException());
+                }
+                bFound = true;
+            }
+
+            return bFound;
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ContractInstanceProvider.cs

@@ -0,0 +1,289 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Reflection;
+    using System.Runtime;
+    using System.ServiceModel.Channels;
+    using System.ServiceModel.Description;
+
+    class ContractInstanceProvider : ProviderBase, IWmiProvider
+    {
+        static Dictionary<string, ContractDescription> knownContracts = new Dictionary<string, ContractDescription>();
+
+        internal static string ContractReference(string contractName)
+        {
+            return String.Format(CultureInfo.InvariantCulture,
+                                 AdministrationStrings.Contract +
+                                        "." +
+                                        AdministrationStrings.Name +
+                                        "='{0}'," +
+                                        AdministrationStrings.ProcessId +
+                                        "={1}," +
+                                        AdministrationStrings.AppDomainId +
+                                        "={2}",
+                                contractName,
+                                AppDomainInfo.Current.ProcessId,
+                                AppDomainInfo.Current.Id);
+        }
+
+        internal static void RegisterContract(ContractDescription contract)
+        {
+            lock (ContractInstanceProvider.knownContracts)
+            {
+                if (!ContractInstanceProvider.knownContracts.ContainsKey(contract.Name))
+                {
+                    ContractInstanceProvider.knownContracts.Add(contract.Name, contract);
+                }
+            }
+        }
+
+        static void FillContract(IWmiInstance contract, ContractDescription contractDescription)
+        {
+            Fx.Assert(null != contractDescription, "contractDescription cannot be null");
+            contract.SetProperty(AdministrationStrings.Type, contractDescription.ContractType.Name);
+            if (null != contractDescription.CallbackContractType)
+            {
+                contract.SetProperty(AdministrationStrings.CallbackContract, ContractReference(contractDescription.CallbackContractType.Name));
+            }
+
+            contract.SetProperty(AdministrationStrings.Name, contractDescription.Name);
+            contract.SetProperty(AdministrationStrings.Namespace, contractDescription.Namespace);
+            contract.SetProperty(AdministrationStrings.SessionMode, contractDescription.SessionMode.ToString());
+
+            IWmiInstance[] operations = new IWmiInstance[contractDescription.Operations.Count];
+            for (int j = 0; j < operations.Length; ++j)
+            {
+                OperationDescription operationDescription = contractDescription.Operations[j];
+                Fx.Assert(operationDescription.Messages.Count > 0, "");
+                IWmiInstance operation = contract.NewInstance(AdministrationStrings.Operation);
+                FillOperation(operation, operationDescription);
+                operations[j] = operation;
+
+            }
+            contract.SetProperty(AdministrationStrings.Operations, operations);
+            FillBehaviorsInfo(contract, contractDescription.Behaviors);
+        }
+
+        static void FillOperation(IWmiInstance operation, OperationDescription operationDescription)
+        {
+            operation.SetProperty(AdministrationStrings.Name, operationDescription.Name);
+            operation.SetProperty(AdministrationStrings.Action, FixWildcardAction(operationDescription.Messages[0].Action));
+            if (operationDescription.Messages.Count > 1)
+            {
+                operation.SetProperty(AdministrationStrings.ReplyAction, FixWildcardAction(operationDescription.Messages[1].Action));
+            }
+            operation.SetProperty(AdministrationStrings.IsOneWay, operationDescription.IsOneWay);
+            operation.SetProperty(AdministrationStrings.IsInitiating, operationDescription.IsInitiating);
+            operation.SetProperty(AdministrationStrings.IsTerminating, operationDescription.IsTerminating);
+            operation.SetProperty(AdministrationStrings.AsyncPattern, null != operationDescription.BeginMethod);
+            if (null != operationDescription.SyncMethod)
+            {
+                if (null != operationDescription.SyncMethod.ReturnType)
+                {
+                    operation.SetProperty(AdministrationStrings.ReturnType, operationDescription.SyncMethod.ReturnType.Name);
+                }
+                operation.SetProperty(AdministrationStrings.MethodSignature, operationDescription.SyncMethod.ToString());
+                ParameterInfo[] parameterInfo = operationDescription.SyncMethod.GetParameters();
+                string[] parameterTypes = new string[parameterInfo.Length];
+                for (int i = 0; i < parameterInfo.Length; i++)
+                {
+                    parameterTypes[i] = parameterInfo[i].ParameterType.ToString();
+                }
+                operation.SetProperty(AdministrationStrings.ParameterTypes, parameterTypes);
+            }
+            operation.SetProperty(AdministrationStrings.IsCallback, operationDescription.Messages[0].Direction == MessageDirection.Output);
+
+            FillBehaviorsInfo(operation, operationDescription.Behaviors);
+
+        }
+
+        static void FillBehaviorsInfo(IWmiInstance operation, KeyedByTypeCollection<IOperationBehavior> behaviors)
+        {
+            List<IWmiInstance> behaviorInstances = new List<IWmiInstance>(behaviors.Count);
+            foreach (IOperationBehavior behavior in behaviors)
+            {
+                IWmiInstance behaviorInstance;
+                FillBehaviorInfo(behavior, operation, out behaviorInstance);
+                if (null != behaviorInstance)
+                {
+                    behaviorInstances.Add(behaviorInstance);
+                }
+            }
+            operation.SetProperty(AdministrationStrings.Behaviors, behaviorInstances.ToArray());
+        }
+
+        static void FillBehaviorsInfo(IWmiInstance operation, KeyedByTypeCollection<IContractBehavior> behaviors)
+        {
+            List<IWmiInstance> behaviorInstances = new List<IWmiInstance>(behaviors.Count);
+            foreach (IContractBehavior behavior in behaviors)
+            {
+                IWmiInstance behaviorInstance;
+                FillBehaviorInfo(behavior, operation, out behaviorInstance);
+                if (null != behaviorInstance)
+                {
+                    behaviorInstances.Add(behaviorInstance);
+                }
+            }
+            operation.SetProperty(AdministrationStrings.Behaviors, behaviorInstances.ToArray());
+        }
+
+        static void FillBehaviorInfo(IContractBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
+        {
+            Fx.Assert(null != existingInstance, "");
+            Fx.Assert(null != behavior, "");
+            instance = null;
+            if (behavior is DeliveryRequirementsAttribute)
+            {
+                instance = existingInstance.NewInstance("DeliveryRequirementsAttribute");
+                DeliveryRequirementsAttribute specificBehavior = (DeliveryRequirementsAttribute)behavior;
+                instance.SetProperty(AdministrationStrings.QueuedDeliveryRequirements, specificBehavior.QueuedDeliveryRequirements.ToString());
+                instance.SetProperty(AdministrationStrings.RequireOrderedDelivery, specificBehavior.RequireOrderedDelivery);
+                if (null != specificBehavior.TargetContract)
+                {
+                    instance.SetProperty(AdministrationStrings.TargetContract, specificBehavior.TargetContract.ToString());
+                }
+            }
+            else if (behavior is IWmiInstanceProvider)
+            {
+                IWmiInstanceProvider instanceProvider = (IWmiInstanceProvider)behavior;
+                instance = existingInstance.NewInstance(instanceProvider.GetInstanceType());
+                instanceProvider.FillInstance(instance);
+            }
+            else
+            {
+                instance = existingInstance.NewInstance("Behavior");
+            }
+            if (null != instance)
+            {
+                instance.SetProperty(AdministrationStrings.Type, behavior.GetType().FullName);
+            }
+        }
+
+        static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
+        {
+            Fx.Assert(null != existingInstance, "");
+            Fx.Assert(null != behavior, "");
+            instance = null;
+            if (behavior is DataContractSerializerOperationBehavior)
+            {
+                instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior");
+                DataContractSerializerOperationBehavior specificBehavior = (DataContractSerializerOperationBehavior)behavior;
+                instance.SetProperty(AdministrationStrings.IgnoreExtensionDataObject, specificBehavior.IgnoreExtensionDataObject);
+                instance.SetProperty(AdministrationStrings.MaxItemsInObjectGraph, specificBehavior.MaxItemsInObjectGraph);
+                if (null != specificBehavior.DataContractFormatAttribute)
+                {
+                    instance.SetProperty(AdministrationStrings.Style, specificBehavior.DataContractFormatAttribute.Style.ToString());
+                }
+            }
+            else if (behavior is OperationBehaviorAttribute)
+            {
+                instance = existingInstance.NewInstance("OperationBehaviorAttribute");
+                OperationBehaviorAttribute specificBehavior = (OperationBehaviorAttribute)behavior;
+                instance.SetProperty(AdministrationStrings.AutoDisposeParameters, specificBehavior.AutoDisposeParameters);
+                instance.SetProperty(AdministrationStrings.Impersonation, specificBehavior.Impersonation.ToString());
+                instance.SetProperty(AdministrationStrings.ReleaseInstanceMode, specificBehavior.ReleaseInstanceMode.ToString());
+                instance.SetProperty(AdministrationStrings.TransactionAutoComplete, specificBehavior.TransactionAutoComplete);
+                instance.SetProperty(AdministrationStrings.TransactionScopeRequired, specificBehavior.TransactionScopeRequired);
+            }
+            else if (behavior is TransactionFlowAttribute)
+            {
+                instance = existingInstance.NewInstance("TransactionFlowAttribute");
+                TransactionFlowAttribute specificBehavior = (TransactionFlowAttribute)behavior;
+                instance.SetProperty(AdministrationStrings.TransactionFlowOption, specificBehavior.Transactions.ToString());
+            }
+            else if (behavior is XmlSerializerOperationBehavior)
+            {
+                instance = existingInstance.NewInstance("XmlSerializerOperationBehavior");
+                XmlSerializerOperationBehavior specificBehavior = (XmlSerializerOperationBehavior)behavior;
+                if (null != specificBehavior.XmlSerializerFormatAttribute)
+                {
+                    instance.SetProperty(AdministrationStrings.Style, specificBehavior.XmlSerializerFormatAttribute.Style.ToString());
+                    instance.SetProperty(AdministrationStrings.Use, specificBehavior.XmlSerializerFormatAttribute.Use.ToString());
+                    instance.SetProperty(AdministrationStrings.SupportFaults, specificBehavior.XmlSerializerFormatAttribute.SupportFaults.ToString());
+                }
+            }
+            else if (behavior is IWmiInstanceProvider)
+            {
+                IWmiInstanceProvider instanceProvider = (IWmiInstanceProvider)behavior;
+                instance = existingInstance.NewInstance(instanceProvider.GetInstanceType());
+                instanceProvider.FillInstance(instance);
+            }
+            else
+            {
+                instance = existingInstance.NewInstance("Behavior");
+            }
+            if (null != instance)
+            {
+                instance.SetProperty(AdministrationStrings.Type, behavior.GetType().FullName);
+            }
+        }
+
+        static string FixWildcardAction(string action)
+        {
+#pragma warning suppress 56507
+            return null != action ? action : MessageHeaders.WildcardAction;
+        }
+
+        static void UpdateContracts()
+        {
+            foreach (ServiceInfo info in new ServiceInfoCollection(ManagementExtension.Services))
+            {
+                foreach (EndpointInfo endpointInfo in info.Endpoints)
+                {
+                    ContractInstanceProvider.RegisterContract(endpointInfo.Contract);
+                }
+            }
+        }
+
+        void IWmiProvider.EnumInstances(IWmiInstances instances)
+        {
+            Fx.Assert(null != instances, "");
+            int processId = AppDomainInfo.Current.ProcessId;
+            int appDomainId = AppDomainInfo.Current.Id;
+            lock (ContractInstanceProvider.knownContracts)
+            {
+                UpdateContracts();
+                foreach (ContractDescription contract in ContractInstanceProvider.knownContracts.Values)
+                {
+                    IWmiInstance instance = instances.NewInstance(null);
+
+                    instance.SetProperty(AdministrationStrings.ProcessId, processId);
+                    instance.SetProperty(AdministrationStrings.AppDomainId, appDomainId);
+
+                    FillContract(instance, contract);
+
+                    instances.AddInstance(instance);
+                }
+            }
+
+        }
+
+        bool IWmiProvider.GetInstance(IWmiInstance contract)
+        {
+            Fx.Assert(null != contract, "");
+            bool bFound = false;
+            if ((int)contract.GetProperty(AdministrationStrings.ProcessId) == AppDomainInfo.Current.ProcessId
+                && (int)contract.GetProperty(AdministrationStrings.AppDomainId) == AppDomainInfo.Current.Id)
+            {
+                string contractName = (string)contract.GetProperty(AdministrationStrings.Name);
+
+                ContractDescription contractDescription;
+                UpdateContracts();
+                if (ContractInstanceProvider.knownContracts.TryGetValue(contractName, out contractDescription))
+                {
+                    bFound = true;
+                    FillContract(contract, contractDescription);
+                }
+            }
+
+            return bFound;
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/EndpointInfo.cs

@@ -0,0 +1,96 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Channels;
+    using System.ServiceModel.Description;
+
+    sealed class EndpointInfo
+    {
+        Uri address;
+        KeyedByTypeCollection<IEndpointBehavior> behaviors;
+        EndpointIdentity identity;
+        AddressHeaderCollection headers;
+        CustomBinding binding;
+        ContractDescription contract;
+        ServiceEndpoint endpoint;
+        string serviceName;
+
+        internal EndpointInfo(ServiceEndpoint endpoint, string serviceName)
+        {
+            Fx.Assert(null != endpoint, "endpoint cannot be null");
+
+            this.endpoint = endpoint;
+            this.address = endpoint.Address.Uri;
+            this.headers = endpoint.Address.Headers;
+            this.identity = endpoint.Address.Identity;
+            this.behaviors = endpoint.Behaviors;
+            this.serviceName = serviceName;
+
+            this.binding = null == endpoint.Binding ? new CustomBinding() : new CustomBinding(endpoint.Binding);
+            this.contract = endpoint.Contract;
+        }
+
+        public Uri Address
+        {
+            get { return this.address; }
+        }
+
+        public Uri ListenUri
+        {
+            get { return null != this.Endpoint.ListenUri ? this.Endpoint.ListenUri : this.Address; }
+        }
+
+        public KeyedByTypeCollection<IEndpointBehavior> Behaviors
+        {
+            get
+            {
+                return this.behaviors;
+            }
+        }
+
+        public ContractDescription Contract
+        {
+            get { return this.contract; }
+        }
+
+        public CustomBinding Binding
+        {
+            get { return this.binding; }
+        }
+
+        public ServiceEndpoint Endpoint
+        {
+            get { return this.endpoint; }
+        }
+
+        public AddressHeaderCollection Headers
+        {
+            get { return this.headers; }
+        }
+
+        public EndpointIdentity Identity
+        {
+            get { return this.identity; }
+        }
+
+        public string Name
+        {
+            get
+            {
+                return this.ServiceName + "." + this.Contract.Name + "@" + this.Address.AbsoluteUri;
+            }
+        }
+
+        public string ServiceName
+        {
+            get { return this.serviceName; }
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/EndpointInfoCollection.cs

@@ -0,0 +1,23 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.ServiceModel.Description;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.Runtime.Serialization;
+
+    internal sealed class EndpointInfoCollection : Collection<EndpointInfo>
+    {
+        internal EndpointInfoCollection(ServiceEndpointCollection endpoints, string serviceName)
+        {
+            for (int i = 0; i < endpoints.Count; ++i)
+            {
+                base.Add(new EndpointInfo(endpoints[i], serviceName));
+            }
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ManagementExtension.cs

@@ -0,0 +1,128 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//-----------------------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime;
+    using System.Security;
+    using System.ServiceModel;
+    using System.ServiceModel.Configuration;
+
+    sealed class ManagementExtension
+    {
+        static Dictionary<ServiceHostBase, DateTime> services;
+        static bool activated = false;
+        static object syncRoot = new object();
+        static bool isEnabled = GetIsWmiProviderEnabled();
+
+        internal static bool IsActivated
+        {
+            get { return ManagementExtension.activated; }
+        }
+
+        internal static bool IsEnabled
+        {
+            get { return ManagementExtension.isEnabled; }
+        }
+
+        [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.",
+            Safe = "Doesn't leak config section instance, just returns a bool.")]
+        [SecuritySafeCritical]
+        static bool GetIsWmiProviderEnabled()
+        {
+            return DiagnosticSection.UnsafeGetSection().WmiProviderEnabled;
+        }
+
+        static Dictionary<ServiceHostBase, DateTime> GetServices()
+        {
+            if (ManagementExtension.services == null)
+            {
+                lock (ManagementExtension.syncRoot)
+                {
+                    if (ManagementExtension.services == null)
+                    {
+                        ManagementExtension.services = new Dictionary<ServiceHostBase, DateTime>();
+                    }
+                }
+            }
+            return ManagementExtension.services;
+        }
+
+        internal static ICollection<ServiceHostBase> Services
+        {
+            get
+            {
+                return GetServices().Keys;
+            }
+        }
+
+        internal static DateTime GetTimeOpened(ServiceHostBase service)
+        {
+            return GetServices()[service];
+        }
+
+        public static void OnServiceOpened(ServiceHostBase serviceHostBase)
+        {
+            EnsureManagementProvider();
+            Add(serviceHostBase);
+        }
+
+        public static void OnServiceClosing(ServiceHostBase serviceHostBase)
+        {
+            Remove(serviceHostBase);
+        }
+
+        static void Add(ServiceHostBase service)
+        {
+            Dictionary<ServiceHostBase, DateTime> services = GetServices();
+            lock (services)
+            {
+                if (!services.ContainsKey(service))
+                {
+                    services.Add(service, DateTime.Now);
+                }
+            }
+        }
+
+        static void Remove(ServiceHostBase service)
+        {
+            Dictionary<ServiceHostBase, DateTime> services = GetServices();
+            lock (services)
+            {
+                if (services.ContainsKey(service))
+                {
+                    services.Remove(service);
+                }
+            }
+        }
+
+        static void EnsureManagementProvider()
+        {
+            if (!ManagementExtension.activated)
+            {
+                lock (ManagementExtension.syncRoot)
+                {
+                    if (!ManagementExtension.activated)
+                    {
+                        Activate();
+                        ManagementExtension.activated = true;
+                    }
+                }
+            }
+        }
+
+        static void Activate()
+        {
+            WbemProvider wmi = new WbemProvider(AdministrationStrings.IndigoNamespace, AdministrationStrings.IndigoAppName);
+            wmi.Register(AdministrationStrings.AppDomainInfo, new AppDomainInstanceProvider());
+            wmi.Register(AdministrationStrings.Service, new ServiceInstanceProvider());
+            wmi.Register(AdministrationStrings.Contract, new ContractInstanceProvider());
+            wmi.Register(AdministrationStrings.Endpoint, new EndpointInstanceProvider());
+            wmi.Register(AdministrationStrings.ServiceAppDomain, new ServiceAppDomainAssociationProvider());
+            wmi.Register(AdministrationStrings.ServiceToEndpointAssociation, new ServiceEndpointAssociationProvider());
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ProviderBase.cs

@@ -0,0 +1,79 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System.Collections;
+    using System.Runtime;
+
+    abstract class ProviderBase : IWmiProvider
+    {
+        public static void FillCollectionInfo(ICollection info, IWmiInstance instance, string propertyName)
+        {
+            Fx.Assert(null != info, "");
+            Fx.Assert(null != instance, "");
+//warning 56507 : Prefer 'string.IsNullOrEmpty(action)' over checks for null and/or emptiness.
+#pragma warning suppress 56507 //[....]; Asserting non-null object for marshalling reasons.  Empty string may be valid input.
+            Fx.Assert(null != propertyName, "");
+
+            string[] data = new string[info.Count];
+            int i = 0;
+            foreach (object o in info)
+            {
+                data[i++] = o.ToString();
+            }
+            instance.SetProperty(propertyName, data);
+        }
+
+        public static void FillCollectionInfo(IEnumerable info, IWmiInstance instance, string propertyName)
+        {
+            Fx.Assert(null != info, "");
+            Fx.Assert(null != instance, "");
+//warning 56507 : Prefer 'string.IsNullOrEmpty(action)' over checks for null and/or emptiness.
+#pragma warning suppress 56507 //[....]; Asserting non-null object for marshalling reasons.  Empty string may be valid input.
+            Fx.Assert(null != propertyName, "");
+
+            int i = 0;
+            foreach (object o in info)
+            {
+                i++;
+            }
+            
+            string[] data = new string[i];
+
+            i = 0;
+            foreach (object o in info)
+            {
+                data[i++] = o.ToString();
+            }
+            instance.SetProperty(propertyName, data);
+        }
+
+        void IWmiProvider.EnumInstances(IWmiInstances instances)
+        {
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemNotSupportedException());
+        }
+
+        bool IWmiProvider.GetInstance(IWmiInstance contract)
+        {
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemNotSupportedException());
+        }
+
+        bool IWmiProvider.PutInstance(IWmiInstance instance)
+        {
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemNotSupportedException());
+        }
+
+        bool IWmiProvider.DeleteInstance(IWmiInstance instance)
+        {
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemNotSupportedException());
+        }
+
+        bool IWmiProvider.InvokeMethod(IWmiMethodContext method)
+        {
+            method.ReturnParameter = 0;
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemNotSupportedException());
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ServiceAppDomainAssociationProvider.cs

@@ -0,0 +1,35 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Runtime;
+
+    class ServiceAppDomainAssociationProvider : ProviderBase, IWmiProvider
+    {
+        void IWmiProvider.EnumInstances(IWmiInstances instances)
+        {
+            Fx.Assert(null != instances, "");
+            foreach (ServiceInfo info in new ServiceInfoCollection(ManagementExtension.Services))
+            {
+                IWmiInstance instance = instances.NewInstance(null);
+
+                instance.SetProperty(AdministrationStrings.AppDomainInfo, AppDomainInstanceProvider.GetReference());
+                instance.SetProperty(AdministrationStrings.Service, ServiceInstanceProvider.GetReference(info));
+
+                instances.AddInstance(instance);
+            }
+        }
+
+        bool IWmiProvider.GetInstance(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            string serviceRef = instance.GetProperty(AdministrationStrings.Service) as string;
+            string appDomainInfoRef = instance.GetProperty(AdministrationStrings.AppDomainInfo) as string;
+
+            return !String.IsNullOrEmpty(serviceRef) && !String.IsNullOrEmpty(appDomainInfoRef);
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ServiceEndpointAssociationProvider.cs

@@ -0,0 +1,42 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.ServiceModel.Description;
+    using System.Diagnostics;
+    using System.ServiceModel.Channels;
+    using System.Globalization;
+
+    internal class ServiceEndpointAssociationProvider : ProviderBase, IWmiProvider
+    {
+        void IWmiProvider.EnumInstances(IWmiInstances instances)
+        {
+            foreach (ServiceInfo info in new ServiceInfoCollection(ManagementExtension.Services))
+            {
+                string serviceRef = ServiceInstanceProvider.GetReference(info);
+
+                foreach (EndpointInfo endpointInfo in info.Endpoints)
+                {
+                    IWmiInstance instance = instances.NewInstance(null);
+
+                    string endpointRef = EndpointInstanceProvider.EndpointReference(endpointInfo.ListenUri, endpointInfo.Contract.Name);
+                    instance.SetProperty(AdministrationStrings.Endpoint, endpointRef);
+                    instance.SetProperty(AdministrationStrings.Service, serviceRef);
+
+                    instances.AddInstance(instance);
+                }
+            }
+        }
+
+        bool IWmiProvider.GetInstance(IWmiInstance instance)
+        {
+            string serviceRef = instance.GetProperty(AdministrationStrings.Service) as string;
+            string endpointRef = instance.GetProperty(AdministrationStrings.Endpoint) as string;
+
+            return !String.IsNullOrEmpty(serviceRef) && !String.IsNullOrEmpty(endpointRef);
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ServiceInfo.cs

@@ -0,0 +1,167 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Description;
+
+    sealed class ServiceInfo
+    {
+        KeyedByTypeCollection<IServiceBehavior> behaviors;
+        EndpointInfoCollection endpoints;
+        ServiceHostBase service;
+        string serviceName;
+
+        internal ServiceInfo(ServiceHostBase service)
+        {
+            this.service = service;
+            this.behaviors = service.Description.Behaviors;
+            this.serviceName = service.Description.Name;
+            this.endpoints = new EndpointInfoCollection(service.Description.Endpoints, this.ServiceName);
+        }
+
+        public string ConfigurationName
+        {
+            get { return this.service.Description.ConfigurationName; }
+        }
+
+        public string DistinguishedName
+        {
+            get { return this.serviceName + "@" + this.FirstAddress; }
+        }
+
+        public string FirstAddress
+        {
+            get
+            {
+                Fx.Assert(null != this.Service.BaseAddresses, "");
+                string address = "";
+                if (this.Service.BaseAddresses.Count > 0)
+                {
+                    Fx.Assert(null != this.Service.BaseAddresses[0], "");
+                    address = this.Service.BaseAddresses[0].ToString();
+                }
+                else if (this.Endpoints.Count > 0)
+                {
+                    Uri addressUri = this.Endpoints[0].Address;
+                    if (null != addressUri)
+                    {
+                        address = addressUri.ToString();
+                    }
+                }
+                return address;
+            }
+        }
+
+        public string Name
+        {
+            get { return this.serviceName; }
+        }
+
+        public string Namespace
+        {
+            get { return this.service.Description.Namespace; }
+        }
+
+        public string ServiceName
+        {
+            get { return this.serviceName; }
+        }
+
+        public ServiceHostBase Service
+        {
+            get
+            {
+                return this.service;
+            }
+        }
+
+        public KeyedByTypeCollection<IServiceBehavior> Behaviors
+        {
+            get
+            {
+                return this.behaviors;
+            }
+        }
+
+        public CommunicationState State
+        {
+            get
+            {
+                return this.Service.State;
+            }
+        }
+
+        public EndpointInfoCollection Endpoints
+        {
+            get
+            {
+                return this.endpoints;
+            }
+        }
+
+        public string[] Metadata
+        {
+            get
+            {
+                string[] result = null;
+                ServiceMetadataExtension metadataExtension = service.Extensions.Find<ServiceMetadataExtension>();
+                if (null != metadataExtension)
+                {
+                    Collection<string> metadataStrings = new Collection<string>();
+                    try
+                    {
+                        foreach (MetadataSection section in metadataExtension.Metadata.MetadataSections)
+                        {
+                            using (StringWriter sw = new StringWriter(CultureInfo.InvariantCulture))
+                            {
+                                if (section.Metadata is System.Web.Services.Description.ServiceDescription)
+                                {
+                                    System.Web.Services.Description.ServiceDescription metadata = (System.Web.Services.Description.ServiceDescription)section.Metadata;
+                                    metadata.Write(sw);
+                                    metadataStrings.Add(sw.ToString());
+                                }
+                                else if (section.Metadata is System.Xml.XmlElement)
+                                {
+                                    System.Xml.XmlElement metadata = (System.Xml.XmlElement)section.Metadata;
+                                    using (System.Xml.XmlWriter xmlWriter = System.Xml.XmlWriter.Create(sw))
+                                    {
+                                        metadata.WriteTo(xmlWriter);
+                                        metadataStrings.Add(sw.ToString());
+                                    }
+                                }
+                                else if (section.Metadata is System.Xml.Schema.XmlSchema)
+                                {
+                                    System.Xml.Schema.XmlSchema metadata = (System.Xml.Schema.XmlSchema)section.Metadata;
+                                    metadata.Write(sw);
+                                    metadataStrings.Add(sw.ToString());
+                                }
+                                else
+                                {
+                                    metadataStrings.Add(section.Metadata.ToString());
+                                }
+
+                            }
+                        }
+                    }
+                    catch (InvalidOperationException e)
+                    {
+                        metadataStrings.Add(e.ToString());
+                    }
+                    result = new string[metadataStrings.Count];
+                    metadataStrings.CopyTo(result, 0);
+                }
+
+                return result;
+            }
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ServiceInfoCollection.cs

@@ -0,0 +1,24 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System.Collections.Generic;
+    using System.ServiceModel;
+    using System.Collections.ObjectModel;
+    using System.Reflection;
+    using System.Runtime.Serialization;
+
+    [KnownType(typeof(List<ServiceInfo>))]
+    internal sealed class ServiceInfoCollection : Collection<ServiceInfo>
+    {
+        internal ServiceInfoCollection(IEnumerable<ServiceHostBase> services)
+        {
+            foreach (ServiceHostBase service in services)
+            {
+                base.Add(new ServiceInfo(service));
+            }
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/ServiceInstanceProvider.cs

@@ -0,0 +1,375 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Runtime;
+    using System.Runtime.Diagnostics;
+    using System.Security.Cryptography.X509Certificates;
+    using System.ServiceModel;
+    using System.ServiceModel.Activation;
+    using System.ServiceModel.Channels;
+    using System.ServiceModel.Description;
+    using System.ServiceModel.Diagnostics;
+
+    class ServiceInstanceProvider : ProviderBase, IWmiProvider
+    {
+        void IWmiProvider.EnumInstances(IWmiInstances instances)
+        {
+            Fx.Assert(null != instances, "");
+            int processId = AppDomainInfo.Current.ProcessId;
+            foreach (ServiceInfo info in new ServiceInfoCollection(ManagementExtension.Services))
+            {
+                IWmiInstance instance = instances.NewInstance(null);
+                instance.SetProperty(AdministrationStrings.DistinguishedName, info.DistinguishedName);
+                instance.SetProperty(AdministrationStrings.ProcessId, processId);
+
+                FillServiceInfo(info, instance);
+                instances.AddInstance(instance);
+            }
+        }
+
+        bool IWmiProvider.GetInstance(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            bool bFound = false;
+            if ((int)instance.GetProperty(AdministrationStrings.ProcessId) == AppDomainInfo.Current.ProcessId)
+            {
+                foreach (ServiceInfo info in new ServiceInfoCollection(ManagementExtension.Services))
+                {
+                    if (String.Equals((string)instance.GetProperty(AdministrationStrings.DistinguishedName), info.DistinguishedName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        FillServiceInfo(info, instance);
+                        bFound = true;
+                        break;
+                    }
+                }
+            }
+
+            return bFound;
+        }
+
+        internal static string GetReference(ServiceInfo serviceInfo)
+        {
+            Fx.Assert(null != serviceInfo, "");
+            return String.Format(CultureInfo.InvariantCulture, AdministrationStrings.Service +
+                                    "." +
+                                    AdministrationStrings.DistinguishedName +
+                                    "='{0}'," +
+                                    AdministrationStrings.ProcessId +
+                                    "={1}",
+                                 serviceInfo.DistinguishedName,
+                                 AppDomainInfo.Current.ProcessId);
+        }
+
+        internal static IWmiInstance GetAppDomainInfo(IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            IWmiInstance appDomainInfo = instance.NewInstance(AdministrationStrings.AppDomainInfo);
+            if (null != appDomainInfo)
+            {
+                AppDomainInstanceProvider.FillAppDomainInfo(appDomainInfo);
+            }
+
+            return appDomainInfo;
+        }
+
+        void FillBehaviorsInfo(ServiceInfo info, IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            List<IWmiInstance> behaviors = new List<IWmiInstance>(info.Behaviors.Count);
+            foreach (IServiceBehavior behavior in info.Behaviors)
+            {
+                IWmiInstance behaviorInstance;
+                FillBehaviorInfo(behavior, instance, out behaviorInstance);
+                if (null != behaviorInstance)
+                {
+                    behaviors.Add(behaviorInstance);
+                }
+            }
+            instance.SetProperty(AdministrationStrings.Behaviors, behaviors.ToArray());
+        }
+
+        void FillChannelsInfo(ServiceInfo info, IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            Fx.Assert(null != info, "");
+            int channelsCount = 0;
+
+            List<IWmiInstance> instances = new List<IWmiInstance>();
+            IEnumerable<InstanceContext> contexts = info.Service.GetInstanceContexts();
+            foreach (InstanceContext instanceContext in contexts)
+            {
+                lock (instanceContext.ThisLock)
+                {
+                    channelsCount += instanceContext.WmiChannels.Count;
+                    foreach (IChannel channel in instanceContext.WmiChannels)
+                    {
+                        IWmiInstance channelInstance = instance.NewInstance(AdministrationStrings.Channel);
+                        FillChannelInfo(channel, channelInstance);
+                        instances.Add(channelInstance);
+                    }
+                }
+            }
+
+            instance.SetProperty(AdministrationStrings.Channels, instances.ToArray());
+        }
+
+        static void FillExtensionsInfo(ServiceInfo info, IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            Fx.Assert(null != info, "");
+            ProviderBase.FillCollectionInfo(info.Service.Extensions, instance, AdministrationStrings.Extensions);
+        }
+
+        void FillServiceInfo(ServiceInfo info, IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            Fx.Assert(null != info, "");
+            ProviderBase.FillCollectionInfo(info.Service.BaseAddresses, instance, AdministrationStrings.BaseAddresses);
+            instance.SetProperty(AdministrationStrings.CounterInstanceName, PerformanceCounters.PerformanceCountersEnabled ? ServicePerformanceCounters.GetFriendlyInstanceName(info.Service) : String.Empty);
+            instance.SetProperty(AdministrationStrings.ConfigurationName, info.ConfigurationName);
+            instance.SetProperty(AdministrationStrings.DistinguishedName, info.DistinguishedName);
+            instance.SetProperty(AdministrationStrings.Name, info.Name);
+            instance.SetProperty(AdministrationStrings.Namespace, info.Namespace);
+            instance.SetProperty(AdministrationStrings.Metadata, info.Metadata);
+            instance.SetProperty(AdministrationStrings.Opened, ManagementExtension.GetTimeOpened(info.Service));
+
+
+            FillBehaviorsInfo(info, instance);
+            FillExtensionsInfo(info, instance);
+            FillChannelsInfo(info, instance);
+        }
+
+        void FillBehaviorInfo(IServiceBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
+        {
+            Fx.Assert(null != existingInstance, "");
+            Fx.Assert(null != behavior, "");
+            instance = null;
+            if (behavior is AspNetCompatibilityRequirementsAttribute)
+            {
+                instance = existingInstance.NewInstance("AspNetCompatibilityRequirementsAttribute");
+                AspNetCompatibilityRequirementsAttribute specificBehavior = (AspNetCompatibilityRequirementsAttribute)behavior;
+                instance.SetProperty(AdministrationStrings.RequirementsMode, specificBehavior.RequirementsMode.ToString());
+            }
+            else if (behavior is ServiceCredentials)
+            {
+                instance = existingInstance.NewInstance("ServiceCredentials");
+                ServiceCredentials specificBehavior = (ServiceCredentials)behavior;
+                if (specificBehavior.ClientCertificate != null && specificBehavior.ClientCertificate.Certificate != null)
+                {
+                    string result = string.Empty;
+                    result += String.Format(CultureInfo.InvariantCulture, "Certificate: {0}\n", specificBehavior.ClientCertificate.Certificate);
+                    instance.SetProperty(AdministrationStrings.ClientCertificate, result);
+                }
+                if (specificBehavior.IssuedTokenAuthentication != null && specificBehavior.IssuedTokenAuthentication.KnownCertificates != null)
+                {
+                    string result = string.Empty;
+                    result += String.Format(CultureInfo.InvariantCulture, "AllowUntrustedRsaIssuers: {0}\n", specificBehavior.IssuedTokenAuthentication.AllowUntrustedRsaIssuers);
+                    result += String.Format(CultureInfo.InvariantCulture, "CertificateValidationMode: {0}\n", specificBehavior.IssuedTokenAuthentication.CertificateValidationMode);
+                    result += String.Format(CultureInfo.InvariantCulture, "RevocationMode: {0}\n", specificBehavior.IssuedTokenAuthentication.RevocationMode);
+                    result += String.Format(CultureInfo.InvariantCulture, "TrustedStoreLocation: {0}\n", specificBehavior.IssuedTokenAuthentication.TrustedStoreLocation);
+                    foreach (X509Certificate2 certificate in specificBehavior.IssuedTokenAuthentication.KnownCertificates)
+                    {
+                        if (certificate != null)
+                        {
+                            result += String.Format(CultureInfo.InvariantCulture, "Known certificate: {0}\n", certificate.FriendlyName);
+                        }
+                    }
+                    result += String.Format(CultureInfo.InvariantCulture, "AudienceUriMode: {0}\n", specificBehavior.IssuedTokenAuthentication.AudienceUriMode);
+                    if (specificBehavior.IssuedTokenAuthentication.AllowedAudienceUris != null)
+                    {
+                        foreach (string str in specificBehavior.IssuedTokenAuthentication.AllowedAudienceUris)
+                        {
+                            if (str != null)
+                            {
+                                result += String.Format(CultureInfo.InvariantCulture, "Allowed Uri: {0}\n", str);
+                            }
+                        }
+                    }
+
+                    instance.SetProperty(AdministrationStrings.IssuedTokenAuthentication, result);
+                }
+                if (specificBehavior.Peer != null && specificBehavior.Peer.Certificate != null)
+                {
+                    string result = string.Empty;
+                    result += String.Format(CultureInfo.InvariantCulture, "Certificate: {0}\n", specificBehavior.Peer.Certificate.ToString(true));
+                    instance.SetProperty(AdministrationStrings.Peer, result);
+                }
+                if (specificBehavior.SecureConversationAuthentication != null && specificBehavior.SecureConversationAuthentication.SecurityContextClaimTypes != null)
+                {
+                    string result = string.Empty;
+                    foreach (Type claimType in specificBehavior.SecureConversationAuthentication.SecurityContextClaimTypes)
+                    {
+                        if (claimType != null)
+                        {
+                            result += String.Format(CultureInfo.InvariantCulture, "ClaimType: {0}\n", claimType);
+                        }
+                    }
+                    instance.SetProperty(AdministrationStrings.SecureConversationAuthentication, result);
+                }
+                if (specificBehavior.ServiceCertificate != null && specificBehavior.ServiceCertificate.Certificate != null)
+                {
+                    instance.SetProperty(AdministrationStrings.ServiceCertificate, specificBehavior.ServiceCertificate.Certificate.ToString());
+                }
+                if (specificBehavior.UserNameAuthentication != null)
+                {
+                    instance.SetProperty(AdministrationStrings.UserNameAuthentication, String.Format(CultureInfo.InvariantCulture, "{0}: {1}", AdministrationStrings.ValidationMode, specificBehavior.UserNameAuthentication.UserNamePasswordValidationMode.ToString()));
+                }
+                if (specificBehavior.WindowsAuthentication != null)
+                {
+                    instance.SetProperty(AdministrationStrings.WindowsAuthentication, String.Format(CultureInfo.InvariantCulture, "{0}: {1}", AdministrationStrings.AllowAnonymous, specificBehavior.WindowsAuthentication.AllowAnonymousLogons.ToString()));
+                }
+            }
+            else if (behavior is ServiceAuthorizationBehavior)
+            {
+                instance = existingInstance.NewInstance("ServiceAuthorizationBehavior");
+                ServiceAuthorizationBehavior specificBehavior = (ServiceAuthorizationBehavior)behavior;
+                instance.SetProperty(AdministrationStrings.ImpersonateCallerForAllOperations, specificBehavior.ImpersonateCallerForAllOperations);
+                instance.SetProperty(AdministrationStrings.ImpersonateOnSerializingReply, specificBehavior.ImpersonateOnSerializingReply);
+                if (specificBehavior.RoleProvider != null)
+                {
+                    instance.SetProperty(AdministrationStrings.RoleProvider, specificBehavior.RoleProvider.ToString());
+                }
+                if (specificBehavior.ServiceAuthorizationManager != null)
+                {
+                    instance.SetProperty(AdministrationStrings.ServiceAuthorizationManager, specificBehavior.ServiceAuthorizationManager.ToString());
+                }
+                instance.SetProperty(AdministrationStrings.PrincipalPermissionMode, specificBehavior.PrincipalPermissionMode.ToString());
+            }
+            else if (behavior is ServiceSecurityAuditBehavior)
+            {
+                instance = existingInstance.NewInstance("ServiceSecurityAuditBehavior");
+                ServiceSecurityAuditBehavior specificBehavior = (ServiceSecurityAuditBehavior)behavior;
+                instance.SetProperty(AdministrationStrings.AuditLogLocation, specificBehavior.AuditLogLocation.ToString());
+                instance.SetProperty(AdministrationStrings.SuppressAuditFailure, specificBehavior.SuppressAuditFailure);
+                instance.SetProperty(AdministrationStrings.ServiceAuthorizationAuditLevel, specificBehavior.ServiceAuthorizationAuditLevel.ToString());
+                instance.SetProperty(AdministrationStrings.MessageAuthenticationAuditLevel, specificBehavior.MessageAuthenticationAuditLevel.ToString());
+            }
+            else if (behavior is ServiceBehaviorAttribute)
+            {
+                instance = existingInstance.NewInstance("ServiceBehaviorAttribute");
+                ServiceBehaviorAttribute serviceBehavior = (ServiceBehaviorAttribute)behavior;
+                instance.SetProperty(AdministrationStrings.AddressFilterMode, serviceBehavior.AddressFilterMode.ToString());
+                instance.SetProperty(AdministrationStrings.AutomaticSessionShutdown, serviceBehavior.AutomaticSessionShutdown);
+                instance.SetProperty(AdministrationStrings.ConcurrencyMode, serviceBehavior.ConcurrencyMode.ToString());
+                instance.SetProperty(AdministrationStrings.ConfigurationName, serviceBehavior.ConfigurationName);
+                instance.SetProperty(AdministrationStrings.EnsureOrderedDispatch, serviceBehavior.EnsureOrderedDispatch);
+                instance.SetProperty(AdministrationStrings.IgnoreExtensionDataObject, serviceBehavior.IgnoreExtensionDataObject);
+                instance.SetProperty(AdministrationStrings.IncludeExceptionDetailInFaults, serviceBehavior.IncludeExceptionDetailInFaults);
+                instance.SetProperty(AdministrationStrings.InstanceContextMode, serviceBehavior.InstanceContextMode.ToString());
+                instance.SetProperty(AdministrationStrings.MaxItemsInObjectGraph, serviceBehavior.MaxItemsInObjectGraph);
+                instance.SetProperty(AdministrationStrings.Name, serviceBehavior.Name);
+                instance.SetProperty(AdministrationStrings.Namespace, serviceBehavior.Namespace);
+                instance.SetProperty(AdministrationStrings.ReleaseServiceInstanceOnTransactionComplete, serviceBehavior.ReleaseServiceInstanceOnTransactionComplete);
+                instance.SetProperty(AdministrationStrings.TransactionAutoCompleteOnSessionClose, serviceBehavior.TransactionAutoCompleteOnSessionClose);
+                instance.SetProperty(AdministrationStrings.TransactionIsolationLevel, serviceBehavior.TransactionIsolationLevel.ToString());
+                if (serviceBehavior.TransactionTimeoutSet)
+                {
+                    instance.SetProperty(AdministrationStrings.TransactionTimeout, serviceBehavior.TransactionTimeoutTimespan);
+                }
+                instance.SetProperty(AdministrationStrings.UseSynchronizationContext, serviceBehavior.UseSynchronizationContext);
+                instance.SetProperty(AdministrationStrings.ValidateMustUnderstand, serviceBehavior.ValidateMustUnderstand);
+            }
+            else if (behavior is ServiceDebugBehavior)
+            {
+                instance = existingInstance.NewInstance("ServiceDebugBehavior");
+                ServiceDebugBehavior specificBehavior = (ServiceDebugBehavior)behavior;
+                if (null != specificBehavior.HttpHelpPageUrl)
+                {
+                    instance.SetProperty(AdministrationStrings.HttpHelpPageUrl, specificBehavior.HttpHelpPageUrl.ToString());
+                }
+                instance.SetProperty(AdministrationStrings.HttpHelpPageEnabled, specificBehavior.HttpHelpPageEnabled);
+                if (null != specificBehavior.HttpsHelpPageUrl)
+                {
+                    instance.SetProperty(AdministrationStrings.HttpsHelpPageUrl, specificBehavior.HttpsHelpPageUrl.ToString());
+                }
+                instance.SetProperty(AdministrationStrings.HttpsHelpPageEnabled, specificBehavior.HttpsHelpPageEnabled);
+                instance.SetProperty(AdministrationStrings.IncludeExceptionDetailInFaults, specificBehavior.IncludeExceptionDetailInFaults);
+            }
+            else if (behavior is ServiceMetadataBehavior)
+            {
+                instance = existingInstance.NewInstance("ServiceMetadataBehavior");
+                ServiceMetadataBehavior metadataBehavior = (ServiceMetadataBehavior)behavior;
+                if (null != metadataBehavior.ExternalMetadataLocation)
+                {
+                    instance.SetProperty(AdministrationStrings.ExternalMetadataLocation, metadataBehavior.ExternalMetadataLocation.ToString());
+                }
+                instance.SetProperty(AdministrationStrings.HttpGetEnabled, metadataBehavior.HttpGetEnabled);
+                if (null != metadataBehavior.HttpGetUrl)
+                {
+                    instance.SetProperty(AdministrationStrings.HttpGetUrl, metadataBehavior.HttpGetUrl.ToString());
+                }
+                instance.SetProperty(AdministrationStrings.HttpsGetEnabled, metadataBehavior.HttpsGetEnabled);
+                if (null != metadataBehavior.HttpsGetUrl)
+                {
+                    instance.SetProperty(AdministrationStrings.HttpsGetUrl, metadataBehavior.HttpsGetUrl.ToString());
+                }
+                FillMetadataExporterInfo(instance, metadataBehavior.MetadataExporter);
+            }
+            else if (behavior is ServiceThrottlingBehavior)
+            {
+                instance = existingInstance.NewInstance("ServiceThrottlingBehavior");
+                ServiceThrottlingBehavior throttlingBehavior = (ServiceThrottlingBehavior)behavior;
+                instance.SetProperty(AdministrationStrings.MaxConcurrentCalls, throttlingBehavior.MaxConcurrentCalls);
+                instance.SetProperty(AdministrationStrings.MaxConcurrentSessions, throttlingBehavior.MaxConcurrentSessions);
+                instance.SetProperty(AdministrationStrings.MaxConcurrentInstances, throttlingBehavior.MaxConcurrentInstances);
+            }
+            else if (behavior is ServiceTimeoutsBehavior)
+            {
+                instance = existingInstance.NewInstance("ServiceTimeoutsBehavior");
+                ServiceTimeoutsBehavior specificBehavior = (ServiceTimeoutsBehavior)behavior;
+                instance.SetProperty(AdministrationStrings.TransactionTimeout, specificBehavior.TransactionTimeout);
+            }
+            else if (behavior is IWmiInstanceProvider)
+            {
+                IWmiInstanceProvider instanceProvider = (IWmiInstanceProvider)behavior;
+                instance = existingInstance.NewInstance(instanceProvider.GetInstanceType());
+                instanceProvider.FillInstance(instance);
+            }
+            else
+            {
+                instance = existingInstance.NewInstance("Behavior");
+            }
+            if (null != instance)
+            {
+                instance.SetProperty(AdministrationStrings.Type, behavior.GetType().FullName);
+            }
+        }
+
+        void FillMetadataExporterInfo(IWmiInstance instance, MetadataExporter exporter)
+        {
+            DiagnosticUtility.EventLog.LogEvent(TraceEventType.Information, (ushort)System.Runtime.Diagnostics.EventLogCategory.Wmi, (uint)System.Runtime.Diagnostics.EventLogEventId.MessageLoggingOn, true, "metadata exporter called");
+            Fx.Assert(null != instance, "");
+            Fx.Assert(null != exporter, "");
+            IWmiInstance metadataExporterInstance = instance.NewInstance(AdministrationStrings.MetadataExporter);
+            metadataExporterInstance.SetProperty(AdministrationStrings.PolicyVersion, exporter.PolicyVersion.ToString());
+            instance.SetProperty(AdministrationStrings.MetadataExportInfo, metadataExporterInstance);
+        }
+
+
+        void FillChannelInfo(IChannel channel, IWmiInstance instance)
+        {
+            Fx.Assert(null != instance, "");
+            Fx.Assert(null != channel, "");
+            instance.SetProperty(AdministrationStrings.Type, channel.GetType().ToString());
+
+            ServiceChannel serviceChannel = ServiceChannelFactory.GetServiceChannel(channel);
+            if (null != serviceChannel)
+            {
+                string uri = serviceChannel.RemoteAddress == null ? String.Empty : serviceChannel.RemoteAddress.ToString();
+                instance.SetProperty(AdministrationStrings.RemoteAddress, uri);
+                string contractName = null != serviceChannel.ClientRuntime ? serviceChannel.ClientRuntime.ContractName : String.Empty;
+                string remoteEndpoint = EndpointInstanceProvider.EndpointReference(uri, contractName, false);
+                instance.SetProperty(AdministrationStrings.RemoteEndpoint, remoteEndpoint);
+                instance.SetProperty(AdministrationStrings.LocalAddress, serviceChannel.LocalAddress == null ? String.Empty : serviceChannel.LocalAddress.ToString());
+                instance.SetProperty(AdministrationStrings.SessionId, ((IContextChannel)serviceChannel).SessionId);
+            }
+        }
+    }
+}

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Administration/WbemException.cs

@@ -0,0 +1,90 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Administration
+{
+    using System;
+    using System.ComponentModel;
+    using System.Diagnostics;
+
+    internal class WbemException : Win32Exception
+    {
+        internal WbemException(WbemNative.WbemStatus hr)
+            : base((int)hr)
+        {
+        }
+
+        internal WbemException(int hr)
+            : base(hr)
+        {
+        }
+
+        internal WbemException(int hr, string message)
+            : base(hr, message)
+        {
+        }
+
+        internal static void Throw(WbemNative.WbemStatus hr)
+        {
+            switch (hr)
+            {
+                case WbemNative.WbemStatus.WBEM_E_NOT_FOUND:
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemInstanceNotFoundException());
+                case WbemNative.WbemStatus.WBEM_E_INVALID_PARAMETER:
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemInvalidParameterException());
+                case WbemNative.WbemStatus.WBEM_E_NOT_SUPPORTED:
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemNotSupportedException());
+                case WbemNative.WbemStatus.WBEM_E_INVALID_METHOD:
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemInvalidMethodException());
+                default:
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WbemException(hr));
+            }
+        }
+
+        internal static void ThrowIfFail(int hr)
+        {
+            if (hr < 0)
+            {
+                Throw((WbemNative.WbemStatus)hr);
+            }
+        }
+    }
+
+    internal class WbemInstanceNotFoundException : WbemException
+    {
+        internal WbemInstanceNotFoundException()
+            : base(WbemNative.WbemStatus.WBEM_E_NOT_FOUND)
+        {
+        }
+    }
+
+    internal class WbemInvalidParameterException : WbemException
+    {
+        internal WbemInvalidParameterException(string name)
+            : base((int)WbemNative.WbemStatus.WBEM_E_INVALID_PARAMETER, name)
+        {
+        }
+
+        internal WbemInvalidParameterException()
+            : base(WbemNative.WbemStatus.WBEM_E_INVALID_PARAMETER)
+        {
+        }
+    }
+
+    internal class WbemNotSupportedException : WbemException
+    {
+        internal WbemNotSupportedException()
+            : base(WbemNative.WbemStatus.WBEM_E_NOT_SUPPORTED)
+        {
+        }
+    }
+
+    internal class WbemInvalidMethodException : WbemException
+    {
+        internal WbemInvalidMethodException()
+            : base(WbemNative.WbemStatus.WBEM_E_INVALID_METHOD)
+        {
+        }
+    }
+}