public void Constructor0_Deny_Unrestricted ()
{
CodeDelegateInvokeExpression cdie = new CodeDelegateInvokeExpression ();
Assert.AreEqual (0, cdie.Parameters.Count, "Parameters");
Assert.IsNull (cdie.TargetObject, "TargetObject");
cdie.TargetObject = new CodeExpression ();
}
public static CodeDelegateInvokeExpression Clone(this CodeDelegateInvokeExpression expression)
{
if (expression == null) return null;
CodeDelegateInvokeExpression e = new CodeDelegateInvokeExpression();
e.Parameters.AddRange(expression.Parameters.Clone());
e.TargetObject = expression.TargetObject.Clone();
e.UserData.AddRange(expression.UserData);
return e;
}
public void Constructor2_Deny_Unrestricted ()
{
CodeExpression target = new CodeExpression ();
CodeExpression[] parameters = new CodeExpression[1] { target };
CodeDelegateInvokeExpression cdie = new CodeDelegateInvokeExpression (target, parameters);
Assert.AreEqual (1, cdie.Parameters.Count, "Parameters");
Assert.AreSame (target, cdie.TargetObject, "TargetObject");
cdie.TargetObject = new CodeExpression ();
}
public TypescriptDelegateInvokeExpression(
IExpressionFactory expressionFactory,
CodeDelegateInvokeExpression codeExpression,
CodeGeneratorOptions options)
{
_expressionFactory = expressionFactory;
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptDelegateInvokeExpression Created");
}
public bool ValidateCodeDelegateInvokeExpression (CodeDelegateInvokeExpression exp) {
bool result = true;
PushLocation (exp);
foreach (CodeExpression e in exp.Parameters)
if (!IsSimpleTarget (e))
result = false;
if (exp.TargetObject != null && !IsSimpleTarget (exp.TargetObject))
result = false;
PopLocation();
return result;
}
protected override void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression expression)
{
if (expression.TargetObject != null)
GenerateExpression (expression.TargetObject);
Output.Write ('(');
OutputExpressionList (expression.Parameters);
Output.Write (')');
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression expression)
{
throw new NotSupportedException();
}
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.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.Parameters.Add (new CodeParameterDeclarationExpression (typeof(object), "sender"));
delegateType.Parameters.Add (new CodeParameterDeclarationExpression (argsClassName, "args"));
// Event member
CodeMemberEvent codeEvent = new CodeMemberEvent ();
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);
}
protected override void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression e)
{
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
Output.Write("[CodeDelegateInvokeExpression: {0}]", e.ToString());
}
public CodeExpression ParseBaseExpression()
{
if (TokenType == CDILToken.Integer)
{
CodePrimitiveExpression expr = new CodePrimitiveExpression(TokenValue);
GetNextToken();
return expr;
}
if (TokenType == CDILToken.String)
{
CodePrimitiveExpression expr = new CodePrimitiveExpression(TokenValue);
GetNextToken();
return expr;
}
if (IsKeyword("base"))
{
GetNextToken();
return new CodeBaseReferenceExpression();
}
if (IsKeyword("null"))
{
GetNextToken();
return new CodePrimitiveExpression(null);
}
if (IsKeyword("false"))
{
GetNextToken();
return new CodePrimitiveExpression(false);
}
if (IsKeyword("true"))
{
GetNextToken();
return new CodePrimitiveExpression(true);
}
if (IsKeyword("this"))
{
GetNextToken();
return new CodeThisReferenceExpression();
}
if (IsKeyword("setvalue"))
{
GetNextToken();
return new CodePropertySetValueReferenceExpression();
}
if (IsKeyword("arg"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
string name = EatKeyword();
Expect(CDILToken.RightParen);
return new CodeArgumentReferenceExpression(name);
}
if (IsKeyword("delegatecall"))
{
CodeDelegateInvokeExpression retval = new CodeDelegateInvokeExpression();
GetNextToken();
Expect(CDILToken.LeftParen);
retval.TargetObject = ParseExpression();
Expect(CDILToken.RightParen);
Expect(CDILToken.LeftParen);
while (TokenType != CDILToken.RightParen && TokenType != CDILToken.EOF)
{
CodeExpression expr = ParseExpression();
retval.Parameters.Add(expr);
if (TokenType == CDILToken.Comma)
{
GetNextToken();
}
}
Expect(CDILToken.RightParen);
return retval;
}
if (IsKeyword("typeref"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeTypeReference typeRef = ParseType();
Expect(CDILToken.RightParen);
return new CodeTypeReferenceExpression(typeRef);
}
if (IsKeyword("typeof"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeTypeReference typeRef = ParseType();
Expect(CDILToken.RightParen);
return new CodeTypeOfExpression(typeRef);
}
if (IsKeyword("add"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.Add;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("equal"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.ValueEquality;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("refequal"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.IdentityEquality;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("refnotequal"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.IdentityInequality;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("arrayitem"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeArrayIndexerExpression caie = new CodeArrayIndexerExpression();
caie.TargetObject = ParseExpression();
while (TokenType == CDILToken.Comma)
{
Expect(CDILToken.Comma);
caie.Indices.Add(ParseExpression());
}
Expect(CDILToken.RightParen);
return caie;
}
if (IsKeyword("index"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeIndexerExpression cie = new CodeIndexerExpression();
cie.TargetObject = ParseExpression();
while (TokenType == CDILToken.Comma)
{
Expect(CDILToken.Comma);
cie.Indices.Add(ParseExpression());
}
Expect(CDILToken.RightParen);
return cie;
}
if (IsKeyword("var"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
string name = EatKeyword();
Expect(CDILToken.RightParen);
return new CodeVariableReferenceExpression(name);
}
if (IsKeyword("defaultscope"))
{
GetNextToken();
return null;
}
if (IsKeyword("ref"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeExpression expr = ParseExpression();
Expect(CDILToken.RightParen);
return new CodeDirectionExpression(FieldDirection.Ref, expr);
}
if (IsKeyword("out"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeExpression expr = ParseExpression();
Expect(CDILToken.RightParen);
return new CodeDirectionExpression(FieldDirection.Out, expr);
}
if (IsKeyword("cast"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeTypeReference type = ParseType();
Expect(CDILToken.Comma);
CodeExpression expr = ParseExpression();
Expect(CDILToken.RightParen);
return new CodeCastExpression(type, expr);
}
if (IsKeyword("new"))
{
GetNextToken();
CodeTypeReference type = ParseType();
CodeObjectCreateExpression retval = new CodeObjectCreateExpression(type);
Expect(CDILToken.LeftParen);
while (TokenType != CDILToken.RightParen && TokenType != CDILToken.EOF)
{
CodeExpression expr = ParseExpression();
retval.Parameters.Add(expr);
if (TokenType == CDILToken.Comma)
{
GetNextToken();
}
}
Expect(CDILToken.RightParen);
return retval;
}
if (IsKeyword("newarray"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeArrayCreateExpression retval = new CodeArrayCreateExpression();
retval.CreateType = ParseType();
Expect(CDILToken.Comma);
retval.SizeExpression = ParseExpression();
Expect(CDILToken.RightParen);
return retval;
}
throw BuildException("Unexpected token '" + TokenType + "'");
}
protected abstract void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression e);
private void ValidateDelegateInvokeExpression(CodeDelegateInvokeExpression e) {
if (e.TargetObject != null) {
ValidateExpression(e.TargetObject);
}
ValidateExpressionList(e.Parameters);
}
MakeReadFieldStatements(Type type,
CodeExpression objExpr,
FieldInfo finfo,
CodeVariableReferenceExpression[] indexExprs)
{
CodeStatement[] stmts;
CodeExpression readerExpr = new CodeArgumentReferenceExpression("reader");
string readerName = GetBuiltinReaderName(type);
if (readerName == null)
{
// For non-builtin types
string serializerName = GetStaticSerializerName(type);
CodeVariableReferenceExpression serializerExpr = new CodeVariableReferenceExpression(serializerName);
CodeVariableDeclarationStatement tempDecl = null;
CodeExpression setterExpr = null;
CodeExpression fieldExpr;
if (finfo == null)
{
fieldExpr = new CodeArrayIndexerExpression(objExpr, indexExprs);
}
else if (finfo.IsPublic && !finfo.IsInitOnly)
{
fieldExpr = new CodeFieldReferenceExpression(objExpr, finfo.Name);
}
else
{
string fieldName = TypeSystem.FieldName(finfo.Name);
if (!TypeSystem.IsBackingField(finfo.Name) ||
finfo.DeclaringType.GetProperty(fieldName, FieldFlags).GetSetMethod() == null)
{
setterExpr = new CodeVariableReferenceExpression(ExtensionClassName + "." + this.SetterFieldName(finfo));
fieldName = this.m_fieldToStaticName[finfo];
}
tempDecl = new CodeVariableDeclarationStatement(type, fieldName);
fieldExpr = new CodeVariableReferenceExpression(tempDecl.Name);
}
CodeExpression fieldValExpr = new CodeMethodInvokeExpression(serializerExpr, "Read", readerExpr);
CodeStatement readCall = new CodeAssignStatement(fieldExpr, fieldValExpr);
if (tempDecl == null)
{
stmts = new CodeStatement[] { readCall };
}
else
{
CodeStatement setCall;
if (setterExpr == null)
{
CodeExpression propExpr = new CodePropertyReferenceExpression(objExpr, tempDecl.Name);
setCall = new CodeAssignStatement(propExpr, fieldExpr);
}
else
{
if (finfo.DeclaringType.IsValueType)
{
objExpr = new CodeDirectionExpression(FieldDirection.Out, objExpr);
}
CodeExpression setExpr = new CodeDelegateInvokeExpression(setterExpr, objExpr, fieldExpr);
setCall = new CodeExpressionStatement(setExpr);
}
stmts = new CodeStatement[] { tempDecl, readCall, setCall };
}
}
else
{
// for builtin types
CodeExpression readCall = new CodeMethodInvokeExpression(readerExpr, readerName);
if (finfo == null)
{
CodeExpression fieldExpr = new CodeArrayIndexerExpression(objExpr, indexExprs);
stmts = new CodeStatement[] { new CodeAssignStatement(fieldExpr, readCall) };
}
else
{
string fieldName = TypeSystem.FieldName(finfo.Name);
if ((finfo.IsPublic && !finfo.IsInitOnly) ||
(TypeSystem.IsBackingField(finfo.Name) &&
finfo.DeclaringType.GetProperty(fieldName, FieldFlags).GetSetMethod() != null))
{
CodeExpression fieldExpr = new CodeFieldReferenceExpression(objExpr, fieldName);
stmts = new CodeStatement[] { new CodeAssignStatement(fieldExpr, readCall) };
}
else
{
CodeExpression setterExpr = new CodeVariableReferenceExpression(
ExtensionClassName + "." + this.SetterFieldName(finfo));
if (finfo.DeclaringType.IsValueType)
{
objExpr = new CodeDirectionExpression(FieldDirection.Out, objExpr);
}
CodeExpression setExpr = new CodeDelegateInvokeExpression(setterExpr, objExpr, readCall);
stmts = new CodeStatement[] { new CodeExpressionStatement(setExpr) };
}
}
}
if (!type.IsValueType &&
(finfo != null || StaticConfig.AllowNullArrayElements) &&
(finfo == null || AttributeSystem.FieldCanBeNull(finfo)))
{
CodeExpression bvIndex = indexExprs[0];
if (finfo == null)
{
string bvIndexString = indexExprs[0].VariableName;
for (int i = 1; i < indexExprs.Length; i++)
{
bvIndexString += "*" + indexExprs[i].VariableName;
}
bvIndex = new CodeSnippetExpression(bvIndexString);
}
CodeExpression bvExpr = new CodeArgumentReferenceExpression("bv");
CodeExpression ifExpr = new CodeBinaryOperatorExpression(
new CodeIndexerExpression(bvExpr, bvIndex),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false));
CodeStatement stmt = new CodeConditionStatement(ifExpr, stmts);
stmts = new CodeStatement[] { stmt };
}
return stmts;
}
private CodeExpression VisitInvocation(InvocationExpression invocationExpression)
{
CodeExpression to = _Visit(invocationExpression.Expression);
if (typeof(CodeMethodInvokeExpression).IsAssignableFrom(to.GetType()))
{
CodeMethodInvokeExpression mi = to as CodeMethodInvokeExpression;
if (invocationExpression.Arguments.Count > 0)
{
if (invocationExpression.Arguments[0] is ConstantExpression)
mi.Parameters.Add(_Visit(invocationExpression.Arguments[0]));
else
foreach (var par in (invocationExpression.Arguments[0] as NewArrayExpression).Expressions)
{
AddParam(mi.Parameters, par);
}
}
return mi;
}
else if (to is CodeDelegateInvokeExpression)
{
if (invocationExpression.Arguments.Count > 0)
{
if (invocationExpression.Arguments[0] is ConstantExpression)
(to as CodeDelegateInvokeExpression).Parameters.Add(_Visit(invocationExpression.Arguments[0]));
else
foreach (var par in (invocationExpression.Arguments[0] as NewArrayExpression).Expressions)
{
AddParam((to as CodeDelegateInvokeExpression).Parameters, par);
}
}
return to;
}
else
{
var mi = new CodeDelegateInvokeExpression(to);
if (invocationExpression.Arguments.Count > 0)
{
if (invocationExpression.Arguments[0] is ConstantExpression)
mi.Parameters.Add(_Visit(invocationExpression.Arguments[0]));
else
foreach (var par in invocationExpression.Arguments)
{
AddParam(mi.Parameters, par);
}
}
return mi;
}
}
protected override void GenerateDelegateInvokeExpression(System.CodeDom.CodeDelegateInvokeExpression e)
{
throw new Exception("The method or operation is not implemented.");
}
private void Write(CodeDelegateInvokeExpression e){
TextWriter w = this.writer;
this.Write(e.TargetObject);
this.Write(e.Parameters);
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
GenerateExpression(e.TargetObject);
string comma = "";
foreach (CodeExpression ce in e.Parameters) {
Write(comma);
GenerateExpression(ce);
comma = ", ";
}
}
private CodeExpression VisitMethodCall(MethodCallExpression methodCallExpression)
{
var mr = GetMethodRef(methodCallExpression.Method);
if (methodCallExpression.Object == null)
{
if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.VarRef" ||
mr.MethodName == "LinqToCodedom.Generator.CodeDom.ParamRef")
{
return new LinqToCodedom.Generator.CodeDom.CodeVarExpression(
CodeDom.Eval<string>(methodCallExpression.Arguments[0]));
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.TypeRef")
{
var c = new CodeTypeReferenceExpression(
CodeDom.Eval<string>(methodCallExpression.Arguments[0]));
if (methodCallExpression.Arguments.Count == 2)
{
NewArrayExpression arr = methodCallExpression.Arguments[1] as NewArrayExpression;
foreach (Expression ee in arr.Expressions)
{
object t = CodeDom.Eval(ee);
c.Type.TypeArguments.Add(CodeDom.GetTypeReference(t));
}
}
return c;
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.TypeOf")
{
var c = new CodeTypeOfExpression(
CodeDom.Eval<string>(methodCallExpression.Arguments[0]));
if (methodCallExpression.Arguments.Count == 2)
{
NewArrayExpression arr = methodCallExpression.Arguments[1] as NewArrayExpression;
foreach (Expression ee in arr.Expressions)
{
object t = CodeDom.Eval(ee);
c.Type.TypeArguments.Add(CodeDom.GetTypeReference(t));
}
}
return c;
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.get_nil")
{
return null;
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.Property")
{
CodeExpression targetExp = _Visit(methodCallExpression.Arguments[0]);
if (targetExp is CodePrimitiveExpression && ((CodePrimitiveExpression)targetExp).Value == null)
{
targetExp = null;
}
return new CodePropertyReferenceExpression(
targetExp,
CodeDom.Eval<string>(methodCallExpression.Arguments[1]));
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.Field")
{
object val = null;
try
{
val = CodeDom.Eval(methodCallExpression.Arguments[0]);
}
catch (Exception)
{
}
if (val != null && val is CodeTypeReference)
{
return new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression((CodeTypeReference)val),
CodeDom.Eval<string>(methodCallExpression.Arguments[1]));
}
else
{
CodeExpression targetExp = _Visit(methodCallExpression.Arguments[0]);
if (targetExp is CodePrimitiveExpression && ((CodePrimitiveExpression)targetExp).Value == null)
{
targetExp = null;
}
return new CodeFieldReferenceExpression(
targetExp,
CodeDom.Eval<string>(methodCallExpression.Arguments[1]));
}
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.Call")
{
if (methodCallExpression.Arguments.Count == 1)
{
return new CodeMethodInvokeExpression(
null,
CodeDom.Eval<string>(methodCallExpression.Arguments[0]));
}
else
{
CodeExpression targetExp = _Visit(methodCallExpression.Arguments[0]);
if (targetExp is CodePrimitiveExpression && ((CodePrimitiveExpression)targetExp).Value == null)
{
targetExp = null;
}
var m = new CodeMethodReferenceExpression(
targetExp,
CodeDom.Eval<string>(methodCallExpression.Arguments[1]));
if (methodCallExpression.Arguments.Count == 3)
{
foreach (Expression e in (methodCallExpression.Arguments[2] as NewArrayExpression).Expressions)
{
m.TypeArguments.Add(CodeDom.GetTypeReference(CodeDom.Eval(e)));
}
}
return new CodeMethodInvokeExpression(m);
}
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.new")
{
object t = CodeDom.Eval(methodCallExpression.Arguments[0]);
CodeTypeReference type = CodeDom.GetTypeReference(t);
if (methodCallExpression.Arguments.Count == 2)
{
NewArrayExpression arr = methodCallExpression.Arguments[1] as NewArrayExpression;
var exp = new CodeObjectCreateExpression(type);
foreach (Expression par in arr.Expressions)
{
AddParam(exp.Parameters, par);
}
return exp;
}
else
return new CodeObjectCreateExpression(type);
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.cast")
{
object t = CodeDom.Eval(methodCallExpression.Arguments[0]);
CodeTypeReference type = CodeDom.GetTypeReference(t);
if (methodCallExpression.Method.IsGenericMethod && methodCallExpression.Method.GetGenericArguments()[0] == typeof(Var))
{
return new CodeDom.CodeWrapExpression(new CodeCastExpression(type, _Visit(methodCallExpression.Arguments[1])));
}
else
return new CodeCastExpression(type, _Visit(methodCallExpression.Arguments[1]));
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.default")
{
object t = CodeDom.Eval(methodCallExpression.Arguments[0]);
CodeTypeReference type = CodeDom.GetTypeReference(t);
return new CodeDefaultValueExpression(type);
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.InjectExp")
{
int num = CodeDom.Eval<int>(methodCallExpression.Arguments[0]);
return _ctx.Injections[num];
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.Is")
{
return new CodeIdentityEqualityExpression(
true,
_Visit(methodCallExpression.Arguments[0]),
_Visit(methodCallExpression.Arguments[1])
);
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.IsNot")
{
return new CodeIdentityEqualityExpression(
false,
_Visit(methodCallExpression.Arguments[0]),
_Visit(methodCallExpression.Arguments[1])
);
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.Lambda")
{
if (methodCallExpression.Arguments[0].Type.IsArray)
{
List<LambdaParam> pars = new List<LambdaParam>();
foreach (LambdaParam lambdaParam in CodeDom.Eval<IEnumerable>(methodCallExpression.Arguments[0]))
{
pars.Add(lambdaParam);
}
List<CodeStatement> stmts = new List<CodeStatement>();
foreach (CodeStatement stmt in CodeDom.Eval<IEnumerable>(methodCallExpression.Arguments[1]))
{
stmts.Add(stmt);
}
return new CodeLambdaStatements(stmts, pars);
}
else
{
CodeExpression exp = _Visit(methodCallExpression.Arguments[0]);
List<LambdaParam> pars = new List<LambdaParam>();
if (methodCallExpression.Arguments.Count == 2)
{
NewArrayExpression arr = methodCallExpression.Arguments[1] as NewArrayExpression;
foreach (Expression par in arr.Expressions)
{
pars.Add(CodeDom.Eval<LambdaParam>(par));
}
}
return new CodeLambdaExpression(exp, pars);
}
}
else if (mr.MethodName == "LinqToCodedom.Generator.CodeDom.CallDelegate")
{
CodeExpression target = null;
if (methodCallExpression.Arguments[0].Type == typeof(string))
{
target = new CodeVariableReferenceExpression(CodeDom.Eval<string>(methodCallExpression.Arguments[0]));
}
else
{
target = _Visit(methodCallExpression.Arguments[0]);
}
var d = new CodeDelegateInvokeExpression(target);
return d;
}
}
var to = _Visit(methodCallExpression.Object);
if (to is CodeDom.CodeThisExpression || to is CodeDom.CodeBaseExpression || to is CodeDom.CodeVarExpression || to is CodeDom.CodeWrapExpression)
{
CodeExpression rto = to is CodeDom.CodeThisExpression ?
new CodeThisReferenceExpression() :
to is CodeDom.CodeBaseExpression ?
new CodeBaseReferenceExpression() :
to is CodeVariableReferenceExpression ?
to as CodeVariableReferenceExpression :
to;
switch (mr.MethodName)
{
case "Call":
//case "CallFunction":
if (methodCallExpression.Arguments.Count > 0)
{
var m = new CodeMethodReferenceExpression(
rto,
CodeDom.Eval<string>(methodCallExpression.Arguments[0]));
if (methodCallExpression.Arguments.Count == 2)
{
foreach (Expression e in (methodCallExpression.Arguments[1] as NewArrayExpression).Expressions)
{
m.TypeArguments.Add(CodeDom.GetTypeReference(CodeDom.Eval(e)));
}
}
return new CodeMethodInvokeExpression(m);
}
else
{
return new CodeDelegateInvokeExpression(rto);
}
case "Property":
string propertyName = CodeDom.Eval<string>(methodCallExpression.Arguments[0]);
if (methodCallExpression.Arguments.Count > 1)
throw new NotImplementedException();
return new CodeDom.CodeWrapExpression(new CodePropertyReferenceExpression(rto, propertyName));
//return new CodePropertyReferenceExpression(rto, propertyName);
case "Field":
string fieldName = CodeDom.Eval<string>(methodCallExpression.Arguments[0]);
if (methodCallExpression.Arguments.Count > 1)
throw new NotImplementedException();
return new CodeFieldReferenceExpression(rto, fieldName);
case "Raise":
string eventName = CodeDom.Eval<string>(methodCallExpression.Arguments[0]);
return new CodeDom.CodeDelegateArgsInvoke(
new CodeEventReferenceExpression(rto, eventName));
case "ArrayGet":
return new CodeArrayIndexerExpression(rto,
VisitExpressionList((methodCallExpression.Arguments[0] as NewArrayExpression).Expressions).ToArray()
);
case "JaggedArrayGet":
var n = methodCallExpression.Arguments[0] as NewArrayExpression;
CodeArrayIndexerExpression prev = null;
foreach (CodeExpression e in VisitExpressionList(n.Expressions.Reverse()))
{
if (prev == null)
prev = new CodeArrayIndexerExpression(rto, e);
else
prev = new CodeArrayIndexerExpression(prev, e);
}
return prev;
case "cast":
return rto;
default:
throw new NotImplementedException(mr.MethodName);
}
}
//else if (to is CodeDom.CodeArgsInvoke)
//{
// var c = to as CodeMethodInvokeExpression;
// c.Parameters.AddRange(VisitArguments(methodCallExpression.Arguments));
// //foreach (CodeExpression par in VisitSequence(
// // new QueryVisitor((e) => e is LambdaExpression)
// // .Visit(methodCallExpression.Arguments[0]) as LambdaExpression))
// //{
// // c.Parameters.Add(par);
// //}
// return c;
//}
//else if (to is CodeDom.CodeDelegateArgsInvoke)
//{
// var c = to as CodeDelegateInvokeExpression;
// c.Parameters.AddRange(VisitArguments(methodCallExpression.Arguments));
// //foreach (CodeExpression par in VisitSequence(
// // new QueryVisitor((e) => e is LambdaExpression)
// // .Visit(methodCallExpression.Arguments[0]) as LambdaExpression))
// //{
// // c.Parameters.Add(par);
// //}
// return c;
//}
else
{
if ((methodCallExpression.Object != null && methodCallExpression.Object.Type.IsArray &&
mr.MethodName == "Get") ||
(mr.MethodName == "get_Item" && methodCallExpression.Method.IsSpecialName))
{
var c = new CodeArrayIndexerExpression();
foreach (var par in methodCallExpression.Arguments)
{
AddParam(c.Indices, par);
}
c.TargetObject = to;
return c;
}
else
{
var c = new CodeMethodInvokeExpression(mr);
foreach (var par in methodCallExpression.Arguments)
{
AddParam(c.Parameters, par);
}
c.Method.TargetObject = to;
return c;
}
}
}
/// <include file='doc\CSharpCodeProvider.uex' path='docs/doc[@for="CSharpCodeGenerator.GenerateDelegateInvokeExpression"]/*' />
/// <devdoc>
/// <para>
/// Generates code for the specified CodeDom based delegate invoke
/// expression representation.
/// </para>
/// </devdoc>
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e) {
if (e.TargetObject != null) {
GenerateExpression(e.TargetObject);
}
Output.Write("(");
OutputExpressionList(e.Parameters);
Output.Write(")");
}
/// <devdoc>
/// <para>
/// Generates code for the specified CodeDom based delegate invoke
/// expression.
/// </para>
/// </devdoc>
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e) {
if (e.TargetObject != null) {
if (e.TargetObject is CodeEventReferenceExpression) {
Output.Write("RaiseEvent ");
GenerateFormalEventReferenceExpression((CodeEventReferenceExpression)e.TargetObject);
}
else {
GenerateExpression(e.TargetObject);
}
}
CodeExpressionCollection parameters = e.Parameters;
if (parameters.Count > 0) {
Output.Write("(");
OutputExpressionList(e.Parameters);
Output.Write(")");
}
}
private CodeStmtPair MakeWriteFieldStatements(Type type,
CodeExpression objExpr,
FieldInfo finfo,
CodeVariableReferenceExpression[] indexExprs)
{
CodeExpression writerExpr = new CodeArgumentReferenceExpression("writer");
CodeExpression fieldExpr;
if (finfo == null)
{
fieldExpr = new CodeArrayIndexerExpression(objExpr, indexExprs);
}
else
{
string fieldName = TypeSystem.FieldName(finfo.Name);
if (finfo.IsPublic ||
(TypeSystem.IsBackingField(finfo.Name) &&
finfo.DeclaringType.GetProperty(fieldName, FieldFlags).GetGetMethod() != null))
{
fieldExpr = new CodeFieldReferenceExpression(objExpr, fieldName);
}
else
{
CodeExpression getterExpr = new CodeVariableReferenceExpression(
ExtensionClassName + "." + this.GetterFieldName(finfo));
if (finfo.DeclaringType.IsValueType)
{
objExpr = new CodeDirectionExpression(FieldDirection.Out, objExpr);
}
fieldExpr = new CodeDelegateInvokeExpression(getterExpr, objExpr);
}
}
CodeExpression writeCall;
if (GetBuiltinReaderName(type) == null)
{
// for non-builtin types
string serializerName = GetStaticSerializerName(type);
CodeVariableReferenceExpression serializerExpr = new CodeVariableReferenceExpression(serializerName);
writeCall = new CodeMethodInvokeExpression(serializerExpr, "Write", writerExpr, fieldExpr);
}
else
{
// for builtin types
writeCall = new CodeMethodInvokeExpression(writerExpr, "Write", fieldExpr);
}
CodeStatement stmt1 = new CodeExpressionStatement(writeCall);
if (type.IsValueType)
{
return new CodeStmtPair(null, new CodeStatement[] { stmt1 });
}
else if (finfo == null)
{
if (StaticConfig.AllowNullArrayElements)
{
string bvIndexString = indexExprs[0].VariableName;
for (int i = 1; i < indexExprs.Length; i++)
{
bvIndexString += "*" + indexExprs[i].VariableName;
}
CodeExpression bvIndex = new CodeSnippetExpression(bvIndexString);
CodeExpression nullExpr = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("Object"),
"ReferenceEquals",
fieldExpr,
NullExpr);
CodeExpression bvExpr = new CodeArgumentReferenceExpression("bv");
CodeStatement stmt0 = new CodeExpressionStatement(
new CodeMethodInvokeExpression(bvExpr, "Set", bvIndex));
stmt0 = new CodeConditionStatement(nullExpr, stmt0);
CodeExpression notNullExpr = new CodeBinaryOperatorExpression(
new CodeIndexerExpression(bvExpr, bvIndex),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false));
stmt1 = new CodeConditionStatement(notNullExpr, stmt1);
return new CodeStmtPair(new CodeStatement[] { stmt0 }, new CodeStatement[] { stmt1 });
}
else
{
return new CodeStmtPair(null, new CodeStatement[] { stmt1 });
}
}
else
{
CodeExpression nullExpr = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("Object"),
"ReferenceEquals",
fieldExpr,
NullExpr);
if (AttributeSystem.FieldCanBeNull(finfo))
{
CodeExpression bvExpr = new CodeArgumentReferenceExpression("bv");
CodeStatement stmt0 = new CodeExpressionStatement(
new CodeMethodInvokeExpression(bvExpr, "Set", indexExprs[0]));
stmt0 = new CodeConditionStatement(nullExpr, stmt0);
CodeExpression notNullExpr = new CodeBinaryOperatorExpression(
new CodeIndexerExpression(bvExpr, indexExprs[0]),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false));
stmt1 = new CodeConditionStatement(notNullExpr, stmt1);
return new CodeStmtPair(new CodeStatement[] { stmt0 }, new CodeStatement[] { stmt1 });
}
else
{
// YY: For now we always check null
string msg = "Field " + finfo.DeclaringType.Name + "." + finfo.Name + " is null.";
CodeExpression msgExpr = new CodePrimitiveExpression(msg);
CodeExpression throwExpr = new CodeObjectCreateExpression(typeof(ArgumentNullException), msgExpr);
CodeStatement stmt0 = new CodeConditionStatement(nullExpr, new CodeThrowExceptionStatement(throwExpr));
return new CodeStmtPair(null, new CodeStatement[] { stmt0, stmt1 });
}
}
}
public void Generate(CodeDelegateInvokeExpression expression)
{
Generate(expression.TargetObject);
Write(".Invoke");
if (expression.Parameters.Count > 0)
{
Write("(");
for (int i = 0; i < expression.Parameters.Count; i++)
{
Generate(expression.Parameters[i]);
if (i != expression.Parameters.Count - 1)
Write(", ");
}
Write(")");
}
}
public void Visit (CodeDelegateInvokeExpression o)
{
g.GenerateDelegateInvokeExpression (o);
}
private void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
if (e.TargetObject != null)
{
GenerateExpression(e.TargetObject);
}
Output.Write('(');
OutputExpressionList(e.Parameters);
Output.Write(')');
}
protected override void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression expression)
{
CodeEventReferenceExpression ev = expression.TargetObject as CodeEventReferenceExpression;
if (ev != null) {
Output.Write ("RaiseEvent ");
if (ev.TargetObject != null && !(ev.TargetObject is CodeThisReferenceExpression)) {
GenerateExpression (ev.TargetObject);
Output.Write (".");
}
Output.Write (ev.EventName);
} else if (expression.TargetObject != null) {
GenerateExpression (expression.TargetObject);
}
Output.Write ('(');
OutputExpressionList (expression.Parameters);
Output.Write (')');
}
private void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
if (e.TargetObject != null)
{
this.GenerateExpression(e.TargetObject);
}
this.Output.Write("(");
this.OutputExpressionList(e.Parameters);
this.Output.Write(")");
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
if (e.TargetObject != null)
{
if (e.TargetObject is CodeEventReferenceExpression)
{
base.Output.Write("RaiseEvent ");
this.GenerateFormalEventReferenceExpression((CodeEventReferenceExpression)e.TargetObject);
}
else
{
base.GenerateExpression(e.TargetObject);
}
}
if (e.Parameters.Count > 0)
{
base.Output.Write("(");
this.OutputExpressionList(e.Parameters);
base.Output.Write(")");
}
}
/// <summary>
/// Generates code for the specified delegate invoke expression.
/// </summary>
/// <remarks><c>TARGETOBJECT->Invoke(PARAMETERS)</c></remarks>
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
OutputInvocation(new CodeMethodReferenceExpression(e.TargetObject, SpecialWords.Invoke), e.Parameters);
}
/// <summary>
/// Creates the property changed method.
/// </summary>
/// <returns>CodeMemberMethod on Property Change handler</returns>
/// <remarks>
/// <code>
/// protected virtual void OnPropertyChanged(string info) {
/// PropertyChangedEventHandler handler = PropertyChanged;
/// if (handler != null) {
/// handler(this, new PropertyChangedEventArgs(info));
/// }
/// }
/// </code>
/// </remarks>
internal static CodeMemberMethod CreatePropertyChangedMethod()
{
const string paramName = "propertyName";
const string variableName = "handler";
var propertyChangedMethod = new CodeMemberMethod
{
Name = "OnPropertyChanged",
Attributes = MemberAttributes.Public
};
propertyChangedMethod.Parameters.Add(new CodeParameterDeclarationExpression(
new CodeTypeReference(typeof(String)), paramName));
if (GeneratorContext.GeneratorParams.TrackingChanges.Enabled && GeneratorContext.GeneratorParams.Language == GenerationLanguage.CSharp)
{
propertyChangedMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "value"));
// this.ChangeTracker.RecordCurrentValue(info, value);
var changeTrackerParams = new CodeExpression[] { new CodeArgumentReferenceExpression(paramName), new CodeArgumentReferenceExpression(("value")) };
var changeTrackerInvokeExpression = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "ChangeTracker.RecordCurrentValue"), changeTrackerParams);
propertyChangedMethod.Statements.Add(changeTrackerInvokeExpression);
}
//Declare temp variable holding the event
var vardec = new CodeVariableDeclarationStatement(
new CodeTypeReference(typeof(PropertyChangedEventHandler)), variableName);
vardec.InitExpression = new CodeEventReferenceExpression(
new CodeThisReferenceExpression(), "PropertyChanged");
propertyChangedMethod.Statements.Add(vardec);
//The part of the true, create the event and invoke it
//var createArgs = new CodeObjectCreateExpression(
// new CodeTypeReference(typeof(PropertyChangedEventArgs)),
// new CodeArgumentReferenceExpression(paramName));
var createArgs = CodeDomHelper.CreateInstance(typeof(PropertyChangedEventArgs), paramName);
var raiseEvent = new CodeDelegateInvokeExpression(
new CodeVariableReferenceExpression(variableName),
new CodeThisReferenceExpression(), createArgs);
//The Condition
CodeExpression condition = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(variableName),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
//The if condition
var ifTempIsNull = new CodeConditionStatement();
ifTempIsNull.Condition = condition;
ifTempIsNull.TrueStatements.Add(raiseEvent);
propertyChangedMethod.Statements.Add(ifTempIsNull);
return propertyChangedMethod;
}
static void ImplementType(CodeCompileUnit unit, Type t, bool isAbstract)
{
var nspace = new CodeNamespace(t.Namespace + ".Generated");
nspace.Imports.Add(new CodeNamespaceImport("System"));
var type = new CodeTypeDeclaration(t.Name);
type.IsClass = true;
type.TypeAttributes = TypeAttributes.Public;
type.BaseTypes.Add(t);
var ctors = t.GetConstructors();
foreach (var ctor in ctors)
{
var args = ctor.GetParameters();
var _ctor = new CodeConstructor();
_ctor.Attributes = MemberAttributes.Public;
_ctor.Parameters.AddRange(args.Select(a => new CodeParameterDeclarationExpression(a.ParameterType, a.Name)).ToArray());
_ctor.BaseConstructorArgs.AddRange(args.Select(a => new CodeVariableReferenceExpression(a.Name)).ToArray());
type.Members.Add(_ctor);
}
var props = t.GetProperties();
Func<PropertyInfo, bool> lazyFilter = null;
Func<PropertyInfo, bool> InpcFilter = null;
if (isAbstract)
{
lazyFilter = p => (p.GetMethod != null && p.SetMethod == null && p.GetMethod.IsAbstract);
InpcFilter = p => (p.GetMethod != null && p.SetMethod != null && p.GetMethod.IsAbstract && p.SetMethod.IsAbstract);
}
else
{
lazyFilter = p => p.GetMethod != null && p.SetMethod == null;
InpcFilter = p => p.GetMethod != null && p.SetMethod != null;
}
var lazy = props.Where(lazyFilter);
var inpc = props.Where(InpcFilter).ToArray();
foreach (var p in lazy)
{
ImplementProperty(type, p, isAbstract, isLazy: true);
}
if (inpc.Any())
{
type.BaseTypes.Add(typeof(INotifyPropertyChanged));
CodeMemberEvent PropertyChangedEvent = new CodeMemberEvent();
PropertyChangedEvent.Name = "PropertyChanged";
PropertyChangedEvent.Type = new CodeTypeReference(typeof(PropertyChangedEventHandler));
PropertyChangedEvent.Attributes = MemberAttributes.Public;
type.Members.Add(PropertyChangedEvent);
CodeMemberMethod OnPropertyChanged = new CodeMemberMethod();
OnPropertyChanged.Name = "OnPropertyChanged";
OnPropertyChanged.Attributes = MemberAttributes.Family;
OnPropertyChanged.Parameters.Add(new CodeParameterDeclarationExpression(
new CodeTypeReference(typeof(String)), "Property"));
//Declare temp variable holding the event
CodeVariableDeclarationStatement vardec = new CodeVariableDeclarationStatement(
new CodeTypeReference(typeof(PropertyChangedEventHandler)), "temp");
vardec.InitExpression = new CodeEventReferenceExpression(
new CodeThisReferenceExpression(), "PropertyChanged");
OnPropertyChanged.Statements.Add(vardec);
//The part of the true, create the event and invoke it
CodeObjectCreateExpression createArgs = new CodeObjectCreateExpression(
new CodeTypeReference(typeof(PropertyChangedEventArgs)),
new CodeArgumentReferenceExpression("Property"));
CodeDelegateInvokeExpression raiseEvent = new CodeDelegateInvokeExpression(
new CodeVariableReferenceExpression("temp"),
new CodeThisReferenceExpression(), createArgs);
//The conditino
CodeExpression condition = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("temp"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
//The if condition
CodeConditionStatement ifTempIsNull = new CodeConditionStatement();
ifTempIsNull.Condition = condition;
ifTempIsNull.TrueStatements.Add(raiseEvent);
OnPropertyChanged.Statements.Add(ifTempIsNull);
type.Members.Add(OnPropertyChanged);
foreach (var p in inpc)
ImplementProperty(type, p, isAbstract, isLazy: false);
}
nspace.Types.Add(type);
unit.Namespaces.Add(nspace);
}
