一、前言

特别不喜欢麻烦的一个人,最近碰到了微信开发。下载下来了一些其他人写的微信开发“框架”,但是被恶心到了,实现的太臃肿啦。

最不喜欢的就是把微信返回的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[].Value;
else if (binder.Name == "Count")
result = _elements.Count;
else
{
var attr = _elements[].Attribute(XName.Get(binder.Name));
if (attr != null)
result = attr;
else
{
var items = _elements.Descendants(XName.Get(binder.Name));
if (items == null || items.Count() == ) return false;
result = new DynamicXml(items);
}
}
return true;
} public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
{
int ndx = (int)indexes[];
result = new DynamicXml(_elements[ndx]);
return true;
} public IEnumerator GetEnumerator()
{
foreach (var element in _elements)
yield return new DynamicXml(element);
}
}

这个代码我也没仔细看,反正能用,没出过差错。

2.以下是DynamicJson.cs类,文件头有原作者的版权信息

/*--------------------------------------------------------------------------
* DynamicJson
* ver 1.2.0.0 (May. 21th, 2010)
*
* created and maintained by neuecc <ils@neue.cc>
* 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 = ;
foreach (var item in xml.Elements())
{
array[index++] = DeserializeValue(item, elemType);
}
return array;
}
else // List<Foo>
{
var elemType = targetType.GetGenericArguments()[];
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[])
: Delete((string)args[]);
return true;
} // IsDefined, if has args then TryGetMember
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
if (args.Length > )
{
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[]), out result)
: TryGet(xml.Element((string)indexes[]), 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[], value)
: TrySet((string)indexes[], 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()));
}
}
}

这个代码我也依旧没仔细看,反正也能用,没出过差错。

这个最核心的拦路虎解决了,后面的事情就顺理成章的进行啦。

      3.基础支持API包装

/*--------------------------------------------------------------------------
* BasicAPI.cs
*Auth:deepleo
* Date:2013.12.31
* Email:2586662969@qq.com
*--------------------------------------------------------------------------*/ 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;
} }
}

4.发送消息包装

/*--------------------------------------------------------------------------
* SendMessageAPI.cs
*Auth:deepleo
* Date:2013.12.31
* Email:2586662969@qq.com
*--------------------------------------------------------------------------*/ 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;
}
}
}

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
};
} }
}
/*--------------------------------------------------------------------------
* WeixinExecutor.cs
*Auth:deepleo
* Date:2013.12.31
* Email:2586662969@qq.com
*--------------------------------------------------------------------------*/ 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; }
}
}

Github在线浏览:https://github.com/night-king/weixinSDK

QQ互助交流群:173564082

开发者论坛:http://www.weixinsdk.net

