public void AddRange(IEnumerable <TModel> models)
{
var mapper = new RecordMapper();
foreach (TModel model in models)
{
_store.InsertRecord(mapper.MapToFields(model));
}
}
public PersonService(
RecordMapper <PersonBase, Person> recordMapper,
EntityMapper <Person, PersonBase> entityMapper,
MyDbContext dbContext)
{
_recordMapper = recordMapper;
_entityMapper = entityMapper;
_dbContext = dbContext;
}
/// <summary>
/// Async returns a RecordMapper<T>
/// </summary>
/// <param name="IAsyncResult "></param>
/// <param name="result"></param>
/// <returns>void</returns>
public static T EndExecuteAndGetInstance <T>(IAsyncResult ar, RecordMapper <T> recordMapper) where T : new()
{
T objectInstance = new T();
SqlCommand command = (SqlCommand)ar.AsyncState;
using (SqlDataReader reader = command.EndExecuteReader(ar))
{
recordMapper(new DataRecord(reader), objectInstance);
}
return(objectInstance);
}
//删除作废表格
internal static void DeleteErrorTable(uint incidentId)
{
if (incidentId == 1)
{
return;
}
for (uint i = 1; i < incidentId; i++)
{
RecordMapper.DeleteTable(i);
}
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
try
{
RecordMapper.map(value as string, map);
}
catch (Exception e)
{
return(new ValidationResult(false, e.Message));
}
return(ValidationResult.ValidResult);
}
public void Test_MapRecord_Properly_Maps_Record_With_ExtractedAssocations()
{
// arrange
var sourceRecord = new Dictionary<string, object> {
{"tblResponsible1", "value1"},
{"tblResponsible2", "value2"}};
var mapper = new RecordMapper(new AccountConversionRules());
// act
var mappedRecord = mapper.MapRecord(sourceRecord);
// assert
}
public void Test_MapRecord_Properly_Maps_Record()
{
// arrange
var preMappedRecord = new Dictionary<string, object> { { "tblContactLoginID", "ahaley"} };
var mapper = new RecordMapper(new AccountConversionRules());
// act
var mappedRecord = mapper.MapRecord(preMappedRecord);
// assert
Assert.IsTrue(mappedRecord.Keys.Contains("username"));
Assert.AreEqual("ahaley", mappedRecord["username"]);
}
public void Test_MapRecord_Does_Nothing_With_Null_Rules()
{
// arrange
var record = new Dictionary<string, object> {{"tblContactLoginID", "ahaley"}};
var mapper = new RecordMapper(null);
// act
var mappedRecord = mapper.MapRecord(record);
// assert
Assert.IsTrue(mappedRecord.Keys.Contains("tblContactLoginID"));
Assert.AreEqual("ahaley", mappedRecord["tblContactLoginID"]);
}
public void GetRecordById_WhenCalledCorrectly_Succeeds()
{
// Assemble
var recordRepository = new Mock <IRecordRepository>();
recordRepository.Setup(a => a.FindById(It.IsAny <long>()))
.Returns(RecordMapper.ToEntity(SampleData.SampleRecordData.ValidSampleRecord1()));
// Act
var record = recordRepository.Object.FindById(1);
// Assert
Assert.NotNull(record);
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
foreach (RecordViewModel record in (value as BindingGroup).Items)
{
try
{
RecordMapper.RecordToReportingInfo(record.Record);
}
catch (Exception e)
{
return(new ValidationResult(false, e.Message));
}
}
return(ValidationResult.ValidResult);
}
public void FindAll_WhenCalledCorrectly_Succeeds()
{
// Assemble
var recordRepository = new Mock <IRecordRepository>();
recordRepository.Setup(a => a.FindAll())
.Returns(new List <RecordEntity> {
RecordMapper.ToEntity(SampleData.SampleRecordData.ValidSampleRecord1())
});
// Act
var records = recordRepository.Object.FindAll();
// Assert
Assert.NotNull(records);
}
// 后续记录需要过滤掉未变化的重复项
private void SaveBeanForOtherRecord(RecordBean bean, RecordBean[] childDirBeans)
{
RecordBean targetBean = Extend.GetLastBean(bean.Path);
if (targetBean == null)
{
bean.IsChange = true;
}
else
{
bean.IsChange = bean.IsChange || !bean.Equals(targetBean);
}
//如果该bean没有变化，则不再记录
if (bean.IsChange)
{
bean.Id = RecordMapper.AddOne(bean, incidentId, false);
beanCount++;
//刷新索引
DirIndexMapper.RefreshIndex(new DirIndexBean()
{
Path = bean.Path,
IncidentId = incidentId,
TargectId = bean.Id,
});
foreach (RecordBean dirBean in childDirBeans)
{
if (dirBean.IsChange)
{
RecordMapper.SetParentId(dirBean.Id, bean.Id, incidentId);
}
else
{
//将未改变的bena也记录下来
dirBean.ParentId = bean.Id;
RecordMapper.AddOne(dirBean, incidentId, false);
beanCount++;
}
}
}
else
{
//为未改变节点添加索引
bean.IncidentId = targetBean.IncidentId;
bean.TargetId = targetBean.Id;
}
}
// 第一次记录
private void SaveBeanForFirstRecord(RecordBean bean, RecordBean[] childDirBeans)
{
//记录并获取当前id
bean.Id = RecordMapper.AddOne(bean, incidentId, true);
//记录索引
DirIndexMapper.AddOne(new DirIndexBean()
{
Path = bean.Path,
IncidentId = incidentId,
TargectId = bean.Id,
});
beanCount++;
//设置子一级的父id
foreach (RecordBean dirBean in childDirBeans)
{
RecordMapper.SetParentId(dirBean.Id, bean.Id, incidentId);
}
}
public void Test_MapRecord_Properly_Maps_Record_With_ExtractedColumns()
{
// arrange
var sourceRecord = new Dictionary<string, object> {
{"tblContactCat", "Developer"},
{"tblContactLoginID", "ahaley"}};
//var sourceColumn = "tblContactCat";
var extractedColumns = new ForeignKeyResolver();
extractedColumns.InsertID("Title", "Developer", 4);
var mapper = new RecordMapper(new AccountConversionRules(), extractedColumns);
// act
var mappedRecord = mapper.MapRecord(sourceRecord);
// assert
Assert.IsTrue(mappedRecord.Keys.Contains("title_id"));
Assert.AreEqual(4, mappedRecord["title_id"]);
}
//通过路径获取最新的记录节点
internal static RecordBean GetLastBean(string path)
{
DirIndexBean dirIndex = DirIndexMapper.GetOneByPath(path);
if (dirIndex == null)
{
return(null);
}
RecordBean bean = RecordMapper.GetOneById(dirIndex.TargectId, dirIndex.IncidentId);
if (bean == null)
{
return(null);
}
//告知该bean是属于哪一个事件的
bean.IncidentId = dirIndex.IncidentId;
return(bean);
}
/// <summary>
/// Creates a new T instance, executes a procedure and fires a mapping delegate and returns the T instance
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static T ExecuteAndGetInstance <T>(Database database, string procedureName, RecordMapper <T> recordMapper, params object[] parameters) where T : new()
{
T objectInstance = new T();
if (!ExecuteAndHydrateInstance(objectInstance, database, procedureName, recordMapper, parameters))
{
return(default(T));
}
return(objectInstance);
}
/// <summary>
/// Executes a procedure and for each row returned creates a T instance, fires a mapping delegate and add the instance to the return List.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static List <T> ExecuteAndGetInstanceList <T>(Database database, string procedureName, RecordMapper <T> recordMapper, params object[] parameters) where T : new()
{
List <T> instanceList = new List <T>();
ExecuteAndHydrateInstanceList(instanceList, database, procedureName, recordMapper, parameters);
return(instanceList);
}
/// <summary>
/// Executes a procedure and fires a mapping delegate and hydrates the T instance
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objectInstance"></param>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
public static bool ExecuteAndHydrateInstance <T>(T objectInstance, Database database, string procedureName, RecordMapper <T> recordMapper, params object[] parameters)
{
bool result = false;
try
{
using (IRecordSet reader = Procedure.Execute(database, procedureName, parameters))
{
if (reader.Read())
{
recordMapper(reader, objectInstance);
result = true;
}
}
}
catch (Core.Data.Exceptions.DataException) // Procedure class already wrapped all necessary data
{
throw;
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, typeof(T), e);
}
return(result);
}
/// <summary>
/// Executes a procedure and fires a mapping delegate and hydrates the T instance
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objectInstance"></param>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
public static bool ExecuteAndHydrateInstance <T>(T objectInstance, Database database, string procedureName, RecordMapper recordMapper, params object[] parameters)
{
return(ExecuteAndHydrateInstance <T>(objectInstance, database, procedureName,
delegate(IRecord reader, T instance)
{
recordMapper(reader);
}, parameters));
}
/// <summary>
/// Executes a single-result procedure and fires a mapping delegate for each row that is returned and then fires a parameter mapping delegate for output params.
/// </summary>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="parameterMapper"></param>
/// <param name="recordMapper"></param>
/// <param name="outputMapper"></param>
public static void ExecuteAndMapRecords(Database database, string procedureName, ParameterMapper parameterMapper, RecordMapper recordMapper, OutputParameterMapper outputMapper)
{
try
{
using (SqlConnection connection = database.GetConnection())
{
SqlCommand command = CommandFactory.CreateParameterMappedCommand(connection, procedureName, parameterMapper);
connection.Open();
IRecordSet reader = new DataRecord(command.ExecuteReader(CommandBehavior.CloseConnection));
while (reader.Read())
{
recordMapper(reader);
}
connection.Close();
if (outputMapper != null)
{
outputMapper(new ParameterSet(command.Parameters));
}
}
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, e);
}
}
/// <summary>
/// Executes a single-result procedure and fires a mapping delegate for each row that is returned.
/// </summary>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
public static void ExecuteAndMapRecords(Database database, string procedureName, RecordMapper recordMapper, params object[] parameters)
{
try
{
using (IRecordSet reader = Procedure.Execute(database, procedureName, parameters))
{
while (reader.Read())
{
recordMapper(reader);
}
}
}
catch (Core.Data.Exceptions.DataException) // Procedure class already wrapped all necessary data
{
throw;
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, e);
}
}
public RecordModel FindById(long id)
{
return(RecordMapper.ToModel(_recordRepository.FindById(id)));
}
/// <summary>
/// Executes a single-result procedure and fires a mapping delegate for each row that is returned.
/// </summary>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="parameterMapper"></param>
/// <param name="recordMapper"></param>
public static void ExecuteAndMapRecords(Database database, string procedureName, ParameterMapper parameterMapper, RecordMapper recordMapper)
{
try
{
using (IRecordSet reader = Procedure.Execute(database, procedureName, parameterMapper))
{
while (reader.Read())
{
recordMapper(reader);
}
}
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, e);
}
}
public void Test_MapRecord_With_Missing_ExtractColumn_Ignores_Record()
{
// arrange
var sourceRecord = new Dictionary<string, object> { { "tblContactCat", "Developer" } };
var extractedColumns = new ForeignKeyResolver(); // purposefully not loading it with id, field
var mapper = new RecordMapper(new AccountConversionRules(), extractedColumns);
// act
var mappedRecord = mapper.MapRecord(sourceRecord);
// assert
Assert.IsFalse(mappedRecord.Keys.Contains("title_id"));
}
public void Update(RecordModel entity)
{
_recordRepository.Update(RecordMapper.ToEntity(entity));
}
public void Test()
{
var dbdef = new DatabaseDefinition()
.Table("KV")
.Column("Key").AsString().NotNull().Table
.Column("Value").AsText().NotNull().Table
.Index("IX_KV_Key").Asc("Key").Primary().Table
.Database;
var db = new EsentDatabase(@"c:\temp\fluesent\a.db");
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession(false))
{
session.CreateDatabase(null, CreateDatabaseGrbit.OverwriteExisting);
using (var transaction = session.CreateTransaction())
{
dbdef.Create(transaction);
transaction.Commit();
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
table.CreateInsertRecord()
.AddString("Key", "A")
.AddString("Value", "Some text")
.Insert();
table.CreateInsertRecord()
.AddString("Key", "B")
.AddString("Value", "Another text")
.Insert();
table.CreateInsertRecord()
.AddString("Key", "C")
.AddString("Value", "Text for C")
.Insert();
}
transaction.Commit();
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
var stopwatch = new EsentStopwatch();
stopwatch.Start();
const int n = 100000;
using (var table = transaction.OpenTable("KV"))
{
foreach (var i in Enumerable.Range(0, n))
{
table.CreateInsertRecord()
.AddString("Key", "key" + i)
.AddString("Value", "akjsdhakhdkadhkajhd")
.Insert();
if ((i % 1000) == 999)
{
transaction.Pulse();
}
}
}
transaction.Commit();
stopwatch.Stop();
Console.Out.WriteLine("Inserted {0} records in {1}", n, stopwatch.Elapsed);
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
var mapper = new RecordMapper<KvRecord>()
.String("Key", (o, s) => o.Key = s)
.String("Value", (o, s) => o.Value = s);
//var search = table.CreateSearch(mapper);
//var a = search.FindEq(
// table.CreateKey().String("A")
// )
// .ToArray();
//var b = search.FindEq(
// table.CreateKey().String("B")
// )
// .ToArray();
}
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
session.AttachDatabase();
session.OpenDatabase();
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
var mapper = new RecordMapper<KvRecord>()
.String("Key", (o, s) => o.Key = s)
.String("Value", (o, s) => o.Value = s);
//var search = table.CreateSearch(mapper);
//foreach (var record in search.FindAll().Take(100))
//{
// Console.Out.WriteLine("({0},{1})",record.Key,record.Value);
//}
}
}
}
}
}
/// <summary>
/// 通过节点获取文件夹的比较信息
/// </summary>
public static ComparisonInfo GetInfoByNode(DirNode node)
{
//获取bean
RecordBean oldBean = null;
if (node.OldId != 0)
{
oldBean = RecordMapper.GetOneById(node.OldId, node.OldIncidentId);
}
RecordBean newBean = null;
if (node.NewId != 0)
{
newBean = RecordMapper.GetOneById(node.NewId, node.NewIncidentId);
}
//设置标签
ComparisonInfo info = new ComparisonInfo()
{
TagName = string.Concat("标签：", node.Tag.Name ?? "没有标签")
};
//设置主要比较的数据
BigInteger oldSize, newSize, oldUsage, newUsage;
if (oldBean != null)
{
info.Title = oldBean.Name;
info.Location = oldBean.Location;
info.CreateTime = "创建时间：" + oldBean.CerateTime.ToString("yy-MM-dd HH:mm:ss");
info.OldFileCount = Convert.ToInt32(oldBean.FileCount);
info.OldDirCount = Convert.ToInt32(oldBean.DirCount);
oldSize = oldBean.Size;
oldUsage = oldBean.SpaceUsage;
}
else
{
oldSize = BigInteger.Zero;
oldUsage = BigInteger.Zero;
}
if (newBean != null)
{
info.Title = newBean.Name;
info.Location = newBean.Location;
info.CreateTime = "创建时间：" + newBean.CerateTime.ToString("yy-MM-dd HH:mm:ss");
info.NewFileCount = Convert.ToInt32(newBean.FileCount);
info.NewDirCount = Convert.ToInt32(newBean.DirCount);
newSize = newBean.Size;
newUsage = newBean.SpaceUsage;
}
else
{
newSize = BigInteger.Zero;
newUsage = BigInteger.Zero;
}
//单位换算
info.OldSize = ConversionUtil.StorageFormate(oldSize, false);
info.NewSize = ConversionUtil.StorageFormate(newSize, false);
info.SizeChanged = ConversionUtil.StorageFormate(newSize - oldSize, true);
info.OldUsage = ConversionUtil.StorageFormate(oldUsage, false);
info.NewUsage = ConversionUtil.StorageFormate(newUsage, false);
info.UsageChanged = ConversionUtil.StorageFormate(newUsage - oldUsage, true);
//设置状态
switch (node.Type)
{
case DirNodeType.Unchanged:
info.Action = "文件夹未发生变化";
break;
case DirNodeType.Added:
info.Action = "该文件夹是新增的文件夹";
break;
case DirNodeType.Changed:
info.Action = "该文件夹发生了变化";
break;
case DirNodeType.Deleted:
info.Action = "该文件夹已经被删除";
break;
}
return(info);
}
/// <summary>
/// 建立该节点的子节点
/// </summary>
/// <param name="node">文件夹节点</param>
public static void BuildChildrenNodes(DirNode node)
{
//获取对应节点下的文件夹列表
RecordBean[] oldBeans;
if (node.OldIncidentId == 0)
{
oldBeans = new RecordBean[0];
}
else
{
oldBeans = RecordMapper.GetBeansByPid(node.OldId, node.OldIncidentId);
}
RecordBean[] newBeans;
if (node.NewIncidentId == 0)
{
newBeans = new RecordBean[0];
}
else
{
newBeans = RecordMapper.GetBeansByPid(node.NewId, node.NewIncidentId);
}
List <DirNode> dirNodes = new List <DirNode>();
//遍历两个文件夹列表
foreach (RecordBean oldBean in oldBeans)
{
RecordBean newBean = null;
//去除重复项
for (int i = 0; i < newBeans.Length; i++)
{
if (newBeans[i] == null)
{
continue;
}
if (oldBean.Path == newBeans[i].Path)
{
newBean = newBeans[i];
newBeans[i] = null;
}
}
//建立node
DirNode dirNode = new DirNode()
{
Name = oldBean.Name,
Path = oldBean.Path,
// 放入一个空数组，告知页面该节点可以展开
Children = oldBean.DirCount > 0 ? new DirNode[1] : null,
};
SetOldId(ref dirNode, oldBean, node.OldIncidentId);
//设置类型
if (newBean != null)
{
SetNewId(ref dirNode, newBean, node.NewIncidentId);
if (oldBean.Equals(newBean))
{
dirNode.Type = DirNodeType.Unchanged;
}
else
{
dirNode.Type = DirNodeType.Changed;
}
}
else
{
dirNode.Type = DirNodeType.Deleted;
}
dirNodes.Add(dirNode);
}
//新纪录中新增的部分
foreach (RecordBean newBean in newBeans)
{
if (newBean == null)
{
continue;
}
DirNode dirNode = new DirNode()
{
Name = newBean.Name,
Path = newBean.Path,
Children = newBean.DirCount > 0 ? new DirNode[1] : null,
//新增的节点
Type = DirNodeType.Added,
};
SetNewId(ref dirNode, newBean, node.NewIncidentId);
dirNodes.Add(dirNode);
}
//添加标签
TagBean nullTag = new TagBean()
{
Color = "#FFFFFF"
};
foreach (DirNode dirNode in dirNodes)
{
TagBean tagBean = TagSupport.GetTagByPath(dirNode.Path, out bool isThis);
if (tagBean == null)
{
dirNode.Tag = nullTag;
continue;
}
dirNode.IsRootTag = isThis;
dirNode.Tag = tagBean;
}
node.Children = dirNodes.ToArray();
}
public void AddOne(object obj)
{
DateTime startTime = DateTime.Now;
Thread.Sleep(1000);
object[] objs = (object[])obj;
ProgramWindow programWindow = (ProgramWindow)objs[0];
IncidentBean bean = (IncidentBean)objs[1];
programWindow.WriteLine("初始化...");
try
{
//处理事件
bean.CreateTime = DateTime.Now;
bean.State = 1;
incidentId = IncidentMapper.AddOne(bean);
isFirst = IncidentMapper.IsFirstRecord();
//第一次记录必须保证索引表为空
if (isFirst)
{
DirIndexMapper.CleanAll();
}
//新建记录表
Extend.BuildTable(incidentId, isFirst);
programWindow.WriteLine("开始记录硬盘使用空间...");
programWindow.WriteLine("(建议此时不要修改硬盘上的文件，以免影响最终的分析结果)");
programWindow.Freeze();
isRunning = true;
Thread showProgress = new Thread(ShowProgress)
{
Name = "showProgress"
};
showProgress.Start(programWindow);
DriveInfo[] drives = DriveInfo.GetDrives();
//遍历分区
foreach (DriveInfo drive in drives)
{
DirectoryInfo rootDir = new DirectoryInfo(drive.Name);
SeeDirectory(rootDir, 0);
}
isRunning = false;
programWindow.WriteAll("记录完成，建立索引...\n");
Extend.BuildIndex(incidentId);
//收尾工作
long count = RecordMapper.Count(incidentId);
IncidentMapper.SetStateById(incidentId, 0);
if (isFirst)
{
//删除以前记录失败的作废表格
Extend.DeleteErrorTable(incidentId);
}
TimeSpan consumption = DateTime.Now - startTime;
Log.Info(string.Format("数据记录完成, 记录：{0}({1}), 耗时：{2}", count, beanCount, consumption));
programWindow.WriteLine(string.Format("数据记录完成，耗时：{0}小时{1}分。",
consumption.Days * 24 + consumption.Hours, consumption.Minutes));
programWindow.RunOver();
}
catch (Exception e)
{
Log.Add(e);
isRunning = false;
programWindow.WriteLine("\n错误：");
programWindow.WriteLine(e.Message);
programWindow.RunOver();
//throw e;
}
}
/// <summary>
/// Executes a procedure and for each row returned creates a T instance, fires a mapping delegate and add the instance to a List.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instanceList"></param>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
public static void ExecuteAndHydrateInstanceList <T>(List <T> instanceList, Database database, string procedureName, RecordMapper recordMapper, params object[] parameters) where T : new()
{
try
{
using (IRecordSet reader = Procedure.Execute(database, procedureName, parameters))
{
while (reader.Read())
{
T objectInstance = new T();
recordMapper(reader);
instanceList.Add(objectInstance);
}
}
}
catch (Core.Data.Exceptions.DataException) // Procedure class already wrapped all necessary data
{
throw;
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, typeof(T), e);
}
}
/// <summary>
/// Executes a procedure and for each row returned creates a T instance, fires a mapping delegate and adds the instance to a dictionary. First column returned must be the int key.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="recordMapper"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static Dictionary <int, T> ExecuteAndGetDictionary <T>(Database database, string procedureName, RecordMapper <T> recordMapper, params object[] parameters) where T : new()
{
try
{
Dictionary <int, T> dictionaryList = new Dictionary <int, T>();
using (IRecordSet reader = Procedure.Execute(database, procedureName, parameters))
{
while (reader.Read())
{
T objectInstance = new T();
recordMapper(reader, objectInstance);
dictionaryList[reader.GetInt32(0)] = objectInstance;
}
}
return(dictionaryList);
}
catch (Core.Data.Exceptions.DataException) // Procedure class already wrapped all necessary data
{
throw;
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, typeof(T), e);
}
}
public Enumerator(DataStore store)
{
_store = store;
_mapper = new RecordMapper();
}
public void Add(TModel model)
{
var mapper = new RecordMapper();
_store.InsertRecord(mapper.MapToFields(model));
}
//public static bool ExecuteAndHydrateInstance<T>(T objectInstance,Database database, string procedureName, ParameterMapper parameterMapper, RecordMapper<T> recordMapper)
//{
// bool result = false;
// return result;
//}
public static bool ExecuteAndHydrateInstance <T>(T objectInstance, Database database,
string procedureName, ParameterMapper parameterMapper, RecordMapper <T> recordMapper)
{
bool result = false;
try
{
using (IRecordSet reader = Procdure.Execute(database, procedureName, parameterMapper))
{
if (reader.Read())
{
recordMapper(reader, objectInstance);
result = true;
}
}
}
catch (Exception ex) // Procedure class already wrapped all necessary data
{
throw ex;
}
return(result);
}
