public static string FormatToString(object value, DataFormatType dataFormatType)
{
if (value == null)
{
return(String.Empty);
}
string format = GetDataFormatString(dataFormatType);
switch (dataFormatType)
{
case DataFormatType.None:
default:
return(value.ToString());
case DataFormatType.Currency:
{
decimal parsedValue;
if (Decimal.TryParse(value.ToString(), out parsedValue))
{
return(String.Format(format, parsedValue));
}
break;
}
case DataFormatType.Date:
case DataFormatType.DateTime:
case DataFormatType.Time:
{
DateTime parsedValue;
if (DateTime.TryParse(value.ToString(), out parsedValue))
{
return(String.Format(format, parsedValue));
}
break;
}
case DataFormatType.Double:
{
double parsedValue;
if (Double.TryParse(value.ToString(), out parsedValue))
{
return(String.Format(format, parsedValue));
}
break;
}
case DataFormatType.Integer:
{
int parsedValue;
if (Int32.TryParse(value.ToString(), out parsedValue))
{
return(String.Format(format, parsedValue));
}
break;
}
}
return(value.ToString());
}
/// <summary>
/// Deserialisiert die Daten zu einem Object
/// </summary>
/// <param name="data"></param>
/// <param name="format"></param>
/// <returns></returns>
public static object DeSerialize(this byte[] data, DataFormatType format)
{
MemoryStream ms = new MemoryStream(data);
object objectToSerialize = null;
try {
switch (format)
{
case DataFormatType.Binary:
BinaryFormatter bFormatter = new BinaryFormatter();
objectToSerialize = bFormatter.Deserialize(ms);
break;
case DataFormatType.Soap:
throw new NotImplementedException();
//SoapFormatter sFormatter = new SoapFormatter();
//objectToSerialize = sFormatter.Deserialize(ms);
//break;
case DataFormatType.XML:
throw new NotImplementedException();
//XmlSerializer xFormatter = new XmlSerializer();
//objectToSerialize = xFormatter.Deserialize(ms);
//break;
}
#pragma warning disable 0168
} catch (Exception ex) { }
#pragma warning restore 0168
ms.Close();
return(objectToSerialize);
}
/// <summary>
/// Deserialisiert die Daten zu einem Object
/// </summary>
/// <param name="data"></param>
/// <param name="format"></param>
/// <returns></returns>
public static object DeSerialize(this byte[] data, DataFormatType format)
{
MemoryStream ms = new MemoryStream(data);
object objectToSerialize = null;
try {
switch (format) {
case DataFormatType.Binary:
BinaryFormatter bFormatter = new BinaryFormatter();
objectToSerialize = bFormatter.Deserialize(ms);
break;
case DataFormatType.Soap:
SoapFormatter sFormatter = new SoapFormatter();
objectToSerialize = sFormatter.Deserialize(ms);
break;
case DataFormatType.XML:
throw new NotImplementedException();
//XmlSerializer xFormatter = new XmlSerializer();
//objectToSerialize = xFormatter.Deserialize(ms);
//break;
}
#pragma warning disable 0168
} catch (Exception ex) { }
#pragma warning restore 0168
ms.Close();
return objectToSerialize;
}
public static string GetDataFormatString(DataFormatType dataFormatType)
{
switch (dataFormatType)
{
case DataFormatType.None:
default:
return("{0}");
case DataFormatType.Currency:
return("{0:N2}");
case DataFormatType.Date:
return("{0:" + System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern + "}");
case DataFormatType.DateTime:
return("{0:" + System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern + " " + System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortTimePattern + "}");
case DataFormatType.Double:
return("{0}");
case DataFormatType.Integer:
return("{0:0}");
case DataFormatType.Time:
return("{0:" + System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortTimePattern + "}");
}
}
public static string GetOfficeDataFormat(DataFormatType dataFormatType)
{
switch (dataFormatType)
{
case DataFormatType.None:
default:
return("");
case DataFormatType.Currency:
return(@"\#\.\#\#0\,00");
case DataFormatType.Date:
return(System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern);
case DataFormatType.DateTime:
return(System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern + " " + System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortTimePattern);
case DataFormatType.Double:
return(@"0\,00");
case DataFormatType.Integer:
return("");
case DataFormatType.Time:
return(System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortTimePattern);
}
}
/// <summary>
/// Construct a data chunk
/// </summary>
/// <param name="dataFormat">what kind of encoding represents the data?</param>
/// <param name="description">a brief description of what the data represents</param>
/// <param name="rawData">the raw byte data</param>
/// <param name="offset">the offset to start in the rawData that represents the chunk</param>
/// <param name="dataLength">the length of the data from the offset that represents the chunk</param>
/// <param name="addToValue">the value to add to each of each byte value (used occasionaly for bytes that represent offsets)</param>
public DataChunk(DataFormatType dataFormat, string description, List <byte> rawData, int offset, int dataLength, byte addToValue)
{
DataFormat = dataFormat;
Description = description;
DataLength = dataLength;
FileOffset = offset;
RawData = new byte[dataLength];
rawData.CopyTo(offset, RawData, 0, dataLength);
ValueModifier = addToValue;
if (dataFormat == DataFormatType.StringListFromIndexes || dataFormat == DataFormatType.UINT16List)
{
fullRawData = rawData;
}
}
public override void WriteJson(JsonWriter writer,
object untypedValue,
JsonSerializer serializer)
{
if (untypedValue == null)
{
serializer.Serialize(writer,
null);
return;
}
DataFormatType value = (DataFormatType)untypedValue;
switch (value)
{
case DataFormatType.Csv:
serializer.Serialize(writer,
"csv");
return;
case DataFormatType.Dsv:
serializer.Serialize(writer,
"dsv");
return;
case DataFormatType.Json:
serializer.Serialize(writer,
"json");
return;
case DataFormatType.Topojson:
serializer.Serialize(writer,
"topojson");
return;
case DataFormatType.Tsv:
serializer.Serialize(writer,
"tsv");
return;
}
throw new Exception("Cannot marshal type DataFormatType");
}
static void Main(string[] args)
{
DataFormatType dataFormatType = DataFormatType.Xml | DataFormatType.Csv;
switch (dataFormatType)
{
case DataFormatType.Xml | DataFormatType.Json: { Console.WriteLine("Xml and Json selected."); } break;
case DataFormatType.Xml | DataFormatType.Csv: { Console.WriteLine("Xml and Csv selected."); } break;
case DataFormatType.Json | DataFormatType.Csv: { Console.WriteLine("Json and Csv selected."); } break;
case DataFormatType.Text | DataFormatType.Html: { Console.WriteLine("Text and Html selected."); } break;
default: { Console.WriteLine("None selected."); } break;
}
}
/// <summary>Gets column data type</summary>
/// <param name="type">Data type</param>
public void SetType(DataFormatType type)
{
switch (type)
{
case DataFormatType.Date:
this.name = "DATE";
break;
case DataFormatType.Image:
this.name = "IMAGE";
break;
case DataFormatType.Document:
this.name = "DOCUMENT";
break;
}
}
public static string GetString(this DataFormatType dataFormatType)
{
switch (dataFormatType)
{
case DataFormatType.Csv: return("csv");
case DataFormatType.Dsv: return("dsv");
case DataFormatType.Json: return("json");
case DataFormatType.Topojson: return("topojson");
case DataFormatType.Tsv: return("tsv");
default:
return(null);
}
}
public static IGenericSerializer <T> CreateSerializerObject(DataFormatType dataFormat)
{
IGenericSerializer <T> serializer;
switch (dataFormat)
{
case DataFormatType.XML:
serializer = new XmlGenericSerializer <T>();
break;
case DataFormatType.JSON:
serializer = new JsonGenericSerializer <T>();
break;
default:
throw new NotSupportedException();
}
return(serializer);
}
public static string GetExportDataFormat(DataFormatType dataFormatType)
{
switch (dataFormatType)
{
default:
case DataFormatType.None:
return("exportTextFormat");
case DataFormatType.Double:
return("exportDoubleFormat");
case DataFormatType.Currency:
return("exportCurrencyFormat");
case DataFormatType.Date:
return("exportDateFormat");
case DataFormatType.Time:
return("exportTimeFormat");
}
}
public static bool Validate(DataFormatType dataFormat, int min, int max, string data)
{
switch (dataFormat)
{
case DataFormatType.Alphanumeric:
return(Regex.IsMatch(data, string.Format(AlphanumericPattern, min, max)));
case DataFormatType.Numeric:
return(Regex.IsMatch(data, string.Format(NumericPattern, min, max)));
case DataFormatType.Digit:
return(Regex.IsMatch(data, string.Format(NumericPattern, min, max)));
case DataFormatType.Date:
break;
case DataFormatType.DateTime:
break;
default:
throw new ArgumentOutOfRangeException(nameof(dataFormat), dataFormat, null);
}
throw new ArgumentOutOfRangeException(nameof(dataFormat), dataFormat, null);
}
/// <summary>
/// Construct a data chunk
/// Note: Assumes nothing to add to the byte values
/// </summary>
/// <param name="dataFormat">what kind of encoding represents the data?</param>
/// <param name="description">a brief description of what the data represents</param>
/// <param name="rawData">the raw byte data</param>
/// <param name="offset">the offset to start in the rawData that represents the chunk</param>
/// <param name="dataLength">the length of the data from the offset that represents the chunk</param>
public DataChunk(DataFormatType dataFormat, string description, List <byte> rawData, int offset, int dataLength) :
this(dataFormat, description, rawData, offset, dataLength, 0)
{
}
/// <summary>
/// TOP API POST 请求
/// </summary>
/// <param name="method">API接口方法名</param>
/// <param name="session">调用私有的sessionkey</param>
/// <param name="param">请求参数</param>
/// <param name="dataType">淘宝返回数据格式</param>
/// <returns>返回字符串</returns>
public static string Post(string nick, string method, string session, IDictionary <string, string> param, DataFormatType dataType)
{
#region -----API系统参数----
string url = "http://gw.api.taobao.com/router/rest";
//string appkey = "12287381";//"12159997";
//string appSecret = "d3486dac8198ef01000e7bd4504601a4";//"614e40bfdb96e9063031d1a9e56fbed5";
//免费版
//string appkey = "12132145";
//string appSecret = "1fdd2aadd5e2ac2909db2967cbb71e7f";
param.Add("method", method);
param.Add("session", session);
param.Add("timestamp", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
param.Add("format", dataType.ToString());
param.Add("v", "2.0");
param.Add("sign_method", "md5");
List <TopNickSessionInfo> nicks = CacheCollection.GetNickSessionList().Where(o => o.Nick == nick).ToList();
if (nicks.Count > 0)
{
//订购多个服务
foreach (TopNickSessionInfo ninfo in nicks)
{
//访问的当前服务
if (ninfo.Session == session)
{
//根据具体调用哪个服务,插入该服务appkey
if (ninfo.ServiceId == Enum.TopTaoBaoService.YingXiaoJueCe)
{
param.Add("app_key", newAppkey);
param.Add("sign", CreateSign(param, newAppSecret));
}
if (ninfo.ServiceId == Enum.TopTaoBaoService.Temporary)
{
param.Add("app_key", appkey);
param.Add("sign", CreateSign(param, appSecret));
}
break; //服务不同,session不可能相同
}
}
}
#endregion
string result = string.Empty;
#region ---- 完成 HTTP POST 请求----
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.Method = "POST";
req.KeepAlive = true;
req.Timeout = 300000;
req.ContentType = "application/x-www-form-urlencoded;charset=gb2312";
byte[] postData = Encoding.UTF8.GetBytes(PostData(param));
Stream reqStream = req.GetRequestStream();
reqStream.Write(postData, 0, postData.Length);
reqStream.Close();
try
{
HttpWebResponse rsp = (HttpWebResponse)req.GetResponse();
Encoding encoding = Encoding.GetEncoding(rsp.CharacterSet);
Stream stream = null;
StreamReader reader = null;
stream = rsp.GetResponseStream();
reader = new StreamReader(stream, encoding);
result = reader.ReadToEnd();
if (reader != null)
{
reader.Close();
}
if (stream != null)
{
stream.Close();
}
if (rsp != null)
{
rsp.Close();
}
}
catch (Exception ex)
{
LogInfo.WriteLog("session:" + session + "获取淘宝服务响应错误", ex.Message);
}
#endregion
return(Regex.Replace(result, @"[\x00-\x08\x0b-\x0c\x0e-\x1f]", ""));
}
public static bool Validate(DataFormatType dataFormat, int length, string data)
{
return(Validate(dataFormat, length, length, data));
}
/// <summary>
/// A String formatter method which is localized by global data format.
/// </summary>
/// <param name="o">Object to format.</param>
/// <param name="dataFormatType">Globalized data format.</param>
/// <returns></returns>
public static string ToString(this object o, DataFormatType dataFormatType)
{
return(DataFormatManager.FormatToString(o, dataFormatType));
}
/// <summary>
/// Statically create a DataChunk
/// Handy for quick and dirty variable extraction
/// </summary>
/// <param name="dataFormat">what kind of encoding represents the data?</param>
/// <param name="description">a brief description of what the data represents</param>
/// <param name="rawData">the raw byte data</param>
/// <param name="offset">the offset to start in the rawData that represents the chunk</param>
/// <param name="dataLength">the length of the data from the offset that represents the chunk</param>
/// <returns>a new DataChunk object</returns>
static public DataChunk CreateDataChunk(DataFormatType dataFormat, string description, List <byte> rawData, int offset, int dataLength)
{
DataChunk dataChunk = new DataChunk(dataFormat, description, rawData, offset, dataLength);
return(dataChunk);
}
