GhostDoc 的注释规则备注

最新推荐文章于 2017-04-20 16:24:00 发布
最新推荐文章于 2017-04-20 16:24:00 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： C# 工具使用 文章标签： GhostDoc 注释 规则 rules
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyh1112/article/details/31741781
版权 
<#@ template language="C#" #>
/// *********************<#= Context.GetGlobalProperty("CompanyName") #>*************************************
<#  CodeElement codeElement = Context.CurrentCodeElement; #>
/// Author           : <#= Context.GetGlobalProperty("UserName") #>
/// Created          : <#= Context.DestinationFileCreationDateTime.ToString("yyyy-MM-dd HH:mm:ss") #>
/// <summary>
///<# GenerateSummaryText(); #>
/// </summary>
<#	if(codeElement.HasTypeParameters) 
	{
		for(int i = 0; i < codeElement.TypeParameters.Length; i++) 
		{ 
			TypeParameter typeParameter = codeElement.TypeParameters[i]; 
#>
/// <typeparam name="<#= typeParameter.Name #>"><# GenerateTypeParamText(typeParameter, i); #></typeparam>
<#		}	
	} 
   
	if(codeElement.HasParameters) 
	{
		for(int i = 0; i < codeElement.Parameters.Length; i++) 
		{ 
			Parameter parameter = codeElement.Parameters[i];
#>
/// <param name="<#= parameter.Name #>"><# GenerateParamText(parameter, i); #></param>
<#		}	
	} 
GenerateReturnsText(); #>
/// Last Modified By : <#= Context.GetGlobalProperty("UserName") #>
/// Last Modified On : <#= Context.DestinationFileModificationDateTime.ToString("yyyy-MM-dd HH:mm:ss") #>
/// *********************<#= Context.GetGlobalProperty("CompanyName") #>*************************************
<#= Context.GetNonGeneratedExceptionTags() #>
<#= Context.GetNonGeneratedTags() #>
<# GenerateRemarksText(); #>

<#+
	private void GenerateSummaryText()
	{
		if(Context.HasExistingTagText("summary"))
		{
			this.WriteLine(Context.GetExistingTagText("summary"));
		}
		else if(IsAsyncMethod())
		{
			this.WriteLine(Context.ExecMacro("$(MethodName.Words.ExceptLast)") + " as an asynchronous operation.");
		}
		else if(IsMainMethod())
		{
			this.WriteLine("Defines the entry point of the application.");        
		}
		else if(IsGetHashCodeMethod())
		{
			this.WriteLine("Returns a hash code for this instance.");        
		}
		else if(IsEqualsMethod())
		{
			this.WriteLine("Determines whether the specified <see cref=\"System.Object\" /> is equal to this instance.");
		}
		else if(IsToStringMethod())
		{
			this.WriteLine("Returns a <see cref=\"System.String\" /> that represents this instance.");        
		}
		else if(Context.HasInheritedTagText("summary"))
		{
			this.WriteLine(Context.GetInheritedTagText("summary"));
		}
		else if(IsOnMethod())
		{
			if(Context.CurrentCodeElement.HasParameters && IsEventArgsParameter(Context.CurrentCodeElement.Parameters[Context.CurrentCodeElement.Parameters.Length - 1]))
			{
				this.WriteLine(Context.ExecMacro("Handles the <see cref=\"E:$(MethodName.Words.Verbatim.ExceptFirst)\" /> event."));        
			}
			else
			{
				this.WriteLine(Context.ExecMacro("Called when $(End)[$(MethodName.Words.ExceptFirst)]."));        
			}          
		}
		else if(IsControlEventHandlerMethod())
		{
			string name = Context.CurrentCodeElement.Name;
			int index = name.LastIndexOf('_');
			if(index >= 0)
			{
				this.WriteLine(string.Format(
					"Handles the {0} event of the {1} control.",
					name.Substring(index + 1),
					name.Substring(0, index)));        
			}
			else
			{
				this.WriteLine("[ERROR: No underscore found in name]");        
			}          
		}
		else if(IsFinalizeMethod())
		{
		    // commented for StypeCop compliance (SA1643)
			// this.WriteLine(Context.ExecMacro("Releases unmanaged resources and performs other cleanup operations before the $(DeclaringTypeName.ShortNameAsSee) is reclaimed by garbage collection."));        
			this.WriteLine(Context.ExecMacro("Finalizes an instance of the $(DeclaringTypeName.ShortNameAsSee) class."));        
		}       
		else if(IsStateCheckMethod())
		{
			bool bWithParameters = Context.CurrentCodeElement.HasParameters;
			Words words = Context.GetWords(Context.CurrentCodeElement.Name);
			bool bSingleWord = (words != null && words.Count == 2);

			if (bWithParameters)
			{
				if (bSingleWord)
				{
					this.WriteLine(Context.ExecMacro("Determines whether the specified $(Parameters.First.Name.Words.All) $(MethodName.Words.All)."));
				}
				else
				{
					this.WriteLine(Context.ExecMacro("Determines whether $(End)[$(MethodName.Words.All)] [the specified $(Parameters.First.Name.Words.All)]."));
				}
			}
			else if (bSingleWord)
			{
				this.WriteLine(Context.ExecMacro("Determines whether this instance $(MethodName.Words.All)."));
			}
			else
			{
				this.WriteLine(Context.ExecMacro("Determines whether $(End)[$(MethodName.Words.All)]."));
			}
		}       
		else if(IsCapabilityCheckMethod())
		{
			bool bWithParameters = Context.CurrentCodeElement.HasParameters;
			Words words = Context.GetWords(Context.CurrentCodeElement.Name);
			bool bSingleWord = (words != null && words.Count == 2);

			if (bWithParameters)
			{
				if (bSingleWord)
				{
					this.WriteLine(Context.ExecMacro("Determines whether this instance $(MethodName.Words.All) the specified $(Parameters.First.Name.Words.All)."));
				}
				else
				{
					this.WriteLine(Context.ExecMacro("Determines whether this instance $(End)[$(MethodName.Words.All)] the specified $(Parameters.First.Name.Words.All)."));
				}
			}
			else if (bSingleWord)
			{
				this.WriteLine(Context.ExecMacro("Determines whether this instance $(MethodName.Words.All)."));
			}
			else
			{
				this.WriteLine(Context.ExecMacro("Determines whether this instance $(End)[$(MethodName.Words.All)]."));
			}
		}  
		else if(IsImplicitOperatorMethod())
		{
			this.WriteLine(Context.ExecMacro("Performs an implicit conversion from $(Parameters.First.TypeName.FullNameAsSee) to $(ReturnTypeName.FullNameAsSee)."));        
		}                                        
		else if(IsExplicitOperatorMethod())
		{
			this.WriteLine(Context.ExecMacro("Performs an explicit conversion from $(Parameters.First.TypeName.FullNameAsSee) to $(ReturnTypeName.FullNameAsSee)."));        
		}                                        
		else if(Context.CurrentCodeElement.IsOperator)
		{
			this.WriteLine(Context.ExecMacro("Implements the $(MethodName.ActualName)."));        
		}                                        
		else if(IsDisposeMethod())
		{
			this.WriteLine("Releases unmanaged and - optionally - managed resources.");        
		}                                        
		else if(IsSingleWordMethod())
		{
			if(Context.CurrentCodeElement.HasParameters)
			{
				this.WriteLine(Context.ExecMacro("$(MethodName.Words.FirstAsVerbStartingSentence) the specified $(Parameters.First.Name.Words.All)."));
			}
			else
			{
				this.WriteLine(Context.ExecMacro("$(MethodName.Words.FirstAsVerbStartingSentence) this instance."));
			}          
		}
		else if(Context.ContainsOfTheReordering(Context.CurrentCodeElement.Name))
		{
			this.WriteLine(Context.ExecMacro("$(OfTheReordering)"));
		}                                                
		else
		{
			if(Context.CurrentCodeElement.IsMethod)
			{
				this.WriteLine(Context.ExecMacro("$(DefaultMethodName)"));
			}
			else
			{
				this.WriteLine(Context.ExecMacro("$(End)"));
			}
		}
    }
    
	private void GenerateTypeParamText(TypeParameter typeParameter, int index)
	{
		if(Context.HasExistingTagText("typeparam", index)) 
		{ 
			this.Write(Context.GetExistingTagText("typeparam", index));
		} 
		else if(Context.HasInheritedTagText("typeparam", index))
		{
			this.Write(Context.GetInheritedTagText("typeparam", index));
		}
		else 
		{
			string typeParameterName = typeParameter.Name;
			if(typeParameterName != null)
			{
				if(typeParameterName.Length == 1)
				{
					this.Write("");
				}
				else
				{
					this.Write("The type of " + Context.ExecMacro(typeParameterName, "$(TheAndAll)") + ".");
				}            
			}          
		} 
	}
    
	private void GenerateParamText(Parameter parameter, int index)
	{
		if(Context.HasExistingTagText("param", index)) 
		{ 
			this.Write(Context.GetExistingTagText("param", index));
		} 
		else if(Context.HasInheritedTagText("param", index))
		{
			this.Write(Context.GetInheritedTagText("param", index));
		}
		else if(IsEqualsMethod() && index == 0)
		{
			this.Write("The <see cref=\"System.Object\" /> to compare with this instance.");
		}
		else if(IsDisposeMethod() && index == 0)
		{
			this.Write(Context.ExecMacro("$(True) to release both managed and unmanaged resources; $(False) to release only unmanaged resources."));
		}        
		else if(IsControlEventHandlerMethod() && index == 0)
		{
			this.Write("The source of the event.");
		}        
		else if(IsBooleanParameter(parameter)) 
		{
			this.Write("if set to " + Context.ExecMacro("$(True)") + " [" + Context.ExecMacro(parameter.Name, "$(All)") + "].");
		}
		else if(IsEventArgsParameter(parameter)) 
		{
			this.Write("The " + Context.ExecMacro(parameter.ReturnType.FullName, "$(TypeName.FullNameAsSee)") + " instance containing the event data.");
		}
		else if(Context.ContainsOfTheReordering(parameter.Name)) 
		{
			this.Write(Context.ExecMacro(parameter.Name, "$(OfTheReordering)"));
		}
		else 
		{
			this.Write(Context.ExecMacro(parameter.Name, "$(TheAndAllAsSentence)") + ".");
		} 
	}
    
	private void GenerateReturnsText()
	{
		if(Context.HasExistingTagText("returns"))
		{
#>
/// <returns><#= Context.GetExistingTagText("returns") #></returns>
<#+     
		}
		else if(IsGetHashCodeMethod())
		{
#>
/// <returns>A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.</returns>
<#+     
		}
		else if(IsEqualsMethod())
		{
#>
/// <returns><#= Context.ExecMacro("$(True) if the specified <see cref=\"System.Object\" /> is equal to this instance; otherwise, $(False).") #></returns>
<#+     
		}
		else if(IsToStringMethod())
		{
#>
/// <returns>A <see cref="System.String" /> that represents this instance.</returns>
<#+     
		}
		else if(Context.HasInheritedTagText("returns"))
		{
#>
/// <returns><#= Context.GetInheritedTagText("returns") #></returns>
<#+     
		}
		else if(IsStateCheckMethod())
		{
			if(!IsBooleanMethod())
			{
				return;
			}
		  
			bool bWithParameters = Context.CurrentCodeElement.HasParameters;
			Words words = Context.GetWords(Context.CurrentCodeElement.Name);
			bool bSingleWord = (words != null && words.Count == 2);

			if (bWithParameters)
			{
				if (bSingleWord)
				{
#>
/// <returns><#= Context.ExecMacro("$(True) if the specified $(Parameters.First.Name.Words.All) $(MethodName.Words.All); otherwise, $(False).") #></returns>
<#+     
				}
				else
				{			
#>
/// <returns><#= Context.ExecMacro("$(True) if [$(MethodName.Words.All)] [the specified $(Parameters.First.Name.Words.All)]; otherwise, $(False).") #></returns>
<#+     
				}
			}
			else if (bSingleWord)
			{
#>
/// <returns><#= Context.ExecMacro("$(True) if this instance $(MethodName.Words.All); otherwise, $(False).") #></returns>
<#+     
			}
			else
			{	
#>
/// <returns><#= Context.ExecMacro("$(True) if [$(MethodName.Words.All)]; otherwise, $(False).") #></returns>
<#+     
			}
		}                     
		else if(IsCapabilityCheckMethod())
		{
			if(!IsBooleanMethod())
			{
				return;
			}
		  
			bool bWithParameters = Context.CurrentCodeElement.HasParameters;
			Words words = Context.GetWords(Context.CurrentCodeElement.Name);
			bool bSingleWord = (words != null && words.Count == 2);

			if (bWithParameters)
			{
				if (bSingleWord)
				{
#>
/// <returns><#= Context.ExecMacro("$(True) if this instance $(MethodName.Words.All) the specified $(Parameters.First.Name.Words.All); otherwise, $(False).") #></returns>
<#+     
				}
				else
				{			
#>
/// <returns><#= Context.ExecMacro("$(True) if this instance [$(MethodName.Words.All)] the specified $(Parameters.First.Name.Words.All); otherwise, $(False).") #></returns>
<#+     
				}
			}
			else if (bSingleWord)
			{
#>
/// <returns><#= Context.ExecMacro("$(True) if this instance $(MethodName.Words.All); otherwise, $(False).") #></returns>
<#+     
			}
			else
			{	
#>
/// <returns><#= Context.ExecMacro("$(True) if this instance [$(MethodName.Words.All)]; otherwise, $(False).") #></returns>
<#+     
			}
		}                                
		else if(IsImplicitOperatorMethod())
		{
#>
/// <returns>The result of the conversion.</returns>
<#+     
		}                                        
		else if(IsExplicitOperatorMethod())
		{
#>
/// <returns>The result of the conversion.</returns>
<#+     
		}                                        
		else if(Context.CurrentCodeElement.IsOperator)
		{
#>
/// <returns>The result of the operator.</returns>
<#+     
		}                                        
		else if(Context.CurrentCodeElement.HasReturnType && 
			Context.CurrentCodeElement.ReturnType.FullName.Length > 0 && 
			String.Compare( Context.CurrentCodeElement.ReturnType.FullName, "System.Boolean", true) == 0) 
		{
#>
/// <returns><#= Context.ExecMacro("$(True)") #> if XXXX, <#= Context.ExecMacro("$(False)") #> otherwise.</returns>
<#+     
		}
		else if(Context.CurrentCodeElement.HasReturnType && 
			!(Context.CurrentCodeElement.ReturnType.FullName.Length == 0 || 
			String.Compare( Context.CurrentCodeElement.ReturnType.FullName, "void", true) == 0)) 
		{
#>
/// <returns><#= Context.ExecMacro("$(ReturnTypeName.FullName).") #></returns>
<#+     
		}
	} 
    
	private bool IsBooleanParameter(Parameter parameter)
	{
		return (bool)(parameter.ReturnType != null && 
			parameter.ReturnType.FullName != null &&
			parameter.ReturnType.FullName.Length > 0 && 
			(string.Compare( parameter.ReturnType.FullName, "System.Boolean", true) == 0 ||
			string.Compare( parameter.ReturnType.FullName, "System.Nullable<bool>", true) == 0));
	}     
    
	private bool IsEventArgsParameter(Parameter parameter)
	{
		return (bool)(parameter.ReturnType != null && 
			parameter.ReturnType.FullName != null &&
			parameter.ReturnType.FullName.Length >= "EventArgs".Length && 
			parameter.ReturnType.FullName.EndsWith("EventArgs"));
	} 
	
	private bool IsBooleanMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.ReturnType != null && 
			codeElement.ReturnType.FullName != null &&
			codeElement.ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.ReturnType.FullName, "System.Boolean", true) == 0);
	}
	
	private bool IsGetHashCodeMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name == "GetHashCode" &&
			codeElement.ReturnType != null && 
			codeElement.ReturnType.FullName != null &&
			codeElement.ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.ReturnType.FullName, "System.Int32", true) == 0);
	}

	private bool IsEqualsMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name == "Equals" &&
			codeElement.ReturnType != null && 
			codeElement.ReturnType.FullName != null &&
			codeElement.ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.ReturnType.FullName, "System.Boolean", true) == 0 &&
			codeElement.HasParameters && codeElement.Parameters.Length == 1 &&
			codeElement.Parameters[0].ReturnType != null && 
			codeElement.Parameters[0].ReturnType.FullName != null &&
			codeElement.Parameters[0].ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.Parameters[0].ReturnType.FullName, "System.Object", true) == 0);
	}

	private bool IsToStringMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name == "ToString" &&
			codeElement.ReturnType != null && 
			codeElement.ReturnType.FullName != null &&
			codeElement.ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.ReturnType.FullName, "System.String", true) == 0);
	}

	private bool IsOnMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		Words words = Context.GetWords(codeElement.Name);
		return (bool)(words != null && words.Count > 1 && codeElement.Name != null &&
			codeElement.Name.Length > "On".Length && codeElement.Name.StartsWith("On"));
	}
     
	private bool IsControlEventHandlerMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.HasParameters && codeElement.Parameters.Length == 2 &&
			codeElement.Parameters[0].ReturnType != null && 
			codeElement.Parameters[0].ReturnType.FullName != null &&
			codeElement.Parameters[0].ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.Parameters[0].ReturnType.FullName, "System.Object", true) == 0 &&
			codeElement.Parameters[1].ReturnType != null && 
			codeElement.Parameters[1].ReturnType.FullName != null &&
			codeElement.Parameters[1].ReturnType.FullName.Length >= "EventArgs".Length &&
			codeElement.Parameters[1].ReturnType.FullName.EndsWith("EventArgs") &&
			codeElement.Name.LastIndexOf('_') != -1);
	}
      
	private bool IsFinalizeMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name != null && codeElement.Name.Length > 1 &&
			codeElement.Name.StartsWith("~"));
	}

	private bool IsStateCheckMethod()
	{
		string[] triggerWords = new string[] { "is", "has", "contains" };
	    
		CodeElement codeElement = Context.CurrentCodeElement;  
	    
		Words words = Context.GetWords(codeElement.Name);
		return (bool)(words != null && Array.IndexOf(triggerWords, words.First) >= 0);
	}   

	private bool IsCapabilityCheckMethod()
	{
		string[] triggerWords = new string[] { "can" };
	    
		CodeElement codeElement = Context.CurrentCodeElement;  
	    
		Words words = Context.GetWords(codeElement.Name);
		return (bool)(words != null && Array.IndexOf(triggerWords, words.First) >= 0);
	}
   
	private bool IsImplicitOperatorMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name != null && codeElement.Name.Length > "implicit operator".Length &&
			codeElement.Name != null && codeElement.Name.StartsWith("implicit operator"));
	}
       
	private bool IsExplicitOperatorMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name != null && codeElement.Name.Length > "explicit operator".Length &&
			codeElement.Name.StartsWith("explicit operator"));
	}

	private bool IsDisposeMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		return (bool)(codeElement.Name == "Dispose" &&
			codeElement.HasParameters && codeElement.Parameters.Length == 1 &&
			codeElement.Parameters[0].ReturnType != null && 
			codeElement.Parameters[0].ReturnType.FullName != null &&
			codeElement.Parameters[0].ReturnType.FullName.Length > 0 && 
			string.Compare( codeElement.Parameters[0].ReturnType.FullName, "System.Boolean", true) == 0);
	}
	
	private bool IsSingleWordMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		Words words = Context.GetWords(codeElement.Name);
		return (bool)(words != null && words.Count == 1);
	}  

	private bool IsOfTheSuffixMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
		
		Words words = Context.GetWords(codeElement.Name);
		return (bool)(words != null && words.Count == 1);
	}           
	
	private bool IsAsyncMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;				
		return (bool)(codeElement.IsAsync && codeElement.Name.Length > "Async".Length && codeElement.Name.EndsWith("Async"));
	}
	
	private bool IsMainMethod()
	{
		CodeElement codeElement = Context.CurrentCodeElement;
				
		return (bool)(codeElement.Name == "Main" && codeElement.IsStatic && 
			((codeElement.HasParameters && codeElement.Parameters.Length == 1) || !codeElement.HasParameters));
	}
		
	private void GenerateRemarksText()
	{
		if(Context.HasInheritedTagText("remarks"))
		{ #>
/// <remarks><#= Context.GetInheritedTagText("remarks") #></remarks>
<#+	    }
		else if(Context.HasExistingTagText("remarks"))
		{ #>
/// <remarks><#= Context.GetExistingTagText("remarks") #></remarks>
<#+	    }
		else if (!string.IsNullOrEmpty(Context.GetGlobalProperty("DefaultBlankRemarksText")))
		{ 
            // Should you require a default comment, set it in
			// Options -> Global Properties -> DefaultBlankRemarksText		
#>
/// <remarks><#= Context.GetGlobalProperty("DefaultBlankRemarksText") #></remarks>
<#+	    }
	}	
#>


步骤如图：



默认注释快捷键：shift+ctrl+D 效果如下图:


lyh1112
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#.NET必备工具GhostDoc为代码生成注释文档GhostDocPro_v4.5_Cracked
05-28
hostDoc是Visual Studio的一个免费插件，可以帮助开发人员编写XML格式的注释文档。 C#中XML格式的文档注释好处多多：Visual Studio会在很多地方显示这些注释内容（例如，编辑器的工具提示或对象浏览器），还有一些工具（比如NDoc或微软的文档工具Sandcastle） 也可以利用这些注释生成具有良好外观的帮助文件。这些都让XML格式的注释看上去很美——但很不幸，你首先得编写大量简单、乏味的注释。 目录下两个dll 覆盖安装目录
GhostDoc_Pro破解版
08-28
破解版的GhostDoc_Pro，我已经在VS2015上使用，还是很方便的。
VS自动注释——GhostDoc
weixin_30887919的博客
04-20 231
直接上图片，使用步骤是按顺序来的： 安装就不多说了，直接下一步，下一步。直接讲讲如何自定义注释规则 软件下载链接：http://pan.baidu.com/s/1dF5TSel 密码：peuz 链接：http://pan.baidu.com/s/1nv7FUpN 密码：tx31 转载于:https://www.cnblogs.com/shuai7boy/p/6739415.ht...
巧用GhostDoc,实现自定义注释
weixin_34390996的博客
03-02 102
   使用GhostDoc可以帮我们生成比较完整规范的代码注释，如果变量命名规范的话，只需要按下Ctrl+Shift+D (默认热键)，由它自动产生的注释就已经完全可以很好地表达我们的创建方法或属性的目的，而不需要我们手动去修改注释了。除了这些以外，它的强大之处在于它的可订制性。我们完全可以通过规则定义定制我们需要的注释说明。下面图解如何定制注释。在Vs 2005 Tools 菜单下打选择 Gho...
GhostDoc代码注释规范
cuibinmo3519的博客
06-24 96
GhostDoc事实上并不懂英语，那为何它生成的文档却常常令人相当满意？其中的基本原理颇为简单，GhostDoc假定你的代码遵从微软类库开发人员设计规范： 1、你的代码使用Pascal或Camel命名法为由多个单词组成的标识...
GhostDoc使用与原始注释
codepython的专栏
07-20 1405
一、简介 　　GhostDoc是Visual Studio的一个免费插件，可以为开发人员自动生成XML格式的注释文档。 　　 　　二、下载 　　需要的朋友可以去这里下载，填个Email地址就可以下了：GhostDoc下载地址 　　 　　三、安装 　　下载安装完成后，可以在Visual Studio的工具菜单下找到GhostDoc的身影。   　
GhostDoc的使用
weixin_33807284的博客
04-20 147
　　一、简介 　　GhostDoc是Visual Studio的一个免费插件，可以为开发人员自动生成XML格式的注释文档。 　　二、下载 　　需要的朋友可以去这里下载，填个Email地址就可以下了：GhostDoc下载地址 　　三、安装 　　下载安装完成后，可以在Visual Studio的工具菜单下找到GhostDoc的身影。 　　 　　在第一次使用时，会要求设置快捷键，默认的是C...
VS10-15注释插件ghostDoc.zip
12-13
GhostDoc是一款广受欢迎的Visual Studio插件，专为开发者设计，用于自动生成代码注释。这个"VS10-15注释插件ghostDoc.zip"压缩包包含了适用于Visual Studio 2010到2015版本的GhostDoc插件，确保在这些版本的IDE中...
VS自动注释——GhostDoc-附件资源
03-02
VS自动注释——GhostDoc-附件资源
GhostDoc Ent 2022试用版
03-01
- **自动注释生成**：通过分析代码结构和上下文，GhostDoc能自动生成有意义的注释，适用于C#、VB.NET、F#等多种编程语言。 - **多版本支持**：GhostDoc Enterprise 2022覆盖了多个Visual Studio版本，确保与不同开发...
GhostDoc v4.9.15086
01-19
GhostDoc是Visual Studio的一个免费插件，可以帮助开发人员编写XML格式的注释文档。
GhostDoc.v5.9.18070
08-22
GhostDoc.v5.9.18070亲测Win10 2010 13 15都可用免费免费
GhostDoc.v2018.1.18330.VS2017.Extension
01-11
GhostDoc是Visual Studio的一个免费插件，可以帮助开发人员编写XML格式的注释文档。
GhostDoc Pro v4.5.13017
04-17
已经注册的GhostDoc专业版本，测试工作正常有效！！
GhostDoc_Pro_v5.3.16270
11-30
GhostDoc_Pro_v5.3.16270
通过GhostDoc实现自定义方法概要（summary）
weixin_34326179的博客
04-09 128
首先是下载GhostDoc 　　来自园友：http://www.cnblogs.com/VAllen/p/GhostDocPro49.html 修改模板 　　安装好后，修改下模板，工具>GhostDoc Pro>Options>GhostDoc Pro>Rules>Methods>Rule template，编辑模板 　　我设置后整个导出...
GhostDoc 安装与配置
cuibinmo3519的博客
06-24 258
1、GhostDoc1.2.1简介 GhostDoc 是一个基于Visual Studio的 XML 文档注释生成器，相比 NDoc 而言它更可以帮助你自动生成大量令人厌烦的相似的描述。 2、安装（for VS2005）...
VS工具--GhostDoc
赵栎安
09-21 706
VS工具--GhostDoc 一、介绍： GhostDoc是Visual Studio的一个免费插件，可以帮助开发人员编写XML格式的注释文档。 C#中XML格式的文档注释好处多多：Visual Studio会在很多地方显示这些注释内容（例如，编辑器的工具提示或对象浏览器），还有一些工具（比如NDoc或微软的文档工具Sandcastle...
ghostdoc enterprise for vs2019下载
最新发布
12-17
GhostDoc Enterprise for VS2019是一个用于提高代码文档化效率的Visual Studio 2019插件。它可以快速生成代码注释、XML文档和代码模板，帮助开发人员节省编写和维护文档的时间和精力。 要下载GhostDoc Enterprise for VS2019，可以通过以下步骤进行操作： 1. 打开任何Web浏览器，如Chrome、Firefox或Edge等。 2. 在搜索栏中输入“GhostDoc Enterprise for VS2019下载”。 3. 按下“Enter”键或点击搜索按钮进行搜索。 4. 在搜索结果页面中，找到GhostDoc官方网站或可靠的第三方软件下载网站。 5. 根据搜索结果，选择适合您操作系统和开发环境的版本。 6. 点击下载按钮或链接，开始下载插件的安装程序。 7. 下载完成后，双击运行安装程序。 8. 按照安装程序的指示，选择安装路径和其他自定义选项。 9. 等待安装程序完成插件的安装过程。 10. 启动Visual Studio 2019，插件将自动集成到编程环境中。 GhostDoc Enterprise for VS2019下载后，您就可以享受其提供的快速生成代码注释和文档的功能，从而提高代码质量和开发效率。记得定期检查官方网站或订阅该插件的更新以获取最新版本和功能。祝您使用愉快！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值