CoreRow.cs 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Linq.Expressions;
  6. namespace InABox.Core
  7. {
  8. [Serializable]
  9. public class CoreRow : ICoreRow, IEnumerable<KeyValuePair<string, object?>>
  10. {
  11. #region Fields
  12. [NonSerialized]
  13. private static Dictionary<int, string> _accessedcolumns = new Dictionary<int, string>();
  14. [NonSerialized]
  15. private Dictionary<string, int> _columnindexes = new Dictionary<string, int>();
  16. #endregion
  17. #region Properties
  18. [DoNotSerialize]
  19. [field: NonSerialized]
  20. public CoreTable Table { get; private set; }
  21. public List<object?> Values { get; private set; }
  22. [DoNotSerialize]
  23. public int Index => Table.Rows.IndexOf(this);
  24. #endregion
  25. protected internal CoreRow(CoreTable owner)
  26. {
  27. Table = owner;
  28. Values = new List<object?>(owner.Columns.Count);
  29. }
  30. public static CoreRow[] None
  31. {
  32. get { return new CoreRow[] { }; }
  33. }
  34. //private DynamicObject rowObject;
  35. public Dictionary<string, object?> ToDictionary(string[]? exclude = null)
  36. {
  37. var result = new Dictionary<string, object?>();
  38. var columns = exclude == null
  39. ? Table.Columns
  40. : Table.Columns.Where(x => !exclude.Contains(x.ColumnName));
  41. foreach (var column in columns)
  42. result[column.ColumnName] = this[column.ColumnName];
  43. return result;
  44. }
  45. [DoNotSerialize]
  46. public object? this[string columnName]
  47. {
  48. get =>
  49. //return this.RowObject.GetValue<object>(columnName);
  50. Get<object>(columnName);
  51. set =>
  52. //this.RowObject.SetValue(columnName, value);
  53. Set(columnName, value);
  54. }
  55. /// <summary>
  56. /// Fill an object with the data from this row.
  57. /// </summary>
  58. /// <remarks>
  59. /// If <paramref name="overrideExisting"/> is <see langword="true"/>, then the data in the row will override the data in <paramref name="obj"/>,
  60. /// even if that column has previously been loaded (i.e., it is in <see cref="BaseObject.LoadedColumns"/>).
  61. /// </remarks>
  62. /// <param name="t">The type of <paramref name="obj"/>.</param>
  63. /// <param name="obj">The object to fill.</param>
  64. /// <param name="overrideExisting">Override any data which already exists in <paramref name="obj"/>.</param>
  65. public void FillObject(Type t, BaseObject obj, bool overrideExisting = false)
  66. {
  67. obj.SetObserving(false);
  68. if (!Table.Setters.TryGetValue("", out var setters))
  69. {
  70. setters = new List<Action<object, object>?>();
  71. Table.Setters[""] = setters;
  72. }
  73. var bFirst = !setters.Any();
  74. for (var i = 0; i < Table.Columns.Count; i++)
  75. {
  76. var column = Table.Columns[i].ColumnName;
  77. var value = i < Values.Count
  78. ? Values[i]
  79. : CoreUtils.GetDefault(Table.Columns[i].DataType);
  80. try
  81. {
  82. if (obj.LoadedColumns.Add(column) || overrideExisting)
  83. {
  84. if (bFirst)
  85. {
  86. var prop = DatabaseSchema.Property(t, column);
  87. setters.Add(prop?.Setter());
  88. }
  89. var setter = setters[i];
  90. if (setter != null && value != null && !(value is System.DBNull))
  91. setter.Invoke(obj, value);
  92. else
  93. CoreUtils.SetPropertyValue(obj, column, value);
  94. }
  95. }
  96. catch (Exception e)
  97. {
  98. Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
  99. }
  100. }
  101. obj.SetObserving(true);
  102. }
  103. /// <summary>
  104. /// Fill an object with the data from this row.
  105. /// </summary>
  106. /// <remarks>
  107. /// If <paramref name="overrideExisting"/> is <see langword="true"/>, then the data in the row will override the data in <paramref name="obj"/>,
  108. /// even if that column has previously been loaded (i.e., it is in <see cref="BaseObject.LoadedColumns"/>).
  109. /// </remarks>
  110. /// <param name="obj">The object to fill.</param>
  111. /// <param name="overrideExisting">Override any data which already exists in <paramref name="obj"/>.</param>
  112. public void FillObject<T>(T obj, bool overrideExisting = false) where T : BaseObject
  113. {
  114. FillObject(typeof(T), obj, overrideExisting: overrideExisting);
  115. }
  116. public BaseObject ToObject(Type t)
  117. {
  118. var entity = (Activator.CreateInstance(t) as BaseObject)!;
  119. FillObject(t, entity, overrideExisting: true);
  120. return entity;
  121. }
  122. public T ToObject<T>() where T : BaseObject, new()
  123. {
  124. return (ToObject(typeof(T)) as T)!;
  125. }
  126. public T Get<T>(int col, bool usedefault = true)
  127. {
  128. if (col < 0 || col >= Values.Count)
  129. {
  130. if (usedefault)
  131. return CoreUtils.GetDefault<T>();
  132. throw new Exception(string.Format("Column [{0}] does not exist!", col));
  133. }
  134. return Values[col] != null ? (T)CoreUtils.ChangeType(Values[col], typeof(T)) : CoreUtils.GetDefault<T>();
  135. }
  136. public T Get<T>(string columnname, bool usedefault = true)
  137. {
  138. var col = GetColumn(columnname);
  139. if (col < 0 || col >= Values.Count)
  140. {
  141. if (usedefault)
  142. return CoreUtils.GetDefault<T>();
  143. throw new Exception(string.Format("Column [{0}] does not exist!", columnname));
  144. }
  145. return Values[col] != null ? (T)CoreUtils.ChangeType(Values[col], typeof(T)) : CoreUtils.GetDefault<T>();
  146. }
  147. public TType Get<TSource, TType>(Expression<Func<TSource, TType>> expression, bool usedefault = true)
  148. {
  149. var colname = GetColName(expression);
  150. //String colname = CoreUtils.GetFullPropertyName(expression, ".");
  151. return Get<TType>(colname, usedefault);
  152. }
  153. public void Set<TSource, TType>(Expression<Func<TSource, TType>> expression, TType value)
  154. {
  155. var colname = GetColName(expression);
  156. //String colname = CoreUtils.GetFullPropertyName(expression, ".");
  157. Set(colname, value);
  158. }
  159. public void Update<TSource, TType>(Expression<Func<TSource, TType>> expression, Func<TType, TType> update)
  160. {
  161. var colname = GetColName(expression);
  162. //String colname = CoreUtils.GetFullPropertyName(expression, ".");
  163. Set(colname, update(Get<TType>(colname)));
  164. }
  165. public void Set<T>(int col, T value)
  166. {
  167. if(Values.Count <= col)
  168. {
  169. while (Values.Count < col)
  170. Values.Add(Table.Columns[Values.Count].DataType.GetDefault());
  171. Values.Add(value);
  172. }
  173. else
  174. {
  175. Values[col] = value;
  176. }
  177. }
  178. public void Set<T>(string columnname, T value)
  179. {
  180. var col = GetColumn(columnname);
  181. if (col < 0)
  182. throw new Exception("Column not found: " + columnname);
  183. if(Values.Count <= col)
  184. {
  185. while (Values.Count < col)
  186. Values.Add(Table.Columns[Values.Count].DataType.GetDefault());
  187. Values.Add(value);
  188. }
  189. else
  190. {
  191. Values[col] = value;
  192. }
  193. //this.RowObject.SetValue(columnname, value);
  194. }
  195. public void LoadValues(IEnumerable<object?> values)
  196. {
  197. Values = values.ToList();
  198. }
  199. public T ToObject<TSource, TLink, T>(Expression<Func<TSource, TLink>> property)
  200. where TLink : IEntityLink<T>
  201. where T : BaseObject, new()
  202. {
  203. var entity = new T();
  204. entity.SetObserving(false);
  205. var prefix = CoreUtils.GetFullPropertyName(property, ".");
  206. if (!Table.Setters.TryGetValue(prefix, out var setters))
  207. {
  208. setters = new List<Action<object, object>?>();
  209. Table.Setters[prefix] = setters;
  210. }
  211. var bFirst = !setters.Any();
  212. var cols = Table.Columns.Where(x => x.ColumnName.StartsWith(prefix + ".")).ToArray();
  213. for (var i = 0; i < cols.Length; i++)
  214. {
  215. var column = cols[i].ColumnName;
  216. var prop = column.Substring((prefix + ".").Length);
  217. var value = this[column];
  218. try
  219. {
  220. if (bFirst)
  221. {
  222. var p2 = DatabaseSchema.Property(typeof(T), prop);
  223. setters.Add(p2?.Setter());
  224. }
  225. var setter = setters[i];
  226. if (setter != null && value != null)
  227. setter.Invoke(entity, value);
  228. else
  229. CoreUtils.SetPropertyValue(entity, prop, value);
  230. }
  231. catch (Exception e)
  232. {
  233. Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
  234. }
  235. }
  236. entity.CommitChanges();
  237. entity.SetObserving(true);
  238. return entity;
  239. }
  240. private string GetColName<TSource, TType>(Expression<Func<TSource, TType>> expression)
  241. {
  242. //int hash = expression.GetHashCode();
  243. //if (_accessedcolumns.ContainsKey(hash))
  244. // return _accessedcolumns[hash];
  245. var colname = CoreUtils.GetFullPropertyName(expression, ".");
  246. //_accessedcolumns[hash] = colname;
  247. return colname;
  248. }
  249. private int GetColumn(string columnname)
  250. {
  251. if (_columnindexes.TryGetValue(columnname, out var index))
  252. return index;
  253. index = Table.GetColumnIndex(columnname);
  254. _columnindexes[columnname] = index;
  255. return index;
  256. }
  257. #region IEnumerable
  258. public IEnumerable<KeyValuePair<string, object?>> Entries
  259. {
  260. get
  261. {
  262. var columns = Table.Columns;
  263. for (var i = 0; i < columns.Count; i++)
  264. {
  265. var column = columns[i];
  266. var value = i < Values.Count
  267. ? Values[i]
  268. : CoreUtils.GetDefault(column.DataType);
  269. yield return new KeyValuePair<string, object?>(column.ColumnName, value);
  270. }
  271. }
  272. }
  273. public IEnumerator<KeyValuePair<string, object?>> GetEnumerator() => Entries.GetEnumerator();
  274. IEnumerator IEnumerable.GetEnumerator() => Entries.GetEnumerator();
  275. #endregion
  276. }
  277. public static class CoreRowExtensions
  278. {
  279. public static IEnumerable<T> ToObjects<T>(this IEnumerable<CoreRow> rows)
  280. where T : BaseObject, new()
  281. {
  282. return rows.Select(x => x.ToObject<T>());
  283. }
  284. public static List<T> ToList<T>(this IList<CoreRow> rows)
  285. where T : BaseObject, new()
  286. {
  287. var result = new List<T>(rows.Count);
  288. for (var i = 0; i < rows.Count; ++i)
  289. {
  290. result.Add(rows[i].ToObject<T>());
  291. }
  292. return result;
  293. }
  294. public static T[] ToArray<T>(this IList<CoreRow> rows)
  295. where T : BaseObject, new()
  296. {
  297. var result = new T[rows.Count];
  298. for (var i = 0; i < rows.Count; ++i)
  299. {
  300. result[i] = rows[i].ToObject<T>();
  301. }
  302. return result;
  303. }
  304. }
  305. }