Set version to 1.5.3

Added overloading methods for easier access

Database-Attribute_System/Attributes/DbForeignObject.cs

@@ -26,14 +26,15 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
             this._foreignKeyName = foreignKeyName;
         }
 
-        public void Init(FieldInfo fi, DbObject classAttribute)
+        public void Init(FieldInfo fi, DbObject classAttribute, DbObject foreignClassAttribute = null)
         {
             this.parentField = fi;
             this.classAttribute = classAttribute;
             this.foreignObjectType = fi.FieldType;
 
             // Init foreign-object class
-            DbObject foreignClassAttribute = ClassAction.Init(this.foreignObjectType);
+            if(foreignClassAttribute == null)
+                foreignClassAttribute = ClassAction.Init(this.foreignObjectType);
 
             // Check if something is weird
             if (foreignClassAttribute.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"'{foreignClassAttribute.parentClassType.Name}' does not have a primaryKey.");

Database-Attribute_System/Attributes/DbIntermediateForeignObject.cs

@@ -41,15 +41,12 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
             this.classAttribute = classAttribute;
             this.foreignObjectType = fi.FieldType;
 
-            // Init foreign-object class
-            DbObject foreignClassAttribute = ClassAction.Init(this.foreignObjectType);
-
             if (classAttribute.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"'{classAttribute.parentClassType.Name}' does not have a primaryKey.");
             if (classAttribute.primaryKeyAttributes.Count > 1) throw new InvalidOperationException($"IntermediateObject does not support multiple primaryKeys.");
             // Get primaryKey name if none is set
             if (_keyName == null) _keyName = classAttribute.primaryKeyAttributes[0]._attributeName;
 
-            if (!(fi.FieldType is IList && fi.FieldType.IsGenericType))  // 1:m
+            if (!(fi.FieldType.IsGenericType && (fi.FieldType.GetGenericTypeDefinition() == typeof(List<>))))  // 1:m
                 throw new InvalidOperationException($"IntermediateObject has to be typeof(List<T>). Maybe you meant to use DbForeignObject or DbReverseForeignObject for 1:m or 1:1 relations.");
 
             // Check the generic list and get inner-type
@@ -66,13 +63,14 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
             }
             if (foreignObjectType == null) throw new InvalidOperationException("Could not read innter-type of generic-list!");
 
-            // Now get the primaryKey from my foreignObject
-            DbObject foreignDbObject = ClassAction.Init(foreignObjectType);
+            // Init inner-type class
+            DbObject foreignClassAttribute = ClassAction.Init(foreignObjectType);
+
             // Check the primaryKey/s
-            if (foreignDbObject.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"'{foreignDbObject.parentClassType.Name}' does not have a primaryKey.");
-            if (foreignDbObject.primaryKeyAttributes.Count > 1) throw new InvalidOperationException($"IntermediateObject does not support multiple primaryKeys. (Found '{foreignDbObject.primaryKeyAttributes.Count}' in '{foreignDbObject.parentClassType.Name}')");
+            if (foreignClassAttribute.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"'{foreignClassAttribute.parentClassType.Name}' does not have a primaryKey.");
+            if (foreignClassAttribute.primaryKeyAttributes.Count > 1) throw new InvalidOperationException($"IntermediateObject does not support multiple primaryKeys. (Found '{foreignClassAttribute.primaryKeyAttributes.Count}' in '{foreignClassAttribute.parentClassType.Name}')");
             // Save it
-            foreignPrimaryKeyAttribute = foreignDbObject.primaryKeyAttributes[0];
+            foreignPrimaryKeyAttribute = foreignClassAttribute.primaryKeyAttributes[0];
 
             if (_foreignKeyName == null) _foreignKeyName = foreignPrimaryKeyAttribute._attributeName;
         }

Database-Attribute_System/Attributes/DbObject.cs

@@ -13,6 +13,7 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
         public string _tableName;
 
         public Type parentClassType;
+        public ConstructorInfo parentCInfo;
 
         // All childrenAttributes
         public List<BaseAttribute> baseAttributes = new List<BaseAttribute>() { };
