public static void Validate(string filename, ValidationEventHandler validationEventHandler)
{
var settings = new XmlReaderSettings
{
ValidationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints,
ValidationType = ValidationType.Schema,
};
settings.Schemas.Add(ReaderSchema());
settings.ValidationEventHandler += validationEventHandler;
using (var reader = XmlReader.Create(filename, settings))
{
while (reader.Read())
{
}
}
XmlSchema ReaderSchema()
{
var readInfo = new CremaXmlReadInfo(filename);
using (var reader = XmlReader.Create(readInfo.SchemaPath))
{
return(XmlSchema.Read(reader, (s, e) => { }));
}
}
}
/// <summary>
/// xml 파일을 사용하여 스키마를 찾아 읽어들이고 데이터를 읽어들입니다.
/// </summary>
public void ReadTable(string filename)
{
var readInfo = new CremaXmlReadInfo(filename);
this.ReadXmlSchema(readInfo.SchemaPath, readInfo.ItemName);
this.ReadXml(readInfo.XmlPath, readInfo.ItemName);
}
public CremaDataSet GetTableCategoryData(string repositoryPath, string localPath, long revision)
{
var tempPath = PathUtility.GetTempPath(true);
try
{
var revisionValue = revision == -1 ? this.Revision : revision;
var repoUri = this.GetUri(repositoryPath, revisionValue);
var categoryUri = this.GetUri(localPath, revisionValue);
var categoryPath = this.Export(categoryUri, tempPath);
var baseUri = this.GetDataBaseUri($"{repoUri}", $"{categoryUri}");
var files = DirectoryUtility.GetAllFiles(categoryPath, "*" + CremaSchema.XmlExtension);
foreach (var item in files)
{
var relativeItemUri = UriUtility.MakeRelative(categoryPath, item);
var itemUri = UriUtility.Combine(UriUtility.GetDirectoryName(categoryUri), $"{relativeItemUri}@{revisionValue}");
var xmlInfo = new CremaXmlReadInfo(item);
var schemaUri = UriUtility.Combine(UriUtility.GetDirectoryName(itemUri), $"{xmlInfo.RelativeSchemaPath}@{revisionValue}");
var schemaPath = new Uri(UriUtility.Combine(Path.GetDirectoryName(item), xmlInfo.RelativeSchemaPath)).LocalPath;
if (File.Exists(schemaPath) == false)
{
this.Export(schemaUri, tempPath);
}
ExportTypes(schemaUri, schemaPath);
}
void ExportTypes(Uri schemaUri, string schemaPath)
{
var xsdInfo = new CremaSchemaReadInfo(schemaPath);
foreach (var item in xsdInfo.RelativeTypePaths)
{
var typeUri = UriUtility.Combine(UriUtility.GetDirectoryName(schemaUri), $"{item}@{revisionValue}");
var typePath = new Uri(UriUtility.Combine(Path.GetDirectoryName(schemaPath), item)).LocalPath;
if (File.Exists(typePath) == false)
{
this.Export(typeUri, tempPath);
}
}
}
var pureBaseUri = $"{baseUri}".Replace($"@{revisionValue}", string.Empty);
var pureCategoryUri = $"{categoryUri}".Replace($"@{revisionValue}", string.Empty);
var dataBaseRelativeUri = UriUtility.MakeRelativeOfDirectory(pureCategoryUri, pureBaseUri);
var dataBasePath = UriUtility.Combine(new Uri(categoryPath), dataBaseRelativeUri).LocalPath;
return(CremaDataSet.ReadFromDirectory(dataBasePath));
}
finally
{
DirectoryUtility.Delete(tempPath);
}
}
public string[] GetPath(string itemPath, Type type, ObjectSerializerSettings settings)
{
if (type == typeof(CremaDataTable))
{
var xmlPath = itemPath + CremaSchema.XmlExtension;
if (settings is CremaDataTableSerializerSettings prop && prop.RelativePath != string.Empty)
{
return(new string[] { xmlPath });
}
else
{
if (File.Exists(xmlPath) == true)
{
var xmlInfo = new CremaXmlReadInfo(xmlPath);
return(new string[] { xmlPath, xmlInfo.SchemaPath, });
}
else
{
var schemaPath = itemPath + CremaSchema.SchemaExtension;
return(new string[] { xmlPath, schemaPath, });
}
}
}
public CremaDataSet GetTableData(string repositoryPath, string tableXmlPath, string tableSchemaPath, long revision)
{
var tempPath = PathUtility.GetTempPath(true);
try
{
var revisionValue = revision == -1 ? this.Revision : revision;
var repoUri = this.GetUri(repositoryPath, revisionValue);
var xmlUri = this.GetUri(tableXmlPath, revisionValue);
var baseUri = this.GetDataBaseUri($"{repoUri}", $"{xmlUri}");
var xmlPath = this.Export(xmlUri, tempPath);
var xmlInfo = new CremaXmlReadInfo(xmlPath);
var schemaUri = UriUtility.Combine(UriUtility.GetDirectoryName(xmlUri), xmlInfo.RelativeSchemaPath + "@" + revisionValue);
var schemaPath = this.Export(schemaUri, tempPath);
var xsdInfo = new CremaSchemaReadInfo(schemaPath);
foreach (var item in xsdInfo.RelativeTypePaths)
{
var typeUri = UriUtility.Combine(UriUtility.GetDirectoryName(schemaUri), $"{item}@{revisionValue}");
this.Export(typeUri, tempPath);
}
var pureBaseUri = $"{baseUri}".Replace($"@{revisionValue}", string.Empty);
var pureTableXmlUri = $"{xmlUri}".Replace($"@{revisionValue}", string.Empty);
var dataBaseRelativeUri = UriUtility.MakeRelativeOfDirectory(pureTableXmlUri, pureBaseUri);
var dataBasePath = UriUtility.Combine(new Uri(xmlPath), dataBaseRelativeUri).LocalPath;
return(CremaDataSet.ReadFromDirectory(dataBasePath));
}
finally
{
DirectoryUtility.Delete(tempPath);
}
}
public void ReadMany(string[] typeFiles, string[] tableFiles)
{
#if USE_PARALLEL
Parallel.ForEach(typeFiles, item =>
{
this.ReadType(item);
});
#else
foreach (var item in typeFiles)
{
this.ReadType(item);
}
#endif
var readInfos = new List <CremaXmlReadInfo>(tableFiles.Length);
Parallel.ForEach(tableFiles, item =>
{
var info = new CremaXmlReadInfo(item);
lock (readInfos)
{
readInfos.Add(info);
}
});
#if USE_PARALLEL
Parallel.ForEach(readInfos.Where(i => i.IsInherited == false), item =>
{
this.ReadXmlSchema(item.SchemaPath, item.ItemName);
});
Parallel.ForEach(readInfos.Where(i => i.IsInherited), item =>
{
this.ReadXmlSchema(item.SchemaPath, item.ItemName);
});
#else
foreach (var item in readInfos.Where(i => i.IsInherited == false))
{
this.ReadXmlSchema(item.SchemaPath, item.ItemName);
}
foreach (var item in readInfos.Where(i => i.IsInherited))
{
this.ReadXmlSchema(item.SchemaPath, item.ItemName);
}
#endif
this.BeginLoad();
#if USE_PARALLEL
readInfos.Sort((x, y) => y.XmlSize.CompareTo(x.XmlSize));
var threadcount = 8;
var query = from item in readInfos
let key = readInfos.IndexOf(item) % threadcount
group item by key into g
select g;
var parallellist = new List <CremaXmlReadInfo>(readInfos.Count);
foreach (var item in query)
{
parallellist.AddRange(item);
}
try
{
Parallel.ForEach(parallellist, new ParallelOptions {
MaxDegreeOfParallelism = threadcount
}, item =>
{
this.ReadXml(item.XmlPath, item.ItemName);
});
}
catch (AggregateException e)
{
throw e.InnerException;
}
#else
foreach (var item in readInfos)
{
this.ReadXml(item.XmlPath, item.ItemName);
}
#endif
this.EndLoad();
}
