c#类图生成器

我不是女神ヾ 2022-08-13 13:51 144阅读 0赞

原文：[http://www.codeproject.com/Articles/834517/Class-Diagram-Generator?msg=4932808\#xx4932808xx][http_www.codeproject.com_Articles_834517_Class-Diagram-Generator_msg_4932808_xx4932808xx]

作者是个老外，东西不是很难，基本都是反射，但是做出这样的工具，想法很好，便于开发人员快速了解dll文件内部结构，要给一个大大的赞！！！

下面是我测试的一个dll文件，且看生成的图片效果：

![SouthEast][]

这仅仅是其中一张图，很明了吧。

原文内容摘录如下：

## Introduction ##

This article targets class diagram generation and the in-ability of Visual Studio to export individual or all class diagrams as single files. We will look at Assemblies and how to get information like Fields, Properties, Methods and Events back from them.   
  
![Screenshot.PNG][]

[Download ClassDiagramGen\_EXE.zip][Download ClassDiagramGen_EXE.zip]

[Download source][]

## Background ##

While all developers hate documentation and repetitive tasks it is still a part of our sometimes daily tasks.

Yes there are tools out there that ease the pain like Ghost Doc or Sandcastle Help Builder, but none of them actually generate class diagrams as well. The Code Project too houses a couple of class diagram generators but what makes this one different? Well... I'd say the ability to create a project with multiple entries pointing to dll's or exe that you wish to dump to class diagrams. This article will describe how I went about analyzing the dll or exe and how one then generates the class diagrams. Another feature of this code is to point it to the code directory and add remarks to the class headers; assisting with CHM generation that contains a visual representation of your class.

## Using the code ##

Analyzing a .NET dll or exe.  
  
\[The following code is found in CDGenerator.cs\]

![minus.gif][]  Collapse  |  [Copy Code][]

/// <summary>
            /// Analyzes the DLL.
            /// </summary>
            /// <param name="dllLocation">The DLL location.</param>
            /// <param name="excludeServices">if set to <c>true</c> [exclude services].</param>
            /// <param name="excludeCLR">if set to <c>true</c> [exclude color].</param>
            public static void AnalyzeDLL(string dllLocation, bool excludeServices = false, bool excludeCLR = true)
            {
                string assemblyNameSpace = "";
                Type currentType = null;
                Type[] typesFound = null;
                ClassList = new List<ClassInfo>();
                CDAssembly = null;
    
                try
                {
                    if (dllLocation != string.Empty && File.Exists(dllLocation))
                    {
                        CDAssembly = Assembly.LoadFrom(dllLocation);
                        if (CDAssembly.FullName != "")
                        {
                            assemblyNameSpace = CDAssembly.FullName.Substring(0, CDAssembly.FullName.IndexOf(","));
    
                            typesFound = CDAssembly.GetTypes();
    
                            if (typesFound != null)
                            {
                                foreach (var type in typesFound)
                                {
                                    if (type.Namespace != null)
                                    {
                                        if (type.IsNotPublic)
                                        {
                                            continue;
                                        }
                                        else
                                        {
                                            //Excludes Meta data classes and only generate for the current namespace
                                            if (!type.FullName.Contains("Metadata") && type.Namespace.Contains(assemblyNameSpace))
                                            {
                                                if (excludeServices && type.FullName.Contains("Service."))
                                                {
                                                    continue;
                                                }
    
                                                //Exclude weird naming conventions.. usually generated classes not coded by a developer
                                                if (!type.FullName.Contains("<") && !type.FullName.Contains(">"))
                                                {
                                                    currentType = type;
                                                    ClassList.Add(new ClassInfo(Path.GetFileName(dllLocation), type, excludeCLR));
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(string.Format("{0}: {1}", currentType.Name, ex.Message));
                    throw ex;
                }
            }

Have a look at the `AnalyzeDLL `method above. You will see a few helper classes used inside.  
`ClassInfo` : Stores information like Class Type, Name and a List of `BasicInfo` found inside the dll or exe.  
`BasicInfo `:  Stores the info type (e.g. Fields, Properties, Constructor, Methods or Events).

The code starts by setting a couple of variable and doing a couple of checks to ensure we actually passed it a valid location to the dll or exe to analyze.  
  
The actual work of loading the dll or exe into memory is done by the following command.

![minus.gif][]  Collapse  |  [Copy Code][]

CDAssembly = Assembly.LoadFrom(dllLocation);

I use `Assembly.LoadFrom()` to ensure that we don't get any errors with referenced assemblies that possibly lay in the same directory as the loaded file. This is generally the problem when loading a dll or exe with Assembly.Load().  
  
To ensure that the file is actually loaded a check is done on the assemblies full name after wich the namespace is recorded into the `assemblyNameSpace `variable.

A array of types are extracted from the assembly by using the GetTypes() method on our `CDAssembly`.

Further checks are done to see that types are actually found and that they are publically accessible.  
Meta data is excluded and a check is done that we only look at methods in the main Namespace.

If all these checks pass the current type is added to the `ClassList `where a new `ClassInfo `item is created.

![minus.gif][]  Collapse  |  [Copy Code][]

ClassList.Add(new ClassInfo(Path.GetFileName(dllLocation), currentType, excludeCLR));

By looking closer at the `ClassInfo `constructor you will find that a check is done on the type of class (e.g. Class, Interface, AbstractClass, Enum or Struct).

Once we know what type the class is the `GetMoreInfo()` method is called. This method finds all the Properties, Fields, Constructors, Methods and Events.

All of these are found in the same fashion.

Let's have a look at how the Fields are found:

![minus.gif][]  Collapse  |  [Copy Code][]

FieldInfo[] fieldInfos = referenceType.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.CreateInstance);

An array is built up by checking the assembly type and calling the GetMethods() method. This holds true for Fields(GetFields()), Properties (GetProperties()) etc. Flags are set to Public , Static , Instance or CreateInstance.

![minus.gif][]  Collapse  |  [Copy Code][]

if (methodInfos != null && methodInfos.Length > 0)
                    {
                        foreach (MethodInfo methodInfo in methodInfos)
                        {
                            //Only add custom methods. Don't show built in DotNet methods
                            if (excludeCLR && methodInfo.Module.ScopeName != ReferenceFileName)
                            {
                                continue;
                            }
                            else
                            {
                                ClassInformation.Add(new BasicInfo(BasicInfo.BasicInfoType.Methods, methodInfo.Name, methodInfo.ReturnType));
                            }
                        }
                    }

Once the array has been built up a check is done to check for nulls and that the array actually contains records.  
When the check passes we loop through all the methods found whilst checking if the method falls within the scope of the file passed and if built in .NET fields must be excluded. An example of a built in .NET method would be ToString() or GetType().

Generating a Class Diagram

![minus.gif][]  Collapse  |  [Copy Code][]

public static void GeneratesClassDiagram(ClassInfo classInfo, string outputPath, bool includeProperties = true, bool includeMethods = true, bool includeEvents = true, bool includeFields = true, bool includeConstructor = true)
            {... }

![HashType.png][] Now that we have a Class (`ClassInfo`) with lists of all its Constructor, Fields, Properties,  Methods and Events we can actually generate an class diagram image.  
 This is all done by the `GeneratesClassDiagram()` method contained in the `CDGenerator`   Class.  
  
 A helper method and class is used inside GeneratesClassDiagram.   
 `CalculateSize `: Calculates the image size for the new class diagram based on how many  constructors, fields, properties, methods and events are present.

`RoundedRectangle `:  This class creates a graphic path for GDI+ to draw. It aids with calculating  the rounded corners based on the given width, height and diameter.   
  
Graphics are drawn in 'Layers' to represent the class box and its shadow along with a gradient title containing the class name and type. Based on configuration settings each class type can have a different color.

AntiAliasing is applied to enhance text readability.

![minus.gif][]  Collapse  |  [Copy Code][]

//Enable AntiAliasing
    g.TextRenderingHint = TextRenderingHint.AntiAlias;

Finally when all the 'Layers' are drawn; a size comparison is done to avoid saving empty class diagrams.

Remarking the Code

Remarking the code is done by calling the `RemarkAllImages()` method.  
It takes the code path and image path as variables and then proceeds to "Remark" all classes in code that have a resulting class diagram image.

![minus.gif][]  Collapse  |  [Copy Code][]

/// <summary>
            /// Remarks all images.
            /// </summary>
            /// <param name="codePath">The code path.</param>
            /// <param name="imagesPath">The images path.</param>
            public static void RemarkAllImages(string codePath, string imagesPath)
            {
                string currentClassName = "";
                string remarkTemplate = Properties.Settings.Default.RemarkTemplate;
                string searchString = "";
                string currentClassRemark = "";
    
                int startIndex = 0;
                StreamReader sr;
                StreamWriter sw;
                FileInfo currentCodeFile;
                string currentCodeFileText = "";
                string outCodeFileText = "";
                if (Directory.Exists(imagesPath))
                {
                    DirectoryInfo codeDirInfo = new DirectoryInfo(codePath);
    
                    FileUtils.GetAllFilesInDir(codeDirInfo, "*.cs");
    
                    foreach (string fileName in Directory.GetFiles(imagesPath, "*.png"))
                    {
                        startIndex = 0;
                        try
                        {
                            currentClassName = Path.GetFileName(fileName).Replace(".png", "");
                            currentCodeFile = FileUtils.files.Where(f => f.Name == string.Format("{0}.cs", currentClassName)).FirstOrDefault();
    
                            if (currentCodeFile != null)
                            {
                                using (sr = new StreamReader(currentCodeFile.FullName))
                                {
                                    currentCodeFileText = sr.ReadToEnd();
                                    sr.Close();
    
                                    //Finding the class description logic goes here. In essence it results in something like this:
                                    //searchString = string.Format("public {0}", currentClassName);
                                    
    
                                    startIndex = currentCodeFileText.IndexOf(searchString);
    
                                    //Add the remark
                                    currentClassRemark = string.Format("{0}{1}\t", string.Format(remarkTemplate, currentClassName), Environment.NewLine);
    
                                    if (!currentCodeFileText.Contains(currentClassRemark))
                                    {
                                        outCodeFileText = currentCodeFileText.Insert(startIndex, currentClassRemark);
    
                                        using (sw = new StreamWriter(currentCodeFile.FullName, false))
                                        {
                                            sw.WriteLine(outCodeFileText);
                                            sw.Close();
                                        }
                                    }
    
                                    if (RemarkDone != null)
                                    {
                                        RemarkDone(currentClassName);
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                            ErrorOccurred(ex, null);
                        }
                    }
                }
            }

Have a look at the `RemarkAllImages `method above.

It makes use of the FileUtils class to find all C\# code files:

![minus.gif][]  Collapse  |  [Copy Code][]

FileUtils.GetAllFilesInDir(codeDirInfo, "*.cs");

The method has a loop that then gets all png files and with the help of LINQ it filters out all code files that do not have a resulting image.

![minus.gif][]  Collapse  |  [Copy Code][]

FileUtils.files.Where(f => f.Name == string.Format("{0}.cs", currentClassName)).FirstOrDefault();

A bit of logic is applied to build up a search string based on the class type.  
The search string then finds the class header and adds the remark above that using the remark template.

Once the string is appended it is written back to the code file.

## Points of Interest ##

We already use this tool quite extensively at our place of work and it is in the process of being expanded to include EF helper class generation, SQL Database commenting from comments in code and database dictionary generation. Hopefully one-day I can upload it here as a tool that can assist an even greater audience.

[http_www.codeproject.com_Articles_834517_Class-Diagram-Generator_msg_4932808_xx4932808xx]: http://www.codeproject.com/Articles/834517/Class-Diagram-Generator?msg=4932808#xx4932808xx
[SouthEast]: /images/20220810/5187f844f9c944a2853083ca29348417.png
[Screenshot.PNG]: /images/20220810/4c83210cad014663a6dd2486cdcc2dfa.png
[Download ClassDiagramGen_EXE.zip]: http://www.codeproject.com/KB/DLL/834517/ClassDiagramGen_EXE.zip
[Download source]: http://www.codeproject.com/KB/DLL/834517/ClassDiagramGen_Source.zip
[minus.gif]: /images/20220810/1321c47f15c44be2a3215a1cb1ef43c0.png
[Copy Code]: http://www.codeproject.com/Articles/834517/Class-Diagram-Generator?msg=4932808#
[HashType.png]: /images/20220810/da1c96567d964c5abdafe4ffdd0636d1.png

发表评论取消回复

表情：

评论列表（有 0 条评论，144人围观）

还没有评论，来说两句吧...

相关阅读

相关 D3.js（三）：线段生成器、区域生成器、弧生成器、符号生成器、弦生成器、对角线生成器、饼图、弦图

线段生成器 ![在这里插入图片描述][e22372b6a8694429aee04a29eaa8178c.png_pic_center] let lines =

￡神魔★判官ぃ/ 2024年04月06日 10:16/ 0 赞/ 34 阅读

相关 ID生成器工具类UUIDUtil

import cn.hutool.core.lang.UUID; / ID生成器工具类 / public c

缺乏、安全感/ 2024年03月17日 22:31/ 0 赞/ 50 阅读

相关 UML图类图

软件开发过程中经常会遇到UML建模，那么你对UML符号是否熟悉，这里向大家简单介绍一下UML类图符号，每种符号都有不同的意义，希望通过本节的学习你对UML类图符

超、凢脫俗/ 2022年11月22日 02:49/ 0 赞/ 256 阅读

相关 c 语言随机值的生成器,C 语言随机数生成器的实现分析

原标题：C 语言随机数生成器的实现分析 (点击上方公众号，可快速关注) 来源：伯乐在线 - 卢亮如需转载，发送「转载」二字查看说明本文是为了记录和澄清一个由来已久

柔光的暖阳◎/ 2022年10月15日 05:56/ 0 赞/ 148 阅读

相关【python应用】 gif动图简易生成器

【python应用】 gif动图简易生成器 1、背景 2、代码 3、打包 4、使用方法 5、资源 1、背景有很多场景，我们需要用g

雨点打透心脏的1/2处/ 2022年10月05日 00:57/ 0 赞/ 247 阅读

相关 C#类生成器

今天上课的时候，出于兴趣，自己要搭建的框架需要数据库返回的类为传参类型，要用到数据库的列为成员变量，所以就花了一节课时间写了一个简单

矫情吗；*/ 2022年08月26日 11:12/ 0 赞/ 108 阅读

相关 UML图——类图

什么是类？类是具有相同属性和方法的一组对象的抽象，是面向对象设计中的基本单位。比如老虎、鱼、鸟等这些动物都有生命，都需要进行新陈代谢

痛定思痛。/ 2022年08月25日 02:20/ 0 赞/ 307 阅读

相关 c#类图生成器

原文：[http://www.codeproject.com/Articles/834517/Class-Diagram-Generator?msg=4932808\xx493

我不是女神ヾ/ 2022年08月13日 13:51/ 0 赞/ 145 阅读

相关 UML图-类图

类图类图主要包含两部分：类定义和类关系类定义：用来表示某个类类关系：用来表示类之间的关系类定义类定义图包含三部分：类名称、属性区、方法区

た入场券/ 2022年05月21日 05:38/ 0 赞/ 342 阅读

相关 SQL条件生成器类（C#）

在实际项目中，程序与数据库的交互离不开SQL，当然我们可以采用O/R或LINQ等技术来避开SQL的拼写，但是由于种种原因，在程序中拼写SQL还相当的多。在程序中拼写WHERE条

电玩女神/ 2022年01月27日 03:17/ 0 赞/ 225 阅读