Esempio n. 1
0
        public void TestInstantiateObject()
        {
            string signatures = @"[
                                        {
                                            'key' : 'StringBuilder',
                                            'signature' : 'mscorlib',
                                            'namespace' : 'System.Text.StringBuilder'
                                        },
                                        {
                                            'key' : 'Random', 
                                            'signature' : 'mscorlib',
                                            'namespace' : 'System.Random'
                                        }
                                    ]";

            StringBuilder sb  = null;
            Random        rnd = null;

            using (PluginFactory pf = new PluginFactory(signatures))
            {
                sb  = (StringBuilder)pf.Create("StringBuilder");
                rnd = (Random)pf.Create("Random");
            }

            Assert.IsNotNull(sb);
            Assert.IsNotNull(rnd);

            Assert.IsInstanceOfType(sb, typeof(StringBuilder));
            Assert.IsInstanceOfType(rnd, typeof(Random));
        }
Esempio n. 2
0
        /// <summary>
        /// Loads the plugin
        /// </summary>
        /// <param name="config">configuration to use</param>
        public void Open(CameraControlInfo config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            Plugin       = PluginFactory.Create(config, this);
            CameraConfig = config;
        }
        /// <summary>
        ///     Loads the writers found by the plugin factory.
        /// </summary>
        /// <param name="settings">The settings to load the writer from.</param>
        /// <param name="pluginFactory">The server's plugin factory.</param>
        /// <param name="logManager">The server's log manager.</param>
        internal void LoadWriters(ServerSpawnData.MetricsSettings settings, PluginFactory pluginFactory, LogManager logManager)
        {
            if (MetricsWriter != null)
            {
                throw new InvalidOperationException("Cannot load writers if writer is already present. This suggests that writers have already been loaded into the server.\n\nThis is likely an internal DR issue, please consider creating an issue here: https://github.com/DarkRiftNetworking/DarkRift/issues");
            }

            if (settings.MetricsWriter != null && settings.MetricsWriter.Type != null)
            {
                MetricsWriterLoadData loadData = new MetricsWriterLoadData(settings.MetricsWriter.Type, server, settings.MetricsWriter.Settings, logManager.GetLoggerFor(settings.MetricsWriter.Type));

                MetricsWriter = pluginFactory.Create <MetricsWriter>(settings.MetricsWriter.Type, loadData, null);
            }
        }
Esempio n. 4
0
        static void Main(string[] args)
        {
            Console.WriteLine("Press a key to start...");
            Console.ReadKey();

            // Retrieve assembly signatures from configuration
            Console.WriteLine();
            Console.WriteLine("Retrieve assembly signatures from configuration...");
            string signatures = Settings.AssemblySignatures;

            #region Call services using base factory
            Console.WriteLine();
            Console.WriteLine("Call services using base factory...");

            // Use first service
            using (var factory = new PluginFactory(signatures))
            {
                IService service1 = (IService)factory.Create("Service1");
                Console.WriteLine($"Message from first service: { service1.GetMessage() }");
            }

            // Use second service
            using (var factory = new PluginFactory(signatures))
            {
                IService service2 = (IService)factory.Create("Service2");
                Console.WriteLine($"Message from second service: { service2.GetMessage() }");
            }

            // Use first service loaded from path
            using (var factory = new PluginFactory(signatures))
            {
                IService service1 = (IService)factory.Create("Service1FromPath");
                Console.WriteLine($"Message from first service loaded from path: { service1.GetMessage() }");
            }

            // Use second service loaded from path
            using (var factory = new PluginFactory(signatures))
            {
                IService service2 = (IService)factory.Create("Service2FromPath");
                Console.WriteLine($"Message from second service loaded from path: { service2.GetMessage() }");
            }
            #endregion

            #region Call services using the generics factory
            Console.WriteLine();
            Console.WriteLine("Call services using generics factory...");

            // Use first service
            using (var factory = new PluginFactory <IService>(signatures))
            {
                IService service1 = factory.Create("Service1");
                Console.WriteLine($"Message from first service: { service1.GetMessage() }");
            }

            // Use second service
            using (var factory = new PluginFactory <IService>(signatures))
            {
                IService service2 = factory.Create("Service2");
                Console.WriteLine($"Message from second service: { service2.GetMessage() }");
            }

            // Use first service loaded from path
            using (var factory = new PluginFactory <IService>(signatures))
            {
                IService service1 = factory.Create("Service1FromPath");
                Console.WriteLine($"Message from first service loaded from path: { service1.GetMessage() }");
            }

            // Use second service loaded from path
            using (var factory = new PluginFactory <IService>(signatures))
            {
                IService service2 = factory.Create("Service2FromPath");
                Console.WriteLine($"Message from second service loaded from path: { service2.GetMessage() }");
            }
            #endregion

            #region Call services using derived factory
            Console.WriteLine();
            Console.WriteLine("Call services using derived factory...");

            // Use first service
            using (var factory = new ServiceFactory <IService>(signatures))
            {
                IService service1 = factory.CreateService("Service1");
                Console.WriteLine($"Message from first service: { service1.GetMessage() }");
            }

            // Use second service
            using (var factory = new ServiceFactory <IService>(signatures))
            {
                IService service2 = factory.CreateService("Service2");
                Console.WriteLine($"Message from second service: { service2.GetMessage() }");
            }

            // Use first service loaded from path
            using (var factory = new ServiceFactory <IService>(signatures))
            {
                IService service1 = factory.CreateService("Service1FromPath");
                Console.WriteLine($"Message from first service loaded from path: { service1.GetMessage() }");
            }

            // Use second service loaded from path
            using (var factory = new ServiceFactory <IService>(signatures))
            {
                IService service2 = factory.CreateService("Service2FromPath");
                Console.WriteLine($"Message from second service loaded from path: { service2.GetMessage() }");
            }
            #endregion

            // Done
            Console.WriteLine();
            Console.WriteLine("Press a key to quit...");
            Console.ReadKey();
        }