private void EmitReturnStatement(CodeMethodReturnStatement Return)
{
Depth++;
Debug("Emitting return statement");
if (Method.ReturnType != typeof(void))
{
Type Top;
if (Return.Expression == null)
{
// Default to an empty string if this method expects a return value
Generator.Emit(OpCodes.Ldstr, "");
Top = typeof(string);
}
else Top = EmitExpression(Return.Expression);
if (Top != null)
ForceTopStack(Top, Method.ReturnType);
}
else if (Return.Expression != null)
throw new CompileException(Return, "Can not return value from void method " + Method.Name);
Generator.Emit(OpCodes.Ret);
Depth--;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeExpression expression = new CodeExpression ();
CodeMethodReturnStatement cmrs = new CodeMethodReturnStatement (expression);
Assert.AreSame (expression, cmrs.Expression, "Expression");
cmrs.Expression = new CodeExpression ();
}
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;
}
private void AddPropertyGroup(AssemblyBuilder assemblyBuilder, string groupName, string propertyNames, Hashtable properties, CodeTypeDeclaration type, CodeNamespace ns)
{
CodeMemberProperty property = new CodeMemberProperty {
Name = groupName,
Attributes = MemberAttributes.Public,
HasGet = true,
Type = new CodeTypeReference("ProfileGroup" + groupName)
};
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodeThisReferenceExpression(), MethodName = "GetProfileGroup" }
};
expression.Parameters.Add(new CodePrimitiveExpression(property.Name));
CodeMethodReturnStatement statement = new CodeMethodReturnStatement(new CodeCastExpression(property.Type, expression));
property.GetStatements.Add(statement);
type.Members.Add(property);
CodeTypeDeclaration declaration = new CodeTypeDeclaration {
Name = "ProfileGroup" + groupName
};
declaration.BaseTypes.Add(new CodeTypeReference(typeof(ProfileGroupBase)));
foreach (string str in propertyNames.Split(new char[] { ';' }))
{
this.CreateCodeForProperty(assemblyBuilder, declaration, (ProfileNameTypeStruct) properties[str]);
}
ns.Types.Add(declaration);
}
/// <summary>
/// Generates the <c>IRequestProvider.CreateRequest()</c> method.
/// </summary>
/// <returns><c>CodeMemberMethod</c> describing the method.</returns>
internal CodeMemberMethod GenerateCreateRequestMethod()
{
var method = new CodeMemberMethod();
method.Name = CreateRequestMethodName;
method.ImplementationTypes.Add(typeof(IRequestProvider));
method.ReturnType = new CodeTypeReference(typeof(IRequest));
method.Attributes = MemberAttributes.Public;
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "resource"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "method"));
//Google.Apis.Requests.Request request = this.genericService.CreateRequest(resource, method);
method.Statements.Add(CreateRequestLocalVar());
// if (string.IsNullOrEmpty(APIKey) == false)
// request = request.WithAPIKey(APIKey)
method.Statements.Add(CreateWithApiKey());
// return request.WithAuthentication(authenticator);
var statement =
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("request"), "WithAuthentication"),
new CodeVariableReferenceExpression(ServiceClassGenerator.AuthenticatorName));
var returnStatment = new CodeMethodReturnStatement(statement);
method.Statements.Add(returnStatment);
return method;
}
private void AddMemberOverride(string name, Type type, CodeExpression expr) {
CodeMemberProperty member = new CodeMemberProperty();
member.Name = name;
member.Attributes = MemberAttributes.Override | MemberAttributes.Family;
member.Type = new CodeTypeReference(type.FullName);
CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement(expr);
member.GetStatements.Add(returnStmt);
_sourceDataClass.Members.Add(member);
}
public override void Compile(IEnumerable<IColumInfoModel> columnInfos, Stream to = null)
{
if (string.IsNullOrEmpty(TableName))
{
TableName = TargetCsName;
}
var spAttribute = new CodeAttributeDeclaration(typeof(StoredProcedureAttribute).Name);
_base.CustomAttributes.Add(spAttribute);
if (_base.TypeParameters.Count == 0)
{
//_base.TypeParameters.Add(new CodeTypeParameter(typeof ().FullName));
}
//Create Caller
var createFactoryMethod = new CodeMemberMethod();
createFactoryMethod.Name = "Invoke" + TableName;
createFactoryMethod.ReturnType = new CodeTypeReference(typeof(QueryFactoryResult));
createFactoryMethod.CustomAttributes.Add(
new CodeAttributeDeclaration(typeof(SelectFactoryMethodAttribute).FullName));
//Create the Params
string query = "EXEC " + TableName;
var nameOfListOfParamater = "paramaters";
var listOfParams = new CodeObjectCreateExpression(typeof(List<IQueryParameter>));
var listOfParamscreator = new CodeVariableDeclarationStatement(typeof(List<IQueryParameter>), nameOfListOfParamater, listOfParams);
createFactoryMethod.Statements.Add(listOfParamscreator);
int i = 0;
foreach (var item in _base.Members)
{
if (item is CodeMemberProperty)
{
var variable = item as CodeMemberProperty;
var paramName = "param" + i++;
query += " @" + paramName + " ";
var createParams = new CodeObjectCreateExpression(typeof(QueryParameter),
new CodePrimitiveExpression(paramName),
new CodeVariableReferenceExpression(variable.Name));
var addToList =
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(nameOfListOfParamater),
"Add", createParams);
createFactoryMethod.Statements.Add(addToList);
}
}
//Finaly create the instance
var createFactory = new CodeObjectCreateExpression(typeof(QueryFactoryResult),
new CodePrimitiveExpression(query),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(nameOfListOfParamater), "ToArray"));
var queryFactoryVariable = new CodeMethodReturnStatement(createFactory);
createFactoryMethod.Statements.Add(queryFactoryVariable);
_base.Members.Add(createFactoryMethod);
}
private CodeCompileUnit GeneraCodigo()
{
//Unidad de Compilación (ensamblado)
var cu = new CodeCompileUnit();
cu.ReferencedAssemblies.Add("System.dll");//Ensamblados que enlaza (aunque este debería estar por defecto)
//Espacio de nombres
var n = new CodeNamespace("EjemploGeneracionCodigo1");
cu.Namespaces.Add(n);
n.Imports.Add(new CodeNamespaceImport("System"));//Espacios de nombres que utiliza este namespace para compilar
//Clase
var c = new CodeTypeDeclaration("ClaseGenerada");
n.Types.Add(c);
c.BaseTypes.Add(new CodeTypeReference(typeof(System.Timers.Timer)));//Su clase padre
c.IsPartial = true;
//Atributo de la clase
CodeMemberField mf = new CodeMemberField(typeof(string),"_atributo");
c.Members.Add(mf);
//Propiedad de la clase
CodeMemberProperty cp = new CodeMemberProperty();
c.Members.Add(cp);
cp.Attributes = MemberAttributes.Public | MemberAttributes.Final;//lo de Final para que no sea virtual (por defecto si es público es virtual)
cp.Type = new CodeTypeReference(typeof(string));
cp.Name = "atributo";
CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_atributo");
CodeMethodReturnStatement mrs = new CodeMethodReturnStatement(cfre);
cp.GetStatements.Add(mrs);
//Metodo de la clase
CodeMemberMethod cmm = new CodeMemberMethod();
c.Members.Add(cmm);
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Name = "Metodo1";
cmm.ReturnType = new CodeTypeReference(typeof(int));
CodeParameterDeclarationExpression pde = new CodeParameterDeclarationExpression(typeof(int),"enteroDeEntrada");
cmm.Parameters.Add(pde);
pde = new CodeParameterDeclarationExpression(typeof(string),"cadenaDeEntrada");
cmm.Parameters.Add(pde);
//Declaración de variable
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(typeof(string),"aux",new CodePrimitiveExpression("Prueba1") );
cmm.Statements.Add(vds);
//Llamar a método arbitrario
//variable a llamar y método
CodeMethodReferenceExpression ctr = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression("Console"),"WriteLine");
//Llamada en sí con sus parámetros
CodeMethodInvokeExpression invoke1 = new CodeMethodInvokeExpression( ctr, new CodeExpression[] {new CodePrimitiveExpression("Hola mundo")} );
cmm.Statements.Add(invoke1);
//Código a pelo. Ojo no se puede generar, por ejemplo, un foreach.
cmm.Statements.Add(new CodeSnippetStatement("foreach(string s in cadenas){"));
cmm.Statements.Add(new CodeSnippetStatement("Console.WriteLine(s);"));
cmm.Statements.Add(new CodeSnippetStatement("}"));
mrs = new CodeMethodReturnStatement(new CodePrimitiveExpression(42));
cmm.Statements.Add(mrs);
return cu;
}
// Generate a codedom return statement.
public static CodeStatement Emit(Return r)
{
var codeMethodReturnStatement = new CodeMethodReturnStatement();
// Attach the expression to return, if any.
if(r.ChildExpressions.Count > 0)
codeMethodReturnStatement.Expression = CodeDomEmitter.EmitCodeExpression(r.ChildExpressions[0]);
return codeMethodReturnStatement;
}
internal void AddFactoryMethod(string typeToCreate)
{
CodeMemberMethod method = new CodeMemberMethod {
Name = GetCreateMethodNameForType(typeToCreate),
ReturnType = new CodeTypeReference(typeof(object)),
Attributes = MemberAttributes.Static
};
CodeMethodReturnStatement statement = new CodeMethodReturnStatement(new CodeObjectCreateExpression(typeToCreate, new CodeExpression[0]));
method.Statements.Add(statement);
this._factoryClass.Members.Add(method);
}
public static CodeMethodReturnStatement Clone(this CodeMethodReturnStatement statement)
{
if (statement == null) return null;
CodeMethodReturnStatement s = new CodeMethodReturnStatement();
s.EndDirectives.AddRange(statement.EndDirectives);
s.Expression = statement.Expression.Clone();
s.LinePragma = statement.LinePragma;
s.StartDirectives.AddRange(statement.StartDirectives);
s.UserData.AddRange(statement.UserData);
return s;
}
private void AddMemberOverride(string name, Type type, CodeExpression expr)
{
CodeMemberProperty property = new CodeMemberProperty {
Name = name,
Attributes = MemberAttributes.Family | MemberAttributes.Override,
Type = new CodeTypeReference(type.FullName)
};
CodeMethodReturnStatement statement = new CodeMethodReturnStatement(expr);
property.GetStatements.Add(statement);
base._sourceDataClass.Members.Add(property);
}
public TypescriptMethodReturnStatement(
IStatementFactory statementFactory,
IExpressionFactory expressionFactory,
CodeMethodReturnStatement statement,
CodeGeneratorOptions options)
{
_statementFactory = statementFactory;
_expressionFactory = expressionFactory;
_statement = statement;
_options = options;
}
/// <summary>
///
/// </summary>
/// <param name="member"></param>
/// <param name="inner"></param>
/// <param name="attrs"></param>
/// <returns></returns>
public CodeTypeMember CreateMember(MemberInfo member, CodeFieldReferenceExpression inner, MemberAttributes attrs)
{
Debug.Assert(member is MethodInfo);
MethodInfo method = member as MethodInfo;
CodeMemberMethod codeMethod = new CodeMemberMethod();
codeMethod.Name = method.Name;
codeMethod.ReturnType = new CodeTypeReference(method.ReturnType);
codeMethod.Attributes = attrs;
// try
CodeTryCatchFinallyStatement tryCode = new CodeTryCatchFinallyStatement();
// decleare parameters
List<CodeArgumentReferenceExpression> codeParamiteRefrs = new List<CodeArgumentReferenceExpression>();
foreach (ParameterInfo codeParameter in method.GetParameters()) {
CodeParameterDeclarationExpression codeParameterDeclare = new CodeParameterDeclarationExpression(codeParameter.ParameterType, codeParameter.Name);
codeMethod.Parameters.Add(codeParameterDeclare);
codeParamiteRefrs.Add(new CodeArgumentReferenceExpression(codeParameter.Name));
}
// invoke
CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression(
inner, method.Name, codeParamiteRefrs.ToArray());
if (method.ReturnType.Name.ToLower() == "void") {
tryCode.TryStatements.Add(invokeMethod);
} else {
CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(method.ReturnType, "returnObject", invokeMethod);
//CodeAssignStatement assign = new CodeAssignStatement(var, invokeMethod);
tryCode.TryStatements.Add(var);
CodeCommentStatement todo = new CodeCommentStatement("TODO: your code", false);
tryCode.TryStatements.Add(todo);
CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("returnObject");
CodeMethodReturnStatement codeReturn = new CodeMethodReturnStatement(varRef);
tryCode.TryStatements.Add(codeReturn);
}
// catch
CodeTypeReference codeTypeRef = new CodeTypeReference(typeof(Exception));
CodeCatchClause catchClause = new CodeCatchClause("ex", codeTypeRef);
catchClause.Statements.Add(new CodeThrowExceptionStatement());
tryCode.CatchClauses.Add(catchClause);
codeMethod.Statements.Add(tryCode);
return codeMethod;
}
private void AddCodeForGetProfileForUser(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod {
Name = "GetProfile",
Attributes = MemberAttributes.Public,
ReturnType = new CodeTypeReference("ProfileCommon")
};
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "username"));
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodeTypeReferenceExpression("ProfileBase"), MethodName = "Create" }
};
expression.Parameters.Add(new CodeArgumentReferenceExpression("username"));
CodeMethodReturnStatement statement = new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, expression));
MTConfigUtil.GetProfileAppConfig();
method.Statements.Add(statement);
type.Members.Add(method);
}
public CodeMemberProperty CreateProperty(Type type, string propertyName)
{
var codeMemberProperty = new CodeMemberProperty
{
Name = propertyName,
HasGet = true,
HasSet = true,
Attributes = MemberAttributes.Public,
Type = new CodeTypeReference(type)
};
var fieldName = propertyName.MakeFirstCharLowerCase();
var codeFieldReferenceExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
var returnStatement = new CodeMethodReturnStatement(codeFieldReferenceExpression);
codeMemberProperty.GetStatements.Add(returnStatement);
var assignStatement = new CodeAssignStatement(codeFieldReferenceExpression, new CodePropertySetValueReferenceExpression());
codeMemberProperty.SetStatements.Add(assignStatement);
return codeMemberProperty;
}
public CodeMethodReturnStatement Return(CodeExpression expr)
{
CodeMethodReturnStatement st = new CodeMethodReturnStatement(expr);
csc.Add(st);
return st;
}
// ReSharper disable once FunctionComplexityOverflow
public void AddMembersTo(CodeTypeDeclaration typeDeclaration, bool withDataBinding)
{
CodeTypeMember member;
var typeClassModel = TypeClassModel;
var isArray = IsArray;
var propertyType = PropertyType;
var isNullableValueType = IsNullableValueType;
var typeReference = TypeReference;
var simpleType = propertyType as SimpleModel;
var requiresBackingField = withDataBinding || DefaultValue != null || IsCollection || isArray;
var backingField = new CodeMemberField(typeReference, OwningType.GetUniqueFieldName(this))
{
Attributes = MemberAttributes.Private
};
var ignoreAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlIgnoreAttribute)));
var notMappedAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(NotMappedAttribute)));
backingField.CustomAttributes.Add(ignoreAttribute);
if (requiresBackingField)
{
typeDeclaration.Members.Add(backingField);
}
if (DefaultValue == null)
{
var propertyName = isNullableValueType && Configuration.GenerateNullables ? Name + "Value" : Name;
member = new CodeMemberField(typeReference, propertyName);
var isPrivateSetter = IsCollection || isArray;
if (requiresBackingField)
{
member.Name += GetAccessors(member.Name, backingField.Name,
IsCollection || isArray ? PropertyValueTypeCode.Array : propertyType.GetPropertyValueTypeCode(),
isPrivateSetter, withDataBinding);
}
else
{
// hack to generate automatic property
member.Name += isPrivateSetter ? " { get; private set; }" : " { get; set; }";
}
}
else
{
var defaultValueExpression = propertyType.GetDefaultValueFor(DefaultValue);
backingField.InitExpression = defaultValueExpression;
member = new CodeMemberField(typeReference, Name);
member.Name += GetAccessors(member.Name, backingField.Name, propertyType.GetPropertyValueTypeCode(), false, withDataBinding);
if (IsNullable)
{
if (!(defaultValueExpression is CodeObjectCreateExpression))
{
var defaultValueAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(DefaultValueAttribute)),
new CodeAttributeArgument(defaultValueExpression));
member.CustomAttributes.Add(defaultValueAttribute);
}
}
}
member.Attributes = MemberAttributes.Public;
typeDeclaration.Members.Add(member);
AddDocs(member);
if (IsDeprecated)
{
// From .NET 3.5 XmlSerializer doesn't serialize objects with [Obsolete] >(
//var deprecatedAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(ObsoleteAttribute)));
//member.CustomAttributes.Add(deprecatedAttribute);
}
if (isNullableValueType)
{
var specifiedName = Configuration.GenerateNullables ? Name + "Value" : Name;
var specifiedMember = new CodeMemberField(typeof(bool), specifiedName + "Specified { get; set; }");
specifiedMember.CustomAttributes.Add(ignoreAttribute);
if (Configuration.EntityFramework && Configuration.GenerateNullables) specifiedMember.CustomAttributes.Add(notMappedAttribute);
specifiedMember.Attributes = MemberAttributes.Public;
var specifiedDocs = new[] { new DocumentationModel { Language = "en", Text = string.Format("Gets or sets a value indicating whether the {0} property is specified.", Name) },
new DocumentationModel { Language = "de", Text = string.Format("Ruft einen Wert ab, der angibt, ob die {0}-Eigenschaft spezifiziert ist, oder legt diesen fest.", Name) } };
specifiedMember.Comments.AddRange(DocumentationModel.GetComments(specifiedDocs).ToArray());
typeDeclaration.Members.Add(specifiedMember);
if (Configuration.GenerateNullables)
{
// public X? Name
// {
// get { return NameSpecified ? NameValue : null; }
// set
// {
// NameValue = value.GetValueOrDefault();
// NameSpecified = value.HasValue;
// }
// }
var nullableType = new CodeTypeReference(typeof(Nullable<>));
nullableType.TypeArguments.Add(typeReference);
var nullableMember = new CodeMemberProperty
{
Type = nullableType,
Name = Name,
HasSet = true,
HasGet = true,
Attributes = MemberAttributes.Public | MemberAttributes.Final,
};
nullableMember.CustomAttributes.Add(ignoreAttribute);
nullableMember.Comments.AddRange(member.Comments);
var specifiedExpression = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), specifiedName + "Specified");
var valueExpression = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), Name + "Value");
var conditionStatement = new CodeConditionStatement(specifiedExpression,
new CodeStatement[] { new CodeMethodReturnStatement(valueExpression) },
new CodeStatement[] { new CodeMethodReturnStatement(new CodePrimitiveExpression(null)) });
nullableMember.GetStatements.Add(conditionStatement);
var getValueOrDefaultExpression = new CodeMethodInvokeExpression(new CodePropertySetValueReferenceExpression(), "GetValueOrDefault");
var setValueStatement = new CodeAssignStatement(valueExpression, getValueOrDefaultExpression);
var hasValueExpression = new CodePropertyReferenceExpression(new CodePropertySetValueReferenceExpression(), "HasValue");
var setSpecifiedStatement = new CodeAssignStatement(specifiedExpression, hasValueExpression);
var statements = new List<CodeStatement>();
if (withDataBinding)
{
var ifNotEquals = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeMethodInvokeExpression(valueExpression, "Equals", getValueOrDefaultExpression),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(false)
),
setValueStatement,
setSpecifiedStatement,
new CodeExpressionStatement(new CodeMethodInvokeExpression(null, "OnPropertyChanged",
new CodePrimitiveExpression(Name)))
);
statements.Add(ifNotEquals);
}
else
{
statements.Add(setValueStatement);
statements.Add(setSpecifiedStatement);
}
nullableMember.SetStatements.AddRange(statements.ToArray());
typeDeclaration.Members.Add(nullableMember);
var editorBrowsableAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(EditorBrowsableAttribute)));
editorBrowsableAttribute.Arguments.Add(new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), "Never")));
specifiedMember.CustomAttributes.Add(editorBrowsableAttribute);
member.CustomAttributes.Add(editorBrowsableAttribute);
if (Configuration.EntityFramework) member.CustomAttributes.Add(notMappedAttribute);
}
}
else if ((IsCollection || isArray) && IsNullable && !IsAttribute)
{
var specifiedProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(bool)),
Name = Name + "Specified",
HasSet = false,
HasGet = true,
};
specifiedProperty.CustomAttributes.Add(ignoreAttribute);
if (Configuration.EntityFramework) specifiedProperty.CustomAttributes.Add(notMappedAttribute);
specifiedProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
var listReference = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), Name);
var countReference = new CodePropertyReferenceExpression(listReference, "Count");
var notZeroExpression = new CodeBinaryOperatorExpression(countReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(0));
var returnStatement = new CodeMethodReturnStatement(notZeroExpression);
specifiedProperty.GetStatements.Add(returnStatement);
var specifiedDocs = new[] { new DocumentationModel { Language = "en", Text = string.Format("Gets a value indicating whether the {0} collection is empty.", Name) },
new DocumentationModel { Language = "de", Text = string.Format("Ruft einen Wert ab, der angibt, ob die {0}-Collection leer ist.", Name) } };
specifiedProperty.Comments.AddRange(DocumentationModel.GetComments(specifiedDocs).ToArray());
typeDeclaration.Members.Add(specifiedProperty);
}
var attribute = GetAttribute(isArray);
member.CustomAttributes.Add(attribute);
// initialize List<>
if (IsCollection || isArray)
{
var constructor = typeDeclaration.Members.OfType<CodeConstructor>().FirstOrDefault();
if (constructor == null)
{
constructor = new CodeConstructor { Attributes = MemberAttributes.Public | MemberAttributes.Final };
var constructorDocs = new[] { new DocumentationModel { Language = "en", Text = string.Format(@"Initializes a new instance of the <see cref=""{0}"" /> class.", typeDeclaration.Name) },
new DocumentationModel { Language = "de", Text = string.Format(@"Initialisiert eine neue Instanz der <see cref=""{0}"" /> Klasse.", typeDeclaration.Name) } };
constructor.Comments.AddRange(DocumentationModel.GetComments(constructorDocs).ToArray());
typeDeclaration.Members.Add(constructor);
}
var listReference = requiresBackingField ? (CodeExpression)new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name) :
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), Name);
var initTypeReference = propertyType.GetReferenceFor(OwningType.Namespace, true, true);
var initExpression = new CodeObjectCreateExpression(initTypeReference);
constructor.Statements.Add(new CodeAssignStatement(listReference, initExpression));
}
if (isArray)
{
var arrayItemProperty = typeClassModel.Properties[0];
var propertyAttribute = arrayItemProperty.GetAttribute(false);
// HACK: repackage as ArrayItemAttribute
var arrayItemAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlArrayItemAttribute)),
propertyAttribute.Arguments.Cast<CodeAttributeArgument>().Where(x => !string.Equals(x.Name, "Order", StringComparison.Ordinal)).ToArray());
member.CustomAttributes.Add(arrayItemAttribute);
}
if (IsKey)
{
var keyAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(KeyAttribute)));
member.CustomAttributes.Add(keyAttribute);
}
if (IsAny && Configuration.EntityFramework)
{
member.CustomAttributes.Add(notMappedAttribute);
}
}
internal void GenerateProcessMethod(BrowserDefinition bd, CodeTypeDeclaration ctd, string prefix)
{
CodeMemberMethod cmm = new CodeMemberMethod {
Name = prefix + bd.Name + "Process",
ReturnType = new CodeTypeReference(typeof(bool)),
Attributes = MemberAttributes.Private
};
CodeParameterDeclarationExpression expression = new CodeParameterDeclarationExpression(typeof(NameValueCollection), "headers");
cmm.Parameters.Add(expression);
expression = new CodeParameterDeclarationExpression(typeof(HttpBrowserCapabilities), "browserCaps");
cmm.Parameters.Add(expression);
bool regexWorkerGenerated = false;
this.GenerateIdentificationCode(bd, cmm, ref regexWorkerGenerated);
this.GenerateCapturesCode(bd, cmm, ref regexWorkerGenerated);
this.GenerateSetCapabilitiesCode(bd, cmm, ref regexWorkerGenerated);
this.GenerateSetAdaptersCode(bd, cmm);
if (bd.IsDeviceNode)
{
CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("browserCaps"), "AddBrowser", new CodeExpression[0]);
expression2.Parameters.Add(new CodePrimitiveExpression(bd.ID));
cmm.Statements.Add(expression2);
}
foreach (BrowserDefinition definition in bd.RefGateways)
{
this.AddComment("ref gateways, parent=" + bd.ID, cmm);
this.GenerateSingleProcessCall(definition, cmm);
}
if (this.GenerateOverrides && (prefix.Length == 0))
{
string methodName = prefix + bd.Name + "ProcessGateways";
this.GenerateChildProcessMethod(methodName, ctd, false);
this.GenerateChildProcessInvokeExpression(methodName, cmm, false);
}
foreach (BrowserDefinition definition2 in bd.Gateways)
{
this.AddComment("gateway, parent=" + bd.ID, cmm);
this.GenerateSingleProcessCall(definition2, cmm);
}
if (this.GenerateOverrides)
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeof(bool), "ignoreApplicationBrowsers", new CodePrimitiveExpression(bd.Browsers.Count != 0));
cmm.Statements.Add(statement);
}
if (bd.Browsers.Count > 0)
{
CodeStatementCollection stmts = cmm.Statements;
this.AddComment("browser, parent=" + bd.ID, cmm);
foreach (BrowserDefinition definition3 in bd.Browsers)
{
stmts = this.GenerateTrackedSingleProcessCall(stmts, definition3, cmm, prefix);
}
if (this.GenerateOverrides)
{
CodeAssignStatement statement2 = new CodeAssignStatement {
Left = new CodeVariableReferenceExpression("ignoreApplicationBrowsers"),
Right = new CodePrimitiveExpression(false)
};
stmts.Add(statement2);
}
}
foreach (BrowserDefinition definition4 in bd.RefBrowsers)
{
this.AddComment("ref browsers, parent=" + bd.ID, cmm);
if (definition4.IsDefaultBrowser)
{
this.GenerateSingleProcessCall(definition4, cmm, "Default");
}
else
{
this.GenerateSingleProcessCall(definition4, cmm);
}
}
if (this.GenerateOverrides)
{
string str2 = prefix + bd.Name + "ProcessBrowsers";
this.GenerateChildProcessMethod(str2, ctd, true);
this.GenerateChildProcessInvokeExpression(str2, cmm, true);
}
CodeMethodReturnStatement statement3 = new CodeMethodReturnStatement(new CodePrimitiveExpression(true));
cmm.Statements.Add(statement3);
ctd.Members.Add(cmm);
}
/// <summary>
/// Adds a method to the class. This method multiplies values stored
/// in both fields.
/// </summary>
public void AddMethod()
{
// Declaring a ToString method
CodeMemberMethod toStringMethod = new CodeMemberMethod();
toStringMethod.Attributes =
MemberAttributes.Public | MemberAttributes.Override;
toStringMethod.Name = "ToString";
toStringMethod.ReturnType =
new CodeTypeReference(typeof(System.String));
CodeFieldReferenceExpression widthReference =
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), "Width");
CodeFieldReferenceExpression heightReference =
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), "Height");
CodeFieldReferenceExpression areaReference =
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), "Area");
// Declaring a return statement for method ToString.
CodeMethodReturnStatement returnStatement =
new CodeMethodReturnStatement();
// This statement returns a string representation of the width,
// height, and area.
string formattedOutput = "The object:" + Environment.NewLine +
" width = {0}," + Environment.NewLine +
" height = {1}," + Environment.NewLine +
" area = {2}";
returnStatement.Expression =
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.String"), "Format",
new CodePrimitiveExpression(formattedOutput),
widthReference, heightReference, areaReference);
toStringMethod.Statements.Add(returnStatement);
targetClass.Members.Add(toStringMethod);
}
public override object Visit(ReturnStatement returnStatement, object data)
{
ProcessSpecials(returnStatement.Specials);
CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement((CodeExpression)returnStatement.ReturnExpression.AcceptVisitor(this,data));
AddStmt(returnStmt);
return returnStmt;
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(System.CodeDom.CodeTypeDeclaration codeClass, System.CodeDom.CodeStatementCollection codeStatementCollection, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context)
{
MethodInvokeParameterControl retCtrl = null;
Dictionary <BaseNodeControl, System.CodeDom.CodeExpression> paramCodeExps = new Dictionary <BaseNodeControl, System.CodeDom.CodeExpression>();
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
var param = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
if (param.ParamInfo.ParamName == "Return")
{
retCtrl = pm;
continue;
}
if (pm.HasLink())
{
await pm.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, pm.ParamPin, context);
var exp = new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParamInfo.ParameterType, pm.GCode_CodeDom_GetValue(pm.ParamPin, context));
paramCodeExps[paramNode] = exp;
codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(
new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName),
exp));
}
else if (mTemplateClassInstance != null)
{
var proInfo = mTemplateClassInstance.GetType().GetProperty(param.ParamInfo.ParamName);
object proValue;
if (proInfo == null)
{
proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType);
}
else
{
proValue = proInfo.GetValue(mTemplateClassInstance);
}
var valueExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue);
paramCodeExps[paramNode] = valueExp;
codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName), valueExp));
}
}
else
{
throw new InvalidOperationException();
}
}
if (retCtrl != null)
{
if (retCtrl.HasLink())
{
await retCtrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, retCtrl.ParamPin, context);
}
System.CodeDom.CodeExpression retExp = null;
if (retCtrl.HasLink())
{
var retStatement = new System.CodeDom.CodeMethodReturnStatement();
retExp = retCtrl.GCode_CodeDom_GetValue(retCtrl.ParamPin, context);
paramCodeExps[retCtrl] = retExp;
}
else if (mTemplateClassInstance != null)
{
var param = retCtrl.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
var proInfo = mTemplateClassInstance.GetType().GetProperty("Return");
object proValue;
if (proInfo == null)
{
proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType);
}
else
{
proValue = proInfo.GetValue(mTemplateClassInstance);
}
retExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue);
paramCodeExps[retCtrl] = retExp;
}
#region Debug
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection);
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
System.CodeDom.CodeExpression exp;
if (paramCodeExps.TryGetValue(paramNode, out exp))
{
CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, pm.ParamPin.GetLinkPinKeyName(), exp, pm.GCode_GetTypeString(pm.ParamPin, context), context);
}
}
else
{
throw new InvalidOperationException("未实现");
}
}
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes);
#endregion
var returnParam = CSParam as ReturnConstructParam;
foreach (var param in returnParam.MethodInfo.Params)
{
// ref或out，需要将displayType造成的临时变量再赋给原函数参数
if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null)
{
codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("temp___" + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName))));
}
}
if (returnParam.MethodInfo.ReturnType.BaseType == typeof(System.Threading.Tasks.Task))
{
var genericType = returnParam.MethodInfo.ReturnType.GetGenericArguments()[0];
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(new CodeGenerateSystem.CodeDom.CodeCastExpression(genericType, retExp)));
}
else
{
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(new CodeGenerateSystem.CodeDom.CodeCastExpression(returnParam.MethodInfo.ReturnType, retExp)));
}
}
else
{
#region Debug
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection);
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes);
#endregion
var returnParam = CSParam as ReturnConstructParam;
foreach (var param in returnParam.MethodInfo.Params)
{
// ref或out，需要将displayType造成的临时变量再赋给原函数参数
if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null)
{
codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("temp___" + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName))));
}
}
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement());
}
}
protected override void GenerateMethodReturnStatement(System.CodeDom.CodeMethodReturnStatement e)
{
throw new Exception("The method or operation is not implemented.");
}
/// <summary>
/// Generate Code to put the views in the generated code.
/// </summary>
/// <param name="typeDeclaration"></param>
/// <param name="generatedViews"></param>
/// <returns></returns>
private static void CreateAndAddGetViewAtMethod(CodeTypeDeclaration typeDeclaration, Dictionary<EntitySetBase, string> generatedViews)
{
//Add the views to a method
CodeMemberMethod getViewAtMethod = new CodeMemberMethod();
getViewAtMethod.Name = EntityViewGenerationConstants.GetViewAtMethodName;
getViewAtMethod.ReturnType = new CodeTypeReference(typeof(KeyValuePair<,>).MakeGenericType(new Type[] { typeof(string), typeof(string) }));
CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "index");
getViewAtMethod.Parameters.Add(parameter);
getViewAtMethod.Comments.Add(new CodeCommentStatement(EntityViewGenerationConstants.SummaryStartElement, true /*docComment*/));
getViewAtMethod.Comments.Add(new CodeCommentStatement(Strings.GetViewAtMethodComments, true /*docComment*/));
getViewAtMethod.Comments.Add(new CodeCommentStatement(EntityViewGenerationConstants.SummaryEndElement, true /*docComment*/));
getViewAtMethod.Attributes = MemberAttributes.Family | MemberAttributes.Override;
typeDeclaration.Members.Add(getViewAtMethod);
int index = 0;
CodeVariableReferenceExpression indexParameterReference = new CodeVariableReferenceExpression(getViewAtMethod.Parameters[0].Name);
foreach (KeyValuePair<EntitySetBase, string> generatedViewPair in generatedViews)
{
// the CodeDom does not support the following scenarios
// 1. switch statement
// 2. if(){} else if(){}
// The original design here was to have the following code,
// if() { else { if(){} } }
// but this had some drawbacks as described in TFS workitem 590996
// Given the not supported scenarios in CodeDom, we choose only use if statement in this case
// if(index == 0)
CodeConditionStatement currentIf = new CodeConditionStatement(new CodeBinaryOperatorExpression(
indexParameterReference, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(index)));
getViewAtMethod.Statements.Add(currentIf);
EntitySetBase entitySet = generatedViewPair.Key;
string extentFullName = GetExtentFullName(entitySet);
CodeMemberMethod viewMethod = CreateViewReturnMethod(extentFullName, index, generatedViewPair.Value);
typeDeclaration.Members.Add(viewMethod);
// return GetNorthwindContext_Customers();
CodeMethodReturnStatement returnViewMethodCall = new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(null, viewMethod.Name)));
currentIf.TrueStatements.Add(returnViewMethodCall);
index++;
}
// if an invalid index is asked for throw
getViewAtMethod.Statements.Add(new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(new CodeTypeReference(typeof(IndexOutOfRangeException)))));
}
protected override void GenerateMethodReturnStatement(CodeMethodReturnStatement e)
{
Output.WriteLine("[CodeMethodReturnStatement: {0}]", e.ToString());
}
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);
}
private void CheckOccurrence(CodeStatementCollection getStatements)
{
Debug.Assert(!this.IsList);
CodeStatement returnStatement = null;
if (IsNullable && DefaultValue == null)
{
if (typeRef.IsValueType)
{
// Need to return T?, since parseValue handles only T,
// checking for null
returnStatement = new CodeMethodReturnStatement(
new CodePrimitiveExpression(null));
}
}
else if (VerifyRequired)
{
Debug.Assert(this.occursInSchema == Occurs.One);
string origin =
this.propertyOrigin == SchemaOrigin.Element ?
"Element" :
this.propertyOrigin == SchemaOrigin.Attribute ?
"Attribute":
// otherwise
null;
returnStatement = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(Constants.LinqToXsdException, new CodePrimitiveExpression("Missing required " + origin)));
}
if (returnStatement != null) {
getStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x"),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
returnStatement));
}
}
protected override void GenerateMethodReturnStatement(CodeMethodReturnStatement e)
{
if (e.Expression != null)
{
base.Output.Write("Return ");
base.GenerateExpression(e.Expression);
base.Output.WriteLine("");
}
else
{
base.Output.WriteLine("Return");
}
}
public CodeMemberProperty CreateProperty(Type type, string propertyName, bool fieldIsNull, bool useLazy = true)
{
bool setFieldAsNullable = fieldIsNull && IsNullable(type);
var codeMemberProperty = new CodeMemberProperty
{
Name = propertyName,
HasGet = true,
HasSet = true,
Attributes = MemberAttributes.Public,
Type =
(setFieldAsNullable
? new CodeTypeReference(typeof(Nullable))
: new CodeTypeReference(type))
};
if (setFieldAsNullable)
codeMemberProperty.Type.TypeArguments.Add(type);
string fieldName = "_" + propertyName.MakeFirstCharLowerCase();
var codeFieldReferenceExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
fieldName);
var returnStatement = new CodeMethodReturnStatement(codeFieldReferenceExpression);
codeMemberProperty.GetStatements.Add(returnStatement);
var assignStatement = new CodeAssignStatement(codeFieldReferenceExpression,
new CodePropertySetValueReferenceExpression());
codeMemberProperty.SetStatements.Add(assignStatement);
if (!useLazy)
codeMemberProperty.Attributes = codeMemberProperty.Attributes | MemberAttributes.Final;
return codeMemberProperty;
}
public override object VisitReturnStatement(ReturnStatement returnStatement, object data)
{
CodeMethodReturnStatement returnStmt;
if (returnStatement.Expression.IsNull)
returnStmt = new CodeMethodReturnStatement();
else
returnStmt = new CodeMethodReturnStatement((CodeExpression)returnStatement.Expression.AcceptVisitor(this,data));
AddStmt(returnStmt);
return returnStmt;
}
internal CodeMemberProperty CreatePropertyDeclaration(CodeMemberField field, string name, string typeName) {
CodeMemberProperty prop = new CodeMemberProperty();
prop.Type = new CodeTypeReference(typeName);
prop.Name = name;
prop.Attributes = (prop.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
//add get
CodeMethodReturnStatement ret = new CodeMethodReturnStatement();
ret.Expression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
prop.GetStatements.Add(ret);
CodeAssignStatement propertySet = new CodeAssignStatement();
CodeExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
CodeExpression right = new CodePropertySetValueReferenceExpression();
propertySet.Left = left;
propertySet.Right = right;
if (EnableDataBinding)
{
prop.SetStatements.Add(propertySet);
prop.SetStatements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), RaisePropertyChangedEventMethod.Name, new CodePrimitiveExpression(name)));
}
else
prop.SetStatements.Add(propertySet);
return prop;
}
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);
}
