public static IContainer ConfigureContainer()
{
var cb = new ContainerBuilder();
cb.RegisterType <HealthMonitorService>().As <IHealthMonitorService>();
AutofacHostFactory.HostConfigurationAction = host =>
{
foreach (var endpoint in host.Description.Endpoints)
{
var configuredBehaviors = new IEndpointBehavior[endpoint.Behaviors.Count];
endpoint.Behaviors.CopyTo(configuredBehaviors, 0);
endpoint.Behaviors.Clear();
endpoint.Behaviors.Add(new PingEndpointBehavior());
foreach (var configuredBehavior in configuredBehaviors)
{
if (!endpoint.Behaviors.Contains(configuredBehavior.GetType()))
{
endpoint.Behaviors.Add(configuredBehavior);
}
}
}
};
var reader = new ConfigurationSettingsReader();
cb.RegisterModule(reader);
Container = cb.Build();
return(Container);
}
// This method runs validators (both builtin and ones in description).
// Precondition: EnsureInvariants() should already have been called.
void Validate(bool runOperationValidators, bool isForService)
{
// contract behaviors
ContractDescription contract = Contract;
for (int j = 0; j < contract.ContractBehaviors.Count; j++)
{
IContractBehavior iContractBehavior = contract.ContractBehaviors[j];
iContractBehavior.Validate(contract, this);
}
// endpoint behaviors
for (int j = 0; j < EndpointBehaviors.Count; j++)
{
IEndpointBehavior ieb = EndpointBehaviors[j];
ieb.Validate(this);
}
// operation behaviors
if (runOperationValidators)
{
for (int j = 0; j < contract.Operations.Count; j++)
{
OperationDescription op = contract.Operations[j];
TaskOperationDescriptionValidator.Validate(op, isForService);
for (int k = 0; k < op.OperationBehaviors.Count; k++)
{
IOperationBehavior iob = op.OperationBehaviors[k];
iob.Validate(op);
}
}
}
}
void ApplyServiceElement(ServiceElement service)
{
//base addresses
HostElement host = service.Host;
foreach (BaseAddressElement baseAddress in host.BaseAddresses)
{
AddBaseAddress(new Uri(baseAddress.BaseAddress));
}
// behaviors
AddServiceBehaviors(service.BehaviorConfiguration, true);
// endpoints
foreach (ServiceEndpointElement endpoint in service.Endpoints)
{
ServiceEndpoint se;
var binding = String.IsNullOrEmpty(endpoint.Binding) ? null : ConfigUtil.CreateBinding(endpoint.Binding, endpoint.BindingConfiguration);
if (!String.IsNullOrEmpty(endpoint.Kind))
{
var contract = String.IsNullOrEmpty(endpoint.Contract) ? null : GetContract(endpoint.Contract, false);
se = ConfigUtil.ConfigureStandardEndpoint(contract, endpoint);
if (se.Binding == null)
{
se.Binding = binding;
}
if (se.Address == null && se.Binding != null) // standard endpoint might have empty address
{
se.Address = new EndpointAddress(CreateUri(se.Binding.Scheme, endpoint.Address));
}
if (se.Binding == null && se.Address != null) // look for protocol mapping
{
se.Binding = ConfigUtil.GetBindingByProtocolMapping(se.Address.Uri);
}
AddServiceEndpoint(se);
}
else
{
if (binding == null && endpoint.Address != null) // look for protocol mapping
{
binding = ConfigUtil.GetBindingByProtocolMapping(endpoint.Address);
}
se = AddServiceEndpoint(endpoint.Contract, binding, endpoint.Address);
}
// endpoint behaviors
EndpointBehaviorElement epbehavior = ConfigUtil.BehaviorsSection.EndpointBehaviors [endpoint.BehaviorConfiguration];
if (epbehavior != null)
{
foreach (var bxe in epbehavior)
{
IEndpointBehavior b = (IEndpointBehavior)bxe.CreateBehavior();
se.Behaviors.Add(b);
}
}
}
}
public object CreateClient(string configurationName, IEndpointBehavior behaviour)
{
var client = (ClientBase <TChannel>)CreateClient(configurationName);
client.Endpoint.Behaviors.Add(behaviour);
return(client);
}
/// <summary>
/// Initializes a new instance of the <see cref="SoapPatientService"/> class.
/// Constructor that requires an IEndpointBehavior for dependency injection.
/// </summary>
/// <param name="logger">The service Logger.</param>
/// <param name="configuration">The service configuration.</param>
/// <param name="loggingEndpointBehaviour">Endpoint behaviour for logging purposes.</param>
public SoapPatientService(ILogger <SoapPatientService> logger, IConfiguration configuration, IEndpointBehavior loggingEndpointBehaviour)
{
if (configuration is null)
{
throw new ArgumentNullException(nameof(configuration));
}
this.loggingEndpointBehaviour = loggingEndpointBehaviour;
this.logger = logger;
IConfigurationSection clientConfiguration = configuration.GetSection("ClientRegistries");
// Load Certificate
string clientCertificatePath = clientConfiguration.GetSection("ClientCertificate").GetValue <string>("Path");
string certificatePassword = clientConfiguration.GetSection("ClientCertificate").GetValue <string>("Password");
X509Certificate2 clientCertificate = new X509Certificate2(System.IO.File.ReadAllBytes(clientCertificatePath), certificatePassword);
string serviceUrl = clientConfiguration.GetValue <string>("ServiceUrl");
EndpointAddress endpoint = new EndpointAddress(new Uri(serviceUrl));
// Create client
this.getDemographicsClient = new QUPA_AR101102_PortTypeClient(QUPA_AR101102_PortTypeClient.EndpointConfiguration.QUPA_AR101102_Port, endpoint);
this.getDemographicsClient.Endpoint.EndpointBehaviors.Add(this.loggingEndpointBehaviour);
this.getDemographicsClient.ClientCredentials.ClientCertificate.Certificate = clientCertificate;
// TODO: - HACK - Remove this once we can get the server certificate to be trusted.
this.getDemographicsClient.ClientCredentials.ServiceCertificate.SslCertificateAuthentication =
new X509ServiceCertificateAuthentication()
{
CertificateValidationMode = X509CertificateValidationMode.None,
RevocationMode = X509RevocationMode.NoCheck,
};
}
/// <summary>
/// Creates the WCF endpoint and configures port sharing depending on the
/// Core.WCFEnablePortSharing setting.
/// </summary>
/// <returns>The Castle endpoint facility contract</returns>
private IWcfEndpoint CreateEndpoint(
BindingEndpointModel baseEndpoint,
IEndpointBehavior endpointBehaviour,
List <string> baseAddresses,
string serviceUri)
{
IWcfEndpoint endpoint = baseEndpoint;
if (Settings.WCFEnablePortSharing)
{
baseAddresses.Add(serviceUri);
baseEndpoint.AddExtensions(endpointBehaviour);
}
else
{
// add ACL's to allow http service registrations without account elevation (for mex endpoints)
// run these commands in an elevated console (only need to run this once)
// NOTE: this is only required when not running as an administrator
// netsh http add urlacl url = http://+:8002/ user=\Everyone
// netsh http add urlacl url = http://+:8003/ user=\Everyone
// netsh http add urlacl url = http://+:8502/ user=\Everyone
endpoint = baseEndpoint
// The .At(uri) enables a fully qualified endpoint Uri which avoids using a base address configuration
// By limiting base addresses to only HTTP (mex) endpoints we eliminate the requirement of port sharing
.At(serviceUri)
.AddExtensions(endpointBehaviour);
}
return(endpoint);
}
private void SetBehaviors( )
{
ValidationBehavior validation = new ValidationBehavior(true, false, ruleSet);
endpointBehavior = (IEndpointBehavior)validation;
contractBehavior = (IContractBehavior)validation;
}
public static List <IEndpointBehavior> GetDefaultEndPointBehaviors(string scheme)
{
List <IEndpointBehavior> list = new List <IEndpointBehavior>();
WCFConfigProvider.InitServiceModel();
if (WCFConfigProvider._serviceModel == null)
{
return(list);
}
string defaultEndPointBehaviorName = WCFConfigProvider.GetDefaultEndPointBehaviorName(scheme);
if (WCFConfigProvider._serviceModel.Behaviors.EndpointBehaviors.ContainsKey(defaultEndPointBehaviorName))
{
EndpointBehaviorElement endpointBehaviorElement = WCFConfigProvider._serviceModel.Behaviors.EndpointBehaviors[defaultEndPointBehaviorName];
foreach (BehaviorExtensionElement current in endpointBehaviorElement)
{
IEndpointBehavior endpointBehavior = WCFConfigProvider.CreateBehavior <IEndpointBehavior>(current);
if (endpointBehavior != null)
{
list.Add(endpointBehavior);
}
}
}
return(list);
}
/// <summary>
/// 获取终结点行为列表
/// </summary>
/// <returns>终结点行为列表</returns>
private ICollection <IEndpointBehavior> GetEndpointBehaviors <T>()
{
string endpointName = typeof(T).FullName;
#region # 验证
if (!ServiceModelSetting.Endpoints.ContainsKey(endpointName))
{
throw new NullReferenceException($"名称为\"{endpointName}\"的终结点未配置！");
}
#endregion
ICollection <IEndpointBehavior> endpointBehaviors = new HashSet <IEndpointBehavior>();
ChannelEndpointElement endpoint = ServiceModelSetting.Endpoints[endpointName];
if (!string.IsNullOrWhiteSpace(endpoint.BehaviorConfiguration))
{
if (!ServiceModelSetting.BehaviorConfigurations.TryGetValue(endpoint.BehaviorConfiguration, out BehaviorConfigurationElement behaviorConfiguration))
{
throw new KeyNotFoundException($"未找到名称为\"{endpoint.BehaviorConfiguration}\"的行为配置！");
}
foreach (EndpointBehaviorElement endpointBehaviorElement in behaviorConfiguration.EndpointBehaviors)
{
IEndpointBehavior endpointBehavior = endpointBehaviorElement.CreateEndpointBehavior();
endpointBehaviors.Add(endpointBehavior);
}
}
return(endpointBehaviors);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceClient{TLocalType}"/> class.
/// </summary>
/// <param name="customEndPointBehaviour">The custom end point behaviour.</param>
public ServiceClient(IEndpointBehavior customEndPointBehaviour)
{
_channel = new ChannelFactory <TLocalType>(typeof(TLocalType).FullName);
_channel.Endpoint.Behaviors.Add(customEndPointBehaviour);
_serviceInstance = _channel.CreateChannel();
_channel.Faulted += ServiceInstance_Faulted;
}
public ProxyMapper(Binding binding, IEndpointBehavior endpointBehavior, INameMapper nameMapper)
{
_generator = new ProxyGenerator();
_nameMapper = nameMapper;
_binding = binding;
_endpointBehavior = endpointBehavior;
}
private void SetBehaviors()
{
ValidationBehavior validation = new ValidationBehavior(true, false, ruleSet);
endpointBehavior = (IEndpointBehavior)validation;
contractBehavior = (IContractBehavior)validation;
operationBehavior = (IOperationBehavior)validation;
}
public VerintConnection(IOptions <VerintConnectionConfiguration> verintConfiguration, IEndpointBehavior requestBehavior)
{
_verintConfiguration = verintConfiguration.Value;
_requestBehavior = requestBehavior;
_verintHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
_verintHttpBinding.Security.Mode = BasicHttpSecurityMode.None;
}
private void ReflectOnCallbackInstance(ServiceEndpoint endpoint)
{
if (this.callbackType != null)
{
if (endpoint.Contract.CallbackContractType == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SfxCallbackTypeCannotBeNull", new object[] { endpoint.Contract.ContractType.FullName })));
}
this.TypeLoader.AddBehaviorsFromImplementationType(endpoint, this.callbackType);
}
else if ((this.CallbackInstance != null) && (this.CallbackInstance.UserObject != null))
{
if (endpoint.Contract.CallbackContractType == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SfxCallbackTypeCannotBeNull", new object[] { endpoint.Contract.ContractType.FullName })));
}
object userObject = this.CallbackInstance.UserObject;
System.Type implementationType = userObject.GetType();
this.TypeLoader.AddBehaviorsFromImplementationType(endpoint, implementationType);
IEndpointBehavior item = userObject as IEndpointBehavior;
if (item != null)
{
endpoint.Behaviors.Add(item);
}
IContractBehavior behavior2 = userObject as IContractBehavior;
if (behavior2 != null)
{
endpoint.Contract.Behaviors.Add(behavior2);
}
}
}
public void addService(Type contract, String address, Binding binding, IEndpointBehavior behavior)
{
ServiceEndpoint endPt = sh.AddServiceEndpoint(contract, binding, address);
endPt.Behaviors.Add(behavior);
endPt.Behaviors.Add(new MessageInterceptor());
}
private void SetBehaviors()
{
ValidatingBehavior validation = new ValidatingBehavior(true, false, Ruleset);
_endpointBehavior = (IEndpointBehavior)validation;
_contractBehavior = (IContractBehavior)validation;
_operationBehavior = (IOperationBehavior)validation;
}
public static void AddBehaviorOnAllEndpoints(
this ServiceHostBase serviceHost,
IEndpointBehavior behavior)
{
ReplaceBehaviorOnAllEndpoints(
serviceHost,
null,
behavior);
}
void IServiceBehavior.Validate(ServiceDescription description, ServiceHostBase host)
{
IEndpointBehavior endpointBehavior = this;
foreach (ServiceEndpoint endpoint in description.Endpoints)
{
endpointBehavior.Validate(endpoint);
}
}
private IEndpointBehavior GetEndpointBehavior()
{
if (_endpointBehavior == null)
{
_endpointBehavior = new CancellationEndpointBehavior(new ServiceServiceProvider());
}
return(_endpointBehavior);
}
public CurrencyConverterModel(
CurrencyConverterServiceClient currencyConverterServiceProxy,
IEndpointBehavior endpointBehavior
)
{
_currencyConverterServiceProxy = currencyConverterServiceProxy ?? throw new ArgumentNullException(nameof(currencyConverterServiceProxy));
endpointBehavior = endpointBehavior ?? throw new ArgumentNullException(nameof(endpointBehavior));
_currencyConverterServiceProxy.ChannelFactory.Endpoint.Behaviors.Add(endpointBehavior);
}
public static IEndpointBehavior CreateBehavior(BehaviorExtensionElement behaviorExtension)
{
IEndpointBehavior endPointBehavior = (IEndpointBehavior)behaviorExtension.GetType().InvokeMember(
"CreateBehavior",
BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance,
null,
behaviorExtension,
null);
return(endPointBehavior);
}
public IOnvifRequestBuilder <DeviceInformation, IDeviceInformation> SetAuthentication(IEndpointBehavior authenticator)
{
if (authenticator == null)
{
throw new ArgumentNullException(nameof(authenticator));
}
_authenticator = authenticator;
return(this);
}
public static I CreateInstance <S, I>(IServiceBehavior serviceBehavior, IEndpointBehavior clientBehavior) where I : class
where S : class, I
{
EndpointAddress address = GetAddress <S, I>(serviceBehavior, Binding as NetNamedPipeContextBinding);
ChannelFactory <I> factory = new ChannelFactory <I>(Binding, address);
factory.AddGenericResolver();
factory.Endpoint.EndpointBehaviors.Add(clientBehavior);
return(factory.CreateChannel());
}
public ServiceModelBuilder AddGlobalBehavior(IEndpointBehavior behavior)
{
Services.ConfigureAll <ServiceModelOptions>(option =>
{
foreach (var service in option.Services)
{
service.Behaviors.Add(behavior);
}
});
return(this);
}
public void Use2()
{
// This time with ServiceDiscoveryBehavior.
var b = new EndpointDiscoveryBehavior();
IEndpointBehavior eb = b;
var host = new ServiceHost(typeof(TestService));
var se = host.AddServiceEndpoint(typeof(ITestService), new BasicHttpBinding(), new Uri("http://localhost:37564"));
var sdb = new ServiceDiscoveryBehavior();
sdb.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
IServiceBehavior sb = sdb;
se.Behaviors.Add(b);
var bc = new BindingParameterCollection();
sb.AddBindingParameters(host.Description, host, host.Description.Endpoints, bc);
eb.AddBindingParameters(se, bc);
Assert.AreEqual(0, bc.Count, "#1");
Assert.AreEqual(0, host.Extensions.Count, "#1-2");
sb.Validate(host.Description, host);
eb.Validate(se);
// ... should "validate" not "apply dispatch behavior" do "add host extension" job? I doubt that.
Assert.AreEqual(1, host.Extensions.Count, "#2-2");
var dse = host.Extensions.Find <DiscoveryServiceExtension> ();
Assert.IsNotNull(dse, "#2-3");
Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#2-4");
Assert.AreEqual(2, se.Behaviors.Count, "#2-5"); // EndpointDiscoveryBehavior + discovery initializer.
Assert.AreEqual(0, host.ChannelDispatchers.Count, "#3-1");
Assert.AreEqual(1, host.Description.Endpoints.Count, "#3-2");
Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#3-4");
// The IEndpointBehavior from EndpointDiscoveryBehavior, when ApplyDispatchBehavior() is invoked, publishes an endpoint.
sb.ApplyDispatchBehavior(host.Description, host);
Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#3-5"); // not yet published
eb.ApplyDispatchBehavior(se, new EndpointDispatcher(new EndpointAddress("http://localhost:37564"), "ITestService", "http://tempuri.org/"));
Assert.AreEqual(2, host.ChannelDispatchers.Count, "#3-6-1"); // for online and offline announcements
Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#3-6-2"); // still not published.
host.Open();
try
{
Assert.AreEqual(3, host.ChannelDispatchers.Count, "#4-1"); // for online and offline announcements
Assert.AreEqual(1, dse.PublishedEndpoints.Count, "#4-2"); // The endpoint is published again. (Not sure if it's worthy of testing.)
}
finally
{
host.Close();
}
}
private void ApplyBehavior(string behaviorConfig)
{
BehaviorsSection behaviorsSection = ConfigUtil.BehaviorsSection;
EndpointBehaviorElement behaviorElement = behaviorsSection.EndpointBehaviors [behaviorConfig];
int i = 0;
foreach (BehaviorExtensionElement el in behaviorElement)
{
IEndpointBehavior behavior = (IEndpointBehavior)el.CreateBehavior();
Endpoint.Behaviors.Remove(behavior.GetType());
Endpoint.Behaviors.Add(behavior);
}
}
private ChannelFactory GetChannelFactory <T>(string URI, Binding binding, IEndpointBehavior endpointBehavior)
{
string key = typeof(T).FullName + URI;
return(_channels.GetOrAdd(key, k =>
{
var channel = new ChannelFactory <T>(binding);
if (endpointBehavior != null)
{
channel.Endpoint.Behaviors.Add(endpointBehavior);
}
channel.Endpoint.Address = new EndpointAddress(URI);
return channel;
}));
}
internal static ChannelFactory <I> InitializeInstance <S, I>(IServiceBehavior serviceBehavior,
IEndpointBehavior clientBehavior,
NetNamedPipeContextBinding proxyBinding,
NetNamedPipeContextBinding serviceBinding) where I : class
where S : class, I
{
Debug.Assert(proxyBinding != null);
Debug.Assert(serviceBinding != null);
EndpointAddress address = GetAddress <S, I>(serviceBehavior, serviceBinding);
ChannelFactory <I> factory = new ChannelFactory <I>(proxyBinding, address);
factory.AddGenericResolver();
factory.Endpoint.EndpointBehaviors.Add(clientBehavior);
return(factory);
}
public static IEndpoint AddBehavior(this IEndpoint endpoint, IEndpointBehavior behavior)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (behavior == null)
{
throw new ArgumentNullException(nameof(behavior));
}
endpoint.Behaviors.Add(behavior);
return(endpoint);
}
/// <summary>
/// 创建终结点行为
/// </summary>
/// <returns>终结点行为</returns>
public IEndpointBehavior CreateEndpointBehavior()
{
Assembly assembly = System.Reflection.Assembly.Load(this.Assembly);
Type type = assembly.GetType(this.Type);
#region # 验证
if (!typeof(IEndpointBehavior).IsAssignableFrom(type))
{
throw new InvalidOperationException($"类型\"{type.FullName}\"未实现接口\"{nameof(IEndpointBehavior)}\"！");
}
#endregion
IEndpointBehavior endpointBehavior = (IEndpointBehavior)Activator.CreateInstance(type);
return(endpointBehavior);
}
internal static ChannelFactory <I> InitializeInstance <S, I>(IServiceBehavior serviceBehavior,
IEndpointBehavior clientBehavior,
NetNamedPipeContextBinding proxyBinding,
NetNamedPipeContextBinding serviceBinding) where I : class
where S : class, I
{
if (serviceBinding == null)
{
serviceBinding = Binding as NetNamedPipeContextBinding;
}
EndpointAddress address = GetAddress <S, I>(serviceBehavior, serviceBinding);
ChannelFactory <I> factory = new ChannelFactory <I>(proxyBinding, address);
factory.AddGenericResolver(defaultGenericResolverTypes);
factory.Endpoint.EndpointBehaviors.Add(clientBehavior);
return(factory);
}
private static void FillBehaviorInfo(IEndpointBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
{
instance = null;
if (behavior is ClientCredentials)
{
instance = existingInstance.NewInstance("ClientCredentials");
ClientCredentials credentials = (ClientCredentials) behavior;
instance.SetProperty("SupportInteractive", credentials.SupportInteractive);
if ((credentials.ClientCertificate != null) && (credentials.ClientCertificate.Certificate != null))
{
instance.SetProperty("ClientCertificate", credentials.ClientCertificate.Certificate.ToString());
}
if (credentials.IssuedToken != null)
{
string str = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", new object[] { "CacheIssuedTokens", credentials.IssuedToken.CacheIssuedTokens });
instance.SetProperty("IssuedToken", str);
}
if (credentials.HttpDigest != null)
{
string str2 = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", new object[] { "AllowedImpersonationLevel", credentials.HttpDigest.AllowedImpersonationLevel.ToString() });
instance.SetProperty("HttpDigest", str2);
}
if ((credentials.Peer != null) && (credentials.Peer.Certificate != null))
{
instance.SetProperty("Peer", credentials.Peer.Certificate.ToString(true));
}
if (credentials.UserName != null)
{
instance.SetProperty("UserName", "********");
}
if (credentials.Windows != null)
{
string str3 = string.Format(CultureInfo.InvariantCulture, "{0}: {1}, {2}: {3}", new object[] { "AllowedImpersonationLevel", credentials.Windows.AllowedImpersonationLevel.ToString(), "AllowNtlm", credentials.Windows.AllowNtlm });
instance.SetProperty("Windows", str3);
}
}
else if (behavior is MustUnderstandBehavior)
{
instance = existingInstance.NewInstance("MustUnderstandBehavior");
}
else if (behavior is SynchronousReceiveBehavior)
{
instance = existingInstance.NewInstance("SynchronousReceiveBehavior");
}
else if (behavior is DispatcherSynchronizationBehavior)
{
instance = existingInstance.NewInstance("DispatcherSynchronizationBehavior");
}
else if (behavior is TransactedBatchingBehavior)
{
instance = existingInstance.NewInstance("TransactedBatchingBehavior");
instance.SetProperty("MaxBatchSize", ((TransactedBatchingBehavior) behavior).MaxBatchSize);
}
else if (behavior is ClientViaBehavior)
{
instance = existingInstance.NewInstance("ClientViaBehavior");
instance.SetProperty("Uri", ((ClientViaBehavior) behavior).Uri.ToString());
}
else if (behavior is IWmiInstanceProvider)
{
IWmiInstanceProvider provider = (IWmiInstanceProvider) behavior;
instance = existingInstance.NewInstance(provider.GetInstanceType());
provider.FillInstance(instance);
}
else
{
instance = existingInstance.NewInstance("Behavior");
}
if (instance != null)
{
instance.SetProperty("Type", behavior.GetType().FullName);
}
}
static void FillBehaviorInfo(IEndpointBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
{
Fx.Assert(null != existingInstance, "");
Fx.Assert(null != behavior, "");
instance = null;
if (behavior is ClientCredentials)
{
instance = existingInstance.NewInstance("ClientCredentials");
ClientCredentials specificBehavior = (ClientCredentials)behavior;
instance.SetProperty(AdministrationStrings.SupportInteractive, specificBehavior.SupportInteractive);
if (specificBehavior.ClientCertificate != null && specificBehavior.ClientCertificate.Certificate != null)
{
instance.SetProperty(AdministrationStrings.ClientCertificate, specificBehavior.ClientCertificate.Certificate.ToString());
}
if (specificBehavior.IssuedToken != null)
{
string result = String.Format(CultureInfo.InvariantCulture,
"{0}: {1}",
AdministrationStrings.CacheIssuedTokens, specificBehavior.IssuedToken.CacheIssuedTokens);
instance.SetProperty(AdministrationStrings.IssuedToken, result);
}
if (specificBehavior.HttpDigest != null)
{
string result = String.Format(CultureInfo.InvariantCulture,
"{0}: {1}",
AdministrationStrings.AllowedImpersonationLevel, specificBehavior.HttpDigest.AllowedImpersonationLevel.ToString());
instance.SetProperty(AdministrationStrings.HttpDigest, result);
}
if (specificBehavior.Peer != null && specificBehavior.Peer.Certificate != null)
{
instance.SetProperty(AdministrationStrings.Peer, specificBehavior.Peer.Certificate.ToString(true));
}
if (specificBehavior.UserName != null)
{
instance.SetProperty(AdministrationStrings.UserName, "********");
}
if (specificBehavior.Windows != null)
{
#pragma warning disable 618 // To suppress AllowNtlm warning.
string result = String.Format(CultureInfo.InvariantCulture,
"{0}: {1}, {2}: {3}",
AdministrationStrings.AllowedImpersonationLevel,
specificBehavior.Windows.AllowedImpersonationLevel.ToString(),
AdministrationStrings.AllowNtlm,
specificBehavior.Windows.AllowNtlm);
#pragma warning restore 618
instance.SetProperty(AdministrationStrings.Windows, result);
}
}
else if (behavior is MustUnderstandBehavior)
{
instance = existingInstance.NewInstance("MustUnderstandBehavior");
}
else if (behavior is SynchronousReceiveBehavior)
{
instance = existingInstance.NewInstance("SynchronousReceiveBehavior");
}
else if (behavior is DispatcherSynchronizationBehavior)
{
instance = existingInstance.NewInstance("DispatcherSynchronizationBehavior");
}
else if (behavior is TransactedBatchingBehavior)
{
instance = existingInstance.NewInstance("TransactedBatchingBehavior");
instance.SetProperty(AdministrationStrings.MaxBatchSize, ((TransactedBatchingBehavior)behavior).MaxBatchSize);
}
else if (behavior is ClientViaBehavior)
{
instance = existingInstance.NewInstance("ClientViaBehavior");
instance.SetProperty(AdministrationStrings.Uri, ((ClientViaBehavior)behavior).Uri.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);
}
}
private static ServiceHost GetServiceHost(Type serviceType, IEndpointBehavior endpointBehavior, Binding binding, out string baseAddress)
{
ServiceHost host = null;
baseAddress = null;
while (host == null)
{
try
{
baseAddress = string.Format("http://localhost:{0}/SomeBasePath", GetNextPortNumber());
host = new ServiceHost(serviceType, new Uri(baseAddress));
ServiceEndpoint endpoint = host.AddServiceEndpoint(serviceType, binding, string.Empty);
endpoint.Behaviors.Add(endpointBehavior);
host.Open();
}
catch (AddressAlreadyInUseException)
{
host = null;
}
catch (UriFormatException)
{
host = null;
}
}
return host;
}