超级懒汉编写的基于.NET的微信SDK的更多相关文章

  1. [转贴]超级懒汉编写的基于.NET的微信SDK

    一.前言 特别不喜欢麻烦的一个人,最近碰到了微信开发.下载下来了一些其他人写的微信开发“框架”,但是被恶心到了,实现的太臃肿啦. 最不喜欢的就是把微信返回的xml消息在组装成实体类,所以会比较臃肿,现 ...

  2. 基于.NET的微信SDK

    超级懒汉编写的基于.NET的微信SDK   一.前言 特别不喜欢麻烦的一个人,最近碰到了微信开发.下载下来了一些其他人写的微信开发“框架”,但是被恶心到了,实现的太臃肿啦. 最不喜欢的就是把微信返回的 ...

  3. 基于nodejs 的微信 JS-SDK 简单应用

    2015 是 Hybrid App 崛起之年 ,Web App 和 Native App 各有其强大之处,也有着致命的缺点,人们一边追求native流畅的用户体验,一边同时期望产品能够快速的迭代更新, ...

  4. 基于H5的微信支付开发详解

    这次总结一下用户在微信内打开网页时,可以调用微信支付完成下单功能的模块开发,也就是在微信内的H5页面通过jsApi接口实现支付功能.当然了,微信官网上的微信支付开发文档也讲解的很详细,并且有实现代码可 ...

  5. 基于fastweixin的微信开发环境搭建(一)

    由于公司业务需要,开发微信版本,才开始接触微信公众平台.在github折腾了几天,试过好几个微信sdk,最终选择fastweixin.个人觉得这个框架还是值得使用的,使用也简单.那么问题来了,很多人想 ...

  6. ****基于H5的微信支付开发详解[转]

    这次总结一下用户在微信内打开网页时,可以调用微信支付完成下单功能的模块开发,也就是在微信内的H5页面通过jsApi接口实现支付功能.当然了,微信官网上的微信支付开发文档也讲解的很详细,并且有实现代码可 ...

  7. 基于ThinkPHP3的微信平台开发_1

    微信公众平台是个好东西,具体的就不说了,我直接说技术>_< 下图为目录结构一览: 微信开发 - 文件目录结构 平台功能: 此次开发的平台是面向多微信公众号.微信多公众号主(下面简称号主)的 ...

  8. 自己编写的基于VC++6.0的串口调试软件,并贡献源程序!

    自己编写的基于VC++6.0的串口调试软件源程序! 程序下载链接: 点击打开链接

  9. c#编写的基于Socket的异步通信系统

    c#编写的基于Socket的异步通信系统 SanNiuSignal是一个基于异步socket的完全免费DLL:它里面封装了Client,Server以及UDP:有了这个DLL:用户不用去关心心跳:粘包 ...

随机推荐

  1. Finger Gestures 3.1

    3.x自定义手势 Finger Gestures用起来非常爽,除了有常用的手势之外,3.x的版本还增加了自定义手势! 官方Document:http://fingergestures.fatalfro ...

  2. 我的WCF摸爬滚打之路(2)

    昨天抽空写了一个wcf的创建和宿主程序的创建文章,下面也有很多园友给了评论,在此谢谢大家给了我继续记录我的摸爬滚打之路信心……抱拳! 上次的文章<我的WCF摸爬滚打之路(1)>中写到,在测 ...

  3. pandas groupby

    pandas.DataFrame.groupby DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, gr ...

  4. 如何在高并发分布式系统中生成全局唯一Id(转)

    http://www.cnblogs.com/heyuquan/p/global-guid-identity-maxId.html 又一个多月没冒泡了,其实最近学了些东西,但是没有安排时间整理成博文, ...

  5. 无法加载一个或多个请求的类型。有关更多信息,请检索 LoaderExceptions 属性。

    新建一个MVC4的项目,引用DAL后,将DAL的连接字符串考入: <connectionStrings>     <add name="brnmallEntities&qu ...

  6. JS 之DOM range对象

    DOM范围 DOM中的range对象是DOM2中新定义的接口.通过这个对象可以选择文档中的某个区域,而不必考虑节点的界限. 创建范围 document.createRange()创建一个范围,这个范围 ...

  7. Android 动画之AlphaAnimation应用详解

    窗口的动画效果,淡入淡出什么的,有些游戏的欢迎动画,logo的淡入淡出效果就使用AlphaAnimation.AlphaAnimation(0.01f, 1.0f); 从0.01f到1.0f渐变.学过 ...

  8. 系分过了,mark一下,就从这里开始吧

    算是重新归回吧,发现写博客还是这里人气比较旺,开源中国不行,动弹人气还可以,不过都没啥节操, 这么多年没来了,发现竟然还排名1150,不容易,继续加油.有种回娘家的赶脚

  9. [CareerCup] 6.1 Find Heavy Bottle 寻找重瓶子

    6.1 You have 20 bottles of pills. 19 bottles have 1.0 gram pills, but one has pills of weight 1.1 gr ...

  10. EF实体框架之CodeFirst六

    上午的时候把复杂类型学习了一下,想着趁着周六日把Code First学习完,所以下午还是把Code First中的关系学习下.在数据库中最重要的恐怕就是E-R图了,E-R体现了表与表直接的关系.使用C ...