Méthode de développement de compte public C# WeChat pour la réception de push d'événements et la déduplication de messages

L'exemple de cet article décrit la méthode de réception du push d'événements et de la déduplication des messages dans le développement de comptes publics C# WeChat. Partagez-le avec tout le monde pour votre référence. L'analyse spécifique est la suivante :

Si le serveur WeChat ne reçoit pas de réponse dans les 5 secondes, il déconnectera la connexion et relancera la demande, en réessayant trois fois au total. Dans ce cas, le problème se pose. Il existe un tel scénario : lorsqu'un utilisateur suit un compte WeChat, les informations de l'utilisateur actuel sont obtenues, puis les informations sont écrites dans la base de données. Semblable à l’inscription sur le site Web du PC. C'est peut-être à cause de cette préoccupation que la logique métier que nous devons gérer est relativement complexe. Tels que l'envoi de points, la rédaction de journaux d'utilisateurs et l'attribution de groupes d'utilisateurs. Attendez... Une série de logiques doit être exécutée, ou l'environnement réseau est relativement complexe et il n'y a aucune garantie que l'opération de l'utilisateur actuel recevra une réponse dans les 5 secondes. Ensuite, si l'opération n'est pas encore terminée, le serveur WeChat. pousse le même événement d'attention sur notre serveur. Nous exécuterons à nouveau notre logique, ce qui peut conduire à des données en double dans la base de données (certains chaussures d'enfants diront, avant d'insérer les données, je détermine d'abord si elles existent déjà, et si elles existent, l'insertion ne sera pas effectuée. Ce que je veux dire, c'est que je le pensais au début, mais il y a encore un écart entre l'environnement d'exploitation réel et notre environnement de débogage. Ce n'est que lorsque j'ai découvert qu'il y en avait beaucoup. des informations utilisateur en double dans la base de données que j'ai découvert l'importance de la déduplication des messages.).

Il existe une différence entre les messages normaux et les messages d'événement dans la déduplication des messages. Les messages ordinaires utilisent msgid, tandis que les messages d'événement utilisent FromUserName CreateTime. Mon idée est la suivante :
Créer une nouvelle classe BaseMsg avec trois attributs : FromUser, MsgFlag et CreateTime. Le code est le suivant :

public class BaseMsg
{
        /// <summary>
        /// 发送者标识
        /// </summary>
        public string FromUser { get; set; }
        /// <summary>
        /// 消息表示。普通消息时，为msgid，事件消息时，为事件的创建时间
        /// </summary>
        public string MsgFlag { get; set; }
        /// <summary>
        /// 添加到队列的时间
        /// </summary>
        public DateTime CreateTime { get; set; }
}

Créez une file d'attente list_queue statique pour stocker la liste de messages. Le type de liste est List.
Avant de traiter le corps du message WeChat, déterminez d'abord si le corps du message WeChat est affiché. list est instanciée, si elle n'est pas instanciée, instanciez-la, sinon jugez si la longueur de la liste est supérieure ou égale à 50 (cela peut être personnalisé et est utilisé pour le volume de messages simultanés de WeChat). supérieur ou égal à 50, conservez les messages qui n'ont pas répondu dans les 20 secondes (Réessayez une fois toutes les 5 secondes, pour un total de 3 tentatives, soit 15 secondes. Par mesure de sécurité, j'écris ici 20 secondes).
Obtenez le type de message du corps du message actuel et déterminez si le message actuel a été demandé en fonction de _queue. S'il s'agit d'un événement, FromUser et l'heure de création sont enregistrés. S'il s'agit d'un message normal, MsgFlag est enregistré. Voici le code :

