public void Constructor1 ()
{
CodeTypeReference type1 = new CodeTypeReference ("mono1");
CodeExpression expression1 = new CodeExpression ();
CodeCastExpression cce = new CodeCastExpression (type1, expression1);
Assert.IsNotNull (cce.Expression, "#1");
Assert.AreSame (expression1, cce.Expression, "#2");
Assert.IsNotNull (cce.TargetType, "#3");
Assert.AreSame (type1, cce.TargetType, "#4");
cce.Expression = null;
Assert.IsNull (cce.Expression, "#5");
CodeExpression expression2 = new CodeExpression ();
cce.Expression = expression2;
Assert.IsNotNull (cce.Expression, "#6");
Assert.AreSame (expression2, cce.Expression, "#7");
cce.TargetType = null;
Assert.IsNotNull (cce.TargetType, "#8");
Assert.AreEqual (typeof (void).FullName, cce.TargetType.BaseType, "#9");
CodeTypeReference type2 = new CodeTypeReference ("mono2");
cce.TargetType = type2;
Assert.IsNotNull (cce.TargetType, "#10");
Assert.AreSame (type2, cce.TargetType, "#11");
cce = new CodeCastExpression ((CodeTypeReference) null, (CodeExpression) null);
Assert.IsNull (cce.Expression, "#12");
Assert.IsNotNull (cce.TargetType, "#13");
Assert.AreEqual (typeof (void).FullName, cce.TargetType.BaseType, "#14");
}
CodeMemberMethod CreateMethod()
{
CodeMemberMethod method = new CodeMemberMethod();
// BeginInit method call.
CodeExpressionStatement statement = new CodeExpressionStatement();
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
statement.Expression = methodInvoke;
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression();
methodRef.MethodName = "BeginInit";
CodeCastExpression cast = new CodeCastExpression();
cast.TargetType = new CodeTypeReference();
cast.TargetType.BaseType = "System.ComponentModel.ISupportInitialize";
CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression();
fieldRef.FieldName = "pictureBox1";
fieldRef.TargetObject = new CodeThisReferenceExpression();
cast.Expression = fieldRef;
methodRef.TargetObject = cast;
methodInvoke.Method = methodRef;
method.Statements.Add(statement);
return method;
}
protected CodeExpression ConvertTo(string value, Type type)
{
var valueExpression = new CodePrimitiveExpression(value);
var converter = TypeDescriptor.GetConverter(type);
if (type == typeof(string) || type == typeof(object))
return valueExpression;
if (type == typeof(double))
return new CodePrimitiveExpression(double.Parse(value, CultureInfo.InvariantCulture));
if (type == typeof(BindingBase))
{
var bindingParser = new BindingParser(State);
var bindingVariableName = bindingParser.Parse(value);
return new CodeVariableReferenceExpression(bindingVariableName);
}
// there is no conversion availabe, the generated code won't compile, but there is nothing we can do about that
if (converter == null)
return valueExpression;
var conversion = new CodeCastExpression(
type.Name,
new CodeMethodInvokeExpression(
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("TypeDescriptor"), "GetConverter",
new CodeTypeOfExpression(type.Name)), "ConvertFromInvariantString",
new CodePrimitiveExpression(value)));
return conversion;
}
private CodeStatement GenerateCallStatementC2J(GMethod method, CodeExpression invokeExpression)
{
CodeStatement call;
if (method.IsConstructor || method.IsVoid)
{
call = new CodeExpressionStatement(invokeExpression);
}
else
{
if (method.ReturnType.IsPrimitive)
{
if (method.ReturnType.JVMSubst != null)
{
invokeExpression = new CodeCastExpression(method.ReturnType.CLRReference, invokeExpression);
}
call = new CodeMethodReturnStatement(invokeExpression);
}
else
{
CodeMethodInvokeExpression conversionExpression = CreateConversionExpressionJ2CParam(method.ReturnType,
invokeExpression);
call = new CodeMethodReturnStatement(conversionExpression);
}
}
return call;
}
public void Constructor0_Deny_Unrestricted ()
{
CodeCastExpression cce = new CodeCastExpression ();
Assert.IsNull (cce.Expression, "Expression");
cce.Expression = new CodeExpression ();
Assert.AreEqual ("System.Void", cce.TargetType.BaseType, "TargetType.BaseType");
cce.TargetType = new CodeTypeReference ("System.Void");
}
public static CodeCastExpression Clone(this CodeCastExpression expression)
{
if (expression == null) return null;
CodeCastExpression e = new CodeCastExpression();
e.Expression = expression.Expression.Clone();
e.TargetType = expression.TargetType.Clone();
e.UserData.AddRange(expression.UserData);
return e;
}
protected override void GenerateCastExpression(System.CodeDom.CodeCastExpression e)
{
Output.Write("(");
OutputType(e.TargetType);
Output.Write("(");
GenerateExpression(e.Expression);
Output.Write("))");
//throw new Exception("The method or operation is not implemented.");
}
public void Constructor1_Deny_Unrestricted ()
{
CodeTypeReference target = new CodeTypeReference ("System.Int32");
CodeExpression expression = new CodeExpression ();
CodeCastExpression cce = new CodeCastExpression (target, expression);
Assert.AreSame (expression, cce.Expression, "Expression");
cce.Expression = new CodeExpression ();
Assert.AreEqual ("System.Int32", cce.TargetType.BaseType, "TargetType.BaseType");
cce.TargetType = new CodeTypeReference ("System.Void");
}
public TypescriptCastExpression(
IExpressionFactory expressionFactory,
CodeCastExpression codeExpression,
CodeGeneratorOptions options,
ITypescriptTypeMapper typescriptTypeMapper)
{
_expressionFactory = expressionFactory;
_codeExpression = codeExpression;
_options = options;
_typescriptTypeMapper = typescriptTypeMapper;
System.Diagnostics.Debug.WriteLine("TypescriptCastExpression Created");
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression = new CodePrimitiveExpression(value);
if (value == null
|| value is bool
|| value is char
|| value is int
|| value is float
|| value is double)
{
// work aroundf for J#, since they don't support auto-boxing of value types yet.
CodeDomProvider codeProvider = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
if (codeProvider != null && String.Equals(codeProvider.FileExtension, JSharpFileExtension))
{
// See if we are boxing - if so, insert a cast.
ExpressionContext cxt = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
//Debug.Assert(cxt != null, "No expression context on stack - J# boxing cast will not be inserted");
if (cxt != null)
{
if (cxt.ExpressionType == typeof(object))
{
expression = new CodeCastExpression(value.GetType(), expression);
expression.UserData.Add("CastIsBoxing", true);
}
}
}
return expression;
}
String stringValue = value as string;
if (stringValue != null)
{
// WinWS: The commented code breaks us when we have long strings
//if (stringValue.Length > 200)
//{
// return SerializeToResourceExpression(manager, stringValue);
//}
//else
return expression;
}
// generate a cast for non-int types because we won't parse them properly otherwise because we won't know to convert
// them to the narrow form.
//
return new CodeCastExpression(new CodeTypeReference(value.GetType()), expression);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression left = null;
using (CodeDomSerializerBase.TraceScope("EnumCodeDomSerializer::Serialize"))
{
Enum[] enumArray;
if (!(value is Enum))
{
return left;
}
bool flag = false;
TypeConverter converter = TypeDescriptor.GetConverter(value);
if ((converter != null) && converter.CanConvertTo(typeof(Enum[])))
{
enumArray = (Enum[]) converter.ConvertTo(value, typeof(Enum[]));
flag = enumArray.Length > 1;
}
else
{
enumArray = new Enum[] { (Enum) value };
flag = true;
}
CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(value.GetType());
TypeConverter converter2 = new EnumConverter(value.GetType());
foreach (Enum enum2 in enumArray)
{
string str = (converter2 != null) ? converter2.ConvertToString(enum2) : null;
CodeExpression right = !string.IsNullOrEmpty(str) ? new CodeFieldReferenceExpression(targetObject, str) : null;
if (right != null)
{
if (left == null)
{
left = right;
}
else
{
left = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BitwiseOr, right);
}
}
}
if ((left != null) && flag)
{
left = new CodeCastExpression(value.GetType(), left);
}
}
return left;
}
public void Visit(InsertIntoDirectoryStatement statement)
{
if (statement.Select.Args.Length != 2) //can only select one thing into a directory
{
Errors.Add(new OnlyTwoSelectParamForDirectory(new Semantic.LineInfo(statement.Line.Line, statement.Line.CharacterPosition)));
return;
}
var domArg = VisitChild(statement.Select);
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "InsertIntoDir_" + domArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
((Action)domArg.Tag)();
//needs to foreach around the returned table from select like the other inserts
method.Statements.Add(new CodeVariableDeclarationStatement(domArg.Scope.CodeDomReference,
"resultRows",
domArg.CodeExpression));
var cast = new CodeCastExpression(typeof(string),
new CodeIndexerExpression(new CodeIndexerExpression(new CodeVariableReferenceExpression("resultRows"),
new CodePrimitiveExpression(0)), new CodePrimitiveExpression(0)));
method.Statements.Add(new CodeVariableDeclarationStatement(typeof(string), "filename", cast));
cast = new CodeCastExpression(typeof(byte[]),
new CodeIndexerExpression(new CodeIndexerExpression(new CodeVariableReferenceExpression("resultRows"),
new CodePrimitiveExpression(0)), new CodePrimitiveExpression(1)));
method.Statements.Add(new CodeVariableDeclarationStatement(typeof(byte[]), "bytes", cast));
var directoryArgs = VisitChild(statement.Directory);
method.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("bytes"), "WriteFile",
directoryArgs.CodeExpression, new CodeVariableReferenceExpression("filename")));
_mainType.Type.Members.Add(method);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_codeStack.Peek().ParentStatements.Add(methodcall);
_codeStack.Peek().CodeExpression = methodcall;
}
protected internal override void CreateMethods ()
{
base.CreateMethods ();
Type type = parser.MasterType;
if (type != null) {
CodeMemberProperty mprop = new CodeMemberProperty ();
mprop.Name = "Master";
mprop.Type = new CodeTypeReference (parser.MasterType);
mprop.Attributes = MemberAttributes.Public | MemberAttributes.New;
CodeExpression prop = new CodePropertyReferenceExpression (new CodeBaseReferenceExpression (), "Master");
prop = new CodeCastExpression (parser.MasterType, prop);
mprop.GetStatements.Add (new CodeMethodReturnStatement (prop));
mainClass.Members.Add (mprop);
AddReferencedAssembly (type.Assembly);
}
}
public CodeTypeDeclaration ToClass()
{
var cs = new CodeTypeDeclaration(this.Name);
var iname = "I" + cs.Name;
if (cs.Name.Contains('`'))
{
cs.Name = cs.Name.Substring(0, cs.Name.Length - 2);
if (cs.Name.EndsWith("Base"))
{
iname = "I" + cs.Name.Substring(0, cs.Name.Length - 4);
}
cs.Name += "<T>";
}
if (iname != null)
{
cs.BaseTypes.Add(new CodeTypeReference(iname));
}
cs.IsPartial = true;
foreach (var p in Properties)
{
if (p.IsInherited) continue;
var prop = new CodeMemberProperty();
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Name = p.Name;
prop.Type = new CodeTypeReference(p.Type);
prop.HasGet = true;
prop.HasSet = false;
var indexer = new CodeIndexerExpression(new CodeThisReferenceExpression(), new CodePrimitiveExpression(p.Name));
var cast = new CodeCastExpression(prop.Type, indexer);
prop.GetStatements.Add(new CodeMethodReturnStatement(cast));
cs.Members.Add(prop);
}
return cs;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression = new CodePrimitiveExpression(value);
if ((((value == null) || (value is bool)) || ((value is char) || (value is int))) || ((value is float) || (value is double)))
{
CodeDomProvider service = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
if ((service != null) && string.Equals(service.FileExtension, JSharpFileExtension))
{
ExpressionContext context = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if ((context != null) && (context.ExpressionType == typeof(object)))
{
expression = new CodeCastExpression(value.GetType(), expression);
expression.UserData.Add("CastIsBoxing", true);
}
}
return expression;
}
if (value is string)
{
return expression;
}
return new CodeCastExpression(new CodeTypeReference(value.GetType()), expression);
}
public void Constructor0 ()
{
CodeCastExpression cce = new CodeCastExpression ();
Assert.IsNull (cce.Expression, "#1");
Assert.IsNotNull (cce.TargetType, "#2");
Assert.AreEqual (typeof (void).FullName, cce.TargetType.BaseType, "#3");
CodeExpression expression = new CodeExpression ();
cce.Expression = expression;
Assert.IsNotNull (cce.Expression, "#4");
Assert.AreSame (expression, cce.Expression, "#5");
cce.Expression = null;
Assert.IsNull (cce.Expression, "#6");
CodeTypeReference type = new CodeTypeReference ("mono");
cce.TargetType = type;
Assert.IsNotNull (cce.TargetType, "#7");
Assert.AreSame (type, cce.TargetType, "#8");
cce.TargetType = null;
Assert.IsNotNull (cce.TargetType, "#9");
Assert.AreEqual (typeof (void).FullName, cce.TargetType.BaseType, "#10");
}
protected override void GenerateCastExpression(CodeCastExpression e)
{
Output.Write("[CodeCastExpression: {0}]", e.ToString());
}
/// <summary>
/// Creates a new body in stlye of an Ado.net Constructor and attaches it to the <paramref name="target"/>
/// </summary>
/// <param name="properties"></param>
/// <param name="settings"></param>
/// <param name="importNameSpace"></param>
/// <param name="container"></param>
/// <param name="target"></param>
public static void GenerateBody(Dictionary<string, DbPropertyInfoCache> properties,
FactoryHelperSettings settings,
CodeNamespace importNameSpace,
CodeMemberMethod container,
CodeExpression target)
{
foreach (var propertyInfoCache in properties.Values)
{
propertyInfoCache.Refresh();
var columnName = propertyInfoCache.DbName;
if (settings.EnforcePublicPropertys)
{
if (propertyInfoCache.Getter.MethodInfo.IsPrivate)
throw new AccessViolationException(string.Format(
"The Getter of {0} is private. Full creation cannot be enforced", propertyInfoCache.PropertyName));
if (propertyInfoCache.Setter.MethodInfo.IsPrivate)
throw new AccessViolationException(string.Format(
"The Setter of {0} is private. Full creation cannot be enforced", propertyInfoCache.PropertyName));
}
var codeIndexerExpression = new CodeIndexerExpression(new CodeVariableReferenceExpression("record"),
new CodePrimitiveExpression(columnName));
var variableName = columnName.ToLower();
CodeVariableDeclarationStatement bufferVariable = null;
//var propertyRef = new CodeVariableReferenceExpression(propertyInfoCache.PropertyName);
var refToProperty = new CodeFieldReferenceExpression(target, propertyInfoCache.PropertyName);
var attributes = propertyInfoCache.Attributes;
var valueConverterAttributeModel =
attributes.FirstOrDefault(s => s.Attribute is ValueConverterAttribute);
var isXmlProperty = attributes.FirstOrDefault(s => s.Attribute is FromXmlAttribute);
CodeVariableReferenceExpression uncastLocalVariableRef = null;
if (isXmlProperty != null)
{
bufferVariable = new CodeVariableDeclarationStatement(typeof(object), variableName);
container.Statements.Add(bufferVariable);
uncastLocalVariableRef = new CodeVariableReferenceExpression(variableName);
var buffAssignment = new CodeAssignStatement(uncastLocalVariableRef, codeIndexerExpression);
container.Statements.Add(buffAssignment);
var checkXmlForNull = new CodeConditionStatement();
checkXmlForNull.Condition = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(variableName),
CodeBinaryOperatorType.IdentityInequality,
new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("System.DBNull"), "Value"));
container.Statements.Add(checkXmlForNull);
var xmlRecordType = new CodeTypeReferenceExpression(typeof(XmlDataRecord));
importNameSpace.Imports.Add(new CodeNamespaceImport(typeof(DbClassInfoCache).Namespace));
importNameSpace.Imports.Add(new CodeNamespaceImport(typeof(DataConverterExtensions).Namespace));
importNameSpace.Imports.Add(new CodeNamespaceImport(typeof(DbConfigHelper).Namespace));
if (propertyInfoCache.CheckForListInterface())
{
var typeArgument = propertyInfoCache.PropertyInfo.PropertyType.GetGenericArguments().FirstOrDefault();
var codeTypeOfListArg = new CodeTypeOfExpression(typeArgument);
var instanceHelper = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(NonObservableDbCollection<>).MakeGenericType(typeArgument)),
"FromXml",
new CodeCastExpression(typeof(string), new CodeVariableReferenceExpression(variableName)));
//var tryParse = new CodeMethodInvokeExpression(xmlRecordType,
// "TryParse",
// new CodeCastExpression(typeof(string), uncastLocalVariableRef),
// codeTypeOfListArg,
// new CodePrimitiveExpression(false));
//var xmlDataRecords = new CodeMethodInvokeExpression(tryParse, "CreateListOfItems");
//var getClassInfo = new CodeMethodInvokeExpression(codeTypeOfListArg, "GetClassInfo");
//var xmlRecordsToObjects = new CodeMethodInvokeExpression(xmlDataRecords, "Select",
// new CodeMethodReferenceExpression(getClassInfo, "SetPropertysViaReflection"));
//CodeObjectCreateExpression collectionCreate;
//if (typeArgument != null && (typeArgument.IsClass && typeArgument.GetInterface("INotifyPropertyChanged") != null))
//{
// collectionCreate = new CodeObjectCreateExpression(typeof(DbCollection<>).MakeGenericType(typeArgument),
// xmlRecordsToObjects);
//}
//else
//{
// collectionCreate = new CodeObjectCreateExpression(typeof(NonObservableDbCollection<>).MakeGenericType(typeArgument),
// xmlRecordsToObjects);
//}
var setExpr = new CodeAssignStatement(refToProperty, instanceHelper);
checkXmlForNull.TrueStatements.Add(setExpr);
}
else
{
var typeofProperty = new CodeTypeOfExpression(propertyInfoCache.PropertyType);
var getClassInfo = new CodeMethodInvokeExpression(typeofProperty, "GetClassInfo");
var tryParse = new CodeMethodInvokeExpression(xmlRecordType,
"TryParse",
new CodeCastExpression(typeof(string), uncastLocalVariableRef),
typeofProperty,
new CodePrimitiveExpression(true));
var setProps = new CodeMethodInvokeExpression(getClassInfo, "SetPropertysViaReflection", tryParse,
new CodeSnippetExpression("null"),
new CodeSnippetExpression("null"));
var setExpr = new CodeAssignStatement(refToProperty,
new CodeCastExpression(propertyInfoCache.PropertyType, setProps));
checkXmlForNull.TrueStatements.Add(setExpr);
}
}
else
{
//Should the SQL value be converted
if (valueConverterAttributeModel != null)
{
//create object buff123;
bufferVariable = new CodeVariableDeclarationStatement(typeof(object), variableName);
container.Statements.Add(bufferVariable);
//Assing buff123 = record[x]
uncastLocalVariableRef = new CodeVariableReferenceExpression(variableName);
var buffAssignment = new CodeAssignStatement(uncastLocalVariableRef, codeIndexerExpression);
container.Statements.Add(buffAssignment);
var converter = valueConverterAttributeModel.Attribute as ValueConverterAttribute;
//Create the converter and then convert the value before everything else
importNameSpace.Imports.Add(new CodeNamespaceImport(converter.Converter.Namespace));
var converterCall = new CodeObjectCreateExpression(converter.Converter);
var converterInstanceCall = new CodeMethodInvokeExpression(converterCall, "Convert",
new CodeVariableReferenceExpression(variableName),
new CodeTypeOfExpression(propertyInfoCache.PropertyType),
new CodePrimitiveExpression(converter.Parameter),
new CodeVariableReferenceExpression("System.Globalization.CultureInfo.CurrentCulture"));
var codeAssignment = new CodeAssignStatement(new CodeVariableReferenceExpression(variableName),
converterInstanceCall);
container.Statements.Add(codeAssignment);
}
else
{
if (propertyInfoCache.PropertyType.IsEnum)
{
bufferVariable = new CodeVariableDeclarationStatement(typeof(object), variableName);
container.Statements.Add(bufferVariable);
uncastLocalVariableRef = new CodeVariableReferenceExpression(variableName);
var setToValue = new CodeAssignStatement(refToProperty,
new CodeCastExpression(
new CodeTypeReference(propertyInfoCache.PropertyType, CodeTypeReferenceOptions.GenericTypeParameter),
uncastLocalVariableRef));
container.Statements.Add(setToValue);
}
}
var isNullable = false;
var baseType = Nullable.GetUnderlyingType(propertyInfoCache.PropertyType);
if (baseType != null)
isNullable = true;
if (propertyInfoCache.PropertyType == typeof(string))
{
baseType = typeof(string);
}
else if (propertyInfoCache.PropertyType.IsArray)
{
baseType = propertyInfoCache.PropertyType;
}
if (baseType != null)
{
if (bufferVariable == null)
{
bufferVariable = new CodeVariableDeclarationStatement(typeof(object), variableName);
container.Statements.Add(bufferVariable);
uncastLocalVariableRef = new CodeVariableReferenceExpression(variableName);
var buffAssignment = new CodeAssignStatement(uncastLocalVariableRef, codeIndexerExpression);
container.Statements.Add(buffAssignment);
}
var checkForDbNull = new CodeConditionStatement
{
Condition = new CodeBinaryOperatorExpression(uncastLocalVariableRef,
CodeBinaryOperatorType.IdentityEquality,
new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("System.DBNull"), "Value"))
};
CodeAssignStatement setToNull;
if (!isNullable && baseType != typeof(string))
{
setToNull = new CodeAssignStatement(refToProperty,
new CodeDefaultValueExpression(
CreateShortCodeTypeReference(baseType, importNameSpace.Imports)));
}
else
{
setToNull = new CodeAssignStatement(refToProperty, new CodePrimitiveExpression(null));
}
var setToValue = new CodeAssignStatement(refToProperty,
new CodeCastExpression(
new CodeTypeReference(baseType, CodeTypeReferenceOptions.GenericTypeParameter),
uncastLocalVariableRef));
checkForDbNull.TrueStatements.Add(setToNull);
checkForDbNull.FalseStatements.Add(setToValue);
container.Statements.Add(checkForDbNull);
}
else
{
if (bufferVariable != null)
{
CodeExpression castExp = new CodeCastExpression(
new CodeTypeReference(propertyInfoCache.PropertyType, CodeTypeReferenceOptions.GenericTypeParameter),
new CodeVariableReferenceExpression(bufferVariable.Name));
var setExpr = new CodeAssignStatement(refToProperty, castExp);
container.Statements.Add(setExpr);
}
else
{
CodeExpression castExp = new CodeCastExpression(
new CodeTypeReference(propertyInfoCache.PropertyType, CodeTypeReferenceOptions.GenericTypeParameter),
codeIndexerExpression);
var setExpr = new CodeAssignStatement(refToProperty, castExp);
container.Statements.Add(setExpr);
}
}
}
}
}
private static string AddExpressionEvaluation(CodeTypeDeclaration declaration, CodeExpression root, ref int methodSuffix)
{
int currentMethodSuffix = methodSuffix;
CodeMemberMethod method = new CodeMemberMethod();
method.Name = string.Format("Eval{0}", currentMethodSuffix);
method.Attributes = MemberAttributes.Private | MemberAttributes.Final;
method.ReturnType = new CodeTypeReference(typeof(object));
method.Parameters.Add(
new CodeParameterDeclarationExpression(
typeof(object[]),
"e"));
if (root is CodeBinaryOperatorExpression)
{
CodeBinaryOperatorExpression binaryRoot = (CodeBinaryOperatorExpression)root;
CodeExpression left = null;
if (binaryRoot.Left is CodePrimitiveExpression)
{
left = binaryRoot.Left;
}
else
{
methodSuffix++;
Type expressionType = GetType(binaryRoot.Left, true);
if (expressionType == null)
return null;
left =
new CodeCastExpression(expressionType,
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
AddExpressionEvaluation(declaration, binaryRoot.Left, ref methodSuffix),
new CodeVariableReferenceExpression("e")));
}
CodeExpression right = null;
if (binaryRoot.Right is CodePrimitiveExpression)
{
right = binaryRoot.Right;
}
else
{
methodSuffix++;
right =
new CodeCastExpression(GetType(binaryRoot.Right, true),
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
AddExpressionEvaluation(declaration, binaryRoot.Right, ref methodSuffix),
new CodeVariableReferenceExpression("e")));
}
method.Statements.Add(
new CodeConditionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"IsEmpty",
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("e"),
new CodePrimitiveExpression(currentMethodSuffix))),
new CodeStatement[] {
new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(
left,
binaryRoot.Operator,
right)) },
new CodeStatement[] {
new CodeMethodReturnStatement(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("e"),
new CodePrimitiveExpression(currentMethodSuffix))) }));
}
else
{
method.Statements.Add(
new CodeConditionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"IsEmpty",
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("e"),
new CodePrimitiveExpression(currentMethodSuffix))),
new CodeStatement[] {
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
typeof(ArgumentException),
new CodePrimitiveExpression("Cannot have an empty parameter for a non-binary expression"),
new CodePrimitiveExpression("e[" + currentMethodSuffix + "]"))) },
new CodeStatement[] {
new CodeMethodReturnStatement(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("e"),
new CodePrimitiveExpression(currentMethodSuffix))) }));
}
declaration.Members.Add(method);
SetParameterIndex(root, currentMethodSuffix);
return method.Name;
}
public void GenerateProperties(CodeTypeDeclaration ctd, ClassInfo ci)
{
CodeMemberProperty prop;
foreach (FieldInfo fi in classInfo.LocalFields)
{
if (fi.References != null)
continue;
if (fi.IsNullable)
{
if (options.NullableRepresentation == PrimitiveRepresentation.RawWithIsNull)
{
ctd.Members.Add(_IsNull(fi));
if (!ci.ReadOnly)
{
ctd.Members.Add(_SetNull(fi));
}
}
}
else
{
if (options.NotNullRepresentation == PrimitiveRepresentation.RawWithIsNull)
{
if (!ci.ReadOnly)
{
// if it's read-only, not-null means not-null and there's no
// exception
ctd.Members.Add(_IsNull(fi));
}
}
}
}
int primaryKeyComponentNumber = 0;
foreach (FieldInfo fi in classInfo.LocalFields)
{
PrimitiveRepresentation actualNullableRepresentation = options.NullableRepresentation;
PrimitiveRepresentation actualNotNullRepresentation = options.NotNullRepresentation;
if (fi.GetNullableFieldHandler().GetSqlType() == null)
{
if (actualNotNullRepresentation == PrimitiveRepresentation.SqlType)
actualNotNullRepresentation = PrimitiveRepresentation.Raw;
if (actualNullableRepresentation == PrimitiveRepresentation.SqlType)
actualNullableRepresentation = PrimitiveRepresentation.Raw;
}
CodeTypeReference returnType;
//if (fi.Name == ci.PrimaryKeyFieldName)
//{
// returnType = GetReturnType(PrimitiveRepresentation.Raw, fi.DataType);
//}
//else
if (fi.References != null)
{
returnType = new CodeTypeReference(fi.References);
}
else if (fi.IsNullable)
{
returnType = GetReturnType(actualNullableRepresentation, fi);
}
else
{
returnType = GetReturnType(actualNotNullRepresentation, fi);
}
prop = new CodeMemberProperty();
prop.Name = fi.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = returnType;
//prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, "_FieldNames")));
if (fi.Description != null)
{
prop.Comments.Add(new CodeCommentStatement("<summary>", true));
prop.Comments.Add(new CodeCommentStatement(fi.Description, true));
prop.Comments.Add(new CodeCommentStatement("</summary>", true));
}
ctd.Members.Add(prop);
if (fi.Size != -1)
{
CodeAttributeDeclaration cad = new CodeAttributeDeclaration("Sooda.SoodaFieldSizeAttribute");
cad.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(fi.Size)));
prop.CustomAttributes.Add(cad);
}
if (fi.IsPrimaryKey)
{
CodeExpression getPrimaryKeyValue = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "GetPrimaryKeyValue");
if (classInfo.GetPrimaryKeyFields().Length > 1)
{
getPrimaryKeyValue = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(SoodaTuple)), "GetValue", getPrimaryKeyValue, new CodePrimitiveExpression(primaryKeyComponentNumber));
}
if (fi.References != null)
{
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
LoaderClass(fi.ReferencedClass),
"GetRef",
GetTransaction(),
new CodeCastExpression(
GetReturnType(actualNotNullRepresentation, fi),
getPrimaryKeyValue
))));
}
else
{
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(
prop.Type,
getPrimaryKeyValue
)));
}
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
if (classInfo.GetPrimaryKeyFields().Length == 1)
{
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "SetPrimaryKeyValue",
new CodePropertySetValueReferenceExpression())));
}
else
{
CodeExpression plainValue = new CodePropertySetValueReferenceExpression();
if (fi.References != null)
plainValue = new CodeMethodInvokeExpression(plainValue, "GetPrimaryKeyValue");
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "SetPrimaryKeySubValue",
plainValue,
new CodePrimitiveExpression(primaryKeyComponentNumber),
new CodePrimitiveExpression(classInfo.GetPrimaryKeyFields().Length))));
}
}
primaryKeyComponentNumber++;
continue;
}
if (options.NullPropagation && (fi.References != null || fi.IsNullable) && actualNullableRepresentation != PrimitiveRepresentation.Raw)
{
CodeExpression retVal = new CodePrimitiveExpression(null);
if (fi.References == null && actualNullableRepresentation == PrimitiveRepresentation.SqlType)
{
retVal = new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(fi.GetNullableFieldHandler().GetSqlType()), "Null");
}
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeThisReferenceExpression(),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
new CodeStatement[]
{
new CodeMethodReturnStatement(retVal)
},
new CodeStatement[]
{
}));
}
if (fi.References != null)
{
// reference field getter
//
CodeExpression pk = new CodeVariableReferenceExpression("pk");
Type pkType;
CodeExpression isFieldNotNull;
CodeExpression getRef;
if (fi.ParentClass.GetDataSource().EnableDynamicFields)
{
pkType = typeof(object);
isFieldNotNull = new CodeBinaryOperatorExpression(
pk,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
getRef = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(SoodaObject)),
"GetRefHelper",
GetTransaction(),
Factory(fi.References),
pk);
}
else
{
pkType = fi.GetNullableFieldHandler().GetSqlType();
isFieldNotNull = new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(pk, "IsNull"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(false));
getRef = new CodeMethodInvokeExpression(
LoaderClass(fi.ReferencedClass),
"GetRef",
GetTransaction(),
new CodePropertyReferenceExpression(pk, "Value"));
}
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
RefCacheExpression(ci, fi),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
new CodeStatement[]
{
new CodeVariableDeclarationStatement(pkType, "pk", GetFieldValueForRead(fi)),
new CodeConditionStatement(
isFieldNotNull,
new CodeStatement[]
{
new CodeAssignStatement(
RefCacheExpression(ci, fi),
getRef)
})
}
));
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(returnType,
RefCacheExpression(ci, fi))));
// reference field setter
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.ObjectMapper.SoodaObjectImpl)), "SetRefFieldValue",
// parameters
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(fi.Table.OrdinalInClass),
new CodePrimitiveExpression(fi.Name),
new CodePrimitiveExpression(fi.ClassUnifiedOrdinal),
new CodePropertySetValueReferenceExpression(),
RefCacheArray(),
new CodePrimitiveExpression(GetFieldRefCacheIndex(ci, fi)),
Factory(returnType.BaseType)
)));
}
}
else
{
// plain field getter
CodeExpression fieldValue = GetFieldValueForRead(fi);
if (fi.ParentClass.GetDataSource().EnableDynamicFields)
{
switch (fi.IsNullable ? actualNullableRepresentation : actualNotNullRepresentation)
{
case PrimitiveRepresentation.Boxed:
break;
case PrimitiveRepresentation.SqlType:
case PrimitiveRepresentation.RawWithIsNull:
case PrimitiveRepresentation.Raw:
fieldValue = new CodeCastExpression(new CodeTypeReference(fi.GetNullableFieldHandler().GetFieldType()), fieldValue);
break;
case PrimitiveRepresentation.Nullable:
fieldValue = new CodeCastExpression(new CodeTypeReference(fi.GetNullableFieldHandler().GetNullableType()), fieldValue);
break;
default:
throw new NotImplementedException("Unknown PrimitiveRepresentation");
}
}
prop.GetStatements.Add(new CodeMethodReturnStatement(fieldValue));
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
// plain field setter
CodeExpression beforeDelegate = new CodePrimitiveExpression(null);
CodeExpression afterDelegate = new CodePrimitiveExpression(null);
if (classInfo.Triggers)
{
beforeDelegate = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SoodaFieldUpdateDelegate)),
new CodeThisReferenceExpression(), "BeforeFieldUpdate_" + fi.Name);
afterDelegate = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SoodaFieldUpdateDelegate)),
new CodeThisReferenceExpression(), "AfterFieldUpdate_" + fi.Name);
}
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.ObjectMapper.SoodaObjectImpl)), "SetPlainFieldValue",
// parameters
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(fi.Table.OrdinalInClass),
new CodePrimitiveExpression(fi.Name),
new CodePrimitiveExpression(fi.ClassUnifiedOrdinal),
Box(new CodePropertySetValueReferenceExpression()),
beforeDelegate,
afterDelegate
)));
}
}
}
if (classInfo.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo coli in classInfo.Collections1toN)
{
prop = new CodeMemberProperty();
prop.Name = coli.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = GetCollectionPropertyType(coli.ClassName);
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)), new CodeStatement[]
{
new CodeAssignStatement(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
new CodeObjectCreateExpression(GetCollectionWrapperType(coli.ClassName),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Sooda.ObjectMapper.SoodaObjectOneToManyCollection)),
new CodeExpression[] {
new CodeMethodInvokeExpression(This, "GetTransaction"),
new CodeTypeOfExpression(new CodeTypeReference(coli.ClassName)),
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(coli.ForeignFieldName),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(coli.ClassName + "_Factory"), "TheClassInfo"),
new CodeFieldReferenceExpression(null, "_collectionWhere_" + coli.Name),
new CodePrimitiveExpression(coli.Cache)
}))),
}, new CodeStatement[] { }));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name)));
ctd.Members.Add(prop);
#if DOTNET35
CodeExpression whereExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.QL.Soql)),
"FieldEquals",
new CodePrimitiveExpression(coli.ForeignFieldName),
This);
if (!string.IsNullOrEmpty(coli.Where))
{
whereExpression = new CodeObjectCreateExpression(
typeof(Sooda.QL.SoqlBooleanAndExpression),
whereExpression,
new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, "_collectionWhere_" + coli.Name), "WhereExpression"));
}
prop = GetCollectionLinqQuery(coli, whereExpression);
ctd.Members.Add(prop);
#endif
}
}
if (classInfo.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo coli in classInfo.CollectionsNtoN)
{
RelationInfo relationInfo = coli.GetRelationInfo();
// FieldInfo masterField = relationInfo.Table.Fields[1 - coli.MasterField];
string relationTargetClass = relationInfo.Table.Fields[coli.MasterField].References;
prop = new CodeMemberProperty();
prop.Name = coli.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = GetCollectionPropertyType(relationTargetClass);
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)), new CodeStatement[] {
new CodeAssignStatement(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
new CodeObjectCreateExpression(GetCollectionWrapperType(relationTargetClass),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Sooda.ObjectMapper.SoodaObjectManyToManyCollection)),
new CodeExpression[] {
new CodeMethodInvokeExpression(This, "GetTransaction"),
new CodePrimitiveExpression(coli.MasterField),
new CodeMethodInvokeExpression(This, "GetPrimaryKeyValue"),
new CodeTypeOfExpression(relationInfo.Name + "_RelationTable"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(relationInfo.Name + "_RelationTable"), "theRelationInfo")
}))
),
}
, new CodeStatement[] { }));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name)));
ctd.Members.Add(prop);
#if DOTNET35
CodeExpression whereExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.QL.Soql)),
"CollectionFor",
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(classInfo.Name + "_Factory"), "TheClassInfo"),
"FindCollectionManyToMany",
new CodePrimitiveExpression(coli.Name)),
This);
prop = GetCollectionLinqQuery(coli, whereExpression);
ctd.Members.Add(prop);
#endif
}
}
}
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers)
{
CodeIdentifiers pids = new CodeIdentifiers ();
CodeMemberMethod method = new CodeMemberMethod ();
CodeMemberMethod methodBegin = new CodeMemberMethod ();
CodeMemberMethod methodEnd = new CodeMemberMethod ();
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final;
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
// Find unique names for temporary variables
for (int n=0; n<inputMembers.Count; n++)
pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]);
if (outputMembers != null)
for (int n=0; n<outputMembers.Count; n++)
pids.AddUnique (outputMembers[n].MemberName, outputMembers[n]);
string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult");
string varResults = pids.AddUnique ("results","results");
string varCallback = pids.AddUnique ("callback","callback");
string varAsyncState = pids.AddUnique ("asyncState","asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method);
method.Name = CodeIdentifier.MakeValid(Operation.Name);
if (method.Name == ClassName) method.Name += "1";
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name),method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name),method);
method.ReturnType = new CodeTypeReference (typeof(void));
methodEnd.ReturnType = new CodeTypeReference (typeof(void));
methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0];
for (int n=0; n<inputMembers.Count; n++)
{
CodeParameterDeclarationExpression param = GenerateParameter (inputMembers[n], FieldDirection.In);
method.Parameters.Add (param);
GenerateMemberAttributes (inputMembers, inputMembers[n], bodyBinding.Use, param);
methodBegin.Parameters.Add (GenerateParameter (inputMembers[n], FieldDirection.In));
paramArray [n] = new CodeVariableReferenceExpression (param.Name);
}
if (outputMembers != null)
{
bool hasReturn = false;
for (int n=0; n<outputMembers.Count; n++)
{
CodeParameterDeclarationExpression cpd = GenerateParameter (outputMembers[n], FieldDirection.Out);
outParams [n] = cpd;
bool found = false;
foreach (CodeParameterDeclarationExpression ip in method.Parameters)
{
if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType) {
ip.Direction = FieldDirection.Ref;
methodEnd.Parameters.Add (GenerateParameter (outputMembers[n], FieldDirection.Out));
found = true;
break;
}
}
if (found) continue;
if (!hasReturn)
{
hasReturn = true;
method.ReturnType = cpd.Type;
methodEnd.ReturnType = cpd.Type;
GenerateReturnAttributes (outputMembers, outputMembers[n], bodyBinding.Use, method);
outParams [n] = null;
continue;
}
method.Parameters.Add (cpd);
GenerateMemberAttributes (outputMembers, outputMembers[n], bodyBinding.Use, cpd);
methodEnd.Parameters.Add (GenerateParameter (outputMembers[n], FieldDirection.Out));
}
}
methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback));
methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState));
methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
methodParams = new CodeArrayCreateExpression (typeof(object), paramArray);
else
methodParams = new CodeArrayCreateExpression (typeof(object), 0);
// Assignment of output parameters
CodeStatementCollection outAssign = new CodeStatementCollection ();
CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression (varResults);
for (int n=0; n<outParams.Length; n++)
{
CodeExpression index = new CodePrimitiveExpression (n);
if (outParams[n] == null)
{
CodeExpression res = new CodeCastExpression (method.ReturnType, new CodeArrayIndexerExpression (arrVar, index));
outAssign.Add (new CodeMethodReturnStatement (res));
}
else
{
CodeExpression res = new CodeCastExpression (outParams[n].Type, new CodeArrayIndexerExpression (arrVar, index));
CodeExpression var = new CodeVariableReferenceExpression (outParams[n].Name);
outAssign.Insert (0, new CodeAssignStatement (var, res));
}
}
if (Style == ServiceDescriptionImportStyle.Client)
{
// Invoke call
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName);
CodeMethodInvokeExpression inv;
CodeVariableDeclarationStatement dec;
inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, methodParams);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement (typeof(object[]), varResults, inv);
method.Statements.Add (dec);
method.Statements.AddRange (outAssign);
}
else
method.Statements.Add (inv);
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState);
inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add (new CodeMethodReturnStatement (inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult);
inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement (typeof(object[]), varResults, inv);
methodEnd.Statements.Add (dec);
methodEnd.Statements.AddRange (outAssign);
}
else
methodEnd.Statements.Add (inv);
}
else {
method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
}
// Attributes
ImportHeaders (method);
CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.WebMethodAttribute");
if (messageName != method.Name) att.Arguments.Add (GetArg ("MessageName",messageName));
AddCustomAttribute (method, att, (Style == ServiceDescriptionImportStyle.Server));
if (style == SoapBindingStyle.Rpc)
{
att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.SoapRpcMethodAttribute");
att.Arguments.Add (GetArg (soapOper.SoapAction));
if (inputMembers.ElementName != method.Name) att.Arguments.Add (GetArg ("RequestElementName", inputMembers.ElementName));
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response")) att.Arguments.Add (GetArg ("ResponseElementName", outputMembers.ElementName));
att.Arguments.Add (GetArg ("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null) att.Arguments.Add (GetArg ("ResponseNamespace", outputMembers.Namespace));
if (outputMembers == null) att.Arguments.Add (GetArg ("OneWay", true));
}
else
{
if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" ||
inputMembers.ElementName != "" && outputMembers.ElementName == ""))
throw new InvalidOperationException ("Parameter style is not the same for the input message and output message");
att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.SoapDocumentMethodAttribute");
att.Arguments.Add (GetArg (soapOper.SoapAction));
if (inputMembers.ElementName != "") {
if (inputMembers.ElementName != method.Name) att.Arguments.Add (GetArg ("RequestElementName", inputMembers.ElementName));
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response")) att.Arguments.Add (GetArg ("ResponseElementName", outputMembers.ElementName));
att.Arguments.Add (GetArg ("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null) att.Arguments.Add (GetArg ("ResponseNamespace", outputMembers.Namespace));
att.Arguments.Add (GetEnumArg ("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped"));
}
else
att.Arguments.Add (GetEnumArg ("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare"));
if (outputMembers == null) att.Arguments.Add (GetArg ("OneWay", true));
att.Arguments.Add (GetEnumArg ("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString()));
}
AddCustomAttribute (method, att, true);
CodeTypeDeclaration.Members.Add (method);
if (Style == ServiceDescriptionImportStyle.Client) {
CodeTypeDeclaration.Members.Add (methodBegin);
CodeTypeDeclaration.Members.Add (methodEnd);
}
return method;
}
internal void ConnectStyleEvent(XamlClrEventNode xamlClrEventNode)
{
CodeConditionStatement ccsConnector = null;
// validate the event handler name per C# grammar for identifiers
ValidateEventHandlerName(xamlClrEventNode.EventName, xamlClrEventNode.Value);
EnsureStyleConnector();
if (!xamlClrEventNode.IsSameScope)
{
int connectionId = xamlClrEventNode.ConnectionId;
if (SwitchStatementSupported())
{
// break any previous case staements as we are starting a new connection scope.
if (_ccRoot.StyleConnectorFn.Statements.Count > 1)
{
CodeSnippetStatement cssBreak = new CodeSnippetStatement(BREAK_STATEMENT);
_ccRoot.StyleConnectorFn.Statements.Add(cssBreak);
}
// case 1:
//
CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON);
_ccRoot.StyleConnectorFn.Statements.Add(cssCase);
}
else
{
// if (connectionId == 1)
//
ccsConnector = new CodeConditionStatement();
ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(connectionId));
}
}
else if (!SwitchStatementSupported())
{
// if in the same scope then use the if statement that was last generated
// at the start of the scope
Debug.Assert(_ccRoot.StyleConnectorFn.Statements.Count > 0);
ccsConnector = _ccRoot.StyleConnectorFn.Statements[_ccRoot.StyleConnectorFn.Statements.Count - 1] as CodeConditionStatement;
Debug.Assert(ccsConnector != null);
}
CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
if (xamlClrEventNode.IsStyleSetterEvent)
{
// EventSetter declaration only once to avoid warning!
if (!_hasEmittedEventSetterDeclaration)
{
_hasEmittedEventSetterDeclaration = true;
// EventSetter eventSetter;
//
CodeVariableDeclarationStatement cvdsES = new CodeVariableDeclarationStatement(KnownTypes.Types[(int)KnownElements.EventSetter], EVENTSETTER);
_ccRoot.StyleConnectorFn.Statements.Insert(0, cvdsES);
}
// eventSetter = new EventSetter();
//
CodeExpression[] esParams = {};
CodeVariableReferenceExpression cvreES = new CodeVariableReferenceExpression(EVENTSETTER);
CodeAssignStatement casES = new CodeAssignStatement(cvreES,
new CodeObjectCreateExpression(KnownTypes.Types[(int)KnownElements.EventSetter],
esParams));
// eventSetter.Event = Button.ClickEvent;
//
CodePropertyReferenceExpression cpreEvent = new CodePropertyReferenceExpression(cvreES, EVENT);
CodeAssignStatement casEvent = new CodeAssignStatement(cpreEvent,
GetEvent(xamlClrEventNode.EventMember,
xamlClrEventNode.EventName,
xamlClrEventNode.Value));
// eventSetter.Handler = new RoutedEventHandler(OnClick);
//
CodePropertyReferenceExpression cpreHandler = new CodePropertyReferenceExpression(cvreES, HANDLER);
CodeAssignStatement casHandler = new CodeAssignStatement(cpreHandler,
GetEventDelegate(null,
xamlClrEventNode.EventMember,
xamlClrEventNode.EventName,
xamlClrEventNode.Value));
AddLinePragma(casHandler, xamlClrEventNode.LineNumber);
// ((Style)target).Setters.Add(eventSetter);
//
CodeCastExpression cceTarget = new CodeCastExpression(KnownTypes.Types[(int)KnownElements.Style], careTarget);
CodePropertyReferenceExpression cpreSetters = new CodePropertyReferenceExpression(cceTarget, SETTERS);
CodeMethodInvokeExpression cmieAdd = new CodeMethodInvokeExpression(cpreSetters, ADD, cvreES);
if (SwitchStatementSupported())
{
_ccRoot.StyleConnectorFn.Statements.Add(casES);
_ccRoot.StyleConnectorFn.Statements.Add(casEvent);
_ccRoot.StyleConnectorFn.Statements.Add(casHandler);
_ccRoot.StyleConnectorFn.Statements.Add(new CodeExpressionStatement(cmieAdd));
}
else
{
ccsConnector.TrueStatements.Add(casES);
ccsConnector.TrueStatements.Add(casEvent);
ccsConnector.TrueStatements.Add(casHandler);
ccsConnector.TrueStatements.Add(new CodeExpressionStatement(cmieAdd));
// Only add if statement at start of new scope
if (!xamlClrEventNode.IsSameScope)
{
_ccRoot.StyleConnectorFn.Statements.Add(ccsConnector);
}
}
}
else
{
//
// ((Foo)target).Bar += new BarEventHandler(OnBar);
//
// *or*
//
// ((Foo)target).AddHandler( Baz.BarEvent, new BarEventHandler(OnBar));
//
CodeCastExpression cceTarget;
Type eventTarget;
// Create the markup event information
MarkupEventInfo mei = new MarkupEventInfo( xamlClrEventNode.Value, // Event handler string
xamlClrEventNode.EventName, // Event name string
xamlClrEventNode.EventMember, // MemberInfo
xamlClrEventNode.LineNumber); // LineNumber
// Get the type that defines the event (e.g. typeof(Button) for Button.Clicked or typeof(Mouse) for Mouse.MouseMove)
eventTarget = xamlClrEventNode.ListenerType;
// Create the type cast expression "(Foo)target"
cceTarget = new CodeCastExpression( eventTarget, careTarget);
// Create the whole code statement (either in += form or in AddHandler form)
CodeStatement csAddCLREvent = AddCLREvent( eventTarget, null, cceTarget, mei );
if (SwitchStatementSupported())
{
_ccRoot.StyleConnectorFn.Statements.Add( csAddCLREvent );
}
else
{
ccsConnector.TrueStatements.Add( csAddCLREvent );
// Only add if statement at start of new scope
if (!xamlClrEventNode.IsSameScope)
{
_ccRoot.StyleConnectorFn.Statements.Add(ccsConnector);
}
}
}
}
internal void ConnectNameAndEvents(string elementName, ArrayList events, int connectionId)
{
CodeContext cc = (CodeContext)_codeContexts.Peek();
bool isAllowedNameScope = cc.IsAllowedNameScope;
if (_codeContexts.Count > 1 && KnownTypes.Types[(int)KnownElements.INameScope].IsAssignableFrom(cc.ElementType))
{
cc.IsAllowedNameScope = false;
}
if ((elementName == null || !isAllowedNameScope) && (events == null || events.Count == 0))
{
_typeArgsList = null;
return;
}
EnsureHookupFn();
CodeConditionStatement ccsConnector = null;
if (SwitchStatementSupported())
{
// case 1:
//
CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON);
_ccRoot.HookupFn.Statements.Add(cssCase);
}
else
{
// if (connectionId == 1)
//
ccsConnector = new CodeConditionStatement();
ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(connectionId));
}
// (System.Windows.Controls.Footype)target;
CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
CodeCastExpression cceTarget = new CodeCastExpression(cc.ElementTypeReference, careTarget);
CodeExpression ceEvent = cceTarget;
// Names in nested Name scopes not be hooked up via ICC.Connect() as no fields are generated in this case.
if (elementName != null && isAllowedNameScope)
{
// this.fooId = (System.Windows.Controls.Footype)target;
//
ceEvent = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), elementName);
CodeAssignStatement casName = new CodeAssignStatement(ceEvent, cceTarget);
if (SwitchStatementSupported())
{
_ccRoot.HookupFn.Statements.Add(casName);
}
else
{
ccsConnector.TrueStatements.Add(casName);
}
}
if (events != null)
{
foreach (MarkupEventInfo mei in events)
{
CodeStatement csEvent = AddCLREvent(cc, ceEvent, mei);
if (SwitchStatementSupported())
{
_ccRoot.HookupFn.Statements.Add(csEvent);
}
else
{
ccsConnector.TrueStatements.Add(csEvent);
}
}
}
// return;
//
if (SwitchStatementSupported())
{
_ccRoot.HookupFn.Statements.Add(new CodeMethodReturnStatement());
}
else
{
ccsConnector.TrueStatements.Add(new CodeMethodReturnStatement());
_ccRoot.HookupFn.Statements.Add(ccsConnector);
}
_typeArgsList = null;
}
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
{
// RG:
// foreach (T t in x)
// {
// stmts;
// }
//
// Emulate with
//
// for (System.Collections.IEnumerator _it = x.GetEnumerator(); _it.MoveNext(); )
// {
// T t = ((T)_it.Current);
//
// stmts;
// }
foreachId++;
string name = "_it" + foreachId.ToString();
CodeIterationStatement _for1 = new CodeIterationStatement();
breakableStack.Push(new Breakable());
// init
CodeVariableDeclarationStatement _decl2 = new CodeVariableDeclarationStatement();
CodeMethodInvokeExpression _invoke1 = new CodeMethodInvokeExpression();
CodeMethodReferenceExpression _GetEnumerator_method1 = new CodeMethodReferenceExpression();
_GetEnumerator_method1.MethodName = "GetEnumerator";
//CodeCastExpression _cast1 = new CodeCastExpression();
//codeStack.Push(NullStmtCollection);
//_cast1.Expression = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
//codeStack.Pop();
//CodeTypeReference _IEnumerable_type1 = new CodeTypeReference("System.Collections.IEnumerable");
//_cast1.TargetType = _IEnumerable_type1;
//_GetEnumerator_method1.TargetObject = _cast1;
codeStack.Push(NullStmtCollection);
_GetEnumerator_method1.TargetObject = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
codeStack.Pop();
_invoke1.Method = _GetEnumerator_method1;
_decl2.InitExpression = _invoke1;
_decl2.Name = name;
CodeTypeReference _IEnumerator_type1 = new CodeTypeReference("System.Collections.IEnumerator");
_decl2.Type = _IEnumerator_type1;
_for1.InitStatement = _decl2;
// Condition
CodeMethodInvokeExpression _invoke2 = new CodeMethodInvokeExpression();
CodeMethodReferenceExpression _MoveNext_method1 = new CodeMethodReferenceExpression();
_MoveNext_method1.MethodName = "MoveNext";
CodeVariableReferenceExpression _arg2 = new CodeVariableReferenceExpression();
_arg2.VariableName = name;
_MoveNext_method1.TargetObject = _arg2;
_invoke2.Method = _MoveNext_method1;
_for1.TestExpression = _invoke2;
// Empty Increment
_for1.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());
// T t = ((T)_it.Current);
CodeVariableDeclarationStatement _decl3 = new CodeVariableDeclarationStatement();
CodeCastExpression _cast2 = new CodeCastExpression();
CodePropertyReferenceExpression _prop1 = new CodePropertyReferenceExpression();
_prop1.PropertyName = "Current";
CodeVariableReferenceExpression _arg3 = new CodeVariableReferenceExpression();
_arg3.VariableName = name;
_prop1.TargetObject = _arg3;
_cast2.Expression = _prop1;
CodeTypeReference _System_String_type5 = ConvType(foreachStatement.TypeReference);
_cast2.TargetType = _System_String_type5;
_decl3.InitExpression = _cast2;
_decl3.Name = foreachStatement.VariableName;
CodeTypeReference _System_String_type6 = ConvType(foreachStatement.TypeReference);
_decl3.Type = _System_String_type6;
_for1.Statements.Add(_decl3);
_for1.Statements.Add(new CodeSnippetStatement());
codeStack.Push(_for1.Statements);
foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
codeStack.Pop();
Breakable breakable = breakableStack.Pop();
if (breakable.IsContinue)
{
_for1.Statements.Add(new CodeSnippetStatement());
_for1.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
}
AddStmt(_for1);
if (breakable.IsBreak)
{
AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
}
return _for1;
}
public static void GenerateFile (string xaml_file, string out_file)
{
XmlDocument xmldoc = new XmlDocument ();
xmldoc.Load (xaml_file);
XmlNamespaceManager nsmgr = new XmlNamespaceManager (xmldoc.NameTable);
nsmgr.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml");
XmlNode root = xmldoc.SelectSingleNode ("/*", nsmgr);
if (root == null) {
Console.Error.WriteLine ("{0}: No root node found.", xaml_file);
return;
}
XmlAttribute root_class = root.Attributes ["x:Class"];
if (root_class == null) {
File.WriteAllText (out_file, "");
return;
}
bool is_application = root.LocalName == "Application";
string root_ns;
string root_type;
string root_asm;
ParseXmlns (root_class.Value, out root_type, out root_ns, out root_asm);
Hashtable names_and_types = GetNamesAndTypes (root, nsmgr);
// Hashtable keys_and_types = GetKeysAndTypes (root, nsmgr);
CodeCompileUnit ccu = new CodeCompileUnit ();
CodeNamespace decl_ns = new CodeNamespace (root_ns);
ccu.Namespaces.Add (decl_ns);
decl_ns.Imports.Add (new CodeNamespaceImport ("System"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Controls"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Controls.Primitives"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Documents"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Input"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Media"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Media.Animation"));
decl_ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Shapes"));
CodeTypeDeclaration decl_type = new CodeTypeDeclaration (root_type);
decl_type.IsPartial = true;
decl_ns.Types.Add (decl_type);
CodeMemberMethod initcomp = new CodeMemberMethod ();
initcomp.Name = "InitializeComponent";
decl_type.Members.Add (initcomp);
if (sl2) {
CodeMemberField field = new CodeMemberField ();
field.Name = "_contentLoaded";
field.Type = new CodeTypeReference (typeof (bool));
decl_type.Members.Add (field);
CodeConditionStatement is_content_loaded = new CodeConditionStatement (new CodeVariableReferenceExpression ("_contentLoaded"),
new CodeStatement [] { new CodeMethodReturnStatement () });
initcomp.Statements.Add (is_content_loaded);
CodeAssignStatement set_content_loaded = new CodeAssignStatement (new CodeVariableReferenceExpression ("_contentLoaded"),
new CodePrimitiveExpression (true));
initcomp.Statements.Add (set_content_loaded);
if (!Path.GetFullPath (xaml_file).StartsWith (root_folder))
throw new ApplicationException ("the -root directory is not a parent of the xaml file");
string component_path = String.Format ("/{0};component/{1}", app_name, Path.GetFullPath (xaml_file).Substring (root_folder.Length + (root_folder.EndsWith ("/") ? 0 : 1)));
//string component_path = String.Format ("/{0};component/{1}", app_name, Path.GetFileName (xaml_file));
CodeMethodInvokeExpression load_component = new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression ("System.Windows.Application"), "LoadComponent",
new CodeExpression [] { new CodeThisReferenceExpression (),
new CodeObjectCreateExpression (new CodeTypeReference ("System.Uri"), new CodeExpression [] {
new CodePrimitiveExpression (component_path),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.UriKind"), "Relative") })
});
initcomp.Statements.Add (load_component);
}
if (!is_application) {
foreach (DictionaryEntry entry in names_and_types) {
string name = (string) entry.Key;
CodeTypeReference type = (CodeTypeReference) entry.Value;
CodeMemberField field = new CodeMemberField ();
if (sl2)
field.Attributes = MemberAttributes.Assembly;
field.Name = name;
field.Type = type;
decl_type.Members.Add (field);
CodeMethodInvokeExpression find_invoke = new CodeMethodInvokeExpression (
new CodeThisReferenceExpression(), "FindName",
new CodeExpression[] { new CodePrimitiveExpression (name) } );
CodeCastExpression cast = new CodeCastExpression (type, find_invoke);
CodeAssignStatement assign = new CodeAssignStatement (
new CodeVariableReferenceExpression (name), cast);
initcomp.Statements.Add (assign);
}
}
using (StreamWriter writer = new StreamWriter (out_file)) {
provider.GenerateCodeFromCompileUnit (ccu, writer, new CodeGeneratorOptions ());
}
}
protected override void GenerateCastExpression(CodeCastExpression e)
{
base.Output.Write("CType(");
base.GenerateExpression(e.Expression);
base.Output.Write(",");
this.OutputType(e.TargetType);
this.OutputArrayPostfix(e.TargetType);
base.Output.Write(")");
}
void AddProfileClassGroupProperty (string groupName, string memberName, CodeTypeDeclaration profileClass)
{
CodeMemberProperty property = new CodeMemberProperty ();
property.Name = memberName;
property.Type = new CodeTypeReference (groupName);
property.Attributes = MemberAttributes.Public;
CodeMethodReturnStatement ret = new CodeMethodReturnStatement ();
CodeCastExpression cast = new CodeCastExpression ();
ret.Expression = cast;
CodeMethodReferenceExpression mref = new CodeMethodReferenceExpression (
new CodeThisReferenceExpression (),
"GetProfileGroup");
CodeMethodInvokeExpression minvoke = new CodeMethodInvokeExpression (
mref,
new CodeExpression[] { new CodePrimitiveExpression (memberName) }
);
cast.TargetType = new CodeTypeReference (groupName);
cast.Expression = minvoke;
property.GetStatements.Add (ret);
profileClass.Members.Add (property);
}
void AddProfileClassProperty (ProfileSection ps, CodeTypeDeclaration profileClass, ProfilePropertySettings pset)
{
string name = pset.Name;
if (String.IsNullOrEmpty (name))
throw new HttpException ("Profile property 'Name' attribute cannot be null.");
CodeMemberProperty property = new CodeMemberProperty ();
string typeName = pset.Type;
if (typeName == "string")
typeName = "System.String";
property.Name = name;
property.Type = GetProfilePropertyType (typeName);
property.Attributes = MemberAttributes.Public;
CodeAttributeDeclarationCollection collection = new CodeAttributeDeclarationCollection();
GetProfileProviderAttribute (ps, collection, pset.Provider);
GetProfileSettingsSerializeAsAttribute (ps, collection, pset.SerializeAs);
property.CustomAttributes = collection;
CodeMethodReturnStatement ret = new CodeMethodReturnStatement ();
CodeCastExpression cast = new CodeCastExpression ();
ret.Expression = cast;
CodeMethodReferenceExpression mref = new CodeMethodReferenceExpression (
new CodeThisReferenceExpression (),
"GetPropertyValue");
CodeMethodInvokeExpression minvoke = new CodeMethodInvokeExpression (
mref,
new CodeExpression[] { new CodePrimitiveExpression (name) }
);
cast.TargetType = new CodeTypeReference (typeName);
cast.Expression = minvoke;
property.GetStatements.Add (ret);
if (!pset.ReadOnly) {
mref = new CodeMethodReferenceExpression (
new CodeThisReferenceExpression (),
"SetPropertyValue");
minvoke = new CodeMethodInvokeExpression (
mref,
new CodeExpression[] { new CodePrimitiveExpression (name), new CodeSnippetExpression ("value") }
);
property.SetStatements.Add (minvoke);
}
profileClass.Members.Add (property);
}
private void AddGetStatements(CodeStatementCollection getStatements)
{
if (IsSubstitutionHead)
{
AddSubstGetStatements(getStatements);
return;
}
CodeExpression returnExp = null;
if (FixedValue != null)
{
getStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
null,
NameGenerator.ChangeClrName(
this.propertyName,
NameOptions.MakeFixedValueField)))
);
return;
}
getStatements.Add(GetValueMethodCall());
CheckOccurrence(getStatements);
CodeVariableReferenceExpression returnValueExp =
new CodeVariableReferenceExpression("x");
if (!IsRef && typeRef.IsSimpleType)
{
//for referencing properties, directly create the object of referenced type
CodeTypeReference parseType = ReturnType;
if (typeRef.IsValueType && IsNullable)
{
parseType = new CodeTypeReference(clrTypeName);
}
if (IsUnion)
{
returnExp = CodeDomHelper.CreateMethodCall(
CodeDomHelper.CreateTypeReferenceExp(Constants.XTypedServices),
Constants.ParseUnionValue,
returnValueExp,
GetSimpleTypeClassExpression());
}
else
{
string parseMethodName = null;
CodeExpression simpleTypeExpression = GetSchemaDatatypeExpression();
if (IsSchemaList)
{
parseMethodName = Constants.ParseListValue;
parseType = new CodeTypeReference(clrTypeName);
}
else
{
parseMethodName = Constants.ParseValue;
}
returnExp = CodeDomHelper.CreateGenericMethodCall(
CodeDomHelper.CreateTypeReferenceExp(
Constants.XTypedServices),
parseMethodName,
parseType,
returnValueExp,
simpleTypeExpression);
if(DefaultValue != null)
{
((CodeMethodInvokeExpression)returnExp).Parameters.Add(
new CodeFieldReferenceExpression(
null,
NameGenerator.ChangeClrName(
this.propertyName,
NameOptions.MakeDefaultValueField)));
}
}
}
else {
returnExp = new CodeCastExpression(ReturnType, returnValueExp);
}
getStatements.Add(new CodeMethodReturnStatement(returnExp));
}
protected override void CreateMethods ()
{
base.CreateMethods ();
#if NET_2_0
if (pageParser.MasterType != null) {
CodeMemberProperty mprop = new CodeMemberProperty ();
mprop.Name = "Master";
mprop.Type = new CodeTypeReference (pageParser.MasterType);
mprop.Attributes = MemberAttributes.Public | MemberAttributes.New;
CodeExpression prop = new CodePropertyReferenceExpression (new CodeBaseReferenceExpression (), "Master");
prop = new CodeCastExpression (pageParser.MasterType, prop);
mprop.GetStatements.Add (new CodeMethodReturnStatement (prop));
mainClass.Members.Add (mprop);
}
#endif
CreateGetTypeHashCode ();
}
private void GenerateInternalTypeHelperImplementation()
{
if (!IsInternalAccessSupported ||
!(HasInternals || HasLocalReference) ||
_hasGeneratedInternalTypeHelper)
{
return;
}
_hasGeneratedInternalTypeHelper = true;
// namespace XamlGeneratedNamespace
// {
//
CodeNamespace cns = new CodeNamespace();
cns.Name = XamlTypeMapper.GeneratedNamespace;
// [EditorBrowsable(EditorBrowsableState.Never)]
// public sealed class GeneratedInternalTypeHelper : InternalTypeHelper
// {
//
CodeTypeDeclaration ctdClass = new CodeTypeDeclaration();
ctdClass.Name = XamlTypeMapper.GeneratedInternalTypeHelperClassName;
ctdClass.BaseTypes.Add(new CodeTypeReference("System.Windows.Markup.InternalTypeHelper"));
ctdClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
AddDebuggerNonUserCodeAttribute(ctdClass);
AddGeneratedCodeAttribute(ctdClass);
AddEditorBrowsableAttribute(ctdClass);
GenerateXmlComments(ctdClass, ctdClass.Name);
// protected override object CreateInstance(Type type, CultureInfo culture)
// {
// return Activator.CreateInstance(type,
// BindingFlags.Public |
// BindingFlags.NonPublic |
// BindingFlags.Instance |
// BindingFlags.CreateInstance,
// null,
// null,
// culture);
// }
//
CodeMemberMethod cmmCI = new CodeMemberMethod();
cmmCI.Name = "CreateInstance";
cmmCI.Attributes = MemberAttributes.Family | MemberAttributes.Override;
cmmCI.ReturnType = new CodeTypeReference(typeof(Object));
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), TYPE);
CodeParameterDeclarationExpression param4 = new CodeParameterDeclarationExpression(typeof(CultureInfo), CULTURE);
cmmCI.Parameters.Add(param1);
cmmCI.Parameters.Add(param4);
CodeMethodReferenceExpression cmreCI = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Activator)), "CreateInstance");
CodeMethodInvokeExpression cmieCI = new CodeMethodInvokeExpression();
cmieCI.Method = cmreCI;
cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(TYPE));
CodeFieldReferenceExpression cfre1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Public");
CodeFieldReferenceExpression cfre2 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "NonPublic");
CodeFieldReferenceExpression cfre3 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Instance");
CodeFieldReferenceExpression cfre4 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "CreateInstance");
CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(cfre1, CodeBinaryOperatorType.BitwiseOr, cfre2);
CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(cfre3, CodeBinaryOperatorType.BitwiseOr, cfre4);
CodeBinaryOperatorExpression cboeCI = new CodeBinaryOperatorExpression(cboe1, CodeBinaryOperatorType.BitwiseOr, cboe2);
cmieCI.Parameters.Add(cboeCI);
cmieCI.Parameters.Add(new CodePrimitiveExpression(null));
cmieCI.Parameters.Add(new CodePrimitiveExpression(null));
cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));
cmmCI.Statements.Add(new CodeMethodReturnStatement(cmieCI));
GenerateXmlComments(cmmCI, cmmCI.Name);
ctdClass.Members.Add(cmmCI);
// protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture)
// {
// return propertyInfo.GetValue(target, BindingFlags.Default, null, null, culture);
// }
//
CodeMemberMethod cmmGPV = new CodeMemberMethod();
cmmGPV.Name = "GetPropertyValue";
cmmGPV.Attributes = MemberAttributes.Family | MemberAttributes.Override;
cmmGPV.ReturnType = new CodeTypeReference(typeof(Object));
param1 = new CodeParameterDeclarationExpression(typeof(PropertyInfo), PROPINFO);
CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET);
cmmGPV.Parameters.Add(param1);
cmmGPV.Parameters.Add(param2);
cmmGPV.Parameters.Add(param4);
CodeMethodReferenceExpression cmreGPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "GetValue");
CodeMethodInvokeExpression cmieGPV = new CodeMethodInvokeExpression();
cmieGPV.Method = cmreGPV;
cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
cmieGPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT));
cmieGPV.Parameters.Add(new CodePrimitiveExpression(null));
cmieGPV.Parameters.Add(new CodePrimitiveExpression(null));
cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));
cmmGPV.Statements.Add(new CodeMethodReturnStatement(cmieGPV));
GenerateXmlComments(cmmGPV, cmmGPV.Name);
ctdClass.Members.Add(cmmGPV);
// protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture)
// {
// propertyInfo.SetValue(target, value, BindingFlags.Default, null, null, culture);
// }
//
CodeMemberMethod cmmSPV = new CodeMemberMethod();
cmmSPV.Name = "SetPropertyValue";
cmmSPV.Attributes = MemberAttributes.Family | MemberAttributes.Override;
CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression(typeof(object), VALUE);
cmmSPV.Parameters.Add(param1);
cmmSPV.Parameters.Add(param2);
cmmSPV.Parameters.Add(param3);
cmmSPV.Parameters.Add(param4);
CodeMethodReferenceExpression cmreSPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "SetValue");
CodeMethodInvokeExpression cmieSPV = new CodeMethodInvokeExpression();
cmieSPV.Method = cmreSPV;
cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(VALUE));
cmieSPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT));
cmieSPV.Parameters.Add(new CodePrimitiveExpression(null));
cmieSPV.Parameters.Add(new CodePrimitiveExpression(null));
cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));
cmmSPV.Statements.Add(new CodeExpressionStatement(cmieSPV));
GenerateXmlComments(cmmSPV, cmmSPV.Name);
ctdClass.Members.Add(cmmSPV);
// protected override Delegate CreateDelegate(Type delegateType, object target, string handler)
// {
// return (Delegate)target.GetType().InvokeMember("_CreateDelegate",
// BindingFlags.Instance |
// BindingFlags.NonPublic |
// BindingFlags.InvokeMethod,
// null,
// target,
// new object[] { delegateType, handler });
// }
//
CodeMemberMethod cmmCD = new CodeMemberMethod();
cmmCD.Name = "CreateDelegate";
cmmCD.Attributes = MemberAttributes.Family | MemberAttributes.Override;
cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate));
param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE);
param3 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG);
cmmCD.Parameters.Add(param1);
cmmCD.Parameters.Add(param2);
cmmCD.Parameters.Add(param3);
CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
CodeMethodReferenceExpression cmreGetType = new CodeMethodReferenceExpression(careTarget, "GetType");
CodeMethodInvokeExpression cmieGetType = new CodeMethodInvokeExpression();
cmieGetType.Method = cmreGetType;
CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(cmieGetType, "InvokeMember");
CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression();
cmieCD.Method = cmreCD;
cmieCD.Parameters.Add(new CodePrimitiveExpression(CREATEDELEGATEHELPER));
CodeFieldReferenceExpression cfre5 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "InvokeMethod");
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(cfre2, CodeBinaryOperatorType.BitwiseOr, cfre3);
CodeBinaryOperatorExpression cboeCD = new CodeBinaryOperatorExpression(cfre5, CodeBinaryOperatorType.BitwiseOr, cboe);
cmieCD.Parameters.Add(cboeCD);
cmieCD.Parameters.Add(new CodePrimitiveExpression(null));
cmieCD.Parameters.Add(careTarget);
CodeArrayCreateExpression caceCD = new CodeArrayCreateExpression(typeof(object));
CodeArgumentReferenceExpression careDelType = new CodeArgumentReferenceExpression(DELEGATETYPE);
CodeArgumentReferenceExpression careHandler = new CodeArgumentReferenceExpression(HANDLERARG);
caceCD.Initializers.Add(careDelType);
caceCD.Initializers.Add(careHandler);
cmieCD.Parameters.Add(caceCD);
cmieCD.Parameters.Add(new CodePrimitiveExpression(null));
CodeCastExpression cceCD = new CodeCastExpression(typeof(Delegate), cmieCD);
cmmCD.Statements.Add(new CodeMethodReturnStatement(cceCD));
GenerateXmlComments(cmmCD, cmmCD.Name);
ctdClass.Members.Add(cmmCD);
// protected override void AddEventHandler(EventInfo eventInfo, object target, Delegate handler);
// {
// eventInfo.AddEventHandler(target, handler);
// }
//
CodeMemberMethod cmmAEH = new CodeMemberMethod();
cmmAEH.Name = "AddEventHandler";
cmmAEH.Attributes = MemberAttributes.Family | MemberAttributes.Override;
param1 = new CodeParameterDeclarationExpression(typeof(EventInfo), EVENTINFO);
param3 = new CodeParameterDeclarationExpression(typeof(Delegate), HANDLERARG);
cmmAEH.Parameters.Add(param1);
cmmAEH.Parameters.Add(param2);
cmmAEH.Parameters.Add(param3);
CodeMethodReferenceExpression cmreAEH = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(EVENTINFO), "AddEventHandler");
CodeMethodInvokeExpression cmieAEH = new CodeMethodInvokeExpression();
cmieAEH.Method = cmreAEH;
cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG));
cmmAEH.Statements.Add(new CodeExpressionStatement(cmieAEH));
GenerateXmlComments(cmmAEH, cmmAEH.Name);
ctdClass.Members.Add(cmmAEH);
// }
//
cns.Types.Add(ctdClass);
// }
//
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cns);
// For VB only we need to let the parser know about the RootNamespace value
// in order to look for the XamlGeneratedNamespace.GeneratedInternalTypeHelper
// type whose full type name would have been implicitly by the VB comopiler to
// RootNS.XamlGeneratedNamespace.GeneratedInternalTypeHelper
if (IsLanguageVB && !string.IsNullOrEmpty(DefaultNamespace))
{
// [assembly: RootNamespaceAttribute("RootNS")]
CodeAttributeDeclaration cad = new CodeAttributeDeclaration(
"System.Windows.Markup.RootNamespaceAttribute",
new CodeAttributeArgument(new CodePrimitiveExpression(DefaultNamespace)));
ccu.AssemblyCustomAttributes.Add(cad);
}
MemoryStream codeMemStream = new MemoryStream();
// using Disposes the StreamWriter when it ends. Disposing the StreamWriter
// also closes the underlying MemoryStream. Furthermore, don't add BOM here since
// TaskFileService.WriteGeneratedCodeFile adds it.
using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
{
CodeGeneratorOptions o = new CodeGeneratorOptions();
CodeDomProvider codeProvider = EnsureCodeProvider();
codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o);
codeStreamWriter.Flush();
TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(),
TargetPath + SharedStrings.GeneratedInternalTypeHelperFileName,
SharedStrings.GeneratedExtension, SharedStrings.IntellisenseGeneratedExtension,
LanguageSourceExtension);
}
}
