public void Ctor_String(string localName)
{
var catchClause = new CodeCatchClause(localName);
Assert.Equal(localName ?? string.Empty, catchClause.LocalName);
Assert.Equal(typeof(Exception).ToString(), catchClause.CatchExceptionType.BaseType);
Assert.Empty(catchClause.Statements);
}
public void Ctor_String_CodeTypeReference_ParamsCodeStatement(string localName, CodeTypeReference catchExceptionType, CodeStatement[] statements)
{
var catchClause = new CodeCatchClause(localName, catchExceptionType, statements);
Assert.Equal(localName ?? string.Empty, catchClause.LocalName);
Assert.Equal((catchExceptionType ?? new CodeTypeReference(typeof(Exception))).BaseType, catchClause.CatchExceptionType.BaseType);
Assert.Equal(statements, catchClause.Statements.Cast<CodeStatement>());
}
public void Ctor_Default()
{
var catchClause = new CodeCatchClause();
Assert.Empty(catchClause.LocalName);
Assert.Empty(catchClause.Statements);
Assert.Equal(new CodeTypeReference(typeof(Exception)).BaseType, catchClause.CatchExceptionType.BaseType);
}
public CodeCatchClause[] ToCodeDomArray()
{
CodeCatchClause[] cc = new CodeCatchClause[this.Count];
int i = 0;
foreach (CatchClause st in this)
{
cc[i++] = st.ToCodeDom();
}
return(cc);
}
public void Constructor2_Deny_Unrestricted()
{
CodeTypeReference ctr = new CodeTypeReference("System.Void");
CodeCatchClause ccc = new CodeCatchClause("mono", ctr);
Assert.AreEqual("System.Void", ccc.CatchExceptionType.BaseType, "CatchExceptionType.BaseType");
ccc.CatchExceptionType = new CodeTypeReference("System.Int32");
Assert.AreEqual("mono", ccc.LocalName, "LocalName");
ccc.LocalName = String.Empty;
Assert.AreEqual(0, ccc.Statements.Count, "Statements");
}
/// <summary>
/// Creates a method that finds a row containing the given elements of an index.
/// </summary>
/// <param name="uniqueConstraintSchema">A description of a unique constraint.</param>
public FindByKeyMethod(UniqueConstraintSchema uniqueConstraintSchema)
{
// /// <summary>
// /// Finds a row in the Configuration table containing the key elements.
// /// </summary>
// /// <param name="key">An array of key elements.</param>
// /// <returns>A ConfigurationKey row that contains the key elements, or null if there is no match.</returns>
// public new ConfigurationRow Find(object[] key) {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(string.Format("Finds a row in the {0} table containing the key elements.", uniqueConstraintSchema.Table.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Comments.Add(new CodeCommentStatement("<param name=\"key\">An array of key elements.</param>", true));
this.Comments.Add(new CodeCommentStatement(string.Format("<returns>A {0} row that contains the key elements, or null if there is no match.</returns>", uniqueConstraintSchema.Name), true));
this.Attributes = MemberAttributes.Public | MemberAttributes.New | MemberAttributes.Final;
this.ReturnType = new CodeTypeReference(string.Format("{0}Row", uniqueConstraintSchema.Table.Name));
this.Name = "Find";
this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(System.Object[])), "key"));
// try {
// DataModel.Configuration.AcquireLock();
// return ((ConfigurationRow)(base.Find(key)));
// }
// catch (global::System.ArgumentException argumentException) {
// throw new global::System.ServiceModel.FaultException<ArgumentFault>(new global::FluidTrade.Core.ArgumentFault(argumentException.Message));
// }
// finally {
// DataModel.Configuration.ReleaseLock();
// }
CodeTryCatchFinallyStatement tryCatchFinallyStatement = new CodeTryCatchFinallyStatement();
CodePropertyReferenceExpression tableExpression = new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(string.Format("{0}", uniqueConstraintSchema.Table.DataModel.Name)), uniqueConstraintSchema.Table.Name);
tryCatchFinallyStatement.TryStatements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(uniqueConstraintSchema.Table.DataModel.Name), "DataLock"),
"EnterReadLock"));
tryCatchFinallyStatement.TryStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(this.ReturnType, new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), "Find", new CodeArgumentReferenceExpression("key")))));
CodeCatchClause catchArgumentException = new CodeCatchClause("argumentException", new CodeGlobalTypeReference(typeof(System.ArgumentException)));
catchArgumentException.Statements.Add(new CodeThrowArgumentExceptionStatement(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("argumentException"), "Message")));
tryCatchFinallyStatement.CatchClauses.Add(catchArgumentException);
CodeCatchClause catchFormatException = new CodeCatchClause("formatException", new CodeGlobalTypeReference(typeof(System.FormatException)));
catchFormatException.Statements.Add(new CodeThrowFormatExceptionStatement(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("formatException"), "Message")));
tryCatchFinallyStatement.CatchClauses.Add(catchFormatException);
tryCatchFinallyStatement.FinallyStatements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(uniqueConstraintSchema.Table.DataModel.Name), "DataLock"),
"ExitReadLock"));
this.Statements.Add(tryCatchFinallyStatement);
// }
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private CodeMemberMethod Set_DefaultNodeConfig_Tree()
{
CodeMemberMethod Set_DefaultNodeConfig_Tree = null;
CodeMethodInvokeExpression MethodInvokation = null;
try
{
Set_DefaultNodeConfig_Tree = new CodeMemberMethod
{
Name = "Set_DefaultNodeConfig_Tree",
Attributes = MemberAttributes.Public | MemberAttributes.Final,
ReturnType = new CodeTypeReference(typeof(Object))
};
//try block
CodeTryCatchFinallyStatement tryblock = AddTryBlock(Set_DefaultNodeConfig_Tree);
IEnumerable <IGrouping <string, Tree> > treeGroups = _ilbo.Trees.GroupBy(t => t.Name);
foreach (IGrouping <string, Tree> treeGrp in treeGroups)
{
Tree tree = treeGrp.First();
foreach (TreeInfo treeinfo in tree.Info)
{
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.OpenImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_openimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.NotExpandedImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_notexpandedimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.ExpandableImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_expandableimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.ExpandedImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_expandedimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.CloseImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_closeimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.CheckImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_checkimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.UnCheckImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "vwt_uncheckimage") }));
tryblock.AddStatement(MethodInvocationExp(TypeReferenceExp("oDefaultNTConfig"), "Add").AddParameters(new Object[] { Convert.ToString(treeinfo.PartialCheckImage), string.Format("{0}~~{1}~~{2}", tree.Name, treeinfo.NodeType, "chkbox_parial_chkimg") }));
}
}
tryblock.TryStatements.Add(ReturnExpression(SnippetExpression("null")));
//catch block
CodeCatchClause catchblock = AddCatchBlock(tryblock);
MethodInvokation = MethodInvocationExp(TypeReferenceExp("Trace"), "WriteLineIf");
AddParameters(MethodInvokation, new Object[] { PrimitiveExpression(false), PrimitiveExpression("Set_DefaultNodeConfig_Tree"), SnippetExpression("e.Message.ToString()") });
catchblock.Statements.Add(MethodInvokation);
catchblock.Statements.Add(ReturnExpression(SnippetExpression("null")));
}
catch (Exception ex)
{
throw new Exception(string.Format("GenerateTreeClass.Set_DefaultNodeConfig_Tree()->{0}", !object.Equals(ex.InnerException, null) ? ex.InnerException.Message : ex.Message));
}
return(Set_DefaultNodeConfig_Tree);
}
internal static CodeCatchClause Catch(CodeTypeReference type, string name, CodeStatement catchStmnt)
{
CodeCatchClause clause = new CodeCatchClause {
CatchExceptionType = type,
LocalName = name
};
if (catchStmnt != null)
{
clause.Statements.Add(catchStmnt);
}
return(clause);
}
public void Constructor1()
{
CodeCatchClause cc1 = new CodeCatchClause();
CodeCatchClause cc2 = new CodeCatchClause();
CodeCatchClause[] catchClauses = new CodeCatchClause[] { cc1, cc2 };
CodeCatchClauseCollection coll = new CodeCatchClauseCollection(
catchClauses);
Assert.AreEqual(2, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(cc1), "#2");
Assert.AreEqual(1, coll.IndexOf(cc2), "#3");
}
public static CodeCatchClause Clone(this CodeCatchClause clause)
{
if (clause == null)
{
return(null);
}
CodeCatchClause c = new CodeCatchClause();
c.CatchExceptionType = clause.CatchExceptionType.Clone();
c.LocalName = clause.LocalName;
c.Statements.AddRange(clause.Statements.Clone());
return(c);
}
public void CatchClauses_AddMultiple_ReturnsExpected()
{
var tryCatchFinally = new CodeTryCatchFinallyStatement();
CodeCatchClause catchClause1 = new CodeCatchClause("Local1");
tryCatchFinally.CatchClauses.Add(catchClause1);
Assert.Equal(new CodeCatchClause[] { catchClause1 }, tryCatchFinally.CatchClauses.Cast <CodeCatchClause>());
CodeCatchClause catchClause2 = new CodeCatchClause("Local2");
tryCatchFinally.CatchClauses.Add(catchClause2);
Assert.Equal(new CodeCatchClause[] { catchClause1, catchClause2 }, tryCatchFinally.CatchClauses.Cast <CodeCatchClause>());
}
void VisitCodeCatchClause(CodeCatchClause catchClause)
{
WriteLine("VisitCodeCatchClause");
WriteLine("Exception caught: " + catchClause.CatchExceptionType.BaseType);
WriteLine("Exception variable: " + catchClause.LocalName);
WriteLine("Catch statements follow: Count: " + catchClause.Statements.Count);
using (IDisposable currentLevel = Indentation.IncrementLevel()) {
foreach (CodeStatement statement in catchClause.Statements)
{
VisitCodeStatement(statement);
}
}
}
public void Statements_AddMultiple_ReturnsExpected()
{
var catchClause = new CodeCatchClause();
CodeStatement statement1 = new CodeCommentStatement("Value1");
catchClause.Statements.Add(statement1);
Assert.Equal(new CodeStatement[] { statement1 }, catchClause.Statements.Cast <CodeStatement>());
CodeStatement statement2 = new CodeCommentStatement("Value1");
catchClause.Statements.Add(statement2);
Assert.Equal(new CodeStatement[] { statement1, statement2 }, catchClause.Statements.Cast <CodeStatement>());
}
/// <summary>
/// Gets the throw clause.
/// </summary>
/// <returns>return catch...throw statement</returns>
internal static CodeCatchClause[] GetThrowClause()
{
var catchStatmanents = new CodeStatementCollection();
catchStatmanents.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("ex")));
var catchClause = new CodeCatchClause(
"ex",
new CodeTypeReference(typeof(Exception)),
catchStatmanents.ToArray());
var catchClauses = new[] { catchClause };
return(catchClauses);
}
internal void UCodeAddTestMethod(string methodName, Dictionary <string, string> methodAttribute,
string reportCollection = "unifiedLogCollection", string reportInstance = "unifiedReport")
{
string testCaseDescription = string.Empty;
CodeMemberMethod sampleMethod = new CodeMemberMethod();
sampleMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
sampleMethod.Name = methodName;
sampleMethod.ReturnType =
new CodeTypeReference(typeof(void));
CodeAttributeDeclarationCollection collection = new CodeAttributeDeclarationCollection();
if (methodAttribute != null)
{
foreach (KeyValuePair <string, string> singleItem in methodAttribute)
{
if (singleItem.Key.ToLower().ToString().Contains("description"))
{
testCaseDescription = "\"" + singleItem.Value + "\"";
}
if (string.IsNullOrEmpty(singleItem.Value))
{
collection.Add(new CodeAttributeDeclaration(singleItem.Key));
}
else
{
collection.Add(new CodeAttributeDeclaration(singleItem.Key,
new CodeAttributeArgument(new CodePrimitiveExpression(singleItem.Value))));
}
}
foreach (CodeAttributeDeclaration singleDeclaration in collection)
{
sampleMethod.CustomAttributes.Add(singleDeclaration);
}
}
sampleMethod.Statements.Add(new CodeSnippetExpression(reportCollection + ".Add(" + reportInstance + ".StartTest(" + testCaseDescription + "));"));
CodeTryCatchFinallyStatement testMethodTry = new CodeTryCatchFinallyStatement();
testMethodTry.TryStatements.Add(new CodeCommentStatement("Please fill in you code here"));
sampleMethod.Statements.Add(testMethodTry);
CodeCatchClause testMethodCatch = new CodeCatchClause("ex");
testMethodCatch.Statements.Add(new CodeCommentStatement("Code to handle the Exception"));
testMethodTry.CatchClauses.Add(testMethodCatch);
testMethodTry.FinallyStatements.Add(new CodeCommentStatement("Handle any finally block"));
targetClass.Members.Add(sampleMethod);
}
public void Constructor1_Deny_Unrestricted()
{
CodeStatement[] try_statements = new CodeStatement[1] {
new CodeStatement()
};
CodeCatchClause[] catch_clauses = new CodeCatchClause[1] {
new CodeCatchClause()
};
CodeTryCatchFinallyStatement ctcfs = new CodeTryCatchFinallyStatement(try_statements, catch_clauses);
Assert.AreEqual(1, ctcfs.CatchClauses.Count, "CatchClauses");
Assert.AreEqual(0, ctcfs.FinallyStatements.Count, "FinallyStatements");
Assert.AreEqual(1, ctcfs.TryStatements.Count, "TryStatements");
}
public void Insert()
{
CodeCatchClause cc1 = new CodeCatchClause();
CodeCatchClause cc2 = new CodeCatchClause();
CodeCatchClauseCollection coll = new CodeCatchClauseCollection();
coll.Add(cc1);
Assert.AreEqual(1, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(cc1), "#2");
coll.Insert(0, cc2);
Assert.AreEqual(2, coll.Count, "#3");
Assert.AreEqual(1, coll.IndexOf(cc1), "#4");
Assert.AreEqual(0, coll.IndexOf(cc2), "#5");
}
public void CodeTryCatchFinallyStatementTest()
{
CodeStatement cs = new CodeGotoStatement("exit");
CodeCatchClause ccc1 = new CodeCatchClause("ex1", new CodeTypeReference("System.ArgumentException"));
CodeCatchClause ccc2 = new CodeCatchClause(null, new CodeTypeReference("System.ApplicationException"));
CodeSnippetStatement fin1 = new CodeSnippetStatement("A");
CodeSnippetStatement fin2 = new CodeSnippetStatement("B");
statement = new CodeTryCatchFinallyStatement(new CodeStatement[] { cs },
new CodeCatchClause[] { ccc1, ccc2 }, new CodeStatement[] { fin1, fin2 });
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"try {{{0}" +
" goto exit;{0}" +
"}}{0}" +
"catch (System.ArgumentException ex1) {{{0}" +
"}}{0}" +
"catch (System.ApplicationException ) {{{0}" +
"}}{0}" +
"finally {{{0}" +
"A{0}" +
"B{0}" +
"}}{0}", NewLine), Generate(), "#1");
options.ElseOnClosing = true;
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"try {{{0}" +
" goto exit;{0}" +
"}} catch (System.ArgumentException ex1) {{{0}" +
"}} catch (System.ApplicationException ) {{{0}" +
"}} finally {{{0}" +
"A{0}" +
"B{0}" +
"}}{0}", NewLine), Generate(), "#2");
statement = new CodeTryCatchFinallyStatement();
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"try {{{0}" +
"}}{0}", NewLine), Generate(), "#3");
options.ElseOnClosing = false;
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"try {{{0}" +
"}}{0}", NewLine), Generate(), "#4");
}
public void Constructor2()
{
CodeCatchClause cc1 = new CodeCatchClause();
CodeCatchClause cc2 = new CodeCatchClause();
CodeCatchClauseCollection c = new CodeCatchClauseCollection();
c.Add(cc1);
c.Add(cc2);
CodeCatchClauseCollection coll = new CodeCatchClauseCollection(c);
Assert.AreEqual(2, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(cc1), "#2");
Assert.AreEqual(1, coll.IndexOf(cc2), "#3");
}
/// <summary>
/// 创建一个Try
/// </summary>
/// <param name="tryCode"></param>
/// <returns></returns>
public CodeTryCatchFinallyStatement CreateTry(Func <CodeStatementCollection> tryCode)
{
CodeCatchClause @catch = new CodeCatchClause
{
CatchExceptionType = new CodeTypeReference(typeof(Exception)),
LocalName = "ex"
};
@catch.Statements.Add(new CodeSnippetExpression("throw ex;"));
CodeTryCatchFinallyStatement codeTryCatchFinallyStatement = new CodeTryCatchFinallyStatement();
codeTryCatchFinallyStatement.TryStatements.AddRange(tryCode());
codeTryCatchFinallyStatement.CatchClauses.Add(@catch);
return(codeTryCatchFinallyStatement);
}
/// <summary>
/// Return catch statements
/// </summary>
/// <returns>CodeCatchClause statements</returns>
internal static CodeCatchClause[] GetCatchClause()
{
var catchStatmanents = new CodeStatement[2];
catchStatmanents[0] = new CodeAssignStatement(
new CodeVariableReferenceExpression("exception"),
new CodeVariableReferenceExpression("ex"));
catchStatmanents[1] = GetReturnFalse();
var catchClause = new CodeCatchClause(
"ex",
new CodeTypeReference(typeof(Exception)),
catchStatmanents);
var catchClauses = new[] { catchClause };
return(catchClauses);
}
private CodeMemberMethod ResetChartControls()
{
CodeMemberMethod ResetChartControls = null;
try
{
ResetChartControls = new CodeMemberMethod
{
Name = "ResetChartControls",
Attributes = MemberAttributes.Public | MemberAttributes.Final,
ReturnType = new CodeTypeReference(typeof(bool)),
};
CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression();
parameter.Name = "cContextItemsChart";
parameter.Type = new CodeTypeReference(typeof(Dictionary <String, Object>));
parameter.Direction = FieldDirection.Ref;
ResetChartControls.Parameters.Add(parameter);
CodeTryCatchFinallyStatement tryBlock = new CodeTryCatchFinallyStatement();
foreach (string sChartName in _ilbo.Charts.Select(c => c.Name).Distinct())
{
CodeConditionStatement ifKeyExists = IfCondition();
ifKeyExists.Condition = BinaryOpertorExpression(MethodInvocationExp(MethodInvocationExp(VariableReferenceExp("cContextItemsChart"), "ContainsKey").AddParameter(PrimitiveExpression(string.Format("ICT_ILBO_CHART_{0}", sChartName))), "ToString"), CodeBinaryOperatorType.IdentityEquality, PrimitiveExpression("True"));
ifKeyExists.TrueStatements.Add(MethodInvocationExp(VariableReferenceExp("cContextItemsChart"), "Remove").AddParameter(PrimitiveExpression(string.Format("ICT_ILBO_CHART_{0}", sChartName))));
tryBlock.AddStatement(ifKeyExists);
}
tryBlock.AddStatement(ReturnExpression(PrimitiveExpression(true)));
CodeCatchClause catchBlock = AddCatchBlock(tryBlock, "e");
catchBlock.AddStatement(MethodInvocationExp(TypeReferenceExp("Trace"), "WriteLineIf").AddParameters(new CodeExpression[] { PrimitiveExpression(false), PrimitiveExpression("ResetChartControls"), MethodInvocationExp(GetProperty("e", "Message"), "ToString") }));
ResetChartControls.AddStatement(tryBlock);
ResetChartControls.AddStatement(ReturnExpression(PrimitiveExpression(false)));
return(ResetChartControls);
}
catch (Exception ex)
{
throw new Exception(string.Format("ResetChartControls->{0}", ex.InnerException != null ? ex.InnerException.Message : ex.Message));
}
}
internal void UCodeAddMethod(string methodName, Dictionary <string, string> methodAttribute = null, bool tryCatchBlock = false)
{
CodeMemberMethod sampleMethod = new CodeMemberMethod();
sampleMethod.Attributes = MemberAttributes.Public;
sampleMethod.Name = methodName;
sampleMethod.ReturnType =
new CodeTypeReference(typeof(void));
CodeAttributeDeclarationCollection collection = new CodeAttributeDeclarationCollection();
if (methodAttribute != null)
{
foreach (KeyValuePair <string, string> singleItem in methodAttribute)
{
if (string.IsNullOrEmpty(singleItem.Value))
{
collection.Add(new CodeAttributeDeclaration(singleItem.Key));
}
else
{
collection.Add(new CodeAttributeDeclaration(singleItem.Key,
new CodeAttributeArgument(new CodePrimitiveExpression(singleItem.Value))));
}
}
foreach (CodeAttributeDeclaration singleDeclaration in collection)
{
sampleMethod.CustomAttributes.Add(singleDeclaration);
}
}
if (tryCatchBlock)
{
CodeTryCatchFinallyStatement testMethodTry = new CodeTryCatchFinallyStatement();
testMethodTry.TryStatements.Add(new CodeCommentStatement("Please fill in you code here"));
sampleMethod.Statements.Add(testMethodTry);
CodeCatchClause testMethodCatch = new CodeCatchClause("ex");
testMethodCatch.Statements.Add(new CodeCommentStatement("Code to handle the Exception"));
testMethodTry.CatchClauses.Add(testMethodCatch);
testMethodTry.FinallyStatements.Add(new CodeCommentStatement("Handle any finally block"));
}
targetClass.Members.Add(sampleMethod);
}
/// <summary>
/// Creates a property that gets or sets the value of an item in a row.
/// </summary>
/// <param name="tableSchema">The table to which this row belongs.</param>
/// <param name="columnSchema">The nullable column.</param>
public ColumnProperty(TableSchema tableSchema, ColumnSchema columnSchema)
{
// /// <summary>
// /// Gets or sets the data in the RaceCode column.
// /// </summary>
// public int RaceCode {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(string.Format("Gets or sets the data in the {0} column.", columnSchema.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.Type = new CodeGlobalTypeReference(columnSchema.DataType);
this.Name = columnSchema.Name;
// get {
// try {
// return ((int)(this[this.tableEmployee.RaceCodeColumn]));
// }
// catch (global::System.InvalidCastException e) {
// throw new global::System.Data.StrongTypingException("Cannot get value because it is DBNull.", e);
// }
// }
if (columnSchema.IsNullable)
{
CodeTryCatchFinallyStatement tryCatchBlock = new CodeTryCatchFinallyStatement();
tryCatchBlock.TryStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(this.Type, new CodeArrayIndexerExpression(new CodeThisReferenceExpression(), new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), string.Format("table{0}", tableSchema.Name)), string.Format("{0}Column", columnSchema.Name))))));
CodeCatchClause catchStrongTypeException = new CodeCatchClause("e", new CodeGlobalTypeReference(typeof(System.InvalidCastException)));
catchStrongTypeException.Statements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(System.Data.StrongTypingException)), new CodePrimitiveExpression("Cannot get value because it is DBNull."), new CodeArgumentReferenceExpression("e"))));
tryCatchBlock.CatchClauses.Add(catchStrongTypeException);
this.GetStatements.Add(tryCatchBlock);
}
else
{
this.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(this.Type, new CodeArrayIndexerExpression(new CodeThisReferenceExpression(), new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), string.Format("table{0}", tableSchema.Name)), string.Format("{0}Column", columnSchema.Name))))));
}
// set {
// this[this.tableEmployee.RaceCodeColumn] = value;
// }
this.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(new CodeThisReferenceExpression(), new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), string.Format("table{0}", tableSchema.Name)), string.Format("{0}Column", columnSchema.Name))), new CodePropertySetValueReferenceExpression()));
// }
}
public static CodeStatement CreateTryCatchStatement(CodeTypeDeclaration classType, CodeStatement statement, CodeGenerationInfo generationInfo)
{
var tryStatement = new CodeTryCatchFinallyStatement();
tryStatement.TryStatements.Add(statement);
var catchClause = new CodeCatchClause("e", new CodeTypeReference("std::exception&"));
var methodRefExp = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression($"{generationInfo.BaseNamespace}.CremaData"), "InvokeErrorOccured");
var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("e"));
var conditionStatement = new CodeConditionStatement();
conditionStatement.Condition = new CodeBinaryOperatorExpression(methodInvokeExp, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(false));
conditionStatement.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("e")));
catchClause.Statements.Add(conditionStatement);
tryStatement.CatchClauses.Add(catchClause);
return(tryStatement);
}
public void TestCodeTryCatchStatement()
{
CodeTryCatchFinallyStatement try1 = new CodeTryCatchFinallyStatement();
try1.TryStatements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "ThrowApplicationException"));
CodeCatchClause catch1 = new CodeCatchClause("ex", new CodeTypeReference("System.ApplicationException"));
catch1.Statements.Add(new CodeCommentStatement("Handle any System.ApplicationException here."));
try1.CatchClauses.Add(catch1);
TestCodeStatement(try1,
@" try {
this.ThrowApplicationException();
}
catch (ex) {
// Handle any System.ApplicationException here.
}
");
}
/// <summary>
/// Constructs FillMessageObject
/// </summary>
/// <returns>CodeMemberMethod</returns>
private CodeMemberMethod FillMessageObject()
{
CodeMemberMethod FillMessageObject = null;
try
{
FillMessageObject = new CodeMemberMethod
{
Name = "FillMessageObject",
Attributes = MemberAttributes.Private
};
//method parameters
FillMessageObject.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "sMethod"));
FillMessageObject.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "sErrNumber"));
FillMessageObject.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "sErrMessage"));
//method summary
AddMethodSummary(FillMessageObject, "Fills the Message object when an error occurs");
CodeTryCatchFinallyStatement TryBlock = AddTryBlock(FillMessageObject);
TryBlock.TryStatements.Add(AddTrace(FillMessageObject, TraceSeverity.Info));
TryBlock.TryStatements.Add(DeclareVariableAndAssign("ISessionManager", "ISManager", true, SnippetExpression("(ISessionManager)System.Web.HttpContext.Current.Session[\"SessionManager\"]")));
TryBlock.TryStatements.Add(DeclareVariableAndAssign("IMessage", "Imsg", true, SnippetExpression("ISManager.GetMessageObject()")));
CodeMethodInvokeExpression AddMessage = MethodInvocationExp(TypeReferenceExp("Imsg"), "AddMessage");
AddParameters(AddMessage, new object[] { ArgumentReferenceExp("sErrNumber"), ArgumentReferenceExp("sErrMessage"), ArgumentReferenceExp("sMethod"), GetProperty(TypeReferenceExp(typeof(string)), "Empty"), PrimitiveExpression("5") });
TryBlock.TryStatements.Add(AddMessage);
CodeCatchClause catchBlock = CodeDomHelper.AddCatchBlock(TryBlock);
catchBlock.Statements.Add(AddTrace(FillMessageObject, TraceSeverity.Error));
CodeDomHelper.ThrowException(catchBlock);
}
catch (Exception ex)
{
throw new Exception(string.Format("FillMessageObject->{0}", !object.Equals(ex.InnerException, null) ? ex.InnerException.Message : ex.Message));
}
return(FillMessageObject);
}
private static CodeMemberMethod CreateClassMethod(string name, string inType, string inName, string outType, string noun, string verb, string attribute)
{
CodeMemberMethod method = new CodeMemberMethod()
{
Name = name,
Attributes = MemberAttributes.Public | MemberAttributes.Final,
ReturnType = new CodeTypeReference(outType)
};
method.Parameters.Add(new CodeParameterDeclarationExpression(inType, inName));
if (attribute != "")
{
method.CustomAttributes.Add(new string[] { $"{attribute}" });
}
CodeTryCatchFinallyStatement try1 = new CodeTryCatchFinallyStatement();
CodeCatchClause catch1 = new CodeCatchClause("e1");
if (IsEvent(verb))
{
try1.TryStatements.Add(new CodeSnippetExpression($"{inName}.{ChangeinType(inType, verb)}Message.IsHeaderOk(false, false)"));
}
else
{
try1.TryStatements.Add(new CodeSnippetExpression($"{inName}.{ChangeinType(inType, verb)}Message.IsHeaderOk(false, false, false)"));
try1.TryStatements.Add(new CodeSnippetExpression($"{inName}.{ChangeinType(inType, verb)}Message.IsRequestOk(true, true, true, true)"));
}
try1.TryStatements.Add(new CodeSnippetStatement($""));
try1.TryStatements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), $"{verb}Handler", new CodeExpression[] { new CodeArgumentReferenceExpression($"{inName}") })));
catch1.Statements.Add(new CodeSnippetStatement(GetErrorReplyStatement(inType, outType, noun, verb)));
try1.CatchClauses.Add(catch1);
method.Statements.Add(try1);
return(method);
}
private void ValidateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e)
{
this.ValidateStatements(e.TryStatements);
CodeCatchClauseCollection catchClauses = e.CatchClauses;
if (catchClauses.Count > 0)
{
IEnumerator enumerator = catchClauses.GetEnumerator();
while (enumerator.MoveNext())
{
CodeCatchClause current = (CodeCatchClause)enumerator.Current;
ValidateTypeReference(current.CatchExceptionType);
ValidateIdentifier(current, "LocalName", current.LocalName);
this.ValidateStatements(current.Statements);
}
}
CodeStatementCollection finallyStatements = e.FinallyStatements;
if (finallyStatements.Count > 0)
{
this.ValidateStatements(finallyStatements);
}
}
static CodeCatchClause _ParseCatchClause(_PC pc)
{
if (ST.catchKeyword != pc.SymbolId)
{
pc.Error("Expecting catch");
}
pc.Advance();
if (ST.lparen != pc.SymbolId)
{
pc.Error("Expecting ( in catch clause");
}
pc.Advance();
var result = new CodeCatchClause();
result.CatchExceptionType = _ParseType(pc);
if (ST.rparen != pc.SymbolId)
{
result.LocalName = _ParseIdentifier(pc);
}
if (ST.rparen != pc.SymbolId)
{
pc.Error("Expecting ) in catch clause");
}
pc.Advance();
if (ST.lbrace != pc.SymbolId)
{
pc.Error("Expecting { in catch clause");
}
pc.Advance();
result.Statements.AddRange(_ParseStatements(pc, true));
if (ST.rbrace != pc.SymbolId)
{
pc.Error("Expecting } in catch clause");
}
pc.Advance();
return(result);
}
public void Constructor3()
{
string localName = "mono";
CodeTypeReference cet = new CodeTypeReference("SomeException");
CodeStatement cs1 = new CodeStatement();
CodeStatement cs2 = new CodeStatement();
CodeCatchClause ccc = new CodeCatchClause(localName, cet, cs1, cs2);
Assert.IsNotNull(ccc.CatchExceptionType, "#1");
Assert.AreSame(cet, ccc.CatchExceptionType, "#2");
Assert.IsNotNull(ccc.LocalName, "#3");
Assert.AreEqual(localName, ccc.LocalName, "#4");
Assert.AreSame(localName, ccc.LocalName, "#5");
Assert.IsNotNull(ccc.Statements, "#6");
Assert.AreEqual(2, ccc.Statements.Count, "#7");
Assert.AreSame(cs1, ccc.Statements[0], "#8");
Assert.AreSame(cs2, ccc.Statements[1], "#9");
ccc.LocalName = null;
Assert.IsNotNull(ccc.LocalName, "#8");
Assert.AreEqual(string.Empty, ccc.LocalName, "#9");
ccc.CatchExceptionType = null;
Assert.IsNotNull(ccc.CatchExceptionType, "#10");
Assert.AreEqual(typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#11");
ccc = new CodeCatchClause((string)null, (CodeTypeReference)null, cs1);
Assert.IsNotNull(ccc.LocalName, "#12");
Assert.AreEqual(string.Empty, ccc.LocalName, "#13");
Assert.IsNotNull(ccc.CatchExceptionType, "#14");
Assert.AreEqual(typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#15");
Assert.AreEqual(1, ccc.Statements.Count, "#16");
Assert.AreSame(cs1, ccc.Statements[0], "#17");
}
public void Constructor1()
{
string localName = "mono";
CodeCatchClause ccc = new CodeCatchClause(localName);
Assert.IsNotNull(ccc.CatchExceptionType, "#1");
Assert.AreEqual(typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#2");
Assert.IsNotNull(ccc.LocalName, "#3");
Assert.AreEqual(localName, ccc.LocalName, "#4");
Assert.AreSame(localName, ccc.LocalName, "#5");
Assert.IsNotNull(ccc.Statements, "#6");
Assert.AreEqual(0, ccc.Statements.Count, "#7");
ccc.LocalName = null;
Assert.IsNotNull(ccc.LocalName, "#8");
Assert.AreEqual(string.Empty, ccc.LocalName, "#9");
ccc = new CodeCatchClause((string)null);
Assert.IsNotNull(ccc.LocalName, "#10");
Assert.AreEqual(string.Empty, ccc.LocalName, "#22");
}
// Generate a codedom exception handler statement
public static CodeStatement Emit(ExceptionHandler ex)
{
// Create the codedom exception handler statement
var codeTry = new CodeTryCatchFinallyStatement();
// Add the statements in the try block
foreach (var e in ex.Try.ChildExpressions)
{
codeTry.TryStatements.Add(CodeDomEmitter.EmitCodeStatement(e));
}
// Add all the catch clauses.
foreach (var c in ex.CatchClauses)
{
// Create the codedom catch statement.
var catchClause = new CodeCatchClause();
// To do: replace with non-test code
catchClause.CatchExceptionType = new CodeTypeReference("System.Exception");
catchClause.LocalName = "ex";
codeTry.CatchClauses.Add(catchClause);
// Add the statemnts in the catch block
foreach (var e in c.ChildExpressions)
{
catchClause.Statements.Add(CodeDomEmitter.EmitCodeStatement(e));
}
}
// Add the statements in the finally block.
foreach (var e in ex.Finally.ChildExpressions)
{
codeTry.FinallyStatements.Add(CodeDomEmitter.EmitCodeStatement(e));
}
return(codeTry);
}
public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses, CodeStatement[] finallyStatements)
{
TryStatements.AddRange(tryStatements);
CatchClauses.AddRange(catchClauses);
FinallyStatements.AddRange(finallyStatements);
}
public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses, CodeStatement[] finallyStatements) {}
public void CatchExceptionType_Set_Get_ReturnsExpected(CodeTypeReference value)
{
var catchClause = new CodeCatchClause();
catchClause.CatchExceptionType = value;
Assert.Equal((value ?? new CodeTypeReference(typeof(Exception))).BaseType, catchClause.CatchExceptionType.BaseType);
}
public void Statements_AddMultiple_ReturnsExpected()
{
var catchClause = new CodeCatchClause();
CodeStatement statement1 = new CodeCommentStatement("Value1");
catchClause.Statements.Add(statement1);
Assert.Equal(new CodeStatement[] { statement1 }, catchClause.Statements.Cast<CodeStatement>());
CodeStatement statement2 = new CodeCommentStatement("Value1");
catchClause.Statements.Add(statement2);
Assert.Equal(new CodeStatement[] { statement1, statement2 }, catchClause.Statements.Cast<CodeStatement>());
}
public CodeCatchClauseCollection(CodeCatchClause[] value) {}
public void Remove(CodeCatchClause value) {}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// create a namespace
CodeNamespace ns = new CodeNamespace ("NS");
ns.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (ns);
// create a class
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "Test";
class1.IsClass = true;
ns.Types.Add (class1);
if (Supports (provider, GeneratorSupport.TryCatchStatements)) {
// try catch statement with just finally
// GENERATE (C#):
// public static int FirstScenario(int a) {
// try {
// }
// finally {
// a = (a + 5);
// }
// return a;
// }
AddScenario ("CheckFirstScenario");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "FirstScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement ();
tcfstmt.FinallyStatements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), new
CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (5))));
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
// in VB (a = a/a) generates an warning if a is integer. Cast the expression just for VB language.
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Divide, new CodeArgumentReferenceExpression ("a"));
CodeAssignStatement assignStatement = null;
if (provider is Microsoft.VisualBasic.VBCodeProvider)
assignStatement = new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), new CodeCastExpression (typeof (int), cboExpression));
else
assignStatement = new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), cboExpression);
// try catch statement with just catch
// GENERATE (C#):
// public static int SecondScenario(int a, string exceptionMessage) {
// try {
// a = (a / a);
// }
// catch (System.Exception e) {
// a = 3;
// exceptionMessage = e.ToString();
// }
// finally {
// a = (a + 1);
// }
// return a;
// }
AddScenario ("CheckSecondScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "SecondScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement ();
CodeCatchClause catchClause = new CodeCatchClause ("e");
tcfstmt.TryStatements.Add (assignStatement);
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (3)));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("exceptionMessage"),
new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("e"), "ToString")));
tcfstmt.CatchClauses.Add (catchClause);
tcfstmt.FinallyStatements.Add (CDHelper.CreateIncrementByStatement (new CodeArgumentReferenceExpression ("a"), 1));
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
// try catch statement with multiple catches
// GENERATE (C#):
// public static int ThirdScenario(int a, string exceptionMessage) {
// try {
// a = (a / a);
// }
// catch (System.ArgumentNullException e) {
// a = 10;
// exceptionMessage = e.ToString();
// }
// catch (System.DivideByZeroException f) {
// exceptionMessage = f.ToString();
// a = 9;
// }
// return a;
// }
AddScenario ("CheckThirdScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "ThirdScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement ();
catchClause = new CodeCatchClause ("e", new CodeTypeReference (typeof (ArgumentNullException)));
tcfstmt.TryStatements.Add (assignStatement);
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (9)));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("exceptionMessage"),
new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("e"), "ToString")));
tcfstmt.CatchClauses.Add (catchClause);
// add a second catch clause
catchClause = new CodeCatchClause ("f", new CodeTypeReference (typeof (Exception)));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("exceptionMessage"),
new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("f"), "ToString")));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (9)));
tcfstmt.CatchClauses.Add (catchClause);
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
// catch throws exception
// GENERATE (C#):
// public static int FourthScenario(int a) {
// try {
// a = (a / a);
// }
// catch (System.Exception e) {
// // Error handling
// throw e;
// }
// return a;
// }
AddScenario ("CheckFourthScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "FourthScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
tcfstmt = new CodeTryCatchFinallyStatement ();
catchClause = new CodeCatchClause ("e");
tcfstmt.TryStatements.Add (assignStatement);
catchClause.Statements.Add (new CodeCommentStatement ("Error handling"));
catchClause.Statements.Add (new CodeThrowExceptionStatement (new CodeArgumentReferenceExpression ("e")));
tcfstmt.CatchClauses.Add (catchClause);
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
}
}
public int IndexOf(CodeCatchClause value) {}
public void CopyTo(CodeCatchClause[] array, int index) {}
public bool Contains(CodeCatchClause value) {}
public void TryCatchThrow()
{
var cd = new CodeTypeDeclaration();
cd.Name = "Test";
cd.IsClass = true;
// try catch statement with just finally
var cmm = new CodeMemberMethod();
cmm.Name = "FirstScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Divide, new CodeVariableReferenceExpression("a"));
CodeAssignStatement assignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("a"), cboExpression);
// try catch statement with just catch
cmm = new CodeMemberMethod();
cmm.Name = "SecondScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
CodeCatchClause catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(3)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
tcfstmt.FinallyStatements.Add(CreateVariableIncrementExpression("a", 1));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// try catch statement with multiple catches
cmm = new CodeMemberMethod();
cmm.Name = "ThirdScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e", new CodeTypeReference(typeof(ArgumentNullException)));
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
// add a second catch clause
catchClause = new CodeCatchClause("f", new CodeTypeReference(typeof(Exception)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "ToString")));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// catch throws exception
cmm = new CodeMemberMethod();
cmm.Name = "FourthScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeCommentStatement("Error handling"));
catchClause.Statements.Add(new CodeThrowExceptionStatement(new CodeArgumentReferenceExpression("e")));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
AssertEqual(cd,
@"public class Test {
public static int FirstScenario(int a) {
try {
}
finally {
a = (a + 5);
}
return a;
}
public static int SecondScenario(int a, string exceptionMessage) {
try {
a = (a / a);
}
catch (System.Exception e) {
a = 3;
exceptionMessage = e.ToString();
}
finally {
a = (a + 1);
}
return a;
}
public static int ThirdScenario(int a, string exceptionMessage) {
try {
a = (a / a);
}
catch (System.ArgumentNullException e) {
a = 9;
exceptionMessage = e.ToString();
}
catch (System.Exception f) {
exceptionMessage = f.ToString();
a = 9;
}
return a;
}
public static int FourthScenario(int a) {
try {
a = (a / a);
}
catch (System.Exception e) {
// Error handling
throw e;
}
return a;
}
}");
}
// Methods
public int Add(CodeCatchClause value) {}
private bool WriteTry(BasicBlock block, List<CodeStatement> stmts, Context context)
{
// find catch/finally blocks that match this try
// write this block into the try
// continue until we find the try follow, which is the first block that has a last != leave
// if the try follow lands on a loop or conditional header, then use their follow instead
// TODO: deal with nested trys
var tryStmt = new CodeTryStatement();
AddStatement(stmts, tryStmt);
var tryContext = context.NewTry(block.Try);
WriteCode(null, block, tryStmt.Try, tryContext);
foreach (BasicBlock catchBlock in block.Try.Catches) {
var catchType = catchBlock.ExceptionHandler.CatchType;
var variable = Interpreter.CreateExceptionVariableReference(this.method.Definition, catchType);
var catchClause = new CodeCatchClause {
Type = new CodeTypeReference(catchType),
Variable = variable
};
tryStmt.Catches.Add(catchClause);
WriteCode(null, catchBlock, catchClause.Statements, tryContext);
}
if (block.Try.Finally != null) {
WriteCode(null, (BasicBlock)block.Try.Finally, tryStmt.Finally, tryContext);
}
if (block.Try.Follow != null) {
return WriteCode(block, (BasicBlock)block.Try.Follow, stmts, context);
}
return true;
}
public void Insert(int index, CodeCatchClause value) {}
public void TryCatchThrow()
{
var cd = new CodeTypeDeclaration();
cd.Name = "Test";
cd.IsClass = true;
// try catch statement with just finally
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "FirstScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Divide, new CodeVariableReferenceExpression("a"));
CodeAssignStatement assignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("a"), cboExpression);
// try catch statement with just catch
cmm = new CodeMemberMethod();
cmm.Name = "SecondScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
CodeCatchClause catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(3)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
tcfstmt.FinallyStatements.Add(CreateVariableIncrementExpression("a", 1));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// try catch statement with multiple catches
cmm = new CodeMemberMethod();
cmm.Name = "ThirdScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e", new CodeTypeReference(typeof(ArgumentNullException)));
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
// add a second catch clause
catchClause = new CodeCatchClause("f", new CodeTypeReference(typeof(Exception)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "ToString")));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// catch throws exception
cmm = new CodeMemberMethod();
cmm.Name = "FourthScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeCommentStatement("Error handling"));
catchClause.Statements.Add(new CodeThrowExceptionStatement(new CodeArgumentReferenceExpression("e")));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
AssertEqual(cd,
@"Public Class Test
Public Shared Function FirstScenario(ByVal a As Integer) As Integer
Try
Finally
a = (a + 5)
End Try
Return a
End Function
Public Shared Function SecondScenario(ByVal a As Integer, ByVal exceptionMessage As String) As Integer
Try
a = (a / a)
Catch e As System.Exception
a = 3
exceptionMessage = e.ToString
Finally
a = (a + 1)
End Try
Return a
End Function
Public Shared Function ThirdScenario(ByVal a As Integer, ByVal exceptionMessage As String) As Integer
Try
a = (a / a)
Catch e As System.ArgumentNullException
a = 9
exceptionMessage = e.ToString
Catch f As System.Exception
exceptionMessage = f.ToString
a = 9
End Try
Return a
End Function
Public Shared Function FourthScenario(ByVal a As Integer) As Integer
Try
a = (a / a)
Catch e As System.Exception
'Error handling
Throw e
End Try
Return a
End Function
End Class");
}
public void AddRange(CodeCatchClause[] value) {}
public void LocalName_Set_Get_ReturnsExpected(string value)
{
var catchClause = new CodeCatchClause();
catchClause.LocalName = value;
Assert.Equal(value ?? string.Empty, catchClause.LocalName);
}