public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ComponentBase).BaseType, typeof(CodeDomSerializer));
object obj = codeDomSerializer.Serialize(manager, value);
CodeExpression codeExpression = base.SerializeToExpression(manager, value);
if (codeExpression == null)
{
return(obj);
}
if (!(obj is CodeStatementCollection))
{
return(obj);
}
CodeStatementCollection codeStatementCollection = (CodeStatementCollection)obj;
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(codeExpression, "LoadingBegin");
int num = 0;
for (int i = 0; i < codeStatementCollection.Count; i++)
{
if (codeStatementCollection[i] is CodeCommentStatement)
{
num = i + 1;
}
}
codeStatementCollection.Insert(num, new CodeExpressionStatement(expression));
expression = new CodeMethodInvokeExpression(codeExpression, "SetForm", new CodeThisReferenceExpression());
codeStatementCollection.Insert(num + 1, new CodeExpressionStatement(expression));
expression = new CodeMethodInvokeExpression(codeExpression, "LoadingEnd");
codeStatementCollection.Add(expression);
return(obj);
}
/// <summary>
/// We customize the output from the default serializer here, adding
/// a comment and an extra line of code.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// first, locate and invoke the default serializer for
// the ButtonArray's base class (UserControl)
//
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(WizardStepsControl).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
// now add some custom code
//
if (codeObject is CodeStatementCollection)
{
// add a custom comment to the code.
//
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
statements.Insert(4, new CodeCommentStatement("This is a custom comment added by a custom serializer on " + DateTime.Now.ToLongDateString()));
// call a custom method.
//
CodeExpression targetObject = base.SerializeToExpression(manager, value);
WizardStepsControl wsc = (WizardStepsControl)value;
if (targetObject != null && wsc.Steps != null)
{
CodePropertyReferenceExpression leftNode = new CodePropertyReferenceExpression(targetObject, "Steps");
CodeObjectCreateExpression rightNode = new CodeObjectCreateExpression(typeof(Collection <Step>));
CodeAssignStatement initializeStepsStatement = new CodeAssignStatement(leftNode, rightNode);
statements.Insert(5, initializeStepsStatement);
}
}
// finally, return the statements that have been created
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer =
(CodeDomSerializer)manager.GetSerializer(typeof(ResourceControl).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
statements.Insert(0, new CodeCommentStatement("MLUResManager is used to set the custom resource file which in the another resource.dll."));
statements.Insert(0, new CodeCommentStatement("Must to set the BaseName property which is use to get the resource file name."));
CodeExpression targetObject =
base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeExpression Paramter = new CodeArgumentReferenceExpression("ref resources");
CodeMethodInvokeExpression methodCall =
new CodeMethodInvokeExpression(targetObject, "reInitResManger", Paramter);
statements.Add(methodCall);
}
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer _codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(MultiFunctionChartLegend).BaseType, typeof(CodeDomSerializer));
object _object = _codeDomSerializer.Serialize(manager, value);
if (_object is CodeStatementCollection)
{
CodeStatementCollection _codeStatementCollection = (CodeStatementCollection)_object;
CodeExpression _targetObject = base.GetExpression(manager, value);
if (_targetObject != null)
{
CodePropertyReferenceExpression _codePropertyReferenceExpression = new CodePropertyReferenceExpression(_targetObject, "OwnerChart");
CodeAssignStatement _codeAssignStatement = new CodeAssignStatement(_codePropertyReferenceExpression, new CodeThisReferenceExpression());
_codeStatementCollection.Insert(0, _codeAssignStatement);
CodeCommentStatement _codeCommentStatement = new CodeCommentStatement(
new CodeComment("WARNING: This generates an exception in design time, but is ok (select 'Ignore and continue')."));
_codeStatementCollection.Insert(0, _codeCommentStatement);
}
}
return(_object);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(BvResourceManagerChanger).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
Component component = (Component)value;
IDesignerHost host = component.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (host != null)
{
CodeCommentStatement comment = new CodeCommentStatement("Form Is Localizable: " + IsLocalizable(host));
statements.Insert(0, comment);
if (IsLocalizable(host))
{
CodeTypeDeclaration classTypeDeclaration = (CodeTypeDeclaration)manager.GetService(typeof(CodeTypeDeclaration));
CodeExpression typeofExpression = new CodeTypeOfExpression(classTypeDeclaration.Name);
CodeDirectionExpression outResourceExpression = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("resources"));
CodeExpression rightCodeExpression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("bv.common.Resources.BvResourceManagerChanger"), "GetResourceManager", new CodeExpression[] { typeofExpression, outResourceExpression });
statements.Insert(0, new CodeExpressionStatement(rightCodeExpression));
}
}
}
return(codeObject);
}
private static void ReplaceControlCreateStatement(Type ctrlType, CodeAssignStatement objAssignStatement, CodeStatementCollection statements)
{
/* Generate code like below
*
* IServiceProvider __activator = HttpRuntime.WebObjectActivator;
*
* if (activator != null) {
* _ctrl = (ctrlType)activator.GetService(ctrlType);
* }
*
* // if default c-tor exists
* else {
* _ctrl = new ....
* }
* // if no default c-tor
* else {
* throw new InvalidOperationException(SR.GetString(SR.Could_not_create_type_instance, ctrlType))
* }
*
*/
var webObjectActivatorExpr = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Web.HttpRuntime"), "WebObjectActivator");
var activatorRefExpr = new CodeVariableReferenceExpression("__activator");
var getServiceExpr = new CodeMethodInvokeExpression(webObjectActivatorExpr, "GetService", new CodeTypeOfExpression(ctrlType));
var castExpr = new CodeCastExpression(new CodeTypeReference(ctrlType), getServiceExpr);
var createObjectStatement = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression(activatorRefExpr,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null))
};
createObjectStatement.TrueStatements.Add(new CodeAssignStatement(objAssignStatement.Left, castExpr));
// If default c-tor exists
if (DoesTypeHaveDefaultCtor(ctrlType))
{
createObjectStatement.FalseStatements.Add(objAssignStatement);
}
else
{
var throwExceptionStatement = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(
new CodeTypeReference(typeof(System.InvalidOperationException)),
new CodeExpression[] { new CodePrimitiveExpression(SR.GetString(SR.Could_not_create_type_instance, ctrlType)) }));
createObjectStatement.FalseStatements.Add(throwExceptionStatement);
}
// replace the old assign statement
var indexOfStatement = statements.IndexOf(objAssignStatement);
statements.Insert(indexOfStatement, createObjectStatement);
statements.Insert(indexOfStatement, new CodeAssignStatement(activatorRefExpr, webObjectActivatorExpr));
statements.Insert(indexOfStatement, new CodeVariableDeclarationStatement(typeof(IServiceProvider), "__activator"));
statements.Remove(objAssignStatement);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(MyComponent).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
// Initial MyList
// Generate "myComponent1.MyList = new System.Collections.Generic.List<string>();"
CodeObjectCreateExpression objectCreate1;
objectCreate1 = new CodeObjectCreateExpression("System.Collections.Generic.List<string>", new CodeExpression[] { });
CodeAssignStatement as2 =
new CodeAssignStatement(new CodeVariableReferenceExpression(manager.GetName(value) + ".MyList"),
objectCreate1);
statements.Insert(0, as2);
// Add my generated code comment
string commentText = "MyList generation code";
CodeCommentStatement comment = new CodeCommentStatement(commentText);
statements.Insert(1, comment);
// Add items to MyList
// Generate the following code
// this.myComponent1.MyList.Add("string5");
// this.myComponent1.MyList.Add("string4");
// this.myComponent1.MyList.Add("string3");
// this.myComponent1.MyList.Add("string2");
// this.myComponent1.MyList.Add("string1");
MyComponent myCom = (MyComponent)manager.GetInstance(manager.GetName(value));
for (int i = 0; i < myCom.MyList.Count; i++)
{
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(
// targetObject that contains the method to invoke.
new CodeThisReferenceExpression(),
// methodName indicates the method to invoke.
manager.GetName(value) + ".MyList.Add",
// parameters array contains the parameters for the method.
new CodeExpression[] { new CodePrimitiveExpression(myCom.MyList[i]) });
CodeExpressionStatement expressionStatement;
expressionStatement = new CodeExpressionStatement(methodInvoke);
statements.Insert(2, expressionStatement);
}
// Remove system generated code
statements.RemoveAt(statements.Count - 1);
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer _codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(DXPlayer).BaseType, typeof(CodeDomSerializer));
object _object = _codeDomSerializer.Serialize(manager, value);
if (_object is CodeStatementCollection)
{
CodeStatementCollection _codeStatementCollection = (CodeStatementCollection)_object;
CodeExpression _targetObject = base.GetExpression(manager, value);
if (_targetObject != null)
{
CodePropertyReferenceExpression _codePropertyReferenceExpression =
new CodePropertyReferenceExpression(_targetObject, "Owner");
CodeAssignStatement _codeAssignStatement = new CodeAssignStatement(
_codePropertyReferenceExpression, new CodeThisReferenceExpression());
_codeStatementCollection.Insert(0, _codeAssignStatement);
}
}
return(_object);
}
private void InsertCodeCommentHeader(CodeStatementCollection statements)
{
for (int i = m_codeCommentHeader.Length - 1; i >= 0; --i)
{
statements.Insert(0, m_codeCommentHeader[i]);
}
}
public static void AddVariableDeclaration(Type type, string name, CodeStatementCollection statements)
{
for (int i = 0; i < statements.Count; i++)
{
CodeVariableDeclarationStatement vd = statements[i] as CodeVariableDeclarationStatement;
if (vd != null)
{
if (vd.Name == name)
{
return;
}
}
}
CodeVariableDeclarationStatement p;
if (type.IsValueType)
{
p = new CodeVariableDeclarationStatement(type, name);
}
else
{
p = new CodeVariableDeclarationStatement(type, name, ObjectCreationCodeGen.GetDefaultValueExpression(type));
}
statements.Insert(0, p);
}
/*
* Build first-time intialization statements
*/
protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements)
{
base.BuildInitStatements(trueStatements, topLevelStatements);
CodeMemberField fileDependencies = new CodeMemberField(typeof(ArrayList), fileDependenciesName);
fileDependencies.Attributes |= MemberAttributes.Static;
_sourceDataClass.Members.Add(fileDependencies);
// Note: it may look like this local variable declaraiton is redundant. However it is necessary
// to make this init code re-entrant safe. This way, even if two threads enter the contructor
// at the same time, they will not add multiple dependencies.
// e.g. ArrayList dependencies;
CodeVariableDeclarationStatement dependencies = new CodeVariableDeclarationStatement();
dependencies.Type = new CodeTypeReference(typeof(ArrayList));
dependencies.Name = dependenciesLocalName;
topLevelStatements.Insert(0, dependencies);
// e.g. dependencies = new System.Collections.ArrayList();
CodeAssignStatement assignDependencies = new CodeAssignStatement();
assignDependencies.Left = new CodeVariableReferenceExpression(dependenciesLocalName);
assignDependencies.Right = new CodeObjectCreateExpression(typeof(ArrayList));
// Note: it is important to add all local variables at the top level for CodeDom Subset compliance.
trueStatements.Add(assignDependencies);
Debug.Assert(Parser.FileDependencies != null);
if (Parser.FileDependencies != null)
{
int count = Parser.FileDependencies.Length;
for (int i = 0; i < count; i++)
{
// depdendencies.Add("...");
CodeMethodInvokeExpression addFileDep = new CodeMethodInvokeExpression();
addFileDep.Method.TargetObject = new CodeVariableReferenceExpression(dependenciesLocalName);
addFileDep.Method.MethodName = "Add";
addFileDep.Parameters.Add(new CodePrimitiveExpression((string)Parser.FileDependencies[i]));
trueStatements.Add(new CodeExpressionStatement(addFileDep));
}
}
// e.g. __fileDependencies = dependencies;
CodeAssignStatement initFile = new CodeAssignStatement();
initFile.Left = new CodeFieldReferenceExpression(_classTypeExpr,
fileDependenciesName);
initFile.Right = new CodeVariableReferenceExpression(dependenciesLocalName);
#if DBG
AppendDebugComment(trueStatements);
#endif
trueStatements.Add(initFile);
}
public void Constructor1_Deny_Unrestricted()
{
CodeStatementCollection coll = new CodeStatementCollection(array);
coll.CopyTo(array, 0);
Assert.AreEqual(1, coll.Add(cs), "Add");
Assert.AreSame(cs, coll[0], "this[int]");
coll.AddRange(array);
coll.AddRange(coll);
Assert.IsTrue(coll.Contains(cs), "Contains");
Assert.AreEqual(0, coll.IndexOf(cs), "IndexOf");
coll.Insert(0, cs);
coll.Remove(cs);
}
public void Insert()
{
CodeStatement cs1 = new CodeStatement();
CodeStatement cs2 = new CodeStatement();
CodeStatementCollection coll = new CodeStatementCollection();
coll.Add(cs1);
Assert.AreEqual(1, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(cs1), "#2");
coll.Insert(0, cs2);
Assert.AreEqual(2, coll.Count, "#3");
Assert.AreEqual(1, coll.IndexOf(cs1), "#4");
Assert.AreEqual(0, coll.IndexOf(cs2), "#5");
}
public static void AddVariableDeclaration(string type, string name, CodeStatementCollection statements)
{
for (int i = 0; i < statements.Count; i++)
{
CodeVariableDeclarationStatement vd = statements[i] as CodeVariableDeclarationStatement;
if (vd != null)
{
if (vd.Name == name)
{
return;
}
}
}
statements.Insert(0, new CodeVariableDeclarationStatement(type, name));
}
public override object Deserialize(IDesignerSerializationManager AManager, object ACodeObject)
{
CodeDomSerializer LbaseSerializer = (CodeDomSerializer)AManager.GetSerializer(typeof(Alphora.Dataphor.DAE.Client.DataSession).BaseType, typeof(CodeDomSerializer));
if (ACodeObject is CodeStatementCollection)
{
CodeStatementCollection LStatements = (CodeStatementCollection)ACodeObject;
CodeStatement LSetActivePropertyStatement = GetPropertyAssignStatement(LStatements, CPropertyName);
if (LSetActivePropertyStatement != null)
{
LStatements.Remove(LSetActivePropertyStatement);
LStatements.Insert(LStatements.Count, LSetActivePropertyStatement);
}
}
return(LbaseSerializer.Deserialize(AManager, ACodeObject));
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
CodeDomSerializer LbaseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(System.ComponentModel.Component), typeof(CodeDomSerializer));
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
CodeStatement assignPropertyStatement = GetPropertyAssignStatement(statements, PropertyName);
if (assignPropertyStatement != null)
{
statements.Remove(assignPropertyStatement);
statements.Insert(statements.Count, assignPropertyStatement);
}
}
return(LbaseSerializer.Deserialize(manager, codeObject));
}
protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements)
{
CodeMemberField field;
base.BuildInitStatements(trueStatements, topLevelStatements);
field = new CodeMemberField(typeof(object), "__fileDependencies")
{
Attributes = field.Attributes | MemberAttributes.Static
};
base._sourceDataClass.Members.Add(field);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement {
Type = new CodeTypeReference(typeof(string[])),
Name = "dependencies"
};
topLevelStatements.Insert(0, statement);
StringSet set = new StringSet();
set.AddCollection(this.Parser.SourceDependencies);
CodeAssignStatement statement2 = new CodeAssignStatement {
Left = new CodeVariableReferenceExpression("dependencies"),
Right = new CodeArrayCreateExpression(typeof(string), set.Count)
};
trueStatements.Add(statement2);
int num = 0;
foreach (string str in (IEnumerable)set)
{
CodeAssignStatement statement3 = new CodeAssignStatement {
Left = new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("dependencies"), new CodeExpression[] { new CodePrimitiveExpression(num++) })
};
string str2 = UrlPath.MakeVirtualPathAppRelative(str);
statement3.Right = new CodePrimitiveExpression(str2);
trueStatements.Add(statement3);
}
CodeAssignStatement statement4 = new CodeAssignStatement {
Left = new CodeFieldReferenceExpression(base._classTypeExpr, "__fileDependencies")
};
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodeThisReferenceExpression(), MethodName = "GetWrappedFileDependencies" }
};
expression.Parameters.Add(new CodeVariableReferenceExpression("dependencies"));
statement4.Right = expression;
trueStatements.Add(statement4);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
/* Associate the component with the serializer in the same manner as with
* Deserialize */
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(GeniusTreeView).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
// The code statement collection is valid, so add a comment.
string commentText = "GeniusTreeView By Pierrick Gourlain";
CodeCommentStatement comment = new CodeCommentStatement(commentText);
statements.Insert(0, comment);
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
/* Associate the component with the serializer in the same manner as with
* Deserialize */
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(MyComponent).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
/* Anything could be in the codeObject. This sample operates on a
* CodeStatementCollection. */
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
// The code statement collection is valid, so add a comment.
string commentText = "This comment was added to this object by a custom serializer.";
CodeCommentStatement comment = new CodeCommentStatement(commentText);
statements.Insert(0, comment);
}
return(codeObject);
}
CodeMemberMethod GenerateMethod(CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers)
{
CodeIdentifiers pids = new CodeIdentifiers();
CodeMemberMethod method = new CodeMemberMethod();
CodeMemberMethod methodBegin = new CodeMemberMethod();
CodeMemberMethod methodEnd = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final;
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
// Find unique names for temporary variables
for (int n = 0; n < inputMembers.Count; n++)
{
pids.AddUnique(inputMembers[n].MemberName, inputMembers[n]);
}
if (outputMembers != null)
{
for (int n = 0; n < outputMembers.Count; n++)
{
pids.AddUnique(outputMembers[n].MemberName, outputMembers[n]);
}
}
string varAsyncResult = pids.AddUnique("asyncResult", "asyncResult");
string varResults = pids.AddUnique("results", "results");
string varCallback = pids.AddUnique("callback", "callback");
string varAsyncState = pids.AddUnique("asyncState", "asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name), method);
method.Name = CodeIdentifier.MakeValid(Operation.Name);
if (method.Name == ClassName)
{
method.Name += "1";
}
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name), method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name), method);
method.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0];
for (int n = 0; n < inputMembers.Count; n++)
{
CodeParameterDeclarationExpression param = GenerateParameter(inputMembers[n], FieldDirection.In);
method.Parameters.Add(param);
GenerateMemberAttributes(inputMembers, inputMembers[n], bodyBinding.Use, param);
methodBegin.Parameters.Add(GenerateParameter(inputMembers[n], FieldDirection.In));
paramArray [n] = new CodeVariableReferenceExpression(param.Name);
}
if (outputMembers != null)
{
bool hasReturn = false;
for (int n = 0; n < outputMembers.Count; n++)
{
CodeParameterDeclarationExpression cpd = GenerateParameter(outputMembers[n], FieldDirection.Out);
outParams [n] = cpd;
bool found = false;
foreach (CodeParameterDeclarationExpression ip in method.Parameters)
{
if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType)
{
ip.Direction = FieldDirection.Ref;
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
found = true;
break;
}
}
if (found)
{
continue;
}
if (!hasReturn)
{
hasReturn = true;
method.ReturnType = cpd.Type;
methodEnd.ReturnType = cpd.Type;
GenerateReturnAttributes(outputMembers, outputMembers[n], bodyBinding.Use, method);
outParams [n] = null;
continue;
}
method.Parameters.Add(cpd);
GenerateMemberAttributes(outputMembers, outputMembers[n], bodyBinding.Use, cpd);
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
}
}
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), varCallback));
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), varAsyncState));
methodBegin.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
{
methodParams = new CodeArrayCreateExpression(typeof(object), paramArray);
}
else
{
methodParams = new CodeArrayCreateExpression(typeof(object), 0);
}
// Assignment of output parameters
CodeStatementCollection outAssign = new CodeStatementCollection();
CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression(varResults);
for (int n = 0; n < outParams.Length; n++)
{
CodeExpression index = new CodePrimitiveExpression(n);
if (outParams[n] == null)
{
CodeExpression res = new CodeCastExpression(method.ReturnType, new CodeArrayIndexerExpression(arrVar, index));
outAssign.Add(new CodeMethodReturnStatement(res));
}
else
{
CodeExpression res = new CodeCastExpression(outParams[n].Type, new CodeArrayIndexerExpression(arrVar, index));
CodeExpression var = new CodeVariableReferenceExpression(outParams[n].Name);
outAssign.Insert(0, new CodeAssignStatement(var, res));
}
}
if (Style == ServiceDescriptionImportStyle.Client)
{
// Invoke call
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression(messageName);
CodeMethodInvokeExpression inv;
CodeVariableDeclarationStatement dec;
inv = new CodeMethodInvokeExpression(ethis, "Invoke", varMsgName, methodParams);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
method.Statements.Add(dec);
method.Statements.AddRange(outAssign);
}
else
{
method.Statements.Add(inv);
}
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression(varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression(varAsyncState);
inv = new CodeMethodInvokeExpression(ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add(new CodeMethodReturnStatement(inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression(varAsyncResult);
inv = new CodeMethodInvokeExpression(ethis, "EndInvoke", varAsyncr);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
methodEnd.Statements.Add(dec);
methodEnd.Statements.AddRange(outAssign);
}
else
{
methodEnd.Statements.Add(inv);
}
}
else
{
method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
}
// Attributes
ImportHeaders(method);
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.WebMethodAttribute");
if (messageName != method.Name)
{
att.Arguments.Add(GetArg("MessageName", messageName));
}
AddCustomAttribute(method, att, (Style == ServiceDescriptionImportStyle.Server));
if (style == SoapBindingStyle.Rpc)
{
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapRpcMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
}
else
{
if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" ||
inputMembers.ElementName != "" && outputMembers.ElementName == ""))
{
throw new InvalidOperationException("Parameter style is not the same for the input message and output message");
}
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapDocumentMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != "")
{
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped"));
}
else
{
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare"));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
att.Arguments.Add(GetEnumArg("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString()));
}
AddCustomAttribute(method, att, true);
CodeTypeDeclaration.Members.Add(method);
if (Style == ServiceDescriptionImportStyle.Client)
{
CodeTypeDeclaration.Members.Add(methodBegin);
CodeTypeDeclaration.Members.Add(methodEnd);
}
return(method);
}
public void Insert_Null()
{
CodeStatementCollection coll = new CodeStatementCollection();
coll.Insert(0, (CodeStatement)null);
}
private static void BuildLogic(CodeStatementCollection statements, ReadOnlyArrayCollection <ParticleSystemLogicStep> steps, bool addMethod)
{
Dictionary <string, bool> argsUsed = new Dictionary <string, bool>();
foreach (string arg in memberTranslate.Keys)
{
argsUsed.Add(arg, false);
}
argsUsed.Add("rand", false);
CodeStatementCollection code = new CodeStatementCollection();
BuildLogic(code, steps, argsUsed, 0);
//rand requires a local variable
if (argsUsed["rand"])
{
statements.Add(
new CodeVariableDeclarationStatement(
typeof(float), "_tmp", new CodePrimitiveExpression(0.0f)));
}
for (int i = 0; i < 4; i++)
{
if (argsUsed["local" + i])
{
code.Insert(0,
new CodeVariableDeclarationStatement(
typeof(float), "local" + i, new CodePrimitiveExpression(0.0f)));
}
}
CodeVariableReferenceExpression ref_i = new CodeVariableReferenceExpression("i");
if (addMethod) // add methods have indices to update...
{
ref_i.VariableName = "_i";
}
CodeIterationStatement loop = new CodeIterationStatement();
loop.InitStatement = new CodeVariableDeclarationStatement(typeof(uint), ref_i.VariableName, new CodePrimitiveExpression(0));
loop.IncrementStatement = new CodeAssignStatement(ref_i, new CodeBinaryOperatorExpression(ref_i, CodeBinaryOperatorType.Add, new CodePrimitiveExpression((uint)1)));
loop.TestExpression = new CodeBinaryOperatorExpression(ref_i, CodeBinaryOperatorType.LessThan, new CodeArgumentReferenceExpression("count"));
// uint i = indices[_i];
if (addMethod)
{
loop.Statements.Add(new CodeVariableDeclarationStatement(typeof(uint), "i", new CodeArrayIndexerExpression(new CodeArgumentReferenceExpression("indices"), ref_i)));
}
else
{
//put in velocity logic
loop.Statements.Add(
new CodeAssignStatement(Arg("position.x"),
new CodeBinaryOperatorExpression(Arg("position.x"), CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(Arg("velocity.x"), CodeBinaryOperatorType.Multiply, Arg("delta_time")))));
loop.Statements.Add(
new CodeAssignStatement(Arg("position.y"),
new CodeBinaryOperatorExpression(Arg("position.y"), CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(Arg("velocity.y"), CodeBinaryOperatorType.Multiply, Arg("delta_time")))));
loop.Statements.Add(
new CodeAssignStatement(Arg("position.z"),
new CodeBinaryOperatorExpression(Arg("position.z"), CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(Arg("velocity.z"), CodeBinaryOperatorType.Multiply, Arg("delta_time")))));
}
loop.Statements.AddRange(code);
statements.Add(loop);
}
// CodeStatementCollection
public void CodeStatementCollectionSample()
{
//<Snippet1>
//<Snippet2>
// Creates an empty CodeStatementCollection.
CodeStatementCollection collection = new CodeStatementCollection();
//</Snippet2>
//<Snippet3>
// Adds a CodeStatement to the collection.
collection.Add(new CodeCommentStatement("Test comment statement"));
//</Snippet3>
//<Snippet4>
// Adds an array of CodeStatement objects to the collection.
CodeStatement[] statements =
{
new CodeCommentStatement("Test comment statement"),
new CodeCommentStatement("Test comment statement")
};
collection.AddRange(statements);
// Adds a collection of CodeStatement objects to the collection.
CodeStatement testStatement = new CodeCommentStatement("Test comment statement");
CodeStatementCollection statementsCollection = new CodeStatementCollection();
statementsCollection.Add(new CodeCommentStatement("Test comment statement"));
statementsCollection.Add(new CodeCommentStatement("Test comment statement"));
statementsCollection.Add(testStatement);
collection.AddRange(statementsCollection);
//</Snippet4>
//<Snippet5>
// Tests for the presence of a CodeStatement in the
// collection, and retrieves its index if it is found.
int itemIndex = -1;
if (collection.Contains(testStatement))
{
itemIndex = collection.IndexOf(testStatement);
}
//</Snippet5>
//<Snippet6>
// Copies the contents of the collection beginning at index 0 to the specified CodeStatement array.
// 'statements' is a CodeStatement array.
CodeStatement[] statementArray = new CodeStatement[collection.Count];
collection.CopyTo(statementArray, 0);
//</Snippet6>
//<Snippet7>
// Retrieves the count of the items in the collection.
int collectionCount = collection.Count;
//</Snippet7>
//<Snippet8>
// Inserts a CodeStatement at index 0 of the collection.
collection.Insert(0, new CodeCommentStatement("Test comment statement"));
//</Snippet8>
//<Snippet9>
// Removes the specified CodeStatement from the collection.
collection.Remove(testStatement);
//</Snippet9>
//<Snippet10>
// Removes the CodeStatement at index 0.
collection.RemoveAt(0);
//</Snippet10>
//</Snippet1>
}
/// <include file='doc\ComponentCodeDomSerializer.uex' path='docs/doc[@for="ComponentCodeDomSerializer.Serialize"]/*' />
/// <devdoc>
/// Serializes the given object into a CodeDom object.
/// </devdoc>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "ComponentCodeDomSerializer::Serialize");
Debug.Indent();
try {
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Value: " + value.ToString());
}
catch {
// in case the ToString throws...
}
if (manager == null || value == null)
{
throw new ArgumentNullException(manager == null ? "manager" : "value");
}
CodeStatementCollection statements = new CodeStatementCollection();
CodeExpression instanceDescrExpr = null;
InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited;
if (inheritanceAttribute != null)
{
inheritanceLevel = inheritanceAttribute.InheritanceLevel;
}
// Get the name for this object. Components can only be serialized if they have
// a name.
//
string name = manager.GetName(value);
bool generateDeclaration = (name != null);
if (name == null)
{
IReferenceService referenceService = (IReferenceService)manager.GetService(typeof(IReferenceService));
if (referenceService != null)
{
name = referenceService.GetName(value);
}
}
Debug.WriteLineIf(traceSerialization.TraceWarning && name == null, "WARNING: object has no name so we cannot serialize.");
if (name != null)
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Name: " + name);
// Push the component being serialized onto the stack. It may be handy to
// be able to discover this.
//
manager.Context.Push(value);
try {
try {
// If the object is not inherited ensure that is has a component declaration.
//
if (generateDeclaration && inheritanceLevel == InheritanceLevel.NotInherited)
{
// Check to make sure this isn't our base component. If it is, there is
// no need to serialize its declaration.
//
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if ((host == null || host.RootComponent != value))
{
SerializeDeclaration(manager, statements, value);
}
}
else
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Skipping declaration of inherited or namespace component.");
}
// Next, if the object is not being privately inherited, serialize the
// rest of its state.
//
if (inheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
bool supportInitialize = (value is ISupportInitialize);
if (supportInitialize)
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Object implements ISupportInitialize.");
SerializeSupportInitialize(manager, statements, value, "BeginInit");
}
// Add a nice comment that declares we're about to serialize this component
//
int insertLoc = statements.Count;
SerializePropertiesToResources(manager, statements, value, designTimeProperties);
SerializeProperties(manager, statements, value, runTimeProperties);
SerializeEvents(manager, statements, value, null);
// if we added some statements, insert the comments
//
if (statements.Count > insertLoc)
{
statements.Insert(insertLoc, new CodeCommentStatement(string.Empty));
statements.Insert(insertLoc, new CodeCommentStatement(name));
statements.Insert(insertLoc, new CodeCommentStatement(string.Empty));
}
if (supportInitialize)
{
SerializeSupportInitialize(manager, statements, value, "EndInit");
}
}
else
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Skipping serialization of read-only inherited component");
}
}
catch (Exception ex) {
manager.ReportError(ex);
}
}
finally {
Debug.Assert(manager.Context.Current == value, "Context stack corrupted");
manager.Context.Pop();
}
}
else
{
Debug.WriteLineIf(traceSerialization.TraceWarning, "Attempting instance descriptor serialization.");
Debug.Indent();
// Last resort, lets see if if can serialize itself to an instance descriptor.
//
if (TypeDescriptor.GetConverter(value).CanConvertTo(typeof(InstanceDescriptor)))
{
Debug.WriteLineIf(traceSerialization.TraceWarning, "Type supports instance descriptor.");
// Got an instance descriptor. Ask it to serialize
//
object o = InstanceDescriptorCodeDomSerializer.Default.Serialize(manager, value);
if (o is CodeExpression)
{
Debug.WriteLineIf(traceSerialization.TraceWarning, "Serialized successfully.");
instanceDescrExpr = (CodeExpression)o;
}
}
Debug.Unindent();
}
if (instanceDescrExpr != null)
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Object serialized into a single InstanceDescriptor expression.");
Debug.Unindent();
return(instanceDescrExpr);
}
else
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "Object serialized into " + statements.Count.ToString() + " statements.");
Debug.Unindent();
return(statements);
}
}
/*
* Build first-time intialization statements
*/
protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements)
{
base.BuildInitStatements(trueStatements, topLevelStatements);
//
CodeMemberField fileDependencies = new CodeMemberField(typeof(object), fileDependenciesName);
fileDependencies.Attributes |= MemberAttributes.Static;
_sourceDataClass.Members.Add(fileDependencies);
// Note: it may look like this local variable declaration is redundant. However it is necessary
// to make this init code re-entrant safe. This way, even if two threads enter the contructor
// at the same time, they will not add multiple dependencies.
// e.g. string[] dependencies;
CodeVariableDeclarationStatement dependencies = new CodeVariableDeclarationStatement();
dependencies.Type = new CodeTypeReference(typeof(string[]));
dependencies.Name = dependenciesLocalName;
// Note: it is important to add all local variables at the top level for CodeDom Subset compliance.
topLevelStatements.Insert(0, dependencies);
Debug.Assert(Parser.SourceDependencies != null);
StringSet virtualDependencies = new StringSet();
virtualDependencies.AddCollection(Parser.SourceDependencies);
// e.g. dependencies = new string[{{virtualDependencies.Count}}];;
CodeAssignStatement assignDependencies = new CodeAssignStatement();
assignDependencies.Left =
new CodeVariableReferenceExpression(dependenciesLocalName);
assignDependencies.Right =
new CodeArrayCreateExpression(typeof(String), virtualDependencies.Count);
trueStatements.Add(assignDependencies);
int i = 0;
foreach (string virtualDependency in virtualDependencies)
{
// e.g. dependencies[i] = "~/sub/foo.aspx";
CodeAssignStatement addFileDep = new CodeAssignStatement();
addFileDep.Left =
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression(dependenciesLocalName),
new CodeExpression[] { new CodePrimitiveExpression(i++) });
string src = UrlPath.MakeVirtualPathAppRelative(virtualDependency);
addFileDep.Right = new CodePrimitiveExpression(src);
trueStatements.Add(addFileDep);
}
// e.g. __fileDependencies = this.GetWrappedFileDependencies(dependencies);
CodeAssignStatement initFile = new CodeAssignStatement();
initFile.Left = new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName);
CodeMethodInvokeExpression createWrap = new CodeMethodInvokeExpression();
createWrap.Method.TargetObject = new CodeThisReferenceExpression();
createWrap.Method.MethodName = "GetWrappedFileDependencies";
createWrap.Parameters.Add(new CodeVariableReferenceExpression(dependenciesLocalName));
initFile.Right = createWrap;
#if DBG
AppendDebugComment(trueStatements);
#endif
trueStatements.Add(initFile);
}
