重新整理 .net core 实践篇————

前言

简单整理一下Mediator。

正文

Mediator 名字是中介者的意思。

那么它和中介者模式有什么关系呢？前面整理设计模式的时候，并没有去介绍具体的中介者模式的代码实现。

如下:

https://www.cnblogs.com/aoximin/p/13600464.html

之所以没写代码就是因为它现在是一种思想，以前的简单的已经很难满足我们现在开发的需求了。

那么看下Mediator 是如何做的吧。

Mediator 这个服务，是如何让我们的命令查询职责分离的。

首先安装一下包:

Mediator 核心接口为:

IMediator
IRequest,IRequest
IRequestHandler<in IRequest,TResponse>

一般从接口就能看到其设计思想，其余的实现，各有各的想法，那么就来看下IMediator吧。

/// <summary>

/// Defines a mediator to encapsulate request/response and publishing interaction patterns

/// </summary>

public interface IMediator : ISender, IPublisher

{

}

这个接口的作用是定义了一个中介者，这个中介者用来装入请求或者响应和实现一些交互模式。

那么看来分别就是ISender和IPublisher来实现了。

看下ISender:

/// <summary>

/// Send a request through the mediator pipeline to be handled by a single handler.

/// </summary>

public interface ISender

{

	/// <summary>

	/// Asynchronously send a request to a single handler

	/// </summary>

	/// <typeparam name="TResponse">Response type</typeparam>

	/// <param name="request">Request object</param>

	/// <param name="cancellationToken">Optional cancellation token</param>

	/// <returns>A task that represents the send operation. The task result contains the handler response</returns>

	Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default);

	/// <summary>

	/// Asynchronously send an object request to a single handler via dynamic dispatch

	/// </summary>

	/// <param name="request">Request object</param>

	/// <param name="cancellationToken">Optional cancellation token</param>

	/// <returns>A task that represents the send operation. The task result contains the type erased handler response</returns>

	Task<object?> Send(object request, CancellationToken cancellationToken = default);

}

这个接口用来通过由单个处理程序的中介者管道中发送请求。

IPublisher：

/// <summary>

/// Publish a notification or event through the mediator pipeline to be handled by multiple handlers.

/// </summary>

public interface IPublisher

{

	/// <summary>

	/// Asynchronously send a notification to multiple handlers

	/// </summary>

	/// <param name="notification">Notification object</param>

	/// <param name="cancellationToken">Optional cancellation token</param>

	/// <returns>A task that represents the publish operation.</returns>

	Task Publish(object notification, CancellationToken cancellationToken = default);

	/// <summary>

	/// Asynchronously send a notification to multiple handlers

	/// </summary>

	/// <param name="notification">Notification object</param>

	/// <param name="cancellationToken">Optional cancellation token</param>

	/// <returns>A task that represents the publish operation.</returns>

	Task Publish<TNotification>(TNotification notification, CancellationToken cancellationToken = default)

		where TNotification : INotification;

}

这个接口用来通过多个处理程序的中介者管道中发送通知或者事件。

好了，现在我们得到的信息有"发布"、"事件"、"请求"、"管道" 这几个名词了。

那么实际上我们也能大致的猜出它是怎么实现的。

接下来查看IRequest:

/// <summary>

/// Marker interface to represent a request with a void response

/// </summary>

public interface IRequest : IRequest<Unit> { }

/// <summary>

/// Marker interface to represent a request with a response

/// </summary>

/// <typeparam name="TResponse">Response type</typeparam>

public interface IRequest<out TResponse> : IBaseRequest { }

/// <summary>

/// Allows for generic type constraints of objects implementing IRequest or IRequest{TResponse}

/// </summary>

public interface IBaseRequest { }

这些上面的英文已经提示了，标志性作用，用来做定义的。

最后来看下IRequestHandler接口:

/// <summary>

/// Defines a handler for a request

/// </summary>

/// <typeparam name="TRequest">The type of request being handled</typeparam>

/// <typeparam name="TResponse">The type of response from the handler</typeparam>

public interface IRequestHandler<in TRequest, TResponse>

	where TRequest : IRequest<TResponse>

{

	/// <summary>

	/// Handles a request

	/// </summary>

	/// <param name="request">The request</param>

	/// <param name="cancellationToken">Cancellation token</param>

	/// <returns>Response from the request</returns>

	Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken);

}

现在我们在来整理一下名词:"发布"、"事件"、"请求"、"管道" 、"处理请求"

那么大概猜测大概通过接口来处理请求，然后还可以发布事件处理的。处理请求有处理请求的管道，且这个处理是单个处理程序，而处理事件是多个处理程序。

接下来操作一遍:

async static Task Main(string[] args)

{

	var services = new ServiceCollection();

	services.AddMediatR(typeof(Program).Assembly);

	var serviceProvider = services.BuildServiceProvider();

	var mediator = serviceProvider.GetService<IMediator>();

	await mediator.Send(new SelfCommand{ CommandName ="zhangsan"});

}

internal class SelfCommand : IRequest<long>

{

	public string CommandName { get; set; }

}

internal class SelfCommandHandler : IRequestHandler<SelfCommand, long>

{

	public Task<long> Handle(SelfCommand request, CancellationToken cancellationToken)