@@ -35,6 +36,8 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
         public void Init(Type classType)
         {
             this.parentClassType = classType;
+            parentCInfo = classType.GetConstructor(Type.EmptyTypes);
+
             this._tableName = this._tableName ?? classType.Name;    // If no alternative table-name is specified, use the class-name
 
             // Iterate thru all fields
@@ -66,7 +69,10 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
                     }
                     else if (fi.GetCustomAttribute(typeof(DbForeignObject), true) is DbForeignObject fobj)    // ForeignObjects
                     {
-                        fobj.Init(fi, this);
+                        if(fi.FieldType == this.parentClassType)    // Check if we are referencing ourselfes
+                            fobj.Init(fi, this, this);
+                        else
+                            fobj.Init(fi, this);
 
                         this.foreignObjectAttributes.Add(fobj);
                     }

Database-Attribute_System/Attributes/DbReverseForeignObject.cs

@@ -32,14 +32,31 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System.Attributes
             this.classAttribute = classAttribute;
             this.foreignObjectType = fi.FieldType;
 
-            // Init foreign-object class
-            DbObject foreignClassAttribute = ClassAction.Init(this.foreignObjectType);
-
             if (classAttribute.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"'{classAttribute.parentClassType.Name}' does not have a primaryKey.");
             if (classAttribute.primaryKeyAttributes.Count > 1) throw new InvalidOperationException($"ReverseForeignObject does not support multiple primaryKeys.");
             // Get primaryKey name if none is set
             if (_foreignKeyName == null) _foreignKeyName = classAttribute.primaryKeyAttributes[0]._attributeName;
 
+            // If its a List, get inner type
+            if (fi.FieldType.IsGenericType && (fi.FieldType.GetGenericTypeDefinition() == typeof(List<>)))
+            {
+                // Check the generic list and get inner-type
+                foreach (Type interfaceType in fi.FieldType.GetInterfaces())
+                {
+                    if (interfaceType.IsGenericType &&
+                        interfaceType.GetGenericTypeDefinition()
+                        == typeof(IList<>))
+                    {
+                        foreignObjectType = fi.FieldType.GetGenericArguments()[0];
+                        break;
+                    }
+                }
+                if (foreignObjectType == null) throw new InvalidOperationException("Could not read innter-type of generic-list!");
+            }
+
+            // Init inner-type class
+            DbObject foreignClassAttribute = ClassAction.Init(foreignObjectType);
+
             // Check if my primary-key is set in the foreign-class as foreignKey
             DbPrimaryKey primaryKey = classAttribute.primaryKeyAttributes[0];
             foreach (DbForeignKey foreignKey in foreignClassAttribute.foreignKeyAttributes)

Database-Attribute_System/ClassAction.cs

@@ -27,8 +27,8 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
                 // Check if given class is marked as dbObject
                 if (!(classType.GetCustomAttribute(typeof(DbObject), true) is DbObject dbObject)) throw new InvalidOperationException($"Cannot init '{classType.Name}'. Missing Attribute 'DbObject'");
 
-                dbObject.Init(classType);   // Init dbObject
                 initiatedClassTypes.Add(classType, dbObject);     // Set it to the list
+                dbObject.Init(classType);   // Init dbObject
 
                 cachedDbObject = dbObject;
             }
@@ -36,7 +36,6 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
             return cachedDbObject;
         }
 
-
         /// <summary>
         /// Fills an given dbObject with given data<para/>
         /// Data-attribute-names and class-fieldNames have to match! (non case-sensitive)
@@ -44,6 +43,21 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         /// <typeparam name="T"></typeparam>
         /// <param name="classObject">Given object (marked with Db-attributes)</param>
         /// <param name="data">The data</param>
