/// <summary> /// Initializes a new instance of the <see cref="SerializationScope"/> class. /// </summary> /// <param name="serializer">The serializer.</param> /// <param name="configuration">The configuration.</param> public SerializationScope(ISerializer serializer, ISerializationConfiguration configuration) { Argument.IsNotNull(() => serializer); Serializer = serializer; Configuration = configuration; }
/// <summary> /// Initializes a new instance of the <see cref="SerializationScope"/> class. /// </summary> /// <param name="serializer">The serializer.</param> /// <param name="configuration">The configuration.</param> public SerializationScope(ISerializer serializer, ISerializationConfiguration configuration) { Argument.IsNotNull(() => serializer); Serializer = serializer; Configuration = configuration; }
public EventHubProducerSpecification(IEventHubHostConfiguration hostConfiguration, IHostSettings hostSettings) { _hostConfiguration = hostConfiguration; _hostSettings = hostSettings; _serializationConfiguration = new SerializationConfiguration(); _sendObservers = new SendObservable(); }
IEnumerable <IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(ISerializationConfiguration serializationConfiguration) { return(((IEnumerable)((XPBaseObject)serializationConfiguration).GetMemberValue(serializationConfiguration.GetPropertyName(x => x.SerializationGraph))). OfType <IClassInfoGraphNode>().Where( node => (node.NodeType == NodeType.Simple && node.SerializationStrategy != SerializationStrategy.DoNotSerialize) || node.NodeType != NodeType.Simple).OrderBy(graphNode => graphNode.NodeType)); }
public AttributesConverter(ISerializationConfiguration serializationConfiguration) { this.serializationConfig = serializationConfiguration; this.dateTimeAttributeMapper = new DateTimeAttributeMapper(); this.dateAttributeMapper = new DateAttributeMapper(); this.timeAttributeMapper = new TimeAttributeMapper(); }
public IEnumerable <IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(XPBaseObject theObject, string typeName) { var type = ReflectionHelper.GetType(typeName); ISerializationConfiguration configuration = GetConfiguration(theObject.Session, type); return(GetSerializedClassInfoGraphNodes(configuration)); }
public static void ConfigureSerializationServices( this Container services, ISerializationConfiguration serializationConfiguration) { services.Options.AllowOverridingRegistrations = true; services.Register(() => serializationConfiguration, Lifestyle.Singleton); }
/// <summary> /// Deserializes the specified model. /// </summary> /// <param name="model">The model.</param> /// <param name="stream">The stream.</param> /// <param name="configuration">The configuration.</param> /// <returns></returns> /// <remarks> /// When deserializing a stream, the binary serializer must use the <see cref="BinaryFormatter" /> because this will /// inject the right <see cref="SerializationInfo" /> into a new serializer. /// </remarks> public override object Deserialize(object model, Stream stream, ISerializationConfiguration configuration) { Argument.IsNotNull("model", model); using (GetCurrentSerializationScopeManager(configuration)) { configuration = GetCurrentSerializationConfiguration(configuration); using (var context = (SerializationContext <BinarySerializationContextInfo>)GetContext(model, model.GetType(), stream, SerializationContextMode.Deserialization, configuration)) { var referenceManager = context.ReferenceManager; if (referenceManager.Count == 0) { Log.Debug("Reference manager contains no objects yet, adding initial reference which is the first model in the graph"); referenceManager.GetInfo(context.Model); } var binaryFormatter = CreateBinaryFormatter(SerializationContextMode.Deserialization); var propertyValues = (List <PropertyValue>)binaryFormatter.Deserialize(stream); var memberValues = ConvertPropertyValuesToMemberValues(context, model.GetType(), propertyValues); context.Context.MemberValues.AddRange(memberValues); return(Deserialize(model, context.Context, context.Configuration)); } } }
/// <summary> /// Creates a json reader with the right configuration. /// </summary> /// <param name="token">The token.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// The json reader. /// </returns> public static JsonReader CreateReader(this JToken token, ISerializationConfiguration configuration) { var reader = token.CreateReader(); reader.Culture = configuration.Culture; return reader; }
/// <summary> /// Initializes a new instance of the <see cref="SerializationContext{TContext}" /> class. /// </summary> /// <param name="model">The model, can be <c>null</c> for value types.</param> /// <param name="modelType">Type of the model.</param> /// <param name="context">The context.</param> /// <param name="contextMode">The context mode.</param> /// <param name="configuration">The configuration.</param> /// <exception cref="ArgumentNullException">The <paramref name="modelType" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="context" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="configuration" /> is <c>null</c>.</exception> public SerializationContext(object model, Type modelType, TContext context, SerializationContextMode contextMode, ISerializationConfiguration configuration = null) { Argument.IsNotNull("modelType", modelType); Argument.IsNotNull("context", context); Argument.IsNotNull("configuration", configuration); Model = model; ModelType = modelType; ModelTypeName = modelType.GetSafeFullName(false); Context = context; ContextMode = contextMode; TypeStack = new Stack <Type>(); Configuration = configuration; var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName(); _typeStackScopeManager = ScopeManager <Stack <Type> > .GetScopeManager(scopeName, () => new Stack <Type>()); TypeStack = _typeStackScopeManager.ScopeObject; _referenceManagerScopeManager = ScopeManager <ReferenceManager> .GetScopeManager(scopeName); ReferenceManager = _referenceManagerScopeManager.ScopeObject; _serializableToken = CreateSerializableToken(); }
/// <summary> /// Saves the object to memory stream so the <see cref="IModel.IsDirty" /> property is set to false. /// </summary> /// <param name="obj">The object.</param> /// <param name="configuration">The configuration.</param> internal static void SaveObjectToMemoryStream(ISavableModel obj, ISerializationConfiguration configuration = null) { using (var memoryStream = new MemoryStream()) { obj.Save(memoryStream, configuration); } }
public void Generate(ISerializationConfiguration configuration) { Type typeToSerialize = configuration.TypeToSerialize; ObjectSpace objectSpace = ObjectSpace.FindObjectSpace(configuration); foreach (IClassInfoGraphNode classInfoGraphNode in GetGraph(objectSpace, typeToSerialize, null)) { configuration.SerializationGraph.Add(classInfoGraphNode); } }
public ISerializationContextInfo GetSerializationContextInfo(ISerializer serializer, object model, object data, ISerializationConfiguration configuration) { var jsonSerializer = new Newtonsoft.Json.JsonSerializer(); jsonSerializer.ContractResolver = new CatelJsonContractResolver(); jsonSerializer.Converters.Add(new CatelJsonConverter((IJsonSerializer)serializer, configuration)); return new JsonSerializationContextInfo(jsonSerializer, null, null); }
/// <summary> /// Creates a json reader with the right configuration. /// </summary> /// <param name="token">The token.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// The json reader. /// </returns> public static JsonReader CreateReader(this JToken token, ISerializationConfiguration configuration) { var reader = token.CreateReader(); reader.Culture = configuration.Culture; return(reader); }
public static CriteriaOperator GetCriteria(Type serializationConfigurationType, ISerializationConfigurationGroup serializationConfigurationGroup) { const ISerializationConfiguration serializationConfiguration = null; var groupOperator = new BinaryOperator(serializationConfiguration.GetPropertyName(x => x.SerializationConfigurationGroup), serializationConfigurationGroup); return(new GroupOperator(new BinaryOperator(serializationConfiguration.GetPropertyName(x => x.TypeToSerialize), serializationConfigurationType), groupOperator)); }
/// <summary> /// Saves the object to a stream using a specific formatting. /// </summary> /// <param name="stream">Stream that will contain the serialized data of this object.</param> /// <param name="serializer">The serializer to use.</param> /// <param name="configuration">The configuration.</param> public void Save(Stream stream, ISerializer serializer, ISerializationConfiguration configuration = null) { Argument.IsNotNull("stream", stream); Argument.IsNotNull("serializer", serializer); serializer.Serialize(this, stream, configuration); this.ClearIsDirtyOnAllChilds(); }
/// <summary> /// Loads the object from a stream using a specific formatting. /// </summary> /// <param name="type">The type.</param> /// <param name="stream">Stream that contains the serialized data of this object.</param> /// <param name="serializer">The serializer.</param> /// <param name="configuration">The configuration.</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 IModel Load(Type type, Stream stream, ISerializer serializer, ISerializationConfiguration configuration = null) { Argument.IsNotNull("type", type); Argument.IsNotNull("stream", stream); Argument.IsNotNull("serializer", serializer); var result = serializer.Deserialize(type, stream, configuration); return(result as IModel); }
/// <summary> /// Deserializes the specified model type. /// </summary> /// <param name="modelType">Type of the model.</param> /// <param name="stream">The stream.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// The serialized object. /// </returns> /// <remarks> /// When deserializing a stream, the binary serializer must use the <see cref="BinaryFormatter" /> because this will /// inject the right <see cref="SerializationInfo" /> into a new serializer. /// </remarks> public override object Deserialize(Type modelType, Stream stream, ISerializationConfiguration configuration) { Argument.IsNotNull("modelType", modelType); // Note: although this looks like an unnecessary overload, it's required to prevent duplicate scopes var model = CreateModelInstance(modelType); return(Deserialize(model, stream, configuration)); }
public EventHubProducerSharedContext(IBusInstance busInstance, SendObservable sendObservers, ISendPipe sendPipe, ISerializationConfiguration serializationConfiguration, IHostSettings hostSettings, EventHubProducerClientOptions options) { SendObservers = sendObservers; SendPipe = sendPipe; _busInstance = busInstance; _serializationConfiguration = serializationConfiguration; _hostSettings = hostSettings; _options = options; _clients = new ConcurrentDictionary <string, EventHubProducerClient>(); }
public void ApplyStrategy(SerializationStrategy serializationStrategy, ISerializationConfiguration serializationConfiguration) { var serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup; var infoGraphNodes = serializationConfigurationGroup.Configurations.SelectMany(configuration => configuration.SerializationGraph); var classInfoGraphNodes = infoGraphNodes.Where(node => node.TypeName == serializationConfiguration.TypeToSerialize.Name); foreach (var classInfoGraphNode in classInfoGraphNodes) { classInfoGraphNode.SerializationStrategy = serializationStrategy; } }
static XDocument ExportRecords(XPObjectSpace XPObjectSpace) { ISerializationConfiguration serializationConfiguration = XPObjectSpace.CreateObject <SerializationConfiguration>(); serializationConfiguration.TypeToSerialize = typeof(PEnumClass); serializationConfiguration.SerializationConfigurationGroup = XPObjectSpace.CreateObject <SerializationConfigurationGroup>(); new ClassInfoGraphNodeBuilder().Generate(serializationConfiguration); XDocument document = new ExportEngine().Export(new[] { _pEnumClass }, serializationConfiguration.SerializationConfigurationGroup); return(document); }
public void Generate(ISerializationConfiguration serializationConfiguration){ var typeToSerialize = serializationConfiguration.TypeToSerialize; var castTypeToTypeInfo = XafTypesInfo.CastTypeToTypeInfo(typeToSerialize); var objectSpace = ObjectSpace.FindObjectSpace(serializationConfiguration); foreach (var descendant in ReflectionHelper.FindTypeDescendants(castTypeToTypeInfo)) { generate(objectSpace, descendant.Type); } foreach (IClassInfoGraphNode classInfoGraphNode in createGraph(objectSpace, castTypeToTypeInfo)){ serializationConfiguration.SerializationGraph.Add(classInfoGraphNode); } }
public XDocument Export( IEnumerable<XPBaseObject> baseCollection, ISerializationConfiguration serializationConfiguration){ var xDocument = new XDocument(); var root = new XElement("SerializedObjects"); xDocument.Add(root); foreach (var baseObject in baseCollection) { var serializedClassInfoGraphNodes = GetSerializedClassInfoGraphNodes(baseObject, serializationConfiguration); ExportCore(baseObject, serializedClassInfoGraphNodes, root); } return xDocument; }
/// <summary> /// Serializes the object to a byte array. /// </summary> /// <returns>Byte array containing the serialized data.</returns> public byte[] ToByteArray(ISerializationConfiguration configuration) { using (var memoryStream = new MemoryStream()) { #if NET Save(memoryStream, SerializationMode.Binary, configuration); #else Save(memoryStream, SerializationMode.Xml, configuration); #endif return(memoryStream.ToArray()); } }
/// <summary> /// Serializes the object to a byte array. /// </summary> /// <param name="model">The model.</param> /// <param name="serializer">The serializer.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// Byte array containing the serialized data. /// </returns> public static byte[] ToByteArray(this IModel model, ISerializer serializer, ISerializationConfiguration configuration = null) { Argument.IsNotNull("model", model); Argument.IsNotNull("serializer", serializer); using (var memoryStream = new MemoryStream()) { serializer.Serialize(model, memoryStream, configuration); memoryStream.Position = 0L; return(memoryStream.ToArray()); } }
/// <summary> /// Serializes the specified model to the json writer. /// </summary> /// <param name="model">The model.</param> /// <param name="jsonWriter">The json writer.</param> /// <param name="configuration">The configuration.</param> public void Serialize(object model, JsonWriter jsonWriter, ISerializationConfiguration configuration) { Argument.IsNotNull("model", model); using (GetCurrentSerializationScopeManager(configuration)) { configuration = GetCurrentSerializationConfiguration(configuration); using (var context = GetContext(model, model.GetType(), null, jsonWriter, SerializationContextMode.Serialization, null, null, configuration)) { base.Serialize(model, context.Context, configuration); } } }
/// <summary> /// Saves the object to a file using a specific formatting. /// </summary> /// <param name="fileName">Filename of the file that will contain the serialized data of this object.</param> /// <param name="mode"><see cref="SerializationMode" /> to use.</param> /// <param name="configuration">The configuration.</param> public void Save(string fileName, SerializationMode mode, ISerializationConfiguration configuration) { var fileInfo = new FileInfo(fileName); if (!Directory.Exists(fileInfo.DirectoryName)) { Directory.CreateDirectory(fileInfo.DirectoryName); } using (Stream stream = new FileStream(fileName, FileMode.Create)) { Save(stream, mode, configuration); } }
/// <summary> /// Serializes the object to and xml object. /// </summary> /// <param name="configuration">The configuration.</param> /// <returns> /// <see cref="XDocument" /> containing the serialized data. /// </returns> public XDocument ToXml(ISerializationConfiguration configuration) { using (var memoryStream = new MemoryStream()) { Save(memoryStream, SerializationMode.Xml, configuration); memoryStream.Position = 0L; using (var xmlReader = XmlReader.Create(memoryStream)) { return(XDocument.Load(xmlReader)); } } }
public void Generate(ISerializationConfiguration serializationConfiguration) { var typeToSerialize = serializationConfiguration.TypeToSerialize; var castTypeToTypeInfo = XafTypesInfo.CastTypeToTypeInfo(typeToSerialize); var objectSpace = XPObjectSpace.FindObjectSpaceByObject(serializationConfiguration); _serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup; if (_serializationConfigurationGroup == null) throw new NullReferenceException("_serializationConfigurationGroup"); foreach (var descendant in ReflectionHelper.FindTypeDescendants(castTypeToTypeInfo)) { Generate(objectSpace, descendant.Type); } foreach (IClassInfoGraphNode classInfoGraphNode in CreateGraph(objectSpace, castTypeToTypeInfo)) { serializationConfiguration.SerializationGraph.Add(classInfoGraphNode); } }
/// <summary> /// Deserializes the specified model type. /// </summary> /// <param name="modelType">Type of the model.</param> /// <param name="stream">The stream.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// The deserialized <see cref="object" />. /// </returns> public virtual object Deserialize(Type modelType, Stream stream, ISerializationConfiguration configuration = null) { Argument.IsNotNull("modelType", modelType); Argument.IsNotNull("stream", stream); using (GetCurrentSerializationScopeManager(configuration)) { configuration = GetCurrentSerializationConfiguration(configuration); using (var context = GetContext(modelType, stream, SerializationContextMode.Deserialization, configuration)) { return(Deserialize(context.Model, context.Context, configuration)); } } }
/// <summary> /// Deserializes the specified model. /// </summary> /// <param name="model">The model.</param> /// <param name="stream">The stream.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// The deserialized model. /// </returns> public virtual object Deserialize(object model, Stream stream, ISerializationConfiguration configuration) { Argument.IsNotNull("model", model); Argument.IsNotNull("stream", stream); using (GetCurrentSerializationScopeManager(configuration)) { configuration = GetCurrentSerializationConfiguration(configuration); using (var context = GetContext(model, model.GetType(), stream, SerializationContextMode.Deserialization, configuration)) { return(Deserialize(model, context)); } } }
/// <summary> /// Serializes the specified model. /// </summary> /// <param name="model">The model.</param> /// <param name="context">The context.</param> /// <param name="configuration">The configuration.</param> public virtual void Serialize(object model, TSerializationContext context, ISerializationConfiguration configuration) { Argument.IsNotNull("model", model); Argument.IsNotNull("context", context); using (GetCurrentSerializationScopeManager(configuration)) { configuration = GetCurrentSerializationConfiguration(configuration); using (var finalContext = GetContext(model, model.GetType(), context, SerializationContextMode.Serialization, configuration)) { Serialize(model, finalContext); } } }
protected override void ConfigureOverride(FilterContext context, ITimestampSerializationOptions options) { ITimestampStringConverter timestampConverter = TimestampStringConverterResolver.Default.Resolve(options.TimestampFormat); var converters = new ISerializationConfiguration[] { new CsvConvertersSerializationConfiguration(new SelectionCsvConverter()) }; context.IO .Formats .GetOrDefault(FileFormat.CSV)? .Configurations .AddRange(converters); }
/// <summary> /// Loads the object from a stream using a specific formatting. /// </summary> /// <param name="type">The type.</param> /// <param name="stream">Stream that contains the serialized data of this object.</param> /// <param name="mode"><see cref="SerializationMode" /> to use.</param> /// <param name="configuration">The configuration.</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 IModel Load(Type type, Stream stream, SerializationMode mode, ISerializationConfiguration configuration) { Argument.IsNotNull("type", type); object result = null; Log.Debug("Loading object '{0}' as '{1}'", type.Name, mode); switch (mode) { #if NET case SerializationMode.Binary: try { var binarySerializer = SerializationFactory.GetBinarySerializer(); result = binarySerializer.Deserialize(type, stream, null); } catch (Exception ex) { Log.Error(ex, "Failed to deserialize the binary object"); } break; #endif case SerializationMode.Xml: try { var xmlSerializer = SerializationFactory.GetXmlSerializer(); result = xmlSerializer.Deserialize(type, stream, null); } catch (Exception ex) { Log.Error(ex, "Failed to deserialize the binary object"); } break; } Log.Debug("Loaded object"); var resultAsModelBase = result as ISavableModel; if (resultAsModelBase != null) { resultAsModelBase.Mode = mode; } return(result as IModel); }
/// <summary> /// Converters the specified model to a json string. /// </summary> /// <param name="model">The model.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// System.String. /// </returns> public static string ToJson(this ModelBase model, ISerializationConfiguration configuration) { var jsonSerializer = new JsonSerializer(SerializationManager, TypeFactory.Default, ObjectAdapter); using (var stream = new MemoryStream()) { jsonSerializer.Serialize(model, stream, configuration); stream.Position = 0L; using (var streamReader = new StreamReader(stream)) { return(streamReader.ReadToEnd()); } } }
/// <summary> /// Converters the specified model to a json string. /// </summary> /// <param name="model">The model.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// System.String. /// </returns> public static string ToJson(this ModelBase model, ISerializationConfiguration configuration) { var jsonSerializer = new JsonSerializer(SerializationManager, TypeFactory.Default, ObjectAdapter); using (var stream = new MemoryStream()) { jsonSerializer.Serialize(model, stream, configuration); stream.Position = 0L; using (var streamReader = new StreamReader(stream)) { return streamReader.ReadToEnd(); } } }
/// <summary> /// Serializes the object to and xml object. /// </summary> /// <param name="model">The model.</param> /// <param name="serializer">The serializer.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// <see cref="XDocument" /> containing the serialized data. /// </returns> public static XDocument ToXml(this IModel model, ISerializer serializer, ISerializationConfiguration configuration = null) { Argument.IsNotNull("model", model); Argument.IsNotNull("serializer", serializer); using (var memoryStream = new MemoryStream()) { serializer.Serialize(model, memoryStream, configuration); memoryStream.Position = 0L; using (var xmlReader = XmlReader.Create(memoryStream)) { return(XDocument.Load(xmlReader)); } } }
/// <summary> /// Serializes the specified model. /// </summary> /// <param name="model">The model.</param> /// <param name="stream">The stream.</param> /// <param name="configuration">The configuration.</param> public virtual void Serialize(object model, Stream stream, ISerializationConfiguration configuration = null) { Argument.IsNotNull("model", model); Argument.IsNotNull("stream", stream); using (GetCurrentSerializationScopeManager(configuration)) { configuration = GetCurrentSerializationConfiguration(configuration); using (var context = GetSerializationContextInfo(model, model.GetType(), stream, SerializationContextMode.Serialization, configuration)) { Serialize(model, context); AppendContextToStream(context, stream); } } }
IEnumerable<IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(XPBaseObject baseObject, ISerializationConfiguration serializationConfiguration) { ISerializationConfiguration configuration = baseObject.GetType() ==serializationConfiguration.TypeToSerialize? serializationConfiguration : SerializationConfigurationQuery.Find(baseObject.Session, baseObject.GetType()); return GetSerializedClassInfoGraphNodes(configuration); }
public void ApplyStrategy(SerializationStrategy serializationStrategy, ISerializationConfiguration serializationConfiguration) { var serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup; var infoGraphNodes = serializationConfigurationGroup.Configurations.SelectMany(configuration => configuration.SerializationGraph); var classInfoGraphNodes = infoGraphNodes.Where(node => node.TypeName == serializationConfiguration.TypeToSerialize.Name); foreach (var classInfoGraphNode in classInfoGraphNodes) { classInfoGraphNode.SerializationStrategy = serializationStrategy; } }
/// <summary> /// Gets the serialization context information. /// </summary> /// <param name="serializer">The serializer.</param> /// <param name="model">The model.</param> /// <param name="data">The data.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// ISerializationContextInfo. /// </returns> public ISerializationContextInfo GetSerializationContextInfo(ISerializer serializer, object model, object data, ISerializationConfiguration configuration) { return new BinarySerializationContextInfo((SerializationInfo)data); }
/// <summary> /// Saves the object to memory stream so the <see cref="IModel.IsDirty" /> property is set to false. /// </summary> /// <param name="obj">The object.</param> /// <param name="configuration">The configuration.</param> internal static void SaveObjectToMemoryStream(ISavableModel obj, ISerializationConfiguration configuration = null) { using (var memoryStream = new MemoryStream()) { obj.Save(memoryStream, configuration); } }
IEnumerable<IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(ISerializationConfiguration serializationConfiguration) { return ((IEnumerable)((XPBaseObject)serializationConfiguration).GetMemberValue(serializationConfiguration.GetPropertyName(x => x.SerializationGraph))). OfType<IClassInfoGraphNode>().Where( node => (node.NodeType == NodeType.Simple && node.SerializationStrategy != SerializationStrategy.DoNotSerialize) || node.NodeType != NodeType.Simple).OrderBy(graphNode => graphNode.NodeType); }
/// <summary> /// Initializes a new instance of the <see cref="CatelJsonConverter" /> class. /// </summary> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="configuration">The configuration.</param> public CatelJsonConverter(IJsonSerializer jsonSerializer, ISerializationConfiguration configuration) { _jsonSerializer = jsonSerializer; _configuration = configuration; }
/// <summary> /// Gets the serialization context information. /// </summary> /// <param name="serializer">The serializer.</param> /// <param name="model">The model.</param> /// <param name="data">The data.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// ISerializationContext. /// </returns> public ISerializationContextInfo GetSerializationContextInfo(ISerializer serializer, object model, object data, ISerializationConfiguration configuration) { return new XmlSerializationContextInfo((XElement)data, model); }