/// <summary>
/// 接收消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queue">队列名称</param>
/// <param name="isProperties"></param>
/// <param name="handler">消费处理</param>
/// <param name="isDeadLetter"></param>
public void Subscribe <T>(string queue, bool isProperties, Action <T> handler, bool isDeadLetter) where T : class
{
//队列声明
var channel = GetModel(queue, isProperties, "Wk.ExchangeName", "Wk.ExchangeName");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = SerializeExtension.DeserializeUtf8(body);
var msg = msgStr.FromJson <T>();
try
{
handler(msg);
}
catch (Exception ex)
{
ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
if (!isDeadLetter)
{
PublishToDead <DeadLetterQueue>(queue, msgStr, ex);
}
}
finally
{
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queue, false, consumer);
}
/// <summary>
/// 获取消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <param name="routingKey"></param>
/// <param name="handler">消费处理</param>
private void Pull <T>(string exchange, string queue, string routingKey, Action <T> handler) where T : class
{
var channel = GetModel(exchange, queue, routingKey);
var result = channel.BasicGet(queue, false);
if (ObjectExtension.IsNull(result))
{
return;
}
var msg = SerializeExtension.DeserializeUtf8(result.Body).FromJson <T>();
try
{
handler(msg);
}
catch (Exception ex)
{
ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
}
finally
{
channel.BasicAck(result.DeliveryTag, false);
}
}
/// <summary>
/// RPC服务端
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <param name="isProperties"></param>
/// <param name="handler"></param>
/// <param name="isDeadLetter"></param>
public void RpcService <T>(string exchange, string queue, bool isProperties, Func <T, T> handler, bool isDeadLetter)
{
//队列声明
var channel = GetModel(queue, isProperties);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = SerializeExtension.DeserializeUtf8(body);
var msg = msgStr.FromJson <T>();
var props = ea.BasicProperties;
var replyProps = channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
try
{
msg = handler(msg);
}
catch (Exception ex)
{
ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
}
finally
{
channel.BasicPublish(exchange, props.ReplyTo, replyProps, msg.ToJson().SerializeUtf8());
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queue, false, consumer);
}
public static AuthToken Parse(string text, bool isRgx = false)
{
AuthToken token = null;
if (isRgx)
{
var matchAccessToken = rgxAccessToken.Match(text);
var matchRefreshToken = rgxRefreshToken.Match(text);
var matchTokenType = rgxTokenType.Match(text);
var matchExpiresIn = rgxExpiresIn.Match(text);
if (matchAccessToken.Success &&
matchRefreshToken.Success)
{
token = new AuthToken();
token.access_token = matchAccessToken.Groups[1].Value;
token.refresh_token = matchRefreshToken.Groups[1].Value;
token.token_type = matchTokenType.Groups[1].Value;
token.expires_in = Convert.ToInt32(matchExpiresIn.Groups[1].Value);
}
else
{
return(null);
}
}
else
{
token = SerializeExtension.JsonDeserlialize <AuthToken>(text);
}
token.ExpiresIn = DateTime.Now.AddSeconds(token.expires_in);
return(token);
}
public static AuthToken Parse(string text)
{
var token = SerializeExtension.JsonDeserlialize <AuthToken>(text);
token.ExpiresIn = DateTime.Now.AddSeconds(token.expires_in);
return(token);
}
public static void SerializeNotesToFile(IEnumerable <Note> notes, string filepath = @"C:\Napominalka\Notes.xml")
{
List <Note> list = notes.ToList();
//соханение в xml строку
string xml = list.SerializeToXmlString();
//сохранение xml строки в файл
SerializeExtension.SaveToXmlFile(xml, filepath);
}
public void DeserializeTest1()
{
var s = SerializeExtension.Serialize("ABCDEFG");
byte[] data = Convert.FromBase64String(s);
var d = SerializeExtension.Deserialize(data);
Assert.AreEqual("ABCDEFG", d);
}
public void DeSerializeNullTest1()
{
var d = SerializeExtension.Deserialize((byte[])null);
Assert.IsNull(d);
var s = SerializeExtension.Deserialize((string)null);
Assert.IsNull(s);
}
public void SerializeTest()
{
string obj = "ABCDEFGH";
string actual = SerializeExtension.Serialize(obj);
Assert.IsNotNull(actual);
var deserialized = SerializeExtension.Deserialize(actual);
Assert.IsNotNull(deserialized);
Assert.AreEqual(obj, deserialized);
}
/// <summary>
/// RPC客户端
/// </summary>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <param name="routingKey"></param>
/// <param name="body"></param>
/// <param name="isProperties"></param>
/// <returns></returns>
public string RpcClient(string exchange, string queue, string routingKey, string body, bool isProperties = false)
{
var channel = GetModel(exchange, queue, routingKey, isProperties);
var consumer = new QueueingBasicConsumer(channel);
channel.BasicConsume(queue, true, consumer);
try
{
var correlationId = Guid.NewGuid().ToString();
var basicProperties = channel.CreateBasicProperties();
basicProperties.ReplyTo = queue;
basicProperties.CorrelationId = correlationId;
channel.BasicPublish(exchange, routingKey, basicProperties, body.SerializeUtf8());
var sw = Stopwatch.StartNew();
while (true)
{
var ea = consumer.Queue.Dequeue();
if (ea.BasicProperties.CorrelationId == correlationId)
{
return(SerializeExtension.DeserializeUtf8(ea.Body));
}
if (sw.ElapsedMilliseconds > 30000)
{
throw new Exception("等待响应超时");
}
}
}
catch (Exception ex)
{
throw ex.GetInnestException();
}
}
/// <summary>
/// 接收消息(订阅广播)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queue">队列名称</param>
/// <param name="isProperties"></param>
/// <param name="handler">消费处理</param>
/// <param name="isDeadLetter"></param>
public void SubscribeBroadcast <T>(string queue, string exchange, bool isProperties, Action <T> handler, bool isDeadLetter) where T : class
{
//队列声明
var channel = GetModel(queue, exchange, "");
channel.ExchangeDeclare(exchange: exchange, type: ExchangeType.Fanout);
//默认队列,用于广播
var queueName = channel.QueueDeclare().QueueName;
channel.QueueBind(queue: queueName, exchange: exchange, routingKey: "");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = SerializeExtension.DeserializeUtf8(body);
var msg = msgStr.FromJson <T>();
try
{
handler(msg);
}
catch (Exception ex)
{
ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
if (!isDeadLetter)
{
PublishToDead <DeadLetterQueue>(queue, msgStr, ex);
}
}
finally
{
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queueName, false, consumer);
}
public async Task <User> GetSelf()
{
return(await Get("http://api.huaban.com/users/me", o => SerializeExtension.JsonDeserlialize <User>(o)));
}
public async Task <User> GetSelf()
{
return(await Get(Client.API_ME, o => SerializeExtension.JsonDeserlialize <User>(o)));
}
public void DeSerializeNullTest()
{
var d = SerializeExtension.Deserialize(string.Empty);
Assert.IsNull(d);
}
public void SerializeTest1()
{
string o = "ABCDEFG";
Assert.IsNotNull(SerializeExtension.Serialize((object)o));
}
public void SerializeNullTest()
{
Assert.IsNull(SerializeExtension.Serialize(null));
}
public static ImageFile Parse(string text)
{
return(SerializeExtension.JsonDeserlialize <ImageFile>(text));
}
public static IEnumerable <Note> DerializeNotesFromFile(string filepath = @"C:\Napominalka\Notes.xml")
{
return(SerializeExtension.LoadFromXml <List <Note> >(filepath));
}