if (_queue == null)
{
 _queue = new List<BaseMsg>();
}
else if(_queue.Count>=50)
{
 _queue = _queue.Where(q => { return q.CreateTime.AddSeconds(20) > DateTime.Now; }).ToList();//保留20秒内未响应的消息
}
XElement xdoc = XElement.Parse(xml);
var msgtype = xdoc.Element("MsgType").Value.ToUpper();
var FromUserName = xdoc.Element("FromUserName").Value;
var MsgId = xdoc.Element("MsgId").Value;
var CreateTime = xdoc.Element("CreateTime").Value;
MsgType type = (MsgType)Enum.Parse(typeof(MsgType), msgtype);
if (type!=MsgType.EVENT)
{
 if (_queue.FirstOrDefault(m => { return m.MsgFlag == MsgId; }) == null)
 {
     _queue.Add(new BaseMsg
     {
  CreateTime = DateTime.Now,
  FromUser = FromUserName,
  MsgFlag = MsgId
     });
 }
 else
 {
     return null;
 }
       
}
else
{
 if (_queue.FirstOrDefault(m => { return m.MsgFlag == CreateTime; }) == null)
 {
     _queue.Add(new BaseMsg
     {
  CreateTime = DateTime.Now,
  FromUser = FromUserName,
  MsgFlag = CreateTime
     });
 }
 else
 {
     return null;
 }
}

Lorsque le message existe déjà dans la file d'attente, le message actuel ne sera pas converti en entité, et null sera renvoyé directement lors de l'appel, aucun traitement ne sera effectué. lorsque null est renvoyé.

Commençons par expliquer l’actualité de l’événement. Suite de l'article précédent. Tous les messages héritent de BaseMessage et tous les types d'événements contiennent une propriété Event. Pour faciliter l'appel ici, une fois le message

/// <summary>
/// 事件类型枚举
/// </summary>
public enum Event
{
        /// <summary>
        /// 非事件类型
        /// </summary>
        NOEVENT,
        /// <summary>
        /// 订阅
        /// </summary>
        SUBSCRIBE,
        /// <summary>
        /// 取消订阅
        /// </summary>
        UNSUBSCRIBE,
        /// <summary>
        /// 扫描带参数的二维码
        /// </summary>
        SCAN,
        /// <summary>
        /// 地理位置
        /// </summary>
        LOCATION,
        /// <summary>
        /// 单击按钮
        /// </summary>
        CLICK,
        /// <summary>
        /// 链接按钮
        /// </summary>
        VIEW,
        /// <summary>
        /// 扫码推事件
        /// </summary>
        SCANCODE_PUSH,
        /// <summary>
        /// 扫码推事件且弹出“消息接收中”提示框
        /// </summary>
        SCANCODE_WAITMSG,
        /// <summary>
        /// 弹出系统拍照发图
        /// </summary>
        PIC_SYSPHOTO,
        /// <summary>
        /// 弹出拍照或者相册发图
        /// </summary>
        PIC_PHOTO_OR_ALBUM,
        /// <summary>
        /// 弹出微信相册发图器
        /// </summary>
        PIC_WEIXIN,
        /// <summary>
        /// 弹出地理位置选择器
        /// </summary>
        LOCATION_SELECT,
        /// <summary>
        /// 模板消息推送
        /// </summary>
        TEMPLATESENDJOBFINISH
}

défini dans l'énumération, l'entité de message est définie.

Suivre/ne plus suivre l'événement
le paquet de données XML est le suivant :

<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[subscribe]]></Event>
</xml>

Entité correspondante :

/// <summary>
/// 订阅/取消订阅事件
/// </summary>
public class SubEventMessage : EventMessage
{
        private string _eventkey;
        /// <summary>
        /// 事件KEY值，qrscene_为前缀，后面为二维码的参数值（已去掉前缀，可以直接使用）
        /// </summary>
        public string EventKey
        {
            get { return _eventkey; }
            set { _eventkey = value.Replace("qrscene_", ""); }
        }
        /// <summary>
        /// 二维码的ticket，可用来换取二维码图片
        /// </summary>
        public string Ticket { get; set; }
}

Ce qui doit être noté ici, c'est que lorsque l'utilisateur scanne Lors de l'utilisation d'un code QR avec des paramètres, si l'utilisateur ne suit pas le compte public actuel, et qu'il le fait, le paramètre qrscene_ et Ticket seront inclus dans le corps du message, donc deux attributs sont définis ici : EventKey et Ticket . Lorsque vous attribuez une valeur à EventKey, remplacez qrscene_, car ce dont nous avons réellement besoin, ce sont les paramètres suivants.

Événement de numérisation de code QR avec paramètres
Lorsqu'un utilisateur scanne un code QR avec une valeur de scène, deux événements peuvent être poussés :

