利用反射生成介面列表

来源:https://www.cnblogs.com/zhouandke/archive/2018/12/18/10135438.html
-Advertisement-
Play Games

公司產品對外公佈的介面, 評審後才能發佈, 然後要求生成介面文檔(去除註釋, 這樣更能檢查介面命名是否合理). 之前用的是微軟的一個免費工具, 但好久都沒有更新了, 對新一點的C#語法不支持, 生成的文檔是錯誤的, 如果不想手動從代碼複製方法簽名, 只能手寫一個工具了 這個段代碼以滿足公司要求來編寫 ...


      公司產品對外公佈的介面, 評審後才能發佈, 然後要求生成介面文檔(去除註釋, 這樣更能檢查介面命名是否合理).

      之前用的是微軟的一個免費工具, 但好久都沒有更新了, 對新一點的C#語法不支持, 生成的文檔是錯誤的, 如果不想手動從代碼複製方法簽名, 只能手寫一個工具了

      這個段代碼以滿足公司要求來編寫, 沒有多餘精力去優化代碼了, 其中用到了擴展方法導致很多地方不合理. 但是總歸不用手動寫文檔了, 避免了很多無意義的工作.

 

　　

    // First: Install-Package NPOI
    using NPOI.XWPF.UserModel;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Reflection;

    public static class InterfaceExportHelper
    {
        static BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static;

        public static int spaceIncreaseCountOfEachLevel = 4;
        public static string CSharpClassColor = "2B93AF";
        public static string CSharpKeywordColor = "0000FF";
        public static bool IsShowParameterDefaultValue = false;

        public static void SeparateInterfaceToDocument(string assemblyPath, string outputDocPath)
        {
            var assembly = Assembly.LoadFrom(assemblyPath);
            var types = assembly.GetTypes().OrderBy(t => t.Name);
            XWPFDocument doc = new XWPFDocument();
            var spaceCount = 0;
            foreach (var type in types)
            {
                if (type.IsClass)
                {
                    var p = DealClass(type, doc, spaceCount);
                    if (p != null)
                    {
                        p.AppendCarriageReturn();
                    }
                }
                else if (type.IsEnum)
                {
                    var p = DealEnum(type, doc, spaceCount);
                    if (p != null)
                    {
                        p.AppendCarriageReturn();
                    }
                }
                else if (type.IsValueType)
                {
                    var p = DealStruct(type, doc, spaceCount);
                    if (p != null)
                    {
                        p.AppendCarriageReturn();
                    }
                }
            }

            var fs = new FileStream(outputDocPath, FileMode.Create);
            doc.Write(fs);
            fs.Close();
        }



        static XWPFParagraph DealClass(Type type, XWPFDocument doc, int spaceCount)
        {
            if (!type.IsPublic)
            {
                return null;
            }
            //if (type.IsNestedPrivate)
            //{
            //    return null;
            //}
            if (type.Name.StartsWith("<"))
            {
                return null;
            }
            var p = doc.CreateParagraph();
            p.AppendSpaces(spaceCount);
            if (type.IsPublic)
            {
                p.AppendKeywordCSharp("public");
            }
            else
            {
                p.AppendKeywordCSharp("internal");
            }
            p.AppendSpaces();

            if (type.IsAbstract && type.IsSealed)
            {
                p.AppendKeywordCSharp("static");
                p.AppendSpaces();
            }
            else if (type.IsSealed)
            {
                p.AppendKeywordCSharp("sealed");
                p.AppendSpaces();
            }
            else if (type.IsAbstract)
            {
                p.AppendKeywordCSharp("abstract");
                p.AppendSpaces();
            }

            p.AppendKeywordCSharp("class");
            p.AppendSpaces();
            p.AppendClassCSharp(type.Name);
            bool hasBaseType = false;
            if (type.BaseType != null && type.BaseType != typeof(object))
            {
                hasBaseType = true;
                p.AppendText(" : ");
                DispalyType(type.BaseType, p);
            }
            bool isFisrtInterface = true;
            foreach (var interfaceType in type.GetInterfaces())
            {
                if (!hasBaseType)
                {
                    p.AppendText(" : ");
                }
                if (!isFisrtInterface || hasBaseType)
                {
                    p.AppendText(", ");
                }
                DispalyType(interfaceType, p);
                isFisrtInterface = false;
            }
            p.AppendCarriageReturn();

            var tempSpaceCount = spaceCount;// - spaceIncreaseCountOfEachLevel > 0 ? spaceCount - spaceIncreaseCountOfEachLevel : 0;
            p.AppendSpaces(tempSpaceCount);
            p.AppendText("{");
            p.AppendCarriageReturn();



            bool hasAddedSomething = false;
            foreach (var filedInfo in type.GetFields(bindingFlags))
            {
                if (!filedInfo.IsPublic && !filedInfo.IsFamily)
                {
                    continue;
                }
                DealFieldInfo(filedInfo, p, spaceCount + spaceIncreaseCountOfEachLevel);
                hasAddedSomething = true;
            }
            if (hasAddedSomething) p.AppendCarriageReturn();




            hasAddedSomething = false;
            foreach (ConstructorInfo constructorInfo in type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
            {
                if (DealConstructor(constructorInfo, p, spaceCount + spaceIncreaseCountOfEachLevel) == true)
                {
                    hasAddedSomething = true;
                }
            }
            if (hasAddedSomething) p.AppendCarriageReturn();



            hasAddedSomething = false;
            foreach (var propertyInfo in type.GetProperties(bindingFlags))
            {
                if (DealProperty(propertyInfo, p, spaceCount + spaceIncreaseCountOfEachLevel) == true)
                {
                    hasAddedSomething = true;
                }
            }
            if (hasAddedSomething) p.AppendCarriageReturn();



            hasAddedSomething = false;
            foreach (MethodInfo method in type.GetMethods(bindingFlags))
            {
                if (DealMethod(method, p, spaceCount + spaceIncreaseCountOfEachLevel) == true)
                {
                    hasAddedSomething = true;
                }
            }
            if (hasAddedSomething) p.AppendCarriageReturn();
            p.RemoveRun(p.Runs.Count - 1);
            p.AppendSpaces(tempSpaceCount);
            p.AppendText("}");
            return p;
        }

        static bool DealFieldInfo(FieldInfo fieldInfo, XWPFParagraph p, int spaceCount)
        {
            if (!(fieldInfo.IsPublic || fieldInfo.IsFamily))
            {
                return false;
            }
            //if (fieldInfo.IsPrivate)
            //{
            //    return false;
            //}
            p.AppendSpaces(spaceCount);
            var eventFieldList = new List<FieldInfo>();

            if (fieldInfo.IsPublic)
            {
                p.AppendKeywordCSharp("public");
            }
            else if (fieldInfo.IsFamily)
            {
                p.AppendKeywordCSharp("protected");
            }
            else if (fieldInfo.IsAssembly)
            {
                p.AppendKeywordCSharp("internal");
            }
            else if (fieldInfo.IsFamilyOrAssembly)
            {
                p.AppendKeywordCSharp("internal protected");
            }
            p.AppendSpaces();

            if (fieldInfo.IsInitOnly)
            {
                p.AppendKeywordCSharp("readonly");
                p.AppendSpaces();
            }

            if (fieldInfo.IsStatic)
            {
                p.AppendKeywordCSharp("static");
                p.AppendSpaces();
            }

            DispalyType(fieldInfo.FieldType, p);
            p.AppendSpaces();

            p.AppendText(fieldInfo.Name);
            p.AppendText(";");
            p.AppendCarriageReturn();
            return true;
        }

        static bool DealProperty(PropertyInfo propertyInfo, XWPFParagraph p, int spaceCount)
        {
            AccessorModifier? getterAccessorModifier = null, setterAccessorModifier = null;
            if (propertyInfo.CanRead)
            {
                getterAccessorModifier = GetAccessorModifier(propertyInfo.GetMethod);
            }
            if (propertyInfo.CanWrite)
            {
                setterAccessorModifier = GetAccessorModifier(propertyInfo.SetMethod);
            }

            var mainAccessorModifier = GetHighAccessorModifier(getterAccessorModifier, setterAccessorModifier);

            if (!(mainAccessorModifier == AccessorModifier.Public || mainAccessorModifier == AccessorModifier.Protected))
            {
                return false;
            }

            p.AppendSpaces(spaceCount);

            p.AppendKeywordCSharp(AccessorModifierToString(mainAccessorModifier));
            p.AppendSpaces();

            DispalyType(propertyInfo.PropertyType, p);
            p.AppendSpaces();

            p.AppendText(propertyInfo.Name);
            p.AppendSpaces();

            p.AppendText("{");
            if (propertyInfo.CanRead && getterAccessorModifier >= AccessorModifier.Protected)
            {
                p.AppendSpaces();
                if (getterAccessorModifier != mainAccessorModifier)
                {
                    p.AppendKeywordCSharp(AccessorModifierToString(getterAccessorModifier.Value));
                    p.AppendSpaces();
                }
                p.AppendKeywordCSharp("get;");
            }
            if (propertyInfo.CanWrite && setterAccessorModifier >= AccessorModifier.Protected)
            {
                p.AppendSpaces();
                if (setterAccessorModifier != mainAccessorModifier)
                {
                    p.AppendKeywordCSharp(AccessorModifierToString(setterAccessorModifier.Value));
                    p.AppendSpaces();
                }
                p.AppendKeywordCSharp("set;");
            }
            p.AppendSpaces();
            p.AppendText("}");
            p.AppendCarriageReturn();
            return true;
        }

        static bool DealConstructor(ConstructorInfo constructorInfo, XWPFParagraph p, int spaceCount)
        {
            if (!(constructorInfo.IsPublic || constructorInfo.IsFamily))
            {
                return false;
            }

            //if (constructorInfo.IsPrivate)
            //{
            //    return false;
            //}

            p.AppendSpaces(spaceCount);
            if (constructorInfo.IsPublic)
            {
                p.AppendKeywordCSharp("public");
            }
            else if (constructorInfo.IsFamily)
            {
                p.AppendKeywordCSharp("protected");
            }
            else if (constructorInfo.IsAssembly)
            {
                p.AppendKeywordCSharp("internal");
            }
            else if (constructorInfo.IsFamilyOrAssembly)
            {
                p.AppendKeywordCSharp("internal protected");
            }
            p.AppendSpaces();


            if (constructorInfo.IsAbstract)
            {
                p.AppendKeywordCSharp("abstract");
                p.AppendSpaces();
            }

            p.AppendClassCSharp(constructorInfo.DeclaringType.Name);
            p.AppendText("(");
            bool isFirst = true;
            foreach (var parameterInfo in constructorInfo.GetParameters())
            {
                if (!isFirst)
                {
                    p.AppendText(", ");
                }
                DispalyType(parameterInfo.ParameterType, p);
                p.AppendSpaces();
                p.AppendText(parameterInfo.Name);
                isFirst = false;
            }
            p.AppendText(");");
            p.AppendCarriageReturn();
            return true;
        }

        static bool DealMethod(MethodInfo method, XWPFParagraph p, int spaceCount)
        {
            if (!(method.IsPublic || method.IsFamily))
            {
                return false;
            }
            //if (method.IsPrivate)
            //{
            //    return false;
            //}

            if (method.Name.StartsWith("get_") || method.Name.StartsWith("set_"))
            {
                return false;
            }
            p.AppendSpaces(spaceCount);
            if (method.Name == "Finalize")
            {
                p.AppendText("~");
                p.AppendClassCSharp(method.DeclaringType.Name);
                p.AppendText("();");
                p.AppendCarriageReturn();
                return true;
            }

            if (method.IsPublic)
            {
                p.AppendKeywordCSharp("public");
            }
            else if (method.IsFamily)
            {
                p.AppendKeywordCSharp("protected");
            }
            else if (method.IsAssembly)
            {
                p.AppendKeywordCSharp("internal");
            }
            else if (method.IsFamilyAndAssembly)
            {
                p.AppendKeywordCSharp("internal protected");
            }
            p.AppendSpaces();

            if (method.IsStatic)
            {
                p.AppendKeywordCSharp("static");
                p.AppendSpaces();
            }
            // a. override parent class method, 
            // b.implement a interface
            // both have Final & virtual keywords
            bool isSealed = false;
            if (method.IsFinal && method != method.GetBaseDefinition())
            {
                p.AppendKeywordCSharp("sealed");
                p.AppendSpaces();
                isSealed = true;
            }
            if (method.IsVirtual)
            {
                if (method != method.GetBaseDefinition())
                {
                    p.AppendKeywordCSharp("override");
                }
                else
                {
                    if (!method.IsFinal)
                    {
                        p.AppendKeywordCSharp("virtual");
                    }
                }
                p.AppendSpaces();
            }
            if (method.IsAbstract)
            {
                p.AppendKeywordCSharp("abstract");
                p.AppendSpaces();
            }

            DispalyType(method.ReturnType, p);
            p.AppendSpaces();

            p.AppendText(method.Name);
            p.AppendText("(");


            bool isFirst = true;
            foreach (var parameterInfo in method.GetParameters())
            {
                if (!isFirst)
                {
                    p.AppendText(", ");
                }

                if (parameterInfo.IsOut)
                {
                    p.AppendKeywordCSharp("out");
                    p.AppendSpaces();
                }
                else if (parameterInfo.IsIn)
                {
                    p.AppendKeywordCSharp("in");
                    p.AppendSpaces();
                }
                else if (parameterInfo.ParameterType.IsByRef)
                {
                    p.AppendKeywordCSharp("ref");
                    p.AppendSpaces();
                }

                DispalyType(parameterInfo.ParameterType, p);
                p.AppendSpaces();
                p.AppendText(parameterInfo.Name);
                if (IsShowParameterDefaultValue && parameterInfo.HasDefaultValue)
                {
                    p.AppendSpaces();
                    p.AppendText("=");
                    p.AppendSpaces();
                    if (parameterInfo.DefaultValue == null)
                    {
                        p.AppendText("null");
                    }
                    else if (parameterInfo.ParameterType == typeof(string))
                    {
                        p.AppendText("\"");
                        p.AppendText(parameterInfo.DefaultValue.ToString());
                        p.AppendText("\"");
                    }
                    else if (parameterInfo.ParameterType == typeof(char))
                    {
                        p.AppendText("'");
                        p.AppendText(parameterInfo.DefaultValue.ToString());
                        p.AppendText("'");
                    }
                    else if (parameterInfo.ParameterType.IsEnum)
                    {
                        DispalyType(parameterInfo.ParameterType, p);
                        p.AppendText(".");
                        p.AppendText(parameterInfo.DefaultValue.ToString());
                    }
                    else
                    {
                        p.AppendText(parameterInfo.DefaultValue.ToString());
                    }
                }
                isFirst = false;
            }

            p.AppendText(");");
            p.AppendCarriageReturn();
            return true;
        }

        static void DispalyType(Type type, XWPFParagraph p)
        {
            // Nullable<> need change to like int?
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                DispalyType(type.GetGenericArguments()[0], p);
                p.AppendText("?");
                return;
            }

            var typeName = type.Name;
            if (typeName.Contains("`"))
            {
                typeName = typeName.Substring(0, typeName.LastIndexOf('`'));
            }
            typeName = ChangeToNormalName(typeName);
            p.AppendClassCSharp(typeName);
            if (type.IsGenericType)
            {
                p.AppendText("<");
                bool isFisrt = true;
                foreach (var genericArgumentType in type.GetGenericArguments())
                {
                    if (!isFisrt)
                    {
                        p.AppendText(", ");
                    }
                    DispalyType(genericArgumentType, p);
                    isFisrt = false;
                }
                p.AppendText(">");
            }
        }

        static string ChangeToNormalName(string typeName)
        {
            typeName = typeName.TrimEnd('&');
            switch (typeName)
            {
                case "Void": return "void";
                case "Object": return "object";
                case "String": return "string";
                case "Boolean": return "bool";
                case "Byte": return "byte";
                case "Char": return "char";
                case "Int16": return "short";
                case "Int32": return "int";
                case "Int64": return "long";
                case "Single": return "float";
                case "Double": return "double";
                default:
                    return typeName;
            }
        }

        static XWPFParagraph DealEnum(Type type, XWPFDocument doc, int spaceCount)
        {
            if (type.IsNestedPrivate)
            {
                return null;
            }
            var p = doc.CreateParagraph();
            if (type.GetCustomAttribute<FlagsAttribute>() != null)
            {
                p.AppendSpaces(spaceCount);
                p.AppendText("[");
                p.AppendKeywordCSharp("Flags");
                p.AppendText("]");
                p.AppendCarriageReturn();
            }
            p.AppendSpaces(spaceCount);
            if (type.IsPublic)
            {
                p.AppendKeywordCSharp("public");
            }
            else if (type.IsNestedAssembly)
            {
                p.AppendKeywordCSharp("internal");
            }
            p.AppendSpaces();

            p.AppendKeywordCSharp("enum");
            p.AppendSpaces();
            p.AppendClassCSharp(type.Name);

            var tempSpaceCount = spaceCount;// - spaceIncreaseCountOfEachLevel > 0 ? spaceCount - spaceIncreaseCountOfEachLevel : 0;
            p.AppendCarriageReturn();
            p.AppendSpaces(tempSpaceCount);
            p.AppendText("{");
            p.AppendCarriageReturn();

            foreach (var enumName in type.GetEnumNames())
            {
                p.AppendSpaces(spaceCount + spaceIncreaseCountOfEachLevel);
                p.AppendText(enumName);
                p.AppendText(",");
                p.AppendCarriageReturn();
            }
            p.AppendSpaces(tempSpaceCount);
            p.AppendText("}");
            return p;
        }

        static XWPFParagraph DealStruct(Type type, XWPFDocument doc, int spaceCount)
        {
            if (!type.IsPublic)
            {
                return null;
            }
            //if (type.IsNestedPrivate)
            //{
            //    return null;
            //}
            if (type.Name.StartsWith("<"))
            {
                return null;
            }
            var p = doc.CreateParagraph();
            p.AppendSpaces(spaceCount);
            if (type.IsPublic)
            {
                p.AppendKeywordCSharp("public");
            }
            else
            {
                p.AppendKeywordCSharp("internal");
            }
            p.AppendSpaces();


            p.AppendKeywordCSharp("struct");
            p.AppendSpaces();
            p.AppendClassCSharp(type.Name);

            bool isFisrtInterface = true;
            foreach (var interfaceType in type.GetInterfaces())
            {
                if (isFisrtInterface)
                {
                    p.AppendText(" : ");
                }
                else
                {
                    p.AppendText(", ");
                }
                DispalyType(interfaceType, p);
                isFisrtInterface = false;
            }
            p.AppendCarriageReturn();

            var tempSpaceCount = spaceCount;// - spaceIncreaseCountOfEachLevel > 0 ? spaceCount - spaceIncreaseCountOfEachLevel : 0;
            p.AppendSpaces(tempSpaceCount);
            p.AppendText("{");
            p.AppendCarriageReturn();



            bool hasAddedSomething = false;
            foreach (var filedInfo in type.GetFields(bindingFlags))
            {
                if (!filedInfo.IsPublic && !filedInfo.IsFamily)
                {
                    continue;
                }
                DealFieldInfo(filedInfo, p, spaceCount + spaceIncreaseCountOfEachLevel);
                hasAddedSomething = true;
            }
            if (hasAddedSomething) p.AppendCarriageReturn();




            hasAddedSomething = false;
            foreach (ConstructorInfo constructorInfo in type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
            {
                if (DealConstructor(constructorInfo, p, spaceCount + spaceIncreaseCountOfEachLevel) == true)
                {
                    hasAddedSomething = true;
                }
            }
            if (hasAddedSomething) p.AppendCarriageReturn();



            hasAddedSomething = false;
            foreach (var propertyInfo in type.GetProperties(bindingFlags))
            {
                if (DealProperty(propertyInfo, p, spaceCount + spaceIncreaseCountOfEachLevel) == true)
                {
                    hasAddedSomething = true;
                }
            }
            if (hasAddedSomething) p.AppendCarriageReturn();



            hasAddedSomething = false;
            foreach (MethodInfo method in type.GetMethods(bindingFlags))
            {
                if (DealMethod(method, p, spaceCount + spaceIncreaseCountOfEachLevel) == true)
                {
                    hasAddedSomething = true;
                }
            }
            if (hasAddedSomething) p.AppendCarriageReturn();
            p.RemoveRun(p.Runs.Count - 1);
            p.AppendSpaces(tempSpaceCount);
            p.AppendText("}");
            return p;
        }

        static AccessorModifier GetAccessorModifier(MethodInfo method)
        {
            if (method.IsPublic)
            {
                return AccessorModifier.Public;
            }
            if (method.IsAssembly)
            {
                return AccessorModifier.Internal;
            }
            if (method.IsFamily)
            {
                return AccessorModifier.Protected;
            }
            if (method.IsFamilyOrAssembly)
            {
                return AccessorModifier.InternalProtected;
            }

            return AccessorModifier.Private;
        }

        static AccessorModifier GetHighAccessorModifier(AccessorModifier? a, AccessorModifier? b)
        {
            // a or b at least have one value
            if (a.HasValue && b.HasValue)
            {
                return (AccessorModifier)Math.Max((int)a.Value, (int)b.Value);
            }
            else if (a.HasValue == false)
            {
                return b.Value;
            }
            else
            {
                return a.Value;
            }
        }

        static string AccessorModifierToString(AccessorModifier accessorModifier)
        {
            switch (accessorModifier)
            {
                case AccessorModifier.Public:
                    return "public";
                case AccessorModifier.Internal:
                    return "internal";
                case AccessorModifier.Protected:
                    return "protected";
                    break;
                case AccessorModifier.InternalProtected:
                    return "internal protected";
                case AccessorModifier.Private:
                    return
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Abp學習筆記(一)
    Application Services Application Services are used to expose domain logic to the presentation layer. An Application Service is called from the present ...
  • C# 動態創建SQL資料庫
    最近在做項目中要求能夠要求動態添加資料庫並建表。具體思路如下 1 提供數據名，根據資料庫創建資料庫 2 自定資料庫與數據表，提供數據表自定與數據類型創建表 創建sqlhelper類，用於資料庫操作 編寫調用函數 最後調用 ...
  • Winform窗體
    這是我之前寫代碼的時候被卡住的一些小知識點，看到這篇博客的人，如果有用，我很高興很夠幫助到你，如果對你沒有幫助，那麼請你路過就好 1.Winform窗體跳轉 Show(非模態顯示) 可以操作其他窗體，在彈出視窗和調用視窗之間隨意切換，比如：彈出Form2窗體了，還是原本的Form窗體進行操作 Sho ...
  • 從Client應用場景介紹IdentityServer4（二）
    本節介紹Client的ClientCredentials客戶端模式，先看下畫的草圖： 一、在Server上添加動態新增Client的API 介面。 為了方便測試，在Server服務端中先添加swagger，添加流程可參考：https://www.cnblogs.com/suxinlcq/p/6757 ...
  • .net MVC使用Aspose.Words 獲取文本域獲取文檔
    controller ...
  • Func與Action
    平時我們如果要用到委托一般都是先聲明一個委托類型，比如： string說明適用於這個委托的方法的返回類型是string類型，委托名Say後面沒有參數，說明對應的方法也就沒有傳入參數。 寫一個適用於該委托的方法： 最後調用: 這裡我們先聲明委托，然後再將方法傳給該委托。有沒有辦法可以不定義委托變數呢？ ...
  • 在Winform中菜單動態添加“最近使用文件”
    最近在做文件處理系統中，要把最近打開文件顯示出來，方便用戶使用。網上資料有說，去遍歷“C:\Documents and Settings\Administrator\Recent”下的最近文檔本。文主要介紹在Winform界面菜單中實現【最近使用的文件】動態菜單的處理，實現一個較為常用的功能。 1 ...
  • Time - Time-interval Measurements
    ```c# public class TimeHelper { private long _start, _stop, _elapsed; /// /// 獲取初始時間戳 /// public void start() { _start = Stopwatch.GetTimestamp(); } /... ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類