	{

		Console.WriteLine($"处理 {nameof(SelfCommand)}请求:{request.CommandName}");

		return Task.FromResult(10L);

	}

}

这里就有一个疑问了，为啥SelfCommandHandler会自动称为处理程序？我们并没有设置啊。

那么就来看一下send在干什么吧:

public Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default)

{

	if (request == null)

	{

		throw new ArgumentNullException(nameof(request));

	}

	var requestType = request.GetType();

	var handler = (RequestHandlerWrapper<TResponse>)_requestHandlers.GetOrAdd(requestType,

		t => (RequestHandlerBase)Activator.CreateInstance(typeof(RequestHandlerWrapperImpl<,>).MakeGenericType(requestType, typeof(TResponse))));

	return handler.Handle(request, cancellationToken, _serviceFactory);

}

上面可以看到生成了一个handle，然后调用了Handle 方法。

然后进RequestHandlerWrapperImpl 查看:

internal class RequestHandlerWrapperImpl<TRequest, TResponse> : RequestHandlerWrapper<TResponse>

	where TRequest : IRequest<TResponse>

{

	public override Task<object?> Handle(object request, CancellationToken cancellationToken,

		ServiceFactory serviceFactory)

	{

		return Handle((IRequest<TResponse>)request, cancellationToken, serviceFactory)

			.ContinueWith(t =>

			{

				if (t.IsFaulted)

				{

					ExceptionDispatchInfo.Capture(t.Exception.InnerException).Throw();

				}

				return (object?)t.Result;

			}, cancellationToken);

	}

	public override Task<TResponse> Handle(IRequest<TResponse> request, CancellationToken cancellationToken,

		ServiceFactory serviceFactory)

	{

		Task<TResponse> Handler() => GetHandler<IRequestHandler<TRequest, TResponse>>(serviceFactory).Handle((TRequest) request, cancellationToken);

		return serviceFactory

			.GetInstances<IPipelineBehavior<TRequest, TResponse>>()

			.Reverse()

			.Aggregate((RequestHandlerDelegate<TResponse>) Handler, (next, pipeline) => () => pipeline.Handle((TRequest)request, cancellationToken, next))();

	}

}

这里埋一个坑，因为看了一下，有很多细节的地方比如说Activator.CreateInstance的机制、一些管道细节，还设计到注册IPipelineBehavior<TRequest, TResponse>的实现类的机制，整理到该系列的细节篇中，将会比较详细的介绍。

现在只需要看Handle的ContinueWith，如果失败的话，那么会返回一个异常，否则返回结果。

然后根据上面的，我们指定Request对应的RequstHandle 必须名字有如下规律：如SelfCommand，只需要SelfCommand加长一些即可，比如说SelfCommandHandler，比如说SelfCommandHandlerV2，还可以SelfCommand2都行。

但是呢，最好改好名字，后面加Handle。

同时，如果我们写两个SelfCommandHandler和SelfCommandHandlerV2，那么是否两个都会执行？不是的，只会执行一个。

internal class SelfCommandHandler2 : IRequestHandler<SelfCommand, long>

{

	public Task<long> Handle(SelfCommand request, CancellationToken cancellationToken)

	{

		Console.WriteLine($"处理 {nameof(SelfCommand)} V2请求:{request.CommandName}");

		return Task.FromResult(10L);

	}

}

internal class SelfCommandHandler : IRequestHandler<SelfCommand, long>

{

	public Task<long> Handle(SelfCommand request, CancellationToken cancellationToken)

	{

		Console.WriteLine($"处理 {nameof(SelfCommand)}请求:{request.CommandName}");

		return Task.FromResult(10L);

	}

}

比如说这样，那么会执行。

也就是说会执行SelfCommandHandler2。

那么请求就算介绍完了，那么看下事件。

调用事件这样调用即可:

 await mediator.Publish(new SelfEvent { EventName = "SelfEvent" });

具体类:

internal class SelfEvent : INotification

{

	public string EventName { get; set; }

}

internal class SelfEventHandler : INotificationHandler<SelfEvent>

{

	public Task Handle(SelfEvent notification, CancellationToken cancellationToken)

	{

		Console.WriteLine($"SelfEventHandler 执行:{notification.EventName}");

		return Task.CompletedTask;

	}

}

internal class SelfEventHandlerV2 : INotificationHandler<SelfEvent>

{

	public Task Handle(SelfEvent notification, CancellationToken cancellationToken)

	{

		Console.WriteLine($"SelfEventHandlerV2 执行:{notification.EventName}");

		return Task.CompletedTask;

	}

}

效果:

那么和requst不同的是，注册几个就会调用几个。

好了现在回到中介者模式中来。

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

那么Mediator 这个模块呢，帮助我们解决了request和requesthandle之间的耦合，和 Event与EventHandle 之间的耦合。

一开始我认为是命令模式，后来一想，命令模式解决“行为请求者”与“行为实现者”的耦合。

命令模式如下:

https://www.cnblogs.com/aoximin/p/13616558.html

上面只是命令模式的一种形式哈。

结

下一节领域事件的处理。以上只是个人整理，如有错误，望请指点。

巴特西

重新整理 .net core 实践篇—————Mediator实践[二十八]

前言

正文

结

最新文章

热门文章