private void ValidateConstructorParameters(Type contractInterface, Type realProxyType, String channelId, AddressEndPoint remoteEp) { if (contractInterface == null) { ThrowHelper.ThrowArgumentNullException("contractInterface"); } if (realProxyType == null) { ThrowHelper.ThrowArgumentNullException("realProxyType"); } if (string.IsNullOrEmpty(channelId)) { ThrowHelper.ThrowArgumentNullException("channelId"); } if (!contractInterface.IsAssignableFrom(realProxyType)) { ThrowHelper.ThrowArgumentException("Provided client proxy does not implements the provided contract interface.", "realProxyType"); } if (remoteEp == null) { ThrowHelper.ThrowArgumentNullException("remoteEp"); } if (!ChannelServices.IsChannelRegistered(channelId)) { throw new ChannelNotFoundException(channelId); } ContractValidator.ValidateContractIntegrity(contractInterface); ImplementationValidator.ValidateProxyIntegration(realProxyType); this.mContractInterface = contractInterface; this.mRealProxyType = realProxyType; this.mChannel = ChannelServices.GetChannelById(channelId); this.mRemoteEndPoint = remoteEp; }
/// <summary> /// Registers the contract. /// </summary> /// <param name="contractType">Type of the contract.</param> /// <param name="defaultChannelId">The default channel id.</param> /// <param name="defaultProxyType">Default type of the proxy.</param> /// <exception cref="System.InvalidOperationException">Contract has already registered.</exception> public static void RegisterContract(Type contractType, string defaultChannelId, Type defaultProxyType) { DoInitializeCheck(); if (contractType == null) { ThrowHelper.ThrowArgumentNullException("contractType"); } ContractValidator.ValidateContractIntegrity(contractType); if (!ChannelServices.IsChannelRegistered(defaultChannelId)) { ThrowHelper.ThrowArgumentException("Default channel identifier has not found."); } if (defaultProxyType != null) { ImplementationValidator.ValidateProxyIntegration(defaultProxyType); } lock (mContractDescriptors) { if (mContractDescriptors.ContainsKey(contractType)) { throw new InvalidOperationException("Contract has already registered."); } ContractClientSideDescriptor descriptor = new ContractClientSideDescriptor(contractType, defaultChannelId, defaultProxyType); mContractDescriptors.Add(contractType, descriptor); } }
/// <summary> /// Registers the contract. /// </summary> /// <param name="contractType">Type of the contract.</param> /// <param name="defaultImplementationType">Default type of the implementation.</param> public static void RegisterContract(Type contractType, Type defaultImplementationType) { DoInitializeCheck(); if (contractType == null) { ThrowHelper.ThrowArgumentNullException("contractType"); } ContractValidator.ValidateContractIntegrity(contractType); if (defaultImplementationType != null) { ImplementationValidator.ValidateImplementationIntegrity(defaultImplementationType); } lock (mContractDescriptors) { if (mContractDescriptors.ContainsKey(contractType)) { ThrowHelper.ThrowArgumentException("Contract type has already registered."); } mContractDescriptors.Add(contractType, new ContractServiceSideDescriptor(contractType, defaultImplementationType)); } }
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) }); } }
/// <summary> /// Prevents a default instance of the <see cref="ServiceFactory<TContract>"/> class from being created. /// </summary> /// <param name="channelId">The channel id.</param> /// <param name="implementationType">Type of the implementation.</param> private ServiceFactory(String channelId, Type implementationType) { if (string.IsNullOrEmpty(channelId)) { ThrowHelper.ThrowArgumentNullException("channelId"); } if (implementationType == null) { ThrowHelper.ThrowArgumentNullException("implementationType"); } if (!ServiceContract.IsAssignableFrom(implementationType)) { throw new ArgumentException("Provided implementation does not implements the contract interface.", "implementationType"); } ContractValidator.ValidateContractIntegrity(ServiceContract); ImplementationValidator.ValidateImplementationIntegrity(implementationType); this.mChannel = ChannelServices.GetChannelById(channelId); if (this.mChannel == null) { throw new ChannelNotFoundException(channelId); } this.mImplementationType = implementationType; // adatstruktúra adminisztrációja // egy factory csak azt adhatja hozzá, ami nincs és csak azt veheti el, ami még nem volt. ContractServiceSideDescriptor descriptor = null; Dictionary <Type, ContractServiceSideDescriptor> contractDescriptors = ServiceBaseServices.ContractDescriptors; lock (contractDescriptors) { if (contractDescriptors.ContainsKey(ServiceContract)) { // ismert contract descriptor = contractDescriptors[ServiceContract]; } else { // ilyen contract még nincs mControlServiceContract = true; mControlChannel = true; } } if (descriptor != null) { lock (descriptor) { if (!descriptor.ImplementationPerChannel.ContainsKey(channelId)) { mControlChannel = true; } else { if (descriptor.ImplementationPerChannel.ContainsKey(channelId)) { // ehhez a csatornához és contracthoz már egy másik implementáció van rendelve Type currentImplType = descriptor.ImplementationPerChannel[channelId]; if (!currentImplType.Equals(implementationType)) { throw new ArgumentException(String.Format("Unable to register provided implementation type: '{0}'. An other implementation type '{1}' has already definied for channel '{2}' and contract '{3}'.", implementationType.FullName, currentImplType.FullName, channelId, ServiceContract.FullName)); } } } } } ChannelServices.UnregisterChannelEvent += new EventHandler <ChannelRegistrationEventArgs>(ChannelUnregisteredEventHandler); }
/// <summary> /// Initializes a new instance of the <see cref="ProxyGenerator<TContract>"/> class. /// </summary> public ProxyGenerator() { ContractValidator.ValidateContractIntegrity(ContractType); ContractValidator.GetWellKnownObjectMode(ContractType, out mWellKnownObjectMode); }
public static void Initialize() { if (!mInitialized) { Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.Before) }); ChannelServices.Initialize(); if (LOGGER.IsInfoEnabled) { LOGGER.Info("Initializing client proxy services."); } CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, "Clients"); if (pi != null) { try { IEnumerator <CategoryPropertyItem> iterator = pi.GetEnumerator(); 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; String defaultChannelId = null; Type defaultProxyType = null; try { contractType = TypeHelper.GetTypeFromString(pi.Id); if (mContractDescriptors.ContainsKey(contractType)) { throw new InvalidConfigurationException(String.Format("Duplicated contract type configuration found in clients. Contract: {0}", contractType.FullName)); } ContractValidator.ValidateContractIntegrity(contractType); } catch (Exception ex) { throw new InvalidConfigurationValueException(String.Format("Unable to resolve contract type: {0}", pi.Id), ex); } { CategoryPropertyItem defaultChannelIdPropertyItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, String.Format("Clients/{0}/Defaults/DefaultChannelId", pi.Id)); if (defaultChannelIdPropertyItem != null) { defaultChannelId = defaultChannelIdPropertyItem.EntryValue; if (string.Empty.Equals(defaultChannelId)) { defaultChannelId = null; } } } { CategoryPropertyItem defaultProxyTypePropertyItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, String.Format("Clients/{0}/Defaults/DefaultProxyType", pi.Id)); if (defaultProxyTypePropertyItem != null) { if (defaultProxyTypePropertyItem.EntryValue != null && !string.Empty.Equals(defaultProxyTypePropertyItem.EntryValue)) { try { defaultProxyType = TypeHelper.GetTypeFromString(defaultProxyTypePropertyItem.EntryValue); ImplementationValidator.ValidateProxyIntegration(defaultProxyType); } catch (Exception ex) { throw new InvalidConfigurationValueException(String.Format("Unable to resolve proxy type: {0} for contract: {1}", defaultProxyTypePropertyItem.EntryValue, pi.Id), ex); } } } } if (!(defaultChannelId == null && defaultProxyType == null)) { if (defaultChannelId == null || defaultProxyType == null) { throw new InvalidConfigurationException(String.Format("Both of 'DefaultChannelId' and 'DefaultProxyType' values are must be filled in configuration. Contract type: {0}", pi.Id)); } if (!contractType.IsAssignableFrom(defaultProxyType)) { throw new InvalidProxyImplementationException(String.Format("Provided default proxy type '{0}' does not implement contract interface '{1}'.", defaultProxyType.FullName, contractType.FullName)); } } ContractClientSideDescriptor descriptor = new ContractClientSideDescriptor(contractType, defaultChannelId, defaultProxyType); { CategoryPropertyItem customDefinitionsPropertyItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, String.Format("Clients/{0}/CustomDefinitions", pi.Id)); if (customDefinitionsPropertyItem != null) { IEnumerator <CategoryPropertyItem> customDefinitionsIterator = customDefinitionsPropertyItem.GetEnumerator(); while (customDefinitionsIterator.MoveNext()) { CategoryPropertyItem channelProxyItem = customDefinitionsIterator.Current; if (string.IsNullOrEmpty(channelProxyItem.Id)) { throw new InvalidConfigurationValueException(String.Format("Channel identifier is missing from a configuration item at the CustomDefinitions of the contract '{0}'", pi.Id)); } if (string.IsNullOrEmpty(channelProxyItem.EntryValue)) { throw new InvalidConfigurationValueException(String.Format("Proxy type is missing from a configuration item at the CustomDefinitions of the contract '{0}'", pi.Id)); } if (!ChannelServices.IsChannelRegistered(channelProxyItem.Id)) { throw new InvalidConfigurationValueException(String.Format("Unregistered channel provided '{0}' in CustomDefinitions configuration section of the contract: {1}.", channelProxyItem.Id, pi.Id)); } Type type = null; try { type = TypeHelper.GetTypeFromString(channelProxyItem.EntryValue); if (!contractType.IsAssignableFrom(type)) { throw new InvalidProxyImplementationException(String.Format("Provided proxy type '{0}' does not implement contract interface '{1}'.", type.FullName, contractType.FullName)); } ImplementationValidator.ValidateProxyIntegration(type); } catch (Exception ex) { throw new InvalidConfigurationValueException(String.Format("Unable to resolve non-default proxy type: {0} for contract: {1} for the channel: {2}", channelProxyItem.EntryValue, pi.Id, channelProxyItem.Id), ex); } if (descriptor.ImplementationPerChannel.ContainsKey(channelProxyItem.Id)) { throw new InvalidConfigurationException(String.Format("Duplicated channel identifier in CustomDefinitions section at contract '{0}'.", pi.Id)); } descriptor.ImplementationPerChannel.Add(channelProxyItem.Id, type); } } } mContractDescriptors.Add(contractType, descriptor); } mSingletonInstance = new ProxyServices(); //if (mContractDescriptors.Count > 0) //{ // mSingletonInstance = new ProxyServices(); //} } catch (Exception ex) { mContractDescriptors.Clear(); throw ex; } } //ChannelServices.startListeningChannels(); mInitialized = true; if (LOGGER.IsInfoEnabled) { LOGGER.Info("Client proxy services successfully initialized."); } Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.After) }); } }