Akka.Streams.Tests.Dsl.GraphPartialSpec.FlowFlowGraph_Partial_must_be_able_to_build_and_reuse_simple_materializing_partial_graphs C# (CSharp) Метод

        public void FlowFlowGraph_Partial_must_be_able_to_build_and_reuse_simple_materializing_partial_graphs()
        {
            var doubler = GraphDsl.Create(Sink.First<IEnumerable<int>>(), (b, sink) =>
            {
                var broadcast = b.Add(new Broadcast<int>(3));
                var zip = b.Add(ZipWith.Apply((int i, int i1) => i + i1));

                b.From(broadcast.Out(0)).To(zip.In0);
                b.From(broadcast.Out(1)).To(zip.In1);
                b.From(broadcast.Out(2)).Via(Flow.Create<int>().Grouped(100)).To(sink.Inlet);

                return new FlowShape<int, int>(broadcast.In, zip.Out);
            });

            var t =
                RunnableGraph.FromGraph(GraphDsl.Create(doubler, doubler, Sink.First<IEnumerable<int>>(), Tuple.Create,
                    (b, d1, d2, sink) =>
                    {
                        var source =
                            Source.From(Enumerable.Range(1, 3))
                                .MapMaterializedValue<Tuple<Task<IEnumerable<int>>, Task<IEnumerable<int>>, Task<IEnumerable<int>>>>(_ => null);

                        b.From(source).To(d1.Inlet);
                        b.From(d1.Outlet).To(d2.Inlet);
                        b.From(d2.Outlet).Via(Flow.Create<int>().Grouped(100)).To(sink.Inlet);

                        return ClosedShape.Instance;
                    })).Run(Materializer);

            var task = Task.WhenAll(t.Item1, t.Item2, t.Item3);
            task.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
            task.Result[0].ShouldAllBeEquivalentTo(new[] {1, 2, 3});
            task.Result[1].ShouldAllBeEquivalentTo(new[] {2, 4, 6});
            task.Result[2].ShouldAllBeEquivalentTo(new[] { 4, 8, 12 });
        }