+        /// <param name="key">Key-name of data</param>
+        public static void FillObject<T>(T classObject, string key, object data)
+        {
+            Dictionary<string, object> dicData = new Dictionary<string, object>();
+            dicData.Add(key, data);
+            FillObject<T>(classObject, dicData);
+        }
+        /// <summary>
+        /// Fills an given dbObject with given data<para/>
+        /// Data-attribute-names and class-fieldNames have to match! (non case-sensitive)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="classObject">Given object (marked with Db-attributes)</param>
+        /// <param name="data">The data</param>
+        /// <param name="key">Key-name of data</param>
         public static void FillObject<T>(T classObject, Dictionary<string, object> data)
         {
             Type classType = classObject.GetType();
@@ -54,6 +68,8 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
             // Iterate through data
             foreach (KeyValuePair<string, object> data_keySet in data)
             {
+                bool dataMatchFound = false;
+
                 // Interate through class-fields
                 foreach (BaseAttribute baseAttribute in dbObject.baseAttributes)
                 {
@@ -69,12 +85,17 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
                     if (baseAttribute._attributeName.ToLower() == data_keySet.Key.ToLower())
                     {
                         object value = data_keySet.Value;
-                        //if (baseAttribute.parentField.FieldType == typeof(Guid)) value = new Guid((string)value);   // If its a guid, i need to convert
+                        if (!(value is DBNull))     // Check if value is empty
+                        {
+                            baseAttribute.parentField.SetValue(classObject, value);
+                        }
 
-                        baseAttribute.parentField.SetValue(classObject, value);
+                        dataMatchFound = true;
                         break;
                     }
                 }
+
+                if (!dataMatchFound) throw new InvalidOperationException($"Attribute '{data_keySet.Key}' has no match in object '{classObject.GetType().Name}'");
             }
         }
 
@@ -83,15 +104,30 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         /// Gets an dbObject by primaryKey/s
         /// </summary>
         /// <typeparam name="T"></typeparam>
-        /// <param name="classObject">Given object (marked with Db-attributes)</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
+        /// <param name="classType">The classType (marked with Db-attributes)</param>
+        /// <param name="primaryKeyName">Name of the primaryKey</param>
+        /// <param name="primaryKeyValue">Value of the primaryKey</param>
+        /// <param name="primaryKeyData">KeyData of multiple primaryKeys</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
         public static T GetByPrimaryKey<T>(Type classType, object primaryKeyValue, Func<string, List<Dictionary<string, object>>> queryExecutor) where T : new()
         {
-            Dictionary<string, object> primaryKeyData = new Dictionary<string, object>() { };
-            primaryKeyData.Add(null, primaryKeyValue);
+            // Read dbObject-attribute
+            DbObject dbObject = ClassAction.Init(classType);
 
-            return GetByPrimaryKey<T>(classType, primaryKeyData, queryExecutor);
+            if (dbObject.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"No primaryKey found in '{classType.Name}'");
+            if (dbObject.primaryKeyAttributes.Count > 1) throw new InvalidOperationException($"This 'GetByPrimaryKey' method only supports 1 primaryKey ('{dbObject.primaryKeyAttributes.Count}' found in '{classType.Name}')");
+
+            return GetByPrimaryKey<T>(classType, dbObject.primaryKeyAttributes[0]._attributeName, primaryKeyValue, queryExecutor);
         }
+        /// <summary>
+        /// Gets an dbObject by primaryKey/s
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="classType">The classType (marked with Db-attributes)</param>
+        /// <param name="primaryKeyName">Name of the primaryKey</param>
+        /// <param name="primaryKeyValue">Value of the primaryKey</param>
+        /// <param name="primaryKeyData">KeyData of multiple primaryKeys</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
         public static T GetByPrimaryKey<T>(Type classType, string primaryKeyName, object primaryKeyValue, Func<string, List<Dictionary<string, object>>> queryExecutor) where T : new()
         {
             Dictionary<string, object> primaryKeyData = new Dictionary<string, object>() { };
@@ -99,14 +135,25 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
 
             return GetByPrimaryKey<T>(classType, primaryKeyData, queryExecutor);
         }
