一、前言
特別不喜歡麻煩的一個人，最近碰到了微信開發。下載下來了一些其他人寫的微信開發“框架”，但是被惡心到了，實現的太臃腫啦。
最不喜歡的就是把微信返回的xml消息在組裝成實體類，所以會比較臃腫，現在都提倡輕量級，所以有什麼辦法可以避免大量實體類的存在呢。
當然，還有包裝的比較繁雜，看完官方API後，再看"框架"，讓人感覺一頭霧水，不夠清晰、明了。
二、我的實現思路
我的微信SDK（不敢自稱框架），最重要的實現2個目標：
1.輕量級，就是要摒棄實體類，盡量少的申明Entity，減少SDK的體量；
2.簡單、明了，就是SDK類的劃分和官方API保持一致，讓人一看就懂你的用意。
用戶發送請是首先POST到微信服務器的，然後微信服務器在POST到我的服務器，這個接受的消息是xml,我猜測為什麼是xml,而不是更輕量級的json，是為了更好的兼容性，畢竟xml更通用一些（說錯了，請指出來）。而我們主動調用微信的一些API時，它返回的是json格式，我靠，要死啊，高大上啊。你們的副總裁張小龍不知道這事嗎？好吧，這樣其實也可以的。
其實，調用微信的工作原理很簡單，沒有必要上來就框架什麼的，我相信是個合格的程序員都能做出來。
我們的服務器只需要一個GET,和一個POST就可以和微信通信了，從這一點來看，設計的還是比較人性化的，贊一個。GET用於接通微信服務的校驗，驗證；POST用於接收微信服務器過來的消息，然後將Response組裝好返回即可。
三、上代碼
好了，廢話不多說了。
由於微信服務器Post給我們的是xml消息，返回的是json,所以需要互轉。這樣就存在3種類型的format,這也是大量的框架定義實體類導致框架不夠輕量級的的原因之所在。
實現第一個目標，我主要用到了.net Framework4.0的Dynamic特性，和一個將xml字符串自動轉換成Dynamic Object的DynamicXml.cs類，還有一個將json字符串自動轉換成Dynamic Object的DynamicJson.cs類。
苦苦尋覓，終於讓我找到了我想要的。
1.以下是DynamicXml.cs類，文件頭有原作者的版權信息。
![]()
/*--------------------------------------------------------------------------
* https://www.captechconsulting.com/blog/kevin-hazzard/fluent-xml-parsing-using-cs-dynamic-type-part-1
* 博客園網友 夜の魔王 友情借用此代碼，用於微信開發。
* http://www.cnblogs.com/deepleo/
*--------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Dynamic;
using System.Xml.Linq;
using System.Collections;
public class DynamicXml : DynamicObject, IEnumerable
{
private readonly List<XElement> _elements;
public DynamicXml(string text)
{
var doc = XDocument.Parse(text);
_elements = new List<XElement> { doc.Root };
}
protected DynamicXml(XElement element)
{
_elements = new List<XElement> { element };
}
protected DynamicXml(IEnumerable<XElement> elements)
{
_elements = new List<XElement>(elements);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
if (binder.Name == "Value")
result = _elements[0].Value;
else if (binder.Name == "Count")
result = _elements.Count;
else
{
var attr = _elements[0].Attribute(XName.Get(binder.Name));
if (attr != null)
result = attr;
else
{
var items = _elements.Descendants(XName.Get(binder.Name));
if (items == null || items.Count() == 0) return false;
result = new DynamicXml(items);
}
}
return true;
}
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
{
int ndx = (int)indexes[0];
result = new DynamicXml(_elements[ndx]);
return true;
}
public IEnumerator GetEnumerator()
{
foreach (var element in _elements)
yield return new DynamicXml(element);
}
}
View Code
這個代碼我也沒仔細看，反正能用，沒出過差錯。
2.以下是DynamicJson.cs類，文件頭有原作者的版權信息
![]()
/*--------------------------------------------------------------------------
* DynamicJson
* ver 1.2.0.0 (May. 21th, 2010)
*
* created and maintained by neuecc <
[email protected]>
* licensed under Microsoft Public License(Ms-PL)
* http://neue.cc/
* http://dynamicjson.codeplex.com/
* 博客園網友 夜の魔王 友情借用此代碼，用於微信開發。
* http://www.cnblogs.com/deepleo/
*--------------------------------------------------------------------------*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Xml;
using System.Xml.Linq;
namespace Codeplex.Data
{
public class DynamicJson : DynamicObject
{
private enum JsonType
{
@string, number, boolean, @object, array, @null
}
// public static methods
/// <summary>from JsonSring to DynamicJson</summary>
public static dynamic Parse(string json)
{
return Parse(json, Encoding.Unicode);
}
/// <summary>from JsonSring to DynamicJson</summary>
public static dynamic Parse(string json, Encoding encoding)
{
using (var reader = JsonReaderWriterFactory.CreateJsonReader(encoding.GetBytes(json), XmlDictionaryReaderQuotas.Max))
{
return ToValue(XElement.Load(reader));
}
}
/// <summary>from JsonSringStream to DynamicJson</summary>
public static dynamic Parse(Stream stream)
{
using (var reader = JsonReaderWriterFactory.CreateJsonReader(stream, XmlDictionaryReaderQuotas.Max))
{
return ToValue(XElement.Load(reader));
}
}
/// <summary>from JsonSringStream to DynamicJson</summary>
public static dynamic Parse(Stream stream, Encoding encoding)
{
using (var reader = JsonReaderWriterFactory.CreateJsonReader(stream, encoding, XmlDictionaryReaderQuotas.Max, _ => { }))
{
return ToValue(XElement.Load(reader));
}
}
/// <summary>create JsonSring from primitive or IEnumerable or Object({public property name:property value})</summary>
public static string Serialize(object obj)
{
return CreateJsonString(new XStreamingElement("root", CreateTypeAttr(GetJsonType(obj)), CreateJsonNode(obj)));
}
// private static methods
private static dynamic ToValue(XElement element)
{
var type = (JsonType)Enum.Parse(typeof(JsonType), element.Attribute("type").Value);
switch (type)
{
case JsonType.boolean:
return (bool)element;
case JsonType.number:
return (double)element;
case JsonType.@string:
return (string)element;
case JsonType.@object:
case JsonType.array:
return new DynamicJson(element, type);
case JsonType.@null:
default:
return null;
}
}
private static JsonType GetJsonType(object obj)
{
if (obj == null) return JsonType.@null;
switch (Type.GetTypeCode(obj.GetType()))
{
case TypeCode.Boolean:
return JsonType.boolean;
case TypeCode.String:
case TypeCode.Char:
case TypeCode.DateTime:
return JsonType.@string;
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.Decimal:
case TypeCode.SByte:
case TypeCode.Byte:
return JsonType.number;
case TypeCode.Object:
return (obj is IEnumerable) ? JsonType.array : JsonType.@object;
case TypeCode.DBNull:
case TypeCode.Empty:
default:
return JsonType.@null;
}
}
private static XAttribute CreateTypeAttr(JsonType type)
{
return new XAttribute("type", type.ToString());
}
private static object CreateJsonNode(object obj)
{
var type = GetJsonType(obj);
switch (type)
{
case JsonType.@string:
case JsonType.number:
return obj;
case JsonType.boolean:
return obj.ToString().ToLower();
case JsonType.@object:
return CreateXObject(obj);
case JsonType.array:
return CreateXArray(obj as IEnumerable);
case JsonType.@null:
default:
return null;
}
}
private static IEnumerable<XStreamingElement> CreateXArray<T>(T obj) where T : IEnumerable
{
return obj.Cast<object>()
.Select(o => new XStreamingElement("item", CreateTypeAttr(GetJsonType(o)), CreateJsonNode(o)));
}
private static IEnumerable<XStreamingElement> CreateXObject(object obj)
{
return obj.GetType()
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Select(pi => new { Name = pi.Name, Value = pi.GetValue(obj, null) })
.Select(a => new XStreamingElement(a.Name, CreateTypeAttr(GetJsonType(a.Value)), CreateJsonNode(a.Value)));
}
private static string CreateJsonString(XStreamingElement element)
{
using (var ms = new MemoryStream())
using (var writer = JsonReaderWriterFactory.CreateJsonWriter(ms, Encoding.Unicode))
{
element.WriteTo(writer);
writer.Flush();
return Encoding.Unicode.GetString(ms.ToArray());
}
}
// dynamic structure represents JavaScript Object/Array
readonly XElement xml;
readonly JsonType jsonType;
/// <summary>create blank JSObject</summary>
public DynamicJson()
{
xml = new XElement("root", CreateTypeAttr(JsonType.@object));
jsonType = JsonType.@object;
}
private DynamicJson(XElement element, JsonType type)
{
Debug.Assert(type == JsonType.array || type == JsonType.@object);
xml = element;
jsonType = type;
}
public bool IsObject { get { return jsonType == JsonType.@object; } }
public bool IsArray { get { return jsonType == JsonType.array; } }
/// <summary>has property or not</summary>
public bool IsDefined(string name)
{
return IsObject && (xml.Element(name) != null);
}
/// <summary>has property or not</summary>
public bool IsDefined(int index)
{
return IsArray && (xml.Elements().ElementAtOrDefault(index) != null);
}
/// <summary>delete property</summary>
public bool Delete(string name)
{
var elem = xml.Element(name);
if (elem != null)
{
elem.Remove();
return true;
}
else return false;
}
/// <summary>delete property</summary>
public bool Delete(int index)
{
var elem = xml.Elements().ElementAtOrDefault(index);
if (elem != null)
{
elem.Remove();
return true;
}
else return false;
}
/// <summary>mapping to Array or Class by Public PropertyName</summary>
public T Deserialize<T>()
{
return (T)Deserialize(typeof(T));
}
private object Deserialize(Type type)
{
return (IsArray) ? DeserializeArray(type) : DeserializeObject(type);
}
private dynamic DeserializeValue(XElement element, Type elementType)
{
var value = ToValue(element);
if (value is DynamicJson)
{
value = ((DynamicJson)value).Deserialize(elementType);
}
return Convert.ChangeType(value, elementType);
}
private object DeserializeObject(Type targetType)
{
var result = Activator.CreateInstance(targetType);
var dict = targetType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanWrite)
.ToDictionary(pi => pi.Name, pi => pi);
foreach (var item in xml.Elements())
{
PropertyInfo propertyInfo;
if (!dict.TryGetValue(item.Name.LocalName, out propertyInfo)) continue;
var value = DeserializeValue(item, propertyInfo.PropertyType);
propertyInfo.SetValue(result, value, null);
}
return result;
}
private object DeserializeArray(Type targetType)
{
if (targetType.IsArray) // Foo[]
{
var elemType = targetType.GetElementType();
dynamic array = Array.CreateInstance(elemType, xml.Elements().Count());
var index = 0;
foreach (var item in xml.Elements())
{
array[index++] = DeserializeValue(item, elemType);
}
return array;
}
else // List<Foo>
{
var elemType = targetType.GetGenericArguments()[0];
dynamic list = Activator.CreateInstance(targetType);
foreach (var item in xml.Elements())
{
list.Add(DeserializeValue(item, elemType));
}
return list;
}
}
// Delete
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = (IsArray)
? Delete((int)args[0])
: Delete((string)args[0]);
return true;
}
// IsDefined, if has args then TryGetMember
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
if (args.Length > 0)
{
result = null;
return false;
}
result = IsDefined(binder.Name);
return true;
}
// Deserialize or foreach(IEnumerable)
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.Type == typeof(IEnumerable) || binder.Type == typeof(object[]))
{
var ie = (IsArray)
? xml.Elements().Select(x => ToValue(x))
: xml.Elements().Select(x => (dynamic)new KeyValuePair<string, object>(x.Name.LocalName, ToValue(x)));
result = (binder.Type == typeof(object[])) ? ie.ToArray() : ie;
}
else
{
result = Deserialize(binder.Type);
}
return true;
}
private bool TryGet(XElement element, out object result)
{
if (element == null)
{
result = null;
return false;
}
result = ToValue(element);
return true;
}
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
{
return (IsArray)
? TryGet(xml.Elements().ElementAtOrDefault((int)indexes[0]), out result)
: TryGet(xml.Element((string)indexes[0]), out result);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
return (IsArray)
? TryGet(xml.Elements().ElementAtOrDefault(int.Parse(binder.Name)), out result)
: TryGet(xml.Element(binder.Name), out result);
}
private bool TrySet(string name, object value)
{
var type = GetJsonType(value);
var element = xml.Element(name);
if (element == null)
{
xml.Add(new XElement(name, CreateTypeAttr(type), CreateJsonNode(value)));
}
else
{
element.Attribute("type").Value = type.ToString();
element.ReplaceNodes(CreateJsonNode(value));
}
return true;
}
private bool TrySet(int index, object value)
{
var type = GetJsonType(value);
var e = xml.Elements().ElementAtOrDefault(index);
if (e == null)
{
xml.Add(new XElement("item", CreateTypeAttr(type), CreateJsonNode(value)));
}
else
{
e.Attribute("type").Value = type.ToString();
e.ReplaceNodes(CreateJsonNode(value));
}
return true;
}
public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
{
return (IsArray)
? TrySet((int)indexes[0], value)
: TrySet((string)indexes[0], value);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return (IsArray)
? TrySet(int.Parse(binder.Name), value)
: TrySet(binder.Name, value);
}
public override IEnumerable<string> GetDynamicMemberNames()
{
return (IsArray)
? xml.Elements().Select((x, i) => i.ToString())
: xml.Elements().Select(x => x.Name.LocalName);
}
/// <summary>Serialize to JsonString</summary>
public override string ToString()
{
// <foo type="null"></foo> is can't serialize. replace to <foo type="null" />
foreach (var elem in xml.Descendants().Where(x => x.Attribute("type").Value == "null"))
{
elem.RemoveNodes();
}
return CreateJsonString(new XStreamingElement("root", CreateTypeAttr(jsonType), xml.Elements()));
}
}
}
View Code
這個代碼我也依舊沒仔細看，反正也能用，沒出過差錯。
這個最核心的攔路虎解決了，後面的事情就順理成章的進行啦。
3.基礎支持API包裝
![]()
/*--------------------------------------------------------------------------
* BasicAPI.cs
*Auth:deepleo
* Date:2013.12.31
* Email:
[email protected]
*--------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Http;
using Codeplex.Data;
using System.IO;
namespace Deepleo.Weixin.SDK
{
/// <summary>
/// 對應微信API的 "基礎支持"
/// </summary>
public class BasicAPI
{
/// <summary>
/// 檢查簽名是否正確:
/// http://mp.weixin.qq.com/wiki/index.php?title=%E6%8E%A5%E5%85%A5%E6%8C%87%E5%8D%97
/// </summary>
/// <param name="signature"></param>
/// <param name="timestamp"></param>
/// <param name="nonce"></param>
/// <param name="token">AccessToken</param>
/// <returns>
/// true: check signature success
/// false: check failed, 非微信官方調用!
/// </returns>
public static bool CheckSignature(string signature, string timestamp, string nonce, string token, out string ent)
{
var arr = new[] { token, timestamp, nonce }.OrderBy(z => z).ToArray();
var arrString = string.Join("", arr);
var sha1 = System.Security.Cryptography.SHA1.Create();
var sha1Arr = sha1.ComputeHash(Encoding.UTF8.GetBytes(arrString));
StringBuilder enText = new StringBuilder();
foreach (var b in sha1Arr)
{
enText.AppendFormat("{0:x2}", b);
}
ent = enText.ToString();
return signature == enText.ToString();
}
/// <summary>
/// 獲取AccessToken
/// http://mp.weixin.qq.com/wiki/index.php?title=%E8%8E%B7%E5%8F%96access_token
/// </summary>
/// <param name="grant_type"></param>
/// <param name="appid"></param>
/// <param name="secrect"></param>
/// <returns>access_toke</returns>
public static dynamic GetAccessToken( string appid, string secrect)
{
var url = string.Format("https://api.weixin.qq.com/cgi-bin/token?grant_type={0}&appid={1}&secret={2}", "client_credential", appid, secrect);
var client = new HttpClient();
var result = client.GetAsync(url).Result;
if (!result.IsSuccessStatusCode) return string.Empty;
var token = DynamicJson.Parse(result.Content.ReadAsStringAsync().Result);
return token;
}
/// <summary>
/// 上傳多媒體文件
/// http://mp.weixin.qq.com/wiki/index.php?title=%E4%B8%8A%E4%BC%A0%E4%B8%8B%E8%BD%BD%E5%A4%9A%E5%AA%92%E4%BD%93%E6%96%87%E4%BB%B6
/// 1.上傳的媒體文件限制：
///圖片（image) : 1MB，支持JPG格式
///語音（voice）：1MB，播放長度不超過60s，支持MP4格式
///視頻（video）：10MB，支持MP4格式
///縮略圖（thumb)：64KB，支持JPG格式
///2.媒體文件在後台保存時間為3天，即3天後media_id失效
/// </summary>
/// <param name="token"></param>
/// <param name="type"></param>
/// <param name="file"></param>
/// <returns>media_id</returns>
public static string UploadMedia(string token, string type, string file)
{
var url = string.Format("http://api.weixin.qq.com/cgi-bin/media/upload?access_token={0}&type={1}&filename={2}", token, type, Path.GetFileName(file));
var client = new HttpClient();
var result = client.PostAsync(url, new StreamContent(new FileStream(file, FileMode.Open, FileAccess.Read)));
if (!result.Result.IsSuccessStatusCode) return string.Empty;
var media = DynamicJson.Parse(result.Result.Content.ReadAsStringAsync().Result);
return media.media_id;
}
}
}
View Code
4.發送消息包裝
![]()
/*--------------------------------------------------------------------------
* SendMessageAPI.cs
*Auth:deepleo
* Date:2013.12.31
* Email:
[email protected]
*--------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Codeplex.Data;
using System.Net;
using System.Net.Http;
namespace Deepleo.Weixin.SDK
{
/// <summary>
/// 對應微信API的 "發送消息”
/// </summary>
public class SendMessageAPI
{
/// <summary>
/// 被動回復消息
/// </summary>
/// <param name="message">微信服務器推送的消息</param>
/// <param name="executor">用戶自定義的消息執行者</param>
/// <returns></returns>
public static string Relay(WeixinMessage message, IWeixinExecutor executor)
{
return executor.Execute(message);
}
/// <summary>
/// 主動發送客服消息
/// http://mp.weixin.qq.com/wiki/index.php?title=%E5%8F%91%E9%80%81%E5%AE%A2%E6%9C%8D%E6%B6%88%E6%81%AF
/// 當用戶主動發消息給公眾號的時候
/// 開發者在一段時間內（目前為24小時）可以調用客服消息接口，在24小時內不限制發送次數。
/// </summary>
/// <param name="token"></param>
/// <param name="msg">json格式的消息，具體格式請參考微信官方API</param>
/// <returns></returns>
public static bool Send(string token, string msg)
{
var client = new HttpClient();
var task = client.PostAsync(string.Format("https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token={0}", token), new StringContent(msg)).Result;
return task.IsSuccessStatusCode;
}
}
}
View Code
5.其他代碼就不一一貼出來了。可以在文章最後自行下載完整代碼查閱。
6.處理與微信服務器通信的WeixinController.cs,WeixinExecutor.cs
![]()
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Xml.Linq;
using Deepleo.Weixin.SDK;
using Deepleo.NewTon.Web.Services;
using System.Xml;
using Deepleo.NewTon.Framework.Services.Admin;
using Deepleo.Log;
namespace Deepleo.NewTon.Web.Controllers
{
public class WeixinController : Controller
{
public WeixinController()
{
}
/// <summary>
/// 微信後台驗證地址（使用Get），微信後台的“接口配置信息”的Url
/// </summary>
[HttpGet]
[ActionName("Index")]
public ActionResult Get(string signature, string timestamp, string nonce, string echostr)
{
var token = new SettingsService().Get().Token;
if (string.IsNullOrEmpty(_token)) return Content("請先設置Token！");
var ent = "";
if (!BasicAPI.CheckSignature(signature, timestamp, nonce, _token, out ent))
{
new WeixinLogService().Create(new Framework.Entities.WeixinLog("get(failed)", string.Format("(get weixin)signature:{0},timestamp:{1},nonce:{2},echostr:{3},ent:{4},token:{5}",
signature, timestamp, nonce, echostr, ent, _token)));
return Content("參數錯誤！");
}
return Content(echostr); //返回隨機字符串則表示驗證通過
}
/// <summary>
/// 用戶發送消息後，微信平台自動Post一個請求到這裡，並等待響應XML。
/// </summary>
[HttpPost]
[ActionName("Index")]
public ActionResult Post(string signature, string timestamp, string nonce, string echostr)
{
WeixinMessage message = null;
using (var streamReader = new StreamReader(Request.InputStream))
{
message = AcceptMessageAPI.Parse(streamReader.ReadToEnd());
}
var response = new WeixinExecutor().Execute(message);
return new ContentResult
{
Content = response,
ContentType = "text/xml",
ContentEncoding = System.Text.UTF8Encoding.UTF8
};
}
}
}
View Code
![]()
/*--------------------------------------------------------------------------
* WeixinExecutor.cs
*Auth:deepleo
* Date:2013.12.31
* Email:
[email protected]
*--------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Deepleo.Weixin.SDK;
using System.Text;
using System.Text.RegularExpressions;
namespace Deepleo.Weixin
{
public class WeixinExecutor : IWeixinExecutor
{
public WeixinExecutor()
{
}
public string Execute(WeixinMessage message)
{
var result = "";
string openId = message.Body.FromUserName.Value;
var myUserName = message.Body.ToUserName.Value;
switch (message.Type)
{
case WeixinMessageType.Text:
string userMessage = message.Body.Content.Value;
result = RepayText(openId, myUserName, "歡迎使用");
break;
case WeixinMessageType.Event:
string eventType = message.Body.Event.Value.ToLower();
string eventKey = message.Body.EventKey.Value;
switch (eventType)
{
case "subscribe":
result = RepayText(openId, myUserName, "歡迎訂閱");
break;
case "unsubscribe":
result = RepayText(openId, myUserName, "歡迎再來");
break;
case "scan":
result = RepayText(openId, myUserName, "歡迎使用");
break;
case "location"://用戶進入應用時記錄用戶地理位置
#region location
var lat = message.Body.Latitude.Value.ToString();
var lng = message.Body.Longitude.Value.ToString();
var pcn = message.Body.Precision.Value.ToString();
#endregion
break;
case "click":
switch (eventKey)//refer to： Recources/menu.json
{
case "myaccount":
#region 我的賬戶
result = RepayText(openId, myUserName, "我的賬戶.");
#endregion
break;
default:
result = string.Format("<xml><ToUserName><![CDATA[{0}]]></ToUserName>" +
"<FromUserName><![CDATA[{1}]]></FromUserName>" +
"<CreateTime>{2}</CreateTime>" +
"<MsgType><![CDATA[text]]></MsgType>" +
"<Content><![CDATA[{3}]]></Content>" + "</xml>",
openId, myUserName, DateTime.Now.ToBinary(), "沒有響應菜單事件");
break;
}
break;
}
break;
default:
result = string.Format("<xml><ToUserName><![CDATA[{0}]]></ToUserName>" +
"<FromUserName><![CDATA[{1}]]></FromUserName>" +
"<CreateTime>{2}</CreateTime>" +
"<MsgType><![CDATA[text]]></MsgType>" +
"<Content><![CDATA[{3}]]></Content>" + "</xml>",
openId, myUserName, DateTime.Now.ToBinary(), string.Format("未處理消息類型:{0}", message.Type));
break;
}
return result;
}
private string RepayText(string toUserName, string fromUserName, string content)
{
return string.Format("<xml><ToUserName><![CDATA[{0}]]></ToUserName>" +
"<FromUserName><![CDATA[{1}]]></FromUserName>" +
"<CreateTime>{2}</CreateTime>" +
"<MsgType><![CDATA[text]]></MsgType>" +
"<Content><![CDATA[{3}]]></Content>" + "</xml>",
toUserName, fromUserName, DateTime.Now.ToBinary(), content);
}
private string RepayNews(string toUserName, string fromUserName, List<WeixinNews> news)
{
var couponesBuilder = new StringBuilder();
couponesBuilder.Append(string.Format("<xml><ToUserName><![CDATA[{0}]]></ToUserName>" +
"<FromUserName><![CDATA[{1}]]></FromUserName>" +
"<CreateTime>{2}</CreateTime>" +
"<MsgType><![CDATA[news]]></MsgType>" +
"<ArticleCount>{3}</ArticleCount><Articles>",
toUserName, fromUserName,
DateTime.Now.ToBinary(),
news.Count
));
foreach (var c in news)
{
couponesBuilder.Append(string.Format("<item><Title><![CDATA[{0}]]></Title>" +
"<Description><![CDATA[{1}]]></Description>" +
"<PicUrl><![CDATA[{2}]]></PicUrl>" +
"<Url><![CDATA[{3}]]></Url>" +
"</item>",
c.Title, c.Description, c.PicUrl, c.Url
));
}
couponesBuilder.Append("</Articles></xml>");
return couponesBuilder.ToString();
}
}
public class WeixinNews
{
public string Title { set; get; }
public string Description { set; get; }
public string PicUrl { set; get; }
public string Url { set; get; }
}
}
View Code
Github在線浏覽：https://github.com/night-king/weixinSDK
