public static void Load()
{
if (!XmlSerialize <Settings> .Load(File, ref ApplicationSettings))
{
ApplicationSettings = new Settings();
}
}
private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
{
if (this.Visible)
{
_userSettings.FormHeight = this.Height;
_userSettings.FormWidth = this.Width;
_userSettings.Maximized = this.WindowState == FormWindowState.Maximized;
_userSettings.ThumbnailSize = ilMain.ImageSize.Width;
_userSettings.SplitterDistance = splitMain.SplitterDistance;
_userSettings.DrawColorArgb = ucImageEditor.DrawColor.ToArgb();
_userSettings.DrawWidth = ucImageEditor.DrawWidth;
_userSettings.HighlightColorArgb = ucImageEditor.HighlightColor.ToArgb();
_userSettings.HighlightWidth = ucImageEditor.HighlightWidth;
_userSettings.EraseColorArgb = ucImageEditor.EraseColor.ToArgb();
_userSettings.EraseWidth = ucImageEditor.EraseWidth;
_userSettings.Font = new FontConverter().ConvertToString(ucImageEditor.CurrentFont);
_userSettings.Radius = ucImageEditor.CurrentRadius;
XmlSerialize.SerializeObjectToFile <UserSettings>(_userSettings, userSettingsConfigFile);
}
if (_lock)
{
return;
}
this.WindowState = FormWindowState.Minimized;
this.Visible = false;
this.ShowInTaskbar = false;
e.Cancel = true;
}
void ButtonRead_Click(object sender, EventArgs e)
{
Person person = KVConfig.Instance.Read <Person>("c:\\person.config");
string s = XmlSerialize.Serialize <Person>(person);
rs.Text = s;
}
public ZS3WG()
{
XmlSerialize xfs = new XmlSerialize("ZS3WG.Config");
Config _config = xfs.DeSerialize <Config>();
account = _config.Account;
password = _config.Password;
serverUrl = _config.ServerUrl;
scrId = _config.SrcID;
userId = _config.UserId;
balanceUrl = serverUrl + "/sms.aspx";
sendUrl = serverUrl + "/sms.aspx";
statusUrl = serverUrl + "/statusApi.aspx";
moUrl = serverUrl + "/callApi.aspx";
tmrReport = new Timer(10000);
tmrReport.Elapsed += tmrReport_Elapsed;
tmrMO = new Timer(10000);
tmrMO.Elapsed += tmrMO_Elapsed;
sends = new Dictionary <string, ReportEventArgs>();
try
{
BinarySerialize <Dictionary <string, ReportEventArgs> > bs = new BinarySerialize <Dictionary <string, ReportEventArgs> >();
sends = bs.DeSerialize("ReportCache");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
LogClient.LogHelper.LogInfo("ZS3WG", "Save ReportCache Error ->", ex.Message);
}
}
//public async Task<string> PostAsync(string url, List<IFormFile> files)
//{
// var client = _httpClientFactory.CreateClient();
// var httpContent = new MultipartFormDataContent();
// if (files != null && files.Count > 0)
// foreach (var file in files)
// {
// var byteArr = await file.GetBytesAsync();
// var imageContent = new ByteArrayContent(byteArr);
// imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("image/jpeg");
// }
// var response = await client.PostAsync(url, httpContent);
// if (response.StatusCode != HttpStatusCode.OK)
// return null;
// var resultStr = await response.Content.ReadAsStringAsync();
// return resultStr;
//}
public async Task <TOutResult> GetAsync <TOutResult>(string url, DeserializeType deserializeType = DeserializeType.JsonDeserialize) where TOutResult : class, new()
{
var client = _httpClientFactory.CreateClient();
var response = await client.GetAsync(url);
if (response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
var resultStr = await response.Content.ReadAsStringAsync();
TOutResult result = new TOutResult();
switch (deserializeType)
{
case DeserializeType.JsonDeserialize:
result = JsonConvert.DeserializeObject <TOutResult>(resultStr);
break;
case DeserializeType.XmlDeserialize:
var xmlSerialize = new XmlSerialize();
result = xmlSerialize.Deserialize <TOutResult>(resultStr);
break;
default:
break;
}
return(result);
}
public void SerializeDeserializeTest_IfEverythingIsOk_ShouldBeOk()
{
string path = Directory.GetParent(Directory.GetCurrentDirectory()).ToString();
string root = "Tests";
while (!(path.Substring(path.Length - root.Length) == root))
{
Console.WriteLine(path);
path = path.Remove(path.Length - 1);
}
string filename = "\\TPA.ApplicationArchitecture.dll";
string xmlName = "\\test.xml";
string fullFilePath = path + filename;
string fullXmlPath = path + xmlName;
Console.WriteLine(path);
AssemblyMetadata assemblyMetaData = DataService.LoadAssembly(fullFilePath);
ISerialize xmlSerialize = new XmlSerialize();
xmlSerialize.Save(AssemblyMapper.MapToDTGModel(assemblyMetaData), fullXmlPath);
AssemblyMetadata assemblyMetadata2 = AssemblyMapper.MapToModel(xmlSerialize.Read(fullXmlPath));
Console.WriteLine(assemblyMetaData.Name);
Console.WriteLine(assemblyMetadata2.Name);
Assert.AreEqual(assemblyMetaData.Name, assemblyMetadata2.Name);
}
private void btnAcceptAddApp_Click(object sender, EventArgs e)
{
bool volver = this.validarCamposVacios(this);
if (volver)
{
return;
}
bool guardadoConExito = false;
bool puedeGuardar = true;
string curFile = "../../../proyectos.xml";
List <Apps> listApps = new List <Apps>();
XmlSerialize <Apps> ser = new XmlSerialize <Apps>();
if (File.Exists(curFile))
{
listApps = ser.DesSerializarXML(listApps, curFile);
}
Apps app = new Apps();
app.Name = txtNameAddApp.Text;
app.Path = txtPathAddApp.Text;
if (listApps.Count > 0)
{
for (int i = 0; i < listApps.Count; i++)
{
if (listApps[i].Name.Equals(app.Name))
{
puedeGuardar = false;
}
}
if (puedeGuardar)
{
listApps.Add(app);
guardadoConExito = true;
}
else
{
MessageBox.Show("No se puede agregar el proyecto, ya existe un proyecto con ese nombre.", "El Proyecto ya existe",
MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
}
}
else
{
listApps.Add(app);
guardadoConExito = true;
}
ser.SerializarXML(listApps, curFile);
if (guardadoConExito)
{
this.Close();
}
}
public ZSXWG()
{
Console.WriteLine("DIR:" + AssDir);
XmlSerialize xfs = new XmlSerialize(System.IO.Path.Combine(AssDir, "ZSXWG.Config"));
Config _config = xfs.DeSerialize <Config>();
account = _config.Account;
password = _config.Password;
serverUrl = _config.ServerUrl;
scrId = _config.SrcID;
userId = _config.UserId;
SignaturePos = _config.SignaturePos;
balanceUrl = serverUrl + "/sms.aspx";
sendUrl = serverUrl + "/sms.aspx";
statusUrl = serverUrl + "/statusApi.aspx";
moUrl = serverUrl + "/callApi.aspx";
tmrReport = new Timer(10000);
tmrReport.Elapsed += tmrReport_Elapsed;
tmrMO = new Timer(10000);
tmrMO.Elapsed += tmrMO_Elapsed;
sends = new Dictionary <string, ReportEventArgs>();
try
{
BinarySerialize <Dictionary <string, ReportEventArgs> > bs = new BinarySerialize <Dictionary <string, ReportEventArgs> >();
sends = bs.DeSerialize(System.IO.Path.Combine(AssDir, "ReportCache"));
}
catch (Exception ex)
{
MessageHelper.Instance.WirteError(ex.ToString());
LogClient.LogHelper.LogInfo("ZSXWG", "Save ReportCache Error ->", ex.Message);
}
}
static PaymentProcessor()
{
logDir =
Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase).Replace(@"file:\", string.Empty), @"..\Tran.xml");
//ser = new YAXLib.YAXSerializer(typeof(Dictionary<string, Payment>));
//ser = new YAXLib.YAXSerializer(typeof(List<Payment>));
paymentInfo = new Dictionary <string, trasactionlistTransaction>();
if (File.Exists(logDir))
{
trasactionlist list = XmlSerialize.Deserialize <trasactionlist>(logDir);
if (list != null && list.Items != null)
{
foreach (trasactionlistTransaction item in list.Items)
{
if (!string.IsNullOrEmpty(item.tid))
{
paymentInfo[item.tid] = item;
}
}
}
//object o = ser.Deserialize(logDir);
//paymentInfo = o as Dictionary<string, trasactionlistTransaction>;
}
if (paymentInfo == null)
{
paymentInfo = new Dictionary <string, trasactionlistTransaction>();
}
}
private void LoadNumber()
{
List <Operators> operators = XmlSerialize.DeSerialize <List <Operators> >("Operators.Config");
foreach (Operators oper in operators)
{
foreach (string num in oper.DNSEG)
{
if (num.Length == 3)
{
if (!_number3.ContainsKey(num))
{
_number3.Add(num, oper.Name);
}
}
if (num.Length == 4)
{
if (!_number4.ContainsKey(num))
{
_number4.Add(num, oper.Name);
}
}
}
}
}
private void btnGuardarServidor_Click(object sender, EventArgs e)
{
bool volver = this.validarCamposVacios(this);
if (volver)
{
return;
}
bool guardadoConExito = false;
bool puedeGuardar = true;
string curFile = "../../../servidores.xml";
List <Server> serversList = new List <Server>();
XmlSerialize <Server> ser = new XmlSerialize <Server>();
if (File.Exists(curFile))
{
serversList = ser.DesSerializarXML(serversList, curFile);
}
Server server = new Server();
server.Name = txtNameAddApp.Text;
server.Path = txtPathAddApp.Text;
if (serversList.Count > 0)
{
for (int i = 0; i < serversList.Count; i++)
{
if (serversList[i].Name.Equals(server.Name))
{
puedeGuardar = false;
}
}
if (puedeGuardar)
{
serversList.Add(server);
guardadoConExito = true;
}
else
{
MessageBox.Show("No se puede agregar el servidor, ya existe un servidor con ese nombre.", "El servidor ya existe",
MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
}
}
else
{
serversList.Add(server);
guardadoConExito = true;
}
ser.SerializarXML(serversList, curFile);
if (guardadoConExito)
{
this.Close();
}
}
public static void Serialize([NotNull] Type type, [NotNull] object data, [NotNull] string filename, Type[] extraTypes, ExceptionHandler exceptionHandler)
{
Debug.Assert(filename != null, "filename == null");
using (var writer = new StreamWriter(filename))
{
XmlSerialize.Serialize(type, data, writer, extraTypes, exceptionHandler);
}
}
public static void Serialize <T>([NotNull] T data, [NotNull] string filename, ExceptionHandler exceptionHandler)
{
Debug.Assert(filename != null, "filename == null");
using (var writer = new StreamWriter(filename))
{
XmlSerialize.Serialize(data, writer, exceptionHandler);
}
}
public override void SetCargo(string cargo)
{
try
{
List <SerializablePoint> points = XmlSerialize.DeserializeObject <List <SerializablePoint> >(cargo);
_pointsToDraw = points.Select(p => new Point(p.X, p.Y)).ToList();
}
catch { }
}
public async Task <TOutResult> PostAsync <TOutResult>(string url, string content, DeserializeType deserializeType = DeserializeType.JsonDeserialize, X509Certificate2 cert = null) where TOutResult : class, new()
{
var client = _httpClientFactory.CreateClient();
//HttpResponseMessage sendCertResponse = new HttpResponseMessage();
if (cert != null)
{
var request = new HttpRequestMessage()
{
RequestUri = new Uri(url),
Method = HttpMethod.Get,
};
request.Headers.Add("X-ARR-ClientCert", cert.GetRawCertDataString());
var sendCertResponse = await client.SendAsync(request);
if (!sendCertResponse.IsSuccessStatusCode)
{
throw new ASampleException("certificate is error");
}
}
HttpContent httpContent = null;
if (!string.IsNullOrEmpty(content))
{
httpContent = new StringContent(content);
}
var response = await client.PostAsync(url, httpContent);
if (response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
var resultStr = await response.Content.ReadAsStringAsync();
var result = new TOutResult();
switch (deserializeType)
{
case DeserializeType.JsonDeserialize:
result = JsonConvert.DeserializeObject <TOutResult>(resultStr);
break;
case DeserializeType.XmlDeserialize:
var xmlSerialize = new XmlSerialize();
result = xmlSerialize.Deserialize <TOutResult>(resultStr);
break;
case DeserializeType.Default:
break;
default:
throw new ArgumentOutOfRangeException(nameof(deserializeType), deserializeType, null);
}
return(result);
}
private static void serialize <T>([NotNull] T data, [NotNull] string filename, ExceptionHandler exceptionHandler)
{
Assert.NotNull(filename);
using (var writer = new StreamWriter(filename))
{
Assert.NotNull(writer);
Assert.IsInstanceOf <StreamWriter>(writer);
XmlSerialize.Serialize(data, writer, exceptionHandler);
}
}
public override string GetCargo()
{
List <SerializablePoint> points = new List <SerializablePoint>();
points.AddRange(_pointsToDraw.Select(p => new SerializablePoint()
{
X = p.X, Y = p.Y
}));
return(XmlSerialize.SerializeObject <List <SerializablePoint> >(points));
}
public override string GetCargo()
{
if (Radius < 1)
{
return(string.Empty);
}
return(XmlSerialize.SerializeObject <SerializableRadiusDrawObject>(new SerializableRadiusDrawObject()
{
Radius = Radius
}));
}
public static List <DrawObject> GetDrawObjectsFromXML(Graphics graphics, string xml, float zoomMultiplier)
{
try
{
List <SerializableDrawObject> serializable = XmlSerialize.DeserializeObject <List <SerializableDrawObject> >(xml);
return(serializable.ConvertAll(o => DrawObject.FromSerialized(graphics, o, zoomMultiplier)));
}
catch
{
return(new List <DrawObject>());
}
}
public override string GetCargo()
{
if (string.IsNullOrEmpty(CurrentText))
{
return(string.Empty);
}
return(XmlSerialize.SerializeObject <SerializableTextDrawObject>(new SerializableTextDrawObject()
{
CurrentText = CurrentText,
Font = TypeDescriptor.GetConverter(typeof(Font)).ConvertToString(Font)
}));
}
public static T Deserialize <T>([NotNull] string fileName, ExceptionHandler exceptionHandler)
{
Debug.Assert(fileName != null, $"{nameof(XmlIO)}.{nameof(Deserialize)} filename == null");
if (!File.Exists(fileName))
{
return(default(T));
}
using (var reader = new StreamReader(fileName))
{
return(XmlSerialize.Deserialize <T>(reader, exceptionHandler));
}
}
public static void AddTransactionInfo(Payment payment)
{
if (payment != null && !string.IsNullOrEmpty(payment.transactionid))
{
lock (lockObj)
{
paymentInfo[payment.transactionid] = Convert(payment);
tlist.Items = paymentInfo.Values.ToArray();
XmlSerialize.Serialize <trasactionlist>(logDir, tlist, Encoding.UTF8);
}
}
}
private static T deserialize <T>([NotNull] string fileName, ExceptionHandler exceptionHandler)
{
Assert.NotNull(fileName);
if (!File.Exists(fileName))
{
Assert.False(File.Exists(fileName), $"{nameof(XmlSerializeTests)}.{nameof(deserialize)}<{typeof(T).Name}>({fileName}) does not exist!");
}
using (var reader = new StreamReader(fileName))
{
return(XmlSerialize.Deserialize <T>(reader, exceptionHandler));
}
}
private void PersistDataLocallySafe(string recordingName, List <HandsDataRecordedFrame> handsDataRecordedFrames)
{
try
{
var xml = XmlSerialize.Serialize(new PersistedHandsDataRecording(recordingName, handsDataRecordedFrames, _initHandData));
var recordingFileInfo = new FileInfo(GenerateRecordingFilePath(recordingName));
recordingFileInfo.Directory.Create();
File.WriteAllText(recordingFileInfo.FullName, xml);
}
catch (Exception e)
{
Debug.LogError($"Unable to {nameof(PersistDataLocallySafe)}");
}
}
private void HandleIncomingData(byte[] data)
{
var stringData = Encoding.ASCII.GetString(data);
var handRelatedData = XmlSerialize.Deserialize <HandRelatedDataContainer>(IsDataGzipCompressed
? GzipCompression.Decompress(stringData)
: stringData);
switch (handRelatedData.HandRelatedData)
{
case HandRelatedData.Hand:
var handData = handRelatedData.HandData;
if (handData.Step == OVRPlugin.Step.Render)
{
if (handData.Hand == OVRPlugin.Hand.HandLeft)
{
_lastLeftHandRenderUpdateDataToProcess = handData;
}
if (handData.Hand == OVRPlugin.Hand.HandRight)
{
_lastRightHandRenderUpdateDataToProcess = handData;
}
}
if (handData.Step == OVRPlugin.Step.Physics)
{
if (handData.Hand == OVRPlugin.Hand.HandLeft)
{
_lastLeftHandPhysicsUpdateDataToProcess = handData;
}
if (handData.Hand == OVRPlugin.Hand.HandRight)
{
_lastRightHandPhysicsUpdateDataToProcess = handData;
}
}
break;
case HandRelatedData.Skeleton:
_skeletonUpdateDataToProcess.Enqueue(handRelatedData.SkeletonData);
break;
case HandRelatedData.Mesh:
_meshUpdateDataToProcess.Enqueue(handRelatedData.MeshData);
break;
case HandRelatedData.Unknown:
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// コンストラクタ．
/// </summary>
/// <param name="singer_config"></param>
public UtauVoiceDB(SingerConfig singer_config)
{
name_ = singer_config.VOICENAME;
singconfig = singer_config.VOICEIDSTR;
string oto_ini = Path.Combine(singer_config.VOICEIDSTR, "oto.ini");
string oto_Cache = Path.Combine(singer_config.VOICEIDSTR, "oto.cache");
if (System.IO.File.Exists(oto_Cache))
{
string S = System.IO.File.ReadAllText(oto_Cache, System.Text.Encoding.UTF8);
root_ = XmlSerialize.DeserializeXML <Oto>(S);
}
else
{
root_ = new Oto(oto_ini, singer_config.VOICEIDSTR);
string O = XmlSerialize.SerializeXML <Oto>(root_);
System.IO.File.WriteAllText(oto_Cache, O, System.Text.Encoding.UTF8);
}
var prefixmap = Path.Combine(singer_config.VOICEIDSTR, "prefix.map");
if (File.Exists(prefixmap))
{
prefixmap_ = new PrefixMap(prefixmap);
}
foreach (var directory in Directory.EnumerateDirectories(singer_config.VOICEIDSTR))
{
var maybe_oto_file = Path.Combine(directory, "oto.ini");
var maybe_oto_cache = Path.Combine(directory, "oto.cache");
if (File.Exists(maybe_oto_file))
{
Oto oto = null;
if (System.IO.File.Exists(maybe_oto_cache))
{
string S = System.IO.File.ReadAllText(maybe_oto_cache, System.Text.Encoding.UTF8);
oto = XmlSerialize.DeserializeXML <Oto>(S);
}
else
{
oto = new Oto(maybe_oto_file, singer_config.VOICEIDSTR);
string O = XmlSerialize.SerializeXML <Oto>(oto);
System.IO.File.WriteAllText(maybe_oto_cache, O, System.Text.Encoding.UTF8);
}
sub_.Add(oto);
}
}
}
public override void SetCargo(string cargo)
{
if (string.IsNullOrEmpty(cargo))
{
return;
}
try
{
var sdo = XmlSerialize.DeserializeObject <SerializableRadiusDrawObject>(cargo);
Radius = sdo.Radius;
}
catch
{
return;
}
}
public void XmlSerialize_WithPathAsStringElement_SerializesIntoString()
{
const string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
<XmlSerialize xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
<Folder>c:\users\nemec</Folder>
</XmlSerialize>";
var data = new XmlSerialize {
Folder = new PureWindowsPath(@"c:\users\nemec")
};
var writer = new StringWriter(new StringBuilder());
new XmlSerializer(typeof(XmlSerialize))
.Serialize(writer, data);
Assert.AreEqual(expected, writer.ToString());
}
private bool EmergencyBroadcast(string TmcId, string path, string BrdStateCode, string TimingTerminalState)
{
EBD ebd;
DataTable dt;
bool flag = false;
try
{
using (FileStream fs = new FileStream(path, FileMode.Open))
{
StreamReader sr = new StreamReader(fs, System.Text.Encoding.UTF8);
String xmlInfo = sr.ReadToEnd();
xmlInfo = xmlInfo.Replace("xmlns:xs", "xmlns");
sr.Close();
xmlInfo = XmlSerialize.ReplaceLowOrderASCIICharacters(xmlInfo);
xmlInfo = XmlSerialize.GetLowOrderASCIICharacters(xmlInfo);
ebd = XmlSerialize.DeserializeXML <EBD>(xmlInfo);
}
if (Convert.ToInt32(BrdStateCode) != 0)
{
if (Convert.ToInt32(TmcId) < 0)
{
return(flag);
}
else
{
dt = ViewDataTsCmdStore(TmcId);
if (dt != null && dt.Rows.Count > 0)
{
flag = FeedbackFunction(ebd, BrdStateCode, TimingTerminalState);
return(flag);
}
}
}
else
{
flag = FeedbackFunction(ebd, BrdStateCode, TimingTerminalState);
return(flag);
}
return(false);
}
catch (Exception ex)
{
throw new Exception("应急消息回馈:" + ex.Message);
}
}
private void NewPanelButton_Click(Object sender, System.EventArgs e)
{
Button clickedButton = (Button)sender;
XmlSerialize <Apps> ser = new XmlSerialize <Apps>();
appsList = ser.DesSerializarXML(appsList, appPath);
foreach (Apps a in appsList)
{
if (clickedButton.Text == a.Name)
{
foreach (string p in a.Piezas)
{
Deployer.Deployar(p, a.Path);
}
}
}
}
/// <summary>
/// 点击领取按钮
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnGetRedPackage_Click(object sender, EventArgs e)
{
//请在0到8点之外的时间领取
int hour = DateTime.Now.Hour;
if (hour >= 0 && hour <= 8)
{
this.lblMsg.Text = "很抱歉，请在0：00-8：00之外的时间领红包。";
log.WriteLog("很抱歉，请在0：00-8：00之外的时间领红包。");
return;
}
//获取到用户标识
bool isSucess = false;
string re_openid = "";
if (ViewState["isSucess"] != null && ViewState["re_openid"] != null)
{
isSucess = (bool)ViewState["isSucess"];
re_openid = ViewState["re_openid"].ToString();
if (!isSucess || string.IsNullOrEmpty(re_openid))
{
this.lblMsg.Text = "很抱歉,获取用户信息失败，请联系客服！";
log.WriteLog("很抱歉,获取用户信息失败，请联系客服！");
return;
}
}
else
{
this.lblMsg.Text = "很抱歉,获取用户信息失败，请联系客服！";
log.WriteLog("很抱歉,获取用户信息失败，请联系客服！");
return;
}
//判断手机号是否合法
string phoneNo = this.txtPhoneNo.Text; //手机号
string msg = "";
if (!CheckIsLegal(phoneNo,out msg)) //验证输入是否合法
{
this.lblMsg.Text = msg;
return;
}
string nonce_str = weixin.randString(32); //随机字符串
string appid = ConfigurationManager.AppSettings["AppID"]; //公众账号
string mch_id = ConfigurationManager.AppSettings["mch_id"]; //商户号
string mch_billno = mch_id + DateTime.Now.ToString("yyyyMMdd") + DateTime.Now.Ticks.ToString().PadLeft(18).Substring(8, 10); //商户订单号
string send_name = "Luxlead洛诗琳"; //商户名称
string act_name = "双11红包疯狂送"; //活动名称
string wishing = "恭喜发财,大吉大利！"; //祝福语
string client_ip = "180.76.132.217"; //IP地址
string remark = "红包备注"; //备注
int total_amount = weixin.randInt(); //总金额(单位为分)
int total_num = 1; //总数量(单位为个)
//参数字符串
string parm = string.Format("nonce_str={0}&mch_billno={1}&mch_id={2}&wxappid={3}&send_name={4}&re_openid={5}&total_amount={6}&total_num={7}&wishing={8}&client_ip={9}&act_name={10}&remark={11}", nonce_str, mch_billno, mch_id, appid, send_name, re_openid, total_amount,total_num,wishing,client_ip, act_name,remark);
//生成参数签名
string[] parmarr = parm.Split('&');
Dictionary<string, string> di = new Dictionary<string, string>();
foreach (string item in parmarr)
{
string[] dd = item.Split('=');
di.Add(dd[0], dd[1]);
}
string sign = Sign.GetSign(di);
parm = parm + "&sign=" + sign;
string body = string.Format(@"<xml>
<sign><![CDATA[{0}]]></sign>
<mch_billno><![CDATA[{1}]]></mch_billno>
<mch_id><![CDATA[{2}]]></mch_id>
<wxappid><![CDATA[{3}]]></wxappid>
<send_name><![CDATA[{4}]]></send_name>
<re_openid><![CDATA[{5}]]></re_openid>
<total_amount><![CDATA[{6}]]></total_amount>
<total_num><![CDATA[{7}]]></total_num>
<wishing><![CDATA[{8}]]></wishing>
<client_ip><![CDATA[{9}]]></client_ip>
<act_name><![CDATA[{10}]]></act_name>
<remark><![CDATA[{11}]]></remark>
<nonce_str><![CDATA[{12}]]></nonce_str>
</xml>", sign, di["mch_billno"], di["mch_id"], di["wxappid"], di["send_name"], di["re_openid"], di["total_amount"], di["total_num"], di["wishing"], di["client_ip"], di["act_name"], di["remark"], di["nonce_str"]);
log.WriteLog("微信红包接口Post的body数据是：" + body);
try
{
string returnXml = weixin.PostHttp("https://api.mch.weixin.qq.com/mmpaymkttransfers/sendredpack", body);
log.WriteLog("微信红包接口返回字符串：" + returnXml);
//解析返回数据,跳转到领取页面
string returnMsg = "",showMsg="";
XmlSerialize xmlS = new XmlSerialize();
BaseReturn baseReturn = xmlS.XmlToModel<BaseReturn>(returnXml, "BaseReturn");
if (baseReturn.return_code.ToUpper() == "SUCCESS")
{
SuccessReturn successReturn = xmlS.XmlToModel<SuccessReturn>(returnXml, "SuccessReturn");
if (successReturn.result_code.ToUpper() == "SUCCESS")
{
//将红包领取汇总记录写入数据库
Model.WxOrder modelOrder = new WxOrder()
{
PhoneNo = phoneNo,
TotalAmount = total_amount,
Remark = mch_billno,
};
if (bllPR.Update(modelOrder) <= 0)
{
log.WriteLog("微信红包领取汇总记录保存到数据库失败！");
this.lblMsg.Text = "很抱歉，领取失败，系统错误请联系客服！";
return;
}
else
{
log.WriteLog("微信红包领取汇总记录保存到数据库成功！");
}
//将红包领取明细记录写入数据库
Model.PaymentRecord modlePR = new Model.PaymentRecord()
{
PhoneNo = phoneNo,
WxOrderId = bllPR.GetOrderId(mch_billno),
nonce_str = nonce_str,
sign = sign,
mch_billno = mch_billno,
mch_id = mch_id,
wxappid = appid,
send_name = send_name,
re_openid = re_openid,
total_amount = total_amount,
total_num = total_num,
wishing = wishing,
client_ip = client_ip,
act_name = act_name,
remark = remark,
return_code = successReturn.result_code,
return_msg = successReturn.return_msg,
err_code = successReturn.err_code,
err_code_des = successReturn.err_code_des,
send_time = DateTime.ParseExact(successReturn.send_time, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
send_listid = successReturn.send_listid,
};
if (bllPR.Add(modlePR) <= 0)
{
log.WriteLog("微信红包领取明细记录保存到数据库失败！");
this.lblMsg.Text = "很抱歉，领取失败，请稍候再试！";
return;
}
else
{
log.WriteLog("微信红包领取明细记录保存到数据库成功！");
}
returnMsg = string.Format("微信红包接口发送红包成功,发送时间是{0},微信订单号是{1}", successReturn.send_time, successReturn.send_listid);
log.WriteLog(returnMsg);
showMsg = "恭喜你，领取成功！";
this.lblMsg.Text = showMsg;
this.btnGetRedPackage.Text = "领取成功!";
Response.Redirect("GetSuccess.aspx",false);
return;
}
else
{
ErrorReturn errorReturn = xmlS.XmlToModel<ErrorReturn>(returnXml, "ErrorReturn");
returnMsg = string.Format("微信红包接口发送红包失败，错误代号:{0},错误消息：{1}。", errorReturn.err_code, errorReturn.err_code_des);
switch (errorReturn.err_code.ToUpper())
{
case "NO_AUTH":
showMsg = string.Format("很抱歉，该微信账号异常，请使用活跃的微信号。");
break;
case "TIME_LIMITED":
showMsg = string.Format("很抱歉，请在0：00-8：00之外的时间领红包。");
break;
case "NOTENOUGH":
showMsg = string.Format("很抱歉，账户余额不足，请联系客服处理。");
break;
default:
showMsg = "很抱歉，领取失败,请联系客服处理。";
break;
}
}
}
else
{
ErrorReturn errorReturn = xmlS.XmlToModel<ErrorReturn>(returnXml,"ErrorReturn");
returnMsg = string.Format("微信红包接口发送红包失败，错误代号:{0},错误消息：{1}。", errorReturn.err_code, errorReturn.err_code_des);
switch (errorReturn.err_code.ToUpper())
{
case "NO_AUTH":
showMsg = string.Format("很抱歉，该微信账号异常，请使用活跃的微信号。");
break;
case "TIME_LIMITED":
showMsg = string.Format("很抱歉，请在0：00-8：00之外的时间领红包。");
break;
case "NOTENOUGH":
showMsg = string.Format("很抱歉，账户余额不足，请联系客服处理。");
break;
default:
showMsg = "很抱歉，领取失败,请联系客服处理。";
break;
}
}
if (!string.IsNullOrEmpty(showMsg))
{
this.btnGetRedPackage.Text = "领红包";
}
log.WriteLog(returnMsg);
this.lblMsg.Text = showMsg;
}
catch (Exception ex)
{
log.WriteLog("微信红包接口调用错误,错误信息：" + ex.Message);
}
}
