public override System.CodeDom.CodeExpression GetCodeExpression(
BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
CodeTypeReferenceExpression targetClass =
new CodeTypeReferenceExpression(typeof(ExpressionBuilderIdentity));
string targetMethod = "GetIdentity";
CodeExpression methodParameter =
new CodePrimitiveExpression(entry.Expression.Trim());
return new CodeMethodInvokeExpression(
targetClass, targetMethod, methodParameter);
}
public override CodeExpression GetCodeExpression(
BoundPropertyEntry entry, object parsedData,
ExpressionBuilderContext context)
{
// entry.Expression is the number string
// (minus the RandomNumber: prefix).
if (!entry.Expression.Contains(","))
{
throw new ArgumentException("Must include two numbers separated by a comma.");
}
else
{
// Get the two numbers.
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Only include two numbers.");
}
else
{
int lowerLimit, upperLimit;
if (Int32.TryParse(numbers[0], out lowerLimit) &&
Int32.TryParse(numbers[1], out upperLimit))
{
// So far all the operations have been performed in
// normal code. That's because the two numbers are
// specified in the expression, and so they won't
// change each time the page is requested.
// However, the random number should be allowed to
// change each time, so you need to switch to CodeDOM.
Type type = entry.DeclaringType;
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(type)[entry.PropertyInfo.Name];
CodeExpression[] expressionArray = new CodeExpression[2];
expressionArray[0] = new CodePrimitiveExpression(lowerLimit);
expressionArray[1] = new CodePrimitiveExpression(upperLimit);
return new CodeCastExpression(descriptor.PropertyType, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetRandomNumber", expressionArray));
}
else
{
throw new ArgumentException("Use valid integers.");
}
}
}
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry,
object parsedData, ExpressionBuilderContext context)
{
// entry.Expression - строка с числом
// без префикса (например: "1,6").
if (!entry.Expression.Contains(","))
{
throw new ArgumentException(" Должны быть указаны два числа, разделенные запятой");
}
else
{
// Получить два числа
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Должны быть указаны два числа");
}
else
{
int min, max;
if (Int32.TryParse(numbers[0], out min) &&
Int32.TryParse(numbers[1], out max))
{
// Получить ссылку на класс, имеющий метод GetRandomNumber().
// (Это класс, где данный код выполняется.)
CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType());
// Определить параметры для GetRandomNumber().
CodeExpression[] methodParameters = new CodeExpression[2];
methodParameters[0] = new CodePrimitiveExpression(min);
methodParameters[1] = new CodePrimitiveExpression(max);
// Вернуть выражение привязки вызвав метод GetRandomNumber()
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(
typeRef, "GetRandomNumber", methodParameters);
return methodCall;
}
else
{
throw new ArgumentException("Должны использоваться допустимые целые числа");
}
}
}
}
public static void FormatComment(string docs, CodeTypeMember cmp, bool obsolete = false, string tag = "summary")
{
StringBuilder obsoleteMessageBuilder = new StringBuilder();
cmp.Comments.Add(new CodeCommentStatement(string.Format("<{0}>", tag), true));
foreach (string line in HtmlEncoder.HtmlEncode(docs).Split(Environment.NewLine.ToCharArray(), StringSplitOptions.None))
{
cmp.Comments.Add(new CodeCommentStatement(string.Format("<para>{0}</para>", line), true));
if (obsolete && (line.Contains("instead") || line.Contains("deprecated")))
{
obsoleteMessageBuilder.Append(HtmlEncoder.HtmlDecode(line));
obsoleteMessageBuilder.Append(' ');
}
}
cmp.Comments.Add(new CodeCommentStatement(string.Format("</{0}>", tag), true));
if (obsoleteMessageBuilder.Length > 0)
{
obsoleteMessageBuilder.Remove(obsoleteMessageBuilder.Length - 1, 1);
CodeTypeReference obsoleteAttribute = new CodeTypeReference(typeof(ObsoleteAttribute));
CodePrimitiveExpression obsoleteMessage = new CodePrimitiveExpression(obsoleteMessageBuilder.ToString());
cmp.CustomAttributes.Add(new CodeAttributeDeclaration(obsoleteAttribute, new CodeAttributeArgument(obsoleteMessage)));
}
}
public override CodeExpression GetCodeExpression(System.Web.UI.BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
if (!entry.Expression.Contains(","))
{
throw new ArgumentException(
"Must include two numbers separated by a comma.");
}
else
{
// Get the two numbers.
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Only include two numbers.");
}
else
{
int lowerLimit, upperLimit;
if (Int32.TryParse(numbers[0], out lowerLimit) &&
Int32.TryParse(numbers[1], out upperLimit))
{
// Get a reference to the class that has the
// GetRandomNumber() method.
// (It's the class where this code is executing.)
CodeTypeReferenceExpression typeRef = new
CodeTypeReferenceExpression(this.GetType());
CodeExpression[] methodParameters = new CodeExpression[2];
methodParameters[0] = new CodePrimitiveExpression(lowerLimit);
methodParameters[1] = new CodePrimitiveExpression(upperLimit);
return new CodeMethodInvokeExpression(typeRef, "GetRandomNumber", methodParameters);
}
else
{
throw new ArgumentException("Use valid integers.");
}
}
}
}
void AddAsyncMembers(string messageName, CodeMemberMethod method)
{
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression enull = new CodePrimitiveExpression(null);
CodeMemberField codeField = new CodeMemberField(typeof(System.Threading.SendOrPostCallback), messageName + "OperationCompleted");
codeField.Attributes = MemberAttributes.Private;
CodeTypeDeclaration.Members.Add(codeField);
// Event arguments class
string argsClassName = classNames.AddUnique(messageName + "CompletedEventArgs", null);
CodeTypeDeclaration argsClass = new CodeTypeDeclaration(argsClassName);
argsClass.Attributes |= MemberAttributes.Public;
#if NET_2_0
argsClass.IsPartial = true;
#endif
argsClass.BaseTypes.Add(new CodeTypeReference("System.ComponentModel.AsyncCompletedEventArgs"));
CodeMemberField resultsField = new CodeMemberField(typeof(object[]), "results");
resultsField.Attributes = MemberAttributes.Private;
argsClass.Members.Add(resultsField);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Assembly;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object[]), "results"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(System.Exception), "exception"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("exception"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("cancelled"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("userState"));
CodeExpression thisResults = new CodeFieldReferenceExpression(ethis, "results");
cc.Statements.Add(new CodeAssignStatement(thisResults, new CodeVariableReferenceExpression("results")));
argsClass.Members.Add(cc);
int ind = 0;
if (method.ReturnType.BaseType != "System.Void")
{
argsClass.Members.Add(CreateArgsProperty(method.ReturnType, "Result", ind++));
}
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
if (par.Direction == FieldDirection.Out || par.Direction == FieldDirection.Ref)
{
argsClass.Members.Add(CreateArgsProperty(par.Type, par.Name, ind++));
}
}
bool needsArgsClass = (ind > 0);
if (needsArgsClass)
{
asyncTypes.Add(argsClass);
}
else
{
argsClassName = "System.ComponentModel.AsyncCompletedEventArgs";
}
// Event delegate type
CodeTypeDelegate delegateType = new CodeTypeDelegate(messageName + "CompletedEventHandler");
delegateType.Attributes |= MemberAttributes.Public;
delegateType.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
delegateType.Parameters.Add(new CodeParameterDeclarationExpression(argsClassName, "args"));
// Event member
CodeMemberEvent codeEvent = new CodeMemberEvent();
codeEvent.Attributes = codeEvent.Attributes & ~MemberAttributes.AccessMask | MemberAttributes.Public;
codeEvent.Name = messageName + "Completed";
codeEvent.Type = new CodeTypeReference(delegateType.Name);
CodeTypeDeclaration.Members.Add(codeEvent);
// Async method (without user state param)
CodeMemberMethod am = new CodeMemberMethod();
am.Attributes = MemberAttributes.Public | MemberAttributes.Final;
am.Name = method.Name + "Async";
am.ReturnType = new CodeTypeReference(typeof(void));
CodeMethodInvokeExpression inv;
inv = new CodeMethodInvokeExpression(ethis, am.Name);
am.Statements.Add(inv);
// On...Completed method
CodeMemberMethod onCompleted = new CodeMemberMethod();
onCompleted.Name = "On" + messageName + "Completed";
onCompleted.Attributes = MemberAttributes.Private | MemberAttributes.Final;
onCompleted.ReturnType = new CodeTypeReference(typeof(void));
onCompleted.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "arg"));
CodeConditionStatement anIf = new CodeConditionStatement();
CodeExpression eventField = new CodeEventReferenceExpression(ethis, codeEvent.Name);
anIf.Condition = new CodeBinaryOperatorExpression(eventField, CodeBinaryOperatorType.IdentityInequality, enull);
CodeExpression castedArg = new CodeCastExpression(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), new CodeVariableReferenceExpression("arg"));
CodeStatement invokeArgs = new CodeVariableDeclarationStatement(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), "invokeArgs", castedArg);
anIf.TrueStatements.Add(invokeArgs);
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression();
delegateInvoke.TargetObject = eventField;
delegateInvoke.Parameters.Add(ethis);
CodeObjectCreateExpression argsInstance = new CodeObjectCreateExpression(argsClassName);
CodeExpression invokeArgsVar = new CodeVariableReferenceExpression("invokeArgs");
if (needsArgsClass)
{
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Results"));
}
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Error"));
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Cancelled"));
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "UserState"));
delegateInvoke.Parameters.Add(argsInstance);
anIf.TrueStatements.Add(delegateInvoke);
onCompleted.Statements.Add(anIf);
// Async method
CodeMemberMethod asyncMethod = new CodeMemberMethod();
asyncMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
asyncMethod.Name = method.Name + "Async";
asyncMethod.ReturnType = new CodeTypeReference(typeof(void));
CodeExpression delegateField = new CodeFieldReferenceExpression(ethis, codeField.Name);
anIf = new CodeConditionStatement();
anIf.Condition = new CodeBinaryOperatorExpression(delegateField, CodeBinaryOperatorType.IdentityEquality, enull);;
CodeExpression delegateRef = new CodeMethodReferenceExpression(ethis, onCompleted.Name);
CodeExpression newDelegate = new CodeObjectCreateExpression(typeof(System.Threading.SendOrPostCallback), delegateRef);
CodeAssignStatement cas = new CodeAssignStatement(delegateField, newDelegate);
anIf.TrueStatements.Add(cas);
asyncMethod.Statements.Add(anIf);
CodeArrayCreateExpression paramsArray = new CodeArrayCreateExpression(typeof(object));
// Assign parameters
CodeIdentifiers paramsIds = new CodeIdentifiers();
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
paramsIds.Add(par.Name, null);
if (par.Direction == FieldDirection.In || par.Direction == FieldDirection.Ref)
{
CodeParameterDeclarationExpression inpar = new CodeParameterDeclarationExpression(par.Type, par.Name);
am.Parameters.Add(inpar);
asyncMethod.Parameters.Add(inpar);
inv.Parameters.Add(new CodeVariableReferenceExpression(par.Name));
paramsArray.Initializers.Add(new CodeVariableReferenceExpression(par.Name));
}
}
inv.Parameters.Add(enull);
string userStateName = paramsIds.AddUnique("userState", null);
asyncMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userStateName));
CodeExpression userStateVar = new CodeVariableReferenceExpression(userStateName);
asyncMethod.Statements.Add(BuildInvokeAsync(messageName, paramsArray, delegateField, userStateVar));
CodeTypeDeclaration.Members.Add(am);
CodeTypeDeclaration.Members.Add(asyncMethod);
CodeTypeDeclaration.Members.Add(onCompleted);
asyncTypes.Add(delegateType);
}
private void ValidatePrimitiveExpression(CodePrimitiveExpression e)
{
}
private void GeneratePrimitiveExpression(CodePrimitiveExpression e)
{
if (e.Value is char)
{
GeneratePrimitiveChar((char)e.Value);
}
else if (e.Value is SByte)
{
// C# has no literal marker for types smaller than Int32
Output.Write(((SByte)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is UInt16)
{
// C# has no literal marker for types smaller than Int32, and you will
// get a conversion error if you use "u" here.
Output.Write("0x");
Output.Write(((UInt16)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is UInt32)
{
Output.Write("0x");
Output.Write(((UInt32)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is UInt64)
{
Output.Write("0x");
Output.Write(((UInt64)e.Value).ToString(CultureInfo.InvariantCulture));
}
else
{
GeneratePrimitiveExpressionBase(e);
}
}
void GenerateEventBasedAsyncSupport(CodeTypeDeclaration type, OperationDescription od, CodeNamespace cns)
{
var method = FindByName(type, od.Name) ?? FindByName(type, "Begin" + od.Name);
var endMethod = method.Name == od.Name ? null : FindByName(type, "End" + od.Name);
bool methodAsync = method.Name.StartsWith("Begin", StringComparison.Ordinal);
var resultType = endMethod != null ? endMethod.ReturnType : method.ReturnType;
var thisExpr = new CodeThisReferenceExpression();
var baseExpr = new CodeBaseReferenceExpression();
var nullExpr = new CodePrimitiveExpression(null);
var asyncResultType = new CodeTypeReference(typeof(IAsyncResult));
// OnBeginXxx() implementation
var cm = new CodeMemberMethod()
{
Name = "OnBegin" + od.Name,
Attributes = MemberAttributes.Private | MemberAttributes.Final,
ReturnType = asyncResultType
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(object []), "args");
AddMethodParam(cm, typeof(AsyncCallback), "asyncCallback");
AddMethodParam(cm, typeof(object), "userState");
var call = new CodeMethodInvokeExpression(
thisExpr,
"Begin" + od.Name);
for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
{
var p = method.Parameters [idx];
cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name, new CodeCastExpression(p.Type, new CodeArrayIndexerExpression(new CodeArgumentReferenceExpression("args"), new CodePrimitiveExpression(idx)))));
call.Parameters.Add(new CodeVariableReferenceExpression(p.Name));
}
call.Parameters.Add(new CodeArgumentReferenceExpression("asyncCallback"));
call.Parameters.Add(new CodeArgumentReferenceExpression("userState"));
cm.Statements.Add(new CodeMethodReturnStatement(call));
// OnEndXxx() implementation
cm = new CodeMemberMethod()
{
Name = "OnEnd" + od.Name,
Attributes = MemberAttributes.Private | MemberAttributes.Final,
ReturnType = new CodeTypeReference(typeof(object []))
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(IAsyncResult), "result");
var outArgRefs = new List <CodeVariableReferenceExpression> ();
for (int idx = 0; idx < method.Parameters.Count; idx++)
{
var p = method.Parameters [idx];
if (p.Direction != FieldDirection.In)
{
cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name));
outArgRefs.Add(new CodeVariableReferenceExpression(p.Name)); // FIXME: should this work? They need "out" or "ref" modifiers.
}
}
call = new CodeMethodInvokeExpression(
thisExpr,
"End" + od.Name,
new CodeArgumentReferenceExpression("result"));
call.Parameters.AddRange(outArgRefs.Cast <CodeExpression> ().ToArray()); // questionable
var retCreate = new CodeArrayCreateExpression(typeof(object));
if (resultType.BaseType == "System.Void")
{
cm.Statements.Add(call);
}
else
{
cm.Statements.Add(new CodeVariableDeclarationStatement(typeof(object), "__ret", call));
retCreate.Initializers.Add(new CodeVariableReferenceExpression("__ret"));
}
foreach (var outArgRef in outArgRefs)
{
retCreate.Initializers.Add(new CodeVariableReferenceExpression(outArgRef.VariableName));
}
cm.Statements.Add(new CodeMethodReturnStatement(retCreate));
// OnXxxCompleted() implementation
cm = new CodeMemberMethod()
{
Name = "On" + od.Name + "Completed",
Attributes = MemberAttributes.Private | MemberAttributes.Final
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(object), "state");
string argsname = identifiers.AddUnique(od.Name + "CompletedEventArgs", null);
var iaargs = new CodeTypeReference("InvokeAsyncCompletedEventArgs"); // avoid messy System.Type instance for generic nested type :|
var iaref = new CodeVariableReferenceExpression("args");
var methodEventArgs = new CodeObjectCreateExpression(new CodeTypeReference(argsname),
new CodePropertyReferenceExpression(iaref, "Results"),
new CodePropertyReferenceExpression(iaref, "Error"),
new CodePropertyReferenceExpression(iaref, "Cancelled"),
new CodePropertyReferenceExpression(iaref, "UserState"));
cm.Statements.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeEventReferenceExpression(thisExpr, od.Name + "Completed"), CodeBinaryOperatorType.IdentityInequality, nullExpr),
new CodeVariableDeclarationStatement(iaargs, "args", new CodeCastExpression(iaargs, new CodeArgumentReferenceExpression("state"))),
new CodeExpressionStatement(new CodeMethodInvokeExpression(thisExpr, od.Name + "Completed", thisExpr, methodEventArgs))));
// delegate fields
type.Members.Add(new CodeMemberField(new CodeTypeReference("BeginOperationDelegate"), "onBegin" + od.Name + "Delegate"));
type.Members.Add(new CodeMemberField(new CodeTypeReference("EndOperationDelegate"), "onEnd" + od.Name + "Delegate"));
type.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(SendOrPostCallback)), "on" + od.Name + "CompletedDelegate"));
// XxxCompletedEventArgs class
var argsType = new CodeTypeDeclaration(argsname);
argsType.BaseTypes.Add(new CodeTypeReference(typeof(AsyncCompletedEventArgs)));
cns.Types.Add(argsType);
var argsCtor = new CodeConstructor()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object []), "results"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Exception), "error"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("error"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("cancelled"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("userState"));
var resultsField = new CodeFieldReferenceExpression(thisExpr, "results");
argsCtor.Statements.Add(new CodeAssignStatement(resultsField, new CodeArgumentReferenceExpression("results")));
argsType.Members.Add(argsCtor);
argsType.Members.Add(new CodeMemberField(typeof(object []), "results"));
if (resultType.BaseType != "System.Void")
{
var resultProp = new CodeMemberProperty {
Name = "Result",
Type = resultType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
resultProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(resultProp.Type, new CodeArrayIndexerExpression(resultsField, new CodePrimitiveExpression(0)))));
argsType.Members.Add(resultProp);
}
// event field
var handlerType = new CodeTypeReference(typeof(EventHandler <>));
handlerType.TypeArguments.Add(new CodeTypeReference(argsType.Name));
type.Members.Add(new CodeMemberEvent()
{
Name = od.Name + "Completed",
Type = handlerType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
});
// XxxAsync() implementations
bool hasAsync = false;
foreach (int __x in Enumerable.Range(0, 2))
{
cm = new CodeMemberMethod();
type.Members.Add(cm);
cm.Name = od.Name + "Async";
cm.Attributes = MemberAttributes.Public
| MemberAttributes.Final;
var inArgs = new List <CodeParameterDeclarationExpression> ();
for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
{
var pd = method.Parameters [idx];
inArgs.Add(pd);
cm.Parameters.Add(pd);
}
// First one is overload without asyncState arg.
if (!hasAsync)
{
call = new CodeMethodInvokeExpression(thisExpr, cm.Name, inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray());
call.Parameters.Add(nullExpr);
cm.Statements.Add(new CodeExpressionStatement(call));
hasAsync = true;
continue;
}
// Second one is the primary one.
cm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
// if (onBeginBarOperDelegate == null) onBeginBarOperDelegate = new BeginOperationDelegate (OnBeginBarOper);
// if (onEndBarOperDelegate == null) onEndBarOperDelegate = new EndOperationDelegate (OnEndBarOper);
// if (onBarOperCompletedDelegate == null) onBarOperCompletedDelegate = new BeginOperationDelegate (OnBarOperCompleted);
var beginOperDelegateRef = new CodeFieldReferenceExpression(thisExpr, "onBegin" + od.Name + "Delegate");
var endOperDelegateRef = new CodeFieldReferenceExpression(thisExpr, "onEnd" + od.Name + "Delegate");
var operCompletedDelegateRef = new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate");
var ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(beginOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(beginOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("BeginOperationDelegate"), thisExpr, "OnBegin" + od.Name)));
cm.Statements.Add(ifstmt);
ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(endOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(endOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("EndOperationDelegate"), thisExpr, "OnEnd" + od.Name)));
cm.Statements.Add(ifstmt);
ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(operCompletedDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(operCompletedDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SendOrPostCallback)), thisExpr, "On" + od.Name + "Completed")));
cm.Statements.Add(ifstmt);
// InvokeAsync (onBeginBarOperDelegate, inValues, onEndBarOperDelegate, onBarOperCompletedDelegate, userState);
inArgs.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
var args = new List <CodeExpression> ();
args.Add(beginOperDelegateRef);
args.Add(new CodeArrayCreateExpression(typeof(object), inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray()));
args.Add(endOperDelegateRef);
args.Add(new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate"));
args.Add(new CodeArgumentReferenceExpression("userState"));
call = new CodeMethodInvokeExpression(baseExpr, "InvokeAsync", args.ToArray());
cm.Statements.Add(new CodeExpressionStatement(call));
}
}
public void AddMethod(MemberAttributes sMemberAttributes,
string szName,
string szComments,
string szType)
{
//Establish the structure of the method
CodeMemberMethod oCodeMemberMethod = new CodeMemberMethod();
oCodeMemberMethod.Attributes = sMemberAttributes;
oCodeMemberMethod.Name = szName;
oCodeMemberMethod.Comments.Add(new CodeCommentStatement(szComments));
oCodeMemberMethod.ReturnType = new CodeTypeReference(szType);
//Indicate the data type and name of the parameter
oCodeMemberMethod.Parameters.Add(new
CodeParameterDeclarationExpression("System.Int32", "iCustomerID"));
//declare a variable within the body of the method
CodeVariableDeclarationStatement oCodeVariableDeclarationStatement =
new CodeVariableDeclarationStatement("System.String", "szSQL");
CodeArgumentReferenceExpression oCodeArgumentReferenceExpression =
new CodeArgumentReferenceExpression("\"DELETE FROM\"");
oCodeVariableDeclarationStatement.InitExpression =
oCodeArgumentReferenceExpression;
oCodeMemberMethod.Statements.Add(oCodeVariableDeclarationStatement);
//CodeVariableReferenceExpression oCodeVariableReferenceExpression =
// new CodeVariableReferenceExpression("oDatabase.Parameters");
//CodeMethodInvokeExpression oCodeMethodInvokeExpression =
// new CodeMethodInvokeExpression(oCodeVariableReferenceExpression, "Add");
//oCodeMethodInvokeExpression.Parameters.Add(
// new CodeVariableReferenceExpression("iCustomerID"));
//oCodeMethodInvokeExpression.Parameters.Add(
// new CodePrimitiveExpression("12345"));
//oCodeMemberMethod.Statements.Add(oCodeMethodInvokeExpression);
CodeVariableReferenceExpression oCodeVariableReferenceExpression =
new CodeVariableReferenceExpression("i");
CodePrimitiveExpression oCodePrimitiveExpression1 =
new CodePrimitiveExpression(1);
CodePrimitiveExpression oCodePrimitiveExpression5 =
new CodePrimitiveExpression(5);
CodeAssignStatement oCodeAssignStatement =
new CodeAssignStatement(oCodeVariableReferenceExpression, oCodePrimitiveExpression1);
CodeBinaryOperatorExpression oCodeBinaryOperatorExpressionLessThan =
new CodeBinaryOperatorExpression(oCodeVariableReferenceExpression,
CodeBinaryOperatorType.LessThan,
oCodePrimitiveExpression5);
CodeMethodInvokeExpression oCodeMethodInvokeExpression =
new CodeMethodInvokeExpression(oCodeVariableReferenceExpression, "ToString");
CodeBinaryOperatorExpression oCodeBinaryOperatorExpression =
new CodeBinaryOperatorExpression(oCodeVariableReferenceExpression,
CodeBinaryOperatorType.Add,
oCodePrimitiveExpression1);
CodeAssignStatement oCodeAssignStatement1 =
new CodeAssignStatement(oCodeVariableReferenceExpression,
oCodeBinaryOperatorExpression);
CodeTypeReferenceExpression oCodeTypeReferenceExpression =
new CodeTypeReferenceExpression("MessageBox");
CodeMethodReferenceExpression oCodeMethodReferenceExpression =
new CodeMethodReferenceExpression(oCodeTypeReferenceExpression, "Show");
CodeExpressionStatement oCodeExpressionStatement =
new CodeExpressionStatement(
new CodeMethodInvokeExpression(oCodeVariableReferenceExpression, "ToString"));
CodeMethodInvokeExpression oCodeMethodInvokeExpressionToString =
new CodeMethodInvokeExpression(oCodeVariableReferenceExpression, "ToString");
CodeIterationStatement oCodeIterationStatement = new CodeIterationStatement(
oCodeAssignStatement,
oCodeBinaryOperatorExpressionLessThan,
oCodeAssignStatement1,
new CodeStatement[] { new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
oCodeTypeReferenceExpression, "Show"),
oCodeMethodInvokeExpressionToString)) });
oCodeMemberMethod.Statements.Add(oCodeIterationStatement);
oCodeTypeDeclaration.Members.Add(oCodeMemberMethod);
}
private CodeAttributeArgument[] GetDefaultValueArguments(PrimitiveMapping mapping, object value, out CodeExpression initExpression)
{
initExpression = null;
if (value == null)
{
return(null);
}
CodeExpression valueExpression = null;
CodeExpression typeofValue = null;
Type type = value.GetType();
CodeAttributeArgument[] arguments = null;
if (mapping is EnumMapping)
{
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (value.GetType() != typeof(string))
{
throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorDetails, "Invalid enumeration type " + value.GetType().Name));
}
#endif
if (((EnumMapping)mapping).IsFlags)
{
string[] values = ((string)value).Split(null);
for (int i = 0; i < values.Length; i++)
{
if (values[i].Length == 0)
{
continue;
}
CodeExpression enumRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), values[i]);
if (valueExpression != null)
{
valueExpression = new CodeBinaryOperatorExpression(valueExpression, CodeBinaryOperatorType.BitwiseOr, enumRef);
}
else
{
valueExpression = enumRef;
}
}
}
else
{
valueExpression = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), (string)value);
}
initExpression = valueExpression;
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(valueExpression) };
}
else if (type == typeof(bool) ||
type == typeof(Int32) ||
type == typeof(string) ||
type == typeof(double))
{
initExpression = valueExpression = new CodePrimitiveExpression(value);
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(valueExpression) };
}
else if (type == typeof(Int16) ||
type == typeof(Int64) ||
type == typeof(float) ||
type == typeof(byte) ||
type == typeof(decimal))
{
valueExpression = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo));
typeofValue = new CodeTypeOfExpression(type.FullName);
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value));
}
else if (type == typeof(sbyte) ||
type == typeof(UInt16) ||
type == typeof(UInt32) ||
type == typeof(UInt64))
{
// need to promote the non-CLS complient types
value = PromoteType(type, value);
valueExpression = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo));
typeofValue = new CodeTypeOfExpression(type.FullName);
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value));
}
else if (type == typeof(DateTime))
{
DateTime dt = (DateTime)value;
string dtString;
long ticks;
if (mapping.TypeDesc.FormatterName == "Date")
{
dtString = XmlCustomFormatter.FromDate(dt);
ticks = (new DateTime(dt.Year, dt.Month, dt.Day)).Ticks;
}
else if (mapping.TypeDesc.FormatterName == "Time")
{
dtString = XmlCustomFormatter.FromDateTime(dt);
ticks = dt.Ticks;
}
else
{
dtString = XmlCustomFormatter.FromDateTime(dt);
ticks = dt.Ticks;
}
valueExpression = new CodePrimitiveExpression(dtString);
typeofValue = new CodeTypeOfExpression(type.FullName);
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] { new CodePrimitiveExpression(ticks) });
}
else if (type == typeof(Guid))
{
valueExpression = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo));
typeofValue = new CodeTypeOfExpression(type.FullName);
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(Guid)), new CodeExpression[] { valueExpression });
}
if (mapping.TypeDesc.FullName != type.ToString() && !(mapping is EnumMapping))
{
// generate cast
initExpression = new CodeCastExpression(mapping.TypeDesc.FullName, initExpression);
}
return(arguments);
}
public static CodeExpression CreateFacets(ClrSimpleTypeInfo type)
{
//object o = null;
CodeExpression codePrimitiveExpression;
CompiledFacets facets = type.RestrictionFacets;
CodeObjectCreateExpression createFacets = new CodeObjectCreateExpression()
{
CreateType = new CodeTypeReference("Xml.Schema.Linq.RestrictionFacets")
};
Xml.Schema.Linq.RestrictionFlags flags = facets.Flags;
if ((int)flags != 0)
{
CodeCastExpression cast = new CodeCastExpression(new CodeTypeReference("Xml.Schema.Linq.RestrictionFlags"), new CodePrimitiveExpression((object)Convert.ToInt32(flags, CultureInfo.InvariantCulture.NumberFormat)));
createFacets.Parameters.Add(cast);
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.Enumeration) == 0)
{
createFacets.Parameters.Add(new CodePrimitiveExpression(null));
}
else
{
CodeArrayCreateExpression enums = new CodeArrayCreateExpression()
{
CreateType = new CodeTypeReference("System.Object")
};
foreach (object o in facets.Enumeration)
{
SimpleTypeCodeDomHelper.GetCreateValueExpression(o, type, enums.Initializers);
}
createFacets.Parameters.Add(enums);
}
int fractionDigits = 0;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.FractionDigits) != 0)
{
fractionDigits = facets.FractionDigits;
}
createFacets.Parameters.Add(new CodePrimitiveExpression((object)fractionDigits));
int length = 0;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.Length) != 0)
{
length = facets.Length;
}
createFacets.Parameters.Add(new CodePrimitiveExpression((object)length));
object maxExclusive = null;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MaxExclusive) != 0)
{
maxExclusive = facets.MaxExclusive;
}
SimpleTypeCodeDomHelper.GetCreateValueExpression(maxExclusive, type, createFacets.Parameters);
object maxInclusive = null;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MaxInclusive) != 0)
{
maxInclusive = facets.MaxInclusive;
}
SimpleTypeCodeDomHelper.GetCreateValueExpression(maxInclusive, type, createFacets.Parameters);
int maxLength = 0;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MaxLength) != 0)
{
maxLength = facets.MaxLength;
}
createFacets.Parameters.Add(new CodePrimitiveExpression((object)maxLength));
object minExclusive = null;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MinExclusive) != 0)
{
minExclusive = facets.MinExclusive;
}
SimpleTypeCodeDomHelper.GetCreateValueExpression(minExclusive, type, createFacets.Parameters);
object minInclusive = null;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MinInclusive) != 0)
{
minInclusive = facets.MinInclusive;
}
SimpleTypeCodeDomHelper.GetCreateValueExpression(minInclusive, type, createFacets.Parameters);
int minLength = 0;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MinLength) != 0)
{
minLength = facets.MinLength;
}
createFacets.Parameters.Add(new CodePrimitiveExpression((object)minLength));
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.Pattern) == 0)
{
createFacets.Parameters.Add(new CodePrimitiveExpression(null));
}
else
{
CodeArrayCreateExpression patternStrs = new CodeArrayCreateExpression()
{
CreateType = new CodeTypeReference(XTypedServices.typeOfString)
};
foreach (object pattern in facets.Patterns)
{
string str = pattern.ToString();
patternStrs.Initializers.Add(new CodePrimitiveExpression(str));
}
createFacets.Parameters.Add(patternStrs);
}
int totalDigits = 0;
if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.TotalDigits) != 0)
{
totalDigits = facets.TotalDigits;
}
createFacets.Parameters.Add(new CodePrimitiveExpression((object)totalDigits));
Xml.Schema.Linq.XmlSchemaWhiteSpace ws = facets.WhiteSpace;
createFacets.Parameters.Add(CodeDomHelper.CreateFieldReference("XmlSchemaWhiteSpace", ws.ToString()));
codePrimitiveExpression = createFacets;
}
else
{
codePrimitiveExpression = new CodePrimitiveExpression(null);
}
return(codePrimitiveExpression);
}
public CodeExpression GenerateLoadPixbuf(string name, Gtk.IconSize size)
{
bool found = false;
foreach (CodeTypeDeclaration t in cns.Types)
{
if (t.Name == "IconLoader")
{
found = true;
break;
}
}
if (!found)
{
CodeTypeDeclaration cls = new CodeTypeDeclaration("IconLoader");
cls.Attributes = MemberAttributes.Private;
cls.TypeAttributes = System.Reflection.TypeAttributes.NestedAssembly;
cns.Types.Add(cls);
CodeMemberMethod met = new CodeMemberMethod();
cls.Members.Add(met);
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
met.Name = "LoadIcon";
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Gtk.Widget), "widget"));
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name"));
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Gtk.IconSize), "size"));
met.ReturnType = new CodeTypeReference(typeof(Gdk.Pixbuf));
CodeExpression widgetExp = new CodeVariableReferenceExpression("widget");
CodeExpression nameExp = new CodeVariableReferenceExpression("name");
CodeExpression sizeExp = new CodeVariableReferenceExpression("size");
CodeExpression szExp = new CodeVariableReferenceExpression("sz");
CodeExpression mgExp = new CodeBinaryOperatorExpression(szExp, CodeBinaryOperatorType.Divide, new CodePrimitiveExpression(4));
CodeExpression pmapExp = new CodeVariableReferenceExpression("pmap");
CodeExpression gcExp = new CodeVariableReferenceExpression("gc");
CodeExpression szM1Exp = new CodeBinaryOperatorExpression(szExp, CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1));
CodeExpression zeroExp = new CodePrimitiveExpression(0);
CodeExpression resExp = new CodeVariableReferenceExpression("res");
met.Statements.Add(
new CodeVariableDeclarationStatement(typeof(Gdk.Pixbuf), "res",
new CodeMethodInvokeExpression(
widgetExp,
"RenderIcon",
nameExp,
sizeExp,
new CodePrimitiveExpression(null)
)
)
);
CodeConditionStatement nullcheck = new CodeConditionStatement();
met.Statements.Add(nullcheck);
nullcheck.Condition = new CodeBinaryOperatorExpression(
resExp,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)
);
nullcheck.TrueStatements.Add(new CodeMethodReturnStatement(resExp));
// int sz, h;
// Gtk.Icon.SizeLookup (size, out sz, out h);
nullcheck.FalseStatements.Add(new CodeVariableDeclarationStatement(typeof(int), "sz"));
nullcheck.FalseStatements.Add(new CodeVariableDeclarationStatement(typeof(int), "sy"));
nullcheck.FalseStatements.Add(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Gtk.Icon).ToGlobalTypeRef()),
"SizeLookup",
sizeExp,
new CodeDirectionExpression(FieldDirection.Out, szExp),
new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("sy"))
));
CodeTryCatchFinallyStatement trycatch = new CodeTryCatchFinallyStatement();
nullcheck.FalseStatements.Add(trycatch);
trycatch.TryStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(typeof(Gtk.IconTheme))),
"Default"
),
"LoadIcon",
nameExp,
szExp,
zeroExp
)
)
);
CodeCatchClause ccatch = new CodeCatchClause();
trycatch.CatchClauses.Add(ccatch);
CodeConditionStatement cond = new CodeConditionStatement();
ccatch.Statements.Add(cond);
cond.Condition = new CodeBinaryOperatorExpression(
nameExp,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression("gtk-missing-image")
);
cond.TrueStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(cns.Name + "." + cls.Name),
"LoadIcon",
widgetExp,
new CodePrimitiveExpression("gtk-missing-image"),
sizeExp
)
)
);
CodeStatementCollection stms = cond.FalseStatements;
stms.Add(
new CodeVariableDeclarationStatement(typeof(Gdk.Pixmap), "pmap",
new CodeObjectCreateExpression(
typeof(Gdk.Pixmap),
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(typeof(Gdk.Screen)),
"Default"
),
"RootWindow"
),
szExp,
szExp
)
)
);
stms.Add(
new CodeVariableDeclarationStatement(typeof(Gdk.GC), "gc",
new CodeObjectCreateExpression(typeof(Gdk.GC), pmapExp)
)
);
stms.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression(
typeof(Gdk.Color),
new CodePrimitiveExpression(255),
new CodePrimitiveExpression(255),
new CodePrimitiveExpression(255)
)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawRectangle",
gcExp,
new CodePrimitiveExpression(true),
zeroExp,
zeroExp,
szExp,
szExp
)
);
stms.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression(
typeof(Gdk.Color),
zeroExp, zeroExp, zeroExp
)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawRectangle",
gcExp,
new CodePrimitiveExpression(false),
zeroExp,
zeroExp,
szM1Exp,
szM1Exp
)
);
stms.Add(
new CodeMethodInvokeExpression(
gcExp,
"SetLineAttributes",
new CodePrimitiveExpression(3),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Gdk.LineStyle)), "Solid"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Gdk.CapStyle)), "Round"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Gdk.JoinStyle)), "Round")
)
);
stms.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression(
typeof(Gdk.Color),
new CodePrimitiveExpression(255),
zeroExp,
zeroExp
)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawLine",
gcExp,
mgExp,
mgExp,
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp),
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp)
)
);
stms.Add(
new CodeMethodInvokeExpression(
pmapExp,
"DrawLine",
gcExp,
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp),
mgExp,
mgExp,
new CodeBinaryOperatorExpression(szM1Exp, CodeBinaryOperatorType.Subtract, mgExp)
)
);
stms.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Gdk.Pixbuf)),
"FromDrawable",
pmapExp,
new CodePropertyReferenceExpression(pmapExp, "Colormap"),
zeroExp, zeroExp, zeroExp, zeroExp, szExp, szExp
)
)
);
}
int sz, h;
Gtk.Icon.SizeLookup(size, out sz, out h);
return(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(cns.Name + ".IconLoader", CodeTypeReferenceOptions.GlobalReference)),
"LoadIcon",
rootObject,
new CodePrimitiveExpression(name),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(typeof(Gtk.IconSize), CodeTypeReferenceOptions.GlobalReference)),
size.ToString()
)
));
}
internal /*public*/ static CodeExpression GenerateExpressionForValue(PropertyInfo propertyInfo, object value, Type valueType)
{
#if DEBUG
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("GenerateExpressionForValue() {");
Debug.Indent();
}
#endif // DEBUG
CodeExpression rightExpr = null;
if (valueType == null)
{
throw new ArgumentNullException("valueType");
}
PropertyDescriptor pd = null;
if (propertyInfo != null)
{
pd = TypeDescriptor.GetProperties(propertyInfo.ReflectedType)[propertyInfo.Name];
}
if (valueType == typeof(string) && value is string)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("simple string");
}
rightExpr = new CodePrimitiveExpression((string)value);
}
else if (valueType.IsPrimitive)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("primitive");
}
rightExpr = new CodePrimitiveExpression(value);
}
else if (propertyInfo == null && valueType == typeof(object) &&
(value == null || value.GetType().IsPrimitive))
{
// If the type is object, and the value is a primitive, simply use a
// CodePrimitiveExpression instead of trying to use a TypeConverter (VSWhidbey 518773)
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("primitive to object");
}
rightExpr = new CodePrimitiveExpression(value);
}
else if (valueType.IsArray)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("array");
}
Array array = (Array)value;
CodeArrayCreateExpression exp = new CodeArrayCreateExpression();
exp.CreateType = new CodeTypeReference(valueType.GetElementType());
if (array != null)
{
foreach (object o in array)
{
exp.Initializers.Add(GenerateExpressionForValue(null, o, valueType.GetElementType()));
}
}
rightExpr = exp;
}
else if (valueType == typeof(Type))
{
rightExpr = new CodeTypeOfExpression((Type)value);
}
else
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("other");
}
TypeConverter converter = null;
if (pd != null)
{
converter = pd.Converter;
}
else
{
converter = TypeDescriptor.GetConverter(valueType);
}
bool added = false;
if (converter != null)
{
InstanceDescriptor desc = null;
if (converter.CanConvertTo(typeof(InstanceDescriptor)))
{
desc = (InstanceDescriptor)converter.ConvertTo(value, typeof(InstanceDescriptor));
}
if (desc != null)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("has converter with instance descriptor");
}
// static field ref...
//
if (desc.MemberInfo is FieldInfo)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a field ref");
}
CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
rightExpr = fieldRef;
added = true;
}
// static property ref
else if (desc.MemberInfo is PropertyInfo)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a property ref");
}
CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
rightExpr = propRef;
added = true;
}
// static method invoke
//
else
{
object[] args = new object[desc.Arguments.Count];
desc.Arguments.CopyTo(args, 0);
CodeExpression[] expressions = new CodeExpression[args.Length];
if (desc.MemberInfo is MethodInfo)
{
MethodInfo mi = (MethodInfo)desc.MemberInfo;
ParameterInfo[] parameters = mi.GetParameters();
for (int i = 0; i < args.Length; i++)
{
expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
}
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a method invoke");
}
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
foreach (CodeExpression e in expressions)
{
methCall.Parameters.Add(e);
}
rightExpr = new CodeCastExpression(valueType, methCall);
added = true;
}
else if (desc.MemberInfo is ConstructorInfo)
{
ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
ParameterInfo[] parameters = ci.GetParameters();
for (int i = 0; i < args.Length; i++)
{
expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
}
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a constructor call");
}
CodeObjectCreateExpression objectCreate = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName);
foreach (CodeExpression e in expressions)
{
objectCreate.Parameters.Add(e);
}
rightExpr = objectCreate;
added = true;
}
}
}
}
if (!added)
{
#if DEBUG
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("unabled to determine type, attempting Parse");
Debug.Indent();
Debug.WriteLine("value.GetType == " + value.GetType().FullName);
Debug.WriteLine("value.ToString == " + value.ToString());
Debug.WriteLine("valueType == " + valueType.FullName);
if (propertyInfo != null)
{
Debug.WriteLine("propertyInfo == " + propertyInfo.ReflectedType.FullName + "." + propertyInfo.Name + " : " + propertyInfo.PropertyType.FullName);
}
else
{
Debug.WriteLine("propertyInfo == (null)");
}
Debug.Unindent();
}
#endif // DEBUG
// Not a known type: try calling Parse
// If possible, pass it an InvariantCulture (ASURT 79412)
if (valueType.GetMethod("Parse", new Type[] { typeof(string), typeof(CultureInfo) }) != null)
{
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(valueType.FullName), "Parse");
// Convert the object to a string.
// If we have a type converter, use it to convert to a string in a culture
// invariant way (ASURT 87094)
string s;
if (converter != null)
{
s = converter.ConvertToInvariantString(value);
}
else
{
s = value.ToString();
}
methCall.Parameters.Add(new CodePrimitiveExpression(s));
methCall.Parameters.Add(new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(typeof(CultureInfo)), "InvariantCulture"));
rightExpr = methCall;
}
else if (valueType.GetMethod("Parse", new Type[] { typeof(string) }) != null)
{
// Otherwise, settle for passing just the string
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(valueType.FullName), "Parse");
methCall.Parameters.Add(new CodePrimitiveExpression(value.ToString()));
rightExpr = methCall;
}
else
{
throw new HttpException(SR.GetString(SR.CantGenPropertySet, propertyInfo.Name, valueType.FullName));
}
}
}
#if DEBUG
if (WebFormsCompilation.Enabled)
{
Debug.Unindent();
Debug.WriteLine("}");
}
#endif // DEBUG
return(rightExpr);
}
void AddDefaultValueAttribute(CodeMemberField field, CodeAttributeDeclarationCollection metadata, object value, TypeMapping mapping)
{
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (!(mapping is PrimitiveMapping))
{
throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Default value is invalid for " + mapping.GetType().Name));
}
else if (mapping.IsList)
{
throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Default value is invalid for " + mapping.GetType().Name));
}
#endif
if (value == null)
{
return;
}
CodeExpression valueExpression = null;
CodeExpression initExpression = null;
CodeExpression typeofValue = null;
string typeName = mapping.TypeDesc.FullName;
Type type = value.GetType();
CodeAttributeArgument[] arguments = null;
if (mapping is EnumMapping)
{
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (value.GetType() != typeof(string))
{
throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Invalid enumeration type " + value.GetType().Name));
}
#endif
if (((EnumMapping)mapping).IsFlags)
{
string[] values = ((string)value).Split(null);
for (int i = 0; i < values.Length; i++)
{
if (values[i].Length == 0)
{
continue;
}
CodeExpression enumRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeName), values[i]);
if (valueExpression != null)
{
valueExpression = new CodeBinaryOperatorExpression(valueExpression, CodeBinaryOperatorType.BitwiseOr, enumRef);
}
else
{
valueExpression = enumRef;
}
}
}
else
{
valueExpression = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeName), (string)value);
}
initExpression = valueExpression;
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(valueExpression) };
}
else if (type == typeof(bool) ||
type == typeof(Int32) ||
type == typeof(string) ||
type == typeof(double))
{
initExpression = valueExpression = new CodePrimitiveExpression(value);
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(valueExpression) };
}
else if (type == typeof(Int16) ||
type == typeof(Int64) ||
type == typeof(float) ||
type == typeof(byte) ||
type == typeof(decimal))
{
valueExpression = new CodePrimitiveExpression(value.ToString());
typeofValue = new CodeTypeOfExpression(CodeIdentifier.EscapeKeywords(type.FullName));
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value));
}
else if (type == typeof(sbyte) ||
type == typeof(UInt16) ||
type == typeof(UInt32) ||
type == typeof(UInt64))
{
// need to promote the non-CLS complient types
value = PromoteType(type, value);
valueExpression = new CodePrimitiveExpression(value.ToString());
typeofValue = new CodeTypeOfExpression(CodeIdentifier.EscapeKeywords(type.FullName));
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value));
}
else if (type == typeof(DateTime))
{
DateTime dt = (DateTime)value;
string dtString;
long ticks;
if (mapping.TypeDesc.FormatterName == "Date")
{
dtString = XmlCustomFormatter.FromDate(dt);
ticks = (new DateTime(dt.Year, dt.Month, dt.Day)).Ticks;
}
else if (mapping.TypeDesc.FormatterName == "Time")
{
dtString = XmlCustomFormatter.FromDateTime(dt);
ticks = dt.Ticks;
}
else
{
dtString = XmlCustomFormatter.FromDateTime(dt);
ticks = dt.Ticks;
}
valueExpression = new CodePrimitiveExpression(dtString);
typeofValue = new CodeTypeOfExpression(CodeIdentifier.EscapeKeywords(type.FullName));
arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) };
initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] { new CodePrimitiveExpression(ticks) });
}
if (arguments != null)
{
if (field != null)
{
field.InitExpression = initExpression;
}
AddCustomAttribute(metadata, typeof(DefaultValueAttribute), arguments);
}
}
/// <summary>
/// create a CodeExpression to generate an object
/// </summary>
/// <param name="v">the object to be generated</param>
/// <returns>the CodeExpression generating the object</returns>
public static CodeExpression ObjectCreationCode(object v)
{
//===simple values===
if (v == null)
{
return(new CodePrimitiveExpression(null));
}
if (v == System.DBNull.Value)
{
return(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(System.DBNull)), "Value"));
}
Type t = v.GetType();
if (t.Equals(typeof(EventArgs)))
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EventArgs)), "Empty"));
}
if (t.IsPrimitive)
{
if (t.Equals(typeof(IntPtr)) || t.Equals(typeof(UIntPtr)))
{
CodeObjectCreateExpression coce;
if (t.Equals(typeof(IntPtr)))
{
IntPtr val = (IntPtr)v;
if (IntPtr.Size == 4)
{
coce = new CodeObjectCreateExpression(t, new CodePrimitiveExpression(val.ToInt32()));
}
else
{
coce = new CodeObjectCreateExpression(t, new CodePrimitiveExpression(val.ToInt64()));
}
}
else
{
UIntPtr val = (UIntPtr)v;
if (IntPtr.Size == 4)
{
coce = new CodeObjectCreateExpression(t, new CodePrimitiveExpression(val.ToUInt32()));
}
else
{
coce = new CodeObjectCreateExpression(t, new CodePrimitiveExpression(val.ToUInt64()));
}
}
return(coce);
}
else
{
CodePrimitiveExpression cpi = new CodePrimitiveExpression(v);
if (VPLUtil.IsNumber(t))
{
if (!typeof(int).Equals(t))
{
return(new CodeCastExpression(t, cpi));
}
}
return(cpi);
}
}
if (t.Equals(typeof(string)))
{
return(new CodePrimitiveExpression(v));
}
if (t.IsEnum)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(t), v.ToString()));
}
if (t.IsArray)
{
Type te = t.GetElementType();
Array a = (Array)v;
if (a.Rank == 1)
{
CodeExpression[] inits = new CodeExpression[a.Length];
for (int i = 0; i < inits.Length; i++)
{
object val = a.GetValue(i);
if (val == null)
{
inits[i] = GetDefaultValueExpression(te);
}
else
{
inits[i] = ObjectCreationCodeGen.ObjectCreationCode(val);
}
}
CodeArrayCreateExpression ac = new CodeArrayCreateExpression(t, inits);
return(ac);
}
else
{
StringBuilder sb = new StringBuilder(CreateArrayCreationCodeString(a.Rank, te.Name));
sb.Append("{");
for (int i = 0; i < a.Rank; i++)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
for (int j = a.GetLowerBound(i); j <= a.GetUpperBound(i); j++)
{
if (j > 0)
{
sb.Append(",");
}
sb.Append(ObjectCreationCodeGen.GetObjectCreationCodeSnippet(a.GetValue(i, j)));
}
sb.Append("}");
}
sb.Append("}");
return(new CodeSnippetExpression(sb.ToString()));
}
}
//===use plug-ins to handle it===
if (creators != null)
{
foreach (IGetObjectCreationCode occ in creators.Values)
{
CodeExpression ce = occ.ObjectCreationCode(v);
if (ce != null)
{
return(ce);
}
}
}
//===use default handlers===
if (t.Equals(typeof(Size)))
{
Size v1 = (Size)v;
return(new CodeObjectCreateExpression(t,
new CodePrimitiveExpression(v1.Width),
new CodePrimitiveExpression(v1.Height)));
}
if (t.Equals(typeof(Point)))
{
Point v1 = (Point)v;
return(new CodeObjectCreateExpression(t,
new CodePrimitiveExpression(v1.X),
new CodePrimitiveExpression(v1.Y)));
}
if (t.Equals(typeof(Color)))
{
Color v1 = (Color)v;
return(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Color)), "FromArgb"),
new CodeCastExpression(typeof(int), new CodePrimitiveExpression(v1.A)),
new CodeCastExpression(typeof(int), new CodePrimitiveExpression(v1.R)),
new CodeCastExpression(typeof(int), new CodePrimitiveExpression(v1.G)),
new CodeCastExpression(typeof(int), new CodePrimitiveExpression(v1.B))
));
}
if (t.Equals(typeof(Cursor)))
{
//System.Windows.Forms.Cursors.
Cursor v1 = (Cursor)v;
if (v1 == Cursors.AppStarting)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "AppStarting"));
}
else if (v1 == Cursors.Arrow)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "Arrow"));
}
else if (v1 == Cursors.Cross)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "Cross"));
}
else if (v1 == Cursors.Default)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "Default"));
}
else if (v1 == Cursors.Hand)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "Hand"));
}
else if (v1 == Cursors.Help)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "Help"));
}
else if (v1 == Cursors.HSplit)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "HSplit"));
}
else if (v1 == Cursors.IBeam)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "IBeam"));
}
else if (v1 == Cursors.No)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "No"));
}
else if (v1 == Cursors.NoMove2D)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "NoMove2D"));
}
else if (v1 == Cursors.NoMoveHoriz)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "NoMoveHoriz"));
}
else if (v1 == Cursors.NoMoveVert)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "NoMoveVert"));
}
else if (v1 == Cursors.PanEast)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanEast"));
}
else if (v1 == Cursors.PanNE)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanNE"));
}
else if (v1 == Cursors.PanNorth)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanNorth"));
}
else if (v1 == Cursors.PanNW)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanNW"));
}
else if (v1 == Cursors.PanSE)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanSE"));
}
else if (v1 == Cursors.PanSouth)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanSouth"));
}
else if (v1 == Cursors.PanSW)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanSW"));
}
else if (v1 == Cursors.PanWest)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "PanWest"));
}
else if (v1 == Cursors.SizeAll)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "SizeAll"));
}
else if (v1 == Cursors.SizeNESW)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "SizeNESW"));
}
else if (v1 == Cursors.SizeNS)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "SizeNS"));
}
else if (v1 == Cursors.SizeNWSE)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "SizeNWSE"));
}
else if (v1 == Cursors.SizeWE)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "SizeWE"));
}
else if (v1 == Cursors.UpArrow)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "UpArrow"));
}
else if (v1 == Cursors.VSplit)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "VSplit"));
}
else if (v1 == Cursors.WaitCursor)
{
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(Cursors)), "WaitCursor"));
}
else
{
CursorConverter cc = new CursorConverter();
string s = cc.ConvertToString(v);
return(new CodeMethodInvokeExpression(
new CodeObjectCreateExpression(typeof(CursorConverter), null),
"ConvertFromString",
new CodePrimitiveExpression(s)
));
}
}
if (t.Equals(typeof(Font)))
{
Font f = (Font)v;
return(new CodeObjectCreateExpression(typeof(Font), new CodePrimitiveExpression(f.FontFamily.ToString()), new CodePrimitiveExpression(f.Size)));
}
//use string converter ===================================
TypeConverter sc = TypeDescriptor.GetConverter(t);
if (sc != null)
{
if (sc.CanConvertTo(typeof(string)) && sc.CanConvertFrom(typeof(string)))
{
string svalue = sc.ConvertToInvariantString(v);
CodeMethodInvokeExpression mgc = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeTypeOfExpression(t));
CodeMethodInvokeExpression fs = new CodeMethodInvokeExpression(mgc, "ConvertFromInvariantString", new CodePrimitiveExpression(svalue));
//
return(new CodeCastExpression(t, fs));
}
}
//===use TypeConverter as the last resort===
PropertyDescriptorCollection pifs = TypeDescriptor.GetProperties(v);
if (pifs == null || pifs.Count == 0)
{
return(new CodeObjectCreateExpression(t));
}
int nCount = 0;
for (int i = 0; i < pifs.Count; i++)
{
if (pifs[i].IsBrowsable && !pifs[i].IsReadOnly)
{
nCount++;
}
}
if (nCount == 0)
{
return(new CodeObjectCreateExpression(t));
}
string sCodeSnippet = GetObjectCreationCodeSnippet(v);
return(new CodeSnippetExpression(sCodeSnippet));
}
public override void ProcessDirective(string directiveName, IDictionary <string, string> arguments)
{
if (!arguments.TryGetValue("name", out string name) || string.IsNullOrEmpty(name))
{
throw new DirectiveProcessorException("Proxymodel directive has no name argument");
}
if (!arguments.TryGetValue("type", out string type) || string.IsNullOrEmpty(type))
{
type = typeof(ProxyModel).ToString();
}
string fieldName = "_" + name + "Field";
var typeRef = new CodeTypeReference(type);
var thisRef = new CodeThisReferenceExpression();
var fieldRef = new CodeFieldReferenceExpression(thisRef, fieldName);
members.Add(new CodeMemberField(typeRef, fieldName));
var property = new CodeMemberProperty()
{
Name = name,
Attributes = MemberAttributes.Public | MemberAttributes.Final,
HasGet = true,
HasSet = false,
Type = typeRef
};
property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef));
members.Add(property);
var valRef = new CodeVariableReferenceExpression("data");
var namePrimitive = new CodePrimitiveExpression(name);
var sessionRef = new CodePropertyReferenceExpression(thisRef, "Session");
bool hasAcquiredCheck = hostSpecific;
string acquiredName = "_" + name + "Acquired";
var acquiredVariable = new CodeVariableDeclarationStatement(typeof(bool), acquiredName, new CodePrimitiveExpression(false));
var acquiredVariableRef = new CodeVariableReferenceExpression(acquiredVariable.Name);
if (hasAcquiredCheck)
{
postStatements.Add(acquiredVariable);
}
//checks the local called "data" can be cast and assigned to the field, and if successful, sets acquiredVariable to true
var checkCastThenAssignVal = new CodeConditionStatement(
new CodeMethodInvokeExpression(
new CodeTypeOfExpression(typeRef), "IsAssignableFrom", new CodeMethodInvokeExpression(valRef, "GetType")),
hasAcquiredCheck
? new CodeStatement[] {
new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, valRef)),
new CodeAssignStatement(acquiredVariableRef, new CodePrimitiveExpression(true)),
}
: new CodeStatement[] {
new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, valRef)),
}
,
new CodeStatement[] {
new CodeExpressionStatement(new CodeMethodInvokeExpression(thisRef, "Error",
new CodePrimitiveExpression("The type '" + type + "' of the parameter '" + name +
"' did not match the type passed to the template"))),
});
//tries to gets the value from the session
var checkSession = new CodeConditionStatement(
new CodeBinaryOperatorExpression(NotNull(sessionRef), CodeBinaryOperatorType.BooleanAnd,
new CodeMethodInvokeExpression(sessionRef, "ContainsKey", namePrimitive)),
new CodeVariableDeclarationStatement(typeof(object), "data", new CodeIndexerExpression(sessionRef, namePrimitive)),
checkCastThenAssignVal);
this.postStatements.Add(checkSession);
}
// generate CodeDOM for code that displays message nDisplays times.
static CodeCompileUnit GenerateProgram(string message, int nDisplays)
{
// Create Main method
CodeEntryPointMethod mainMethod = new CodeEntryPointMethod();
mainMethod.Name = "Main";
// generate this expression: Console
CodeTypeReferenceExpression consoleType = new
CodeTypeReferenceExpression();
consoleType.Type = new CodeTypeReference(typeof(Console));
// generate this statement: int i=0;
CodeVariableDeclarationStatement declareI = new CodeVariableDeclarationStatement();
declareI.Name = "i";
declareI.InitExpression = new CodePrimitiveExpression(0);
declareI.Type = new CodeTypeReference(typeof(int));
// generate this expression: i;
CodeVariableReferenceExpression iVar = new CodeVariableReferenceExpression(declareI.Name);
// generate this statement: i=i+1;
CodeAssignStatement incrI = new CodeAssignStatement();
incrI.Left = iVar;
incrI.Right = new CodeBinaryOperatorExpression(iVar, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1));
// generate this for loop: for (int i=0 ; i<nDisplays ; i++)
CodeIterationStatement forLoop = new CodeIterationStatement();
forLoop.InitStatement = declareI;
forLoop.TestExpression = new CodeBinaryOperatorExpression(iVar, CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(nDisplays));
forLoop.IncrementStatement = incrI;
// Set up the argument list to pass to Console.WriteLine()
CodeExpression[] writeLineArgs = new CodeExpression[1];
CodePrimitiveExpression arg0 = new CodePrimitiveExpression(message);
writeLineArgs[0] = arg0;
// generate this statement: Console.WriteLine(message)
CodeMethodReferenceExpression writeLineRef = new
CodeMethodReferenceExpression(consoleType, "WriteLine");
CodeMethodInvokeExpression writeLine = new
CodeMethodInvokeExpression(writeLineRef, writeLineArgs);
// insert Console.WriteLine() statement into for loop
forLoop.Statements.Add(writeLine);
// add the for loop to the Main() method
mainMethod.Statements.Add(forLoop);
// Add a return statement to the Main() method
CodeMethodReturnStatement ret = new CodeMethodReturnStatement();
mainMethod.Statements.Add(ret);
// Add Main() method to a class
CodeTypeDeclaration theClass = new CodeTypeDeclaration();
theClass.Members.Add(mainMethod);
theClass.Name = "EntryPoint";
// Add namespace and add class
CodeNamespace ns = new CodeNamespace("Apress.ExpertDotNet.CodeDomSample");
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Types.Add(theClass);
// Create whole program (code compile unit)
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(ns);
return(unit);
}
private CodeBinaryOperatorExpression ParseBinaryOperatorExpression(string expression, out TypeCode expressionType)
{
if (!string.IsNullOrEmpty(expression))
{
string[] operands = expression.Split(s_operatorSymbols, StringSplitOptions.None);
// Expression is only valid if there are exactly two operands
if (operands.Length == 2)
{
CodePrimitiveExpression leftOperand, rightOperand;
CodeBinaryOperatorType operatorType;
if (int.TryParse(operands[0], out int left) && int.TryParse(operands[1], out int right))
{
// Both operands can be compared as integers
leftOperand = new CodePrimitiveExpression(left);
rightOperand = new CodePrimitiveExpression(right);
expressionType = TypeCode.Int32;
}
else if (double.TryParse(operands[0], out double leftF) && double.TryParse(operands[1], out double rightF))
{
// Both operands can be compared as doubles
leftOperand = new CodePrimitiveExpression(leftF);
rightOperand = new CodePrimitiveExpression(rightF);
expressionType = TypeCode.Double;
}
else
{
// Default to string comparison of operands
leftOperand = new CodePrimitiveExpression(operands[0]);
rightOperand = new CodePrimitiveExpression(operands[1]);
expressionType = TypeCode.String;
}
// Determine operator type - order of detection is critical Symbol:
if (expression.Contains(s_operatorSymbols[OperatorType.Equality]))
{
operatorType = CodeBinaryOperatorType.IdentityEquality; // ==
}
else if (expression.Contains(s_operatorSymbols[OperatorType.Inequality]))
{
operatorType = CodeBinaryOperatorType.IdentityInequality; // !=
}
else if (expression.Contains(s_operatorSymbols[OperatorType.Inequality2]))
{
operatorType = CodeBinaryOperatorType.IdentityInequality; // <>
}
else if (expression.Contains(s_operatorSymbols[OperatorType.LessThanOrEqual]))
{
operatorType = CodeBinaryOperatorType.LessThanOrEqual; // <=
}
else if (expression.Contains(s_operatorSymbols[OperatorType.LessThan]))
{
operatorType = CodeBinaryOperatorType.LessThan; // <
}
else if (expression.Contains(s_operatorSymbols[OperatorType.GreaterThanOrEqual]))
{
operatorType = CodeBinaryOperatorType.GreaterThanOrEqual; // >=
}
else if (expression.Contains(s_operatorSymbols[OperatorType.GreaterThan]))
{
operatorType = CodeBinaryOperatorType.GreaterThan; // >
}
else
{
operatorType = CodeBinaryOperatorType.IdentityEquality; // =
}
return(new CodeBinaryOperatorExpression(leftOperand, operatorType, rightOperand));
}
}
expressionType = TypeCode.Object;
return(null);
}
// Generate code for a primitive expression.
protected virtual void GeneratePrimitiveExpression
(CodePrimitiveExpression e)
{
Object value = e.Value;
if (value == null)
{
Output.Write(NullToken);
}
else if (value is String)
{
Output.Write(QuoteSnippetString((String)value));
}
else if (value is Char)
{
char ch = (char)value;
String chvalue;
switch (ch)
{
case '\'': chvalue = "'\\''"; break;
case '\\': chvalue = "'\\\\'"; break;
case '\n': chvalue = "'\\n'"; break;
case '\r': chvalue = "'\\r'"; break;
case '\t': chvalue = "'\\t'"; break;
case '\f': chvalue = "'\\f'"; break;
case '\v': chvalue = "'\\v'"; break;
case '\a': chvalue = "'\\a'"; break;
case '\b': chvalue = "'\\b'"; break;
default:
{
if (ch >= ' ' && ch <= 0x7E)
{
chvalue = "\"" + ch.ToString() + "\"";
}
else if (ch < 0x0100)
{
chvalue = "\"\\x" +
hexchars[(ch >> 4) & 0x0F] +
hexchars[ch & 0x0F] + "\"";
}
else
{
chvalue = "\"\\u" +
hexchars[(ch >> 12) & 0x0F] +
hexchars[(ch >> 8) & 0x0F] +
hexchars[(ch >> 4) & 0x0F] +
hexchars[ch & 0x0F] + "\"";
}
}
break;
}
Output.Write(chvalue);
}
else if (value is SByte)
{
Output.Write((int)(sbyte)value);
}
else if (value is Byte)
{
Output.Write((int)(byte)value);
}
else if (value is Int16)
{
Output.Write((int)(short)value);
}
else if (value is UInt16)
{
Output.Write((int)(ushort)value);
}
else if (value is Int32)
{
Output.Write((int)value);
}
else if (value is UInt32)
{
Output.Write((uint)value);
}
else if (value is Int64)
{
Output.Write((long)value);
}
else if (value is UInt64)
{
Output.Write((ulong)value);
}
else if (value is Single)
{
GenerateSingleFloatValue((float)value);
}
else if (value is Double)
{
GenerateDoubleValue((double)value);
}
else if (value is Decimal)
{
GenerateDecimalValue((Decimal)value);
}
else if (value is Boolean)
{
if ((bool)value)
{
Output.Write("true");
}
else
{
Output.Write("false");
}
}
else
{
throw new ArgumentException
(S._("Arg_InvalidCodeDom"), "e");
}
}
protected virtual void processInterface(Protocol protocol)
{
// Create abstract class
string protocolNameMangled = CodeGenUtil.Instance.Mangle(protocol.Name);
var ctd = new CodeTypeDeclaration(protocolNameMangled);
ctd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public;
ctd.IsClass = true;
ctd.BaseTypes.Add("Avro.Specific.ISpecificProtocol");
AddProtocolDocumentation(protocol, ctd);
// Add static protocol field.
var protocolField = new CodeMemberField();
protocolField.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final;
protocolField.Name = "protocol";
protocolField.Type = new CodeTypeReference("readonly Avro.Protocol");
var cpe = new CodePrimitiveExpression(protocol.ToString());
var cmie = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Protocol)), "Parse"),
new CodeExpression[] { cpe });
protocolField.InitExpression = cmie;
ctd.Members.Add(protocolField);
// Add overridden Protocol method.
var property = new CodeMemberProperty();
property.Attributes = MemberAttributes.Public | MemberAttributes.Final;
property.Name = "Protocol";
property.Type = new CodeTypeReference("Avro.Protocol");
property.HasGet = true;
property.GetStatements.Add(new CodeTypeReferenceExpression("return protocol"));
ctd.Members.Add(property);
//var requestMethod = CreateRequestMethod();
//ctd.Members.Add(requestMethod);
var requestMethod = CreateRequestMethod();
//requestMethod.Attributes |= MemberAttributes.Override;
var builder = new StringBuilder();
if (protocol.Messages.Count > 0)
{
builder.Append("switch(messageName)\n\t\t\t{");
foreach (var a in protocol.Messages)
{
builder.Append("\n\t\t\t\tcase \"").Append(a.Key).Append("\":\n");
bool unused = false;
string type = getType(a.Value.Response, false, ref unused);
builder.Append("\t\t\t\trequestor.Request<")
.Append(type)
.Append(">(messageName, args, callback);\n");
builder.Append("\t\t\t\tbreak;\n");
}
builder.Append("\t\t\t}");
}
var cseGet = new CodeSnippetExpression(builder.ToString());
requestMethod.Statements.Add(cseGet);
ctd.Members.Add(requestMethod);
AddMethods(protocol, false, ctd);
string nspace = protocol.Namespace;
if (string.IsNullOrEmpty(nspace))
{
throw new CodeGenException("Namespace required for enum schema " + nspace);
}
CodeNamespace codens = addNamespace(nspace);
codens.Types.Add(ctd);
// Create callback abstract class
ctd = new CodeTypeDeclaration(protocolNameMangled + "Callback");
ctd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public;
ctd.IsClass = true;
ctd.BaseTypes.Add(protocolNameMangled);
// Need to override
AddProtocolDocumentation(protocol, ctd);
AddMethods(protocol, true, ctd);
codens.Types.Add(ctd);
}
private void ImplementSetParentMethod(IReference input, CodeTypeDeclaration output, CodeTypeReference elementTypeReference, CodeMemberMethod method, ITransformationContext context)
{
var opposite = input.Opposite;
var item = new CodeArgumentReferenceExpression("item");
var parent = new CodeArgumentReferenceExpression("parent");
var thisRef = new CodeThisReferenceExpression();
var nullRef = new CodePrimitiveExpression(null);
var item_opp = new CodePropertyReferenceExpression(item, context.Trace.ResolveIn(Rule <Reference2Property>(), opposite).Name);
var ifNotNull = new CodeConditionStatement(new CodeBinaryOperatorExpression(parent, CodeBinaryOperatorType.IdentityInequality, nullRef));
var targetClass = input.Type;
var eventName = input.IsContainment ? "ParentChanged" : "Deleted";
var eventType = input.IsContainment ? typeof(ValueChangedEventArgs).ToTypeReference() : typeof(EventArgs).ToTypeReference();
var onItemDeleted = new CodeMemberMethod()
{
Name = "OnItem" + eventName,
Attributes = MemberAttributes.Private,
ReturnType = new CodeTypeReference(typeof(void))
};
onItemDeleted.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
onItemDeleted.Parameters.Add(new CodeParameterDeclarationExpression(eventType, "e"));
var actualRemove = new CodeMethodInvokeExpression(
thisRef, "Remove", new CodeCastExpression(elementTypeReference, new CodeArgumentReferenceExpression("sender")));
if (input.IsContainment)
{
var newValue = new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("e"), "NewValue");
var parentRef = new CodePropertyReferenceExpression(thisRef, "Parent");
onItemDeleted.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(newValue, CodeBinaryOperatorType.IdentityInequality, parentRef),
new CodeExpressionStatement(actualRemove)));
}
else
{
onItemDeleted.Statements.Add(actualRemove);
}
output.Members.Add(onItemDeleted);
ifNotNull.TrueStatements.Add(new CodeAttachEventStatement(item, eventName, new CodeMethodReferenceExpression(thisRef, onItemDeleted.Name)));
ifNotNull.FalseStatements.Add(new CodeRemoveEventStatement(item, eventName, new CodeMethodReferenceExpression(thisRef, onItemDeleted.Name)));
if (opposite.UpperBound == 1)
{
var assignStatement = new CodeAssignStatement(item_opp, parent);
ifNotNull.TrueStatements.Add(assignStatement);
ifNotNull.FalseStatements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(
item_opp, CodeBinaryOperatorType.IdentityEquality, new CodePropertyReferenceExpression(thisRef, "Parent")),
assignStatement));
}
else
{
ifNotNull.FalseStatements.Add(new CodeMethodInvokeExpression(item_opp, "Remove", new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Parent")));
ifNotNull.TrueStatements.Add(new CodeMethodInvokeExpression(item_opp, "Add", parent));
}
method.Statements.Add(ifNotNull);
}
private void ConditionalBranch(Instruction il, bool test)
{
var rhs = new CodePrimitiveExpression(test);
var lhs = Pop();
var condition = OptimizeBinaryExpression(lhs, CodeBinaryOperator.IdentityEquality, rhs);
var stmt = new CodeExpressionStatement(condition);
AddStatment(stmt);
}
private static CodeExpression CreateTypedValueExpression(XmlSchemaDatatype dataType, object value)
{
CodeExpression codePrimitiveExpression;
CodeExpression[] codeExpressionArray;
switch (dataType.TypeCode)
{
case XmlTypeCode.None:
case XmlTypeCode.Item:
case XmlTypeCode.AnyAtomicType:
case XmlTypeCode.Idref:
case XmlTypeCode.Entity:
{
throw new InvalidOperationException();
}
case XmlTypeCode.Node:
case XmlTypeCode.Document:
case XmlTypeCode.Element:
case XmlTypeCode.Attribute:
case XmlTypeCode.Namespace:
case XmlTypeCode.ProcessingInstruction:
case XmlTypeCode.Comment:
case XmlTypeCode.Text:
case XmlTypeCode.UntypedAtomic:
{
throw new InvalidOperationException();
}
case XmlTypeCode.String:
case XmlTypeCode.Notation:
case XmlTypeCode.NormalizedString:
case XmlTypeCode.Token:
case XmlTypeCode.Language:
case XmlTypeCode.Id:
{
string str = value as string;
Debug.Assert(str != null);
codePrimitiveExpression = new CodePrimitiveExpression(str);
break;
}
case XmlTypeCode.Boolean:
{
Debug.Assert(value is bool);
codePrimitiveExpression = new CodePrimitiveExpression(value);
break;
}
case XmlTypeCode.Decimal:
case XmlTypeCode.Integer:
case XmlTypeCode.NonPositiveInteger:
case XmlTypeCode.NegativeInteger:
case XmlTypeCode.Long:
case XmlTypeCode.Int:
case XmlTypeCode.Short:
case XmlTypeCode.Byte:
case XmlTypeCode.NonNegativeInteger:
case XmlTypeCode.UnsignedLong:
case XmlTypeCode.UnsignedInt:
case XmlTypeCode.UnsignedShort:
case XmlTypeCode.UnsignedByte:
case XmlTypeCode.PositiveInteger:
{
codePrimitiveExpression = new CodePrimitiveExpression(value);
break;
}
case XmlTypeCode.Float:
case XmlTypeCode.Double:
{
Debug.Assert((value is double?true: value is float));
codePrimitiveExpression = new CodePrimitiveExpression(value);
break;
}
case XmlTypeCode.Duration:
{
Debug.Assert(value is TimeSpan);
TimeSpan ts = (TimeSpan)value;
Type type = typeof(TimeSpan);
codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression((object)ts.Ticks) };
codePrimitiveExpression = new CodeObjectCreateExpression(type, codeExpressionArray);
break;
}
case XmlTypeCode.DateTime:
case XmlTypeCode.Time:
case XmlTypeCode.Date:
case XmlTypeCode.GYearMonth:
case XmlTypeCode.GYear:
case XmlTypeCode.GMonthDay:
case XmlTypeCode.GDay:
case XmlTypeCode.GMonth:
{
Debug.Assert(value is DateTime);
DateTime dt = (DateTime)value;
Type type1 = typeof(DateTime);
codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression((object)dt.Ticks) };
codePrimitiveExpression = new CodeObjectCreateExpression(type1, codeExpressionArray);
break;
}
case XmlTypeCode.HexBinary:
case XmlTypeCode.Base64Binary:
{
codePrimitiveExpression = SimpleTypeCodeDomHelper.CreateByteArrayExpression(value);
break;
}
case XmlTypeCode.AnyUri:
{
Debug.Assert(value is Uri);
Type type2 = typeof(Uri);
codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression(((Uri)value).OriginalString) };
codePrimitiveExpression = new CodeObjectCreateExpression(type2, codeExpressionArray);
break;
}
case XmlTypeCode.QName:
{
XmlQualifiedName qname = value as XmlQualifiedName;
Type type3 = typeof(XmlQualifiedName);
codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression(qname.Name), new CodePrimitiveExpression(qname.Namespace) };
codePrimitiveExpression = new CodeObjectCreateExpression(type3, codeExpressionArray);
break;
}
case XmlTypeCode.NmToken:
case XmlTypeCode.Name:
case XmlTypeCode.NCName:
{
CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(typeof(XmlConvert));
codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression(value.ToString()) };
codePrimitiveExpression = CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "EncodeName", codeExpressionArray);
break;
}
default:
{
throw new InvalidOperationException();
}
}
return(codePrimitiveExpression);
}
public List <string> GenerateUnitTestsForClass(string solutionPath,
string generatedUnitTestProject, List <string> projClasses)
{
List <string> generatedTestClasses = new List <string>();
// analyze solution, discover basic information about each project
var solutionAnalyzer = new SolutionAnalyzer(solutionPath);
var analyedSolution = solutionAnalyzer.AnalyzeSolution();
CompilerHelper compileHelper = new CompilerHelper(_generatedTestClassesDirectory);
foreach (AnalyzedProject proj in analyedSolution.Projects)
{
if (proj.Name != generatedUnitTestProject)
{
var assembly = Assembly.LoadFile(proj.OutputFilePath); //TODO: what if the assembly does not exist because the project is not compiled??
_assemblyExportedTypes = assembly.GetExportedTypes();
inputParamGenerator = new InputParamGenerator(_assemblyExportedTypes);
foreach (Type type in _assemblyExportedTypes)
{
if (projClasses.Any(pc => pc == type.Name))
{
if (!type.IsInterface) // don't want to write unit tests for interfaces
{
// create a class
CodeTypeDeclaration targetClass = new CodeTypeDeclaration
(string.Format("{0}UnitTestsClass", type.Name))
{
IsClass = true,
TypeAttributes = TypeAttributes.Public
};
// create a code unit (the in-memory representation of a class)
CodeCompileUnit codeUnit = CreateCodeCompileUnit(proj.Name, type.Name, targetClass);
string classSourceName = string.Format("{0}UnitTestsClass.cs", type.Name);
// generate the constructor for the unit test class in which all the
// external dependencies/calls will be mocked
var cut_ConstructorGenerator = new CUT_AddConstructor(inputParamGenerator, selectedProjectName);
cut_ConstructorGenerator.AddTestClassConstructor(classSourceName, targetClass, type, analyedSolution);
// generate a unit test for each method
// the method will be called and a Assert.NotNull assertion will be added
var methods = type.GetMethods(BindingFlags.Public
| BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (MethodInfo m in methods)
{
// randomly generate method parameters
var methodParameters = m.GetParameters();
CodeExpression[] parameters = new CodeExpression[methodParameters.Length];
int j = 0;
foreach (ParameterInfo p in methodParameters)
{
// TODO: Rethink this !!!
if (p.ParameterType.Name == "String" || p.ParameterType.Name == "Int32")
{
parameters[j] = new CodePrimitiveExpression(
inputParamGenerator.ResolveParameter(p.ParameterType.Name));
}
else
{
CodeObjectCreateExpression createObjectExpression =
inputParamGenerator.CreateCustomType(p.ParameterType.Name);
parameters[j] = createObjectExpression;
}
j++;
}
var cut_addTestMethod = new CUT_AddTestMethod(inputParamGenerator);
// Assert.NotNull(result);
// Assert.NotThrow(() => targetObj.SomePublicMethod())
cut_addTestMethod.AddTestMethod_ShouldNotThrowExceptionResultShouldNotBeNull(targetClass, m.Name,
parameters, type, "CallShouldNotThrowExceptionAndResultShouldNotBeNull");
// Assert.AreEqual(result, "Insert expected value here.");
cut_addTestMethod.AddTestMethod_ExpectedResultPlaceholder(targetClass, m.Name,
parameters, type, "ResultShouldBeAsExpected");
}
// generate the c# code based on the created code unit
string generatedTestClassPath = compileHelper.GenerateCSharpCode(codeUnit, classSourceName);
// compile the above generated code into a DLL/EXE
bool isGeneratedClassCompiled = compileHelper.CompileAsDLL(classSourceName, new List <string>()
{
string.Format("{0}\\{1}", _packagesFolder, "NUnit.3.10.1\\lib\\net45\\nunit.framework.dll"),
string.Format("{0}\\{1}", _packagesFolder, "Moq.4.10.0\\lib\\net45\\Moq.dll"),
proj.OutputFilePath,
typeof(System.Linq.Enumerable).Assembly.Location
});
if (!string.IsNullOrEmpty(generatedTestClassPath) && isGeneratedClassCompiled)
{
generatedTestClasses.Add(generatedTestClassPath);
}
}
}
}
}
}
return(generatedTestClasses);
}
protected override void CreateConstructor(CodeStatementCollection localVars,
CodeStatementCollection trueStmt)
{
#if NET_2_0
if (!String.IsNullOrEmpty(pageParser.MasterPageFile))
{
// This is here just to trigger master page build, so that its type
// is available when compiling the page itself.
BuildManager.GetCompiledType(pageParser.MasterPageFile);
}
#endif
if (pageParser.ClientTarget != null)
{
CodeExpression prop;
prop = new CodePropertyReferenceExpression(thisRef, "ClientTarget");
CodeExpression ct = new CodePrimitiveExpression(pageParser.ClientTarget);
if (localVars == null)
{
localVars = new CodeStatementCollection();
}
localVars.Add(new CodeAssignStatement(prop, ct));
}
ArrayList deps = pageParser.Dependencies;
int depsCount = deps != null ? deps.Count : 0;
if (depsCount > 0)
{
if (localVars == null)
{
localVars = new CodeStatementCollection();
}
if (trueStmt == null)
{
trueStmt = new CodeStatementCollection();
}
CodeAssignStatement assign;
#if NET_2_0
localVars.Add(
new CodeVariableDeclarationStatement(
typeof(string[]),
"dependencies")
);
CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression("dependencies");
trueStmt.Add(
new CodeAssignStatement(dependencies, new CodeArrayCreateExpression(typeof(string), depsCount))
);
CodeArrayIndexerExpression arrayIndex;
object o;
for (int i = 0; i < depsCount; i++)
{
o = deps [i];
arrayIndex = new CodeArrayIndexerExpression(dependencies, new CodeExpression[] { new CodePrimitiveExpression(i) });
assign = new CodeAssignStatement(arrayIndex, new CodePrimitiveExpression(o));
trueStmt.Add(assign);
}
CodeMethodInvokeExpression getDepsCall = new CodeMethodInvokeExpression(
thisRef,
"GetWrappedFileDependencies",
new CodeExpression[] { dependencies }
);
assign = new CodeAssignStatement(GetMainClassFieldReferenceExpression("__fileDependencies"), getDepsCall);
#else
localVars.Add(new CodeVariableDeclarationStatement(
typeof(ArrayList),
"dependencies")
);
CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression("dependencies");
trueStmt.Add(
new CodeAssignStatement(dependencies, new CodeObjectCreateExpression(typeof(ArrayList), new CodeExpression[] { new CodePrimitiveExpression(depsCount) }))
);
CodeMethodInvokeExpression invoke;
for (int i = 0; i < depsCount; i++)
{
invoke = new CodeMethodInvokeExpression(dependencies, "Add", new CodeExpression[] { new CodePrimitiveExpression(deps [i]) });
trueStmt.Add(invoke);
}
assign = new CodeAssignStatement(GetMainClassFieldReferenceExpression("__fileDependencies"), dependencies);
#endif
trueStmt.Add(assign);
}
base.CreateConstructor(localVars, trueStmt);
}
private void GenerateXmlLoadAndSaveCode(CodeConstructor xmlConstructor, CodeMemberMethod saveToXmlMethod, Relation relation, string foreignClassShort)
{
/*
* XmlNodeList nodeList = xmlNode.SelectNodes("SubNodeName");
* for(int i = 0; i < nodeList.Count; i = i + 1)
* {
* XmlNode subNode = nodeList[i];
* this.relationField.Add(new RelatedType(subNode));
* }
*/
TargetLanguage targetLanguage = ApplicationController.Instance.AssemblyNode.Assembly.TargetLanguage;
string xpath = null;
if (relation.IsForeign)
{
xpath = ((ForeignFkRelation)relation).XPath;
}
else
{
throw new Exception("Internal Error 132 in RelationGenerator: Relation is not a ForeignFkRelation.");
}
string nodeListName = relation.FieldName + "NodeList";
CodeVariableReferenceExpression nsManager = new CodeVariableReferenceExpression("NamespaceManager");
CodePropertyReferenceExpression nsInstance = new CodePropertyReferenceExpression(nsManager, "Instance");
CodeVariableDeclarationStatement nodeListDecl = new CodeVariableDeclarationStatement("XmlNodeList", nodeListName,
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("xmlNode"), "SelectNodes", new CodePrimitiveExpression(xpath), nsInstance));
xmlConstructor.Statements.Add(nodeListDecl);
CodeVariableReferenceExpression iExpr = new CodeVariableReferenceExpression("i");
CodeFieldReferenceExpression relationField = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), relation.FieldName);
CodeIterationStatement forLoop = new CodeIterationStatement(
new CodeAssignStatement(iExpr, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(
iExpr,
CodeBinaryOperatorType.LessThan,
new CodeVariableReferenceExpression(nodeListName + ".Count")), // should work in C# and VB
new CodeAssignStatement(
iExpr,
new CodeBinaryOperatorExpression(
iExpr,
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1))),
new CodeVariableDeclarationStatement("XmlNode", "subNode",
new CodeIndexerExpression(
new CodeVariableReferenceExpression(nodeListName),
iExpr)),
new CodeExpressionStatement(
new CodeMethodInvokeExpression(relationField, "Add",
new CodeObjectCreateExpression(foreignClassShort,
new CodeVariableReferenceExpression("subNode")))));
xmlConstructor.Statements.Add(forLoop);
/*
* for ( int i = 0; i < relatedContainer.Count; i = i + 1 )
* {
* RelatedType relObject = relContainer[i];
* relObject.Save(newElement, "Elementname", "Namespace");
* }
*/
string elementNodeName = null;
string[] xpathParts = xpath.Split('/');
if (xpath.IndexOf('/') > -1)
{
elementNodeName = GenerateNestedXpathCode(xpathParts, saveToXmlMethod);
}
else
{
elementNodeName = "myElement";
}
string elementPath = xpathParts[xpathParts.Length - 1];
string namespc = this.namespaceWrapper[NamespaceWrapper.GetPrefixFromQualifiedName(elementPath)];
elementPath = NamespaceWrapper.GetXpathFromQualifiedName(elementPath);
CodeExpression namespcExpr = new CodePrimitiveExpression(namespc);
forLoop = new CodeIterationStatement(
new CodeAssignStatement(iExpr, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(
iExpr,
CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(relationField, "Count")),
new CodeAssignStatement(
iExpr,
new CodeBinaryOperatorExpression(
iExpr,
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1))),
new CodeVariableDeclarationStatement(foreignClassShort, "relObject",
new CodeIndexerExpression(relationField, iExpr)),
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("relObject"), "Save",
new CodeVariableReferenceExpression(elementNodeName),
new CodePrimitiveExpression(elementPath), namespcExpr)));
saveToXmlMethod.Statements.Add(forLoop);
}
protected void AddInitializeRuntimeOptionsStatements(CodeStatementCollection statements, CodeVariableReferenceExpression optionsVar)
{
// Initial template
//------------------------------------------------
BindingExpressionInfo bind = parser.InitialTemplateBinding;
XmlQualifiedName initialTempl = parser.InitialTemplate;
if (bind != null || initialTempl != null)
{
CodeAssignStatement assignFromPrimitive = null;
if (initialTempl != null)
{
assignFromPrimitive = new CodeAssignStatement {
Left = new CodePropertyReferenceExpression {
PropertyName = "InitialTemplate",
TargetObject = optionsVar
},
Right = new CodeObjectCreateExpression(
typeof(XmlQualifiedName),
new CodePrimitiveExpression(initialTempl.Name),
new CodePrimitiveExpression(initialTempl.Namespace)
)
};
}
if (bind != null)
{
bool bindRequired = initialTempl == null;
var paramName = new CodePrimitiveExpression(bind.ParsedValues.ContainsKey("name") ? bind.ParsedValues["name"] : bind.Expression);
var initialTemplVar = new CodeVariableDeclarationStatement {
Name = "initialTempl",
Type = new CodeTypeReference(typeof(String)),
InitExpression = new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "CheckParamLength",
TargetObject = new CodeThisReferenceExpression()
},
Parameters =
{
paramName,
bind.GetCodeExpression(),
new CodePrimitiveExpression(bindRequired ? 1 : 0),
new CodePrimitiveExpression(1)
}
}
};
if (bind.LineNumber > 0)
{
initialTemplVar.LinePragma = new CodeLinePragma(this.parser.PhysicalPath.LocalPath, bind.LineNumber);
}
if (bind.ParsedValues.ContainsKey("accept"))
{
initialTemplVar.InitExpression = new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "CheckParamValues",
TargetObject = new CodeThisReferenceExpression()
},
Parameters =
{
paramName,
initialTemplVar.InitExpression,
new CodeArrayCreateExpression(typeof(string), ((string[])bind.ParsedValues["accept"]).Select(s => new CodePrimitiveExpression(s)).ToArray())
}
};
}
initialTemplVar.InitExpression = new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "AsString",
TargetObject = new CodeThisReferenceExpression()
},
Parameters =
{
initialTemplVar.InitExpression
}
};
statements.Add(initialTemplVar);
var assignFromVar = new CodeAssignStatement {
Left = new CodePropertyReferenceExpression {
PropertyName = "InitialTemplate",
TargetObject = optionsVar
},
Right = new CodeObjectCreateExpression(
typeof(XmlQualifiedName),
new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "ToString",
TargetObject = new CodeVariableReferenceExpression(initialTemplVar.Name)
}
}
)
};
if (bindRequired)
{
statements.Add(assignFromVar);
}
else
{
var ifStatement = new CodeConditionStatement {
Condition = new CodeBinaryOperatorExpression {
Left = new CodeVariableReferenceExpression(initialTemplVar.Name),
Operator = CodeBinaryOperatorType.IdentityInequality,
Right = new CodePrimitiveExpression(null)
},
TrueStatements = { assignFromVar },
FalseStatements = { assignFromPrimitive }
};
statements.Add(ifStatement);
}
}
else
{
statements.Add(assignFromPrimitive);
}
}
// Initial context node
//------------------------------------------------
if (initialContextNodeField != null || this.parser.PageType == XsltPageType.SimplifiedStylesheet)
{
if (initialContextNodeField != null)
{
statements.Add(
new CodeAssignStatement {
Left = new CodePropertyReferenceExpression {
PropertyName = "InitialContextNode",
TargetObject = optionsVar
},
Right = new CodeFieldReferenceExpression {
FieldName = initialContextNodeField.Name,
TargetObject = PageTypeReferenceExpression
}
}
);
}
else
{
statements.Add(
new CodeAssignStatement {
Left = new CodePropertyReferenceExpression {
PropertyName = "InitialContextNode",
TargetObject = optionsVar
},
Right = new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "CreateNodeReadOnly",
TargetObject = new CodePropertyReferenceExpression {
PropertyName = "ItemFactory",
TargetObject = new CodePropertyReferenceExpression {
PropertyName = "Processor",
TargetObject = new CodePropertyReferenceExpression {
PropertyName = "Executable",
TargetObject = new CodeThisReferenceExpression()
}
}
}
},
}
}
);
}
}
}
private CodeTypeDeclaration GetTypeDecalaration(StructDeclaration structDeclaration)
{
CodeTypeDeclaration type = new CodeTypeDeclaration(structDeclaration.Name)
{
IsClass = structDeclaration.IsRef,
IsStruct = !structDeclaration.IsRef,
IsPartial = true
};
string serializerName = structDeclaration.Name + "Serializer";
string serializerFullName = $"{structDeclaration.Name}.{serializerName}";
AddMemorySizeAttribute(type, (int)structDeclaration.Size);
AddSerializeByAttribute(type, serializerFullName);
AddSerializableAttribute(type);
AddMessageMethods(type);
if (structDeclaration.Doc != null)
{
type.Comments.Add(GetDocument(structDeclaration.Doc));
}
switch (structDeclaration.Visibility)
{
case TypeVisibility.Internal when structDeclaration.IsNested:
type.TypeAttributes = TypeAttributes.NestedAssembly;
break;
case TypeVisibility.Internal:
type.TypeAttributes = TypeAttributes.NotPublic;
break;
case TypeVisibility.Private:
type.TypeAttributes = TypeAttributes.NestedPrivate;
break;
case TypeVisibility.PrivateProtected:
type.TypeAttributes = TypeAttributes.NestedFamANDAssem;
break;
case TypeVisibility.Protected:
type.TypeAttributes = TypeAttributes.NestedFamily;
break;
case TypeVisibility.ProtectedInternal:
type.TypeAttributes = TypeAttributes.NestedFamORAssem;
break;
case TypeVisibility.Public:
type.TypeAttributes = TypeAttributes.Public;
break;
}
if (structDeclaration.IsFinal)
{
type.TypeAttributes |= TypeAttributes.Sealed;
}
CodeTypeReference structRef = new CodeTypeReference(structDeclaration.Name);
AddShortcutMethod(type, structDeclaration.Name, structRef);
AddSerializerType(type, structRef, serializerName, structDeclaration.Name, out var serializeMethod, out var deserializeMethod);
foreach (var declaration in structDeclaration.Declarations.Declarations)
{
switch (declaration)
{
case FieldDeclaration fieldDeclaration:
string fieldName = "m_" + fieldDeclaration.Name;
string typeName = ValidateType(fieldDeclaration.Type.RawString);
CodeTypeReference fieldType = GetTypeReference(typeName, fieldDeclaration.Type);
CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(s_ObjRef, fieldName);
CodePrimitiveExpression index = new CodePrimitiveExpression((int)fieldDeclaration.Index);
CodeTypeReferenceExpression realType = fieldDeclaration.RealType == null ? null : new CodeTypeReferenceExpression(GetTypeReference(ValidateType(fieldDeclaration.RealType.RawString), fieldDeclaration.Type));
CodeMemberField field = new CodeMemberField()
{
Attributes = MemberAttributes.Private | MemberAttributes.Final,
Name = fieldName,
Type = fieldType,
};
if (fieldDeclaration.IsNeverNull)
{
field.CustomAttributes.Add(s_NeverNullAttr);
}
if (fieldDeclaration.IsObsolete)
{
field.CustomAttributes.Add(s_ObsoleteAttr);
}
AddSerialIndexAttribute(field, index);
if (realType != null)
{
AddFacadeTypeAttribute(field, realType.Type);
}
#if UNITY
field.CustomAttributes.Add(s_SerializeFieldAttr);
#endif
CodeMemberProperty property = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = fieldDeclaration.Name,
Type = fieldType,
HasGet = true,
HasSet = true
};
if (fieldDeclaration.Doc != null)
{
property.Comments.Add(GetDocument(fieldDeclaration.Doc));
}
if (fieldDeclaration.IsObsolete)
{
property.CustomAttributes.Add(s_ObsoleteAttr);
}
SetPropertyMethods(property, fieldName);
type.Members.Add(field);
type.Members.Add(property);
if (!fieldDeclaration.IsObsolete)
{
AddSerializedField(serializeMethod, fieldRef, index, realType, fieldDeclaration.IsNeverNull);
}
break;
case StructDeclaration structDeclaration1:
CodeTypeDeclaration type1 = GetTypeDecalaration(structDeclaration1);
type.Members.Add(type1);
break;
}
}
deserializeMethod.Statements.Add(GetDeserializeMethodBody(structDeclaration.Declarations.Declarations));
deserializeMethod.Statements.Add(s_OnAfterDeserialization);
deserializeMethod.Statements.Add(s_ReturnResult);
return(type);
}
public override void ProcessDirective(string directiveName, IDictionary <string, string> arguments)
{
string name = arguments["name"];
string type = arguments["type"];
if (string.IsNullOrEmpty(name))
{
throw new DirectiveProcessorException("Parameter directive has no name argument");
}
if (string.IsNullOrEmpty(type))
{
throw new DirectiveProcessorException("Parameter directive has no type argument");
}
string fieldName = "_" + name + "Field";
var typeRef = new CodeTypeReference(type);
var thisRef = new CodeThisReferenceExpression();
var fieldRef = new CodeFieldReferenceExpression(thisRef, fieldName);
var property = new CodeMemberProperty()
{
Name = name,
Attributes = MemberAttributes.Public | MemberAttributes.Final,
HasGet = true,
HasSet = false,
Type = typeRef
};
property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef));
members.Add(new CodeMemberField(typeRef, fieldName));
members.Add(property);
string acquiredName = "_" + name + "Acquired";
var valRef = new CodeVariableReferenceExpression("data");
var namePrimitive = new CodePrimitiveExpression(name);
var sessionRef = new CodePropertyReferenceExpression(thisRef, "Session");
var callContextTypeRefExpr = new CodeTypeReferenceExpression("System.Runtime.Remoting.Messaging.CallContext");
var nullPrim = new CodePrimitiveExpression(null);
var acquiredVariable = new CodeVariableDeclarationStatement(typeof(bool), acquiredName, new CodePrimitiveExpression(false));
var acquiredVariableRef = new CodeVariableReferenceExpression(acquiredVariable.Name);
this.postStatements.Add(acquiredVariable);
//checks the local called "data" can be cast and assigned to the field, and if successful, sets acquiredVariable to true
var checkCastThenAssignVal = new CodeConditionStatement(
new CodeMethodInvokeExpression(
new CodeTypeOfExpression(typeRef), "IsAssignableFrom", new CodeMethodInvokeExpression(valRef, "GetType")),
new CodeStatement[] {
new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, valRef)),
new CodeAssignStatement(acquiredVariableRef, new CodePrimitiveExpression(true)),
},
new CodeStatement[] {
new CodeExpressionStatement(new CodeMethodInvokeExpression(thisRef, "Error",
new CodePrimitiveExpression("The type '" + type + "' of the parameter '" + name +
"' did not match the type passed to the template"))),
});
//tries to gets the value from the session
var checkSession = new CodeConditionStatement(
new CodeBinaryOperatorExpression(NotNull(sessionRef), CodeBinaryOperatorType.BooleanAnd,
new CodeMethodInvokeExpression(sessionRef, "ContainsKey", namePrimitive)),
new CodeVariableDeclarationStatement(typeof(object), "data", new CodeIndexerExpression(sessionRef, namePrimitive)),
checkCastThenAssignVal);
this.postStatements.Add(checkSession);
//if acquiredVariable is false, tries to gets the value from the host
if (hostSpecific)
{
var hostRef = new CodePropertyReferenceExpression(thisRef, "Host");
var checkHost = new CodeConditionStatement(
BooleanAnd(IsFalse(acquiredVariableRef), NotNull(hostRef)),
new CodeVariableDeclarationStatement(typeof(string), "data",
new CodeMethodInvokeExpression(hostRef, "ResolveParameterValue", nullPrim, nullPrim, namePrimitive)),
new CodeConditionStatement(NotNull(valRef), checkCastThenAssignVal));
this.postStatements.Add(checkHost);
}
//if acquiredVariable is false, tries to gets the value from the call context
var checkCallContext = new CodeConditionStatement(
IsFalse(acquiredVariableRef),
new CodeVariableDeclarationStatement(typeof(object), "data",
new CodeMethodInvokeExpression(callContextTypeRefExpr, "LogicalGetData", namePrimitive)),
new CodeConditionStatement(NotNull(valRef), checkCastThenAssignVal));
this.postStatements.Add(checkCallContext);
}
private void AddSerializedField(CodeMemberMethod serializeMethod, CodeFieldReferenceExpression fieldRef, CodePrimitiveExpression index, CodeTypeReferenceExpression realType, bool isNeverNull)
{
CodeExpression param = realType == null ? fieldRef as CodeExpression : new CodeCastExpression(realType.Type, fieldRef);
CodeExpression expr = new CodeMethodInvokeExpression(s_WriterRef, "WriteValue", index, param);
if (isNeverNull)
{
serializeMethod.Statements.Add(expr);
}
else
{
CodeConditionStatement condition = new CodeConditionStatement(new CodeBinaryOperatorExpression(fieldRef, CodeBinaryOperatorType.IdentityInequality, s_Null), new CodeExpressionStatement(expr));
serializeMethod.Statements.Add(condition);
}
}
private static void BuildStandardMethod(
CodeTypeDeclaration declaration,
string methodName,
string rpcMethodName,
Type[] argTypes,
string[] argNames,
Type returnType,
Type implementationType)
{
var cmm = new CodeMemberMethod();
// normal, unqualified type names are public
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.ImplementationTypes.Add(implementationType);
cmm.Name = methodName;
// set the return type
var ctrReturn = new CodeTypeReference(returnType);
cmm.ReturnType = ctrReturn;
MakeParameterList(cmm, argTypes, argNames);
// add an XmlRpcMethod attribute to the type
var cad = new CodeAttributeDeclaration();
cad.Name = typeof(XmlRpcMethodAttribute).FullName;
var caa = new CodeAttributeArgument();
var cpe = new CodePrimitiveExpression(rpcMethodName);
caa.Value = cpe;
cad.Arguments.Add(caa);
cmm.CustomAttributes.Add(cad);
// generate the method body:
// if non-void return, declared locals for processing return value
if (returnType != typeof(void))
{
// add some local variables
MakeTempVariable(cmm, typeof(object));
MakeReturnVariable(cmm, returnType);
}
MakeTempParameterArray(cmm, argTypes, argNames);
// construct a call to the base Invoke method
var ctre = new CodeThisReferenceExpression();
var cmre = new CodeMethodReferenceExpression(ctre, "Invoke");
var cmie = new CodeMethodInvokeExpression();
cmie.Method = cmre;
cmie.Parameters.Add(new CodePrimitiveExpression(methodName));
cmie.Parameters.Add(new CodeVariableReferenceExpression(DEFAULT_ARR));
if (returnType != typeof(void))
{
// assign the result to tempRetVal
var casTemp = new CodeAssignStatement();
casTemp.Left = new CodeVariableReferenceExpression(DEFAULT_TEMP);
casTemp.Right = cmie;
cmm.Statements.Add(casTemp);
}
else
{
// discard return type
cmm.Statements.Add(cmie);
}
MakeReturnStatement(cmm, returnType);
// add the finished method to the type
declaration.Members.Add(cmm);
}
public void VisitPrimitive(CodePrimitiveExpression p)
{
if (p.Value == null)
writer.Write("null");
else if (p.Value is string)
WriteStringLiteral(p.Value as string);
else if (p.Value is int)
writer.Write(p.Value.ToString());
else if (p.Value is long)
writer.Write("{0}L", p.Value);
else if (p.Value is bool)
writer.Write((bool)p.Value ? "true" : "false");
else if (p.Value is double)
{
var s = p.Value.ToString();
if (!s.Contains('.') && !s.Contains('e') && !s.Contains('E'))
s += ".0";
writer.Write(s);
}
else if (p.Value is Syntax.Str)
WriteStringLiteral((Syntax.Str)p.Value);
else
throw new NotImplementedException("" + p.Value);
}
private void GeneratePrimitiveExpressionBase(CodePrimitiveExpression e)
{
if (e.Value == null)
{
Output.Write(NullToken);
}
else if (e.Value is string)
{
Output.Write(QuoteSnippetString((string)e.Value));
}
else if (e.Value is char)
{
Output.Write("'" + e.Value.ToString() + "'");
}
else if (e.Value is byte)
{
Output.Write(((byte)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is Int16)
{
Output.Write(((Int16)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is Int32)
{
Output.Write(((Int32)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is Int64)
{
Output.Write(((Int64)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is Single)
{
GenerateSingleFloatValue((Single)e.Value);
}
else if (e.Value is Double)
{
GenerateDoubleValue((Double)e.Value);
}
else if (e.Value is Decimal)
{
GenerateDecimalValue((Decimal)e.Value);
}
else if (e.Value is bool)
{
if ((bool)e.Value)
{
Output.Write("true");
}
else
{
Output.Write("false");
}
}
else
{
throw new ArgumentException("Invalid primitive type", e.Value.GetType().ToString());
}
}
protected virtual void GeneratePrimitiveExpression(CodePrimitiveExpression e)
{
object value = e.Value;
if (value == null)
{
output.Write(NullToken);
return;
}
Type type = value.GetType();
TypeCode typeCode = Type.GetTypeCode(type);
switch (typeCode)
{
case TypeCode.Boolean:
output.Write(value.ToString().ToLower(CultureInfo.InvariantCulture));
break;
case TypeCode.Char:
output.Write("'" + value.ToString() + "'");
break;
case TypeCode.String:
output.Write(EscapeString((string)value));
break;
case TypeCode.Single:
GenerateSingleFloatValue((float)value);
break;
case TypeCode.Double:
GenerateDoubleValue((double)value);
break;
case TypeCode.Decimal:
GenerateDecimalValue((decimal)value);
break;
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
output.Write(((IFormattable)value).ToString(null, CultureInfo.InvariantCulture));
break;
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
"Invalid Primitive Type: {0}. Only CLS compliant primitive " +
"types can be used. Consider using CodeObjectCreateExpression.",
type.FullName));
}
}
// Generate code for a primitive expression.
protected virtual void GeneratePrimitiveExpression
(CodePrimitiveExpression e)
{
Object value = e.Value;
if(value == null)
{
Output.Write(NullToken);
}
else if(value is String)
{
Output.Write(QuoteSnippetString((String)value));
}
else if(value is Char)
{
char ch = (char)value;
String chvalue;
switch(ch)
{
case '\'': chvalue = "'\\''"; break;
case '\\': chvalue = "'\\\\'"; break;
case '\n': chvalue = "'\\n'"; break;
case '\r': chvalue = "'\\r'"; break;
case '\t': chvalue = "'\\t'"; break;
case '\f': chvalue = "'\\f'"; break;
case '\v': chvalue = "'\\v'"; break;
case '\a': chvalue = "'\\a'"; break;
case '\b': chvalue = "'\\b'"; break;
default:
{
if(ch >= ' ' && ch <= 0x7E)
{
chvalue = "\"" + ch.ToString() + "\"";
}
else if(ch < 0x0100)
{
chvalue = "\"\\x" +
hexchars[(ch >> 4) & 0x0F] +
hexchars[ch & 0x0F] + "\"";
}
else
{
chvalue = "\"\\u" +
hexchars[(ch >> 12) & 0x0F] +
hexchars[(ch >> 8) & 0x0F] +
hexchars[(ch >> 4) & 0x0F] +
hexchars[ch & 0x0F] + "\"";
}
}
break;
}
Output.Write(chvalue);
}
else if(value is SByte)
{
Output.Write((int)(sbyte)value);
}
else if(value is Byte)
{
Output.Write((int)(byte)value);
}
else if(value is Int16)
{
Output.Write((int)(short)value);
}
else if(value is UInt16)
{
Output.Write((int)(ushort)value);
}
else if(value is Int32)
{
Output.Write((int)value);
}
else if(value is UInt32)
{
Output.Write((uint)value);
}
else if(value is Int64)
{
Output.Write((long)value);
}
else if(value is UInt64)
{
Output.Write((ulong)value);
}
else if(value is Single)
{
GenerateSingleFloatValue((float)value);
}
else if(value is Double)
{
GenerateDoubleValue((double)value);
}
else if(value is Decimal)
{
GenerateDecimalValue((Decimal)value);
}
else if(value is Boolean)
{
if((bool)value)
{
Output.Write("true");
}
else
{
Output.Write("false");
}
}
else
{
throw new ArgumentException
(S._("Arg_InvalidCodeDom"), "e");
}
}
public static string Print(CodePrimitiveExpression expr)
{
return(expr.Value.ToString());
}
public void Visit(CodePrimitiveExpression o)
{
g.GeneratePrimitiveExpression(o);
}
private static void CreateLoad(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeMemberMethod()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = "Load",
};
cc.Parameters.Add("IDataSet", "dataSet");
cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision");
var dataSet = new CodeVariableReferenceExpression("dataSet");
{
var ccs = CreateCompareDataBaseStatement(classType, generationInfo);
var tst = CreateTryCatchStatement(classType, ccs, generationInfo);
cc.Statements.Add(tst);
}
{
var ccs = CreateCompareRevisionStatement(classType, generationInfo);
var tst = CreateTryCatchStatement(classType, ccs, generationInfo);
cc.Statements.Add(tst);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_name");
var property = new CodePropertyReferenceExpression(dataSet, "Name");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_revision");
var property = new CodePropertyReferenceExpression(dataSet, "Revision");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_typesHashValue");
var property = new CodePropertyReferenceExpression(dataSet, "TypesHashValue");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tablesHashValue");
var property = new CodePropertyReferenceExpression(dataSet, "TablesHashValue");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tags");
var property = new CodePropertyReferenceExpression(dataSet, "Tags");
cc.Statements.AddAssign(field, property);
}
foreach (var item in generationInfo.GetTables(true))
{
var tableName = new CodePrimitiveExpression(item.Name);
var tablesProp = new CodePropertyReferenceExpression(dataSet, "Tables");
var table = new CodeIndexerExpression(tablesProp, tableName);
var field = item.GetFieldExpression();
var instance = new CodeObjectCreateExpression(item.GetCodeType(), table);
var assignStatement = new CodeAssignStatement(field, instance);
if (generationInfo.IsDevmode == true)
{
var tryStatement = CreateTryCatchStatement(classType, assignStatement, generationInfo);
cc.Statements.Add(tryStatement);
}
else
{
cc.Statements.Add(assignStatement);
}
}
classType.Members.Add(cc);
}
CodeMemberMethod GenerateMethod(CodeIdentifiers memberIds, HttpOperationBinding httpOper, XmlMembersMapping inputMembers, XmlTypeMapping outputMember)
{
CodeIdentifiers pids = new CodeIdentifiers();
CodeMemberMethod method = new CodeMemberMethod();
CodeMemberMethod methodBegin = new CodeMemberMethod();
CodeMemberMethod methodEnd = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public;
methodBegin.Attributes = MemberAttributes.Public;
methodEnd.Attributes = MemberAttributes.Public;
// Find unique names for temporary variables
for (int n = 0; n < inputMembers.Count; n++)
{
pids.AddUnique(inputMembers[n].MemberName, inputMembers[n]);
}
string varAsyncResult = pids.AddUnique("asyncResult", "asyncResult");
string varCallback = pids.AddUnique("callback", "callback");
string varAsyncState = pids.AddUnique("asyncState", "asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name), method);
method.Name = Operation.Name;
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + Operation.Name), method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + Operation.Name), method);
method.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
for (int n = 0; n < inputMembers.Count; n++)
{
string ptype = GetSimpleType(inputMembers[n]);
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(ptype, inputMembers[n].MemberName);
param.Direction = FieldDirection.In;
method.Parameters.Add(param);
methodBegin.Parameters.Add(param);
paramArray [n] = new CodeVariableReferenceExpression(param.Name);
}
bool isVoid = true;
if (outputMember != null)
{
method.ReturnType = new CodeTypeReference(outputMember.TypeFullName);
methodEnd.ReturnType = new CodeTypeReference(outputMember.TypeFullName);
xmlExporter.AddMappingMetadata(method.ReturnTypeCustomAttributes, outputMember, "");
isVoid = false;
}
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), varCallback));
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), varAsyncState));
methodBegin.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
{
methodParams = new CodeArrayCreateExpression(typeof(object), paramArray);
}
else
{
methodParams = new CodeArrayCreateExpression(typeof(object), 0);
}
// Generate method url
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodeExpression thisURlExp = new CodeFieldReferenceExpression(ethis, "Url");
CodePrimitiveExpression metUrl = new CodePrimitiveExpression(httpOper.Location);
CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression(thisURlExp, CodeBinaryOperatorType.Add, metUrl);
// Invoke call
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression(messageName);
CodeMethodInvokeExpression inv;
inv = new CodeMethodInvokeExpression(ethis, "Invoke", varMsgName, expMethodLocation, methodParams);
if (!isVoid)
{
method.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, inv)));
}
else
{
method.Statements.Add(inv);
}
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression(varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression(varAsyncState);
inv = new CodeMethodInvokeExpression(ethis, "BeginInvoke", varMsgName, expMethodLocation, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add(new CodeMethodReturnStatement(inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression(varAsyncResult);
inv = new CodeMethodInvokeExpression(ethis, "EndInvoke", varAsyncr);
if (!isVoid)
{
methodEnd.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(methodEnd.ReturnType, inv)));
}
else
{
methodEnd.Statements.Add(inv);
}
// Attributes
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.Protocols.HttpMethodAttribute");
att.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(GetOutMimeFormatter())));
att.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(GetInMimeFormatter())));
AddCustomAttribute(method, att, true);
CodeTypeDeclaration.Members.Add(method);
CodeTypeDeclaration.Members.Add(methodBegin);
CodeTypeDeclaration.Members.Add(methodEnd);
return(method);
}
private void ValidatePrimitiveExpression(CodePrimitiveExpression e)
{
}
protected virtual void GeneratePrimitiveExpression(CodePrimitiveExpression e)
{
if (e.Value == null)
{
Output.Write(NullToken);
}
else if (e.Value is string)
{
Output.Write(QuoteSnippetString((string)e.Value));
}
else if (e.Value is char)
{
Output.Write("'" + e.Value.ToString() + "'");
}
else if (e.Value is byte)
{
Output.Write(((byte)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is short)
{
Output.Write(((short)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is int)
{
Output.Write(((int)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is long)
{
Output.Write(((long)e.Value).ToString(CultureInfo.InvariantCulture));
}
else if (e.Value is float)
{
GenerateSingleFloatValue((float)e.Value);
}
else if (e.Value is double)
{
GenerateDoubleValue((double)e.Value);
}
else if (e.Value is decimal)
{
GenerateDecimalValue((decimal)e.Value);
}
else if (e.Value is bool)
{
if ((bool)e.Value)
{
Output.Write("true");
}
else
{
Output.Write("false");
}
}
else
{
throw new ArgumentException(SR.Format(SR.InvalidPrimitiveType, e.Value.GetType().ToString()));
}
}
void AddSubelementsOfSkippedElement(TableNode parentNode, string xpath)
{
if (parentNode.Table.Skipped)
{
TableNode pparentNode = (TableNode)parentNode.UserData["parentnode"];
string path = xpath + '/' + parentNode.Name;
AddSubelementsOfSkippedElement(pparentNode, path);
return;
//-------
}
CodeCompileUnit cunit = (CodeCompileUnit)parentNode.UserData["cunit"];
CodeNamespace ns = cunit.Namespaces[0];
CodeTypeDeclaration persClass = ns.Types[0];
CodeConstructor xmlConstructor = null;
CodeMemberMethod xmlSaveMethod = null;
foreach (CodeTypeMember member in persClass.Members)
{
if (member.Name == ".ctor")
{
CodeConstructor cc = (CodeConstructor)member;
if (cc.Parameters.Count > 0)
{
xmlConstructor = cc;
}
}
else if (member.Name == "Save")
{
CodeMemberMethod cmm = (CodeMemberMethod)member;
if (cmm.Parameters.Count == 1 && cmm.Parameters[0].Type.BaseType == "XmlNode")
{
xmlSaveMethod = cmm;
}
}
if (xmlConstructor != null && xmlSaveMethod != null)
{
break;
}
}
/*
* XmlElement subElement = parentNode.OwnerDocument.CreateElement("MyElement");
* newElement.AppendChild(subElement);
* newElement = subElement;
*/
int p = xpath.LastIndexOf(':');
string namespc = this.namespaceWrapper[NamespaceWrapper.GetPrefixFromQualifiedName(xpath)];
string elementName = NamespaceWrapper.GetXpathFromQualifiedName(xpath);
CodePrimitiveExpression myElementName = new CodePrimitiveExpression(elementName);
CodePrimitiveExpression myNamespace = new CodePrimitiveExpression(namespc);
CodeVariableReferenceExpression newElement = new CodeVariableReferenceExpression("myElement");
CodeVariableReferenceExpression subElement = new CodeVariableReferenceExpression("subElement");
CodeVariableReferenceExpression ownerDoc = new CodeVariableReferenceExpression("parentNode.OwnerDocument");
CodeMethodInvokeExpression createElementCall;
if (namespc != null)
{
createElementCall = new CodeMethodInvokeExpression(ownerDoc, "CreateElement", myElementName, myNamespace);
}
else
{
createElementCall = new CodeMethodInvokeExpression(ownerDoc, "CreateElement", myElementName);
}
CodeVariableDeclarationStatement newElementAssign = new CodeVariableDeclarationStatement(new CodeTypeReference("XmlElement"), "subElement", createElementCall);
xmlSaveMethod.Statements.Add(newElementAssign);
CodeMethodInvokeExpression appendChild = new CodeMethodInvokeExpression(newElement, "AppendChild", subElement);
xmlSaveMethod.Statements.Add(appendChild);
CodeAssignStatement backAssign = new CodeAssignStatement(newElement, subElement);
xmlSaveMethod.Statements.Add(backAssign);
/*
* xmlNode = xmlNode.SelectSingleNode("xpath");
*/
CodeVariableReferenceExpression xmlNode = new CodeVariableReferenceExpression("xmlNode");
CodePrimitiveExpression xPathExpr = new CodePrimitiveExpression(xpath);
CodeVariableReferenceExpression nsManager = new CodeVariableReferenceExpression("NamespaceManager");
CodePropertyReferenceExpression nsInstance = new CodePropertyReferenceExpression(nsManager, "Instance");
CodeMethodInvokeExpression selectNodes = new CodeMethodInvokeExpression(xmlNode, "SelectSingleNode", xPathExpr, nsInstance);
CodeAssignStatement xmlNodeAssign = new CodeAssignStatement(xmlNode, selectNodes);
xmlConstructor.Statements.Add(xmlNodeAssign);
GenerateMembers(persClass, xmlConstructor, xmlSaveMethod);
// xmlNode = xmlNode.ParentNode;
CodePropertyReferenceExpression parentNodeProperty = new CodePropertyReferenceExpression(xmlNode, "ParentNode");
xmlNodeAssign = new CodeAssignStatement(xmlNode, parentNodeProperty);
xmlConstructor.Statements.Add(xmlNodeAssign);
// newElement = (XmlElement) newElement.ParentNode;
parentNodeProperty = new CodePropertyReferenceExpression(newElement, "ParentNode");
CodeCastExpression xmlElementCast = new CodeCastExpression("XmlElement", parentNodeProperty);
backAssign = new CodeAssignStatement(newElement, xmlElementCast);
xmlSaveMethod.Statements.Add(backAssign);
}
private static void GenerateProperties(Type t, CodeTypeDeclaration codeType)
{
foreach (PropertyInfo property in t.GetProperties())
{
if (OmittedProperties.ContainsKey(t.FullName) && OmittedProperties[t.FullName].Contains(property.Name))
{
continue;
}
if (property.CustomAttributes.Any(x => x.AttributeType.FullName.Contains("Obsolete")))
{
continue;
}
string propertyType = GetPropertyType(property.PropertyType);
bool isGenericCollection = property.PropertyType.IsGenericType &&
(property.PropertyType.GetGenericTypeDefinition() == typeof(IList <>) || property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable <>) ||
property.PropertyType.GetGenericTypeDefinition() == typeof(IReadOnlyList <>));
CodeFieldReferenceExpression wrappedObject = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), OmObject);
CodePropertyReferenceExpression wrappedObjectProperty = new CodePropertyReferenceExpression(wrappedObject, property.Name);
CodeFieldReferenceExpression fieldReference = null;
if (isGenericCollection || OMtoPSClassMappings.ContainsKey(property.PropertyType.FullName))
{
// Add a backing field for the property with the same name but using camel case.
string fieldName = string.Format("{0}{1}", property.Name.ToLower()[0], property.Name.Substring(1, property.Name.Length - 1));
CodeMemberField backingField = new CodeMemberField();
backingField.Attributes = MemberAttributes.Private;
backingField.Name = fieldName;
backingField.Type = new CodeTypeReference(propertyType);
codeType.Members.Add(backingField);
fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
}
CodeMemberProperty codeProperty = new CodeMemberProperty();
codeProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
codeProperty.Name = property.Name;
codeProperty.Type = new CodeTypeReference(propertyType);
// For properties with a backing field, the field will not be initialized in the constructor in order to avoid
// hitting a run time access constraint from the OM. Instead, the field is initialized on the first access of
// the property.
if (isGenericCollection)
{
// Collections are not kept in sync with the wrapped OM object. Cmdlets will need to sync them before sending
// a request to the server.
Type argType = property.PropertyType.GetGenericArguments()[0];
string wrapperArgType = argType.FullName.StartsWith("System") ? argType.FullName : OMtoPSClassMappings[argType.FullName];
string wrapperListType = string.Format("List<{0}>", wrapperArgType);
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
// Build a list of wrapper objects
const string listVariableName = "list";
CodeVariableDeclarationStatement listDeclaration = new CodeVariableDeclarationStatement(wrapperListType, listVariableName);
CodeVariableReferenceExpression listReference = new CodeVariableReferenceExpression(listVariableName);
CodeAssignStatement initializeList = new CodeAssignStatement(listReference, new CodeObjectCreateExpression(wrapperListType));
// CodeDom doesn't support foreach loops very well, so instead explicitly get the enumerator and loop on MoveNext() calls
const string enumeratorVariableName = "enumerator";
CodeVariableDeclarationStatement enumeratorDeclaration = new CodeVariableDeclarationStatement(string.Format("IEnumerator<{0}>", argType.FullName), enumeratorVariableName);
CodeVariableReferenceExpression enumeratorReference = new CodeVariableReferenceExpression(enumeratorVariableName);
CodeAssignStatement initializeEnumerator = new CodeAssignStatement(enumeratorReference, new CodeMethodInvokeExpression(wrappedObjectProperty, "GetEnumerator"));
CodeIterationStatement loopStatement = new CodeIterationStatement();
loopStatement.TestExpression = new CodeMethodInvokeExpression(enumeratorReference, "MoveNext");
loopStatement.IncrementStatement = new CodeSnippetStatement(string.Empty);
loopStatement.InitStatement = new CodeSnippetStatement(string.Empty);
CodePropertyReferenceExpression enumeratorCurrent = new CodePropertyReferenceExpression(enumeratorReference, "Current");
// Fill the list by individually wrapping each item in the loop
if (wrapperArgType.Contains("System"))
{
CodeMethodInvokeExpression addToList = new CodeMethodInvokeExpression(listReference, "Add", enumeratorCurrent);
loopStatement.Statements.Add(addToList);
}
else
{
CodeObjectCreateExpression createListItem = new CodeObjectCreateExpression(wrapperArgType, enumeratorCurrent);
CodeMethodInvokeExpression addToList = new CodeMethodInvokeExpression(listReference, "Add", createListItem);
loopStatement.Statements.Add(addToList);
}
// Initialize the backing field with the built list on first access of the property
CodeAssignStatement assignStatement;
if (property.PropertyType.GetGenericTypeDefinition() == typeof(IReadOnlyList <>))
{
CodeMethodInvokeExpression asReadOnlyList = new CodeMethodInvokeExpression(listReference, "AsReadOnly");
assignStatement = new CodeAssignStatement(fieldReference, asReadOnlyList);
}
else
{
assignStatement = new CodeAssignStatement(fieldReference, listReference);
}
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
CodeBinaryOperatorExpression fieldNullCheck = new CodeBinaryOperatorExpression(fieldReference, CodeBinaryOperatorType.IdentityEquality, nullExpression);
CodeBinaryOperatorExpression wrappedPropertyNullCheck = new CodeBinaryOperatorExpression(wrappedObjectProperty, CodeBinaryOperatorType.IdentityInequality, nullExpression);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(fieldNullCheck, CodeBinaryOperatorType.BooleanAnd, wrappedPropertyNullCheck);
CodeConditionStatement ifBlock = new CodeConditionStatement(condition, listDeclaration, initializeList, enumeratorDeclaration, initializeEnumerator, loopStatement, assignStatement);
codeProperty.GetStatements.Add(ifBlock);
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
// Call the "set" on the OM object to ensure that constraints are enforced.
codeProperty.HasSet = true;
CodePropertySetValueReferenceExpression valueReference = new CodePropertySetValueReferenceExpression();
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(valueReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeAssignStatement nullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodePrimitiveExpression(null));
CodeAssignStatement nonNullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodeObjectCreateExpression(string.Format("List<{0}>", argType.FullName)));
CodeConditionStatement ifBlock = new CodeConditionStatement(nullCheck, new CodeStatement[] { nullAssignment }, new CodeStatement[] { nonNullAssignment });
codeProperty.SetStatements.Add(ifBlock);
codeProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, valueReference));
}
}
else if (OMtoPSClassMappings.ContainsKey(property.PropertyType.FullName))
{
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
CodeObjectCreateExpression createFieldObject = new CodeObjectCreateExpression(OMtoPSClassMappings[property.PropertyType.FullName], wrappedObjectProperty);
CodeAssignStatement assignStatement = new CodeAssignStatement(fieldReference, createFieldObject);
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
CodeBinaryOperatorExpression fieldNullCheck = new CodeBinaryOperatorExpression(fieldReference, CodeBinaryOperatorType.IdentityEquality, nullExpression);
CodeBinaryOperatorExpression wrappedPropertyNullCheck = new CodeBinaryOperatorExpression(wrappedObjectProperty, CodeBinaryOperatorType.IdentityInequality, nullExpression);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(fieldNullCheck, CodeBinaryOperatorType.BooleanAnd, wrappedPropertyNullCheck);
CodeConditionStatement ifBlock = new CodeConditionStatement(condition, assignStatement);
codeProperty.GetStatements.Add(ifBlock);
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
codeProperty.HasSet = true;
CodePropertySetValueReferenceExpression valueReference = new CodePropertySetValueReferenceExpression();
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(valueReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeAssignStatement nullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodePrimitiveExpression(null));
CodePropertyReferenceExpression valueProperty = new CodePropertyReferenceExpression(valueReference, OmObject);
CodeAssignStatement nonNullAssignment = new CodeAssignStatement(wrappedObjectProperty, valueProperty);
CodeConditionStatement ifBlock = new CodeConditionStatement(nullCheck, new CodeStatement[] { nullAssignment }, new CodeStatement[] { nonNullAssignment });
codeProperty.SetStatements.Add(ifBlock);
codeProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, valueReference));
}
}
else
{
// By default, just pass through to the wrapped OM object's property.
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(wrappedObjectProperty));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
codeProperty.HasSet = true;
codeProperty.SetStatements.Add(new CodeAssignStatement(wrappedObjectProperty, new CodePropertySetValueReferenceExpression()));
}
}
codeType.Members.Add(codeProperty);
}
}
private static void FormatComment(string docs, CodeTypeMember cmp, bool obsolete = false, string tag = "summary")
{
StringBuilder obsoleteMessageBuilder = new StringBuilder();
cmp.Comments.Add(new CodeCommentStatement(string.Format("<{0}>", tag), true));
foreach (string line in HtmlEncoder.HtmlEncode(docs).Split(Environment.NewLine.ToCharArray()))
{
cmp.Comments.Add(new CodeCommentStatement(string.Format("<para>{0}</para>", line), true));
if (obsolete && (line.Contains("instead") || line.Contains("deprecated")))
{
obsoleteMessageBuilder.Append(HtmlEncoder.HtmlDecode(line));
obsoleteMessageBuilder.Append(' ');
}
}
cmp.Comments.Add(new CodeCommentStatement(string.Format("</{0}>", tag), true));
if (obsolete)
{
if (obsoleteMessageBuilder.Length > 0)
{
obsoleteMessageBuilder.Remove(obsoleteMessageBuilder.Length - 1, 1);
}
CodeSnippetTypeMember snippet = cmp as CodeSnippetTypeMember;
if (snippet != null)
{
const string template = " [System.ObsoleteAttribute(\"{0}\")]{1}";
snippet.Text = snippet.Text.Insert(0, string.Format(template, obsoleteMessageBuilder, Environment.NewLine));
}
else
{
CodeTypeReference obsoleteAttribute = new CodeTypeReference(typeof(ObsoleteAttribute));
CodePrimitiveExpression obsoleteMessage = new CodePrimitiveExpression(obsoleteMessageBuilder.ToString());
cmp.CustomAttributes.Add(new CodeAttributeDeclaration(obsoleteAttribute, new CodeAttributeArgument(obsoleteMessage)));
}
}
}
