C# IMediator.Send方法代码示例

        public BuildModule(IMediator mediator)
            : base("/api")
        {
            this.Get["/builds/{teamProject?}/{buildDefinition?}/{buildNumber?}"] = parameters =>
            {
                var query = this.Bind<BuildsQuery>();

                var result = mediator.Send(query);

                return this.Response.AsJson(result);
            };

            this.Get["/builds/stats"] = parameters =>
            {
                var query = this.Bind<BuildStatsQuery>();

                var result = mediator.Send(query);

                return this.Response.AsJson(result);
            };

            this.Get["/builds/perDay"] = parameters =>
            {
                var query = this.Bind<BuildsPerDayQuery>();

                var response = mediator.Send(query);

                return this.Response.AsJson(response);
            };
        }

        public TodoItemsModule(IMediator mediator) : base("/todo-items")
        {
            _mediator = mediator;
            Get["/"] = parameters =>
            {
                var todoItems = _mediator.Send(new GetTodoItems());

                return Response.AsJson(todoItems);
            };

            Get["/{id}"] = parameters =>
            {
                var todoItem = _mediator.Send(new GetTodoItemById(parameters.id));

                return Response.AsJson(todoItem);
            };

            Post["/"] = parameters =>
            {
                var createTodoItem = this.Bind<CreateTodoItem>();
                var item =_mediator.Send(createTodoItem);
                return item;
            };

            Put["/{id}/complete"] = parameters =>
            {
                var id = parameters.id;
                var todoItem = _mediator.Send(new MarkTodoItemCompleted(id));
                return todoItem;
            };
        }

        public BuildDefinitionModule(IMediator mediator, IDocumentSession session)
            : base("/api")
        {
            this.Get["/build-definitions/{teamProject?}"] = parameters =>
            {
                var query = this.Bind<GetBuildDefinitions>();

                var results = mediator.Send(query);

                return this.Response.AsJson(results);
            };

            this.Get["/build-definitions/stats/{teamProject?}"] = parameters =>
            {
                var query = this.Bind<GetBuildDefinitionsStats>();

                var results = mediator.Send(query);

                return this.Response.AsJson(results);

                //string teamProject = parameters.TeamProject;

                //var query = session.Query<BuildDefinitionStats, BuildDefinitionStatusIndex>()
                //    .AsQueryable();

                //if (!string.IsNullOrEmpty(teamProject))
                //{
                //    query = query.Where(k => k.TeamProject == teamProject);
                //}

                //var results = query.ToList();

                //return this.Response.AsJson(results);
            };
        }

        public RequestHandlerModule(IMediator mediator, RequestTypeProvider requestTypeProvider)
            : base("/RequestHandler/request")
        {
            Post["/{requestType}", true] = async (parameters, ct) =>
            {
                Console.WriteLine("Call to AsyncRequestHandlerModule");
                var requestTypeString = (string)parameters.requestType;

                var requestType = requestTypeProvider.FindByFullName(requestTypeString);

                if (requestType == null)
                {
                    return (int)HttpStatusCode.NotAcceptable;
                }

                dynamic deserializedRequest = this.Bind(requestType);

                var isAsyncRequest = requestType.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IAsyncRequest<>));

                if (requestType.BaseType != typeof(object) && requestType.BaseType == typeof(FileRequest))
                {
                    var response = new Response { StatusCode = HttpStatusCode.OK, ContentType = "application/octet-stream", Contents = async s => {
                        ((FileRequest)deserializedRequest).SetStream(s);
                        if (isAsyncRequest)
                        {
                            await mediator.SendAsync(deserializedRequest);
                        }
                        else
                        {
                            mediator.Send(deserializedRequest);
                        }
                    } };

                    return response;
                }

                try
                {
                    if (isAsyncRequest)
                    {
                        return await mediator.SendAsync(deserializedRequest);
                    }

                    return mediator.Send(deserializedRequest);
                }
                catch (Exception exc)
                {
                    //todo:log, etc.
                    var errorResponse = Response.AsText(exc.Message);
                    errorResponse.StatusCode = HttpStatusCode.InternalServerError;

                    return errorResponse;
                }
            };
        }

        public BuildControllersModule(IMediator mediator)
            : base("/api")
        {
            this.Get["/build-controllers"] = parameters =>
            {
                var results = mediator.Send(new GetBuildControllersQuery());

                return this.Response.AsJson(results);
            };

            this.Get["/build-controllers/stats"] = parameters =>
            {
                var results = mediator.Send(new BuildControllersCountByStatusQuery());

                return this.Response.AsJson(results);
            };
        }

        public QueuedBuildsModule(IMediator mediator)
            : base("/api")
        {
            this.Get["/queue"] = parameters =>
            {
                var results = mediator.Send(new GetQueuedBuildsQuery());

                return this.Response.AsJson(results);
            };

            this.Get["/queue/stats"] = parameters =>
            {
                var results = mediator.Send(new QueuedBuildsCountByStatusQuery());

                return this.Response.AsJson(results);
            };
        }

        public static async Task Run(IMediator mediator, TextWriter writer)
        {
            await writer.WriteLineAsync("Sample mediator implementation using send, publish and post-request handlers in sync and async version.");
            await writer.WriteLineAsync("---------------");

            await writer.WriteLineAsync("Sending Ping...");
            var pong = await mediator.Send(new Ping { Message = "Ping" });
            await writer.WriteLineAsync("Received: " + pong.Message);

            await writer.WriteLineAsync("Sending Ping async...");
            var response = await mediator.Send(new PingAsync { Message = "Ping" });
            await writer.WriteLineAsync("Received async: " + response.Message);

            await writer.WriteLineAsync("Publishing Pinged...");
            await mediator.Publish(new Pinged());

            await writer.WriteLineAsync("Publishing Pinged async...");
            await mediator.Publish(new PingedAsync());
        }

        public ServersModule(IMediator mediator)
            : base("/api")
        {
            this.Get["/servers"] = parameters =>
            {
                var servers = mediator.Send(new ServersQuery());

                return this.Response.AsJson(servers);
            };
        }

        public TeamProjectsModule(IMediator mediator)
            : base("/api")
        {
            this.Get["/projects"] = parameters =>
            {
                var results = mediator.Send(new GetTeamProjectsQuery());

                var response = results.ToArray();
                
                return this.Response.AsJson(response);
            };
        }

        public static void Run(IMediator mediator, TextWriter writer)
        {
            writer.WriteLine("Sample mediator implementation using send, publish and post-request handlers in sync and async version.");
            writer.WriteLine("---------------");
            
            writer.WriteLine("Sending Ping...");
            var pong = mediator.Send(new Ping { Message = "Ping" });
            writer.WriteLine("Received: " + pong.Message);

            writer.WriteLine("Sending Ping async...");
            var response = mediator.SendAsync(new PingAsync { Message = "Ping" });
            Task.WaitAll(response);
            writer.WriteLine("Received async: " + response.Result.Message);

            writer.WriteLine("Publishing Pinged...");
            mediator.Publish(new Pinged());

            writer.WriteLine("Publishing Pinged async...");
            var publishResponse = mediator.PublishAsync(new PingedAsync());
            Task.WaitAll(publishResponse);
        }

        public static AllReadyTask ToModel(this TaskViewModel taskViewModel, IMediator mediator)
        {
            var campaignEvent = mediator.Send(new EventByIdQuery { EventId = taskViewModel.EventId });
            if (campaignEvent == null)
            {
                return null;
            }

            var newTask = true;
            AllReadyTask dbtask;
            if (taskViewModel.Id == 0)
            {
                dbtask = new AllReadyTask();
            }
            else
            {
                dbtask = mediator.Send(new TaskByTaskIdQuery { TaskId = taskViewModel.Id });
                newTask = false;
            }

            dbtask.Id = taskViewModel.Id;
            dbtask.Description = taskViewModel.Description;
            dbtask.Event = campaignEvent;
            dbtask.EndDateTime = taskViewModel.EndDateTime.HasValue ? taskViewModel.EndDateTime.Value.UtcDateTime : new DateTime?();
            dbtask.StartDateTime = taskViewModel.EndDateTime.HasValue ? taskViewModel.StartDateTime.Value.UtcDateTime : new DateTime?();
            dbtask.Name = taskViewModel.Name;
            dbtask.RequiredSkills = dbtask.RequiredSkills ?? new List<TaskSkill>();
            taskViewModel.RequiredSkills = taskViewModel.RequiredSkills ?? new List<int>();
            ////Remove old skills
            //dbtask.RequiredSkills.RemoveAll(ts => !taskViewModel.RequiredSkills.Any(s => ts.SkillId == s));
            ////Add new skills
            //dbtask.RequiredSkills.AddRange(taskViewModel.RequiredSkills
            //    .Where(rs => !dbtask.RequiredSkills.Any(ts => ts.SkillId == rs))
            //    .Select(rs => new TaskSkill() { SkillId = rs, TaskId = taskViewModel.Id }));

            // Workaround:  POST is bringing in empty AssignedVolunteers.  Clean this up. Discussing w/ Kiran Challa.
            // Workaround: the if statement is superflous, and should go away once we have the proper fix referenced above.
            if (taskViewModel.AssignedVolunteers != null)
            {
                var bogusAssignedVolunteers = (from assignedVolunteer in taskViewModel.AssignedVolunteers
                                               where string.IsNullOrEmpty(assignedVolunteer.UserId)
                                               select assignedVolunteer).ToList();
                foreach (var bogus in bogusAssignedVolunteers)
                {
                    taskViewModel.AssignedVolunteers.Remove(bogus);
                }
            }
            // end workaround

            if (taskViewModel.AssignedVolunteers != null && taskViewModel.AssignedVolunteers.Count > 0)
            {
                var taskUsersList = taskViewModel.AssignedVolunteers.Select(tvm => new TaskSignup
                {
                    Task = dbtask,
                    User = mediator.Send(new UserByUserIdQuery { UserId = tvm.UserId })
                }).ToList();

                // We may be updating an existing task
                if (newTask || dbtask.AssignedVolunteers.Count == 0)
                {
                    dbtask.AssignedVolunteers = taskUsersList;
                }
                else
                {
                    // Can probably rewrite this more efficiently.
                    foreach (var taskUsers in taskUsersList)
                    {
                        if (!(from entry in dbtask.AssignedVolunteers
                              where entry.User.Id == taskUsers.User.Id
                              select entry).Any())
                        {
                            dbtask.AssignedVolunteers.Add(taskUsers);
                        }
                    }
                }
            }

            return dbtask;
        }