Exemple #1
0
 private void writeContentsOfServiceTypes(IEnumerable <IServiceFamilyConfiguration> serviceTypes,
                                          StringWriter writer, WhatDoIHaveDisplay display)
 {
     if (display == WhatDoIHaveDisplay.Summary)
     {
         writeSummary(serviceTypes, writer);
     }
     else
     {
         writeBuildPlan(serviceTypes, writer);
     }
 }
        private void WriteNamespaceServices(LamarServicesInput input, IGrouping <string, IServiceFamilyConfiguration> ns,
                                            WhatDoIHaveDisplay displayMode, IContainer container)
        {
            var top = new Tree(ns.Key);

            foreach (var configuration in ns)
            {
                var node = top.AddNode(configuration.ServiceType.CleanFullName());
                WriteInstances(node, configuration, input, displayMode, container);
            }

            AnsiConsole.Render(top);

            Console.WriteLine();
        }
Exemple #3
0
        public string GetText(ModelQuery query, string title = null, WhatDoIHaveDisplay display = WhatDoIHaveDisplay.Summary)
        {
            using (var writer = new StringWriter())
            {
                if (title.IsNotEmpty())
                {
                    writer.WriteLine(title);
                }

                writer.WriteLine("");

                var model = _graph;

                var serviceTypes = query.Query(model);

                writeContentsOfServiceTypes(serviceTypes, writer, display);

                return(writer.ToString());
            }
        }
        public static void WriteInstancesTable(this TreeNode parent, IServiceFamilyConfiguration configuration,
                                               WhatDoIHaveDisplay displayMode)
        {
            var table = new Table();

            table.AddColumns("Name", "Description", "Lifetime");
            foreach (var instance in configuration.Instances)
            {
                if (configuration.Default.Instance.Equals(instance.Instance))
                {
                    table.AddRow((instance.Name + " (Default)").BoldText(), instance.Instance.ToDescription().BoldText(),
                                 instance.Lifetime.BoldText());
                }
                else
                {
                    table.AddRow(instance.Name, instance.Instance.ToDescription(),
                                 instance.Lifetime.ToString());
                }
            }

            parent.AddNode(table);
        }
        private void WriteInstances(TreeNode parent, IServiceFamilyConfiguration configuration,
                                    LamarServicesInput input, WhatDoIHaveDisplay displayMode, IContainer container)
        {
            if (!configuration.Instances.Any())
            {
                parent.AddNode("None");
                return;
            }

            if (configuration.Instances.Count() == 1)
            {
                var instance = configuration.Default.Instance;

                if (displayMode == WhatDoIHaveDisplay.Summary)
                {
                    parent.WriteSingleInstanceNode(input, instance, true);
                }
                else
                {
                    parent.WriteBuildPlanNode(input, instance, true);
                }
            }
            else if (displayMode == WhatDoIHaveDisplay.Summary)
            {
                parent.WriteInstancesTable(configuration, displayMode);
            }
            else
            {
                foreach (var instanceRef in configuration.Instances)
                {
                    var isDefault = configuration.Default.Instance == instanceRef.Instance;

                    parent.WriteBuildPlanNode(input, instanceRef.Instance, isDefault);
                }
            }
        }
        private void WriteSummaries(LamarServicesInput input, IGrouping <Assembly, IServiceFamilyConfiguration>[] configurations, WhatDoIHaveDisplay display,
                                    IContainer container)
        {
            if (display == WhatDoIHaveDisplay.Summary)
            {
                AnsiConsole.MarkupLine("[bold]Key:[/] ");

                var rule = new Rule($"[blue]Assembly Name (Assembly Version)[/]")
                {
                    Alignment = Justify.Left
                };
                AnsiConsole.Render(rule);


                var node = new Tree("{Service Type Namespace}");
                node.AddNode("{Service Type Full Name}").AddNode("{Lifetime}: {Description of Registration}");
                AnsiConsole.Render(node);
                Console.WriteLine();
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine("Build Plans for registrations built by calling constructors");
                Console.WriteLine();
            }


            foreach (var group in configurations)
            {
                WriteAssemblyServices(input, @group, display, container);
            }
        }
        private void WriteAssemblyServices(LamarServicesInput input,
                                           IGrouping <Assembly, IServiceFamilyConfiguration> @group, WhatDoIHaveDisplay displayMode,
                                           IContainer container)
        {
            var rule = new Rule($"[blue]{@group.Key.GetName().Name} ({@group.Key.GetName().Version})[/]")
            {
                Alignment = Justify.Left
            };

            AnsiConsole.Render(rule);

            var namespaces = @group.GroupBy(x => x.ServiceType.ResolveServiceType().Namespace);

            foreach (var ns in namespaces)
            {
                WriteNamespaceServices(input, ns, displayMode, container);
            }

            Console.WriteLine();
        }