예제 #1
0
        /// <summary>
        /// Register a WCF client proxy for the given service interface with the IOC. The service
        /// will be contacted at the given URI.
        /// </summary>
        /// <remarks>
        /// <para>
        /// To register different endpoint behaviours the behaviour must be added to the clientModel (not the endpoint directly like the service registration).
        /// Adding the endpoint behaviours directly to the endpoint will not invoke the endpoint behaviours.
        /// </para>
        /// </remarks>
        /// <typeparam name="T">service interface</typeparam>
        /// <param name="k">IoC kernel to register to</param>
        /// <param name="uri">service URI</param>
        /// <param name="streamed">true if streaming must be supported</param>
        /// <param name="maxMsg">maximum message size supported</param>
        /// <param name="sendTimeout">WCF proxy timeout to send a message</param>
        /// <param name="receiveTimeout">WCF proxy timeout to receive a message</param>
        /// <param name="useExternalEndpointBehaviour">Optional: Flag to add external endpoint behaviour (<c>true</c>) or the default endpoint behaviour. Default: false</param>

        public void RegisterWCFClientProxy <T>(string uri, bool streamed, int maxMsg, TimeSpan sendTimeout, TimeSpan receiveTimeout, bool useExternalEndpointBehaviour) where T : class
        {
            var endPoint = GetEndpoint(uri, streamed, maxMsg, sendTimeout, receiveTimeout);

            try
            {
                var clientModel = new DefaultClientModel()
                {
                    Endpoint = endPoint.At(uri)
                };
                clientModel = clientModel.WithoutAsyncCapability();
                var endpointBehaviour = this.CreateEndpointBehaviour(useExternalEndpointBehaviour);
                clientModel.AddExtensions(endpointBehaviour);

                Kernel.Register(Component
                                .For <T>()
                                .LifeStyle.Transient
                                .AsWcfClient(clientModel)
                                );

                Logger.InfoFormat("WCF CLIENT proxy registered at [{0}]: Endpoint-Behaviour-Count: {1}, Use-External-EndpointBehaviour = '{2}.'", uri, clientModel.Extensions.Count(), useExternalEndpointBehaviour.ToString());
            }
            catch (Exception ex)
            {
                var msg = string.Format("Error: WCF client proxy registration failed at address = [{0}], useExternalEndpointBehaviour = '{1}', Ex='{2}'", uri, useExternalEndpointBehaviour.ToString(), ex.ToString());
                Logger.Fatal(msg);
                IoCSetup.ShutdownAndExit(msg, 1);
            }
        }
예제 #2
0
파일: DBC.cs 프로젝트: Oshchenkov/moss
        /// <summary>
        /// If in debug mode, shut the application down before throwing an assertion exception.
        /// Otherwise just throw an assertion exception.
        /// </summary>
        /// <remarks>
        /// IoCSetup.Shutdown() is asynchronous. That is, control may return from the shutdown
        /// call which in turn measns control will return from assert. Previously, we just
        /// allowed a normal return in this situation with the result that code *after* the
        /// assert would continue to execute for a small time window (i.e. until the async
        /// shutdown completed). Allowing code to execute after an assert is bad, so now
        /// we always thrown an exception.
        /// </remarks>

        private static void ShutdownIfNeededAndThrow(string msg)
        {
            #if DEBUG
            IoCSetup.ShutdownAndExit("Shutting down - " + msg, 1);
            Thread.Sleep(1000);
            #endif

            throw new AssertException(msg);
        }
