/// <summary> /// 尝试根据方法的修饰属性来构造IActionResult实例 /// </summary> /// <param name="result">Action的执行结果</param> /// <param name="actionAttr">Action方法上的ActionAttribute实例</param> /// <returns></returns> private IActionResult ObjectToResult(object result, ActionAttribute actionAttr) { IActionResult actionResult = null; SerializeFormat format = actionAttr.OutFormat; // 先判断是不是由客户端指定的自动模式,如果是就解析客户端需要的序列化格式 if (format == SerializeFormat.Auto) { // 如果是自动响应,那么就根据请求头的指定的方式来决定 string expectFormat = this.HttpContext.Request.Headers["X-Result-Format"]; if (string.IsNullOrEmpty(expectFormat) == false) { SerializeFormat outFormat; if (Enum.TryParse <SerializeFormat>(expectFormat, true, out outFormat)) { format = outFormat; } } } // 根据已指定的序列化格式包装具体的IActionResult实例 if (format == SerializeFormat.Json) { actionResult = new JsonResult(result); } else if (format == SerializeFormat.Json2) { actionResult = new JsonResult(result, true); } else if (format == SerializeFormat.Xml) { actionResult = new XmlResult(result); } else if (format == SerializeFormat.Text) { actionResult = new TextResult(result); } else if (format == SerializeFormat.Form) { string text = FormDataCollection.Create(result).ToString(); actionResult = new TextResult(text); } // 无法构造出IActionResult实例,就交给ActionProcessor来处理 if (actionResult == null) { ActionHelper actionProcessor = ObjectFactory.New <ActionHelper>(); actionResult = actionProcessor.ObjectToResult(result); } return(actionResult); }
/// <summary> /// 从请求流中反序列化构造参数值 /// </summary> /// <param name="p"></param> /// <param name="requst"></param> /// <returns></returns> public virtual object FromBodyDeserializeObject(ParameterInfo p, HttpRequest requst) { // 从请求流中反序列化对象中,要注意三点: // 1、忽略参数的名称 // 2、直接使用参数类型,不做可空类型处理 // 3、仅支持 JSON, XML 的数据格式 SerializeFormat format = RequestContentType.GetFormat(requst.ContentType); if (format == SerializeFormat.Json) { string text = requst.GetPostText(); return(JsonExtensions.FromJson(text, p.ParameterType)); } if (format == SerializeFormat.Xml) { string text = requst.GetPostText(); return(XmlExtensions.FromXml(text, p.ParameterType)); } // 仅仅是需要读取整个请求流字符串, // 而且目标类型已经是字符串,就没有必要反序列化了,所以就直接以字符串返回 if (p.ParameterType == typeof(string)) { return(requst.GetPostText()); } throw new NotSupportedException("[FromBody]标记只能配合 JSON/XML 数据格式来使用。"); }
public void SerializeTest(SerializeFormat format) { var engine = new NodeEngine(); string stream = null; engine.GetOrCreateNode("Node1") .SetColor(Colors.Coral) .SetPos(150, 200); engine.GetOrCreateNode("Node2"); engine.Connect("Node1", "Node2"); stream = engine.Serialize(format); var engine2 = new NodeEngine(); engine2.Deserialize(stream, format); Assert.Equal(engine.Network.Nodes[0].Guid, engine2.Network.Nodes[0].Guid); Assert.Equal(engine.Network.Nodes[0].Y, engine2.Network.Nodes[0].Y); Assert.Equal(engine.Network.Nodes[0].HeaderColor, engine2.Network.Nodes[0].HeaderColor); Assert.Equal(engine.Network.Nodes.Count, engine2.Network.Nodes.Count); Assert.Equal(engine.Network.Connections.Count, engine2.Network.Connections.Count); Assert.Equal(engine.Network.Nodes.SelectMany(x => x.InputPlugs).Count(), engine2.Network.Nodes.SelectMany(x => x.InputPlugs).Count()); Assert.Equal(engine.Network.Nodes.SelectMany(x => x.OutputPlugs).Count(), engine2.Network.Nodes.SelectMany(x => x.OutputPlugs).Count()); }
private void Write(Stream stream, object data, SerializeFormat format) { switch (format) { case SerializeFormat.Text: WriteAsTextFormat(stream, data); break; case SerializeFormat.Json: WriteAsJsonFormat(stream, data); break; case SerializeFormat.Json2: WriteAsJson2Format(stream, data); break; case SerializeFormat.Xml: WriteAsXmlFormat(stream, data); break; case SerializeFormat.Form: WriteAsFormFormat(stream, data); break; case SerializeFormat.Auto: case SerializeFormat.None: WriteAsAutoFormat(stream, data); break; default: throw new NotSupportedException(); } }
private void Write(Stream stream, object data, SerializeFormat format) { switch (format) { case SerializeFormat.Text: WriteAsTextFormat(stream, data); break; case SerializeFormat.Json: WriteAsJsonFormat(stream, data); break; case SerializeFormat.Json2: WriteAsJson2Format(stream, data); break; case SerializeFormat.Xml: WriteAsXmlFormat(stream, data); break; case SerializeFormat.Form: WriteAsFormFormat(stream, data); break; default: WriteAsUnknownFormat(stream, data); break; } }
public static string Serialize <T>(T data, SerializeFormat format) { return(format switch { SerializeFormat.XML => SerializeToXml(data), SerializeFormat.JSON => SerializeToJson(data), _ => string.Empty, });
/// <summary> /// 根据指定的URL以及提交数据,用【同步】方式发起一次HTTP请求 /// </summary> /// <typeparam name="T">返回值的类型参数</typeparam> /// <param name="url">要访问的URL地址</param> /// <param name="data">要提交的数据对象</param> /// <param name="format">数据对象在传输过程中采用的序列化方式</param> /// <returns>返回服务端的调用结果,并转换成指定的类型</returns> public async static Task <T> SendAsync <T>(string url, object data = null, SerializeFormat format = SerializeFormat.Form) { return(await new HttpOption { Url = url, Data = data, Format = format }.SendAsync <T>()); }
/// <summary> /// 根据指定的URL以及提交数据,用【同步】方式发起一次HTTP请求 /// </summary> /// <typeparam name="T">返回值的类型参数</typeparam> /// <param name="url">要访问的URL地址</param> /// <param name="data">要提交的数据对象</param> /// <param name="format">数据对象在传输过程中采用的序列化方式</param> /// <returns>返回服务端的调用结果,并转换成指定的类型</returns> public static T Send <T>(string url, object data = null, SerializeFormat format = SerializeFormat.Form) { return(new HttpOption { Url = url, Data = data, Format = format }.Send <T>()); }
private static SerializerStream CreateSerializer(SerializeFormat format, IEnumerable <Type> knownTypes) { switch (format) { default: case SerializeFormat.Xml: return(new DataContract.SerializerStreamXml(knownTypes: knownTypes)); case SerializeFormat.Json: return(new DataContract.SerializerStreamJson(knownTypes)); } }
/// <summary> /// 根据指定的URL以及提交数据,用【同步】方式发起一次HTTP请求 /// </summary> /// <typeparam name="T">返回值的类型参数</typeparam> /// <param name="url">要访问的URL地址</param> /// <param name="obj">要提交的数据对象</param> /// <param name="format">数据对象在传输过程中采用的序列化方式</param> /// <returns>返回服务端的调用结果,并转换成指定的类型</returns> public async static Task <T> SendAsync <T>(string url, object obj = null, SerializeFormat format = SerializeFormat.FORM) { HttpOption option = new HttpOption { Url = url, Data = obj, Format = format }; using (HttpClient client = ObjectFactory.New <HttpClient>()) { return(await client.GetResultAsync <T>(option)); } }
/// <summary> /// 设置要提交的数据(以异步方式) /// </summary> /// <param name="data"></param> /// <param name="format"></param> public async Task SetRequestDataAsync(object data, SerializeFormat format) { if (data == null) { return; } _beforeArgs.Data = data; _beforeArgs.Format = format; RequestWriter writer = new RequestWriter(Request); await writer.WriteAsync(data, format); }
/// <summary> /// 根据指定的URL以及提交数据,用【同步】方式发起一次HTTP请求 /// </summary> /// <typeparam name="T">返回值的类型参数</typeparam> /// <param name="url">要访问的URL地址</param> /// <param name="data">要提交的数据对象</param> /// <param name="format">数据对象在传输过程中采用的序列化方式</param> /// <returns>返回服务端的调用结果,并转换成指定的类型</returns> public async static Task <T> SendAsync <T>(string url, object data = null, SerializeFormat format = SerializeFormat.Form) { HttpClient client = ObjectFactory.New <HttpClient>(); client.CreateWebRequest(url); await client.SetRequestDataAsync(data, format); using (HttpWebResponse response = await client.GetResponseAsync()) { return(client.GetResult <T>(response)); } }
/// <summary> /// 设置要提交的数据 /// </summary> /// <param name="data"></param> /// <param name="format"></param> public void SetRequestData(object data, SerializeFormat format) { if (data == null) { return; } _beforeArgs.Data = data; _beforeArgs.Format = format; RequestWriter writer = new RequestWriter(Request); writer.Write(data, format); }
/// <summary> /// 尝试根据方法的修饰属性来构造IActionResult实例 /// </summary> /// <param name="result"></param> /// <param name="format"></param> /// <returns></returns> private IActionResult ObjectToActionResult(object result, SerializeFormat format) { IActionResult actionResult = null; if (format == SerializeFormat.AUTO) { // 如果是自动响应,那么就根据请求头的指定的方式来决定 string expectFormat = this.HttpContext.Request.Headers["Result-Format"]; if (string.IsNullOrEmpty(expectFormat) == false) { SerializeFormat f2; if (Enum.TryParse <SerializeFormat>(expectFormat.ToUpper(), out f2)) { format = f2; } } } if (format == SerializeFormat.JSON) { actionResult = new JsonResult(result); } else if (format == SerializeFormat.JSON2) { actionResult = new JsonResult(result, true); } else if (format == SerializeFormat.XML) { actionResult = new XmlResult(result); } else if (format == SerializeFormat.FORM) { string text = FormDataProvider.Serialize(result).ToString(); actionResult = new TextResult(text); } // 无法构造出IActionResult实例,就按字符串形式输出 if (actionResult == null) { actionResult = new TextResult(result); } return(actionResult); }
private Tuple <string, string> WriteStream(object data, SerializeFormat format) { HttpWebRequest request = WebRequest.CreateHttp("http://www.bing.com"); RequestWriter writer = new RequestWriter(request); using (MemoryStream ms = new MemoryStream()) { _writeMethod.Invoke(writer, new object[] { ms, data, format }); ms.Position = 0; return(new Tuple <string, string>( request.ContentType, Encoding.UTF8.GetString(ms.ToArray()) )); } }
/// <summary> /// Method to select a serialization. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="t">Generic class of the type to be serialized</param> /// <param name="format">Enum of selected serialization method</param> /// <param name="filePath">File path to save/read file to/from</param> /// <returns></returns> public static bool Serialize <T>(T t, SerializeFormat format, string filePath) { switch (format) { case SerializeFormat.Bin: return(SerializeToBin(t, filePath)); case SerializeFormat.XML: return(SerializeToXml(t, filePath)); case SerializeFormat.TXT: return(SerializeToTxt(t, filePath)); default: return(false); } }
/// <summary> /// 根据SerializeFormat枚举转换成 Content-Type 请求头字符串, /// 对于无效的枚举,返回空字符串“” /// </summary> /// <param name="format"></param> /// <returns></returns> public static string GetByFormat(SerializeFormat format) { switch (format) { case SerializeFormat.Form: return(RequestContentType.Form); case SerializeFormat.Json: return(RequestContentType.Json); case SerializeFormat.Xml: return(RequestContentType.Xml); default: return(string.Empty); } }
/// <summary> /// Generic method to select a deserialization method.. /// </summary> /// <typeparam name="T">The Generic type of the deserialized data.</typeparam> /// <param name="data">The path (and name) of the file containing data to be deserialized.</param> /// <param name="format">type of deserialization</param> /// <returns></returns> public static T Deserialize <T>(string data, SerializeFormat format) { switch (format) { case SerializeFormat.Bin: return(DeserializeBin <T>(data, out string errorMessage)); case SerializeFormat.XML: return(DeserializeXml <T>(data)); case SerializeFormat.TXT: return(DeserializeTXT <T>(data)); default: return(default(T)); } }
/// <summary> /// 初始化 /// </summary> /// <param name="config"></param> public void Init(WriterSection config) { // 避免重复调用 if (s_url != null) { return; } string url = config.GetOptionValue("url"); if (string.IsNullOrEmpty(url)) { throw new LogConfigException("日志配置文件中,没有为HttpWriter指定url属性。"); } string format = config.GetOptionValue("format"); if (string.IsNullOrEmpty(format)) { s_format = SerializeFormat.Xml; // 默认值 } else { if (Enum.TryParse <SerializeFormat>(format, out s_format) == false || s_format == SerializeFormat.None || s_format == SerializeFormat.Auto ) { throw new LogConfigException("日志配置文件中,为HttpWriter指定的format属性无效,建议选择:Json or Xml"); } } s_retryCount = config.GetOptionValue("retry-count").TryToUInt(10); s_retryWaitMillisecond = config.GetOptionValue("retry-wait-millisecond").TryToUInt(1000); s_datatypeInHeader = config.GetOptionValue("datatype-in-header").TryToBool(true); List <NameValue> queryString = ReadHttpArgs(config, "querystring:"); s_header = ReadHttpArgs(config, "header:"); s_url = url.ConcatQueryStringArgs(queryString); s_client = new HttpWriterClient(); }
/// <summary> /// NetworkModelをストリームから構築します。 /// </summary> public void Deserialize(string stream, SerializeFormat format) { if (format == SerializeFormat.Xml) { var xmlSerializer = new XmlSerializer(typeof(Network)); using (var stringReader = new StringReader(stream)) { Network = (Network)xmlSerializer.Deserialize(stringReader); } } #if NETCOREAPP3_1 else if (format == SerializeFormat.Json) { var option = new JsonSerializerOptions(); option.Converters.Add(new JsonStringEnumConverter()); Network = JsonSerializer.Deserialize <Network>(stream, option); } #endif Network.Deserialized(); NodeMap.Clear(); }
/// <summary> /// NetworkModelをシリアライズします。 /// </summary> /// <param name="serializeType"></param> /// <returns></returns> public string Serialize(SerializeFormat serializeType) { Network.PreSerialize(); if (serializeType == SerializeFormat.Xml) { var xmlSerializer = new XmlSerializer(typeof(Network)); using (var streamWriter = new StringWriter()) { xmlSerializer.Serialize(streamWriter, Network); return(streamWriter.ToString()); } } #if NETCOREAPP3_1 else if (serializeType == SerializeFormat.Json) { var options = new JsonSerializerOptions(); options.WriteIndented = true; return(JsonSerializer.Serialize(Network, options)); } #endif return(string.Empty); }
public virtual void Init(WriterSection config) { string url = config.GetOptionValue("url"); if (string.IsNullOrEmpty(url)) { throw new LogConfigException("日志配置文件中,没有为HttpWriter指定url参数。"); } string format = config.GetOptionValue("format"); _format = (string.IsNullOrEmpty(format) || format.Is("json")) ? SerializeFormat.Json : SerializeFormat.Xml; _retryCount = config.GetOptionValue("retry-count").TryToUInt(10); _retryWaitMillisecond = config.GetOptionValue("retry-wait-millisecond").TryToUInt(1000); _header = ReadHttpArgs(config, "header:"); List <NameValue> queryString = ReadHttpArgs(config, "querystring:"); _url = url.ConcatQueryStringArgs(queryString); }
public void Save(string path, SerializeFormat serializeFormat) { Stream s = File.Open(path, FileMode.Create); switch (serializeFormat) { case SerializeFormat.Binary: BinaryFormatter bf = new BinaryFormatter(); bf.Serialize(s, this); break; case SerializeFormat.Soap: SoapFormatter binFormat = new SoapFormatter(); binFormat.Serialize(s, this); break; case SerializeFormat.Xml: XmlSerializer xmlFormat = new XmlSerializer(typeof(CoolImage)); xmlFormat.Serialize(s, this); break; } s.Close(); }
public void Read(string path) { SerializeFormat serializeFormat = getFormat(path); using (Stream s = File.Open(path, FileMode.Open)) { CoolImage cl = this; switch (serializeFormat) { case SerializeFormat.Binary: BinaryFormatter bf = new BinaryFormatter(); cl = bf.Deserialize(s) as CoolImage; break; case SerializeFormat.Soap: SoapFormatter soapFormat = new SoapFormatter(); cl = soapFormat.Deserialize(s) as CoolImage; break; case SerializeFormat.Xml: XmlSerializer xmlFormat = new XmlSerializer(typeof(CoolImage)); cl = xmlFormat.Deserialize(s) as CoolImage; break; case SerializeFormat.Png: // using (FileStream fs = new FileStream(path, FileMode.Open)) { // Bitmap a = new Bitmap(fs); cl = new CoolImage(new Bitmap(s)); } break; } this.img = cl.img; this.pixelArr = cl.pixelArr; } }
public static extern int hb_buffer_serialize_glyphs(IntPtr buffer, int start, int end, IntPtr buf, int buf_size, out int buf_consumed, IntPtr font, SerializeFormat format, SerializeFlag flags);
public static extern bool hb_buffer_deserialize_glyphs(IntPtr buffer, [MarshalAs(UnmanagedType.LPStr)] string buf, int buf_len, out IntPtr end_ptr, IntPtr font, SerializeFormat format);
public Serializer(string fileName, string directoryPath, SerializeFormat format = SerializeFormat.Binary) { FileName = fileName; DirectoryPath = directoryPath; Format = format; }
public Serializer(string fileName, SerializeFormat format = SerializeFormat.Binary) { FileName = fileName; Format = format; }
//Classe permettant de (dé)serialiser un objet dans l'un des formats json,xml ou binaire public Serializer(SerializeFormat format = SerializeFormat.Binary) { Format = format; }
/// <summary> /// 尝试根据方法的修饰属性来构造IActionResult实例 /// </summary> /// <param name="result"></param> /// <param name="format"></param> /// <returns></returns> private IActionResult ObjectToActionResult(object result, SerializeFormat format) { IActionResult actionResult = null; if( format == SerializeFormat.AUTO ) { // 如果是自动响应,那么就根据请求头的指定的方式来决定 string expectFormat = this.HttpContext.Request.Headers["Result-Format"]; if( string.IsNullOrEmpty(expectFormat) == false ) { SerializeFormat f2; if( Enum.TryParse<SerializeFormat>(expectFormat.ToUpper(), out f2) ) format = f2; } } if( format == SerializeFormat.JSON ) actionResult = new JsonResult(result); else if( format == SerializeFormat.JSON2 ) actionResult = new JsonResult(result, true); else if( format == SerializeFormat.XML ) actionResult = new XmlResult(result); else if( format == SerializeFormat.FORM ) { string text = FormDataProvider.Serialize(result).ToString(); actionResult = new TextResult(text); } // 无法构造出IActionResult实例,就按字符串形式输出 if( actionResult == null ) actionResult = new TextResult(result); return actionResult; }
public Serializer(SerializeFormat format = SerializeFormat.Json, IEnumerable <Type> knownTypes = null) { this.Format = format; this.SerializerStream = CreateSerializer(format, knownTypes); }