protected override void Visit(CodeAttributeDeclaration attr) { base.Visit(attr); string[] propsToRemove = null; if (CodeDomHelpers.MatchType(attr.AttributeType, typeof(ServiceContractAttribute))) { propsToRemove = s_serviceContractPropsToRemove; } else if (CodeDomHelpers.MatchType(attr.AttributeType, typeof(OperationContractAttribute))) { propsToRemove = s_operationContractPropsToRemove; } else if (CodeDomHelpers.MatchType(attr.AttributeType, typeof(FaultContractAttribute))) { propsToRemove = s_faultContractPropsToRemove; } else if (CodeDomHelpers.MatchType(attr.AttributeType, typeof(GeneratedCodeAttribute))) { attr.Arguments.Clear(); attr.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(Tool.ToolName))); attr.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(Tool.PackageVersion))); } if (propsToRemove != null) { CollectionHelpers.MapList <CodeAttributeArgument>(attr.Arguments, delegate(CodeAttributeArgument arg) { return(IsValidProperty(propsToRemove, arg.Name)); }, null ); } }
protected override bool IsSpecificType(CodeTypeDeclaration type) { return(type.IsClass && type.BaseTypes.Count == 2 && (CodeDomHelpers.MatchGenericBaseType(type.BaseTypes[0], typeof(ClientBase <>)) || CodeDomHelpers.MatchGenericBaseType(type.BaseTypes[0], typeof(DuplexClientBase <>)))); }
private static CodeTypeDeclaration GetCallbackContractType(CodeTypeDeclaration iface) { CodeAttributeDeclaration serviceContractAttribute = null; foreach (CodeAttributeDeclaration attr in iface.CustomAttributes) { if (CodeDomHelpers.MatchType(attr.AttributeType, typeof(ServiceContractAttribute))) { serviceContractAttribute = attr; break; } } if (serviceContractAttribute != null) { foreach (CodeAttributeArgument arg in serviceContractAttribute.Arguments) { if (arg.Name == "CallbackContract") { CodeTypeOfExpression exp = (CodeTypeOfExpression)arg.Value; return(CodeDomHelpers.ResolveTypeReference(exp.Type)); } } } return(null); }
protected override bool IsSpecificType(CodeTypeDeclaration type) { // Check if the current client class is for duplex service. return(_taskBasedAsync && base.IsSpecificType(type) && CodeDomHelpers.MatchGenericBaseType(type.BaseTypes[0], typeof(DuplexClientBase <>))); }
// first-pass looks at each public BeginFoo or EndFoo method and makes it private. // for methods that are interface implementations, we need to remember them so that we can update // the calling code in the second pass private bool MapMethodFirstPass(CodeMemberMethod method) { if (method != null && (CodeDomHelpers.IsBeginMethod(method) || CodeDomHelpers.IsEndMethod(method)) && IsPublic(method.Attributes)) { if (method.ImplementationTypes.Count == 0) { // doesn't impl an iface method, just make it private, and remember it for the second pass method.Attributes = MakePrivate(method.Attributes); // clobber existing entries -- non iface-methods take precedence _privateIfaceMethods[method.Name] = new PrivateInterfaceMethod(null); } else { // impls an iface method, make it a private impl, and remember it for the second pass CodeTypeReference ifaceType = method.ImplementationTypes[0]; method.ImplementationTypes.Clear(); method.PrivateImplementationType = ifaceType; if (!_privateIfaceMethods.ContainsKey(method.Name)) { // only add it if it wasn't already there -- non-iface methods take precedence _privateIfaceMethods.Add(method.Name, new PrivateInterfaceMethod(ifaceType)); } } } return(true); // don't remove }
protected override void VisitClientClass(CodeTypeDeclaration type) { base.VisitClientClass(type); CodeTypeDeclaration serviceContractInterface = CodeDomHelpers.ResolveTypeReference(type.BaseTypes[0].TypeArguments[0]); CodeTypeDeclaration callbackInterface = GetCallbackContractType(serviceContractInterface); RemoveAsyncMethods(callbackInterface); CreateEventBasedDuplexClass(type, callbackInterface); }
private static bool IsValidAttribute(CodeAttributeDeclaration attr) { for (int i = 0; i < s_attrsToRemove.Length; i++) { if (CodeDomHelpers.MatchType(attr.AttributeType, s_attrsToRemove[i])) { return(false); } } return(true); }
private static void RemoveAsyncMethods(CodeTypeDeclaration callbackInterface) { CollectionHelpers.MapList <CodeMemberMethod>( callbackInterface.Members, delegate(CodeMemberMethod method) { return(!CodeDomHelpers.IsTaskAsyncMethod(method)); }, null ); }
private static bool IsIXmlSerializableType(CodeTypeDeclaration typeDecl) { foreach (CodeTypeReference typeRef in typeDecl.BaseTypes) { if (CodeDomHelpers.MatchType <Microsoft.Xml.Serialization.IXmlSerializable>(typeRef)) { return(true); } } return(false); }
private static bool IsValidConstructor(CodeConstructor ctor, Type[][] validCtors) { for (int i = 0; i < validCtors.Length; i++) { if (CodeDomHelpers.MatchSignatures(ctor.Parameters, validCtors[i])) { return(true); } } return(false); }
protected override void VisitAttributedType(CodeTypeDeclaration type) { base.VisitAttributedType(type); CollectionHelpers.MapList <CodeMemberMethod>( type.Members, delegate(CodeMemberMethod method) { return(CodeDomHelpers.IsBeginMethod(method) || CodeDomHelpers.IsTaskAsyncMethod(method) || CodeDomHelpers.IsEndMethod(method)); }, this.CopyAttrsToTaskAsyncMethod ); }
protected override void VisitClientClass(CodeTypeDeclaration type) { base.VisitClientClass(type); CollectionHelpers.MapList <CodeMemberMethod>( type.Members, delegate(CodeMemberMethod method) { return(method is CodeConstructor || CodeDomHelpers.IsBeginMethod(method) || CodeDomHelpers.IsEndMethod(method) || CodeDomHelpers.IsTaskAsyncMethod(method)); }, null ); }
private void CopyAttrsToTaskAsyncMethod(CodeMemberMethod syncMethod, int index) { CodeMemberMethod taskAyncMethod = CodeDomHelpers.GetTaskAsyncMethodForMethod(CurrentType.Members, syncMethod); if (taskAyncMethod != null && !ReferenceEquals(taskAyncMethod, syncMethod)) { foreach (CodeAttributeDeclaration attr in syncMethod.CustomAttributes) { // skip [OperationContract] as that appears in both places and is guaranteed to be the same if (!CodeDomHelpers.MatchType <OperationContractAttribute>(attr.AttributeType)) { taskAyncMethod.CustomAttributes.Add(attr); } } } }
private static bool IsExtensionDataMember(CodeTypeMember member) { CodeTypeReference memberType = null; switch (member.Name) { case "ExtensionData": // property memberType = member is CodeMemberProperty ? ((CodeMemberProperty)member).Type : null; break; case "extensionDataField": // field memberType = member is CodeMemberField ? ((CodeMemberField)member).Type : null; break; } return(memberType != null && CodeDomHelpers.MatchType(memberType, typeof(ExtensionDataObject))); }
private static void AddMethods(CodeTypeDeclaration callbackImpl, CodeTypeDeclaration callbackInterface, Dictionary <string, string> methodNames) { foreach (CodeMemberMethod method in callbackInterface.Members) { System.Diagnostics.Debug.Assert((IsSyncOperationContract(method)), "Only support sync callback on immersive project"); CodeMemberMethod m = CodeDomHelpers.GetImplementationOfMethod(callbackImpl.BaseTypes[1], method); // new object[] { msg, timestamp }); CodeArrayCreateExpression arr = new CodeArrayCreateExpression(); arr.CreateType = new CodeTypeReference(typeof(object)); foreach (CodeParameterDeclarationExpression p in method.Parameters) { arr.Initializers.Add(new CodeVariableReferenceExpression(p.Name)); } // proxy.OnOnEchoReceived(new object[] { msg, timestamp}); m.Statements.Add( new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression() { TargetObject = new CodeFieldReferenceExpression() { TargetObject = new CodeThisReferenceExpression(), FieldName = "proxy" }, MethodName = methodNames[method.Name], }, Parameters = { arr }, } ); if (method.ReturnType.BaseType != typeof(void).FullName) { m.Statements.Add(new CodeMethodReturnStatement( new CodeDefaultValueExpression( method.ReturnType) )); } callbackImpl.Members.Add(m); } }
private static bool IsNonFilteredMember(CodeTypeMember member) { CodeTypeReference memberType = null; CodeMemberProperty memberProp = member as CodeMemberProperty; if (memberProp != null) { memberType = memberProp.Type; } else { CodeMemberField memberField = member as CodeMemberField; if (memberField != null) { memberType = memberField.Type; } } return(memberType == null || !CodeDomHelpers.MatchAnyBaseType(memberType, s_filteredTypes)); }
private void MoveConfigIntoCode(CodeTypeDeclaration clientType, Collection <ServiceEndpoint> endpoints, CodeNamespace namespaceDecl) { string contractName = ExtractContract(clientType); List <string> endpointNames = new List <string>(); MethodCreationHelper helperMethodCreator = new MethodCreationHelper(clientType); foreach (ServiceEndpoint endpoint in endpoints) { if (contractName.EndsWith(endpoint.Contract.Name, StringComparison.Ordinal) || contractName.EndsWith(UniqueCodeIdentifierScope.MakeValid(endpoint.Contract.CodeName, endpoint.Contract.CodeName), StringComparison.Ordinal)) { endpoint.Name = CodeDomHelpers.GetValidValueTypeIdentifier(endpoint.Name); // resolve duplicated names. int i = 1; while (endpointNames.Contains(endpoint.Name)) { endpoint.Name += i; i++; } if (helperMethodCreator.AddClientEndpoint(endpoint)) { endpointNames.Add(endpoint.Name); } } } bool endpointConfigurationExists = false; if (endpointNames.Count > 0) { helperMethodCreator.AddConfigurationEnum(endpointNames); helperMethodCreator.AddMethods(endpointNames, this.IsVB); endpointConfigurationExists = true; } bool shouldRemoveDefault = (endpointNames.Count != 1); this.FixupConstructors(clientType, shouldRemoveDefault, endpointConfigurationExists, namespaceDecl, endpointNames); }
protected override void VisitAttributedType(CodeTypeDeclaration type) { base.VisitAttributedType(type); // remove IExtensibleDataObject impl CollectionHelpers.MapList <CodeTypeReference>( type.BaseTypes, delegate(CodeTypeReference typeRef) { return(!CodeDomHelpers.MatchType <IExtensibleDataObject>(typeRef)); }, null ); // remove ExtensionData members CollectionHelpers.MapList <CodeTypeMember>( type.Members, delegate(CodeTypeMember member) { return(!IsExtensionDataMember(member)); }, null ); }
protected virtual bool Match(CodeTypeReference typeref) { return(CodeDomHelpers.MatchBaseType(typeref, this.srcType)); }
internal static CodeMemberMethod GetTaskAsyncMethodForMethod(CodeTypeMemberCollection members, CodeMemberMethod method) { return(CodeDomHelpers.IsTaskAsyncMethod(method) ? method : CodeDomHelpers.FindMethodByName(members, CodeDomHelpers.GetMethodNameBase(method) + "Async")); }
public void AddConfigurationEnum(List <string> endpointNames) { CodeTypeDeclaration configurationsEnum = new CodeTypeDeclaration(ConfigToCodeConstants.EndpointConfigurationEnumTypeName); configurationsEnum.IsEnum = true; foreach (string endpointName in endpointNames) { configurationsEnum.Members.Add(new CodeMemberField(ConfigToCodeConstants.EndpointConfigurationEnumTypeName, CodeDomHelpers.EscapeName(endpointName))); } this.ClientType.Members.Add(configurationsEnum); }
protected override bool IsSpecificType(CodeTypeDeclaration type) { return(CodeDomHelpers.FindAttribute <T>(type.CustomAttributes) != null); }