public static void Main() { XmlDoc dc=new XmlDoc(); XmlElement nd=new XmlElement("dotgnu"); XmlElement nd2=new XmlElement("pnet"); nd2.AddChild(new XmlCData("Hey I work here &")); nd2.AddChild(new XmlComment("so does rhys !")); nd.AddChild(nd2); XmlElement nd3=new XmlElement("phpgw"); nd3.AddChild(new XmlPI("php","echo \"phpgroupware\";")); nd.AddChild(nd3); dc.AddChild(nd); //dc.Compression = 3; //dc.SaveToFile("/tmp/xml.gz",1); Console.WriteLine(dc.DumpXml()); //printRecursive(dc); }
/// <summary> /// Creates the content of the local style. /// </summary> private void CreateLocalStyleContent() { XElement nodeAutomaticStyles = XmlDoc.Elements(Ns.Office + "document-content") .Elements(Ns.Office + "automatic-styles").First(); foreach (IStyle style in Styles.ToValueList()) { bool exist = false; if (style.StyleName != null) { string styleName = style.StyleName; XElement node = nodeAutomaticStyles.Elements(Ns.Style + "style") .Where(e => string.Equals((string)e.Attribute(Ns.Style + "name"), styleName)).FirstOrDefault(); if (node != null) { exist = true; } } if (!exist) { nodeAutomaticStyles.Add(style.Node); } } }
public override void Execute() { XmlNamespaceManager nsManager = new XmlNamespaceManager(this.XmlDoc.NameTable); nsManager.AddNamespace("cp1", "http://schemas.microsoft.com/pag/cab-profile"); nsManager.AddNamespace("cp2", "http://schemas.microsoft.com/pag/cab-profile/2.0"); XmlNode moduleList = this.XmlDoc.SelectSingleNode("//cp1:Modules", nsManager); XmlNode newModule = null; if (moduleList == null && !string.IsNullOrEmpty(SectionName)) { moduleList = this.XmlDoc.SelectSingleNode("//cp2:Section[@Name='" + SectionName + "']/cp2:Modules", nsManager); newModule = XmlDoc.CreateElement("ModuleInfo", "http://schemas.microsoft.com/pag/cab-profile/2.0"); } else { newModule = XmlDoc.CreateElement("ModuleInfo", "http://schemas.microsoft.com/pag/cab-profile"); } XmlAttribute xmlAttrib = XmlDoc.CreateAttribute("AssemblyFile"); xmlAttrib.Value = this.ModuleName + ".dll"; newModule.Attributes.Append(xmlAttrib); moduleList.AppendChild(newModule); }
private static XmlDoc GetDoc(XmlReader reader) { var doc = new XmlDoc { Name = reader.GetAttribute("name") }; do { reader.Read(); if (reader.Name == "summary") { doc.Summary = CleanString(reader.ReadInnerXml()); } else if (reader.Name == "returns") { doc.Returns = CleanString(reader.ReadInnerXml()); } else if (reader.Name == "param") { doc.Parameters.Add(reader.GetAttribute("name"), CleanString(reader.ReadInnerXml())); } } while (reader.Name != "member"); return(doc); }
public static void SaveToDisk(IDataTypeDefinition item) { if (item != null) { var packagingService = ApplicationContext.Current.Services.PackagingService; try { XElement node = packagingService.Export(item); // node.AddMD5Hash(true); // md5 hash of file with preval ids blanked. node = ReplaceCotentNodes(node); // content node hunting goes here.... XmlDoc.SaveElement("DataTypeDefinition", XmlDoc.ScrubFile(item.Name), node); } catch (Exception ex) { LogHelper.Error <SyncDataType>(string.Format("DataType Failed {0}", item.Name), ex); } } else { LogHelper.Debug <SyncDataType>("Null DataType Save attempt - aborted"); } }
private static ClassDeclarationSyntax GenerateClass(string ns, SourceFileContext ctx, IEnumerable <FileDescriptor> packageFileDescriptors) { var typ = Typ.Manual(ns, ClassName); var cls = Class(Internal | Static, typ) .WithXmlDoc(XmlDoc.Summary("Static class to provide common access to package-wide API metadata.")); var yieldStatements = packageFileDescriptors.Select(GenerateYieldStatement).ToArray(); var fileDescriptorMethod = Method(Private | Static, ctx.Type(Typ.Of <IEnumerable <FileDescriptor> >()), "GetFileDescriptors")() .WithBlockBody(yieldStatements); var apiMetadataType = ctx.Type <ApiMetadata>(); var property = AutoProperty(Internal | Static, apiMetadataType, PropertyName) .WithInitializer(New(apiMetadataType)(ns, IdentifierName(fileDescriptorMethod.Identifier))) .WithXmlDoc(XmlDoc.Summary("The ", apiMetadataType, " for services in this package.")); return(cls.AddMembers(property, fileDescriptorMethod)); YieldStatementSyntax GenerateYieldStatement(FileDescriptor descriptor) { var type = ctx.Type(ProtoTyp.OfReflectionClass(descriptor)); return(YieldStatement(SyntaxKind.YieldReturnStatement, type.Access("Descriptor"))); } }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); //var sm = ScriptManager.GetCurrent(this.Page); //sm.ScriptMode = ScriptMode.Release; if (this.Page.Request.FilePath.ToLower().Contains("index.aspx")) { _source.Visible = false; return; } var content = String.Empty; using (var fs = new FileStream(Server.MapPath(this.Page.Request.FilePath), FileMode.Open)) using (var sr = new StreamReader(fs)) { content = sr.ReadToEnd(); } var start = content.IndexOf("</h2>") + "<h2/>".Length; content = content.Substring(start); content = content.Replace("</asp:content>", String.Empty); content = "\t" + content.Trim(); content = content.Replace("\t", " "); // tabs to spaces for pretty display on the web content = Server.HtmlEncode(content); source.Text = content; var desc = XmlDoc.GetDescription(Request.Path); _desc.Text = desc; }
public async Task Bug17819() { await TestAsync( @"_ _() { } ///<param name='_ }", Identifier("_"), Method("_"), Punctuation.OpenParen, Punctuation.CloseParen, Punctuation.OpenCurly, Punctuation.CloseCurly, XmlDoc.Delimiter("///"), XmlDoc.Delimiter("<"), XmlDoc.Name("param"), XmlDoc.AttributeName(" "), XmlDoc.AttributeName("name"), XmlDoc.Delimiter("="), XmlDoc.AttributeQuotes("'"), Identifier("_"), Punctuation.CloseCurly); }
public ClassDeclarationSyntax GenerateClass(SourceFileContext ctx) { var cls = Class(Modifier.Public, Typ, Parent is null ? new[] { ctx.Type <IDirectResponseSchema>() } : Array.Empty <TypeSyntax>()); using (ctx.InClass(Typ)) { if (_schema.Description is string description) { cls = cls.WithXmlDoc(XmlDoc.Summary(description)); } cls = cls.AddMembers(Properties.SelectMany(p => p.GeneratePropertyDeclarations(ctx)).ToArray()); // Top-level data models automatically have an etag property if one isn't otherwise generated. if (Parent is null && !Properties.Any(p => p.Name == "etag")) { var etag = AutoProperty(Modifier.Public | Modifier.Virtual, ctx.Type <string>(), "ETag", hasSetter: true) .WithXmlDoc(XmlDoc.Summary("The ETag of the item.")); cls = cls.AddMembers(etag); } cls = cls.AddMembers(Properties.SelectMany(p => p.GenerateAnonymousModels(ctx)).ToArray()); } return(cls); }
private IEnumerable <MethodDeclarationSyntax> FormatMethods() { bool first = true; foreach (var pattern in PatternDetails) { var xmlDoc = pattern.PathElements.Select(x => x.ParameterXmlDoc) .Prepend(XmlDoc.Summary("Formats the IDs into the string representation of this ", _ctx.Type(_def.ResourceNameTyp), " with pattern ", XmlDoc.C(pattern.PatternString), ".")) .Append(XmlDoc.Returns("The string representation of this ", _ctx.Type(_def.ResourceNameTyp), " with pattern ", XmlDoc.C(pattern.PatternString), ".")) .ToArray(); var expandArgs = pattern.PathSegments.Where(x => x.Segment.ParameterCount > 0).Select(x => { if (x.Segment.IsComplex) { var dollarItems = x.Elements.Zip(x.Segment.Separators.Select(x => x.ToString()).Append(""), (element, sep) => (FormattableString) $"{Parens(_ctx.Type(typeof(GaxPreconditions)).Call(nameof(GaxPreconditions.CheckNotNullOrEmpty))(element.Parameter, Nameof(element.Parameter)))}{sep:raw}"); return((object)Dollar(dollarItems.ToArray())); } else { return(_ctx.Type(typeof(GaxPreconditions)).Call(nameof(GaxPreconditions.CheckNotNullOrEmpty))(x.Elements[0].Parameter, Nameof(x.Elements[0].Parameter))); } }); var method = Method(Public | Static, _ctx.Type <string>(), $"Format{pattern.UpperName}")(pattern.PathElements.Select(x => x.Parameter).ToArray()) .WithBody(Return(pattern.PathTemplateField.Call(nameof(PathTemplate.Expand))(expandArgs))) .WithXmlDoc(xmlDoc); if (first) { yield return(Method(Public | Static, _ctx.Type <string>(), "Format")(pattern.PathElements.Select(x => x.Parameter).ToArray()) .WithBody(Return(This.Call(method)(pattern.PathElements.Select(x => x.Parameter)))) .WithXmlDoc(xmlDoc)); first = false; } yield return(method); } }
private IEnumerable <MethodDeclarationSyntax> FromMethods() { foreach (var pattern in PatternDetails) { var xmlDocSummary = XmlDoc.Summary($"Creates a ", _ctx.Type(_def.ResourceNameTyp), " with the pattern ", XmlDoc.C(pattern.PatternString), "."); var xmlDocReturns = XmlDoc.Returns("A new instance of ", _ctx.Type(_def.ResourceNameTyp), " constructed from the provided ids."); yield return(Method(Public | Static, _ctx.Type(_def.ResourceNameTyp), $"From{pattern.UpperName}")(pattern.PathElements.Select(x => x.Parameter).ToArray()) .WithBody(Return(New(_ctx.Type(_def.ResourceNameTyp))( pattern.PathElements.Select(x => (object)(x.Parameter.Identifier.ValueText, _ctx.Type(typeof(GaxPreconditions)) .Call(nameof(GaxPreconditions.CheckNotNullOrEmpty))(x.Parameter, Nameof(x.Parameter)))) .Prepend(_ctx.Type(ResourceNameTypeTyp).Access(pattern.UpperName)).ToArray()))) .WithXmlDoc(pattern.PathElements.Select(x => x.ParameterXmlDoc).Prepend(xmlDocSummary).Append(xmlDocReturns).ToArray())); } }
private EnumDeclarationSyntax ResourceTypeEnum() { var resources = PatternDetails.Select((x, i) => EnumMember(x.UpperName, value: i + 1).WithXmlDoc( XmlDoc.Summary("A resource name with pattern ", XmlDoc.C(x.PatternString), "."))) .Prepend(EnumMember("Unparsed", value: 0).WithXmlDoc(XmlDoc.Summary("An unparsed resource name."))); return(Enum(Public, ResourceNameTypeTyp)(resources.ToArray()) .WithXmlDoc(XmlDoc.Summary("The possible contents of ", _ctx.Type(_def.ResourceNameTyp), "."))); }
/// <summary> /// 通过节点名称读取节点列表 /// </summary> /// <param name="nodeName"></param> /// <returns></returns> private XmlNodeList Read(string nodeName) { return(XmlDoc.GetElementsByTagName(nodeName)); }
/// <summary> /// 添加节点 /// </summary> /// <param name="filename">文件名称.xml</param> /// <param name="rootnode">根结点</param> /// <param name="node">rootnode的子节点</param> /// <param name="attributename">rootnode的子节点属性名称</param> /// <param name="attributevalue">rootnode的子节点属性值</param> /// <param name="subnode">node的子节点</param> /// <param name="subatt">node的子节点属性名称</param> /// <param name="subattvalue">node的子节点属性名称</param> private static string AddNode(string filename, string rootnode, string node, string attributename, string attributevalue, string subnode, string subatt, string subattvalue, object[] prams) { bool saveorno = false; System.Uri u = new Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase); string xmlpath = System.IO.Path.GetDirectoryName(u.LocalPath) + "\\" + filename; if (prams != null && prams.Length > 0) { if (File.Exists(filename)) { xmlpath = filename; } } System.Xml.XmlDocument XmlDoc = GetDocument(xmlpath); if (XmlDoc == null) { XmlDoc = new XmlDocument(); saveorno = true; } if (XmlDoc.ChildNodes.Count == 0) { XmlDeclaration dec = XmlDoc.CreateXmlDeclaration("1.0", "utf-8", null); XmlDoc.AppendChild(dec); saveorno = true; } XmlElement root = (XmlElement)XmlDoc.SelectSingleNode("/" + rootnode); if (root == null) { root = XmlDoc.CreateElement(rootnode); XmlDoc.AppendChild(root); saveorno = true; } XmlElement ele = XmlDoc.SelectSingleNode("/" + rootnode + "/" + node) as XmlElement; if (ele == null) { ele = XmlDoc.CreateElement(node); if (!string.IsNullOrEmpty(attributename)) { ele.SetAttribute(attributename, attributevalue); } if (!string.IsNullOrEmpty(subnode)) { XmlElement sub = XmlDoc.CreateElement(subnode); if (!string.IsNullOrEmpty(subatt)) { sub.SetAttribute(subatt, subattvalue); } ele.AppendChild(sub); } root.AppendChild(ele); saveorno = true; } else { XmlNodeList nodes = XmlDoc.SelectNodes("/" + rootnode + "/" + node); XmlNode existnode = null; if (!string.IsNullOrEmpty(attributename)) { foreach (XmlNode n1 in nodes) { if (n1.Attributes[attributename].Value.Equals(attributevalue)) { existnode = n1; break; } } if (existnode == null) { XmlElement ele1 = XmlDoc.CreateElement(node); ele1.SetAttribute(attributename, attributevalue); if (!string.IsNullOrEmpty(subnode)) { XmlElement sub = XmlDoc.CreateElement(subnode); ele1.AppendChild(sub); } root.InsertBefore(ele1, ele); saveorno = true; } else { if (!string.IsNullOrEmpty(subnode)) { XmlElement ele2 = (XmlElement)existnode.SelectSingleNode(subnode); if (ele2 == null) { ele2 = XmlDoc.CreateElement(subnode); existnode.AppendChild(ele2); saveorno = true; } } } } else { if (nodes != null) { if (!string.IsNullOrEmpty(subnode)) { existnode = nodes[0]; XmlElement ele2 = (XmlElement)existnode.SelectSingleNode(subnode); if (ele2 == null) { ele2 = XmlDoc.CreateElement(subnode); existnode.AppendChild(ele2); saveorno = true; } } } } } if (saveorno) { XmlDoc.Save(xmlpath); } return(xmlpath); }
public XPathNavigator Navigator() { return(XmlDoc.CreateNavigator()); }
public override List <string> ListPreprocess(IReadOnlyList <string> list) { _PreProcessResult = new Dictionary <string, XmlDoc>(); List <string> errors = new List <string>(); try { List <string> keys = KeyElements.Split(',').ToList(); string firstKey = keys.FirstOrDefault(); if (String.IsNullOrEmpty(firstKey)) { throw new Exception("KeyElements has no value."); } foreach (string d in list) { XmlDoc doc = null; try { lock (_Documents) { doc = _Documents.FirstOrDefault(i => i.Filename.Equals(d, StringComparison.InvariantCultureIgnoreCase)); if (doc != null) { System.Threading.Monitor.Enter(doc); if (!File.Exists(doc.Filename) || doc.OriginalLastWriteTime == File.GetLastWriteTimeUtc(doc.Filename)) { foreach (string s in doc.Nodes.Keys) { _PreProcessResult[s] = doc; } continue; } else { doc.OriginalLastWriteTime = File.GetLastWriteTimeUtc(d); doc.Document = XDocument.Parse(File.ReadAllText(d)); doc.Nodes = new Dictionary <string, XElement>(); } } else { doc = new XmlDoc(); doc.Filename = d; doc.OriginalLastWriteTime = File.GetLastWriteTimeUtc(d); doc.Document = XDocument.Parse(File.ReadAllText(d)); doc.Nodes = new Dictionary <string, XElement>(); System.Threading.Monitor.Enter(doc); _Documents.Add(doc); } } foreach (XElement e in doc.Document.Descendants().Where(i => i.Name.LocalName.Equals(firstKey)).Select(i => i.Parent)) { string fullKey = ""; foreach (string key in keys) { string s = e.Descendants().Where(i => i.Name.LocalName.Equals(key)).Select(i => i.Value).FirstOrDefault(); if (s == null) { fullKey = null; break; } if (fullKey != "") { fullKey += " "; } fullKey += s; } if (fullKey == null) { continue; } doc.Nodes[fullKey] = e; _PreProcessResult[fullKey] = doc; } } catch (Exception ex) { errors.Add("XmlConsumingController encountered an error processing " + d + ": " + ex.Message); STEM.Sys.EventLog.WriteEntry("XmlConsumingController.ListPreprocess", d + ": " + ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } finally { if (doc != null) { System.Threading.Monitor.Exit(doc); } } } if (errors.Count == 0) { PollError = ""; } else { throw new Exception(String.Join("\r\n", errors)); } } catch (Exception ex) { PollError = "(" + STEM.Sys.IO.Net.MachineIP() + ") encountered errors: \r\n" + ex.Message; STEM.Sys.EventLog.WriteEntry("XmlConsumingController.ListPreprocess", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } List <string> returnList = _PreProcessResult.Keys.ToList(); if (HonorPriorityFilters) { returnList = ApplyPriorityFilterOrdering(returnList); } return(returnList); }
public ClassDeclarationSyntax GenerateServiceClass(SourceFileContext ctx) { var cls = Class(Modifier.Public, ServiceTyp, ctx.Type <BaseClientService>()).WithXmlDoc(XmlDoc.Summary($"The {ClassName} Service.")); using (ctx.InClass(cls)) { var discoveryVersionTyp = Typ.Manual("Google.Apis.Discovery", "DiscoveryVersion"); var version = Field(Modifier.Public | Modifier.Const, ctx.Type <string>(), "Version") .WithInitializer(ApiVersion) .WithXmlDoc(XmlDoc.Summary("The API version.")); var discoveryVersion = Field(Modifier.Public | Modifier.Static, ctx.Type(discoveryVersionTyp), "DiscoveryVersionUsed") .WithInitializer(ctx.Type(discoveryVersionTyp).Access(nameof(DiscoveryVersion.Version_1_0))) .WithXmlDoc(XmlDoc.Summary("The discovery version used to generate this service.")); var parameterlessCtor = Ctor(Modifier.Public, cls, ThisInitializer(New(ctx.Type <BaseClientService.Initializer>())()))() .WithBody() .WithXmlDoc(XmlDoc.Summary("Constructs a new service.")); var initializerParam = Parameter(ctx.Type <BaseClientService.Initializer>(), "initializer"); var featuresArrayInitializer = ApiFeatures.Any() ? NewArray(ctx.ArrayType(Typ.Of <string[]>()))(ApiFeatures.ToArray()) : NewArray(ctx.ArrayType(Typ.Of <string[]>()), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))); var features = Property(Modifier.Public | Modifier.Override, ctx.Type <IList <string> >(), "Features") .WithGetBody(featuresArrayInitializer) .WithXmlDoc(XmlDoc.Summary("Gets the service supported features.")); var nameProperty = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "Name") .WithGetBody(ApiName) .WithXmlDoc(XmlDoc.Summary("Gets the service name.")); // Note: the following 4 properties have special handling post-generation, in terms // of adding the #if directives in. var baseUri = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "BaseUri") .WithGetBody(IdentifierName("BaseUriOverride").NullCoalesce(BaseUri)) .WithXmlDoc(XmlDoc.Summary("Gets the service base URI.")); var basePath = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "BasePath") .WithGetBody(BasePath) .WithXmlDoc(XmlDoc.Summary("Gets the service base path.")); var batchUri = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "BatchUri") .WithGetBody(BatchUri) .WithXmlDoc(XmlDoc.Summary("Gets the batch base URI; ", XmlDoc.C("null"), " if unspecified.")); var batchPath = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "BatchPath") .WithGetBody(BatchPath) .WithXmlDoc(XmlDoc.Summary("Gets the batch base path; ", XmlDoc.C("null"), " if unspecified.")); var resourceProperties = Resources.Select(resource => resource.GenerateProperty(ctx)).ToArray(); var parameterizedCtor = Ctor(Modifier.Public, cls, BaseInitializer(initializerParam))(initializerParam) .WithBlockBody(resourceProperties.Zip(Resources).Select(pair => pair.First.Assign(New(ctx.Type(pair.Second.Typ))(This))).ToArray()) .WithXmlDoc( XmlDoc.Summary("Constructs a new service."), XmlDoc.Param(initializerParam, "The service initializer.")); cls = cls.AddMembers(version, discoveryVersion, parameterlessCtor, parameterizedCtor, features, nameProperty, baseUri, basePath, batchUri, batchPath); if (AuthScopes.Any()) { var scopeClass = Class(Modifier.Public, Typ.Manual(PackageName, "Scope")) .WithXmlDoc(XmlDoc.Summary($"Available OAuth 2.0 scopes for use with the {Title}.")); using (ctx.InClass(scopeClass)) { foreach (var scope in AuthScopes) { var field = Field(Modifier.Public | Modifier.Static, ctx.Type <string>(), scope.Name) .WithInitializer(scope.Value) .WithXmlDoc(XmlDoc.Summary(scope.Description)); scopeClass = scopeClass.AddMembers(field); } } var scopeConstantsClass = Class(Modifier.Public | Modifier.Static, Typ.Manual(PackageName, "ScopeConstants")) .WithXmlDoc(XmlDoc.Summary($"Available OAuth 2.0 scope constants for use with the {Title}.")); using (ctx.InClass(scopeConstantsClass)) { foreach (var scope in AuthScopes) { var field = Field(Modifier.Public | Modifier.Const, ctx.Type <string>(), scope.Name) .WithInitializer(scope.Value) .WithXmlDoc(XmlDoc.Summary(scope.Description)); scopeConstantsClass = scopeConstantsClass.AddMembers(field); } } cls = cls.AddMembers(scopeClass, scopeConstantsClass); } // TODO: Find an example of this... foreach (var method in Methods) { cls = cls.AddMembers(method.GenerateDeclarations(ctx).ToArray()); } cls = cls.AddMembers(resourceProperties); } return(cls); }
/// <summary> /// Flushes this instance. This action is optional, for example if a DataContext should be flushed multiple times before committing or rolling back a transaction. /// </summary> /// <remarks></remarks> public override void Flush() { this.CheckThrowObjectDisposed(base.IsDisposed, "XmlStore...DataContext:Flush"); XmlDoc.Save(_path); // The XmlStore transaction method is to backup at the start of a transaction, and rollback overwrites from the backup, so just save to normal path }
internal IEnumerable <XElement> FindElementsByExpression(string expression) { return(((IEnumerable)XmlDoc.XPathEvaluate(expression)).Cast <XElement>()); }
public XmlNode GetNode(string xmlPathNode) { return(XmlDoc.SelectSingleNode(xmlPathNode)); }
/// <summary> /// 保存文档 /// </summary> /// <param name="fileName">要保存的路径</param> public void Save(string fileName) { XmlDoc.Save(fileName); }
public string GetNodeText(string xmlPathNode) { return(XmlDoc.SelectSingleNode(xmlPathNode).InnerText); }
private IEnumerable <Tuple <string, Response> > GetResponses(MethodInfo method, Dictionary <string, List <Attribute> > methodAttr, XmlDoc doc) { bool IsVoid(Type type) => type == null || type.FullName == "System.Void"; var docDescription = doc?.Returns ?? string.Empty; var methodReturnType = method.ReturnType; if (methodReturnType == typeof(Task)) { methodReturnType = typeof(void); } else if (methodReturnType.Name == "Task`1") { methodReturnType = methodReturnType.GenericTypeArguments[0]; } else if (methodReturnType == typeof(HttpResponseMessage) || typeof(IActionResult).IsAssignableFrom(methodReturnType)) { methodReturnType = typeof(object); } var methodStatusCode = IsVoid(methodReturnType) ? "204" : "200"; var methodDescription = IsVoid(methodReturnType) ? "No Content" : docDescription; const string responsetypeattribute = nameof(ResponseTypeAttribute); var overriddenCodes = new HashSet <string>(); if (methodAttr.ContainsKey(responsetypeattribute)) { var responseTypeAttributes = methodAttr[responsetypeattribute].Cast <ResponseTypeAttribute>(); foreach (var responseTypeAttribute in responseTypeAttributes) { var returnType = responseTypeAttribute.ResponseType; var statusCode = responseTypeAttribute.HttpStatusCode ?? (IsVoid(returnType) ? "204" : "200"); overriddenCodes.Add(statusCode); var schema = _schemaGenerator.MapToSchema(_schemaGenerator.GetSchema(returnType)); var description = IsVoid(returnType) ? "No Content" : docDescription; yield return(Tuple.Create(statusCode, new Response { Description = description, Schema = schema })); } } if (!overriddenCodes.Contains(methodStatusCode)) { var response = new Response { Description = methodDescription }; if (!IsVoid(methodReturnType)) { response.Schema = _schemaGenerator.MapToSchema(_schemaGenerator.GetSchema(methodReturnType)); } yield return(Tuple.Create(methodStatusCode, response)); } yield return (Tuple.Create("default", new Response { Description = "Unexected Error", Schema = new SchemaObject() { Ref = "#/definitions/ErrorModel" } })); }
} // InitEmptyXMLDoc #endregion // ******************************************************************************* // ******************************************************************************* #region ***** WRITE METHODS /// <summary> /// Adds a concept element as child to the root element /// </summary> public void AddConcept() // Code History: // 2014-03-05 mws { AddNarPropertyToParent("/nar:" + RootElemName, NameSeqCiRoot, XmlDoc.CreateElement("concept", G2NsCs)); } // AddConcept
public void JsonSerialise_Object_GetAsArrayReturnsNull() { var d1 = new XmlDoc { SV = "test" }; string s = d1.ToJsonString(); string[] array = s.AsJsonObject<string[]>(); Assert.Null(array); }
/// <summary> /// 根据字段类型,显示此类型所需要配置的信息项 /// </summary> public void Attribute() { if (!String.IsNullOrEmpty(Field)) { xml = new XmlDoc(); xml.xmlfilePath = "../../App_Data/TableXml/" + TableName + ".xml"; dt = xml.GetDataTable("Type='" + FieldType + "' and Name='" + Field + "'", ""); } switch (FieldType) { case "SingleLine": SingleLineType(); break; case "Password": PasswordType(); break; case "MultiLine": MultiLineType(); break; case "Editor": EditorType(); break; case "Select": SelectType(); break; case "Number": NumberType(); break; case "DateTime": DateTimeType(); break; case "Image": ImageType(); break; case "File": FileType(); break; case "BatchImage": BatchImageType(); break; case "BatchFile": BatchFileType(); break; case "OtherMenu": OtherMenuType(); break; case "Provinces": ProvincesType(); break; case "Increment": Increment(); break; } }
public void JsonSerialise_Object_ValidString() { var d1 = new XmlDoc { SV = "test" }; string s = d1.ToJsonString(); Assert.NotNull(s); XmlDoc d2 = s.AsJsonObject<XmlDoc>(); Assert.Equal(d1.SV, d2.SV); }
/// <summary> /// 保存文档 /// </summary> public void Save() { XmlDoc.Save(XmlPath); }
public void XmlSerialiseDeserialise_Object_ValidString() { XmlDoc d1 = new XmlDoc { SV = "test" }; string s = d1.XmlSerialise(); XmlDoc d2 = s.XmlDeserialise<XmlDoc>(); XmlDoc d3 = (XmlDoc)s.XmlDeserialise(typeof(XmlDoc)); Assert.Equal("test", d2.SV); Assert.Equal("test", d3.SV); }
private static IEnumerable <MemberDeclarationSyntax> LroPartialClasses(SourceFileContext ctx, ServiceDetails svc) { if (svc.Methods.Any(m => m is MethodDetails.StandardLro)) { // Emit partial class to give access to an LRO operations client. var grpcOuterCls = Class(Public | Static | Partial, svc.GrpcClientTyp.DeclaringTyp); using (ctx.InClass(grpcOuterCls)) { var grpcInnerClass = Class(Public | Partial, svc.GrpcClientTyp); using (ctx.InClass(grpcInnerClass)) { var callInvoker = Property(Private, ctx.TypeDontCare, "CallInvoker"); var opTyp = ctx.Type <Operations.OperationsClient>(); var createOperationsClientMethod = Method(Public | Virtual, opTyp, "CreateOperationsClient")() .WithBody(New(opTyp)(callInvoker)) .WithXmlDoc( XmlDoc.Summary("Creates a new instance of ", opTyp, " using the same call invoker as this client."), XmlDoc.Returns("A new Operations client for the same target as this client.") ); grpcInnerClass = grpcInnerClass.AddMembers(createOperationsClientMethod); } grpcOuterCls = grpcOuterCls.AddMembers(grpcInnerClass); } yield return(grpcOuterCls); } // Generate partial classes to delegate to other services handling operations if (svc.Methods.Any(m => m is MethodDetails.NonStandardLro)) { var operationServices = svc.Methods.OfType <MethodDetails.NonStandardLro>().Select(lro => lro.OperationService).Distinct().ToList(); // Emit partial class to give access to an LRO operations client. var grpcOuterCls = Class(Public | Static | Partial, svc.GrpcClientTyp.DeclaringTyp); using (ctx.InClass(grpcOuterCls)) { var grpcInnerClass = Class(Public | Partial, svc.GrpcClientTyp); using (ctx.InClass(grpcInnerClass)) { var callInvoker = Property(Private, ctx.TypeDontCare, "CallInvoker"); var opTyp = ctx.Type <Operations.OperationsClient>(); foreach (var operationService in operationServices) { var grpcClient = ctx.Type(Typ.Nested(Typ.Manual(ctx.Namespace, operationService), $"{operationService}Client")); var createOperationsClientMethod = Method(Public | Virtual, opTyp, $"CreateOperationsClientFor{operationService}")() .WithBody(grpcClient.Call("CreateOperationsClient")(callInvoker)) .WithXmlDoc( XmlDoc.Summary("Creates a new instance of ", opTyp, $" using the same call invoker as this client, delegating to {operationService}."), XmlDoc.Returns("A new Operations client for the same target as this client.") ); grpcInnerClass = grpcInnerClass.AddMembers(createOperationsClientMethod); } } grpcOuterCls = grpcOuterCls.AddMembers(grpcInnerClass); } yield return(grpcOuterCls); } // Generate partial classes for the operation-handling services if (svc.NonStandardLro is ServiceDetails.NonStandardLroDetails lroDetails) { // Emit partial class to give access to an LRO operations client. var grpcOuterCls = Class(Public | Static | Partial, svc.GrpcClientTyp.DeclaringTyp); using (ctx.InClass(grpcOuterCls)) { var grpcInnerClass = Class(Public | Partial, svc.GrpcClientTyp); using (ctx.InClass(grpcInnerClass)) { var callInvoker = Parameter(ctx.Type <CallInvoker>(), "callInvoker"); var request = Parameter(ctx.TypeDontCare, "request"); var response = Parameter(ctx.TypeDontCare, "response"); var opTyp = ctx.Type <Operations.OperationsClient>(); var forwardingCallInvoker = Local(ctx.Type <CallInvoker>(), "forwardingCallInvoker"); var createOperationsClientMethod = Method(Internal | Static, opTyp, "CreateOperationsClient")(callInvoker) .WithBody( forwardingCallInvoker.WithInitializer( // Note: can't use Typ.Of<ForwardingCallInvoker<GetOperationRequest>> as it's a static class. ctx.Type(Typ.Generic(Typ.Of(typeof(ForwardingCallInvoker <>)), Typ.Of <GetOperationRequest>())).Call("Create")( callInvoker, "/google.longrunning.Operations/GetOperation", Property(Private, ctx.TypeDontCare, $"__Method_{lroDetails.PollingMethod.Name}"), ctx.Type(lroDetails.PollingRequestTyp).Access("ParseLroRequest"), // Method group conversion Lambda(request, response)(response.Call("ToLroResponse")(request.Access("Name"))) )), Return(New(opTyp)(forwardingCallInvoker))) .WithXmlDoc( XmlDoc.Summary( "Creates a new instance of ", opTyp, "using the specified call invoker, but ", $"redirecting Google.LongRunning RPCs to {lroDetails.Service.Name} RPCs."), XmlDoc.Returns("A new Operations client for the same target as this client.") ); grpcInnerClass = grpcInnerClass.AddMembers(createOperationsClientMethod); } grpcOuterCls = grpcOuterCls.AddMembers(grpcInnerClass); } yield return(grpcOuterCls); } }
public void JsonSerialise_ObjectAsCompressed_SmallerString() { var odoc = new XmlDoc { SV = "value" }; string fullString = odoc.ToJsonString(); string compString = odoc.ToCompressedJsonString(); Assert.True(fullString.Length > compString.Length); }
public DomConverter CompileAllIfNeed(string FileName, bool parse_only_interface = false) { this.FileName = FileName; this.Text = comp.GetSourceFileText(FileName); string ext = Path.GetExtension(FileName); List <Error> ErrorsList = new List <Error>(); List <CompilerWarning> Warnings = new List <CompilerWarning>(); compilation_unit cu = null; if (Text != null) { cu = ParsersController.GetCompilationUnit(FileName, Text, ErrorsList, Warnings); } Parser = ParsersController.selectParser(Path.GetExtension(FileName).ToLower()); ErrorsList.Clear(); Warnings.Clear(); documentation_comment_list dt = ParsersController.Compile(System.IO.Path.ChangeExtension(FileName, get_doctagsParserExtension(ext)), Text, ErrorsList, Warnings, ParseMode.Normal) as documentation_comment_list; DocumentationConstructor docconst = new DocumentationConstructor(); if (cu != null) { docs = docconst.Construct(cu, dt); } DomConverter dconv = new DomConverter(this); dconv.visitor.parse_only_interface = parse_only_interface; if (XmlDoc.LookupLocalizedXmlDocForUnitWithSources(FileName, CodeCompletionController.currentLanguageISO) != null) { dconv.visitor.add_doc_from_text = false; } if (cu != null) { dconv.ConvertToDom(cu); } else { ErrorsList.Clear(); Warnings.Clear(); //cu = ParsersControllerGetComilationUnit(FileName, Text, ErrorsList, true); if (comp_modules[FileName] == null) { string tmp = ParsersHelper.GetModifiedProgramm(Text); if (tmp != null) { cu = ParsersControllerGetCompilationUnitSpecial(FileName, tmp, ErrorsList, Warnings); ErrorsList.Clear(); } if (cu == null) { cu = get_fictive_unit(Text, FileName); } } ErrorsList.Clear(); Warnings.Clear(); dt = ParsersController.Compile(System.IO.Path.ChangeExtension(FileName, get_doctagsParserExtension(ext)), Text, ErrorsList, Warnings, ParseMode.Normal) as documentation_comment_list; if (cu != null) { docs = docconst.Construct(cu, dt); } if (XmlDoc.LookupLocalizedXmlDocForUnitWithSources(FileName, CodeCompletionController.currentLanguageISO) != null) { dconv.visitor.add_doc_from_text = false; } if (cu != null) { dconv.ConvertToDom(cu); } } if (dconv.is_compiled) { comp_modules[FileName] = dconv; } if (docs != null) { docs.Clear(); } //comp_modules[FileName] = dconv; // GC.Collect(); return(dconv); }
/// <summary> /// 设置XML输出信息 /// </summary> /// <param name="To_JavaXml">XML文档</param> /// <param name="project">工程对象</param> /// <param name="sqlID">SQL查询标识</param> /// <param name="xmlInfo">节点XML</param> /// <param name="template">模板名称</param> /// <param name="where">查询条件</param> /// <returns>自定义字段集合</returns> public static List <T_Model> setXmlInfo(XmlDocument To_JavaXml, T_Projects project, string sqlID, XmlElement xmlInfo, string template, string where = "") { XmlDoc doc = new XmlDoc(Application.StartupPath + @"\Common\XMLTemplate\" + template + ".xml"); XmlNodeList nodeList = doc.GetNodeList("root"); XmlNodeList columList = null; XmlNodeList sqlList = null; List <T_Model> modelList = new List <T_Model>(); List <T_Model> resultList = new List <T_Model>(); string sql = string.Empty; #region XML节点 for (int i = 0; i < nodeList.Count; i++) { switch (nodeList[i].Name.ToLower()) { case "columns": columList = nodeList[i].ChildNodes; break; case "selects": sqlList = nodeList[i].ChildNodes; break; } } #endregion #region 模板字段 if (columList != null) { modelList.Clear(); resultList.Clear(); T_Model model = null; for (int i = 0; i < columList.Count; i++) { XmlNode node = columList[i]; XmlAttributeCollection attrCollection = node.Attributes; if (attrCollection == null) { continue; } model = new T_Model(); for (int j = 0; j < attrCollection.Count; j++) { switch (attrCollection[j].Name) { case "column": model.Column = attrCollection[j].Value; break; case "mappColumn": model.MappColumn = attrCollection[j].Value; break; case "display": model.Display = attrCollection[j].Value; break; case "description": model.Description = attrCollection[j].Value; break; case "type": model.Type = attrCollection[j].Value; break; case "default": model.Default = attrCollection[j].Value; break; } } if (model.Display == "1") { modelList.Add(model); } if (model.Type == "1") { resultList.Add(model); } } } #endregion #region 射字段 if (sqlList.Count > 0) { for (int j = 0; j < sqlList.Count; j++) { XmlAttributeCollection attrColl = sqlList[j].Attributes; if (attrColl["id"].Value.ToString() == sqlID) { sql = sqlList[j].InnerText.Trim(); #region 参数处理 //switch (attrColl["parameterClass"].Value.ToLower()) //{ // case "string": // sql = sql.Replace("#value#", "'" + project.ProjectNO + "'"); // break; // case "int": // sql = sql.Replace("#value#", project.ProjectNO); // break; // default: // dynamic d = attrColl["parameterClass"].Value; // sql = sql.Replace("#value#", project.ProjectNO); // break; //} #endregion #region 输出XML try { DataSet ds = ERM.DAL.MyBatis.QueueyForSql(sql + " " + where); if (ds.Tables.Count > 0) { for (int m = 0; m < ds.Tables[0].Rows.Count; m++) { for (int k = 0; k < modelList.Count; k++) { for (int n = 0; n < ds.Tables[0].Columns.Count; n++) { if (modelList[k].Column.ToString().ToLower() == ds.Tables[0].Columns[n].ColumnName.ToString().ToLower()) { XmlElement X_temp = To_JavaXml.CreateElement(modelList[k].MappColumn); if (!string.IsNullOrEmpty(ds.Tables[0].Rows[m][n].ToString())) { X_temp.SetAttribute("value", ds.Tables[0].Rows[m][n].ToString()); } else { X_temp.SetAttribute("value", modelList[k].Default); } xmlInfo.AppendChild(X_temp); } } } } } } catch (Exception ex) { TX.Framework.WindowUI.Forms.TXMessageBoxExtensions.Info(ex.Message.ToString()); } break; #endregion } } } return(resultList); #endregion }
/// <summary> /// 关闭 /// </summary> public void Close() { XmlDoc.Save(xmlPath); XmlDoc = null; xmlPath = null; }
private IEnumerable <Tuple <string, Response> > GetResponses(MethodInfo method, Dictionary <string, List <Attribute> > methodAttr, XmlDoc doc) { Func <Type, bool> isVoid = type => type == null || type.FullName == "System.Void"; var returnType = method.ReturnType; if (returnType == typeof(Task)) { returnType = typeof(void); } else if (returnType.Name == "Task`1") { returnType = returnType.GenericTypeArguments[0]; } else if (returnType == typeof(HttpResponseMessage) || returnType == typeof(ActionResult)) { returnType = typeof(object); } var description = doc?.Returns ?? string.Empty; var mayBeNull = !SchemaGenerator.IsParameterRequired(method.ReturnParameter); const string responsetypeattribute = nameof(ResponseTypeAttribute); if (methodAttr.ContainsKey(responsetypeattribute)) { var responseTypeAttributes = methodAttr[responsetypeattribute].Cast <ResponseTypeAttribute>(); foreach (var responseTypeAttribute in responseTypeAttributes) { returnType = responseTypeAttribute.ResponseType; var httpStatusCode = responseTypeAttribute.HttpStatusCode ?? (isVoid(returnType) ? "204" : "200"); yield return(Tuple.Create(httpStatusCode, new Response { Description = isVoid(returnType) ? "No Content" : description, Schema = _schemaGenerator.MapToSchema(_schemaGenerator.GetSchema(returnType)) })); } } else { yield return(isVoid(returnType) ? Tuple.Create("204", new Response() { Description = "No Content." }) : Tuple.Create("200", new Response { Description = description, Schema = _schemaGenerator .MapToSchema(_schemaGenerator.GetSchema(returnType)) })); } yield return (Tuple.Create("default", new Response() { Description = "Unexected Error", Schema = new SchemaObject() { Ref = "#/definitions/ErrorModel" } })); }