public void Save(string path, AssemblyMetadata metadata) { BaseAssemblyMetadata Assembly = container.First(); Serializer.Serialize(path, AssemblyModelMapper.MapDown(metadata, Assembly)); //Serializer.Serialize(path, AssemblyModelMapper.MapDown(metadata, Assembly.GetType())); }
public static void Save(BaseAssemblyMetadata baseAssembly, string addr) { ISerializer serializer = Composition.MEF.Container.GetExportedValue <ISerializer>(ConfigurationManager.AppSettings["serialization"]); ILogger logger = Composition.MEF.Container.GetExportedValue <ILogger>(ConfigurationManager.AppSettings["logging"]); serializer.Serialize(baseAssembly, addr); }
public void Serialize(BaseAssemblyMetadata target, string path) { using (var context = new DBModelContext()) { context.Assemblies.Add(DBAssemblyMapper.MapToDB(target)); context.SaveChanges(); } }
public void Serialize(string path, BaseAssemblyMetadata obj) { ClearDB(); using (DatabaseContext context = new DatabaseContext()) { DBAssemblyMetadata assemblyMetadata = (DBAssemblyMetadata)obj; context.AssemblyMetadata.Add(assemblyMetadata); context.SaveChanges(); } }
public static BaseAssemblyMetadata MapToBase(DBAssemblyModel assemblyMetadata) { Dictionares.ResetDictonaries(); BaseAssemblyMetadata assemblyModel = new BaseAssemblyMetadata { AssemblyName = assemblyMetadata.Name, Namespaces = from DBNamespaceModel _namespace in assemblyMetadata.NamespacesL select DBNamespaceMapper.MapToBase(_namespace) }; return(assemblyModel); }
public AssemblyMetadata(BaseAssemblyMetadata assemblyMetadata) { m_Name = assemblyMetadata.AssemblyName; if (assemblyMetadata.Namespaces != null) { List <NamespaceMetadata> namespaces = new List <NamespaceMetadata>(); foreach (BaseNamespaceMetadata namespac in assemblyMetadata.Namespaces) { NamespaceMetadata namespaceMetadata = new NamespaceMetadata(namespac); namespaces.Add(namespaceMetadata); } m_Namespaces = namespaces; } }
public static DBAssemblyModel MapToDB(BaseAssemblyMetadata assemblyMetadata) { Dictionares.ResetDictonaries(); DBAssemblyModel assemblyModel = new DBAssemblyModel { Name = assemblyMetadata.AssemblyName, Namespaces = from BaseNamespaceMetadata _namespaces in assemblyMetadata.Namespaces select DBNamespaceMapper.MapToDB(_namespaces) }; assemblyModel.SetValues(); return(assemblyModel); }
public static BaseAssemblyMetadata MapDown(AssemblyMetadata model, BaseAssemblyMetadata assemblyModel) { //object assemblyModel = Activator.CreateInstance(assemblyModelType); PropertyInfo nameProperty = assemblyModel.GetType().GetProperty("Name"); PropertyInfo namespaceModelsProperty = assemblyModel.GetType().GetProperty("Namespaces", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); nameProperty?.SetValue(assemblyModel, model.Name); namespaceModelsProperty?.SetValue( assemblyModel, HelperClass.ConvertList(namespaceModelsProperty.PropertyType.GetGenericArguments()[0], model.Namespaces.Select(n => new NamespaceModelMapper().MapDown(n, namespaceModelsProperty.PropertyType.GetGenericArguments()[0])).ToList())); return((BaseAssemblyMetadata)assemblyModel); }
public static AssemblyMetadata MapUp(BaseAssemblyMetadata model) { AssemblyMetadata assemblyModel = new AssemblyMetadata(); Type type = model.GetType(); assemblyModel.Name = model.Name; PropertyInfo namespaceModelsProperty = type.GetProperty("Namespaces", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); List <BaseNamespaceMetadata> namespaceModels = (List <BaseNamespaceMetadata>)HelperClass.ConvertList(typeof(BaseNamespaceMetadata), (IList)namespaceModelsProperty?.GetValue(model)); if (namespaceModels != null) { assemblyModel.Namespaces = namespaceModels.Select(n => new NamespaceModelMapper().MapUp(n)).ToList(); } return(assemblyModel); }
public BaseAssemblyMetadata MapUp() { BaseAssemblyMetadata AssemblyMetadata = new BaseAssemblyMetadata(); AssemblyMetadata.AssemblyName = m_Name; if (m_Namespaces != null) { List <BaseNamespaceMetadata> NamespaceMetadataDTO = new List <BaseNamespaceMetadata>(); foreach (NamespaceMetadata basenamespace in m_Namespaces) { NamespaceMetadataDTO.Add(basenamespace.MapUp()); } AssemblyMetadata.Namespaces = NamespaceMetadataDTO; } return(AssemblyMetadata); }
public void Serialize(BaseAssemblyMetadata data, string path) { using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None)) { //XmlWriterSettings sets = new XmlWriterSettings { Indent = true, IndentChars = "\t" }; //sets.CloseOutput = true; //XmlWriter writer = XmlWriter.Create(fs, sets); //DataContractSerializer ser; //if (data is AssemblyMetadata) //{ // ser = new DataContractSerializer(typeof(AssemblyMetadata)); //} //else //{ // ser = new DataContractSerializer(typeof(T)); //} //ser.WriteObject(writer, data); //writer.Close(); List <Type> lista = new List <Type> { typeof(System.FlagsAttribute), typeof(System.Reflection.DefaultMemberAttribute), typeof(System.AttributeUsageAttribute), typeof(System.ObsoleteAttribute), typeof(System.SerializableAttribute), typeof(System.Runtime.Serialization.KnownTypeAttribute) }; DataContractSerializerSettings DCsettings = new DataContractSerializerSettings { PreserveObjectReferences = true, KnownTypes = lista }; DataContractSerializer ser = new DataContractSerializer(typeof(BaseAssemblyMetadata), DCsettings); var XmlWriterSettings = new XmlWriterSettings() { Indent = true, IndentChars = "\t" }; using (var XmlWriter = System.Xml.XmlWriter.Create(fs, XmlWriterSettings)) { ser.WriteObject(XmlWriter, data); } } }
public void Write(BaseAssemblyMetadata obj, string path) { using (DatabaseContext context = new DatabaseContext()) { context.Database.ExecuteSqlCommand("DELETE FROM ParameterMetadata"); context.Database.ExecuteSqlCommand("DELETE FROM PropertyMetadata"); context.Database.ExecuteSqlCommand("DELETE FROM MethodMetadata"); context.Database.ExecuteSqlCommand("DELETE FROM TypeMetadata"); context.Database.ExecuteSqlCommand("DELETE FROM NamespaceMetadata"); context.Database.ExecuteSqlCommand("DELETE FROM AssemblyMetadata"); context.SaveChanges(); } using (DatabaseContext context = new DatabaseContext()) { AssemblyMetadataDatabaseDTO assemblyMetadata = new AssemblyMetadataDatabaseDTO(obj); context.AssemblyMetadata.Add(assemblyMetadata); context.SaveChanges(); } }
//private readonly DataContractSerializer serializer = new DataContractSerializer(typeof(XMLAs)) public BaseAssemblyMetadata Deserialize(string path) { List <Type> lista = new List <Type> { typeof(System.FlagsAttribute), typeof(System.Reflection.DefaultMemberAttribute), typeof(System.AttributeUsageAttribute), typeof(System.ObsoleteAttribute), typeof(System.SerializableAttribute), typeof(System.Runtime.Serialization.KnownTypeAttribute) }; BaseAssemblyMetadata temp = default(BaseAssemblyMetadata); DataContractSerializer ser = new DataContractSerializer(typeof(BaseAssemblyMetadata)); using (var xmlreader = XmlReader.Create(path)) { // XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas { MaxDepth = int.MaxValue }); temp = (BaseAssemblyMetadata)ser.ReadObject(xmlreader); } return(temp); }
public void Write(BaseAssemblyMetadata obj, string filePath) { List <Type> lista = new List <Type> { typeof(System.FlagsAttribute), typeof(System.Reflection.DefaultMemberAttribute), typeof(System.AttributeUsageAttribute), typeof(System.ObsoleteAttribute), typeof(System.SerializableAttribute), typeof(System.Runtime.Serialization.KnownTypeAttribute), typeof(AssemblyMetadataDTO), typeof(MethodMetadataDTO), typeof(NamespaceMetadataDTO), typeof(ParameterMetadataDTO), typeof(PropertyMetadataDTO), typeof(TypeMetadataDTO), typeof(FieldMetadataDTO) }; DataContractSerializerSettings DCSsettings = new DataContractSerializerSettings { PreserveObjectReferences = true }; XmlWriterSettings XmlWriterSettings = new XmlWriterSettings() { Indent = true, IndentChars = "\t" }; DataContractSerializer serializer = new DataContractSerializer(typeof(AssemblyMetadataDTO), lista); using (FileStream stream = File.Create(filePath)) { serializer.WriteObject(stream, new AssemblyMetadataDTO(obj)); } }
public XMLAssemblyModel(BaseAssemblyMetadata assemblyBase) { AssemblyName = assemblyBase.AssemblyName; Namespaces = assemblyBase.Namespaces?.Select(ns => new XMLNamespaceModel(ns)); }
public void Save(string addr) { BaseAssemblyMetadata temp = this.MapUp(); SerializationOperations.Save(temp, addr); }
public void SerializeAssembly(string path) { BaseAssemblyMetadata dataToSerialize = M_AssemblyModel; Serialization.Write(dataToSerialize, path); }
public void DeserializeAssembly(string path) { BaseAssemblyMetadata deserializedData = Serialization.Read(path); M_AssemblyModel = new AssemblyMetadata(deserializedData); }