예제 #3
0
        /// <summary>
        /// Register a WCF service and implementation with the IoC
        /// </summary>
        /// <para>
        /// WCF configuration is finicky. If you want metadata published, you need to use BaseAddresses rather
        /// than configuring the endpoint with .At() -- which is the interface that most examples use. Also,
        /// metadata cannot be published over the Net.Tcp transport; it only works over Http. So if you are
        /// using Net.Tcp and want metadata published then you have to have an Http base address in addition
        /// to the Net.Tcp address. And in this case, the Http base address and the Net.Tcp address must
        /// have different port numbers (because you can't have two different transports bound to the
        /// same port).
        /// </para>
        /// <para>
        /// For self-hosted services, you must *not* use .Hosted() on the service model, as that indicates
        /// the services lives in IIS/WAS. Also, the service implementation must *not* have a ServiceBehaviour
        /// attribute, because that will cause .NET to try and create the service host and it demands a
        /// parameter-less constructor (which we don't have since we're trying to do dependency injection
        /// via constructor parameters).
        /// </para>
        /// <para>
        /// To register different endpoint behaviours the behaviour must be added to the endpoint instance as an extension (AddExtension).
        /// Adding the endpoint behaviours to the serviceModel directly fails if the same endpoint behaviour is registered for another service.
        /// </para>
        /// <para>
        /// Every service will be registered with a unique random name because registering 2 services with different (I) interfaces but same implementation (C)
        /// conflicts with Castle Windsor - it needs a unique name.
        /// The unique name is never been used to resolve the registered service. It is only needed to generate a unique key for Castle Windsor.
        /// Resolve the service with the proper interface (I).
        /// </para>
        /// </remarks>
        /// <typeparam name="I">interface for service</typeparam>
        /// <typeparam name="C">implementation class for service</typeparam>
        /// <param name="serviceName">service name (used in endpoint URL)</param>
        /// <param name="http">indicates whether to use the HTTP transport or Net.Tcp</param>
        /// <param name="streamed">whether the service needs a streamed protocol</param>
        /// <param name="port">the port number to use for the service</param>
        /// <param name="mexPort">the port for the mex endpoint (only used if http == false)</param>
        /// <param name="maxMsg">the max message size configuration parameter for WCF</param>
        /// <param name="sendTimeout">WCF service timeout to send a message</param>
        /// <param name="receiveTimeout">WCF service timeout to receive a message</param>
        /// <param name="useExternalEndpointBehaviour">Optional: Flag to add external endpoint behaviour (<c>true</c>) or the default endpoint behaviour. Default: false</param>

        public void RegisterWCFServiceImpl <I, C>(string serviceName, bool http, bool streamed, int port, int mexPort, int maxMsg, TimeSpan sendTimeout, TimeSpan receiveTimeout,
                                                  bool useExternalEndpointBehaviour) where I : class where C : I
        {
            Func <int, string, string> GenAddr = GetServiceAddressNetTCP;

            if (http)
            {
                GenAddr = GetServiceAddressHTTP;
            }
            var           serviceUri    = GenAddr(port, serviceName);
            List <string> baseAddresses = new List <string>();

            var endPoint = CreateEndpoint(
                GetEndpoint(serviceUri, streamed, maxMsg, sendTimeout, receiveTimeout),
                this.CreateEndpointBehaviour(useExternalEndpointBehaviour),
                baseAddresses,
                serviceUri);

            if (!http)
            {
                var mexUri = GetServiceAddressHTTP(mexPort, serviceName);
                baseAddresses.Add(mexUri);
            }

            try
            {
                var serviceModel = new DefaultServiceModel()
                                   .PublishMetadata(o => o.EnableHttpGet())
                                   .AddBaseAddresses(baseAddresses.ToArray());

                serviceModel.AddEndpoints(endPoint);

                string uniqueRegistrationName = Guid.NewGuid().ToString();
                Kernel.Register(Component
                                .For <I>()
                                .ImplementedBy <C>()
                                .AsWcfService(serviceModel)
                                .Named(uniqueRegistrationName));

                Logger.InfoFormat("START and REGISTER service '{0}' - listening at [{1}]: Endpoint-Behaviour-Count: {2}, Use-External-EndpointBehaviour = '{3}'.", serviceName, serviceUri, serviceModel.Extensions.Count(), useExternalEndpointBehaviour.ToString());
            }
            catch (Exception ex)
            {
                var msg = string.Format("Error: Service registration failed for address = [{0}], Use-External-EndpointBehaviour = '{1}', Ex='{2}'", serviceUri, useExternalEndpointBehaviour.ToString(), ex.ToString());
                Logger.Fatal(msg);
                IoCSetup.ShutdownAndExit(msg, 1);
            }
        }