public override void ImportClass()
{
SoapAddressBinding binding = (base.ImportContext.Port == null) ? null : ((SoapAddressBinding) base.ImportContext.Port.Extensions.Find(typeof(SoapAddressBinding)));
if (base.ImportContext.Style == ServiceDescriptionImportStyle.Client)
{
base.ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(SoapHttpClientProtocol).FullName);
CodeConstructor ctor = WebCodeGenerator.AddConstructor(base.ImportContext.CodeTypeDeclaration, new string[0], new string[0], null, CodeFlags.IsPublic);
ctor.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true));
bool flag = true;
if (base.ImportContext is Soap12ProtocolImporter)
{
flag = false;
CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(typeof(SoapProtocolVersion));
CodeFieldReferenceExpression right = new CodeFieldReferenceExpression(targetObject, Enum.Format(typeof(SoapProtocolVersion), SoapProtocolVersion.Soap12, "G"));
CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "SoapVersion");
CodeAssignStatement statement = new CodeAssignStatement(left, right);
ctor.Statements.Add(statement);
}
ServiceDescription serviceDescription = base.ImportContext.Binding.ServiceDescription;
string url = (binding != null) ? binding.Location : null;
string appSettingUrlKey = serviceDescription.AppSettingUrlKey;
string appSettingBaseUrl = serviceDescription.AppSettingBaseUrl;
ProtocolImporterUtil.GenerateConstructorStatements(ctor, url, appSettingUrlKey, appSettingBaseUrl, flag && !base.ImportContext.IsEncodedBinding);
}
else if (base.ImportContext.Style == ServiceDescriptionImportStyle.Server)
{
base.ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(WebService).FullName);
}
}
protected CodeStatementCollection GenerateSetMappedPropertyCode(CodeExpression targetObj, CodeExpression value)
{
CodeStatementCollection statements = new CodeStatementCollection();
CodePropertyReferenceExpression property = new CodePropertyReferenceExpression(targetObj, MappedProperty.Name);
if (_mappedProperty.PropertyType.IsArray)
{
statements.Add(new CodeAssignStatement(
new CodeIndexerExpression(property, new CodePrimitiveExpression(_index)), value));
return statements;
}
if (IsCollection(_mappedProperty.PropertyType))
{
CodeBinaryOperatorExpression isNull =
new CodeBinaryOperatorExpression(property, CodeBinaryOperatorType.ValueEquality, new CodeSnippetExpression("null"));
CodeAssignStatement create = new CodeAssignStatement(property, new CodeObjectCreateExpression(_mappedProperty.PropertyType));
statements.Add(new CodeConditionStatement(isNull, create));
statements.Add(new CodeMethodInvokeExpression(property, "Add", value));
return statements;
}
statements.Add(new CodeAssignStatement(property, value));
return statements;
}
private void BuildAddContentPlaceHolderNames(CodeMemberMethod method, string placeHolderID) {
CodePropertyReferenceExpression propertyExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ContentPlaceHolders");
CodeExpressionStatement stmt = new CodeExpressionStatement();
stmt.Expression = new CodeMethodInvokeExpression(propertyExpr, "Add", new CodePrimitiveExpression(placeHolderID.ToLower(CultureInfo.InvariantCulture)));
method.Statements.Add(stmt);
}
public override void ImportClass() {
// grab this here so it gets marked "handled" for both client and server
SoapAddressBinding soapAddress = ImportContext.Port == null ? null : (SoapAddressBinding)ImportContext.Port.Extensions.Find(typeof(SoapAddressBinding));
if (ImportContext.Style == ServiceDescriptionImportStyle.Client) {
ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(SoapHttpClientProtocol).FullName);
CodeConstructor ctor = WebCodeGenerator.AddConstructor(ImportContext.CodeTypeDeclaration, new string[0], new string[0], null, CodeFlags.IsPublic);
ctor.Comments.Add(new CodeCommentStatement(Res.GetString(Res.CodeRemarks), true));
bool soap11 = true;
if (ImportContext is Soap12ProtocolImporter) {
soap11 = false;
// add version code
CodeTypeReferenceExpression versionEnumTypeReference = new CodeTypeReferenceExpression(typeof(SoapProtocolVersion));
CodeFieldReferenceExpression versionEnumFieldReference = new CodeFieldReferenceExpression(versionEnumTypeReference, Enum.Format(typeof(SoapProtocolVersion), SoapProtocolVersion.Soap12, "G"));
CodePropertyReferenceExpression versionPropertyReference = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "SoapVersion");
CodeAssignStatement assignVersionStatement = new CodeAssignStatement(versionPropertyReference, versionEnumFieldReference);
ctor.Statements.Add(assignVersionStatement);
}
ServiceDescription serviceDescription = ImportContext.Binding.ServiceDescription;
string url = (soapAddress != null) ? soapAddress.Location : null;
string urlKey = serviceDescription.AppSettingUrlKey;
string baseUrl = serviceDescription.AppSettingBaseUrl;
ProtocolImporterUtil.GenerateConstructorStatements(ctor, url, urlKey, baseUrl, soap11 && !ImportContext.IsEncodedBinding);
}
else if (ImportContext.Style == ServiceDescriptionImportStyle.Server) {
ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(WebService).FullName);
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object obj2 = ((CodeDomSerializer) manager.GetSerializer(typeof(ImageList).BaseType, typeof(CodeDomSerializer))).Serialize(manager, value);
ImageList list = value as ImageList;
if (list != null)
{
StringCollection keys = list.Images.Keys;
if (!(obj2 is CodeStatementCollection))
{
return obj2;
}
CodeExpression targetObject = base.GetExpression(manager, value);
if (targetObject == null)
{
return obj2;
}
CodeExpression expression2 = new CodePropertyReferenceExpression(targetObject, "Images");
if (expression2 == null)
{
return obj2;
}
for (int i = 0; i < keys.Count; i++)
{
if ((keys[i] != null) || (keys[i].Length != 0))
{
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(expression2, "SetKeyName", new CodeExpression[] { new CodePrimitiveExpression(i), new CodePrimitiveExpression(keys[i]) });
((CodeStatementCollection) obj2).Add(expression3);
}
}
}
return obj2;
}
private static CodePropertyReferenceExpression DeserializeAppConfigExpression(string[] expressionParts)
{
int index = expressionParts.Length - 1;
CodePropertyReferenceExpression expression = new CodePropertyReferenceExpression {
PropertyName = expressionParts[index]
};
index--;
CodeIndexerExpression expression2 = new CodeIndexerExpression();
expression.TargetObject = expression2;
expression2.Indices.Add(new CodePrimitiveExpression(expressionParts[index]));
index--;
CodePropertyReferenceExpression expression3 = new CodePropertyReferenceExpression();
expression2.TargetObject = expression3;
expression3.PropertyName = expressionParts[index];
index--;
CodeTypeReferenceExpression expression4 = new CodeTypeReferenceExpression();
expression3.TargetObject = expression4;
expression4.Type.Options = (CodeTypeReferenceOptions) Enum.Parse(typeof(CodeTypeReferenceOptions), expressionParts[index]);
index--;
expression4.Type.BaseType = expressionParts[index];
index--;
while (index > 0)
{
expression4.Type.BaseType = expressionParts[index] + "." + expression4.Type.BaseType;
index--;
}
return expression;
}
public override void HandleBoolean()
{
this.proprefContainerField = new CodePropertyReferenceExpression(CodeBuilderCommon.varrefReadValue, "DbusBoolean");
#if !INHERIT_FROM_INTERFACE
base.HandleBoolean();
#endif // !INHERIT_FROM_INTERFACE
}
public void Constructor0 ()
{
CodePropertyReferenceExpression cpre = new CodePropertyReferenceExpression ();
Assert.IsNotNull (cpre.PropertyName, "#1");
Assert.AreEqual (string.Empty, cpre.PropertyName, "#2");
Assert.IsNull (cpre.TargetObject, "#3");
string propertyName = "mono";
cpre.PropertyName = propertyName;
Assert.IsNotNull (cpre.PropertyName, "#4");
Assert.AreSame (propertyName, cpre.PropertyName, "#5");
cpre.PropertyName = null;
Assert.IsNotNull (cpre.PropertyName, "#6");
Assert.AreEqual (string.Empty, cpre.PropertyName, "#7");
CodeExpression expression = new CodeExpression ();
cpre.TargetObject = expression;
Assert.IsNotNull (cpre.TargetObject, "#8");
Assert.AreSame (expression, cpre.TargetObject, "#9");
cpre.TargetObject = null;
Assert.IsNull (cpre.TargetObject, "#10");
}
protected override void CreateConstructor (CodeStatementCollection localVars,
CodeStatementCollection trueStmt)
{
if (pageParser.ClientTarget != null) {
CodeExpression prop;
prop = new CodePropertyReferenceExpression (thisRef, "ClientTarget");
CodeExpression ct = new CodePrimitiveExpression (pageParser.ClientTarget);
if (localVars == null)
localVars = new CodeStatementCollection ();
localVars.Add (new CodeAssignStatement (prop, ct));
}
#if NET_2_0
if (pageParser.MasterPageFile != null) {
CodeExpression prop;
prop = new CodePropertyReferenceExpression (thisRef, "MasterPageFile");
CodeExpression ct = new CodePrimitiveExpression (pageParser.MasterPageFile);
if (localVars == null)
localVars = new CodeStatementCollection ();
localVars.Add (new CodeAssignStatement (prop, ct));
}
#endif
base.CreateConstructor (localVars, trueStmt);
}
void GenerateXmlType (XmlQualifiedName qname)
{
var cns = GetCodeNamespace (qname.Namespace);
var td = new CodeTypeDeclaration () {
Name = GetUniqueName (CodeIdentifier.MakeValid (qname.Name), cns),
TypeAttributes = GenerateInternal ? TypeAttributes.NotPublic : TypeAttributes.Public,
IsPartial = true };
cns.Types.Add (td);
td.BaseTypes.Add (new CodeTypeReference (typeof (IXmlSerializable)));
var thisNodes = new CodePropertyReferenceExpression (new CodeThisReferenceExpression (), "Nodes"); // property this.Nodes
var xmlSerializableServices = new CodeTypeReferenceExpression (typeof (XmlSerializableServices)); // static XmlSerializableServices.
var qnameType = new CodeTypeReference (typeof (XmlQualifiedName));
// XmlQualifiedName qname = new XmlQualifiedName ({qname.Name}, {qname.Namespace});
td.Members.Add (new CodeMemberField () { Name = "qname", Type = qnameType, InitExpression = new CodeObjectCreateExpression (qnameType, new CodePrimitiveExpression (qname.Name), new CodePrimitiveExpression (qname.Namespace)) });
// public XmlNode[] Nodes { get; set; }
td.Members.Add (new CodeMemberProperty () { Name = "Nodes", Type = new CodeTypeReference (typeof (XmlNode [])), Attributes = (GenerateInternal ? MemberAttributes.Assembly : MemberAttributes.Public) | MemberAttributes.Final, HasGet = true, HasSet = true });
// public void ReadXml(XmlReader reader) {
var read = new CodeMemberMethod () { Name = "ReadXml", Attributes = (GenerateInternal ? MemberAttributes.Assembly : MemberAttributes.Public) | MemberAttributes.Final };
read.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (XmlReader)), "reader"));
// this.Nodes = XmlSerializableServices.ReadXml(reader);
read.Statements.Add (
new CodeAssignStatement (thisNodes,
new CodeMethodInvokeExpression (
new CodeMethodReferenceExpression (xmlSerializableServices, "ReadXml"),
new CodeArgumentReferenceExpression ("reader"))));
// }
td.Members.Add (read);
// public void WriteXml(XmlWriter writer) {
var write = new CodeMemberMethod () { Name = "WriteXml",Attributes = (GenerateInternal ? MemberAttributes.Assembly : MemberAttributes.Public) | MemberAttributes.Final };
write.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (XmlWriter)), "writer"));
// XmlSerializableServices.WriteXml(writer, this.Nodes);
write.Statements.Add (
new CodeMethodInvokeExpression (
new CodeMethodReferenceExpression (xmlSerializableServices, "WriteXml"),
new CodeArgumentReferenceExpression ("writer"),
thisNodes));
// }
td.Members.Add (write);
// public XmlSchema GetSchema () { return null; }
var getSchema = new CodeMemberMethod () { Name = "GetSchema", Attributes = (GenerateInternal ? MemberAttributes.Assembly : MemberAttributes.Public) | MemberAttributes.Final, ReturnType = new CodeTypeReference (typeof (XmlSchema)) };
getSchema.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (null)));
td.Members.Add (getSchema);
// public static XmlQualifiedName ExportSchema (XmlSchemaSet schemas) {
var export = new CodeMemberMethod () { Name = "ExportSchema", Attributes = (GenerateInternal ? MemberAttributes.Assembly : MemberAttributes.Public) | MemberAttributes.Final | MemberAttributes.Static, ReturnType = qnameType };
export.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (XmlSchemaSet)), "schemas"));
// XmlSerializableServices.AddDefaultSchema (schemas);
export.Statements.Add (new CodeMethodInvokeExpression (xmlSerializableServices, "AddDefaultSchema", new CodeArgumentReferenceExpression ("schemas")));
// return qname;
export.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "qname")));
// }
td.Members.Add (export);
}
private void BuildAddContentPlaceHolderNames(CodeMemberMethod method, string placeHolderID)
{
CodePropertyReferenceExpression targetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ContentPlaceHolders");
CodeExpressionStatement statement = new CodeExpressionStatement {
Expression = new CodeMethodInvokeExpression(targetObject, "Add", new CodeExpression[] { new CodePrimitiveExpression(placeHolderID.ToLower(CultureInfo.InvariantCulture)) })
};
method.Statements.Add(statement);
}
public void Constructor0_Deny_Unrestricted ()
{
CodePropertyReferenceExpression cpre = new CodePropertyReferenceExpression ();
Assert.AreEqual (String.Empty, cpre.PropertyName, "PropertyName");
cpre.PropertyName = "mono";
Assert.IsNull (cpre.TargetObject, "TargetObject");
cpre.TargetObject = new CodeExpression ();
}
public override string GetClassCodeForProcessingRun ()
{
var hostProp = new CodePropertyReferenceExpression (new CodeThisReferenceExpression (), "Host");
return TemplatingEngine.GenerateIndentedClassCode (
languageProvider,
CreateIsTrueMethod (hostProp),
CreateTagsProperty (hostProp)
);
}
public static CodePropertyReferenceExpression Clone(this CodePropertyReferenceExpression expression)
{
if (expression == null) return null;
CodePropertyReferenceExpression e = new CodePropertyReferenceExpression();
e.PropertyName = expression.PropertyName;
e.TargetObject = expression.TargetObject.Clone();
e.UserData.AddRange(expression.UserData);
return e;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeExpression target = new CodeExpression ();
CodePropertyReferenceExpression cpre = new CodePropertyReferenceExpression (target, "mono");
Assert.AreEqual ("mono", cpre.PropertyName, "PropertyName");
cpre.PropertyName = String.Empty;
Assert.AreSame (target, cpre.TargetObject, "TargetObject");
cpre.TargetObject = new CodeExpression ();
}
public TypescriptPropertyReferenceExpression(
IExpressionFactory expressionFactory,
CodePropertyReferenceExpression codeExpression,
CodeGeneratorOptions options)
{
_expressionFactory = expressionFactory;
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptPropertyReferenceExpression Created");
}
public override void Generate(CodeObject codeObject, Entity entity)
{
var propNode = (CodeMemberProperty) codeObject;
var property = (GenericProperty) entity;
var contentRef = new CodePropertyReferenceExpression(null, "Content");
var getPropertyValueMethod = new CodeMethodReferenceExpression(contentRef, "GetPropertyValue", propNode.Type);
var getPropertyValueCall = new CodeMethodInvokeExpression(getPropertyValueMethod, new CodePrimitiveExpression(property.Alias));
propNode.GetStatements.Add(new CodeMethodReturnStatement(getPropertyValueCall));
}
internal static CodeExpression BuildPropertyReferenceExpression(CodeExpression objRefExpr, string propName)
{
string[] strArray = propName.Split(new char[] { '.' });
CodeExpression targetObject = objRefExpr;
foreach (string str in strArray)
{
targetObject = new CodePropertyReferenceExpression(targetObject, str);
}
return targetObject;
}
protected override void AddStatementsToInitMethodTop (ControlBuilder builder, CodeMemberMethod method)
{
base.AddStatementsToInitMethodTop (builder, method);
if (parser.MasterPageFile != null) {
CodeExpression prop;
prop = new CodePropertyReferenceExpression (new CodeArgumentReferenceExpression("__ctrl"), "MasterPageFile");
CodeExpression ct = new CodePrimitiveExpression (parser.MasterPageFile);
method.Statements.Add (AddLinePragma (new CodeAssignStatement (prop, ct), parser.DirectiveLocation));
}
}
internal static void GenerateConstructorStatements(CodeConstructor ctor, string url, string appSettingUrlKey, string appSettingBaseUrl, bool soap11)
{
bool flag = (url != null) && (url.Length > 0);
bool flag2 = (appSettingUrlKey != null) && (appSettingUrlKey.Length > 0);
CodeAssignStatement statement = null;
if (flag || flag2)
{
CodeExpression expression;
CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Url");
if (flag)
{
expression = new CodePrimitiveExpression(url);
statement = new CodeAssignStatement(left, expression);
}
if (flag && !flag2)
{
ctor.Statements.Add(statement);
}
else if (flag2)
{
CodeVariableReferenceExpression expression3 = new CodeVariableReferenceExpression("urlSetting");
CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(typeof(ConfigurationManager));
CodePropertyReferenceExpression expression5 = new CodePropertyReferenceExpression(targetObject, "AppSettings");
expression = new CodeIndexerExpression(expression5, new CodeExpression[] { new CodePrimitiveExpression(appSettingUrlKey) });
ctor.Statements.Add(new CodeVariableDeclarationStatement(typeof(string), "urlSetting", expression));
if ((appSettingBaseUrl == null) || (appSettingBaseUrl.Length == 0))
{
expression = expression3;
}
else
{
if ((url == null) || (url.Length == 0))
{
throw new ArgumentException(Res.GetString("IfAppSettingBaseUrlArgumentIsSpecifiedThen0"));
}
string str = new Uri(appSettingBaseUrl).MakeRelative(new Uri(url));
CodeExpression[] parameters = new CodeExpression[] { expression3, new CodePrimitiveExpression(str) };
expression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(string)), "Concat", parameters);
}
CodeStatement[] trueStatements = new CodeStatement[] { new CodeAssignStatement(left, expression) };
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(expression3, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
if (flag)
{
ctor.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[] { statement }));
}
else
{
ctor.Statements.Add(new CodeConditionStatement(condition, trueStatements));
}
}
}
}
protected override void ParseElement(XElement element)
{
if (!m_firstElement)
throw new InvalidOperationException();
var objectParser = new ObjectParser(State);
objectParser.Parse(element);
var left = new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression(Parent.VariableName), Name);
var right = new CodeVariableReferenceExpression(objectParser.VariableName);
var assignment = new CodeAssignStatement(left, right);
State.AddStatement(assignment);
}
public override void SetTestInitializeMethod(TestClassGenerationContext generationContext)
{
base.SetTestInitializeMethod(generationContext);
// SenarioContext.Current.SetTestInstance(this);
var scenarioContext = new CodeTypeReferenceExpression("ScenarioContext");
var currentContext = new CodePropertyReferenceExpression(scenarioContext, "Current");
var scenarioContextExtensions = new CodeTypeReferenceExpression("ScenarioContextExtensions");
var setTestInstance = new CodeMethodInvokeExpression(scenarioContextExtensions, "SetTestInstance",
currentContext, new CodeThisReferenceExpression());
// Add it to ScenarioSetup
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeExpressionStatement(setTestInstance));
}
private void SerializeNormalProperty (IDesignerSerializationManager manager,
object value, PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodeExpression leftSide = base.SerializeToExpression (manager, value);
CodeExpression rightSide = null;
MemberRelationship relationship = GetRelationship (manager, value, descriptor);
if (!relationship.IsEmpty)
rightSide = new CodePropertyReferenceExpression (base.SerializeToExpression (manager, relationship.Owner),
relationship.Member.Name);
else
rightSide = base.SerializeToExpression (manager, descriptor.GetValue (value));
statements.Add (new CodeAssignStatement (leftSide, rightSide));
}
static CodeTypeMember CreateIsTrueMethod (CodePropertyReferenceExpression hostProp)
{
var stringTypeRef = new CodeTypeReference (typeof(string));
var boolTypeRef = new CodeTypeReference (typeof(bool));
var meth = new CodeMemberMethod { Name = "IsTrue" };
meth.Parameters.Add (new CodeParameterDeclarationExpression (stringTypeRef, "key"));
meth.ReturnType = boolTypeRef;
meth.Statements.Add (
new CodeMethodReturnStatement (
new CodeMethodInvokeExpression (
hostProp, "IsTrue", new CodeArgumentReferenceExpression (meth.Parameters[0].Name)
)
)
);
return meth;
}
public void SetNodeValue(XmlNode n)
{
for (int i = 0; i < n.Attributes.Count; i++)
{
string value = n.Attributes[i].Value;
//AddField(n.Attributes[i].Name, value, MemberAttributes.Private);
fieldList.Add(new ItemField(n.Attributes[i].Name, value, MemberAttributes.Private));
ItemProperty item = new ItemProperty(n.Attributes[i].Name);
item.SetGetName();
item.SetValueType(value);
item.SetModifier(MemberAttributes.Public | MemberAttributes.Final);
propertyList.Add(item);
CodeConditionStatement condition = new CodeConditionStatement();
condition.Condition = new CodeVariableReferenceExpression("inArg0.ContainsKey(\"" + n.Attributes[i].Name + "\")");
string parseLeft = "";
string parseRight = "";
if (Stringer.IsNumber(value))
{
parseLeft = value.Contains(".") ? "float.Parse(" : "uint.Parse(";
parseRight = ")";
}
CodeVariableReferenceExpression right = new CodeVariableReferenceExpression(parseLeft + "inArg0[\"" + n.Attributes[i].Name + "\"]" + parseRight);
CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "_" + Stringer.FirstLetterLower(n.Attributes[i].Name));
if (Stringer.IsNumber(value))
{
CodeConditionStatement numCondition = new CodeConditionStatement();
numCondition.Condition = new CodeVariableReferenceExpression("inArg0[\"" + n.Attributes[i].Name + "\"] == \"\"");
numCondition.TrueStatements.Add(new CodeAssignStatement(left, new CodeVariableReferenceExpression("0")));
numCondition.FalseStatements.Add(new CodeAssignStatement(left, right));
condition.TrueStatements.Add(numCondition);
}
else
{
condition.TrueStatements.Add(new CodeAssignStatement(left, right));
}
AddConditionStatement(condition);
}
Create();
}
protected internal override void CreateMethods ()
{
base.CreateMethods ();
Type type = parser.MasterType;
if (type != null) {
CodeMemberProperty mprop = new CodeMemberProperty ();
mprop.Name = "Master";
mprop.Type = new CodeTypeReference (parser.MasterType);
mprop.Attributes = MemberAttributes.Public | MemberAttributes.New;
CodeExpression prop = new CodePropertyReferenceExpression (new CodeBaseReferenceExpression (), "Master");
prop = new CodeCastExpression (parser.MasterType, prop);
mprop.GetStatements.Add (new CodeMethodReturnStatement (prop));
mainClass.Members.Add (mprop);
AddReferencedAssembly (type.Assembly);
}
}
private void SerializeNormalProperty (IDesignerSerializationManager manager,
object component, PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodeAssignStatement assignment = new CodeAssignStatement ();
CodeExpression leftSide = null;
CodePropertyReferenceExpression propRef = null;
ExpressionContext expression = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
RootContext root = manager.Context[typeof (RootContext)] as RootContext;
if (expression != null && expression.PresetValue == component && expression.Expression != null) {
leftSide = new CodePropertyReferenceExpression (expression.Expression, descriptor.Name);
} else if (root != null && root.Value == component) {
leftSide = new CodePropertyReferenceExpression (root.Expression, descriptor.Name);
} else {
propRef = new CodePropertyReferenceExpression ();
propRef.PropertyName = descriptor.Name;
propRef.TargetObject = TryGetCachedExpression (manager, component, propRef);
leftSide = propRef;
}
CodeExpression rightSide = null;
MemberRelationship relationship = GetRelationship (manager, component, descriptor);
if (!relationship.IsEmpty) {
propRef = new CodePropertyReferenceExpression ();
propRef.PropertyName = relationship.Member.Name;
propRef.TargetObject = TryGetCachedExpression (manager, relationship.Owner, propRef);
rightSide = propRef;
} else {
object rightSideValue = descriptor.GetValue (component);
rightSide = TryGetCachedExpression (manager, rightSideValue, null, component);
}
if (rightSide == null) {
Console.WriteLine ("SerializeNormalProperty: <" + component.GetType().Name + "." +
descriptor.Name + "> - unable to serialize the right side of the assignment to expression");
} else if (leftSide == null) {
Console.WriteLine ("SerializeNormalProperty: <" + component.GetType().Name + "." +
descriptor.Name + "> - unable to serialize the left side of the assignment to expression");
} else {
assignment.Left = leftSide;
assignment.Right = rightSide;
statements.Add (assignment);
}
}
public virtual void SetScenarioSetup(CodeMemberMethod memberMethod)
{
//ScenarioContext
var scenarioContext = new CodeTypeReferenceExpression("ScenarioContext");
// .Current
var currentContext = new CodePropertyReferenceExpression(scenarioContext, "Current");
// ["SomeKey"]
var indexer = new CodeIndexerExpression(currentContext, new CodePrimitiveExpression(CALLING_FEATURE_KEY));
// = this;
var assignMent = new CodeAssignStatement(indexer, new CodeThisReferenceExpression());
//ScenarioContext.Current["SomeKey"] = this;
memberMethod.Statements.Add(assignMent);
}
protected CodeExpression GetMappedProperty(CodeExpression targetObj)
{
CodePropertyReferenceExpression property = new CodePropertyReferenceExpression(targetObj, MappedProperty.Name);
if (IsCollection(_mappedProperty.PropertyType))
{
return new CodeIndexerExpression(property,
new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(property, "Count"),
CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1)));
}
if (_mappedProperty.PropertyType.IsArray)
return new CodeIndexerExpression(property, new CodePrimitiveExpression(_index));
return property;
}
public void Constructor1 ()
{
CodeExpression expression = new CodeExpression ();
string propertyName = "mono";
CodePropertyReferenceExpression cpre = new CodePropertyReferenceExpression (
expression, propertyName);
Assert.IsNotNull (cpre.PropertyName, "#1");
Assert.AreSame (propertyName, cpre.PropertyName, "#2");
Assert.IsNotNull (cpre.TargetObject, "#3");
Assert.AreSame (expression, cpre.TargetObject, "#4");
cpre = new CodePropertyReferenceExpression ((CodeExpression) null,
(string) null);
Assert.IsNotNull (cpre.PropertyName, "#5");
Assert.AreEqual (string.Empty, cpre.PropertyName, "#6");
Assert.IsNull (cpre.TargetObject, "#7");
}
protected override void GeneratePropertyReferenceExpression(System.CodeDom.CodePropertyReferenceExpression e)
{
GenerateExpression(e.TargetObject);
Output.Write(".");
Output.Write(e.PropertyName);
}