Si l'utilisateur n'a pas suivi le compte officiel, l'utilisateur Vous pouvez suivre le compte public. Après avoir suivi, WeChat transmettra les événements suivants avec les valeurs de scène aux développeurs.
Si l'utilisateur a suivi le compte officiel, WeChat transmettra l'événement d'analyse avec la valeur de la scène au développeur. ,
Le premier type a été discuté ci-dessus, et seul le deuxième type sera expliqué ici.

Evénement push lorsque l'utilisateur a suivi

Le package xml est le suivant :

<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[SCAN]]></Event>
<EventKey><![CDATA[SCENE_VALUE]]></EventKey>
<Ticket><![CDATA[TICKET]]></Ticket>
</xml>

Les entités correspondantes sont les suivantes :

/// <summary>
/// 扫描带参数的二维码实体
/// </summary>
public class ScanEventMessage : EventMessage
{
 
        /// <summary>
        /// 事件KEY值，是一个32位无符号整数，即创建二维码时的二维码scene_id
        /// </summary>
        public string EventKey { get; set; }
        /// <summary>
        /// 二维码的ticket，可用来换取二维码图片
        /// </summary>
        public string Ticket { get; set; }
}

Signaler un événement de géolocalisation
Lorsque le compte officiel active la fonction de rapport de localisation géographique, chaque fois que l'utilisateur entre dans la session du compte officiel et accepte de signaler la situation géographique, la position géographique sera signalée lors de l'entrée, ou la position géographique l'emplacement sera signalé toutes les 5 secondes après avoir saisi la réponse Emplacement, le compte public peut modifier les paramètres en arrière-plan de la plateforme publique. Lors du signalement de l'emplacement géographique, WeChat transmettra l'événement de localisation géographique signalé vers l'URL renseignée par le développeur.

Le package de données XML est le suivant :

<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[fromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[LOCATION]]></Event>
<Latitude>23.137466</Latitude>
<Longitude>113.352425</Longitude>
<Precision>119.385040</Precision>
</xml>

Les entités correspondantes sont les suivantes :

/// <summary>
/// 上报地理位置实体
/// </summary>
public class LocationEventMessage : EventMessage
{
 
        /// <summary>
        /// 地理位置纬度
        /// </summary>
        public string Latitude { get; set; }
        /// <summary>
        /// 地理位置经度
        /// </summary>
        public string Longitude { get; set; }
       /// <summary>
        /// 地理位置精度
       /// </summary>
        public string Precision { get; set; }
}

Les événements couramment utilisés pour les événements de menu personnalisés sont : cliquer, afficher , scancode_puth, scancode_waitmsg, location_select. Il existe également trois événements pour publier des images. Comme ils ne sont pas couramment utilisés, l'auteur n'a pas pensé aux scénarios d'utilisation, je ne les décrirai donc pas un par un. Si vous êtes intéressé, vous pouvez les étudier vous-même ou communiquer avec moi. .

Le paquet de données XML poussé par l'événement click :

<xml>
<ToUserName><![CDATA[toUser]]></ToUserName>
<FromUserName><![CDATA[FromUser]]></FromUserName>
<CreateTime>123456789</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[CLICK]]></Event>
<EventKey><![CDATA[EVENTKEY]]></EventKey>
</xml>

Le format du paquet de données XML poussé par l'événement view est le même que celui du clic, il suffit donc de définir une classe , comme suit :

/// <summary>
/// 普通菜单事件，包括click和view
/// </summary>
public class NormalMenuEventMessage : EventMessage
{
 
        /// <summary>
        /// 事件KEY值，设置的跳转URL
        /// </summary>
        public string EventKey { get; set; }
}

Le paquet de données XML de l'événement scancode est le suivant :

