public static void Initialize()
{
if (!mInitialized)
{
Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.Before) });
ChannelServices.Initialize();
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("Initializing ServiceBase services.");
}
CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, "Services");
if (pi != null)
{
IEnumerator <CategoryPropertyItem> iterator = pi.GetEnumerator();
try
{
while (iterator.MoveNext())
{
pi = iterator.Current;
if (string.IsNullOrEmpty(pi.Id))
{
throw new InvalidConfigurationException("Contract type not definied. Empty item found in configuration.");
}
Type contractType = null;
Type defaultImplementationType = null;
try
{
contractType = TypeHelper.GetTypeFromString(pi.Id);
if (ContractDescriptors.ContainsKey(contractType))
{
throw new InvalidConfigurationException(String.Format("Duplicated contract type configuration found in services. Contract: {0}", contractType.FullName));
}
ContractValidator.ValidateContractIntegrity(contractType);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve contract type: {0}", pi.Id), ex);
}
if (!string.IsNullOrEmpty(pi.EntryValue))
{
try
{
defaultImplementationType = TypeHelper.GetTypeFromString(pi.EntryValue);
if (!contractType.IsAssignableFrom(defaultImplementationType))
{
throw new InvalidProxyImplementationException(String.Format("Provided default implementation type '{0}' does not implement contract interface '{1}'.", defaultImplementationType.FullName, contractType.FullName));
}
ImplementationValidator.ValidateImplementationIntegrity(defaultImplementationType);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve implementation type: {0}", pi.EntryValue), ex);
}
}
ContractServiceSideDescriptor descriptor = new ContractServiceSideDescriptor(contractType, defaultImplementationType);
IEnumerator <CategoryPropertyItem> channelIterator = pi.GetEnumerator();
while (channelIterator.MoveNext())
{
CategoryPropertyItem channelImplementationItem = channelIterator.Current;
if (string.IsNullOrEmpty(channelImplementationItem.Id))
{
throw new InvalidConfigurationValueException(String.Format("Channel identifier is missing from a configuration item of the contract '{0}'", pi.Id));
}
if (string.IsNullOrEmpty(channelImplementationItem.EntryValue))
{
throw new InvalidConfigurationValueException(String.Format("Implementation type is missing from a configuration item of the contract '{0}'", pi.Id));
}
if (!ChannelServices.IsChannelRegistered(channelImplementationItem.Id))
{
throw new InvalidConfigurationValueException(String.Format("Unregistered channel provided '{0}' in configuration section of the contract: {1}.", channelImplementationItem.Id, pi.Id));
}
Type type = null;
try
{
type = TypeHelper.GetTypeFromString(channelImplementationItem.EntryValue);
if (!contractType.IsAssignableFrom(type))
{
throw new InvalidProxyImplementationException(String.Format("Provided implementation type '{0}' does not implement contract interface '{1}'.", type.FullName, contractType.FullName));
}
ImplementationValidator.ValidateImplementationIntegrity(type);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve non-default implementation type: {0} for contract: {1} for the channel: {2}", channelImplementationItem.EntryValue, pi.Id, channelImplementationItem.Id), ex);
}
if (descriptor.ImplementationPerChannel.ContainsKey(channelImplementationItem.Id))
{
throw new InvalidConfigurationException(String.Format("Duplicated channel identifier at contract '{0}'.", pi.Id));
}
descriptor.ImplementationPerChannel.Add(channelImplementationItem.Id, type);
}
ContractDescriptors.Add(contractType, descriptor);
}
ChannelServices.StartListeningChannels();
}
catch (Exception ex)
{
ContractDescriptors.Clear();
throw ex;
}
}
mInitialized = true;
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("ServiceBase services successfully initialized.");
}
Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.After) });
}
}
