/// <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) { _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); }
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) {}