public ConfigurationDiscoveryEndpointProvider(ChannelEndpointElement channelEndpointElement)
{
Fx.Assert(channelEndpointElement != null, "The channelEndpointElement parameter must be non null.");
ConfigurationDiscoveryEndpointProvider.ValidateAndGetDiscoveryEndpoint(channelEndpointElement);
this.channelEndpointElement = channelEndpointElement;
}
static DiscoveryEndpoint ValidateAndGetDiscoveryEndpoint(ChannelEndpointElement channelEndpointElement)
{
if (string.IsNullOrEmpty(channelEndpointElement.Kind))
{
throw FxTrace.Exception.AsError(
new ConfigurationErrorsException(
SR2.DiscoveryConfigDiscoveryEndpointMissingKind(
typeof(DiscoveryEndpoint).FullName)));
}
ServiceEndpoint serviceEndpoint = ConfigLoader.LookupEndpoint(channelEndpointElement, null);
if (serviceEndpoint == null)
{
throw FxTrace.Exception.AsError(
new ConfigurationErrorsException(
SR2.DiscoveryConfigInvalidEndpointConfiguration(
channelEndpointElement.Kind)));
}
DiscoveryEndpoint discoveryEndpoint = serviceEndpoint as DiscoveryEndpoint;
if (discoveryEndpoint == null)
{
throw FxTrace.Exception.AsError(
new InvalidOperationException(
SR2.DiscoveryConfigInvalidDiscoveryEndpoint(
typeof(DiscoveryEndpoint).FullName,
channelEndpointElement.Kind,
serviceEndpoint.GetType().FullName)));
}
return(discoveryEndpoint);
}
public CodeTypeReference GenerateServiceEndpoint(
ServiceEndpoint endpoint,
out ChannelEndpointElement channelElement)
{
if (config == null)
{
throw new InvalidOperationException();
}
var cd = endpoint.Contract;
var cns = GetNamespace(cd.Namespace);
var cache = ExportInterface_internal(cd, cns);
string bindingSectionName, configurationName;
GenerateBinding(endpoint.Binding, out bindingSectionName, out configurationName);
channelElement = new ChannelEndpointElement();
channelElement.Binding = bindingSectionName;
channelElement.BindingConfiguration = configurationName;
channelElement.Name = configurationName;
channelElement.Contract = cache.ConfigurationName;
channelElement.Address = endpoint.Address.Uri;
var section = (ClientSection)config.GetSection("system.serviceModel/client");
section.Endpoints.Add(channelElement);
return(cache.GetReference());
}
protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ChannelEndpointElement serviceEndpointElement)
{
DynamicEndpoint dynamicEndpoint = (DynamicEndpoint)endpoint;
if (!dynamicEndpoint.ValidateAndInsertDiscoveryClientBindingElement(dynamicEndpoint.Binding))
{
throw FxTrace.Exception.AsError(new ConfigurationErrorsException(SR.DiscoveryClientBindingElementPresentInDynamicEndpoint));
}
if (PropertyValueOrigin.Default == this.DiscoveryClientSettings.ElementInformation.Properties[ConfigurationStrings.Endpoint].ValueOrigin)
{
dynamicEndpoint.DiscoveryEndpointProvider = new ConfigurationDiscoveryEndpointProvider();
}
else
{
dynamicEndpoint.DiscoveryEndpointProvider = new ConfigurationDiscoveryEndpointProvider(this.DiscoveryClientSettings.DiscoveryEndpoint);
}
this.DiscoveryClientSettings.FindCriteria.ApplyConfiguration(dynamicEndpoint.FindCriteria);
if (dynamicEndpoint.FindCriteria.ContractTypeNames.Count == 0)
{
dynamicEndpoint.FindCriteria.ContractTypeNames.Add(
new XmlQualifiedName(dynamicEndpoint.Contract.Name, dynamicEndpoint.Contract.Namespace));
}
}
/// <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>
/// LookupEndpoint
/// </summary>
/// <param name="endpointName"></param>
/// <returns></returns>
private string LookupEndpoint(string endpointName)
{
if (string.IsNullOrWhiteSpace(endpointName))
{
return("*");
}
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
ClientSection clientSection = ServiceModelSectionGroup.GetSectionGroup(config).Client;
ChannelEndpointElement endpointElement = null;
foreach (ChannelEndpointElement element in clientSection.Endpoints)
{
if (element.Name.EndsWith("_" + endpointName, StringComparison.OrdinalIgnoreCase) &&
element.Contract == typeof(TChannel).FullName)
{
endpointElement = element;
break;
}
}
if (endpointElement == null)
{
return("*");
}
return(endpointElement.Name);
}
private EndpointAddress CreateEndpointAddress(
ChannelEndpointElement clientEndpointElem)
{
EndpointIdentity identity = GetIdentity(clientEndpointElem.Identity);
return(new EndpointAddress(clientEndpointElem.Address, identity, clientEndpointElem.Headers.Headers));
}
/// <summary>
/// Updates an existing endpoint address in the assigned <see cref="SectionHandler{T}.ConfigSection"/> with a new name and a new address. The old
/// endpoint can be located using the <paramref name="oldItem"/> parameter. If an old endpoint is not found, a new endpoint
/// should be inserted.
/// </summary>
/// <param name="newKey">The updated key name for the endpoint.</param>
/// <param name="newValue">The updated value for the endpoint.</param>
/// <param name="oldKey">The old key name for the endpoint, or null.</param>
/// <param name="oldItem">A reference to the old <see cref="ChannelEndpointElement"/> object obtained by <see cref="GetEnumerator"/>, or null.</param>
public override void InsertOrUpdate(string newKey, string newValue, string oldKey = null, object oldItem = null)
{
if (newValue != null)
{
ChannelEndpointElement[] endpoints = new ChannelEndpointElement[ConfigSection.Endpoints.Count];
ConfigSection.Endpoints.CopyTo(endpoints, 0);
var oldKeyEndpoint = endpoints.FirstOrDefault(x => x.Name == oldKey);
// Preserve the old entry if it exists, as it might have more than just name/address attributes.
var cee = (oldItem as ChannelEndpointElement) ?? oldKeyEndpoint;
var newKeyEndpoint = endpoints.FirstOrDefault(x => x.Name == newKey);
// Make sure there are no entries using the old or new name other than this one
if (oldKeyEndpoint != null)
{
ConfigSection.Endpoints.Remove(oldKeyEndpoint);
}
if (oldKey != newKey && newKeyEndpoint != null)
{
ConfigSection.Endpoints.Remove(newKeyEndpoint);
}
// Update values and re-add to the collection
cee.Name = newKey;
cee.Address = new Uri(newValue);
ConfigSection.Endpoints.Add(cee);
}
}
private void UpdateServiceAddress(string address, string endpointName)
{
Configuration config = ConfigurationManager.OpenExeConfiguration(System.Reflection.Assembly.GetExecutingAssembly().Location);
ClientSection clientSection = (ClientSection)config.GetSection("system.serviceModel/client");
ChannelEndpointElement endpointElement = null;
foreach (ChannelEndpointElement element in clientSection.Endpoints)
{
if (element.Name == endpointName)
{
endpointElement = element;
break;
}
}
if (endpointElement != null)
{
endpointElement.Address = new Uri(string.Format("{0}://{1}:{2}{3}",
endpointElement.Address.Scheme,
address,
endpointElement.Address.Port.ToString(),
endpointElement.Address.AbsolutePath));
config.Save();
ConfigurationManager.RefreshSection("system.serviceModel/client");
}
else
{
throw new ApplicationException(string.Format("Could not find {0} endpoint configuration section", endpointName));
}
}
internal static void InitializeAndValidateUdpChannelEndpointElement(ChannelEndpointElement channelEndpointElement)
{
if (!(channelEndpointElement.Address == null || String.IsNullOrEmpty(channelEndpointElement.Address.ToString())))
{
throw FxTrace.Exception.AsError(new ConfigurationErrorsException(SR2.DiscoveryConfigAddressSpecifiedForUdpDiscoveryEndpoint(channelEndpointElement.Kind)));
}
channelEndpointElement.Address = null;
}
public ClientServiceWrapper(string baseUrl, string configurationName)
{
BaseUrl = baseUrl;
ConfigurationName = configurationName;
EndpointElement = GetEndPointElement(configurationName);
Factory = new ChannelFactory <TService>(EndpointElement.Name);
Service = CreateService(baseUrl, Factory, EndpointElement);
}
public static string GetServiceUrl()
{
ClientSection clientSection = (ClientSection)WebConfigurationManager.GetSection("system.serviceModel/client");
ChannelEndpointElement endpoint = clientSection.Endpoints[0];
string address = endpoint.Address.ToString();
return(address.Substring(0, address.LastIndexOf("/")));
}
/// <summary>
/// When called from a derived class, loads the service description information
/// from the configuration file and applies it to the runtime being constructed.
/// </summary>
/// <param name="endpoint">And endpoint that enables clients to find and communicate with a service.</param>
/// <param name="channelEndpointElement">An endpoint element that defined the physical
/// transfer of messages ack and forth between the client and the service.</param>
protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ChannelEndpointElement channelEndpointElement)
{
throw Fx.Exception.AsError(
new NotSupportedException(
Http.SR.HttpEndpointNotSupported(
httpEndpointType.Name,
httpClientType.Name)));
}
/// <summary>
/// When called from a derived class, initializes and verifies the format of the
/// specified service endpoint element in a service application configuration file.
/// </summary>
/// <param name="channelEndpointElement">An endpoint element that defineds the physical transfer
/// of messages back and forth between the client and the service.</param>
protected override void OnInitializeAndValidate(ChannelEndpointElement channelEndpointElement)
{
throw Fx.Exception.AsError(
new NotSupportedException(
Http.SR.HttpEndpointNotSupported(
httpEndpointType.Name,
httpClientType.Name)));
}
public void CanGetClientEndpoint()
{
ServiceModelConfigurationManager manager = LoadManager();
ChannelEndpointElement endpoint = manager.GetEndpoint(Constants.ServiceDescription.ClientEndpointName);
Assert.AreEqual(Constants.ServiceDescription.ClientEndpointName, endpoint.Name);
Assert.AreEqual(Constants.ServiceDescription.ClientBehaviorConfiguration, endpoint.BehaviorConfiguration);
Assert.AreEqual(Constants.ServiceDescription.ClientBindingName, endpoint.Binding);
}
private static Type GetChannelType(ChannelEndpointElement endpointElement)
{
ChannelEndpointElement element = endpointElement;
return((from asm in AppDomain.CurrentDomain.GetAssemblies()
let contractType = asm.GetType(element.Contract)
where contractType != null
select contractType)
.FirstOrDefault());
}
/// <summary>
/// Gets an <see cref="IEnumerator{T}"/> that iterates over the key/value pairs contained in the assigned <see cref="SectionHandler{T}.ConfigSection"/>. />
/// </summary>
/// <returns>An enumerator over pairs where the key is the existing name for each setting in the system.serviceModel/client section, and the value
/// is a reference to the <see cref="ChannelEndpointElement"/> object referred to by that name.</returns>
public override IEnumerator <KeyValuePair <string, object> > GetEnumerator()
{
// The Endpoints collection may change on us while we enumerate. :/
ChannelEndpointElement[] endpoints = new ChannelEndpointElement[ConfigSection.Endpoints.Count];
ConfigSection.Endpoints.CopyTo(endpoints, 0);
foreach (ChannelEndpointElement cee in endpoints)
{
yield return(new KeyValuePair <string, object>(cee.Name, cee));
}
}
/// <summary>
/// Loads the serviceEndpoint description from the specified configuration file
/// </summary>
/// <returns></returns>
protected override ServiceEndpoint CreateDescription()
{
ServiceEndpoint serviceEndpoint = base.CreateDescription();
ExeConfigurationFileMap map = GetExeConfigurationFileMap(serviceEndpoint);
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
ServiceModelSectionGroup group = ServiceModelSectionGroup.GetSectionGroup(config);
ChannelEndpointElement selectedEndpoint = GetSelectedEndpoint(group, serviceEndpoint);
SetSelectedEndpoint(selectedEndpoint, group, serviceEndpoint);
return(serviceEndpoint);
}
public static TServiceContract CreateService <TServiceContract>(string bindingName)
{
ChannelEndpointElement endpoint = ConfigHelper.GetEndpoint(bindingName);
if (endpoint == null)
{
throw new Exception("Endpoint not found!");
}
return(CreateService <TServiceContract>(endpoint.Address.ToString(), endpoint.Binding));
}
/// <summary>
/// Loads the serviceEndpoint description from the specified configuration file
/// </summary>
/// <returns>
/// The <see cref="ServiceEndpoint"/>.
/// </returns>
protected override ServiceEndpoint CreateDescription()
{
var serviceEndpoint = base.CreateDescription();
if (endpointConfigurationName != null)
{
serviceEndpoint.Name = endpointConfigurationName;
}
var map = new ExeConfigurationFileMap();
map.ExeConfigFilename = configurationPath;
var config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
var group = ServiceModelSectionGroup.GetSectionGroup(config);
ChannelEndpointElement selectedEndpoint = null;
foreach (ChannelEndpointElement endpoint in group.Client.Endpoints)
{
if (endpoint.Contract == serviceEndpoint.Contract.ConfigurationName &&
(endpointConfigurationName == null || endpointConfigurationName == endpoint.Name))
{
selectedEndpoint = endpoint;
break;
}
}
if (selectedEndpoint != null)
{
if (serviceEndpoint.Binding == null)
{
serviceEndpoint.Binding = CreateBinding(selectedEndpoint.Binding, group);
}
if (serviceEndpoint.Address == null)
{
serviceEndpoint.Address = new EndpointAddress(
selectedEndpoint.Address,
GetIdentity(selectedEndpoint.Identity),
selectedEndpoint.Headers.Headers);
}
if (serviceEndpoint.Behaviors.Count == 0 && selectedEndpoint.BehaviorConfiguration != null)
{
AddBehaviors(selectedEndpoint.BehaviorConfiguration, serviceEndpoint, group);
}
serviceEndpoint.Name = selectedEndpoint.Contract;
}
return(serviceEndpoint);
}
public void TestEmptyProps()
{
ChannelEndpointElement empty = new ChannelEndpointElement();
Assert.AreEqual("", empty.Name, "#01");
Assert.AreEqual(null, empty.Contract, "#02");
Assert.AreEqual(null, empty.Binding, "#03");
Assert.AreEqual(null, empty.Address, "#04");
Assert.AreEqual("", empty.BindingConfiguration, "#05");
Assert.AreEqual("", empty.BehaviorConfiguration, "#06");
Assert.IsNotNull(empty.Headers, "#07");
Assert.IsNotNull(empty.Identity, "#08");
}
public static ChannelEndpointElement GetServiceModelEndpoint(String name)
{
ClientSection clientSection = ConfigurationManager.GetSection("system.serviceModel/client") as ClientSection;
List<ChannelEndpointElement> channelEndpointElements = new List<ChannelEndpointElement>();
foreach (ChannelEndpointElement endpointElement in clientSection.Endpoints)
{
channelEndpointElements.Add(endpointElement);
}
ChannelEndpointElement channelEndpointElement = channelEndpointElements.Single(x => x.Name == name);
return channelEndpointElement;
}
private ChannelEndpointElement CreateEndPoint(string name, string address, string binding, string bindingConfiguration, string contract)
{
Uri addressUri = new Uri(address);
ChannelEndpointElement endpoint = new ChannelEndpointElement();
endpoint.Name = name;
endpoint.Binding = binding;
endpoint.BindingConfiguration = bindingConfiguration;
endpoint.Address = addressUri;
endpoint.Contract = contract;
return(endpoint);
}
public void Endpoints()
{
ServiceModelSectionGroup g = GetConfig("Test/config/test1");
ChannelEndpointElementCollection col = g.Client.Endpoints;
Assert.AreEqual(1, col.Count, "initial count");
ChannelEndpointElement e = col [0];
Assert.AreEqual(String.Empty, e.Name, "0.Name");
Assert.AreEqual("IFoo", e.Contract, "0.Contract");
Assert.AreEqual("basicHttpBinding", e.Binding, "0.Binding");
col.Add(new ChannelEndpointElement());
Assert.AreEqual(2, col.Count, "after Add()");
}
internal ChannelEndpointElement WriteChannelDescription(ServiceEndpoint endpoint, string typeName)
{
ChannelEndpointElement element = null;
BindingDictionaryValue value2 = this.CreateBindingConfig(endpoint.Binding);
element = new ChannelEndpointElement(endpoint.Address, typeName)
{
Name = NamingHelper.GetUniqueName(NamingHelper.CodeName(endpoint.Name), new NamingHelper.DoesNameExist(this.CheckIfChannelNameInUse), null),
BindingConfiguration = value2.BindingName,
Binding = value2.BindingSectionName
};
this.channels.Add(element);
return(element);
}
internal static Client <ProvisioningServiceClient> ConstructProvisioningServiceClient(string endpointConfigName, string userName, string userPassword)
{
ProvisioningServiceClient client = null;
ChannelEndpointElement channelEE = _configDictionary[typeof(ProvisioningService).FullName].Find(delegate(ChannelEndpointElement cee) { return(cee.Name == endpointConfigName); });
if (null != channelEE)
{
client = new ProvisioningServiceClient(endpointConfigName, channelEE.Address.ToString());
client.ClientCredentials.UserName.UserName = userName;
client.ClientCredentials.UserName.Password = userPassword;
}
return(ClientFactory.CreateClient <ProvisioningServiceClient, ProvisioningService>(client));
}
internal static ReportingV200810ClientProxy.ReportServiceClient ConstructReportServiceClientV200810(string endpointConfigName, string userName, string userPassword)
{
ReportingV200810ClientProxy.ReportServiceClient client = null;
ChannelEndpointElement channelEE = _configDictionary[typeof(ReportingV200810ClientProxy.IReportService).FullName].Find(delegate(ChannelEndpointElement cee) { return(cee.Name == endpointConfigName); });
if (null != channelEE)
{
client = new ReportingV200810ClientProxy.ReportServiceClient(endpointConfigName, channelEE.Address.ToString());
client.ClientCredentials.UserName.UserName = userName;
client.ClientCredentials.UserName.Password = userPassword;
}
return(client);
}
protected override ServiceEndpoint CreateDescription()
{
ServiceEndpoint serviceEndpoint = base.CreateDescription();
serviceEndpoint.Name = string.IsNullOrEmpty(this.endpointConfigurationName)
? string.Empty
: this.endpointConfigurationName;
Configuration config =
ConfigurationManager.OpenMappedExeConfiguration(
new ExeConfigurationFileMap {
ExeConfigFilename = this.configurationPath
},
ConfigurationUserLevel.None);
ServiceModelSectionGroup sectionGroup = ServiceModelSectionGroup.GetSectionGroup(config);
ChannelEndpointElement channelEndpointElement = null;
if (sectionGroup != null)
{
foreach (ChannelEndpointElement channelEndpointElement2 in sectionGroup.Client.Endpoints)
{
if (channelEndpointElement2.Contract == serviceEndpoint.Contract.ConfigurationName &&
(this.endpointConfigurationName == null ||
this.endpointConfigurationName == channelEndpointElement2.Name))
{
channelEndpointElement = channelEndpointElement2;
break;
}
}
if (channelEndpointElement != null)
{
if (serviceEndpoint.Binding == null)
{
serviceEndpoint.Binding = this.CreateBinding(channelEndpointElement.Binding, sectionGroup);
}
if (serviceEndpoint.Address == null)
{
serviceEndpoint.Address = new EndpointAddress(
channelEndpointElement.Address,
this.GetIdentity(channelEndpointElement.Identity),
channelEndpointElement.Headers.Headers);
}
if (serviceEndpoint.Behaviors.Count == 0 && channelEndpointElement.BehaviorConfiguration != null)
{
this.AddBehaviors(channelEndpointElement.BehaviorConfiguration, serviceEndpoint, sectionGroup);
}
serviceEndpoint.Name = channelEndpointElement.Contract;
}
}
return(serviceEndpoint);
}
public static IClientChannel GetClientConfigChannel <T>(string name, string host = "")
{
ClientSection clientSection = ConfigurationManager.GetSection("system.serviceModel/client") as ClientSection;
if (clientSection == null)
{
throw new Exception("Errore nella configurazione WCF. Aggiungere la sezione system.serviceModel/client.");
}
ChannelEndpointElement endpoint = clientSection.Endpoints.OfType <ChannelEndpointElement>().FirstOrDefault(x => x.Name == name);
if (endpoint == null)
{
throw new Exception($"Errore nella configurazione WCF. Aggiungere la sezione endpoint con chiave: {name}.");
}
Binding binding = null;
switch (endpoint.Binding)
{
case "basicHttpBinding":
binding = (BasicHttpBinding)GetBinding(typeof(BasicHttpBinding), endpoint.BindingConfiguration);
break;
case "wsHttpBinding":
binding = (WSHttpBinding)GetBinding(typeof(WSHttpBinding), endpoint.BindingConfiguration);
break;
case "netNamedPipeBinding":
binding = (NetNamedPipeBinding)GetBinding(typeof(NetNamedPipeBinding), endpoint.BindingConfiguration);
break;
case "netTcpBinding":
binding = (NetTcpBinding)GetBinding(typeof(NetTcpBinding), endpoint.BindingConfiguration);
break;
default:
throw new Exception($"Errore nella configurazione WCF. Binding non supportato: {endpoint.Binding}.");
}
string address = endpoint.Address.ToString();
if (!string.IsNullOrEmpty(host))
{
string hostName = endpoint.Address.Host;
address = address.Replace(hostName, host);
}
return((IClientChannel)CreateChannelFactory <T>(address, binding).CreateChannel());
}
public void AddMachineConfigurationInfo()
{
System.Configuration.Configuration config = ConfigurationManager.OpenMachineConfiguration();
Debug.Assert(config != null, "Machine.Config returned null");
ServiceModelSectionGroup sectionGroup = config.GetSectionGroup("system.serviceModel") as ServiceModelSectionGroup;
if (sectionGroup != null)
{
bool channelEndpointElementExists = false;
ClientSection clientSection = sectionGroup.Client;
foreach (ChannelEndpointElement elem in clientSection.Endpoints)
{
if (elem.Binding.Equals(BINDING_NAME, StringComparison.OrdinalIgnoreCase) && elem.Name.Equals(BINDING_SCHEME, StringComparison.OrdinalIgnoreCase) && elem.Contract.Equals("IMetadataExchange", StringComparison.OrdinalIgnoreCase))
{
channelEndpointElementExists = true;
break;
}
}
if (!channelEndpointElementExists)
{
Debug.WriteLine("Adding ChannelEndpointElement for : " + BINDING_NAME);
ChannelEndpointElement elem = new ChannelEndpointElement();
elem.Binding = BINDING_NAME;
elem.Name = BINDING_SCHEME;
elem.Contract = "IMetadataExchange";
sectionGroup.Client.Endpoints.Add(elem);
Debug.WriteLine("Added ChannelEndpointElement for : " + BINDING_NAME);
}
if (!sectionGroup.Extensions.BindingElementExtensions.ContainsKey(BINDINGELEM_NAME))
{
ExtensionElement ext = new ExtensionElement(BINDINGELEM_NAME, bindingElementExtensionType.FullName + "," + bindingElementExtensionType.Assembly.FullName);
sectionGroup.Extensions.BindingElementExtensions.Add(ext);
}
if (!sectionGroup.Extensions.BindingExtensions.ContainsKey(BINDING_NAME))
{
ExtensionElement ext = new ExtensionElement(BINDING_NAME, bindingSectionType.FullName + "," + bindingSectionType.Assembly.FullName);
sectionGroup.Extensions.BindingExtensions.Add(ext);
}
config.Save();
}
else
{
throw new InstallException("Machine.Config doesn't contain system.serviceModel node");
}
}
