public static ISerializer GetCurrent(SerializationFormat format)
{
var serializers = Container.GetAll<ISerializer>();
return (from s in serializers
where s.Format == format
select s).FirstOrDefault();
}
/// <summary>
/// Creates a new instance of RESTDataClient.
/// </summary>
/// <param name="serviceUrl">The url endpoint of the service to send data to.</param>
/// <param name="timeout">A timeout for all requests.</param>
/// <param name="compress">Whether to compress data before sending. Only applies when posting JSON or XML, not with HttpQueryString mode.</param>
/// <param name="serializationFormat">The version number to send to the server.</param>
/// <param name="version">The version number to send to the server.</param>
public RESTDataClient(Uri serviceUrl, int timeout, bool compress, SerializationFormat serializationFormat, int version)
{
Version = version;
ServiceUrl = serviceUrl;
Timeout = TimeSpan.FromSeconds(timeout);
Compress = compress;
SerializationFormat = serializationFormat;
AdditionalHttpHeaders = new Dictionary<string, string>();
}
public Claim ToClaim(SerializationFormat serializationFormat = SerializationFormat.Json)
{
return new Claim(ClaimTypes.GroupSid, Sid);
//var serialized = serializationFormat == SerializationFormat.Json
// ? this.ToJson()
// : this.ToXml();
//return new Claim(LDAPClaimTypes.ActiveDirectoryGroup, serialized);
}
public SerializedValue([NotNull] string assemblyQualifiedName)
{
if (assemblyQualifiedName == null)
{
throw new ArgumentNullException("assemblyQualifiedName");
}
_assemblyQualifiedName = assemblyQualifiedName;
_format = SerializationFormat.Null;
}
// private SyncReader syncReader;
// private SyncWriter syncWriter;
public HttpCacheRequestHandler(Uri serviceUri, CacheControllerBehavior behaviors)
{
baseUri = serviceUri;
serializationFormat = behaviors.SerializationFormat;
scopeName = behaviors.ScopeName;
credentials = behaviors.Credentials;
knownTypes = new Type[behaviors.KnownTypes.Count];
behaviors.KnownTypes.CopyTo(knownTypes, 0);
scopeParameters = new Dictionary<string, string>(behaviors.ScopeParametersInternal);
}
public JsonResult(object data, string contentType,
Encoding contentEncoding, SerializationFormat format,
IEnumerable<JavaScriptConverter> converters)
{
_converters = new List<JavaScriptConverter>(
converters ?? Enumerable.Empty<JavaScriptConverter>());
_data = data;
_contentType = contentType;
_contentEncoding = contentEncoding;
_format = format;
}
// private SyncReader syncReader;
// private SyncWriter syncWriter;
public HttpCacheRequestHandler(Uri serviceUri, CacheControllerBehavior behaviors)
{
baseUri = serviceUri;
serializationFormat = behaviors.SerializationFormat;
scopeName = behaviors.ScopeName;
credentials = behaviors.Credentials;
knownTypes = new Type[behaviors.KnownTypes.Count];
behaviors.KnownTypes.CopyTo(knownTypes, 0);
scopeParameters = new Dictionary<string, string>(behaviors.ScopeParametersInternal);
customHeaders = new Dictionary<string, string>(behaviors.CustomHeadersInternal);
automaticDecompression = behaviors.AutomaticDecompression;
this.CookieContainer = behaviors.CookieContainer;
}
// ReSharper restore FieldCanBeMadeReadOnly.Local
public SerializedValue([NotNull] string assemblyQualifiedName, [NotNull] string jsonData)
{
if (assemblyQualifiedName == null)
{
throw new ArgumentNullException("assemblyQualifiedName");
}
if (jsonData == null)
{
throw new ArgumentNullException("jsonData");
}
_assemblyQualifiedName = assemblyQualifiedName;
_jsonData = jsonData;
_format = SerializationFormat.UnityJson;
}
public SerializedValue([NotNull] string assemblyQualifiedName, [NotNull] byte[] binaryData)
{
if (assemblyQualifiedName == null)
{
throw new ArgumentNullException("assemblyQualifiedName");
}
if (binaryData == null)
{
throw new ArgumentNullException("binaryData");
}
_assemblyQualifiedName = assemblyQualifiedName;
_binaryData = binaryData;
_format = SerializationFormat.BinaryFormatter;
}
public static Stream SerializeSystemBoolean(bool obj, SerializationFormat serializationFormat, WebMessageFormat webMessageFormat)
{
if (IsXml(serializationFormat, webMessageFormat))
{
var root = new XElement(XName.Get("Boolean"));
var xDocument = new XDocument(root);
root.Add(XmlConvert.ToString(obj));
var stream = GetStream(xDocument);
return stream;
}
else
{
return GetStream(obj.ToJsonString());
}
}
public void Run(AmfFile file, out string name, out SerializationFormat format)
{
// Case for "save to file". Fenoxo only serializes ones object and there is no header.
if (_reader.PeekChar() == 0x0A)
{
format = SerializationFormat.Exported;
ReadPlainDataFile(file, out name);
}
// Case for "save to slot". Real AMF3 file with a proper header.
else
{
format = SerializationFormat.Slot;
ReadStandardFile(file, out name);
}
}
public static BaseConverter <T> GetConverter(SerializationFormat serializationFormat)
{
switch (serializationFormat)
{
case SerializationFormat.Json:
return(new JsonConverter <T>());
case SerializationFormat.DmSerializer:
return(new DmBinaryConverter <T>());
case SerializationFormat.Custom:
return(null);
}
throw new Exception("Cant get Converter");
}
public override byte[] ProcessDataOnSave(string path, SerializationFormat serializationFormat, byte[] data)
{
using (MemoryStream targetStream = new MemoryStream())
{
using (
DeflateStream compressionStream =
new DeflateStream(
targetStream,
(CompressionLevel)ParametersInfo[compressionLevelParamName].Value))
{
compressionStream.Write(data, 0, data.Length);
}
return(targetStream.ToArray());
}
}
/// <summary>
/// Serializes an <see cref="Object"/>.
/// </summary>
/// <typeparam name="T"><see cref="Type"/> of the <paramref name="serializableObject"/>.</typeparam>
/// <param name="serializableObject"><see cref="Object"/> to be serialized.</param>
/// <param name="serializationFormat"><see cref="SerializationFormat"/> in which the <paramref name="serializableObject"/> is to be serialized.</param>
/// <returns>An <see cref="Array"/> of <see cref="Byte"/> of the serialized <see cref="Object"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="serializableObject"/> is null.</exception>
/// <exception cref="NotSupportedException">Specified <paramref name="serializationFormat"/> is not supported.</exception>
public static byte[] Serialize <T>(T serializableObject, SerializationFormat serializationFormat)
{
// FYI, using statement will not work here as this creates a read-only variable that cannot be passed by reference
Stream stream = null;
try
{
stream = new BlockAllocatedMemoryStream();
Serialize(serializableObject, serializationFormat, stream);
return(((BlockAllocatedMemoryStream)stream).ToArray());
}
finally
{
stream?.Dispose();
}
}
private static void SerializeDateTime(DateTime datetime, StringBuilder sb,
SerializationFormat serializationFormat)
{
if (serializationFormat == SerializationFormat.JSON)
{
sb.Append("\"\\/Date(");
sb.Append((long)(((datetime.ToUniversalTime()).Ticks - DatetimeMinTimeTicks) / 0x2710L));
sb.Append(")\\/\"");
}
else
{
sb.Append("new Date(");
sb.Append((long)(((datetime.ToUniversalTime()).Ticks - DatetimeMinTimeTicks) / 0x2710L));
sb.Append(")");
}
}
/// <summary>
/// Use this constructor when you are on the Remote Side, only
/// </summary>
public WebProxyClientProvider(Uri serviceUri,
Dictionary <string, string> scopeParameters = null,
Dictionary <string, string> customHeaders = null,
SerializationFormat serializationFormat = SerializationFormat.Json)
{
this.httpRequestHandler = new HttpRequestHandler(serviceUri, serializationFormat, CancellationToken.None);
foreach (var sp in scopeParameters)
{
this.AddScopeParameter(sp.Key, sp.Value);
}
foreach (var ch in customHeaders)
{
this.AddCustomHeader(ch.Key, ch.Value);
}
}
public IDataSerializer Create(SerializationFormat format)
{
switch (format)
{
case SerializationFormat.Json:
return(new JsonSerializer());
case SerializationFormat.Xml:
return(new XmlDataSerializer());
case SerializationFormat.Csv:
return(new CsvSerializer());
default:
throw new Exception("Unknown serialization format");
}
}
public string Serialize(SerializationFormat format, bool prettyPrint)
{
switch (format)
{
case SerializationFormat.Xml:
return(ToXml(prettyPrint));
case SerializationFormat.Json:
return(ToJson(prettyPrint));
case SerializationFormat.Yaml:
return(ToYaml());
default:
throw new Exception("Unsupported Format Type [" + format + "]");
}
}
private static string AddFileExtension(string fileName, SerializationFormat format)
{
string newFileName = fileName;
string fileExt = String.Empty;
switch (format)
{
case SerializationFormat.DataContract:
{
fileExt = ".xml";
if (!fileName.EndsWith(fileExt, StringComparison.CurrentCultureIgnoreCase))
{
newFileName = String.Format("{0}{1}", fileName, fileExt);
}
break;
}
case SerializationFormat.JSON:
{
fileExt = ".xml";
if (!fileName.EndsWith(fileExt, StringComparison.CurrentCultureIgnoreCase))
{
newFileName = String.Format("{0}{1}", fileName, fileExt);
}
break;
}
case SerializationFormat.XML:
{
fileExt = ".xml";
if (!fileName.EndsWith(fileExt, StringComparison.CurrentCultureIgnoreCase))
{
newFileName = String.Format("{0}{1}", fileName, fileExt);
}
break;
}
}
return(newFileName);
}
private static Tuple <string, T> SerializeAndDeserialize <T>(
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat,
T objectToSerialize)
{
var serializer = SerializerFactory.Instance.BuildSerializer(serializerRepresentation);
var describedSerialization = objectToSerialize.ToDescribedSerializationUsingSpecificSerializer(serializer, serializationFormat);
var deserializedObject = (T)describedSerialization.DeserializePayloadUsingSpecificSerializer(serializer);
// note that we cannot return a ValueTuple (DescribedSerialization DescribedSerialization, T actual)
// here because ValueTuple is not [Serializable]
var result = new Tuple <string, T>(describedSerialization.SerializedPayload, deserializedObject);
return(result);
}
public override byte[] ProcessDataOnSave(string path, SerializationFormat serializationFormat, byte[] data)
{
if (SerializationFormat.XML == serializationFormat)
{
string xmlStr = Encoding.UTF8.GetString(data);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xmlStr);
string jsonStr =
JsonConvert.SerializeXmlNode(xmlDocument, Newtonsoft.Json.Formatting.None, true);
return(Encoding.UTF8.GetBytes(jsonStr));
}
return(data);
}
private void SerializeEnumerable(IEnumerable enumerable, StringBuilder sb, int depth, Hashtable objectsInUse,
SerializationFormat serializationFormat)
{
sb.Append('[');
bool flag = true;
foreach (object obj2 in enumerable)
{
if (!flag)
{
sb.Append(',');
}
SerializeValue(obj2, sb, depth, objectsInUse, serializationFormat, "");
flag = false;
}
sb.Append(']');
}
/// <summary>
/// Deserializes a serialized <see cref="Object"/>.
/// </summary>
/// <typeparam name="T"><see cref="Type"/> of the deserialized <see cref="Object"/> to be returned.</typeparam>
/// <param name="serializedObject"><see cref="Stream"/> containing the serialized <see cref="Object"/> that is to be deserialized.</param>
/// <param name="serializationFormat"><see cref="SerializationFormat"/> in which the <paramref name="serializedObject"/> was serialized.</param>
/// <returns>The deserialized <see cref="Object"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="serializedObject"/> is null.</exception>
/// <exception cref="NotSupportedException">Specified <paramref name="serializationFormat"/> is not supported.</exception>
public static T Deserialize <T>(Stream serializedObject, SerializationFormat serializationFormat)
{
if ((object)serializedObject == null)
{
throw new ArgumentNullException("serializedObject");
}
// Deserialize the serialized object.
T deserializedObject;
if (serializationFormat == SerializationFormat.Xml)
{
if (typeof(T).GetCustomAttributes(typeof(XmlSerializerFormatAttribute), false).Length > 0)
{
// Deserialize from XML format using XmlSerializer.
XmlSerializer serializer = new XmlSerializer(typeof(T));
deserializedObject = (T)serializer.Deserialize(serializedObject);
}
else
{
// Deserialize from XML format using DataContractSerializer.
DataContractSerializer serializer = new DataContractSerializer(typeof(T));
deserializedObject = (T)serializer.ReadObject(serializedObject);
}
}
else if (serializationFormat == SerializationFormat.Json)
{
// Deserialize from JSON format.
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
deserializedObject = (T)serializer.ReadObject(serializedObject);
}
else if (serializationFormat == SerializationFormat.Binary)
{
// Deserialize from binary format.
BinaryFormatter serializer = new BinaryFormatter();
serializer.Binder = LegacyBinder;
deserializedObject = (T)serializer.Deserialize(serializedObject);
}
else
{
// Serialization format is not supported.
throw new NotSupportedException(string.Format("{0} serialization is not supported", serializationFormat));
}
return(deserializedObject);
}
/// <summary>
/// 将文件反序列化成对象
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="path">文件路径</param>
/// <param name="format">格式： json 或 xml</param>
/// <returns></returns>
public static T DeserializeFile <T>(this string path, SerializationFormat format)
{
switch (format)
{
case SerializationFormat.Xml:
return(SerializationExtend.DeSerializableXML <T>(path));
case SerializationFormat.Json:
return(SerializationExtend.DeSerializableJson <T>(path));
case SerializationFormat.Binary:
return(SerializationExtend.DeSerializableBinary <T>(path));
default:
throw new ArgumentException();
}
}
/// <summary>
/// 对象序列化成文件并保存
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="t">对象实体</param>
/// <param name="path">文件路径</param>
/// <param name="format">格式：json或 xml</param>
/// <returns></returns>
public static bool SerializableFile(this object t, string path, SerializationFormat format)
{
switch (format)
{
case SerializationFormat.Xml:
return(SerializationExtend.SerializableXML(t, path));
case SerializationFormat.Json:
return(SerializationExtend.SerializableJson(t, path));
case SerializationFormat.Binary:
return(SerializationExtend.SerializableBinary(t, path));
default:
throw new ArgumentException();
}
}
public static T DeserializeFromStream <T>(Stream inputStream, SerializationFormat format, params Type[] knownTypes)
{
T returnObject = default(T);
try
{
if (inputStream.Length >= 0)
{
inputStream.Position = 0;
}
switch (format)
{
case SerializationFormat.DataContract:
DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(T), knownTypes);
returnObject = (T)dataContractSerializer.ReadObject(inputStream);
break;
case SerializationFormat.JSON:
DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T), knownTypes);
returnObject = (T)dataContractJsonSerializer.ReadObject(inputStream);
break;
case SerializationFormat.XML:
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T), knownTypes);
inputStream.Position = 0;
returnObject = (T)xmlSerializer.Deserialize(inputStream);
break;
}
if (returnObject is IDeserializationDefault)
{
((IDeserializationDefault)returnObject).SetDeserializationDefault();
}
}
catch (Exception ex)
{
string logStr = String.Format("Exception in DeserializeFromStream<{0}>: {1}", typeof(T).Name, ex.ToString());
Debug.WriteLine(logStr);
//Logger.Write(logStr, EnumResources.Exception);
}
return(returnObject);
}
/// <summary>
/// Utility method to return the CycloneDX media type with the specification version specified.
/// </summary>
/// <param name="format">The CycloneDX format. i.e. <c>Format.Xml</c></param>
/// <param name="specificationVersion">The CycloneDX specification version. i.e. <c>SpecificationVersion.v1_3</c></param>
public static string GetMediaType(SerializationFormat format, SpecificationVersion specificationVersion)
{
var mediaType = GetMediaType(format);
var version = "1.4";
if (specificationVersion == SpecificationVersion.v1_3)
{
version = "1.3";
}
else if (specificationVersion == SpecificationVersion.v1_2)
{
if (format == SerializationFormat.Protobuf)
{
throw new UnsupportedFormatSpecificationVersionException("Protocol Buffers format is only supported from v1.3.");
}
version = "1.2";
}
else if (specificationVersion == SpecificationVersion.v1_1)
{
if (format == SerializationFormat.Json)
{
throw new UnsupportedFormatSpecificationVersionException("JSON format is only supported from v1.2.");
}
if (format == SerializationFormat.Protobuf)
{
throw new UnsupportedFormatSpecificationVersionException("Protocol Buffers format is only supported from v1.3.");
}
version = "1.1";
}
else if (specificationVersion == SpecificationVersion.v1_0)
{
if (format == SerializationFormat.Json)
{
throw new UnsupportedFormatSpecificationVersionException("JSON format is only supported from v1.2.");
}
if (format == SerializationFormat.Protobuf)
{
throw new UnsupportedFormatSpecificationVersionException("Protocol Buffers format is only supported from v1.3.");
}
version = "1.0";
}
return($"{mediaType}; version={version}");
}
/// <summary>
/// Serializes the object for persistence
/// </summary>
/// <param name="instance">The object to serialize</param>
/// <param name="format">The format of serialization to perform</param>
/// <returns></returns>
public static string Serialize(object instance, SerializationFormat format = SerializationFormat.Json)
{
if (format != SerializationFormat.Json)
{
throw new NotImplementedException();
}
if (instance is string)
{
return(instance as string);
}
string result = string.Empty;
WithinJsonScope(() => { result = JsonSerializer.SerializeToString(instance); });
return(result);
}
public ISerializer Get(SerializationFormat format)
{
switch (format)
{
case SerializationFormat.None:
return this.Null;
case SerializationFormat.Json:
return this.Json;
case SerializationFormat.Xml:
return this.Xml;
case SerializationFormat.Binary:
return this.Binary;
case SerializationFormat.Null:
throw new Exception("You must specify a valid SerializationFormat");
default:
throw new Exception(string.Format("There is no serializer with format '{0}'", format));
}
}
public byte[] Serialize(SerializationFormat format = SerializationFormat.Normal)
{
byte[] buffer;
switch (format)
{
case SerializationFormat.Normal:
default:
buffer = new byte[NativeMethods.roaring_bitmap_size_in_bytes(_pointer)];
NativeMethods.roaring_bitmap_serialize(_pointer, buffer);
break;
case SerializationFormat.Portable:
buffer = new byte[NativeMethods.roaring_bitmap_portable_size_in_bytes(_pointer)];
NativeMethods.roaring_bitmap_portable_serialize(_pointer, buffer);
break;
}
return(buffer);
}
static void Main(string[] args)
{
SerializationFormat obj = new SerializationFormat
{
metadata = new MyMetaData {
foo = "xyz", bar = 12
},
data = new byte[] { 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21 }
};
using (Stream stream = new FileStream(@"c:\temp\test.json", FileMode.Create))
using (TextWriter textWriter = new StreamWriter(stream, Encoding.UTF8))
using (JsonWriter jsonWriter = new JsonTextWriter(textWriter))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(jsonWriter, obj);
}
}
public Task RunBenchmark(Query query, QueryType queryType, SerializationFormat serializationFormat)
{
JsonSerializationFormat jsonSerializationFormat = serializationFormat switch
{
SerializationFormat.Text => JsonSerializationFormat.Text,
SerializationFormat.Binary => JsonSerializationFormat.Binary,
_ => throw new ArgumentOutOfRangeException(nameof(serializationFormat)),
};
Func <Container, string, JsonSerializationFormat, Task> func = queryType switch
{
QueryType.CosmosElement => QueryWithCosmosElements,
QueryType.TextStream => QueryWithTextStream,
_ => throw new ArgumentOutOfRangeException(nameof(queryType)),
};
return(func(this.container, query.Text, jsonSerializationFormat));
}
private void SerializeDictionary(IDictionary o, StringBuilder sb, int depth, Hashtable objectsInUse,
SerializationFormat serializationFormat)
{
sb.Append('{');
bool isFirstElement = true;
DictionaryEntry[] entrys = new DictionaryEntry[o.Count];
o.CopyTo(entrys, 0);
for (int i = 0; i < entrys.Length; i++)
{
DictionaryEntry entry = entrys[i];
if (!isFirstElement)
{
sb.Append(',');
}
string key = entry.Key as string;
if (key == null)
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, Resources.JSON_DictionaryTypeNotSupported, o.GetType().FullName));
}
SerializeString((string)entry.Key, sb);
sb.Append(':');
SerializeValue(entry.Value, sb, depth, objectsInUse, serializationFormat);
isFirstElement = false;
}
/* foreach (DictionaryEntry entry in (IDictionary)o) // 并发有时会报错:集合已修改；可能无法执行枚举操作 msf,2012.2.28
* {
* if (!isFirstElement)
* {
* sb.Append(',');
* }
* string key = entry.Key as string;
* if (key == null)
* {
* throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, Resources.JSON_DictionaryTypeNotSupported, o.GetType().FullName));
* }
* SerializeString((string)entry.Key, sb);
* sb.Append(':');
* SerializeValue(entry.Value, sb, depth, objectsInUse, serializationFormat);
* isFirstElement = false;
* }*/
sb.Append('}');
}
private static XmlObjectSerializer GetSerializer(Type type, SerializationFormat format)
{
XmlObjectSerializer serializer = null;
switch (format)
{
case SerializationFormat.Xml:
serializer = new DataContractSerializer(type);
break;
case SerializationFormat.Json:
serializer = new DataContractJsonSerializer(type);
break;
default:
throw new NotSupportedException("Serialization format '{0}' is not supported.".FormatWith(format));
}
return(serializer);
}
public static string Deserialize(byte[] data, bool isKey, string topic, SerializationFormat serializationFormat)
{
if (data == null || data.Length == 0)
{
return(string.Empty);
}
switch (serializationFormat)
{
case SerializationFormat.Bytes: return(DeserializeBytes(data));
case SerializationFormat.Json: return(DeserializeJson(data));
case SerializationFormat.Avro: return(DeserializeAvro(data, topic, isKey));
default:
return("UNKNOWN_SERIALIZATION_FORMAT");
}
}
private object PostProcess(Type type, object value, SerializationFormat requestedFormat)
{
if (value == null)
{
return(value);
}
var processed = value;
var doEncryption = CacheConfiguration.Current.Encryption.Enabled;
if (doEncryption)
{
processed = Encryption.Decrypt((string)processed);
}
var serializer = GetSerializer(requestedFormat, doEncryption);
processed = serializer.Deserialize(type, processed);
return(processed);
}
public T DeserializeObject(byte[] byteData, string stringData, SerializationFormat serializationFormat)
{
byte[] dataBuffer = null;
switch (serializationFormat)
{
case SerializationFormat.Binary:
return(this.DeserializeObjectDataInternal(byteData));
case SerializationFormat.Base64:
dataBuffer = Convert.FromBase64String(stringData);
break;
case SerializationFormat.Hex:
dataBuffer = Converters.GeneralConverters.HexStringToByteArray(stringData);
break;
}
return(this.DeserializeObjectDataInternal(dataBuffer));
}
/// <summary>
/// Deserializes the string representation from persistence into an instance
/// </summary>
/// <typeparam name="T">The type of object being deserialized</typeparam>
/// <param name="serializedData">The data to be deserialized</param>
/// <param name="defaultValue">A default value should the data be undefined</param>
/// <param name="format">The format of serialization to perform</param>
/// <returns></returns>
public static T Deserialize <T>(string serializedData, T defaultValue,
SerializationFormat format = SerializationFormat.Json)
{
if (format != SerializationFormat.Json)
{
throw new NotImplementedException();
}
T result = default(T);
WithinJsonScope(() =>
{
result = (serializedData.HasValue())
? JsonSerializer.DeserializeFromString <T>(serializedData)
: defaultValue;
});
return(result);
}
public static Stream SerializeSystemBooleanArray(bool[] objs, SerializationFormat serializationFormat, WebMessageFormat webMessageFormat)
{
if (IsXml(serializationFormat, webMessageFormat))
{
var root = new XElement(XName.Get("BooleanArray"));
var xDocument = new XDocument(root);
foreach (var obj in objs)
{
var child = new XElement(XName.Get("Boolean"));
child.Add(XmlConvert.ToString(obj));
}
var stream = GetStream(xDocument);
return stream;
}
else
{
return GetStream(objs.ToJsonString());
}
}
private static void RunVerification <T>(
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat,
RoundtripSerializationVerification <T> verificationCallback,
AppDomainScenarios appDomainScenario,
string serializedPayload,
T deserializedObject)
{
new { verificationCallback }.AsArg().Must().NotBeNull();
try
{
verificationCallback(serializedPayload, serializationFormat, deserializedObject);
}
catch (Exception ex)
{
throw new InvalidOperationException(Invariant($"Failed to roundtrip specified object to/from {serializerRepresentation.SerializationKind} {serializationFormat} using {serializerRepresentation.SerializationConfigType.ResolveFromLoadedTypes().ToStringReadable()} with the App Domain Scenario '{appDomainScenario}'. Serialized payload is: {serializedPayload}. Deserialized object is: {deserializedObject}."), ex);
}
}
public void Run(AmfFile file, string newName, SerializationFormat format)
{
switch (format)
{
case SerializationFormat.Slot:
WriteStandardFile(file, newName);
break;
case SerializationFormat.Exported:
WritePlainDataFile(file);
break;
default:
throw new NotImplementedException();
}
// Flush
_writer.Flush();
}
/// <summary>
/// Serializes an <see cref="Object"/>.
/// </summary>
/// <typeparam name="T"><see cref="Type"/> of the <paramref name="serializableObject"/>.</typeparam>
/// <param name="serializableObject"><see cref="Object"/> to be serialized.</param>
/// <param name="serializationFormat"><see cref="SerializationFormat"/> in which the <paramref name="serializableObject"/> is to be serialized.</param>
/// <returns>An <see cref="Array"/> of <see cref="Byte"/> of the serialized <see cref="Object"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="serializableObject"/> is null.</exception>
/// <exception cref="NotSupportedException">Specified <paramref name="serializationFormat"/> is not supported.</exception>
public static byte[] Serialize <T>(T serializableObject, SerializationFormat serializationFormat)
{
Stream stream = null;
try
{
stream = new MemoryStream();
Serialize(serializableObject, serializationFormat, ref stream);
return(stream.ReadStream());
}
finally
{
if ((object)stream != null)
{
stream.Dispose();
}
}
}
private void SetDataSetSize()
{
SerializationFormat remotingFormat = this.dsVisualizacao.RemotingFormat;
this.dsVisualizacao.RemotingFormat = SerializationFormat.Binary;
try
{
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, this.dsVisualizacao);
DataSetSize = $"Size: {((double)memoryStream.Length / 1024.0).ToString("N")} KB";
}
}
finally
{
this.dsVisualizacao.RemotingFormat = remotingFormat;
}
}
/// <summary>
/// Сериализаует объект в заданном формате в заданный поток
/// </summary>
/// <param name="value">сериализуемый объект</param>
/// <param name="format">формат</param>
/// <param name="output">целевой поток</param>
/// <param name="objectname">имя для сериализуемого объекта</param>
/// <param name="options">Опции сериализации</param>
public static void SerializeToFormat(this object value, SerializationFormat format, TextWriter output,
string objectname = DefaultObjectName, string usermode = "", object options = null)
{
if (null == output)
{
throw new SerializationException("output not given");
}
var serializer =
#if EMBEDQPT
sfactory.GetSerializer(format);
#else
Applications.Application.Current.Serialization.GetSerializer(format);
#endif
if (string.IsNullOrWhiteSpace(objectname))
{
objectname = DefaultObjectName;
}
serializer.Serialize(objectname, value, output, usermode);
}
public XmlSerializationWriterInterpreter (XmlMapping typeMap)
{
_typeMap = typeMap;
_format = typeMap.Format;
}
private void Write(string path, SerializationFormat format, string name)
{
EnsureDeleted(path);
using (var stream = File.Create(path))
{
using (var writer = new AmfWriter(stream))
{
writer.Run(this, name, format);
stream.Flush();
stream.Close();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceHelper"/> class.
/// </summary>
public ServiceHelper()
{
m_telnetSessionPassword = "******";
m_logStatusUpdates = DefaultLogStatusUpdates;
m_maxStatusUpdatesLength = DefaultMaxStatusUpdatesLength;
m_maxStatusUpdatesFrequency = DefaultMaxStatusUpdatesFrequency;
m_monitorServiceHealth = DefaultMonitorServiceHealth;
m_healthMonitorInterval = DefaultHealthMonitorInterval;
m_requestHistoryLimit = DefaultRequestHistoryLimit;
m_supportFileManagementCommands = DefaultSupportFileManagementCommands;
m_supportTelnetSessions = DefaultSupportTelnetSessions;
m_supportSystemCommands = DefaultSupportSystemCommands;
m_secureRemoteInteractions = DefaultSecureRemoteInteractions;
m_serializationFormat = DefaultSerializationFormat;
m_persistSettings = DefaultPersistSettings;
m_settingsCategory = DefaultSettingsCategory;
m_processes = new List<ServiceProcess>();
m_remoteClients = new List<ClientInfo>();
m_clientRequestHistory = new List<ClientRequestInfo>();
m_serviceComponents = new List<object>();
m_clientRequestHandlers = new List<ClientRequestHandler>();
m_componentEnabledStates = new Dictionary<ISupportLifecycle, bool>();
m_clientStatusUpdateLookup = new Dictionary<Guid, ClientStatusUpdateConfiguration>();
m_threadScheduler = new LogicalThreadScheduler();
m_threadScheduler.UnhandledException += LogicalThread_ProcessException;
m_statusUpdateThread = m_threadScheduler.CreateThread(2);
m_statusUpdateQueue = new List<StatusUpdate>();
// Components
m_statusLog = new LogFile();
m_statusLog.FileName = "StatusLog.txt";
m_statusLog.SettingsCategory = "StatusLog";
m_statusLog.LogException += StatusLog_LogException;
m_processScheduler = new ScheduleManager();
m_processScheduler.SettingsCategory = "ProcessScheduler";
m_processScheduler.ScheduleDue += Scheduler_ScheduleDue;
m_errorLogger = new ErrorLogger();
m_errorLogger.ExitOnUnhandledException = false;
m_errorLogger.SettingsCategory = "ErrorLogger";
m_errorLogger.ErrorLog.SettingsCategory = "ErrorLog";
m_errorLogger.LoggingException += ErrorLogger_LoggingException;
}
public bool CanBeSaved(SerializationFormat format)
{
try
{
using (var stream = new MemoryStream())
{
using (var writer = new AmfWriter(stream))
{
writer.Run(this, "Test", format);
stream.Flush();
stream.Close();
}
}
}
catch (Exception)
{
return false;
}
return true;
}
public void Save(string path, SerializationFormat format)
{
// Delete existing file
var name = Path.GetFileNameWithoutExtension(path);
// Write it to a temporary file, then move it.
try
{
var tempPath = Path.GetTempFileName();
Write(tempPath, format, name);
EnsureDeleted(path);
File.Move(tempPath, path);
}
// If this fails (no temporary folder access?), save directly
catch (UnauthorizedAccessException)
{
Write(path, format, name);
}
catch (SecurityException)
{
Write(path, format, name);
}
catch (IOException)
{
Write(path, format, name);
}
}
//*******************************************************
// Writer generation
//
public void GenerateWriter (string writerClassName, ArrayList maps)
{
_mapsToGenerate = new ArrayList ();
InitHooks ();
if (_config == null || !_config.GenerateAsInternal)
WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
else
WriteLine ("internal class " + writerClassName + " : XmlSerializationWriter");
WriteLineInd ("{");
WriteLine ("const string xmlNamespace = \"http://www.w3.org/2000/xmlns/\";");
// ToBinHexString() is not public, so use reflection here.
WriteLine ("static readonly System.Reflection.MethodInfo toBinHexStringMethod = typeof (XmlConvert).GetMethod (\"ToBinHexString\", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (byte [])}, null);");
WriteLine ("static string ToBinHexString (byte [] input)");
WriteLineInd ("{");
WriteLine ("return input == null ? null : (string) toBinHexStringMethod.Invoke (null, new object [] {input});");
WriteLineUni ("}");
for (int n=0; n<maps.Count; n++)
{
GenerationResult res = (GenerationResult) maps [n];
_typeMap = res.Mapping;
_format = _typeMap.Format;
_result = res;
GenerateWriteRoot ();
}
for (int n=0; n<_mapsToGenerate.Count; n++)
{
XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
GenerateWriteObject (map);
if (map.TypeData.SchemaType == SchemaTypes.Enum)
GenerateGetXmlEnumValue (map);
}
GenerateWriteInitCallbacks ();
UpdateGeneratedTypes (_mapsToGenerate);
WriteLineUni ("}");
}
internal CacheControllerBehavior()
{
this._userSession = new SessionInfo();
this._knownTypes = new List<EntityType>();
this._serFormat = SerializationFormat.ODataAtom;
this._scopeParameters = new Dictionary<string, string>();
}
//*******************************************************
// Reader generation
//
public void GenerateReader (string readerClassName, ArrayList maps)
{
if (_config == null || !_config.GenerateAsInternal)
WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
else
WriteLine ("internal class " + readerClassName + " : XmlSerializationReader");
WriteLineInd ("{");
// FromBinHexString() is not public, so use reflection here.
WriteLine ("static readonly System.Reflection.MethodInfo fromBinHexStringMethod = typeof (XmlConvert).GetMethod (\"FromBinHexString\", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (string)}, null);");
WriteLine ("static byte [] FromBinHexString (string input)");
WriteLineInd ("{");
WriteLine ("return input == null ? null : (byte []) fromBinHexStringMethod.Invoke (null, new object [] {input});");
WriteLineUni ("}");
_mapsToGenerate = new ArrayList ();
_fixupCallbacks = new ArrayList ();
InitHooks ();
for (int n=0; n<maps.Count; n++)
{
GenerationResult res = (GenerationResult) maps [n];
_typeMap = res.Mapping;
_format = _typeMap.Format;
_result = res;
GenerateReadRoot ();
}
for (int n=0; n<_mapsToGenerate.Count; n++)
{
XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
if (map == null) continue;
GenerateReadObject (map);
if (map.TypeData.SchemaType == SchemaTypes.Enum)
GenerateGetEnumValueMethod (map);
}
GenerateReadInitCallbacks ();
if (_format == SerializationFormat.Encoded)
{
GenerateFixupCallbacks ();
GenerateFillerCallbacks ();
}
WriteLineUni ("}");
UpdateGeneratedTypes (_mapsToGenerate);
}
// Serialize the table schema and data.
private void SerializeDataTable(SerializationInfo info, StreamingContext context, bool isSingleTable, SerializationFormat remotingFormat) {
info.AddValue("DataTable.RemotingVersion", new Version(2, 0));
// SqlHotFix 299, SerializationFormat enumeration types don't exist in V1.1 SP1
if (SerializationFormat.Xml != remotingFormat) {
info.AddValue("DataTable.RemotingFormat", remotingFormat);
}
if (remotingFormat != SerializationFormat.Xml) {//Binary
SerializeTableSchema(info, context, isSingleTable);
if (isSingleTable) {
SerializeTableData(info, context, 0);
}
} else {//XML/V1.0/V1.1
string tempDSNamespace = "";
Boolean fCreatedDataSet = false;
if (dataSet == null) {
DataSet ds = new DataSet("tmpDataSet");
// if user set values on DataTable, it isn't necessary
// to set them on the DataSet because they won't be inherited
// but it is simpler to set them in both places
// if user did not set values on DataTable, it is required
// to set them on the DataSet so the table will inherit
// the value already on the Datatable
ds.SetLocaleValue(_culture, _cultureUserSet);
ds.CaseSensitive = this.CaseSensitive;
ds.namespaceURI = this.Namespace;
Debug.Assert(ds.RemotingFormat == SerializationFormat.Xml, "RemotingFormat must be SerializationFormat.Xml");
ds.Tables.Add(this);
fCreatedDataSet = true;
} else {
tempDSNamespace = this.DataSet.Namespace;
this.DataSet.namespaceURI = this.Namespace; //this.DataSet.Namespace = this.Namespace; ??
}
info.AddValue(KEY_XMLSCHEMA, dataSet.GetXmlSchemaForRemoting(this));
info.AddValue(KEY_XMLDIFFGRAM, dataSet.GetRemotingDiffGram(this));
if (fCreatedDataSet) {
dataSet.Tables.Remove(this);
}
else{
dataSet.namespaceURI = tempDSNamespace;
}
}
}
private void DeserializeDataSetData(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat)
{
if (remotingFormat != SerializationFormat.Xml)
{
for (int i = 0; i < this.Tables.Count; i++)
{
this.Tables[i].DeserializeTableData(info, context, i);
}
}
else
{
string s = (string) info.GetValue("XmlDiffGram", typeof(string));
if (s != null)
{
this.ReadXml(new XmlTextReader(new StringReader(s)), XmlReadMode.DiffGram);
}
}
}
private void DeserializeDataSetSchema(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat, System.Data.SchemaSerializationMode schemaSerializationMode)
{
if (remotingFormat != SerializationFormat.Xml)
{
if (schemaSerializationMode == System.Data.SchemaSerializationMode.IncludeSchema)
{
this.DeserializeDataSetProperties(info, context);
int num4 = info.GetInt32("DataSet.Tables.Count");
for (int i = 0; i < num4; i++)
{
byte[] buffer = (byte[]) info.GetValue(string.Format(CultureInfo.InvariantCulture, "DataSet.Tables_{0}", new object[] { i }), typeof(byte[]));
MemoryStream serializationStream = new MemoryStream(buffer) {
Position = 0L
};
BinaryFormatter formatter = new BinaryFormatter(null, new StreamingContext(context.State, false));
DataTable table = (DataTable) formatter.Deserialize(serializationStream);
this.Tables.Add(table);
}
for (int j = 0; j < num4; j++)
{
this.Tables[j].DeserializeConstraints(info, context, j, true);
}
this.DeserializeRelations(info, context);
for (int k = 0; k < num4; k++)
{
this.Tables[k].DeserializeExpressionColumns(info, context, k);
}
}
else
{
this.DeserializeDataSetProperties(info, context);
}
}
else
{
string s = (string) info.GetValue("XmlSchema", typeof(string));
if (s != null)
{
this.ReadXmlSchema(new XmlTextReader(new StringReader(s)), true);
}
}
}
protected CacheRequestHandler(Uri baseUri, SerializationFormat format, string scopeName)
{
this._baseUri = baseUri;
this._serializationFormat = format;
this._scopeName = scopeName;
}
/// <devdoc>
/// Internal method for setting the DataSet pointer.
/// </devdoc>
internal void SetDataSet(DataSet dataSet) {
if (this.dataSet != dataSet) {
this.dataSet = dataSet;
// Inform all the columns of the dataset being set.
DataColumnCollection cols = Columns;
for (int i = 0; i < cols.Count; i++)
cols[i].OnSetDataSet();
if (this.DataSet != null) {
defaultView = null;
}
//Set the remoting format variable directly
if (dataSet != null) {
_remotingFormat = dataSet.RemotingFormat;
}
}
}
private void SerializeDataSet(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat)
{
info.AddValue("DataSet.RemotingVersion", new Version(2, 0));
if (remotingFormat != SerializationFormat.Xml)
{
info.AddValue("DataSet.RemotingFormat", remotingFormat);
}
if (System.Data.SchemaSerializationMode.IncludeSchema != this.SchemaSerializationMode)
{
info.AddValue("SchemaSerializationMode.DataSet", this.SchemaSerializationMode);
}
if (remotingFormat != SerializationFormat.Xml)
{
if (this.SchemaSerializationMode == System.Data.SchemaSerializationMode.IncludeSchema)
{
this.SerializeDataSetProperties(info, context);
info.AddValue("DataSet.Tables.Count", this.Tables.Count);
for (int j = 0; j < this.Tables.Count; j++)
{
BinaryFormatter formatter = new BinaryFormatter(null, new StreamingContext(context.State, false));
MemoryStream serializationStream = new MemoryStream();
formatter.Serialize(serializationStream, this.Tables[j]);
serializationStream.Position = 0L;
info.AddValue(string.Format(CultureInfo.InvariantCulture, "DataSet.Tables_{0}", new object[] { j }), serializationStream.GetBuffer());
}
for (int k = 0; k < this.Tables.Count; k++)
{
this.Tables[k].SerializeConstraints(info, context, k, true);
}
this.SerializeRelations(info, context);
for (int m = 0; m < this.Tables.Count; m++)
{
this.Tables[m].SerializeExpressionColumns(info, context, m);
}
}
else
{
this.SerializeDataSetProperties(info, context);
}
for (int i = 0; i < this.Tables.Count; i++)
{
this.Tables[i].SerializeTableData(info, context, i);
}
}
else
{
string xmlSchemaForRemoting = this.GetXmlSchemaForRemoting(null);
string str = null;
info.AddValue("XmlSchema", xmlSchemaForRemoting);
StringBuilder sb = new StringBuilder(this.EstimatedXmlStringSize() * 2);
StringWriter w = new StringWriter(sb, CultureInfo.InvariantCulture);
XmlTextWriter writer = new XmlTextWriter(w);
this.WriteXml(writer, XmlWriteMode.DiffGram);
str = w.ToString();
info.AddValue("XmlDiffGram", str);
}
}
// Deserialize the table schema and data.
internal void DeserializeDataTable(SerializationInfo info, StreamingContext context, bool isSingleTable, SerializationFormat remotingFormat) {
if (remotingFormat != SerializationFormat.Xml) {//Binary
DeserializeTableSchema(info, context, isSingleTable);
if (isSingleTable) {
DeserializeTableData(info, context, 0);
this.ResetIndexes();
}
} else {//XML/V1.0/V1.1
string strSchema = (String)info.GetValue(KEY_XMLSCHEMA, typeof(System.String));
string strData = (String)info.GetValue(KEY_XMLDIFFGRAM, typeof(System.String));
if (strSchema != null) {
DataSet ds = new DataSet();
// fxcop: ReadXmlSchema will provide the CaseSensitive, Locale, Namespace information
ds.ReadXmlSchema(new XmlTextReader( new StringReader( strSchema ) ) );
Debug.Assert(ds.Tables.Count == 1, "There should be exactly 1 table here");
DataTable table = ds.Tables[0];
table.CloneTo(this, null, false);// WebData 111656
//this is to avoid the cascading rules in the namespace
this.Namespace = table.Namespace;
if (strData != null) {
ds.Tables.Remove(ds.Tables[0]);
ds.Tables.Add(this);
ds.ReadXml(new XmlTextReader( new StringReader( strData ) ), XmlReadMode.DiffGram);
ds.Tables.Remove(this);
}
}
}
}
internal void DeserializeDataSet(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat, System.Data.SchemaSerializationMode schemaSerializationMode)
{
this.DeserializeDataSetSchema(info, context, remotingFormat, schemaSerializationMode);
this.DeserializeDataSetData(info, context, remotingFormat);
}
