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);
}
