public static void GetCreateValueExpression(object value,
ClrSimpleTypeInfo typeDef,
CodeExpressionCollection collection)
{
if (value == null)
{
collection.Add(new CodePrimitiveExpression(value));
return;
}
switch (typeDef.Variety)
{
case XmlSchemaDatatypeVariety.List:
string str = ListSimpleTypeValidator.ToString(value);
collection.Add(new CodePrimitiveExpression(str));
break;
case XmlSchemaDatatypeVariety.Atomic:
if (value is string)
{
collection.Add(new CodePrimitiveExpression(value));
}
else
{
collection.Add(CreateTypedValueExpression(typeDef.InnerType.Datatype, value));
}
break;
case XmlSchemaDatatypeVariety.Union:
GetCreateUnionValueExpression(value, typeDef as UnionSimpleTypeInfo, collection);
break;
default:
break;
}
}
internal static CodeObjectCreateExpression CreateSetCreateExpression(Set <int> set)
{
CodeObjectCreateExpression createSet =
new CodeObjectCreateExpression(
CodeDomHelper.CreateGenericTypeReference("Set", new string[] { Constants.Int }));
CodeExpressionCollection parameters = createSet.Parameters;
if (set.Count == 1)
{
foreach (int i in set)
{
parameters.Add(new CodePrimitiveExpression(i));
}
}
else if (set.Count > 1)
{
CodeArrayCreateExpression array = new CodeArrayCreateExpression();
array.CreateType = CodeDomHelper.CreateTypeReference(Constants.Int);
CodeExpressionCollection initializers = array.Initializers;
foreach (int i in set)
{
initializers.Add(new CodePrimitiveExpression(i));
}
parameters.Add(array);
}
return(createSet);
}
public void AddRange()
{
CodeExpression exp1 = new CodeExpression();
CodeExpression exp2 = new CodeExpression();
CodeExpression exp3 = new CodeExpression();
CodeExpressionCollection coll1 = new CodeExpressionCollection();
coll1.Add(exp1);
coll1.Add(exp2);
CodeExpressionCollection coll2 = new CodeExpressionCollection();
coll2.Add(exp3);
coll2.AddRange(coll1);
Assert.AreEqual(3, coll2.Count, "#1");
Assert.AreEqual(1, coll2.IndexOf(exp1), "#2");
Assert.AreEqual(2, coll2.IndexOf(exp2), "#3");
Assert.AreEqual(0, coll2.IndexOf(exp3), "#4");
CodeExpressionCollection coll3 = new CodeExpressionCollection();
coll3.Add(exp3);
coll3.AddRange(new CodeExpression[] { exp1, exp2 });
Assert.AreEqual(3, coll2.Count, "#5");
Assert.AreEqual(1, coll2.IndexOf(exp1), "#6");
Assert.AreEqual(2, coll2.IndexOf(exp2), "#7");
Assert.AreEqual(0, coll2.IndexOf(exp3), "#8");
}
internal static CodeObjectCreateExpression CreateSetCreateExpression(Set <int> set)
{
string[] strArrays = new string[] { "System.Int32" };
CodeObjectCreateExpression createSet = new CodeObjectCreateExpression(CodeDomHelper.CreateGenericTypeReference("Set", strArrays), new CodeExpression[0]);
CodeExpressionCollection parameters = createSet.Parameters;
if (set.Count == 1)
{
foreach (int num in set)
{
parameters.Add(new CodePrimitiveExpression((object)num));
}
}
else if (set.Count > 1)
{
CodeArrayCreateExpression array = new CodeArrayCreateExpression()
{
CreateType = CodeDomHelper.CreateTypeReference("System.Int32")
};
CodeExpressionCollection initializers = array.Initializers;
foreach (int i in set)
{
initializers.Add(new CodePrimitiveExpression((object)i));
}
parameters.Add(array);
}
return(createSet);
}
private void GenerateMethod(IDLInterface idlIntf, IDLMethod idlMethod
, Udbus.Parsing.ICodeTypeDeclarationHolder contextDeclarationHolder
, CodeTypeReference typerefDbusInterface
, CodeTypeReference typerefDbusMarshal
, CodeTypeDeclaration typeProxy)
{
// Straight-forward interface method.
CodeMemberMethod methodInterface = new CodeMemberMethod();
CodeExpressionCollection interfaceCallArgs = new CodeExpressionCollection();
methodInterface.Name = idlMethod.Name;
methodInterface.Attributes = MemberAttributes.Public;
Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(contextDeclarationHolder);
#region Methods args
foreach (IDLMethodArgument idlMethodArg in idlMethod.Arguments)
{
CodeCommentStatement commentMethod = new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlMethodArg.Direction, idlMethodArg.Name, idlMethodArg.Type));
methodInterface.Comments.Add(commentMethod);
// Parse the type string for the argument, creating required structs as we go, and returning a type for the argument.
Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod);
ParamCodeTypeFactory paramtypeHolder = new ParamCodeTypeFactory(CodeTypeFactory.Default,
idlMethodArg.Direction == "out" ? FieldDirection.Out : FieldDirection.In);
Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolder, nameBuilder, idlMethodArg.Type, context);
Udbus.Parsing.ICodeParamType paramtype = paramtypeHolder.paramtype;
// Arguments.
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name);
CodeVariableReferenceExpression varrefMethodArg = new CodeVariableReferenceExpression(idlMethodArg.Name);
if (idlMethodArg.Direction == "out")
{
// Add to interface parameters.
interfaceCallArgs.Add(new CodeDirectionExpression(FieldDirection.Out, varrefMethodArg));
// Add parameter to interface method.
param.Direction = FieldDirection.Out;
}
else
{
interfaceCallArgs.Add(varrefMethodArg);
}
methodInterface.Parameters.Add(param);
} // Ends loop over method arguments
#endregion
methodInterface.Statements.Add(this.DeclareTargetVariable(typerefDbusInterface, typerefDbusMarshal));
methodInterface.Statements.Add(new CodeMethodInvokeExpression(varrefTarget, idlMethod.Name, interfaceCallArgs.Cast <CodeExpression>().ToArray()));
//methodInterface.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(thisProxyFieldRef, idlMethod.Name)
// , interfaceCallArgs.Cast<CodeExpression>().ToArray()
//));
// Finish up.
typeProxy.Members.Add(methodInterface);
}
public void Add()
{
CodeExpression exp1 = new CodeExpression();
CodeExpression exp2 = new CodeExpression();
CodeExpressionCollection coll = new CodeExpressionCollection();
Assert.AreEqual(0, coll.Add(exp1), "#1");
Assert.AreEqual(1, coll.Count, "#2");
Assert.AreEqual(0, coll.IndexOf(exp1), "#3");
Assert.AreEqual(1, coll.Add(exp2), "#4");
Assert.AreEqual(2, coll.Count, "#5");
Assert.AreEqual(1, coll.IndexOf(exp2), "#6");
}
public void Constructor2()
{
CodeExpression exp1 = new CodeExpression();
CodeExpression exp2 = new CodeExpression();
CodeExpressionCollection c = new CodeExpressionCollection();
c.Add(exp1);
c.Add(exp2);
CodeExpressionCollection coll = new CodeExpressionCollection(c);
Assert.AreEqual(2, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(exp1), "#2");
Assert.AreEqual(1, coll.IndexOf(exp2), "#3");
}
internal void AddDeclaredParameters(CodeTypeDeclaration classDeclaration,
IMethod method,
CodeMemberMethod member,
CodeExpressionCollection constructorParameters,
bool addOptionalParameters)
{
if (method.Parameters == null)
{
return;
}
// Add all parameters to the method.
foreach (var param in method.GetAllParametersSorted())
{
if (!addOptionalParameters && !param.IsRequired)
{
continue;
}
// Generate a safe parameter name which was not yet used.
// Also exclude method name as VB can not have parameterName the same as method name.
string parameterName = GeneratorUtils.GetParameterName(
param, method.Parameters.Keys.Without(param.Name).Concat(method.Name));
// Declare the parameter, and add it to the list of constructor parameters of the request class.
member.Parameters.Add(DeclareInputParameter(classDeclaration, param, method));
constructorParameters.Add(new CodeVariableReferenceExpression(parameterName));
AddParameterComment(commentCreator, member, param, parameterName);
}
}
private void SerializeResumeLayout(IDesignerSerializationManager manager, CodeStatementCollection statements, object control)
{
CodeExpressionCollection parameters = new CodeExpressionCollection();
parameters.Add(new CodePrimitiveExpression(false));
Type[] paramTypes = { typeof(bool) };
SerializeMethodInvocation(manager, statements, control, "ResumeLayout", parameters, paramTypes, StatementOrdering.Append);
}
public void Remove()
{
CodeExpression ce1 = new CodeExpression();
CodeExpression ce2 = new CodeExpression();
CodeExpressionCollection coll = new CodeExpressionCollection();
coll.Add(ce1);
coll.Add(ce2);
Assert.AreEqual(2, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(ce1), "#2");
Assert.AreEqual(1, coll.IndexOf(ce2), "#3");
coll.Remove(ce1);
Assert.AreEqual(1, coll.Count, "#4");
Assert.AreEqual(-1, coll.IndexOf(ce1), "#5");
Assert.AreEqual(0, coll.IndexOf(ce2), "#6");
}
public void AddRange_Self()
{
CodeExpressionCollection coll = new CodeExpressionCollection();
coll.Add(new CodeExpression());
Assert.AreEqual(1, coll.Count, "#1");
coll.AddRange(coll);
Assert.AreEqual(2, coll.Count, "#2");
}
/// <summary>Converts a list of expressions to CodeDom expressions.</summary>
void ConvertExpressions(CodeExpressionCollection args, ExpressionCollection expressions)
{
foreach (Expression e in expressions)
{
_expression = null;
e.Accept(this);
args.Add(_expression);
}
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
if (entry == null)
{
throw new NullReferenceException(".NET emulation (entry == null)");
}
var ret = new CodeMethodInvokeExpression();
ret.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(RouteUrlExpressionBuilder)), "GetRouteUrl");
CodeExpressionCollection parameters = ret.Parameters;
parameters.Add(new CodeThisReferenceExpression());
parameters.Add(new CodePrimitiveExpression(entry.Expression));
return(ret);
}
private void addParamToInvoker(EventType evt, ParameterType param, CodeExpressionCollection targetCollection)
{
//todo add param to the collection
setParamName(evt, param);
CodeVariableReferenceExpression _name = new CodeVariableReferenceExpression(param.name);
targetCollection.Add(_name);
}
private void AddParam(CodeExpressionCollection @params, Expression par)
{
try
{
object v = CodeDom.Eval(par);
if (v == null && par != null)
{
@params.Add(_Visit(par));
}
else
{
@params.Add(GetFromPrimitive(v));
}
}
catch (Exception)
{
@params.Add(_Visit(par));
}
}
//public CodeExpressionCollection VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection<Expression> original)
public CodeExpressionCollection VisitExpressionList(IEnumerable <Expression> original)
{
CodeExpressionCollection list = new CodeExpressionCollection();
foreach (Expression e in original)
{
list.Add(_Visit(e));
}
return(list);
}
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 SerializeResumeLayout(IDesignerSerializationManager manager, CodeStatementCollection statements, object control)
{
CodeExpressionCollection codeExpressionCollection = new CodeExpressionCollection();
codeExpressionCollection.Add(new CodePrimitiveExpression(false));
Type[] paramTypes = new Type[]
{
typeof(bool)
};
this.SerializeMethodInvocation(manager, statements, control, "ResumeLayout", codeExpressionCollection, paramTypes, ControlCodeDomSerializer.StatementOrdering.Append);
}
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier)
{
CodeBinaryOperatorExpression expression2 = (CodeBinaryOperatorExpression)expression;
RuleBinaryExpressionInfo info = analysis.Validation.ExpressionInfo(expression2) as RuleBinaryExpressionInfo;
if (info != null)
{
MethodInfo methodInfo = info.MethodInfo;
if (methodInfo != null)
{
List <CodeExpression> attributedExprs = new List <CodeExpression>();
CodeExpressionCollection argExprs = new CodeExpressionCollection();
argExprs.Add(expression2.Left);
argExprs.Add(expression2.Right);
CodeExpression targetExpr = new CodeTypeReferenceExpression(methodInfo.DeclaringType);
analysis.AnalyzeRuleAttributes(methodInfo, targetExpr, qualifier, argExprs, methodInfo.GetParameters(), attributedExprs);
}
}
RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Left, true, false, null);
RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Right, true, false, null);
}
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("Xml.Schema.Linq.AtomicSimpleTypeValidator", new CodeExpression[0]);
expressions = simpleTypeCreate.Parameters;
expressions.Add(SimpleTypeCodeDomHelper.CreateGetBuiltInSimpleType(typeInfo.TypeCode));
expressions.Add(SimpleTypeCodeDomHelper.CreateFacets(typeInfo));
break;
}
case XmlSchemaDatatypeVariety.List:
{
simpleTypeCreate = new CodeObjectCreateExpression("Xml.Schema.Linq.ListSimpleTypeValidator", new CodeExpression[0]);
expressions = simpleTypeCreate.Parameters;
expressions.Add(SimpleTypeCodeDomHelper.CreateGetBuiltInSimpleType(typeInfo.TypeCode));
expressions.Add(SimpleTypeCodeDomHelper.CreateFacets(typeInfo));
ClrSimpleTypeInfo itemType = (typeInfo as ListSimpleTypeInfo).ItemType;
expressions.Add(SimpleTypeCodeDomHelper.CreateSimpleTypeDef(itemType, nameMappings, settings, true));
break;
}
case XmlSchemaDatatypeVariety.Union:
{
simpleTypeCreate = new CodeObjectCreateExpression("Xml.Schema.Linq.UnionSimpleTypeValidator", new CodeExpression[0]);
expressions = simpleTypeCreate.Parameters;
expressions.Add(SimpleTypeCodeDomHelper.CreateGetBuiltInSimpleType(typeInfo.TypeCode));
expressions.Add(SimpleTypeCodeDomHelper.CreateFacets(typeInfo));
UnionSimpleTypeInfo unionType = typeInfo as UnionSimpleTypeInfo;
CodeArrayCreateExpression memberTypeCreate = new CodeArrayCreateExpression()
{
CreateType = new CodeTypeReference("Xml.Schema.Linq.SimpleTypeValidator")
};
ClrSimpleTypeInfo[] memberTypes = unionType.MemberTypes;
for (int i = 0; i < (int)memberTypes.Length; i++)
{
ClrSimpleTypeInfo st = memberTypes[i];
memberTypeCreate.Initializers.Add(SimpleTypeCodeDomHelper.CreateSimpleTypeDef(st, nameMappings, settings, true));
}
expressions.Add(memberTypeCreate);
break;
}
}
return(simpleTypeCreate);
}
public static void GetCreateValueExpression(object value, ClrSimpleTypeInfo typeDef, CodeExpressionCollection collection)
{
if (value != null)
{
switch (typeDef.Variety)
{
case XmlSchemaDatatypeVariety.Atomic:
{
if (!(value is string))
{
collection.Add(SimpleTypeCodeDomHelper.CreateTypedValueExpression(typeDef.InnerType.Datatype, value));
}
else
{
collection.Add(new CodePrimitiveExpression(value));
}
break;
}
case XmlSchemaDatatypeVariety.List:
{
string str = ListSimpleTypeValidator.ToString(value);
collection.Add(new CodePrimitiveExpression(str));
break;
}
case XmlSchemaDatatypeVariety.Union:
{
SimpleTypeCodeDomHelper.GetCreateUnionValueExpression(value, typeDef as UnionSimpleTypeInfo, collection);
break;
}
}
}
else
{
collection.Add(new CodePrimitiveExpression(value));
}
}
public void Constructor1_Deny_Unrestricted()
{
CodeExpressionCollection coll = new CodeExpressionCollection(array);
coll.CopyTo(array, 0);
Assert.AreEqual(1, coll.Add(ce), "Add");
Assert.AreSame(ce, coll[0], "this[int]");
coll.AddRange(array);
coll.AddRange(coll);
Assert.IsTrue(coll.Contains(ce), "Contains");
Assert.AreEqual(0, coll.IndexOf(ce), "IndexOf");
coll.Insert(0, ce);
coll.Remove(ce);
}
public static CodeExpressionCollection Clone(this CodeExpressionCollection collection)
{
if (collection == null)
{
return(null);
}
CodeExpressionCollection c = new CodeExpressionCollection();
foreach (CodeExpression expression in collection)
{
c.Add(expression.Clone());
}
return(c);
}
private static void AddTypes(string prepend, bool nested, CodeTypeDeclarationCollection types, CodeExpressionCollection into)
{
foreach (CodeTypeDeclaration t in types)
{
into.Add(new CodeTypeOfExpression(
((prepend == null || prepend == "") ? "" : (prepend + (nested ? "+" : "."))) + t.Name));
CodeTypeDeclarationCollection ctd = new CodeTypeDeclarationCollection();
foreach (CodeTypeMember m in t.Members)
{
if (m is CodeTypeDeclaration)
{
ctd.Add((CodeTypeDeclaration)m);
}
}
AddTypes(
((prepend == null || prepend == "") ? "" : (prepend + (nested ? "+" : "."))) + t.Name,
true, ctd, into);
}
}
/// <summary>
/// Serializes the specified object into a CodeDOM object.
/// </summary>
/// <param name="manager">The serialization manager to use during serialization.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>
/// A CodeDOM object representing the object that has been serialized.
/// </returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// Invoke the default serializer for base class
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ControlListBase).BaseType, typeof(CodeDomSerializer));
CodeStatementCollection statements = baseSerializer.Serialize(manager, value) as CodeStatementCollection;
// Add layout methods
if (statements != null)
{
SerializeMethodInvocation(manager, statements, value, "SuspendLayout", null, new Type[0], true);
CodeExpressionCollection parameters = new CodeExpressionCollection();
parameters.Add(new CodePrimitiveExpression(true));
Type[] paramTypes = new Type[] { typeof(bool) };
SerializeMethodInvocation(manager, statements, value, "ResumeLayout", parameters, paramTypes, false);
}
// Return the new statements
return(statements);
}
private void BuildParameters(CodeStatementCollection statements, MethodInfo method, object[] paramValues,
CodeExpressionCollection parameters)
{
ParameterInfo[] infoArray1 = method.GetParameters();
for (int num1 = 0; num1 < infoArray1.Length; num1++)
{
ParameterInfo info1 = infoArray1[num1];
Type type1 = infoArray1[num1].ParameterType;
FieldDirection direction1 = FieldDirection.In;
if (type1.IsByRef)
{
direction1 = FieldDirection.Ref;
type1 = type1.GetElementType();
}
CodeExpression expression1 = null;
if (!info1.IsOut)
{
expression1 = BuildObject(statements, info1.Name, paramValues[num1]);
}
else
{
direction1 = FieldDirection.Out;
}
if (direction1 != FieldDirection.In)
{
if ((expression1 == null) || !(expression1 is CodeVariableReferenceExpression))
{
CodeVariableDeclarationStatement statement1 =
new CodeVariableDeclarationStatement(type1.FullName, info1.Name);
if (expression1 != null)
{
statement1.InitExpression = expression1;
}
statements.Add(statement1);
expression1 = new CodeVariableReferenceExpression(statement1.Name);
}
expression1 = new CodeDirectionExpression(direction1, expression1);
}
parameters.Add(expression1);
}
}
private void BuildParameters(CodeStatementCollection statements, MethodInfo method, object[] paramValues,
CodeExpressionCollection parameters)
{
ParameterInfo[] infoArray = method.GetParameters();
for (int i = 0; i < infoArray.Length; i++)
{
ParameterInfo info = infoArray[i];
Type parameterType = infoArray[i].ParameterType;
var @in = FieldDirection.In;
if (parameterType.IsByRef)
{
@in = FieldDirection.Ref;
parameterType = parameterType.GetElementType();
}
CodeExpression expression = null;
if (!info.IsOut)
{
expression = BuildObject(statements, info.Name, paramValues[i]);
}
else
{
@in = FieldDirection.Out;
}
if (@in != FieldDirection.In)
{
if ((expression == null) || !(expression is CodeVariableReferenceExpression))
{
var statement = new CodeVariableDeclarationStatement(parameterType.FullName, info.Name);
if (expression != null)
{
statement.InitExpression = expression;
}
statements.Add(statement);
expression = new CodeVariableReferenceExpression(statement.Name);
}
expression = new CodeDirectionExpression(@in, expression);
}
parameters.Add(expression);
}
}
internal override void AddToContentModel(CodeObjectCreateExpression contentModelExpression)
{
Debug.Assert((contentModelExpression == null ? false : this.propertyOrigin == SchemaOrigin.Element));
if (!this.IsSubstitutionHead)
{
CodeExpressionCollection parameters = contentModelExpression.Parameters;
CodeExpression[] codeExpressionArray = new CodeExpression[] { this.xNameGetExpression };
parameters.Add(new CodeObjectCreateExpression("NamedContentModelEntity", codeExpressionArray));
}
else
{
CodeExpression[] substParams = new CodeExpression[this.substitutionMembers.Count];
int i = 0;
foreach (XmlSchemaElement elem in this.substitutionMembers)
{
int num = i;
i = num + 1;
substParams[num] = CodeDomHelper.XNameGetExpression(elem.QualifiedName.Name, elem.QualifiedName.Namespace);
}
contentModelExpression.Parameters.Add(new CodeObjectCreateExpression("SubstitutedContentModelEntity", substParams));
}
}
// CodeExpressionCollection
public void CodeExpressionCollectionExample()
{
//<Snippet1>
//<Snippet2>
// Creates an empty CodeExpressionCollection.
CodeExpressionCollection collection = new CodeExpressionCollection();
//</Snippet2>
//<Snippet3>
// Adds a CodeExpression to the collection.
collection.Add(new CodePrimitiveExpression(true));
//</Snippet3>
//<Snippet4>
// Adds an array of CodeExpression objects to the collection.
CodeExpression[] expressions = { new CodePrimitiveExpression(true), new CodePrimitiveExpression(true) };
collection.AddRange(expressions);
// Adds a collection of CodeExpression objects to the collection.
CodeExpressionCollection expressionsCollection = new CodeExpressionCollection();
expressionsCollection.Add(new CodePrimitiveExpression(true));
expressionsCollection.Add(new CodePrimitiveExpression(true));
collection.AddRange(expressionsCollection);
//</Snippet4>
//<Snippet5>
// Tests for the presence of a CodeExpression in the
// collection, and retrieves its index if it is found.
CodeExpression testComment = new CodePrimitiveExpression(true);
int itemIndex = -1;
if (collection.Contains(testComment))
{
itemIndex = collection.IndexOf(testComment);
}
//</Snippet5>
//<Snippet6>
// Copies the contents of the collection beginning at index 0 to the specified CodeExpression array.
// 'expressions' is a CodeExpression array.
collection.CopyTo(expressions, 0);
//</Snippet6>
//<Snippet7>
// Retrieves the count of the items in the collection.
int collectionCount = collection.Count;
//</Snippet7>
//<Snippet8>
// Inserts a CodeExpression at index 0 of the collection.
collection.Insert(0, new CodePrimitiveExpression(true));
//</Snippet8>
//<Snippet9>
// Removes the specified CodeExpression from the collection.
CodeExpression expression = new CodePrimitiveExpression(true);
collection.Remove(expression);
//</Snippet9>
//<Snippet10>
// Removes the CodeExpression at index 0.
collection.RemoveAt(0);
//</Snippet10>
//</Snippet1>
}
public CodeMemberMethod CreateMethod(CodeTypeDeclaration classDeclaration,
IResource resource,
IMethod method,
bool addOptionalParameters,
MethodType methodType)
{
// Create a new method and make it public.
var member = new CodeMemberMethod();
member.Name = GeneratorUtils.GetMethodName(method, resource.Methods.Keys.Without(method.Name));
member.Attributes = MemberAttributes.Public;
if (commentCreator != null)
{
member.Comments.AddRange(commentCreator.CreateMethodComment(method));
}
// Check if this method has a body.
CodeExpressionCollection constructorParameters = new CodeExpressionCollection();
constructorParameters.Add(new CodeVariableReferenceExpression(ServiceFieldName));
if (method.HasBody)
{
// If so, add a body parameter.
ResourceCallAddBodyDeclaration(method, member, GetBodyType(method), false);
}
// If a body parameter or similar parameters were added, also add them to the constructor.
foreach (CodeParameterDeclarationExpression existingParameter in member.Parameters)
{
constructorParameters.Add(new CodeVariableReferenceExpression(existingParameter.Name));
}
// Add all request parameters to this method.
AddDeclaredParameters(
classDeclaration, method, member, constructorParameters, addOptionalParameters);
string requestClassNamingScheme = RequestClassGenerator.RequestClassNamingScheme;
// If this is the media-upload convenience method, add the stream and content-type
// parameters.
if (methodType == MethodType.Media)
{
member.Parameters.Add(new CodeParameterDeclarationExpression(
typeof(System.IO.Stream), StreamParameterName));
member.Parameters.Add(new CodeParameterDeclarationExpression(
typeof(System.String), ContentTypeParameterName));
constructorParameters.Add(new CodeVariableReferenceExpression(StreamParameterName));
constructorParameters.Add(new CodeVariableReferenceExpression(ContentTypeParameterName));
requestClassNamingScheme = RequestClassGenerator.MediaUploadClassNamingScheme;
}
// new ...Request(paramOne, paramTwo, paramThree)
// TODO(mlinder): add method signature collision checking here.
CodeTypeReference requestType = new CodeTypeReference(
RequestClassGenerator.GetProposedName(
method, requestClassNamingScheme));
member.ReturnType = requestType;
var newRequest = new CodeObjectCreateExpression(requestType);
newRequest.Parameters.AddRange(constructorParameters);
// return ...;
var returnStatment = new CodeMethodReturnStatement(newRequest);
member.Statements.Add(returnStatment);
return(member);
}
