/// <summary> /// Returns a collection of business objects that are connected to /// this object through the specified relationship (eg. would return /// a father and a mother if the relationship was "parents"). This /// method is to be used in the case of multiple relationships. /// </summary> /// <param name="relationshipName">The name of the relationship</param> /// <returns>Returns a business object collection</returns> /// <exception cref="InvalidRelationshipAccessException">Thrown if /// the relationship specified is a single relationship, when a /// multiple one was expected</exception> public virtual IBusinessObjectCollection GetRelatedCollection(string relationshipName) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IMultipleRelationship multipleRelationship = GetMultiple(relationshipName); return(multipleRelationship.BusinessObjectCollection); }
///<summary> /// Returns a multiple relationship for with the specified relationship name. ///</summary> ///<param name="relationshipName">The specified relationship name</param> ///<returns>The multiple relationship</returns> public IMultipleRelationship GetMultiple(string relationshipName) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IMultipleRelationship relationship = GetRelationshipAsMultiple(relationshipName); return(relationship); }
///<summary> /// Returns a single relationship for with the specified relationship name. ///</summary> ///<param name="relationshipName">The specified relationship name</param> ///<returns>THe single relationship</returns> public ISingleRelationship GetSingle(string relationshipName) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IRelationship relationship = GetRelationshipAsSingle(relationshipName); return((ISingleRelationship)relationship); }
/// <summary> /// Returns the business object that is related to this object /// through the specified relationship (eg. would return a father /// if the relationship was called "father"). This method is to be /// used in the case of single relationships. /// </summary> /// <param name="relationshipName">The name of the relationship</param> /// <returns>Returns a business object</returns> /// <exception cref="InvalidRelationshipAccessException">Thrown if /// the relationship specified is a multiple relationship, when a /// single one was expected</exception> public IBusinessObject GetRelatedObject(string relationshipName) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); ISingleRelationship relationship = GetSingle(relationshipName); return(relationship.GetRelatedObject()); }
/// <summary> /// Returns the business object that is related to this object /// through the specified relationship (eg. would return a father /// if the relationship was called "father"). This method is to be /// used in the case of single relationships. /// </summary> /// <param name="relationshipName">The name of the relationship</param> /// <returns>Returns a business object</returns> /// <exception cref="InvalidRelationshipAccessException">Thrown if /// the relationship specified is a multiple relationship, when a /// single one was expected</exception> public T GetRelatedObject <T>(string relationshipName) where T : class, IBusinessObject, new() { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); SingleRelationship <T> relationship = GetSingle <T>(relationshipName); return(relationship.GetRelatedObject()); }
/// <summary> /// Executes a raw sql statement. BEWARE OF SQL INJECTION ATTACKS. Use for hardcoded sql only. /// </summary> /// <param name="sql">The sql statement to run as a scalar</param> /// <returns>The scalar result</returns> public object ExecuteRawSqlScalar(string sql) { ArgumentValidationHelper.CheckArgumentNotNull(sql, "sql"); IDbConnection con = null; try { con = OpenConnection; var cmd = CreateCommand(con); cmd.CommandText = sql; return(cmd.ExecuteScalar()); } catch (Exception ex) { Log.Log ("Error reading database : " + Environment.NewLine + ExceptionUtilities.GetExceptionString(ex, 10, true), LogCategory.Exception); Log.Log("Sql: " + sql, LogCategory.Exception); Console.WriteLine (@"Error reading database : " + Environment.NewLine + ExceptionUtilities.GetExceptionString(ex, 10, true)); Console.WriteLine(@"Connect string: " + this.ErrorSafeConnectString()); throw new DatabaseReadException ("There was an error reading the database. Please contact your system administrator.", "The command ExecuteScalar could not be completed.", ex, sql, ErrorSafeConnectString()); } finally { if (con != null && con.State != ConnectionState.Closed) { con.Close(); } } }
// 1、返回IQueryable<TEntity>使用延迟加载技术 // 2、返回IEnumerable<TEntity>,需要把数据集加载到内存 /// <summary> /// 检查实体是否存在 /// </summary> /// <param name="predicate">查询条件表达式</param> /// <returns>是否存在</returns> public virtual bool CheckExists(Expression <Func <TEntity, bool> > predicate) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(predicate, "传入的对象key为空"); // 存在返回true,否则false return(EFContext.Set <TEntity>().Count(predicate) == 0 ? false :true); }
/// <summary> /// 查找指定主键的实体记录 /// </summary> /// <param name="key"> 指定主键 </param> /// <returns> 符合编号的记录,不存在返回null </returns> public virtual TEntity GetByKey(object key) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(key, "传入的对象key为空"); // 执行查询 return(EFContext.Set <TEntity>().Find(key)); }
/// <summary> /// Constructor to create new RelPropDef object /// </summary> /// <param name="ownerClassPropDef">The property definition of the /// owner object</param> /// <param name="relatedObjectPropName">The property name of the /// related object</param> public RelPropDef(IPropDef ownerClassPropDef, string relatedObjectPropName) { ArgumentValidationHelper.CheckArgumentNotNull(ownerClassPropDef, "ownerClassPropDef"); OwnerPropDef = ownerClassPropDef; RelatedClassPropName = relatedObjectPropName; }
static async Task Main(string[] args) { //setup DI _serviceProvider = DependencyBuilderClient.Configure(); //Parameters validation if (ArgumentValidationHelper.CheckParameters(args)) { var cube1 = CubeFactory.BuildCube(args[0], args[1], args[2], args[3], args[4]); var cube2 = CubeFactory.BuildCube(args[5], args[6], args[7], args[8], args[9]); //Process execution if ((cube1 != null) && (cube2 != null)) { var service = _serviceProvider.GetService <ICubeService>(); if (service.IsIntersection(cube1, cube2)) { ConsoleLogHelper.ShowInfoMessage($"Cubes intersect.", System.ConsoleColor.Green); var volumeIntersecion = service.VolumeIntersection(cube1, cube2); ConsoleLogHelper.ShowInfoMessage($"Intersected volume: {volumeIntersecion}", System.ConsoleColor.Green); } else { ConsoleLogHelper.ShowInfoMessage($"Cubes DON'T intersect.", System.ConsoleColor.Yellow); } } } Console.WriteLine(string.Empty); Console.WriteLine("Press any key to close the application..."); Console.ReadLine(); }
///<summary> /// Returns a strongly typed multiple relationship for with the specified relationship name. ///</summary> ///<param name="relationshipName">The specified relationship name</param> ///<returns>The multiple relationship</returns> public MultipleRelationship <T> GetMultiple <T>(string relationshipName) where T : BusinessObject, new() { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IMultipleRelationship relationship = GetRelationshipAsMultiple(relationshipName); return((MultipleRelationship <T>)relationship); }
/// <summary> /// Returns a collection of business objects that are connected to /// this object through the specified relationship (eg. would return /// a father and a mother if the relationship was "parents"). This /// method is to be used in the case of multiple relationships. /// </summary> /// <param name="relationshipName">The name of the relationship</param> /// <returns>Returns a business object collection</returns> /// <exception cref="InvalidRelationshipAccessException">Thrown if /// the relationship specified is a single relationship, when a /// multiple one was expected</exception> public BusinessObjectCollection <TBusinessObject> GetRelatedCollection <TBusinessObject>(string relationshipName) where TBusinessObject : BusinessObject, new() { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); MultipleRelationship <TBusinessObject> multipleRelationship = GetMultiple <TBusinessObject>(relationshipName); return(multipleRelationship.BusinessObjectCollection); }
///<summary> /// Returns a strongly typed single relationship for with the specified relationship name. ///</summary> ///<param name="relationshipName">The specified relationship name</param> ///<returns>THe single relationship</returns> public SingleRelationship <T> GetSingle <T>(string relationshipName) where T : class, IBusinessObject, new() { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IRelationship relationship = GetRelationshipAsSingle(relationshipName); return((SingleRelationship <T>)relationship); }
/// <summary> /// 批量插入实体记录集合 /// </summary> /// <param name="entities"> 实体记录集合 </param> /// <param name="isSave"> 是否执行保存 </param> /// <returns> 操作影响的行数 </returns> public virtual int Insert(IEnumerable <TEntity> entities, bool isSave = true) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(entities, "传入的对象t为空"); // 对象加入仓储上下文(暂不提交数据库) EFContext.RegisterNew(entities); // 立即提交或暂缓执行 return(isSave ? EFContext.Commit() : 0); }
/// <summary> /// 更新实体记录 /// </summary> /// <param name="entity"> 实体对象 </param> /// <param name="isSave"> 是否执行保存 </param> /// <returns> 操作影响的行数 </returns> public virtual int Update(TEntity entity, bool isSave = true) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(entity, "传入的对象entity为空"); // 对象加入仓储上下文(暂不提交数据库) EFContext.RegisterModified(entity); //TEntity entity0 = EFContext. // 立即提交或暂缓执行 return(isSave ? EFContext.Commit() : 0); }
/// <summary> /// 更新所有符合特定表达式的记录 /// </summary> /// <param name="predicate"> 查询条件谓语表达式 </param> /// <param name="isSave"> 是否执行保存 </param> /// <returns> 操作影响的行数 </returns> public virtual int Update(Expression <Func <TEntity, bool> > predicate, bool isSave = true) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(predicate, "传入的对象predicate为空"); // 依据条件表达式查询实体记录 List <TEntity> entities = EFContext.Set <TEntity>().Where(predicate).ToList(); // 记录存在则立即执行,否则返回0 return(entities.Count > 0 ? Update(entities, isSave) : 0); }
/// <summary> /// 删除指定编号的记录 /// </summary> /// <param name="id"> 实体记录编号 </param> /// <param name="isSave"> 是否执行保存 </param> /// <returns> 操作影响的行数 </returns> public virtual int Delete(object id, bool isSave = true) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(id, "传入的对象id为空"); // 实体记录在数据库是否存在 TEntity entity = EFContext.Set <TEntity>().Find(id); // 记录存在则立即执行,否则返回0 return(entity != null?Delete(entity, isSave) : 0); }
/// <summary> /// Constructor to create a new single relationship definition /// </summary> /// <param name="relationshipName">A name for the relationship</param> /// <param name="relatedObjectAssemblyName">The assembly name of the related object</param> /// <param name="relatedObjectClassName">The class name of the related object</param> /// <param name="relKeyDef">The related key definition</param> /// <param name="keepReferenceToRelatedObject">Whether to keep a /// reference to the related object. Could be false for memory- /// intensive applications.</param> /// <param name="orderBy">The sql order-by clause</param> /// <param name="deleteParentAction">Provides specific instructions /// with regards to deleting a parent object. See the DeleteParentAction /// enumeration for more detail.</param> /// <param name="insertParentAction"></param> /// <param name="relationshipType">Provides specific instructions for adding/removing a child object.</param> /// <param name="timeout">The timout in milliseconds. The collection will not be automatically refreshed from the DB if the timeout has nto expired</param> public MultipleRelationshipDef(string relationshipName, string relatedObjectAssemblyName, string relatedObjectClassName, IRelKeyDef relKeyDef, bool keepReferenceToRelatedObject, string orderBy, DeleteParentAction deleteParentAction, InsertParentAction insertParentAction, RelationshipType relationshipType, int timeout) : base(relationshipName, relatedObjectAssemblyName, relatedObjectClassName, relKeyDef, keepReferenceToRelatedObject, deleteParentAction, insertParentAction, relationshipType) { ArgumentValidationHelper.CheckArgumentNotNull(orderBy, "orderBy"); TimeOut = timeout; OrderCriteriaString = orderBy; OrderCriteria = new OrderCriteria(); OrderCriteria = Base.OrderCriteria.FromString(orderBy); }
/// <summary> /// Adds a <see cref="IBOProp"/> to the key /// </summary> /// <param name="boProp">The BOProp to add</param> public virtual void Add(IBOProp boProp) { ArgumentValidationHelper.CheckArgumentNotNull(boProp, "boProp"); if (_props.ContainsKey(boProp.PropertyName)) { throw new InvalidPropertyException(String.Format( "The property with the name '{0}' that is being added already " + "exists in the key collection.", boProp.PropertyName)); } _props.Add(boProp.PropertyName, boProp); boProp.Updated += BOPropUpdated_Handler; }
private IMultipleRelationship GetRelationshipAsMultiple(string relationshipName) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IRelationship relationship = this[relationshipName]; if (relationship is ISingleRelationship) { throw new InvalidRelationshipAccessException("The 'single' relationship " + relationshipName + " was accessed as a 'multiple' relationship (using GetRelatedCollection())."); } return((IMultipleRelationship)relationship); }
/// <summary> /// Constructor to create a new Multiple Relationship Definition /// </summary> /// <param name="relationshipName">A name for the relationship</param> /// <param name="relatedObjectClassType">The class type of the related objects</param> /// <param name="relKeyDef">The related key definition</param> /// <param name="keepReferenceToRelatedObject">Whether to keep a /// reference to the related object. Could be false for memory- /// intensive applications.</param> /// <param name="orderBy">The sql order-by clause</param> /// <param name="deleteParentAction">Provides specific instructions /// with regards to deleting a parent object. See the DeleteParentAction /// enumeration for more detail.</param> public MultipleRelationshipDef(string relationshipName, Type relatedObjectClassType, IRelKeyDef relKeyDef, bool keepReferenceToRelatedObject, string orderBy, DeleteParentAction deleteParentAction) : base(relationshipName, relatedObjectClassType, relKeyDef, keepReferenceToRelatedObject, deleteParentAction) { ArgumentValidationHelper.CheckArgumentNotNull(orderBy, "orderBy"); OrderCriteriaString = orderBy; this.OrderCriteria = Base.OrderCriteria.FromString(orderBy); }
/// <summary> /// Sets the related business object of a <b>single</b> relationship. /// This includes setting the RelKey properties of the relationship owner /// to the value of the related object's properties. /// </summary> /// <param name="relationshipName">The name of a single relationship</param> /// <param name="relatedObject">The new related object</param> /// <exception cref="InvalidRelationshipAccessException">Thrown if /// the relationship named is a multiple relationship instead of a /// single one</exception> public void SetRelatedObject(string relationshipName, IBusinessObject relatedObject) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); IRelationship relationship = this[relationshipName]; if (relationship is IMultipleRelationship) { throw new InvalidRelationshipAccessException("SetRelatedObject() was passed a relationship (" + relationshipName + ") that is of type 'multiple' when it expects a 'single' relationship"); } ((ISingleRelationship)relationship).SetRelatedObject(relatedObject); }
/// <summary> /// Executes a stored proc with the params given using the timeout length given. /// </summary> /// <param name="procName">The stored proc name</param> /// <param name="params">The parameters to pass in</param> /// <param name="timeout">The timeout in seconds</param> /// <returns>A scalar result</returns> public int ExecuteStoredProcNonQuery(string procName, IEnumerable <Param> @params, int timeout) { ArgumentValidationHelper.CheckArgumentNotNull(procName, "procName"); ArgumentValidationHelper.CheckArgumentNotNull(@params, "params"); IDbConnection con = null; try { con = OpenConnection; var cmd = CreateCommand(con); cmd.CommandType = CommandType.StoredProcedure; cmd.CommandText = procName; if (timeout > 0) { cmd.CommandTimeout = timeout; } foreach (var param in @params) { var dbParam = cmd.CreateParameter(); dbParam.DbType = param.DbType; dbParam.ParameterName = param.ParamName; dbParam.Value = param.ParamValue; cmd.Parameters.Add(dbParam); } return(cmd.ExecuteNonQuery()); } catch (Exception ex) { Log.Log ("Error executing stored procedure : " + Environment.NewLine + ExceptionUtilities.GetExceptionString(ex, 10, true), LogCategory.Exception); Log.Log("Stored procedure: " + procName, LogCategory.Exception); throw new DatabaseWriteException ("There was an error writing to the database. Please contact your system administrator." + Environment.NewLine + "A stored procedure command could not be completed.", "A stored procedure command could not be completed: " + procName, ex, procName + String.Join(", ", @params), ErrorSafeConnectString()); } finally { if (con != null && con.State != ConnectionState.Closed) { con.Close(); } } }
/// <summary> /// Executes a collection of sql commands that returns no result set /// and takes no parameters, using the provided connection. /// This method can be used effectively where the database vendor /// supports the execution of several sql statements in one /// ExecuteNonQuery. However, for database vendors like Microsoft /// Access and MySql, the sql statements will need to be split up /// and executed as separate transactions. /// </summary> /// <param name="statements">A valid sql statement object (typically "insert", /// "update" or "delete"). Note_ that this assumes that the /// sqlCommand is not a stored procedure.</param> /// <param name="transaction">A valid transaction object in which the /// sql must be executed, or null</param> /// <returns>Returns the number of rows affected</returns> /// <exception cref="DatabaseWriteException">Thrown if there is an /// error writing to the database. Also outputs error messages to the log. /// </exception> /// <future> /// In future override this method with methods that allow you to /// pass in stored procedures and parameters. /// </future> public virtual int ExecuteSql(IEnumerable <ISqlStatement> statements, IDbTransaction transaction) { var inTransaction = transaction != null; ArgumentValidationHelper.CheckArgumentNotNull(statements, "statements"); IDbConnection con = null; try { con = GetOpenConnection(transaction); if (transaction == null) { transaction = BeginTransaction(con); } var totalRowsAffected = ExecuteSqlInternal(statements, con, transaction); if (!inTransaction) { transaction.Commit(); } return(totalRowsAffected); } catch (Exception ex) { Log.Log ("Error writing to database : " + Environment.NewLine + ExceptionUtilities.GetExceptionString(ex, 10, true), LogCategory.Exception); Log.Log("Sql: " + statements, LogCategory.Exception); if (transaction != null) { transaction.Rollback(); } throw new DatabaseWriteException ("There was an error writing to the database. Please contact your system administrator." + Environment.NewLine + "The command executeNonQuery could not be completed. :" + statements, "The command executeNonQuery could not be completed.", ex, statements.ToString(), ErrorSafeConnectString()); } finally { if (!inTransaction) { if (con != null && con.State != ConnectionState.Closed) { con.Close(); } } } }
void HaveSomeFun(bool summers) { string waterGun = < Some Value > string jacket = < Some Other Value > ArgumentValidationHelper.ValidateNotNullOrEmpty("WaterGun", waterGun); ArgumentValidationHelper.ValidateNotNullOrEmpty("Jacket", jacket); if (summers) { Console.WriteLine("Using {0}", waterGun); } else { Console.WriteLine("Using {0}", jacket); } }
/// <summary> /// 删除实体记录 /// </summary> /// <param name="entity"> 实体对象 </param> /// <param name="isSave"> 是否执行保存 </param> /// <returns> 操作影响的行数 </returns> public virtual int Delete(TEntity entity, bool isSave = true) { // 参数有效性检查 ArgumentValidationHelper.CheckForNullReference(entity, "传入的对象t为空"); try { // 对象加入仓储上下文(暂不提交数据库) EFContext.RegisterDeleted(entity); } catch (InvalidOperationException) { Delete(entity.ID); } catch (Exception) { throw; } // 立即提交或暂缓执行 return(isSave ? EFContext.Commit() : 0); }
// ReSharper disable DoNotCallOverridableMethodsInConstructor private RelationshipDef(string relationshipName, Type relatedObjectClassType, string relatedObjectAssemblyName, string relatedObjectClassName, IRelKeyDef relKeyDef, bool keepReferenceToRelatedObject, DeleteParentAction deleteParentAction, InsertParentAction insertParentAction, RelationshipType relationshipType) { ArgumentValidationHelper.CheckArgumentNotNull(relKeyDef, "relKeyDef"); ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName"); if (relatedObjectClassType != null) { MyRelatedObjectClassType = relatedObjectClassType; } else { _relatedObjectAssemblyName = relatedObjectAssemblyName; _relatedObjectClassName = relatedObjectClassName; _relatedObjectClassType = null; } RelKeyDef = relKeyDef; RelationshipName = relationshipName; KeepReferenceToRelatedObject = keepReferenceToRelatedObject; this.DeleteParentAction = deleteParentAction; this.InsertParentAction = insertParentAction; RelationshipType = relationshipType; }
/// <summary> /// Constructor to create new RelPropDef object /// </summary> /// <param name="ownerClassPropDefName">The name of the prop on the owner object</param> /// <param name="relatedObjectPropName">The property name of the /// related object</param> public RelPropDef(string ownerClassPropDefName, string relatedObjectPropName) { ArgumentValidationHelper.CheckArgumentNotNull(ownerClassPropDefName, "ownerClassPropDefName"); _ownerPropDefName = ownerClassPropDefName; RelatedClassPropName = relatedObjectPropName; }
/// <summary> /// Constructor to initialise a new instance /// </summary> /// <param name="lKeyDef">The key definition</param> internal BOKey(KeyDef lKeyDef) { ArgumentValidationHelper.CheckArgumentNotNull(lKeyDef, "lKeyDef"); _keyDef = lKeyDef; _props = new Dictionary <string, IBOProp>(); }
/// <summary> /// Returns true if a property with this name is part of this key /// </summary> /// <param name="propName">The property name</param> /// <returns>Returns true if it is contained</returns> public bool Contains(string propName) { ArgumentValidationHelper.CheckStringArgumentNotEmpty(propName, "propName"); return(_props.ContainsKey(propName)); }