| public Add ( string identifier, object value ) : void | ||
| identifier | string | |
| value | object | |
| Résultat | void | |
public void IgnoreCase ()
{
CodeIdentifiers c = new CodeIdentifiers (false);
c.Add ("test", "x");
c.Add ("Test", "y");
Assert.IsTrue ("test" != c.AddUnique ("Test", "z"), "#1");
Assert.IsTrue (c.IsInUse ("tEsT"), "#2");
Assert.AreEqual ("camelCase", c.MakeRightCase ("CAMELCASE"), "#3");
}
private MemberMapping ImportChoiceGroup(XmlSchemaGroupBase group, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, string ns, bool groupRepeats, ref bool needExplicitOrder, bool allowDuplicates)
{
NameTable choiceElements = new NameTable();
if (GatherGroupChoices(group, choiceElements, identifier, ns, ref needExplicitOrder, allowDuplicates))
groupRepeats = true;
MemberMapping member = new MemberMapping();
member.Elements = (ElementAccessor[])choiceElements.ToArray(typeof(ElementAccessor));
Array.Sort(member.Elements, new ElementComparer());
AddScopeElements(elementsScope, member.Elements, ref needExplicitOrder, allowDuplicates);
bool duplicateTypes = false;
bool nullableMismatch = false;
Hashtable uniqueTypeDescs = new Hashtable(member.Elements.Length);
for (int i = 0; i < member.Elements.Length; i++)
{
ElementAccessor element = member.Elements[i];
string tdFullName = element.Mapping.TypeDesc.FullName;
object val = uniqueTypeDescs[tdFullName];
if (val != null)
{
duplicateTypes = true;
ElementAccessor existingElement = (ElementAccessor)val;
if (!nullableMismatch && existingElement.IsNullable != element.IsNullable)
nullableMismatch = true;
}
else
{
uniqueTypeDescs.Add(tdFullName, element);
}
ArrayMapping arrayMapping = element.Mapping as ArrayMapping;
if (arrayMapping != null)
{
if (IsNeedXmlSerializationAttributes(arrayMapping))
{
// we cannot use ArrayMapping in choice if additional custom
// serialization attributes are needed to serialize it
element.Mapping = arrayMapping.TopLevelMapping;
element.Mapping.ReferencedByTopLevelElement = false;
element.Mapping.ReferencedByElement = true;
}
}
}
if (nullableMismatch)
member.TypeDesc = Scope.GetTypeDesc(typeof(object));
else
{
TypeDesc[] typeDescs = new TypeDesc[uniqueTypeDescs.Count];
IEnumerator enumerator = uniqueTypeDescs.Values.GetEnumerator();
for (int i = 0; i < typeDescs.Length; i++)
{
if (!enumerator.MoveNext())
break;
typeDescs[i] = ((ElementAccessor)enumerator.Current).Mapping.TypeDesc;
}
member.TypeDesc = TypeDesc.FindCommonBaseTypeDesc(typeDescs);
if (member.TypeDesc == null) member.TypeDesc = Scope.GetTypeDesc(typeof(object));
}
if (groupRepeats)
member.TypeDesc = member.TypeDesc.CreateArrayTypeDesc();
if (membersScope != null)
{
member.Name = membersScope.AddUnique(groupRepeats ? "Items" : "Item", member);
if (members != null)
{
members.Add(member.Name, member);
}
}
if (duplicateTypes)
{
member.ChoiceIdentifier = new ChoiceIdentifierAccessor();
member.ChoiceIdentifier.MemberName = member.Name + "ElementName";
// we need to create the EnumMapping to store all of the element names
member.ChoiceIdentifier.Mapping = ImportEnumeratedChoice(member.Elements, ns, member.Name + "ChoiceType");
member.ChoiceIdentifier.MemberIds = new string[member.Elements.Length];
ConstantMapping[] constants = ((EnumMapping)member.ChoiceIdentifier.Mapping).Constants;
for (int i = 0; i < member.Elements.Length; i++)
{
member.ChoiceIdentifier.MemberIds[i] = constants[i].Name;
}
MemberMapping choiceIdentifier = new MemberMapping();
choiceIdentifier.Ignore = true;
choiceIdentifier.Name = member.ChoiceIdentifier.MemberName;
if (groupRepeats)
{
choiceIdentifier.TypeDesc = member.ChoiceIdentifier.Mapping.TypeDesc.CreateArrayTypeDesc();
}
else
{
choiceIdentifier.TypeDesc = member.ChoiceIdentifier.Mapping.TypeDesc;
}
// create element accessor for the choiceIdentifier
ElementAccessor choiceAccessor = new ElementAccessor();
choiceAccessor.Name = choiceIdentifier.Name;
choiceAccessor.Namespace = ns;
choiceAccessor.Mapping = member.ChoiceIdentifier.Mapping;
choiceIdentifier.Elements = new ElementAccessor[] { choiceAccessor };
if (membersScope != null)
{
choiceAccessor.Name = choiceIdentifier.Name = member.ChoiceIdentifier.MemberName = membersScope.AddUnique(member.ChoiceIdentifier.MemberName, choiceIdentifier);
if (members != null)
{
members.Add(choiceAccessor.Name, choiceIdentifier);
}
}
}
return member;
}
private void ImportAnyAttributeMember(XmlSchemaAnyAttribute any, CodeIdentifiers members, CodeIdentifiers membersScope)
{
SpecialMapping mapping = new SpecialMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(XmlAttribute));
mapping.TypeName = mapping.TypeDesc.Name;
AttributeAccessor accessor = new AttributeAccessor();
accessor.Any = true;
accessor.Mapping = mapping;
MemberMapping member = new MemberMapping();
member.Elements = new ElementAccessor[0];
member.Attribute = accessor;
member.Name = membersScope.MakeRightCase("AnyAttr");
member.Name = membersScope.AddUnique(member.Name, member);
members.Add(member.Name, member);
member.TypeDesc = ((TypeMapping)accessor.Mapping).TypeDesc;
member.TypeDesc = member.TypeDesc.CreateArrayTypeDesc();
}
private void ImportXmlnsDeclarationsMember(XmlSchemaType type, CodeIdentifiers members, CodeIdentifiers membersScope)
{
string xmlnsMemberName;
if (!KeepXmlnsDeclarations(type, out xmlnsMemberName))
return;
TypeDesc xmlnsTypeDesc = Scope.GetTypeDesc(typeof(XmlSerializerNamespaces));
StructMapping xmlnsMapping = new StructMapping();
xmlnsMapping.TypeDesc = xmlnsTypeDesc;
xmlnsMapping.TypeName = xmlnsMapping.TypeDesc.Name;
xmlnsMapping.Members = new MemberMapping[0];
xmlnsMapping.IncludeInSchema = false;
xmlnsMapping.ReferencedByTopLevelElement = true;
ElementAccessor xmlns = new ElementAccessor();
xmlns.Mapping = xmlnsMapping;
MemberMapping member = new MemberMapping();
member.Elements = new ElementAccessor[] { xmlns };
member.Name = CodeIdentifier.MakeValid(xmlnsMemberName == null ? "Namespaces" : xmlnsMemberName);
member.Name = membersScope.AddUnique(member.Name, member);
members.Add(member.Name, member);
member.TypeDesc = xmlnsTypeDesc;
member.Xmlns = new XmlnsAccessor();
member.Ignore = true;
}
private void ImportElementMember(XmlSchemaElement element, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, string ns, bool repeats, ref bool needExplicitOrder, bool allowDuplicates, bool allowUnboundedElements)
{
repeats = repeats | element.IsMultipleOccurrence;
XmlSchemaElement headElement = GetTopLevelElement(element);
if (headElement != null && ImportSubstitutionGroupMember(headElement, identifier, members, membersScope, ns, repeats, ref needExplicitOrder, allowDuplicates))
{
return;
}
ElementAccessor accessor;
if ((accessor = ImportArray(element, identifier, ns, repeats)) == null)
{
accessor = ImportElement(element, identifier, typeof(TypeMapping), null, ns, false);
}
MemberMapping member = new MemberMapping();
string name = CodeIdentifier.MakeValid(Accessor.UnescapeName(accessor.Name));
member.Name = membersScope.AddUnique(name, member);
if (member.Name.EndsWith("Specified", StringComparison.Ordinal))
{
name = member.Name;
member.Name = membersScope.AddUnique(member.Name, member);
membersScope.Remove(name);
}
members.Add(member.Name, member);
// we do not support lists for elements
if (accessor.Mapping.IsList)
{
accessor.Mapping = GetDefaultMapping(TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue);
member.TypeDesc = accessor.Mapping.TypeDesc;
}
else
{
member.TypeDesc = accessor.Mapping.TypeDesc;
}
AddScopeElement(elementsScope, accessor, ref needExplicitOrder, allowDuplicates);
member.Elements = new ElementAccessor[] { accessor };
if (element.IsMultipleOccurrence || repeats)
{
if (!allowUnboundedElements && accessor.Mapping is ArrayMapping)
{
accessor.Mapping = ((ArrayMapping)accessor.Mapping).TopLevelMapping;
accessor.Mapping.ReferencedByTopLevelElement = false;
accessor.Mapping.ReferencedByElement = true;
}
member.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc();
}
if (element.MinOccurs == 0 && member.TypeDesc.IsValueType && !element.HasDefault && !member.TypeDesc.HasIsEmpty)
{
member.CheckSpecified = SpecifiedAccessor.ReadWrite;
}
}
private void ImportAttributeMember(XmlSchemaAttribute attribute, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, string ns)
{
AttributeAccessor accessor = ImportAttribute(attribute, identifier, ns, attribute);
if (accessor == null) return;
MemberMapping member = new MemberMapping();
member.Elements = new ElementAccessor[0];
member.Attribute = accessor;
member.Name = CodeIdentifier.MakeValid(Accessor.UnescapeName(accessor.Name));
member.Name = membersScope.AddUnique(member.Name, member);
if (member.Name.EndsWith("Specified", StringComparison.Ordinal))
{
string name = member.Name;
member.Name = membersScope.AddUnique(member.Name, member);
membersScope.Remove(name);
}
members.Add(member.Name, member);
member.TypeDesc = accessor.IsList ? accessor.Mapping.TypeDesc.CreateArrayTypeDesc() : accessor.Mapping.TypeDesc;
if ((attribute.Use == XmlSchemaUse.Optional || attribute.Use == XmlSchemaUse.None) && member.TypeDesc.IsValueType && !attribute.HasDefault && !member.TypeDesc.HasIsEmpty)
{
member.CheckSpecified = SpecifiedAccessor.ReadWrite;
}
}
private void ImportTextMember(CodeIdentifiers members, CodeIdentifiers membersScope, XmlQualifiedName simpleContentType)
{
TypeMapping mapping;
bool isMixed = false;
if (simpleContentType != null)
{
// allow to use all primitive types
mapping = ImportType(simpleContentType, typeof(TypeMapping), null, TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue, false);
if (!(mapping is PrimitiveMapping || mapping.TypeDesc.CanBeTextValue))
{
return;
}
}
else
{
// this is a case of the mixed content type, just generate string typeDesc
isMixed = true;
mapping = GetDefaultMapping(TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue);
}
TextAccessor accessor = new TextAccessor();
accessor.Mapping = mapping;
MemberMapping member = new MemberMapping();
member.Elements = new ElementAccessor[0];
member.Text = accessor;
if (isMixed)
{
// just generate code for the standard mixed case (string[] text)
member.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc();
member.Name = members.MakeRightCase("Text");
}
else
{
// import mapping for the simpleContent
PrimitiveMapping pm = (PrimitiveMapping)accessor.Mapping;
if (pm.IsList)
{
member.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc();
member.Name = members.MakeRightCase("Text");
}
else
{
member.TypeDesc = accessor.Mapping.TypeDesc;
member.Name = members.MakeRightCase("Value");
}
}
member.Name = membersScope.AddUnique(member.Name, member);
members.Add(member.Name, member);
}
private MemberMapping ImportAnyMember(XmlSchemaAny any, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, string ns, ref bool mixed, ref bool needExplicitOrder, bool allowDuplicates)
{
ElementAccessor[] accessors = ImportAny(any, !mixed, ns);
AddScopeElements(elementsScope, accessors, ref needExplicitOrder, allowDuplicates);
MemberMapping member = new MemberMapping();
member.Elements = accessors;
member.Name = membersScope.MakeRightCase("Any");
member.Name = membersScope.AddUnique(member.Name, member);
members.Add(member.Name, member);
member.TypeDesc = ((TypeMapping)accessors[0].Mapping).TypeDesc;
bool repeats = any.IsMultipleOccurrence;
if (mixed)
{
SpecialMapping textMapping = new SpecialMapping();
textMapping.TypeDesc = Scope.GetTypeDesc(typeof(XmlNode));
textMapping.TypeName = textMapping.TypeDesc.Name;
member.TypeDesc = textMapping.TypeDesc;
TextAccessor text = new TextAccessor();
text.Mapping = textMapping;
member.Text = text;
repeats = true;
mixed = false;
}
if (repeats)
{
member.TypeDesc = member.TypeDesc.CreateArrayTypeDesc();
}
return member;
}
private void ImportAttributeMember(XmlSchemaAttribute attribute, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, string ns)
{
AttributeAccessor accessor = this.ImportAttribute(attribute, identifier, ns, attribute);
if (accessor != null)
{
MemberMapping mapping;
mapping = new MemberMapping {
Elements = new ElementAccessor[0],
Attribute = accessor,
Name = CodeIdentifier.MakeValid(Accessor.UnescapeName(accessor.Name)),
Name = membersScope.AddUnique(mapping.Name, mapping)
};
if (mapping.Name.EndsWith("Specified", StringComparison.Ordinal))
{
string name = mapping.Name;
mapping.Name = membersScope.AddUnique(mapping.Name, mapping);
membersScope.Remove(name);
}
members.Add(mapping.Name, mapping);
mapping.TypeDesc = accessor.IsList ? accessor.Mapping.TypeDesc.CreateArrayTypeDesc() : accessor.Mapping.TypeDesc;
if (((attribute.Use == XmlSchemaUse.Optional) || (attribute.Use == XmlSchemaUse.None)) && ((mapping.TypeDesc.IsValueType && !attribute.HasDefault) && !mapping.TypeDesc.HasIsEmpty))
{
mapping.CheckSpecified = SpecifiedAccessor.ReadWrite;
}
}
}
private MemberMapping ImportChoiceGroup(XmlSchemaGroupBase group, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, string ns, bool groupRepeats, ref bool needExplicitOrder, bool allowDuplicates)
{
System.Xml.Serialization.NameTable choiceElements = new System.Xml.Serialization.NameTable();
if (this.GatherGroupChoices(group, choiceElements, identifier, ns, ref needExplicitOrder, allowDuplicates))
{
groupRepeats = true;
}
MemberMapping mapping = new MemberMapping {
Elements = (ElementAccessor[]) choiceElements.ToArray(typeof(ElementAccessor))
};
Array.Sort(mapping.Elements, new ElementComparer());
this.AddScopeElements(elementsScope, mapping.Elements, ref needExplicitOrder, allowDuplicates);
bool flag = false;
bool flag2 = false;
Hashtable hashtable = new Hashtable(mapping.Elements.Length);
for (int i = 0; i < mapping.Elements.Length; i++)
{
ElementAccessor accessor = mapping.Elements[i];
string fullName = accessor.Mapping.TypeDesc.FullName;
object obj2 = hashtable[fullName];
if (obj2 != null)
{
flag = true;
ElementAccessor accessor2 = (ElementAccessor) obj2;
if (!flag2 && (accessor2.IsNullable != accessor.IsNullable))
{
flag2 = true;
}
}
else
{
hashtable.Add(fullName, accessor);
}
ArrayMapping arrayMapping = accessor.Mapping as ArrayMapping;
if ((arrayMapping != null) && this.IsNeedXmlSerializationAttributes(arrayMapping))
{
accessor.Mapping = arrayMapping.TopLevelMapping;
accessor.Mapping.ReferencedByTopLevelElement = false;
accessor.Mapping.ReferencedByElement = true;
}
}
if (flag2)
{
mapping.TypeDesc = base.Scope.GetTypeDesc(typeof(object));
}
else
{
TypeDesc[] typeDescs = new TypeDesc[hashtable.Count];
IEnumerator enumerator = hashtable.Values.GetEnumerator();
for (int j = 0; j < typeDescs.Length; j++)
{
if (!enumerator.MoveNext())
{
break;
}
typeDescs[j] = ((ElementAccessor) enumerator.Current).Mapping.TypeDesc;
}
mapping.TypeDesc = TypeDesc.FindCommonBaseTypeDesc(typeDescs);
if (mapping.TypeDesc == null)
{
mapping.TypeDesc = base.Scope.GetTypeDesc(typeof(object));
}
}
if (groupRepeats)
{
mapping.TypeDesc = mapping.TypeDesc.CreateArrayTypeDesc();
}
if (membersScope != null)
{
mapping.Name = membersScope.AddUnique(groupRepeats ? "Items" : "Item", mapping);
if (members != null)
{
members.Add(mapping.Name, mapping);
}
}
if (flag)
{
mapping.ChoiceIdentifier = new ChoiceIdentifierAccessor();
mapping.ChoiceIdentifier.MemberName = mapping.Name + "ElementName";
mapping.ChoiceIdentifier.Mapping = this.ImportEnumeratedChoice(mapping.Elements, ns, mapping.Name + "ChoiceType");
mapping.ChoiceIdentifier.MemberIds = new string[mapping.Elements.Length];
ConstantMapping[] constants = ((EnumMapping) mapping.ChoiceIdentifier.Mapping).Constants;
for (int k = 0; k < mapping.Elements.Length; k++)
{
mapping.ChoiceIdentifier.MemberIds[k] = constants[k].Name;
}
MemberMapping mapping3 = new MemberMapping {
Ignore = true,
Name = mapping.ChoiceIdentifier.MemberName
};
if (groupRepeats)
{
mapping3.TypeDesc = mapping.ChoiceIdentifier.Mapping.TypeDesc.CreateArrayTypeDesc();
}
else
{
mapping3.TypeDesc = mapping.ChoiceIdentifier.Mapping.TypeDesc;
}
ElementAccessor accessor3 = new ElementAccessor {
Name = mapping3.Name,
Namespace = ns,
Mapping = mapping.ChoiceIdentifier.Mapping
};
mapping3.Elements = new ElementAccessor[] { accessor3 };
if (membersScope != null)
{
accessor3.Name = mapping3.Name = mapping.ChoiceIdentifier.MemberName = membersScope.AddUnique(mapping.ChoiceIdentifier.MemberName, mapping3);
if (members != null)
{
members.Add(accessor3.Name, mapping3);
}
}
}
return mapping;
}
private MemberMapping ImportAnyMember(XmlSchemaAny any, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, string ns, ref bool mixed, ref bool needExplicitOrder, bool allowDuplicates)
{
MemberMapping mapping;
ElementAccessor[] elements = this.ImportAny(any, !mixed, ns);
this.AddScopeElements(elementsScope, elements, ref needExplicitOrder, allowDuplicates);
mapping = new MemberMapping {
Elements = elements,
Name = membersScope.MakeRightCase("Any"),
Name = membersScope.AddUnique(mapping.Name, mapping)
};
members.Add(mapping.Name, mapping);
mapping.TypeDesc = elements[0].Mapping.TypeDesc;
bool isMultipleOccurrence = any.IsMultipleOccurrence;
if (mixed)
{
SpecialMapping mapping2;
mapping2 = new SpecialMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(XmlNode)),
TypeName = mapping2.TypeDesc.Name
};
mapping.TypeDesc = mapping2.TypeDesc;
TextAccessor accessor = new TextAccessor {
Mapping = mapping2
};
mapping.Text = accessor;
isMultipleOccurrence = true;
mixed = false;
}
if (isMultipleOccurrence)
{
mapping.TypeDesc = mapping.TypeDesc.CreateArrayTypeDesc();
}
return mapping;
}
private void ImportAnyAttributeMember(XmlSchemaAnyAttribute any, CodeIdentifiers members, CodeIdentifiers membersScope)
{
SpecialMapping mapping;
MemberMapping mapping2;
mapping = new SpecialMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(XmlAttribute)),
TypeName = mapping.TypeDesc.Name
};
AttributeAccessor accessor = new AttributeAccessor {
Any = true,
Mapping = mapping
};
mapping2 = new MemberMapping {
Elements = new ElementAccessor[0],
Attribute = accessor,
Name = membersScope.MakeRightCase("AnyAttr"),
Name = membersScope.AddUnique(mapping2.Name, mapping2)
};
members.Add(mapping2.Name, mapping2);
mapping2.TypeDesc = accessor.Mapping.TypeDesc;
mapping2.TypeDesc = mapping2.TypeDesc.CreateArrayTypeDesc();
}
private void ImportXmlnsDeclarationsMember(XmlSchemaType type, CodeIdentifiers members, CodeIdentifiers membersScope)
{
string str;
if (this.KeepXmlnsDeclarations(type, out str))
{
StructMapping mapping;
MemberMapping mapping2;
TypeDesc typeDesc = base.Scope.GetTypeDesc(typeof(XmlSerializerNamespaces));
mapping = new StructMapping {
TypeDesc = typeDesc,
TypeName = mapping.TypeDesc.Name,
Members = new MemberMapping[0],
IncludeInSchema = false,
ReferencedByTopLevelElement = true
};
ElementAccessor accessor = new ElementAccessor {
Mapping = mapping
};
mapping2 = new MemberMapping {
Elements = new ElementAccessor[] { accessor },
Name = CodeIdentifier.MakeValid((str == null) ? "Namespaces" : str),
Name = membersScope.AddUnique(mapping2.Name, mapping2)
};
members.Add(mapping2.Name, mapping2);
mapping2.TypeDesc = typeDesc;
mapping2.Xmlns = new XmlnsAccessor();
mapping2.Ignore = true;
}
}
private void ImportTextMember(CodeIdentifiers members, CodeIdentifiers membersScope, XmlQualifiedName simpleContentType)
{
TypeMapping defaultMapping;
bool flag = false;
if (simpleContentType != null)
{
defaultMapping = this.ImportType(simpleContentType, typeof(TypeMapping), null, TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue, false);
if (!(defaultMapping is PrimitiveMapping) && !defaultMapping.TypeDesc.CanBeTextValue)
{
return;
}
}
else
{
flag = true;
defaultMapping = this.GetDefaultMapping(TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue);
}
TextAccessor accessor = new TextAccessor {
Mapping = defaultMapping
};
MemberMapping mapping2 = new MemberMapping {
Elements = new ElementAccessor[0],
Text = accessor
};
if (flag)
{
mapping2.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc();
mapping2.Name = members.MakeRightCase("Text");
}
else
{
PrimitiveMapping mapping = (PrimitiveMapping) accessor.Mapping;
if (mapping.IsList)
{
mapping2.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc();
mapping2.Name = members.MakeRightCase("Text");
}
else
{
mapping2.TypeDesc = accessor.Mapping.TypeDesc;
mapping2.Name = members.MakeRightCase("Value");
}
}
mapping2.Name = membersScope.AddUnique(mapping2.Name, mapping2);
members.Add(mapping2.Name, mapping2);
}
void AddAsyncMembers (string messageName, CodeMemberMethod method)
{
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression enull = new CodePrimitiveExpression (null);
CodeMemberField codeField = new CodeMemberField (typeof(System.Threading.SendOrPostCallback), messageName + "OperationCompleted");
codeField.Attributes = MemberAttributes.Private;
CodeTypeDeclaration.Members.Add (codeField);
// Event arguments class
string argsClassName = classNames.AddUnique (messageName + "CompletedEventArgs", null);
CodeTypeDeclaration argsClass = new CodeTypeDeclaration (argsClassName);
argsClass.BaseTypes.Add (new CodeTypeReference ("System.ComponentModel.AsyncCompletedEventArgs"));
CodeMemberField resultsField = new CodeMemberField (typeof(object[]), "results");
resultsField.Attributes = MemberAttributes.Private;
argsClass.Members.Add (resultsField);
CodeConstructor cc = new CodeConstructor ();
cc.Attributes = MemberAttributes.Assembly;
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof(object[]), "results"));
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof(System.Exception), "exception"));
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof(bool), "cancelled"));
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof(object), "userState"));
cc.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("exception"));
cc.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("cancelled"));
cc.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("userState"));
CodeExpression thisResults = new CodeFieldReferenceExpression (ethis, "results");
cc.Statements.Add (new CodeAssignStatement (thisResults, new CodeVariableReferenceExpression ("results")));
argsClass.Members.Add (cc);
int ind = 0;
if (method.ReturnType.BaseType != "System.Void")
argsClass.Members.Add (CreateArgsProperty (method.ReturnType, "Result", ind++));
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
if (par.Direction == FieldDirection.Out || par.Direction == FieldDirection.Ref)
argsClass.Members.Add (CreateArgsProperty (par.Type, par.Name, ind++));
}
bool needsArgsClass = (ind > 0);
if (needsArgsClass)
asyncTypes.Add (argsClass);
else
argsClassName = "System.ComponentModel.AsyncCompletedEventArgs";
// Event delegate type
CodeTypeDelegate delegateType = new CodeTypeDelegate (messageName + "CompletedEventHandler");
delegateType.Parameters.Add (new CodeParameterDeclarationExpression (typeof(object), "sender"));
delegateType.Parameters.Add (new CodeParameterDeclarationExpression (argsClassName, "args"));
// Event member
CodeMemberEvent codeEvent = new CodeMemberEvent ();
codeEvent.Name = messageName + "Completed";
codeEvent.Type = new CodeTypeReference (delegateType.Name);
CodeTypeDeclaration.Members.Add (codeEvent);
// Async method (without user state param)
CodeMemberMethod am = new CodeMemberMethod ();
am.Attributes = MemberAttributes.Public | MemberAttributes.Final;
am.Name = method.Name + "Async";
am.ReturnType = new CodeTypeReference (typeof(void));
CodeMethodInvokeExpression inv;
inv = new CodeMethodInvokeExpression (ethis, am.Name);
am.Statements.Add (inv);
// On...Completed method
CodeMemberMethod onCompleted = new CodeMemberMethod ();
onCompleted.Name = "On" + messageName + "Completed";
onCompleted.Attributes = MemberAttributes.Private | MemberAttributes.Final;
onCompleted.ReturnType = new CodeTypeReference (typeof(void));
onCompleted.Parameters.Add (new CodeParameterDeclarationExpression (typeof(object), "arg"));
CodeConditionStatement anIf = new CodeConditionStatement ();
CodeExpression eventField = new CodeEventReferenceExpression (ethis, codeEvent.Name);
anIf.Condition = new CodeBinaryOperatorExpression (eventField, CodeBinaryOperatorType.IdentityInequality, enull);
CodeExpression castedArg = new CodeCastExpression (typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), new CodeVariableReferenceExpression ("arg"));
CodeStatement invokeArgs = new CodeVariableDeclarationStatement (typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), "invokeArgs", castedArg);
anIf.TrueStatements.Add (invokeArgs);
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression ();
delegateInvoke.TargetObject = eventField;
delegateInvoke.Parameters.Add (ethis);
CodeObjectCreateExpression argsInstance = new CodeObjectCreateExpression (argsClassName);
CodeExpression invokeArgsVar = new CodeVariableReferenceExpression ("invokeArgs");
if (needsArgsClass) argsInstance.Parameters.Add (new CodeFieldReferenceExpression (invokeArgsVar, "Results"));
argsInstance.Parameters.Add (new CodeFieldReferenceExpression (invokeArgsVar, "Error"));
argsInstance.Parameters.Add (new CodeFieldReferenceExpression (invokeArgsVar, "Cancelled"));
argsInstance.Parameters.Add (new CodeFieldReferenceExpression (invokeArgsVar, "UserState"));
delegateInvoke.Parameters.Add (argsInstance);
anIf.TrueStatements.Add (delegateInvoke);
onCompleted.Statements.Add (anIf);
// Async method
CodeMemberMethod asyncMethod = new CodeMemberMethod ();
asyncMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
asyncMethod.Name = method.Name + "Async";
asyncMethod.ReturnType = new CodeTypeReference (typeof(void));
CodeExpression delegateField = new CodeFieldReferenceExpression (ethis, codeField.Name);
anIf = new CodeConditionStatement ();
anIf.Condition = new CodeBinaryOperatorExpression (delegateField, CodeBinaryOperatorType.IdentityEquality, enull);;
CodeExpression delegateRef = new CodeMethodReferenceExpression (ethis, onCompleted.Name);
CodeExpression newDelegate = new CodeObjectCreateExpression (typeof(System.Threading.SendOrPostCallback), delegateRef);
CodeAssignStatement cas = new CodeAssignStatement (delegateField, newDelegate);
anIf.TrueStatements.Add (cas);
asyncMethod.Statements.Add (anIf);
CodeArrayCreateExpression paramsArray = new CodeArrayCreateExpression (typeof(object));
// Assign parameters
CodeIdentifiers paramsIds = new CodeIdentifiers ();
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
paramsIds.Add (par.Name, null);
if (par.Direction == FieldDirection.In || par.Direction == FieldDirection.Ref) {
CodeParameterDeclarationExpression inpar = new CodeParameterDeclarationExpression (par.Type, par.Name);
am.Parameters.Add (inpar);
asyncMethod.Parameters.Add (inpar);
inv.Parameters.Add (new CodeVariableReferenceExpression (par.Name));
paramsArray.Initializers.Add (new CodeVariableReferenceExpression (par.Name));
}
}
inv.Parameters.Add (enull);
string userStateName = paramsIds.AddUnique ("userState", null);
asyncMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof(object), userStateName));
CodeExpression userStateVar = new CodeVariableReferenceExpression (userStateName);
asyncMethod.Statements.Add (BuildInvokeAsync (messageName, paramsArray, delegateField, userStateVar));
CodeTypeDeclaration.Members.Add (am);
CodeTypeDeclaration.Members.Add (asyncMethod);
CodeTypeDeclaration.Members.Add (onCompleted);
asyncTypes.Add (delegateType);
}