<xml><ToUserName><![CDATA[ToUserName]]></ToUserName>
<FromUserName><![CDATA[FromUserName]]></FromUserName>
<CreateTime>1419265698</CreateTime>
<MsgType><![CDATA[event]]></MsgType>
<Event><![CDATA[scancode_push]]></Event>
<EventKey><![CDATA[EventKey]]></EventKey>
<ScanCodeInfo><ScanType><![CDATA[qrcode]]></ScanType>
<ScanResult><![CDATA[http://weixin.qq.com/r/JEy5oRLE0U_urVbC9xk2]]></ScanResult>
</ScanCodeInfo>
</xml>

Les entités correspondantes sont les suivantes :

/// <summary>
/// 菜单扫描事件
/// </summary>
public class ScanMenuEventMessage : EventMessage
{
 
        /// <summary>
        /// 事件KEY值
        /// </summary>
        public string EventKey { get; set; }
        /// <summary>
        /// 扫码类型。qrcode是二维码，其他的是条码
        /// </summary>
        public string ScanType { get; set; }
        /// <summary>
        /// 扫描结果
        /// </summary>
        public string ScanResult { get; set; }
}

À ce stade, les messages de type d'événement actuellement couramment utilisés ont été définis, combinés à ce qui a été mentionné dans l'article précédent, le code complet pour convertir les paquets de données XML en objets est le suivant :

public class MessageFactory
{
        private static List<BaseMsg> _queue; 
        public static BaseMessage CreateMessage(string xml)
        {
            if (_queue == null)
            {
                _queue = new List<BaseMsg>();
            }
            else if(_queue.Count>=50)
            {
                _queue = _queue.Where(q => { return q.CreateTime.AddSeconds(20) > DateTime.Now; }).ToList();//保留20秒内未响应的消息
            }
            XElement xdoc = XElement.Parse(xml);
            var msgtype = xdoc.Element("MsgType").Value.ToUpper();
            var FromUserName = xdoc.Element("FromUserName").Value;
            var MsgId = xdoc.Element("MsgId").Value;
            var CreateTime = xdoc.Element("CreateTime").Value;
            MsgType type = (MsgType)Enum.Parse(typeof(MsgType), msgtype);
            if (type!=MsgType.EVENT)
            {
                if (_queue.FirstOrDefault(m => { return m.MsgFlag == MsgId; }) == null)
                {
                    _queue.Add(new BaseMsg
                    {
                        CreateTime = DateTime.Now,
                        FromUser = FromUserName,
                        MsgFlag = MsgId
                    });
                }
                else
                {
                    return null;
                }
               
            }
            else
            {
                if (_queue.FirstOrDefault(m => { return m.MsgFlag == CreateTime; }) == null)
                {
                    _queue.Add(new BaseMsg
                    {
                        CreateTime = DateTime.Now,
                        FromUser = FromUserName,
                        MsgFlag = CreateTime
                    });
                }
                else
                {
                    return null;
                }
            }
            switch (type)
            {
                case MsgType.TEXT: return Utils.ConvertObj<TextMessage>(xml);
                case MsgType.IMAGE: return Utils.ConvertObj<ImgMessage>(xml);
                case MsgType.VIDEO: return Utils.ConvertObj<VideoMessage>(xml);
                case MsgType.VOICE: return Utils.ConvertObj<VoiceMessage>(xml);
                case MsgType.LINK:
                    return Utils.ConvertObj<LinkMessage>(xml);
                case MsgType.LOCATION:
                    return Utils.ConvertObj<LocationMessage>(xml);
                case MsgType.EVENT://事件类型
                {
                    var eventtype = (Event)Enum.Parse(typeof(Event), xdoc.Element("Event").Value.ToUpper());
                    switch (eventtype)
                    {
                        case Event.CLICK:
                            return Utils.ConvertObj<NormalMenuEventMessage>(xml);
                        case Event.VIEW: return Utils.ConvertObj<NormalMenuEventMessage>(xml);
                        case Event.LOCATION: return Utils.ConvertObj<LocationEventMessage>(xml);
                        case Event.LOCATION_SELECT: return Utils.ConvertObj<LocationMenuEventMessage>(xml);
                        case Event.SCAN: return Utils.ConvertObj<ScanEventMessage>(xml);
                        case Event.SUBSCRIBE: return Utils.ConvertObj<SubEventMessage>(xml);
                        case Event.UNSUBSCRIBE: return Utils.ConvertObj<SubEventMessage>(xml);
                        case Event.SCANCODE_WAITMSG: return Utils.ConvertObj<ScanMenuEventMessage>(xml);
                        default:
                            return Utils.ConvertObj<EventMessage>(xml);
                    }
                } break;
                default:
                    return Utils.ConvertObj<BaseMessage>(xml);
            }
        }
}

J'espère cet article sera utile au développement WeChat de chacun basé sur C#.

Pour plus d'articles liés aux méthodes de réception de push d'événements et de déduplication de messages dans le développement de comptes publics C# WeChat, veuillez prêter attention au site Web PHP chinois !