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);
}
