partial void OnWriteEventStarting(CodeTypeDeclaration feederCode, EventType evt)
{
WriteCodeTypeDelegate(feederCode, evt);
//formats param of events that have the save name as the event ID
//(fasten design and to generate code: EventIDEventArgs automatically)
formatParametersShortcuts(evt);
var _eventFeederMethod = new CodeMemberMethod( );
writeRegionStart(evt, _eventFeederMethod);
#region Event Caller
string __methodEventName = evt.id + "Event";
_eventFeederMethod.Attributes = MemberAttributes.Final;
_eventFeederMethod.Name = evt.id;
_eventFeederMethod.Attributes = _eventFeederMethod.Attributes | MemberAttributes.Public;
feederCode.Members.Add(_eventFeederMethod);
#endregion
//---- PARTIAL----------CodeMemberMethod----------------------
#region Partials after/before
// Create partial statement
string partialPostInvokerName = StateStore.onPostEventPrefix + evt.id;
string partialPreInvokerName = StateStore.onPreEventPrefix + evt.id;
var _partialOnPost_declaration = new CodeMemberMethod( );
feederCode.Members.Add(_partialOnPost_declaration);
var _partialOnPre_declaration = new CodeMemberMethod( );
feederCode.Members.Add(_partialOnPre_declaration);
#region region end
var regionpartiolInvokerEND = new CodeRegionDirective( )
{
RegionMode = CodeRegionMode.End,
RegionText = evt.id
};
_partialOnPre_declaration
.EndDirectives.Add(regionpartiolInvokerEND);
#endregion
_partialOnPost_declaration.Name = partialPostInvokerName;
_partialOnPost_declaration.Attributes = MemberAttributes.Public;
_partialOnPost_declaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPost_declaration.ReturnType = new CodeTypeReference("partial void");
_partialOnPost_declaration.Comments.Add(new CodeCommentStatement("Extension method for " + evt.id));
_partialOnPre_declaration.Name = partialPreInvokerName;
_partialOnPre_declaration.Attributes = MemberAttributes.Public;
_partialOnPre_declaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPre_declaration.ReturnType = new CodeTypeReference("partial void");
#endregion
#region Comments lines
_eventFeederMethod.Comments.Add(
new CodeCommentStatement($"-------------{_eventFeederMethod .Name}------------"));
_eventFeederMethod.Comments.Add(
new CodeCommentStatement($"--------------------------------"));
#endregion
var context_eventInvoker
= new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(
Model.settings.context.instance),
evt.id);
CodeDelegateInvokeExpression _eventDelegateInvoker = null;
string _invokerParam = "";
//Declare the Event delegate
//example: public delegate void HookRetiredEventHandler(object sender, EventArgs e);
CodeTypeDelegate cd
= new CodeTypeDelegate(evt.name + "EventHandler");
#region Partial Method Invoker Declaration
var _partialOnPost_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression( ),
partialPostInvokerName);
var _partialOnPre_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression( ),
partialPreInvokerName);
#endregion
if (evt.parameter != null)
{
foreach (ParameterType param in evt.parameter)
{
#region Add Events Params to Declaration and invoker
_invokerParam = addEventsParamsTo(evt, _eventFeederMethod, _partialOnPost_declaration, _partialOnPre_declaration, context_eventInvoker, _partialOnPost_MethodInvoker, _partialOnPre_MethodInvoker, param);
#endregion
}
}
if (evt.parameter != null)
{
_eventDelegateInvoker = createEventInvoker(evt.id, true, _invokerParam);
}
else
{
_eventDelegateInvoker = createEventInvoker(evt.id, false);
}
//Extension OnPre
_eventFeederMethod.Statements.Add(_partialOnPre_MethodInvoker);
// Add StateCurrent.EvOpen(this);
_eventFeederMethod.Statements.Add(context_eventInvoker);
#region if delegate not null call event
/*I want:
* if (this.EventDELEGATE != null) this.EventDELEGATE(this,e);
*/
conditionallyInvokeOfEventDelegate(_eventFeederMethod, __methodEventName, _eventDelegateInvoker);
#endregion
//invoke the onPostPartial
_eventFeederMethod.Statements.Add(_partialOnPost_MethodInvoker);
SetMethodVisibility(_eventFeederMethod, evt);
}
/// <summary>
/// Generates the proxy class events.
/// </summary>
/// <param name="genClass">The generated class.</param>
/// <param name="constructor">The generated class constructor.</param>
/// <param name="interfaceType">Type of the interface.</param>
/// <param name="sourceType">Type of the source.</param>
static void GenerateProxyClassEvents(CodeTypeDeclaration genClass, CodeConstructor constructor, Type interfaceType, Type sourceType)
{
List <string> processed = new List <string>();
foreach (Type type in GetInterfaceTypes(interfaceType)) //zos
{
foreach (EventInfo eventInfo in type.GetEvents())
{
if (processed.Contains(eventInfo.Name))
{
continue;
}
processed.Add(eventInfo.Name);
// Event Definition
CodeMemberEvent genEvent = new CodeMemberEvent();
genEvent.Attributes = MemberAttributes.Public | MemberAttributes.Final;
genEvent.Name = eventInfo.Name;
genEvent.Type = new CodeTypeReference(eventInfo.EventHandlerType);
genClass.Members.Add(genEvent);
// Create event handler
CodeMemberMethod genMethod = new CodeMemberMethod();
genMethod.Name = "On" + eventInfo.Name;
genMethod.Attributes = MemberAttributes.Private | MemberAttributes.Final;
genMethod.ReturnType = new CodeTypeReference(typeof(void));
CodeDelegateInvokeExpression genEventDalegate = new CodeDelegateInvokeExpression(new CodeVariableReferenceExpression("eventDelegate"));
foreach (ParameterInfo paramInfo in eventInfo.EventHandlerType.GetMethod("Invoke").GetParameters())
{
FieldDirection dir = FieldDirection.In;
Type paramType;
if (paramInfo.ParameterType.IsByRef)
{
paramType = paramInfo.ParameterType.GetElementType();
if (paramInfo.IsOut)
{
dir = FieldDirection.Out;
}
else
{
dir = FieldDirection.Ref;
}
}
else
{
paramType = paramInfo.ParameterType;
}
genMethod.Parameters.Add(new CodeParameterDeclarationExpression(paramType, paramInfo.Name)
{
Direction = dir
});
if (paramInfo.ParameterType == typeof(object) && paramInfo.Name == "sender" && !paramInfo.ParameterType.IsByRef)
{
genEventDalegate.Parameters.Add(new CodeThisReferenceExpression());
}
else
{
genEventDalegate.Parameters.Add(new CodeDirectionExpression(dir, new CodeArgumentReferenceExpression(paramInfo.Name)));
}
}
genMethod.Statements.Add(new CodeVariableDeclarationStatement(eventInfo.EventHandlerType,
"eventDelegate",
new CodeVariableReferenceExpression(eventInfo.Name)));
genMethod.Statements.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("eventDelegate"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)
),
new CodeExpressionStatement(genEventDalegate)
));
genClass.Members.Add(genMethod);
// Subscribe to source event
constructor.Statements.Add(
new CodeAttachEventStatement(
new CodeEventReferenceExpression(
new CodeVariableReferenceExpression("_obj"),
eventInfo.Name),
new CodeMethodReferenceExpression(
new CodeThisReferenceExpression(),
genMethod.Name
)));
}
}
}
private static void PrintExpression(TextWriter output, CodeExpression expression)
{
if (expression is CodeMethodInvokeExpression)
{
CodeMethodInvokeExpression cmi = (CodeMethodInvokeExpression)expression;
if (cmi.Method.TargetObject == null)
{
output.Write("defaultscope");
}
else
{
PrintExpression(output, cmi.Method.TargetObject);
}
output.Write('.');
output.Write(cmi.Method.MethodName);
output.Write('(');
for (int i = 0; i < cmi.Parameters.Count; ++i)
{
if (i > 0)
{
output.Write(", ");
}
PrintExpression(output, cmi.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodeDelegateInvokeExpression)
{
CodeDelegateInvokeExpression die = (CodeDelegateInvokeExpression)expression;
output.Write("delegatecall(");
PrintExpression(output, die.TargetObject);
output.Write(')');
output.Write('(');
for (int i = 0; i < die.Parameters.Count; ++i)
{
if (i > 0)
{
output.Write(", ");
}
PrintExpression(output, die.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodePropertyReferenceExpression)
{
CodePropertyReferenceExpression cpre = (CodePropertyReferenceExpression)expression;
if (cpre.TargetObject == null)
{
output.Write("defaultscope");
}
else
{
PrintExpression(output, cpre.TargetObject);
}
output.Write('.');
output.Write(cpre.PropertyName);
return;
}
if (expression is CodeFieldReferenceExpression)
{
CodeFieldReferenceExpression cpre = (CodeFieldReferenceExpression)expression;
if (cpre.TargetObject == null)
{
output.Write("defaultscope");
}
else
{
PrintExpression(output, cpre.TargetObject);
}
output.Write('.');
output.Write(cpre.FieldName);
output.Write('$');
return;
}
if (expression is CodePrimitiveExpression)
{
object value = ((CodePrimitiveExpression)expression).Value;
if (value == null)
{
output.Write("null");
}
else if (value.Equals(true))
{
output.Write("true");
}
else if (value.Equals(false))
{
output.Write("false");
}
else if (value is string)
{
output.Write("'{0}'", value.ToString().Replace("'", "\\'"));
}
else
{
output.Write("{0}", value);
}
return;
}
if (expression is CodeThisReferenceExpression)
{
output.Write("this");
return;
}
if (expression is CodeBaseReferenceExpression)
{
output.Write("base");
return;
}
if (expression is CodeArgumentReferenceExpression)
{
output.Write("arg({0})", ((CodeArgumentReferenceExpression)expression).ParameterName);
return;
}
if (expression is CodeVariableReferenceExpression)
{
output.Write("var({0})", ((CodeVariableReferenceExpression)expression).VariableName);
return;
}
if (expression is CodeTypeReferenceExpression)
{
output.Write("typeref(");
CodeTypeReferenceExpression ctr = (CodeTypeReferenceExpression)expression;
PrintTypeReference(output, ctr.Type);
output.Write(')');
return;
}
if (expression is CodeCastExpression)
{
CodeCastExpression cce = expression as CodeCastExpression;
output.Write("cast(");
PrintTypeReference(output, cce.TargetType);
output.Write(", ");
PrintExpression(output, cce.Expression);
output.Write(')');
return;
}
if (expression is CodeTypeOfExpression)
{
CodeTypeOfExpression ctoe = (CodeTypeOfExpression)expression;
output.Write("typeof(");
PrintTypeReference(output, ctoe.Type);
output.Write(')');
return;
}
if (expression is CodeObjectCreateExpression)
{
CodeObjectCreateExpression coce = (CodeObjectCreateExpression)expression;
output.Write("new ");
PrintTypeReference(output, coce.CreateType);
output.Write('(');
for (int i = 0; i < coce.Parameters.Count; ++i)
{
if (i > 0)
{
output.Write(", ");
}
PrintExpression(output, coce.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodeArrayIndexerExpression)
{
CodeArrayIndexerExpression caie = (CodeArrayIndexerExpression)expression;
output.Write("arrayitem(");
PrintExpression(output, caie.TargetObject);
for (int i = 0; i < caie.Indices.Count; ++i)
{
output.Write(", ");
PrintExpression(output, caie.Indices[i]);
}
output.Write(')');
return;
}
if (expression is CodeArrayCreateExpression)
{
CodeArrayCreateExpression cace = (CodeArrayCreateExpression)expression;
output.Write("newarray(");
PrintTypeReference(output, cace.CreateType);
output.Write(',');
PrintExpression(output, cace.SizeExpression);
output.Write(')');
return;
}
if (expression is CodeBinaryOperatorExpression)
{
CodeBinaryOperatorExpression cboe = (CodeBinaryOperatorExpression)expression;
switch (cboe.Operator)
{
case CodeBinaryOperatorType.ValueEquality:
output.Write("equals");
break;
case CodeBinaryOperatorType.IdentityEquality:
output.Write("refequal");
break;
case CodeBinaryOperatorType.IdentityInequality:
output.Write("refnotequal");
break;
case CodeBinaryOperatorType.Add:
output.Write("add");
break;
default:
output.Write("UNKNOWN CBOE: {0}", cboe.Operator);
break;
}
output.Write('(');
PrintExpression(output, cboe.Left);
output.Write(", ");
PrintExpression(output, cboe.Right);
output.Write(')');
return;
}
if (expression is CodePropertySetValueReferenceExpression)
{
output.Write("setvalue");
return;
}
if (expression is CodeDirectionExpression)
{
switch (((CodeDirectionExpression)expression).Direction)
{
case FieldDirection.In:
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
break;
case FieldDirection.Out:
output.Write("out(");
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
output.Write(')');
break;
case FieldDirection.Ref:
output.Write("ref(");
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
output.Write(')');
break;
}
return;
}
output.Write("*** UNKNOWN EXPRESSION:" + expression.GetType() + " ***");
}
protected override void GenerateDelegateInvokeExpression
(CodeDelegateInvokeExpression e)
{
if(e.TargetObject != null)
{
GenerateExpression(e.TargetObject);
}
Output.Write("(");
OutputExpressionList(e.Parameters);
Output.Write(")");
}
protected abstract void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e);
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(CodeDelegateInvokeExpression e)
{
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression expression)
{
throw new NotSupportedException();
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu)
{
// GENERATES (C#):
//
// namespace NSPC {
// public class DelegateClass {
//
// public virtual int Sum(
// int val1,
// int val2,
// int val3,
// int val4,
// int val5,
// int val6,
// int val7,
// int val8,
// int val9,
// int val10,
// int val11,
// int val12,
// int val13,
// int val14,
// int val15,
// int val16,
// int val17,
// int val18,
// int val19,
// int val20) {
// int mySum = 0;
// mySum = (mySum + val1);
// mySum = (mySum + val2);
// mySum = (mySum + val3);
// mySum = (mySum + val4);
// mySum = (mySum + val5);
// mySum = (mySum + val6);
// mySum = (mySum + val7);
// mySum = (mySum + val8);
// mySum = (mySum + val9);
// mySum = (mySum + val10);
// mySum = (mySum + val11);
// mySum = (mySum + val12);
// mySum = (mySum + val13);
// mySum = (mySum + val14);
// mySum = (mySum + val15);
// mySum = (mySum + val16);
// mySum = (mySum + val17);
// mySum = (mySum + val18);
// mySum = (mySum + val19);
// mySum = (mySum + val20);
// return mySum;
// }
//
// public virtual int Do() {
// MyDelegate myDel = new DelegateClass.MyDelegate(this.Sum);
// return myDel(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765);
// }
// }
//
// public delegate int MyDelegate(
// int val1,
// int val2,
// int val3,
// int val4,
// int val5,
// int val6,
// int val7,
// int val8,
// int val9,
// int val10,
// int val11,
// int val12,
// int val13,
// int val14,
// int val15,
// int val16,
// int val17,
// int val18,
// int val19,
// int val20);
// }
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
// only produce code if the generator can declare delegates
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("DelegateClass");
class1.IsClass = true;
nspace.Types.Add (class1);
CodeTypeDelegate td = new CodeTypeDelegate ("MyDelegate");
td.ReturnType = new CodeTypeReference (typeof (Int32));
for (int i = 1; i <= 5; i++)
td.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (Int32)), "val" + i));
nspace.Types.Add (td);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "Sum";
cmm.ReturnType = new CodeTypeReference (typeof (Int32));
for (int i = 1; i <= 5; i++)
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (Int32)), "val" + i));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "mySum", new CodePrimitiveExpression (0)));
for (int i = 1; i <= 5; i++)
cmm.Statements.Add (CDHelper.CreateIncrementByStatement ("mySum", new CodeArgumentReferenceExpression ("val" + i)));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("mySum")));
class1.Members.Add (cmm);
#if !WHIDBEY
if (!(provider is VBCodeProvider)) {
#endif
AddScenario ("CheckDo", "Check Do()'s return value.");
cmm = new CodeMemberMethod ();
cmm.Name = "Do";
cmm.ReturnType = new CodeTypeReference (typeof (Int32));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("MyDelegate"), "myDel",
new CodeDelegateCreateExpression (new CodeTypeReference ("NSPC.MyDelegate"),
new CodeThisReferenceExpression (), "Sum")));
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression ();
delegateInvoke.TargetObject = new CodeVariableReferenceExpression ("myDel");
for (int i = 1; i <= 5; i++)
delegateInvoke.Parameters.Add (new CodePrimitiveExpression (fib (i)));
cmm.Statements.Add (new CodeMethodReturnStatement (delegateInvoke));
class1.Members.Add (cmm);
#if !WHIDBEY
}
#endif
}
}
/// <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);
}
protected void GenerateExpression(CodeExpression e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
CodeArgumentReferenceExpression argref = e as CodeArgumentReferenceExpression;
if (argref != null)
{
GenerateArgumentReferenceExpression(argref);
return;
}
CodeArrayCreateExpression mkarray = e as CodeArrayCreateExpression;
if (mkarray != null)
{
GenerateArrayCreateExpression(mkarray);
return;
}
CodeArrayIndexerExpression arrayidx = e as CodeArrayIndexerExpression;
if (arrayidx != null)
{
GenerateArrayIndexerExpression(arrayidx);
return;
}
CodeBaseReferenceExpression baseref = e as CodeBaseReferenceExpression;
if (baseref != null)
{
GenerateBaseReferenceExpression(baseref);
return;
}
CodeBinaryOperatorExpression binary = e as CodeBinaryOperatorExpression;
if (binary != null)
{
GenerateBinaryOperatorExpression(binary);
return;
}
CodeCastExpression cast = e as CodeCastExpression;
if (cast != null)
{
GenerateCastExpression(cast);
return;
}
CodeDelegateCreateExpression mkdel = e as CodeDelegateCreateExpression;
if (mkdel != null)
{
GenerateDelegateCreateExpression(mkdel);
return;
}
CodeDelegateInvokeExpression delinvoke = e as CodeDelegateInvokeExpression;
if (delinvoke != null)
{
GenerateDelegateInvokeExpression(delinvoke);
return;
}
CodeDirectionExpression direction = e as CodeDirectionExpression;
if (direction != null)
{
GenerateDirectionExpression(direction);
return;
}
CodeEventReferenceExpression eventref = e as CodeEventReferenceExpression;
if (eventref != null)
{
GenerateEventReferenceExpression(eventref);
return;
}
CodeFieldReferenceExpression fieldref = e as CodeFieldReferenceExpression;
if (fieldref != null)
{
GenerateFieldReferenceExpression(fieldref);
return;
}
CodeIndexerExpression idx = e as CodeIndexerExpression;
if (idx != null)
{
GenerateIndexerExpression(idx);
return;
}
CodeMethodInvokeExpression methodinv = e as CodeMethodInvokeExpression;
if (methodinv != null)
{
GenerateMethodInvokeExpression(methodinv);
return;
}
CodeMethodReferenceExpression methodref = e as CodeMethodReferenceExpression;
if (methodref != null)
{
GenerateMethodReferenceExpression(methodref);
return;
}
CodeObjectCreateExpression objref = e as CodeObjectCreateExpression;
if (objref != null)
{
GenerateObjectCreateExpression(objref);
return;
}
CodeParameterDeclarationExpression param = e as CodeParameterDeclarationExpression;
if (param != null)
{
GenerateParameterDeclarationExpression(param);
return;
}
CodePrimitiveExpression primitive = e as CodePrimitiveExpression;
if (primitive != null)
{
GeneratePrimitiveExpression(primitive);
return;
}
CodePropertyReferenceExpression propref = e as CodePropertyReferenceExpression;
if (propref != null)
{
GeneratePropertyReferenceExpression(propref);
return;
}
CodePropertySetValueReferenceExpression propset = e as CodePropertySetValueReferenceExpression;
if (propset != null)
{
GeneratePropertySetValueReferenceExpression(propset);
return;
}
CodeSnippetExpression snippet = e as CodeSnippetExpression;
if (snippet != null)
{
GenerateSnippetExpression(snippet);
return;
}
CodeThisReferenceExpression thisref = e as CodeThisReferenceExpression;
if (thisref != null)
{
GenerateThisReferenceExpression(thisref);
return;
}
CodeTypeOfExpression typeOf = e as CodeTypeOfExpression;
if (typeOf != null)
{
GenerateTypeOfExpression(typeOf);
return;
}
CodeTypeReferenceExpression typeref = e as CodeTypeReferenceExpression;
if (typeref != null)
{
GenerateTypeReferenceExpression(typeref);
return;
}
CodeVariableReferenceExpression varref = e as CodeVariableReferenceExpression;
if (varref != null)
{
GenerateVariableReferenceExpression(varref);
return;
}
throw new ArgumentException("Element type " + e + " is not supported.", "e");
}
// public void Print()
// {
// context.EvPrint();
// }
private void WriteEvent(CodeTypeDeclaration feederCode, EventType evt)
{
string __methodEventName = evt.id + "Event";
CodeMemberMethod _eventFeederMethod = new CodeMemberMethod();
feederCode.Members.Add(_eventFeederMethod);
_eventFeederMethod.Attributes = MemberAttributes.Final;
_eventFeederMethod.Name = evt.id;
_eventFeederMethod.Attributes = _eventFeederMethod.Attributes | MemberAttributes.Public;
//---- PARTIAL----------CodeMemberMethod----------------------
// Create partial statement
string partialPostInvokerName = "OnPost" + evt.id;
string partialPreInvokerName = "OnPre" + evt.id;
CodeMemberMethod _partialOnPost_MethodDeclaration = new CodeMemberMethod();
feederCode.Members.Add(_partialOnPost_MethodDeclaration);
CodeMemberMethod _partialOnPre_MethodDeclaration = new CodeMemberMethod();
feederCode.Members.Add(_partialOnPre_MethodDeclaration);
_partialOnPost_MethodDeclaration.Name = partialPostInvokerName;
_partialOnPost_MethodDeclaration.Attributes = MemberAttributes.Public;
_partialOnPost_MethodDeclaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPost_MethodDeclaration.ReturnType = new CodeTypeReference("partial void");
_partialOnPost_MethodDeclaration.Comments.Add(new CodeCommentStatement("Extension method for " + evt.id));
_partialOnPre_MethodDeclaration.Name = partialPreInvokerName;
_partialOnPre_MethodDeclaration.Attributes = MemberAttributes.Public;
_partialOnPre_MethodDeclaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPre_MethodDeclaration.ReturnType = new CodeTypeReference("partial void");
_eventFeederMethod.Comments.Add(
new CodeCommentStatement($"-------------{_eventFeederMethod.Name}------------"));
_eventFeederMethod.Comments.Add(
new CodeCommentStatement($"--------------------------------"));
CodeMethodInvokeExpression _contextMethodInvoker
= new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(
Model.settings.context.instance),
evt.id);
CodeDelegateInvokeExpression _eventDelegateInvoker = null;
string _invokerParam = "";
//Declare the Event delegate
//example: public delegate void HookRetiredEventHandler(object sender, EventArgs e);
CodeTypeDelegate cd
= new CodeTypeDelegate(evt.name + "EventHandler");
CodeMethodInvokeExpression _partialOnPost_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
partialPostInvokerName);
CodeMethodInvokeExpression _partialOnPre_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
partialPreInvokerName);
if (evt.parameter != null)
{
foreach (ParameterType param in evt.parameter)
{
//Deals with the shortcut of using the same event id as args
if (param.type == evt.id)
{
param.type = evt.id + "EventArgs";
}
_eventFeederMethod.Parameters.Add(new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name));
_contextMethodInvoker.Parameters.Add(new CodeVariableReferenceExpression(param.name));
_partialOnPost_MethodDeclaration.Parameters.Add(new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name));
_partialOnPost_MethodInvoker.Parameters.Add(new CodeVariableReferenceExpression(param.name));
_partialOnPre_MethodDeclaration.Parameters.Add(new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name));
_partialOnPre_MethodInvoker.Parameters.Add(new CodeVariableReferenceExpression(param.name));
//get the parameter name out of here
_invokerParam = param.name;
}
}
if (evt.parameter != null)
{
_eventDelegateInvoker = CreateEventInvoker(evt.id, true, _invokerParam);
}
else
{
_eventDelegateInvoker = CreateEventInvoker(evt.id, false);
}
//Extension OnPre
_eventFeederMethod.Statements.Add(_partialOnPre_MethodInvoker);
// Add StateCurrent.EvOpen(this);
_eventFeederMethod.Statements.Add(_contextMethodInvoker);
//todo ADd if not null invoke
_eventFeederMethod.Comments.Add(new CodeCommentStatement("todo Add if..."));
#region if delegate not null call event
/*I want:
* if (this.EventDELEGATE != null) this.EventDELEGATE(this,e);
*/
CodeSnippetExpression cex = new CodeSnippetExpression(__methodEventName + "!=null");
CodeExpression condition2
= new CodeBinaryOperatorExpression(
);
CodeStatement[] trueStatements2 = { new CodeCommentStatement("Do this if true") };
CodeConditionStatement ifStatement2 = new CodeConditionStatement(cex, trueStatements2);
ifStatement2.TrueStatements.Add(_eventDelegateInvoker);
_eventFeederMethod.Statements.Add(ifStatement2);
#endregion
// _eventFeederMethod.Statements.Add(_eventDelegateInvoker);
_eventFeederMethod.Statements.Add(_partialOnPost_MethodInvoker);
}
private void ValidateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
if (e.TargetObject != null)
{
ValidateExpression(e.TargetObject);
}
ValidateExpressionList(e.Parameters);
}
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);
}
internal static void conditionallyInvokeOfEventDelegate(CodeMemberMethod eventMethod, string __methodEventName, CodeDelegateInvokeExpression _eventDelegateInvoker)
{
//CodeSnippetExpression cex = new CodeSnippetExpression(__methodEventName + "!=null");
//CodeExpression condition2
// = new CodeBinaryOperatorExpression();
//CodeStatement[] trueStatements2 = { new CodeCommentStatement("Call subscriber if any") };
//CodeConditionStatement ifStatement2 = new CodeConditionStatement(cex, trueStatements2);
//ifStatement2.TrueStatements.Add(_eventDelegateInvoker);
//eventMethod.Statements.Add(ifStatement2);
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
Output.Write("delegateInvoke");
}
void OnWriteEventStartedOLD(CodeTypeDeclaration feederCode, EventType evt, CodeMemberMethod _eventFeederMethod)
{
// throw new NotSupportedException ( );
#region region start
var regionpartialInvokerStart = new CodeRegionDirective( )
{
RegionMode = CodeRegionMode.Start,
RegionText = evt.id
};
#endregion
__methodEventName = evt.id + "Event";
_eventFeederMethod.StartDirectives.Add(regionpartialInvokerStart);
#region 2
//---- PARTIAL----------CodeMemberMethod----------------------
// Create partial statement
partialPostInvokerName = StateStore.onPostEventPrefix + evt.id;
partialPreInvokerName = StateStore.onPreEventPrefix + evt.id;
var _partialOnPost_MethodDeclaration = new CodeMemberMethod( );
//_partialOnPost_MethodDeclaration.StartDirectives.Add(regionpartialInvokerStart);
feederCode.Members.Add(_partialOnPost_MethodDeclaration);
var _partialOnPre_MethodDeclaration = new CodeMemberMethod( );
feederCode.Members.Add(_partialOnPre_MethodDeclaration);
#region region end
var regionpartiolInvokerEND = new CodeRegionDirective( )
{
RegionMode = CodeRegionMode.End,
RegionText = evt.id
};
_partialOnPre_MethodDeclaration
.EndDirectives.Add(regionpartiolInvokerEND);
#endregion
_partialOnPost_MethodDeclaration.Name = partialPostInvokerName;
_partialOnPost_MethodDeclaration.Attributes = MemberAttributes.Public;
_partialOnPost_MethodDeclaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPost_MethodDeclaration.ReturnType = new CodeTypeReference("partial void");
_partialOnPost_MethodDeclaration.Comments.Add(new CodeCommentStatement("Extension method for " + evt.id));
_partialOnPre_MethodDeclaration.Name = partialPreInvokerName;
_partialOnPre_MethodDeclaration.Attributes = MemberAttributes.Public;
_partialOnPre_MethodDeclaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPre_MethodDeclaration.ReturnType = new CodeTypeReference("partial void");
_eventFeederMethod.Comments.Add(
new CodeCommentStatement($"-------------{_eventFeederMethod .Name}------------"));
_eventFeederMethod.Comments.Add(
new CodeCommentStatement($"--------------------------------"));
CodeMethodInvokeExpression _contextMethodInvoker
= new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(
Model.settings.context.instance),
evt.id);
CodeDelegateInvokeExpression _eventDelegateInvoker = null;
string _invokerParam = "";
//Declare the Event delegate
//example: public delegate void HookRetiredEventHandler(object sender, EventArgs e);
CodeTypeDelegate cd
= new CodeTypeDelegate(evt.name + "EventHandler");
CodeMethodInvokeExpression _partialOnPost_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression( ),
partialPostInvokerName);
CodeMethodInvokeExpression _partialOnPre_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression( ),
partialPreInvokerName);
#endregion
}
private static CodeMemberMethod CreateOperationCompletedMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeTypeDeclaration operationCompletedEventArgsType, CodeMemberEvent operationCompletedEvent)
{
CodeObjectCreateExpression expression;
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Private;
method.Name = NamingHelper.GetUniqueName(GetOperationCompletedMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), "state"));
method.ReturnType = new CodeTypeReference(voidType);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(invokeAsyncCompletedEventArgsTypeName, "e");
statement.InitExpression = new CodeCastExpression(invokeAsyncCompletedEventArgsTypeName, new CodeArgumentReferenceExpression(method.Parameters[0].Name));
CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression(statement.Name);
if (operationCompletedEventArgsType != null)
{
expression = new CodeObjectCreateExpression(operationCompletedEventArgsType.Name, new CodeExpression[] { new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[0]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[1]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[2]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[3]) });
}
else
{
expression = new CodeObjectCreateExpression(asyncCompletedEventArgsType, new CodeExpression[] { new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[1]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[2]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[3]) });
}
CodeEventReferenceExpression expression3 = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), operationCompletedEvent.Name);
CodeDelegateInvokeExpression expression4 = new CodeDelegateInvokeExpression(expression3, new CodeExpression[] { new CodeThisReferenceExpression(), expression });
CodeConditionStatement statement2 = new CodeConditionStatement(new CodeBinaryOperatorExpression(expression3, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)), new CodeStatement[] { statement, new CodeExpressionStatement(expression4) });
method.Statements.Add(statement2);
clientType.Members.Add(method);
return method;
}
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);
}
}
}
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 + "'");
}
public CodeDelegateInvokeExpressionExample()
{
//<Snippet2>
// Declares a type to contain the delegate and constructor method.
CodeTypeDeclaration type1 = new CodeTypeDeclaration("DelegateInvokeTest");
// Declares an event that accepts a custom delegate type of "TestDelegate".
CodeMemberEvent event1 = new CodeMemberEvent();
event1.Name = "TestEvent";
event1.Type = new CodeTypeReference("DelegateInvokeTest.TestDelegate");
type1.Members.Add(event1);
// Declares a delegate type called TestDelegate with an EventArgs parameter.
CodeTypeDelegate delegate1 = new CodeTypeDelegate("TestDelegate");
delegate1.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "sender"));
delegate1.Parameters.Add(new CodeParameterDeclarationExpression("System.EventArgs", "e"));
type1.Members.Add(delegate1);
// Declares a method that matches the "TestDelegate" method signature.
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "TestMethod";
method1.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "sender"));
method1.Parameters.Add(new CodeParameterDeclarationExpression("System.EventArgs", "e"));
type1.Members.Add(method1);
// Defines a constructor that attaches a TestDelegate delegate pointing to the TestMethod method
// to the TestEvent event.
CodeConstructor constructor1 = new CodeConstructor();
constructor1.Attributes = MemberAttributes.Public;
constructor1.Statements.Add(new CodeCommentStatement("Attaches a delegate to the TestEvent event."));
// Creates and attaches a delegate to the TestEvent.
CodeDelegateCreateExpression createDelegate1 = new CodeDelegateCreateExpression(
new CodeTypeReference("DelegateInvokeTest.TestDelegate"), new CodeThisReferenceExpression(), "TestMethod");
CodeAttachEventStatement attachStatement1 = new CodeAttachEventStatement(new CodeThisReferenceExpression(), "TestEvent", createDelegate1);
constructor1.Statements.Add(attachStatement1);
constructor1.Statements.Add(new CodeCommentStatement("Invokes the TestEvent event."));
// Invokes the TestEvent.
CodeDelegateInvokeExpression invoke1 = new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "TestEvent"),
new CodeExpression[] { new CodeThisReferenceExpression(), new CodeObjectCreateExpression("System.EventArgs") });
constructor1.Statements.Add(invoke1);
type1.Members.Add(constructor1);
// A C# code generator produces the following source code for the preceeding example code:
// public class DelegateInvokeTest
// {
//
// public DelegateInvokeTest()
// {
// // Attaches a delegate to the TestEvent event.
// this.TestEvent += new DelegateInvokeTest.TestDelegate(this.TestMethod);
// // Invokes the TestEvent event.
// this.TestEvent(this, new System.EventArgs());
// }
//
// private event DelegateInvokeTest.TestDelegate TestEvent;
//
// private void TestMethod(object sender, System.EventArgs e)
// {
// }
//
// public delegate void TestDelegate(object sender, System.EventArgs e);
// }
//</Snippet2>
}
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu)
{
// GENERATES (C#):
//
// namespace NSPC {
// public class DelegateClass {
//
// public virtual int Sum(
// int val1,
// int val2,
// int val3,
// int val4,
// int val5,
// int val6,
// int val7,
// int val8,
// int val9,
// int val10,
// int val11,
// int val12,
// int val13,
// int val14,
// int val15,
// int val16,
// int val17,
// int val18,
// int val19,
// int val20) {
// int mySum = 0;
// mySum = (mySum + val1);
// mySum = (mySum + val2);
// mySum = (mySum + val3);
// mySum = (mySum + val4);
// mySum = (mySum + val5);
// mySum = (mySum + val6);
// mySum = (mySum + val7);
// mySum = (mySum + val8);
// mySum = (mySum + val9);
// mySum = (mySum + val10);
// mySum = (mySum + val11);
// mySum = (mySum + val12);
// mySum = (mySum + val13);
// mySum = (mySum + val14);
// mySum = (mySum + val15);
// mySum = (mySum + val16);
// mySum = (mySum + val17);
// mySum = (mySum + val18);
// mySum = (mySum + val19);
// mySum = (mySum + val20);
// return mySum;
// }
//
// public virtual int Do() {
// MyDelegate myDel = new DelegateClass.MyDelegate(this.Sum);
// return myDel(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765);
// }
// }
//
// public delegate int MyDelegate(
// int val1,
// int val2,
// int val3,
// int val4,
// int val5,
// int val6,
// int val7,
// int val8,
// int val9,
// int val10,
// int val11,
// int val12,
// int val13,
// int val14,
// int val15,
// int val16,
// int val17,
// int val18,
// int val19,
// int val20);
// }
CodeNamespace nspace = new CodeNamespace("NSPC");
cu.Namespaces.Add(nspace);
// only produce code if the generator can declare delegates
if (Supports(provider, GeneratorSupport.DeclareDelegates))
{
CodeTypeDeclaration class1 = new CodeTypeDeclaration("DelegateClass");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeTypeDelegate td = new CodeTypeDelegate("MyDelegate");
td.ReturnType = new CodeTypeReference(typeof(Int32));
for (int i = 1; i <= 5; i++)
{
td.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Int32)), "val" + i));
}
nspace.Types.Add(td);
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "Sum";
cmm.ReturnType = new CodeTypeReference(typeof(Int32));
for (int i = 1; i <= 5; i++)
{
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Int32)), "val" + i));
}
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "mySum", new CodePrimitiveExpression(0)));
for (int i = 1; i <= 5; i++)
{
cmm.Statements.Add(CDHelper.CreateIncrementByStatement("mySum", new CodeArgumentReferenceExpression("val" + i)));
}
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("mySum")));
class1.Members.Add(cmm);
#if !WHIDBEY
if (!(provider is VBCodeProvider))
{
#endif
AddScenario("CheckDo", "Check Do()'s return value.");
cmm = new CodeMemberMethod();
cmm.Name = "Do";
cmm.ReturnType = new CodeTypeReference(typeof(Int32));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("MyDelegate"), "myDel",
new CodeDelegateCreateExpression(new CodeTypeReference("NSPC.MyDelegate"),
new CodeThisReferenceExpression(), "Sum")));
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression();
delegateInvoke.TargetObject = new CodeVariableReferenceExpression("myDel");
for (int i = 1; i <= 5; i++)
{
delegateInvoke.Parameters.Add(new CodePrimitiveExpression(fib(i)));
}
cmm.Statements.Add(new CodeMethodReturnStatement(delegateInvoke));
class1.Members.Add(cmm);
#if !WHIDBEY
}
#endif
}
}
public void Visit(CodeDelegateInvokeExpression o)
{
g.GenerateDelegateInvokeExpression(o);
}
private void WriteEvent(CodeTypeDeclaration contextCode, EventType evt, CodeMemberMethod eventMethod, bool asynchronous, CodeMethodInvokeExpression methodInvoke)
{
//todo cleanup old buspublish idea code...
#region Extension using the buspublish="true" to Event
//Suggestion : Add the BusName="MyBus" to the Xml
// eventMethod.Comments.Add(new CodeCommentStatement("Extending the Model with publishing Event to the BUS"));
//I want to publish the event to the bus if the
//if (evt.buspublishSpecified)
//{
//code with the ext
//string tstModelExtComments =
// "...EXTENDED Model Extension : " + evt.buspublish;
//eventMethod.Comments.Add(new CodeCommentStatement(tstModelExtComments));
//string n = "";
//if (evt.busname != null)
// if (evt.busname.Length > 0)
// {
// n = ", \"" + evt.busname + "\"";
// }
//if (Model .settings .buspublisherenabledSpecified)
//{
// string busSnip = "";
// //--------------------------------IBusPublisher--------------
// //TODO Consider 171127 Design with the IBusPublisher from the State context that the Feeded object will implement or refer to another object....
// busSnip = MakeBusPublishMethodCall2 ( evt );
// File .WriteAllText ( "bussnip.txt", busSnip );
// bool pubBus = false;
// if (evt .buspublish)
// pubBus = true;
// if (pubBus)
// eventMethod .Statements .Add (
// new CodeSnippetExpression
// ( busSnip ) );
//}
//}
//else
//{
// //code with the ext
// string tstModelExtComments =
// "Model NO Extension : " + evt.buspublish;
// eventMethod.Comments.Add(new CodeCommentStatement(tstModelExtComments));
//}
#endregion
#region region start
var regionpartialInvokerStart = new CodeRegionDirective( )
{
RegionMode = CodeRegionMode.Start,
RegionText = evt.id
};
#endregion
string __methodEventName = evt.id + "Event";
//---- PARTIAL----------CodeMemberMethod----------------------
// Create partial statement
string partialPostInvokerName = StateStore.onPostEventPrefix + evt.id;
string partialPreInvokerName = StateStore.onPreEventPrefix + evt.id;
#region Add Partial declaration
var _partialOnPost_MethodDeclaration = new CodeMemberMethod( );
contextCode.Members.Add(_partialOnPost_MethodDeclaration);
var _partialOnPre_MethodDeclaration = new CodeMemberMethod( );
contextCode.Members.Add(_partialOnPre_MethodDeclaration);
//---------------------------------- POST / PRE---------------
//Partial method Declaration POST / PRE
_partialOnPost_MethodDeclaration.Name = partialPostInvokerName;
_partialOnPost_MethodDeclaration.Attributes = MemberAttributes.Public;
_partialOnPost_MethodDeclaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPost_MethodDeclaration.ReturnType = new CodeTypeReference("partial void");
_partialOnPost_MethodDeclaration.Comments.Add(new CodeCommentStatement("Extension method for " + evt.id));
_partialOnPre_MethodDeclaration.Name = partialPreInvokerName;
_partialOnPre_MethodDeclaration.Attributes = MemberAttributes.Public;
_partialOnPre_MethodDeclaration.Attributes = MemberAttributes.ScopeMask;
_partialOnPre_MethodDeclaration.ReturnType = new CodeTypeReference("partial void");
#endregion
#region Event Delegate
CodeDelegateInvokeExpression _eventDelegateInvoker = null;
string _invokerParam = "";
//Declare the Event delegate
//example: public delegate void HookRetiredEventHandler(object sender, EventArgs e);
CodeTypeDelegate cd
= new CodeTypeDelegate(evt.name + "EventHandler");
CodeMethodInvokeExpression _partialOnPost_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression( ),
partialPostInvokerName);
CodeMethodInvokeExpression _partialOnPre_MethodInvoker
= new CodeMethodInvokeExpression(
new CodeThisReferenceExpression( ),
partialPreInvokerName);
#endregion
if (evt.parameter != null)
{
foreach (ParameterType param in evt.parameter)
{
//Deals with the shortcut of using the same event id as args
//if (param .type == evt .id) MOVED IN StateMachineXmlModel when model is created
//{
// param .type = evt .id + "EventArgs";
//}
eventMethod.Parameters.Add(new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name));
// _contextMethodInvoker.Parameters.Add(new CodeVariableReferenceExpression(param.name));
_partialOnPost_MethodDeclaration.Parameters.Add(new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name));
_partialOnPost_MethodInvoker.Parameters.Add(new CodeVariableReferenceExpression(param.name));
_partialOnPre_MethodDeclaration.Parameters.Add(new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name));
_partialOnPre_MethodInvoker.Parameters.Add(new CodeVariableReferenceExpression(param.name));
//get the parameter name out of here
_invokerParam = param.name;
}
}
if (evt.parameter != null)
{
_eventDelegateInvoker = WriteEventInvoker(evt.id, true, _invokerParam);
}
else
{
_eventDelegateInvoker = WriteEventInvoker(evt.id, false);
}
SetMethodVisibility(eventMethod, evt);
//Extension OnPre
eventMethod.Statements.Add(_partialOnPre_MethodInvoker);
//extension to Insert after the Partial Pre added
OnEventMethodPartialPreAdded(contextCode, evt, eventMethod, asynchronous, methodInvoke);
#region new 1711 bus code
// string feederPropName = GetPropertyName()
//todo add
// IBusPublisher __busPub= his .FeederProperty .BusPublisher;
//...into event context method if buspublish==true
//IBusPublisher __busPub = this .FeederProperty .BusPublisher;
#endregion
// Add StateCurrent.EvOpen(this);
// _eventFeederMethod.Statements.Add(_contextMethodInvoker);
//todo ADd if not null invoke
//_eventFeederMethod.Comments.Add(new CodeCommentStatement("todo Add if..."));
#region if delegate not null call event
/*I want:
* if (this.EventDELEGATE != null) this.EventDELEGATE(this,e);
*/
CodeSnippetExpression cex = new CodeSnippetExpression(__methodEventName + "!=null");
CodeExpression condition2
= new CodeBinaryOperatorExpression(
);
CodeStatement[] trueStatements2 = { new CodeCommentStatement("Do this if true") };
CodeConditionStatement ifStatement2 = new CodeConditionStatement(cex, trueStatements2);
ifStatement2.TrueStatements.Add(_eventDelegateInvoker);
// Add StateCurrent.EvOpen(this);
eventMethod.Statements.Add(methodInvoke);
eventMethod.Statements.Add(ifStatement2);
#endregion
// _eventFeederMethod.Statements.Add(_eventDelegateInvoker);
eventMethod.Statements.Add(_partialOnPost_MethodInvoker);
eventMethod.Comments.Add(
new CodeCommentStatement($"--------------------------------"));
}
protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
{
Output.Write("[CodeDelegateInvokeExpression: {0}]", e.ToString());
}
private void AddEvent(Project currentAssembly,
CodeTypeDeclaration proxyClass, CodeClass interopFormClass,
CodeEvent evt, CodeTypeDeclaration proxyClassEventSinkInterface)
{
CodeDelegate2 delegate1 = null;
try
{
delegate1 = (CodeDelegate2)currentAssembly.CodeModel.CodeTypeFromFullName(evt.Type.AsFullName);
}
catch (Exception exception2)
{
foreach (CodeElement element1 in evt.ProjectItem.FileCodeModel.CodeElements)
{
if (element1.IsCodeType)
{
CodeType type1 = (CodeType)element1;
foreach (CodeElement element2 in type1.Children)
{
if ((element2.Kind == vsCMElement.vsCMElementDelegate) &
(String.Compare(element2.FullName, evt.Type.AsFullName, false) == 0))
{
delegate1 = (CodeDelegate2)element2;
}
}
continue;
}
}
}
if (delegate1 == null)
{
this.DisplayWarning(string.Format(Resource.EventErrMsg, evt.Name, evt.Type.AsFullName));
}
else
{
CodeMemberMethod method1 = null;
foreach (CodeTypeMember member1 in proxyClass.Members)
{
if (String.Compare(member1.Name, "HookCustomEvents", false) == 0)
{
method1 = (CodeMemberMethod)member1;
}
}
if (method1 == null)
{
method1 = new CodeMemberMethod();
method1.Name = "HookCustomEvents";
method1.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method1.Statements.Add(this.GetStatementCastFormInstance(interopFormClass));
proxyClass.Members.Add(method1);
}
CodeMemberEvent event1 = new CodeMemberEvent();
event1.Attributes = MemberAttributes.Public;
event1.Type = new CodeTypeReference(evt.Type.AsFullName);
event1.Name = evt.Name;
CodeMemberMethod method3 = new CodeMemberMethod();
method3.Name = evt.Name;
CodeTypeDelegate delegate2 = new CodeTypeDelegate(evt.Name + "Handler");
bool flag1 = false;
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "castFormInstance_" + evt.Name;
CodeDelegateInvokeExpression expression1 = new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), event1.Name));
foreach (CodeParameter parameter1 in delegate1.Parameters)
{
CodeParameterDeclarationExpression expression2;
CodeArgumentReferenceExpression expression3;
CodeParameterDeclarationExpression expression4;
if ((parameter1.Type.CodeType != null) && this.IsEventArgs(parameter1.Type.CodeType))
{
if (!flag1)
{
proxyClass.Members.Add(delegate2);
event1.Type = new CodeTypeReference(delegate2.Name);
}
expression4 = new CodeParameterDeclarationExpression("System.EventArgs", parameter1.Name);
expression2 = new CodeParameterDeclarationExpression(parameter1.Type.AsFullName, parameter1.Name);
expression3 = new CodeArgumentReferenceExpression(expression4.Name);
event1.Comments.Add(new CodeCommentStatement(this.EVENT_ARGS_COMMENT));
method3.Comments.Add(new CodeCommentStatement(this.EVENT_ARGS_COMMENT));
}
else
{
if (!this.IsSupported(parameter1.Type))
{
this.DisplayWarning(String.Format(Resource.EventErrMsg2, parameter1.Type.AsFullName, evt.Name));
return;
}
expression4 = new CodeParameterDeclarationExpression(parameter1.Type.AsFullName, parameter1.Name);
expression2 = new CodeParameterDeclarationExpression(parameter1.Type.AsFullName, parameter1.Name);
expression3 = new CodeArgumentReferenceExpression(expression4.Name);
}
method3.Parameters.Add(expression4);
delegate2.Parameters.Add(expression4);
method2.Parameters.Add(expression2);
expression1.Parameters.Add(expression3);
}
method2.Statements.Add(expression1);
method1.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeVariableReferenceExpression("castFormInstance"), event1.Name), new CodeDelegateCreateExpression(event1.Type, new CodeThisReferenceExpression(), method2.Name)));
proxyClassEventSinkInterface.Members.Add(method3);
proxyClass.Members.Add(method2);
proxyClass.Members.Add(event1);
}
}
protected abstract void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e);
public static string GenerateWrapper(WrapperClass wrapperClass, Language language)
{
// Namespace
CodeNamespace _namespace = new CodeNamespace(wrapperClass.Namespace);
// Comments
string comment =
@"------------------------------------------------------------------------------" + Environment.NewLine +
@" <auto-generated>" + Environment.NewLine +
@" This code was generated by '.NET Wrapper Class Generator'" + Environment.NewLine +
@" Product Version:" + Assembly.GetExecutingAssembly().GetName().Version + Environment.NewLine + Environment.NewLine +
@" Changes to this file may cause incorrect behavior and will be lost if" + Environment.NewLine +
@" the code is regenerated." + Environment.NewLine +
@" </auto-generated>" + Environment.NewLine +
@" ------------------------------------------------------------------------------";
_namespace.Comments.Add(new CodeCommentStatement(comment));
// Class
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(wrapperClass.ClassName);
classDeclaration.IsPartial = wrapperClass.Partial;
if (wrapperClass.Sealed)
{
classDeclaration.TypeAttributes |= TypeAttributes.Sealed;
}
_namespace.Types.Add(classDeclaration);
// Initialization
CodeParameterDeclarationExpressionCollection initializationParameters = null;
CodeStatementCollection initiazationStatements = null;
if (wrapperClass.Partial)
{
// Initialization method
CodeMemberMethod initializer = new CodeMemberMethod();
classDeclaration.Members.Add(initializer);
initializer.Name = "InitializeWrapper";
initializer.Attributes = MemberAttributes.Private;
{
comment =
@"***************************************************************" + Environment.NewLine +
@" This method should be called by the user-provided constructor!" + Environment.NewLine +
@"***************************************************************";
initializer.Comments.Add(new CodeCommentStatement(comment));
}
initializationParameters = initializer.Parameters;
initiazationStatements = initializer.Statements;
}
else
{
// Constructor
CodeConstructor constructor = new CodeConstructor();
classDeclaration.Members.Add(constructor);
constructor.Attributes = MemberAttributes.Public;
initializationParameters = constructor.Parameters;
initiazationStatements = constructor.Statements;
}
// Iterate over the wrapped types
foreach (WrappedType wrappedType in wrapperClass.WrappedTypes)
{
// Fields
CodeMemberField field = new CodeMemberField(wrappedType.Type, wrappedType.FieldName);
if (wrappedType.Acquisition != Acquisition.UserManaged)
{
classDeclaration.Members.Add(field);
}
string memberPrefix = string.Empty;
if (wrappedType.PrefixMembers)
{
memberPrefix = wrappedType.FieldName;
memberPrefix = memberPrefix.Substring(0, 1).ToUpper() + memberPrefix.Substring(1);
}
CodeFieldReferenceExpression fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), wrappedType.FieldName);
if (wrappedType.Acquisition == Acquisition.Construct)
{
// Instantiation
CodeObjectCreateExpression instantiation = new CodeObjectCreateExpression(wrappedType.Type);
CodeAssignStatement instanceAssignment = new CodeAssignStatement(fieldReference, instantiation);
initiazationStatements.Add(instanceAssignment);
}
else if (wrappedType.Acquisition == Acquisition.Parameter)
{
// Pass as parameter
initializationParameters.Add(new CodeParameterDeclarationExpression(wrappedType.Type, wrappedType.FieldName));
initiazationStatements.Add(new CodeAssignStatement(fieldReference, new CodeVariableReferenceExpression(wrappedType.FieldName)));
}
else if (wrappedType.Acquisition == Acquisition.Property)
{
// Set as property
CodeMemberProperty property = new CodeMemberProperty();
property.Attributes = MemberAttributes.Public;
property.HasGet = property.HasSet = true;
property.Type = new CodeTypeReference(wrappedType.Type);
property.Name = wrappedType.Type.Name;
property.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
property.SetStatements.Add(new CodeAssignStatement(fieldReference, new CodeVariableReferenceExpression("value")));
classDeclaration.Members.Add(property);
}
// Methods
foreach (WrappedMethod wrappedMethod in wrappedType.WrappedMethods)
{
// Method
CodeMemberMethod method = new CodeMemberMethod();
classDeclaration.Members.Add(method);
method.Name = memberPrefix + wrappedMethod.Method.Name;
method.ReturnType = new CodeTypeReference(wrappedMethod.Method.ReturnType);
Generator.SetMember(method, wrappedMethod);
if (!string.IsNullOrEmpty(wrappedMethod.Interface))
{
method.PrivateImplementationType = new CodeTypeReference(wrappedMethod.Interface);
}
// Parameters
List <CodeExpression> arguments = Generator.SetParameters(method, wrappedMethod.Method.GetParameters());
// Statement
CodeMethodInvokeExpression invocation = null;
if (!wrappedMethod.Method.IsStatic)
{
invocation = new CodeMethodInvokeExpression(fieldReference, wrappedMethod.Method.Name, arguments.ToArray());
}
else
{
invocation = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(wrappedType.Type), wrappedMethod.Method.Name, arguments.ToArray());
method.Attributes |= MemberAttributes.Static;
}
if (wrappedMethod.Method.ReturnType == typeof(void))
{
method.Statements.Add(invocation);
}
else
{
method.Statements.Add(new CodeMethodReturnStatement(invocation));
}
}
// Properties
foreach (WrappedProperty wrappedProperty in wrappedType.WrappedProperties)
{
// Property
CodeMemberProperty property = new CodeMemberProperty();
classDeclaration.Members.Add(property);
property.Name = memberPrefix + wrappedProperty.Property.Name;
property.Type = new CodeTypeReference(wrappedProperty.Property.PropertyType);
Generator.SetMember(property, wrappedProperty);
if (!string.IsNullOrEmpty(wrappedProperty.Interface))
{
property.PrivateImplementationType = new CodeTypeReference(wrappedProperty.Interface);
}
CodePropertyReferenceExpression invocation = null;
if (true) // TODO: check if property is static
{
invocation = new CodePropertyReferenceExpression(fieldReference, wrappedProperty.Property.Name);
}
else
{
}
// Get statement
if (wrappedProperty.Get)
{
property.GetStatements.Add(new CodeMethodReturnStatement(invocation));
}
// Set statement
if (wrappedProperty.Set)
{
property.SetStatements.Add(new CodeAssignStatement(invocation, new CodeVariableReferenceExpression("value")));
}
}
// Events
foreach (WrappedEvent wrappedEvent in wrappedType.WrappedEvents)
{
// Event
MethodInfo eventDelegate = wrappedEvent.Event.EventHandlerType.GetMethod("Invoke");
CodeMemberEvent _event = new CodeMemberEvent();
classDeclaration.Members.Add(_event);
_event.Name = memberPrefix + wrappedEvent.Event.Name;
_event.Type = new CodeTypeReference(wrappedEvent.Event.EventHandlerType);
Generator.SetMember(_event, wrappedEvent);
if (!string.IsNullOrEmpty(wrappedEvent.Interface))
{
_event.PrivateImplementationType = new CodeTypeReference(wrappedEvent.Interface);
}
// Event handler/raiser
CodeMemberMethod eventHandler = new CodeMemberMethod();
classDeclaration.Members.Add(eventHandler);
eventHandler.Name = string.Format("On{0}", _event.Name);
eventHandler.ReturnType = new CodeTypeReference(eventDelegate.ReturnType);
eventHandler.Attributes = MemberAttributes.Private;
List <CodeExpression> arguments = Generator.SetParameters(eventHandler, eventDelegate.GetParameters());
CodeEventReferenceExpression eventReference = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), _event.Name);
CodeConditionStatement conditional = new CodeConditionStatement();
eventHandler.Statements.Add(conditional);
conditional.Condition = new CodeBinaryOperatorExpression(eventReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeDelegateInvokeExpression eventInvocation = new CodeDelegateInvokeExpression(eventReference, arguments.ToArray());
if (eventDelegate.ReturnType == typeof(void))
{
conditional.TrueStatements.Add(eventInvocation);
}
else
{
conditional.TrueStatements.Add(new CodeMethodReturnStatement(eventInvocation));
}
// Event registration
CodeEventReferenceExpression wrappedEventReference = new CodeEventReferenceExpression(fieldReference, wrappedEvent.Event.Name);
CodeMethodReferenceExpression eventRaiserReference = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), eventHandler.Name);
CodeAttachEventStatement eventRegistration = new CodeAttachEventStatement(wrappedEventReference, eventRaiserReference);
initiazationStatements.Add(eventRegistration);
}
}
// Generate the code
StringWriter stringWriter = new StringWriter();
CodeDomProvider codeProvider = null;
if (language == Language.CSharp)
{
codeProvider = new CSharpCodeProvider();
}
else if (language == Language.VBNet)
{
codeProvider = new VBCodeProvider();
}
else
{
throw new ArgumentException("Specified language is not supported: " + language);
}
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
codeProvider.GenerateCodeFromNamespace(_namespace, stringWriter, options);
return(stringWriter.ToString());
}