+        /// <summary>
+        /// Gets an dbObject by primaryKey/s
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="classType">The classType (marked with Db-attributes)</param>
+        /// <param name="primaryKeyName">Name of the primaryKey</param>
+        /// <param name="primaryKeyValue">Value of the primaryKey</param>
+        /// <param name="primaryKeyData">KeyData of multiple primaryKeys</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
         public static T GetByPrimaryKey<T>(Type classType, Dictionary<string, object> primaryKeyData, Func<string, List<Dictionary<string, object>>> queryExecutor) where T: new()
         {
-            // Create new empty object
-            T obj = new T();
-
             // Read dbObject-attribute
             DbObject dbObject = ClassAction.Init(classType);
 
+            if (dbObject.primaryKeyAttributes.Count < 1) throw new InvalidOperationException($"No primaryKey found in '{classType.Name}'");
+
+            // Create new empty object
+            T obj = (T)dbObject.parentCInfo.Invoke(null);
+
             // iterate thru them to check and fill object
             foreach (DbPrimaryKey primaryKeyAtt in dbObject.primaryKeyAttributes)
             {
@@ -130,8 +177,15 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
                 if (!dataMatchFound) throw new InvalidOperationException($"PrimaryKey='{primaryKeyAtt.parentField.Name}' is missing.");
             }
 
-            ResolveByPrimaryKey<T>(obj, queryExecutor);
-
+            try
+            {
+                ResolveByPrimaryKey<T>(obj, queryExecutor);
+            }catch(InvalidOperationException)
+            {
+                // If there is no result, return null
+                return default(T);
+            }
+            
             return obj;
         }
 
@@ -142,7 +196,7 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="classObject">Given object (marked with Db-attributes)</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
         public static List<T> GetList<T>(Type classType, Func<string, List<Dictionary<string, object>>> queryExecutor) where T : new()
         {
             // Read dbObject - attribute
@@ -163,18 +217,21 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         }
 
         /// <summary>
-        /// Gets an dbObject by custom where-clause
+        /// Gets a list of dbObjects by attribute/s
         /// </summary>
         /// <typeparam name="T"></typeparam>
-        /// <param name="classObject">Given object (marked with Db-attributes)</param>
-        /// <param name="whereClause">Custom where-clause params attached to query (SELECT * FROM tableName WHERE whereClause)</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
-        public static List<T> GetListWithWhere<T>(Type classType, Func<string, List<Dictionary<string, object>>> queryExecutor, params object[] whereClause) where T : new()
+        /// <param name="classType">Type of class</param>
+        /// <param name="fields">class-fields for select</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        /// <returns>List of dbObjects</returns>
+        public static List<T> GetListByAttribute<T>(Type classType, Dictionary<string, object> fields, Func<string, List<Dictionary<string, object>>> queryExecutor) where T : new()
         {
-            // Read dbObject - attribute
+            // Read dbObject-attribute
             DbObject dbObject = ClassAction.Init(classType);
 
-            string query = QueryBuilder.SelectWithWhere(dbObject._tableName, whereClause);   // Generate query
+            Function.ConvertAttributeToDbAttributes(classType, fields);
+
+            string query = QueryBuilder.SelectByAttribute(dbObject._tableName, fields);   // Generate query
             List<Dictionary<string, object>> dataSet = queryExecutor(query);    // Execute
 
             List<T> objs = new List<T>() { };
@@ -189,18 +246,18 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         }
 
         /// <summary>
-        /// Gets an dbObject by full query
+        /// Gets an dbObject by custom where-clause
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="classObject">Given object (marked with Db-attributes)</param>
-        /// <param name="customQuery">Custom sql-query</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
-        public static List<T> GetListWithQuery<T>(Type classType, Func<string, List<Dictionary<string, object>>> queryExecutor, params object[] customQuery) where T : new()
+        /// <param name="whereClause">Custom where-clause params attached to query (SELECT * FROM tableName WHERE whereClause)</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        public static List<T> GetListWithWhere<T>(Type classType, Func<string, List<Dictionary<string, object>>> queryExecutor, params object[] whereClause) where T : new()
         {
             // Read dbObject - attribute
             DbObject dbObject = ClassAction.Init(classType);
 
-            string query = QueryBuilder.BuildQuery(customQuery);
+            string query = QueryBuilder.SelectWithWhere(dbObject._tableName, whereClause);   // Generate query
             List<Dictionary<string, object>> dataSet = queryExecutor(query);    // Execute
 
             List<T> objs = new List<T>() { };
@@ -214,27 +271,23 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
             return objs;    // Return list
         }
 
