// public static void RunAutofacConfig()
// {
// Program.PrintHeader("Serialization reference object - autofac config");
//
// var builder = new ContainerBuilder();
// builder.RegisterModule<AutofacExtendedXmlSerializerModule>();
// builder.RegisterType<PersonConfig>().As<ExtendedXmlSerializerConfig<Person>>().SingleInstance();
// var containter = builder.Build();
//
// var serializer = containter.Resolve<IExtendedXmlSerializer>();
// Run(serializer);
// }
static void Run(IExtendedXmlSerializer serializer)
{
// CreateObject
Person boss = new Person {
Id = 1, Name = "John"
};
boss.Boss = boss; //himself boss
Person worker = new Person {
Id = 2, Name = "Oliver"
};
worker.Boss = boss;
Company obj = new Company
{
Employees = new List <Person>
{
worker,
boss
}
};
// EndCreateObject
string xml = serializer.Serialize(new XmlWriterSettings {
Indent = true
}, obj);
File.WriteAllText("bin\\ObjectReferenceSamples.xml", xml);
Console.WriteLine(xml);
Company obj2 = serializer.Deserialize <Company>(xml);
Console.WriteLine("Employees count = " + obj2.Employees.Count);
}
private static void Run(IExtendedXmlSerializer serializer)
{
var boss = new Person {
Id = 1, Name = "John"
};
boss.Boss = boss; //himself boss
var worker = new Person {
Id = 2, Name = "Oliver"
};
worker.Boss = boss;
var obj = new Company
{
Employees = new List <Person>
{
worker,
boss
}
};
var xml = serializer.Serialize(obj);
Console.WriteLine(xml);
var obj2 = serializer.Deserialize <Company>(xml);
Console.WriteLine("Employees count = " + obj2.Employees.Count);
}
//////////////////////////////////////////////////////////////////////////////
/// Autofac configuration
//////////////////////////////////////////////////////////////////////////////
// ConfigureServices is where you register dependencies. This gets
// called by the runtime before the Configure method, below.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// Add services to the collection.
services.AddMvc(options =>
{
options.RespectBrowserAcceptHeader = true; // false by default
//Resolve ExtendedXmlSerializer
IExtendedXmlSerializer serializer = ApplicationContainer.Resolve <IExtendedXmlSerializer>();
//Add ExtendedXmlSerializer's formatter
options.OutputFormatters.Add(new ExtendedXmlSerializerOutputFormatter(serializer));
options.InputFormatters.Add(new ExtendedXmlSerializerInputFormatter(serializer));
});
// Create the container builder.
var builder = new ContainerBuilder();
// Register dependencies, populate the services from
// the collection, and build the container. If you want
// to dispose of the container at the end of the app,
// be sure to keep a reference to it as a property or field.
builder.Populate(services);
builder.RegisterModule <AutofacExtendedXmlSerializerModule>();
builder.RegisterType <TestClassConfig>().As <ExtendedXmlSerializerConfig <TestClass> >().SingleInstance();
this.ApplicationContainer = builder.Build();
// Create the IServiceProvider based on the container.
return(new AutofacServiceProvider(this.ApplicationContainer));
}
public XmlDeviceRepository(Uri uri, IDownloader downloader)
{
this.uri = uri;
this.downloader = downloader;
this.serializer = new ConfigurationContainer()
.Type <Device>().EnableReferences(x => x.Id)
.Create();
}
/// <summary>
/// Initializes a new instance of <see cref="T:Microsoft.AspNetCore.Mvc.Formatters.ExtendedXmlSerializerOutputFormatter" />
/// </summary>
/// <param name="serializer">The serializer <see cref="IExtendedXmlSerializer"/></param>
public ExtendedXmlSerializerOutputFormatter(IExtendedXmlSerializer serializer)
{
_serializer = serializer ?? new ExtendedXmlSerializer();
SupportedEncodings.Add(Encoding.UTF8);
SupportedEncodings.Add(Encoding.Unicode);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.TextXml);
}
public ExtendedXmlSerializerInputFormatter(IExtendedXmlSerializer serializer)
{
_serializer = serializer ?? new ExtendedXmlSerializer();
SupportedEncodings.Add(UTF8EncodingWithoutBOM);
SupportedEncodings.Add(UTF16EncodingLittleEndian);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.TextXml);
}
public GenericSerializer()
{
serializer = new ConfigurationContainer()
.EnableAllConstructors()
.EnableParameterizedContentWithPropertyAssignments()
.UseOptimizedNamespaces()
.EnableReferences()
.UseOptimizedNamespaces()
.Create();
}
public static string GetXmlFromObject(object obj)
{
IExtendedXmlSerializer serializer = DefaultXmlSerializer();
var document = serializer.Serialize(new XmlWriterSettings {
Indent = true
},
obj);
return(document);
}
private static void Run(IExtendedXmlSerializer serializer)
{
var obj = new TestClass("Value");
var xml = serializer.Serialize(obj);
Console.WriteLine(xml);
var obj2 = serializer.Deserialize <TestClass>(xml);
Console.WriteLine("Obiect PropStr = " + obj2.PropStr);
}
// public static void RunAutofacConfig()
// {
// Program.PrintHeader("Custom serialization - autofac config");
//
// var builder = new ContainerBuilder();
// builder.RegisterModule<AutofacExtendedXmlSerializerModule>();
// builder.RegisterType<TestClassConfig>().As<ExtendedXmlSerializerConfig<TestClass>>().SingleInstance();
// var containter = builder.Build();
//
// var serializer = containter.Resolve<IExtendedXmlSerializer>();
// Run(serializer);
// }
static void Run(IExtendedXmlSerializer serializer)
{
TestClass obj = new TestClass("Value", 1);
string xml = serializer.Serialize(obj);
Console.WriteLine(xml);
TestClass obj2 = serializer.Deserialize <TestClass>(xml);
Console.WriteLine("Obiect PropStr = " + obj2.PropStr);
Console.WriteLine("Obiect PropStr = " + obj2.PropInt);
}
public UserAppService(IRepository <User> userRepository, IRepository <UserInfo> userInfoRepository, IRepository <Role> roleRepository, IRepository <UserRole> userRoleRepository, IRepository <RolePermission> rolePermissionRepository, IRepository <Permission> permissionRepository, IRepository <Department> departmentReposiotry, IRepository <UserDepartment> userDepartmentReposiotry, ICache cache, IExtendedXmlSerializer serializer)
{
_userRepository = userRepository;
_userInfoRepository = userInfoRepository;
_roleRepository = roleRepository;
_userRoleRepository = userRoleRepository;
_rolePermissionRepository = rolePermissionRepository;
_permissionRepository = permissionRepository;
_departmentReposiotry = departmentReposiotry;
_userDepartmentReposiotry = userDepartmentReposiotry;
//_redisCache = cache;
_serializer = serializer;
}
void VerifyComposite()
{
IConfigurationContainer container = ConfiguredContainer.New <ComplexProfile>();
IExtendedXmlSerializer serializer = container.UseAutoFormatting()
.EnableImplicitTyping(typeof(Subject))
.UseOptimizedNamespaces()
.Create();
var instance = new Subject {
Message = "Hello World!", Number = 123
};
string document = serializer.Serialize(instance);
document.Should()
.Be(@"<?xml version=""1.0"" encoding=""utf-8""?><Issue282Tests_Profiles-Subject NewNumber=""123"" NewMessage=""Hello World!"" />");
}
private static void Run(IExtendedXmlSerializer serializer)
{
var list = new List <Person>
{
new Person {
Name = "John", Password = "******"
},
new Person {
Name = "Oliver", Password = "******"
}
};
var xml = serializer.Serialize(list);
Console.WriteLine(xml);
var obj2 = serializer.Deserialize <List <Person> >(xml);
Console.WriteLine("Employees count = " + obj2.Count + " - passwords " + string.Join(", ", obj2.Select(p => p.Password)));
}
private static void Run(IExtendedXmlSerializer serializer)
{
var xml =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<TestClass type=""ExtendedXmlSerialization.Samples.MigrationMap.TestClass"">
<Id>1</Id>
<Type>Type</Type>
</TestClass>";
Console.WriteLine(xml);
var obj = serializer.Deserialize <TestClass>(xml);
Console.WriteLine("Obiect Id = " + obj.Id);
Console.WriteLine("Obiect Name = " + obj.Name);
Console.WriteLine("Obiect Value = " + obj.Value);
Console.WriteLine("Serialization to new version");
var xml2 = serializer.Serialize(obj);
Console.WriteLine(xml2);
}
// public static void RunAutofacConfig()
// {
// Program.PrintHeader("Deserialization old version of xml - autofac config");
//
// var builder = new ContainerBuilder();
// builder.RegisterModule<AutofacExtendedXmlSerializerModule>();
// builder.RegisterType<TestClassConfig>().As<ExtendedXmlSerializerConfig<TestClass>>().SingleInstance();
// var containter = builder.Build();
//
// var serializer = containter.Resolve<IExtendedXmlSerializer>();
// Run(serializer);
// }
static void Run(IExtendedXmlSerializer serializer)
{
string xml =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<TestClass xmlns=""clr-namespace:ExtendedXmlSerializer.Samples.MigrationMap;assembly=ExtendedXmlSerializer.Samples"">
<Id>1</Id>
<Type>Type</Type>
</TestClass>";
Console.WriteLine(xml);
TestClass obj = serializer.Deserialize <TestClass>(xml);
Console.WriteLine("Obiect Id = " + obj.Id);
Console.WriteLine("Obiect Name = " + obj.Name);
Console.WriteLine("Obiect Value = " + obj.Value);
Console.WriteLine("Serialization to new version");
string xml2 = serializer.Serialize(new XmlWriterSettings {
Indent = true
}, obj);
File.WriteAllText("bin\\XmlLastVersion.xml", xml2);
Console.WriteLine(xml2);
}
/// <summary> /// Serialization convenience method to serialize the provided instance into the provided destination /// <see cref="TextWriter"/>. /// </summary> /// <param name="this">The serializer to use for serialization.</param> /// <param name="writer">The destination writer.</param> /// <param name="instance">The instance to serialize.</param> public static void Serialize(this IExtendedXmlSerializer @this, TextWriter writer, object instance) => @this.Serialize(XmlWriterFactory.Default, writer, instance);
static string Serialize(this IExtendedXmlSerializer @this, IXmlWriterFactory factory, Func <Stream> stream,
object instance)
=> new InstanceFormatter(@this, factory, stream).Get(instance);
/// <summary>
/// Serialization convenience method to serialize the provided instance into a string along with the provided
/// destination <see cref="Stream"/> while using the settings configured in the provided
/// <see cref="XmlWriterSettings"/>.
/// </summary>
/// <param name="this">The serializer to use for serialization.</param>
/// <param name="settings">The writer settings for handling the xml writer used create the resulting Xml.</param>
/// <param name="stream">The destination stream.</param>
/// <param name="instance">The instance to serialize.</param>
/// <returns>A string that represents the provided instance in Xml format.</returns>
public static string Serialize(this IExtendedXmlSerializer @this, XmlWriterSettings settings, Stream stream,
object instance)
=> @this.Serialize(new XmlWriterFactory(settings), stream.Self, instance);
/// <summary> /// Serialization convenience method to serialize the provided instance into a string along with the provided /// destination <see cref="Stream"/>. /// </summary> /// <param name="this">The serializer to use for serialization.</param> /// <param name="stream">The destination stream.</param> /// <param name="instance">The instance to serialize.</param> /// <returns>A string that represents the provided instance in Xml format.</returns> public static string Serialize(this IExtendedXmlSerializer @this, Stream stream, object instance) => @this.Serialize(XmlWriterFactory.Default, stream.Self, instance);
/// <summary> /// Serialization convenience method to serialize the provided instance into a string with the provided /// <see cref="XmlWriterSettings"/>. /// </summary> /// <param name="this">The serializer to use for serialization.</param> /// <param name="settings">The writer settings for handling the xml writer used create the resulting Xml.</param> /// <param name="instance">The instance to serialize.</param> /// <returns>A string that represents the provided instance in Xml format.</returns> public static string Serialize(this IExtendedXmlSerializer @this, XmlWriterSettings settings, object instance) => @this.Serialize(new XmlWriterFactory(CloseSettings.Default.Get(settings)), New, instance);
/// <summary>
/// Specifies an existing reference to use as target for deserialization of values. Read values during
/// deserialization will be read and assigned into the provided target instance. NOTICE: Be sure to call
/// <see cref="AllowTargetInstances"/> when configuring the container before using this method.
/// </summary>
/// <typeparam name="T">The instance type.</typeparam>
/// <param name="this">The serializer</param>
/// <param name="instance">The instance to deserialize</param>
/// <returns>A deserialization context that will assign values to the provided instance.</returns>
/// <seealso href="https://github.com/ExtendedXmlSerializer/home/issues/230" />
public static ReferencedDeserializationContext <T> UsingTarget <T>(this IExtendedXmlSerializer @this, T instance)
where T : class
=> new ReferencedDeserializationContext <T>(@this, instance);
public static T Deserialize <T>(this IExtendedXmlSerializer @this, T existing, string data) where T : class => @this.UsingTarget(existing) .Deserialize(data);
/// <summary>
/// Serialization convenience method to serialize the provided instance into the provided destination
/// <see cref="TextWriter"/> while using the settings configured in the provided <see cref="XmlWriterSettings"/>.
/// </summary>
/// <param name="this">The serializer to use for serialization.</param>
/// <param name="settings">The writer settings for handling the xml writer used create the resulting Xml.</param>
/// <param name="writer">The destination writer.</param>
/// <param name="instance">The instance to serialize.</param>
public static void Serialize(this IExtendedXmlSerializer @this, XmlWriterSettings settings, TextWriter writer,
object instance)
=> @this.Serialize(new XmlWriterFactory(settings), writer, instance);
/// <summary> /// Deserialization convenience method to deserialize a document found within the provided string into an instance of /// the requested instance type, using the provided <see cref="XmlReaderSettings"/>. /// </summary> /// <typeparam name="T">The requested instance type.</typeparam> /// <param name="this">The serializer to create the requested instance.</param> /// <param name="settings">The reader settings for handling the xml reader used create the instance.</param> /// <param name="data">A text representation of an Xml document.</param> /// <returns>An instance of the requested type.</returns> public static T Deserialize <T>(this IExtendedXmlSerializer @this, XmlReaderSettings settings, string data) => @this.Deserialize <T>(settings, new MemoryStream(Encoding.UTF8.GetBytes(data)));
static void Serialize(this IExtendedXmlSerializer @this, IXmlWriterFactory factory, TextWriter writer,
object instance)
=> @this.Serialize(factory.Get(writer), instance);
/// <summary> /// Deserialization convenience method to deserialize a document found within the provided <see cref="TextReader"/> /// into an instance of the requested instance type, using the default reader settings found at /// <see cref="ExtensionModel.Xml.Defaults.ReaderSettings"/>. /// </summary> /// <typeparam name="T">The requested instance type.</typeparam> /// <param name="this">The serializer to create the requested instance.</param> /// <param name="reader">The reader containing the necessary data to deserialize the object of requested type.</param> /// <returns>An instance of the requested type.</returns> public static T Deserialize <T>(this IExtendedXmlSerializer @this, TextReader reader) => @this.Deserialize <T>(ExtensionModel.Xml.Defaults.ReaderSettings, reader);
public static T Deserialize <T>(this IExtendedXmlSerializer @this, T existing, XmlReaderSettings settings,
Stream stream)
where T : class
=> @this.UsingTarget(existing).Deserialize(settings, stream);
/// <summary> /// Deserialization convenience method to deserialize a document found within the provided <see cref="TextReader"/> /// into an instance of the requested instance type, using the provided <see cref="XmlReaderSettings"/>. /// </summary> /// <typeparam name="T">The requested instance type.</typeparam> /// <param name="this">The serializer to create the requested instance.</param> /// <param name="settings">The reader settings for handling the xml reader used create the instance.</param> /// <param name="reader">The reader containing the necessary data to deserialize the object of requested type.</param> /// <returns>An instance of the requested type.</returns> public static T Deserialize <T>(this IExtendedXmlSerializer @this, XmlReaderSettings settings, TextReader reader) => @this.Deserialize(new XmlReaderFactory(settings, settings.NameTable.Context()).Get(reader)).AsValid <T>();
/// <summary> /// Deserialization convenience method to deserialize a document found within the provided <see cref="Stream"/> into /// an instance of the requested instance type, using the default reader settings found at /// <see cref="ExtensionModel.Xml.Defaults.ReaderSettings"/>. /// </summary> /// <typeparam name="T">The requested instance type.</typeparam> /// <param name="this">The serializer to create the requested instance.</param> /// <param name="stream">The stream containing the necessary data to deserialize the object of requested type.</param> /// <returns>An instance of the requested type.</returns> public static T Deserialize <T>(this IExtendedXmlSerializer @this, Stream stream) => @this.Deserialize <T>(ExtensionModel.Xml.Defaults.ReaderSettings, stream);
/// <summary> /// Serialization convenience method to serialize the provided instance into a string. /// </summary> /// <param name="this">The serializer to use for serialization.</param> /// <param name="instance">The instance to serialize.</param> /// <returns>A string that represents the provided instance in Xml format.</returns> public static string Serialize(this IExtendedXmlSerializer @this, object instance) => @this.Serialize(WriterFactory, New, instance);