public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression;
CodeTypeDeclaration declaration = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration;
RootContext context = manager.Context[typeof(RootContext)] as RootContext;
CodeStatementCollection statements = new CodeStatementCollection();
if ((declaration != null) && (context != null))
{
CodeMemberField field = new CodeMemberField(typeof(IContainer), "components") {
Attributes = MemberAttributes.Private
};
declaration.Members.Add(field);
expression = new CodeFieldReferenceExpression(context.Expression, "components");
}
else
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeof(IContainer), "components");
statements.Add(statement);
expression = new CodeVariableReferenceExpression("components");
}
base.SetExpression(manager, value, expression);
CodeObjectCreateExpression right = new CodeObjectCreateExpression(typeof(Container), new CodeExpression[0]);
CodeAssignStatement statement2 = new CodeAssignStatement(expression, right);
statement2.UserData["IContainer"] = "IContainer";
statements.Add(statement2);
return statements;
}
static void AddEntryPoint()
{
CodeEntryPointMethod start = new CodeEntryPointMethod();
CodeObjectCreateExpression objectCreate =
new CodeObjectCreateExpression(
new CodeTypeReference("CodeDOMCreatedClass"),
new CodePrimitiveExpression(5.3),
new CodePrimitiveExpression(6.9));
// Add the statement:
// "CodeDOMCreatedClass testClass =
// new CodeDOMCreatedClass(5.3, 6.9);"
start.Statements.Add(new CodeVariableDeclarationStatement(
new CodeTypeReference("CodeDOMCreatedClass"), "testClass",
objectCreate));
// Creat the expression:
// "testClass.ToString()"
CodeMethodInvokeExpression toStringInvoke =
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("testClass"), "ToString");
// Add a System.Console.WriteLine statement with the previous
// expression as a parameter.
start.Statements.Add(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.Console"),
"WriteLine", toStringInvoke));
targetClass.Members.Add(start);
}
protected CodeExpression CreateNewWizardStepReference(WizardControllerTreeNode node, string wizardStepPage)
{
CodeExpression createMethodSignature = new CodeObjectCreateExpression(
source[typeof (MethodSignature)],
new CodeExpression[]
{
new CodeTypeOfExpression(node.FullName),
new CodePrimitiveExpression(node.Name),
new CodeArrayCreateExpression(source[typeof (Type)], 0)
});
var constructionArguments = new[]
{
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), naming.ToMemberVariableName(serviceIdentifier)),
new CodeTypeOfExpression(node.FullName),
new CodePrimitiveExpression(node.Area),
new CodePrimitiveExpression(naming.ToControllerName(node.Name)),
new CodePrimitiveExpression(wizardStepPage),
createMethodSignature,
new CodeArrayCreateExpression(source[typeof (ActionArgument)], 0)
};
return new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), naming.ToMemberVariableName(serviceIdentifier)),
"ControllerReferenceFactory"),
"CreateActionReference"),
constructionArguments);
}
// Generates a codedom instantiation expression: new foo() or new foo[x].
public static CodeExpression Emit(Instantiation instantiation)
{
// Array instantiation needs a different treatment.
if (instantiation.IsArray)
{
var c = new CodeArrayCreateExpression();
c.CreateType = new CodeTypeReference(instantiation.Name);
c.SizeExpression = CodeDomEmitter.EmitCodeExpression(instantiation.Parameters.ChildExpressions[0]);
return c;
}
else // Non-array instantiation
{
var c = new CodeObjectCreateExpression();
// The type that is being created
var createType = new CodeTypeReference(instantiation.Name);
// Apply the generic type names, if any.
foreach (var g in instantiation.GenericTypes)
{
createType.TypeArguments.Add(new CodeTypeReference(g));
}
c.CreateType = createType;
// Translate the instantiation parameters.
foreach (var a in instantiation.Parameters.ChildExpressions)
c.Parameters.Add(CodeDomEmitter.EmitCodeExpression(a));
return c;
}
}
public override void OnProcessGeneratedCode(ControlBuilder controlBuilder, CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType, CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod, System.Collections.IDictionary additionalState)
{
// only run this once during page compilation, and only use this one builder (so that we don't get master pages, etc.)
if (controlBuilder.GetType() == typeof(FileLevelPageControlBuilder))
{
// the page will only contain one namespace and one type
var ns = codeCompileUnit.Namespaces.Cast<CodeNamespace>().FirstOrDefault();
if (ns != null)
{
var type = ns.Types.Cast<CodeTypeDeclaration>().FirstOrDefault();
if (type != null)
{
/* When this is output, it will inject this into every page:
*
* protected override PageStatePersister PageStatePersister {
* get { return new CompressedHiddenFieldPageStatePersister(this); }
* }
*
*/
CodeMemberProperty property = new CodeMemberProperty()
{
Name = "PageStatePersister",
HasGet = true,
Attributes = MemberAttributes.Override | MemberAttributes.Family,
Type = new CodeTypeReference(typeof(PageStatePersister))
};
var newObj = new CodeObjectCreateExpression(typeof(CompressedHiddenFieldPageStatePersister), new CodeThisReferenceExpression());
property.GetStatements.Add(new CodeMethodReturnStatement(newObj));
type.Members.Add(property);
}
}
}
base.OnProcessGeneratedCode(controlBuilder, codeCompileUnit, baseType, derivedType, buildMethod, dataBindingMethod, additionalState);
}
internal static void AddCallbackImplementation(CodeTypeDeclaration codeClass, string callbackName, string handlerName, string handlerArgs, bool methodHasOutParameters)
{
CodeFlags[] parameterFlags = new CodeFlags[1];
CodeMemberMethod method = AddMethod(codeClass, callbackName, parameterFlags, new string[] { typeof(object).FullName }, new string[] { "arg" }, typeof(void).FullName, null, (CodeFlags) 0);
CodeEventReferenceExpression left = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeStatement[] trueStatements = new CodeStatement[2];
trueStatements[0] = new CodeVariableDeclarationStatement(typeof(InvokeCompletedEventArgs), "invokeArgs", new CodeCastExpression(typeof(InvokeCompletedEventArgs), new CodeArgumentReferenceExpression("arg")));
CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression("invokeArgs");
CodeObjectCreateExpression expression4 = new CodeObjectCreateExpression();
if (methodHasOutParameters)
{
expression4.CreateType = new CodeTypeReference(handlerArgs);
expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Results"));
}
else
{
expression4.CreateType = new CodeTypeReference(typeof(AsyncCompletedEventArgs));
}
expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Error"));
expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Cancelled"));
expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "UserState"));
trueStatements[1] = new CodeExpressionStatement(new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName), new CodeExpression[] { new CodeThisReferenceExpression(), expression4 }));
method.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[0]));
}
public override object Serialize(IDesignerSerializationManager manager, object value) {
var baseSerializer = (CodeDomSerializer)manager
.GetSerializer(typeof(ResourceManagerSetter).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
var statements = codeObject as CodeStatementCollection;
if (statements != null) {
CodeExpression leftCodeExpression = new CodeVariableReferenceExpression("resources");
var classTypeDeclaration = (CodeTypeDeclaration)manager.GetService(typeof(CodeTypeDeclaration));
CodeExpression typeofExpression = new CodeTypeOfExpression(classTypeDeclaration.Name);
CodeExpression rightCodeExpression =
new CodeObjectCreateExpression(typeof(XafComponentResourceManager),
new[] { typeofExpression });
//CodeExpression rightCodeExpression =
// new CodeTypeReferenceExpression(
// "new DevExpress.ExpressApp.Win.Templates"),
// "XafComponentResourceManager", new[] { typeofExpression });
statements.Insert(0, new CodeAssignStatement(leftCodeExpression, rightCodeExpression));
}
return codeObject;
}
public void Constructor0_Deny_Unrestricted ()
{
CodeObjectCreateExpression coce = new CodeObjectCreateExpression ();
Assert.AreEqual ("System.Void", coce.CreateType.BaseType, "CreateType.BaseType");
coce.CreateType = new CodeTypeReference ("System.Int32");
Assert.AreEqual (0, coce.Parameters.Count, "Parameters");
}
public void AssignParametersCheckCreatorParameters()
{
var testClass = new CodeTypeDeclaration();
var creator = new CodeObjectCreateExpression();
// standard parameterless ctor, "public ComposeMeCtorVoid()"
testObject.BuildTestObject(MemberVisibility.Public);
testObject.AssignParameters(testClass, creator);
var actualCreatorParameters = creator.Parameters.OfType<CodeFieldReferenceExpression>().ToArray();
Assert.Count(0, actualCreatorParameters);
// with a constructor from "public ComposeMeTwoCtor(string para1, int para2)"
testClass = new CodeTypeDeclaration();
CreateTestObject(typeof(ComposeMeTwoCtor));
testObject.BuildTestObject(MemberVisibility.Public);
testObject.AssignParameters(testClass, creator);
actualCreatorParameters = creator.Parameters.OfType<CodeFieldReferenceExpression>().ToArray();
Assert.Count(2, actualCreatorParameters);
var expected = "para1";
var actual = actualCreatorParameters[0].FieldName;
Assert.AreEqual(expected, actual);
expected = "para2";
actual = actualCreatorParameters[1].FieldName;
Assert.AreEqual(expected, actual);
}
private void Process(ref CodeObject target, CodeObject parent, int indent)
{
CodeMethodInvokeExpression methodInvokeExpr = target as CodeMethodInvokeExpression;
if (methodInvokeExpr != null &&
methodInvokeExpr.Method.TargetObject == null &&
StringUtils.CaseInsensitiveEquals(methodInvokeExpr.Method.MethodName, "CreateObject") &&
methodInvokeExpr.Parameters.Count == 1)
{
CodePrimitiveExpression primitiveExpr = methodInvokeExpr.Parameters[0] as CodePrimitiveExpression;
if (primitiveExpr != null)
{
string progId = primitiveExpr.Value as string;
if (progId != null)
{
Type type = (_importer == null
? Type.GetTypeFromProgID(progId)
: _importer.ImportProgId(progId));
if (type != null)
{
target = new CodeObjectCreateExpression(Utils.CreateTypeReference(type));
}
}
}
}
}
private static string AppendCreateDictionaryLocalVariable(string dictionary, CodeDomClassBuilder builder)
{
var parser = new AttributeParser(dictionary);
parser.Parse();
var keyValuePairType = new CodeTypeReference(typeof(KeyValuePair<string,object>));
var createDictionaryMethod = new CodeMethodInvokeExpression();
foreach (var attribute in parser.Attributes)
{
var newKeyValueExpression = new CodeObjectCreateExpression {CreateType = keyValuePairType};
var keyExpression = new CodePrimitiveExpression {Value = attribute.Name};
newKeyValueExpression.Parameters.Add(keyExpression);
if (attribute.Type == ParsedAttributeType.String)
{
AppendStringDictValue(attribute, newKeyValueExpression);
}
else
{
newKeyValueExpression.Parameters.Add(new CodeSnippetExpression
{
Value = attribute.Value
});
}
createDictionaryMethod.Parameters.Add(newKeyValueExpression);
}
var getDictionaryMethod = new CodeMethodReferenceExpression
{
MethodName = "GetDictionaryFromKeyValue",
TargetObject =
new CodeVariableReferenceExpression
{
VariableName = "NHamlMonoRailView"
}
};
createDictionaryMethod.Method = getDictionaryMethod;
var variableName = string.Format("nhamlTempDictionary{0}", tempDictionaryCount);
tempDictionaryCount++;
var dictionaryDecleration = new CodeVariableDeclarationStatement
{
InitExpression = createDictionaryMethod,
Name = variableName,
Type = new CodeTypeReference(typeof (IDictionary<string, object>))
};
builder.RenderMethod.Statements.Add(dictionaryDecleration);
return variableName;
}
public static Tuple<CodeVariableDeclarationStatement, CodeVariableReferenceExpression> CreateVariable(CodeTypeReference typeReference, string name, params CodeExpression[] constructorParameters)
{
CodeObjectCreateExpression initializer = new CodeObjectCreateExpression(typeReference, constructorParameters);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeReference, name, initializer);
CodeVariableReferenceExpression reference = new CodeVariableReferenceExpression(name);
return new Tuple<CodeVariableDeclarationStatement, CodeVariableReferenceExpression>(statement, reference);
}
public void Constructor1_Deny_Unrestricted ()
{
CodeTypeReference create = new CodeTypeReference ("System.Int32");
CodeExpression[] parameters = new CodeExpression[1] { new CodeExpression () };
CodeObjectCreateExpression coce = new CodeObjectCreateExpression (create, parameters);
Assert.AreSame (create, coce.CreateType, "CreateType");
coce.CreateType = new CodeTypeReference ("System.Void");
Assert.AreEqual (1, coce.Parameters.Count, "Parameters");
}
public static CodeObjectCreateExpression Clone(this CodeObjectCreateExpression expression)
{
if (expression == null) return null;
CodeObjectCreateExpression e = new CodeObjectCreateExpression();
e.CreateType = expression.CreateType.Clone();
e.Parameters.AddRange(expression.Parameters.Clone());
e.UserData.AddRange(expression.UserData);
return e;
}
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 void BuildControlSkinMember()
{
int count = this._controlSkinBuilderEntryList.Count;
CodeMemberField field = new CodeMemberField(typeof(HybridDictionary).FullName, "__controlSkins");
CodeObjectCreateExpression expression = new CodeObjectCreateExpression(typeof(HybridDictionary), new CodeExpression[0]);
expression.Parameters.Add(new CodePrimitiveExpression(count));
field.InitExpression = expression;
base._sourceDataClass.Members.Add(field);
}
public void Init()
{
functionalConstructor = null;
staticConstructor = null;
hasElementWildCards = false;
contentModelExpression = null;
if (propertyNameTypeTable != null) {
propertyNameTypeTable.Clear();
}
}
private CodeStatement createChildContainerStatement(CodeVariableReferenceExpression picoContainer,
CodeVariableReferenceExpression childContainer)
{
CodeExpression[] arguments = new CodeExpression[] {picoContainer};
CodeExpression rightHandSide = new CodeObjectCreateExpression(Constants.DefaultPicoContainerType, arguments);
return new CodeVariableDeclarationStatement(Constants.DefaultPicoContainerType,
childContainer.VariableName,
rightHandSide);
}
/// <summary>
/// Generates code for value
/// </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 Generate(CodeTypeDeclaration parentClass, CodeMemberMethod method, object value, string baseName, ResourceDictionary dictionary = null)
{
Color color = (Color)value;
CodeObjectCreateExpression colorExpr = new CodeObjectCreateExpression(
"ColorW",
new CodePrimitiveExpression(color.R),
new CodePrimitiveExpression(color.G),
new CodePrimitiveExpression(color.B),
new CodePrimitiveExpression(color.A));
return colorExpr;
}
public TypescriptObjectCreateExpression(
IExpressionFactory expressionFactory,
CodeObjectCreateExpression codeExpression,
CodeGeneratorOptions options,
ITypescriptTypeMapper typescriptTypeMapper)
{
_expressionFactory = expressionFactory;
_codeExpression = codeExpression;
_options = options;
_typescriptTypeMapper = typescriptTypeMapper;
System.Diagnostics.Debug.WriteLine("TypescriptObjectCreateExpression Created");
}
internal override CodeExpression Clone(CodeExpression expression)
{
CodeObjectCreateExpression expression2 = (CodeObjectCreateExpression) expression;
CodeObjectCreateExpression expression3 = new CodeObjectCreateExpression {
CreateType = TypeReferenceExpression.CloneType(expression2.CreateType)
};
foreach (CodeExpression expression4 in expression2.Parameters)
{
expression3.Parameters.Add(RuleExpressionWalker.Clone(expression4));
}
return expression3;
}
internal static CodeExpression MaterializeSimpleTypeDef(
ClrSimpleTypeInfo typeInfo,
Dictionary<XmlSchemaObject, string> nameMappings,
LinqToXsdSettings settings)
{
CodeObjectCreateExpression simpleTypeCreate = null;
CodeExpressionCollection expressions = null;
switch(typeInfo.Variety) {
case XmlSchemaDatatypeVariety.Atomic:
simpleTypeCreate = new CodeObjectCreateExpression(
Constants.AtomicSimpleTypeValidator);
expressions = simpleTypeCreate.Parameters;
expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode));
expressions.Add(CreateFacets(typeInfo));
break;
case XmlSchemaDatatypeVariety.List:
simpleTypeCreate = new CodeObjectCreateExpression(
Constants.ListSimpleTypeValidator);
expressions = simpleTypeCreate.Parameters;
expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode));
expressions.Add(CreateFacets(typeInfo));
ListSimpleTypeInfo listType = typeInfo as ListSimpleTypeInfo;
ClrSimpleTypeInfo itemType = listType.ItemType;
expressions.Add(CreateSimpleTypeDef(
itemType, nameMappings, settings, true));
break;
case XmlSchemaDatatypeVariety.Union:
simpleTypeCreate = new CodeObjectCreateExpression(
Constants.UnionSimpleTypeValidator);
expressions = simpleTypeCreate.Parameters;
expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode));
expressions.Add(CreateFacets(typeInfo));
UnionSimpleTypeInfo unionType = typeInfo as UnionSimpleTypeInfo;
CodeArrayCreateExpression memberTypeCreate =
new CodeArrayCreateExpression();
memberTypeCreate.CreateType = new CodeTypeReference(
Constants.SimpleTypeValidator);
foreach (ClrSimpleTypeInfo st in unionType.MemberTypes)
{
memberTypeCreate.Initializers.Add(CreateSimpleTypeDef(
st, nameMappings, settings, true));
}
expressions.Add(memberTypeCreate);
break;
}
return simpleTypeCreate;
}
private void SetupAsyncTestClass(TestClassGenerationContext generationContext)
{
generationContext.TestClass.BaseTypes.Add(new CodeTypeReference(ASYNCTEST_INTERFACE));
//AsyncTestRunner.RegisterAsyncTestExecutor(testRunner, new TechTalk.SpecFlow.Async.SilverlightAsyncTestExecutor(this));
var nawSilverlightAsyncTestExecutorExpr = new CodeObjectCreateExpression("TechTalk.SpecFlow.Async.SilverlightAsyncTestExecutor", new CodeThisReferenceExpression());
var registerAsyncExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(AsyncTestRunner)),
"RegisterAsyncTestExecutor",
new CodeVariableReferenceExpression("testRunner"),
nawSilverlightAsyncTestExecutorExpr);
generationContext.TestInitializeMethod.Statements.Add(new CodeExpressionStatement(registerAsyncExpression));
}
public void Constructor0 ()
{
CodeObjectCreateExpression coce = new CodeObjectCreateExpression ();
Assert.IsNotNull (coce.CreateType, "#1");
Assert.AreEqual (typeof (void).FullName, coce.CreateType.BaseType, "#2");
Assert.IsNotNull (coce.Parameters, "#3");
Assert.AreEqual (0, coce.Parameters.Count, "#4");
CodeTypeReference type = new CodeTypeReference ("mono");
coce.CreateType = type;
Assert.IsNotNull (coce.CreateType, "#8");
Assert.AreSame (type, coce.CreateType, "#9");
coce.CreateType = null;
Assert.IsNotNull (coce.CreateType, "#10");
Assert.AreEqual (typeof (void).FullName, coce.CreateType.BaseType, "#11");
}
private void GenerateCode()
{
keys.ToObservable();
var cgo = new CodeGeneratorOptions
{
BracingStyle = "C",
BlankLinesBetweenMembers = false
};
using (var provider = new CSharpCodeProvider())
{
var method = new CodeMemberMethod
{
Name = "KeyStream",
ReturnType = new CodeTypeReference(typeof(IObservable<InterceptKeyEventArgs>))
};
var player =
new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(KeyPlayer)), "keys",
new CodeObjectCreateExpression(typeof(KeyPlayer)));
method.Statements.Add(player);
foreach (var interceptKeyEventArgse in keys)
{
var key = new CodeObjectCreateExpression(new CodeTypeReference(typeof(InterceptKeyEventArgs)),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(Keys)), interceptKeyEventArgse.Key.ToString()),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(KeyDirection)), interceptKeyEventArgse.KeyDirection.ToString()),
new CodePrimitiveExpression(interceptKeyEventArgse.AltPressed),
new CodePrimitiveExpression(interceptKeyEventArgse.ControlPressed),
new CodePrimitiveExpression(interceptKeyEventArgse.ShiftPressed));
var keyPress = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("keys"), "Add", key);
method.Statements.Add(keyPress);
}
method.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("keys")));
var sb = new StringBuilder();
using(var stringWriter = new StringWriter(sb))
{
provider.GenerateCodeFromMember(method, stringWriter, cgo);
}
textBox.Text = sb.ToString();
}
}
private CodeStatement BuildControlSkinAssignmentStatement(ControlBuilder builder, string skinID)
{
Type controlType = builder.ControlType;
string name = base.GetMethodNameForBuilder(BaseTemplateCodeDomTreeGenerator.buildMethodPrefix, builder) + "_skinKey";
CodeMemberField field = new CodeMemberField(typeof(object), name) {
Attributes = MemberAttributes.Private | MemberAttributes.Static
};
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(PageTheme)), "CreateSkinKey")
};
expression.Parameters.Add(new CodeTypeOfExpression(controlType));
expression.Parameters.Add(new CodePrimitiveExpression(skinID));
field.InitExpression = expression;
base._sourceDataClass.Members.Add(field);
CodeFieldReferenceExpression targetObject = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "__controlSkins");
CodeIndexerExpression left = new CodeIndexerExpression(targetObject, new CodeExpression[] { new CodeVariableReferenceExpression(name) });
CodeDelegateCreateExpression expression4 = new CodeDelegateCreateExpression(this._controlSkinDelegateType, new CodeThisReferenceExpression(), base.GetMethodNameForBuilder(BaseTemplateCodeDomTreeGenerator.buildMethodPrefix, builder));
CodeObjectCreateExpression right = new CodeObjectCreateExpression(this._controlSkinType, new CodeExpression[0]);
right.Parameters.Add(new CodeTypeOfExpression(controlType));
right.Parameters.Add(expression4);
return new CodeAssignStatement(left, right);
}
public void Constructor1 ()
{
CodeTypeReference type = new CodeTypeReference ("mono");
CodeExpression expression1 = new CodeExpression ();
CodeExpression expression2 = new CodeExpression ();
CodeObjectCreateExpression coce = new CodeObjectCreateExpression (
type, expression1, expression2);
Assert.IsNotNull (coce.CreateType, "#1");
Assert.AreSame (type, coce.CreateType, "#2");
Assert.IsNotNull (coce.Parameters, "#3");
Assert.AreEqual (2, coce.Parameters.Count, "#4");
Assert.AreEqual (0, coce.Parameters.IndexOf(expression1), "#5");
Assert.AreEqual (1, coce.Parameters.IndexOf(expression2), "#6");
coce = new CodeObjectCreateExpression ((CodeTypeReference) null,
expression1);
Assert.IsNotNull (coce.CreateType, "#7");
Assert.AreEqual (typeof (void).FullName, coce.CreateType.BaseType, "#8");
Assert.IsNotNull (coce.Parameters, "#9");
Assert.AreEqual (1, coce.Parameters.Count, "#10");
Assert.AreEqual (0, coce.Parameters.IndexOf(expression1), "#11");
}
public HardwireParameterDescriptor(Table tpar)
{
CodeExpression ename = new CodePrimitiveExpression(tpar.Get("name").String);
CodeExpression etype = new CodeTypeOfExpression(tpar.Get("origtype").String);
CodeExpression hasDefaultValue = new CodePrimitiveExpression(tpar.Get("default").Boolean);
CodeExpression defaultValue = tpar.Get("default").Boolean ? (CodeExpression)(new CodeObjectCreateExpression(typeof(DefaultValue))) :
(CodeExpression)(new CodePrimitiveExpression(null));
CodeExpression isOut = new CodePrimitiveExpression(tpar.Get("out").Boolean);
CodeExpression isRef = new CodePrimitiveExpression(tpar.Get("ref").Boolean);
CodeExpression isVarArg = new CodePrimitiveExpression(tpar.Get("varargs").Boolean);
CodeExpression restrictType = tpar.Get("restricted").Boolean ? (CodeExpression)(new CodeTypeOfExpression(tpar.Get("type").String)) :
(CodeExpression)(new CodePrimitiveExpression(null));
Expression = new CodeObjectCreateExpression(typeof(ParameterDescriptor), new CodeExpression[] {
ename, etype, hasDefaultValue, defaultValue, isOut, isRef,
isVarArg }
);
ParamType = tpar.Get("origtype").String;
HasDefaultValue = tpar.Get("default").Boolean;
IsOut = tpar.Get("out").Boolean;
IsRef = tpar.Get("ref").Boolean;
}
/// <summary>
/// Generates code for value
/// </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 Generate(CodeTypeDeclaration parentClass, CodeMemberMethod method, object value, string baseName, ResourceDictionary dictionary = null)
{
CodeExpression valueExpression = null;
if (value != null)
{
Thickness thickness = (Thickness)value;
if (thickness.Left == thickness.Top && thickness.Top == thickness.Right && thickness.Right == thickness.Bottom)
{
valueExpression = new CodeObjectCreateExpression("Thickness", new CodePrimitiveExpression((float)thickness.Left));
}
else
{
valueExpression = new CodeObjectCreateExpression(
"Thickness",
new CodePrimitiveExpression((float)thickness.Left),
new CodePrimitiveExpression((float)thickness.Top),
new CodePrimitiveExpression((float)thickness.Right),
new CodePrimitiveExpression((float)thickness.Bottom));
}
}
return valueExpression;
}
private void GenerateCodeFromObjectCreateExpression(CodeObjectCreateExpression e, TextWriter w,
CodeGeneratorOptions o)
{
w.Write("New-Object -TypeName " + e.CreateType.BaseType);
if (e.Parameters.Count > 0)
{
w.Write(" -ArgumentList @(");
int count = e.Parameters.Count;
foreach (CodeExpression parameter in e.Parameters)
{
count--;
GenerateCodeFromExpression(parameter, w, o);
if (count > 0)
{
w.Write(",");
}
}
w.Write(")");
}
}
protected override void GenerateObjectCreateExpression(System.CodeDom.CodeObjectCreateExpression e)
{
Output.Write("new ");
OutputType(e.CreateType);
OutputParameters(e.Parameters);
}