/// <summary>
/// Creates the metadata required to serialize the <paramref name="structType" />.
/// </summary>
/// <param name="structType">The type of the struct the metadata should be created for.</param>
/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
public static IEnumerable <StateSlotMetadata> FromStruct(Type structType, SerializationMode mode)
{
Requires.NotNull(structType, nameof(structType));
Requires.That(structType.IsStructType(), "Expected a value type.");
return(FromStruct(structType, mode, new FieldInfo[0]));
}
internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
this.mode = SerializationMode.SharedContract;
this.preserveObjectReferences = serializer.PreserveObjectReferences;
this.dataContractSurrogate = serializer.DataContractSurrogate;
}
/// <summary>
/// Encodes a generic.
/// </summary>
public static string Encode(object value, SerializationMode mode)
{
var sb = new StringBuilder();
Encode(sb, value, mode);
return(sb.ToString());
}
public static void ObjectToStream <TItem>(TItem obj, Stream stream, SerializationMode mode, bool compress)
{
if (mode == SerializationMode.Json)
{
if (compress)
{
using (var outZStream = new GZipOutputStream(stream)
{
IsStreamOwner = false
})
{
var writer = new JsonTextWriter(new StreamWriter(outZStream));
Serializer.Serialize(writer, obj);
writer.Flush();
}
}
else
{
var writer = new JsonTextWriter(new StreamWriter(stream));
Serializer.Serialize(writer, obj);
writer.Flush();
}
}
else
{
ProtoBuf.Serializer.SerializeWithLengthPrefix(stream, obj, PrefixStyle.Fixed32);
}
}
internal static object Deserialize(string serializedValue, SerializationMode mode, IMachineKey machineKey)
{
if (String.IsNullOrEmpty(serializedValue))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "serializedValue");
}
MachineKeyProtection protectionMode = GetMachineKeyProtectionMode(mode);
try
{
// First, need to decrypt / verify data
byte[] rawBytes = machineKey.Decode(serializedValue, protectionMode);
// Next, verify magic header
if (!ArrayContainsMagicHeader(rawBytes))
{
throw new SerializationException(MvcResources.MvcSerializer_MagicHeaderCheckFailed);
}
// Finally, deserialize the object graph
using (MemoryStream ms = new MemoryStream(rawBytes, _magicHeader.Length, rawBytes.Length - _magicHeader.Length))
{
return(DeserializeGraph(ms));
}
}
catch (Exception ex)
{
throw CreateSerializationException(ex);
}
}
private static MvcHtmlString SerializeInternal(HtmlHelper htmlHelper, string name, object data, SerializationMode mode, bool useViewData, MvcSerializer serializer)
{
if (htmlHelper == null)
{
throw new ArgumentNullException("htmlHelper");
}
if (String.IsNullOrEmpty(name))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
}
name = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
if (useViewData)
{
data = htmlHelper.ViewData.Eval(name);
}
string serializedData = (serializer ?? new MvcSerializer()).Serialize(data, mode);
TagBuilder builder = new TagBuilder("input");
builder.Attributes["type"] = "hidden";
builder.Attributes["name"] = name;
builder.Attributes["value"] = serializedData;
return MvcHtmlString.Create(builder.ToString(TagRenderMode.SelfClosing));
}
internal static object Deserialize(string serializedValue, SerializationMode mode, IMachineKey machineKey) {
if (String.IsNullOrEmpty(serializedValue)) {
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "serializedValue");
}
MachineKeyProtection protectionMode = GetMachineKeyProtectionMode(mode);
try {
// First, need to decrypt / verify data
byte[] rawBytes = machineKey.Decode(serializedValue, protectionMode);
// Next, verify magic header
if (!ArrayContainsMagicHeader(rawBytes)) {
throw new SerializationException(MvcResources.MvcSerializer_MagicHeaderCheckFailed);
}
// Finally, deserialize the object graph
using (MemoryStream ms = new MemoryStream(rawBytes, _magicHeader.Length, rawBytes.Length - _magicHeader.Length)) {
return DeserializeGraph(ms);
}
}
catch (Exception ex) {
throw CreateSerializationException(ex);
}
}
internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
this.mode = SerializationMode.SharedContract;
this.preserveObjectReferences = serializer.PreserveObjectReferences;
this.dataContractSurrogate = serializer.DataContractSurrogate;
}
internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
_mode = SerializationMode.SharedContract;
_preserveObjectReferences = serializer.PreserveObjectReferences;
_serializationSurrogateProvider = serializer.SerializationSurrogateProvider;
}
internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
_mode = SerializationMode.SharedContract;
_preserveObjectReferences = serializer.PreserveObjectReferences;
_serializationSurrogateProvider = serializer.SerializationSurrogateProvider;
}
public static IKafkaProducer GetProducer(string topic,
TableSchema tableSchema,
SerializationMode serializationMode,
bool sendWithKey,
string kafkaBootstrapServers,
string schemaRegistryUrl)
{
if (serializationMode == SerializationMode.Avro)
{
var avroSchema = AvroSchemaGenerator.GenerateSchema("CdcToRedshift", tableSchema);
if (sendWithKey)
{
return(new KeyedAvroProducer(kafkaBootstrapServers, schemaRegistryUrl, topic, new AvroTableTypeConverter(avroSchema), tableSchema));
}
else
{
return(new NonKeyedAvroProducer(kafkaBootstrapServers, schemaRegistryUrl, topic, new AvroTableTypeConverter(avroSchema), tableSchema));
}
}
else
{
if (sendWithKey)
{
return(new KeyedJsonProducer(kafkaBootstrapServers, topic));
}
else
{
return(new NonKeyedJsonProducer(kafkaBootstrapServers, topic));
}
}
}
public static TItem ObjectFromBytes <TItem>(byte[] bytes, SerializationMode mode, bool compress)
{
var stream = new MemoryStream(bytes);
if (mode == SerializationMode.Json)
{
string json;
if (compress)
{
using (var zInStream = new GZipInputStream(stream))
{
var reader = new BinaryReader(zInStream);
json = reader.ReadString();
}
}
else
{
var reader = new BinaryReader(stream);
json = reader.ReadString();
}
return(JsonConvert.DeserializeObject <TItem>(json, JsonSettings()));
}
return(Serializer.DeserializeWithLengthPrefix <TItem>(stream, PrefixStyle.Fixed32));
}
public bool SaveContents(JsonTextWriter tw, object o, SerializationMode mode, SerializationVisitTracker visits)
{
if (visits.Objects.Contains(o))
{
return(true);
}
bool include = true;
if ((mode & SerializationMode.OnlyChanged) != 0)
{
// Point of this? if we have object graph a->b->c, if c is modified, both a and b need to be included even if unmodified to support proper hierarchy
include = RequiresPersistenceForChanges(o, mode, new ConcurrentDictionary <object, bool>(Globals.DefaultCollectionConcurrencyLevel, Globals.DefaultDictionaryCapacity));
}
if (include)
{
WriteSerializationText(tw, o, mode, visits);
}
visits.Objects.Add(o);
var wot = o.AsInfraWrapped()?.GetWrappedObject()?.GetType() ?? o.GetBaseType();
if (!visits.Types.Contains(wot))
{
visits.Types.Add(wot);
}
return(include);
}
public static void ObjectToStream <TItem>(TItem obj, Stream stream, SerializationMode mode, bool compress)
{
if (mode == SerializationMode.Json)
{
var json = JsonConvert.SerializeObject(obj, JsonSettings());
if (compress)
{
var outZStream = new GZipOutputStream(stream);
var writer = new BinaryWriter(outZStream);
writer.Write(json);
outZStream.Flush();
outZStream.Finish();
}
else
{
var writer = new BinaryWriter(stream);
writer.Write(json);
}
}
else
{
Serializer.SerializeWithLengthPrefix(stream, obj, PrefixStyle.Fixed32);
}
}
public static byte[] ObjectToBytes <TItem>(TItem obj, SerializationMode mode, TypeDescription typeDescription)
{
using (var output = new MemoryStream())
{
if (mode == SerializationMode.Json)
{
var json = ObjectToJson(obj, typeDescription);
if (typeDescription.UseCompression)
{
using (var outZStream = new GZipOutputStream(output))
{
var writer = new BinaryWriter(outZStream);
writer.Write(json);
outZStream.Flush();
outZStream.Finish();
}
}
else
{
var writer = new BinaryWriter(output);
writer.Write(json);
}
}
else
{
Serializer.SerializeWithLengthPrefix(output, obj, PrefixStyle.Fixed32);
}
return(output.ToArray());
}
}
/// <summary>
/// Generates the state slot metadata for the <paramref name="obj" />.
/// </summary>
/// <param name="obj">The object the state slot metadata should be generated for.</param>
/// <param name="objectIdentifier">The identifier of the <paramref name="obj" />.</param>
/// <param name="mode">The serialization mode that should be used to generate the metadata.</param>
protected internal override IEnumerable<StateSlotMetadata> GetStateSlotMetadata(object obj, int objectIdentifier, SerializationMode mode)
{
foreach (var field in GetFields(obj, mode))
{
if (field.FieldType.IsStructType())
{
foreach (var metadataSlot in StateSlotMetadata.FromStruct(field.FieldType, mode))
{
metadataSlot.Object = obj;
metadataSlot.ObjectIdentifier = objectIdentifier;
metadataSlot.ObjectType = obj.GetType();
metadataSlot.ElementCount = 1;
metadataSlot.Field = field;
yield return metadataSlot;
}
}
else
{
yield return new StateSlotMetadata
{
Object = obj,
ObjectType = obj.GetType(),
ObjectIdentifier = objectIdentifier,
DataType = field.FieldType,
Field = field,
ElementCount = 1
};
}
}
}
internal void Serialize(ClassMapping mapping, object instance, bool summary, SerializationMode mode = SerializationMode.AllMembers)
{
if (mapping == null)
{
throw Error.ArgumentNull("mapping");
}
_current.WriteStartComplexContent();
// Emit members that need xml /attributes/ first (to facilitate stream writer API)
foreach (var prop in mapping.PropertyMappings.Where(pm => pm.SerializationHint == XmlSerializationHint.Attribute))
{
if (!summary || prop.InSummary)
{
write(mapping, instance, summary, prop, mode);
}
}
// Then emit the rest
foreach (var prop in mapping.PropertyMappings.Where(pm => pm.SerializationHint != XmlSerializationHint.Attribute))
{
if (!summary || prop.InSummary)
{
write(mapping, instance, summary, prop, mode);
}
}
_current.WriteEndComplexContent();
}
/// <summary>
/// Generates the state slot metadata for the <paramref name="obj" />.
/// </summary>
/// <param name="obj">The object the state slot metadata should be generated for.</param>
/// <param name="objectIdentifier">The identifier of the <paramref name="obj" />.</param>
/// <param name="mode">The serialization mode that should be used to generate the metadata.</param>
protected internal override IEnumerable<StateSlotMetadata> GetStateSlotMetadata(object obj, int objectIdentifier, SerializationMode mode)
{
Requires.That(((Array)obj).Rank == 1 && !obj.GetType().GetElementType().IsArray, "Multidimensional arrays are not supported.");
var elementType = obj.GetType().GetElementType();
var length = ((Array)obj).GetLength(0);
if (elementType.IsStructType())
{
foreach (var metadataSlot in StateSlotMetadata.FromStruct(elementType, mode))
{
metadataSlot.Object = obj;
metadataSlot.ObjectIdentifier = objectIdentifier;
metadataSlot.ObjectType = obj.GetType();
metadataSlot.ElementCount = length;
yield return metadataSlot;
}
}
else
{
yield return new StateSlotMetadata
{
Object = obj,
ObjectIdentifier = objectIdentifier,
ObjectType = obj.GetType(),
DataType = obj.GetType().GetElementType(),
ElementCount = length
};
}
}
private void Set(string key, object value, Type targetType = null, SerializationMode serializationMode = SerializationMode.Xml)
{
if (targetType == null)
{
if (value is int && (int)value == 0)
{
value = false;
targetType = typeof(bool);
}
else if (value is int && (int)value == 1)
{
value = true;
targetType = typeof(bool);
}
else
{
targetType = ConvertSettingsType(Check.TryCatch <SettingsType, Exception>(() => settingsStore.GetPropertyType(collectionPath, key)), value?.GetType());
}
}
if (targetType.IsEnum)
{
targetType = typeof(int);
}
if (targetType == typeof(bool))
{
settingsStore.SetBoolean(collectionPath, key, Convert.ToBoolean(value));
}
else if (targetType == typeof(string))
{
var s = value?.ToString() ?? string.Empty;
settingsStore.SetString(collectionPath, key, s);
}
else if (targetType == typeof(int))
{
settingsStore.SetInt32(collectionPath, key, Convert.ToInt32(value));
}
else
{
using (var ms = new MemoryStream())
{
if (serializationMode == SerializationMode.Binary)
{
var serializer = new BinaryFormatter();
serializer.Serialize(ms, value);
ms.Position = 0;
settingsStore.SetMemoryStream(collectionPath, key, ms);
}
else if (serializationMode == SerializationMode.Xml)
{
var serializer = new XmlSerializer(targetType);
serializer.Serialize(ms, value);
string xmlContent = Encoding.UTF8.GetString(ms.ToArray());
settingsStore.SetString(collectionPath, key, xmlContent);
}
}
}
}
internal XmlObjectSerializerReadContextComplex(NetDataContractSerializer serializer) : base(serializer)
{
this.mode = SerializationMode.SharedType;
this.preserveObjectReferences = true;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.assemblyFormat = serializer.AssemblyFormat;
}
private static void Set(SerializationMode serializationMode)
{
Log($"{nameof(SetSerializationMode)}.{serializationMode}");
EditorSettings.serializationMode = serializationMode;
Quit(EditorSettings.serializationMode == serializationMode);
}
/// <summary>
/// Loads the object from a file using a specific formatting.
/// </summary>
/// <typeparam name="T">Type of the object that should be loaded.</typeparam>
/// <param name="fileName">Filename of the file that contains the serialized data of this object.</param>
/// <param name="mode"><see cref="SerializationMode" /> to use.</param>
/// <returns>Deserialized instance of the object. If the deserialization fails, <c>null</c> is returned.</returns>
/// <remarks>When enableRedirects is enabled, loading will take more time. Only set
/// the parameter to <c>true</c> when the deserialization without redirects fails.</remarks>
public static T Load <T>(string fileName, SerializationMode mode)
where T : class
{
using (Stream stream = new FileStream(fileName, FileMode.Open))
{
return(Load <T>(stream, mode));
}
}
public SerializationCallbackInvokationExpressionEmitter(SerializationMode mode)
{
if (!Enum.IsDefined(typeof(SerializationMode), mode))
{
throw new InvalidEnumArgumentException(nameof(mode), (int)mode, typeof(SerializationMode));
}
Mode = mode;
}
private static IStateFormatter GetFormatter(SerializationMode mode)
{
Func<IStateFormatter> formatterFactory;
if (!_factories.TryGetValue(mode, out formatterFactory))
throw Error.InvalidModelStateSerializationMode(mode);
return formatterFactory();
}
public static T JsonDeserializeFromPath <T>(
string filePath,
SerializationMode serializationMode = SerializationMode.Compact)
{
var text = File.ReadAllText(filePath);
return(JsonDeserializeWithSettings <T>(text, serializationMode));
}
/// <summary>
/// Loads the object from a file using a specific formatting.
/// </summary>
/// <typeparam name="T">Type of the object that should be loaded.</typeparam>
/// <param name="fileName">Filename of the file that contains the serialized data of this object.</param>
/// <param name="mode"><see cref="SerializationMode"/> to use.</param>
/// <param name="enableRedirects">if set to <c>true</c>, redirects will be enabled.</param>
/// <returns>
/// Deserialized instance of the object. If the deserialization fails, <c>null</c> is returned.
/// </returns>
/// <remarks>
/// When enableRedirects is enabled, loading will take more time. Only set
/// the parameter to <c>true</c> when the deserialization without redirects fails.
/// </remarks>
public static T Load <T>(string fileName, SerializationMode mode, bool enableRedirects = false)
where T : class
{
using (Stream stream = new FileStream(fileName, FileMode.Open))
{
return(Load <T>(stream, mode, enableRedirects));
}
}
private SerializationWriter(Stream stream, SerializationMode mode, Encoding encoding)
{
_stream = stream ?? new MemoryStream(512);
_encoding = encoding ?? new UTF8Encoding();
_serializeAll = (mode | SerializationMode.SerializeAll) == SerializationMode.SerializeAll;
_includePropertyNames = (mode | SerializationMode.IncludePropertyNames) == SerializationMode.IncludePropertyNames;
Write((byte)mode);
}
private static IStateFormatter GetFormatter(SerializationMode mode) {
Func<IStateFormatter> formatterFactory;
if (!_registeredFormatterFactories.TryGetValue(mode, out formatterFactory)) {
throw new ArgumentOutOfRangeException("mode", MvcResources.MvcSerializer_InvalidSerializationMode);
}
return formatterFactory();
}
public static Vector4 Serialize(Stream stream, SerializationMode mode, ref Vector4 value)
{
value.x = Serialize(stream, mode, ref value.x);
value.y = Serialize(stream, mode, ref value.y);
value.z = Serialize(stream, mode, ref value.z);
value.w = Serialize(stream, mode, ref value.w);
return(value);
}
internal XmlObjectSerializerReadContextComplex(NetDataContractSerializer serializer) : base(serializer)
{
this.mode = SerializationMode.SharedType;
this.preserveObjectReferences = true;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.assemblyFormat = serializer.AssemblyFormat;
}
public StreamManager([NotNull] Stream underlyingStream,
SerializationMode receiveMode = SerializationMode.Binary,
SerializationMode sendMode = SerializationMode.Binary)
{
UnderlyingStream = underlyingStream ?? throw new ArgumentNullException(nameof(underlyingStream));
ReceiveMode = receiveMode;
SendMode = sendMode;
}
/// <summary>
/// Attempts to clone an object via serialization
/// </summary>
public static T Clone <T>(T obj, SerializationMode mode)
{
if (obj != null)
{
byte[] oBytes = Serializer.ToBytes(obj, mode);
return((T)Serializer.FromBytes(typeof(object), oBytes, mode));
}
return(default(T));
}
public static Vector2Int Serialize(Stream stream, SerializationMode mode, ref Vector2Int value)
{
int x = value.x;
int y = value.y;
value.x = Serialize(stream, mode, ref x);
value.y = Serialize(stream, mode, ref y);
return(value);
}
internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts) : base(serializer)
{
this.mode = SerializationMode.SharedType;
base.preserveObjectReferences = true;
this.streamingContext = serializer.Context;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.surrogateDataContracts = surrogateDataContracts;
}
public FlatComplexTypeSerializationMethodBlockEmitter(SerializationMode mode, [NotNull] ITypeSymbol symbol)
{
if (!Enum.IsDefined(typeof(SerializationMode), mode))
{
throw new InvalidEnumArgumentException(nameof(mode), (int)mode, typeof(SerializationMode));
}
Mode = mode;
Symbol = symbol ?? throw new ArgumentNullException(nameof(symbol));
}
void OnInit()
{
//需要把资源文件的序列化改成明文text，这样才可以解析资源的guid
oldSerializationMode = EditorSettings.serializationMode;
if (EditorSettings.serializationMode != SerializationMode.ForceText)
{
EditorSettings.serializationMode = SerializationMode.ForceText;
}
}
public static void JsonSerializeToPath(
object value,
string filePath,
SerializationMode serializationMode = SerializationMode.Compact)
{
var text = JsonSerializeWithSettings(value, serializationMode);
File.WriteAllText(filePath, text);
}
/// <summary>
/// Gets the fields declared by the <paramref name="obj" /> that should be serialized.
/// </summary>
/// <param name="obj">The object that should be serialized.</param>
/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
/// <param name="startType">
/// The first type in <paramref name="obj" />'s inheritance hierarchy whose fields should be returned.
/// If <c>null</c>, corresponds to <paramref name="obj" />'s actual type.
/// </param>
/// <param name="inheritanceRoot">
/// The first base type of the <paramref name="obj" /> whose fields should be ignored. If
/// <c>null</c>, <see cref="object" /> is the inheritance root.
/// </param>
/// <param name="discoveringObjects">Indicates whether objects are being discovered.</param>
protected override IEnumerable<FieldInfo> GetFields(object obj, SerializationMode mode, Type startType = null, Type inheritanceRoot = null,
bool discoveringObjects = false)
{
var fields = base.GetFields(obj, mode, startType, inheritanceRoot, discoveringObjects);
if (mode == SerializationMode.Full || discoveringObjects)
return fields;
return fields.Where(field => field.Name == "_size");
}
internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts)
: base(serializer)
{
this.mode = SerializationMode.SharedType;
this.preserveObjectReferences = true;
this.streamingContext = serializer.Context;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.surrogateDataContracts = surrogateDataContracts;
}
private object ParseValue(SerializationMode mode)
{
var machine = new TypeConversionStateMachine(this, mode);
machine.Run();
Type = machine.Type;
return(machine.NewValue);
}
protected BaseSerializationStatementsBlockEmitter([NotNull] ITypeSymbol actualType, [NotNull] ISymbol member, SerializationMode mode)
{
if (!Enum.IsDefined(typeof(SerializationMode), mode))
{
throw new InvalidEnumArgumentException(nameof(mode), (int)mode, typeof(SerializationMode));
}
ActualType = actualType ?? throw new ArgumentNullException(nameof(actualType));
Member = member ?? throw new ArgumentNullException(nameof(member));
Mode = mode;
}
public ProfilePropertySettings(string name, bool readOnly, SerializationMode serializeAs, string providerName, string defaultValue, string profileType, bool allowAnonymous, string customProviderData)
{
this.Name = name;
this.ReadOnly = readOnly;
this.SerializeAs = serializeAs;
this.Provider = providerName;
this.DefaultValue = defaultValue;
this.Type = profileType;
this.AllowAnonymous = allowAnonymous;
this.CustomProviderData = customProviderData;
}
private static MachineKeyProtection GetMachineKeyProtectionMode(SerializationMode mode) {
switch (mode) {
case SerializationMode.Signed:
return MachineKeyProtection.Validation;
case SerializationMode.EncryptedAndSigned:
return MachineKeyProtection.All;
default:
// bad
throw new ArgumentOutOfRangeException("mode", MvcResources.MvcSerializer_InvalidSerializationMode);
}
}
public static ISerializer GetSerializer(SerializationMode mode)
{
switch(mode)
{
case SerializationMode.Xml:
return Serializer.Xml;
case SerializationMode.DataContractJson:
return Serializer.DataContractJson;
case SerializationMode.NewtonsoftJson:
return Serializer.NewtonsoftJson;
default:
throw new NotSupportedException();
}
}
public virtual object Deserialize(string serializedValue, SerializationMode mode) {
if (String.IsNullOrEmpty(serializedValue)) {
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "serializedValue");
}
IStateFormatter formatter = GetFormatter(mode);
try {
object deserializedValue = formatter.Deserialize(serializedValue);
return deserializedValue;
}
catch (Exception ex) {
throw CreateSerializationException(ex);
}
}
/// <summary>
/// Gets the fields declared by the <paramref name="obj" /> that should be serialized.
/// </summary>
/// <param name="obj">The object that should be serialized.</param>
/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
/// <param name="startType">
/// The first type in <paramref name="obj" />'s inheritance hierarchy whose fields should be returned.
/// If <c>null</c>, corresponds to <paramref name="obj" />'s actual type.
/// </param>
/// <param name="inheritanceRoot">
/// The first base type of the <paramref name="obj" /> whose fields should be ignored. If
/// <c>null</c>, <see cref="object" /> is the inheritance root.
/// </param>
/// <param name="discoveringObjects">Indicates whether objects are being discovered.</param>
protected override IEnumerable<FieldInfo> GetFields(object obj, SerializationMode mode,
Type startType = null,
Type inheritanceRoot = null,
bool discoveringObjects = false)
{
// Gets the fields declared by the obj that should be serialized. In full serialization mode, this only
// includes the fields declared by <paramref name="obj" /> itself, not any of the fields declared by its base types. In
// optimized mode, this includes all fields. The reason is that in optimized mode, fault effects are actually treated as
// components, whereas in full mode, they only serve to serialize the delta to their base class.
var type = ((Component)obj).FaultEffectType;
return mode == SerializationMode.Optimized
? base.GetFields(obj, mode)
: base.GetFields(obj, mode, type, type.BaseType);
}
internal void Serialize(ClassMapping mapping, object instance, bool summary, SerializationMode mode = SerializationMode.AllMembers)
{
if (mapping == null) throw Error.ArgumentNull("mapping");
_current.WriteStartComplexContent();
// Emit members that need xml /attributes/ first (to facilitate stream writer API)
foreach (var prop in mapping.PropertyMappings.Where(pm => pm.SerializationHint == XmlSerializationHint.Attribute))
if(!summary || prop.InSummary) write(mapping, instance, summary, prop, mode);
// Then emit the rest
foreach (var prop in mapping.PropertyMappings.Where(pm => pm.SerializationHint != XmlSerializationHint.Attribute))
if (!summary || prop.InSummary) write(mapping, instance, summary, prop, mode);
_current.WriteEndComplexContent();
}
/// <summary>
/// Gets all objects referenced by <paramref name="obj" /> potentially marked with the <paramref name="hidden" /> attribute.
/// </summary>
/// <param name="obj">The object the referenced objects should be returned for.</param>
/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
/// <param name="hidden">The <see cref="HiddenAttribute" /> instance, if any, the field storing <paramref name="obj" /> was marked with.</param>
protected internal override IEnumerable<object> GetReferencedObjects(object obj, SerializationMode mode, HiddenAttribute hidden)
{
// Optimization: Skip enumerables with hidden elements
if (mode == SerializationMode.Optimized && hidden?.HideElements == true)
{
// We have to make sure the objects referenced by the list are discovered nevertheless
var enumerable = obj as IEnumerable;
if (enumerable == null)
yield break;
foreach (var element in enumerable.Cast<object>().Where(item => item.GetType().IsReferenceType()))
yield return element;
}
else
yield return obj;
}
/// <summary>
/// Gets all objects referenced by <paramref name="obj" />, excluding <paramref name="obj" /> itself.
/// </summary>
/// <param name="obj">The object the referenced objects should be returned for.</param>
/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
protected internal override IEnumerable<object> GetReferencedObjects(object obj, SerializationMode mode)
{
if (mode == SerializationMode.Optimized)
yield break;
var d = (Delegate)obj;
var method = d.Method;
yield return obj.GetType();
yield return method.ReturnType;
yield return method.DeclaringType;
foreach (var parameter in method.GetParameters())
yield return parameter.GetType();
yield return new DelegateMetadata(d);
}
public static string Serialize(this HtmlHelper helper,
string name, object data, SerializationMode mode)
{
Precondition.Require(helper, () => Error.ArgumentNull("helper"));
Precondition.Defined(name, () => Error.ArgumentNull("name"));
ModelStateSerializer serializer = new ModelStateSerializer();
string elementName = helper.Context.ViewData.Template.GetHtmlElementName(name);
string value = serializer.Serialize(data ?? helper.Context.ViewData.Model, mode);
HtmlElementBuilder builder = new HtmlElementBuilder("input");
builder.Attributes["type"] = "hidden";
builder.Attributes["name"] = elementName;
builder.Attributes["value"] = value;
return builder.ToString();
}
private void write(ClassMapping mapping, object instance, bool summary, PropertyMapping prop, SerializationMode mode)
{
// Check whether we are asked to just serialize the value element (Value members of primitive Fhir datatypes)
// or only the other members (Extension, Id etc in primitive Fhir datatypes)
// Default is all
if (mode == SerializationMode.ValueElement && !prop.RepresentsValueElement) return;
if (mode == SerializationMode.NonValueElements && prop.RepresentsValueElement) return;
var value = prop.GetValue(instance);
var isEmptyArray = (value as IList) != null && ((IList)value).Count == 0;
// Message.Info("Handling member {0}.{1}", mapping.Name, prop.Name);
if (value != null && !isEmptyArray)
{
string memberName = prop.Name;
// For Choice properties, determine the actual name of the element
// by appending its type to the base property name (i.e. deceasedBoolean, deceasedDate)
if (prop.Choice == ChoiceType.DatatypeChoice)
{
memberName = determineElementMemberName(prop.Name, GetSerializationTypeForDataTypeChoiceElements(prop, value));
}
_writer.WriteStartProperty(memberName);
var writer = new DispatchingWriter(_writer);
// Now, if our writer does not use dual properties for primitive values + rest (xml),
// or this is a complex property without value element, serialize data normally
if(!_writer.HasValueElementSupport || !serializedIntoTwoProperties(prop,value))
writer.Serialize(prop, value, summary, SerializationMode.AllMembers);
else
{
// else split up between two properties, name and _name
writer.Serialize(prop,value, summary, SerializationMode.ValueElement);
_writer.WriteEndProperty();
_writer.WriteStartProperty("_" + memberName);
writer.Serialize(prop, value, summary, SerializationMode.NonValueElements);
}
_writer.WriteEndProperty();
}
}
protected void GenerateCode(SerializationMode mode, params object[] objects)
{
objects = SerializationRegistry.Default.GetReferencedObjects(objects, mode).ToArray();
var model = TestModel.InitializeModel(new DummyComponent(objects));
_objectTable = new ObjectTable(objects);
StateVectorLayout = SerializationRegistry.Default.GetStateVectorLayout(model, _objectTable, mode);
_serializer = StateVectorLayout.CreateSerializer(_objectTable);
_deserializer = StateVectorLayout.CreateDeserializer(_objectTable);
_rangeRestrictor = StateVectorLayout.CreateRangeRestrictor(_objectTable);
StateSlotCount = StateVectorLayout.SizeInBytes / 4;
StateVectorSize = StateVectorLayout.SizeInBytes;
_buffer = new MemoryBuffer();
_buffer.Resize(StateVectorSize, zeroMemory: true);
SerializedState = _buffer.Pointer;
Output.Log("{0}", StateVectorLayout);
}
public static DataSerializer GetDataSerializer(SerializationMode mode)
{
switch (mode)
{
//+ json
case SerializationMode.DataContractJson:
return new DataContractJsonDataSerializer();
//+ xml
case SerializationMode.DataContract:
return new DataContractDataSerializer();
//+ javascript
case SerializationMode.DynamicJavaScript:
return new DynamicJavaScriptDataSerializer();
}
//+
return null;
}
/// <summary>
/// 获取序列化器。
/// </summary>
/// <param name="mode">序列化器的模式。</param>
/// <returns>序列化器。</returns>
public static ISerializer GetSerializer(SerializationMode mode)
{
ISerializer serializer = null;
switch (mode)
{
case SerializationMode.XmlSerializer:
serializer = XmlSerializerWrapper.GetInstance();
break;
//case SerializationMode.DataContractSerializer:
// serializer = DataContractSerializerWrapper.GetInstance();
// break;
//case SerializationMode.NetDataContractSerializer:
// serializer = NetDataContractSerializerWrapper.GetInstance();
//break;
case SerializationMode.BinaryFormatter:
serializer = BinaryFormatterWrapper.GetInstance();
break;
default:
throw new NotSupportedException();
}
return serializer;
}
public IConfiguration SetDefaultSerializationMode(SerializationMode value)
{
_defaultSerializationMode = value;
return this;
}
void GetProfileSettingsSerializeAsAttribute (ProfileSection ps, CodeAttributeDeclarationCollection collection,
SerializationMode mode)
{
string parameter = String.Concat ("SettingsSerializeAs.", mode.ToString ());
collection.Add (
new CodeAttributeDeclaration (
"SettingsSerializeAs",
new CodeAttributeArgument (
new CodeSnippetExpression (parameter)
)
)
);
}
public DeserializingModelBinder(SerializationMode mode, MvcSerializer serializer)
{
_mode = mode;
_serializer = serializer ?? new MvcSerializer();
}
public DeserializeAttribute(SerializationMode mode)
{
Mode = mode;
}
public static string Serialize(this HtmlHelper helper,
string name, SerializationMode mode)
{
return Serialize(helper, name, null, mode);
}
public ProfilePropertySettings(string name, bool readOnly, SerializationMode serializeAs, string providerName, string defaultValue, string profileType, bool allowAnonymous, string customProviderData) {}
