C# ConsoleLogger类代码示例

		private ICategoryService GetCategoryService(UnitOfWork uow) {
			ICategoryRepository cateRepo = new CategoryRepository(uow);

			IState request = new DummyRequest();

			ILogger logger = new ConsoleLogger();

			IUserRepository userRepo = new UserRepository(uow);
			User user = userRepo.Create(new User {
				Name = "D. Ummy",
				ProviderId = "12345678",
				FullName = "Mr. Doh Ummy",
				EmailAddress = "[email protected]",
				Culture = "th-TH",
				TimeZone = "GMT Standard Time"
			});

			List<IEventSubscriber> subscribers = new List<IEventSubscriber>();

			IEventPublisher eventPublisher = new EventPublisher(subscribers, logger, request);
			IUserProvider userProvider = new DummyUserProvider(user);
			IPermissionService permService = new PermissionService();

			return new CategoryService(userProvider, cateRepo, eventPublisher, logger, permService);
		}

        static void ComposeModules()
        {
            //Bootstrapping section
            //Wherein we select the modules this application will use.
            //This is referred to as the "composition root" of a modular application.
            //There are several ways of implementing it, but I'm doing the simple route of hard coding the modules.

            var defaultLogger = new ConsoleLogger();
            var defaultItemRepository = new ItemRepository();

            _defaultWorkflowEngine = new WorkflowEngine(defaultLogger);

            _defaultWorkflowProducer = new WorkflowProducer
                (
                    new FooWorkflowFactory
                        (
                            defaultItemRepository,
                            new FooProcessor(),
                            new FooSender(defaultLogger)
                        ),
                    new BarWorkflowFactory
                        (
                            defaultItemRepository,
                            new RecordDeleter(defaultLogger)
                        )
                );
        }

        static void Main(string[] args)
        {
            calculator culc = new calculator();

            //--- Add logers
            ConsoleLogger cLogger = new ConsoleLogger();
            culc.OperationCompleted += cLogger.Log;
            culc.OperationFailed += cLogger.Log;

            FileLogger fLogger = new FileLogger(@"D:\LogFile.log");
            culc.OperationCompleted += fLogger.Log;
            culc.OperationFailed += fLogger.Log;
            //----------------------------------------------------

            string operation = string.Empty;
            string arg1 = string.Empty;
            string arg2 = string.Empty;
            Console.WriteLine("Enter argument 1:\r\n");
            arg1 = Console.ReadLine();
            Console.WriteLine("Enter argument 2:\r\n");
            arg2 = Console.ReadLine();
            Console.WriteLine("Enter operation(+,-,*,/):\r\n");
            operation = Console.ReadLine();

            culc.DoOperation(operation, arg1, arg2);

            Console.ReadLine();
        }

        private void ClearMeABus()
        {
            // Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
            // deleting queues and topics is slow.
            var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {"Some.Namespace.That.Does.Not.Exist"});
            var messageBroker = new DefaultMessageHandlerFactory(typeProvider);

            var logger = new ConsoleLogger();

            var busBuilder = new BusBuilder().Configure()
                                             .WithNames("IntegrationTestHarness", Environment.MachineName)
                                             .WithConnectionString(CommonResources.ConnectionString)
                                             .WithTypesFrom(typeProvider)
                                             .WithCommandHandlerFactory(messageBroker)
                                             .WithRequestHandlerFactory(messageBroker)
                                             .WithMulticastEventHandlerFactory(messageBroker)
                                             .WithCompetingEventHandlerFactory(messageBroker)
                                             .WithMulticastRequestHandlerFactory(messageBroker)
                                             .WithDefaultTimeout(TimeSpan.FromSeconds(10))
                                             .WithLogger(logger)
                                             .WithDebugOptions(
                                                 dc =>
                                                     dc.RemoveAllExistingNamespaceElementsOnStartup(
                                                         "I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
                ;

            using (var bus = busBuilder.Build())
            {
                bus.Start();
            }
        }

        public async Task SendHttpRequest()
        {

            // Arrange
            var httpRequestMessage = new HttpRequestMessage() {
                RequestUri = new Uri("http://example.com/foo")
            };

            var httpMessage = new HttpMessage()
            {
                IsRequest = true,
                HttpRequestMessage = httpRequestMessage
            };

            var consoleLogger = new ConsoleLogger();
            var fakeMessageHandler = new FakeMessageHandler();
            var httpClient = new HttpClient(fakeMessageHandler);
            httpClient.BaseAddress = new Uri("http://api.runscope.com/");

            var message = new RunscopeHttpMessageProcessor(httpClient,consoleLogger);

            // Act
            await message.ProcessHttpMessage(httpMessage);

            // Assert
            Assert.NotNull(fakeMessageHandler.LastResponseMessage);
            Assert.Equal("api.runscope.com", fakeMessageHandler.LastResponseMessage.RequestMessage.RequestUri.Host);
        }

		static bool ProcessCommand(IEnumerable<string> args)
		{
			if (args.Count() == 0)
				return true;
			ILogger logger = new ConsoleLogger(false);
			var commandName = args.First().ToLowerInvariant();
			args = args.Skip(1);
			switch (commandName) {
				case "quit":
				case "q":
				case "exit":
				case "e":
					return false;
				case "help":
				case "?":
					return HelpCommand(logger, args);
				default:
					foreach (ICommand command in _commands)
						if (command.Matches(commandName))
							using (logger.Block)
								return command.Process(logger, args, _metaProjectPersistence, _components, PackagesOutputDirectory);
					break;
			}
			logger.Error("Unknown command '{0}'", commandName);
			return true;
		}

        public async Task<Bus> CreateAndStart()
        {
            var logger = new ConsoleLogger();
            //var logger = new NullLogger();

            // Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
            // deleting queues and topics is slow.
            var typeProvider = new TestHarnessTypeProvider(new[] {_testFixtureType.Assembly}, new[] {_testFixtureType.Namespace});

            var bus = new BusBuilder().Configure()
                                      .WithNames("MyTestSuite", Environment.MachineName)
                                      .WithConnectionString(CommonResources.ServiceBusConnectionString)
                                      .WithTypesFrom(typeProvider)
                                      .WithGlobalInboundInterceptorTypes(typeProvider.InterceptorTypes.Where(t => typeof(IInboundInterceptor).IsAssignableFrom(t)).ToArray())
                                      .WithGlobalOutboundInterceptorTypes(typeProvider.InterceptorTypes.Where(t => typeof(IOutboundInterceptor).IsAssignableFrom(t)).ToArray())
                                      .WithDependencyResolver(new DependencyResolver(typeProvider))
                                      .WithDefaultTimeout(TimeSpan.FromSeconds(10))
                                      .WithLogger(logger)
                                      .WithDebugOptions(
                                          dc =>
                                              dc.RemoveAllExistingNamespaceElementsOnStartup(
                                                  "I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
                                      .Build();
            await bus.Start(MessagePumpTypes.All);

            return bus;
        }

        public void SetUp()
        {
            var connectionFactory = new ConnectionFactoryWrapper(new ConnectionFactory
            {
                HostName = "localhost",
                VirtualHost = "/",
                UserName = "guest",
                Password = "guest"
            });

            var serializer = new JsonSerializer();
            var logger = new ConsoleLogger();
            var consumerErrorStrategy = new DefaultConsumerErrorStrategy(connectionFactory, serializer, logger);
            var conventions = new Conventions();

            advancedBus = new RabbitAdvancedBus(
                connectionFactory,
                TypeNameSerializer.Serialize,
                serializer,
                new QueueingConsumerFactory(logger, consumerErrorStrategy),
                logger,
                CorrelationIdGenerator.GetCorrelationId,
                conventions);

            while (!advancedBus.IsConnected)
            {
                Thread.Sleep(10);
            }
        }

        public static void Main()
        {
            Console.Write("Enter pass: ");
            string password = Console.ReadLine();

            // Change connection string with your database name
            string connectionString = "Server=localhost;Database=library;Uid=root;Pwd=" + password + ";";

            MySqlLibraryProvider provider = new MySqlLibraryProvider(connectionString);
            ILogger logger = new ConsoleLogger();

            // List all books
            provider.ListBooks(logger);

            // Add new book
            string title = "It";
            bool isBookAdded = provider.AddBook(title, 2, new DateTime(), "A2123143234");
            if (isBookAdded)
            {
                logger.Log("Book added!");
            }

            // Get book by title
            string bookAsString = provider.GetBookByTitle(title);
            logger.Log("Book:");
            logger.Log(bookAsString);
        }

        public void ConsoleLoggerCanLogMessagesToConsole()
        {
            string msg_text = "This is a test.";
            string actual = String.Empty;

            ConsoleLogger cl = new ConsoleLogger();

            TextWriter old_out = Console.Out;
            using (MemoryStream ms = new MemoryStream())
            {
                using (StreamWriter sw = new StreamWriter(ms, Encoding.UTF8, 512, true))
                {
                    Console.SetOut(sw);

                    cl.Log(new GeneralMessage(msg_text));
                }

                ms.Position = 0;
                using (StreamReader reader = new StreamReader(ms, Encoding.UTF8, true))
                {
                    actual = reader.ReadToEnd();
                }
            }

            Console.SetOut(old_out);

            Assert.AreEqual(msg_text + Environment.NewLine, actual);
        }

        public void DomainServiceCatalog_Ctors()
        {
            IEnumerable<string> empty = new string[0];
            ConsoleLogger logger = new ConsoleLogger();

            // Ctor taking assemblies -- null arg tests
            ExceptionHelper.ExpectArgumentNullExceptionStandard(() => new DomainServiceCatalog((IEnumerable<string>)null, logger), "assembliesToLoad");
            ExceptionHelper.ExpectArgumentNullExceptionStandard(() => new DomainServiceCatalog(empty, null), "logger");

            // Ctor taking one type -- null arg tests
            ExceptionHelper.ExpectArgumentNullExceptionStandard(() => new DomainServiceCatalog((Type) null, logger), "domainServiceType");
            ExceptionHelper.ExpectArgumentNullExceptionStandard(() => new DomainServiceCatalog(typeof(DSC_DomainServiceType), null), "logger");

            // Ctor taking multiple types -- null arg tests
            ExceptionHelper.ExpectArgumentNullExceptionStandard(() => new DomainServiceCatalog((IEnumerable<Type>)null, logger), "domainServiceTypes");
            ExceptionHelper.ExpectArgumentNullExceptionStandard(() => new DomainServiceCatalog(new Type[] {typeof(DSC_DomainServiceType)}, null), "logger");

            // Ctor taking assemblies -- legit
            string[] realAssemblies = new string[] { this.GetType().Assembly.Location,
                                                     typeof(string).Assembly.Location };

            // Assembly based ctors are tested more deeply in other test methods

            // Ctor taking one type -- legit
            DomainServiceCatalog dsc = new DomainServiceCatalog(typeof(DSC_DomainServiceType), logger);
            IEnumerable<DomainServiceDescription> descriptions = dsc.DomainServiceDescriptions;
            Assert.IsNotNull(descriptions, "Did not expect null descriptions");
            Assert.AreEqual(1, descriptions.Count(), "Expected exactly one domain service description");

            // Ctor taking multiple type -- legit
            dsc = new DomainServiceCatalog(new Type[] {typeof(DSC_DomainServiceType)}, logger);
            descriptions = dsc.DomainServiceDescriptions;
            Assert.IsNotNull(descriptions, "Did not expect null descriptions");
            Assert.AreEqual(1, descriptions.Count(), "Expected exactly one domain service description");
        }

        public void Just_verify_the_regular_write()
        {

            var sut = new ConsoleLogger(GetType());
            sut.Debug("Hello world");

        }

        public void Just_verify_exception_Write()
        {

            var sut = new ConsoleLogger(GetType());
            sut.Debug("Hello world", new Exception());

        }

        public void Just_verify_formatted_Write()
        {

            var sut = new ConsoleLogger(GetType());
            sut.Debug("Hello {0}", "world");

        }

        public void ClientCodeGenerationDispatcher_Finds_Derived_Custom()
        {
            ConsoleLogger logger = new ConsoleLogger();
            ClientCodeGenerationOptions options = new ClientCodeGenerationOptions()
            {
                Language = "G#"
            };

            ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null);

            // Create a new dispatcher and call an internal extensibility point to add ourselves
            // into the MEF composition container
            using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher())
            {
                string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location };

                IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, MockGSharpCodeGeneratorDerived.GeneratorName);
                Assert.IsNotNull(generator, "the dispatcher did not find any code generator");
                Assert.AreEqual(generator.GetType(), typeof(MockGSharpCodeGeneratorDerived), "dispatcher found " + generator.GetType() + " but should have found MockGSharpCodeGeneratorDerived");

                string generatedCode = generator.GenerateCode(host, Enumerable.Empty<DomainServiceDescription>(), options);

                Assert.AreEqual(MockGSharpCodeGeneratorDerived.DerivedGeneratedCode, generatedCode, "test code generator did not generate expected code.");
            }
        }