/// <summary> /// Produces a Pascal-case string from an input string. /// It compares the idenfier and compareIdentifier params, in case they're the same then the suffix Field is appended to the identifier. /// </summary> /// <param name="identifier">The name of a code entity, such as a method parameter.</param> /// <param name="compareIdentifier">The name of a code entity, such as a method parameter to compare.</param> /// <returns></returns> public static string ToPascalCase(string identifier, string compareIdentifier) { Guard.ArgumentNotNullOrEmptyString(identifier, "identifier"); Guard.ArgumentNotNullOrEmptyString(compareIdentifier, "compareIdentifier"); string pascalCase = CodeIdentifier.MakePascal(identifier); return(compareIdentifier == pascalCase || !csProvider.IsValidIdentifier(pascalCase) ? pascalCase + "Field" : pascalCase); }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public string MakeRightCase(string identifier) { if (_camelCase) { return(CodeIdentifier.MakeCamel(identifier)); } else { return(CodeIdentifier.MakePascal(identifier)); } }
private static string Proper(string text) { if (text.Contains("_")) { StringBuilder sb = new StringBuilder(); foreach (var section in text.Split('_')) { sb.Append(CodeIdentifier.MakePascal(section)); } return(sb.ToString()); } else { return(CodeIdentifier.MakePascal(text)); } }
private void Initialize(OpenApiSchema schema, Entity entity, OpenApiOptions options) { if (entity.Initialized) { return; } entity.Initialized = true; AddPrimaryKeyProperty(entity, options); foreach (var kvp in schema.Properties) { //if (schema.Type == "array" || schema.Reference != null) //{ // continue; //} string propertyName = CodeIdentifier.MakePascal(kvp.Key); OpenApiSchema propertySchema = kvp.Value; string propertyType = Converter.ConvertToType(propertySchema); Property property = entity.AddProperty(propertyName, propertyType); } foreach (var kvp in schema.Properties) { string propertyName = kvp.Key; OpenApiSchema propertySchema = kvp.Value; if (propertySchema.Type == "array") { Property property = entity.GetProperties().FirstOrDefault(p => p.Name == propertyName); if (propertySchema.Items.Reference?.IsLocal == true) { string findName = propertySchema.Items.Reference.Id; Entity dependentEntity = Model.GetOrAddEntity(findName); OpenApiSchema openApiSchema = options.Document.Components.Schemas[findName]; Initialize(openApiSchema, dependentEntity, options); Key principalKey = entity.FindPrimaryKey(); Entity principalEntity = entity; string foreignKeyName = principalKey.Property.Name; dependentEntity.AddProperty(foreignKeyName, options.PrimaryKeyTypeName); dependentEntity.AddProperty(principalEntity.Name, principalEntity.Name); } } } }
public static string MakeCommandIDName(string id) { return(string.Format("{0}CommandId", CodeIdentifier.MakePascal(id))); }
public static string MakeBeforeQueryStatusMethodName(string id) { return(string.Format("OnBeforeQueryStatus{0}", CodeIdentifier.MakePascal(id))); }
public static string MakeExecuteCommandMethodName(string id) { return(string.Format("OnExecute{0}", CodeIdentifier.MakePascal(id))); }
/// <summary> /// Produces a Pascal-case string from an input string. /// </summary> /// <param name="identifier">The name of a code entity, such as a method parameter.</param> /// <returns></returns> public static string ToPascalCase(string identifier) { Guard.ArgumentNotNullOrEmptyString(identifier, "identifier"); return(csProvider.CreateValidIdentifier(CodeIdentifier.MakePascal(identifier))); }
void GenerateClassForBinding() { try { if (bindingCount == 1 && service != null && Style != ServiceDescriptionImportStyle.ServerInterface) { // If there is only one binding, then use the name of the service className = XmlConvert.DecodeName(service.Name); } else { // If multiple bindings, then use the name of the binding className = binding.Name; if (Style == ServiceDescriptionImportStyle.ServerInterface) { // append "I" if we are generating interfaces className = "I" + CodeIdentifier.MakePascal(className); } } className = XmlConvert.DecodeName(className); className = ClassNames.AddUnique(CodeIdentifier.MakeValid(className), null); this.codeClass = BeginClass(); int methodCount = 0; for (int i = 0; i < portType.Operations.Count; i++) { MoveToOperation(portType.Operations[i]); if (!IsOperationFlowSupported(operation.Messages.Flow)) { // switch (operation.Messages.Flow) { case OperationFlow.SolicitResponse: UnsupportedOperationWarning(Res.GetString(Res.SolicitResponseIsNotSupported0)); continue; case OperationFlow.RequestResponse: UnsupportedOperationWarning(Res.GetString(Res.RequestResponseIsNotSupported0)); continue; case OperationFlow.OneWay: UnsupportedOperationWarning(Res.GetString(Res.OneWayIsNotSupported0)); continue; case OperationFlow.Notification: UnsupportedOperationWarning(Res.GetString(Res.NotificationIsNotSupported0)); continue; } } CodeMemberMethod method; try { method = GenerateMethod(); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } throw new InvalidOperationException(Res.GetString(Res.UnableToImportOperation1, operation.Name), e); } if (method != null) { AddExtensionWarningComments(codeClass.Comments, operationBinding.Extensions); if (operationBinding.Input != null) { AddExtensionWarningComments(codeClass.Comments, operationBinding.Input.Extensions); } if (operationBinding.Output != null) { AddExtensionWarningComments(codeClass.Comments, operationBinding.Output.Extensions); } methodCount++; } } bool newAsync = (ServiceImporter.CodeGenerationOptions & CodeGenerationOptions.GenerateNewAsync) != 0 && ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareEvents) && ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareDelegates); if (newAsync && methodCount > 0 && Style == ServiceDescriptionImportStyle.Client) { CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection(); string cancelAsync = "CancelAsync"; string cancelMethodName = MethodNames.AddUnique(cancelAsync, cancelAsync); CodeMemberMethod asyncCancelMethod = WebCodeGenerator.AddMethod(this.CodeTypeDeclaration, cancelMethodName, new CodeFlags[1], new string[] { typeof(object).FullName }, new string[] { "userState" }, typeof(void).FullName, metadata, CodeFlags.IsPublic | (cancelAsync != cancelMethodName ? 0 : CodeFlags.IsNew)); asyncCancelMethod.Comments.Add(new CodeCommentStatement(Res.GetString(Res.CodeRemarks), true)); CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), cancelAsync); invoke.Parameters.Add(new CodeArgumentReferenceExpression("userState")); asyncCancelMethod.Statements.Add(invoke); } EndClass(); if (portType.Operations.Count == 0) { NoMethodsGeneratedWarning(); } AddExtensionWarningComments(codeClass.Comments, binding.Extensions); if (port != null) { AddExtensionWarningComments(codeClass.Comments, port.Extensions); } codeNamespace.Types.Add(codeClass); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } throw new InvalidOperationException(Res.GetString(Res.UnableToImportBindingFromNamespace2, binding.Name, binding.ServiceDescription.TargetNamespace), e); } }
// UNDONE Nullable private void SetArrayMappingType(ArrayMapping mapping) { bool useDefaultNs = false; string itemTypeName; string itemTypeNamespace; TypeMapping itemTypeMapping; if (mapping.Elements.Length == 1) { itemTypeMapping = mapping.Elements[0].Mapping; } else { itemTypeMapping = null; } if (itemTypeMapping is EnumMapping) { itemTypeNamespace = itemTypeMapping.Namespace; itemTypeName = itemTypeMapping.TypeName; } else if (itemTypeMapping is PrimitiveMapping) { itemTypeNamespace = itemTypeMapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : UrtTypes.Namespace; itemTypeName = itemTypeMapping.TypeDesc.DataType.Name; useDefaultNs = true; } else if (itemTypeMapping is StructMapping) { if (itemTypeMapping.TypeDesc.IsRoot) { itemTypeNamespace = XmlSchema.Namespace; itemTypeName = Soap.UrType; useDefaultNs = true; } else { itemTypeNamespace = itemTypeMapping.Namespace; itemTypeName = itemTypeMapping.TypeName; } } else if (itemTypeMapping is ArrayMapping) { itemTypeNamespace = itemTypeMapping.Namespace; itemTypeName = itemTypeMapping.TypeName; } else { throw new InvalidOperationException(SR.Format(SR.XmlInvalidSoapArray, mapping.TypeDesc.FullName)); } itemTypeName = CodeIdentifier.MakePascal(itemTypeName); string uniqueName = "ArrayOf" + itemTypeName; string ns = useDefaultNs ? _defaultNs : itemTypeNamespace; int i = 1; TypeMapping existingMapping = (TypeMapping)_types[uniqueName, ns]; while (existingMapping != null) { if (existingMapping is ArrayMapping) { ArrayMapping arrayMapping = (ArrayMapping)existingMapping; if (AccessorMapping.ElementsMatch(arrayMapping.Elements, mapping.Elements)) { break; } } // need to re-name the mapping uniqueName = itemTypeName + i.ToString(CultureInfo.InvariantCulture); existingMapping = (TypeMapping)_types[uniqueName, ns]; i++; } mapping.Namespace = ns; mapping.TypeName = uniqueName; }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { return(System.Enum.Parse(typeof(JurisdictionType), CodeIdentifier.MakePascal(value.ToString()))); }
static string[] unwantedPrefixes = new string[] { "", "xsd", "abs", "cct" }; //,"ccts-cct" ,"ds", "xades" }; /// <summary> /// </summary> public UblNamespaceManager(XmlSchemaSet schemaSet, string csDefaultNamespace, bool optimizeCommonBasicComponents) { this.schemaSet = schemaSet; this.csDefaultNamespace = csDefaultNamespace; this.OptionOptimizeCommonBasicComponents = optimizeCommonBasicComponents; // Build a xml namespace(key) to csharp codenamespace/scope(value) dictionary by looking at all schema root xmlns attributes // Will bomb out on Distinct() if schemas use different namespace prefixes for the same namespace (empty ones are removed) xml2CSharpNamespaceDictionary = schemaSet.Schemas().Cast <XmlSchema>() .SelectMany(schema => schema.Namespaces.ToArray().Where(qname => !unwantedPrefixes.Contains(qname.Name))) .Select(qname => new { qname.Namespace, qname.Name }) .Distinct() .ToDictionary(key => key.Namespace, val => $"{csDefaultNamespace}.{ CodeIdentifier.MakePascal(val.Name)}"); // missing references in 2.1. Is it unused? xml2CSharpNamespaceDictionary.Add(Constants.CommonSignatureComponentsTargetNamespace, $"{csDefaultNamespace}.Csc"); xml2CSharpNamespaceDictionary[Constants.Xadesv132TargetNamespace] = $"{csDefaultNamespace}.Xades"; xml2CSharpNamespaceDictionary[Constants.Xadesv141TargetNamespace] = $"{csDefaultNamespace}.Xades";// 141"; // Probably incorrect // add key:xmlns value:cSharpScope for all maindocs. They all point to the same scope value string foreach (XmlSchema schema in schemaSet.MaindocSchemas().Cast <XmlSchema>()) { string targetNamespace = schema.TargetNamespace; if (!xml2CSharpNamespaceDictionary.ContainsKey(targetNamespace)) { xml2CSharpNamespaceDictionary.Add(targetNamespace, csDefaultNamespace); } } // using directives in csharp files may vary depending on optimising of types if (this.OptionOptimizeCommonBasicComponents) { codeNamespaceUsings = codeNamespaceUsingsOptimized; } else { codeNamespaceUsings = codeNamespaceUsingsNonOptimized; } // prepend dictionary keys with default C# code namespace separated by a dot. codeNamespaceUsings = codeNamespaceUsings.ToDictionary(k => csDefaultNamespace + (k.Key == "" ? "" : ".") + k.Key, v => v.Value); }
private void GenerateClassForBinding() { try { if (((this.bindingCount == 1) && (this.service != null)) && (this.Style != ServiceDescriptionImportStyle.ServerInterface)) { this.className = XmlConvert.DecodeName(this.service.Name); } else { this.className = this.binding.Name; if (this.Style == ServiceDescriptionImportStyle.ServerInterface) { this.className = "I" + CodeIdentifier.MakePascal(this.className); } } this.className = XmlConvert.DecodeName(this.className); this.className = this.ClassNames.AddUnique(CodeIdentifier.MakeValid(this.className), null); this.codeClass = this.BeginClass(); int num = 0; for (int i = 0; i < this.portType.Operations.Count; i++) { CodeMemberMethod method; this.MoveToOperation(this.portType.Operations[i]); if (!this.IsOperationFlowSupported(this.operation.Messages.Flow)) { switch (this.operation.Messages.Flow) { case OperationFlow.OneWay: { this.UnsupportedOperationWarning(System.Web.Services.Res.GetString("OneWayIsNotSupported0")); continue; } case OperationFlow.Notification: { this.UnsupportedOperationWarning(System.Web.Services.Res.GetString("NotificationIsNotSupported0")); continue; } case OperationFlow.RequestResponse: { this.UnsupportedOperationWarning(System.Web.Services.Res.GetString("RequestResponseIsNotSupported0")); continue; } case OperationFlow.SolicitResponse: { this.UnsupportedOperationWarning(System.Web.Services.Res.GetString("SolicitResponseIsNotSupported0")); continue; } } } try { method = this.GenerateMethod(); } catch (Exception exception) { if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException)) { throw; } throw new InvalidOperationException(System.Web.Services.Res.GetString("UnableToImportOperation1", new object[] { this.operation.Name }), exception); } if (method != null) { this.AddExtensionWarningComments(this.codeClass.Comments, this.operationBinding.Extensions); if (this.operationBinding.Input != null) { this.AddExtensionWarningComments(this.codeClass.Comments, this.operationBinding.Input.Extensions); } if (this.operationBinding.Output != null) { this.AddExtensionWarningComments(this.codeClass.Comments, this.operationBinding.Output.Extensions); } num++; } } if ((((((this.ServiceImporter.CodeGenerationOptions & CodeGenerationOptions.GenerateNewAsync) != CodeGenerationOptions.None) && this.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareEvents)) && this.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareDelegates)) && (num > 0)) && (this.Style == ServiceDescriptionImportStyle.Client)) { CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection(); string identifier = "CancelAsync"; string methodName = this.MethodNames.AddUnique(identifier, identifier); CodeMemberMethod method2 = WebCodeGenerator.AddMethod(this.CodeTypeDeclaration, methodName, new CodeFlags[1], new string[] { typeof(object).FullName }, new string[] { "userState" }, typeof(void).FullName, metadata, CodeFlags.IsPublic | ((identifier != methodName) ? ((CodeFlags)0) : CodeFlags.IsNew)); method2.Comments.Add(new CodeCommentStatement(System.Web.Services.Res.GetString("CodeRemarks"), true)); CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), identifier, new CodeExpression[0]); expression.Parameters.Add(new CodeArgumentReferenceExpression("userState")); method2.Statements.Add(expression); } this.EndClass(); if (this.portType.Operations.Count == 0) { this.NoMethodsGeneratedWarning(); } this.AddExtensionWarningComments(this.codeClass.Comments, this.binding.Extensions); if (this.port != null) { this.AddExtensionWarningComments(this.codeClass.Comments, this.port.Extensions); } this.codeNamespace.Types.Add(this.codeClass); } catch (Exception exception2) { if (((exception2 is ThreadAbortException) || (exception2 is StackOverflowException)) || (exception2 is OutOfMemoryException)) { throw; } throw new InvalidOperationException(System.Web.Services.Res.GetString("UnableToImportBindingFromNamespace2", new object[] { this.binding.Name, this.binding.ServiceDescription.TargetNamespace }), exception2); } }