Shulou(Shulou.com)06/01 Report--

This article mainly explains "how to write chat software in c #". The content of the explanation in the article is simple and clear, and it is easy to learn and understand. let's study and learn "how to write chat software in c #"!

Responsibility chain model

The chain of responsibility pattern contains a number of command objects and a series of processing objects, each of which determines which command objects it can process, and it also knows how to pass command objects that it cannot handle to the next processing object in the chain. The pattern also describes how to add a new processing object to the end of the processing chain.

We are no stranger to the chain of responsibility model. ChannelHandler in Netty and Slot in Sentinel all use the chain of responsibility model.

ChannelHandler chain of responsibility model in Netty:

Slot chain of responsibility model in Sentinel:

For example, the purpose of Netty and Sentinel also lies in that there are some differences in the use of the two. The former realizes the responsibility chain of two-way transmission, while the latter is one-way transmission. The two also have something in common, both use linked lists to connect a series of processing objects into a chain of responsibility.

In addition to using an one-way or two-way linked list to implement the responsibility chain invocation pattern, you can also use a collection implementation to put the processing objects into the collection sequentially and call it by traversing the collection.

The relationship between filter, interceptor and chain of responsibility

Among the 23 design patterns, filter pattern and interceptor pattern are not defined separately, and they are only classified as structural design patterns on wiki.

Both filter pattern and interceptor pattern depend on the responsibility chain pattern in implementation. therefore, the author regards the filter pattern and interceptor pattern as a derivative of the responsibility chain pattern and a variation of the responsibility chain pattern. but you can't use the equal sign.

The filter mode is to form a linked list of all filter objects, and as long as one of the filters meets the criteria, subsequent filters will not be called, and commands can eventually be processed by that filter.

The filtering method of the filter generally returns a Boolean value, indicating filtering or not filtering. When the filtering method returns a value type of void, it means that the filter must respond to the command to end the command processing after deciding to filter the current command.

The filter mode has no strict requirements on the order of calling the filter, which mainly depends on the specific usage scenario.

If you need to consider the priority of the blacklist and whitelist filter, the order is different and the results are completely different.

For example, Shiro uses filter mode to implement the authentication and authorization function.

(Shiro frame filter mode)

Interceptor pattern is roughly the same as filter pattern, often used in conjunction with dynamic proxy mode, interceptor can intercept method calls (requests) or change the parameters passed by method calls (requests).

The relationship between Agent Mode and entrustment Mode

Reference Wikipedia: the goal of the proxy pattern is to define a proxy object that operates between the client and the actual principal to control access to the real principal and to perform the necessary tasks each time the real topic is accessed.

Agent mode is also divided into dynamic agent and static agent, in which dynamic agent mode is the most widely used and most widely used agent mode. The proxy pattern is also one of the most frequently used design patterns.

Refer to Wikipedia: delegated patterns are a basic skill in software design patterns. In delegate mode, two objects participate in processing the same request, and the object that accepts the request delegates the request to another object to process.

The difference between agency mode and entrustment mode is also controversial.

Among the 23 design patterns, there is no separate definition of the delegate pattern. Some people think that the delegate pattern is just another name for the proxy pattern, while others think that the delegate does not have to call the same method or implement the same interface. A proxy is a method or all the methods of an interface.

From a definition point of view, the two are indeed different design patterns, for the above two views, if you want to discuss right or wrong, the author agrees with the latter.

The author used to use C # to develop windows applications using delegation mode, such as dealing with a diary event, when listening to the diary, entrusting a class to display the diary on the front-end control, and the trustee entrusted the trustee to display the diary, there is no strict agreement between the two.

(chat software written by c #)

Combined use of combination mode and policy mode

A composite pattern, also known as a composite pattern, describes a set of objects that are treated in the same way as a single instance of the same type of object. The purpose of composition is to "combine" objects into a tree structure to represent part of the overall hierarchy.

According to a popular understanding, a combination pattern is to combine instances that implement the same interface, or to combine multiple combinations of the same type together to form a tree. When the method of this number is called externally, the methods of all leaf nodes are called.

The combination model may be unfamiliar to us, so let's look at an example to understand it.

1. Declare the object interface in the composition: component (Component), and provide interface implementation class (Leaf)

2. Define composite classes with component behavior, store components, and support adding components

3. Combine the objects in the combination operation.

Refer to Wikipedia: policy mode means that an object has a behavior, but in different scenarios, the behavior has different implementation algorithms.

The combination pattern, used in combination with the policy pattern, is very common in SpringBoot's web framework, such as implementing method parameter parsing.

Define the method parameter parser (HandlerMethodArgumentResolver). The HandlerMethodArgumentResolver is both the policy interface (Strategy) in the policy pattern and the component (Component) in the composite pattern.

The composition pattern combines objects that have the same treatment, that is, all the method parameter parsers.

The policy pattern selects a parser that can parse the method parameters according to the type of the method parameters or the comments on the parameters, and the parser parses the method parameters from the request (packet).

HandlerMethodArgumentResolverComposite is not only the Composite in the combination mode, but also the Context in the policy mode.

RequestResponseBodyMethodProcessor is responsible for parsing the method parameters annotated by the @ ResponseBody annotation and the PathVariableMethodArgumentResolver load resolution annotated by the @ PathVariable annotation, all of which are Leaf in the combined pattern and entity policies in the policy pattern.

Adapter mode

Definition of the adapter pattern: the adapter pattern is to enable classes that cannot work together because of interface incompatibility by wrapping the class's own interface in an existing class.

Taking the implementation of failed timed retry of payment result callback as an example, assume that there are two existing implementation schemes of failed timed retry:

One is to support failed timing retries using cron expressions.

The other is to support a custom cycle of failure timing retry, such as interval 2 seconds, 4 seconds, 8 seconds. Try again later.

Use the adapter pattern to combine the two ways to provide services, and make some extensions.

For external callers, only need to access one interface to get a variety of ways of support, internal multiple ways to provide services to the outside.

Adapt to the use of different scenarios

How to understand that design patterns should be changed to adapt to different scenarios? Let's take the encapsulated json serialization and deserialization tool as an example.

In practical projects, we can use frameworks such as gson and Jackson to serialize and deserialize Java objects, but generally we don't use multiple ones at the same time, nor do we use different frameworks for different businesses. On the contrary, we usually only choose one of them, and we don't change it very often.

The policy pattern can be used to switch the framework later without modifying the business code, but in this scenario, do we really need a textbook policy pattern?

The most appropriate approach should be to decide which serialization strategy to use based on the introduction of different frameworks, and to implement the "policy" through class loading, a subtle change that provides a smarter strategy for encapsulated components.

For example, after we add gson dependencies to the project, the serialization and deserialization of the entire project will be done by gson, and when we change from relying on gson to relying on Jackson, the serialization and deserialization of the entire project will automatically switch to Jackson.

Thank you for your reading. the above is the content of "how to write chat software in c #". After the study of this article, I believe you have a deeper understanding of the problem of how to write chat software in c #. The specific use of the situation also needs to be verified by practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.