public override System.CodeDom.CodeExpression GetCodeExpression( BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context) { CodeTypeReferenceExpression targetClass = new CodeTypeReferenceExpression(typeof(ExpressionBuilderIdentity)); string targetMethod = "GetIdentity"; CodeExpression methodParameter = new CodePrimitiveExpression(entry.Expression.Trim()); return new CodeMethodInvokeExpression( targetClass, targetMethod, methodParameter); }
//public static string ToPrettyString<TException>(this TException exception, ExceptionOrder order = ExceptionOrder.Ascending, int indentWidth = 4) where TException : Exception //{ // var nodes = exception.SelectMany(); // var exceptionStrings = nodes.Select(n => BuildExceptionString(n.Exception, n.Depth)).ToList(); // if (order == ExceptionOrder.Ascending) { exceptionStrings.Reverse(); } // return string.Join(Environment.NewLine, exceptionStrings); // string BuildExceptionString(Exception ex, int depth) // { // return // new ExceptionStringBuilder(indentWidth) // .AppendExceptionMessage(ex, depth) // .AppendInnerExceptionCount(ex, depth) // .AppendExceptionProperties(ex, depth) // .AppendExceptionData(ex, depth) // .AppendExceptionStackTrace(ex, depth); // } //} public string Render(Type type, bool includeNamespace) { if (type == null) { throw new ArgumentNullException(nameof(type)); } using (var codeDomProvider = CodeDomProvider.CreateProvider("C#")) using (var stringWriter = new StringWriter()) { var typeReferenceExpression = new CodeTypeReferenceExpression(type); codeDomProvider.GenerateCodeFromExpression(typeReferenceExpression, stringWriter, new CodeGeneratorOptions()); var typeName = stringWriter.GetStringBuilder().ToString(); return(includeNamespace ? typeName : RemoveNamespace(typeName)); } }
private static CodeConditionStatement CreateStringCompareStatement(CodeMemberMethod methodToAddTo, string action, string paramName, string returnActionName) { MethodInfo stringEqualsMethodInfo = GetMethodInfo <string>(set => string.Equals(null, null, StringComparison.CurrentCultureIgnoreCase)); CodeTypeReferenceExpression stringType = new CodeTypeReferenceExpression(typeof(string)); CodePrimitiveExpression actionName = new CodePrimitiveExpression(action); CodeVariableReferenceExpression pathName = new CodeVariableReferenceExpression(paramName); CodeVariableReferenceExpression caseInvariantName = new CodeVariableReferenceExpression("StringComparison.CurrentCultureIgnoreCase"); CodeMethodInvokeExpression stringCompare = new CodeMethodInvokeExpression(stringType, stringEqualsMethodInfo.Name, pathName, actionName, caseInvariantName); CodeMethodReturnStatement returnAction = new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(SteamVR_Input)), returnActionName)); CodeConditionStatement condition = new CodeConditionStatement(stringCompare, returnAction); methodToAddTo.Statements.Add(condition); return(condition); }
private string GetReturnType(MethodBase methodBase) { var returnTypeFullName = (methodBase as MethodInfo).ReturnType.FullName; return(_cache.GetOrCreate(returnTypeFullName, (ce) => { StringBuilder sb = new StringBuilder(); using (StringWriter sw = new StringWriter(sb)) { var expr = new CodeTypeReferenceExpression(returnTypeFullName); var prov = new CSharpCodeProvider(); prov.GenerateCodeFromExpression(expr, sw, new CodeGeneratorOptions()); } return sb.ToString(); })); }
private CodeExpression GenerateAspectInvocationForProperty(bool isGet) { var parameterDictionaryExpression = this.GenerateParameterDictionaryExpression(isGet); var aspectExecutorExpression = new CodeTypeReferenceExpression(typeof(AspectExecutor)); var getCurrentMethodExpression = new CodeSnippetExpression( string.Format("{0}.GetType().GetProperty(\"{1}\")", VariableNames.Target, this.memberInfo.Name)); var returnValueExpression = new CodeDirectionExpression( FieldDirection.Ref, Constructs.BoxedReturnValueExpression); return(new CodeMethodInvokeExpression(aspectExecutorExpression, "ExecuteEntryAspects", Constructs.TargetFieldExpression, getCurrentMethodExpression, parameterDictionaryExpression, returnValueExpression)); }
protected virtual void AddConstructorCode(CodeConstructor constructor, ISitecoreConnectionSettings settings) { var contextDb = settings.ContextDatabaseName; if (string.IsNullOrEmpty(contextDb)) { contextDb = "master"; } var targetObject = new CodeTypeReferenceExpression(new CodeTypeReference("Sitecore.Data.Database")); var right = new CodeMethodInvokeExpression(targetObject, "GetDatabase", new CodeExpression[] { new CodePrimitiveExpression(contextDb) }); var expression3 = new CodeTypeReferenceExpression(new CodeTypeReference("Sitecore.Context")); var left = new CodePropertyReferenceExpression(expression3, "Database"); var statement = new CodeAssignStatement(left, right); constructor.Statements.Add(statement); }
private CodeExpression GenerateAspectInvocationForMethod(bool returnsValue) { var parameterDictionaryExpression = this.GenerateParameterDictionaryExpression(returnsValue); var aspectExecutorExpression = new CodeTypeReferenceExpression(typeof(AspectExecutor)); var getCurrentMethodExpression = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"); var returnValueExpression = new CodeDirectionExpression( FieldDirection.Ref, Constructs.BoxedReturnValueExpression); return(new CodeMethodInvokeExpression(aspectExecutorExpression, "ExecuteEntryAspects", Constructs.TargetFieldExpression, getCurrentMethodExpression, parameterDictionaryExpression, returnValueExpression)); }
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context) { // entry.Expression - строка с числом // без префикса (например: "1,6"). if (!entry.Expression.Contains(",")) { throw new ArgumentException(" Должны быть указаны два числа, разделенные запятой"); } else { // Получить два числа string[] numbers = entry.Expression.Split(','); if (numbers.Length != 2) { throw new ArgumentException("Должны быть указаны два числа"); } else { int min, max; if (Int32.TryParse(numbers[0], out min) && Int32.TryParse(numbers[1], out max)) { // Получить ссылку на класс, имеющий метод GetRandomNumber(). // (Это класс, где данный код выполняется.) CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType()); // Определить параметры для GetRandomNumber(). CodeExpression[] methodParameters = new CodeExpression[2]; methodParameters[0] = new CodePrimitiveExpression(min); methodParameters[1] = new CodePrimitiveExpression(max); // Вернуть выражение привязки вызвав метод GetRandomNumber() CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression( typeRef, "GetRandomNumber", methodParameters); return methodCall; } else { throw new ArgumentException("Должны использоваться допустимые целые числа"); } } } }
public override CodeExpression CreateMethodInvokeCode(string typeString, CodeExpressionCollection parameters, CodeStatementCollection statements) { CodeMethodInvokeExpression cmi = new CodeMethodInvokeExpression(); if (parameters != null) { foreach (CodeExpression p in parameters) { cmi.Parameters.Add(p); } } CodeTypeReferenceExpression t = new CodeTypeReferenceExpression(typeString); CodePropertyReferenceExpression pr = new CodePropertyReferenceExpression(t, DrawingPage.DEFAULTFORM); cmi.Method = new CodeMethodReferenceExpression(pr, MethodName); return(cmi); }
/// <include file='doc\EnumCodeDomSerializer.uex' path='docs/doc[@for="EnumCodeDomSerializer.Serialize"]/*' /> /// <devdoc> /// Serializes the given object into a CodeDom object. /// </devdoc> public override object Serialize(IDesignerSerializationManager manager, object value) { CodeExpression expression = null; Debug.WriteLineIf(traceSerialization.TraceVerbose, "EnumCodeDomSerializer::Serialize"); Debug.Indent(); Debug.WriteLineIf(traceSerialization.TraceVerbose, "Type: " + (value == null ? "(null)" : value.GetType().Name)); if (value is Enum) { string enumName = TypeDescriptor.GetConverter(value.GetType()).ConvertToInvariantString(value); Debug.WriteLineIf(traceSerialization.TraceVerbose, "Names: " + enumName); string[] names = enumName.Split(new char[] { ',' }); CodeTypeReferenceExpression enumType = new CodeTypeReferenceExpression(value.GetType()); // If names is of length 1, then this is a simple field reference. Otherwise, // it is an or-d combination of expressions. // Debug.WriteLineIf(traceSerialization.TraceVerbose && names.Length == 1, "Single field entity."); Debug.WriteLineIf(traceSerialization.TraceVerbose && names.Length > 1, "Multi field entity."); foreach (string name in names) { string nameCopy = name.Trim(); CodeExpression newExpression = new CodeFieldReferenceExpression(enumType, nameCopy); if (expression == null) { expression = newExpression; } else { expression = new CodeBinaryOperatorExpression(expression, CodeBinaryOperatorType.BitwiseOr, newExpression); } } // If we had to combine multiple names, wrap the result in an appropriate cast. // if (names.Length > 1) { expression = new CodeCastExpression(value.GetType(), expression); } } Debug.Unindent(); return(expression); }
public static void ShowTypeReferenceExpression() { //<Snippet3> // Creates an expression referencing the System.DateTime type. CodeTypeReferenceExpression typeRef1 = new CodeTypeReferenceExpression("System.DateTime"); // Create a C# code provider CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); // Generate code and send the output to the console provider.GenerateCodeFromExpression(typeRef1, Console.Out, new CodeGeneratorOptions()); // The code generator produces the following source code for the preceeding example code: // System.DateTime //</Snippet3> }
private static void Main() { var ccu = new CodeCompileUnit(); var cns = new CodeNamespace("Aesop.Demo"); cns.Imports.Add(new CodeNamespaceImport("System")); var ctd = new CodeTypeDeclaration("Test") { TypeAttributes = TypeAttributes.Public }; var ctre = new CodeTypeReferenceExpression("Console"); var cmie = new CodeMethodInvokeExpression(ctre, "WriteLine", new CodePrimitiveExpression("Hello World!")); var cmm = new CodeMemberMethod { Name = "Hello", Attributes = MemberAttributes.Public }; cmm.Statements.Add(cmie); ctd.Members.Add(cmm); cns.Types.Add(ctd); ccu.Namespaces.Add(cns); var provider = new CSharpCodeProvider(); var parameters = new CompilerParameters { CompilerOptions = "/target:library /optimize", GenerateExecutable = false, GenerateInMemory = true }; ////parameters.ReferencedAssemblies.Add("System.dll"); var results = provider.CompileAssemblyFromDom(parameters, ccu); if (results.Errors.Count == 0) { var t = results.CompiledAssembly.GetType("Aesop.Demo.Test"); var inst = results.CompiledAssembly.CreateInstance("Aesop.Demo.Test"); t.InvokeMember("Hello", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, inst, null); } Console.ReadLine(); }
public override IEnumerable <CodeStatement> GetStubStatements() { if (stub.IsPublic && stub.IsLiteral && !stub.IsInitOnly && stub.DeclaringType != null) { if (manipulator.isPubliclyGettable) { var targetType = new CodeTypeReference(manipulator.targetType, CodeTypeReferenceOptions.GlobalReference); var accessorType = new CodeTypeReference(manipulator.type, CodeTypeReferenceOptions.GlobalReference); var property = new CodeTypeReferenceExpression(targetType); var propertyReference = new CodePropertyReferenceExpression(property, manipulator.name); yield return(new CodeVariableDeclarationStatement(accessorType, "accessor", propertyReference)); } const string variableName = "optimized"; var optimizedAccessorType = new CodeTypeReference( GetOptimizedAccessor(stub).GetType(), CodeTypeReferenceOptions.GlobalReference); yield return(new CodeVariableDeclarationStatement(optimizedAccessorType, variableName, new CodeObjectCreateExpression(optimizedAccessorType, new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeOfExpression( new CodeTypeReference(stub.DeclaringType, CodeTypeReferenceOptions.GlobalReference)), nameof(Type.GetField)), new CodePrimitiveExpression(stub.Name), new CodeSnippetExpression("System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static"))))); if (manipulator.isGettable) { var target = new CodePrimitiveExpression(null); yield return(new CodeExpressionStatement( new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(variableName), nameof(IOptimizedAccessor.GetValue), target))); } yield break; } foreach (var statement in base.GetStubStatements()) { yield return(statement); } }
static CodeTypeDeclaration GenerateType(XPathModuleInfo module) { var type = new CodeTypeDeclaration { Name = module.Type.FullName.Replace('.', '_') + "_extobj", IsClass = true, TypeAttributes = TypeAttributes.Public, CustomAttributes = { new CodeAttributeDeclaration( new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute)) ) } }; CodeExpression moduleExpr; if (module.TypeIsStatic) { moduleExpr = new CodeTypeReferenceExpression(module.Type); } else { var moduleField = new CodeMemberField { Name = "module", Type = new CodeTypeReference(module.Type), InitExpression = new CodeObjectCreateExpression(module.Type) }; type.Members.Add(moduleField); moduleExpr = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), moduleField.Name); if (module.Dependencies.Count > 0) { type.Members.Add(GenerateInitialize(module, moduleExpr)); } } foreach (XPathFunctionInfo function in module.Functions) { type.Members.Add(GenerateFunction(function, moduleExpr)); } return(type); }
public override CodeExpression ExportCode(IMethodCompile method) { if (_property != null) { CodeExpression ownerCode; CheckDeclareField(_property.IsStatic, _property.FieldMemberName, _property.PropertyType, method.TypeDeclaration, _property.DefaultValue); if (_property.IsStatic) { ownerCode = new CodeTypeReferenceExpression(_property.Holder.TypeString); } else { ownerCode = new CodeThisReferenceExpression(); } return(new CodeFieldReferenceExpression(ownerCode, _property.FieldMemberName)); } return(null); }
// http://stackoverflow.com/a/1363212/1060807 public static string TypeToString(Type type) { if (type == null) { throw new ArgumentNullException("type"); } var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { var expr = new CodeTypeReferenceExpression(type); var prov = new CSharpCodeProvider(); prov.GenerateCodeFromExpression(expr, sw, new CodeGeneratorOptions()); } return(sb.ToString()); }
public CodeExpression GetReferenceCode(IMethodCompile method) { if (Property != null) { CodeExpression ownerCode; MathNodePropertyField.CheckDeclareField(Property.IsStatic, Property.FieldMemberName, Property.PropertyType.TypeString, method.TypeDeclaration); if (Property.IsStatic) { ownerCode = new CodeTypeReferenceExpression(Property.Holder.TypeString); } else { ownerCode = new CodeThisReferenceExpression(); } return(new CodeFieldReferenceExpression(ownerCode, Property.FieldMemberName)); } return(null); }
private static void CreateChildProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { var cmp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = item.GetPropertyName(), Type = item.GetCodeType() }; if (generationInfo.OmitComment == false) { cmp.Comments.AddSummary(item.Comment); } if (generationInfo.OmitSignatureDate == false) { cmp.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID); cmp.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime); cmp.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID); cmp.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime); } cmp.HasGet = true; cmp.HasSet = false; { var state = new CodeConditionStatement(); var testExp = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); state.Condition = testExp; var staticRefExp = new CodeTypeReferenceExpression(tableInfo.GetRowCodeType()); var fieldExp = new CodeFieldReferenceExpression(staticRefExp, item.GetFieldName() + "Empty"); state.TrueStatements.AddMethodReturn(fieldExp); cmp.GetStatements.Add(state); } { var fieldExp = item.GetFieldExpression(); cmp.GetStatements.AddMethodReturn(fieldExp); } classType.Members.Add(cmp); } }
void CreateImportFor(bool isNestedSrc, IEnumerable <TypeDefinition> types, CodeMemberMethod method) { foreach (var type in types) { // If the library was written in F#, those resource ID classes are not nested but rather combined with '_'. var srcClassRef = new CodeTypeReferenceExpression( new CodeTypeReference(primary_name + (isNestedSrc ? '.' : '_') + type.Name, CodeTypeReferenceOptions.GlobalReference)); // destination language may not support nested types, but they should take care of such types by themselves. var dstClassRef = new CodeTypeReferenceExpression( new CodeTypeReference(type.FullName.Replace('/', '.'), CodeTypeReferenceOptions.GlobalReference)); foreach (var field in type.Fields) { var dstField = new CodeFieldReferenceExpression(dstClassRef, field.Name); var srcField = new CodeFieldReferenceExpression(srcClassRef, field.Name); // This simply assigns field regardless of whether it is int or int[]. method.Statements.Add(new CodeAssignStatement(dstField, srcField)); } } }
private void Generate_CacheMethod(CodeTypeDeclaration pContainerType, CodeMemberMethod pInitMethod, string strListDataName, string strMapFieldName, string strCacheFieldName, bool bIsOverlapKey) { string strMethodName = $"Init_{strMapFieldName}"; var pMethod = pContainerType.AddMethod(strMethodName); pMethod.Attributes = MemberAttributes.Private | MemberAttributes.Final; CodeFieldReferenceExpression pCasheMemberReference = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), strMapFieldName); CodeTypeReferenceExpression pField_List = new CodeTypeReferenceExpression($"{strListDataName}"); if (bIsOverlapKey) { CodeMethodInvokeExpression pMethod_CachingLocal = new CodeMethodInvokeExpression( pField_List, "GroupBy", new CodeSnippetExpression($"x => x.{strCacheFieldName}")); CodeVariableDeclarationStatement pGroupbyVariableDeclaration = new CodeVariableDeclarationStatement( "var", "arrLocal", pMethod_CachingLocal); pMethod.Statements.Add(pGroupbyVariableDeclaration); CodeMethodInvokeExpression pMethod_Caching = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("arrLocal"), "ToDictionary", new CodeSnippetExpression($"g => g.Key, g => g.ToList()")); CodeAssignStatement pCacheAssign = new CodeAssignStatement(pCasheMemberReference, pMethod_Caching); pMethod.Statements.Add(pCacheAssign); } else { CodeMethodInvokeExpression pMethod_Caching = new CodeMethodInvokeExpression( pField_List, "ToDictionary", new CodeSnippetExpression($"x => x.{strCacheFieldName}")); CodeAssignStatement pCacheAssign = new CodeAssignStatement(pCasheMemberReference, pMethod_Caching); pMethod.Statements.Add(pCacheAssign); } pInitMethod.Statements.Add(new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeSnippetExpression(const_strFieldName_private_instance), strMethodName))); }
public override bool AddEventHandler(EventDescription eventDescription, string objectName, string methodName) { //FixMe: VladD2: Какая-то питоновская чушь! Надо разобраться и переписать. const string Init = "__init__"; //This is not the most optimal solution for WPF since we will call FindLogicalNode for each event handler, //but it simplifies the code generation for now. CodeDomDocDataAdapter adapter = GetDocDataAdapterForNemerleFile(); CodeMemberMethod method = null; //Find the __init__ method foreach (CodeTypeMember ctMember in adapter.TypeDeclaration.Members) { if (ctMember is CodeConstructor) { if (ctMember.Name == Init) { method = ctMember as CodeMemberMethod; break; } } } if (method == null) { method = new CodeConstructor(); method.Name = Init; } //Create a code statement which looks like: LogicalTreeHelper.FindLogicalNode(self.Root, "button1").Click += self.button1_Click var logicalTreeHelper = new CodeTypeReferenceExpression("LogicalTreeHelper"); var findLogicalNodeMethod = new CodeMethodReferenceExpression(logicalTreeHelper, "FindLogicalNode"); var selfWindow = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Root"); var findLogicalNodeInvoke = new CodeMethodInvokeExpression(findLogicalNodeMethod, selfWindow, new CodeSnippetExpression("\'" + objectName + "\'")); var createDelegateExpression = new CodeDelegateCreateExpression(new CodeTypeReference("System.EventHandler"), new CodeThisReferenceExpression(), methodName); var attachEvent = new CodeAttachEventStatement(findLogicalNodeInvoke, eventDescription.Name, createDelegateExpression); method.Statements.Add(attachEvent); adapter.Generate(); return(true); }
private static void CreateConstructorFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor() { Attributes = MemberAttributes.Public }; cc.Parameters.Add(typeof(string), "filename"); cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision"); var readerRef = new CodeTypeReferenceExpression(string.Join(".", generationInfo.ReaderNamespace, "CremaReader")); var paramExp = new CodeVariableReferenceExpression("filename"); var methodInvokeExp = new CodeMethodInvokeExpression(readerRef, "Read", paramExp); cc.ChainedConstructorArgs.Add(methodInvokeExp); cc.ChainedConstructorArgs.Add(new CodeVariableReferenceExpression("verifyRevision")); classType.Members.Add(cc); }
public void VisitPrint(PrintStatement p) { CodeExpression e = null; if (p.outputStream != null) { e = p.outputStream.Accept(xlat); } else { e = new CodeTypeReferenceExpression("Console"); } e = new CodeMethodReferenceExpression( e, "WriteLine"); gen.SideEffect( gen.Appl( e, p.args.Select(a => xlat.VisitArgument(a)).ToArray())); }
private static void CreateReadFromFileMethod(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public; cmm.Name = "readFromFile"; cmm.Parameters.Add(typeof(string), "filename"); cmm.Parameters.Add(typeof(bool), "verifyRevision"); var filename = new CodeVariableReferenceExpression("filename"); var verifyRevision = new CodeVariableReferenceExpression("verifyRevision"); var cremaReader = new CodeTypeReferenceExpression(Utility.GenerateCodeType("reader", "CremaReader")); var readFromFile = new CodeMethodInvokeExpression(cremaReader, "readFromFile", filename); var readFromDataSet = new CodeMethodInvokeExpression(thisRef, "readFromDataSet", readFromFile, verifyRevision); cmm.Statements.Add(readFromDataSet); classType.Members.Add(cmm); }
/// <summary> /// Processes the generators. /// </summary> /// <param name="parentClass">The parent class.</param> /// <param name="method">The method.</param> /// <param name="value">The value.</param> /// <param name="baseName">Name of the base.</param> /// <param name="dictionary">The dictionary.</param> /// <returns></returns> public CodeExpression ProcessGenerators(CodeTypeDeclaration parentClass, CodeMemberMethod method, object value, string baseName, ResourceDictionary dictionary = null) { if (value == null) { return(new CodePrimitiveExpression(null)); } IGeneratorValue generator; Type valueType = value.GetType(); CodeExpression valueExpression = null; if (Generators.TryGetValue(valueType, out generator)) { valueExpression = generator.Generate(parentClass, method, value, baseName, dictionary); } else if (valueType.IsEnum) { CodeTypeReferenceExpression typeReference = new CodeTypeReferenceExpression(valueType.Name); valueExpression = new CodeFieldReferenceExpression(typeReference, value.ToString()); } else if (valueType.BaseType.Name.Contains("ViewModelLocatorBase")) { valueExpression = new CodeObjectCreateExpression(valueType); } else { //try reflection var gen = new ReflectionValueGenerator(valueType); Generators.Add(valueType, gen); valueExpression = gen.Generate(parentClass, method, value, baseName, dictionary); /*valueExpression = new CodePrimitiveExpression("NOT SUPPORTED!"); * string errorText = string.Format("Type {0} not supported", valueType.Name); * Console.WriteLine(errorText); * * CodeSnippetStatement error = new CodeSnippetStatement("#error " + errorText); * method.Statements.Add(error);*/ } return(valueExpression); }
private static CodeMemberProperty GenerateElement(GenerationContext context, @class cls, element element) { String value; @class typeCls = context.Classes.FirstOrDefault(c => String.Equals(c.name, element.type)); if (typeCls != null) { // Make sure that we use the correct plural value = typeCls.plural ?? typeCls.name + "s"; } else { // Use the default name value = element.type; } String elementName = NamingHelper.GenerateDotNetName(String.Empty, value); String selector = NamingHelper.GenerateObjCName(value); // Define various references CodeTypeReference typeReference = new CodeTypeReference("SBElementArray"); CodeThisReferenceExpression thisReferenceExpression = new CodeThisReferenceExpression(); CodeTypeReferenceExpression typeReferenceExpression = new CodeTypeReferenceExpression("ObjectiveCRuntime"); // Define the property CodeMemberProperty memberProperty = new CodeMemberProperty(); memberProperty.Attributes = MemberAttributes.Public; memberProperty.Name = elementName; memberProperty.Type = typeReference; // Generate the getter CodeMethodReferenceExpression methodReferenceExpression = new CodeMethodReferenceExpression(typeReferenceExpression, "SendMessage"); methodReferenceExpression.TypeArguments.Add(typeReference); CodeMethodInvokeExpression invokeExpression = new CodeMethodInvokeExpression(methodReferenceExpression, thisReferenceExpression, new CodePrimitiveExpression(selector)); CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(invokeExpression); memberProperty.GetStatements.Add(returnStatement); return(memberProperty); }
private IEnumerable <CodeTypeMember> NewSchemaSingletonMembers(CRflModel aModel, string aSchemaClassName) { var aCdPrpNme = this.Tok.Dom_P_Singleton_Nme; var aFieldName = this.Tok.GetFieldName(aCdPrpNme); var aCdFieldType = new CodeTypeReference(aSchemaClassName); var aCdFieldDecl = new CodeMemberField(aCdFieldType, aFieldName); aCdFieldDecl.Attributes = MemberAttributes.Public | MemberAttributes.Static ; aCdFieldDecl.InitExpression = new CodeObjectCreateExpression(aCdFieldType); var aCdPrpDecl = new CodeMemberProperty(); aCdPrpDecl.Name = aCdPrpNme; aCdPrpDecl.Type = aCdFieldType; aCdPrpDecl.Attributes = MemberAttributes.Public | MemberAttributes.Static ; var aCdTypeRefExp = new CodeTypeReferenceExpression(aSchemaClassName); var aCdFldRefExp = new CodeFieldReferenceExpression(aCdTypeRefExp, aFieldName); var aRetStm = new CodeMethodReturnStatement(aCdFldRefExp); aCdPrpDecl.GetStatements.Add(aRetStm); var aCdFieldTypeRef = new CodeTypeReferenceExpression(aSchemaClassName); var aGetSchemaMthNme = this.Tok.GetGetSchemaFuncName(); var aCdGetSchemaMth = new CodeMemberMethod(); aCdGetSchemaMth.Name = aGetSchemaMthNme; aCdGetSchemaMth.ReturnType = this.CodeDomBuilder.NewCodeTypeRef <CSchema>(); aCdGetSchemaMth.Attributes = MemberAttributes.Static | MemberAttributes.Public ; aCdGetSchemaMth.Statements.Add(new CodeMethodReturnStatement(aCdFldRefExp)); yield return(aCdFieldDecl); yield return(aCdPrpDecl); yield return(aCdGetSchemaMth); }
protected virtual CodeMemberMethod CreateService(CodeTypeReference typerefWCFService, CodeTypeReference typerefService) { CodeTypeReferenceExpression typerefexprService = new CodeTypeReferenceExpression(typerefService); CodeMethodReferenceExpression methodrefDbusServiceCreate = new CodeMethodReferenceExpression(typerefexprService, "Create"); CodeMemberMethod methodCreateService = new CodeMemberMethod(); methodCreateService.Name = CreateServiceName; methodCreateService.ReturnType = typerefWCFService; methodCreateService.Attributes = MemberAttributes.Static; methodCreateService.Parameters.Add(new CodeParameterDeclarationExpression(CodeBuilderCommon.typerefWCFServiceParams, nameWCFServiceParamsArg)); // * <wcfservice> wcfService = new <wcfservice>(wcfserviceparams); methodCreateService.Statements.Add(new CodeVariableDeclarationStatement(typerefWCFService, wcfService , new CodeObjectCreateExpression(typerefWCFService, argrefWCFServiceParams) )); // return wcfService; methodCreateService.Statements.Add(new CodeMethodReturnStatement(varrefWcfService)); return(methodCreateService); }
protected virtual void BuildPageClass(CodeTypeDeclaration codeType) { this.PageTypeReferenceExpression = new CodeTypeReferenceExpression(new CodeTypeReference(codeType.Name)); AddPageBaseTypes(codeType.BaseTypes); AddPageFields(codeType.Members); AddPageProperties(codeType.Members); CodeTypeConstructor cctor = new CodeTypeConstructor(); cctor.CustomAttributes.Add(new CodeAttributeDeclaration(DebuggerNonUserCodeTypeReference)); AddPageTypeCtorStatements(cctor.Statements); if (cctor.Statements.Count > 0) { codeType.Members.Add(cctor); } AddPageMethods(codeType.Members); }
internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten) { CodeTypeReferenceExpression expression2 = (CodeTypeReferenceExpression)expression; if (expression2.Type == null) { ValidationError item = new ValidationError(Messages.NullTypeType, 0x53d); item.UserData["ErrorObject"] = expression2; validation.Errors.Add(item); return(null); } if (isWritten) { ValidationError error2 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeTypeReferenceExpression).ToString() }), 0x17a); error2.UserData["ErrorObject"] = expression2; validation.Errors.Add(error2); return(null); } return(new RuleExpressionInfo(validation.ResolveType(expression2.Type))); }
private void AddListSetStatements(CodeStatementCollection setStatements, CodeTypeReference listType, string listName) { this.AddFixedValueChecking(setStatements); CodeStatement[] codeAssignStatement = new CodeStatement[] { new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), listName), new CodePrimitiveExpression(null)) }; CodeStatement[] trueStatements = codeAssignStatement; codeAssignStatement = new CodeStatement[1]; CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), listName), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); CodeStatement[] codeExpressionStatement = new CodeStatement[] { new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), listName), new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(listType), "Initialize", this.GetListParameters(true, false))) }; CodeStatement[] codeStatementArray = codeExpressionStatement; codeExpressionStatement = new CodeStatement[1]; CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); string str = string.Concat("SetList<", this.clrTypeName, ">"); CodeExpression[] codeFieldReferenceExpression = new CodeExpression[] { new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), listName), CodeDomHelper.SetValue() }; codeExpressionStatement[0] = new CodeExpressionStatement(new CodeMethodInvokeExpression(codeTypeReferenceExpression, str, codeFieldReferenceExpression)); codeAssignStatement[0] = new CodeConditionStatement(codeBinaryOperatorExpression, codeStatementArray, codeExpressionStatement); CodeStatement[] falseStatements = codeAssignStatement; setStatements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(CodeDomHelper.SetValue(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)), trueStatements, falseStatements)); }
/// <summary> /// Generates System.CodeDom.CodeExpression from the given expression. /// </summary> /// <param name="expression">Expression from which System.CodeDom.CodeExpression is generated.</param> /// <returns>Generated System.CodeDom.CodeExpression.</returns> public virtual CodeExpression Visit(QueryFunctionImportCallExpression expression) { var clrMethod = expression.FunctionImport.Annotations.OfType <ClrMethodAnnotation>().SingleOrDefault(); ExceptionUtilities.CheckObjectNotNull(clrMethod, "Cannot generate Linq syntax for function import call expression as there is no information about corresponding Clr method. Function: {0}.", expression.FunctionImport.Name); var type = new CodeTypeReferenceExpression(clrMethod.FullTypeName); var arguments = new List <CodeExpression>(); if (expression.IsRoot) { ExceptionUtilities.CheckObjectNotNull(this.QueryProvider, "Cannot generate function import call expression as a root as QueryProvider is not setup."); arguments.Add(this.QueryProvider); } arguments.AddRange(this.GenerateCodeForArguments(expression.Arguments)); return(type.Call(clrMethod.MethodName, arguments.ToArray())); }
public override CodeExpression GetCodeExpression(System.Web.UI.BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context) { if (!entry.Expression.Contains(",")) { throw new ArgumentException( "Must include two numbers separated by a comma."); } else { // Get the two numbers. string[] numbers = entry.Expression.Split(','); if (numbers.Length != 2) { throw new ArgumentException("Only include two numbers."); } else { int lowerLimit, upperLimit; if (Int32.TryParse(numbers[0], out lowerLimit) && Int32.TryParse(numbers[1], out upperLimit)) { // Get a reference to the class that has the // GetRandomNumber() method. // (It's the class where this code is executing.) CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType()); CodeExpression[] methodParameters = new CodeExpression[2]; methodParameters[0] = new CodePrimitiveExpression(lowerLimit); methodParameters[1] = new CodePrimitiveExpression(upperLimit); return new CodeMethodInvokeExpression(typeRef, "GetRandomNumber", methodParameters); } else { throw new ArgumentException("Use valid integers."); } } } }
public void VisitTypeReference(CodeTypeReferenceExpression t) { GenerateTypeName(t.TypeName); }
public void VisitPrint(PrintStatement p) { CodeExpression e= null; if (p.outputStream != null) { e = p.outputStream.Accept(xlat); } else { e = new CodeTypeReferenceExpression("Console"); } e = new CodeMethodReferenceExpression( e, "WriteLine"); gen.SideEffect( gen.Appl( e, p.args.Select(a => xlat.VisitArgument(a)).ToArray())); }
public void Visit(CodeTypeReferenceExpression o) { g.GenerateTypeReferenceExpression(o); }
private void GenerateTypeReferenceExpression(CodeTypeReferenceExpression e) { OutputType(e.Type); }
private static CodeAttributeDeclaration CreateEditorBrowsableAttribute(EditorBrowsableState editorBrowsableState) { CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(new CodeTypeReference(typeof(EditorBrowsableAttribute))); CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(typeof(EditorBrowsableState)); CodeAttributeArgument argument = new CodeAttributeArgument(new CodeFieldReferenceExpression(targetObject, editorBrowsableState.ToString())); declaration.Arguments.Add(argument); return declaration; }
protected virtual void GenerateTypeReferenceExpression(CodeTypeReferenceExpression e) { OutputType(e.Type); }