-
         /// <summary>
-        /// Gets a list of dbObjects by attribute/s
+        /// Gets an dbObject by full query
         /// </summary>
         /// <typeparam name="T"></typeparam>
-        /// <param name="classType">Type of class</param>
-        /// <param name="fields">class-fields for select</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
-        /// <returns>List of dbObjects</returns>
-        public static List<T> GetListByAttribute<T>(Type classType, Dictionary<string, object> fields, Func<string, List<Dictionary<string, object>>> queryExecutor) where T : new()
+        /// <param name="classObject">Given object (marked with Db-attributes)</param>
+        /// <param name="customQuery">Custom sql-query</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        public static List<T> GetListWithQuery<T>(Type classType, Func<string, List<Dictionary<string, object>>> queryExecutor, params object[] customQuery) where T : new()
         {
-            // Read dbObject-attribute
+            // Read dbObject - attribute
             DbObject dbObject = ClassAction.Init(classType);
 
-            Function.ConvertAttributeToDbAttributes(classType, fields);
-
-            string query = QueryBuilder.SelectByAttribute(dbObject._tableName, fields);   // Generate query
+            string query = QueryBuilder.BuildQuery(customQuery);
             List<Dictionary<string, object>> dataSet = queryExecutor(query);    // Execute
 
             List<T> objs = new List<T>() { };
-            foreach(Dictionary<string, object> data in dataSet)
+            foreach (Dictionary<string, object> data in dataSet)
             {
                 T obj = new T();    // New object
                 FillObject(obj, data);   // Fill it
@@ -252,14 +305,17 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="classObject">Given object (marked with Db-attributes)</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
-        public static void ResolveByPrimaryKey<T>(T classObject, Func<string, List<Dictionary<string, object>>> queryExecutor)
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        public static void ResolveByPrimaryKey<T>(T classObject, Func<string, List<Dictionary<string, object>>> queryExecutor, bool throwExceptions = true)
         {
             string query = QueryBuilder.SelectByPrimaryKey(classObject);   // Generate query
             List<Dictionary<string, object>> dataSet = queryExecutor(query);    // Execute
 
-            if (dataSet.Count == 0) throw new InvalidOperationException($"Cannot fetch '{typeof(T).Name}' by primary key/s. No results!");
-            FillObject(classObject, dataSet[0]);   // Fill the object
+            if (dataSet.Count == 0)
+            {
+                if (throwExceptions) throw new InvalidOperationException($"Cannot fetch '{typeof(T).Name}' by primary key/s. No results!");
+            }
+            else FillObject(classObject, dataSet[0]);   // Fill the object
         }
 
         /// <summary>
@@ -268,7 +324,7 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="classObject">Given object (marked with Db-attributes)</param>
-        /// <param name="queryExecutor">Function to handle query-calls - Has to return Dictionary[attributeName, attributeValue]</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
         /// <param name="max_depth">Determents how deep resolving will be executed</param>
         public static void ResolveForeignKeys<T>(T classObject, Func<string, List<Dictionary<string, object>>> queryExecutor, int max_depth = 1) where T: new()
         {
@@ -280,13 +336,14 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
             // Resolve foreignObjects
             foreach (DbForeignObject foreignObjectAtt in dbObject.foreignObjectAttributes)
             {
+                object foreignKey_value = foreignObjectAtt.foreignKeyAttribute.parentField.GetValue(classObject);
                 object foreignObject_value = foreignObjectAtt.parentField.GetValue(classObject);
 
-                // When its empty, get it & set it
-                if(foreignObject_value == null)
+                // When key is set and object is empty, get it & set it
+                if(foreignKey_value != null && foreignObject_value == null)
                 {
                     // Resolve it
-                    foreignObject_value = GetByPrimaryKey<T>(classType, foreignObjectAtt.foreignKeyAttribute.parentField.GetValue(classObject), queryExecutor);
+                    foreignObject_value = GetByPrimaryKey<T>(foreignObjectAtt.foreignObjectType, foreignKey_value, queryExecutor);
                     foreignObjectAtt.parentField.SetValue(classObject, foreignObject_value);    // Set the value
 
                     // Now scan the just resolved class to be able to set myself
@@ -442,5 +499,89 @@ namespace eu.railduction.netcore.dll.Database_Attribute_System
                 }
             }
         }
+
+
+        /// <summary>
+        /// Updates class to database-object</pragma>
+        /// Only works with primary-key/s!
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="classObject">Given object (marked with Db-attributes)</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        /// <param name="max_depth">Determents how deep resolving will be executed (if the corresponding foreignKey-object is resolved)</param>
+        public static void Update<T>(T classObject, Func<string, List<Dictionary<string, object>>> queryExecutor, int max_depth = 1)
+        {
+            // Read dbObject-attribute
+            DbObject dbObject = ClassAction.Init(classObject.GetType());
+
+            if(max_depth-1 > 0)
+            {
+                // Update all foreignObjects before handling myself
+                foreach (DbForeignObject foreignObject in dbObject.foreignObjectAttributes)
+                {
+                    object foreignObjectRef = foreignObject.parentField.GetValue(classObject);
+                    if (foreignObjectRef != null)
+                        Update(foreignObjectRef, queryExecutor, max_depth - 1);
+                }
+            }
+
+            string updateQuery = QueryBuilder.UpdateByPrimaryKey(classObject);
+            queryExecutor.Invoke(updateQuery);
+        }
+
+        /// <summary>
+        /// Inserts class to database-object
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="classObject">Given object (marked with Db-attributes)</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        /// <param name="max_depth">Determents how deep insertion will be executed (if the corresponding foreignKey-object is resolved)</param>
+        public static void Insert<T>(T classObject, Func<string, List<Dictionary<string, object>>> queryExecutor, int max_depth = 1)
+        {
+            // Read dbObject-attribute
+            DbObject dbObject = ClassAction.Init(classObject.GetType());
+
+            if (max_depth - 1 > 0)
+            {
+                // Update all foreignObjects before handling myself
+                foreach (DbForeignObject foreignObject in dbObject.foreignObjectAttributes)
+                {
+                    object foreignObjectRef = foreignObject.parentField.GetValue(classObject);
+                    if (foreignObjectRef != null)
+                        Insert(foreignObjectRef, queryExecutor, max_depth - 1);
+                }
+            }
+
+            string insertQuery = QueryBuilder.InsertAttributesByObject(classObject);
+            queryExecutor.Invoke(insertQuery);
+        }
+
+        /// <summary>
+        /// Deletes class from database-object</pragma>
+        /// Only works with primary-key/s!
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="classObject">Given object (marked with Db-attributes)</param>
+        /// <param name="queryExecutor">Function to handle query-calls</param>
+        /// <param name="max_depth">Determents how deep deletion will be executed (if the corresponding foreignKey-object is resolved)</param>
+        public static void Delete<T>(T classObject, Func<string, List<Dictionary<string, object>>> queryExecutor, int max_depth = 1)
+        {
+            // Read dbObject-attribute
+            DbObject dbObject = ClassAction.Init(classObject.GetType());
+
+            if (max_depth - 1 > 0)
+            {
+                // Update all foreignObjects before handling myself
+                foreach (DbForeignObject foreignObject in dbObject.foreignObjectAttributes)
+                {
+                    object foreignObjectRef = foreignObject.parentField.GetValue(classObject);
+                    if (foreignObjectRef != null)
+                        Delete(foreignObjectRef, queryExecutor, max_depth - 1);
+                }
+            }
+
+            string deleteQuery = QueryBuilder.DeleteByPrimaryKey(classObject);
+            queryExecutor.Invoke(deleteQuery);
+        }
     }
 }

Database-Attribute_System/Database-Attribute_System.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>netcoreapp2.1</TargetFramework>
     <RootNamespace>eu.railduction.netcore.dll.Database_Attribute_System</RootNamespace>
     <SignAssembly>false</SignAssembly>
-    <Version>1.5.20</Version>
+    <Version>1.5.3</Version>
   </PropertyGroup>
 
 </Project>