public T ReadInternal <T>(ILogin login, Func <T, bool> where = null)
where T : class, IEquatable <T>, new()
{
SettingFileAttribute attr = GetSettingAttrute <T>();
IEnumerable <T> settings = Singleton?.ReadFile <T>(attr);
if (settings == null)
{
return(null);
}
bool isIndividualUser = typeof(IIndividualUserSetting)
.IsAssignableFrom(typeof(T));
if (isIndividualUser && login == null)
{
throw new ArgumentNullException(nameof(login));
}
if (isIndividualUser)
{
IEnumerable <T> values = (where == null)
? settings
: settings.Where(where);
T individual = values
.Cast <IIndividualUserSetting>()
.FirstOrDefault(i => i.CompanyCode == login.CompanyCode &&
i.UserCode == login.UserCode) as T;
return(individual);
}
return((where == null)
? settings.FirstOrDefault()
: settings.FirstOrDefault(where));
}
private SettingFileAttribute GetSettingAttrute <T>()
where T : class, IEquatable <T>, new()
{
SettingFileAttribute setting = typeof(T)
.GetCustomAttributes(typeof(SettingFileAttribute), false)
.FirstOrDefault() as SettingFileAttribute;
if (setting == null)
{
throw new InvalidOperationException();
}
return(setting);
}
public virtual void SaveFile <T>(SettingFileAttribute attr, object target)
{
string filePath = attr.GetFilePath();
Type rootType = attr.ContainerType ?? typeof(T);
var serializer = new DataContractSerializer(rootType, rootType.Name, string.Empty);
using (var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
using (var writer = XmlWriter.Create(stream,
new XmlWriterSettings()
{
Encoding = Encoding.GetEncoding(932)
}))
{
serializer.WriteObject(writer, target);
}
}
public virtual void SaveInternal <T>(T setting)
where T : class, IEquatable <T>, new()
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
SettingFileAttribute attr = GetSettingAttrute <T>();
IList <T> settings = Singleton.ReadFile <T>(attr);
object target = null;
if (attr.ContainerType == null)
{
target = setting;
}
else
{
if (settings == null)
{
settings = Activator.CreateInstance(attr.ContainerType) as IList <T>;
}
T original = settings.FirstOrDefault(i => i.Equals(setting));
if (original == null)
{
settings.Add(setting);
}
else
{
int index = settings.IndexOf(original);
settings[index] = setting;
}
target = settings;
}
Singleton.SaveFile <T>(attr, target);
}
public virtual IList <T> ReadFile <T>(SettingFileAttribute attr)
where T : class, IEquatable <T>, new()
{
string filePath = attr.GetFilePath();
if (!System.IO.File.Exists(filePath))
{
return(null);
}
var serializer = new DataContractSerializer(attr.ContainerType ?? typeof(T));
using (var reader = XmlReader.Create(filePath))
{
if (attr.ContainerType == null)
{
return(new T[] { serializer.ReadObject(reader) as T });
}
else
{
return(serializer.ReadObject(reader) as IList <T>);
}
}
}
