/// <summary> /// Konstruktor /// </summary> /// <param name="requireContract">Der Kontrakt zur Eintrittsprüfung.</param> /// <param name="ensureContract">Der Kontrakt zur Austrittsprufung.</param> /// <param name="member">Das Element an dem der DbcAspect definiert wurde</param> /// <param name="accessType">Gibt an, bei welchem Zugriff der Kontrakt angewendet werden soll.</param> /// <param name="checkTime">Gibt an, zu welchem Zeitpunkt der Kontrakt angewendet werden soll.</param> /// <param name="contractClassName">Gibt den Namen der Kontraktklasse an.</param> /// <param name="exceptionType">Gibt den Typ der Exception an, die für den Nichterfüllungsfall geworfen werden soll.</param> /// <param name="exceptionString">Gibt den Exceptiontext an, der bei Nichterfüllung geworfen werden soll.</param> internal MethodModel(string requireContract, string ensureContract, MemberInfo member, AccessType accessType, CheckTime checkTime, string contractClassName, Type exceptionType, string exceptionString) : base(member, accessType, checkTime, contractClassName, exceptionType, exceptionString) { // Erzeugen und zuweisen der ContractModels. if (requireContract == ensureContract) { RequireContract = new ContractModel(requireContract); EnsureContract = RequireContract; ContractsAreEqual = true; return; } if (!string.IsNullOrEmpty(requireContract)) RequireContract = new ContractModel(requireContract); if (!string.IsNullOrEmpty(ensureContract)) EnsureContract = new ContractModel(ensureContract); }
/// <summary> /// Konstruktor /// </summary> /// <param name="getContract">Der Kontrakt der beim Lesezugriff geprüft wird.</param> /// <param name="setContract">Der Kontrakt der beim Schreibzugriff geprüft wird.</param> /// <param name="member">Das Element an dem der DbcAspect definiert wurde</param> /// <param name="accessType">Gibt an, bei welchem Zugriff der Kontrakt angewendet werden soll.</param> /// <param name="checkTime">Gibt an, zu welchem Zeitpunkt der Kontrakt angewendet werden soll.</param> /// <param name="contractClassName">Gibt den Namen der Kontraktklasse an.</param> /// <param name="exceptionType">Gibt den Typ der Exception an, die für den Nichterfüllungsfall geworfen werden soll.</param> /// <param name="exceptionString">Gibt den Exceptiontext an, der bei Nichterfüllung geworfen werden soll.</param> internal FieldModel(string getContract, string setContract, MemberInfo member, AccessType accessType, CheckTime checkTime, string contractClassName, Type exceptionType, string exceptionString) : base(member, accessType, checkTime, contractClassName, exceptionType, exceptionString) { // Erzeugen und zuweisen der ContractModels. if (getContract == setContract) { GetContract = new ContractModel(getContract); SetContract = GetContract; ContractsAreEqual = true; return; } if (!string.IsNullOrEmpty(getContract)) GetContract = new ContractModel(getContract); if (!string.IsNullOrEmpty(setContract)) SetContract = new ContractModel(setContract); }
/// <summary> /// Fügt eine weitere Kontrakt Methode der zu erzeugenden Klasse hinzu. /// </summary> /// <param name="contract">ContractModel mit allen nötigen Daten</param> /// <param name="contractedElement">Das Element an dem der Kontrakt definiert wurde.</param> /// <param name="exceptionType">Übergibt den Typ der Exception, der geworfen werden soll wenn der Kontrakt nicht erfüllt wird.</param> /// <param name="exceptionString">Übergibt den Text der Exception, der geworfen werden soll wenn der Kontrakt nicht erfüllt wird.</param> /// <returns>CodeMemberMethod Objekt mit der Kontraktprüfung.</returns> private CodeMemberMethod AddContractMethod(ContractModel contract, MemberInfo contractedElement, Type exceptionType, string exceptionString) { //Methode anlegen CodeMemberMethod contractMethod = new CodeMemberMethod(); contractMethod.Name = contract.ContractKey; contractMethod.ReturnType = new CodeTypeReference(typeof(void)); contractMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; // Übergabeparameter festlegen contractMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object[])), Resources.StrParameterContractArguments)); contractMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), Resources.StrParameterInstance)); contractMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), Resources.StrParameterMethodResult)); contractMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Type[])), Resources.StrParameterGenericTypes)); if (contract.OldValueExist) contractMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object[])), Resources.StrParameterOldValues)); //if Statement erzeugen CodeConditionStatement contractStatement = new CodeConditionStatement(); contractStatement.Condition = new CodeSnippetExpression(contract.ConvertedContract); //return hinzufügen contractStatement.TrueStatements.Add(new CodeMethodReturnStatement()); //Exception erzeugen string fullMethodName = contractedElement.DeclaringType.Namespace + "." + contractedElement.DeclaringType.Name + "." + contractedElement.Name; if (exceptionType == null) exceptionType = typeof(ContractException); if (string.IsNullOrEmpty(exceptionString)) exceptionString = string.Format(CultureInfo.CurrentCulture, Resources.ExcContractNotValid, new object[] { contract.Contract, fullMethodName }); CodeThrowExceptionStatement throwContractException = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(exceptionType), new CodeExpression[] {new CodePrimitiveExpression(exceptionString )})); // Try Catch um diese Methode legen CodeTryCatchFinallyStatement tryContrainer = new CodeTryCatchFinallyStatement(); tryContrainer.TryStatements.Add(contractStatement); // Catch Clauses erzeugen CodeCatchClause exceptionClause = new CodeCatchClause(Resources.StrParameterException); exceptionClause.CatchExceptionType = new CodeTypeReference(typeof(Exception)); exceptionClause.Statements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(typeof(ContractException)), new CodeExpression[] { new CodePrimitiveExpression(string.Format(CultureInfo.CurrentCulture, Resources.ExcErrorInContract, new object[] { contract.Contract, fullMethodName })), new CodeVariableReferenceExpression(Resources.StrParameterException) }))); tryContrainer.CatchClauses.Add(exceptionClause); // Den kompletten Inhalt der Methode zuordnen contractMethod.Statements.Add(tryContrainer); contractMethod.Statements.Add(throwContractException); return contractMethod; }
/// <summary> /// Erzeugt eine Element basierte GetOldValue Methode um die als alten Werte gekennzeichneten /// Werte für einen Kontakt zu laden. /// </summary> /// <param name="contract">ContractModel mit allen nötigen Daten</param> /// <param name="contractedElement">Das Element an dem der Kontrakt definiert wurde.</param> /// <returns>CodeMemberMethod Objekt mit der dem OldValues als Rückgabewerte.</returns> private CodeMemberMethod AddGetOldValueMethod(ContractModel contract, MemberInfo contractedElement) { //Methode anlegen CodeMemberMethod getOldValueMethod = new CodeMemberMethod(); getOldValueMethod.Name = contract.GetOldValueKey; getOldValueMethod.ReturnType = new CodeTypeReference(typeof(object[])); getOldValueMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; // Übergabeparameter festlegen getOldValueMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object[])), Resources.StrParameterContractArguments)); getOldValueMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), Resources.StrParameterInstance)); getOldValueMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Type[])), Resources.StrParameterGenericTypes)); // Try Catch um diese Methode legen CodeTryCatchFinallyStatement tryContrainer = new CodeTryCatchFinallyStatement(); foreach (string expression in contract.GetOldValuesStatements) tryContrainer.TryStatements.Add(new CodeSnippetExpression(expression)); string fullMethodName = contractedElement.DeclaringType.Namespace + "." + contractedElement.DeclaringType.Name + "." + contractedElement.Name; // Catch Clauses erzeugen CodeCatchClause exceptionClause = new CodeCatchClause(Resources.StrParameterException); exceptionClause.CatchExceptionType = new CodeTypeReference(typeof(Exception)); exceptionClause.Statements.Add(new CodeThrowExceptionStatement( new CodeObjectCreateExpression(new CodeTypeReference(typeof(ContractException)), new CodeExpression[] { new CodePrimitiveExpression(string.Format(CultureInfo.CurrentCulture, Resources.ExcErrorInContract, new object[] {contract.Contract, fullMethodName} ) ), new CodeVariableReferenceExpression(Resources.StrParameterException)}))); tryContrainer.CatchClauses.Add(exceptionClause); // Den kompletten Inhalt der Methode zuordnen getOldValueMethod.Statements.Add(tryContrainer); return getOldValueMethod; }
/// <summary> /// Fügt eine weiter Kontraktprüfung der zu erzeugenden Klasse bzw. Assembly hinzu. /// </summary> /// <param name="contractModel">Modell mit allen relevanten Daten zum Kontrakt</param> /// <param name="aspectModel">Modell mit allen relevanten Daten zum Aspekt der den Kontrakt prüft</param> /// <returns>Sofern es sich um den letzten Aspekt handelt</returns> internal void AddContract(ContractModel contractModel, MemberBaseModel aspectModel) { if (!Started) StartContractGenerator(aspectModel.ContractClassName, aspectModel.Member.DeclaringType.Assembly); DbcAspectCurrentCount++; // Den Contract in einen gültigen Ausdruck übersetzen //ExpressionController exprController = new ExpressionController(); //ExpressionModel exprModel = exprController.ConvertExpression(contractModel, aspectModel.Member); CodeMemberMethod contractMethod = AddContractMethod(contractModel, aspectModel.Member, aspectModel.ExceptionType, aspectModel.ExceptionString); mClassModel.Members.Add(contractMethod); //Methodenaufruf in der CheckContract Methode erzeugen. CodeConditionStatement contractCondition = AddContractMethodCall(contractModel.ContractKey, contractModel.OldValueExist); mCheckContractMethodModel.Statements.Add(contractCondition); if (contractModel.OldValueExist) { CodeMemberMethod getOldValueMethod = AddGetOldValueMethod(contractModel, aspectModel.Member); mClassModel.Members.Add(getOldValueMethod); //Methodenaufruf in der GetOldValue Methode erzeugen. CodeConditionStatement getOldValueCondition = AddGetOldValueMethodCall(contractModel.GetOldValueKey); mGetOldValuesMethodModel.Statements.Add(getOldValueCondition); } // Da es sich um den letzten Kontrakt handelt die Assemlby erzeugen und // in das ContractModel speichern. if ((DbcAspectCount == DbcAspectCurrentCount) && (!SourceCodeGenerated)) //System.Windows.Forms.MessageBox.Show("Erzeugen des Codes"); GenerateCode(aspectModel); }