dotnet 职业技术学院

Office versions: Office 2019, 2016, 2013, 2010, 2007, 2003, XP and 2000
Applications: Outlook, Word, Excel, PowerPoint, Access, FrontPage, Publisher, Project, MapPoint, InfoPath, Visio, OneNote
IDEs: Visual Studio 2019, 2017, 2015, 2013, 2012 and 2010 (VB.NET, C#, C++)

NetOfficeFw/NetOffice: 🌌 .NET wrapper assemblies for accessing Microsoft Office applications.

Xamarin iOS 部署应用提示 iOS code signing key 失败

Fri, 04 Dec 2020 00:35:41 +0000

在部署 iOS 应用的时候，如果是拉别人的代码，因为被使用了别人的签名，就会提示 Error: iOS code signing key ‘iPhone Developer: lindexi@icloud.com (F56JH45N57)’ not found in keychain. 部署失败。解决方法是替换为自己的账号

原因就是在 csproj 上的 CodesignProvision 属性设置的是别人的签名，可以通过替换为自己的账号解决

在 Xamarin 从零开始部署 iOS 上的 Walterlv.CloudKeyboard 应用博客里面有提到这个问题，只是这篇博客的内容很多，因此就再写一篇

先进入 Mac 版本的 VisualStudio 的首选项的账号里面，添加自己的苹果开发者账户

添加之后选择自己的账号，然后点击确定

接着进入项目中，编辑选项，进入 iOS 捆绑包签名这里，选择好签名标识和预配配置文件

如果不知道如何设置预配配置文件，请看 Xamarin iOS 切换开发者账号之后的签名标识和预配配置文件更新方法

dotnet OpenXML 从文档生成创建文档的代码的库

Fri, 04 Dec 2020 00:31:10 +0000

本文和大家介绍 Serialize.OpenXml.CodeGen 这个支持从某个文档生成用于创建出这个文档的 C# 或 VB 代码的库。作用就是可以让小伙伴在拿到一份模版文件之后，可以通过 Serialize.OpenXml.CodeGen 生成能创建出这份文档的 C# 或 VB 的代码，用于在这份代码上面更改功能，做到创建定制 Docx 或 PPTX 或 Xlsx 文档的功能

这是一个完全开源的库，代码放在 https://github.com/rmboggs/Serialize.OpenXml.CodeGen 欢迎小伙伴访问

这个库的功能就是从 Office 文档里面，如 Excel 文档里面读取文档内容，生成 CodeCompileUnit 对象，通过 CodeCompileUnit 对象可以序列化为 C# 或 VB 代码

如从一个 xlsx 文件创建对应的 C# 代码，可以使用下面代码

假定在 C 盘有一个 Temp 文件夹，这个文件夹里面有一个 Sample1.xlsx 文件，在调用下面代码之后，将会创建了 Sample1.cs 文件

       static void Main(string[] args)
        {
            var sourceFile = new FileInfo(@"C:\Temp\Sample1.xlsx");
            var targetFile = new FileInfo(@"C:\Temp\Sample1.cs");

            using (var source = sourceFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (var xlsx = SpreadsheetDocument.Open(source, false))
                {
                    if (xlsx != null)
                    {
                        var codeString = new StringBuilder();
                        var cs = new CSharpCodeProvider();

                        // This will build the CodeCompileUnit object containing all of
                        // the commands that would create the source code to rebuild Sample1.xlsx
                        var code = xlsx.GenerateSourceCode();

                        // This will convert the CodeCompileUnit into C# source code
                        using (var sw = new StringWriter(codeString))
                        {
                            cs.GenerateCodeFromCompileUnit(code, sw, Cgo);
                        }

                        // Save the source code to the target file
                        using (var target = targetFile.Open(FileMode.Create, FileAccess.ReadWrite))
                        {
                            using (var tw = new StreamWriter(target))
                            {
                                tw.Write(codeString.ToString().Trim());
                            }
                        }
                    }
                }
            }

            Console.ReadKey();
        }

上面代码的核心是 var code = xlsx.GenerateSourceCode(); 可以将 Word 和 PPT 和 Excel 文档转换 CodeCompileUnit 对象，而 CodeCompileUnit 对象可以序列化为 C# 或 VB 代码

上面代码将创建 Sample1.cs 代码，这个代码可以通过 CreatePackage 方法向一个 Stream 里面写入 Sample1.xlsx 文档内容，而写入的方法是通过代码的形式，因此可以通过修改 Sample1.cs 代码定制写入的内容

例如我给的 Sample1.xlsx 只是一个模版，里面有很多内容可以替换，此时就可以修改 Sample1.cs 的代码，将可以替换的逻辑替换为自己的逻辑

本文代码放在github欢迎小伙伴访问

WPF 列表右键菜单比较符合 MVVM 的命令绑定方法

Thu, 03 Dec 2020 12:38:57 +0000

群里小伙伴问我如何在 ListView 的右击的时候知道右击的是哪一项，他想要获取对应的行信息。他使用的是 GridView 做的，于是我告诉他需要自己写 ItemContainerStyle 在 GridViewRowPresenter 里添加右键的逻辑。但是这样写不清真，我问到了他的本质问题其实只是想要做右键菜单。刚好我在写一个测试应用，用于测试我的文件下载库，此时需要用到在右击某一个下载项的时候，拿到当前下载项的信息，给出右键菜单。我不使用小伙伴的逻辑，就按照我自己会采用的写法，我认为这样写比较符合 WPF 框架的设计，下面让我告诉大家我的用法，十分简单

我开源了一个文件下载库，原因是我的几个项目里面都有自己的文件下载库，我想要统一这些文件下载库。开源出去可以让更多小伙伴帮我踩坑，开源项目是 https://github.com/dotnet-campus/dotnetCampus.FileDownloader 欢迎小伙伴使用

我需要写一个简单的界面程序用来测试我这个库，我计划替换掉我现在自己使用的FDM工具，这样我如果自己下载炸了，我就会去修我的库

在使用的时候我发现我需要这样的一个功能，我需要在下载完成之后，自己去找下载到哪个文件夹，因此我期望能右击对应的下载项的时候，可以给出右键菜单，点击一下就能打开下载的文件所在的文件夹或者打开下载的文件

刚好我的下载界面用了 GridView 用来显示所有的下载项，代码如下

<ListView ItemsSource="{Binding Path=DownloadFileInfoList}">
    <ListView.View>
        <GridView>
            <GridViewColumn Width="200" Header="文件名" DisplayMemberBinding="{Binding FileName}" />
            <GridViewColumn Width="100" Header="大小" DisplayMemberBinding="{Binding FileSize}"/>
            <GridViewColumn Width="200" Header="进度" DisplayMemberBinding="{Binding DownloadProcess}"/>
            <GridViewColumn Width="100" Header="下载速度" DisplayMemberBinding="{Binding DownloadSpeed}"/>
            <GridViewColumn Width="200" Header="添加日期" DisplayMemberBinding="{Binding AddedTime}"/>
        </GridView>
    </ListView.View>

而此时如果我想要先获取所点击的 GridView 是哪一行，然后弹出右键菜单，设置对应的属性，此时的代码逻辑相对来说很复杂

在 WPF 如此优秀的框架里面怎么也需要提供更清真的方法

先忽略绑定的数据是什么，因为没什么意义。按照需求，咱需要一个右键菜单，好那么先创建一个右键菜单

        <ContextMenu x:Key="DownloadFileContextMenu">
            <MenuItem Header="Open File"></MenuItem>
            <MenuItem Header="Open Folder"></MenuItem>
        </ContextMenu>

右键菜单内容十分简单，通过 Header 给定显示的文本，创建右键菜单之后，那么如何让右键菜单绑定到 ListView 上？只需要通过 ItemContainerStyle 设置给 ListView 的每一项就可以了，如下面代码

<ListView Style="{x:Null}" ItemsSource="{Binding Path=DownloadFileInfoList}">
    <ListView.ItemContainerStyle>
        <Style TargetType="{x:Type ListViewItem}">
            <Setter Property="ContextMenu" Value="{StaticResource DownloadFileContextMenu}"/>
        </Style>
    </ListView.ItemContainerStyle>
    <ListView.View>
        <GridView>
            <GridViewColumn Width="200" Header="文件名" DisplayMemberBinding="{Binding FileName}" />
            <GridViewColumn Width="100" Header="大小" DisplayMemberBinding="{Binding FileSize}"/>
            <GridViewColumn Width="200" Header="进度" DisplayMemberBinding="{Binding DownloadProcess}"/>
            <GridViewColumn Width="100" Header="下载速度" DisplayMemberBinding="{Binding DownloadSpeed}"/>
            <GridViewColumn Width="200" Header="添加日期" DisplayMemberBinding="{Binding AddedTime}"/>
        </GridView>
    </ListView.View>
</ListView>

可以看到，主要的代码如下

    <ListView.ItemContainerStyle>
        <Style TargetType="{x:Type ListViewItem}">
            <Setter Property="ContextMenu" Value="{StaticResource DownloadFileContextMenu}"/>
        </Style>
    </ListView.ItemContainerStyle>

通过 ItemContainerStyle 设置一个样式，在样式里面更改 ContextMenu 的内容就可以了，代码量十分少

还有一个问题是如何让右键菜单知道当前点的哪一项？让右键菜单知道当前选中的是哪个 GridView 的 Row 是很逗比的，因为咱可以使用 WPF 的 DataContext 绑定的方法，让数据一层层分发。在每一个 GridView 的 Row 项里面都会使用 ListView 的 ItemSource 的数据的某一项，而咱按照 MVVM 的思想，应该变更的是数据而不是界面本身

而 DataContext 是在视觉树继承的，也就是在对应的元素的右键菜单也会拿到相同的 DataContext 的值。而我的业务是要右击打开下载项的文件夹或文件，此时的数据可以通过对应行的数据拿到

在 ContextMenu 的菜单里面需要绑定命令，而默认的命令不够好用，咱先磨一下刀，新建一个类，请看代码

    public class DelegateCommand : ICommand
    {
        public Func<object, bool>? CanExecuteDelegate { set; get; }

        public Action<object>? ExecuteDelegate { set; get; }

        public bool CanExecute(object parameter)
        {
            return CanExecuteDelegate?.Invoke(parameter) ?? true;
        }

        public void Execute(object parameter)
        {
            ExecuteDelegate?.Invoke(parameter);
        }

        public event EventHandler? CanExecuteChanged;
    }

通过这个类就可以在 XAML 写绑定命令的资源和代码，请看代码

  <local:DelegateCommand x:Key="OpenFileCommand" ExecuteDelegate="OpenFileCommand_OnExecute" ></local:DelegateCommand>
  <local:DelegateCommand x:Key="OpenFolderCommand" ExecuteDelegate="OpenFolderCommand_OnExecute" ></local:DelegateCommand>

记得在 cs 代码里面添加对应的 OpenFileCommand_OnExecute 和 OpenFolderCommand_OnExecute 方法

        private void OpenFileCommand_OnExecute(object parameter)
        {
            if (!(parameter is DownloadFileInfo downloadFileInfo))
            {
                return;
            }

            // 这里的 parameter 就是对应的右击 ListViewItem 的绑定数据
        }

        private void OpenFolderCommand_OnExecute(object parameter)
        {
            if (!(parameter is DownloadFileInfo downloadFileInfo))
            {
                return;
            }

            // 忽略代码
        }

可以看到对应的行的数据就是通过 parameter 参数传入到后台代码的方法，也就是通过命令的参数可以拿到当前右击的 ListViewItem 的数据

那么如何让命令拿到 DataContext 的参数？刚才咱也说到了右键菜单是放在 ListViewItem 的，而 DataContext 是会在视觉树继承的，所以右键菜单的 DataContext 和右击的行的是相同的

<MenuItem Header="Open File" Command="{StaticResource OpenFileCommand}" CommandParameter="{Binding}"></MenuItem>

通过 Command 绑定资源定义的命令，然后让 CommandParameter 命令参数使用 {Binding} 绑定到菜单的 DataContext 就可以将数据给到命令的参数，也就给到了后台代码的方法参数，所以后台代码就可以通过参数拿到右击所在行的数据

这样的代码就不需要去后台代码处理右击的事件，也不需要去找当前右键到哪一项，也不需要去找到对应的右击数据。通过绑定的方法和 DataContext 是视觉树继承的，就可以做到自动拿到当前的右击项的数据，传到后台方法

本文的更改放在 github 上，小伙伴可以通过对比更改内容，就能知道本文修改的代码

如果在右击的本身是需要修改 ListViewItem 的界面的，如果这个界面更改和数据无关，那么可以通过修改 Style 的方法修改界面，而不是通过后台代码修改属性的方式

上面的代码在我实际的测试项目里面是存在一定的更改，本文的代码只是给大家演示，欢迎小伙伴参与开源项目 https://github.com/dotnet-campus/dotnetCampus.FileDownloader 的开发

本文不属于入门博客，如果小伙伴还没入门，我推荐小伙伴看豪哥的 bilibili 免费入门视频用项目带你入门 WPF 开发

Xamarin.Forms 选取文件让用户选择本地文件

Thu, 03 Dec 2020 12:38:55 +0000

在 Xamarin 中，使用文件存储或打开某个特定文件都是很常用的做法，而在跨平台中，每个平台都有自己的 IO 的坑。如何在 Xamarin.Froms 里面让用户可以选择打开哪个本文文件，需要照顾多个不同的平台的文件访问方式

在 Xamarin.Forms 右击管理 NuGet 程序包，搜寻 Xamarin.Plugin.FilePicker 进行安装，或在 csproj 上添加下面代码

    <PackageReference Include="Xamarin.Plugin.FilePicker" Version="2.1.36-beta" />

如果不是让用户选取文件内容，那么在 Xamarin.Essentials 这个提供了 Xamarin 原生 API 交互的库就完全足够使用了

在界面上添加一个按钮，用来让用户选取文件内容

    <StackLayout>
        <Label x:Name="FileText" Margin="10,10,10,10"></Label>
        <Button HorizontalOptions="Center" Text="选取文件" Clicked="Button_OnClicked"></Button>
    </StackLayout>

在后台代码添加按钮点击时让用户选择文件的代码

using Plugin.FilePicker;

        private async void Button_OnClicked(object sender, EventArgs e)
        {
            var pickFile = await CrossFilePicker.Current.PickFile();
            if (pickFile is null)
            {
                // 用户拒绝选择文件
            }
            else
            {
                FileText.Text = $@"选取文件路径 :{pickFile.FilePath}";
            }
        }

此时用户可以不选择文件，如果用户不选择文件，那么将拿到一个空值

现在 CrossFilePicker 的 Open 和 Save 方法都过时了，请使用 Xamarin.Essentials.FileSystem 代替，或者用 Xamarin.Essentials.ShareFile 将文件分享给其他应用打开

这个项目所有代码放在 github 欢迎小伙伴访问

Xamarin 和 WPF 的控件和属性的替换

Thu, 03 Dec 2020 12:38:51 +0000

基本上 Xamarin 和 WPF 的技术是相同的，但是有一些小细节和属性不同，本文记录一些不同的点，方便小伙伴将 WPF 项目迁移为 Xamarin 项目

需要注意的是 Xamarin 原生支持作为 WPF 控件运行，支持在 WPF 运行，反过来不可以

也就是用 Xamarin.Forms 写的应用能作为 UWP 和 WPF 应用运行，也可以作为 Android 和 IOS 运行，也可以使用 GTK# 在 Linux 下运行。本文只是告诉大家如何从一个已有的 WPF 项目迁移到 Xamarin 上

控件

通用控件的属性需要修改

Visibility-IsVisible

Panel

通用的容器属性需要修改

HorizontalAlignment-HorizontalOptions
VerticalAlignment-VerticalOptions
MinWidth-MinimumWidthRequest

StackPanel

在 WPF 的 StackPanel 需要换 StackLayout 布局

TextBlock

用 Label 替换

TextBox

用 Editor 替换

Button

如果是文本按钮将 Content 替换为 Text 属性

将 Click 事件替换为 Clicked 事件，后台代码替换

从

        private void Button_OnClick(object sender, RoutedEventArgs e)
        {

        }

替换为

        private void Button_Clicked(object sender, EventArgs e)
        {

        }

UI 控件比较 - Xamarin

WPF 与 Xamarin：相似性 & 差异 - Xamarin

Xamarin 构建安卓失败因为路径太长

Thu, 03 Dec 2020 12:38:48 +0000

如果将自己的应用放的路径比较深，那么构建安卓的时候可能因为路径超过长度失败

如果在你构建 Xamarin 安卓的时候看到如以下提示，那么请你确定以下你的应用程序路径是不是超过 250 个字符了

obj\Debug\90\android\src\mono\android\support\v4\view\accessibility\AccessibilityManagerCompat_AccessibilityStateChangeListenerImplementor.java

解决方法是减少项目名的长度，移动到距离根文件夹比较近的文件夹，也就是让上面这个文件的总路径不要太长

Xamarin 构建提示 error APT2260 resource 找不到资源

Thu, 03 Dec 2020 12:38:46 +0000

其实这是 VisualStudio 逗比的问题，尝试关闭 VisualStudio 然后干掉 Bin 和 Obj 文件夹，然后先开启安卓模拟器，然后重新构建就可以了。如果一次重新构建失败，那么再次右击重新生成就可以了

如果在新建一个 Xamarin 应用时，或安装了一个 NuGet 库之后，发现在构建时提示下面代码

2>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Xamarin\Android\Xamarin.Android.Common.Debugging.targets(420,2): warning : 发生一个或多个错误。
2>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Xamarin\Android\Xamarin.Android.Aapt2.targets(155,3): error APT2260: resource style/Theme.AppCompat.Light.Dialog (aka com.companyname.fecawjearwhalljearwugeweenere:style/Theme.AppCompat.Light.Dialog) not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(4): error APT2260: style attribute 'attr/colorAccent (aka com.companyname.fecawjearwhalljearwugeweenere:attr/colorAccent)' not found.
2>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Xamarin\Android\Xamarin.Android.Aapt2.targets(155,3): error APT2260: resource style/Theme.AppCompat.Light.DarkActionBar (aka com.companyname.fecawjearwhalljearwugeweenere:style/Theme.AppCompat.Light.DarkActionBar) not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(2): error APT2260: style attribute 'attr/windowNoTitle (aka com.companyname.fecawjearwhalljearwugeweenere:attr/windowNoTitle)' not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(2): error APT2260: style attribute 'attr/windowActionBar (aka com.companyname.fecawjearwhalljearwugeweenere:attr/windowActionBar)' not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(2): error APT2260: style attribute 'attr/colorPrimary (aka com.companyname.fecawjearwhalljearwugeweenere:attr/colorPrimary)' not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(2): error APT2260: style attribute 'attr/colorPrimaryDark (aka com.companyname.fecawjearwhalljearwugeweenere:attr/colorPrimaryDark)' not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(3): error APT2260: style attribute 'attr/colorAccent (aka com.companyname.fecawjearwhalljearwugeweenere:attr/colorAccent)' not found.
2>G:\lindexi_gd\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere\FecawjearwhalljearWugeweenere.Android\Resources\values\styles.xml(4): error APT2260: style attribute 'attr/windowActionModeOverlay (aka com.companyname.fecawjearwhalljearwugeweenere:attr/windowActionModeOverlay)' not found.
2>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Xamarin\Android\Xamarin.Android.Aapt2.targets(155,3): error APT2062: failed linking references.

那么基本都是 VisualStudio 的逗比问题，可以通过还原 NuGet 库和删除 Bin 和 Obj 文件夹或清理项目解决。注意清理项目时不会完全删除 Obj 文件哦，我推荐先手动删除 Bin 和 Obj 文件夹，如果删除失败，那么先将项目代码复制到另一个文件夹就可以了

通过 Git 管理的代码，可以通过下面的代码快速清理 Bin 和 Obj 文件夹，这个方法的缺点是也许会将一些代码也清理掉，除非是熟悉 Git 的小伙伴，不然请不要模仿

git clean -xdf

此外，如果是 NuGet 没有还原成功，因为网络的原因，可以尝试国内的源，请看我收集的各种公有 NuGet 源 - walterlv

Xamarin 解决创建空白项目编译提示 linking references 找不到资源

Thu, 03 Dec 2020 12:38:44 +0000

在新建一个 Xamarin 应用，编译时提示了 linking references 和一些诡异的文件无法访问，原因是文件路径问题和 NuGet 还原问题

如果创建的 Xamarin 项目所在的文件路径比较深，同时包含中文等字符时，在编译时可以会诡异失败

oid\Xamarin.Android.Aapt2.targets(155,3): error APT2062: failed linking references.

或者

error APT0000: resource integer/google_play_services_version (aka com.softoursistemas.rutesc.droid:integer/google_play_services_version) not found

也有比较明确的提示

Failed to create JavaTypeInfo for class: Android.Support.V13.View.Inputmethod.InputConnectionCompat/IOnCommitContentListenerImplementor due to MAX_PATH: System.IO.DirectoryNotFoundException: 未能找到路径“g:\lindexi\ChuwheaweaharfelkalBelqearjurnawnere\ChuwheaweaharfelkalBelqearjurnawnere\ChuwheaweaharfelkalBelqearjurnawnere.Android\obj\Debug\90\android\src\mono\android\support\v13\view\inputmethod\InputConnectionCompat_OnCommitContentListenerImplementor.java”的一部分。
   在 System.IO.__Error.WinIOError(Int32 errorCode, String maybeFullPath)
   在 System.IO.File.InternalDelete(String path, Boolean checkHost)
   在 System.IO.File.Delete(String path)
   在 Xamarin.Android.Tools.Files.CopyIfStreamChanged(Stream stream, String destination)
   在 Xamarin.Android.Tasks.Generator.CreateJavaSources(TaskLoggingHelper log, IEnumerable`1 javaTypes, String outputPath, String applicationJavaClass, String androidSdkPlatform, Boolean useSharedRuntime, Boolean generateOnCreateOverrides, Boolean hasExportReference)	ChuwheaweaharfelkalBelqearjurnawnere.Android	

也有很诡异的提示

Android\obj\Debug\90\lp\39\jl\res : error APT2097: failed to open directory: 绯荤粺

有明确的提示的可以看到，其实 Xamarin 的设计有点坑，就是路径太长了，加上了我的项目命名，在 Windows 下的路径就超过了 260 字符限制，此时就编译不通过

解决方法是尝试将项目移动到磁盘的第二级文件夹，然后使用删除所有的 bin 和 obj 文件夹，此时就可以解决这几个诡异的坑

Failed linking references in Android project (Xamarin - Visual Studio Community 2019) · Issue #3822 · xamarin/xamarin-android

Create a new Mobile.App (Xamarin.Forms) project, try to compile, but “Failed linking references” - Stack Overflow

Xamarin iOS 切换开发者账号之后的签名标识和预配配置文件更新方法

Thu, 03 Dec 2020 12:38:41 +0000

其实这一篇和 Xamarin 开发几乎没有关系，这是苹果开发的一个坑。在原有开发者账号下的设备上，切换为另一个开发者账号，此时的部署也许会找错预配配置文件和证书。苹果：渣渣开发者，这是特性

在 XCode 的选项账户里面的 Download Manual Profiles 按钮里面，下载的证书文件放在 ~/Library/MobileDevice/Provisioning\ Profiles 文件夹里面，如下图

我推荐在苹果上切换开发者的时候，先删除原有的证书文件，删除方法是在命令行输入下面代码

~/Library/MobileDevice/Provisioning\ Profiles
rm *

删除完成之后，重新在 XCode 的选项账户里面点击 Download Manual Profiles 按钮

回到 VS 的 Xamarin 项目里面，右击选项，点击 iOS 捆绑包签名，重新选择签名标识，如下图，我建议不选择自动

参考文档：

删除Xcode中多余的证书provisioning profile

Xcode Provisioning Profiles Location

使用 Xamarin 在 iOS 真机上部署应用进行调试

Xamarin.Forms 按钮样式圆角按钮

Thu, 03 Dec 2020 12:38:39 +0000

在 Xamarin 中可以通过 CornerRadius 设置按钮使用圆角

在 Xamarin 中可以方便进行样式定义或不进行定义样式只修改属性而改变外观，如按钮的圆角可以通过 CornerRadius 属性设置

按钮使用圆角时，如果更改边框的颜色建议同时更改边框的宽度和边框颜色，在不同的平台下默认的样式不相同的，如果想要保持各个平台统一的外观，虽然这样不是好主意，那么请设置固定的值，而不是采用默认值

            <Button Font="Large" Text="选取PPT文件" HorizontalOptions="Center"
                    CornerRadius="5"
                    BackgroundColor="Transparent"
                    BorderColor="Aquamarine" 
                    BorderWidth="2"/>

此时就创建了一个圆角的按钮，注意需要设置边框时同时设置 BorderColor 和 BorderWidth 两个值。因为在 UWP 中 BorderWidth 是 2 而在 Android 中是 0 也就是此时如果干掉了背景颜色，将看不到按钮的圆角

设置按钮背景透明可以通过设置 BackgroundColor 为 Transparent 属性

如果需要让按钮点击时呈现有趣的效果，可以通过 VisualStateManager 的方式定义

            <Button Font="Large" Text="选取PPT文件" HorizontalOptions="Center"
                    CornerRadius="5"
                    BackgroundColor="Transparent"
                    BorderColor="Aquamarine" 
                    BorderWidth="2">
                <VisualStateManager.VisualStateGroups>
                    <VisualStateGroup x:Name="CommonStates">
                        <VisualState x:Name="Normal">
                            <VisualState.Setters>
                                <Setter Property="Scale"
                                        Value="1" />
                            </VisualState.Setters>
                        </VisualState>

                        <VisualState x:Name="Pressed">
                            <VisualState.Setters>
                                <Setter Property="Scale"
                                        Value="0.6" />
                            </VisualState.Setters>
                        </VisualState>

                        <VisualState x:Name="Released">
                            <VisualState.Setters>
                                <Setter Property="Scale"
                                        Value="2" />
                            </VisualState.Setters>
                        </VisualState>
                    </VisualStateGroup>
                </VisualStateManager.VisualStateGroups>
            </Button>

这个项目所有代码放在 github 欢迎小伙伴访问

另外推荐小伙伴的系列博客：Xamarin移动开发之路 - peterYong - 博客园

Xamarin Forms WPF 干掉默认的窗口导航条

Thu, 03 Dec 2020 12:38:30 +0000

在创建默认的 Xamarin Forms WPF 应用，将和 UWP 应用的界面不相同，在 WPF 项目会显示顶部蓝色的一条，看起来不好看，那么可以如何干掉他

下图是一个默认的 Xamarin Forms 应用

此时显示工具的蓝色条就是本文说的窗口导航条，在 Xamarin Forms 的源代码，这个导航条是在 FormsWindow.xaml 文件里面，使用 PART_TopAppBar 控制的，也就是想要不显示这个工具栏，可以通过设置让这个控件不可见

最简单的方法是通过附加属性的方式

在 MainPage.xaml 添加下面代码

NavigationPage.HasNavigationBar="False"

现在的 MainPage.xaml 的代码如下

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:d="http://xamarin.com/schemas/2014/forms/design"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             mc:Ignorable="d" Title="工具" 
             NavigationPage.HasNavigationBar="False"
             x:Class="XamarinNeller.MainPage">

    <StackLayout>
        <Label Text="内容" HorizontalOptions="Center" VerticalOptions="CenterAndExpand"></Label>
    </StackLayout>

</ContentPage>

运行代码可以看到如下界面

此时原本显示工具的蓝色的一条就被干掉了

这部分文档请看

Navigation In Xamarin.Forms

xamarin.forms - Remove navigation bar in contentpage Xamarin - Stack Overflow

Navigating in Xamarin Forms - Xamarin Help

那为什么设置 HasNavigationBar 就能干掉工具栏，在 Xamarin Forms 的源代码 FormsWindow.xaml 是通过绑定设置是否显示

<controls:FormsAppBar x:Name="PART_TopAppBar" Visibility="{Binding HasNavigationBar, FallbackValue=Collapsed, TargetNullValue=Collapsed, Converter={StaticResource BoolToVis}, RelativeSource={RelativeSource AncestorType={x:Type controls:FormsWindow}}}"">
    <Grid>
        <!-- 忽略代码 -->
    </Grid>
</controls:FormsAppBar>

而 HasNavigationBar 属性的设置是在 FormsWindow.cs 的 SynchronizeAppBar 方法，在这个方法里面使用这个代码修改

		public void SynchronizeAppBar()
		{
			IEnumerable<FormsPage> childrens = this.FindVisualChildren<FormsPage>();

			HasNavigationBar = childrens.FirstOrDefault()?.GetHasNavigationBar() ?? false;

			// 忽略代码
		}

而 FormsPage 的 GetHasNavigationBar 方法如下

	public class FormsPage : UserControl
	{
		public virtual bool GetHasNavigationBar()
		{
			return this.HasNavigationBar;
		}
	}

在 VisualPageRenderer 将会在 UpdateNavigationBarVisible 方法里面设置 FormsPage 的 HasNavigationBar 属性

设置方法是通过获取当前元素的附加属性，使用 NavigationPage.GetHasNavigationBar 的方法获取

所以在 MainPage 设置 NavigationPage.HasNavigationBar="False" 就能让 VisualPageRenderer 也就是对应的布局更新工具栏不可见

在 Xamarin Forms 的 WPF 版本里面，在 WPF 实现了大量基础的控件，和 Xamarin Forms 对应，此时做实际交互和渲染都是原生的 WPF 控件，这样能提升性能

C# 写一个24点计算程序

Thu, 03 Dec 2020 12:38:27 +0000

我在和小伙伴玩 24 点这个游戏，但是我的计算速度比他慢，于是我就写了一个作弊的程序

这个游戏的规则是给定 4 个数字，然后你根据加减乘除规则，不重复利用这几个数字计算出 24 这个数字

例如给定了 2 6 1 1 这几个数字，可以使用 2 * 6 = 12 然后 1 + 1 = 2 拿到 2 和 12 两个数字，后面的也不需要说了

简单的实现是在不考虑性能下，先对给定的数字进行全排列，然后排列计算符号，此时计算符号可以有重复，大概就是这个方法

代码放在 github 欢迎小伙伴访问

C# 反射判断属性是抽象继承

Thu, 03 Dec 2020 12:38:25 +0000

我在写一个有趣的 WPF 软件可以通过 dll 反射重新生成代码，我需要了解dll里面每个属性是抽象的还是继承的还是虚属性

在 C# 中可以方便通过反射拿到一个类里面的所有属性，在阅读本文之前，我期望你先看 win10 uwp 反射

抽象

需要知道在 C# 中属性是使用两个方法做的，一个是 Set 方法一个是 Get 方法，其中 Set 方法用来做设置，而 Get 方法用来做获取。但是不一定每个属性都有 Set 和 Get 方法，但是至少有一个。而 C# 中没有提供任何一个判断属性是否抽象的方法，但是提供了方法的判断是否抽象。所以可以尝试获取某个属性的 Set 或 Get 方法是否是抽象方法从而判断这个属性是否抽象属性

假设通过反射拿到了一个属性 PropertyInfo pi 那么可以通过下面代码判断 Set 方法是否是抽象的

if(pi.GetSetMethod().IsAbstract)
{
}

如果发现 Set 方法是抽象的，那么这个属性就是抽象属性

虚属性

判断属性是虚属性也是通过属性的 Set 或 Get 方法判断，但是属性不一定存在 Set 或 Get 方法，如上面代码说的，可以通过 CanRead 属性判断能否读取，如果能读取那么可以用 GetMethod 的方法

var m = p.CanRead ? p.GetMethod() : p.SetMethod();
if(m.IsVirtual)
{

}

重写

也就是继承重写基类的方法，简单的判断就是这个属性的 Set 或 Get 方法的定义的类和当前的类不相同

var getMethod = property.GetGetMethod();

使用 GetBaseDefinition 可以尝试拿到基类的定义，如果能拿到和当前类不同的，那么这个 Get 方法就是继承的，也就是属性是重写的

if (getMethod.GetBaseDefinition().DeclaringType != getMethod.DeclaringType)
{

}

c# - How to identify abstract members via reflection - Stack Overflow

c# - How to check if a property is virtual with reflection?

c# - How do I determine if a property was overridden? - Stack Overflow

C# 纯控制台创建一个全屏窗口

Thu, 03 Dec 2020 12:38:23 +0000

本文告诉大家如何使用 win32 方法创建一个全屏的窗口

使用 user32.dll 的 CreateWindowExW 方法就能创建窗口，代码请看

    internal class Program
    {
        private static void Main(string[] args)
        {
            var thread = new Thread(() =>
            {
                var customWindow = new Window("sdf");
            });

            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();

            Console.ReadLine();
        }
    }

    internal class Window : IDisposable
    {
        public Window(string className)
        {
            var windClass = new WNDCLASS
            {
                lpszClassName = className
            };
            _wndProc = CustomWndProc;

            windClass.lpfnWndProc = Marshal.GetFunctionPointerForDelegate(_wndProc);

            RegisterClassW(ref windClass);

            // Create window
            _mHwnd = CreateWindowExW
            (
                0,
                className,
                string.Empty,
                0,
                0,
                0,
                0,
                0,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero
            );

            const int SW_MAXIMIZE = 3;
            ShowWindow(_mHwnd, SW_MAXIMIZE);

            int ret;
            while ((ret = GetMessage(out var msg, _mHwnd, 0, 0)) != 0)
            {
                if (ret == -1)
                {
                    //-1 indicates an error
                }
                else
                {
                    TranslateMessage(ref msg);
                    DispatchMessage(ref msg);
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        [DllImport("user32.dll", SetLastError = true)]
        private static extern ushort RegisterClassW([In] ref WNDCLASS lpWndClass);

        [DllImport("user32.dll", SetLastError = true)]
        private static extern IntPtr CreateWindowExW
        (
            uint dwExStyle,
            [MarshalAs(UnmanagedType.LPWStr)] string lpClassName,
            [MarshalAs(UnmanagedType.LPWStr)] string lpWindowName,
            uint dwStyle,
            int x,
            int y,
            int nWidth,
            int nHeight,
            IntPtr hWndParent,
            IntPtr hMenu,
            IntPtr hInstance,
            IntPtr lpParam
        );

        [DllImport("user32.dll", SetLastError = true)]
        private static extern IntPtr DefWindowProcW
        (
            IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam
        );

        [DllImport("user32.dll", SetLastError = true)]
        private static extern bool DestroyWindow(IntPtr hWnd);

        private void Dispose(bool disposing)
        {
            if (!_mDisposed)
            {
                if (disposing)
                {
                    // Dispose managed resources
                }

                // Dispose unmanaged resources
                if (_mHwnd != IntPtr.Zero)
                {
                    DestroyWindow(_mHwnd);
                    _mHwnd = IntPtr.Zero;
                }
            }
        }

        [DllImport("user32.dll")]
        private static extern int GetMessage(out int lpMsg, IntPtr hWnd, uint wMsgFilterMin,
            uint wMsgFilterMax);

        [DllImport("user32.dll")]
        private static extern bool TranslateMessage([In] ref int lpMsg);

        [DllImport("user32.dll")]
        private static extern IntPtr DispatchMessage([In] ref int lpmsg);

        [DllImport("user32.dll")]
        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

        private static IntPtr CustomWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
        {
            return DefWindowProcW(hWnd, msg, wParam, lParam);
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        private struct WNDCLASS
        {
            public readonly uint style;
            public IntPtr lpfnWndProc;
            public readonly int cbClsExtra;
            public readonly int cbWndExtra;
            public readonly IntPtr hInstance;
            public readonly IntPtr hIcon;
            public readonly IntPtr hCursor;
            public readonly IntPtr hbrBackground;

            [MarshalAs(UnmanagedType.LPWStr)] public readonly string lpszMenuName;

            [MarshalAs(UnmanagedType.LPWStr)] public string lpszClassName;
        }

        private delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

        private readonly WndProc _wndProc;

        private bool _mDisposed;
        private IntPtr _mHwnd;
    }

本文代码放在github 欢迎小伙伴访问

C# 里面很少人知道但很好用的 Tuple 转换

Thu, 03 Dec 2020 12:38:21 +0000

小伙伴们都知道有 Tuple 但是很少有小伙伴只有原来从一个类转换为一个 Tuple 的方式如此简洁，在 C# 最新版本里面提供了一组语法糖，可以便捷给任意的类扩展转换为元组的能力

先来看看下面这段有趣的代码

我可以将 Lindexi 类解析为 (string name, string doubi) 的元组，只需要 Lindexi 存在Deconstruct方法，存在这个方法的类不需要继承任何接口，只需要方法名是 Deconstruct 参数全部都是 out 的就可以

如上面例子里面的代码

    class Lindexi
    {
        public string Name { get; } = "林德熙";
        public string Doubi { get; } = "逗比";

        public void Deconstruct(out string name, out string doubi)
        {
            name = Name;
            doubi = Doubi;
        }
    }

存在 Deconstruct 方法将会在编译的时候，通过 Roslyn 语法分析，生成有趣的辅助代码

这段代码我放在 github 欢迎小伙伴访问

这个语法糖在 Roslyn 上是如何用的？其实非常简单，上面代码其实可以分为两句代码做到

            lindexi.Deconstruct(out var v1, out var v2);
            var (name, doubi) = (v1, v2);

这里的 v1 和 v2 就是临时用的变量，通过 Roslyn 预编译可以知道这个类 lindexi 存在 Deconstruct 方法，又知道期望的 Tuple 需要几个参数，这样就能做到在将这个有趣的语法转换为原有的代码了

为什么我知道 Roslyn 是如何玩的？原因是看了 IL 代码就知道

    IL_0007: ldloc.0      // lindexi
    IL_0008: ldloca.s     V_3
    IL_000a: ldloca.s     V_4
    IL_000c: callvirt     instance void BepirquwiKedoucawji.Lindexi::Deconstruct(string&, string&)
    IL_0011: nop
    IL_0012: ldloc.3      // V_3
    IL_0013: stloc.1      // name
    IL_0014: ldloc.s      V_4
    IL_0016: stloc.2      // doubi

刚才也说到只要存在对应的方法就可以，那么扩展方法算不算？其实扩展方法也可以

    class Lindexi
    {
        public string Name { get; } = "林德熙";
        public string Doubi { get; } = "逗比";
    }

    static class Extension
    {
        public static void Deconstruct(this Lindexi lindexi, out string name, out string doubi)
        {
            name = lindexi.Name;
            doubi = lindexi.Doubi;
        }
    }

现在我修改为扩展方法了，也可以看到程序是能跑起来的，因为从 IL 代码上可以看到只有 IL_000c 这句代码更改了调用方法

    IL_0007: ldloc.0      // lindexi
    IL_0008: ldloca.s     V_3
    IL_000a: ldloca.s     V_4
    IL_000c: call         void BepirquwiKedoucawji.Extension::Deconstruct(class BepirquwiKedoucawji.Lindexi, string&, string&)
    IL_0011: nop
    IL_0012: ldloc.3      // V_3
    IL_0013: stloc.1      // name
    IL_0014: ldloc.s      V_4
    IL_0016: stloc.2      // doubi

上面代码放在 github 欢迎小伙伴访问

也就是我可以将现有的任何一个类，改造 Tuple 解析，如我可以给一个 List<int> 解析为将每个元素拼为字符串，同时返回他的元素有多少个请看代码

    static class Extension
    {
        public static void Deconstruct(this List<int> list, out string name, out int count)
        {
            name = string.Join(",", list);
            count = list.Count;
        }
    }

添加上面代码就可以愉快写出小伙伴很难看懂的代码

        static void Main(string[] args)
        {
            var (name, count) = new List<int>() { 1, 2, 3 };
            Console.WriteLine($"{name} {count}");
        }

上面代码放在 github 欢迎小伙伴访问

Deconstructing tuples and other types

dotnet C# 使用阿里函数计算服务

Thu, 03 Dec 2020 12:38:19 +0000

现在有很多函数计算服务，通过函数计算服务可以在服务上运行自己的代码，而不需要理会服务器的部署以及运行代码存在的并发问题。这些问题都会在云进行计算。使用阿里的函数计算服务可以使用 dotnet core 2.1 的框架，同时测试使用免费。本文告诉搭建如何在阿里的函数计算服务上运行自己的代码

首先是打开阿里云 https://cn.aliyun.com 进入函数计算服务

点击进入函数计算控制台在右边的快速入口点击新建函数

先创建事件函数，这个函数最简单

下一步需要选择使用 dotnet core 2.1 服务，然后填写所在服务和函数名称，这里的函数入口的填写将会存在一点坑，可以先使用默认的值，接下来再修改

先尝试在本地创建一个 dotnet core 2.1 版本的控制台项目，注意创建的框架需要使用 dotnet core 2.1 版本，可以在 csproj 文件里面通过修改 TargetFramework 的值修改版本

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>

</Project>

在 Program.cs 文件里面添加一个静态的公开的方法 Foo 用于在阿里服务器上执行，注意将 Program 类修改为公有

using System;

namespace RaweayerkeJebarkewere
{
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Hello World!");
        }

        public static void Foo(object o)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

为什么 Foo 方法需要一个 object 的参数，这是因为在阿里服务器将会通过反射调用 Foo 方法，要求调用的方法存在一个参数

此时写好代码，通过命令行编译一下，可以上传的代码是 debug 版的，将 bin\Debug\netcoreapp2.1\ 文件夹压缩，此时要求压缩包里面根文件夹就包含了 *.dll 文件

我创建的控制台项目是 RaweayerkeJebarkewere 的命令，也就是在 bin\Debug\netcoreapp2.1\ 创建了 RaweayerkeJebarkewere.dll 文件

返回刚才的阿里的函数计算创建页面，填写函数入口，这里的函数入口写起来有些诡异

文件名::命名空间.类名::函数名

我这里的文件是RaweayerkeJebarkewere.dll也就是文件名是RaweayerkeJebarkewere而命名空间和类名就不用说了

函数名注意不需要加上括号

RaweayerkeJebarkewere::RaweayerkeJebarkewere.Program::Foo

将压缩了 RaweayerkeJebarkewere.dll 的文件通过点击代码包上传

也就是填写所在服务和函数名称选择使用 dotnet core 2.1 加上函数入口就可以了

在跳转的代码执行页面点击执行就可以看到输出，如果可以输出那么运行就成功了

如果需要修改函数入口，请点击概览页面，然后点击配置就可以修改

dotnet C# 图片等比限制最大和最小大小缩放算法

Thu, 03 Dec 2020 12:38:17 +0000

本文只是告诉大家如何计算缩放之后的宽度和高度，不包含实际的图片缩放方法

如下图，我要将图片的大小进行等比缩放，此时我要求图片的宽度和高度大于最小尺寸，但是要求宽度和高度都不大于最大尺寸，如果这两个规则冲突，优先满足不大于最大尺寸

按照规则可以看到，如下图，图片的宽度等于最大宽度了，此时虽然图片的高度小于最小高度，但是也不应该对图片进行缩放

为什么需要有最大限制？原因是等比缩放对于长图计算不友好，如果我有一张图片的宽度和高度比例是 1:1000 那么此时如果没有限制最大高度，那么将宽度缩放到最小宽度需要缩放10倍，此时的高度就太大了

下面就是计算方法

先定义大小这个类

    public class Size
    {
        public Size(double width, double height)
        {
            Width = width;
            Height = height;
        }

        public double Width { set; get; }
        public double Height { set; get; }

        /// <inheritdoc />
        public override string ToString()
        {
            return $"Width={Width:0.00} Height={Height:0.00}";
        }
    }

计算的方法需要传入当前图片的宽度和高度，最小的宽度和高度和最大的宽度和高度，返回的值是计算的宽度和高度

        static Size OptimizationSize(Size currentSize, Size minSize, Size maxSize)

计算的方法就是先获取宽度和高度的缩放到最小大小的缩放值

            var height = currentSize.Height;
            var width = currentSize.Width;
            var widthScale = minSize.Width / width;
            var heightScale = minSize.Height / height;

如果此时的图片本来就大于最小宽度和高度，就不能让图片的缩放比原来小，除非大于最大宽度或高度

            var minScale = Math.Max(widthScale, heightScale);
            minScale = Math.Max(minScale, 1.0);

计算图片和最大宽度和高度的缩放，同时拿到最大缩放里面的最小的一个，这样缩放完成之后就不会大于最大的宽度和高度

            var maxWidthScale = maxSize.Width / width;
            var maxHeightScale = maxSize.Height / height;

            var maxScale = Math.Min(maxWidthScale, maxHeightScale);

现在获取了 minScale 和 maxScale 需要根据这两个缩放计算最小的缩放

            var scale = Math.Min(minScale, maxScale);

为了让图片显示更锐利，这里让缩放是整数，使用整数可能略大于最大的宽度和高度

            scale = Math.Ceiling(scale);

所有代码

        /// <summary>
        /// 宽度和高度不小于最小大小，但是不大于最大大小，缩放使用等比缩放
        /// <para/>
        /// 规则：
        /// <para/>
        /// - 如果有一边小于最小大小，那么缩放到这一边大于等于最小大小
        /// <para/>
        /// - 如果一边缩放之后大于最大的大小，那么限制不能超过最大的大小
        /// <para/>
        /// - 尽可能让大小接近最小大小，但是保证宽度和高度都不大于最大大小
        /// </summary>
        /// <param name="currentSize"></param>
        /// <param name="minSize"></param>
        /// <param name="maxSize"></param>
        /// <returns></returns>
        static Size OptimizationSize(Size currentSize, Size minSize, Size maxSize)
        {
            if (currentSize.Width > minSize.Width && currentSize.Height > minSize.Height)
            {
                if (currentSize.Width <= maxSize.Width && currentSize.Height <= maxSize.Height)
                {
                    return currentSize;
                }
            }

            var height = currentSize.Height;
            var width = currentSize.Width;
            var widthScale = minSize.Width / width;
            var heightScale = minSize.Height / height;

            // 如果超过最大的大小
            var maxWidthScale = maxSize.Width / width;
            var maxHeightScale = maxSize.Height / height;

            var maxScale = Math.Min(maxWidthScale, maxHeightScale);
            var minScale = Math.Max(widthScale, heightScale);
            minScale = Math.Max(minScale, 1.0);
            var scale = Math.Min(minScale, maxScale);
            // 尽可能使用整数
            scale = Math.Ceiling(scale);
            return new Size(width * scale, height * scale);
        }

在 WPF 中可以通过设置 Image 控件的宽度和高度，此时因为尺寸是使用相同的值缩放，所以刚好图片使用 Fill 就能贴上去

但是无论用什么的算法，只要图片和原始尺寸不相同，那么一定会糊。无论是图片进行放大或缩小，都会模糊，这是基础的知识，想了解原理请自行百度

另一个算法是按照填充像素数量计算的，限制填充像素数量限制大小

public static Size GetImageOptimizationSize(Size originSize, int maxPixel, int requestedPixel)

传入图片的大小，以及限制的最大像素和期望的像素大小。如果图片大小大于期望的像素，小于最大的像素大小，那么返回图片原始大小

        public static Size GetImageOptimizationSize(Size originSize, int maxPixel, int requestedPixel)
        {
            var imagePixel = originSize.Width * originSize.Height;
            if (imagePixel <= maxPixel)
            {
                // 是不是太小了，需要缩放
                if (imagePixel < requestedPixel)
                {
                    return GetOptimizationSize(originSize, requestedPixel);
                }
            }
            else
            {
                return GetOptimizationSize(originSize, maxPixel);
            }

            return originSize;

            static Size GetOptimizationSize(Size originSize, double requestedPixel)
            {
                // 定义 Ow 是 originSize.Width
                // 定义 Oh 是 originSize.Height
                // 返回值为 requestedSize 根据 requestedPixel 计算
                // 定义 Rw 是 requestedSize.Width
                // 定义 Rh 是 requestedSize.Height
                // 假定比例不变，于是有
                // Ow / Oh = Rw / Rh 
                // 也就是前后的宽度高度比例不变
                // 上面表达式交换可以等于
                // Ow * Rh = Rw * Oh
                // 而 requestedPixel = requestedSize.Width * requestedSize.Height
                // 定义 P 是 requestedPixel
                // 于是有 Rw = P / Rh
                // 因此 Ow * Rh = Rw * Oh = P / Rh * Oh
                // Ow * Rh = P / Rh * Oh
                // Rh * Rh = P * Oh / Ow
                // 因此 Rh = Math.Sqrt(P * Oh / Ow)
                // 相同方式可以计算 Rw 的值

                var requestedWidth = (int)Math.Sqrt(requestedPixel * originSize.Width / originSize.Height);
                var requestedHeight = (int)Math.Sqrt(requestedPixel * originSize.Height / originSize.Width);

                return new Size(requestedWidth, requestedHeight);
            }
        }

上面的方法更简单，但是我添加了很多注释用来告诉大家这是如何计算的

dotnet C# 如何不联网下快速获取一段url链接里面读取文件名

Thu, 03 Dec 2020 12:38:14 +0000

在不联网情况下，从 url 获取文件名也就是只能靠 url 本身了，如果是 get 的链接很多链接后面都是带上了文件名，那么如何用最短的代码获取链接里面的文件名

如我有链接 https://blog.lindexi.com/lindexi.html 我想要拿到 lindexi.html 这个文件名可以如何写代码最少

请看下面方法

        private string GetFileName(string url)
        {
            FileInfo fileInfo = new FileInfo(url);
            return fileInfo.Name;
        }

是不是看错代码了，居然用了 FileInfo 的方法，小伙伴请试试用下面代码跑起来

using System;
using System.IO;

        static void Main(string[] args)
        {
            Program program = new Program();
            Console.WriteLine(program.GetFileName("https://blog.lindexi.com/lindexi.html"));
        }

此时可以看到输出了 lindexi.html 就这样返回了 url 链接里面的文件名，那么还有更短的方法

        private string GetFileName(string url)
        {
            return System.IO.Path.GetFileName(url);
        }

没错用 System.IO.Path.GetFileName 就可以了，不需要做任何的字符串修改，直接一个库方法就解决了

在个人的小项目或工具项目，或脚本里面，可以使用上面方法解析 url 的文件名

我可以做到不开 vs 不用任何 ide 只需要记事本加上命令行就完成了上面的玩法

dotnet new console -o KugaybafalJerekunaycerecha
cd KugaybafalJerekunaycerecha
notepad Program.cs

>using System;
>using System.IO;
>
>namespace KugaybafalJerekunaycerecha
>{
>    class Program
>    {
>        static void Main(string[] args)
>        {
>            Console.WriteLine(Path.GetFileName("https://blog.lindexi.com/lindexi.html"));
>        }
>    }
>}

保存
dotnet run

我建议在设备上面安装 dotnet 工具，从官网 https://dotnet.microsoft.com/下载安装 dotnet 工具，就可以在命令行玩起来，在熟悉之后可以提高逗比技能

等等还有一个问题，如果添加了参数呢，如 https://blog.lindexi.com/doubi/lindexi.html?13216546 上面代码返回的是什么？

试试下面代码

        private string GetFileName(string url)
        {
            Uri uri = new Uri(url);
            return System.IO.Path.GetFileName(uri.AbsolutePath);
        }

可以看到上面的 AbsolutePath 就可以去掉了链接参数，不过用 uri 需要小心一些问题，请看 C#/.NET Framework 使用 Uri 类型表示文件路径时需要注意的问题 - J.晒太阳的猫 - 博客园

等等，我拿到的链接里面如果有中文名呢，请看 win10 uwp url encode

dotnet C# 如何让 Json 序列化数组时序列化继承类的属性

Thu, 03 Dec 2020 12:38:11 +0000

如果我使用的是具体的数组而我的数组是基类数组，而我传入子类的元素进行 json 序列化，可能发现 Json.NET 序列化没有包含子类元素的属性。如果要包含子类的属性或字段，可以在序列化的类数组定义为 object 数组的方式

我在用 WPF 写一个复杂的应用，我需要 ASP.NET Core 后台传输一个 AppData 类的数组，包含的属性如下

public class Lindexi
{
	public string Name { set; get; }
}

然后我有 Foo 类继承 Lindexi 类

public class Foo : Lindexi
{
	public string F1 { set; get; }
}

用下面代码序列化

        static void Main(string[] args)
        {
            Console.WriteLine(ToString(new Foo()
            {
                F1 = "林德熙是逗比"
            }));
        }

        static string ToString(Lindexi lindexi)
        {
            return JsonSerializer.Serialize(new [] { lindexi });
        }

运行可以看到输出

[{"Name":null}]

也就是 Foo 的属性被丢失了，在 .NET Core 3.0 可以使用 System.Text.Json 命名空间而不需要用 Newtonsoft.Json 库

此时解决方法是将数组定义为 object 数组

        static string ToString(Lindexi lindexi)
        {
            return JsonSerializer.Serialize(new object[] { lindexi });
        }

刚才定义的属性都是首字符大写的，转换为首字符小写的可以添加配置 PropertyNamingPolicy 请看下面

        static string ToString(Lindexi lindexi)
        {
            return JsonSerializer.Serialize(new object[] { lindexi }, new JsonSerializerOptions()
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
            });
        }

另外作为 json 上传到后台需要注意添加 “application/json” 请看代码

            var stringContent = new StringContent(json, Encoding.UTF8, "application/json");

win10 uwp 客户端如何发送类到 asp dotnet core 作为参数

如果你是被这个问题坑到的，同时一开始没有找到本文解决，请告诉我你之前搜的关键字，我去优化这个博客内容

dotnet CBB 为什么决定推送 Tag 才能打包

Thu, 03 Dec 2020 12:38:08 +0000

通过推送 Tag 才打 NuGet 包的方法的作用不仅仅是让打包方便，让打包这个动作可以完全在本地执行，无需关注其他系统的使用步骤。更重要的是可以强制每个可能被安装的 NuGet 包版本都能有一个和他对应的 Tag 号，原因是为了解决回退到某个版本发现有一个坑，这个坑是因为某个依赖库的版本问题，此时我期望最小改动，我虽然能拿到这个库的代码，但是我很难知道我这个版本安装的 NuGet 库对应依赖库的哪个 commit 的代码

我之前每次需要追踪某个 NuGet 包对应的依赖库的源代码的版本的时候，都需要进入打包服务器，查看打包日志，在这样很坑玩了很久，公司的配置管理员干掉了服务器，删除了日志。而我接到一个很古老的项目需要修复某个坑，此时这个项目引用了一个底层库的古老版本，此时我不能升级底层库，应该底层库的改动量太大了。但是我又很难定位我现在项目引用的 NuGet 库对应的底层库的哪个 commit 代码。后面只能通过二分的方法，用了几天的开发才完成

所以看到了我上面的坑，小伙伴大概也就能知道为什么我期望将 Tag 和 NuGet 包关联了

在我现在团队的约定里面，只要添加了 alpha 也就是预览版，就可以随意推送测试的 Tag 让服务器帮你打包 NuGet 包，然后在其他的项目安装。为什么会鼓励这样做？原因是有小伙伴说我的某个项目的开发依赖某个库，但是假设这个库一定是合并到主分支之后才能打出 Tag 打包，也就是小伙伴在某个项目的代码将一直不能推送。同时小伙伴也不能在 csproj 里面引用某个私有的版本，因为私有的版本只有小伙伴自己能构建通过，其他小伙伴可构建不通过

假设小 A 需要开发项目 F 而这个项目以来库 L 的更改
而库 L 的更改如果没有合并到 master 分支，就不允许推送 Tag 打包
此时小 A 如果推送了代码，这个代码引用了还没有被发布的 L 库的代码，那么其他小伙伴将无法构建通过
此时小 A 如果推送了代码，这个代码引用了小 A 本地生成的 NuGet 库，那么其他小伙伴将找不到这个 NuGet 库，无法构建通过
如果小 A 不推送代码，只是写了一个 commit 但是这个 commit 包含了 L 库的代码，但是没有在 csproj 里面升级 L 库版本，那么在回滚代码的时候，进入到这个 commit 将构建失败
如果小 A 在 commit 里面升级到他本地生成的 NuGet 库，那么回滚代码的时候，因为公共服务器不存在小 A 的本地的 NuGet 库，依然会构建失败

此时有一个叫头像的小伙伴出了一个馊主意，小 A 虽然 L 库代码没有被合并，但是可以知道这个 L 库被合并之后分配的版本号，此时就在 csproj 里面更新到这个版本，然后通过本地打包的方法引用和推送。但是这个方法存在以下问题

小伙伴本地打包第一次，发现翻车了，想要第二次打包，但是此时的版本号就重叠了，需要经过黑科技删除 NuGet 缓存重新构建，此时的效率特别低
小伙伴在这次 commit 写的代码是他认为发布的时候将会添加的公开方法，但是实际上最后发布的时候更改了公开方法，此时回滚到这个 commit 虽然能下载到 NuGet 库，但是发现 L 库的公开方法不匹配，构建失败

这就是为什么选用推送 Tag 打包的原因，允许小伙伴自己选择预览版的版本推送，自动打包，这样就可以在项目中使用此Tag 打出的预览版的代码。此时的 commit 其他小伙伴也能构建，回滚代码的时候也可以在公共服务器找到 NuGet 包或切换到对应版本的源代码

在 VisualStudio 的帮助下，使用推Tag打包的成本非常低，因为在 VS 里面只需要简单5次点击加上输入版本号就能完成 Tag 新建和推送，详细请看 VisualStudio 如何快速添加一个 Git Tag 推送

在本地推Tag打包还有一个好处是能提升不少的效率，有很多团队例如我现在的团队之前就是使用 jenkins 打包，这个工具太强大而让上手和维护成本都特别高，加上使用的小伙伴太多，服务器性能不足，每次打包都需要等待缓慢的系统响应。而通过 Tag 打包的方式可以隐藏这部分动作，所有动作都在本地执行。只有最后一步推送需要依赖 Git 服务的网络

从 DX 层面讲 WPF 渲染卡顿

Thu, 03 Dec 2020 12:38:00 +0000

这不是一篇深入底层的博客，很多细节还请看 DX 底层相关

小伙伴都知道在 WPF 里面使用了 DX 作为底层的渲染，在说到 WPF 卡顿的时候，还请小伙伴不要忘记 dx 部分也是可能存在卡顿的

在 WPF 的 OnRender 方法调用完成之后，会让 dx 做什么？此时的 WPF 将会完成完整帧的帧绘制命令的收集，此时也是 dx 的完整帧的帧绘制命令的完成。然后 dx 将会传递这些绘制命令到 UMD (User Mode Driver) 层

上面这句话仅在单 UI 线程时生效，如果采用多 UI 线程将会复杂一些，本文也不讨论多 UI 线程

而在 WPF 的 OnRender 方法完成之后，其实只是将帧绘制命令传递到 UMD 而不是在屏幕显示

在 UMD 的功能是负责将收集的绘制命令转换为 GPU 能处理的工作批次，也就是 work batches 和命令缓冲器（Display Lists）都是会根据对应的硬件 GPU 转换为不同的指令。这部分相对复杂，详细请看官方文档

在 UMD 完成之后，将会传递命令缓冲器回 D3D 让它将命令交给上下文队列，而KMD（ kernel mode GPU driver）层根据命令进行绘制，详细请看 GPU Rendering Pipeline——GPU渲染流水线简介 - 知乎

绘制完成之后将会在 GPU 缓存里面绘制出一帧完整的图像，而此时依然还不是在屏幕显示，需要等待 Present 命令才会让屏幕输出

通过上文，当然需要您读一下附加的博客，如果 WPF 的 OnRender 卡顿了，此时没有输出绘制命令到 DX 那么将会让完整帧的帧绘制命令延迟，这部分都在用户代码上，比较好调试

第二部分是在收集到的绘制命令转对应的绘制指令，这部分和具体的设备相关，如果给了一些有毒的绘制，那么转换时间将会比较长。换句话说是驱动程序需要使用比预期长的时间才能为GPU准备好需要渲染的某一帧，这部分会在 win7 的切换 dpi 不重启时，部分硬件设备复现

第三部分就是虽然我的绘制命令很少，但是这个绘制命令是一个大几何，刚好这个几何处理是 GPU 没有优化的，那么 GPU 需要使用超过比较长的时间。此部分的 GPU 设备在高端用户很少会遇到，但是我刚好是开发面向大量古老设备的应用，意味着我在使用 PathGeometry 时需要关注这个几何的大小

而根据垂直刷新，只要错过了这帧，将会在下一次绘制才会输出。也就是延迟 1ms - 8ms 对于延迟来说基本相同，也就是一次性能优化，至少需要优化超过 8ms 否则很少有效果

这里插入一点的是 Windows 系统不是只有一个应用在绘制，也就是在存在大量 CPU 的时候，将会让 GPU 的工作线程的运行被频繁中断，在一次渲染过程中存在大量线程的变化。换句话说，一个高性能的 UI 框架反而不是线程越多越好。这部分还请看 DirectX 多线程渲染性能相关

一篇文章入门DirectX 12 - 知乎

提交命令缓冲区 - Windows drivers

GPU Rendering Pipeline——GPU渲染流水线简介 - 知乎

本文的信息比较密集，我能讲的只是一个大概，更多还请小伙伴看本文引用的链接，特别是官方文档

我认为我写的内容最多只能算官方文档的笔记，唯一有点用的就是和 WPF 的关联

在 WPF 中，从 dx 层面出现的卡顿调试顺序建议如下

在 OnRender 的执行时间以及频率，通过 ContentRender 事件可以拿到频率。但是这个事件仅在调试下使用，同时监听此事件将会降低渲染性能
在 WPF 里面使用用到复杂的文本或几何
是否在 WPF 中开启大量的 UI 线程

另外，有一点需要注意，在调试渲染性能的时候，本身调试就会影响卡顿。换句话说用调试方式测量是在哪卡顿是不准确的，在渲染卡顿里面基本上就是慢1ms就是卡顿，而快7ms还没有优化

如果在没有找到 WPF 层的问题，而想要了解是否 dx 的渲染卡顿，可以尝试使用 Fraps 工具

从 gitlab 配置管理聊聊团队项目管理

Thu, 03 Dec 2020 12:37:57 +0000

每个团队都有适合各自的管理方法，本文仅记录我现在的团队所使用的项目管理方法。本文主要聊的是通过 gitlab 的里程碑以及 git 的分支管理项目的开发和送测的代码合并问题

在我现在团队开发的项目，其实是产品级。而不是项目级。什么是产品级什么是项目级，其实产品级就是作出一个面向终端用户或企业的产品。而项目级就类似接国家给出的某个项目，有明确的开发时间以及范围。这两者的管理上有极大的不同

本文仅聊产品级的开发

基本上产品级的项目的迭代可以分为两个部分，一个是开发阶段，另一个是送测阶段。我所在的团队相对来说是一个比较大的团队，每个功能点都可以分为开发前的预研，以及开发和送测三步部分。但总团队的迭代就只有开发和送测两个阶段。开发阶段做什么？主要是产品经理提出需求，于此同时对应的开发小伙伴进入预研技术（可选），接着美工和交互给出界面，同时软件工程师开始编写 demo 逻辑（或者说草图的界面加后台逻辑），在开发阶段完成的里程碑就是产品经理验收通过

整个团队的节奏就是开发阶段一部分小伙伴进入开发新功能，一部分小伙伴继续修上次虽然测试通过但是遗留的优化点以及预研新技术以满足产品大佬有趣的需求。而 CBB 小组，也就是公共组件小组开始造轮子

送测阶段看测试大佬的心情，整个团队主要工作就是修 bug 啦，没 bug 修的时候就做新技术预研以及和产品大佬讨论新需求的技术可行性

整个团队会动态分工为三波小伙伴，第一波是有当前开发阶段的新需求的，第二波是有下个阶段的需求需要预研技术的，第三波是脱离业务做轮子的 CBB 公共组件小组的小伙伴。这三波小伙伴人数和成员不固定，看团队的需要

一般送测阶段会接 bug 最多的就是第一波有新需求的小伙伴，在这些小伙伴忙不过来的时候，整个团队都会投进入协助。当然投进去协助也不是越多越好，人多了说不定 bug 越修越多，这就需要技术经理的调度

刚才也聊到了开发阶段和送测阶段，那么在 gitlab 上的配置上有什么办法用来辅助团队项目管理。理一下需求，团队里面有几个主项目，需要在开发阶段进行开发，而送测阶段的输出文件的版本迭代里面仅能包含修 bug 的逻辑，不得包含其他逻辑

除了主项目外，还有很多公共组件，同样要求在送测阶段不得将非修 bug 的逻辑放在送测阶段输出的包里面

因此简单的方法是 git 分至少两个分支，一个分支是 dev 开发分支，另一个是 release 发布分支。此时要求 dev 分支提供激进的开发。在送测的时候将 dev 分支切出一个 release 分支，然后所有修送测 bug 的逻辑合并到 release 分支，不允许其他逻辑也合并到 release 分支。在送测过程的输出的文件都是从 release 分支构建出来的

而对 release 的所有合并都会同步合并到 dev 分支上，因此可以保持 dev 分支最新

按照上面的管理方法需要在送测第一轮进入之前，将所有项目以及用到的公共组件从 dev 分支切为 release 分支

上面这一点相信大部分团队都会这么干，只是也有差别的，如微信的安卓开发团队，这个团队没有明确的 dev 分支，而是有一个激进分支，但任何新需求功能的开发都是基于上次的 release 版本。送测的时候是产品经理挑选某些功能分支切入到 release 分支，而不是直接切 dev 分支。原因在于微信将会放弃部分开发的需求功能，因此管理方式有些变更。而我团队里面很少会有放弃的需求，因此直接切 dev 分支就可以了

注意，复杂的分支管理和团队管理将会存在混乱，因此假设你的团队没有那么多有趣的需求，就如微信一样，可能放弃某个需求分支等，那么基本上两个分支就满足开发需求了。理论上越简单越好

好，以上是开发分支的，对于公共组件来说，也跟随项目切换 dev 和 release 分支。跟随的好处是让公共组件库在送测的时候也可以通过 release 分支打包，解决送测需要合入代码的控制。另外因为命名上和主项目相同，因此开发小伙伴只需要记住想要合并到主项目的 dev 的代码就合并到 dev 分支，想要合并到主项目的 release 分支的代码就合并到公共组件的 release 分支就可以

接下来另一个需求是统计变动。理论上每次送测之前都需要项目管理或技术经理了解当前的改动有哪些，可以用于辅助编写送测说明。此时的管理我推荐使用里程碑的方式

在 gitlab 上可以开启里程碑，进入送测的时候，切 dev 分支到 release 分支。然后创建一个版本里程碑，此后所有合并到 release 分支的代码都设置此里程碑。同理，所有公共组件也一样

这样做的好处是可以在送测之前知道具体有哪些代码被合并到 release 分支，可以了解到具体有哪些 MR 被合并，方便统计以及填写送测说明

当然，默认开发的 dev 分支也一样创建里程碑。默认开发阶段将创建里程碑，所有合并到 dev 分支的 MR 都设置此里程碑。在送测阶段从 dev 切 release 时，将关闭此里程碑，开启下一个 dev 分支对应的里程碑

因此大概的做法就是两个里程碑对应 dev 和 release 分支，这两个分支对应开发的两个阶段

大概这样的管理既简单，也能满足一部分需求

而一些自动化方向如果有做好，那么软件的质量也会相对好一点。如我现在团队使用 jira 管理需求和 bug 等，因此在 gitlab 上开启和 jira 的关联，此时可以做到每个 jira 都能知道对应的 MR 是哪些

而对公共组件来说，还需要提供旧版本的回溯，我通过推 Tag 打包的方法解决此问题，详细请看 dotnet CBB 为什么决定推送 Tag 才能打包

通过 Tag 打包的方法可以解决在多个主项目的时候，任意项目切换到任意版本时可以根据 NuGet 包版本知道对应的公共组件代码，方便补丁或在某个旧版本添加新功能

一般来说有团队技术经理或项目管理规定是否进入开发阶段或送测阶段，而由配置管理配置以上如分支切换以及里程碑创建

让 snoop 支持 .NET Core WPF 调试

Thu, 03 Dec 2020 12:37:50 +0000

在最新的 snoop 3.0.0-alpha0116 版支持了 .NET Core 的 WPF 的调试，只需要下载安装最新版本就可以

可以到 github 的 Releases 下载最新版本

如果网络太渣，可以到 csdn 下载

如何使用请看关于Snoop的用法_网络_muzizongheng的专栏-CSDN博客

开源公共组件仓库的更新日志应该如何写

Thu, 03 Dec 2020 12:37:46 +0000

在 GitHub 或 Gitlab 等开源的公共组件仓库里面，应该需要维护更新日志 CHANGELOG.md 文档，方便让用户和开发人员更简单明确的知晓项目在不同版本之间有哪些显著变动。但是没有任何一个能说服所有人的更新日志一定需要维护的原因，以及更新日志的文档格式

我推荐 keepachangelog 如何维护更新日志的做法，以下是 https://keepachangelog.com 的中文内容

以下是一个例子，这是放在 OpenXML SDK 库的更新日志

## Version 2.12.0

### Added
- Added `OpenXmlCompositeElement.AddChild(OpenXmlElement)` to add children in the correct order per schema (#774)
- Added `SmartTagClean` and `SmartTagId` in place of `SmtClean` and `SmtId` (#747)
- Added `OpenXmlValidator.Validate(..., CancellationToken)` overrides to allow easier cancellation of long running validation on .NET 4.0+ (#773)
- Added overloads for `CellValue` to take `decimal`, `double`, and `int`, as well as convenience methods to parse them (#782)
- Added validation for `CellType` for numbers and date formats (#782)

### Removed
- Removed explicit reference to `System.IO.Packaging` on .NET 4.6 builds (#774)

## Version 2.11.3 - 2020-07-17
### Fixed
- Fixed massive performance bottleneck when IndexReferenceConstraint and ReferenceExistConstraint are involved (#763)
- Fixed CellValue to only include three most signficant digits on second fractions to correct issue loading dates (#741)
- Fixed a couple of validation indexing errors that might cause erroneous validation errors (#767)
- Updated internal validation system to not use recursion, allowing for better short-circuiting (#766)

## Version 2.11.2 - 2020-07-10

### Fixed
- Fixed broken source link (#749)
- Ensured compilation is deterministic (#749)
- Removed extra file in NuGet package (#749)

## Version 2.11.1 - 2020-07-10

更新日志是什么？

更新日志（Change Log）是一个由人工编辑，以时间为倒序的列表，以记录一个项目中所有版本的显著变动。

为何要提供更新日志？

为了让用户和开发人员更简单明确的知晓项目在不同版本之间有哪些显著变动。

哪些人需要更新日志？

人人需要更新日志。无论是消费者还是开发者，软件的最终用户都关心软件所包含什么。当软件有所变动时，大家希望知道改动是为何、以及如何进行的。

怎样制作高质量的更新日志？

指导原则

记住日志是写给人的，而非机器。
每个版本都应该有独立的入口。
同类改动应该分组放置。
版本与章节应该相互对应。
新版本在前，旧版本在后。
应包括每个版本的发布日期。
注明是否遵守语义化版本格式.

变动类型

Added 新添加的功能。
Changed 对现有功能的变更。
Deprecated 已经不建议使用，准备很快移除的功能。
Removed 已经移除的功能。
Fixed 对bug的修复
Security 对安全的改进

如何减少维护更新日志的精力？

在文档最上方提供 Unreleased 区块以记录即将发布的更新内容。

这样有两大意义：

大家可以知道在未来版本中可能会有哪些变更
在发布新版本时，可以直接将Unreleased区块中的内容移动至新发布版本的描述区块就可以了

更多请看原文 keepachangelog 如何维护更新日志的做法，以下是 https://keepachangelog.com

以下是补充原文的部分

添加更改链接

如 OpenXML SDK 库的更新日志就做的很好，包含了具体是那个 PR 更改了对应的内容，如下面内容

Fixed massive performance bottleneck when IndexReferenceConstraint and ReferenceExistConstraint are involved (#763)

此时的 #763 就是对应的 PR 链接，或 Issues 链接，这样方便小伙伴对更新日志好奇具体实现的时候，可以找到代码

asp dotnet core 不正经的提升效率的单元测试方法

Thu, 03 Dec 2020 12:37:41 +0000

在写 asp dotnet core 时，如果没有单元测试保证，需要每个方法都从 web api 的入口开始运行，此时的执行效率是很低的。而如果写单元测试，又有一个坑的问题是写单元测试也是需要时间的。本文告诉大家一些提高效率的方法，这些方法不是正经的用法，但是能提升效率。至于能不能用好不好用就请观众老爷自己决定

CUnit 中文命名单元测试

在写单元测试时，小伙伴说需要让单元测试的方法名符合 条件_执行_结果 而要求这个方法命名为英文，我的英文就超级渣，这一点少珺小伙伴可以帮我证明。于是你会看到我写了以下的测试 WhenABuDengYuThree_DokanarkelawNinirahajairi_SetSlj 的命名，而如果要我优化这个单元测试的命名，大家都知道，有些小伙伴和我一样想一个好的命名可能占了开发的一半时间

写单元测试时，大量的单元测试方法命名将会占用大量的时间，让小伙伴不愿意写单元测试。或者写出来的单元测试的只有自己能读懂

在一个团队里面的，如果英文水平参差不齐，如我所在的团队有英文特别厉害的walterlv和天龙也有英文特别差国语也特别差的大壮哥，还有英文有毒的本渣。此时用英文命名的单元测试就是一个神坑，除非团队能成立一个改名部专门协助命名

一个解决方法是干脆用中文命名单元测试算了，请看下面单元测试

[TestClass]
public class DemoTest
{
    [ContractTestCase]
    public void Foo()
    {
        "当满足 A 条件时，应该发生 A' 事。".Test(() =>
        {
            // Arrange
            // Action
            // Assert
        });
        
        "当满足 B 条件时，应该发生 B' 事。".Test(() =>
        {
            // Arrange
            // Action
            // Assert
        });
    }
}

运行单元测试将看到这样的结果视图

只要有任何一个单元测试炸了，相信小伙伴看提示特别快就知道哪里炸了

使用这个库的前提是用 NuGet 安装 MSTestEnhancer 库，如果是 SDK 格式的项目文件，可以添加下面代码

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
    <PackageReference Include="Moq" Version="4.13.1" />
    <PackageReference Include="MSTest.TestAdapter" Version="2.0.0" />
    <PackageReference Include="MSTest.TestFramework" Version="2.0.0" />
    <PackageReference Include="coverlet.collector" Version="1.0.1" />
    <PackageReference Include="MSTestEnhancer" Version="1.6.0" />
  </ItemGroup>

注意版本号需要你自己更新

在单元测试的方法里面，推荐写某个需要测试的方法，在方法上面添加特性 ContractTestCase 请看代码

    [ContractTestCase]
    public void Foo()

接下来在方法里面用一段字符串和 .Test 写出对应的单元测试

        "当满足 A 条件时，应该发生 A' 事。".Test(() =>
        {
            // Arrange
            // Action
            // Assert
        });

一个例子是我在DotNetGitLabWebHook用到的方法，代码请看 github 是不是觉得写起来特别快

用 CUnit(MSTestEnhancer) 能让团队内小伙伴写单元测试的效率提升，也能提升团队里面读单元测试以及单元测试炸了解决的效率

现在问题只有一个，你的团队内对中文的看法是如何？千万不要在我的博客下评论，我的博客的评论做的很渣，如果有很多人都在评论我的博客就用不了

利用原有依赖注入

在 asp dotnet core 的各个类可以在构造函数添加依赖注入的方法，如我的DotNetGitLabWebHook就在各个类里面的构造函数添加了依赖注入

在 asp dotnet core 默认的构造函数依赖注入非常好用，例如我的 GitLabMRCheckerFlow.cs 用到两个类 Notify 和 FileChecker 类，而 Notify 用到了 IConfiguration 配置，于是我可以这样写

    public class Notify
    {
        /// <inheritdoc />
        public Notify(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // 忽略代码
    }

    // GitLabMRCheckerFlow.cs

            public GitLabMRCheckerFlow(Notify notify, FileChecker fileChecker)

在 Startup.cs 的 ConfigureServices 添加注入

            services.AddScoped<GitLabMRCheckerFlow>();
            services.AddScoped<Notify>();
            services.AddScoped<FileChecker>();

代码请看 Startup.cs

此时获取对象的方法都是放在构造函数参数，此时各个参数对应的类的创建也会自动注入构造参数。如在 GitLabMRCheckerFlow 需要传入 Notify 参数，而创建 Notify 类需要传入 IConfiguration 参数，这些都会在自带的依赖注入完成

在写 Controller 的单元测试时，难道我是需要运行一个 ASP.NET Core 服务，然后用 postman 进行测试？这样的效率太低了，可以尝试直接创建类调用对应的方法。而如果需要每个类都自己创建，这个创建效率实在太低，因为创建一个类需要在他的构造函数传入其他类，而这个类的构造函数可能后续修改，这样的单元测试小伙伴都想砍人

简单的方法是在单元测试创建服务

            var hostBuilder = Program.CreateHostBuilder(new string[0]);
            var build = hostBuilder.Build();
            var serviceProvider = build.Services;

上面的代码在单元测试里面调用，调用上面代码将会创建服务

然后拿到 serviceProvider 创建对象。如我需要测试 GitLabWebHookController 我可以给他的构造函数每个参数都在 serviceProvider 获取，此时就不需要手动创建

        public void MergeRequestTest()
        {
            var hostBuilder = Program.CreateHostBuilder(new string[0]);
            var build = hostBuilder.Build();
            var serviceProvider = build.Services;
            
            using (var scope = serviceProvider.CreateScope())
            {
                var gitLabMrCheckerFlow = scope.ServiceProvider.GetService<GitLabMRCheckerFlow>();

                var gitLabWebHookController = new GitLabWebHookController(gitLabMrCheckerFlow);
                gitLabWebHookController.MergeRequest(TestMRJson.GetObject());
            }
        }

这里有细节是 Controller 的注入有很多参数都是在 Scope 需要创建

而如果我的 Controller 有某些参数需要使用 Fake 或 Mock 的，这些参数就自己用 Mock 啦

通过这个方法会降低单元测试运行速度，但是能提升写单元测试的效率

asp dotnet core 从零开始创建一个 WebApi 服务

Thu, 03 Dec 2020 12:37:37 +0000

本文将从最简单开始，新从全控制台开始创建一个 WebApi 服务，然后再使用 VisualStudio 创建服务

从官网 https://dotnet.microsoft.com/ 下载和安装最新版本的 dotnet 工具，这个 dotnet 工具还请安装 SDK 版本

安装完成之后，打开一个 cmd 控制台，输入 dotnet --info 确定安装成功

如看到有输出信息说版本是多少，那么就是安装成功了

接下来输入下面命令创建一个 WebApi 项目。此时如果 VisualStudio 还没有安装或更新到 VisualStudio 最新版本，那么请此时点击安装，大概控制台玩过之后差不多 VisualStudio 也安装差不多了

dotnet new webapi -o FarbenergarWacerabe

这里的 FarbenergarWacerabe 就是要创建的项目名，可以随意命名，但是推荐不要太诡异，如果发现创建失败了，自然就知道哪些命名不能作为项目名

通过 cd 命令进入到刚才创建的项目里面

cd FarbenergarWacerabe

然后将创建出来的项目先开跑

dotnet run

恭喜，现在一个 WebApi 服务就创建完成了。安装 ctrl+c 就可以结束这个 WebApi 服务了，首次运行需要还原下载 NuGet 库可能会需要一点时间。现在空白的 WebApi 服务还没有什么好玩的，让咱添加一个 Api 用于返回有趣的内容

默认创建的项目会添加一个 Controllers 文件夹，里面存放着控制器，控制器里面有方法，在方法上面标记特性就可以用来开启 WebApi 的服务啦，这里专业的说法是路由哦

我这里默认有一个叫 Controllers\WeatherForecastController.cs 的例子文件，如果叫其他名字也没关系，尝试打开他

在里面添加一个方法

        [HttpGet]
        [Route("/api/lindexi")]
        public string Lindexi()
        {
            return "林德熙是逗比";
        }

这个代码包含了三个部分内容，第一个部分就是 [HttpGet] 用来表示这个方法提供了 Http 的 Get 请求。而通过 Url 链接是 [Route("/api/lindexi")] 里面标记的 /api/lindexi 链接进行访问，也就是可以通过浏览器的 Get 请求也就是从地址栏输入网址访问到

第三部分就是方法本身，方法本身返回的值将会返回给请求方，如浏览器访问将会返回给浏览器，而客户端访问将会返回给客户端。如何开发一个客户端应用请看 win10 uwp 手把手教你使用 asp dotnet core 做 cs 程序

继续尝试运行代码

dotnet run

此时尝试从浏览器访问 https://localhost:5001/api/lindexi 注意这个端口需要根据控制台输出的值确定，一般都是 5001 表示 Https 的端口

info: Microsoft.Hosting.Lifetime[0]
      Now listening on: https://localhost:5001

首次从浏览器访问如果提示证书缺失如下面界面，只需要点击同意继续访问就可以了

此时应该可以通过浏览器看到了林德熙是逗比的输出了

VisualStudio

如果用 VisualStudio 进行创建需要如何做？首先需要让 VisualStudio 保持最新同时安装负载，我推荐需要勾选的如下图

打开 VisualStudio 点击新建项目，选择 ASP.NET Core Web 应用程序

输入项目名点击下一步

此时可以选择 API 应用等，本文主要告诉大家如何创建一个 WebApi 服务，所以请小伙伴选择 API 应用。在右侧可以选择是否开启 HTTPS 支持，如果是内部的应用，可以考虑不开启 HTTPS 支持。另外如果电脑上不部署 docker 还可以勾选 docker 的容器，勾选之后可以选择 Linux 容器或 Windows 容器

最简单的项目是两个都不要勾选

现在可以看到有以下文件，作用如下图

依然在控制器里面就包含了对外服务的相关方法，和上面用控制台创建的相同

控制器本身可以有多个，如下图创建一个简单的控制器

创建完成之后按下 F5 在 VisualStudio 中运行调试

在浏览器访问 https://127.0.0.1:5001/api/foo 就可以看到输出了 lindexi 的值。那么访问这个链接和我的代码是什么对应关系，请看下图

其实都是通过 Route 这个特性进行识别的，这个特性的功能大概可以水几篇博客哦，本文这里就不多说了，大概通过上面两个例子大家也能知道是如何使用的

大概这样就完成了一个 WebApi 服务的创建了。而除了创建应用之外，可能还需要进行打包发布什么的，这部分在 VisualStudio 的帮助下将会非常简单

设置访问端口

一般的应用在发布的时候都需要设置一个开启的端口，如果是作为非浏览器访问的 WebApi 或者非浏览器首页访问的 WebApi 很多都不会选择使用 80 等常用端口，以提高几乎可以忽略不计的安全性。在 ASP.NET Core 可以在 Program.cs 里面启动主机时设置监听的端口

通过添加 webBuilder.UseUrls("http://0.0.0.0:12307"); 就可以监听 12307 端口，前面的 0.0.0.0 表示本机的所有 ip 地址

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                    webBuilder.UseUrls("http://0.0.0.0:12307");
                });

这样就能将默认的 5000 端口替换为 12307 端口了，这个端口可以请小伙伴自己指定

此时上面的链接需要修改为 http://localhost:12307/api/lindexi 才能访问到

发布应用

发布应用只需要右击项目点击发布就可以了

我推荐如果是测试的话，可以直接选择文件夹输出，这样就不需要配置 Azure 虚拟机等，虽然这部分配置也十分简单

此时点击编辑可以进行设置是否使用框架依赖发布或独立发布

什么是框架发布？框架发布就是依赖对应的框架，我需要在服务器上面先安装 dotnet 工具然后我才可以运行这个应用。而独立发布就是我将所有的依赖全部放在一起，相比框架依赖的优点就是到服务器不需要部署安装环境，只需要运行我的程序就可以了。而缺点就是发布的文件会比较大，虽然这点大小可以忽略，大概就100M左右

完成配置之后，可以点击发布按钮，发布完成之后就可以将发布文件发送给服务器进行运行了。如果服务器上配置了 FTP 等，那么还可以省略上传的步骤。如果设置的是 Azure 虚拟机，部署上去之后还能帮忙跑起来

docker 发布

如果是想要其他小伙伴通过 Docker 运行我的服务也可以在 VisualStudio 上方便进行生成 Docker 文件，作为 docker 发布，在使用之前请安装 docker desktop 应用，可以从他的官网下载，虽然下载速度也是超级慢

如果在创建项目开始的时候有选择开启 docker 支持，那么默认就会创建 dockerfile 文件，而如果没有的话，请右击项目，选择 docker 支持

接着右击 dockerfile 点击生成 docker image 按钮

接着就可以通过命令行输入 docker image list 找到刚才创建的 image 了，此时如何推送 docker 和如何发布本文就不多说了，小伙伴自己百度去

我的网站写完成了之后，此时我想要让外网访问可以如何做？可以试试 dotnet core 通过 frp 发布自己的网站

而更详细的入门我推荐阅读官方文档，微软的官方文档是咱社区的一堆大神协助翻译的，质量非常好

ASP.NET Core 入门官方文档

官方的 Learn 平台还提供了实战例子，请看使用 ASP.NET Core 创建 Web API - Learn

更多阅读：

本文代码放在 github 里面也没有什么内容

Xamarin iOS 部署版本大于手机的系统版本

Thu, 03 Dec 2020 12:37:33 +0000

我觉得苹果肯定会坑我，如果我敢更新我的手机系统的话。苹果觉得像我这样的开发者就应该拖出去打靶，整个手机没几个应用是从应用商店下载的。但是作为开发者，我在使用 Xamarin 部署我的云输入法，在第一步创建的时候需要我使用 XCode 新建一个项目，而新建的项目默认都是需要使用更新版本的系统，此时部署将会失败。本文告诉大家一个简单的方法解决这个问题

如我师傅在使用 Xamarin 在 iOS 真机上部署应用进行调试博客上讲的，苹果为了提升开发者门槛，限制了 VS 创建应用的权限。苹果：这不是我说的，你不要瞎说

在使用 VS 部署应用之前，需要先在 XCode 中新建一个空白 iOS 项目，细节还请看使用 Xamarin 在 iOS 真机上部署应用进行调试

而新建的项目在 2020.10 时，将使用 14.0 的系统。但我的手机是 13.1.2 版本，我不想升级系统，强行选择手机然后部署将会提示下面代码

lindexi’s iOS 13.1.2 doesn’t match cloudkeyboard.app’s iOS 14.0 deployment target. Upgrade lindexi’s iOS version or lower cloudkeyboard.app’s deployment target.

一个简单的解决方法就是使用文本编辑工具将 iOS 项目代码里面所有的 14.0 替换为 13.1 就可以了

如果替换之后，发现跑不过，如提示 @main 是新版本才创建的功能，那一定是你的项目创建的模版选错了

要求选择 UIKit App Delegate 才可以

Xamarin iOS 部署项目提示 Failed to register bundle identifier 失败

Thu, 03 Dec 2020 12:37:31 +0000

这是我在开始部署其他小伙伴的 Xamarin 项目时，在 VS 上提示的失败如下： Failed to register bundle identifier: The app identifier “com.walterlv.CloudKeyboard” cannot be registered to your development team because it is not available. Change your bundle identifier to a unique string to try again 。这个提示的提示就是 Bundle Identifier 不对，原因有很多个，本文将一一告诉你

在 iOS 上有 Bundle Identifier 的概念，细节请看苹果官网以及申请方式请看 iOS项目的Bundle identifier的申请这部分的知识苹果更新很快，本文写在 2020.10 如果你阅读本文时的时间距离本文写的时间太远了，还请小心，本文有些知识也许被苹果改了

在 VS 上部署其他小伙伴的 Xamarin 项目的时候，我推荐是更改对方的 Bundle Identifier 用来解决 Failed to register bundle identifier: The app identifier "com.walterlv.CloudKeyboard" cannot be registered to your development team because it is not available. Change your bundle identifier to a unique string to try again 这样的问题，或者你加入到他的 Team 里面

在使用 Xamarin 在 iOS 真机上部署应用进行调试博客里面告诉大家，在部署 Xamarin 之前需要使用 XCode 新建一个空白项目

在新建的空白项目的项目名依然可以比较随意写入，但是在设置里面的 Bundle Identifier 的更改就有一定的要求了，这一段是对应在使用 Xamarin 在 iOS 真机上部署应用进行调试博客的 *[重要] 修改 Bundle Identifier 这一节中

这里的 com.walterlv.CloudKeyboard 是要求在 walterlv 组织下的哦，如果我没有在他的 Team 下，我的组织是 lindexi-gd 组织，那么在 *[重要] 修改 Bundle Identifier 这一节中的 Bundle Identifier 写 com.walterlv.CloudKeyboard 时将会因为组织名不对而失败

No profiles for 'com.walterlv.CloudKeyboard' were found
Xcode couldn't find any iOS App Development provisioning profiles matching 'com.walterlv.CloudKeyboard'

快速的解决方法是修改 Bundle Identifier 的值，将 com.walterlv 修改为 com.lindexi-gd 的值，同时回到 Xamarin 项目里面，做同样的更改

另外这个 Bundle Identifier 谨慎修改，如果没有给苹果交保护费，那在一周内可使用的不同的 Bundle Identifier 只有10个，如果超过了会提示 Your maximum App ID limit has been reached. You may create up to 10 App IDs every 7 days. 的代码

Xamarin XamlCTask 任务不支持 ValidateOnly 参数

Thu, 03 Dec 2020 12:37:29 +0000

使用 Xamarin 项目，添加一个额外的库项目，被 Xamarin.Form 引用，构建时提示“XamlCTask”任务不支持“ValidateOnly”参数。请确认该参数存在于此任务中，并且是可设置的公共实例属性

英文的提示如下

MSB4064: The "ValidateOnly" parameter is not supported by the "XamlCTask" task

这个算 Xamarin 4.3 的坑，解决方法是在 NuGet 升级到 4.5 就可以了

[Bug] Mixed Xamarin.Forms versions causes error MSB4064: The “ValidateOnly” parameter is not supported by the “XamlCTask” task · Issue #8209 · xamarin/Xamarin.Forms

Xamarin 使用 GTK 提示找不到 libglib-2.0-0.dll 找不到

Thu, 03 Dec 2020 12:37:26 +0000

在使用 Xamarin 开发 Linux 应用的时候，刚开始如果没有弄好 libglib-2.0-0.dll 的依赖库，那么将会在运行的时候，在 Gtk.Application.Init() 这句代码提示找不到这个库

解决方法是先到官网下载 GTK# 安装包或 mono x86 的应用

安装到默认路径，也就是在 C:\Program Files (x86)\GtkSharp\2.12\bin 路径，默认安装的时候会加入到环境变量

接下来到 C:\Program Files (x86)\GtkSharp\2.12\bin 复制 libglib-2.0-0.dll 文件到 xamarin 的输出文件夹，如 D:\lindexi\t\Xamarin\Cla\bin\x86\Debug\net47 文件夹里面，此时尝试运行，应该就不会存在这个提示

注意现在 GTK# 仅支持 x86 应用

DllNotFoundException: Unable to load DLL ‘libgtk-win32-2.0-0.dll · Issue #937 · mono/xwt

Unable to load DLL ‘libgtk-win32-2.0-0.dll’ — Xamarin Community Forums

Gnome - Tomboy - Unable to load DLL ‘libgtk-win 32-2.0-0.dll’

Index of /sources/gtk-sharp212

Xamarin.Forms/Xamarin.Forms.Platform.GTK at master · xamarin/Xamarin.Forms

jsuarezruiz/xamarin-forms-gtk-weather-sample: Xamarin.Forms GTK Backend Weather Sample

windows - Xamarin Studio, GTK 2.0 C# application, runtime error, can’t load libglib-2.0-0.dll - Stack Overflow

Xamarin 从零开始部署 iOS 上的 Walterlv.CloudKeyboard 应用

Thu, 03 Dec 2020 12:37:23 +0000

本文将告诉大家如何从零开始在 iOS 上部署 Walterlv.CloudKeyboard 应用。这个 Walterlv.CloudKeyboard 应用是一个云输入法应用，在 GitHub 完全开源，采用 Xamarin 开发，用途是让手机接收电脑端的打字输入的输入法。因为我没有在 iOS 上找到任何一款稍微能用的输入法，因此只能拜托太子帮我开发一款应用了。太子很给力，帮我开发完成了，但现在的问题就是我如何在我的手机上部署。本文将记录我的部署步骤

太子说：才不是从零开始，第一步就可以放弃，因为第一步是需要去买一台 mac 设备。然后第二步申请开发者，受限于网络，又能让一波开发者放弃了

这部分内容会被苹果不断改改改，因此在阅读本文的时候，请注意你的右下角时间。我写本文的时候是在 2020.11.03 如果你的当前时间距离我写的时间太远了，那么还请小心

假定现在有一台 mac 设备，嗯，我是没有的，于是我就去偷了太子的设备，毕竟他帮我开发了 Walterlv.CloudKeyboard 应用，免费开发应用送设备，听起来逻辑是对的

然后假定现在有一个开发者账号，此时才是真的开始步骤

先通过苹果的应用商店，花费3天的时候下载和安装完成 XCode 开发工具…… 是不是3天，取决于网速

打开 XCode 点击新建应用

在新建应用界面选择好 Team 和输入随意应用名，这个应用名不关键。接着选择 UIKit App Delegate 用于支持 iOS 13 版本，如下图

随意选择一个文件夹保存项目

新建完成之后，大概可以看到的界面如下

进入项目的选项页面，双击或右击项目点选项都可以进入此页面

先放开 XCode 应用，再花三天时间安装上 VisualStudio 以及 Xamarin 功能，从 https://github.com/walterlv/Walterlv.CloudKeyboard 下载好代码然后打开

以下界面是在 VisualStudio 上，咱需要在 VisualStudio 上修改捆绑包标识符，修改方法就是双击 Info.plist 文件

以上关键的就是捆绑包标识符的内容

这里的捆绑包标识符的命名规则是 com.开发者团队名或组织名.随意的应用 格式，而我的开发者团队名实际是 lindexi-gd 而不是 lindexi_gd 或 lindexi 哈，这部分需要在申请开发者账号的时候记录哦

这一步的难度最大的地方在于了解自己的开发者团队名或组织名是什么

在 Walterlv.CloudKeyboard 项目上包含了两个项目，一个是 iOS 键盘应用，另一个是键盘扩展。这两个项目都需要做相同的更改，刚才修改好了 Walterlv.CloudKeyboard.iOS 项目。现在需要修改 Walterlv.CloudKeyboard.iOS.Extension 项目

双击 Walterlv.CloudKeyboard.iOS.Extension 项目的 Info.plist 文件，可以看到如下界面

编辑捆绑包标识符，内容就是在原先的 Walterlv.CloudKeyboard.iOS 项目的捆绑包标识符基础上的后面加上 .Keyboard 如下图

修改完成之后，记得点保存

下一步再回到 XCode 里面，点击签名选项卡，在 Bundle Identifier 输入框里面输入刚才在 Walterlv.CloudKeyboard.iOS.Extension 项目的 Info.plist 文件写的捆绑包标识符，点击 Tab 键失焦，用于生成开发者签名

生成之后大概可以看到如下界面

接着需要在 XCode 先部署一下，在 XCode 部署的作用就是生成一个占坑的应用，用于解锁信任证书

部署之前需要点击选择自己的 iOS 应用，当前就需要让自己的 iOS 应用和 mac 相连了

可以看到我的手机的版本比较低，而我也不想升级，因为一升级了，我的一堆应用就用不了。而刚才为了让应用在我手机能部署，也就选择了 UIKit App Delegate 框架

但此时依然部署将会失败，原因是在 .xcodeproj 文件里面记录的版本号会更高，使用 VisualStudio Code 打开 .xcodeproj 文件，替换掉版本

点击部署按钮，可以看到 XCode 执行安装

但是在安装完成之后，会提示启动失败

在 XCode 上提示 Could not launch “foo” Security 的原因就是发者没有被信任

回到手机上，可以看到 XCode 安装的应用

点击打开这个应用将会失败，因为无法验证 App 需要信任开发者

添加信任的步骤如下

打开设置，进入通用

进入设备管理界面

可以在设备管理界面里面看到自己的证书，点击自己的证书

点击验证

等待一下网络，可以看到应用状态是已验证

此时再次打开 foo 应用，可以看到应用打开

以上的这一步关键就是为了在通用的设备管理里面同意加入自己的证书，这个在 XCode 安装的应用也就被称为占坑的应用

下一步就是尝试在 VisualStudio 开始部署自己的键盘应用，因为我的 mac 设备其实是太子的设备，只是被我偷过来而已，账号啥的信息还没切过来，在 VisualStudio 部署的时候将会提示 iOS code signing key ‘iPhone Developer walterxx@iCloud.com(F53jxxxxxx) not found in keychain.’ 如下图

解决方法就是右击项目，点击选项，修改捆绑包签名

进入捆绑包里面，修改预配配置文件

选择自己的预配配置文件和签名标识，注意不要选自动

选择之后的效果大概如下

上面这一步详细请看 Xamarin iOS 切换开发者账号之后的签名标识和预配配置文件更新方法

也就是说在发现这一步没有任何可以选择的时候，问题的原因就是没有在 XCode 的签名里面进行生成，需要确定在 XCode 里面生成，如下图

在 Bundle Identifier 输入之后，按下 Tab 键失焦，此时将会提示创建，如下图

此时再次在 VisualStudio 进行部署，如果提示因为存在同名的签名的应用，原因就是开始的时候在 XCode 创建的占坑应用用了当前在 VisualStudio 部署使用的捆绑包签名

 BundleIDConflictWithOtherIdentifier: App with identifier com.lindexi-gd.CloudKeyboard.Keyboard is already installed, so we can't install App Extension with that same identifier.
error MT1006: Could not install the application '/Users/lvyi/Documents/Codes/walterlv/Walterlv.CloudKeyboard/CloudKeyboard.iOS/bin/iPhone/Debug/device-builds/iphone10.3-13.1.2/Walterlv.CloudKeyboard.app' on the device 'lindexi': AMDeviceSecureInstallApplicationBundle returned: 0xe80000cc (kAMDBundleIDConflictWithOtherIdentifierError).

此时不能回到手机上删除刚才的占坑应用，因为这是一个占坑应用。如果被删除了，那么将会让刚才在设备管理的签名失效

因此解决方法就是再次回到 XCode 创建另一个应用，修改 Bundle Identifier 重新部署

重新部署之后，可以在手机上看到两个应用

删除掉一开始部署的占坑应用

重新回到 VisualStudio 点击构建部署，此时在手机上可以看到 Xamarin 的图标和部署上的应用

在 VisualStudio 启动调试的时候，可以看到 Xamarin 的界面

这是一个键盘应用，需要经过如下配置才能使用上

进入设置，进入通用，进入键盘

点击键盘

点击添加键盘

选择 CloudKeyBoard 点击之后可以看到如下界面

点击进入云键盘 Cloud 点击允许完全访问

此时就可以使用上 Walterlv 的云键盘了，这个项目在 GitHub 完全开源

开源地址请看 https://github.com/walterlv/Walterlv.CloudKeyboard

这就是整个部署的过程，步骤还不到 50 步，相信你被苹果坑几次就会部署了

Xamarin Forms 进度条控件

Thu, 03 Dec 2020 12:37:16 +0000

本文翻译：http://xamlnative.com/2016/04/14/xamarin-forms-a-simple-circular-progress-control/ 里面都是胡说的，如果看不懂可以联系邮箱源代码：https://github.com/billreiss/xamlnative/tree/master/XamarinForms/CircularProgress 最近作者需要做一个简单的圆形的等待控件在一个Xamarin Forms应用，效果可以看

看起来很容易做，不知道怎么微软就没有弄个这么好看，微软没有，我们来直接做，看起来这个很简单

原来的进度条是一个线，没有UWP那个ring，我要做一个，可以使用本地控制、自定义渲染器渲染、使用组件里面弄很多我之前做的、到Nuget找，这些都觉得不是我要的。

看到他们没有，我就很高兴，我可以做一个很厉害的，自然这里我是原文的那个，写了Xaml的大神

我首先拿出一个本子，我应该弄矢量图形，在Xamarin原生还没有，我会为每个平台定制渲染，所以他不支持我不能使用，我想到使用图片，矢量图片，既然想要图片我如何让很多图片看起来是一个

我想到简单使用两图，实际对称两图是表示4图，不停覆盖的两个图片表示进度，两个图片颜色不同

图片可以在：https://github.com/billreiss/xamlnative/tree/master/XamarinForms/CircularProgress/CircularProgress/CircularProgress.Droid/Resources/drawable

两个保存格式Png图片，一个图表示0-50%，我们叫第一图“completed”，第二“pending”，颜色深的是第一，进度我们需要一个completed，两个pending，我们先放completed，然后在它上面放pending，在pending对面放pending，第一个图在代码叫“progress1”，第二“background1”，第二个覆盖第一个，第三个pending旋转180，总的一个蓝色圆，这是0%

25%：我们旋转pending第二个，可以让看到下面的图，这个我们覆盖原来的pending因为颜色一样，所以我们就可以看到25%

50%：我们需要改变，两个completed，一个pending，pending覆盖completed，但是只是覆盖一个，他们的层次：

completed
pending
completed

可以让pending覆盖右边的completed，超过50%让pending右旋

如果觉得上面说的还是不知道，可以看代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xamarin.Forms;
 
namespace CircularProgress
{
    public class CircularProgressControl : Grid
    {
        View progress1;
        View progress2;
        View background1;
        View background2;
        public CircularProgressControl()
        {
            progress1 = CreateImage("progress_done");
            background1 = CreateImage("progress_pending");
            background2 = CreateImage("progress_pending");
            progress2 = CreateImage("progress_done");
            HandleProgressChanged(1, 0);
        }
 
        private View CreateImage(string v1)
        {
            var img = new Image();
            img.Source = ImageSource.FromFile(v1 + ".png");
            this.Children.Add(img);
            return img;
        }
 
        public static BindableProperty ProgressProperty =
    BindableProperty.Create("Progress", typeof(double), typeof(CircularProgressControl), 0d, propertyChanged: ProgressChanged);
 
        private static void ProgressChanged(BindableObject bindable, object oldValue, object newValue)
        {
            var c = bindable as CircularProgressControl;
            c.HandleProgressChanged(Clamp((double)oldValue, 0, 1), Clamp((double)newValue, 0, 1));
        }
 
        static double Clamp(double value, double min, double max)
        {
            if (value <= max && value >= min) return value;
            else if (value > max) return max;
            else return min;
        }
 
        private void HandleProgressChanged(double oldValue, double p)
        {
            if (p < .5)
            {
                if (oldValue >= .5)
                {
                    // this code is CPU intensive so only do it if we go from >=50% to <50%
                    background1.IsVisible = true;
                    progress2.IsVisible = false;
                    background2.Rotation = 180;
                    progress1.Rotation = 0;
                }
                double rotation = 360 * p;
                background1.Rotation = rotation;
            }
            else
            {
                if (oldValue < .5)
                {
                    // this code is CPU intensive so only do it if we go from <50% to >=50%
                    background1.IsVisible = false;
                    progress2.IsVisible = true;
                    progress1.Rotation = 180;
                }
                double rotation = 360 * p;
                background2.Rotation = rotation;
            }
        }
 
        public double Progress
        {
            get { return (double)this.GetValue(ProgressProperty); }
            set { SetValue(ProgressProperty, value); }
        }
    }
}

我们需要把图片放在不同平台的文件夹，ios放在Resources文件夹，Android放在 AndroidResource

我们把控件放MainPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="CircularProgress.MainPage"
             xmlns:local="clr-namespace:CircularProgress" BackgroundColor="White">
  <Grid>
    <local:CircularProgressControl x:Name="progressControl" Progress="0" HorizontalOptions="Center" VerticalOptions="Center" WidthRequest="60" HeightRequest="60"/>
  </Grid>
</ContentPage>

我们让time进度加0.1每0.02s

namespace CircularProgress
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
            Xamarin.Forms.Device.StartTimer(TimeSpan.FromSeconds(.02), OnTimer);
        }
 
        private bool OnTimer()
        {
            var progress = (progressControl.Progress + .1) ;
            if (progress > 1) progress = 0;
            progressControl.Progress = progress;
            return true;
        }
    }
}

不使用自定义渲染，可以在各个平台没有使用厉害的技术覆盖两个图做出从0-100%，可以使用不同角度表示0.001

本文：http://blog.csdn.net/lindexi_gd

Xamarin Forms 4.7 支持更简化的 Grid 行列布局写法

Thu, 03 Dec 2020 12:36:13 +0000

尽管非官方提供的 Grid 行列简化版本特别多，但是在最近这样的简写方法才被合并到了主仓库。整个 Xamarin Forms 都是开源的，任何小伙伴都可以发布自己的私有版本。也因此有很多有趣的小伙伴说，我这么好的功能就是不想放在官方，我只是用的爽就可以了。不过，也有很多小伙伴十分慷慨，我就是要放在官方，让更多的小伙伴用的爽。本文要和大家介绍的是一个用起来爽的功能

我的小伙伴 Morten Nielsen 和我吹水说他有一个提议被合并到了 Xamarin 的官方主仓库里面，可以让 Grid 的行列定义更加简单

让咱先看看原先版本的行列定义是怎样的

    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="1*" />
            <ColumnDefinition Width="2*" />
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="300" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="1*" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="25" />
            <RowDefinition Height= "14" />
            <RowDefinition Height="20" />
        </Grid.RowDefinitions>
        <!-- 忽略代码 -->
    </Grid>

这是标准版本的 Grid 行列布局定义，上面代码将定义了一个网格，可以看到代码量还是比较多的

而简化之后的版本，可以使用如下定义

<Grid ColumnDefinitions="1*, 2*, Auto, *, 300"
      RowDefinitions="1*, Auto, 25, 14, 20">
        <!-- 忽略代码 -->
</Grid>

是不是觉得瞬间代码就变少了

这个功能其实已经存在很久了，只是都没有合并到官方项目里面，毕竟这个写法还是有一定的争议的

看起来这个写法不错，那么接下来我要在 WPF 官方开源项目里面顶一下 Morten Nielsen 看看能不能将这样的代码也合并到 WPF 官方开源项目里面

如果能赶上的话，大概可以在 WPF 的 .NET 5 发布，也就是 WPF 5 的时候一起上

Xamarin Forms 构建 WPF 版项目失败提示 XamlC error XFC0000 错误

Thu, 03 Dec 2020 12:35:48 +0000

在 Xamarin Forms 从 4.7 到 4.8.0.1560 版本，在 Xamarin Forms 构建 WPF 版项目也许会提示 XamlC error XFC0000 : Cannot resolve type “Application” 构建失败

提示内容如下

App.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "Application".
AppShell.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "Shell".
Views/AboutPage.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "ContentPage".
Views/ItemDetailPage.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "ContentPage".
Views/ItemsPage.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "ContentPage".
Views/NewItemPage.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "ContentPage".

如 [Bug] XAML compiler broke with 4.7.0 · Issue #11101 · xamarin/Xamarin.Forms 所说，一个可以使用的方法是 Michael Schnerring 大佬提供的方法

在 csproj 中添加如下代码

<ItemGroup>
    <EmbeddedResource Remove="**/*.xaml" />
</ItemGroup>

详细请看 https://github.com/xamarin/Xamarin.Forms/issues/11101#issuecomment-678329339

另一个方法是我的方法，删除所有的 App.xaml 和 MainWindow.xaml 等文件，如 https://github.com/lindexi/lindexi_gd/tree/96c9063fdba9fe318eb099da67422de5cc9ae5af/XamarinNeller/XamarinNeller.WPF 项目所示，这样也能构建成功。细节请看 WPF 从零手动创建承载 Xamarin Forms 项目

为什么使用 GUID 做文件名不是好主意

Thu, 03 Dec 2020 12:28:12 +0000

在创建随机文件使用的时候，文件的命名是神坑，我看到一些代码里面使用 GUID 作为文件名，这不是一个好主意。推荐的做法应该使用 Path.GetRandomFileName 方法

为什么使用 Guid 作为文件名不是一个好主意，有以下原因

文件名冲突

有小伙伴认为使用 Guid 作为文件名就一定不会存在冲突，不好意思，如果你是工程师，那么应该会遇到一些非酋的用户，这部分用户将会遇到使用 Guid 创建的文件也重复的问题

有小伙伴会说，创建 Guid 不是会根据网卡还有时间等超级多的内容创建的？其实涉及的越多，就越不可靠

因此在需要创建新文件的时候，请不要认为使用 Guid 创建的就是不会冲突的文件，一定是新文件

文件长度

默认在 Windows 下的文件名加上路径的长度最长是 260 个字符，而一个 Guid 一般长度是 36 个字符，因此如果来个 7 层文件夹就炸了。有趣的是 AppData 文件夹的路径大部分用户差不多有 30 个字符以上，如果再拼接上应用名等，此时差不多也有 36 个字符

使用 Guid 作为文件名的小伙伴，小心也有小伙伴用来做文件夹名

那么使用 Path.GetRandomFileName 有什么优势

文件名更短

其实 Path.GetRandomFileName 仅仅是返回随机的字符串，这个字符串你用来做文件名也好，用来做文件夹名也好。官方的推荐是这个字符串仅仅只用来做文件或文件夹名，不要用来做其他安全相关的用途

默认的 Path.GetRandomFileName 返回的字符串长度是 12 个字符，比 Guid 小3倍，也就是差不多到 21 层的文件夹才会炸

更高的性能

创建 Path.GetRandomFileName 的速度比 Guid 的速度快，原因是 Path.GetRandomFileName 需要的计算量很小。就等小伙伴有空帮我测试一下啦

安全性不变

理论上 Path.GetRandomFileName 生成的文件冲突和使用 Guid 的文件冲突是几乎等价的，或者说在一个数量级，尽管 Guid 的文件名更长

因此使用 Path.GetRandomFileName 代替 Guid 创建随机文件看起来特别有优势。但依然使用 GetRandomFileName 有一个不足，或者说他的一个功能反而不是咱需要的。这就是 GetRandomFileName 创建的文件会加上诡异的后缀，如 tochgevm.edn 这个文件

如果有一些垃圾代码只是判断存在一个 . 作为文件后缀名的，和这些代码对接也许就会炸

推荐的创建文件名的方法如下

        private static string GetNewFileName(string folder)
        {
            while (true)
            {
                var file = Path.GetRandomFileName();
                file = Path.Combine(folder, file);
                if (!File.Exists(file))
                {
                    return file;
                }
            }
        }

上面代码依然无法解决多线程写文件的文件安全问题，依然可以在多进程或多线程获取文件名时文件不存在，但是在准备创建文件时，发现文件存在了

如果你发现使用上面代码遇到文件存在的坑时，请联系我，我要请你买彩票

为何 WPF 对 vcruntime140 有引用

Thu, 03 Dec 2020 12:28:12 +0000

通过阅读 WPF 官方开源仓库的代码和文档，可以了解到在进行独立发布的时候会在仓库里面带上 vcruntime140 的原因

在独立发布的时候，可以在仓库里面找到 vcruntime140.dll 这个文件

这是因为 WPF 框架用到了两个使用 C++\CLI 的项目，分别是 DirectWriteForwarder.dll 和 System.Printing.dll 库

这两个库在进行发布的时候需要引用 vcruntime140.dll 这个文件，如果进行 Debug 下发布的时候需要引用 vcruntime140d.dll 文件

如果不将这个文件带入独立发布的文件里面，那么将要求用户去安装 VC 的运行时，这个将会带来一个神坑，就是 C++ 环境问题。而这里的 WPF 只是需要这个文件而已，所以在独立发布的时候将带上这个文件，此时用户端就无需安装 VC 运行时

因为默认的 vcruntime140.dll 会在应用程序运行的时候根据环境的不同会有选择冲突，同时如果有依赖某些有趣的库，这些库也许对 vc 运行时也有依赖，但是 WPF 用的版本也许和引用的库是不相同的，为了减少这部分的冲突，微软改名部将重写分发的vcruntime140.dll 修改为 vcruntime140_cor3.dll 也就是实际发布的时候看到的文件

为何 C# 的指针不是可空类型

Thu, 03 Dec 2020 12:28:12 +0000

在 C# 里面的指针实际上使用 int32 或 int64 存储，在 C# 里面的指针需要开启不安全代码才能使用，这里的指针是一个结构体，而结构体是存在值的

我尝试写出 byte*? foo 的时候，构建的时候 VS 提示下面代码

// Error CS1519: Invalid token '?' in class, struct, or interface member declaration

原因是 byte* 实际上等价一个 int32 或 int64 的结构体，看了下面代码就知道

byte* foo = null;
// 和下面代码是等价的
byte* foo = (byte*)0;

也就是此时的 byte*? 是不对的

如果要使用可空，可以使用 IntPtr? 代替，但是作用不大

为什么 WPF 软件在 win7 启动时会尝试调起 wisptis 进程

Thu, 03 Dec 2020 12:28:12 +0000

我看到一个问题是在 win7 系统上，如果开机启动的软件是 WPF 软件，而这个 WPF 软件在系统的 wisptis 进程启动之前就启动了，那么 WPF 将会调起 wisptis 进程。而在 wisptis 进程已经启动完成，此时启动 WPF 进程不会再打开新的 wisptis 进程。但是被 WPF 启动的 wisptis 进程存在这样的问题，在触摸屏上 win7 的双指打开右键菜单等功能不可用

在 WPF 启动时，将会在 Window 类的 Visibility 修改时调用到 WispLogic.RegisterHwndForInput 方法进行初始化触摸，这部分详细请看 WPF 触摸到事件而在初始化触摸时，需要用到 PenIMC 的逻辑

在 win7 系统上，触摸需要通过 wisptis 进程的辅助才能让 WPF 进程能够完成实时触摸，这里的 wisptis 是 Windows Ink Services Platform Tablet Input Subsystem 进程，用于处理触摸书写等功能。也是 RealTimeStylus 的提供，通过一些不靠谱的文档和经验，其实 PenIMC 的核心逻辑就是 RealTimeStylus 提供的。上面这句话对或不对我不敢说，只能说用 RealTimeStylus 可以实现 PenIMC 的效果，而且 API 和参数差不多

那么 PenIMC 又是什么呢？其实 PenIMC 是 penimc2_v0400.dll 文件，在不同的版本的 .NET Framework 和系统上这个文件是不同的，包括文件名也不同，看这个文件命名就知道。没错，你可以在 penimc2_v0400.dll 文件所在的文件夹找到一堆 penimc 文件。这个文件就是提供给 WPF 的触摸核心 PenThreadWorker 的 COM 组件（其实没有文档说这货是纯 COM 组件）也就是和触摸相关的

也就是在 WPF 窗口打开显示将会初始化触摸，初始化触摸需要依赖 PenIMC 而假设这个库本质是 RealTimeStylus 的封装，那么依赖于 win7 的 Windows Ink Services Platform Tablet Input Subsystem 服务，此时在我看不到的代码判断了 wisptis 进程的启动

而为什么 WPF 启动的 wisptis 进程有很多坑？只是启动进程权限问题，更详细我也不知道

规避方法是什么？其实不让触摸执行也就是可以了，但是我如何让 WPF 还能交互？没关系，假装自己是一个古老的应用，只支持鼠标消息就可以啦。但是我想要做多指触摸怎么办？先不要触摸，等待 wisptis 进程启动之后，通过 WPF 模拟触摸设备方案重新注册一遍触摸

我一开始启动太快了，没关系，我一开始启动的是一个 win32 的启动图，等待后台逻辑判断 wisptis 启动之后，我才打开 WPF 的窗口。根据上面的说法，其实窗口没有修改 Visiliblity 之前是不会初始化触摸的，也就是不会启动 wisptis 进程的

现在 win7 已经不受微软支持了，是时候升级 win10 啦

WPF 从零手动创建承载 Xamarin Forms 项目

Thu, 03 Dec 2020 12:27:51 +0000

现在完全开源的 Xamarin Forms 是支持使用 WPF 进行承载，也就是使用 Xamarin 开发的控件等是可以在 WPF 项目使用的。本文来告诉大家如何在 WPF 中运行 Xamarin Forms 项目，让 Xamarin Forms 构建为 WPF 应用

默认的 VS 没有加上 WPF 的模版，而官方文档 WPF Platform Setup - Xamarin 旧了一点，因为社区的开发比较激进，而文档没有更新

如果你按照官方文档玩，预计会在构建的时候看到如下提示

 App.xaml : error :  : XamlC error XFC0000 : Cannot resolve type "Application"

当然，现在是 2020.07.31 也许你看本文的博客，官方文档更新了，而本文也失效了。此时请不要以为我在骗你

上面代码的原因是此时不需要使用 App.xaml 了，也不需要使用 MainWindow.xaml 了，让咱手动从零开始创建

当然，需要先存在一个 Xamarin Forms 项目哈，最好这是一个使用模版重新创建的项目，使用的版本都是 4.8 以上。我推荐是新创建一个，这样你通过之后，才进行修改，能解决因为自己原有的 Xamarin Forms 项目的坑让代码构建失败

新建一个叫 Xx.WPF.csproj 的项目，请将 Xx 替换为你自己的名字。使用 WPF 项目没有安卓项目那么弱，对命名长度要求比较多，在安卓项目里面如果你敢将名字命名比较长，那么将会因为路径太长炸掉，详细请看 Xamarin 构建安卓失败因为路径太长

在 Xx.WPF.csproj 添加如下代码

<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net472</TargetFramework>
    <UseWPF>true</UseWPF>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Xamarin.Forms.Platform.WPF" Version="4.8.0.1269" />
  </ItemGroup>

</Project>

可以看到上面代码的是十分简单的逻辑代码。但是如上面代码写的，使用的 TargetFramework 版本是 .NET Framework 4.7.2 这就意味着最低支持的系统是 Win7 带 Sp1 的系统。因为 Win7 非 sp1 最高版本 .NET Framework 是 4.5.2 同时不支持 .NET Core 任何版本，而 Win7 加上 Sp1 的系统能支持到 .NET Framework 4.8 的版本和 .NET Core 版本

那为什么需要采用 .NET Framework 4.7.2 的版本？因为需要有 OpenTK 的支持，而 OpenTK 最低是 .NET Framework 4.6.1 因此暂时无法降级到 .NET Framework 4.5 版本用来支持 Win7 非 sp1 系统

好，继续写一个叫 Program.cs 的类，小伙伴可以看到，一个 WPF 程序是只有 csproj 文件和 Program.cs 文件就可以完成对 Xamarin Forms 项目的承载

在 Program.cs 创建主函数

        static void Main(string[] args)
        {

        }

注意需要给 Main 添加 STA 线程

        [STAThread]
        static void Main(string[] args)
        {

        }

如果没有加上这个特性，那么将会在运行提示如下代码

System.InvalidOperationException:“调用线程必须为 STA，因为许多 UI 组件都需要。”

接下来就是创建 Application 创建 WPF 应用，然后运行消息调度，接着加载 Xamarin Forms 应用作为界面

            var application = new Application();
            Forms.Init();
            var formsApplicationPage = new FormsApplicationPage();
            formsApplicationPage.LoadApplication(new XamarinNeller.App());
            application.Run(formsApplicationPage);

此时就完成了，试试运行一下

代码放在 github 欢迎小伙伴访问

WPF 绑定继承的样式提示只能根据带有基类型 IFrameworkInputElement 的目标类型的 Style 样式

Thu, 03 Dec 2020 12:27:51 +0000

在 WPF 中，如果有一个样式是继承另一个样式，而样式没有使用 TargetType 那么在运行的时候会提示只能根据带有基类型 IFrameworkInputElement 的目标类型的 Style 样式

在界面添加下面代码

    <Window.Resources>
        <Style x:Key="Style1" TargetType="{x:Type ButtonBase}">
        </Style>
        <Style x:Key="ButtonStyle1" BasedOn="{StaticResource Style1}"></Style>
    </Window.Resources>

    <Grid>
        <ToggleButton Style="{StaticResource ButtonStyle1}"></ToggleButton>
    </Grid>

运行将会提示

只能根据带有基类型“IFrameworkInputElement”的目标类型的 Style。

调用的堆栈

   at System.Windows.Style.Seal()
   at System.Windows.StyleHelper.UpdateStyleCache(FrameworkElement fe, FrameworkContentElement fce, Style oldStyle, Style newStyle, Style& styleCache)
   at System.Windows.FrameworkElement.OnStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
   at System.Windows.DependencyObject.OnPropertyChanged(DependencyPropertyChangedEventArgs e)
   at System.Windows.FrameworkElement.OnPropertyChanged(DependencyPropertyChangedEventArgs e)
   at System.Windows.DependencyObject.NotifyPropertyChange(DependencyPropertyChangedEventArgs args)
   at System.Windows.DependencyObject.UpdateEffectiveValue(EntryIndex entryIndex, DependencyProperty dp, PropertyMetadata metadata, EffectiveValueEntry oldEntry, EffectiveValueEntry& newEntry, Boolean coerceWithDeferredReference, Boolean coerceWithCurrentValue, OperationType operationType)
   at System.Windows.DependencyObject.SetValueCommon(DependencyProperty dp, Object value, PropertyMetadata metadata, Boolean coerceWithDeferredReference, Boolean coerceWithCurrentValue, OperationType operationType, Boolean isInternal)
   at System.Windows.DependencyObject.SetValue(DependencyProperty dp, Object value)
   at System.Windows.Baml2006.WpfKnownMemberInvoker.SetValue(Object instance, Object value)
   at MS.Internal.Xaml.Runtime.ClrObjectRuntime.SetValue(XamlMember member, Object obj, Object value)
   at MS.Internal.Xaml.Runtime.ClrObjectRuntime.SetValue(Object inst, XamlMember property, Object value)

原因是 ButtonStyle1 没有设置 TargetType 所以解决方法如下

        <Style x:Key="ButtonStyle1" TargetType="{x:Type ButtonBase}" BasedOn="{StaticResource Style1}"></Style>

给 ButtonStyle1 添加 TargetType 属性

本文代码放在github欢迎小伙伴访问

聊聊 2020 的 dotnet 各大开源项目仓库的情况

Thu, 03 Dec 2020 12:27:51 +0000

现在是 2020.06.21 我来聊聊我所关注的 dotnet 的几个大开源项目的活跃以及定位情况。包括 WPF 和 WinForms 和 Xamarin 和 ASP.NET Core 和 Blazor 仓库

没有被点名的仓库不代表不活跃和不重要，只是我精力有限，没有参与开发。没有在局里面，不好评论

现在的各个仓库的分工如下：

Windows Forms 负责全平台商业化使用，主要是 Windows 和 Linux 系统，同时支持兼容大量诡异的设备。而且开源部分正在疯狂怼功能
WPF 负责 Windows 平台下的应用开发，支持 Win7 sp1 及以上。注意，如果需要支持 xp 依然需要使用 .NET Framework 4.0 之前版本
Xamarin 负责移动端，以及 PC 的 MAC 系统的应用开发。兼职负责 Linux 系统的应用支持，通过 GTK 的方式，有多少坑完全取决于想要支持的 Linux 系统，在 Ubuntu 下相对稳定
Blazor 负责浏览器端的应用开发
ASP.NET Core 负责服务器后台的应用开发，是当前成熟度最高的项目。竟然成熟度比 WPF 还高，哈哈，原因是 WPF 开小差了6年

关于开源情况如下：

dotnet runtime 最活跃的项目，用于提供给上面所有仓库，还包括此外的所有 dotnet 项目的运行时和底层库的支持，是整个 dotnet 的基础。有大量的硬件厂商对 dotnet 做特别优化，如 Intel 这个好基友，还有最近炒的比较火的龙芯也都给了运行时很多支持
ASP.NET Core 这个仓库现在主要是有 Azure 的小伙伴在维护，作为微软三架马车之一的 Azure 有着雄厚的资金，例如给了整个 GitHub 提供所有仓库免费的构建服务器等，有 Azure 超级可怕数量的超强工程师在不断堆代码。每天都有大量 PR 被创建和合并
Windows Forms 和 Xamarin 这两个是现在商业化开源应用开发最成熟的两个仓库，每天都有大量的国际上的各个公司的小伙伴在报很多诡异的 Bug 也都有在不断修复以及探索更强大的功能。这两个仓库官方投入比社区投入的比例要少一些
Blazor 在正式发布 WebAssembly 版本之后进入了疯狂修 Bug 状态，现在属于初步状态，特别适合小伙伴想要了解 WebAssembly 以及一个大型项目维护是如何做的，推荐小伙伴参与进去
WPF 现在有很多小伙伴将积攒了很多年的 Bug 不断扔到 Issues 上面，因为 WPF 按照 xx 的统计，是被最多使用的框架（和上面 ASP.NET Core 和 WinForms 和 Xamarin 等比）因此任何改动都需要十分小心，牵一发而动全身。现在整个团队都在努力搞自动化测试，只有自动化测试完成之后才有勇气合并来自社区的PR否则就只能合并没有 IL 变更的社区代码了。现在 WPF 开源项目是 Issues 天天打仗，而 PR 合并不多

以上所说官方非仅指微软，而是指 dotnet 官方组织，微软是其中最大的一个参与公司。此外在 ASP.NET Core 项目里面可以看到大量 AWS 的小伙伴在贡献代码，甚至谷歌家的小伙伴也会指手画脚。而 dotnet runtime 项目就比较可怕了，我没怎么去统计各方小伙伴的占比，总体看起来 PR 和 Issues 都上天了，每天都看不过来

我现在主要活跃的是在 WPF 仓库里面，其他项目主要是作为格式化工程师的存在，做做代码格式化和修一下注释而已

回答小伙伴几个问题：

现在这些开源项目是不是意味着可以白嫖

答案：没错，不收钱。动动手就可以将其他公司投入海量开发资金开发的项目收归己有。使用这些项目进行二次开发也好，或者在此框架上开发自己的商业应用也好，都不需要交钱给官方，也不需要为此纳税

我是否可以改改项目名，假装这些项目是我拥有的

答案：不用假装，你可以对外宣称是你的。上面这几个项目都没有限制你更改和分发你的私有版本，任何公司或个人都可以在此基础上魔改然后分发。只有一点是被限制的，不能你申请专利等之后反过来告官方项目侵权以及其他使用这些框架的公司侵权。但是你声明是自主产权，这个没问题（至少比其他改系统图标说是自己研发的要好很多）至少法律上讲没问题，如果你声明之后还能将一些有趣的代码提到官方，那这也是官方鼓励的

参与这些项目开发有什么门槛

答案：会使用谷歌翻译或有道翻译或会阅读和写英文…… 任何小伙伴都能免费注册 GitHub 帐号在这几个开源项目里面发 Issues 讨论和提 PR 添加代码

如果官方拒绝我的代码怎么办

答案：很正常，不是所有的代码都符合官方的思想。但是拒绝代码基本上不是一个人能做的决定，是需要整个团队里面多数开发者同意拒绝之后才会拒绝。也就是不是特别逗比的代码，基本上都会被合并或者改改改之后合并。如果咱真的觉得官方逗比，这么好的逗比的代码都不合并，咱可以另起炉灶，自己玩不带官方。可以自己分发自己的版本，如我想要给自己公司的产品定制 WPF 框架，没问题，我可以发布我自己的版本。如果自己发布的版本做的比官方更好，那么自己的这个项目将会最终取代官方的项目哦

我是否可以对外宣称我的产品受到微软的技术支持

答案：如果没有经过授权，是不可以的…… 就像咱的软件在 Intel 的 CPU 上运行，咱是否可以说这个软件受到 Intel 工程师的技术支持？肯定是不成的啦

Roslyn 如何了解某个项目在 msbuild 中所有用到的属性以及构建过程

Thu, 03 Dec 2020 12:27:51 +0000

使用 SDK Style 格式的 csproj 十分简化，但是实际上的构建过程需要用到超级多的逻辑，那么如何知道在 msbuild 所使用的构建过程有哪些，定义了那些属性。有那些 target 文件参与了这个项目构建本文告诉大家一个方法，可以输出某个项目在 msbuild 中的完全使用到的 targets 和属性等

本文需要用到 -pp 这个命令。这个命令可以输出所有内联到此项目的构建过程的文件，以及将构建过程用到的指令输出到文件中。可以通过这个命令了解构建此项目所用到的导入的文件。使用这个命令将不会构建项目

这个命令添加可以参数，参数是输出文件，如果没有参数，就输出控制台

进入某个项目，输入下面命令就可以输出在 msbuild 视角的整个构建用到的内容

dotnet msbuild -pp:FullProject.xml

输入上面命令，将会输出 FullProject.xml 文件

这个文件的内容很多，大概如下

可以加上平台，只输出某个平台下使用的构建过程

dotnet msbuild -p:TargetFramework=netcoreapp2.0 -pp:FullProject.xml

WPF 给任意控件通过按下移动抬起封装点击事件

Thu, 03 Dec 2020 12:27:51 +0000

其实点击这个事件是可以通过按下移动和抬起三个事件封装出来的，本文提供给大家一个辅助的方法，方便给任意的控件附加点击事件

在开始前需要了解一些本文点击的定义，本文点击的定义就是在按下到抬起过程中，不会出现长距离的移动，也就是从点击到抬起的点都是在一定范围内的。同时可以设置一定的时间范围，超过一定时间就是长按了，而不是点击了

根据这个特点咱开始来进行一个简单的封装，在封装之前先告诉大家封装之后的使用方法，下面代码的 uiElement 是一个 UIElement 控件

            InputHelper.AttachMouseDownMoveUpToClick(uiElement, UIElement_OnClicked);

        private void UIElement_OnClicked(object sender, EventArgs e)
        {
            
        }

实现 InputHelper 请看下面代码

    /// <summary>
    /// 输入层的帮助类
    /// </summary>
    public static class InputHelper
    {
        /// <summary>
        /// 将 MouseDown MouseMove MouseUp 封装为点击事件
        /// </summary>
        /// <param name="element">要被附加的元素</param>
        /// <param name="clickEventHandler">点击的事件</param>
        /// <param name="dragStarted">因为拖动而结束点击时触发</param>
        public static void AttachMouseDownMoveUpToClick(UIElement element, EventHandler clickEventHandler,
            EventHandler dragStarted = null)
        {
            var inputInfo = GetOrCreateInputInfo(element);
            inputInfo.ClickEventHandler += clickEventHandler;

            inputInfo.DragStarted += dragStarted;

            element.MouseDown -= Element_MouseDown;
            element.MouseDown += Element_MouseDown;
            element.MouseMove -= Element_MouseMove;
            element.MouseMove += Element_MouseMove;
            element.MouseUp -= Element_MouseUp;
            element.MouseUp += Element_MouseUp;
            element.LostMouseCapture -= Element_LostMouseCapture;
            element.LostMouseCapture += Element_LostMouseCapture;
        }

        /// <summary>
        /// 去掉对 <paramref name="element"/> 的点击时间的监听
        /// </summary>
        /// <param name="element"></param>
        /// <param name="clickEventHandler">点击的事件</param>
        /// <param name="dragStarted">因为拖动而结束点击时触发的事件</param>
        public static void DetachMouseDownMoveUpToClick(UIElement element, EventHandler clickEventHandler,
            EventHandler dragStarted = null)
        {
            var inputInfo = GetInputInfo(element);
            if (inputInfo == null)
            {
                return;
            }

            inputInfo.ClickEventHandler -= clickEventHandler;
            inputInfo.DragStarted -= dragStarted;

            if (inputInfo.IsEmpty())
            {
                element.ClearValue(InputInfoProperty);
                element.MouseDown -= Element_MouseDown;
                element.MouseMove -= Element_MouseMove;
                element.MouseUp -= Element_MouseUp;
                element.LostMouseCapture -= Element_LostMouseCapture;
            }
        }

        private static void Element_LostMouseCapture(object sender, MouseEventArgs e)
        {
            var element = (UIElement) sender;
            GetInputInfo(element)?.LostCapture();
        }

        private static void Element_MouseUp(object sender, MouseButtonEventArgs e)
        {
            var element = (UIElement) sender;

            GetInputInfo(element)?.Up(e.GetPosition(element));
        }

        private static void Element_MouseMove(object sender, MouseEventArgs e)
        {
            var element = (UIElement) sender;

            GetInputInfo(element)?.Move(e.GetPosition(element));
        }

        private static void Element_MouseDown(object sender, MouseButtonEventArgs e)
        {
            var element = (UIElement) sender;

            GetInputInfo(element)?.Down(e.GetPosition(element));
        }

        private static readonly DependencyProperty InputInfoProperty = DependencyProperty.RegisterAttached(
            "InputInfo", typeof(InputInfo), typeof(InputHelper), new PropertyMetadata(default(InputInfo)));

        private static InputInfo GetOrCreateInputInfo(UIElement element)
        {
            var inputInfo = GetInputInfo(element);
            if (inputInfo == null)
            {
                inputInfo = new InputInfo();
                SetInputInfo(element, inputInfo);
            }

            return inputInfo;
        }

        private static void SetInputInfo(DependencyObject element, InputInfo value)
        {
            element.SetValue(InputInfoProperty, value);
        }

        private static InputInfo GetInputInfo(DependencyObject element)
        {
            return (InputInfo) element.GetValue(InputInfoProperty);
        }

        private class InputInfo
        {
            public void Down(Point position)
            {
                _downedPosition = position;
                _downedTime = DateTime.Now;
                _isClick = true;
            }

            public void Move(Point position)
            {
                if (!_isClick) return;

                if ((position - _downedPosition).LengthSquared > ToleranceSquared)
                {
                    _isClick = false;
                    DragStarted?.Invoke(null, EventArgs.Empty);
                }
            }

            public void Up(Point position)
            {
                _isClick = _isClick
                           && (position - _downedPosition).LengthSquared <= ToleranceSquared
                           && DateTime.Now - _downedTime < ClickDuringTime;

                if (!_isClick) return;

                ClickEventHandler?.Invoke(null, EventArgs.Empty);

                _isClick = false;
            }

            public void LostCapture()
            {
                _isClick = false;
            }

            public double ToleranceSquared { set; get; } = 0.01;
            public TimeSpan ClickDuringTime { set; get; } = TimeSpan.MaxValue;

            public event EventHandler ClickEventHandler;
            public event EventHandler DragStarted;

            public bool IsEmpty() => ClickEventHandler is null && DragStarted is null;

            private Point _downedPosition;
            private DateTime _downedTime;
            private bool _isClick;
        }
    }

当前这个类还有什么不足？没有提供外面可以设置点击的范围，也就是从按下开始可以移动的范围的值，以及运行点击的时间。从上面代码可以看到写的是 TimeSpan.MaxValue 也就是没有分开点击和长按的设置

另外方法里面还添加一个可选的委托是点击变拖动的事件，这个事件用来了解当前本来是点击的，但是点击的时候移动的距离判断为拖动

这个封装的方法没有用到什么框架里面的功能，因此换个框架，如 UWP 按照这个思路修改一点代码应该也可以做出来

现在这个逻辑放进了HandyControl欢迎小伙伴使用

How to generate NuGet package with Git Tag version using GitHub Action

Thu, 03 Dec 2020 12:27:51 +0000

We can trigger the GitHub Action by Git tag pushed and we can read the Git tag name as the version. And then we can generate the NuGet package with this version.

There is a dotnet tool that can read Git tags as a version and write it to the version file.

Before using it, we should create the version file and import the version file.

We should use dotnet to install the dotnetCampus.TagToVersion tool and use the tool to write the Git tag to version file.

The step 1:

Adding the Directory.Build.props file to repo folder.

Writing the code to the Directory.Build.props file.

<Project>
  <Import Project="build\Version.props" />
</Project>

The step 2:

Making a folder named build and adding the Version.props file to this folder.

Writing the code to the build\Version.props file.

<Project>
  <PropertyGroup>
    <Version>1.0.5</Version>
  </PropertyGroup>
</Project>

The step 3:

Writing a GitHub Action configuration file in .github\workflows folder, for example create the .github\workflows\push tag and pack nuget.yml file

Making the Action trigger by tag push.

on:
  push:
    tags:
    - '*' 

Writing the tag as version by dotnet tool.

    - name: Install dotnet tool
      run: dotnet tool install -g dotnetCampus.TagToVersion

    - name: Set tag to version  
      run: dotnet TagToVersion -t ${ { github.ref } }

Building the package

# Build and publish

    - name: Build with dotnet
      run: dotnet build --configuration Release

    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:        
        nuget-version: '5.x'

    - name: Add private GitHub registry to NuGet
      run: |
        nuget sources add -name github -Source https://nuget.pkg.github.com/ORGANIZATION_NAME/index.json -Username ORGANIZATION_NAME -Password ${ { secrets.GITHUB_TOKEN } }
    - name: Push generated package to GitHub registry
      run: |
        nuget push .\bin\release\*.nupkg -Source github -SkipDuplicate
        nuget push .\bin\release\*.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${ { secrets.NugetKey } } -NoSymbols 

See https://github.com/dotnet-campus/dotnetCampus.TagToVersion

GitHub 的 Action 如何禁用

Thu, 03 Dec 2020 12:27:51 +0000

我 Fork 了小伙伴的 ant-design-blazor 仓库，这个仓库设置了每天自动同步样式，这个 Action 用到了源仓库的密钥，在我 Fork 的仓库一定跑不通过，于是每天我就收到一次构建不通过的信息。本文告诉大家如何禁用自己 Fork 的某个仓库的 Action 的执行

这是我 Fork 的 ant-design-blazor仓库，每天都告诉我构建失败

解决方法是禁用这个 Fork 仓库的 Action 构建，毕竟需要自动构建的都是将代码推送到源仓库，此时源仓库的 Action 都能触发，也就是我的仓库的 Action 其实没啥用

点击仓库的设置，进入 Actions 页面，点击禁用

如果我表示不让所有 Fork 我的仓库的小伙伴都需要做这个设置，我想要让我的代码仅仅只是在我的仓库运行，可以如何做？简单的方法是添加一个判断

if: github.repository == 'lindexi/doubi'

别的小伙伴 Fork 仓库的时候，拿到 repository 的值就是 小伙伴的名字/doubi 也就是判断不等于我的仓库，代码就不执行

上面的 lindexi/doubi 的意思就是 用户名或组织名/项目名 这就会跟随用户的 Fork 仓库修改值

那么这个 if 判断可以写在哪里？可以放在具体的构建步骤里面，如下面代码

    - name: Build with dotnet
      run: dotnet build --configuration Release
      if: github.repository == 'lindexi/doubi'

上面代码设置了只有在 lindexi 的 doubi 仓库才进行构建

如果不是干掉某个步骤，而是需要让整个 job 都不执行，可以在 job 下面使用 if 判断

jobs:
  build:
    runs-on: windows-latest
    if: github.repository == 'lindexi/doubi'

当然，判断仓库的拥有者也不错，请看代码

    if: github.repository_owner == 'lindexi'

更多请看 GitHub 操作的工作流程语法 - GitHub 帮助

Context and expression syntax for GitHub Actions - GitHub Help

GitHub 的 Action 判断仅在主仓库才执行脚本

Thu, 03 Dec 2020 12:27:51 +0000

我有一个 GitHub 项目，这个项目配置了仅需要在源仓库才能执行的 Action 如推送 NuGet 等发布动作。如何在 Action 里面设置让 Fork 的仓库不执行 Action 的步骤

想要设置 Action 不在 Fork 的仓库执行，只需要添加 if 判断，判断当前执行的仓库和设置的相同，即可执行，否则不执行

在 GitHub 的 Action 的判断使用 if 方法，条件可以是判断 repository 或 repository_owner 的内容

如使用下面代码判断，让构建步骤仅在 lindexi/doubi 仓库执行

    - name: Build with dotnet
      run: dotnet build --configuration Release
      if: github.repository == 'lindexi/doubi'

上面的 lindexi/doubi 的意思就是 用户名或组织名/项目名 这就会跟随用户的 Fork 仓库修改值。也就是小伙伴 frendguo 他 fork 了我的仓库，那么在他仓库里面执行的 action 拿到的 github.repository 的值是 frendguo/doubi 也就是判断逻辑不通过

判断不仅可以放在步骤里面，还可以写在 job 里面，让整个 job 都需要通过某个条件

jobs:
  build:
    runs-on: windows-latest
    if: github.repository == 'lindexi/doubi'

上面代码设置了只有在 lindexi 的 doubi 仓库才进行 build 这个 job 内容

当然上面代码写起来是针对仓库，不利于相同的一个组织内的复制粘贴代码。也就是我将代码粘贴到相同的组织里面的另一个仓库，可以看到另一个仓库是跑不起来的，因为仓库名不相同，此时可以尝试使用 repository_owner 这个值替换，请看代码

    if: github.repository_owner == 'lindexi'

上面代码判断的是只要拥有者是 lindexi 就执行。这里的 repository_owner 的值可以是用户也可以是组织，具体和仓库所在的拥有者相关

如果自己只是 fork 对方的仓库，改不动对方的代码，可以自己禁用 Action 请看 GitHub 的 Action 如何禁用

更多请看 GitHub 操作的工作流程语法 - GitHub 帮助

Context and expression syntax for GitHub Actions - GitHub Help

dotnet 配合 GitHub 的 Action 做自动推 Tag 时打包 NuGet 包

Thu, 03 Dec 2020 12:27:51 +0000

被微软收购的 GitHub 越来越好用，拥有大量免费的工具资源和构建服务器资源，再加上私有项目的无限制使用，我有大量的项目都在向 GitHub 迁移。通过 GitHub 的 Action 的自动构建，可以用上微软土豪的服务器资源，进行自动化测试和构建。对于 CBB 来说，发布就是打出 NuGet 包然后上传到内部 NuGet 服务器。此时遇到的问题是，如何在 GitHub 上执行打包，打包的时候如何指定 NuGet 包的版本号。因为 CBB 的特殊性，我要求每个 NuGet 正式发布的包都应该有一个对应的 Tag 号，这样将 NuGet 库安装到项目里面，之后发现问题了还能找到对应版本的代码

在阅读本文之前，期望小伙伴能了解如何在 dotnet 下使用 GitHub 的 Action 进行自动构建，请看 dotnet 部署 github 的 Action 进行持续集成而发布 NuGet 包的方法请看 dotnet 配置 github 自动打包上传 nuget 文件

本文将在此基础上实现本地推送一个 Tag 到 GitHub 服务器上，就会触发 GitHub 的 Action 的自动构建，自动构建的 NuGet 包的版本就是 Tag 版本。为什么需要在推 Tag 打包，请看 dotnet CBB 为什么决定推送 Tag 才能打包

本文将用到一个 dotnet tool 工具，在 dotnet 里面可以通过 dotnet tool 轻松分发和安装 dotnet tool 工具。更多关于 dotnet tool 请看 dotnet 用 NuGet 将自己的工具作为 dotnet tool 分发

之所以用 dotnet tool 工具，是因为利用 dotnet tool 工具可以明确使用到的工具，通过现有的工具可以简化自动构建的脚本的代码

本文用到的 dotnet tool 工具是 dotnetCampus.TagToVersion 工具

这个工具就是本文的核心，这个工具将 Tag 转换为 Version 版本号写入到版本号文件里面

在使用这个工具的时候有一个前提是在项目的 Build 文件夹存放一个 Version.prop 文件，此文件夹是版本号文件。这个组织方式在当前大量官方的 dotnet 开源项目，如 WPF 开源项目都是这样使用，只是存放的内容和路径不太相同

在自动化构建时，将通过 dotnetCampus.TagToVersion 工具将版本号写入到 Version.prop 版本号文件

在开始之前，请在 .github\workflows 文件夹新建一个 yml 文件，所有放在这个文件夹的 yml 文件都会被 GitHub 的 Action 作为配置文件，本文新建的 yml 文件是 push tag and pack nuget.yml 文件，在这个文件里面先写触发条件是 tag 推送

on:
  push:
    tags:
    - '*' 

然后通过 dotnet tool install 安装工具，然后使用工具

    - name: Install dotnet tool
      run: dotnet tool install -g dotnetCampus.TagToVersion

    - name: Set tag to version  
      run: dotnet TagToVersion -t ${ { github.ref } }

上面代码是通过 ${ { github.ref } } 传入推送的版本，请将花括号之间的空格去掉，详细配置请看 dotnetCampus.TagToVersion 工具的仓库

接下来就是根据项目的构建代码和上传 NuGet 库

    - name: Build with dotnet
      run: dotnet build --configuration Release

    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:        
        nuget-version: '5.x'

    - name: Add private GitHub registry to NuGet
      run: |
        nuget sources add -name github -Source https://nuget.pkg.github.com/ORGANIZATION_NAME/index.json -Username ORGANIZATION_NAME -Password ${ { secrets.GITHUB_TOKEN } }
    - name: Push generated package to GitHub registry
      run: |
        nuget push .\bin\release\*.nupkg -Source github -SkipDuplicate
        nuget push .\bin\release\*.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${ { secrets.NugetKey } } -NoSymbols 

注意上面的代码花括号的中间是不能带空格的，只是因为博客生成平台不支持连续两个花括号

而为了让项目的打包能用到 Build 文件夹的版本号文件还需要修改这个项目

在 .git 文件夹所在的文件夹放一个 Directory.Build.props 文件

什么是 Directory.Build.props 文件请看 Roslyn 使用 Directory.Build.props 文件定义编译

这个文件的大概作用就是定义此文件夹，以及此文件夹的子文件夹的编译步骤。在 Directory.Build.props 文件里面制定 Version.prop 文件的路径

<Project>
  <Import Project="build\Version.props" />
  <PropertyGroup>
    <PackageOutputPath>$(MSBuildThisFileDirectory)bin\$(Configuration)</PackageOutputPath>
    <Authors>dotnet-campus</Authors>
    <Company>dotnet-campus</Company>
    <LangVersion>latest</LangVersion>
    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
    <Description>描述信息</Description>
    <Copyright>Copyright (c) 2020 dotnet-campus</Copyright>
    <PackageProjectUrl>https://github.com/dotnet-campus/dotnetCampus.SourceYard</PackageProjectUrl>
    <RepositoryUrl>https://github.com/dotnet-campus/dotnetCampus.SourceYard.git</RepositoryUrl>
    <RepositoryType>git</RepositoryType>
    <PackageTags>source;dotnet;nuget;msbuild</PackageTags>
    <PackageLicenseExpression>MIT</PackageLicenseExpression>
  </PropertyGroup>
</Project>

请根据你的实际项目添加更改上面代码

核心的代码是设置 Version.props 的路径，放在build文件夹里面

在 Version.props 文件添加下面代码

<Project>
  <PropertyGroup>
    <Version>1.0.0</Version>
  </PropertyGroup>
</Project>

此时的版本号可以自由填写，这样就能解决本地打 NuGet 包指定版本号的问题

对于其他开发者，只有看到这个 Version.props 文件，同时这个文件里面没有其他需要学习的知识，只是知道在这里更改版本号就可以。这个方式对于配置管理员来说很重要，甚至能决定这项技术能否推进。对于大部分开发者是不需要关心，也不愿意了解这部分技术，更多的是想要提升开发的效率，而太多的杂项的配置知识将会降低开发的效率

我用一个例子说明上面的问题，我在 csproj 里面放下面这段代码。然后我告诉你，每次新建文件的时候都需要向 NafojaneKakoweebi 添加一个 o 不然新建的文件没有作用。假设你在我的团队里面，你要不要打我

<NafojaneKakoweebi>WhaljeahalqaboBembibocaooo</NafojaneKakoweebi>

当然，这个例子大家看看就好，虽然我真的写了这样的逻辑。通过仔细看还是能了解下面代码的含义，但是对于开发者的效率降低也确实存在

  <PropertyGroup>
    <Build>$([System.DateTime]::op_Subtraction($([System.DateTime]::get_Now().get_Date()),$([System.DateTime]::new(2000,1,1))).get_TotalDays())</Build>
    <Revision>$([MSBuild]::Divide($([System.DateTime]::get_Now().get_TimeOfDay().get_TotalSeconds()), 2).ToString('F0'))</Revision>
    <Version>1.0.0.$(Revision)</Version>
  </PropertyGroup>

通过本文的方法，可以让开发者在开发的时候不会碰到配置管理的代码，开发者只是看到 Version.props 文件，这个文件有版本号。而开发者最多也就是改版本号做本地打包

此时的项目如果在 csproj 文件没有指定版本号，那么就将会读取版本号文件的版本。而这个版本会在构建的时候被工具修改为推送的版本号，也就是这个项目构建的输出文件的版本号就是推送的版本号，通过这个方式就可以完成打包

可以看到现在有几个项目都在使用这个方式进行打包，如

用推 Tag 打包的好处是解决回滚代码的时候，需要用到某个 NuGet 包进行调试，可以找到对应版本的代码。同时解决了手动叫开发者打 NuGet 包的时候需要记得添加 Tag 号

在调试对应版本的 NuGet 的代码的时候，我推荐使用以下方法

当前 Gitlab 上也可以使用此方法，请看 dotnet 配合 Gitlab 做自动推 Tag 时打包 NuGet 包

另外我开源了一个构建工具集，请看 dotnetcampus.DotNETBuildSDK

本文的方法依然适用构建应用，如构建 WPF 应用，或打包为 UWP 应用。关于 WPF 打包为 UWP 的 GitHub 的 Action 方法请看 GitHub Action 新上线 WPF .NET Core 自动构建模板

WPF 画布工具栏的可扩展设计

Thu, 03 Dec 2020 12:27:51 +0000

我在写一个和 PS 差很多的工具，这个工具中间有一个画布，而我需要写一个扩展很好做的工具栏集合，这个工具栏设计上需要支持可以让小伙伴愉快的拆卸，功能足够独立，使用方便。本文就来告诉大家我的这个设计方案

大概的软件的界面如下图

我期望在代码上，这个库可以方便被大家使用，而小伙伴使用的时候最多的是扩展工具栏。如添加一个自己的工具栏。此时遇到的问题是如何让工具栏能知道画布的存在？毕竟工具栏的作用就是更改画布的内容等

当然，最简单的方法是在后台代码里面使用属性赋值的方法，但是属性赋值的方法意味着在 XAML 写完还必须在后台代码里面添加属性赋值的代码

如我有一个用来管理画布的类，定义如下

    public class BoardManagerGrid : Grid
    {
        /// <inheritdoc />
        protected override void OnInitialized(EventArgs e)
        {
            var boardList = Children.OfType<Board>().ToList();
            if (boardList.Count != 1)
            {
                // 告诉开发者只能添加一个画布
                return;
            }

            CurrentBoard = boardList[0];

            base.OnInitialized(e);
        }


        public Board CurrentBoard { private set; get; }
    }

而画布类的定义如下，下面都是空的类，只是为了说明本文的方案

    /// <summary>
    /// 画布
    /// </summary>
    public class Board : Canvas
    {
    }

而此时我有一个新的工具栏，工具栏里面需要获取当前的画布才能做工具栏业务

    public class FooToolBar : Grid
    {
        public Board CurrentBoard { set; get; }
    }

请问我可以如何做才能让这个工具栏在使用的时候足够简单？比较期望的是在 XAML 添加代码就能自动应用上，无需任何后台代码

    <Grid>
        <local:BoardManagerGrid>
            <local:Board></local:Board>
            <local:FooToolBar></local:FooToolBar>
        </local:BoardManagerGrid>
    </Grid>

这是比较期望的写法，但是如果按照上面的代码，是需要在后台代码里面给 FooToolBar 设置画布，而为了给 FooToolBar 设置，也就是需要还需要给这个工具栏命名，给画布命名

        <local:BoardManagerGrid>
            <local:Board x:Name="Board"></local:Board>
            <local:FooToolBar x:Name="FooToolBar"></local:FooToolBar>
        </local:BoardManagerGrid>

在后台添加赋值的代码

        public MainWindow()
        {
            InitializeComponent();

            FooToolBar.CurrentBoard = Board;
        }

这对于一个库来说，不是很好的设计，至少这让开发者用起来不开森，同时也让 FooToolBar 的属性设计不安全，不知道在哪里会被修改为空值

为了提升工具栏的对画布的属性的安全性，应该让这个属性作为私有的，至少设置方法应该是私有的

    public class FooToolBar : Grid
    {
        private Board CurrentBoard { set; get; }
    }

这样的一个坑是如何给这个属性赋值，如果是放在构造函数，那么这个工具栏就不能写到 XAML 上，只能放在后台代码。而通过 EndInit 方法判断设置又解决不了属性赋值问题

而另一个方式是通过全局静态属性的方法获取，这是当前我团队的一个古老的项目使用的方法，这样就提升了耦合度，存在的坑是我需要在这个项目里面多添加一个画布的时候就发现原有的工具栏无法进行复用

有什么方法可以让开发者只需要在 BoardManagerGrid 里面添加新的工具栏，就知道自动让这个工具栏找到对应的画布？其实可以使用附加属性的方法

附加属性可以支持继承，也就是上层容器，如 Grid 等这些容器控件设置的属性，将会被容器内的所有控件获得。也就是我在上层的 Grid 设置一个可以继承的附加属性，此时在 Grid 里面的所有控件就都能获取这个在 Grid 上设置的属性

设置附加属性的方法是通过将 PropertyMetadata 修改为 FrameworkPropertyMetadata 添加设置 FrameworkPropertyMetadataOptions.Inherits 属性

本文的方案是在 BoardManagerGrid 添加附加属性，这个附加属性就是自己设置自己

        public static readonly DependencyProperty BoardManagerProperty = DependencyProperty.RegisterAttached(
            "BoardManager", typeof(BoardManagerGrid), typeof(BoardManagerGrid),
            new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));

        public static void SetBoardManager(DependencyObject element, BoardManagerGrid value)
        {
            element.SetValue(BoardManagerProperty, value);
        }

        public static BoardManagerGrid GetBoardManager(DependencyObject element)
        {
            return (BoardManagerGrid) element.GetValue(BoardManagerProperty);
        }

这样所有在 BoardManagerGrid 里面的控件就能获取到所在的 BoardManagerGrid 的实例，也就是某个控件可以了解到当前所在的画布所在的容器是哪个

在 BoardManagerGrid 构造函数就需要设置附加属性

        public BoardManagerGrid()
        {
            SetBoardManager(this, this);
        }

接下来是在 BoardManagerGrid 里面找到容器里面的画布控件，按照业务要求，这里的画布只有一个

        /// <inheritdoc />
        protected override void OnInitialized(EventArgs e)
        {
            var boardList = Children.OfType<Board>().ToList();
            if (boardList.Count != 1)
            {
                // 告诉开发者只能添加一个画布
                return;
            }

            CurrentBoard = boardList[0];

            base.OnInitialized(e);
        }


        public Board CurrentBoard { private set; get; }

上面注释的内容请小伙伴自己完善

此时在工具栏就可以在 Loaded 之后通过附加属性的方式拿到画布请看代码

        public FooToolBar()
        {
            Loaded += FooToolBar_Loaded;
        }

        private void FooToolBar_Loaded(object sender, RoutedEventArgs e)
        {
            var boardManager = BoardManagerGrid.GetBoardManager(this);
            // 自动获得画布
            CurrentBoard = boardManager.CurrentBoard;
        }

这样实现的框架可以让工具栏本文可以随意扩展，只要是一个 UIElement 就能加入到画布控制里面，然后在 Loaded 里面拿到画布，使用的方法也简单

本文代码放在github欢迎小伙伴访问

MSBuild 输出日志可视化工具 MSBuild Structured Log Viewer 简介

Thu, 03 Dec 2020 12:27:51 +0000

感谢 Vatsan Madhavan 小伙伴推荐的 MSBuild 输出日志可视化工具，这个工具可以使用漂亮的 WPF 界面预览 MSBuild 复杂的输出内容

这是一个完全开源的工具，请看 KirillOsenkov/MSBuildStructuredLog: A logger for MSBuild that records a structured representation of executed targets, tasks, property and item values.

这个工具的使用方法很简单，首先是在项目里面使用 MSBuild 命令加上 /bl 生成 msbuild.binlog 文件，如使用下面代码

msbuild /bl

从官网 MSBuild Log Viewer 下载最新版本

打开软件，将 msbuild.binlog 文件拖进去就可以显示日志的信息

另外这个工具还提供了 NuGet 库可以用来读取 binlog 文件

先安装 MSBuild.StructuredLogger 库，然后使用下面代码

using System;
using Microsoft.Build.Logging.StructuredLogger;

class BinaryLogReadBuild
{
    static void Main(string[] args)
    {
        string binLogFilePath = @"C:\temp\test.binlog";

        var buildRoot = BinaryLog.ReadBuild(binLogFilePath);
        buildRoot.VisitAllChildren<CscTask>(c => Console.WriteLine(c.CommandLineArguments));
    }
}

这个软件用到了特别漂亮的 TreeView 欢迎小伙伴抄样式

dotnet 使用 OpenXML SDK 解析 Office 的项目符号 buNone 含义

Thu, 03 Dec 2020 12:27:51 +0000

在解析 PPT 文档的时候，文本是比较复杂的一部分，而因为很多有趣的坑，即使是微软大法也有一些诡异的设计，例如项目符号的是否显示

在阅读本文之前，我期望小伙伴是了解基础的解析 Office 的方法。在使用 OpenXML SDK 解析的时候，只需要开发 10 分钟就完成了整个 PPT 的解析了，剩下就是如何使用解析完成的数据。入门的文档请看 C# dotnet 使用 OpenXml 解析 PPT 文件

在 Office 的段落里面可以使用 <a:buNone/> 表示当前这一段不要显示项目符号，而这个属性的作用还需要小伙伴动手改一下 PPT 文档内容才比较好了解。为什么没有项目符号是一个属性？为什么不是没有设置项目符号就是没有项目符号？其实这里涉及一个命名问题，在 OpenXML SDK 里面给了一个很好理解的命名是 NoBullet 也就是不要项目符号。这个符号是什么意思，下面请看小伙伴修改一下 PPT 文档，看一下 Office 的 PPT 是如何显示

咱要支持 WPS 软件，我推荐使用教育版，这个版本几乎没广告

打开 WPS 写一个文本框，里面的文本设置项目符号

保存之后，将后缀名修改为 zip 然后解压缩

move 文本项目符号.pptx 文本项目符号.pptx.zip

解压缩可以看到下面文件

打开 f:\temp\文本项目符号\ppt\slides\slide1.xml 文件

在段落属性添加 <a:buNone/> 如上图，注意不要格式化，上面格式化只是让小伙伴们阅读起来不会要打我

将文件夹压缩，修改后缀名是 pptx 然后用 PPT 打开

用 PPT 打开可以看到文本没有项目符号

当然此时的 WPS 是玩不过 Office 的，在 WPS 里面解析错了，将项目符号显示出来

从微软官方文档 NoBullet Class (DocumentFormat.OpenXml.Drawing) 的原文说的，这个属性表示当前这一段不要显示项目符号，而项目符号在段落里面可以从默认段落以及样式继承。而这个属性就是表示不继承项目符号，也不要使用段落设置的项目符号

即使在段落里面设置了复杂的项目符号，只要存在 <a:buNone/> 那么就不显示项目符号。这个规则在 Office 里面是这样做的，但是在 WPS 不是

在 OpenXML SDK 拿到 TextParagraphPropertiesType 段落属性，可以通过 GetFirstChild 方法尝试获取是否设置 NoBullet 类

private void Foo(TextParagraphPropertiesType paragraphProperties)
{
            // 如果是 NoBullet 就是说不用项目符号
            if (paragraphProperties.GetFirstChild<NoBullet>() != null)
            {
                // [NoBullet Class (DocumentFormat.OpenXml.Drawing)](https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.nobullet )
                // 按照微软文档无论前面是否写了项目符号的字体还是定义了项目符号，只要写了 NoBullet 这一段不要项目符号，那么这一段就是没有项目符号
            }
}

在 WPF 中默认的文本都是没有项目符号可以设置的，只能通过自己用字符的方式，不过这不在本文的范围

Roslyn 如何使用 MSBuild ZipDirectory 压缩文件夹

Thu, 03 Dec 2020 12:27:51 +0000

在 csproj 文件或在 NuGet 的 Targets 文件中可以通过 Target 调用 ZipDirectory 任务用来制作压缩包，在构建的时候，可以用这个方法将某个输出文件夹等内容压缩输出

使用 ZipDirectory 有两个必要的属性，一个是 DestinationFile 表示输出的 zip 文件的路径，另一个是 SourceDirectory 表示将被压缩的文件夹路径

如果 DestinationFile 文件期望进行覆盖，也就是如果 DestinationFile 路径已经存在，将覆盖写入新的 zip 文件，可以使用 Overwrite 属性

使用方法如下

    <Target Name="ZipOutputPath" AfterTargets="Build">
        <ZipDirectory
            SourceDirectory="$(OutputPath)"
            DestinationFile="$(MSBuildProjectDirectory)\lindexi.zip" />
    </Target>

将上面代码放在 csproj 文件，构建将会在 csproj 文件所在文件夹找到创建的文件

本文代码放在github欢迎小伙伴访问

ZipDirectory Task

WPF 如何在静态资源定义字体大小

Thu, 03 Dec 2020 12:27:51 +0000

默认的 WPF 的字体大小的单位是像素，如果想要将字体大小使用 pt 点表示，写在 xaml 里面是直接添加 pt 后缀。但是此时如果在静态资源尝试定义的时候写上了 pt 将会在运行的时候提示无法转换

默认的单位是 Pixel 如下面代码写的

            <TextBlock Margin="10,10,10,10"
                       FontSize="10"
                       Text="林德熙是逗比"></TextBlock>
            <TextBlock Margin="10,10,10,10"
                       FontSize="10pt"
                       Text="林德熙是逗比"></TextBlock>

实际运行的效果可以看到使用 pt 的字体显然比 pixel 的大

这是在 xaml 写的，如果想要在资源里面写，如下面代码，将不能通过运行

    <Window.Resources>
        <system:String x:Key="FontSize">10pt</system:String>
    </Window.Resources>
    <Grid>
        <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center">
            <TextBlock Margin="10,10,10,10"
                       FontSize="10"
                       Text="林德熙是逗比"></TextBlock>
            <TextBlock Margin="10,10,10,10"
                       FontSize="{StaticResource FontSize}"
                       Text="林德熙是逗比"></TextBlock>
        </StackPanel>
    </Grid>

原因是 FontSize 类是一个 double 类型，此时构建将提示不能将字符串转换为 double 类

An object of the type "System.String" cannot be applied to a property that expects the type "System.Double".	CelakercalbochallhiNerjufeeqalchelfu	MainWindow.xaml	19	

但是为什么在 xaml 写在属性里面支持添加单位 pt 呢，原因是在 FontSize 属性标记特性 TypeConverter 通过这个进行转换

按照这个方法，可以在本地定义一个专门的字体大小的类

using System.Windows.Markup;

public class FontSizeExtension : MarkupExtension
{
    [TypeConverter(typeof(FontSizeConverter))]
    public double Size { get; set; }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return Size;
    }
}

将这个类放在代码，然后就可以在 xaml 资源写下面代码

    <Window.Resources>
        <local:FontSize x:Key="FontSize" Size="10pt"></local:FontSize>
    </Window.Resources>
    <Grid>
        <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center">
            <TextBlock Margin="10,10,10,10"
                       FontSize="10"
                       Text="林德熙是逗比"></TextBlock>
            <TextBlock Margin="10,10,10,10"
                       FontSize="{StaticResource FontSize}"
                       Text="林德熙是逗比"></TextBlock>
        </StackPanel>
    </Grid>

在使用 MarkupExtension 可以忽略 Extension 只写前面部分，也就是写的是 FontSize 在资源，换句话说，写 FontSizeExtension 也没问题

    <Window.Resources>
        <local:FontSizeExtension x:Key="FontSize" Size="10pt"></local:FontSizeExtension>
    </Window.Resources>

这样就可以在静态资源里面定义字体大小

本文代码放在 github 欢迎小伙伴访问

GitHub 开源项目如何参与

Thu, 03 Dec 2020 12:27:51 +0000

点击上面图片跳转课件

dotnet 配合 Gitlab 做自动推 Tag 时打包 NuGet 包

Thu, 03 Dec 2020 12:27:51 +0000

我现在的团队内部用的是 Gitlab 工具，在此工具上提供了 Gitlab CI CD 用于做自动化测试和构建。对于 CBB 来说，发布就是打出 NuGet 包然后上传到内部 NuGet 服务器。此时遇到的问题是，如何在 Gitlab 上执行打包，打包的时候如何指定 NuGet 包的版本号。因为 CBB 的特殊性，我要求每个 NuGet 正式发布的包都应该有一个对应的 Tag 号，这样将 NuGet 库安装到项目里面，之后发现问题了还能找到对应版本的代码本文告诉大家如何配合 Gitlab 做自动推 Tag 时打包 NuGet 包。也就是本地打一个 Tag 号，推送到 Gitlab 上，就会出发 Gitlab 的自动构建，自动构建里面将会获取 Tag 版本号，然后打出 NuGet 包推送到服务器

在阅读本文之前，期望大家了解什么是 Gitlab 的 Runner 以及如何开启，详细请看 dotnet 配置 Gitlab 的 Runner 做 CI 自动构建

本文以一个 WPF 的库为例子，其他的 dotnet 库也是相同的方法

在 dotnet 里面打包的方法可以通过以下命令

dotnet pack -c release

在 Gitlab 里面通过 Tag 出发构建命令可以在 .gitlab-ci.yml 添加下面代码

tagpublish:
  stage: publish
  script:
    - "chcp 65001" # 这里的 chcp 65001 是支持中文 GBK 解决命令行输出

  only:
    - tags

通过 only 里面设置 tags 就可以在推送 Tag 到 Gitlab 上自动触发构建

现在的问题是如何让推送的 Tag 的版本号作为 NuGet 包的版本号

在 Gitlab 里面将会在执行构建的时候注入环境变量，使用 Tag 打包的时候将可以找到 CI_COMMIT_TAG 这个环境变量，这个变量的内容就是对应的 Tag 的内容。如我推送到 1.0.0 的 Tag 那么这个 CI_COMMIT_TAG 的值就是 1.0.0 可以通过这个原理拿到推送的内容

在编译里面的设置，可以在 csproj 或 targets 等文件里面通过 $(环境变量) 的方式拿到对应的环境变量，而设置输出的 NuGet 的版本号可以通过 Version 属性，也就是可以在 csproj 里面添加下面代码

<Version>$(CI_COMMIT_TAG)</Version>

此时将会从环境变量获取 CI_COMMIT_TAG 设置为 Version 属性，这样就能让打出来的 NuGet 包和对应的 Tag 相同

此时的 .gitlab-ci.yml 大概代码如下，请根据你的实际需求更改

stages:
  - publish

# 推Tag打包
tagpublish:
  stage: publish
  script:
    - "chcp 65001"
    - 'dotnet pack -c release'
    - 'nuget push bin\Release\*.nupkg'
  only:
    - tags

以上方法有缺陷是如果打的 Tag 是包含 v 开头的，如 v1.0.0 此时就不好玩了。另一个问题是如果想要本地打一个 NuGet 包，那才是糟心

于是我开源了一个工具 dotnetCampus.TagToVersion 这个工具能根据传入的值更改 Version.props 文件的内容，更改为传入的值的版本号

使用这个工具的步骤就相对多了一点了，我在内部做了一个 dotnet 模版，减少了这些步骤。因为是内部用的模版我也没有打算开源

通过三个步骤能使用 dotnetCampus.TagToVersion 这个工具，这个工具能解决在本地打出 NuGet 包的版本号问题，能解决带 v 的特殊的 Tag 的问题

步骤1是添加 Directory.Build.props 文件

什么是 Directory.Build.props 文件请看 Roslyn 使用 Directory.Build.props 文件定义编译

这个文件的大概作用就是定义此文件夹，以及此文件夹的子文件夹的编译步骤。在 Directory.Build.props 文件里面制定 Version.prop 文件的路径

<Project>
  <Import Project="build\Version.props" />
  <PropertyGroup>
    <PackageOutputPath>$(MSBuildThisFileDirectory)bin\$(Configuration)</PackageOutputPath>
    <Authors>dotnet-campus</Authors>
    <Company>dotnet-campus</Company>
    <LangVersion>latest</LangVersion>
    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
    <Description>描述信息</Description>
    <Copyright>Copyright (c) 2020 dotnet-campus</Copyright>
    <PackageProjectUrl>https://github.com/dotnet-campus/dotnetCampus.SourceYard</PackageProjectUrl>
    <RepositoryUrl>https://github.com/dotnet-campus/dotnetCampus.SourceYard.git</RepositoryUrl>
    <RepositoryType>git</RepositoryType>
    <PackageTags>source;dotnet;nuget;msbuild</PackageTags>
    <PackageLicenseExpression>MIT</PackageLicenseExpression>
  </PropertyGroup>
</Project>

请根据你的实际项目添加更改上面代码

核心的代码是设置 Version.props 的路径，放在build文件夹里面

在 Version.props 文件添加下面代码

<Project>
  <PropertyGroup>
    <Version>1.0.0</Version>
  </PropertyGroup>
</Project>

此时的版本号可以自由填写，这样就能解决本地打 NuGet 包指定版本号的问题。同时解决了非配置管理员的其他开发者也需要了解学习什么是 CI_COMMIT_TAG 的问题

<NafojaneKakoweebi>WhaljeahalqaboBembibocaooo</NafojaneKakoweebi>

当然，这个例子大家看看就好，虽然我真的写了这样的逻辑。通过仔细看还是能了解下面代码的含义，但是对于开发者的效率降低也确实存在

  <PropertyGroup>
    <Build>$([System.DateTime]::op_Subtraction($([System.DateTime]::get_Now().get_Date()),$([System.DateTime]::new(2000,1,1))).get_TotalDays())</Build>
    <Revision>$([MSBuild]::Divide($([System.DateTime]::get_Now().get_TimeOfDay().get_TotalSeconds()), 2).ToString('F0'))</Revision>
    <Version>1.0.0.$(Revision)</Version>
  </PropertyGroup>

通过本文的第二个方法，可以让开发者在开发的时候不会碰到配置管理的代码，开发者只是看到 Version.props 文件，这个文件有版本号。而开发者最多也就是改版本号做本地打包

那么对于配置管理来说，如何在推送 Tag 打包的时候自动设置版本号？通过 dotnetCampus.TagToVersion 这个工具根据 CI_COMMIT_TAG 更改 Version 文件的内容就可以做到

修改 .gitlab-ci.yml 为下面代码

stages:
  - publish

# 推Tag打包
tagpublish:
  stage: publish
  script:
    - "chcp 65001"
    - "dotnet new tool-manifest"
    - "dotnet tool install dotnetCampus.TagToVersion"
    - "dotnet tool run dotnet-TagToVersion -t $CI_COMMIT_TAG"
    - 'dotnet pack -c release'
    - 'nuget push bin\Release\*.nupkg'
  only:
    - tags

对比开始的 .gitlab-ci.yml 文件可以看到添加了下面代码

    - "dotnet new tool-manifest"
    - "dotnet tool install dotnetCampus.TagToVersion"
    - "dotnet tool run dotnet-TagToVersion -t $CI_COMMIT_TAG"

这三句话就是创建一个 dotnet tool 清单，安装 dotnet tool 工具，然后运行工具而已。如果提前在 gitlab runner 的设备上安装了 dotnetCampus.TagToVersion 那么可以将上面代码压缩为一句代码

    - "dotnet TagToVersion -t $CI_COMMIT_TAG"

执行上面代码将会自动根据传入的参数修改 Version.props 的值，这样就能做到推送 Tag 打包对应版本号

在调试对应版本的 NuGet 的代码的时候，我推荐使用以下方法

程序猿修养给属性一个单位

Thu, 03 Dec 2020 12:27:51 +0000

在上小学有一道题目是半杯50度的水加上半杯50度的水等于什么，我傻傻写了半杯100度的水。当时我还是逗者级别的，现在是逗尊级别了。在写代码的时候会看到莫名一个不带单位的变量或属性，总是会觉得我会加出100度出来。什么是不带单位的属性？例如我看到了有人写了一个属性叫字体大小的，这个属性是 double 值，这就好玩了，请问这是一个像素单位还是磅单位。程序猿修养给属性一个单位，可以提升代码可读性

还是回到开始的题目，在计算机里面也是无视物理规则，真的加上去也没问题。如果要让两个不相关的值不能相加，最简单的方式是让这两个类型不相同，至少不能直接相加。这句话请大杠不要说隐式转换的问题

在写代码的时候我推荐定义的属性或变量，如果存在一些单位，同时单位还存在不统一时，给这些属性加上单位。加上单位的做法就是定义对应的单位类或结构体等。这样可以在写代码的时候强制要求参数传入的单位以及计算时知道单位

为什么这样建议，请看看本文的例子

我在写文本库的时候就遇到一些有趣的问题

二代文本开发者在文本的字体大小里面混用了像素和磅单位，此时就好玩了。有一个 SetFontSize 方法，这个方法传入的参数是 double value 也就是传入一个 double 值，这个值的单位是磅单位。但是在 GetFontSize 方法里面，返回值也是 double 只是单位就修改为了像素

当然这个问题也许小伙伴觉得不是很坑，因为很简单就能从代码层面理解，下面再给大家讲另一个更坑的问题

还是在文本库里面，文本有分行和分段的概念，此时每个字符的坐标可以分为，这个字符在整个文档里面排第几个字，这个字符在段里面属于第几个字符，这个字符在行里面属于第几个字符。在文本库里面逗比的开发者用了 int 表示，这就好玩了，在调试的时候进入方法内，看到一个 charOffset 变量，请问这个变量代表的是这个字符在文档里面的偏移量还是代表在行内的？其实只有从最上面开始读才知道。如果此时的技术混杂了段内计算，也就有另一个 charOffset2 的存在，如果这个 charOffset2 是一个段内坐标，那么这个代码就更好玩了，就和 C++ 的指针一样

public bool AreSame(int charOffset)
{
	string text = GetText(charOffset);
	int charOffset2 = GetCurrentOffset();
	string text2 = GetText(charOffset2);

	// 忽略代码
}

上面的代码存在坑，但是其实很难通过测试手段或看代码了解，因为如上面说的 charOffset 是文档里面的偏移量，但是 charOffset2 是一个段内坐标，而 GetText 方法就不知道接收参数是什么坐标了。如果此时是在第一段里面，那么文档坐标和段坐标是重合的，测试小伙伴也基本上只会测试输入一行文本。而从代码调试上也只能看到传入的值是一个 int 拿到一个字符串，为什么明明相同的字符串返回的是不同就好玩了

想要写出让小伙伴看不懂的代码，有一条方法就是在一段代码里面使用多个不同的单位，但是多个不同单位的变量使用相同的类型。反过来，想要写出小伙伴或自己能看懂的代码，要么只使用一个单位，如果有多个单位那么给单位定义类型，不同的单位要求转换

再对比优化后的代码，其实优化后只是将 int 转换为我定义的不同的类型

public bool AreSame(DocumentOffset charOffset)
{
	string text = GetText(charOffset);
	ParagraphOffset charOffset2 = GetCurrentOffset();
	string text2 = GetText(charOffset2);

	// 忽略代码
}

此时的逻辑就更清晰了，当然坑也解决了，因为 GetText 是一个重载方法，在拿到参数也就知道返回的是什么坐标的字符

让代码调试简单的做法，减少写出坑的做法就是尽可能给单位一个类型，不要使用不带单位的基础类型

如我在写 Word 文档的时候，在 Word 文档里面有很多有趣的单位，如磅单位和像素单位都是表示文本大小的单位，此时我就定义了两个不同的结构体

分别是结构体磅单位和结构体像素单位

    /// <summary>
    /// 磅
    /// </summary>
    public readonly struct Pound
    {
        /// <summary>
        /// 磅
        /// </summary>
        /// <param name="value"></param>
        public Pound(double value)
        {
            Value = value;
        }

        /// <summary>
        /// 磅
        /// </summary>
        public double Value { get; }
    }

    /// <summary>
    /// 像素
    /// </summary>
    public readonly struct Pixel
    {
        public Pixel(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

上面代码的 readonly struct 是 C# 7.0 的语法，不是本文的重点，此时定义为类也可以

这样在调试代码或看代码看到一个变量，就可以通过变量类型知道单位，而不是需要根据代码上下文才能了解到单位

即使在原有内部比较混乱的混合磅和像素的算计，都能通过类型辅助静态代码定位。这里静态代码定位说的是在不执行调试下，靠看代码定位问题

小伙伴也能注意到我没有给隐式转换两个不同的类型的代码，这是因为这两个类型就是让他完全不同，提高混用的难度

除了在设计类的时候可以用此方法，在使用框架或别人设计的类的时候也推荐使用带单位的方法

我比较推荐在代码中显式定义单位，或传入单位，如小伙伴会用到的 Task 延迟的代码。如下面两句代码

   await Task.Delay(100);

   await Task.Delay(TimeSpan.FromMilliseconds(100));

小伙伴觉得上面两句代码哪句比较好，从性能的角度上说，使用 TimeSpan.FromMilliseconds 参数的 Task 内部也会转换 int 传入到第一句里面。也就是第一句的性能很比第二句好，代码字符数上第一句也比较短

但是从可读上说，抛开 Task.Delay 是熟知的 API 来说，传入一个 100 不带单位其实有点伤，因为不确定这个 100 的含义是什么，等待 100 次还是等待 id 为 100 这个线程？而第二句话就能告诉开发者这是一个延迟 100 毫秒的代码

当然对于一些熟知的 API 来说，这样写的意义不大。但是这句话也是不对的，因为对我来说 Foo 方法是熟知的，但是对小伙伴来说根本不了解这个 Foo 方法是什么。保险做法是按照可读性强的写

在调用现有框架 API 的时候依然推荐使用带单位的方法，这样阅读代码的时候，不熟悉这个 API 都能方便从参数里面了解对应的单位

还有一个有争议的例子

小伙伴觉得设计一个方法，这个方法接收输入的内容是一个文件，此时用 string 表示文件路径好还是用 FileInfo 好？

我提两个问题，从框架或库设计的方面

第一个问题是在使用文件相关的库的时候，遇到最多的文件就是相对路径问题。经常有小伙伴传入的是相对路径，此时换算为绝对路径就出错了。但是很难约束和告诉小伙伴，如果传入相对路径将会相对哪里

第二个问题是文件夹和文件的分开比较难设计，只要夹杂文件夹和文件然后参数都是 string 时，经常会收到小伙伴反馈用错，即使写明了方法是 Folder 也一样。另外如果方法内部混杂了使用 string 代表文件路径和 string 代表文件内容等，有时会混用值，即使这部分很好调试

但是用 string 作为文件代表确实是比较自然的方式，代码写起来也比较简单。只是约束斜杠相对路径什么的坑比较多。另外在 .NET Core 开源框架部分也比较多采用 string 作为文件路径

如 File 等静态类，就提供了从 string 作为文件名的读取方法，这个方法的使用量特别多，也很少见出现坑

从这个方面说，更多在于约定之上，没有说哪个方法会更好

大概，本文要安利大家的内容就这些

本文的内容很简单，就是一句话，给属性一个单位

给属性一个单位的优点是

明确单位，减少混用
减少单位带来的坑
提升代码可读性
约束调用方参数
减少库代码参数判断代码

缺点是

需要进行转换，转换代码影响性能
增加代码的字符数

最简单判断要不要加单位的方法就是尝试加一下单位，如果代码写起来还好，那么就加上单位

Roslyn 如何给每个平台设置 PlatformTarget 属性

Thu, 03 Dec 2020 12:27:51 +0000

在使用 csproj 格式，如果需要给不同的平台设置 PlatformTarget 对应平台的值，需要写比较多的代码，本文告诉大家一个简便的方法

使用三句话就完成了平台设置

<PropertyGroup>
    <PlatformTarget>$(Platform)</PlatformTarget>
</PropertyGroup>

上面代码和下面代码是相同的

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
    <PlatformTarget>AnyCPU</PlatformTarget>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'">
    <PlatformTarget>x86</PlatformTarget>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <PlatformTarget>x64</PlatformTarget>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
    <PlatformTarget>AnyCPU</PlatformTarget>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x86'">
    <PlatformTarget>x86</PlatformTarget>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <PlatformTarget>x64</PlatformTarget>
  </PropertyGroup>

编程思想定义过滤的方式解耦

Thu, 03 Dec 2020 12:27:51 +0000

本文将会很少涉及 dotnet 的知识，主要讲用定义过滤的方式解除过程业务的耦合。在一些业务上，可以从业务层面或逻辑层面明显分为几层，每一层之前的数据相互依赖或处理顺序相互依赖，但逻辑都独立。此时如果将业务处理放在过程处理里面，将会让过程处理耦合具体业务。而定义过滤的方式为让过程逻辑只是搭建框架为主，具体业务通过注入过滤的形式加入到处理

假设我有某个业务需要处理，这个业务分为两个大步骤，分别是 F1 步骤和 F2 步骤。而 F1 里面自然有 F1 步骤的业务，同理 F2 也一样。而我的业务上对于数据处理的过程要求比较高，在过程处理上面的逻辑相对复杂，而如果将 F1 的业务和 F2 的业务放进来，大概的逻辑会是这样

// 复杂的过程处理代码
// 通用的过程处理业务代码
// F1 业务需要处理的代码
// 其他诡异的逻辑业务代码
// 过程处理的业务代码
// F2 业务需要处理的代码
// 其他处理代码

总体看起来逻辑将会比较复杂，同时耦合度也将会比较高

读到这里的小伙伴是否有一个疑问，在什么时候就能定义出过程处理的逻辑，而其中的 F1 业务和 F2 业务是如何能定义出哪些代码是属于哪个步骤

用一个比较具体的例子说明

我需要在 WPF 中处理一个视频文件，视频文件的处理包含了视频文件本身的专业逻辑，也就是如何解码视频文件，如何将视频文件拼接为一张张图片。而处理视频文件包含了业务上的事情，业务上的事情包含以下三个部分

打开视频文件之前需要看看这个视频文件的编码格式，如果不清真就提示用户（判断格式）
每一个视频转出来的图片，在拿到数据之前需要做一点点优化，如在数据上添加一个水印（添加水印）
从图片数据转图片完成之后，需要随机拿出一些图片给用户预览（提供预览）

而如果将上面的业务逻辑混合到整个视频处理逻辑上，大概会是这个样子

打开视频文件，分批加入到内存
判断格式（业务第一个步骤）
解码拿到 HEAD 数据
加载声音
获取视频分辨率，创建空白数据
杂七杂八的专业处理逻辑
按照一秒30张图片组合出视频处理，将视频一秒拆为 30 张图片
以下为视频的每一张图片处理逻辑
解析出视频中的图片
添加水印（业务第二个步骤）
将图片做一些优化
奇特的图片处理
保存图片到文件
提供预览（业务第三个步骤）
压缩处理的所有图片
我也编不出的业务逻辑

大概来说，其实上面的逻辑可以分为三个大部分，第一个部分就是算法部分，或者说专业逻辑代码。这部分主要就是如何解码视频，如何将视频转图片以及优化图片等逻辑。这些逻辑基本都是很通用的，同时这部分逻辑也应该做到很独立。业务上使用只是调用方法传入参数而已，不应该将具体代码写入到耦合某个业务里面

第二个部分就是定义处理的过程，其实上面的逻辑应该可以分为以下过程

从文件加载到内存
解码视频
从视频转图片
处理图片
保存处理逻辑

这里面大部分步骤都是几乎做到通用的，也就是在这些步骤上只是填充专业逻辑。这部分逻辑适合创建一个 NuGet 库存放，这样在多个项目之间都能共用。但是现在的问题来了，我的业务逻辑分散在三个过程里面

文件打开后
图片处理时
图片处理完成

而其中文件打开后这个过程在此业务中只用一次。而后面两个过程将会根据具体视频执行多次

这里的业务逻辑就是第三个部分。这里的逻辑划分其实和代码执行顺序没有直接关系，而是根据代码逻辑的层次划分。进一步说，其实第一部分专业逻辑和第二部分定义处理的过程这两个部分不是紧密的关系。假设咱有很多不同的专业逻辑，如针对不同的视频采用不同的处理方式，但是这些处理方式之前的处理过程是差不多的，也就是第二个部分定义处理的过程部分可以独立出来，根据具体功能填写具体的专业逻辑。也就是从层次上，第二部分属于框架层面，但如果我将第三部分业务逻辑放在了整个处理逻辑里面，那么此时的功能就都无法独立

是否可以让第三部分业务逻辑分离？其实从上面说的内容，连第一部分都可以分离。假设将第二部分框架层面的部分作为框架使用，那么框架就是独立的，但是框架没有任何具体的功能。此时通过在框架各个部分填补专业逻辑可以让第一部分和第二部分联合作出实际的功能

但是想要完成功能还需要有业务的存在，此时的业务就不能写入到库的代码中。这里的库指的是如 NuGet 一样的代码库，或者说是通用代码里面，通用代码不含各个产品的具体业务

既然在第二部分已经可以定义出框架了，那么可以在框架里面应用过滤的方式进行解耦。在框架里面可以定义逻辑处理的顺序，在关键的处理里面开放注入接口。如在视频文件打开之后，此时添加一个可以注入的点，可以让业务层注入业务逻辑

而此时注入的部分的建议是注入一个接口，在框架里面定义了过程用到传入的数据，在某些处理的过程里面可以让开发者注入具体的实现类，通过接口进行约束和获取数据进行处理的方式，就是本文说的定义过滤的方式解耦

例如有简化的逻辑，我的框架的定义如下

    interface IFooHandler
    {
        void AddF1Filter(IF1Filter filter);
        void AddF2Filter(IF2Filter filter);
    }

框架里面提供了添加两个不同的业务过滤的方法，而这两个不同的业务过滤将会在整个过程的不同步骤进行调用，同时也使用两个不同的接口限定了具体的业务逻辑的注入的类的实现方式。这个方法的优点在于，可以将业务的逻辑放在具体的业务上做，而框架和库的部分只是做通用的处理逻辑。换句话说是将不通用的代码作为接口的方式提出，而在业务层进行注入，注入的方式就是调用框架给出的方法传入对应的接口实现。如上面代码，框架在两个步骤里面给出了两个可以注入的方法，通过调用框架的这两个方法传入具体实现就能做到在框架处理的过程调用注入的业务

而对比将所有逻辑都写在一起的优势在于降低耦合，原先的业务逻辑可以分散写，同时还能访问上下文更多信息。而现在只能通过约束的接口，如上面代码的 IF1Filter 定义，此时将可以让业务逻辑不影响到框架里面的逻辑，换句话是框架里面只需要了解接口的内容而不需要了解具体业务

而这个过滤的方式可以在框架里面各个地方提供，甚至框架可以通过判断有注入实际业务和没有注入的行为，如有注入业务时采用业务特殊方法替换原有的逻辑，如下面代码定义

        public void SetF1Filter(IF1Filter filter)
        {
            Filter = filter;
        }

        private IF1Filter Filter { get; set; } = DefaultFilter;

        private static readonly IF1Filter DefaultFilter = new F1Filter();

如果用户没有注入实际的逻辑，那么将会使用 DefaultFilter 的逻辑，如果用户注入了，那么将使用用户的逻辑

对于部分业务处理，如上面说到的在文件打开之后的处理，此时的处理不应该限定只有一个，于是如上面代码定义，可以让用户调用方法多次，之后进行每个用户传入的业务处理

        private static void HandleFoo(IFooHandler fooHandler)
        {
            fooHandler.AddF1Filter(new F1Filter());
            fooHandler.AddF1Filter(new F1Filter());
            fooHandler.AddF1Filter(new F1Filter());
        }

如上面代码可以让框架在 F1 步骤处理三次，虽然上面代码都是传入一样的类创建

而如果将整个注入好了逻辑的框架作为一个实例存放，在软件中的不同业务使用，此时也许会遇到某些业务需要添加一点功能，而某些业务不需要的情况，如下面代码的 fooHandle 是已经注入好了业务逻辑的实例，但是此时我需要在某个业务里面对他的处理过程进行一点更改

            var fooHandle = new FooHandler();
            HandleFoo(fooHandle);

此时的修改如果依然对 fooHandle 进行注入不加任何逻辑，那么此时将会影响到其他使用的业务，这里在 C# 里面可以采用 using 的方法，大概的写法如下

            var f1Filter = new F1Filter();
            using (f1Filter)
            {
                fooHandle.AddF1Filter(f1Filter);
                // 其他业务
            }

在本次处理完成 F1Filter 和业务之后，将会调用 f1Filter 的释放代码，在释放代码里面可以反过来调用 fooHandle 的移除添加方法

大概实现逻辑请看我的代码这里面只是简单定义

程序猿修养使用 NuGet 发射卫星只需要三步

Thu, 03 Dec 2020 12:27:51 +0000

软件行业和其他行业不相同，在很多行业想要复用前人的知识，需要重新再制造一遍。而软件行业，特别是 dotnet 系的技术，想要用前人的经验只需要使用前人写的库。随着越来越多的基础设施和底层库的积累，现在开发一个软件的速度会越来越快。在使用 dotnet 技术栈时，可以通过 NuGet 方便使用前人的库或发布自己的库和工具。有很多功能，其实只需要知道用哪个库和如何用，底层细节可以在完全不知道不了解的情况下也能用起来

回到上篇博客最后的问题，我想要写一个软件，用来发射卫星，请问需要几步？

假设现在已经有大佬将创建卫星和发射卫星等的实现都封装在一个库中，那么此时要发射卫星就非常简单了

第一步：通过 NuGet 安装发射卫星的库
第二步：调用库里面发射卫星函数
第三步：使用 dotnet run 构建运行程序

没错，只需要三步

用 NuGet 就是怎么神奇的东西，根据 GitHub 的统计，每天都会被小伙伴上传几百万行代码（数据不准确）而我每天最多只能看一万行代码，这就意味着有大量的知识或专业的知识其实我很难快速掌握。但是我又想做这方面的开放，难道我需要和之前上学一样，从原理从最底层开始学习，我才可以进行开发？其实不然，如最简单的矩阵转换，我只需要知道调用哪个函数就会发生什么，而不是去了解什么是矩阵，矩阵的转换的最优算法是什么，如何写，有哪些边界。其实我大部分时间写出来的逻辑都没有从 NuGet 上使用其他小伙伴做的库的方法来的稳当

按照中国的教科书，在学习一个东西之前都需要吹半天，而现在吹的部分也差不多了，下面就是实战啦

当然，我不会告诉大家如何发射卫星，这个技术太可怕了。请让咱来个简单一点的东西，在开始之前需要了解什么是 NuGet 工具。其实 NuGet 就是一个用来存放库的东西，这里的库指的是小伙伴编写上传的封装好的东西。可以引用库来做很多有趣的事情。而 NuGet 分为两部分，一部分在云上面，就是上面所说的用来存放库的功能。另一部分放在本地用来安装和管理项目里面用到的库

如果小伙伴遇到一个功能不知道如何实现，在网上是期望找到源代码复制粘贴好呢？还是找到一个现成的库安装好呢？其实我比较推荐后面一个方法

在安装完成了 dotnet 工具之后，可以方便使用 NuGet 在本地的一个项目里面安装神奇的库，我想要读取一个PPT文件里面的所有页面的所有文本将这些文本输出，此时我可以如何做？想要做PPT解析可不是一个简单的事情，但是有了 NuGet 工具，好像就简单了好多了

我通过神奇的bing找到了微软开源的官方 Office 解析库 OpenXml 库，这是一个跨平台的库，可以在任何的 dotnet core 和 dotnet framework 项目上使用，首先就是按照惯例先安装 NuGet 库。如何安装呢？

假设通过下面代码创建了一个控制台项目

dotnet new console -o WhocohefurWallqemwaychurgu

在进入到 WhocohefurWallqemwaychurgu 文件夹之后，可以使用下面代码用 dotnet 工具安装 Openxml 库

dotnet add package DocumentFormat.OpenXml

此时就完成了库的安装了，接下来就是使用这个库啦，假设在 E:\lindexi\测试.pptx 的文件就是本文想要测试输出的文件，可以在 Program 使用下面代码，就是这么方便就完成了一个 PPT 的解析了

            using (var presentationDocument = DocumentFormat.OpenXml.Packaging.PresentationDocument.Open(@"E:\lindexi\测试.pptx", false))
            {
                var presentationPart = presentationDocument.PresentationPart;
                var presentation = presentationPart.Presentation;

                // 先获取页面
                var slideIdList = presentation.SlideIdList;

                foreach (var slideId in slideIdList.ChildElements.OfType<SlideId>())
                {
                    // 获取页面内容
                    var slidePart = (SlidePart) presentationPart.GetPartById(slideId.RelationshipId);

                    foreach (var paragraph in
                        slidePart.Slide
                            .Descendants<DocumentFormat.OpenXml.Drawing.Paragraph>())
                    {
                        // 获取段落
                        // 在 PPT 文本是放在形状里面
                        foreach (var text in
                            paragraph.Descendants<DocumentFormat.OpenXml.Drawing.Text>())
                        {
                            // 获取段落文本，这样不会添加文本格式
                            Debug.WriteLine(text.Text);
                        }
                    }
                }
            }

这个项目所有代码放在 github 欢迎小伙伴访问

通过上面例子小伙伴可以看到用 NuGet 的话，将问题从如何理解一个新的知识和如何应用和编写代码转换为如何寻找一个库，以及如何使用这个库。按照学习模型的分法，寻找一个库和学习如何使用这个库都是属于舒适区范围。而学习一个新知识，如学习 PPT 的格式等，这些就是属于学习模型里面的恐慌区了，学起来的难度和需要投入的时间都是很大的

刚才都是通过命令行的形式安装库的，我是不是还可以使用太阳系里面最强的 IDE 来进行管理 NuGet 库呢？没错请打开 VisualStudio 创建一个控制台项目，我这里还是依然使用刚才的命令行创建的项目为例子。可以双击 xx.csproj 打开项目，此时的 VisualStudio 在你关闭它时会提示保存 sln 文件，而不需要先新建 sln 文件

右击项目点击管理 NuGet 程序包

点击之后可以看到此页面

这里提供了安装 NuGet 库的功能以及卸载库的功能，只需要在搜寻里面输入对应的库的名字，支持模糊搜寻的功能，找到对应的库，点击安装就可以了

多使用 NuGet 库，可以减少自己写的代码的时间，如果看到一个库里面的下载量很多，那么证明这个库还是有比较多小伙伴用的。换句话就是有很多小伙伴帮你踩坑了，基本上可以放心使用

我是一个助人为乐的逗比，我想要将自己写的代码打包为库让更多的小伙伴能用上我的逗比代码，我可以怎么做？

很简单，在 VisualStudio 右击打包就可以啦

请看 VisualStudio 使用新项目格式快速打出 Nuget 包基本上5分钟内就可以完成打包啦

不想打开 VisualStudio 的话，可以用上文介绍的 dotnet pack 一句话进行打包，当然这个命令就只能打包，而对包里面的作者什么的设置就需要手动编辑 csproj 文件啦，没有在 VisualStudio 里面那么方便啦

很不辛苦，很简单打出一个包出来了，请问如何发布呢？访问 https://www.nuget.org/ 官网，点击上传就可以啦。想要进行自动化的发布，在 Github 上往主分支合并时就自动发布，请看 Github 给仓库上传 NuGet 库

更多阅读：

上一篇博客：程序猿修养从安装 dotnet 开始

程序猿修养从安装 dotnet 开始

Thu, 03 Dec 2020 12:27:51 +0000

本来程序员的开始应该是从命令行开始，但是能看到博客的小伙伴，预计都了解命令行了。但是如果是一个空命令行，能做的事情实在不够清真，能提升的效率也有限。如何站在巨人的键盘（没写错）上，用大佬写的各个工具提升日常逗比的效率？答案是从安装 dotnet 开始

小伙伴说 dotnet 不就是一个语言框架？其实不然，这是一个总入口，无论想要做什么，其实只要有这个 dotnet 在，就相当于拥有了一堆工具。无论是不是 dotnet 系的开发者，我都推荐你安装 dotnet 这个工具

安装之后有什么好处？其实我可以两句命令行开启一个静态文件服务，提供给手机或其他设备访问本机资源的功能。我可以两句代码开启校验一个文件的 md5 我可以两句代码清理磁盘垃圾

为什么我能做到这些？因为 dotnet 是一个工具的入口，通过 dotnet 可以自己安装工具，然后通过 dotnet 执行工具

好，说到这里，让咱试试

先到 dotnet 官网 https://dotnet.microsoft.com/ 下载最新版本的 dotnet 工具，然后安装。整个 dotnet 是免费的跨平台的，开源的，也就是想不开可以去随意更改 dotnet 的源代码，构建自己版本的 dotnet 哦

好的，安装完成之后，就来补咱刚才吹的水了，请在命令行敲下这句代码

dotnet tool install -g dotnet-serve

等等，这是要做什么？其实上面的命令是安装了一个叫 dotnet serve 的工具，这个工具可以将本地的文件作为静态文件提供为 web 网页。用命令行进入到一个有文件的文件夹，然后输入下面命令

dotnet serve -o

此时是不是看到浏览器打开了本地文件的预览了，就是这么简单，一句命令开启静态文件服务器。详细使用请看 dotnet serve 一句话开启文件服务器通过 HTTP 将文件共享给其他设备

通过 dotnet 工具，将可以安装世界上超过 100000 个有趣的工具，同时每天都有无数大佬在上传制作自己的工具。在安装 dotnet 之后，除了工具上的便利，还可以提升开发上的便利

在 dotnet 上的工具，除了命令行工具外，还有很多应用软件工具，提供可视化窗口等，如我发布的专业修复 NuGet 合并问题的 NuGet 修复工具，请使用下面命令进行安装和使用

dotnet tool install -g NuGetMergeFixTool
dotnet nugetfix

上面的安装工具的代码魔力在哪里？其实上面的安装命令需要分为下面这几个部分，第一个是 dotnet 命令，这个是调用刚才安装的 dotnet 工具，而 dotnet tool 就是运行 dotnet 里面工具的功能，在这里可以看到这么强大的功能其实只是 dotnet 的一部分。而 dotnet tool install 的 install 就是调用安装的功能，除了安装之外肯定还有删除更新等这些功能

接下来的 -g 是什么意思？其实这是 --global 的缩写，表示安装的是全局的应用，而不是给单个项目用的工具，进行全局安装那么在任何的文件夹里面都能使用上。而最后面的参数就是安装的工具名啦，只需要查阅魔法书，找到工具的名字，就能安装工具，使用强大的功能啦

等等，有一个前提，我的魔法书在哪？其实魔法书存放的地方有很多，也许在你看这个博客的时候，就有小伙伴在创建新的工具啦，而下面是我收藏的一些好用的工具和汇总的网页

dotnetCampus.UpdateAllDotNetTools 一句命令更新所有 dotnet tool 到最新版本
dotnet-serve 一句命令开启文件服务器
NuGetMergeFixTool 修复大型项目的 NuGet 合并，也可以用来快速升级 NuGet 库
natemcmaster/dotnet-tools: A list of tools to extend the .NET Core command line (dotnet)
RehanSaeed/awesome-dotnet-core: A collection of awesome .NET core libraries, tools, frameworks and software

如果你有其他的好用的工具还请告诉我

其实这只是 dotnet 工具的一个功能，更强大的在于构建软件和发布的功能。这个功能能让小伙伴从零开始写出一个有趣的软件

程序员从命令行开始

我想要创建一个控制台应用，我可以如何做？通过下面一句命令就可以啦，这就是我在其他设备上，我不需要要求有什么 IDE 或文本编辑工具。只需要用默认的文本编辑工具，如 Windows 下的记事本或 Ubuntu 下的 Vim 都可以，配合 dotnet 工具我就能写出代码咯

dotnet new console -o 项目名（如不写将会在当前文件夹里面生成，用当前文件夹名作为项目名）

然后如何构建然后运行？没错构建和运行只需要一句代码

dotnet run

而除了控制台，可以创建的文件也是特别多，如 dotnet new wpf 就能创建出 WPF 应用了。接下来就是打包测试发布一条龙的命令啦

dotnet test // 自动运行单元测试项目
dotnet pack // 进行打包
dotnet push // 将打出来的包上传到 NuGet 服务器

通过不断编写代码开发工具，让工具辅助开发代码，不断循环能够建立起强大的生态。其实现在我开发的时候有很多业务和功能甚至核心功能或算法都不需要从零开始写，只需要去找找有没有大佬做出来了，因为使用 dotnet 的好处在于有 NuGet 的分发方式。小伙伴可以方便将自己写的库通过 NuGet 发布，而其他小伙伴可以通过 NuGet 上去下载库，有一个笑话是发射一颗卫星需要多少步骤？没错就是三步

到底是哪三步呢，还请看下一篇博客程序猿修养使用 NuGet 发射卫星只需要三步

安装完成了 dotnet 工具之后，将让设备具备下载和使用海量的工具，这些工具不仅仅只是命令行工具，还有很多应用软件在内。还可以让设备具备构建和发布软件的功能，和让设备分发工具和库的功能

github 设置自动删除合并的分支

Thu, 03 Dec 2020 12:27:51 +0000

在 github 上提 MR 在合并之后的分支，很少需要继续保存，如果真的有需求，建议使用 tag 保存，而在合并之后不需要这个分支，默认的 github 不会删除这个分支

让 github 自动删除 MR 合并的分支是通过在对应的仓库，点击 settings 设置，点击 Automatically delete head branches 自动删除

WPF 给应用程序添加水印

Thu, 03 Dec 2020 12:27:51 +0000

我有一个应用，我想要在应用上添加水印，这个水印可以如何做

例如我有一个应用，我在主页面添加了功能页面，在功能页面的最上层需要一个水印，这个水印不能被用户点击到，例如我的功能页面是一个用户控件放在页面

<Window x:Class="NeachecihaDenemceweefai.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:NeachecihaDenemceweefai"
        mc:Ignorable="d"
        Title="MainWindow" Height="300" Width="600">
    <Grid>
        <local:KekalcigarjeyikelRijurjeeyaira></local:KekalcigarjeyikelRijurjeeyaira>
    </Grid>
</Window>

可以通过在最顶层元素，也就是上面代码的 Grid 里面添加一个水印控件，如一张图或文字，本文这里使用文字，放在容器最后面，为什么需要放在最后面？因为放在后面的显示在最上层

然后设置水印的命中，请看下面代码

        <TextBlock Text="林德熙是逗比" Margin="10,10,10,10" IsHitTestVisible="True"></TextBlock>

上面代码核心是IsHitTestVisible="True"通过这个属性就可以让用户无法点中这个文本

本文代码放在 github 欢迎小伙伴访问

Github 添加 Action 编译图标

Thu, 03 Dec 2020 12:27:51 +0000

在我的仓库里面，可以在首页添加图标显示当前是否编译通过

在 README.md 文件添加下面代码作为图标

![](https://github.com/组织或个人/仓库
/workflows/执行Action的Name注意转码/badge.svg)

如我在 dotnet-campus 的 dotnetcampus.DotNETBuildSDK 仓库里面的 .NET Core 编译任务，可以这样写

![](https://github.com/dotnet-campus/dotnetcampus.DotNETBuildSDK
/workflows/.NET%20Core/badge.svg)

注意这里的 .NET Core 是 Action 对应的 Name 同时需要转码才能用

下面是 Action 配置

name: .NET Core

on: [push]

jobs:
  build:

    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v1
 
    - name: Build with dotnet
      run: dotnet build --configuration Release

注意 Action 的 Name 不是文件名

dotnet tool 判断博客文档链接是否可用的工具

Thu, 03 Dec 2020 12:27:50 +0000

本文来和大家安利一个好用的工具，通过这个工具可以找到自己博客文档里面，是否存在有链接已经失效了

安装

dotnet tool install -g Lindexi.Tool.CheckBlogUrlAvailable

使用

CheckBlogUrlAvailable [folder]

调用此命令，将会找到当前文件夹内所有的 md 文档，读取里面的内容，找到里面的连接，尝试访问链接

其中 folder 文件夹如不写则采用当前命令的工作文件夹

原理

通过正则匹配当前文件夹里面所有的 md 文档的内容，尝试找到属于链接的字符串，接着尝试去访问这个链接。如果访问失败了就输出

此工具是一个 dotnet 工具，因此可以使用 NuGet 进行分发。更多关于 dotnet 工具打包，请看 dotnet 手工打一个 dotnet tool 包

这个项目在 GitHub 完全开源，链接是 https://github.com/lindexi/UWP

.NET 官方图标

Thu, 03 Dec 2020 12:27:50 +0000

在哪可以找到 dotnet 官方权威的图标？正统的 .NET 图标是哪个？本文来回答大家这几个问题

请到 dotnet/brand 品牌指导仓库里面获取最新的 logo 文件

这个 https://github.com/dotnet/brand 仓库的用途是官方与 .NET 开发人员社区进行通信并建立一致的品牌标识。此存储库给是设计人员、编写人员和开发人员为 .NET 创建一致的品牌内容的指南和参考

dotnet 在 GitHub 的 Action 上部署自动代码编码规范机器人

Thu, 03 Dec 2020 12:27:50 +0000

我们的项目中会包含有很多文件，但是可能我们没有注意到的，我们的文件的编码不一定是 UTF-8 编码，这就可能让构建出来的应用程序在别人电脑运行时出现乱码，或者别人拉下来代码，却发现代码里面的中文都是乱码。为了解决文件编码的问题，咱需要一个编码规范工具，本文将告诉大家在 GitHub 上仓库，可以利用 GitHub 的 Action 部署自动代码文件编码规范的机器人，这个机器人可以自动协助咱规范文件的编码规范。可以设置为每次上传代码的时候，自动帮忙设置文件编码为 UTF-8 编码。或者在每次代码合并到主分支之后，机器人将会尝试修复文件的编码，如存在文件需要修复的，那机器人将会创建一个代码审查

只想配置机器人，而不想看原理？没关系，给你一个快餐，复制 dotnet-format.yml 文件到你的 GitHub 仓库的 .github\workflows 文件夹里面即可。效果如何，你试试就知道了，或者在等待 GitHub 的 Action 过程中阅读一下本文

此方法不单适合于 dotnet 系的语言，也适合于其他任何使用文本记录代码的语言。因为本文使用的工具准确来说是针对于文本文件的编码的

本文的修复文件编码规范的工具是利用了在 GitHub 上完全开源的 dotnet-campus/EncodingNormalior 项目的工具，这个项目链接是 https://github.com/dotnet-campus/EncodingNormalior 欢迎大家参与开发

修复文件编码的方法是使用 dotnetCampus.EncodingNormalior 这个 dotnet tool 工具完成的，这个工具的使用方法如下

在使用之前先使用命令行安装或更新，请在命令行输入下面代码

dotnet tool install -g dotnetCampus.EncodingNormalior

修复某个文件夹里面的所有文本文件的编码规范可以使用如下命令

EncodingNormalior -f E:\lindexi\EncodingNormalior --TryFix true

上面代码的 E:\lindexi\EncodingNormalior 为需要修复文本文件的编码规范的文件夹

这个 dotnetCampus.EncodingNormalior 工具的修复文本文件的编码规范的原理是先尝试判断出文本文件的编码，如此文件的编码不符合规范，如上面命令要求默认的规范的编码是 UTF-8 编码，那么此工具将会使用判断出来的文件编码去读取此文件，然后重新按照约定的规范编码将读取出来的文本重新写入到文件中

因为当前世界上不存在一个方法可以准确判断出不带BOM编码格式的文件的编码，因此这个工具也许会判断错文件的编码，如果判断错了编码，也许就会在修复之后让文件乱码

有了这个工具的支持，在 GitHub 上的 Action 做自动代码编码规范机器人就简单很多了，参考 dotnet 基于 dotnet format 的 GitHub Action 自动代码格式化机器人的方法，可以在 GitHub 的 Action 中通过 dotnetCampus.EncodingNormalior 工具尝试修复文本文件的编码规范，如果有文件更改，那么提一个代码审查出来，或者直接推送代码到原分支

在 .github\workflows 文件夹里面创建的所有 yml 文件都会当成构建脚本，咱来创建一个叫 dotnet-format.yml 的文件。按照 GitHub 的 Action 的规定，每个构建脚本文件都应该给定一个名字，如下面代码

name: Code Encoding Check

然后设置构建脚本的触发时机，如下面代码设置了在推送了 master 分支时，触发构建脚本

on: 
  push:
    branches: 
      - master

其他触发时机等，还请大家去阅读官方文档

下一步是指定运行在什么设备上，如下面代码

jobs:
  dotnet-format:
    runs-on: windows-latest

接下来就是将代码拉下来了，可以通过如下代码将当前分支的最新代码拉下来

    steps:
      - name: Checkout repo
        uses: actions/checkout@v2
        with:
          ref: $

本文的格式化方法是使用 dotnetCampus.EncodingNormalior 工具格式化的，在使用这个工具之前，需要先安装，请使用如下代码进行安装

      - name: Install dotnet-format
        run: dotnet tool install -g dotnetCampus.EncodingNormalior

被微软收购的 GitHub 默认构建环境肯定是包含了整个 dotnet 的，因此大家不需要额外再去安装。但如果大家用的是自己的环境，请使用如下代码安装 dotnet 环境

    - name: Setup .NET Core
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 3.1.300

下一步是使用编码规范工具尝试修复代码文件夹里面的文本文件的编码

      - name: Fix encoding
        run: EncodingNormalior -f . --TryFix true

如果有某些特殊文件需要忽略文件的编码的，还请参阅 dotnet-campus/EncodingNormalior 项目的命令行篇的更多用法

如果项目文件夹里面存在文件被更改，那么证明此文件的编码不符合约定的规范。通过 Git 将此更改签入，用于后续的步骤

      - name: Commit files
        # 下面将使用机器人的账号，你可以替换为你自己的账号
        run: |
          git config --local user.name "github-actions-dotnet-formatter[bot]"
          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git commit -a -m 'Automated dotnet-format update'
        continue-on-error: true

上面代码中的邮箱地址和用户名都是使用 GitHub 机器人的账号，这里的代码可以自行替换

在上面代码没有判断是否存在文件变化，是因为在 Git 里面，如果没有文件更改，那么执行 git commit 将会失败，也就是啥都不会做。利用这个特性就可以减少一个判断更改的步骤了

而最后一句话 continue-on-error: true 是因为 git commit 会失败也是预期的，这个步骤可以忽略失败。加上这个命令就可以在这个步骤失败的时候，不会影响其他步骤

在这里可以分为两个不同的方向做，一个方向是将这个更改创建一个代码审查，另一个方向是推送到当前的分支上面去

我比较推荐的做法是创建一个代码审查。尽管使用工具的行为都是预期的，但是根据我这边团队的理念，所有的代码更改都应该被审查。即使是机器人的更改，也是需要审查一下的。这个做法和 dotnet 组织的 WPF 以及 Xamarin 等仓库的做法是相同的

在 GitHub 的 Action 里面创建一个代码审查，可以使用下面代码

      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v3
        with:
          title: '[Bot] Automated PR to fix formatting errors'
          body: |
            Automated PR to fix formatting errors
          committer: GitHub <noreply@github.com>
          author: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
          # 以下是给定代码审查者，需要设置仓库有权限的开发者
          assignees: lindexi,walterlv
          reviewers: lindexi,walterlv
          # 对应的上传分支
          branch: t/bot/fix-codeformatting

上面代码中的给定代码审查者，需要设置仓库有权限的开发者。这里利用了创建代码审查的一个功能，如果两个分支的代码没有历史的差异，是不会创建代码审查的。也就是如果文件夹里面没有文件更改，此时 git commit 将啥都不会做，而创建代码审查时，因为上一步 git commit 没有更改历史，因此两个分支的历史依然相同，不会创建代码审查

利用这个功能，就可以减少判断文件更改的逻辑了。如果文件夹里面的文件都符合编码规范，那么将啥都不会做。而如果有文件不符合编码规范，此时将会自动修改文件编码，然后创建一个代码审查

如果小伙伴觉得不需要创建代码审查，因为整个团队就几个开发者在开发，可以将修改编码之后的文件推送到当前的分支上面去，那么请使用下面代码推送。如果文件夹里面的文件都符合编码规范，那么将啥都不会做，因为没有内容可以推送

      - name: Push changes
        uses: ad-m/github-push-action@v0.5.0
        with:
          github_token: $
          branch: $

但是这个方法也许会让开发者不开森，因为他下一次上传代码的时候需要先拉代码，也许因为格式化给他了额外的改动。另外的，如 Xamarin 仓库的注释，其实代码推送无法用在 fork 的仓库上，也就是说如果这个代码审查是另一个开发者在他 fork 的仓库里面发起的，此时的这个方法将会失效

我现在在 dotnet-campus/AsyncWorkerCollection 仓库就接入这个机器人，用起来还不错

我将自动代码格式化机器人和本文的自动文件编码规范机器人合并一起接入，欢迎小伙伴到 https://github.com/dotnet-campus/AsyncWorkerCollection 项目参观效果

更多关于这个工具请看下面博客

dotnet tool 文件编码规范命令行工具

Thu, 03 Dec 2020 12:27:50 +0000

在咱项目里面，大家是否有关注过文件的编码，一个文件是作为 Ascii 编码保存的，还是作为 GBK 编码保存的，还是 UTF8 编码保存的？不同的编码是否对应用有影响？其实是会有影响的，在 C# 里面的字符串常量等都会受到文件编码的影响。例如我的应用主输出是 UTF8 编码，此时我在二进制可执行文件里面保存的输出字符串的二进制是采用 GBK 编码的内容，在一些用户的设备上也许就会显示出乱码本文来安利大家一个 dotnet 工具，这个工具可以用来协助大家找到项目里面的编码不规范文件

本文告诉大家的这个工具的源代码在 GitHub 完全开源，这个开源仓库是一个古老的仓库，核心功能是提供给 VisualStudio 插件，用于扫整个项目里面的所有文件，尝试找到所有编码不规范的文件。而本文只是用到这个仓库里面的 dotnet tool 工具

仓库请看 dotnet-campus/EncodingNormalior: 规范化文件编码。Make the file’s encoding standard.

在使用之前，请使用下面代码安装或更新工具

dotnet tool install -g dotnetCampus.EncodingNormalior

安装完成工具之后，可以采用如下命令使用工具

EncodingNormalior -f E:\lindexi\EncodingNormalior

上面命令的 E:\lindexi\EncodingNormalior 就是需要扫编码规范的文件夹，使用这个命令可以将这个文件夹里面的所有文本文件扫一次，如果有文件不符合规范的，将会输出出来

如果大家期望使用这个工具自动转换文件编码，此时可以添加 --TryFix true 参数，如下面命令

EncodingNormalior -f E:\lindexi\EncodingNormalior --TryFix true

需要说明的是现在没有一个算法能够准确了解一个没有带编码BOM的文件的编码，因此加上了自动转换文件编码参数之后，工具将会按照自己认为的编码去读取文件，然后再次写入，也许会让文件乱码

更多关于这个命令行的使用方法，还请大家到开源仓库 https://github.com/dotnet-campus/EncodingNormalior

dotnet 基于 dotnet format 的 GitHub Action 自动代码格式化机器人

Thu, 03 Dec 2020 12:27:50 +0000

是不是大家也会觉得代码审查里面审查代码格式化问题是无意义的，但是不审查又觉得过不去？是否有个专门的工具人，用来协助修复代码格式化的问题？本文来安利大家一个特别好用的方法，使用 dotnet 完全开源的专业格式化工具 dotnet format 配合 GitHub 的自动构建 Action 做的自动代码格式化机器人，这个机器人可以被指定到特定时机，如每天晚上或者每次代码合并等，进行代码格式化，格式化完成之后，可以选择直接推送或者提代码审查

这个方法将需要用到 dotnet 完全开源的专业格式化工具 dotnet format 工具，请看 https://github.com/dotnet/format

用法十分简单，可以复制本文最后的 GitHub 的自动构建 Action 的脚本，放在仓库的 .github\workflows 文件夹里面。现在请让我告诉大家这个构建脚本的细节

在 .github\workflows 文件夹里面创建的所有 yml 文件都会当成构建脚本，每个脚本就应该给定一个名字，如下面代码

name: Daily code format check

然后设置构建脚本的触发时机，如下面代码设置了在推送了 master 分支时，触发构建脚本

on: 
  push:
    branches: 
      - master

其他触发时机等，还请大家去阅读官方文档

下一步是指定运行在什么设备上，如下面代码

jobs:
  dotnet-format:
    runs-on: windows-latest

接下来就是将代码拉下来了，可以通过如下代码将当前分支的最新代码拉下来

    steps:
      - name: Checkout repo
        uses: actions/checkout@v2
        with:
          ref: $

本文的格式化方法是使用 dotnet format 工具格式化的，在使用这个工具之前，需要先安装，请使用如下代码进行安装

      - name: Install dotnet-format
        run: dotnet tool install -g dotnet-format

原本可以使用一句命令 dotnet format 就进行格式化，但是当前遇到的问题是，如果代码格式化没有任何文件更改，那么此时就不应该做创建新的分支和开启代码审查了，因此就需要用到 jfversluis 大佬的 dotnet-format 脚本。这个脚本可以输出参数，用于在后续步骤判断，如果没有文件更改，也就是没有代码需要格式化就不需要开启代码审查了

      - name: Run dotnet format
        id: format
        uses: jfversluis/dotnet-format@v1.0.5
        with:
          repo-token: $
          action: "fix"
          only-changed-files: true # only works for PRs
          # workspace: "Xamarin.Forms.sln" 默认根路径只有一个 sln 文件，可以忽略这一行

如果自己的仓库里面的根路径，也就是放在和 .git 文件夹所在的相同的文件夹，存在了一个 sln 文件，那么可以忽略 workspace 参数

调用了上面代码脚本之后，将会输出，可以使用如下代码判断，是否有文件更改

if: steps.format.outputs.has-changes == 'true'

接下来是 commit 代码，如果代码文件有更改的话

      - name: Commit files
        if: steps.format.outputs.has-changes == 'true' # 如果有格式化，才继续
        # 下面将使用机器人的账号，你可以替换为你自己的账号
        run: |
          git config --local user.name "github-actions-dotnet-formatter[bot]"
          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git commit -a -m 'Automated dotnet-format update'

上面代码的邮件等是 GitHub 机器人的账号，你可以替换为你的账号

最后一步是开启代码审查，然后指定代码审查者

      - name: Create Pull Request
        if: steps.format.outputs.has-changes == 'true' # 如果有格式化，才继续
        uses: peter-evans/create-pull-request@v3
        with:
          title: '[Bot] Automated PR to fix formatting errors'
          body: |
            Automated PR to fix formatting errors
          committer: GitHub <noreply@github.com>
          author: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
          # 以下是给定代码审查者，需要设置仓库有权限的开发者
          assignees: lindexi,walterlv
          reviewers: lindexi,walterlv
          # 对应的上传分支
          branch: t/bot/fix-codeformatting

这样就能完成了在开发者将代码合并或推送到主分支的时候，自动尝试代码格式化，如果代码格式化有文件更改了，那么开启一个代码审查，如下图

感谢 jfversluis 大佬的 dotnet-format 脚本，和 Peter Evans 的创建代码审查的 create-pull-request 脚本

我比较推荐使用这个方法，尽管 dotnet format 工具是专业的代码格式化工具，不会让格式化前后的代码的 IL 有变更。但是我依然推荐进行一次代码审查

其实不使用 jfversluis 大佬的脚本也可以，因为 Peter Evans 的创建代码审查的 create-pull-request 脚本会自动判断如果没有 commit 就不创建代码审查，因此只需要跳过 commit 的失败就可以了，如下面代码

      - name: Install dotnet-format
        run: dotnet tool install -g dotnet-format

      - name: Run dotnet format
        run: dotnet format

      - name: Commit files
        # 下面将使用机器人的账号，你可以替换为你自己的账号
        run: |
          git config --local user.name "github-actions-dotnet-formatter[bot]"
          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git commit -a -m 'Automated dotnet-format update'
        continue-on-error: true

可以看到代码十分简洁

而另外的方法是在每个开发者开启代码审查的时候，尝试格式化他的代码，这样可以让代码审查者也许会更开森，代码十分简单，请看下面

name: Format check on pull request
on: pull_request
jobs:
  dotnet-format:
    runs-on: windows-latest
    steps:
      - name: Install dotnet-format
        run: dotnet tool install -g dotnet-format

      - name: Checkout repo
        uses: actions/checkout@v2
        with:
          ref: $

      - name: Run dotnet format
        id: format
        uses: jfversluis/dotnet-format@v1.0.5
        with:
          repo-token: $
          action: "fix"
          only-changed-files: true

      - name: Commit files
        if: steps.format.outputs.has-changes == 'true'
        run: |
          git config --local user.name "github-actions[bot]"
          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git commit -a -m 'Automated dotnet-format update
          Co-authored-by: $ <$+$@users.noreply.github.com>'
      - name: Push changes
        if: steps.format.outputs.has-changes == 'true'
        uses: ad-m/github-push-action@v0.5.0
        with:
          github_token: $
          branch: $

我现在在 dotnetCampus.Ipc 就接入这个自动代码格式化机器人，用起来还不错

构建脚本的全部代码请看下面

name: Code format check

on: 
  push:
    branches: 
      - master
jobs:
  dotnet-format:
    runs-on: windows-latest
    steps:

      - name: Checkout repo
        uses: actions/checkout@v2
        with:
          ref: $

      - name: Install dotnet-format
        run: dotnet tool install -g dotnet-format

      - name: Run dotnet format
        run: dotnet format

      - name: Commit files
        # 下面将使用机器人的账号，你可以替换为你自己的账号
        run: |
          git config --local user.name "github-actions-dotnet-formatter[bot]"
          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git commit -a -m 'Automated dotnet-format update'
        continue-on-error: true
        
      - name: Create Pull Request
        # if: steps.format.outputs.has-changes == 'true' # 如果有格式化，才继续
        uses: peter-evans/create-pull-request@v3
        with:
          title: '[Bot] Automated PR to fix formatting errors'
          body: |
            Automated PR to fix formatting errors
          committer: GitHub <noreply@github.com>
          author: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
          # 以下是给定代码审查者，需要设置仓库有权限的开发者
          assignees: lindexi,walterlv
          reviewers: lindexi,walterlv
          # 对应的上传分支
          branch: t/bot/fix-codeformatting

dotnet 让 C# 可以通过动态生成 HLSL 使用 DX12 的 GPU 并行计算库 ComputeSharp 的简介

Thu, 03 Dec 2020 12:27:50 +0000

本文来安利大家一个超强的库，这个库可以让你的 C# 代码利用上 GPU 显卡的性能，进行一些并行计算。这个库是基于 DirectX12GameEngine 的 ComputeSharp 库。在这个库里面将会动态生成 HLSL 代码，使用着色器的方式在 GPU 上跑起来

这个 ComputeSharp 库在 GitHub 完全开源，请看 https://github.com/Sergio0694/ComputeSharp

在开始之前，按照 dotnet 的基本玩法，先通过 NuGet 安装库，然后使用，咱先来创建一个空白的项目。这个 ComputeSharp 库能支持的 .NET Standard 2.1 和以上的版本

通过 NuGet 安装 ComputeSharp 库，在 NuGet 包命令行输入下面代码

Install-Package ComputeSharp

或者在 csproj 文件上添加下面代码

  <ItemGroup>
    <PackageReference Include="ComputeSharp" Version="1.4.1" />
  </ItemGroup>

下面使用一个并行给一个 float 数组设置顺序值的例子告诉大家如何使用这个库

先定义 Shader 的实现，请看下面代码

    public readonly struct MyShader : IComputeShader
    {
        // 这是特意的命名，请不要更改
        public readonly ReadWriteBuffer<float> buffer;

        public MyShader(ReadWriteBuffer<float> buffer)
        {
            this.buffer = buffer;
        }

        public void Execute(ThreadIds ids)
        {
            buffer[ids.X] = ids.X;
        }
    }

这段代码将会被用来生成 HLSL 代码，因此一些属性的命名是不能更改的

然后从 GPU 中申请一段内存

            // Allocate a writeable buffer on the GPU, with the contents of the array
            ReadWriteBuffer<float> buffer = Gpu.Default.AllocateReadWriteBuffer<float>(1000);

接着在 GPU 上运行

            // Run the shader
            Gpu.Default.For(1000, new MyShader(buffer));

运行完成之后，可以使用下面代码拿到值

            // Get the data back
            float[] array = buffer.GetData();

使用下面代码可以输出数组里面的值

            Console.WriteLine(string.Join(",", array.Select(temp => temp.ToString())));

此时可以看到这个数组里面的值都按照顺序被设置了对应的值

本文代码放在github欢迎小伙伴访问

还有更多高级的用法，还请看 https://github.com/Sergio0694/ComputeSharp

dotnet tool 工具安装提示 Could not find a part of the path 安装失败

Thu, 03 Dec 2020 12:27:50 +0000

我在安装 dotnet tool 工具时发现所有的工具都安装失败，全部都提示 Could not find a part of the path 安装失败。我重新安装了 dotnet SDK 也没有用，更新到了3.1.402 版本也没有修复

我在 GitHub 开源了 dotnetcampus.DotNETBuildSDK 项目，请看 https://github.com/dotnet-campus/dotnetcampus.DotNETBuildSDK

这个开源项目包含了大量构建需要用到的工具

这个开源项目的工具通过 dotnet tool 分发，但是在我的一台服务器发现任何工具都无法安装，提示下面代码

工具“dotnetcampus.buildmd5task”因以下原因而未能更新:
未能安装工具包“dotnetcampus.buildmd5task”: Could not find a part of the path 'C:\Users\lindexi\.dotnet\tools\.store\.stage\4byk1d2b.5hi\dotnetcampus.buildmd5task'.
工具“dotnetcampus.buildmd5task”安装失败。此故障可能由以下原因导致:

* 你尝试安装预览版，但未使用 --version 选项来指定该版本。
* 已找到具有此名称的包，但是它不是 .NET Core 工具。
* 无法访问所需的 NuGet 源，这可能是由于 Internet 连接问题导致。
* 工具名称输入错误。

有关更多原因(包括强制包命名)，请访问 https://aka.ms/failure-installing-tool

我尝试给了 C:\Users\lindexi\.dotnet\ 和里面的文件夹全部加了权限，也尝试删除文件夹重新创建，都无法解决此问题

最后发现可以通过在另一台设备上，在这台设备安装好需要的工具，然后将 .dotnet\tools 文件夹拷贝过去，这样就能解决问题

asp dotnet core 记一次应用拒绝响应调试开启线程等待同步用光线程池

Thu, 03 Dec 2020 12:27:50 +0000

我有一个上古的库，我使用这个库用来上报日志，而刚才日志服务挂了。然后我就发现了我的应用拒绝响应了，通过 VisualStudio 断点调试可以发现线程池的线程全部被占用了。因为没有可用线程因此所有对 asp dotnet core 应用的访问全部都不会收到响应，为什么我的另一个应用日志服务挂了会让我的业务应用拒绝响应？为什么我的业务应用会使用线程池所有的线程，为什么线程池的所有线程被占用将会让应用拒绝响应

很好复现这个坑，在开始复现之前，需要聊一下背景

我有一个业务应用和一个日志服务，基本上可以认为日志服务和业务没有任何关联，而且我从上层业务调用可以看到，都是异步使用。而在日志服务全部挂掉的时候，开始业务应用还能使用，但是当请求大概访问了 100 次，就发现后续的访问都没有任何返回。同时在业务应用的本机控制台和日志文件里面都没有任何记录，而控制台也没有收到 50x 等错误，也就是业务应用还在工作，但是没有任何响应

我在本地上可以复现，使用 VisualStudio 开启所有异常，也什么都没收到。在应用配置文件 appsettings.json 文件里面将日志配置设置为 Debug 也没有拿到任何有用的信息

原本每次的请求都会在默认的 asp dotnet core 日志输出至少一条日志，但是此时什么日志都没有输出

而此时的业务应用的 cpu 和内存占用都很少，在没有请求的时候，可以看到 cpu 几乎没有占用

在点击 VisualStudio 暂停的时候，可以看到业务应用创建了大量的线程

其实调试到线程的时候，大概半个下午了，哈哈

其实我不知道如果一个 asp dotnet core 应用对所有的请求都没有返回，也没有报错的时候可以如何调试

在看到有大量的线程被创建的时候，此时可以调试的是打开调试->窗口->并行堆栈这个工具可以辅助调查所有线程问题

如果一个应用创建了大量线程，如果这些线程都是通过 Task.Run 创建，那么意味着线程池里面的线程全部都使用了。也就是此时的下一次调用 Task.Run 需要等待线程池重新分配或创建线程。如果线程池没有空闲的可以分配需要等待一段时间才能创建新的线程，于是此时的应用就会卡住没有返回值

而根据 Eleven 老师的 asp dotnet core 源代码分析课程可以了解到，在 asp dotnet core 服务主机里面的线程是主线程固定的，但是调用到对应的控制器需要通过线程池调度。当然更多细节还请小伙伴关注 Eleven 老师的社区

在用光线程池的线程，此时的请求可以被主机处理，因此不会抛出远程服务器拒绝请求。但是主机通过线程池调度到对应控制器，因为线程池没有足够的线程，因此将会进入很长的等待。特别是有后续请求，那么将需要不断排队。这就是为什么我看到的业务应用拒绝服务

进一步的调试可以通过并行堆栈找到最多相同的堆栈，也就是有多少线程都在相同的堆栈里，那么证明这部分逻辑有锅

我在调试中看到如下代码

我的底层库给我的方法是异步的上报日志方法，但是这个日志上报方法的核心是通过 Task.Run 一个线程进行同步调用

其实在 asp dotnet core 的性能优化中，要尽量不使用 Task.Run 方法，在 ASP.NET Core Performance Best Practices 官方文档和译文 ASP.NET Core 性能优化最佳实践 - Newbe36524 - 博客园都有提到，原因还请小伙伴看这两篇博客

那么为什么上面的代码将会让线程池的线程都在等待？原因是 GetResponse 是一句同步的代码，同步的代码等待网络的返回，而此时我的日志服务大概写了如下代码

        [HttpGet]
        [Route("/")]
        public async Task<IActionResult> Get()
        {
            await Task.Task;

            return Ok();
        }

        private static readonly TaskCompletionSource<bool> Task = new TaskCompletionSource<bool>();

这是我写出的最简单的日志服务的代码，这个代码的所有请求都会进入到 await Task.Task; 等待一个不会返回的任务，也就是任何的请求进来只能等待超时

而刚好上面业务应用的等待是没有设置超时的，在同步的调用等待一个不会返回的请求，此时的线程就被占用了

如果业务应用对每次请求都需要进行如上面的从线程池获取线程然后进行同步访问，那么线程池的将会被用光。在线程池的线程都被占用的时候，下次调用 Task.Run 就会先等待一段时间，如果等待一段时间还没有线程可以调度，那么此时才会在线程池新建线程

所以应用如果拒绝响应，首先需要调查应用是否用光了线程池，然后再调查连接数。如果是线程池用光，那么打开并行堆栈，看线程最多的堆栈是什么，然后通过堆栈和源代码可以找到是否存在锁或者调用 IO 同步

如果发现这个的 asp dotnet core 应用的性能不足，因为线程开启过多，那么此时可以全局找 Task.Run 的代码，尽可能干掉这部分逻辑

而本文的坑，可以使用将同步修改为异步的方法解决，换句话说，不需要通过线程池开启线程的方法，通过IO自带的异步方法进行异步IO请求。此时在 IO 的异步里面将会自动出让 CPU 执行，这部分是硬件的支持，因此进入异步的 IO 将不会占用线程，线程可以回到线程池给其他业务调用

一个可选的方法是将一些不重要但是需要慢慢执行的任务放在生产者消费者队列里面，如果这部分任务很小，可以尝试使用我的 AsyncQueue 高性能低资源占用的类，详细请看 dotnet 使用 AsyncQueue 创建高性能内存生产者消费者队列

dotnet 双缓存数据结构设计下载库的文件写入缓存框架

Thu, 03 Dec 2020 12:27:50 +0000

我在写一个文件下载库，这个下载库利用断点续传机制，支持多线程下载一个文件。但是文件写入只能支持单线程，我不想让网络下载需要等待磁盘写入，因此我需要先在内存做缓存，然后让磁盘写入。配合 DirectX 渲染的设计方法，采用双缓存数据结构设计，也就是有两个集合，其中一个集合用来被其他模块写入，另一个集合用来作为当前使用。此时能做到网络下载使用的集合和文件写入的集合不是相同的一个集合，因此两部分的速度差异将不会相互影响

这个文件下载库在 GitHub 完全开源，欢迎小伙伴点击 Star 和参与开发

dotnet-campus/dotnetCampus.FileDownloader: The repo includes the file download library and the file download tool.

可以进行试用的方法是通过 dotnet tool 工具使用，命令行版本使用方法如下

dotnet tool install -g dotnetCampus.FileDownloader.Tool
DownloadFile -u [the download url] -o [the download file]

下载方法是在命令输入 DownloadFile -u [下载链接] -o [下载文件路径]

带 GUI 的 WPF 版本请使用下面命令安装

dotnet tool update -g dotnetCampus.FileDownloader.WPF

在控制台输入 dotnetCampus.FileDownloader.WPF 即可启动简单版本的例子

而更多的是这个下载库是通过 NuGet 库的方式，可以让你在其他项目里面引用这个库

可以使用下面代码给项目添加下载库的引用

dotnet add package dotnetCampus.FileDownloader

使用方法如下

var segmentFileDownloader = new SegmentFileDownloader(url, file);

await segmentFileDownloader.DownloadFileAsync();

好的，广告就到这里

我在写下载库遇到的问题是网络下载速度和磁盘写入速度有差异，我不期望网络下载需要等待磁盘下载，因此我抄袭了 DirectX 的设计方法，开了一个双缓存。刚好这个文件写入双缓存类足够通用，可以让我水一篇博客

如果只是想要抄代码的小伙伴，请到文本最后面

这个双缓存类的设计里面需要有两个集合，一个集合用于被加入，另一个集合用于被使用。因此想要这个类足够通用，就需要让集合使用 ICollection 让上层可以注入

而因此具体放的元素是不需要关注的，因此可以作为上层注入，也就是这个类有两个泛形

    /// <summary>
    /// 提供双缓存 线程安全列表
    /// </summary>
    /// 写入的时候写入到一个列表，通过 SwitchBuffer 方法，可以切换当前缓存
    class DoubleBuffer<T, TU> where T : class, ICollection<TU>
    {

    }

接下来定义两个缓存

        private T AList { get; }
        private T BList { get; }

还需要再定义一个当前使用的被写入的缓存属性，这个属性将会指向 AList 或 BList 其中一个值

        private T CurrentList { set; get; }

在初始化的时候将会初始化这三个属性

        public DoubleBuffer(T aList, T bList)
        {
            AList = aList;
            BList = bList;

            CurrentList = AList;
        }

定义加入元素的方法，加入的时候和缓存切换的时候都需要加上锁，因此还需要定义一个对象

        private readonly object _lock = new object();

        public void Add(TU t)
        {
            lock (_lock)
            {
                CurrentList.Add(t);
            }
        }

再定义一个切换缓存的方法

        public T SwitchBuffer()
        {
            lock (_lock)
            {
                if (ReferenceEquals(CurrentList, AList))
                {
                    CurrentList = BList;
                    return AList;
                }
                else
                {
                    CurrentList = AList;
                    return BList;
                }
            }
        }

可以看到上面的缓存切换是十分快的，但是这里存在一个坑，也就是返回的 T 不能被保存，只能用一次，同时也禁止多线程同时调用

上面代码的切换缓存方法只能使用一个线程调用，同步调用。调用的时候返回的集合不能被保存，也就是如下代码是不推荐的

private void Foo()
{
   Buffer = fooDoubleBuffer.SwitchBuffer();
}

private List<int> Buffer { set; get; }

而且有需求是执行完成当前缓存里面的所有任务，而在执行任务的过程中有其他线程加入新的任务，因此就封装了一个方法，调用这个方法传入执行任务的委托就可以实现

        /// <summary>
        /// 执行完所有任务
        /// </summary>
        /// <param name="action">当前缓存里面存在的任务，请不要保存传入的 List 参数</param>
        public void DoAll(Action<T> action)
        {
            while (true)
            {
                var buffer = SwitchBuffer();
                if (buffer.Count == 0) break;

                action(buffer);
                buffer.Clear();
            }
        }

使用上面这个方法大概能执行完成这个双缓存里面的所有任务，但是上面这个是同步的方法，于是再添加一个支持异步的方法

        /// <summary>
        /// 执行完所有任务
        /// </summary>
        /// <param name="action">当前缓存里面存在的任务，请不要保存传入的 List 参数</param>
        /// <returns></returns>
        public async Task DoAllAsync(Func<T, Task> action)
        {
            while (true)
            {
                var buffer = SwitchBuffer();
                if (buffer.Count == 0) break;

                await action(buffer);
                buffer.Clear();
            }
        }

不过这个双缓存也不能完成在不断有其他线程加入任务的时候，执行完成所有。因为在返回之前的 if (buffer.Count == 0) 判断的时候，也许此时又有其他线程加入了任务。但是作为文件写入的双缓存是可以在网络下载完成之后，再次调用 DoAllAsync 方法，只要在 DoAllAsync 方法调用之前就不会存在有新任务加入，那么这个方法是可以完全执行完成所有任务

但是如果需要手动写执行完成所有的调用方法，那么这部分代码也许会写出线程相关的逻辑，因此再封装一个 DoubleBufferTask 类，这是一个使用双缓存的任务调度类

这个类可以支持设置任意的类型作为任务的数据，同时传入处理任务的执行方法

    class DoubleBufferTask<T>
    {
        public DoubleBufferTask(Func<List<T>, Task> doTask)
        {
            _doTask = doTask;
        }

        private readonly Func<List<T>, Task> _doTask;
    }

对 DoubleBufferTask 的使用方法就是创建起来，然后传入执行任务的方法，接着可以多线程调用 AddTask 方法添加任务，在所有任务加入完成之后，调用 Finish 方法表示完成

        public void AddTask(T t)
        {
            DoubleBuffer.Add(t);
            
            // 忽略代码
        }

        public void Finish()
        {
            // 忽略代码
        }

        private DoubleBuffer<T> DoubleBuffer { get; } = new DoubleBuffer<T>();

同时还需要有一个 WaitAllTaskFinish 方法给上层，可以用来等待调用 Finish 方法之后所有任务执行完成

        public Task WaitAllTaskFinish()
        {
            return FinishTask.Task;
        }

        private TaskCompletionSource<bool> FinishTask { get; } = new TaskCompletionSource<bool>();

使用 FinishTask 的优势在于可以在调用 Finish 方法之后，调用 WaitAllTaskFinish 也能返回。有多个线程同时等待 WaitAllTaskFinish 方法也能线程安全返回

本文的全部代码

    /// <summary>
    /// 提供双缓存 线程安全列表
    /// </summary>
    /// 写入的时候写入到一个列表，通过 SwitchBuffer 方法，可以切换当前缓存
    class DoubleBuffer<T> : DoubleBuffer<List<T>, T>
    {
        public DoubleBuffer() : base(new List<T>(), new List<T>())
        {
        }
    }

    /// <summary>
    /// 提供双缓存 线程安全列表
    /// </summary>
    /// 写入的时候写入到一个列表，通过 SwitchBuffer 方法，可以切换当前缓存
    class DoubleBuffer<T, TU> where T : class, ICollection<TU>
    {
        public DoubleBuffer(T aList, T bList)
        {
            AList = aList;
            BList = bList;

            CurrentList = AList;
        }

        public void Add(TU t)
        {
            lock (_lock)
            {
                CurrentList.Add(t);
            }
        }

        public T SwitchBuffer()
        {
            lock (_lock)
            {
                if (ReferenceEquals(CurrentList, AList))
                {
                    CurrentList = BList;
                    return AList;
                }
                else
                {
                    CurrentList = AList;
                    return BList;
                }
            }
        }

        /// <summary>
        /// 执行完所有任务
        /// </summary>
        /// <param name="action">当前缓存里面存在的任务，请不要保存传入的 List 参数</param>
        public void DoAll(Action<T> action)
        {
            while (true)
            {
                var buffer = SwitchBuffer();
                if (buffer.Count == 0) break;

                action(buffer);
                buffer.Clear();
            }
        }

        /// <summary>
        /// 执行完所有任务
        /// </summary>
        /// <param name="action">当前缓存里面存在的任务，请不要保存传入的 List 参数</param>
        /// <returns></returns>
        public async Task DoAllAsync(Func<T, Task> action)
        {
            while (true)
            {
                var buffer = SwitchBuffer();
                if (buffer.Count == 0) break;

                await action(buffer);
                buffer.Clear();
            }
        }

        private readonly object _lock = new object();

        private T CurrentList { set; get; }

        private T AList { get; }
        private T BList { get; }
    }

    class DoubleBufferTask<T>
    {
        public DoubleBufferTask(Func<List<T>, Task> doTask)
        {
            _doTask = doTask;
        }

        public void AddTask(T t)
        {
            DoubleBuffer.Add(t);

            DoInner();
        }

        private async void DoInner()
        {
            // ReSharper disable once InconsistentlySynchronizedField
            if (_isDoing) return;

            lock (DoubleBuffer)
            {
                if (_isDoing) return;
                _isDoing = true;
            }

            await DoubleBuffer.DoAllAsync(_doTask);

            lock (DoubleBuffer)
            {
                _isDoing = false;
                Finished?.Invoke(this, EventArgs.Empty);
            }
        }

        public void Finish()
        {
            lock (DoubleBuffer)
            {
                if (!_isDoing)
                {
                    FinishTask.SetResult(true);
                    return;
                }

                Finished += (sender, args) => FinishTask.SetResult(true);
            }
        }

        public Task WaitAllTaskFinish()
        {
            return FinishTask.Task;
        }

        private TaskCompletionSource<bool> FinishTask { get; } = new TaskCompletionSource<bool>();

        private bool _isDoing;

        private event EventHandler? Finished;

        private readonly Func<List<T>, Task> _doTask;

        private DoubleBuffer<T> DoubleBuffer { get; } = new DoubleBuffer<T>();
    }

本文的双缓存库在 GitHub 独立发布，请看 https://github.com/dotnet-campus/AsyncWorkerCollection/ 可以在 NuGet 上安装

本文的 AsyncWorkerCollection 库提供两个 NuGet 包，一个是 dll 引用，另一个是源代码引用，分别如下

dotnetCampus.AsyncWorkerCollection
dotnetCampus.AsyncWorkerCollection.Source

如果使用 SDK 版本的 csproj 可以在项目文件使用下面代码安装源代码版本

    <ItemGroup>
        <PackageReference Include="dotnetCampus.AsyncWorkerCollection.Source" Version="1.2.1">
            <PrivateAssets>all</PrivateAssets>
            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
        </PackageReference>
    </ItemGroup>

安装完成之后即可使用

dotnet OpenXML 颜色变换

Thu, 03 Dec 2020 12:27:50 +0000

颜色变换是对基础颜色的相关属性的修改。例如，透明度是与颜色相关的属性。颜色转换被指定为任何颜色模型标签的子标签，可以在任何颜色加上颜色变换

大概的写法如下

<a:solidFill>
   <a:srgbClr val="00B050">
        <a:alpha val="51000"/>
   </a:srgbClr>
</a:solidFill> 

上面代码表示一个使用 Solid Color Brush 的填充(a:solidFill) 颜色是 RGB 颜色，基础值是 #00B050 在此基础上加上 alpha 通道，值是 EMU 单位的

而 a:alpha 就是颜色变换的内容，除了 a:alpha 之后，还有很多其他的颜色变换

tint：产生较浅版本的输入颜色。如 10％的色彩是输入颜色的10％，再加上90％的白色。
shade：产生其输入颜色的较暗版本。如 10％的阴影是输入颜色的10％加上90％的黑色。
comp：产生其输入颜色的补码。例如，红色的补码是绿色。
inv：产生其输入颜色的倒数。例如，红色（1,0,0）的倒数是青色（0,1,1）。
gray：考虑到红色，绿色和蓝色原色的相对强度，产生其输入颜色的灰度。
alpha：产生具有指定不透明度的输入颜色，但其颜色不变。
alphaOff：产生其输入颜色或多或少不透明的版本。 Alpha偏移量永远不会使Alpha值超过100％或降低至0％以下；也就是说，转换结果会将alpha固定为[0％，100％]的范围。如 10％的alpha偏移将50％的不透明度增加到60％。如 -10％的alpha偏移将50％的不透明度降低到40％。
alphaMod：产生其输入颜色或多或少的不透明版本。 alpha调制永远不会将alpha增加到100％以上。如 200％的alpha调制使输入颜色的透明度是以前的两倍。 50％的alpha调制使输入颜色的透明度是以前的一半。
hue：产生具有指定色相但饱和度和亮度不变的输入颜色。
hueOff：改变其色调但不改变其饱和度和亮度，以产生输入颜色。
hueMod：产生输入色，其色相由给定百分比调制。
sat：以指定的饱和度产生输入颜色，但其色相和亮度不变。通常，饱和度值在[0％，100％]范围内。
satOff：产生具有饱和度偏移但色相和亮度不变的输入颜色。
satMod：产生输入颜色，其饱和度由给定的百分比调制。如 50％饱和度调制可将饱和度降低一半。如 200％的饱和度调制会使饱和度加倍。
lum：以指定的亮度产生输入颜色，但其色相和饱和度不变。通常，亮度值在[0％，100％]范围内。
lumOff：产生输入颜色，其亮度发生变化，但其色相和饱和度不变。
lumMod：产生输入颜色，其亮度由给定百分比调制。如 50％的亮度调制将亮度降低一半。如 200％的亮度调制使亮度加倍。单位是千倍百分比
red：使用指定的红色分量产生输入颜色，但绿色和蓝色分量不变。
redOff：产生输入颜色，其中红色分量发生偏移，而绿色和蓝色分量保持不变。
redMod：产生输入颜色，其红色分量由给定的百分比调制。如 50％的红色调制将红色分量减少一半。如 200％的红色调制会使红色分量加倍。
green：产生具有指定绿色成分的输入颜色，但红色和蓝色成分不变。
greenOff：产生输入颜色，其中绿色分量发生偏移，但红色和蓝色分量保持不变。
greenMod：产生输入颜色，其绿色分量由给定的百分比调制。如 50％的绿色调制将绿色分量减少一半。如 200％的绿色调制将绿色分量加倍。
blue：产生具有指定蓝色成分的输入颜色，但其红色和绿色成分不变。
blueOff：产生输入颜色，其中蓝色分量已移动，但红色和绿色分量未更改。
blueMod：产生输入颜色，其蓝色分量由给定的百分比调制。如 50％的蓝色调制可将蓝色分量减少一半。如 200％的蓝色调制使蓝色分量加倍。
gamma：产生其输入颜色的sRGB gamma偏移。
invGamma：产生其输入颜色的sRGB逆γ偏移。

详细请看 ECMA 376 的 L.4.8.3 文档和 20.1.2.3 Colors 文档

上面的所有标记了百分比的值的单位都是千倍百分比，也就是在 OpenXML 文档里写的值如下面代码，这里的 lumMod 就是表示百分比

<a:schemeClr val="tx1">
    <a:lumMod val="65000" />
</a:schemeClr>

这里的 65000 就是千倍百分比，每 1000 表示百分之一，关于单位请看Office Open XML 的测量单位

更多请看 Office 使用 OpenXML SDK 解析文档博客目录

dotnet 在国产 UOS 系统利用 dotnet tool 工具做文件传输

Thu, 03 Dec 2020 12:27:50 +0000

我在一台设备上安装了 UOS 系统，但是我如何在我的主开发设备上和 UOS 系统传输文件？通过 dotnet tool 工具可以完成大部分的工作，当然，使用 dotnet tool 不仅做文件传输，还能做很多特别强大的应用。本文就使用文件传输作为例子告诉大家如何使用 dotnet tool 在多个平台里面使用相同的一套技术和命令行作为工具

在 dotnet 里，可以制作一个 dotnet 应用，将这个应用发布到 NuGet 上，无论是外网的 NuGet 的还是自己内网搭建的都可以，然后其他小伙伴就可以通过 NuGet 下载到这个应用。这样的应用就叫 dotnet tool 工具

使用 dotnet tool 工具的优势在于，工具使用自己熟悉的 .NET 编写，其次是分发方便，毕竟咱的项目基本上都需要安装 NuGet 包，也就是咱都是有 NuGet 源和环境的，因此可以方便在设备上利用 NuGet 获取工具或上传自己的工具

在开始之前，请在 UOS 上安装必要的工具，如 dotnet 开发工具，请看 dotnet 在 UOS 国产系统上安装 dotnet sdk 的方法

接下来咱需要使用的工具有两个，一个是用来开启本地文件服务器的，另一个是用来下载文件的

在 UOS 上有一个限制，也就是不能调用全局的工具，只能使用文件夹内本地工具，这个问题我和官方说了，请看 dotnet global tool can not run in UOS system · Issue #13399 · dotnet/sdk

例如我期望在 UOS 上传输一个文件到我的开发机器上？可以如何做？可以使用下面步骤

在 UOS 上开启文件服务器
在开发机上使用下载工具下载文件

如果需要传输一个文件夹呢？其实只需要将文件夹压缩就可以使用上面步骤

在 UOS 上将文件夹压缩成文件
在 UOS 上开启文件服务器
在开发机上使用下载工具下载文件

下面咱一步步来

压缩文件夹成文件

这一步在 UOS 上做，可以使用自带的 tar 工具，压缩命令如下

 tar -cvf 1.tar lindexi/

上面命令就是将 lindexi 文件夹压缩到 1.tar 文件里

详细请看 Linux tar压缩命令：打包与解打包命令

安装 dotnet tool 工具

在 UOS 开启文件服务器可以使用 dotnet-serve 工具，在开始之前需要先初始化一下工具

dotnet new tool-manifest

上面代码将会在当前工作路径下初始化 dotnet tool 工具

然后使用下面命令安装 dotnet 本机文件服务器工具

dotnet tool install dotnet-serve

安装完成之后，可以使用下面代码开启文件服务器

dotnet tool run dotnet-serve -a 0.0.0.0

而在 Windows 端开启文件服务器就没有那么长的命令了，因为 Windows 下是支持全局工具的，也许后续 UOS 也会支持

在 Windows 下第一步是安装工具，注意和 UOS 上安装不同的是添加了 -g 表示全局安装，全局安装的工具，可以在任意工作路径下才能使用。而不加上 -g的是本地安装，只有在当前当前工作路径下才能使用

dotnet tool install -g dotnet-serve

接着使用下面代码开启文件服务器

dotnet serve -a 0.0.0.0

详细请看 dotnet serve 一句话开启文件服务器通过 HTTP 将文件共享给其他设备

下载文件

在 UOS 上是 Linux 系统，可以使用 wget 的工具下载文件，而在 Windows 下可以使用 dotnetCampus.FileDownloader.Tool 工具下载文件，这是一个完全在 GitHub 开源的项目

安装 dotnet tool 的方法和上面安装文件服务器相同，在 Windows 下使用下面代码作为全局工具安装

dotnet tool install -g dotnetCampus.FileDownloader.Tool

安装完成之后，可以使用下面命令下载文件

DownloadFile -u 下载链接 -o 下载文件保存路径

在 UOS 上开启文件服务器，使用下面命令开启

dotnet tool run dotnet-serve -a 0.0.0.0

再打开一个终端，使用下面命令找到 UOS 的 ip 地址

sudo ifconfig

假定在 UOS 上开启文件服务器的工作路径下，有刚才压缩好的 1.tar 文件准备传输到 Windows 服务器上

先记下 UOS 的 ip 地址，和执行 dotnet serve 开启的服务器端口，如 36867 端口，此时可以在 Windows 下使用下面命令下载 1.tar 文件

downloadfile -u http://172.20.115.72:36867/1.tar -o 1.tar

上面代码的 172.20.115.72 就是 UOS 设备的地址

这样就仅通过工具完成了 UOS 到 Windows 文件的传输，有趣的是，反过来也可以，使用的工具和命令也可以是相同的

更多关于下载工具请看 https://github.com/dotnet-campus/dotnetCampus.FileDownloader

也许本文的例子还不够让大家看到 dotnet tool 的优势，因为 UOS 作为 Linux 系统，有大量可用的自带的命令行工具，只是存在一个坑就是我对这些工具都是不熟悉的。而 dotnet tool 可以让两边都使用相同的工具和命令

欢迎小伙伴加入 xamarin 国产 UOS 开发群： 810052083

dotnet 在 UOS 国产系统上安装 dotnet sdk 的方法

Thu, 03 Dec 2020 12:27:50 +0000

本文告诉大家如何在 UOS 国产系统上安装 dotnet sdk 的方法

使用的 UOS 是 UOS 20 x64 版本，这个系统版本是基于 debian 10 的，可以使用 debian 10 的方法安装

进入 UOS 系统，点击左下角的图标，也就是相当于 Windows 的开始按钮，点击终端。这里的终端就是命令行工具类似 Windows 的 cmd 工具

进入 /etc/apt 文件夹，在终端输入下面代码

cd /etc/apt

使用 vim 工具编辑 sources.list 文件，添加 debian 源

vim sources.list

在 vim 工具里面，是纯命令行工具，按下 i 进入输入编辑模式，输入 debian 源

deb https://mirrors.ustc.edu.cn/debian buster main contrib non-free

然后注释掉其他的源

按照在 Debian 上安装 .NET Core 的方法，在命令行输入下面代码，将 Microsoft 包签名密钥添加到受信任密钥列表，并添加包存储库

wget https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

接下来开始安装 dotnet sdk 在控制台输入下面代码

sudo apt-get update; \
  sudo apt-get install -y apt-transport-https && \
  sudo apt-get update && \
  sudo apt-get install -y dotnet-sdk-3.1

欢迎小伙伴加入 xamarin 国产 UOS 开发群： 810052083

如果安装失败了，请看官方文档

dotnet 在 UOS 国产系统上使用 Xamarin Forms 创建 xaml 界面的 GTK 应用

Thu, 03 Dec 2020 12:27:50 +0000

在前面几篇博客告诉大家如何部署 GTK 应用，此时的应用是特别弱的，大概只是到拖控件级。尽管和 WinForms 一样也能写出特别强大的应用，但是为了提升一点开发效率，咱开始使用 xaml 神器写界面。本文告诉大家如何在 UOS 国产系统上，通过 Xamarin.Forms 使用 XAML 写界面逻辑，构建出 GTK 应用

本文将使用特别底层的方法告诉大家如何一步步创建，而不是告诉大家如何在 IDE 上进行快速的创建。因此本文更适合用来告诉大家一些基础的内容，而不适合用来规模化创建上

请注意，本文的步骤很多，只是我为了让大家能了解更多细节。实际上没有那么复杂

在开始之前，请确定你安装好了环境，如何安装请看下面博客

如 dotnet 在 UOS 国产系统上使用 MonoDevelop 创建 GTK 全平台带界面应用所说，创建一个空白的 GTK# 应用

接着创建一个控制台项目，假定这个项目是 A 项目，这个控制台项目将会添加 Xamarin.Foms 负载，然后将构建出基于 Xamarin.Forms 的界面 dll 文件，接着将由 GTK 项目，假定命名为 B 项目，作为最终原生控件支持，被 Xamarin.Forms 的界面 dll 所映射，因此刚才新建的 GTK 项目就是最终入口项目，应用程序由他启动

在创建的控制台项目里面，编辑 csproj 文件，右击刚才创建的控制台项目，点击工具，点击编辑文件

修改 csproj 文件为下面内容

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
    <DebugType>portable</DebugType>
    <DebugSymbols>true</DebugSymbols>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Xamarin.Forms" Version="4.8.0.1364" />
    <PackageReference Include="Xamarin.Essentials" Version="1.5.3.2" />
  </ItemGroup>
</Project>

有小伙伴说，在 Windows 下，用 VS 新建一个 Xamarin.Forms 项目之后，再拷贝到 UOS 上，也是可以的，但是有一点需要注意的是不能拷贝 bin 和 obj 文件夹过去，原因是在 obj 文件夹存放了很多依赖本机电脑的文件夹绝对路径的文件，如 nuget 还原里面的 project.assests.json 文件将会包含 fallback 路径，如果拷贝到 Linux 下的系统，也许会看到如下提示

Error MSB4018 The "ResolvePackageAssets" task failed unexpectedly. NuGet.Packaging.Core.PackagingException: Unable to find fallback package folder 'C:\ProgramData\Xamarin\NuGet\'

或者

Error MSB4018 The "ResolvePackageAssets" task failed unexpectedly. NuGet.Packaging.Core.PackagingException: Unable to find fallback package folder 'C:\Program Files (x86)\Xamarin\NuGet\'

如果忘了这一点复制了 obj 文件夹，可以在 UOS 这个 Linux 系统下删除 obj 文件夹，解决 Xamarin Forms 在 Linux 系统构建失败的问题

先忽略从Windows等系统创建好了 Xamarin Forms 的方法，咱就在 UOS 上一步步创建

删除 A 项目，也就是安装了 Xamarin Forms 的控制台项目，的 Program.cs 文件

然后选择新建一个空 xml 文件，创建完成之后修改命名为 App.xaml 文件，同时创建一个空类叫 App.xaml.cs 文件

这两个文件将表示 Xamarin Forms 项目的起始，也就是在 Xamarin 层的启动入口。在使用 Xamarin.Forms 的 GTK 应用，有两层入口，第一层是本机程序的入口，也就是 B 项目的 Program 文件的 Main 方法入口，第二层就是 Xamarin.Forms 的 App 入口。应用程序启动的时候，先进入第一层入口，在第一层入口初始化本机相关的进程，然后进入第二层入口，在第二层入口初始化 Xamarin 应用

在 App.xaml 添加下面代码，下面代码的 x:Class="WokemhelurnawgelrallKearlallidallla.App" 其实 WokemhelurnawgelrallKearlallidallla 就是项目名

<?xml version="1.0" encoding="utf-8" ?>
<Application xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:d="http://xamarin.com/schemas/2014/forms/design"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             mc:Ignorable="d"
             x:Class="WokemhelurnawgelrallKearlallidallla.App">
    <Application.Resources>

    </Application.Resources>
</Application>

其实上面的 App.xaml 是空代码，有意义的代码放在 App.xaml.cs 请看代码

using Xamarin.Forms;

namespace WokemhelurnawgelrallKearlallidallla
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new MainPage();
        }
    }
}

上面代码的核心就是在构造方法调用 InitializeComponent 方法，然后设置主页面

接着咱需要新建一个主界面，新建 MainPage 的 xml 文件，然后修改命名为 MainPage.xaml 文件

然后填写界面代码

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:d="http://xamarin.com/schemas/2014/forms/design"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             mc:Ignorable="d"
             x:Class="WokemhelurnawgelrallKearlallidallla.MainPage">

    <StackLayout>
        <Label Text="Welcome to Xamarin.Forms!" 
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand" />
    </StackLayout>

</ContentPage>

还请小伙伴先不要改多内容哈

接着新建 MainPage.xaml.cs 文件，添加下面代码

using System.ComponentModel;
using Xamarin.Forms;

namespace WokemhelurnawgelrallKearlallidallla
{
    [DesignTimeVisible(false)]
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
        }
    }
}

现在新建了 App 应用和 MainPage 一个界面，但是还需要一个 AssemblyInfo.cs 文件，设置程序集特性

using Xamarin.Forms.Xaml;

[assembly: XamlCompilation(XamlCompilationOptions.Compile)]

这样一个简单的 Xamarin Forms 项目就完成了，设置 GTK 项目，也就是 B 项目，引用 Xamarin Forms 项目，也就是 A 项目

但是此时将会发现构建不通过，因为 B 项目，也就是 GTK 项目没有引用足够的 NuGet 包。给 B 项目添加以下 NuGet 库

OpenTK
Xamarin.Forms
Xamarin.Forms.Platform.GTK

接着打开 B 项目的 Program.cs 文件，在 Main 方法添加如下代码

            Gtk.Application.Init();
            Forms.Init();
 
            var app = new App();
            var window = new FormsWindow();
            window.LoadApplication(app);
            window.SetApplicationTitle("lindexi");
            window.Show();
            Gtk.Application.Run();

注意在编辑器里面添加 using 引用

然后删除除了 Program.cs 的其他 cs 代码文件

此时 B 项目，构建之后可以看到如下界面

当前的项目大概如下

本文没有给大家一个简单的方法，主要是让大家可以了解更多内容

官方文档请看 GTK# Platform Setup - Xamarin

尽管官方文档里面说的是预览版，但是经过了2年的开发，现在不能的支持的点很少。另外，这里的 GTK 支持的代码都是完全开源的，刚好我改的动，所以用起来也不慌

dotnet 在 UOS 国产系统上安装 MonoDevelop 开发工具

Thu, 03 Dec 2020 12:27:50 +0000

本文告诉大家如何在 UOS 上安装 MonoDevelop 开发工具。本文使用的 UOS 是 UOS 20 x64 版本，这个系统版本是基于 debian 10 的，默认的 MonoDevelop 开发工具是没有提供 UOS 版本，但是有提供 debian 10 版本

手动安装 MonoDevelop 不靠谱，本文推荐大家通过使用 debian 10 版本方法进行安装

在开始之前，还需要小伙伴安装好 mono 开发工具，安装方法请看 dotnet 在 UOS 国产系统上安装 Mono 开发工具的方法

接着进入 /etc/apt 文件夹，在终端输入下面代码

cd /etc/apt

使用 vim 工具编辑 sources.list 文件，添加 debian 源

vim sources.list

在 vim 工具里面，是纯命令行工具，按下 i 进入输入编辑模式，输入 debian 源

deb https://mirrors.ustc.edu.cn/debian buster main contrib non-free

上面命令详细含义请看 Debian 源使用帮助 — USTC Mirror Help 文档

接着加上 Mono 仓库源

sudo apt install apt-transport-https dirmngr
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
echo "deb https://download.mono-project.com/repo/debian vs-buster main" | sudo tee /etc/apt/sources.list.d/mono-official-vs.list
sudo apt update

上面命令详细请看 MonoDevelop 安装方法

接着使用下面代码安装 MonoDevelop 工具

sudo apt-get install monodevelop

安装完成之后，请回到 /etc/apt 文件夹，注释掉 sources.list 文件添加的 debian 源，不然也许会帮你更新 Kernal 组件，然后你重启之后就不能打开了

安装完成之后，可以从 UOS 的编程工具

dotnet 在 UOS 国产系统上使用 MonoDevelop 进行拖控件开发 GTK 应用

Thu, 03 Dec 2020 12:27:50 +0000

先从一个 Hello World 应用开始，试试和古老的 WinForms 一样的拖控件式开发

在创建完成一个 GTK# 2.0 应用之后，咱可以试试开始拖控件的开发，当然这个开发方式开发出来的应用界面有点古老。不过作为玩还是不错的

先拖入一个容器，和 WPF 一样，窗口里面的内容只允许一项，如果这一项是组件，那么意味着不能添加其他的元素，因此此时推荐使用是一个一个容器

接着拖入一个按钮和一个文本

然后点击按钮的属性的 Label 修改按钮显示文本内容为 Click 如下图

选择文本，设置文本内容是空字符串

按钮点击的事件，可以在属性的信号里面找到点击事件

填写事件名，此时将会在 MainWindow.cs 文件创建方法

返回代码，在按钮点击方法里面设置文本内容

此时运行代码，可以看到如下界面

这就是最简单的拖控件的方法

dotnet 在 UOS 国产系统上使用 MonoDevelop 创建 GTK 全平台带界面应用

Thu, 03 Dec 2020 12:27:50 +0000

本文告诉大家如何在 UOS 国产系统上开始使用 MonoDevelop 开发，通过创建 GTK# 应用，进入界面开发的第一步

在开始之前需要小伙伴先安装好 MonoDevelop 工具

安装完成之后，可以在开始菜单找到这个 MonoDevelop 工具

打开之后，点击新建项目

选择新建 GTK# 2.0 的项目，点击下一步，选择路径，加上项目名

请小伙伴记录这个路径，因为 UOS 的资源管理器做的比较弱，需要咱自己通过控制台去找到这个路径

其实MonoDevelop就是基于 GTK# 作为底层渲染的，因此能做到啥小伙伴大家看这个 IDE 也就有底了，有趣的是这个工具也是完全开源的

新建的项目默认啥都没有，可以按下 F5 开始执行

此时就完成了构建逻辑了

可以在命令行里面通过 mono xx.exe 执行构建出来的工具，当前只有一个空白窗口啥都没有，但是这是一个好的开始

dotnet 执行 docker 容器 error MSB4018 CreateAppHost 任务意外失败可能原因

Thu, 03 Dec 2020 12:27:50 +0000

在使用 ASP.NET Core 的 docker 调试的时候，在生成的这一步提示 C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018: “CreateAppHost”任务意外失败可能的原因是 docker 内之前的容器没有关闭

关注输出窗口，如果可以看到如下内容，那么就是 docker 内存在上次运行的容器没有关闭

1>docker exec -i 93b62c811acccda3232d8a18072f54991fc03198f646b810f8da08351d46daf5 /bin/sh -c "if PID=$(pidof dotnet); then kill $PID; fi"
1>/bin/sh: pidof: command not found
1>C:\Users\Lindexi\.nuget\packages\microsoft.visualstudio.azure.containers.tools.targets\1.10.8\build\Container.targets(138,5): warning CTP1006: 未能在容器中停止应用程序。由于文件正在使用中，因此生成可能会失败。
1>C:\Users\Lindexi\.nuget\packages\microsoft.visualstudio.azure.containers.tools.targets\1.10.8\build\Container.targets(138,5): warning CTP1006: Docker 命令失败，退出代码为 0。
1>C:\Users\Lindexi\.nuget\packages\microsoft.visualstudio.azure.containers.tools.targets\1.10.8\build\Container.targets(138,5): warning CTP1006: /bin/sh: pidof: command not found

此时 VS 的错误提示内容如下

11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018: “CreateAppHost”任务意外失败。
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018: Microsoft.NET.HostModel.HResultException: 8007006E
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.NET.HostModel.ResourceUpdater.Update()
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.NET.HostModel.AppHost.HostWriter.<>c__DisplayClass2_0.<CreateAppHost>g__UpdateResources|1()
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.NET.HostModel.RetryUtil.RetryOnWin32Error(Action func)
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.NET.HostModel.AppHost.HostWriter.CreateAppHost(String appHostSourceFilePath, String appHostDestinationFilePath, String appBinaryFilePath, Boolean windowsGraphicalUserInterface, String assemblyToCopyResorcesFrom)
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.NET.Build.Tasks.CreateAppHost.ExecuteCore()
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.NET.Build.Tasks.TaskBase.Execute()
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.Build.BackEnd.TaskExecutionHost.Microsoft.Build.BackEnd.ITaskExecutionHost.Execute()
11>C:\Program Files\dotnet\sdk\3.1.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.targets(424,5): error MSB4018:    在 Microsoft.Build.BackEnd.TaskBuilder.<ExecuteInstantiatedTask>d__26.MoveNext()

解决方法就是通过命令结束 docker 容器

使用 docker ps 命令找到所有在运行的实例，使用 docker kill 命令杀掉正在运行的实例，重新在 VS 按下 F5 开始调试就可以

关于 docker 命令请看 docker常用命令-docker kill_OneZeroTwoFour-CSDN博客

VisualStudio 解决首次调试 docker 的 vs2017u5 exists, deleting 太慢问题

dotnet 在 UOS 国产系统上安装 Mono 开发工具的方法

Thu, 03 Dec 2020 12:27:50 +0000

本文使用的 UOS 是 UOS 20 x64 版本，这个系统版本是基于 debian 10 的。而默认 mono-devel 是没有提供 UOS 版本，但是有提供 debian 10 版本，而 mono-devel 有很多依赖包，因此手动安装不是很靠谱

本文推荐的方法是配置上 debian 10 的源，然后使用 apt-get 安装，这样步骤比较少。但是有缺点是也许 debian 源会帮你更新一些系统组件，会让你的系统凉凉。因此少珺同学推荐在安装完成就干掉 debian 源

进入 UOS 系统，点击左下角的图标，也就是相当于 Windows 的开始按钮，点击终端。这里的终端就是命令行工具类似 Windows 的 cmd 工具

进入 /etc/apt 文件夹，在终端输入下面代码

cd /etc/apt

使用 vim 工具编辑 sources.list 文件，添加 debian 源

vim sources.list

在 vim 工具里面，是纯命令行工具，按下 i 进入输入编辑模式，输入 debian 源

deb https://mirrors.ustc.edu.cn/debian buster main contrib non-free

上面命令详细含义请看 Debian 源使用帮助 — USTC Mirror Help 文档

编辑完成，在 vim 里面退出保存方法是按下 esc 键，也就是键盘的左上角的键，然后输入 :wq 回车就可以退出保存。这一步难度比较大，请小伙伴参阅 Linux vim如何保存退出-百度经验

接着开始安装 mono-devel 工具

sudo apt-get install mono-devel

等待安装

安装完成之后，尝试在终端输入 mono 命令，如果能看到 mono 输出，那么证明安装成功

以上方法步骤很少，很简单，下面是我开始使用的手工方法

下面方法不适合初学者

先进入 https://debian.pkgs.org/10/debian-main-amd64/mono-devel_5.18.0.240+dfsg-3_all.deb.html 找到下载链接

在终端使用 wget 下载

wget http://ftp.br.debian.org/debian/pool/main/m/mono/mono-devel_5.18.0.240+dfsg-3_all.deb

接着使用 dpkg 命令安装

dpkg -i mono-devel_5.18.0.240+dfsg-3_all.deb

安装的时候会提示你缺少必要的库，这些库在 https://debian.pkgs.org/10/debian-main-amd64/mono-devel_5.18.0.240+dfsg-3_all.deb.html 列出

除了系统的库之外，其他的库都需要手动点击进去，然后和上面步骤差不多进行安装

如果安装到一半，因为需要安装的库太多了，准备放弃了，可以采用如上文方法，在 sources.list 文件，添加 debian 源

然后运行下面代码

sudo apt update
sudo apt --fix-broken install

然后输入 y 继续

安装完成尝试输入 mono 如果能看到输出那么证明安装成功

更多请看 Mono 官网

ASP.NET Core 警惕可空类型开启之后模型校验失败

Thu, 03 Dec 2020 12:27:50 +0000

在开启 Nullable 可空类型之后，原本可以调用的 API 也许就会提示 400 BadRequest 因为传入参数不合法，模型校验失败，此时将不会进入预期的 API 函数，同时也不会在输出里面找到有用的信息

在 SDK 风格的 csproj 文件开启可空类型可以添加下面代码

      <Nullable>enable</Nullable>

为了方便让小伙伴知道上面代码加在哪里，我贴出更多的 csproj 文件代码

  <PropertyGroup>
      <TargetFramework>netcoreapp3.1</TargetFramework>
      <Nullable>enable</Nullable>
  </PropertyGroup>

在开启之后，原本工作的很好的 API 也许在客户端调用的时候，将会提示 400 BadRequest 内容大概如下

{
    "type":"https://tools.ietf.org/html/rfc7231#section-6.5.1",
    "title":"One or more validation errors occurred.",
    "status":400,
    "traceId":"00-99b1c07693a55c4990389901832992a4-b2ed63ee45e85344-01",
    "errors":
    {
        "Account":
        [
            "The Account field is required."
        ]
    }
}

复习一下为什么会存在 400 错误

也许调用的 API 错误了，本来是预期调用 Foo 的，但却调用了 A 接口
也许调用的端口不对，也许是被 Fiddler 干扰了
也许是传入的参数不合法

如上面提示，实际内容是 The Account field is required 翻译过来就是接口里面的参数，要求一定存在 Account 属性

而明明之前工作的好好的，接口实现如下

        [HttpPost]
        // ReSharper disable once StringLiteralTypo
        [Route("/lindexi/doubi")]
        [RequestSizeLimit(100_000_000)]
        public async Task<string> PostFile([FromForm] LindexiUploadFileRequest request)

也就是需要通过 FromForm 拿到内容，而 LindexiUploadFileRequest 的定义如下

    [DataContract]
    public class LindexiUploadFileRequest
    {
        [DataMember(Name = "file")]
        [JsonPropertyName("file")]
        public IFormFile File { get; set; }

        [DataMember(Name = "account")]
        [JsonPropertyName("account")]
        public string Account { get; set; }
    }

客户端调用代码大概如下

       public async Task<string> Upload(string host, string file)
        {
            var multipartFormDataContent = new MultipartFormDataContent();
            var fileName = Path.GetFileName(file);

            var stringContent = new StringContent(fileName);
            multipartFormDataContent.Add(stringContent, "Name");

            using var fileStream = new FileStream(file, FileMode.Open);
            using var streamContent = new StreamContent(fileStream);
            multipartFormDataContent.Add(streamContent, "File", fileName);

            var account = "";

            multipartFormDataContent.Add(new StringContent(account), "Account");

            var httpClient = new HttpClient();
            var url = $"{host}/lindexi/doubi";

            var response = await httpClient.PostAsync(url, multipartFormDataContent).ConfigureAwait(false);
            var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
            return $"{response.StatusCode}\n{content}";
        }

小伙伴是否可以看出问题？实际上在开启可空之后，尽管在客户端代码里面设置了 multipartFormDataContent.Add(new StringContent(account), "Account"); 但是传入的内容是空字符串

而开启可空之后，定义的数据模型 public string Account { get; set; } 表示 Account 一定不是空，于是传入空的 Account 属性将会校验不通过

有两个解决方法，第一个解决方法就是标记 Account 属性可空

        [DataMember(Name = "account")]
        [JsonPropertyName("account")]
        public string? Account { get; set; }

但是对于大项目，很难测试全，此时可以在全局配置，让行为和之前相同

services.AddControllers(options => options.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes = true);

打开 Startup.cs 文件，在 ConfigureServices 函数添加上面代码即可

但对于 EF 这边，有更多的变更，详细请看 Working with nullable reference types - EF Core

因此如果是新项目，我推荐开启可空，而对于现有的项目，我不推荐打开

MvcOptions.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes Property (Microsoft.AspNetCore.Mvc)

Nullable=Enabled results in required validation errors for parameters or bound properties with default values · Issue #18403 · dotnet/aspnetcore

dotnet OpenXML 解析 PPT 文本字体获取详解

Thu, 03 Dec 2020 12:27:50 +0000

在 OpenXML 的 PPT 的文本的字体是一个比较复杂的概念，即使在 OpenXML SDK 的辅助下，也需要自己写很多的逻辑。通过 ECMA 376 文档里面散落在各地的描述，和 dotnetCampus.OfficeDocumentZipper 工具的实验帮助之下，我摸到了本文将要告诉大家的规则，以及逻辑的实现

有大量的 Office 相关软件在解析 PPT 文档使用的文本段的字体都非常简单，当然，这部分处理也就不全面

先让咱看一个简单的 PPT 文档的字体定义写法

<a:r>
    <a:rPr lang="zh-CN" altLang="en-US" dirty="0" smtClean="0">
        <a:ea typeface="楷体" panose="02010609060101010101" pitchFamily="49" charset="-122"/>
    </a:rPr>
    <a:t>一行文本</a:t>
</a:r>

请问当前文本的字体是什么？人类简单就能回答是 楷体 了

那么更进一步的，如下面的 PPT 文档呢？

<a:r>
    <a:rPr lang="zh-CN" altLang="en-US" sz="2000" dirty="0" smtClean="0">
        <a:latin typeface="Jokerman" panose="02010609060101010101" pitchFamily="49" charset="-122"/>
        <a:ea typeface="宋体" panose="02010609060101010101" pitchFamily="49" charset="-122"/>
    </a:rPr>
    <a:t>a文本</a:t>
</a:r>

此时的 a:latin 和 a:ea 表示的是什么意思？需要使用哪个字体才对？其实这是 PPT 的允许西文和中文使用不同字体的功能

这就是需要让不同的字符选择不同的字体的功能，解析方式请看 dotnet OpenXML 文本字体的选择规则

是不是觉得有点复杂了？其实这还不算复杂的

看看下面这份简洁的 PPT 文档

<p:txBody>
    <a:bodyPr wrap="square" rtlCol="0">
        <a:spAutoFit/>
    </a:bodyPr>
    <a:lstStyle/>
    <a:p>
        <a:r>
            <a:rPr lang="zh-CN" altLang="en-US" smtClean="0"/>
            <a:t>一行文本</a:t>
        </a:r>
        <a:endParaRPr lang="en-US" dirty="0"/>
    </a:p>
</p:txBody>

请问这份文档的字体是什么？其实上面的代码没有写任何的字体，那么 PPT 是如何知道的？这就需要用到上面代码一个没有写完成的功能，就是样式列表了

小伙伴可以注意到上面代码的一行内容 <a:lstStyle/> 这个的意思是什么？在 OpenXML SDK 里面有这个定义，请看代码

  var textBodyListStyle = textBody.ListStyle;

我准备了这份简洁的文档，这份文档将需要用到本文说讲到的大部分知识才能解析出实际的字体是哪个。本文用的测试文档放在 github 欢迎小伙伴下载测试。另外推荐 dotnetCampus.OfficeDocumentZipper 工具，这个工具可以更好的协助小伙伴测试文档

整个文本的定义如下

<p:sp>
    <p:nvSpPr>
        <p:cNvPr id="4" name="文本框 3"/>
        <p:cNvSpPr txBox="1"/>
        <p:nvPr/>
    </p:nvSpPr>
    <p:spPr>
        <a:xfrm>
            <a:off x="4168346" y="914401"/>
            <a:ext cx="3048000" cy="369332"/>
        </a:xfrm>
        <a:prstGeom prst="rect"></a:prstGeom>
    </p:spPr>
    <p:txBody>
        <a:bodyPr wrap="square" rtlCol="0"></a:bodyPr>
        <a:lstStyle/>
        <a:p>
            <a:r>
                <a:rPr lang="zh-CN" altLang="en-US" smtClean="0"/>
                <a:t>一行文本</a:t>
            </a:r>
            <a:endParaRPr lang="en-US" dirty="0"/>
        </a:p>
    </p:txBody>
</p:sp>

从上面的内容可以看到，这不是一个放在占位符的文本，那么什么是放在占位符的文本？如果 <p:nvPr/> 没有内容，那么就表示不是占位符的文本。而如果是占位符那么 p:nvpr 将会是如下格式

        <p:nvpr>
            <p:ph type="ctrTitle">
            </p:ph>
        </p:nvpr>

对于占位符需要通过继承属性添加更多内容，请看 dotnet OpenXML SDK 文本占位符解析

当然，本文的例子不是占位符是比较简单的元素

但是这个形状没有给一个明确的字体，那么请问这个形状用的字体是什么？此时涉及到了一个文本样式等级的概念

在文档里面有这一句代码 <a:lstStyle/> 表示文本本身没有重新定义样式等级，需要一层层寻找

可以在 Slide 的 Layout 和 Slide 的 Master 找到对应的 p:txStyles 内容，不过样式等级是另外的知识点，不在本文围内。可以告诉大家的是在这份测试课件里面，其实 SlideLayout 和 SlideMaster 的 p:txStyles 都不是此文本的样式。因为这个元素需要的是 <p:defaultTextStyle> 默认文本样式

那么在哪可以拿到 <p:defaultTextStyle> 默认文本样式？这是文档全局的设置，因此需要在 Presentation.xml 拿到，对应的 OpenXML 代码如下

using (var presentationDocument =
       DocumentFormat.OpenXml.Packaging.PresentationDocument.Open("测试.pptx", false))
{
    var presentationPart = presentationDocument.PresentationPart;
    var presentation = presentationPart.Presentation;

    var defaultTextStyle = presentation.DefaultTextStyle;
}

这就是 DefaultTextStyle 的获取方法，从 Presentation 类的属性定义也能了解到这个规则

于是按照规则，默认如果文本存在 ListStyle 那么就使用文本自己的，否则采用文档级的。当然，如果是占位符等元素，那就更复杂了，咱先忽略

在这份课件里面文本元素没有自己的样式重写，可以通过下面代码判断

var defaultTextStyle = presentation.DefaultTextStyle;
var textBody = shape.TextBody;

var textBodyListStyle = textBody.ListStyle;

Debug.Assert(textBodyListStyle.ChildElements.Count == 0);

而 TextStyle 其实准确说是一个列表，有从 Level1 到 Level9 的样式，那么如何知道使用哪一个

其实样式列表针对的是段级的，也就是一个文本里面的多个不同的段落可以使用不同的样式等级，可以使用如下代码

var paragraph = textBody.Descendants<Paragraph>().First();
var level = paragraph.ParagraphProperties?.Level?.Value ?? 1;
Debug.Assert(level == 1);
Debug.Assert(paragraph.ParagraphProperties == null);

var paragraphProperties = defaultTextStyle.Level1ParagraphProperties;

这是测试代码，因此仅获取第一段，而按照测试的文档，可以了解到此时的 level 就是 1 同时文本本身没有重写样式，因此使用的就是 defaultTextStyle.Level1ParagraphProperties 作为段落样式

文本的样式段落里面包含了段落的默认属性，也就是文本的 Run 如果没有定义如字体等这些属性，将会使用段落默认属性

可以使用下面代码获取段落的文本

foreach (var run in paragraph.Descendants<Run>())
{
    var runProperties = run.RunProperties;
    var eastAsianFont = runProperties.GetFirstChild<EastAsianFont>();
    Debug.Assert(eastAsianFont == null);
    // 忽略代码
}

从上面代码可以看到，测试文档是不存在 EastAsianFont 字体的，此时就需要用到 defaultTextStyle 定义的内容，在开始写代码之前，先看一下在文档里面是如何定义的

在测试文档里面的 Presentation.xml 是这样定义的，这份文档放在 github 欢迎小伙伴解压缩

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<p:presentation xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" saveSubsetFonts="1">
    <p:sldMasterIdLst>
        <p:sldMasterId id="2147483648" r:id="rId1"/>
    </p:sldMasterIdLst>
    <p:sldIdLst>
        <p:sldId id="256" r:id="rId2"/>
    </p:sldIdLst>
    <p:sldSz cx="12192000" cy="6858000"/>
    <p:notesSz cx="6858000" cy="9144000"/>
    <p:defaultTextStyle>
        <a:defPPr>
            <a:defRPr lang="en-US"/>
        </a:defPPr>
        <a:lvl1pPr marL="0" algn="l" defTabSz="914400" rtl="0" eaLnBrk="1" latinLnBrk="0" hangingPunct="1">
            <a:defRPr sz="1800" kern="1200">
                <a:solidFill>
                    <a:schemeClr val="tx1"/>
                </a:solidFill>
                <a:latin typeface="+mn-lt"/>
                <a:ea typeface="林德熙"/>
                <a:cs typeface="+mn-cs"/>
            </a:defRPr>
        </a:lvl1pPr>
    </p:defaultTextStyle>
    <p:extLst>
        <p:ext uri="{EFAFB233-063F-42B5-8137-9DF3F51BA10A}">
            <p15:sldGuideLst xmlns:p15="http://schemas.microsoft.com/office/powerpoint/2012/main"/>
        </p:ext>
    </p:extLst>
</p:presentation>

也许看起来的逻辑有点复杂，但是实际需要了解的逻辑如下

<a:lvl1pPr marL="0" algn="l" defTabSz="914400" rtl="0" eaLnBrk="1" latinLnBrk="0" hangingPunct="1">
    <a:defRPr sz="1800" kern="1200">
        <a:solidFill>
            <a:schemeClr val="tx1"/>
        </a:solidFill>
        <a:latin typeface="+mn-lt"/>
        <a:ea typeface="林德熙"/>
        <a:cs typeface="+mn-cs"/>
    </a:defRPr>
</a:lvl1pPr>

此时的 paragraphProperties 的数据，将是上面的内容，默认使用 Level1 的属性

var paragraphProperties = defaultTextStyle.Level1ParagraphProperties;

此时获取的方法如下面代码

eastAsianFont = paragraphProperties.GetFirstChild<DefaultRunProperties>()
    .GetFirstChild<EastAsianFont>();

var typeface = eastAsianFont.Typeface.Value;

Console.WriteLine($"字体是 {typeface}"); 

// typeface == "林德熙"

当然，小伙伴如果没有去阅读 dotnet OpenXML 文本字体的选择规则也许就会好奇为什么我这里的代码只读取 EastAsianFont 字体，而忽略其他的字体

从本文到当前只是在告诉大家如何拿到对的字体属性，字体属性是对于文本段 Run 来说的，而不是段落或文本的。但是如果文本段 Run 不存在字体的定义，那么此时需要尝试去获取段落的默认属性定义。但是如果段落没有任何默认属性定义，就需要获取文档的文本样式定义

这部分逻辑属于 PPT 的逻辑，我在 ECMA 376 没有找到相关的描述，也就是这部分逻辑是没有文档定义的。这也就是 OpenXML SDK 这个库没有提供获取文本最终属性的方法的原因

如果小伙伴认为这么简单就获取到字体了，那么坐等你使用了一个叫 +mn-ea 的字体。等等，这是一个什么字体？其实这是一个有趣的写法

在找到对应的字体属性的时候，不一定拿到最终使用的字体，如果判断是 +mn-ea 的格式，那么就需要再进一步的转换

首先判断的正则代码如下，如果这个代码写错了，还请小伙伴告诉我

private static readonly Regex ThemeFontTypePattern =
            new Regex(@"(^\+(mn|mj)\-(lt|cs|ea)$)", RegexOptions.Compiled);

这个定义的方式是 FontScheme 的定义，需要先解析这个字符串才能了解

按照定义，需要将这个字符串分为两个部分，一个就是 +mn 另一个就是 -ea 两个部分

前面部分表示如下

mn：MinorFont
mj：MajorFont

后面的枚举表示如下

    public enum FontLang
    {
        /// <summary>
        /// lt
        /// </summary>
        LatinFont,

        /// <summary>
        /// ea
        /// </summary>
        EastAsianFont,

        /// <summary>
        /// cs 
        /// </summary>
        ComplexScriptFont,

        /// <summary>
        /// sym
        /// </summary>
        SymbolFont,

        /// <summary>
        ///  不知道哪个语言
        /// </summary>
        Unknown,
    }

那么 MinorFont 和 MajorFont 是什么意思？其实就是正文和标题的提示，小伙伴可以在 PPT 的字体看到有括号写的标题和正文，就是对应的这两个属性的含义

这个主题可以如何获取？请看代码

 private static FontScheme GetFontScheme(SlidePart slidePart)
 {
    if (slidePart.ThemeOverridePart?.ThemeOverride?.FontScheme != null)
    {
        return slidePart.ThemeOverridePart.ThemeOverride.FontScheme;
    }

    var slideLayoutPart = slidePart.SlideLayoutPart;

    //从SlideLayout获取theme
    if (slideLayoutPart.ThemeOverridePart?.ThemeOverride?.FontScheme != null)
    {
        return slideLayoutPart.ThemeOverridePart.ThemeOverride.FontScheme;
    }

    var slideMasterPart = slideLayoutPart.SlideMasterPart;

    //从SlideMaster获取theme
    return slideMasterPart?.ThemePart?.Theme?.ThemeElements?.FontScheme;
 }

请小伙伴换一份测试课件用来测试逻辑，测试的课件放在 github 这份课件更改了 Presentation.xml 定义为下面代码

<a:lvl1pPr marL="0" algn="l" defTabSz="914400" rtl="0" eaLnBrk="1" latinLnBrk="0" hangingPunct="1">
    <a:defRPr sz="1800" kern="1200">
        <a:solidFill>
            <a:schemeClr val="tx1"/>
        </a:solidFill>
        <a:latin typeface="+mn-lt"/>
        <a:ea typeface="+mn-ea"/>
        <a:cs typeface="+mn-cs"/>
    </a:defRPr>
</a:lvl1pPr>

可以看到的是原本是有具体的字体的 a:ea 被更改为 a:ea typeface="+mn-ea" 需要使用 FontScheme 找到对应的逻辑

在这份测试课件里面，其实只有 Theme1.xml 文件才有实际的定义，也就是 slideMasterPart?.ThemePart?.Theme?.ThemeElements?.FontScheme 才有返回值

if (ThemeFontTypePattern.IsMatch(typeface))
{
    // 进入这个分支，字体是 +mn-ea 字体
    // 这个字体的意思里面 mn 表示 Body 字体
    // 而 mj 表示 Title 字体，也就是 Major 字体
    // 后续的 ea 和 lt 等表示采用东亚文字或拉丁文等
    // 此时需要获取字体主题
    var fontScheme = GetFontScheme(slidePart);
    FontCollectionType fontCollection;

    // mn 的 n 传入字符串是 +mn-ea 也就是第三个字符
    if (typeface[2] == 'n')
    {
        fontCollection = fontScheme.MinorFont;
    }
    else
    {
        fontCollection = fontScheme.MajorFont;
    }

    // 忽略代码
}

按照本文的逻辑，下一步需要解析是具体的语言

   FontLang fontLang = FontLang.Unknown;

    if (typeface.Contains("lt"))
    {
        fontLang = FontLang.LatinFont;
    }
    else if (typeface.Contains("cs"))
    {
        fontLang = FontLang.ComplexScriptFont;
    }
    else if (typeface.Contains("ea"))
    {
        fontLang = FontLang.EastAsianFont;
    }

在开始读取字体之前，先看一下 Theme1.xml 文件的定义

<a:fontScheme name="Office">
    <a:majorFont>
        <a:latin typeface="Calibri Light" panose="020F0302020204030204"/>
        <a:ea typeface=""/>
        <a:cs typeface=""/>
        <a:font script="Jpan" typeface="ＭＳ Ｐゴシック"/>
        <a:font script="Hang" typeface="맑은 고딕"/>
        <a:font script="Hans" typeface="宋体"/>
        <a:font script="Hant" typeface="新細明體"/>
    </a:majorFont>
    <a:minorFont>
        <a:latin typeface="Calibri" panose="020F0502020204030204"/>
        <a:ea typeface=""/>
        <a:cs typeface=""/>
        <a:font script="Jpan" typeface="ＭＳ Ｐゴシック"/>
        <a:font script="Hang" typeface="맑은 고딕"/>
        <a:font script="Hans" typeface="逗比"/>
        <a:font script="Hant" typeface="新細明體"/>
    </a:minorFont>
</a:fontScheme>

当然也许你会发现此时的 typeface 不是某个字体或 “mn-lt” 等，而是一个空字符串。此时就需要用到 Theme Font Languages（ThemeFontLang ECMA-376 17.15.1.88）的功能了

请问此时的字体是什么？

为什么是读取 <a:font script="Hans" typeface="逗比"/> 作为字体的？原因就是需要先判断语言

小伙伴是否还记得在 Run 的属性定义

<a:p>
    <a:r>
        <a:rPr lang="zh-CN" altLang="en-US" sz="2000" smtClean="0"/>
        <a:t>一行文本</a:t>
    </a:r>
    <a:endParaRPr lang="en-US" dirty="0"/>
</a:p>

这里有一个属性 lang 是什么作用？其实就是用来决定使用那个 Script 对应的字体的

而 zh-CN 和 Hans 有什么关系，这个是在 RFC 4646 标准定义的，可以根据语言拿到。关于 zh-CN 这个语言格式的标准，请看 BCP47 标准

        private static string GetScript(StringValue language)
        {
            if (language == "zh-CN")
            {
                return "Hans";
            }
            else if (language == "zh-Hant")
            {
                return "Hant";
            }

            // 默认值，当然，在 Office 里面的逻辑是十分多的，需要根据 [国家-地区字符串](https://docs.microsoft.com/zh-CN/cpp/c-runtime-library/country-region-strings?view=vs-2019 ) 文档写代码，只是这部分代码不是本文重点
            return "Hans";
        }

上面是简单的逻辑，更多代码就需要你去通过 RFC 4646 标准去写代码了

在使用 GetScript 返回了 scriptTag 字符串之后，就可以在 FontCollectionType 遍历获取字体

       private static string GetFontFromFontCollection(string scriptTag, FontLang themeTypefaceFontLang,
            FontCollectionType fontCollection)
        {
            if (fontCollection == null)
            {
                return string.Empty;
            }

            // 假定存在对应的语言的字体，那么获取对应的字体
            // 存放方式如
            /*
            <a:majorFont xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
                <a:latin typeface="Calibri Light" panose="020F0302020204030204" />
                <a:ea typeface="" />
                <a:cs typeface="" />
                <a:font script="Jpan" typeface="ＭＳ Ｐゴシック" />
                <a:font script="Hang" typeface="맑은 고딕" />
                <a:font script="Hans" typeface="宋体" />
            </a:majorFont>
            <a:minorFont xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
                <a:latin typeface="Calibri" panose="020F0502020204030204" />
                <a:ea typeface="" />
                <a:cs typeface="" />
                <a:font script="Jpan" typeface="ＭＳ Ｐゴシック" />
                <a:font script="Hang" typeface="맑은 고딕" />
                <a:font script="Hans" typeface="宋体" />
            </a:minorFont>
             */

            foreach (var font in fontCollection.Elements<SupplementalFont>())
            {
                // <a:font script="Hang" typeface="맑은 고딕" />
                if (string.Equals(font.Script, scriptTag, StringComparison.OrdinalIgnoreCase))
                {
                    return font.Typeface;
                }
            }

            // 忽略代码
        }

此时的代码放在 github 欢迎小伙伴访问，此时就能拿到字体

如果此时的 Theme1.xml 定义是如下呢

<a:minorFont>
    <a:latin typeface="Calibri" panose="020F0502020204030204"/>
    <a:ea typeface="林德熙"/>
    <a:cs typeface=""/>
    <a:font script="Jpan" typeface="ＭＳ Ｐゴシック"/>
    <a:font script="Hang" typeface="맑은 고딕"/>
    <!-- <a:font script="Hans" typeface="逗比"/>-->
</a:minorFont>

也就是 font 的 script 是 Hans 的定义是不存在的，那么此时的规则是什么？此时的规则就是 FontLang 对应的内容

            // 也就是先尝试获取语言文化的，如果获取不到，就采用对应语言的
            TextFontType textFont = null;
            switch (themeTypefaceFontLang)
            {
                case FontLang.LatinFont:
                    textFont = fontCollection.LatinFont;
                    break;
                case FontLang.EastAsianFont:
                    textFont = fontCollection.EastAsianFont;
                    break;
                case FontLang.ComplexScriptFont:
                    textFont = fontCollection.ComplexScriptFont;
                    break;
                case FontLang.SymbolFont:
                    // 特别不处理，为什么？
                    // 在 fontCollection 是不存在的 SymbolFont 的
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(themeTypefaceFontLang), themeTypefaceFontLang, null);
            }

            var typeface = textFont?.Typeface?.Value;

            if (!string.IsNullOrEmpty(typeface))
            {
                return typeface;
            }

            Debug.Assert(false, "找不到字体");

            return null;

其实这个找不到字体 Debug.Assert(false, "找不到字体") 的输出也不全对，如果 Theme1.xml 定义是如下

<a:minorFont>
    <a:latin typeface="csdn" panose="020F0502020204030204"/>
    <a:ea typeface=""/>
    <a:cs typeface=""/>
    <a:font script="Jpan" typeface="ＭＳ Ｐゴシック"/>
    <a:font script="Hang" typeface="맑은 고딕"/>
    <!-- <a:font script="Hans" typeface="逗比"/>-->
</a:minorFont>

也就是 Hans 没有这个定义，而 ea 也没有值，此时将会降级使用 latin 的字体

如果 latin 也没有内容呢？将使用本机的默认语言字体

但小伙伴是否觉得上面还有一个没有用到的属性，没错就是 altLang 这个属性

<a:p>
    <a:r>
        <a:rPr lang="zh-CN" altLang="en-US" sz="2000" smtClean="0"/>
        <a:t>一行文本</a:t>
    </a:r>
    <a:endParaRPr lang="en-US" dirty="0"/>
</a:p>

这个属性是做什么用的？这是一个备用的属性，按照 ECMA-376 的 21.1.2.3.2 defRPr (Default Text Run Properties) 这一章的描述，这是一个备用的属性，默认是不写的，不写的时候将会使用 lang 属性。这个属性可以用来显示界面控件时使用的备用语言，也就是在 lang 找不到语言的时候，需要启用 altLang 属性去获取

而实际上本文的规则主要针对 PPT 而不是 OpenXML 的 ECMA-376 的标准，因为实际上 PPT 有些行为和 ECMA-376 不相同，或者说我没有理解对 ECMA-376 的意思。而这部分也是 OpenXML SDK 没有提供接口方法的

以下是 ECMA-376 的原文

17.15.1.88 ThemeFontLang (Theme Font Languages)

These mappings are performed as follows:

For majorAscii/majorHAnsi, locate the font element (§20.1.4.1.16) in the majorFont element (§20.1.4.1.24) in the theme part for the language specified by the val attribute
For majorBidi, locate the font element in the majorFont element in the theme part for the language specified by the bidi attribute
For majorEastAsia, locate the font element in the majorFont element in the theme part for the language specified by the eastAsia attribute
For minorAscii/minorHAnsi, locate the font element in the minorFont element (§20.1.4.1.25) in the theme part for the language specified by the val attribute
For minorBidi, locate the font element in the minorFont element in the theme part for the language specified by the bidi attribute
For minorEastAsia, locate the font element in the minorFont element in the theme part for the language specified by the eastAsia attribute

If this element is omitted, then the default fonts for each region as specified by the latin, ea, and cs elements (§21.1.2.3.7; §21.1.2.3.3; §21.1.2.3.1) should be used

不过 PPT 没有按照文档做

不信你试试 MinorAscii 的字符，也就是 Latin 字符实际上是不遵守上面的规定的。返回的是 Theme 的 latin 字体

<a:p>
    <a:r>
        <a:rPr lang="ja-JP" altLang="en-US" sz="2000" smtClean="0"/>
        <a:t>lindexi</a:t>
    </a:r>
    <a:endParaRPr lang="en-US" dirty="0"/>
</a:p>

<a:minorFont>
    <a:latin typeface="Wingdings" panose="020F0502020204030204"/>
    <a:ea typeface=""/>
    <a:cs typeface=""/>
    <a:font script="Jpan" typeface="微软雅黑"/>
    <a:font script="Hang" typeface="맑은 고딕"/>
    <a:font script="Hans" typeface="逗比"/>
</a:minorFont>

可以看到英文字符用的是 a:latin 的，而不是使用语言的

更多请看 Office 使用 OpenXML SDK 解析文档博客目录

OOXML Hacking: Font Themes Complete - Brandwares

asp dotnet core 提供大文件下载的测试

Thu, 03 Dec 2020 12:27:50 +0000

本文仅仅是提供测试使用的代码

提供文件下载只需要返回 PhysicalFile 方法，如下面代码

        [HttpGet]
        public IActionResult Get()
        {
            var folder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            var file = Path.Combine(folder, "big file");
            const string mime = "application/octet-stream";

            return PhysicalFile(file, mime);
        }

本文的 big file 是程序运行创建的垃圾文件

        private void WriteBigFile()
        {
            var folder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            var file = Path.Combine(folder, "big file");

            if (!File.Exists(file))
            {
                using (var stream = new FileStream(file, FileMode.Create))
                {
                    for (int i = 0; i < 100000000; i++)
                    {
                        stream.WriteByte(0);
                    }
                }
            }
        }

测试代码放在 github 欢迎小伙伴访问

dotnet OpenXML 简单聊聊 PPT 文本解析

Thu, 03 Dec 2020 12:27:50 +0000

在 Office 里面的文本解析最全的范围是 Word 文本，就是属性数量本身就特别多。本文只是简单和大家聊聊 Office 里面的 PPT 的文本的解析入门。尽管 PPT 的文本也是采用 DrawingDL 的文本属性为主，不过会用到的属性将比 Word 少很多。本文将和小伙伴介绍 PPT 的文本存放的方式

在 PPT 中的文本框也是形状，只是形状里面添加了特殊的设置。而没有添加特殊设置的形状也可以添加文本，在 PPT 的文本使用 <p:txBody> 包含，这就是本文主要和大家介绍的内容

阅读本文，你将能大概了解如何开始入手 PPT 的文本解析，以及了解相应的工作量

在开始之前，我期望你是了解 PPT 的整个元素的存放格式的，请看 dotnet OpenXML 解析 PPT 页面元素文档格式

最简单的文本元素，当然，我这里的简单说的是文本解析层的。此时的文本将不引用全局的和占位符等的样式信息，此时的文本将包含自己的所有信息，此时的文本解析是最简单的

简单的文本在 <p:txBody> 里面将会包含一个 <a:bodyPr> 的值，这个值对应在 OpenXML SDK 的 DocumentFormat.OpenXml.Drawing.BodyProperties 类。也就是在 <a:bodyPr> 有啥属性和值都可以在 BodyProperties 这个类里面找到，当然有些可选的值只能通过 GetFirstChild 方法获取了，这部分就不细说了

需要科普的，放在 DocumentFormat.OpenXml.Drawing 的内容意味着是 DrawingDL 的定义，也就是将是 Office 多个格式如 PPT 和 Word 等共同使用的定义，因此对 DrawingDL 的解析完成基本上对 Office 的多个格式的这部分解析也是算完成。关于 DrawingDL 等 Office 多个格式的关系，请小伙伴看 Office 文档解析文档格式和协议

在 PPT 的 <p:txBody> 的 <a:bodyPr> 表示整个文本本身的属性，包括文本是横排还是竖排，文本是否自适宽度高度等信息

在 PPT 的文本是富文本，可以对文本的文本段落进行设置，同时可以对文本的每个字符进行设置样式。因此在 PPT 的文档会给每一段添加段落属性。给每一段里面的某些样式相同的字符添加文本属性，为什么不是给每个字符单独一个属性？原因是这样做会让文本属性太多了。因此连续的文本如果有相同的样式，那么就可以使用相同的一个文本属性

在 <p:txBody> 标准的文档将会在 <a:bodyPr> 的下方添加 <a:p> 段落信息，一个文本框会包含多个段落信息，大概的格式如下

<p:txBody>
  <a:bodyPr>
  </a:bodyPr>

  <a:p></a:p>
  <a:p></a:p>
</p:txBody>

在 <a:p> 包含一个段落信息，在 OpenXML SDK 里面使用 DocumentFormat.OpenXml.Drawing.Paragraph 类。在段落里面，会包含很多 <a:r> 文本，以及段落属性

段落属性使用 <a:pPr> 表示，包含段落的行距等段落信息，具体是哪些属于段落信息？打开 PPT 软件，选择一个文本，可以看到段落的设置，这些就是段落信息。在 OpenXML SDK 里面使用 DocumentFormat.OpenXml.Drawing.ParagraphProperties 类

小伙伴可以看到在 PPT 软件的段落设置旁边有字体设置，这是对应放在 <a:r> 文本的内容，格式如下

<p:txBody>
  <a:bodyPr></a:bodyPr>
  <a:p>
    <a:pPr fontAlgn="auto">
    </a:pPr>
    <a:r>
      <a:rPr b="1" dirty="0" lang="en-US" sz="2400">
        <a:latin typeface="+mn-ea"/>
      </a:rPr>
      <a:t>欢迎</a:t>
    </a:r>
    <a:r>
      <a:rPr altLang="en-US" b="1" dirty="0" lang="zh-CN" sz="2400">
        <a:latin typeface="+mn-ea"/>
      </a:rPr>
      <a:t>访问我博客 https://blog.lindexi.com 里面有大量 UWP WPF 博客</a:t>
    </a:r>
  </a:p>
</p:txBody>

在 <a:r> 里面包含 <a:rPr> 文本属性，也就是上面图片 PPT 软件的字体的设置的内容，包含具体的字体字号等属性。这里的 <a:rPr> 在 OpenXML SDK 里面使用 DocumentFormat.OpenXml.Drawing.RunProperties 类。上面仅是例子，关于属性的作用和含义请忽略

同时在 <a:r> 里面将包含 <a:t> 也就是 DocumentFormat.OpenXml.Drawing.Text 的值，从上面的格式可以看到，这就是纯文本的字符串

因此最简单的解析 PPT 的文本，其实就是需要先拿到整个本文的属性，也就是 <a:bodyPr> 的值，然后分段解析每个 <a:p> 的值。在解析 <a:p> 的值包括解析段落的属性 <a:rPr> 的值和段落里面包含的文本 <a:r> 的值，而文本本身包含纯文本 <a:t> 和文本属性 <a:rPr> 的值

也就是 PPT 的文本排版其实就是拿出纯文本，然后将纯文本先按照文本的富文本属性的不同分组，如不同的文本有不同的字号和颜色等。接着按照文本的段落，也就是换行符将文本分为多个段落，再添加每个段落的段落属性，如行距等

最后的文本需要包含这些段落和文本框的属性，如横排竖排显示等

从本文上面的描述，其实 PPT 用到的文本格式大部分都是 DrawingDL 的定义，也就是其实上面的规则不只是适用于 PPT 一个格式，对 Excel 等也适合

那么解析的工作量大的在哪里？第一点是在收集这些属性上面，在 PPT 里面最简单的文本才会将所有的属性都添加上，而基本上的 PPT 文档里面是不会将所有的属性添加的，那么这些没有添加的属性使用的是默认属性？其实不一定，因为在 PPT 中的属性是有继承的，从页面继承 SlideLayout 属性，从 SlideLayout 继承 SlideMaster 属性。又有文本的样式等级，如 Level1ParagraphProperties 和 Level2ParagraphProperties 等，收集对的属性的工作量很大

等等，什么是 SlideLayout 和 SlideMaster 呀，请看 dotnet OpenXML 的 Slide Master 和 Slide Layout 是什么

第二点就是属性的数量本身，在 OpenXML 里面定义了大量的文本可以被设置的属性，光是定义这些属性就需要大量的代码。而在定义之后还需要了解属性的含义和作用，有些属性本身会相互影响的，就更坑了。好在几乎所有的属性能做出来的效果，都能在 WPF 里面实现，我还没有遇到只有 PPT 能实现的渲染效果而在 WPF 不能实现的。当然使用 WPF 的富本文控件是做不出效果的，需要自己写一个文本库

因此整个 PPT 的文本解析里面的工作量都在属性上面，也就是了解 PPT 的纯文本在加上这些属性之后会有啥的呈现就是解析文本的主要工作

我写了很多 Office 解析相关的博客，请看 Office 使用 OpenXML SDK 解析文档博客目录

Office 文档文本排版布局中华人民共和国国家标准标点符号用法

Thu, 03 Dec 2020 12:27:50 +0000

我在做一个和 Office 差很多的文本排版软件，而文本排版软件里面的是有国家标准的，如果不符合标准那么这个排版软件是不专业的，或者说这个软件只是一个纯文本软件，而不是一个能做文档的软件

核心规则如下

其中标点符号规则相对复杂，规范如下

详细请看 GB/T 15834 标点符号用法

请自行百度 GB/T 15834 就可以找到标准文档

当前支持最好的是 WPS 的文本排版，支持较弱的是 MS Office 的 Word 软件，而我的软件支持更差

C# 8.0 文件长度 Bytes 字节转 KB 等单位字符串

Thu, 03 Dec 2020 12:27:50 +0000

本文将使用 C# 8.0 写一个相对比较省内存和性能不差的将文件长度从 Bytes 转换为单位使用 KB 或 MB 或 GB 等单位的字符串的方法

代码可以复制在你的实际软件中使用

    static class FileSizeFormatter
    {
        public static string FormatSize(long bytes, string formatString = "{0:0.00}")
        {
            int counter = 0;
            double number = bytes;

            // 最大单位就是 PB 了，而 PB 是第 5 级，从 0 开始数
            // "Bytes", "KB", "MB", "GB", "TB", "PB"
            const int maxCount = 5;

            while (Math.Round(number / 1024) >= 1)
            {
                number = number / 1024;
                counter++;

                if (counter >= maxCount)
                {
                    break;
                }
            }

            var suffix = counter switch
            {
                0 => "B",
                1 => "KB",
                2 => "MB",
                3 => "GB",
                4 => "TB",
                5 => "PB",
                // 通过 maxCount 限制了最大的值就是 5 了
                _ => throw new ArgumentException("骚年，你是不是忘了更新 maxCount 等级了")
            };

            return $"{string.Format(formatString, number)}{suffix}";
        }
    }

上面代码使用的 switch 根据 counter 返回对应的单位，对比使用数组的优势在于不需要创建数组对象，能省一点内存。同时进行的计算也比较少，相对性能也不差

上面代码的 ArgumentException 在没有更改代码逻辑是不会进入的，因为通过 maxCount 限制了单位最大就是 PB 了

试试以下测试代码

            for (int i = 0; i < 10; i++)
            {
                Debug.WriteLine(FileSizeFormatter.FormatSize((long)Math.Pow(10, i)));
            }

可以看到控制台的输出如下

00B
00Bytes
00Bytes
98KB
77KB
66KB
95MB
54MB
37MB
93GB

其他小伙伴的实现如下

c# 字节单位转换_weixin_34405925的博客-CSDN博客_c# 单位转换

C#实现获取文件大小进行单位转换与文件大小比较_xiaochenXIHUA的博客-CSDN博客_c# 文件大小单位

也有更快计算当前的数值对应的单位的等级的方法，就是通过 Math.Log 的方法，我没有测试性能对比，但是看起来相差很小，因为循环也就是最多 5 次

    var mag = (int)Math.Max(0, Math.Log(value, 1024));
    var adjustedSize = Math.Round(value / Math.Pow(1024, mag), decimalPlaces);

当然，也有更快的方法，就是通过判断大小

    private string GetFileSize(double byteCount)
    {
        string size = "0 B";
        if (byteCount >= 1073741824.0)
            size = string.Format("{0:##.##}", byteCount / 1073741824.0) + " GB";
        else if (byteCount >= 1048576.0)
            size = string.Format("{0:##.##}", byteCount / 1048576.0) + " MB";
        else if (byteCount >= 1024.0)
            size = string.Format("{0:##.##}", byteCount / 1024.0) + " KB";
        else if (byteCount > 0 && byteCount < 1024.0)
            size = byteCount.ToString() + " B";

        return size;
    }

只是判断大小的代码没有用到 C# 8.0 因此依然推荐小伙伴使用本文开始的代码

Library	Package name	Description
advapi32.dll	`PInvoke.AdvApi32`	Windows Advanced Services
bcrypt.dll	`PInvoke.BCrypt`	Windows Cryptography API: Next Generation
cabinet.dll	`PInvoke.Cabinet`	Cabinet API Functions
cfgmgr32.dll	`PInvoke.CfgMgr32`	Device and Driver Installation
crypt32.dll	`PInvoke.Crypt32`	Windows Cryptography API
DwmApi.dll	`PInvoke.DwmApi`	Desktop Window Manager
fusion.dll	`PInvoke.Fusion`	.NET Framework Fusion
gdi32.dll	`PInvoke.Gdi32`	Windows Graphics Device Interface
hid.dll	`PInvoke.Hid`	Windows Human Interface Devices
iphlpapi.dll	`PInvoke.IPHlpApi`	IP Helper
kernel32.dll	`PInvoke.Kernel32`	Windows Kernel API
magnification.dll	`PInvoke.Magnification`	Windows Magnification API
mscoree.dll	`PInvoke.MSCorEE`	.NET Framework CLR host
msi.dll	`PInvoke.Msi`	Microsoft Installer
ncrypt.dll	`PInvoke.NCrypt`	Windows Cryptography API: Next Generation
netapi32.dll	`PInvoke.NetApi32`	Network Management
newdev.dll	`PInvoke.NewDev`	Device and Driver Installation
ntdll.dll	`PInvoke.NTDll`	Windows NTDll
psapi.dll	`PInvoke.Psapi`	Windows Process Status API
setupapi.dll	`PInvoke.SetupApi`	Windows setup API
SHCore.dll	`PInvoke.SHCore`	Windows Shell
shell32.dll	`PInvoke.Shell32`	Windows Shell
user32.dll	`PInvoke.User32`	Windows User Interface
userenv.dll	`PInvoke.Userenv`	Windows User Environment
uxtheme.dll	`PInvoke.UxTheme`	Windows Visual Styles
winusb.dll	`PInvoke.WinUsb`	USB Driver
WtsApi32.dll	`PInvoke.WtsApi32`	Windows Remote Desktop Services

dotnet OpenXML 的 spcPct 和 spcPts 表示距离的不同

Thu, 03 Dec 2020 12:27:50 +0000

在 OpenXML 里面的文本排版里面使用到 spcPct （Spacing Percent）和 spcPts（Spacing Points）两个不同的单位用来表示段前空白和段后空白以及行间距

在 Office 的文本排版里面，会在 spcAft (Space After) 段后空白空间以及 spcBef (Space Before) 段前空白空间等使用 spcPct （Spacing Percent）百分比空间和 spcPts（Spacing Points）固定点数空间表示空白空间

从命名上可以看出 spcPct （Spacing Percent）百分比空间和 spcPts（Spacing Points）固定点数空间的不同

Spacing Percent

百分比空间相对复杂，这个单位会根据不同的业务采用不同的值，这个值本身只代表百分比，值的本身的数据可以加上百分比单位，如果加上单位了，那么则表示多少百分比。如果不加上单位，那么默认数据单位是千百分比，意思是用一千表示一个百分比

如下面代码，添加了具体百分号单位，此时表示的就是百分比

    <a:pPr …>
      <a:spcBef>
        <a:spcPct val="200%"/> 
      </a:spcBef> 
    </a:pPr>  

如下面代码，没有添加任何单位，此时表示的就是千倍的百分比

    <a:pPr …>
      <a:spcBef>
        <a:spcPct val="200000"/> 
      </a:spcBef> 
    </a:pPr>  

上面两段代码的数值是等价的

在拿到百分比的值还需要知道这是相对于谁的大小才能计算出来

默认这个是相对于当前应用这个 a:rPr (RunProperties) 的 a:t (TextRun) 里面的字号最大的字号的值作为相对的百分比。也就是说在同一行的段落里面有不同的大小的字号，如有 10 号的和 20 号的，那么将使用最大的字号 20 号作为相对的值计算

关于百分比单位等请看 Office Open XML 的测量单位

Spacing Points

固定点数空间的数值单位是百点也就是数值 100 表示 1 point 大小

这里的 point 和文本的字号的 point 是相等的含义

如下代码，由 val="1500" 表示段前空白长度是 15 point 大小

    <a:pPr …>
        <a:spcBef>
                <a:spcPts val="1500"/>
        </a:spcBef>
    </a:pPr>

dotnet 通过依赖注入的 Scoped 给工作流注入相同的上下文信息

Thu, 03 Dec 2020 12:27:50 +0000

本文将来聊聊 Microsoft.Extensions.DependencyInjection 这个依赖注入框架的 Scoped 功能的一个应用，这个框架是默认 ASP.NET Core 的核心库将会默认被引用。而其他 .NET 的应用如 WPF 或 Xamarin 等也可以使用这个库。因此本文标题就是 dotnet 而不是具体哪个框架在开发的时候，咱会有一些复杂的逻辑需要多个类合作进行执行，而在使用多个类进行执行的时候，就涉及到上下文信息的传递。例如最简单的追踪 Id 的值，假定在多个类组成的多个步骤里面，因为存在多线程调用的问题，咱在定位问题的时候需要在日志里面输出当前步骤所使用的追踪 Id 是哪个，这样就运行进行并行多次任务同时执行，同时日志不会乱

尽管本文使用 Scoped 仅作为日志记录的功能没能发挥强大的日志库的作为，但是减弱日志库是为了提升 DependencyInjection 的强大，因此请小伙伴仅认为日志库和输出文本到控制台之间没有任何差别

如上图，假定有三个步骤，分别是 F1 和 F2 和 F3 三个步骤，此时有3个任务同时进来。而我期望能够在日志里面的相关输出能包含当前的步骤在执行的任务是哪一个

最简单的方法是在每个步骤的参数里面传递上任务的追踪 Id 值，此时就可以在每个步骤里面的输出添加追踪信息

这个方法存在什么问题？如果我想要多添加额外的参数，此时我需要改一条链。另外也没有发挥 Scoped 的功能

那么什么是 Scoped 的功能？在 Microsoft.Extensions.DependencyInjection 提供的对象注入里面提供了三个不同的方式，第一个是瞬时 Transient 模式，这个模式可以让每次获取实例的时候，拿到的都是全新的实例。第二个是 Singleton 单例，无论在哪里从这个容器获取到的都是相同的对象。而最后一个也是最复杂的就是 Scoped 范围模式，也是本文要来安利大家的功能

先不说 Scoped 的定义，先来聊聊他的作用。在相同的 using 范围内，嗯，这个 Scoped 是容器的状态，容器可以通过 CreateScope 方法进入 Scoped 范围，如下面代码

// IServiceProvider serviceProvider
using (var serviceScope = serviceProvider.CreateScope())
{
    
}

此时在一个相同的 serviceScope 实例创建的对象，如果这个对象在注入的时候标记了自己是 Scoped 范围，那么将会拿到相同的实例。而在标记了 Scoped 范围的对象在不同的 ServiceScope 实例创建的是不同的对象，如下面代码

// IServiceProvider serviceProvider

// Foo 是注册为 Scoped 的对象
// services.AddScoped<Foo>();

using (var serviceScope1 = serviceProvider.CreateScope())
{
	// 下面代码的 foo 和 foo1 是相同的对象
    var foo = serviceScope.ServiceProvider.GetService<Foo>();
    var foo1 = serviceScope.ServiceProvider.GetService<Foo>();
}

using (var serviceScope2 = serviceProvider.CreateScope())
{
	// 下面的 foo2 和 foo 不是相同的对象
    var foo2 = serviceScope.ServiceProvider.GetService<Foo>();
}

因此假设将各个步骤加上步骤需要的上下文信息类都作为 Scoped 范围注入，那么此时在一次任务过程中，任务使用的步骤都在一个 Scoped 里面，如果此时的任务使用相同的类型的上下文信息类，那么此上下文信息将会是相同的对象。因此各个任务可以使用上下文信息共享信息

假设上下文信息类是 Info 类，里面只有使用一个信息就是 Id 这个信息

    public class Info
    {
        public string Id { set; get; }
    }

为了方便起见，我还是创建一个 ASP.NET Core 应用，因为这个应用框架默认部署好了依赖注入

在 Startup.cs 里面进行注册

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddScoped<Info>();
        }

然后定义三个步骤的类

    public class F1
    {
        public F1(ILogger<F1> logger, Info info, F2 f2)
        {
            _logger = logger;
            Info = info;
            F2 = f2;
        }

        public Info Info { get; }

        public void Do()
        {
            _logger.LogInformation(Info.Id);
            F2.Do();
        }

        private readonly ILogger<F1> _logger;

        private F2 F2 { get; }
    }

    public class F2
    {
        public F2(ILogger<F2> logger, Info info)
        {
            _logger = logger;
            Info = info;
        }

        public Info Info { get; }

        public void Do()
        {
            _logger.LogInformation(Info.Id);
        }

        private readonly ILogger<F2> _logger;
    }

    public class F3
    {
        public F3(ILogger<F3> logger, Info info)
        {
            _logger = logger;
            Info = info;
        }

        public Info Info { get; }

        public void Do()
        {
            _logger.LogInformation(Info.Id);
        }

        private readonly ILogger<F3> _logger;
    }

可以看到上面三个类都是只有一个 Do 方法，在 Do 方法里面调用日志记录上下文信息

在 Startup.cs 里面进行注册这三个步骤

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            services.AddScoped<Info>();

            services.AddScoped<F1>();
            services.AddScoped<F2>();
            services.AddScoped<F3>();
        }

在使用的时候，默认控制器就是注册为 Scoped 的，因此在控制器里面无论是构造注入或者是使用容器获取都是在相同的 Scoped 里面

上面代码是 F1 步骤引用 F2 步骤，咱在构造将 F1 注入。而 F3 是独立步骤，咱通过容器获取

    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        public WeatherForecastController(ILogger<WeatherForecastController> logger, F1 f1, Info info,
            IServiceProvider serviceProvider)
        {
            Info = info;
            _logger = logger;
            _f1 = f1;
            _serviceProvider = serviceProvider;

            using (var serviceScope = serviceProvider.CreateScope())
            {
                var foo = serviceScope.ServiceProvider.GetService<Info>();
                var foo1 = serviceScope.ServiceProvider.GetService<Info>();
                if (ReferenceEquals(foo, foo1))
                {

                }
            }
        }

        public Info Info { get; }

        [HttpGet]
        public IActionResult Get()
        {
            Info.Id = DateTime.Now.ToString();
            _logger.LogInformation(Info.Id);
            _f1.Do();

            var f3 = _serviceProvider.GetService<F3>();
            f3.Do();

            return Ok();
        }

        private readonly F1 _f1;

        private readonly ILogger<WeatherForecastController> _logger;
        private readonly IServiceProvider _serviceProvider;
    }

执行代码可以看到 F1 和 F2 和 F3 的 Info 对象都是相同的对象，于是在 Info 对象设置的值可以在三个步骤使用

通过这个方法，在后续修改的时候，假如有一个信息是 F1 和 F3 都需要的，但是 F1 和 F3 是独立的，此时就可以再新建一个类用于存放此参数，然后将这个类注册为 Scoped 的。接着在 F1 和 F3 注入这个类，此时使用的对象就是相同的对象，因此参数也就能传递

有趣的是这个方法改动仅仅只是 F1 和 F3 两个类加上依赖注入构造，其他模块可以不动

本文代码放在 github 欢迎小伙伴访问

C# dotnet 使用 FileStream 随机文件读写

Thu, 03 Dec 2020 12:27:50 +0000

本文说的随机文件读写的随机的反义词是顺序，这里的随机文件读写对应顺序文件读写。表示文件可以不按照顺序进行读写

进行文件读写的时候，基本上读是几乎不存在问题的，而写的话就稍微坑了一点，在 dotnet 里面默认没有提供 RandomAccessStream 类，这个 RandomAccessStream 类仅在 UWP 中可以使用

如果在不引用 UWP 的 WPF 里面，或者在 ASP.NET Core 以及 Xamarin 里面，也可以通过 FileStream 的 Seek 方法做到进行随机的读写

在随机读写文件的时候使用 FileStream 的 Seek 方法设置当前的文件 Stream 所在的点，此时就可以从 Stream 的这个点开始进行读写。在 Stream 的 Seek 方法会在 FileStream.Windows.cs 调用 SeekCore 方法，在 SeekCore 会调用 Kernel32.SetFilePointerEx 的方法设置到文件的读写

此时使用 Position 属性也能完成，在 FileStream.cs 里面可以看到 Position 的 Set 方法本质也是调用 Seek 方法

        public override long Position
        {
            get {/*忽略代码*/}
        
            set
            {
            	// 忽略代码
                Seek(value, SeekOrigin.Begin);
            }
        }

比较推荐使用 Seek 的方法，因此这个方法功能比较强大，可以设置相对或者从前开始等

大概的做法是如移动到某个字节处开始读写，可以使用如下代码

        private async Task WriteFile(long fileStartPoint, byte[] data, int dataLength)
        {
            Stream.Seek(fileStartPoint, SeekOrigin.Begin);

            await Stream.WriteAsync(data, offset: 0, dataLength);
        }

注意这里的 WriteAsync 使用的第二个参数 offset 指的是第一个参数 byte[] 的偏移而不是写入到 Stream 的偏移。通过 Seek 的方法就能做到让文件支持进行随机读写

另外，如果想要比较大的提升随机文件读写性能，我推荐在知道文件长度的时候通过 SetLength 方法设置文件长度，这样能减少文件碎片分配

如果需要进行多线程读写，此时读可以采用创建多个 FileStream 的方法，注意设置读共享。但如果存在多线程写入，我推荐是使用一个 FileStream 然后其他多个线程委托到一个线程里面进行写入，而不是多个线程同时写入。原因是多个线程同时写入的时候冲突不好处理，加上文件写入有磁盘延迟，此时的写入特别是有长度变化的时候会写出空值

我通过 AsyncQueue 做到多个线程不断写入队列，而一个线程不断从队列取出待写入的数据，写入到文件。这样做的优势在于能做到在一个线程里面写入文件，而其他线程只是委托这个写入文件线程写入，其他线程不访问文件

这部分多线程进行文件随机写入代码放在 github 欢迎小伙伴访问，代码放在 RandomFileWriter.cs 文件

更多 dotnet 底层源代码请看官方开源代码本文用到的代码放在 \src\libraries\System.Private.CoreLib\src\System\IO\FileStream.cs 和 \src\libraries\System.Private.CoreLib\src\System\IO\FileStream.Windows.cs 文件

那么文件随机读写的应用是什么？

可以用在一些业务上，这些业务不需要按照顺序读写文件。例如文件的配置的读写等

文件随机读写可以用在文件配置读写上面，例如我知道文件的数据结构，我的某个数据放在第100个字节到第200个字节间，此时我需要读取修改这个数据的内容，我不需要完全去读取前100个字节的内容，我可以直接使用随机读写的方法读取第100个字节到第200个字节的内容。而写入也同理，我不需要从第0个字节开始写入，我可以从第100个字节开始写入。这样能提升一些读写性能

dotnet OpenXML 解析 PPT 页面元素文档格式

Thu, 03 Dec 2020 12:27:50 +0000

本文告诉大家在 OpenXML 里面的 PPT 页面 Slide 的元素文档格式

是否小伙伴还记得如何使用 OpenXML SDK 获取一份 PPTX 文件的某一个页面？如果不记得，请看 C# dotnet 使用 OpenXml 解析 PPT 文件

如下是一个简单的 PPTX 的 Slide 页面

大概的主结构如下

对应缩写如下

p - Presentation
p:sld - Slide
p:cSld - CommonSlideData
p:spTree - ShapeTree

对应获取代码如下

            using (var presentationDocument =
                PresentationDocument.Open("test.pptx", false))
            {
                var presentationPart = presentationDocument.PresentationPart;
                foreach (var slidePart in presentationPart.SlideParts)
                {
                    var slide = slidePart.Slide;

                    var slideData = slide.CommonSlideData;
                    var shapeTree = slideData.ShapeTree;
                }
            }

元素放在 ShapeTree 里面，文档格式如下

尽管有多媒体元素等不属于 Shape 形状，但是在 PPT 里面形状属于最基础的元素，在 PPT 里面的所有的元素都放在 ShapeTree 里面。虽然 ShapeTree 命名是形状，但实际上所有元素都可以当成形状使用

例如在 ShapeTree 里面放一个文本，文本本身就是 DocumentFormat.OpenXml.Presentation.Shape 也就是形状。形状是形状，而文本框也是形状

获取页面里面的形状的方法如下

foreach (var openXmlElement in shapeTree)
{
    if (openXmlElement is DocumentFormat.OpenXml.Presentation.Shape shape)
    {

    }
}

这里的代码放在 github 欢迎小伙伴访问，运行代码在 openXmlElement is DocumentFormat.OpenXml.Presentation.Shape shape 添加断点就可以看到断点进入

在 VS 的帮助下，其实咱可以不理会PPT文档本身，直接使用 OpenXML 解析完成的值，这样做的优势在于不需要频繁去找文档。除非真的在看了注释之后依然不理解属性的含义和作用，不过一般此时看文档作用也不大

例如想要看某个页面包含的元素，可以点开 shapeTree 的 ChildElements 属性

此时对应的 XML 的缩写的含义以及对应的属性将可以在 VS 调试的时候看到，看到具体的属性含义以及值，相对来说开发效率会提升很多。当然这需要你学会 VS 的调试方法哈

每个元素都有一些通用的属性，例如元素的变换，也就是表示元素的坐标和大小等的属性，元素翻转旋转等

此外对于特定的元素，例如形状元素有形状元素自己的属性，例如线条填充等，这部分就需要每个元素自己去解析了

在 PPT 里面所有文本都是形状，只是文本框是有趣的形状，而其他的形状大部分都是可以添加文本的。但 PPT 使用的文本和 Word 的文本是等价的，而 Word 的文本小伙伴都知道有多复杂了…… 因此在 PPT 解析里面的神坑其实就是文本的解析部分，关于文本解析我写了一些博客

换句话说如果完成了 PPT 的文本的解析和渲染，那么基本上 Word 的文本解析就完成了大半了。当然强大的 Word 可不止文本这一项

现在市面大部分的 PPT 解析工具和软件都只是实现了基础元素的基础属性，例如

通用颜色
通用动画的基础动画
占位符
形状
- 形状线条
- 形状样式
文本
- 纯文本
- 文本多行多段
- 文本装饰下划线等
- 文本字体字号
- 文本上下标
图片
- 图片文件
- 图片裁剪
- 基础图片特效
音视频
- 音视频图片
- 音视频文件
表格
- 基础表格
- 表格线条
- 表格颜色

其中公式以及 Ole 元素等都可以作为图片显示，因此大部分包括 WPS 在内基本上对于公式和 Ole 元素都是当成图片，当然 WPS 很强，能解析一些公式和 Ole 元素

其实PPT解析里面的元素部分大部分都是 Office 通用的，例如文本是 PPT 和 Word 和 Excel 通用的。而表格是 Excel 的简化版

基本上完成一个元素的完全解析，基本上也就完成 Office 系列软件某个元素的解析

本文说的解析其实是不对的，因为使用 OpenXML SDK 库就是瞬间完成了内存模型解析。其他的业务都是根据业务本身从数据拿出来进行处理，例如进行渲染或者修改等

dotnet 找到博客中引用已失败的链接地址

Thu, 03 Dec 2020 12:27:50 +0000

在我的博客里面会添加很多引用，但是有一大部分的链接失修，访问的时候访问不到了，或者需要更新。于是我写了一个工具，可以协助找到所有的已失败的链接

本文用到工具所有代码放在 github 欢迎小伙伴访问

使用方法是在参数传入博客所在的文件夹，此时将会找到所有最顶层的博客文件，接着工具将会使用正则 @"([a-zA-z]+://[^\s^:^)^""]*)" 找到所有的链接，然后尝试访问一下

如果链接不能返回 200 那么输出这个博客文件名和链接

ReanuyawnicayhiFawcerecheca C:\博客

可以在 ReanuyawnicayhiFawcerecheca.exe 所在文件夹找到 Log.txt 文件，里面将会是控制台输出的内容，内容如下

2020-07-02 09:15:09.850 [start] C:\博客\C# 反射调用私有事件.md
2020-07-02 09:15:12.053 C# 反射调用私有事件.md https://walterlv.com/post/add-event-handler-using-reflection.html 404
2020-07-02 09:15:12.311 C# 反射调用私有事件.md https://walterlv.com/post/create-delegate-to-improve-reflection-performance.html 404
2020-07-02 09:15:12.519 C# 反射调用私有事件.md https://walterlv.com/uwp/2017/09/21/reflection-using-dotnet-native-runtime-directive.html 404
2020-07-02 09:15:12.729 C# 反射调用私有事件.md https://walterlv.com/post/handle-ref-or-out-arguments-using-reflection.html 404
2020-07-02 09:15:12.936 C# 反射调用私有事件.md https://walterlv.com/post/design-a-cache-pool.html 404
2020-07-02 09:15:13.122 [end] C:\博客\C# 反射调用私有事件.md

这样小伙伴就能知道有哪些博客需要修改

C# dotnet 解决 Path 获取文件名路径在 Windows 构建在 Linux 执行问题

Thu, 03 Dec 2020 12:27:50 +0000

最近需要支持国产的 UOS 系统，这个系统我采用了 Xamarin 加上 GTK 开发，而我的日志系统有一个功能是记录日志的时候传入当前的文件路径，此时 NuGet 包是在 Windows 下构建的，因此传入的路径是 Window 构建服务器路径。此时在 Linux 上尝试获取文件名就炸了

在 dotnet 中，可以通过 CallerFilePath 特性获取调用当前方法的文件路径是哪个，请看下面代码

public void DoProcessing()
{
    TraceMessage("Something happened.");
}

public void TraceMessage(string message,
        [System.Runtime.CompilerServices.CallerMemberName] string memberName = "",
        [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "",
        [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0)
{
    System.Diagnostics.Trace.WriteLine("message: " + message);
    System.Diagnostics.Trace.WriteLine("member name: " + memberName);
    System.Diagnostics.Trace.WriteLine("source file path: " + sourceFilePath);
    System.Diagnostics.Trace.WriteLine("source line number: " + sourceLineNumber);
}

// Sample Output:
//  message: Something happened.
//  member name: DoProcessing
//  source file path: c:\Users\username\Documents\Visual Studio 2020\Projects\CallerInfoCS\CallerInfoCS\Form1.cs
//  source line number: 31

上面代码是官方的例子，这是在构建的时候，自动注入的值。因此在 Windows 服务器构建的 NuGet 包给日志注入字符串是构建服务器上的代码文件的路径

而我记日志只是使用了文件名而已，如下面代码

        public static void LogInfo(this ILogger logger, string message,
            string traceId = null,
            string userId = null,
            [System.Runtime.CompilerServices.CallerMemberName]
            string memberName = "",
            [System.Runtime.CompilerServices.CallerFilePath]
            string sourceFilePath = "",
            [System.Runtime.CompilerServices.CallerLineNumber]
            int sourceLineNumber = 0,
            params string[] tags)
        {
            // 刚好在 Linux 下构建的在 Linux 下运行，而在 Windows 构建的库在 Windows 下执行。此时使用 GetFileNameWithoutExtension 能保持输入路径和解析相同
            // 假定在 Windows 下构建而在 Linux 下构建，只是让路径变长而已，我相信咱的日志系统炸不了…… 或者说，炸了再说
            // 炸了的解决方法是在 dotnet runtime\src\libraries\System.Private.CoreLib\src\System\IO\Path.cs 的 GetFileName 方法里面将 `PathInternal.IsDirectorySeparator(path[i])` 替换为实际需要的 \ 或 / 符号
            var classFile = Path.GetFileNameWithoutExtension(sourceFilePath);

            // 忽略代码
        }

如注释，使用 Path.GetFileNameWithoutExtension 如果在 Linux 运行，传入的是 Windows 下的路径，那么此时将拿不到文件名

原因是 Path.GetFileNameWithoutExtension 的实现如下

        public static ReadOnlySpan<char> GetFileNameWithoutExtension(ReadOnlySpan<char> path)
        {
            ReadOnlySpan<char> fileName = GetFileName(path);
            int lastPeriod = fileName.LastIndexOf('.');
            return lastPeriod == -1 ?
                fileName : // No extension was found
                fileName.Slice(0, lastPeriod);
        }

        public static ReadOnlySpan<char> GetFileName(ReadOnlySpan<char> path)
        {
            int root = GetPathRoot(path).Length;

            // We don't want to cut off "C:\file.txt:stream" (i.e. should be "file.txt:stream")
            // but we *do* want "C:Foo" => "Foo". This necessitates checking for the root.

            for (int i = path.Length; --i >= 0;)
            {
                if (i < root || PathInternal.IsDirectorySeparator(path[i]))
                    return path.Slice(i + 1, path.Length - i - 1);
            }

            return path;
        }

上面代码的 GetFileName 的 PathInternal.IsDirectorySeparator 判断就不对了，因此就拿不到文件路径了。因为在 Windows 下添加的字符串默认使用的是的是 \ 分割，因此 Linux 下无法解析。反过来，如果是在 Linux 服务器构建的，此时在 Windows 下解析没有问题，因为在 Windows 下的 IsDirectorySeparator 方法的判断是两个方向的都可以

解决方法就是自己抄 dotnet runtime\src\libraries\System.Private.CoreLib\src\System\IO\Path.cs 的 GetFileNameWithoutExtension 方法，修改判断文件夹符号

这是我修改的代码

        public static ReadOnlySpan<char> GetFileNameWithoutExtension(ReadOnlySpan<char> path)
        {
            ReadOnlySpan<char> fileName = GetFileName(path);
            int lastPeriod = fileName.LastIndexOf('.');
            return lastPeriod == -1 ?
                fileName : // No extension was found
                fileName.Slice(0, lastPeriod);
        }

        public static ReadOnlySpan<char> GetFileName(ReadOnlySpan<char> path)
        {
            int root = GetPathRoot(path).Length;

            // We don't want to cut off "C:\file.txt:stream" (i.e. should be "file.txt:stream")
            // but we *do* want "C:Foo" => "Foo". This necessitates checking for the root.

            for (int i = path.Length; --i >= 0;)
            {
                if (i < root || path[i] == '/' || path[i] == '\\')
                    return path.Slice(i + 1, path.Length - i - 1);
            }

            return path;
        }

特别吐槽 Linux 系统的文件路径的坑，在这里被坑了几次了

更好的解决方法是在 Linux 运行的内容就在 Linux 构建，本来我的主项目也是在 Linux 构建的。不过这里炸的是 CBB 公共组件，这些 NuGet 是在 Window 构建的，因为每个 NuGet 都支持 .NET Framework 和 .NET Core 版本

尽管我不能吐槽 UOS 系统，客观说，这个系统现在还是不开源的。我没有看到这个系统的优势。也许唯一的优势就是咱国家的有政策在推动，加上底子是深度的

我依然还会努力去支持国产的系统，尽管支持会让我加好多班，业余时间也用在支持上。整个 dotnet 都是开源的，而且还是完全开源的，加上现在龙芯等在硬件层面对 .NET 添加了运行时优化，此时在 UOS 上基于 .NET 构建从最低到最顶的完全自主研发的软件是十分简单的事情

这里需要说明一下的是完全开源的 .NET 完全允许贴牌，也就是改个名字，说这是自己完全拥有的技术，这是没有问题的，官方也是支持的。如果在贴牌之后还能将自己发现的 Bug 等提到官方，那么官方就更是推荐这样的行为。使用 .NET 的优势在于不会被卡，因为从编译到运行时到库都是完全开源，同时可自行构建，无版权问题。假设现在 M$ 断绝所有技术支持，包括抹掉了中国微软，此时对 .NET 也多少影响，除了可能存在的新代码无法拿到外，现有的代码同时基于现有代码继续开发没有任何问题。咱能改代码，也改的动

C# dotnet Thread.GetCurrentProcessorId 和 CurrentProcess.Id 的区别

Thu, 03 Dec 2020 12:27:50 +0000

使用 Thread.GetCurrentProcessorId 可以获取当前线程处理器的 Id 是哪个，而通过 Process.GetCurrentProcess().Id 可以获取当前进程的 Id 号，这两个的差别从上面描述就能看出

更进一步的 Thread.GetCurrentProcessorId() 方法将会缓存处理器的 Id 因此前后两次线程如果处理器切换，此时拿到的值是不对的。在官方文档里面说了使用代码不得依赖于其正确性，因此这个值基本上只在 DUMP 使用

而 Process.GetCurrentProcess().Id 是一个不需要 win32 的支持的方法，获取速度特别快，详细请看 .NET 中 GetProcess 相关方法的性能 - walterlv

获取速度如下

// 100 次执行耗时

    Process.GetProcesses()
        00:00:00.7254688
    Process.GetProcessById(id)
        00:00:01.3660640（实际数值取决于当前进程数）
    Process.GetProcessesByName("Walterlv.Demo")
        00:00:00.5604279
    Process.GetCurrentProcess()
        00:00:00.0000546

Blazor 获取当前的 Url 链接

Thu, 03 Dec 2020 12:27:50 +0000

在 Blazor 获取当前页面所在的 URL 链接可以通过 NavigationManager 类辅助获取，也可以通过此方法获取当前域名等信息

首先在页面添加依赖注入，如下面代码

@inject NavigationManager NavigationManager

此时就注入了 NavigationManager 属性，获取当前页面所在链接的方法或域名可以采用 Uri 或 BaseUri 两个属性

<p>
	NavigationManager.Uri = @NavigationManager.Uri
</p>

<p>
	NavigationManager.BaseUri = @NavigationManager.BaseUri
</p>

详细请看 ASP.NET Core Blazor 路由

Blazor 的 NavLink 的 NavLinkMatch.Prefix 有啥作用

Thu, 03 Dec 2020 12:27:50 +0000

默认的 NavLink 的 Match 的默认值就是 NavLinkMatch.Prefix 表示只要当前的链接的路由的前部分和 href 的相同，那么将匹配上，修改样式为高亮

本文记于 2020.06.25 也许后续也有点变更

在 NavLink 的取值上有两个可选的值，一个是 NavLinkMatch.All 另一个是 NavLinkMatch.Prefix 按照官方的定义如下

NavLinkMatch.All：NavLink 在与当前整个 URL 匹配的情况下处于活动状态。
NavLinkMatch.Prefix（默认）：NavLink 在与当前 URL 的任何前缀匹配的情况下处于活动状态。

官方这两句是什么意思，可以看到在 NavLink 有一个 href 属性，如下面代码

<NavLink class="nav-link" href="counter">
    <span class="oi oi-plus" aria-hidden="true"></span> Counter
</NavLink>

此时的 NavLink 没有添加 Match 的值，因此是默认 NavLinkMatch.Prefix 表示只要前缀是 counter 的就激活这一项

因此访问链接如 http://127.0.0.1:5000/counter/123 或 http://127.0.0.1:5000/counter 处于都满足前缀是 coutner 因此激活这一项

但如 http://127.0.0.1:5000/counter123 链接，此时是 counter123 不满足此前缀哦，不会激活这一项

而 NavLinkMatch.All 要求是完全匹配，如将上面代码修改如下

<NavLink class="nav-link" href="counter" Match="NavLinkMatch.All">
    <span class="oi oi-plus" aria-hidden="true"></span> Counter
</NavLink>

此时只有访问 http://127.0.0.1:5000/counter 才会激活，访问 http://127.0.0.1:5000/counter/123 不会激活

默认创建的 Blazor 的 WebAssembly 项目可以在 Shared\NavMenu.razor 找到如上代码，默认只有 href="" 被设置为 NavLinkMatch.All 其他使用默认值

本文所有代码放在 github 欢迎小伙伴访问

官方文档请看 ASP.NET Core Blazor 路由

特别推荐两个很好用的 Blazor 的 UI 库

Blazor 的 NavLink 提示 RZ9986 不支持复杂内容

Thu, 03 Dec 2020 12:27:50 +0000

在使用 Blazor 做动态的跳转的时候，如果在 NavLink 的 href 添加了包含 C# 代码，那么将会提示 RZ9986 组件的属性不支持复杂的内容，如混合 C# 代码和标记等。解决方法是通过按钮加上事件代替

在使用如下面代码在循环里面写跳转逻辑

@for (int i = 1; i < PageCount + 1; i++)
{
        <li>
            <NavLink href="/blog/page/@(i)">@(i)</NavLink>
        </li>
}

此时尝试运行代码将会提示如下错误

严重性	代码	说明	项目	文件	行	禁止显示状态
错误	RZ9986	Component attributes do not support complex content (mixed C# and markup). Attribute: 'href', text: '/blog/page/i'	StaticBlog	g:\lindexi\Blog\StaticBlog\RAZORGENERATE	1	

如 RZ9986 Component attributes do not support complex content (mixed C# and markup). Attribute: 'href', text: 所说，这里的坑就是 NavLink 的 href 只支持静态的字符串，不支持拼接，因此如官方文档所说，可以使用 NavigationManager 配合按钮解决此问题

在添加按钮之前，需要知道当前是第几次循环进入，此时需要用到再定义一个变量。如果了解闭包问题的小伙伴应该很好理解，如果不了解的话，就请听我吹一下水。咱需要再写一个变量去获取当前是 for 循环的第几次循环进来，用于传入按钮点击时的事件，如官方文档所说，假设咱在事件的表达式里面使用了循环迭代的变量，因此变量只有一个，因此这个变量的值会被变更，因此做不到让每次循环创建的按钮都知道自己是第几个被创建的

@for (int i = 1; i < PageCount + 1; i++)
{
        // 必须放在标签之前，如下面代码放在标签下面是不对的
        var currentPage = i;
        <li>
            @* 下面这一行代码将会显示为 HTML 内容 *@
            @*var currentPage = i;*@
            <button @onclick="@(e => GotoPage(e, currentPage))">@i</button>
            
            @*<NavLink href="/blog/page/@(i)">@(i)</NavLink>*@
        </li>
}

@code
{
	private void GotoPage(MouseEventArgs e, int currentPage)
    {
        NavigationManager.NavigateTo($"/blog/page/{currentPage}");
    }
}

上面代码有两个注意的地方，第一个地方就是需要创建 currentPage 这个变量，这个变量能固定当前循环进入的值。此外需要将 currentPage 的定义放在标签之前，如上面代码

这样玩就能做到跳转了，对比使用 a 的跳转标签的优势在于用此方法依然是单页应用，而不是重新进入一个新的页面。这句话不理解的小伙伴，请自己修改为 a 跳转对比试试就知道了

Blazor 如何使用代码跳转链接

Thu, 03 Dec 2020 12:27:50 +0000

可以通过在页面注入 NavigationManager 调用 NavigateTo 方法进行跳转

根据官方文档可以在页面注入 NavigationManager 拿到跳转的功能

@page "/todo"
@inject NavigationManager NavigationManager

在注入 NavigationManager 之后可以在代码里面调用 NavigationManager.NavigateTo("链接"); 将链接修改为想要跳转的代码

如下面代码在按钮点击的时候跳转到 counter 页面

<button class="btn btn-primary" @onclick="NavigateToCounterComponent">跳转界面</button>

@code
{
	private void NavigateToCounterComponent()
	{
	    NavigationManager.NavigateTo("counter");
	}
}

运行上面代码就可以在点击按钮的时候跳转到 counter 页面

特别推荐两个很好用的 Blazor 的 UI 库

ASP.NET Core 解决控制台输出日志内容前面[40m等乱码字符

Thu, 03 Dec 2020 12:27:50 +0000

在默认我写了一个 WPF 程序去做管理 ASP.NET Core 进程的日志的时候，重定向输出的内容里面每一行前面都添加了很多乱码字符串。其实这是 ASP.NET Core 控制台的颜色字符，解决方法是禁用控制台颜色

在看到重定向的输出里面包含以下乱码字符

[40m[32minfo[39m[22m[49m:

或者如下乱码字符

[41m[30mfail[39m[22m[49m

这里 asp dotnet core 的日志内容的 [40m[32m 和 [41m[30m 字符是控制颜色的字符，可以在 Startup.cs 的 ConfigureServices 方法使用下面代码禁用控制台输出颜色

public void ConfigureServices(IServiceCollection services)
{
	services.AddLogging(builder => builder
        .ClearProviders()
        // 这里的颜色会被显示为 [41m[30mfail[39m[22m[49m 的内容
        // [40m[32minfo[39m[22m[49m:
        .AddConsole(options => { options.DisableColors = true; }));
}

注意上面代码使用 ClearProviders 清空了日志输出，上面代码禁用颜色用的是 options.DisableColors = true; 禁用

禁用之后输出控制台没有颜色，但重定向的日志里面也没有乱码

另外，在 WPF 之外，在 Kubernetes 上的重定向输出也会是差不多的乱码

�[40m�[32minfo�[39m�[22m�[49m: Microsoft.Hosting.Lifetime[0]
      Now listening on: http://[::]:12312
�[40m�[32minfo�[39m�[22m�[49m: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
�[40m�[32minfo�[39m�[22m�[49m: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Production
�[40m�[32minfo�[39m�[22m�[49m: Microsoft.Hosting.Lifetime[0]
      Content root path: /lindexi/doubi

解决方法和上面相同

白板类应用的业务事件分发模式

Thu, 03 Dec 2020 12:27:50 +0000

在画板上延伸业务的事件，可以通过画板本身，利用路由事件分发，此时能解决依赖事件业务对具体业务对象的依赖

背景

先来聊聊白板应用的背景

基础的白板可以认为是有一个画板 Board 而在画板上面有很多纸张页面，咱称这些纸张页面为 Slide 页面

默认在画板上添加的元素，如笔迹或文本等，都是画在纸张上面的。而通过切换纸张 Slide 可以做到切换页面

多的我也不讲了，因为了解这个行业的小伙伴自然了解哈

那这里要聊的事件分发是什么呢？就是附加在画板上的各个交互，例如我有一个笔的功能，这个笔的功能是一个个独立的类，这个类知道画板以及页面的存在。这个类需要对外抛出事件，例如抛出开始写字以及完成写字的事件

那么我在其他的业务可以如何监听到这些事件呢？或者业务功能通过什么方式拿到事件

咱先聊聊会遇到的问题

为什么

还是使用笔这个功能作为例子

假设咱有一个业务需要监听笔开始写的功能以及写字完成，那么这个业务以及笔功能可以如何设计

最简单的方法就是在笔功能里面添加 CLR 事件，而业务就监听具体的对象拿到事件

这么做有什么问题呢？会遇到的问题是业务需要知道具体笔功能的对象

而根据白板的业务，用户当前选择的交互模式会变更，如用户现在想要进行选择了。此时就会切换走了笔功能。当用户切换回笔功能的时候，就不一定是刚才的对象了。此时业务模块就需要处理模式切换的时候的事件注册的坑

而笔这个功能，假定白板里面有很多不同的笔，这些不同的笔功能甚至连相同的基类都很难做到。此时也许就需要业务方做一个适配器对各个不同的笔监听对应的事件

这看起来的代码复杂度很高，实际上这部分的代码复杂度也很高，因为我就写过这样的逻辑，后续很难维护

如何做

有什么方法可以解决上面所说的问题

解决方法是让事件作为独立的路由事件模块，而具体功能模块触发路由事件，让业务模块监听路由事件。此时业务模块只需要知道从画板以及画板上层的容器可以拿到事件，而不需要关注这个事件是由那个功能触发的。但是如果真需要了解是那个功能模块触发的，可以通过参数拿到是哪个模块

使用笔作为例子

简单的方法是让业务模块不要去知道笔功能的存在，或者不要知道具体的笔功能对象的存在。这样就能解决很多的问题了

假定业务模块不需要知道笔功能的存在，或不需要知道具体对象，那么用户切换交互模式的时候，也就不需要处理事件注册功能。当逻辑上笔功能的对象变化的时候，也不需要去关注对象变化的事件变化。当逻辑上需要多个不同的笔类的时候，也不需要去跟随新的笔类型的创建而添加适配器的逻辑

那如何才能做到让业务模块不要去知道具体的笔功能的存在？简单的方法是将事件从笔功能去掉，将事件放在独立的模块

假设创建一个模块叫笔事件模块

public static class InkEvents
{

}

在笔事件模块里面定义了路由事件，表示笔的开始写和写完成的事件

public static class InkEvents
{
        public static readonly RoutedEvent InkStartedEvent = EventManager.RegisterRoutedEvent("InkStarted",
            RoutingStrategy.Bubble, typeof(EventHandler<InkStartedRoutedEventArgs>), typeof(Board));
}


    public class InkStartedRoutedEventArgs : RoutedEventArgs
    {
        public InkStartedRoutedEventArgs(RoutedEvent routedEvent) : base(routedEvent)
        {
        }
    }

这里的细节是定义自己的 InkStartedRoutedEventArgs 这样可以在后续业务修改的时候方便添加属性，业务修改时添加属性不会影响现有的业务。而在事件定义的时候，注意路由事件最后一个参数写了是 typeof(Board) 使用的是画板的

这样的写法就类似给画板添加了一个事件，而不需要改动画板的功能

利用事件能作出的效果是在页面 Slide 里面触发路由事件，路由事件会在视觉树上面一层层分发，在画板或画板的容器可以让业务去拿到这个路由事件

那笔功能可以如何触发这个路由事件？假设笔功能拿到了页面 Slide 可以使用下面代码触发

Slide.RaiseEvent(new InkStartedRoutedEventArgs(InkEvents.InkStartedEvent));

此时业务模块不需要在页面切换的时候修改事件监听，也不需要关注是哪个对象或类型触发了笔事件。因此业务模块就可以做到很小的依赖，同时也方便做一些有趣的功能，例如有一些不是笔的模块也能通过触发这些事件模拟笔的效果

更多白板应用设计请看

白板类应用的模式交互设计方案

C# dotnet 从后向前删除列表元素提升性能的原理

Thu, 03 Dec 2020 12:27:50 +0000

如果要从一个列表里面删除一些元素，如何做才能让性能比较高？答案是从列表的后面开始删起，从后到前删除

在 dotnet 中的列表存放的底层是一个连续的数组。而列表在删除元素的时候，会通过移动数组的方式让整个列表的元素在内存中依然是连续的

假设我有一个大的列表，此时我删除了第一项，按照上面的说法，列表就需要将后面的所有项移动一次，达到让整个列表的元素在内存是连续

而如果是从后向前开始删除呢？此时列表可能就不需要做移动了，因为从后到前删除，如果刚好后面每一项都需要删除，此时的整个列表无需重新移动元素。而如果不是每一项都需要删除，同时这个列表不关注元素本身的顺序，那么依然还可以优化，优化方法是手动移动元素

假定我是从后向前开始删除元素，这个列表里面的元素不关注元素所在列表的顺序

此时我可以通过将最后一项移动到当前准备删除的元素下标上，然后删除最后一项的方法，让整个列表无需移动元素

一个例子如下：

假设我有列表里面包含元素是 1 2 3 三个元素

此时我从后到前遍历，准备删除元素值是 2 的元素。此时我找到第一个元素 3 不满足，找到第二个元素 2 刚好满足。此时我不是直接删除第二个元素，而是将最后一个元素也就是 3 移动到第二个元素上。然后删除最后一个元素。伪代码如下

var lastIndex = 2;
// 将最后一个元素替换掉准备移除的元素
list[1] = list[lastIndex];
list.RemoveAt(lastIndex);

因为提前将最后一个元素赋值给准备删除的元素，因此准备删除的元素就没有在列表中被记录，而最后一个元素在列表中被记录了两次。此时删除最后一个元素就可以让最后一个元素在列表中只记录一次，刚好在删除最后一个元素的时候，列表不需要移动元素就能让列表里面所有元素依然是连续在内存存储的

这就是从后向前删除列表元素的原理

在整个 dotnet 的运行时底层有很多这样的逻辑，如这段代码就是从后向前开始删除，下面是我简化的代码

            for (int i = timers.Count - 1; i >= 0; --i)
            {
                TimerQueue timer = timers[i];
                long waitDurationMs = timer._scheduledDueTimeMs - currentTimeMs;
                if (waitDurationMs <= 0)
                {
                    int lastIndex = timers.Count - 1;
                    if (i != lastIndex)
                    {
                        timers[i] = timers[lastIndex];
                    }
                    timers.RemoveAt(lastIndex);
                }
            }

咱使用 BenchmarkDotNet 进行测试对比

先安装 BenchmarkDotNet 库，然后编写代码进行测试，代码比较长，放在本文最后

    <ItemGroup>
        <PackageReference Include="BenchmarkDotNet" Version="0.12.1"/>
    </ItemGroup>

大概的测试效果如下

从 dotnet 的源代码可以看到删除的逻辑大概如下，下面代码有删减

        public void RemoveAt(int index)
        {
            _size--;
            if (index < _size)
            {
                Array.Copy(_items, index + 1, _items, index, _size - index);
            }
            else
            {
                _items[_size] = default!;
            }
        }

可以看到如果 index 小于 _size 就表示删除的不是最后一项，就需要通过 Array.Copy 方法复制一次，让存放的元素依然连续

这是本文的测试代码

    class Program
    {
        static void Main(string[] args)
        {
            //var listRemoveTest = new ListRemoveTest();
            //var list = listRemoveTest.GetArgumentList().First();
            //listRemoveTest.RemoveFromEnd(list);

            //if (list.All(temp => temp.N <= ListRemoveTest.MaxCount / 2))
            //{

            //}

            BenchmarkRunner.Run<ListRemoveTest>();
        }
    }

    public class ListRemoveTest
    {
        [Benchmark]
        [ArgumentsSource(nameof(GetArgumentList))]
        public void RemoveAll(List<Foo> list)
        {
            list.RemoveAll(temp => temp.N > MaxCount / 2);
        }

        [Benchmark]
        [ArgumentsSource(nameof(GetArgumentList))]
        public void RemoveFromStart(List<Foo> list)
        {
            for (var i = 0; i < list.Count; i++)
            {
                if (list[i].N > MaxCount / 2)
                {
                    list.RemoveAt(i);
                    i--;
                }
            }
        }

        [Benchmark]
        [ArgumentsSource(nameof(GetArgumentList))]
        public void RemoveFromEnd(List<Foo> list)
        {
            for (var i = list.Count - 1; i >= 0; i--)
            {
                if (list[i].N > MaxCount / 2)
                {
                    var lastIndex = list.Count - 1;
                    if (i != lastIndex)
                    {
                        // 假设列表有值是 1 10 5 而当前 i = 1 而 lastIndex = 2 要移除元素 10 可以先将最后一个值赋值给当前的元素
                        // list[1] = list[lastIndex=2] = 5
                        // 赋值之后的列表是 1 5 5 也就是实际上干掉了 10 这个元素了
                        // 最后再删除多余的最后一个元素就可以了
                        list[i] = list[lastIndex];
                    }

                    list.RemoveAt(lastIndex);
                }
            }
        }

        public const int MaxCount = 20000000;

        public IEnumerable<List<Foo>> GetArgumentList()
        {
            var list = new List<Foo>(MaxCount);
            for (int i = 0; i < MaxCount / 2; i++)
            {
                list.Add(new Foo()
                {
                    N = i
                });
                list.Add(new Foo()
                {
                    N = MaxCount - i
                });
            }

            yield return list;
        }
    }

    public class Foo
    {
        public int N { set; get; }
    }

C# dotnet 一个看上去还能用的二进制序列化帮助类

Thu, 03 Dec 2020 12:27:50 +0000

这仅是一个辅助方法帮助类，可以协助小伙伴写二进制序列化的效率，代码也还看的过去

在开始之前，我需要说明的是，如果不是必要，不要使用二进制序列化。因为很难做到版本兼容，如果写错了也不知道是哪里写错了，调试难度很大。但是对于性能的提升，其实也不大

    /// <summary>
    /// 二进制序列化
    /// </summary>
    interface IBinarySerializable
    {
        void Serialize(BinaryWriter binaryWriter);
        void Deserialize(BinaryReader binaryReader);
    }

这个接口用于给对象继承，如果对象继承了，那么就方便进行序列化

这是一些辅助方法

没有用到反射，需要自己手动写转换代码。注意顺序

    static class BinarySerialize
    {
        /// <summary>
        /// 写入 uin32 列表
        /// </summary>
        /// <param name="binaryWriter"></param>
        /// <param name="list"></param>
        public static void WriteUint32List(this BinaryWriter binaryWriter, List<uint> list)
        {
            // 格式先写入列表长度，然后依次写入内容
            binaryWriter.Write(list.Count);

            foreach (var n in list)
            {
                binaryWriter.Write(n);
            }
        }

        /// <summary>
        /// 读取 uint32 列表
        /// </summary>
        /// <param name="binaryReader"></param>
        /// <returns></returns>
        public static List<uint> ReadUint32List(this BinaryReader binaryReader)
        {
            // 读取长度
            var count = binaryReader.ReadInt32();

            List<uint> list = new List<uint>(count);
            for (int i = 0; i < count; i++)
            {
                list.Add(binaryReader.ReadUInt32());
            }

            return list;
        }

        /// <summary>
        /// 写入字符串列表
        /// </summary>
        /// <param name="binaryWriter"></param>
        /// <param name="stringList"></param>
        public static void WriteStringList(this BinaryWriter binaryWriter, List<string> stringList)
        {
            // 格式先写入列表长度，然后依次写入字符串
            binaryWriter.Write(stringList.Count);

            foreach (var str in stringList)
            {
                binaryWriter.Write(str);
            }
        }

        /// <summary>
        /// 写入可序列化类的列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="binaryWriter"></param>
        /// <param name="list"></param>
        public static void WriteList<T>(this BinaryWriter binaryWriter, List<T> list) where T : IBinarySerializable
        {
            // 先写入长度
            binaryWriter.Write(list.Count);
            foreach (var binarySerializable in list)
            {
                binarySerializable.Serialize(binaryWriter);
            }
        }

        /// <summary>
        /// 读取可序列化类的列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="binaryReader"></param>
        /// <returns></returns>
        public static List<T> ReadList<T>(this BinaryReader binaryReader) where T : IBinarySerializable, new()
        {
            // 读取长度
            var count = binaryReader.ReadInt32();
            List<T> list = new List<T>(count);
            for (int i = 0; i < count; i++)
            {
                T t = new T();
                t.Deserialize(binaryReader);
                list.Add(t);
            }

            return list;
        }

        /// <summary>
        /// 读取字符串列表
        /// </summary>
        /// <param name="binaryReader"></param>
        /// <returns></returns>
        public static List<string> ReadStringList(this BinaryReader binaryReader)
        {
            // 先读取列表长度，然后依次读取字符串
            var count = binaryReader.ReadInt32();
            List<string> stringList = new List<string>(count);
            for (int i = 0; i < count; i++)
            {
                var str = binaryReader.ReadString();
                stringList.Add(str);
            }

            return stringList;
        }

        /// <summary>
        /// 写入头信息，默认是需要固定长度的
        /// </summary>
        /// <param name="binaryWriter"></param>
        /// <param name="head"></param>
        /// <param name="headLength"></param>
        public static void WriteHead(this BinaryWriter binaryWriter, string head, int headLength)
        {
            var headByte = StringToByteList(head);
            binaryWriter.WriteByteList(headByte, headLength);
        }

        /// <summary>
        /// 将字符串转换为 byte 其中字符串添加长度前缀
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static byte[] StringToByteList(string str)
        {
            var strByteList = Utf8.GetBytes(str);
            ushort byteLength = (ushort)strByteList.Length;
            var newLength = sizeof(ushort) + strByteList.Length;

            var byteList = new byte[newLength];
            var binaryWriter = new BinaryWriter(new MemoryStream(byteList));
            binaryWriter.Write(byteLength);
            binaryWriter.Write(strByteList);
            return byteList;
        }

        /// <summary>
        /// 写入二进制写入固定长度
        /// </summary>
        /// <param name="binaryWriter"></param>
        /// <param name="source"></param>
        /// <param name="byteCount"></param>
        public static void WriteByteList(this BinaryWriter binaryWriter, byte[] source, int byteCount)
        {
            var byteList = new byte[byteCount];
            Array.Copy(source, 0, byteList, 0, Math.Min(source.Length, byteCount));

            binaryWriter.Write(byteList, 0, byteCount);
        }

        private static Encoding Utf8 => Encoding.UTF8;

        /// <summary>
        /// 读取固定长度的头
        /// </summary>
        /// <param name="binaryReader"></param>
        /// <param name="headLength"></param>
        /// <returns></returns>
        public static string ReadHead(this BinaryReader binaryReader, int headLength)
        {
            var strByteLength = (ushort)binaryReader.ReadInt16();
            var strByteList = binaryReader.ReadBytes(strByteLength);
            var head = Utf8.GetString(strByteList);

            var readLength = headLength - sizeof(ushort) - strByteLength;
            binaryReader.ReadBytes(readLength);

            return head;
        }
    }

这里的读写 Head 也许小伙伴的业务是用不到的，我用这个方法主要是写入版本号

这是单元测试的代码，只是测试主要使用方法，边界没有测试

    [TestClass]
    public class BinarySerializeTests
    {
        private class FakeBinarySerialize : IBinarySerializable, IEquatable<FakeBinarySerialize>
        {
            /// <inheritdoc />
            public void Serialize(BinaryWriter binaryWriter)
            {
                binaryWriter.Write(F1);
                binaryWriter.Write(F2);
            }

            /// <inheritdoc />
            public void Deserialize(BinaryReader binaryReader)
            {
                F1 = binaryReader.ReadString();
                F2 = binaryReader.ReadInt32();
            }

            public string F1 { set; get; }
            public int F2 { set; get; }

            /// <inheritdoc />
            public bool Equals(FakeBinarySerialize other)
            {
                if (ReferenceEquals(null, other)) return false;
                if (ReferenceEquals(this, other)) return true;
                return F1 == other.F1 && F2 == other.F2;
            }

            /// <inheritdoc />
            public override bool Equals(object obj)
            {
                if (ReferenceEquals(null, obj)) return false;
                if (ReferenceEquals(this, obj)) return true;
                if (obj.GetType() != this.GetType()) return false;
                return Equals((FakeBinarySerialize)obj);
            }

            /// <inheritdoc />
            public override int GetHashCode()
            {
                unchecked
                {
                    return ((F1 != null ? F1.GetHashCode() : 0) * 397) ^ F2;
                }
            }
        }

        [ContractTestCase]
        public void WriteUint32List()
        {
            "写入uint列表，可以读取列表内容".Test(() =>
            {
                // Arrange
                var memoryStream = new MemoryStream();
                var binaryWriter = new BinaryWriter(memoryStream);
                var fakeBinarySerializeList = new List<uint>();
                for (int i = 0; i < 100; i++)
                {
                    fakeBinarySerializeList.Add((uint)i);
                }

                // Action
                binaryWriter.WriteUint32List(fakeBinarySerializeList);

                // Assert
                memoryStream.Seek(0, SeekOrigin.Begin);
                var binaryReader = new BinaryReader(memoryStream);
                var readList = binaryReader.ReadUint32List();

                Equal(fakeBinarySerializeList, readList);
            });
        }

        [ContractTestCase]
        public void WriteList()
        {
            "写入列表内容，可以读取列表".Test(() =>
            {
                // Arrange
                var memoryStream = new MemoryStream();
                var binaryWriter = new BinaryWriter(memoryStream);
                var fakeBinarySerializeList = new List<FakeBinarySerialize>();
                for (int i = 0; i < 100; i++)
                {
                    fakeBinarySerializeList.Add(new FakeBinarySerialize()
                    {
                        F1 = i.ToString(),
                        F2 = i,
                    });
                }

                // Action
                binaryWriter.WriteList(fakeBinarySerializeList);

                // Assert
                memoryStream.Seek(0, SeekOrigin.Begin);
                var binaryReader = new BinaryReader(memoryStream);
                var readList = binaryReader.ReadList<FakeBinarySerialize>();
                Equal(fakeBinarySerializeList, readList);
            });
        }

        private void Equal<T>(List<T> a, List<T> b)
        {
            Assert.AreEqual(a.Count, b.Count);
            for (int i = 0; i < a.Count; i++)
            {
                Assert.AreEqual(a[i], b[i]);
            }
        }

        [ContractTestCase]
        public void WriteStringList()
        {
            "写入空字符串列表，可以读取空的列表".Test(() =>
            {
                // Arrange
                var memoryStream = new MemoryStream();
                var binaryWriter = new BinaryWriter(memoryStream);
                var head = "Font Data 1.0.0";
                var length = 20;
                var test = (byte)0xF1;

                var stringList = new List<string>();

                // Action
                binaryWriter.WriteHead(head, length);
                binaryWriter.Write(test);
                binaryWriter.WriteStringList(stringList);

                // Assert

                memoryStream.Seek(0, SeekOrigin.Begin);
                var binaryReader = new BinaryReader(memoryStream);
                var str = binaryReader.ReadHead(length);
                var b = binaryReader.ReadByte();
                var readList = binaryReader.ReadStringList();

                Assert.AreEqual(0, readList.Count);
            });

            "写入字符串列表，可以读取写入的值".Test(() =>
            {
                // Arrange
                var memoryStream = new MemoryStream();
                var binaryWriter = new BinaryWriter(memoryStream);
                var head = "Font Data 1.0.0";
                var length = 20;
                var test = (byte)0xF1;

                var stringList = new List<string>()
                {
                    "lindexi","doubi"
                };

                // Action
                binaryWriter.WriteHead(head, length);
                binaryWriter.Write(test);
                binaryWriter.WriteStringList(stringList);

                // Assert
                memoryStream.Seek(0, SeekOrigin.Begin);
                var binaryReader = new BinaryReader(memoryStream);
                var str = binaryReader.ReadHead(length);
                var b = binaryReader.ReadByte();
                var readList = binaryReader.ReadStringList();
            });
        }

        [ContractTestCase]
        public void WriteHead()
        {
            "尝试写入长度小于指定长度的头，可以写入和读取".Test(() =>
            {
                // Arrange
                var memoryStream = new MemoryStream();
                var binaryWriter = new BinaryWriter(memoryStream);
                var head = "Font Data 1.0.0";
                var length = 20;
                var test = (byte)0xF1;
                // Action
                binaryWriter.WriteHead(head, length);
                binaryWriter.Write(test);

                // Assert
                memoryStream.Seek(0, SeekOrigin.Begin);
                var binaryReader = new BinaryReader(memoryStream);
                var str = binaryReader.ReadHead(length);
                var b = binaryReader.ReadByte();

                Assert.AreEqual(head, str);
                Assert.AreEqual(test, b);
            });
        }
    }

上面代码需要使用 CUnit 库的支持，才能在单元测试里面使用中文写条件

        <PackageReference Include="MSTestEnhancer" Version="1.6.0" />

C# dotnet 一个还看的过去的 B 树实现

Thu, 03 Dec 2020 12:27:50 +0000

我尝试找到一个 B 树的实现，尽管这个东西十分简单，但是依然网上有很多不同的版本。我在 justcoding121 的版本上魔改了一下，就是本文可以用来给大家的版本

基本上很难有啥需求需要用到 B 树，在 dotnet 里面提供了默认的 SortedList 可以解决快速搜寻的问题，在 SortedList 的实现原理是一个搜寻二叉树。当然本文不是来吹 SortedList 的实现了，继续回到 B 树的实现

因为这个 B 树也许只有在教科书上面才有用，因此比较难会用到真实的需求上，因此大部分对他的实现也仅仅是能实现出来。包括 https://github.com/justcoding121/Advanced-Algorithms 这个比较有名的项目

本文是从 https://github.com/justcoding121/Advanced-Algorithms 魔改的，最大的更改是修复命名错误问题，以及导入了 IValueComparer 接口，开放了 Find 方法

以下是使用方法，使用方法包含测试性能和对比

    internal class Program
    {
        private static void Main(string[] args)
        {
            var random = new Random();

            var stopwatch = new Stopwatch();
            stopwatch.Start();

            var nairqearjojaJemjaremkes = new BTree<NairqearjojaJemjaremke>();
            for (var i = 0; i < 100000; i++)
            {
                nairqearjojaJemjaremkes.Insert(new NairqearjojaJemjaremke
                {
                    WaleawhalharWogerjedearwhel = random.Next()
                });
            }

            stopwatch.Stop();

            Console.WriteLine(stopwatch.ElapsedTicks);

            stopwatch.Restart();

            var find = 0;
            for (var i = 0; i < 1000000; i++)
            {
                var f = i;
                if (nairqearjojaJemjaremkes.Find(n =>
                    f.CompareTo(n.WaleawhalharWogerjedearwhel)) != null)
                {
                    find++;
                }
            }

            stopwatch.Stop();

            Console.WriteLine(stopwatch.ElapsedMilliseconds);
            Console.WriteLine($"Find {find}");

            stopwatch.Restart();

            find = 0;

            for (var i = 0; i < 1000000; i++)
            {
                if (nairqearjojaJemjaremkes.Find(new NairqearjojaJemjaremke
                {
                    WaleawhalharWogerjedearwhel = i
                }) != null)
                {
                    find++;
                }
            }

            stopwatch.Stop();

            Console.WriteLine(stopwatch.ElapsedMilliseconds);
            Console.WriteLine($"Find {find}");

            stopwatch.Restart();

            find = 0;
            var nairqearjojaJemjaremkeComparer = new NairqearjojaJemjaremkeComparer();

            for (var i = 0; i < 1000000; i++)
            {
                nairqearjojaJemjaremkeComparer.NairqearjojaJemjaremke = i;
                if (nairqearjojaJemjaremkes.Find(nairqearjojaJemjaremkeComparer) != null)
                {
                    find++;
                }
            }

            stopwatch.Stop();

            Console.WriteLine(stopwatch.ElapsedMilliseconds);
            Console.WriteLine($"Find {find}");

            stopwatch.Restart();
            var list = new SortedList<int, NairqearjojaJemjaremke>();

            for (var i = 0; i < 100000; i++)
            {
                var nairqearjojaJemjaremke = new NairqearjojaJemjaremke
                {
                    WaleawhalharWogerjedearwhel = i
                };
                list.Add(nairqearjojaJemjaremke.WaleawhalharWogerjedearwhel,nairqearjojaJemjaremke);
            }
            stopwatch.Stop();

            Console.WriteLine(stopwatch.ElapsedMilliseconds);

            stopwatch.Restart();

            find = 0;

            for (var i = 0; i < 100000; i++)
            {
                if (list.TryGetValue(i,out _))
                {
                    find++;
                }
            }

            stopwatch.Stop();

            Console.WriteLine(stopwatch.ElapsedMilliseconds);
            Console.WriteLine($"Find {find}");
        }

        private class NairqearjojaJemjaremkeComparer : IValueComparer<NairqearjojaJemjaremke>
        {
            public int NairqearjojaJemjaremke { set; get; }

            /// <inheritdoc />
            public int CompareTo(NairqearjojaJemjaremke value)
            {
                return NairqearjojaJemjaremke.CompareTo(value.WaleawhalharWogerjedearwhel);
            }
        }

        private class NairqearjojaJemjaremke : IComparable<NairqearjojaJemjaremke>, IComparable
        {
            public int WaleawhalharWogerjedearwhel { set; get; }

            /// <inheritdoc />
            public int CompareTo(object? obj)
            {
                return CompareTo((NairqearjojaJemjaremke)obj);
            }

            /// <inheritdoc />
            public int CompareTo(NairqearjojaJemjaremke other)
            {
                if (ReferenceEquals(this, other)) return 0;
                if (ReferenceEquals(null, other)) return 1;
                return WaleawhalharWogerjedearwhel.CompareTo(other.WaleawhalharWogerjedearwhel);
            }
        }
    }

下面是 B 树的实现，大概可以直接复制粘贴到你的项目里面

下面代码放在 github 欢迎小伙伴访问

    /// <summary>
    /// 值比较方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IValueComparer<in T>
    {
        /// <summary>
        /// 传入的 <paramref name="t"/> 就是存放在树里面的数据
        /// <para></para>
        /// 采用 <code>x.CompareTo(<paramref name="t"/>)</code> 的方法，注意判断顺序不能相反
        /// </summary>
        /// <param name="t"></param>
        /// <returns>如果存根 x 比 <paramref name="t"/> 大，返回 1 等于返回 0 的值</returns>
        int CompareTo(T t);
    }

    /// <summary>
    /// A B-tree implementation.
    /// </summary>
    /// https://github.com/justcoding121/Advanced-Algorithms
    public class BTree<T> : IEnumerable<T> where T : IComparable
    {
        /// <summary>
        /// 创建 B树
        /// </summary>
        /// <param name="maxKeysPerNode">默认一个 Node 有多少个数据，默认值是 3 个，注意不能传入小于3个</param>
        public BTree(int maxKeysPerNode = 3)
        {
            if (maxKeysPerNode < 3)
            {
                throw new ArgumentException(
                    $"Max keys per node should be atleast 3. Current value is {maxKeysPerNode}");
            }

            _maxKeysPerNode = maxKeysPerNode;
            _minKeysPerNode = maxKeysPerNode / 2;
        }

        /// <summary>
        /// 总共有多少数据
        /// </summary>
        public int Count { get; private set; }

        /// <summary>
        /// Time complexity: O(log(n)).
        /// </summary>
        public T Max
        {
            get
            {
                if (Root == null) return default;

                var maxNode = FindMaxNode(Root);
                return maxNode.Keys[maxNode.KeyCount - 1];
            }
        }

        /// <summary>
        /// Time complexity: O(log(n)).
        /// </summary>
        public T Min
        {
            get
            {
                if (Root == null) return default;

                var minNode = FindMinNode(Root);
                return minNode.Keys[0];
            }
        }

        public T Find(IValueComparer<T> comparer)
        {
            return Find(Root, comparer);
        }

        public T Find(T value)
        {
            return Find(Root, value);
        }

        public T Find(Func<T, int> comparer)
        {
            return Find(Root, new DelegateComparer(comparer));
        }

        /// <summary>
        /// Time complexity: O(log(n)).
        /// </summary>
        public void Insert(T newValue)
        {
            if (Root == null)
            {
                Root = new BTreeNode<T>(_maxKeysPerNode, null) { Keys = { [0] = newValue } };
                Root.KeyCount++;
                Count++;
                return;
            }

            var leafToInsert = FindInsertionLeaf(Root, newValue);
            InsertAndSplit(ref leafToInsert, newValue, null, null);
            Count++;
        }

        /// <summary>
        /// Time complexity: O(log(n)).
        /// </summary>
        public void Delete(T value)
        {
            var node = FindDeletionNode(Root, value);

            if (node == null)
            {
                throw new Exception("Item do not exist in this tree.");
            }

            for (var i = 0; i < node.KeyCount; i++)
            {
                if (value.CompareTo(node.Keys[i]) != 0)
                {
                    continue;
                }

                //if node is leaf and no underflow
                //then just remove the node
                if (node.IsLeaf)
                {
                    RemoveAt(node.Keys, i);
                    node.KeyCount--;

                    Balance(node);
                }
                else
                {
                    //replace with max node of left tree
                    var maxNode = FindMaxNode(node.Children[i]);
                    node.Keys[i] = maxNode.Keys[maxNode.KeyCount - 1];

                    RemoveAt(maxNode.Keys, maxNode.KeyCount - 1);
                    maxNode.KeyCount--;

                    Balance(maxNode);
                }

                Count--;
                return;
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public IEnumerator<T> GetEnumerator()
        {
            return new BTreeEnumerator<T>(Root);
        }

        private readonly int _maxKeysPerNode;
        private readonly int _minKeysPerNode;

        private BTreeNode<T> Root { set; get; }

        private static T Find(BTreeNode<T> node, IValueComparer<T> comparer)
        {
            //if leaf then its time to insert
            if (node.IsLeaf)
            {
                for (var i = 0; i < node.KeyCount; i++)
                {
                    var value = node.Keys[i];
                    if (comparer.CompareTo(value) == 0)
                    {
                        return value;
                    }
                }
            }
            else
            {
                //if not leaf then drill down to leaf
                for (var i = 0; i < node.KeyCount; i++)
                {
                    var value = node.Keys[i];
                    if (comparer.CompareTo(value) == 0)
                    {
                        return value;
                    }

                    //current value is less than new value
                    //drill down to left child of current value
                    if (comparer.CompareTo(value) < 0)
                    {
                        return Find(node.Children[i], comparer);
                    }
                    //current value is grearer than new value
                    //and current value is last element 

                    if (node.KeyCount == i + 1)
                    {
                        return Find(node.Children[i + 1], comparer);
                    }
                }
            }

            return default;
        }

        /// <summary>
        /// Find the value node under given node.
        /// </summary>
        private static T Find(BTreeNode<T> node, T value)
        {
            return Find(node, new DefaultComparer(value));
        }


        /// <summary>
        /// Find the leaf node to start initial insertion
        /// </summary>
        private static BTreeNode<T> FindInsertionLeaf(BTreeNode<T> node, T newValue)
        {
            //if leaf then its time to insert
            if (node.IsLeaf)
            {
                return node;
            }

            //if not leaf then drill down to leaf
            for (var i = 0; i < node.KeyCount; i++)
            {
                //current value is less than new value
                //drill down to left child of current value
                if (newValue.CompareTo(node.Keys[i]) < 0)
                {
                    return FindInsertionLeaf(node.Children[i], newValue);
                }
                //current value is grearer than new value
                //and current value is last element 

                if (node.KeyCount == i + 1)
                {
                    return FindInsertionLeaf(node.Children[i + 1], newValue);
                }
            }

            return node;
        }

        /// <summary>
        /// Insert and split recursively up until no split is required
        /// </summary>
        private void InsertAndSplit(ref BTreeNode<T> node, T newValue,
            BTreeNode<T> newValueLeft, BTreeNode<T> newValueRight)
        {
            //add new item to current node
            if (node == null)
            {
                node = new BTreeNode<T>(_maxKeysPerNode, null);
                Root = node;
            }

            //newValue have room to fit in this node
            //so just insert in right spot in asc order of keys
            if (node.KeyCount != _maxKeysPerNode)
            {
                InsertToNotFullNode(ref node, newValue, newValueLeft, newValueRight);
                return;
            }

            //if node is full then split node
            //and  then insert new median to parent.

            //divide the current node values + new Node as left and right sub nodes
            var left = new BTreeNode<T>(_maxKeysPerNode, null);
            var right = new BTreeNode<T>(_maxKeysPerNode, null);

            //median of current Node
            var currentMedianIndex = node.GetMedianIndex();

            //init currentNode under consideration to left
            var currentNode = left;
            var currentNodeIndex = 0;

            //new Median also takes new Value in to Account
            var newMedian = default(T);
            var newMedianSet = false;
            var newValueInserted = false;

            //keep track of each insertion
            var insertionCount = 0;

            //insert newValue and existing values in sorted order
            //to left and right nodes
            //set new median during sorting
            for (var i = 0; i < node.KeyCount; i++)
            {
                //if insertion count reached new median
                //set the new median by picking the next smallest value
                if (!newMedianSet && insertionCount == currentMedianIndex)
                {
                    newMedianSet = true;

                    //median can be the new value or node.keys[i] (next node key)
                    //whichever is smaller
                    if (!newValueInserted && newValue.CompareTo(node.Keys[i]) < 0)
                    {
                        //median is new value
                        newMedian = newValue;
                        newValueInserted = true;

                        if (newValueLeft != null)
                        {
                            SetChild(currentNode, currentNode.KeyCount, newValueLeft);
                        }

                        //now fill right node
                        currentNode = right;
                        currentNodeIndex = 0;

                        if (newValueRight != null)
                        {
                            SetChild(currentNode, 0, newValueRight);
                        }

                        i--;
                        insertionCount++;
                        continue;
                    }

                    //median is next node
                    newMedian = node.Keys[i];

                    //now fill right node
                    currentNode = right;
                    currentNodeIndex = 0;

                    continue;
                }

                //pick the smaller among newValue and node.Keys[i]
                //and insert in to currentNode (left and right nodes)
                //if new Value was already inserted then just copy from node.Keys in sequence
                //since node.Keys is already in sorted order it should be fine
                if (newValueInserted || node.Keys[i].CompareTo(newValue) < 0)
                {
                    currentNode.Keys[currentNodeIndex] = node.Keys[i];
                    currentNode.KeyCount++;

                    //if child is set don't set again
                    //the child was already set by last newValueRight or last node
                    if (currentNode.Children[currentNodeIndex] == null)
                    {
                        SetChild(currentNode, currentNodeIndex, node.Children[i]);
                    }

                    SetChild(currentNode, currentNodeIndex + 1, node.Children[i + 1]);
                }
                else
                {
                    currentNode.Keys[currentNodeIndex] = newValue;
                    currentNode.KeyCount++;

                    SetChild(currentNode, currentNodeIndex, newValueLeft);
                    SetChild(currentNode, currentNodeIndex + 1, newValueRight);

                    i--;
                    newValueInserted = true;
                }

                currentNodeIndex++;
                insertionCount++;
            }

            //could be that thew newKey is the greatest 
            //so insert at end
            if (!newValueInserted)
            {
                currentNode.Keys[currentNodeIndex] = newValue;
                currentNode.KeyCount++;

                SetChild(currentNode, currentNodeIndex, newValueLeft);
                SetChild(currentNode, currentNodeIndex + 1, newValueRight);
            }

            //insert overflow element (newMedian) to parent
            var parent = node.Parent;
            InsertAndSplit(ref parent, newMedian, left, right);
        }

        /// <summary>
        /// Insert to a node that is not full
        /// </summary>
        private static void InsertToNotFullNode(ref BTreeNode<T> node, T newValue,
            BTreeNode<T> newValueLeft, BTreeNode<T> newValueRight)
        {
            var inserted = false;

            //insert in sorted order
            for (var i = 0; i < node.KeyCount; i++)
            {
                if (newValue.CompareTo(node.Keys[i]) >= 0)
                {
                    continue;
                }

                InsertAt(node.Keys, i, newValue);
                node.KeyCount++;

                //Insert children if any
                SetChild(node, i, newValueLeft);
                InsertChild(node, i + 1, newValueRight);


                inserted = true;
                break;
            }

            //newValue is the greatest
            //element should be inserted at the end then
            if (inserted)
            {
                return;
            }

            node.Keys[node.KeyCount] = newValue;
            node.KeyCount++;

            SetChild(node, node.KeyCount - 1, newValueLeft);
            SetChild(node, node.KeyCount, newValueRight);
        }

        /// <summary>
        /// return the node containing max value which will be a leaf at the right most
        /// </summary>
        private static BTreeNode<T> FindMinNode(BTreeNode<T> node)
        {
            //if leaf return node
            return node.IsLeaf ? node : FindMinNode(node.Children[0]);
        }

        /// <summary>
        /// return the node containing max value which will be a leaf at the right most
        /// </summary>
        private static BTreeNode<T> FindMaxNode(BTreeNode<T> node)
        {
            //if leaf return node
            return node.IsLeaf ? node : FindMaxNode(node.Children[node.KeyCount]);
        }

        /// <summary>
        /// Balance a node which is short of Keys by rotations or merge
        /// </summary>
        private void Balance(BTreeNode<T> node)
        {
            if (node == Root || node.KeyCount >= _minKeysPerNode)
            {
                return;
            }

            var rightSibling = GetRightSibling(node);

            if (rightSibling != null
                && rightSibling.KeyCount > _minKeysPerNode)
            {
                LeftRotate(node, rightSibling);
                return;
            }

            var leftSibling = GetLeftSibling(node);

            if (leftSibling != null
                && leftSibling.KeyCount > _minKeysPerNode)
            {
                RightRotate(leftSibling, node);
                return;
            }

            if (rightSibling != null)
            {
                Sandwich(node, rightSibling);
            }
            else
            {
                Sandwich(leftSibling, node);
            }
        }

        /// <summary>
        ///  merge two adjacent siblings to one node
        /// </summary>
        private void Sandwich(BTreeNode<T> leftSibling, BTreeNode<T> rightSibling)
        {
            var separatorIndex = GetNextSeparatorIndex(leftSibling);
            var parent = leftSibling.Parent;

            var newNode = new BTreeNode<T>(_maxKeysPerNode, leftSibling.Parent);
            var newIndex = 0;

            for (var i = 0; i < leftSibling.KeyCount; i++)
            {
                newNode.Keys[newIndex] = leftSibling.Keys[i];

                if (leftSibling.Children[i] != null)
                {
                    SetChild(newNode, newIndex, leftSibling.Children[i]);
                }

                if (leftSibling.Children[i + 1] != null)
                {
                    SetChild(newNode, newIndex + 1, leftSibling.Children[i + 1]);
                }

                newIndex++;
            }

            //special case when left sibling is empty 
            if (leftSibling.KeyCount == 0 && leftSibling.Children[0] != null)
            {
                SetChild(newNode, newIndex, leftSibling.Children[0]);
            }

            newNode.Keys[newIndex] = parent.Keys[separatorIndex];
            newIndex++;

            for (var i = 0; i < rightSibling.KeyCount; i++)
            {
                newNode.Keys[newIndex] = rightSibling.Keys[i];

                if (rightSibling.Children[i] != null)
                {
                    SetChild(newNode, newIndex, rightSibling.Children[i]);
                }

                if (rightSibling.Children[i + 1] != null)
                {
                    SetChild(newNode, newIndex + 1, rightSibling.Children[i + 1]);
                }

                newIndex++;
            }

            //special case when left sibling is empty 
            if (rightSibling.KeyCount == 0 && rightSibling.Children[0] != null)
            {
                SetChild(newNode, newIndex, rightSibling.Children[0]);
            }

            newNode.KeyCount = newIndex;
            SetChild(parent, separatorIndex, newNode);
            RemoveAt(parent.Keys, separatorIndex);
            parent.KeyCount--;

            RemoveChild(parent, separatorIndex + 1);


            if (parent.KeyCount == 0
                && parent == Root)
            {
                Root = newNode;
                Root.Parent = null;

                if (Root.KeyCount == 0)
                {
                    Root = null;
                }

                return;
            }

            if (parent.KeyCount < _minKeysPerNode)
            {
                Balance(parent);
            }
        }

        /// <summary>
        /// do a right rotation 
        /// </summary>
        private static void RightRotate(BTreeNode<T> leftSibling, BTreeNode<T> rightSibling)
        {
            var parentIndex = GetNextSeparatorIndex(leftSibling);

            InsertAt(rightSibling.Keys, 0, rightSibling.Parent.Keys[parentIndex]);
            rightSibling.KeyCount++;

            InsertChild(rightSibling, 0, leftSibling.Children[leftSibling.KeyCount]);

            rightSibling.Parent.Keys[parentIndex] = leftSibling.Keys[leftSibling.KeyCount - 1];

            RemoveAt(leftSibling.Keys, leftSibling.KeyCount - 1);
            leftSibling.KeyCount--;

            RemoveChild(leftSibling, leftSibling.KeyCount + 1);
        }

        /// <summary>
        /// do a left rotation
        /// </summary>
        private static void LeftRotate(BTreeNode<T> leftSibling, BTreeNode<T> rightSibling)
        {
            var parentIndex = GetNextSeparatorIndex(leftSibling);
            leftSibling.Keys[leftSibling.KeyCount] = leftSibling.Parent.Keys[parentIndex];
            leftSibling.KeyCount++;

            SetChild(leftSibling, leftSibling.KeyCount, rightSibling.Children[0]);


            leftSibling.Parent.Keys[parentIndex] = rightSibling.Keys[0];

            RemoveAt(rightSibling.Keys, 0);
            rightSibling.KeyCount--;

            RemoveChild(rightSibling, 0);
        }

        /// <summary>
        /// Locate the node in which the item to delete exist
        /// </summary>
        private static BTreeNode<T> FindDeletionNode(BTreeNode<T> node, T value)
        {
            //if leaf then its time to insert
            if (node.IsLeaf)
            {
                for (var i = 0; i < node.KeyCount; i++)
                {
                    if (value.CompareTo(node.Keys[i]) == 0)
                    {
                        return node;
                    }
                }
            }
            else
            {
                //if not leaf then drill down to leaf
                for (var i = 0; i < node.KeyCount; i++)
                {
                    if (value.CompareTo(node.Keys[i]) == 0)
                    {
                        return node;
                    }

                    //current value is less than new value
                    //drill down to left child of current value
                    if (value.CompareTo(node.Keys[i]) < 0)
                    {
                        return FindDeletionNode(node.Children[i], value);
                    }
                    //current value is grearer than new value
                    //and current value is last element 

                    if (node.KeyCount == i + 1)
                    {
                        return FindDeletionNode(node.Children[i + 1], value);
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Get next key separator index after this child Node in parent 
        /// </summary>
        private static int GetNextSeparatorIndex(BTreeNode<T> node)
        {
            var parent = node.Parent;

            if (node.Index == 0)
            {
                return 0;
            }

            if (node.Index == parent.KeyCount)
            {
                return node.Index - 1;
            }

            return node.Index;
        }

        /// <summary>
        /// get the right sibling node
        /// </summary>
        private static BTreeNode<T> GetRightSibling(BTreeNode<T> node)
        {
            var parent = node.Parent;

            return node.Index == parent.KeyCount ? null : parent.Children[node.Index + 1];
        }

        /// <summary>
        /// get left sibling node
        /// </summary>
        private static BTreeNode<T> GetLeftSibling(BTreeNode<T> node)
        {
            return node.Index == 0 ? null : node.Parent.Children[node.Index - 1];
        }

        private static void SetChild(BTreeNode<T> parent, int childIndex, BTreeNode<T> child)
        {
            parent.Children[childIndex] = child;

            if (child == null)
            {
                return;
            }

            child.Parent = parent;
            child.Index = childIndex;
        }

        private static void InsertChild(BTreeNode<T> parent, int childIndex, BTreeNode<T> child)
        {
            InsertAt(parent.Children, childIndex, child);

            if (child != null)
            {
                child.Parent = parent;
            }

            //update indices
            for (var i = childIndex; i <= parent.KeyCount; i++)
            {
                if (parent.Children[i] != null)
                {
                    parent.Children[i].Index = i;
                }
            }
        }

        private static void RemoveChild(BTreeNode<T> parent, int childIndex)
        {
            RemoveAt(parent.Children, childIndex);

            //update indices
            for (var i = childIndex; i <= parent.KeyCount; i++)
            {
                if (parent.Children[i] != null)
                {
                    parent.Children[i].Index = i;
                }
            }
        }

        /// <summary>
        /// Shift array right at index to make room for new insertion
        /// And then insert at index
        /// Assumes array have atleast one empty index at end
        /// </summary>
        private static void InsertAt<TS>(TS[] array, int index, TS newValue)
        {
            //shift elements right by one indice from index
            Array.Copy(array, index, array, index + 1, array.Length - index - 1);
            //now set the value
            array[index] = newValue;
        }

        /// <summary>
        /// Shift array left at index    
        /// </summary>
        private static void RemoveAt<TS>(TS[] array, int index)
        {
            //shift elements right by one indice from index
            Array.Copy(array, index + 1, array, index, array.Length - index - 1);
        }

        private class DelegateComparer : IValueComparer<T>
        {
            public DelegateComparer(Func<T, int> comparer)
            {
                _comparer = comparer;
            }

            /// <inheritdoc />
            public int CompareTo(T t)
            {
                return _comparer(t);
            }

            private readonly Func<T, int> _comparer;
        }

        private class DefaultComparer : IValueComparer<T>
        {
            public DefaultComparer(T compareObject)
            {
                CompareObject = compareObject;
            }

            /// <inheritdoc />
            public int CompareTo(T t)
            {
                return CompareObject.CompareTo(t);
            }

            private T CompareObject { get; }
        }
    }

    /// <summary>
    /// abstract node shared by both B and B+ tree nodes
    /// so that we can use this for common tests across B and B+ tree
    /// </summary>
    internal abstract class BNode<T> where T : IComparable
    {
        internal BNode(int maxKeysPerNode)
        {
            Keys = new T[maxKeysPerNode];
        }

        /// <summary>
        /// Array Index of this node in parent's Children array
        /// </summary>
        internal int Index { set; get; }

        internal T[] Keys { get; }
        internal int KeyCount { get; set; }

        //for common unit testing across B and B+ tree
        internal abstract BNode<T> GetParent();
        internal abstract BNode<T>[] GetChildren();

        internal int GetMedianIndex()
        {
            return (KeyCount / 2) + 1;
        }
    }

    internal class BTreeNode<T> : BNode<T> where T : IComparable
    {
        internal BTreeNode(int maxKeysPerNode, BTreeNode<T> parent)
            : base(maxKeysPerNode)
        {
            Parent = parent;
            Children = new BTreeNode<T>[maxKeysPerNode + 1];
        }

        internal BTreeNode<T> Parent { get; set; }
        internal BTreeNode<T>[] Children { get; }

        internal bool IsLeaf => Children[0] == null;

        /// <summary>
        /// For shared test method accross B and B+ tree
        /// </summary>
        internal override BNode<T> GetParent()
        {
            return Parent;
        }

        /// <summary>
        /// For shared test method accross B and B+ tree
        /// </summary>
        internal override BNode<T>[] GetChildren()
        {
            return Children;
        }
    }

    internal class BTreeEnumerator<T> : IEnumerator<T> where T : IComparable
    {
        internal BTreeEnumerator(BTreeNode<T> root)
        {
            _root = root;
        }

        public bool MoveNext()
        {
            if (_root == null)
            {
                return false;
            }

            if (_progress == null)
            {
                _current = _root;
                _progress = new Stack<BTreeNode<T>>(_root.Children.Take(_root.KeyCount + 1).Where(x => x != null));
                return _current.KeyCount > 0;
            }

            if (_current != null && _index + 1 < _current.KeyCount)
            {
                _index++;
                return true;
            }

            if (_progress.Count > 0)
            {
                _index = 0;

                _current = _progress.Pop();

                foreach (var child in _current.Children.Take(_current.KeyCount + 1).Where(x => x != null))
                {
                    _progress.Push(child);
                }

                return true;
            }

            return false;
        }

        public void Reset()
        {
            _progress = null;
            _current = null;
            _index = 0;
        }

        object IEnumerator.Current => Current;

        public T Current => _current.Keys[_index];

        public void Dispose()
        {
            _progress = null;
        }

        private readonly BTreeNode<T> _root;

        private BTreeNode<T> _current;
        private int _index;
        private Stack<BTreeNode<T>> _progress;
    }

WPF 获取本机所有字体拿到每个字符的宽度和高度

Thu, 03 Dec 2020 12:27:50 +0000

本文主要采用 GlyphTypeface 类尝试获取每个字符的宽度和高度的值，尽管这个方法和最终 WPF 布局使用的文本的宽度和高度是不相同的，但是依然可以作为参考

获取系统字体文件夹的文件

系统字体文件夹放在 @"C:\Windows\Fonts" 本文不讨论用户的系统盘放在其他盘里面

使用 Directory.GetFiles 可以获取所有字体文件

   var fileList = Directory.GetFiles(@"C:\Windows\Fonts", "*.ttf");

通过 *.ttf 可以限定只获取 ttf 文件

创建 GlyphTypeface 对象

通过 Uri 传入文件路径可以创建

            foreach (var font in fileList)
            {
                var uri = new Uri(font);
                GlyphTypeface g = new GlyphTypeface(uri);
            }

获取定义的字符的宽度和高度比例

需要注意的是一个字体文件也许会包含多个不同的 FontFamily 因此 FontFamily 创建的时候还需要传入名字进去

            foreach (var font in fileList)
            {
                var uri = new Uri(font);
                GlyphTypeface g = new GlyphTypeface(uri);

                var charList = g.AdvanceHeights.Keys;

                foreach (var fontName in g.FamilyNames.Values)
                {
                    var fontFamily = new FontFamily(uri, fontName);

                    var fontSize = 10;

                    foreach (var c in charList)
                    {
                        var w = g.AdvanceWidths[c];
                        var h = g.AdvanceHeights[c];

                    }
                }
            }

这里拿到的 w 和 h 就是宽度和高度比例

注意，这个值和最终文本渲染字符大小没有很本质的关系

以下是我提供的一些测试的值，我隐藏了最终渲染字符的大小计算方法，此方法是团队内部文本框3.0 计算方法，此库可以做出比 PPT 文本框差的多的效果

		size	{1.95666666666667,11.84}	System.Windows.Size
		w	0.466796875	double
		h	0.9443359375	double
		hw	6.0511073253833052	double
		wh	0.165259009009009	double

其中 hw 和 wh 的计算方法如下

var hw = size.Height / size.Width;
var wh = size.Width / size.Height;

GlyphTypeface Class (System.Windows.Media)

如果需要设置 FontWeight 等影响，可以使用先创建 Typeface 的方法，请看下面代码

var typeface = new Typeface(fontFamily, fontStyle, fontWeight, FontStretches.Normal);
typeface.TryGetGlyphTypeface(out GlyphTypeface glyph);
// 如果 TryGetGlyphTypeface 创建失败，那么就是缺少字体等，可以尝试使用微软雅黑等默认字体

上面代码获取 glyph 就可以使用和上文相同的方法获取文本字符宽度

C# CLR 聊聊对象的内存布局一个空对象占用多少内存

Thu, 03 Dec 2020 12:27:50 +0000

在 C# 中的对象大概可以分为三个不同的类型，包括值类型、引用类型和其他类型。本文主要讨论的是引用类型对内存空间的占用情况。在讨论开始之前我想问问大家，一个空的对象会占用多少内存空间？当然这个问题本身就有问题，因为没有区分栈空间与堆空间的内存空间。其实小伙伴会发现这不是一个好回答的问题，因为似乎没有一个可以认为标准的标准答案。请让我为你详细聊聊对象的内存布局

在开始之前，先广告一下农夫的书《.NET Core底层入门》这本书写的非常底层，内存这一篇章写的特别棒。如果看本文之后觉得更加迷糊了，请看农夫大大的书

开始的问题其实问题本身不算对，为什么呢？因为咱 .NET 可以在 x86 和 x64 和 ARM 等运行，而运行时包括了 .NET Framework 和 .NET Core 还有 mono 和 .NET Micro Framework 等，这些表现有稍微的不同。至少有趣的 .NET Framework 有超级多个不同的版本，本考古学家也不能确定这些版本之间是否存在差异，只是听小伙伴吹过。而 .NET Micro Framework (NETMF) 本身就是设计在极度小的内存下运行，里面对引用类型做了很多有趣的优化，而我仅仅知道有优化，具体做了什么就不知道了，也不想知道

而 .NET Core 下还有一个有趣的技术叫 .NET Native 通过这个有趣的技术可以极大混淆引用类型和值类型的概念，这个技术底层没啥文档，需要自己去翻代码。是否有差别还请大佬们教教我

本文仅能告诉大家的只有是 .NET Core 3.1 在 x86 和 x64 下的引用类型的内存占用情况

在我写本文的时候，实际上是很慌的，有太多的分支我没有理清楚。在重新阅读了农夫的《.NET Core底层入门》和《CLR via C#》和 https://github.com/dotnet/runtime 的很小一部分代码之后，稍微有点底气来和大家聊聊

以下情况是不在本文讨论范围

.NET Framework
.NET Micro Framework
Mono
IL2CPP
.NET Native
WASM
ARM
ARM64
AOT
Itanium

在说到内存优化等，这里说的内存默认都是说堆空间的内存空间。为什么不提到栈空间的内存空间？因为栈空间默认是固定大小（.NET Core）也就是用或不用都需要这么大的空间。而栈空间会随方法的执行结束自动清空方法占用的栈空间，这部分就包含了局部变量占用的栈空间。因此使用栈空间不存在内存回收压力，也不存在内存分配的性能问题。但栈空间是很小的一段空间，一旦用完将会抛出堆栈溢出

因此本文所说的空对象占用的内存空间仅说占用的堆空间的内存空间，这不意味着本文说的对象仅仅是引用类型对象，此时值类型对象也是能包含的。但可惜的是我不准备直接讨论值类型对象在堆空间的情况

在开始之前，请让咱忽略吃鸡蛋应该从大的一头开始吃还是从小的一头开始吃的问题，从 x86 和 x64 开始比较好，这是从鸡蛋小的一头开始吃的故事。等等，怎么到了吃鸡蛋的时候了？其实我说的是大端和小端的问题哈。在 .NET Core 下，在 x86 与 x86-64 平台储存整数使用的是 Little Endian 小端法，而在 ARM 与 ARM64 平台储存整数使用的是 Big Endian 大端法。具体这两个存储方法有啥不同，请自行搜寻或看农夫的《.NET Core底层入门》的第7章第二节

试试在 VS 里面新建一个控制台程序，在里面创建一个对象，看看他的内存布局是如何的

        static void Main(string[] args)
        {
            var obj = new object();
        }

在 obj 创建完成的下一行添加断点，运行此断点则内存中存在创建完成的 obj 对象

那如何在 VS 里面查看某个对象的内存？点击调试窗口内存，在内存窗口里面，可以打开4个不同的内存窗口，同时看4个不同的内存。默认打开内存1窗口就足够了。这里的内存4个窗口只是提供了4个窗口可以查看不同的内容，能看到的内存是相同的内存

在内存里面查看某个对象的内存的方法是输入这个对象的变量名

按下回车之后将会自动将变量名修改这个变量对象的内存的地址

这个代表什么意思呢？尽管可以看到内存里面的值，但是依然需要一点文档的辅助，才能了解含义。按照程序运行的原理，内存的值如果脱离了数据结构，那么将没有任意意义，和乱码是相同的。但是有了对应的数据结构，那么将可以解析出里面的含义

从农夫的《.NET Core底层入门》书中可以看到，引用类型对象的值由以下三个部分组成

对象头 (Object Header)
类型信息 (MethodTable Pointer)
各个字段的内容

对象头包含标志与同步块索引 (SyncBlock Index) 等数据，在 32 位平台上占用 4 个字节，在 64 位平台上占用 8 个字节但只有后 4 个字节会使用。类型信息是一个内存地址，指向 .NET 运行时内部保存的类型数据 (类型是 MethodTable)，在 32 位平台上占用 4 个字节，在 64 位平台上占用 8 个字节

而默认运行的控制台是使用 AnyCpu 执行的，而我的系统是 x64 系统，换句话说，此时的 .NET 程序是 x64 程序。在 x64 程序中，根据上面描述可以知道，类型信息占用了 8 个字节

又根据 .NET 中引用类型对象本身储存的内存地址指向类型信息的开始，而对象头会在 对象内存地址 - 4 的位置，可以了解到，当前内存里面显示的内容只是类型信息 (MethodTable Pointer) 的值

因为咱创建的是一个空的 object 对象，因此不包含任何字段，可以看到的内容如下

0x00000231B98AAD70  e8 0a 2e 5c fc 7f 00 00  ?..\?...
0x00000231B98AAD78  00 00 00 00 00 00 00 00  ........
0x00000231B98AAD80  00 00 00 00 00 00 00 00  ........
0x00000231B98AAD88  00 00 00 00 00 00 00 00  ........

而对象头开始的地方是在 对象内存地址 - 4 的地址，可以在内存地址栏添加上 -4 如下图所示看到对象头的值

为什么在 对象内存地址 - 4 的地址就是对象头的值？在 x64 和 x86 是相同的？没错，如上面所说，尽管对象头会在 x64 占用 8 个字节，但是只有后 4 个字节会使用，因此 -4 就能看到对象头了

那么如何校验一下关于对象头和类型信息的值，拿到的是对的值？可以在控制台里面多创建几个空对象，根据相同类型的对象的类型信息一定相同的原理，可以判断咱刚才拿到的类型信息是否是对的。如果多个相同的 object 的类型信息都是相同的值，那么证明多个相同的 object 类型的对象使用了指向相同的内存空间的类型信息

        static void Main(string[] args)
        {
            var obj = new object();
            var obj1 = new object();
            var obj2 = new object();
            var obj3 = new object();
        }

现在创建了 4 个 object 对象了，在执行代码的最后一句之后添加断点，然后运行

理论上此时的应用程序将会将这几个对象做连续的分配，因为此时的堆空间还没有内容

咱先输入 obj 到内存窗口的地址栏，我可以看到以下信息

0x000002532039AD70  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x000002532039AD78  00 00 00 00 00 00 00 00  ........
0x000002532039AD80  00 00 00 00 00 00 00 00  ........
0x000002532039AD88  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x000002532039AD90  00 00 00 00 00 00 00 00  ........
0x000002532039AD98  00 00 00 00 00 00 00 00  ........
0x000002532039ADA0  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x000002532039ADA8  00 00 00 00 00 00 00 00  ........
0x000002532039ADB0  00 00 00 00 00 00 00 00  ........
0x000002532039ADB8  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x000002532039ADC0  00 00 00 00 00 00 00 00  ........
0x000002532039ADC8  00 00 00 00 00 00 00 00  ........

可以看到有相同的 e8 0a 96 60 fc 7f 00 00 这一段二进制值，那么这应该就是类型信息所在的地址了。尝试看一下这个地址的值

根据在 x86 和 x64 下是小端显示的，也就是 e8 0a 96 60 fc 7f 00 00 需要按照字节反过来写才是十六进制的值，反过来写是 0x00007ffc60960ae8 相当于去掉空格，然后两个字符两个字符，从后到前写一次

打开另一个内存窗口，输入 0x00007ffc60960ae8 到地址栏，就可以看到类型信息的内存值

我这里截取一部分内容放在下面，用于证明这就是类型信息的内存值

0x00007FFC60960AE8  00 02 00 00 18 00 00 00  ........
0x00007FFC60960AF0  08 40 7d 00 04 00 00 00  .@}.....
0x00007FFC60960AF8  00 00 00 00 00 00 00 00  ........
0x00007FFC60960B00  20 40 86 60 fc 7f 00 00   @?`?...
0x00007FFC60960B08  50 0b 96 60 fc 7f 00 00  P.?`?...
0x00007FFC60960B10  18 bb 98 60 fc 7f 00 00  .??`?...
0x00007FFC60960B18  88 00 99 60 fc 7f 00 00  ?.?`?...
0x00007FFC60960B20  00 00 00 00 00 00 00 00  ........

如何证明这就是类型信息的内存值？其实尝试多次执行控制台，看看每次 obj 对应的类型信息指针指向的内存地址的值是不是和当前的相同，如果相同，那么证明这就是类型信息的值了

如上述测试，咱可以了解到在 x64 下一个 object 空对象在内存中占用的 byte 数量是 3 * 8 个字节大小

8 字节表示对象头
8 字节表示类型信息的内存地址的值
8 字节用于 object 的占坑信息（字段内存对齐）

上面是不是歪楼了？什么是占坑信息？其实就是本来放字段的空间。咱试试在某个类里面方一个简单的 int 在里面填写特殊的数值，用来找到内存的存放这个字段的空间

    class Program
    {
        static void Main(string[] args)
        {
            var obj = new object();
            var obj1 = new object();
            var obj2 = new object();
            var obj3 = new object();

            var p1 = new Program();
        }

        private uint _foo = 0xFF020306;
    }

如上面代码在 Program 类添加 _foo 字段，然后创建出这个对象，理论上此时这个对象应该是在所有 object 对象的后面。注意，在内存里面有很少对象的时候确实可以这么说，后创建的对象就刚好放在新创建的对象后面。如果内存里面存在碎片的时候，上面这句话就不一定对了。不过咱的测试程序足够简单，因此这句话还是对的

咱继续在内存地址栏输入 obj 按下回车，此时显示的内存就是这几个对象的内存

0x000002961B1CAD70  e8 0a 94 60 fc 7f 00 00  ?.?`?...
0x000002961B1CAD78  00 00 00 00 00 00 00 00  ........
0x000002961B1CAD80  00 00 00 00 00 00 00 00  ........
0x000002961B1CAD88  e8 0a 94 60 fc 7f 00 00  ?.?`?...
0x000002961B1CAD90  00 00 00 00 00 00 00 00  ........
0x000002961B1CAD98  00 00 00 00 00 00 00 00  ........
0x000002961B1CADA0  e8 0a 94 60 fc 7f 00 00  ?.?`?...
0x000002961B1CADA8  00 00 00 00 00 00 00 00  ........
0x000002961B1CADB0  00 00 00 00 00 00 00 00  ........
0x000002961B1CADB8  e8 0a 94 60 fc 7f 00 00  ?.?`?...
0x000002961B1CADC0  00 00 00 00 00 00 00 00  ........
0x000002961B1CADC8  00 00 00 00 00 00 00 00  ........
0x000002961B1CADD0  88 1b a2 60 fc 7f 00 00  ?.?`?...
0x000002961B1CADD8  06 03 02 ff 00 00 00 00  ........

请先注意第一行，可以看到此时的类型信息的内存地址的值和之前一次运行的不相同了，这次的值是 e8 0a 94 60 fc 7f 00 00 咱先尝试在另一个内存窗口输入这个地址 0x00007ffc60940ae8 看看类型信息的内存

大概截取一下内容

0x00007FFC60940AE8  00 02 00 00 18 00 00 00  ........
0x00007FFC60940AF0  08 40 7d 00 04 00 00 00  .@}.....
0x00007FFC60940AF8  00 00 00 00 00 00 00 00  ........
0x00007FFC60940B00  20 40 84 60 fc 7f 00 00   @?`?...
0x00007FFC60940B08  50 0b 94 60 fc 7f 00 00  P.?`?...
0x00007FFC60940B10  18 bb 96 60 fc 7f 00 00  .??`?...
0x00007FFC60940B18  88 00 97 60 fc 7f 00 00  ?.?`?...
0x00007FFC60940B20  00 00 00 00 00 00 00 00  ........

可以和上面的值对比一下，大部分都是相同的，然后依然有几个歪楼的值，咱这里就先忽略

好接下来找到刚才定义的 _foo 的值，咱给他的是 0xFF020306 而根据小端的写法，将会是如下的值 06 03 02 ff 没错，刚好放在了最后一行里面

0x000002961B1CADD8  06 03 02 ff 00 00 00 00  ........

复习一下，在 C# 里面无论在 x86 还是 x64 下，每个 int 都占领 4 个字节

如果觉得不够直观，咱修改一下对象创建的顺序，请看代码

        static void Main(string[] args)
        {
            var obj = new object();
            var p1 = new Program();
            var obj1 = new object();
            var obj2 = new object();
            var obj3 = new object();
        }

此时在内存窗口输入 obj 按下回车可以看到的值如下

0x00000106BFF2AD68  00 00 00 00 00 00 00 00  ........
0x00000106BFF2AD70  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x00000106BFF2AD78  00 00 00 00 00 00 00 00  ........
0x00000106BFF2AD80  00 00 00 00 00 00 00 00  ........
0x00000106BFF2AD88  88 1b a4 60 fc 7f 00 00  ?.?`?...
0x00000106BFF2AD90  06 03 02 ff 00 00 00 00  ........
0x00000106BFF2AD98  00 00 00 00 00 00 00 00  ........
0x00000106BFF2ADA0  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x00000106BFF2ADA8  00 00 00 00 00 00 00 00  ........
0x00000106BFF2ADB0  00 00 00 00 00 00 00 00  ........
0x00000106BFF2ADB8  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x00000106BFF2ADC0  00 00 00 00 00 00 00 00  ........
0x00000106BFF2ADC8  00 00 00 00 00 00 00 00  ........
0x00000106BFF2ADD0  e8 0a 96 60 fc 7f 00 00  ?.?`?...
0x00000106BFF2ADD8  00 00 00 00 00 00 00 00  ........

尽管 _foo 是一个int只占用了 4 个字节，但是根据字节对齐，后面的 4 个字节依然空闲不用。我也就是将他算在了这个对象上面

看到这里小伙伴是不是能够大概知道为什么这个问题不好回答了，一个空的对象必定占的内存一定包括对象头（syncblk信息）和类型信息，而后面的字段的空间就有点争议了，因为不确定是否要将占坑的加上去。尽管这个空间不是我这个对象用的，但是其他对象也不用这部分空间

以上是 x64 下的对象内存布局，大概可以认定答案是一个空对象占用了3*8个字节

那么 x86 下的对象会如何？修改一下配置，让控制台在 x86 下执行

根据农夫大大的书可以了解在 x86 下的对象头和类型信息都是占 4 个字节。而此时对象的占坑的字段也是 4 个字节，因此一个对象占用的内存是 3*4 个字节

运行刚才的程序，继续在内存窗口输入 obj 按下回车，此时可以看到的内存信息如下图。当然你看到的值应该和我看到的不相同

0x057EA794  9c 00 64 05 00 00 00 00  ?.d.....
0x057EA79C  00 00 00 00 e8 eb df 07  ....???.
0x057EA7A4  06 03 02 ff 00 00 00 00  ........
0x057EA7AC  9c 00 64 05 00 00 00 00  ?.d.....
0x057EA7B4  00 00 00 00 9c 00 64 05  ....?.d.
0x057EA7BC  00 00 00 00 00 00 00 00  ........
0x057EA7C4  9c 00 64 05 00 00 00 00  ?.d.....
0x057EA7CC  00 00 00 00 00 00 00 00  ........

这里的 9c 00 64 05 就是 Object 的类型信息，而后面的 00 00 00 00 就是占坑的字段空间。第一行是因为 obj 指向的内存是对象的类型信息，而对象的对象头信息是放在类型信息前面，因此在上图就没有看到第一个对象的对象头

大概看到这里，相信小伙伴也能理解一个空对象在占用了多少堆内存空间了

那么是不是有小伙伴好奇空对象可以在栈空间占用多少内存？回答是0到爆栈这么大，看你如何用

WPF 获取某个窗口的所有子窗口

Thu, 03 Dec 2020 12:27:50 +0000

如果不用到 Win32 方法，可以尝试遍历所有窗口获取 Owner 判断，不过此方法仅仅适合只有一个主线程

通过 Win32 的 EnumChildWindows 可以拿到某个窗口句柄的所有子窗口，大概用法如下，先定义一个辅助类

public class WindowHandleInfo
{
    public static List<IntPtr> GetAllChildHandles(IntPtr handle)
    {
        List<IntPtr> childHandles = new List<IntPtr>();
 
        GCHandle gcChildhandlesList = GCHandle.Alloc(childHandles);
        IntPtr pointerChildHandlesList = GCHandle.ToIntPtr(gcChildhandlesList);
 
        try
        {
            EnumWindowProc childProc = new EnumWindowProc(EnumWindow);
            EnumChildWindows(handle, childProc, pointerChildHandlesList);
        }
        finally
        {
            gcChildhandlesList.Free();
        }
 
        return childHandles;
    }

    private delegate bool EnumWindowProc(IntPtr hwnd, IntPtr lParam);
 
    [DllImport("user32")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool EnumChildWindows(IntPtr window, EnumWindowProc callback, IntPtr lParam);
 
    private static bool EnumWindow(IntPtr hWnd, IntPtr lParam)
    {
        GCHandle gcChildhandlesList = GCHandle.FromIntPtr(lParam);
 
        if (gcChildhandlesList == null || gcChildhandlesList.Target == null)
        {
            return false;
        }
 
        List<IntPtr> childHandles = (List<IntPtr>) gcChildhandlesList.Target;
        childHandles.Add(hWnd);
 
        return true;
    }
}

使用方法是先拿到窗口的句柄，然后传入 GetAllChildHandles 方法，就可以拿到所有子窗口的句柄

            var windowInteropHelper = new WindowInteropHelper(window);
            var hwnd = windowInteropHelper.Handle;
            var childWindowList = WindowHandleInfo.GetAllChildHandles(hwnd);

PINVOKE: Getting all child handles of window · Software adventures and thoughts

使用 EnumWindows 找到满足你要求的窗口 - walterlv

C# dotnet WeakLazy 弱引用的延迟初始化实现方法

Thu, 03 Dec 2020 12:27:50 +0000

本文来告诉大家如何实现一个 WeakLazy 方法

代码很简单，请看代码

    class WeakLazy<T> where T : class, new()
    {
        WeakReference<T> _instance = new WeakReference<T>(null);
        public T Value
        {
            get
            {
                lock (_instance)
                {
                    T value;
                    if (!_instance.TryGetTarget(out value))
                    {
                        value = new T();
                        _instance.SetTarget(value);
                    }
                    return value;
                }
            }
        }
    }

这样就能做到一个简单的缓存

用自动机的思想说明时间断片是无法感知的

Thu, 03 Dec 2020 12:27:50 +0000

用自动机可以模拟出一个世界，虽然这个世界是虚拟的，但这个世界里面将会根据基础的自动机规则自动推算出很多有趣的规则。同时也能很简单理解在自动机模拟的世界里面，在这个世界里面的生物是无法感知时间断片的

我不是物理学家，本文也是不是任何证明现实世界时间相关的文章。但我是计算机的砖家，搬了很多年的砖也知道在计算机里面可以简单做出一个世界，本文就是说明在自动机模拟出来的世界里面的生物是无法感知时间断片的，也无法测量

从我的上篇博客自动机告诉了大家如何创建一个自动机的世界，以下为一个创建自动机世界的方法，创建规则如下

在一个有限的二维布尔数组里面，以 true 代表存活
不断根据算法规则遍历数组，同时创建出新的相同大小的数组用于迭代
新创建的数组将根据旧数组的数据按照一定的算法更新数组每个元素的值

从上层看，可以认为我有一个数组，但这个数组的元素会跟随时间进行变化。虽然底层说的是使用两个数组，但实际上可以从上层上看到的只有一个数组，因为新创建的数组就替换旧的数组。将数组作为一张图片，每个元素具有固定的宽度和高度，里面的元素按照布尔值给不同的颜色，就可以画出自动机的世界，这是一个二维的世界

那么新数组创建的算法可以怎么选？下面是一个简单的计算方法，设定每次更新新数组就成为新的回合开始，每个数组里面的元素称为 Cell 而根据布尔值状态可以认定为 Cell 的存活或不存活，那么创建自动机世界只需要三条规则

在 Cell 周围有两个或三个邻居存活，他就可以存活。这里的周围指的是将二维数组放在二维平面对应的元素的周围的元素
如果 Cell 已经不存活，但他周围有三个邻居，于是他就可以出生
在 Cell 周围，如果有超过三个以上的邻居，他就因为太拥挤而不存活。如果有小于两个邻居存活，他因为他孤单而不存活

简单按照颜色黑色和白色，同时每个格子表示一个数组的元素，那么运行自动机世界可以看到下图

上面是刚好满足以上条件 1 的静态图，也就是随着数组的迭代也就是回合数的变化，这些自动机世界里面的图案是不会发生更改的。但下面的图片将会随着回合数的变化，进行循环变化

根据这个规则，这个世界的驱动是随着时间更改二维布尔数据而让这个世界继续往下走。而这里的随着时间更改的时间却是咱计算机的时间。意味着咱的计算机配置不错，可以一秒跑一遍，让自动机推进。而如果我打开了 QQ 电脑就卡了，此时需要10秒才能跑一遍。而对于没有参照物的自动机里面的世界，是无法知道现在这个自动机的时间流速和计算机时间流速的对比的。甚至，我需要断电了，我将数据保存起来，等到我下一次开机才继续跑。那么自动机里面的生物依然会认为自己的时间还在继续走，不会感知到我曾经断电了

可怕的是我一次断电的时候，我的电脑被了，数据丢了。此时意味着这个自动机的世界没有下一个时间了。也就是自动机里面的杞人可能担忧的是没有下一秒，时间就此结束

而如果我的电脑只是被砸坏了，数据有点损坏，那么自动机里面的生物也许会发现有很多自相矛盾的历史事件，却很难意识到某个时间自动机的世界就被更改数据了

本文所说仅仅是自动机的世界，而不是说现实的世界，请不要认为现实的世界也是这个样子。因为我认为也许在很长的时间，都不会存在时间旅行的技术，则为什么我找不到未来过来的东西

只要设计能进行时间旅行，那么瞬间技术和文化将会爆掉。原因是我时间推进一年，此时将这一年的知识拿回到上一年，于是上一年就拥有了一年的技术。然后递归，不断推进下一年，回到上一年，直到无法消化这部分技术

更多自动机博客请看

用自动机的思想说明光速

WPF 获取进程启动到当前现在的时间

Thu, 03 Dec 2020 12:27:50 +0000

从应用程序线程创建现在的时间可以通过 Process 类的 StartTime 属性获取，也就是其实这个方法不局限 WPF 可用，任何 dotnet 应用都能此方法

通过 Process.GetCurrentProcess().StartTime 可以拿到进程启动时间，而通过 DateTime.Now 可以获取当前的时间

使用下面代码可以知道进程启动到现在的秒数

(DateTime.Now - Process.GetCurrentProcess().StartTime).TotalSeconds

dotnet 字典类找不到 TryAdd 方法

Thu, 03 Dec 2020 12:27:50 +0000

我在给 dotnet 的 runtime 仓库提PR时，小伙伴告诉我可以使用 TryAdd 方法减少判断，但是我修改这个代码发现 100 个自动化测试都失败了，都告诉我没有找到这个方法

在这个更改 https://github.com/dotnet/runtime/pull/37041 有小伙伴告诉我可以使用 TryAdd 方法减少判断，我添加之后发现差不多 100 个自动化测试都失败，提示下面代码

'Dictionary<string, string>' does not contain a definition for 'TryAdd' and no accessible extension method 'TryAdd' accepting a first argument of type

原因是 Microsoft.Extensions.Configuration.CommandLine 这个库使用了 dotnet standard 2.0 版本

  <PropertyGroup>
    <TargetFrameworks>netstandard2.0;</TargetFrameworks>
    <EnableDefaultItems>true</EnableDefaultItems>
  </PropertyGroup>

而 TryAdd 方法是在 .NET Standard 2.1 才添加的，也就是 2.0 是没有这个方法

Dictionary<TKey,TValue>.TryAdd(TKey, TValue) Method (System.Collections.Generic)

ASP.NET Core 将文件夹内容输出为压缩包文件方法

Thu, 03 Dec 2020 12:27:50 +0000

本文主要是告诉大家一个省内存的方法，将整个文件夹的内容作为一个压缩包输出，但是实际上没有申请那么多的内存，也不需要升级创建一个压缩包文件。原理是通过逐个读文件然后按照压缩包格式输出

在每个请求的方法可以拿到 HttpContext 属性，通过这个属性拿到 Response 属性，在这里可以使用 BodyWriter 属性，在这个属性里面写入的内容将会被客户端下载

而这个属性可以作为 Stream 请看下面代码

     using var stream = HttpContext.Response.BodyWriter.AsStream();

在 .NET 中可以通过 ZipArchive 将一个文件夹的文件按照压缩文件格式写入，还可以设置压缩的压缩率等，可以设置文件所在文件夹的路径

通过在这个 stream 创建一个 ZipArchive 类，然后在这个类里面创建文件的方法就可以做到不断向客户端发送文件，发送的文件都在一个压缩包里面

        /// <summary>
        /// 将一个文件夹的内容读取为 Stream 的压缩包
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="stream"></param>
        public static async Task ReadDirectoryToZipStreamAsync(DirectoryInfo directory, Stream stream)
        {
            var fileList = directory.GetFiles();

            using var zipArchive = new ZipArchive(stream, ZipArchiveMode.Create);
            foreach (var file in fileList)
            {
                var relativePath = file.FullName.Replace(directory.FullName, "");
                if (relativePath.StartsWith("\\") || relativePath.StartsWith("//"))
                {
                    relativePath = relativePath.Substring(1);
                }

                var zipArchiveEntry = zipArchive.CreateEntry(relativePath, CompressionLevel.NoCompression);

                using (var entryStream = zipArchiveEntry.Open())
                {
                    using var toZipStream = file.OpenRead();
                    await toZipStream.CopyToAsync(stream);
                }

                await stream.FlushAsync();
            }
        }

上面的代码可以让运行的程序不需要申请和需要传输一样大的内存空间，或者不需要先执行压缩放在本地文件，可以不断读取本地文件然后上传。读取本地文件等都通过 CopyToAsync 自动设置缓存大小。如果不放心 CopyToAsync 方法设置的缓存大小，可以通过重载的方法手动设置缓存的大小

      await toZipStream.CopyToAsync(stream, bufferSize: 100);

上面的代码设置了文件不要压缩，因为作为文件传输的时候，实际上我的业务是在内网传输，我的磁盘读取速度大概是 20M 一秒，而网络传输是 10M 一秒，也就是此时的压缩其实没什么意义，压缩减少的内容减少的传输时间就和压缩的时间差不多

如果小伙伴需要传输的时候压缩，请设置 zipArchive.CreateEntry 方法

当然此方法的缺点是，也许传输的时候服务器自己读取文件炸了，此时就会传输的文件不对，同时客户端不知道服务器传的对不对，因为压缩的大小没有告诉客户端。如果要告诉客户端压缩后的大小就需要先在服务器端进行压缩。本文的方法设置的是没有压缩率的压缩，大概的大小还可以告诉用户

此方法可以如何使用？在随意一个 Get 方法里面就可以通过 HttpContext 传入 Response 属性

在使用 BodyWriter 写入之前需要先设置 StatusCode 的值

            HttpContext.Response.StatusCode = StatusCodes.Status200OK;

            using var stream = HttpContext.Response.BodyWriter.AsStream();

假设需要返回的文件夹是 f:\lindexi\test\ 可以通过下面代码的方式将文件夹输出为压缩包

        [HttpGet]
        [Route("{id}")]
        public async Task Get([FromRoute] string id)
        {
            var folder = @"f:\lindexi\test\";
            HttpContext.Response.StatusCode = StatusCodes.Status200OK;

            using var stream = HttpContext.Response.BodyWriter.AsStream();

            await ReadDirectoryToZipStreamAsync(new DirectoryInfo(folder), stream);
        }

本地我写了一个 PowerShell 脚本运行

For ($i=0; $i -le 100000; $i++) 
{
 (new-object System.Net.WebClient).DownloadFile("http://localhost:5000/File/doubi", "F:\lindexi\zip\2.zip")
} 

本地运行这个脚本可以看到内存其实没有 GC 也没有溢出，我运行看到内存大概在 100M 左右

获取的时候会占用一些 CPU 资源，但是很省内存

如果小伙伴有更好的方法欢迎告诉我

本文代码放在github欢迎小伙伴访问

C# dotnet TypeForwarding 的用法

Thu, 03 Dec 2020 12:27:50 +0000

在 CLR 中提供这样的支持，某个类从程序集 A 放到了程序集 B 里面，可以通过一些黑科技让类型就像原本就在程序集 A 一样。用这个方法可以比较好的解决兼容性的问题

例如我写了一个程序集 A 里面有一个 Foo 类，后续我发现这个类其实应该放在程序集 B 里面

如果我直接移动到程序集 B 里面，那么将会让原本在程序集 A 里面寻找的代码跑不过。例如有很多项目都是引用 A 程序集而不知道存在 B 程序集，而一次性更改这么多项目也不靠谱

一个解决方法是将类型从程序集 A 放到程序集 B 里面，但是注意命名空间和类名等都需要保持相同。然后通过在程序集 A 里面添加 TypeForwarding 特定，然后将程序集 A 引用程序集 B 这样就能做到让原本引用程序集 A 的项目依然能从程序集 A 里面找到类型

// 程序集 A 将原本代码去掉，替换为 TypeForwardedTo 引用程序集 B 相同命名空间的类
[assembly:TypeForwardedTo(typeof(Xx.Foo))]

// namespace Xx
// {
// 	public class Foo
// 	{

// 	}
// }

而根据 NuGet 的做法，高版本可以覆盖低版本，也就是我在很多项目里面虽然引用的是旧版本的 A 程序集，但是在入口项目，也就是最终输出的项目里面是引用了最新版本的 A 程序集。这个最新版本的 A 程序集将会引用 B 程序集，同时使用上面方法引用了 B 程序集的类型

本文代码是小伙伴提供的代码，请看 ikriv-samples/TypeForwardingTest: CLR has a feature to forward type implementation to another assembly

微软官方的 NuGet 包是如何做到同时兼容新旧框架的？例如 System.ValueTuple 是如何做到在新旧版本的框架都能使用的？ - walterlv

白板类应用的模式交互设计方案

Thu, 03 Dec 2020 12:27:50 +0000

在一个白板类应用的交互中一定会涉及到模式之间的更换和交互冲突。白板类软件的交互模式一般包含了笔迹书写模式，选择模式，擦除笔迹模式等。多个模式之间存在切换，而切换可以发生在某个模式执行过程，如需要在白板软件里面支持笔迹书写功能，在书写的过程打断进入笔迹的擦除模式。本文告诉大家我所在团队的白板内核的模式交互设计方案，本文不会涉及到具体实现的逻辑代码

我从 2017 开始到现在都在做白板软件，我对整个白板体系的软件层面都比较了解。整个开发过程也对整个白板软件的模式交互方案换了有一些方案，当前使用的方案也许不是最优的，但是相对来说比较适合业务

整个框架（不敢说架构）里面三个大块，第一块是输入前置，第二块是输入切换，第三块是业务处理

输入前置

小伙伴都知道，在 Windows 下实现触摸不是简单的事情，而在 WPF 中尽管有大量的封装，但是对于整体触摸来说，依然存在一些业务上的坑。如按下和抬起不成对等。而我期望在上层业务里面不应该每个业务都处理这些交互上的问题。因此就有了对 WPF 层的交互的封装，此封装可以定制交互输入数据，同时隔离框架差异。换句话说是这套框架可以脱离 WPF 执行

在触摸屏幕上面，在 WPF 收到的触摸可以通过监听三个不同的事件 Touch Stylus Mouse 事件，这三个事件的触发顺序以及触摸和触笔的差异，会让上层业务开发者们不得不在开发的时候关注这些细节。如果业务开发者需要关注框架细节，那么肯定会带来业务复杂度以及挖坑。毕竟相同的逻辑写10次，基本上就有一次写出坑

在输入前置的第一层就是 SourceInput 层，这一层将隔离框架和平台差异的交互输入，同时约定一些通用交互。包括定义了 PointerDown PointerMove PointerUp PointerHover 这几个事件。从事件命名上可以了解到，这个事件是参照 UWP 的 Pointer 的设计。无论是鼠标输入还是触摸输入还是触笔的输入，全部统一化。至于鼠标和触摸等之间的差异，会放在事件的参数里面，提供给特殊的业务可以判断

上面有一个细节是添加了 PointerHover 事件，这个事件其实是将原本的 Move 事件拆开为 PointerMove 和 PointerHover 两个事件。表达的含义是在没有按下之间发生的都是 Hover 事件，而按下之后发生的就是 Move 事件。为什么这样做？在阅读大量业务的代码发现，基本上所有用到 Move 事件的地方都需要添加一个字段用来判断当前是否是按下，如果是按下的 Move 才做业务。为了减少相同的业务代码，在框架底层将 Move 分为两个事件，可以让业务开发者用到 Move 的时候就是按下状态的移动

更进一步的封装是将 Down Move Up 封装一层 Drag 拖拽事件。此部分仅仅是封装，方便开发者，不属于框架核心

在隔离输入层之后，就可以统一化输入，在框架层不需要了解输入细节。框架层的输入前置还需要保证一点的是对某个模式的输入里面按下和抬起是成对的，保证输入里面一定是先按下再移动再抬起，这个顺序不会乱

为什么这部分保证是在 SourceInput 层之后？原因是这个保证需要处理一些模拟输入，也就是 SourceInput 层仅封装 WPF 框架的输入。不处理模式交互框架里面的各个模式收到输入的保证输入成对

交互模式

每一个不同的交互模式都应该继承相同的交互模式基类，交互模式指的是如笔迹书写模式，选择模式，擦除笔迹模式等。这些模式基本上都包含了以下定义

SwitchOn
SwitchOff
Down
Move
Up

这里的 SwitchOn 和 SwitchOff 表示模式的开启和关闭。在用户进行选择模式的之前应该开启选择模式，简单的业务就是我有一个控制条，控制条上面有三个按钮，包含了选择、书写、橡皮擦三个。在没有点击选择按钮的时候，此时就不应该让选择模式工作。那么选择模式如何知道自己当前没有被选中？难道去监听按钮的状态？其实通过上面的 API 设计可以看到 SwitchOn 和 SwitchOff 就是用来解决模式的开启和关闭，让模式内部状态可以了解到当前的模式是否开启，是否需要处理业务

更进一步的是输入内容的转发，假设一个模式不开启，此时这个模式是否应该收到输入。当前我的设计是如果这个模式没有开启，就不要让这个模式收到输入。于是这个功能又需要框架的支持啦

这个框架里面对模式的输入的控制可以放在模式控制器这个类里面，接下来说的模式切换也是这个类应该实现的功能

模式切换

模式切换最简单的切换是用户的行为切换，用户点击了选择按钮就告诉白板框架当前要切换为选择模式，用户点击了书写按钮就告诉白板框架当前要切换为书写模式。而各个模式的切换是需要框架层面的支持的

按照上文输入的约定，每个模式收到的输入里面按下和抬起是成对的。而交互模式本身不监听元素的事件，需要靠框架层转发。那么假设在选择移动的过程，用户切换了模式，那么此时当前的模式不是选择模式，请问选择模式什么时候可以收到抬起事件。请先忽略用户什么时候可以做到在选择移动的过程中切换模式

最好的做法是在模式切换的时候，给旧模式补充抬起事件，而给新模式补充按下事件。补充事件的时候有一些细节。补充的事件里面需要让补充抬起和按下的点的坐标是当前移动的坐标，而同样的在多指触摸的时候需要补充不止一个按下和抬起才可以

整个模式切换里面需要处理的就是多个模式之间的切换，包括切换的旧模式的输入补充，以及新模式如何接手旧模式的数据。这些数据主要包含了当前模式正在操作的元素，例如选择了某些元素等。简单的例子是在选择模式的时候选择了一些元素，在切换到书写模式的时候应该清空选择，而在切换到 xx 模式的时候就不应该去掉选择等的这些业务。这部分的业务应该抽象出来，而不是具体的处理如是否清空选择框等业务，支持各个模式之前的定制

输入过滤

上文有提到用户在选择的过程切换了模式，那么用户是如何做到切换的？其实这里涉及了用户行为的判断，一个很现实的是软件是无法知道用户的未来的行为，而有些行为判断需要用户的多个交互才能确定。最简单的例子，但是可能行业外的小伙伴无法理解哈，就是一个黑板擦功能，或者叫手势擦除功能，更接地气的手背擦除功能。这是一个什么功能？就是当我使用手背触摸屏幕的时候我期望现在是进行擦除笔迹，这个行为就和在黑板上一样，我用粉笔写字，我用手背擦除

这个功能存在什么问题呢？从软件的角度上，在第一时刻，我收到了一个点。在第二时刻，我收到了这个点在移动。此时软件的模式假设是选择模式，那么是不是就开始选择模式的移动了。没错，从逻辑上讲应该是这样的。在第三时刻，我收到了这个点的宽度变大。而在第三时刻我收到的这个点的宽度是满足了手背擦除的触摸面积，应该切换到手势擦除模式里面。当前手势擦除和擦除模式本身是相同的模式，只是因为用户行为不同叫法不同而已

那么此时问题来了，请问谁处理模式的切换，或者说如何知道模式应该切换？因为软件是不知道用户未来的行为，而用户在行为过程可以让软件判断出用户想要的模式。那么就需要一个输入过滤层，这个输入过滤层可以决定之后的模式切换到哪里，或者说输入传输到哪里

在用到输入过滤之前还需要先聊一下这个业务，在用户进行手势擦除完成之后，在抬手之后需要结束手势擦除模式。下一次进行交互的时候应该回到上一个模式。如上一个模式是选择模式，那么在手势擦除结束之后的下一次模式应该回到选择模式。如上一个模式是笔迹书写模式，那么在手势擦除结束之后的下一次模式应该回到笔迹书写模式

上面这个业务的需求也就是框架层面需要支持一个是当前的模式，另一个是激活模式。什么是当前模式，当前模式就是用户选择的行为，也叫主模式。就是用户当前主要在使用的模式，如进行选择或进行书写等。而激活模式是用户瞬时的一个交互行为，一般来说这个行为都是根据用户的行为作出的判断切换到另一个模式里面，如手势擦除等模式

为什么会放两个不同的模式？因为激活模式可以用来取代当前模式收到交互输入，而当前模式保留实例等待激活模式关闭之后再次激活。默认行为都是当前模式，而输入过滤层，可以在收集到必要的行为的时候更改激活模式，开启激活模式，将框架层的用户交互输入传输到激活模式中，关闭当前模式

输入过滤层的作用就是决定输入数据的流向，让交互输入数据走向 CurrentMode 当前模式还是 ActiveMode 激活模式

通过上面的业务可以了解到，激活模式 ActiveMode 与当前模式 CurrentMode 同时只会有一个生效。而激活模式 ActiveMode 的优先级高于当前模式 CurrentMode 只要 ActiveMode 存在，那么所有交互输入数据都应该传入到 ActiveMode 激活模式中

而在当前模式 CurrentMode 接收用户输入过程中，可以被 ActiveMode 激活模式打断

这一点有点难以理解，为什么需要两个模式？原因是两个模式，其中一个表示激活模式表示用户的瞬时操作，可以用来给输入过滤层切换。换句话说是输入过滤层控制的是 ActiveMode 激活模式。而用户明确行为控制的是 CurrentMode 当前模式。使用两个模式的另一个原因是框架内部可以判断是否存在 ActiveMode 激活模式决定交互输入数据是否走向 CurrentMode 当前模式。同时在 ActiveMode 激活模式完成之后，可以知道切换回的当前模式是哪个模式

那么输入过滤层的定义又是什么？和模式层相同，输入过滤层收到的用户信息也是框架转发的，也就是 Filter 层和 Mode 层都继承相同的类 InputProcessor 输入处理者

在输入处理者提供触发输入函数，也就是在输入层经过模式控制器之后，转发的数据到具体的各个 Filter 和 Mode 时，处理转发数据的基类

回到问题本身，这里的 Filter 的没有实际的功能，仅仅是用来决定数据走向，也就是依靠切换为具体处理业务的某个 Mode 为 ActiveMode 完成业务。如手势擦除就应该配套一个 EraserGestureFilter 来判断用户触摸点的面积是否可以触发手势擦除，如可以触发，那么将 ActiveMode 设置为橡皮擦模式

那么可以被作为 ActiveMode 的模式是否需要是特殊模式？从上面的例子就可以看出，本来可以作为当前模式的橡皮擦模式在手势擦除的时候被作为了手势擦除模式。也就是模式本身不应该关心自己是被当前是 CurrentMode 还是 ActiveMode 激活模式，模式只关心输入的数据的业务处理

通过了框架的数据转发和 Filter 决定数据走向就能完成输入切换的功能，在没有界面功能的时候可以依靠用户的行为给软件定义出更多模式

还有一个问题，这个方案里面哪些是属于不变的框架，哪些属于业务逻辑？整个输入层都是框架，这个输入层解决一些 WPF 触摸的白板业务问题。注意，这里的白板业务问题指的是在白板这个行业里面的业务问题不是说具体的业务哈。模式切换的框架层以及 Filter 和 Mode 的基类实现都是框架层面

而具体的 xx Filter 和 xx Mode 就都是业务了

元素交互和通用交互

在白板核心框架设计里面存在的另一个坑就是元素本身的交互和通用交互的交互冲突问题

例如我有一个元素这个元素是一个地图，这个地图元素支持拖动地图内容，就和小伙伴用高德地图一样的交互。但是通用的交互里面由包含了拖拽元素的行为，也就是可以拖动一个元素。这两个行为是交互冲突的，当用户在地图元素上面拖动的时候，请问用户是想拖动地图元素还是想拖动地图

这部分行为就需要具体的业务定了，但是业务定下之后是否框架层能支持？其实还是可以的，通过设计交互优先级可以解决此问题

假设当前的业务需求是用户在地图元素上面拖动的时候，应该拖动地图而不应该拖动元素

在上面的设计在有 Filter 和 ActiveMode 就可以解决此问题。如果某些元素的交互的优先级是大于通用交互的优先级的，那么这些元素可以通过设置特殊的属性，在 Filter 层通过判断当前命中的元素包含了这个特殊的属性，就可以设置 ActiveMode 为一个什么都不做的 NoMode 模式

按照框架的设计，当存在 ActiveMode 时，将会忽略 CurrentMode 的行为，也就是此时是一个什么都不做的 NoMode 模式，用户的行为落到了元素上，用户可以拖动地图。而因为当前模式选择模式没有收到数据，也就不会拖动元素

所以只需要再定义一个 Filter 让这个 Filter 处理元素交互冲突问题就可以了

而又有另一个问题，用户如果是在地图元素上进行手势擦除呢。假设当前业务需求是手势擦除优先，当前是手势擦除不要拖动地图

而手势擦除在软件层面其实也是移动，那么可以如何做，刚才的 Filter 已经判断了命中元素就激活了一个 NoMode 了

其实只需要引入 Filter 的优先级就可以解决此问题，让手势擦除 Filter 的优先级大于元素交互冲突 ExclusiveModeFilter 的优先级。此时手势擦除 Filter 就会设置 ActiveMode 为橡皮擦模式，在 ExclusiveModeFilter 判断如果存在 ActiveMode 了，也就是存在优先级更高的 Filter 满足条件，那么 ExclusiveModeFilter 就知道当前应该禁用元素的交互，可以通过设置元素不可命中等让元素收不到交互

其实上面有一个细节是手势擦除判断一般都会比 ExclusiveModeFilter 判断慢，原因是第一个点按下的时候，元素交互冲突 ExclusiveModeFilter 就判断了命中的元素了，但是手势擦除判断需要等待第N个点按下才知道。不过这些细节问题都很好处理，本文上面的例子仅仅只是为了方便理解

这就是整套白板类应用的模式交互设计方案。里面的细节特别多，每个细节其实都需要大量的开发。现在是 2020.5 这个白板框架有 27,197 次 commit 和 300 多次 NuGet 版本发布。本文说到的模式交互仅仅是这个白板框架的核心一部分

C# dotnet 获取某个字符所在 Unicode 字符平面映射

Thu, 03 Dec 2020 12:27:50 +0000

在 dotnet 里面可以通过安装 System.Text.Encodings.Web 库拿到 UnicodeRanges 这个包含了 Unicode 标准的平面映射。但是我还没有找到如何判断一个字符是落在哪个平面的逻辑，本文就告诉大家一个可以使用的方法，这个方法同时稍微兼顾了性能

在 System.Text.Encodings.Web 的 UnicodeRanges 其实是根据标准生成的代码，源代码请看 https://github.com/dotnet/runtime/blob/5372ee9dbe48058ca8d3591763e989d3b2e65581/src/libraries/System.Text.Encodings.Web/src/System/Text/Unicode/UnicodeRanges.generated.cs

本文根据 UnicodeRanges 的定义写出了一个列表如下

        /// <summary>
        /// 这个列表已经是按照 FirstCodePoint 排过顺序的
        /// </summary>
        private static List<UnicodeRangeInfo> UnicodeRangeInfoList { get; } = new List<UnicodeRangeInfo>()
        {
            //new UnicodeRangeInfo("None",UnicodeRanges.None),
            //new UnicodeRangeInfo("All",UnicodeRanges.All),
            new UnicodeRangeInfo("BasicLatin", UnicodeRanges.BasicLatin),
            new UnicodeRangeInfo("Latin1Supplement", UnicodeRanges.Latin1Supplement),
            new UnicodeRangeInfo("LatinExtendedA", UnicodeRanges.LatinExtendedA),
            new UnicodeRangeInfo("LatinExtendedB", UnicodeRanges.LatinExtendedB),
            new UnicodeRangeInfo("IpaExtensions", UnicodeRanges.IpaExtensions),
            new UnicodeRangeInfo("SpacingModifierLetters", UnicodeRanges.SpacingModifierLetters),
            new UnicodeRangeInfo("CombiningDiacriticalMarks", UnicodeRanges.CombiningDiacriticalMarks),
            new UnicodeRangeInfo("GreekandCoptic", UnicodeRanges.GreekandCoptic),
            new UnicodeRangeInfo("Cyrillic", UnicodeRanges.Cyrillic),
            new UnicodeRangeInfo("CyrillicSupplement", UnicodeRanges.CyrillicSupplement),
            new UnicodeRangeInfo("Armenian", UnicodeRanges.Armenian),
            new UnicodeRangeInfo("Hebrew", UnicodeRanges.Hebrew),
            new UnicodeRangeInfo("Arabic", UnicodeRanges.Arabic),
            new UnicodeRangeInfo("Syriac", UnicodeRanges.Syriac),
            new UnicodeRangeInfo("ArabicSupplement", UnicodeRanges.ArabicSupplement),
            new UnicodeRangeInfo("Thaana", UnicodeRanges.Thaana),
            new UnicodeRangeInfo("NKo", UnicodeRanges.NKo),
            new UnicodeRangeInfo("Samaritan", UnicodeRanges.Samaritan),
            new UnicodeRangeInfo("Mandaic", UnicodeRanges.Mandaic),
            new UnicodeRangeInfo("SyriacSupplement", UnicodeRanges.SyriacSupplement),
            new UnicodeRangeInfo("ArabicExtendedA", UnicodeRanges.ArabicExtendedA),
            new UnicodeRangeInfo("Devanagari", UnicodeRanges.Devanagari),
            new UnicodeRangeInfo("Bengali", UnicodeRanges.Bengali),
            new UnicodeRangeInfo("Gurmukhi", UnicodeRanges.Gurmukhi),
            new UnicodeRangeInfo("Gujarati", UnicodeRanges.Gujarati),
            new UnicodeRangeInfo("Oriya", UnicodeRanges.Oriya),
            new UnicodeRangeInfo("Tamil", UnicodeRanges.Tamil),
            new UnicodeRangeInfo("Telugu", UnicodeRanges.Telugu),
            new UnicodeRangeInfo("Kannada", UnicodeRanges.Kannada),
            new UnicodeRangeInfo("Malayalam", UnicodeRanges.Malayalam),
            new UnicodeRangeInfo("Sinhala", UnicodeRanges.Sinhala),
            new UnicodeRangeInfo("Thai", UnicodeRanges.Thai),
            new UnicodeRangeInfo("Lao", UnicodeRanges.Lao),
            new UnicodeRangeInfo("Tibetan", UnicodeRanges.Tibetan),
            new UnicodeRangeInfo("Myanmar", UnicodeRanges.Myanmar),
            new UnicodeRangeInfo("Georgian", UnicodeRanges.Georgian),
            new UnicodeRangeInfo("HangulJamo", UnicodeRanges.HangulJamo),
            new UnicodeRangeInfo("Ethiopic", UnicodeRanges.Ethiopic),
            new UnicodeRangeInfo("EthiopicSupplement", UnicodeRanges.EthiopicSupplement),
            new UnicodeRangeInfo("Cherokee", UnicodeRanges.Cherokee),
            new UnicodeRangeInfo("UnifiedCanadianAboriginalSyllabics",
                UnicodeRanges.UnifiedCanadianAboriginalSyllabics),
            new UnicodeRangeInfo("Ogham", UnicodeRanges.Ogham),
            new UnicodeRangeInfo("Runic", UnicodeRanges.Runic),
            new UnicodeRangeInfo("Tagalog", UnicodeRanges.Tagalog),
            new UnicodeRangeInfo("Hanunoo", UnicodeRanges.Hanunoo),
            new UnicodeRangeInfo("Buhid", UnicodeRanges.Buhid),
            new UnicodeRangeInfo("Tagbanwa", UnicodeRanges.Tagbanwa),
            new UnicodeRangeInfo("Khmer", UnicodeRanges.Khmer),
            new UnicodeRangeInfo("Mongolian", UnicodeRanges.Mongolian),
            new UnicodeRangeInfo("UnifiedCanadianAboriginalSyllabicsExtended",
                UnicodeRanges.UnifiedCanadianAboriginalSyllabicsExtended),
            new UnicodeRangeInfo("Limbu", UnicodeRanges.Limbu),
            new UnicodeRangeInfo("TaiLe", UnicodeRanges.TaiLe),
            new UnicodeRangeInfo("NewTaiLue", UnicodeRanges.NewTaiLue),
            new UnicodeRangeInfo("KhmerSymbols", UnicodeRanges.KhmerSymbols),
            new UnicodeRangeInfo("Buginese", UnicodeRanges.Buginese),
            new UnicodeRangeInfo("TaiTham", UnicodeRanges.TaiTham),
            new UnicodeRangeInfo("CombiningDiacriticalMarksExtended", UnicodeRanges.CombiningDiacriticalMarksExtended),
            new UnicodeRangeInfo("Balinese", UnicodeRanges.Balinese),
            new UnicodeRangeInfo("Sundanese", UnicodeRanges.Sundanese),
            new UnicodeRangeInfo("Batak", UnicodeRanges.Batak),
            new UnicodeRangeInfo("Lepcha", UnicodeRanges.Lepcha),
            new UnicodeRangeInfo("OlChiki", UnicodeRanges.OlChiki),
            new UnicodeRangeInfo("CyrillicExtendedC", UnicodeRanges.CyrillicExtendedC),
            new UnicodeRangeInfo("GeorgianExtended", UnicodeRanges.GeorgianExtended),
            new UnicodeRangeInfo("SundaneseSupplement", UnicodeRanges.SundaneseSupplement),
            new UnicodeRangeInfo("VedicExtensions", UnicodeRanges.VedicExtensions),
            new UnicodeRangeInfo("PhoneticExtensions", UnicodeRanges.PhoneticExtensions),
            new UnicodeRangeInfo("PhoneticExtensionsSupplement", UnicodeRanges.PhoneticExtensionsSupplement),
            new UnicodeRangeInfo("CombiningDiacriticalMarksSupplement",
                UnicodeRanges.CombiningDiacriticalMarksSupplement),
            new UnicodeRangeInfo("LatinExtendedAdditional", UnicodeRanges.LatinExtendedAdditional),
            new UnicodeRangeInfo("GreekExtended", UnicodeRanges.GreekExtended),
            new UnicodeRangeInfo("GeneralPunctuation", UnicodeRanges.GeneralPunctuation),
            new UnicodeRangeInfo("SuperscriptsandSubscripts", UnicodeRanges.SuperscriptsandSubscripts),
            new UnicodeRangeInfo("CurrencySymbols", UnicodeRanges.CurrencySymbols),
            new UnicodeRangeInfo("CombiningDiacriticalMarksforSymbols",
                UnicodeRanges.CombiningDiacriticalMarksforSymbols),
            new UnicodeRangeInfo("LetterlikeSymbols", UnicodeRanges.LetterlikeSymbols),
            new UnicodeRangeInfo("NumberForms", UnicodeRanges.NumberForms),
            new UnicodeRangeInfo("Arrows", UnicodeRanges.Arrows),
            new UnicodeRangeInfo("MathematicalOperators", UnicodeRanges.MathematicalOperators),
            new UnicodeRangeInfo("MiscellaneousTechnical", UnicodeRanges.MiscellaneousTechnical),
            new UnicodeRangeInfo("ControlPictures", UnicodeRanges.ControlPictures),
            new UnicodeRangeInfo("OpticalCharacterRecognition", UnicodeRanges.OpticalCharacterRecognition),
            new UnicodeRangeInfo("EnclosedAlphanumerics", UnicodeRanges.EnclosedAlphanumerics),
            new UnicodeRangeInfo("BoxDrawing", UnicodeRanges.BoxDrawing),
            new UnicodeRangeInfo("BlockElements", UnicodeRanges.BlockElements),
            new UnicodeRangeInfo("GeometricShapes", UnicodeRanges.GeometricShapes),
            new UnicodeRangeInfo("MiscellaneousSymbols", UnicodeRanges.MiscellaneousSymbols),
            new UnicodeRangeInfo("Dingbats", UnicodeRanges.Dingbats),
            new UnicodeRangeInfo("MiscellaneousMathematicalSymbolsA", UnicodeRanges.MiscellaneousMathematicalSymbolsA),
            new UnicodeRangeInfo("SupplementalArrowsA", UnicodeRanges.SupplementalArrowsA),
            new UnicodeRangeInfo("BraillePatterns", UnicodeRanges.BraillePatterns),
            new UnicodeRangeInfo("SupplementalArrowsB", UnicodeRanges.SupplementalArrowsB),
            new UnicodeRangeInfo("MiscellaneousMathematicalSymbolsB", UnicodeRanges.MiscellaneousMathematicalSymbolsB),
            new UnicodeRangeInfo("SupplementalMathematicalOperators", UnicodeRanges.SupplementalMathematicalOperators),
            new UnicodeRangeInfo("MiscellaneousSymbolsandArrows", UnicodeRanges.MiscellaneousSymbolsandArrows),
            new UnicodeRangeInfo("Glagolitic", UnicodeRanges.Glagolitic),
            new UnicodeRangeInfo("LatinExtendedC", UnicodeRanges.LatinExtendedC),
            new UnicodeRangeInfo("Coptic", UnicodeRanges.Coptic),
            new UnicodeRangeInfo("GeorgianSupplement", UnicodeRanges.GeorgianSupplement),
            new UnicodeRangeInfo("Tifinagh", UnicodeRanges.Tifinagh),
            new UnicodeRangeInfo("EthiopicExtended", UnicodeRanges.EthiopicExtended),
            new UnicodeRangeInfo("CyrillicExtendedA", UnicodeRanges.CyrillicExtendedA),
            new UnicodeRangeInfo("SupplementalPunctuation", UnicodeRanges.SupplementalPunctuation),
            new UnicodeRangeInfo("CjkRadicalsSupplement", UnicodeRanges.CjkRadicalsSupplement),
            new UnicodeRangeInfo("KangxiRadicals", UnicodeRanges.KangxiRadicals),
            new UnicodeRangeInfo("IdeographicDescriptionCharacters", UnicodeRanges.IdeographicDescriptionCharacters),
            new UnicodeRangeInfo("CjkSymbolsandPunctuation", UnicodeRanges.CjkSymbolsandPunctuation),
            new UnicodeRangeInfo("Hiragana", UnicodeRanges.Hiragana),
            new UnicodeRangeInfo("Katakana", UnicodeRanges.Katakana),
            new UnicodeRangeInfo("Bopomofo", UnicodeRanges.Bopomofo),
            new UnicodeRangeInfo("HangulCompatibilityJamo", UnicodeRanges.HangulCompatibilityJamo),
            new UnicodeRangeInfo("Kanbun", UnicodeRanges.Kanbun),
            new UnicodeRangeInfo("BopomofoExtended", UnicodeRanges.BopomofoExtended),
            new UnicodeRangeInfo("CjkStrokes", UnicodeRanges.CjkStrokes),
            new UnicodeRangeInfo("KatakanaPhoneticExtensions", UnicodeRanges.KatakanaPhoneticExtensions),
            new UnicodeRangeInfo("EnclosedCjkLettersandMonths", UnicodeRanges.EnclosedCjkLettersandMonths),
            new UnicodeRangeInfo("CjkCompatibility", UnicodeRanges.CjkCompatibility),
            new UnicodeRangeInfo("CjkUnifiedIdeographsExtensionA", UnicodeRanges.CjkUnifiedIdeographsExtensionA),
            new UnicodeRangeInfo("YijingHexagramSymbols", UnicodeRanges.YijingHexagramSymbols),
            new UnicodeRangeInfo("CjkUnifiedIdeographs", UnicodeRanges.CjkUnifiedIdeographs),
            new UnicodeRangeInfo("YiSyllables", UnicodeRanges.YiSyllables),
            new UnicodeRangeInfo("YiRadicals", UnicodeRanges.YiRadicals),
            new UnicodeRangeInfo("Lisu", UnicodeRanges.Lisu),
            new UnicodeRangeInfo("Vai", UnicodeRanges.Vai),
            new UnicodeRangeInfo("CyrillicExtendedB", UnicodeRanges.CyrillicExtendedB),
            new UnicodeRangeInfo("Bamum", UnicodeRanges.Bamum),
            new UnicodeRangeInfo("ModifierToneLetters", UnicodeRanges.ModifierToneLetters),
            new UnicodeRangeInfo("LatinExtendedD", UnicodeRanges.LatinExtendedD),
            new UnicodeRangeInfo("SylotiNagri", UnicodeRanges.SylotiNagri),
            new UnicodeRangeInfo("CommonIndicNumberForms", UnicodeRanges.CommonIndicNumberForms),
            new UnicodeRangeInfo("Phagspa", UnicodeRanges.Phagspa),
            new UnicodeRangeInfo("Saurashtra", UnicodeRanges.Saurashtra),
            new UnicodeRangeInfo("DevanagariExtended", UnicodeRanges.DevanagariExtended),
            new UnicodeRangeInfo("KayahLi", UnicodeRanges.KayahLi),
            new UnicodeRangeInfo("Rejang", UnicodeRanges.Rejang),
            new UnicodeRangeInfo("HangulJamoExtendedA", UnicodeRanges.HangulJamoExtendedA),
            new UnicodeRangeInfo("Javanese", UnicodeRanges.Javanese),
            new UnicodeRangeInfo("MyanmarExtendedB", UnicodeRanges.MyanmarExtendedB),
            new UnicodeRangeInfo("Cham", UnicodeRanges.Cham),
            new UnicodeRangeInfo("MyanmarExtendedA", UnicodeRanges.MyanmarExtendedA),
            new UnicodeRangeInfo("TaiViet", UnicodeRanges.TaiViet),
            new UnicodeRangeInfo("MeeteiMayekExtensions", UnicodeRanges.MeeteiMayekExtensions),
            new UnicodeRangeInfo("EthiopicExtendedA", UnicodeRanges.EthiopicExtendedA),
            new UnicodeRangeInfo("LatinExtendedE", UnicodeRanges.LatinExtendedE),
            new UnicodeRangeInfo("CherokeeSupplement", UnicodeRanges.CherokeeSupplement),
            new UnicodeRangeInfo("MeeteiMayek", UnicodeRanges.MeeteiMayek),
            new UnicodeRangeInfo("HangulSyllables", UnicodeRanges.HangulSyllables),
            new UnicodeRangeInfo("HangulJamoExtendedB", UnicodeRanges.HangulJamoExtendedB),
            new UnicodeRangeInfo("CjkCompatibilityIdeographs", UnicodeRanges.CjkCompatibilityIdeographs),
            new UnicodeRangeInfo("AlphabeticPresentationForms", UnicodeRanges.AlphabeticPresentationForms),
            new UnicodeRangeInfo("ArabicPresentationFormsA", UnicodeRanges.ArabicPresentationFormsA),
            new UnicodeRangeInfo("VariationSelectors", UnicodeRanges.VariationSelectors),
            new UnicodeRangeInfo("VerticalForms", UnicodeRanges.VerticalForms),
            new UnicodeRangeInfo("CombiningHalfMarks", UnicodeRanges.CombiningHalfMarks),
            new UnicodeRangeInfo("CjkCompatibilityForms", UnicodeRanges.CjkCompatibilityForms),
            new UnicodeRangeInfo("SmallFormVariants", UnicodeRanges.SmallFormVariants),
            new UnicodeRangeInfo("ArabicPresentationFormsB", UnicodeRanges.ArabicPresentationFormsB),
            new UnicodeRangeInfo("HalfwidthandFullwidthForms", UnicodeRanges.HalfwidthandFullwidthForms),
            new UnicodeRangeInfo("Specials", UnicodeRanges.Specials),
        };

如果不信这个列表已经排好序，请使用下面方法测试一下

        /// <summary>
        /// 按照 FirstCodePoint 排序，看顺序是否是对的，这个方法仅是让你知道这个列表是排序的
        /// </summary>
        /// <returns></returns>
        internal static bool CheckSort()
        {
            var t = UnicodeRangeInfoList.ToList();
            t.Sort((a, b) => a.UnicodeRange.FirstCodePoint.CompareTo(b.UnicodeRange.FirstCodePoint));

            for (var i = 0; i < UnicodeRangeInfoList.Count; i++)
            {
                if (!ReferenceEquals(t[i], UnicodeRangeInfoList[i]))
                {
                    return false;
                }

            }

            return true;
        }

如果上面方法返回 true 那么证明排序之后的列表和当前的列表是完全相同

这里的 UnicodeRangeInfo 是自己定义的类，可以让平面的名字和值关联

        private class UnicodeRangeInfo
        {
            public UnicodeRangeInfo(string unicodeRangeName, UnicodeRange unicodeRange)
            {
                UnicodeRangeName = unicodeRangeName;
                UnicodeRange = unicodeRange;
            }

            public string UnicodeRangeName { get; }

            public UnicodeRange UnicodeRange { get; }
        }

在拿到一个字符的时候，根据 UnicodeRange 可以判断是否落在这个平面里面，从统计里面使用的字符大部分都是中文或英文字符，所以本文就根据这两个优化

        private static UnicodeRangeInfo GetUnicodeRangeInfo(char ch)
        {
            // 这是英文 数字
            if (UnicodeRangeInfoList[0].UnicodeRange.Contain(ch))
            {
                // UnicodeRangeInfoList[0].UnicodeRange == UnicodeRanges.BasicLatin
                return UnicodeRangeInfoList[0];
            }

            // 119
            var currentIndex = 119;//准备二分，这个值刚好是 中日韩统一表意文字 CJK Unified Ideographs 
            var left = 0;
            var right = UnicodeRangeInfoList.Count;
            while (left <= right)
            {
                var unicodeRangeInfo = UnicodeRangeInfoList[currentIndex];
                var unicodeRange = unicodeRangeInfo.UnicodeRange;
                if (unicodeRange.Contain(ch))
                {
                    return unicodeRangeInfo;
                }
                else if (unicodeRange.FirstCodePoint < ch)
                {
                    // 不落在 unicodeRange 里面，同时比 FirstCodePoint 大的，一定比 unicodeRange.FirstCodePoint + unicodeRange.Length 大
                    left = currentIndex + 1;
                }
                else if (unicodeRange.FirstCodePoint > ch)
                {
                    right = currentIndex - 1;
                }

                currentIndex = (right + left) / 2;
            }

            return null;
        }

调用这个类可以使用三个方法，一个是获取字符所在的 UnicodeRange 可以用来判断多个字符是否落在一个平面，另一个是获取平面名。最后一个是根据所在平面获取平面名

        /// <summary>
        /// 获取此字符所在范围
        /// </summary>
        /// <param name="ch"></param>
        /// <returns></returns>
        public static UnicodeRange GetUnicodeRange(char ch)
            => GetUnicodeRangeInfo(ch)?.UnicodeRange;

        /// <summary>
        /// 获取此字符所在范围名
        /// </summary>
        /// <param name="ch"></param>
        /// <returns></returns>
        public static string GetUnicodeRangeName(char ch)
            => GetUnicodeRangeInfo(ch)?.UnicodeRangeName;

        /// <summary>
        /// 获取字符范围名
        /// </summary>
        /// <param name="unicodeRange"></param>
        /// <returns></returns>
        public static string GetUnicodeRangeName(UnicodeRange unicodeRange) => UnicodeRangeInfoList
            .FirstOrDefault(temp => ReferenceEquals(temp.UnicodeRange, unicodeRange))?.UnicodeRangeName;

本文代码放在 https://gist.github.com/lindexi/8945441c782488613fbc695d81a1bb85 欢迎小伙伴到 github 复制代码

本文所有代码放在 github 欢迎小伙伴访问

框架是否有提供差不多的方法？实际上有的，请看 CharUnicodeInfo.GetUnicodeCategory 方法

Azure 无服务器 Function 函数计算服务 dotnet core 3.1 创建和部署入门

Thu, 03 Dec 2020 12:27:50 +0000

本文用的是世纪互联的 Azure.cn 版本，这个版本因为是在国内，所以网速会快超级超级多。使用世纪互联的版本需要一块钱哦，用一块钱就能进入一个月的免费试用。本文主要告诉小伙伴如何使用 Azure 无服务器 Function 函数计算服务

本文会偏向于操作，而且仅仅是一条龙下来没有其他分支。如果想要了解边边角角其他的分支功能，请看微软学习平台的使用 Visual Studio 开发、测试和部署 Azure Functions - Learn

现在是 2020.5.13 因为微软喜欢不断更改界面，如果你阅读本文距离此时间比较远，那么有些界面变化让你看到的和本文不相同，还请小伙伴不要喷我

先登录 Azure.cn 进入仪表板，点击创建资源

如下图选择进入函数应用

点击创建的时候，可以注意到订阅里面用的是 1 元试用，也就是 1 元就能用上一堆有趣的功能。如果小伙伴实在不想付钱，但是想要试试 Azure 的功能，欢迎私聊给我二维码，我免费帮你付一块钱（我就知道有哪些厚颜无耻的人）

点击创建之后需要等待一会，此时可以选择如何将代码上传到 Azure 服务进行部署。咱现在用的是中国的世纪互联也就是在 VS 上无法直接关联，需要通过快速入门里面选择使用部署中心部署

先选择 VisualStudio 然后再选择使用部署中心，选择部署中心将会拿到一个 git 推送链接，通过在 VS 里面配置将代码推送到这个仓库就可以触发自动部署

此时点击完成，转到部署中心

我比较喜欢使用 CI CD 的方式，也就是推送代码就自动部署，其他方式还请看使用 Visual Studio 开发、测试和部署 Azure Functions（一）开发 - Grant_Allen - 博客园

选择应用生成服务，现在 Azure 的 Piplelines 还是预览版，配置起来复杂

一路点击完成，此时可以看到推送的链接

此时在本地创建一个 Azure Function 的项目，推荐使用 VistualStudio 2019 创建

创建项目之后加入源代码管理，可以在设置里面的设置本地存储库设置推送的链接

点击添加仓库，输入刚才创建的推送链接

点击团队管理回到主页，点击同步，推送代码

此时 Azure 将会进入自动构建，自动构建完成将会自动发布，点击一下函数的展开，可以看到 Function1 创建完成

可以点击获取函数 url 拿到访问的链接

点击复制访问链接

试试在浏览器输入复制的链接，默认将会输出 Please pass a name on the query string or in the request body 这是因为对应到代码里面的没有拿到 name 参数

那么如何传入 name 参数？从代码上可以看到会从 Post 内容和从 url 里面获取，最简单的方法是添加到 url 里面，在 url 最后添加下面代码试试 &name=lindexi 运行的时候将会显示 你好， lindexi 这样就完成了简单的部署

一些细节如下

刚才看到的 Function1 函数对应的是代码写的 [FunctionName("Function1")] 特性，可以通过将 Function1 替换为自己的名字然后推送代码，但是此时需要注意在 Azure 部署完成之后，点击刷新

我十分推荐在微软学习平台里面学习如何使用，什么是微软学习平台请看 [工具]微软的学习平台Microsoft Learn很好用，推荐一下 - dino.c - 博客园

现在很多大厂都是提供了函数计算服务，如阿里的服务，请看 dotnet C# 使用阿里函数计算服务

那么这个函数技术能做什么？这里有一个实际的开源的例子 URL 缩短器，请看 https://github.com/FBoucher/AzUrlShortener

[工具]微软的学习平台Microsoft Learn很好用，推荐一下 - dino.c - 博客园

dotnet C# 使用阿里函数计算服务

Azure 函数服务部署失败因为函数应用设置 v3 但主机是 v2 版本

Thu, 03 Dec 2020 12:27:50 +0000

在使用 Azure Function 函数服务的时候，将代码推送到函数服务器的时候提示 Your function app is targeting v3, but Azure host has function version 2 此时是因为在 Azure 的主机设置的版本落后函数的代码版本

在日志例如可以看到下面代码

Your function app is targeting v3, but Azure host has function version ~2, \nplease change the version using the portal or update your 'FUNCTIONS_EXTENSION_VERSION' appsetting and retry

在使用 git 推送可以看到下面代码

remote: Your function app is targeting v3, but Azure host has function version ~2,
remote: please change the version using the portal or update your 'FUNCTIONS_EXTENSION_VERSION' appsetting and retry
remote: Error - Changes committed to remote repository but deployment to website failed.

此时可以通过在 Azure 函数服务管理界面里面设置主机版本，通过点击函数应用设置

在部署中心里面将运行时版本修改为 ~3 然后回到函数服务点击重新部署，或者新推送空白内容都可以

用 C# 写脚本如何输出文件夹内所有文件名

Thu, 03 Dec 2020 12:27:50 +0000

大部分在 Windows 下的脚本都是使用 bat 或 cmd 写的，这部分的脚本对我来说可读性不好。这个可读性也是很主观的，对我来说用 C# 写脚本的可读性很强，但是换个小伙伴就不是了。在 .NET Core 下的 C# 可以通过 dotnet run 运行代码起来，此时特别适合用来写脚本

我需要输出一个文件夹里面的根目录的所有文件，输出一个文件夹的顶层文件的方法可以使用 Directory.GetFiles 拿到文件夹的顶层文件，然后遍历输出。此时注意需要引用 System.IO 命名空间

using System.IO;

        static void Main(string[] args)
        {
            var folder = @"e:\lindexi\";
            foreach (var file in Directory.GetFiles(folder))
            {
                Console.WriteLine(file);
            }

            Console.Read();
        }

这就是整个脚本的核心代码了，十分简单，通过 dotnet run 命令就可以跑起来

额外的，在 Directory.GetFiles 可以输入通配符进行选择输出的文件

            foreach (var file in Directory.GetFiles(folder, "*.enbx"))
            {
                Console.WriteLine(file);
            }

如上面代码就输出文件夹里面后缀是 .enbx 的文件

如果想要遍历所有的子文件夹的文件，可以通过加上 SearchOption.AllDirectories 参数

            foreach (var file in Directory.GetFiles(folder, "*.enbx", SearchOption.AllDirectories))
            {
                Console.WriteLine(file);
            }

本文代码放在 github 欢迎小伙伴访问

dotnet 用 Microsoft.Diagnostics.Runtime 库写代码解析 DUMP 文件

Thu, 03 Dec 2020 12:27:50 +0000

在分析 DUMP 进行自动化调试的时候，很多时候只能通过 WinDbg 和命令行调用的方式，这样的方式很难做到灵活。同时编写各个命令行的难度也特别高，这在需要对命令行的输出进行不同的分支的判断时候，难度会更大。于是找到了 Microsoft.Diagnostics.Runtime 库，这个库提供了简单的方式，可以在 C# 里面用代码写分析 DUMP 的代码

需要先在 NuGet 上添加一个私有的源才能使用这个库，添加私有源的方式请看 VisualStudio 给项目添加特殊的 Nuget 的链接

本文这里就添加了NuGet.config文件，详细内容请看github代码

<?xml version="1.0" encoding="utf-8"?>
<!-- This file should be kept in sync across https://www.github.com/dotnet/wpf and dotnet-wpf-int repos. -->
<configuration>
  <packageSources>
    <clear />
    <add key="dotnet-eng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
    <add key="dotnet5" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json" />
    <add key="dotnet5-transport" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5-transport/nuget/v3/index.json" />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
    <add key="dotnet-tools" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json" />
  </packageSources>
</configuration>

右击项目管理 NuGet 然后输入 Microsoft.Diagnostics.Runtime 然后切换到 dotnet-tools 源

找到一个有趣的项目，让他跑起来，然后炸掉他，这样就能拿到一个 DUMP 文件了。当然不炸掉他也可以，在任务管理器右击创建转储文件

假设放在 f:\lindexi\test\dotnet.exe.52348.dmp 文件，可以使用下面代码进行分析

 using (DataTarget dataTarget = DataTarget.LoadCrashDump(@"f:\lindexi\test\dotnet.exe.52348.dmp"))

此时就可以拿到 dataTarget 的 Clr 版本，请看代码

               foreach (ClrInfo version in dataTarget.ClrVersions)
                {
                    Console.WriteLine("Found CLR Version: " + version.Version);

                    // This is the data needed to request the dac from the symbol server:
                    ModuleInfo moduleInfo = version.ModuleInfo;

                    Console.WriteLine("Filesize:  {0:X}", moduleInfo.IndexFileSize);
                    Console.WriteLine("Timestamp: {0:X}", moduleInfo.IndexTimeStamp);
                    Console.WriteLine("Dac File:  {0}", moduleInfo.FileName);

                    // If we just happen to have the correct dac file installed on the machine,
                    // the "LocalMatchingDac" property will return its location on disk:
                    string dacLocation = version.LocalMatchingDac;
                    if (!string.IsNullOrEmpty(dacLocation))
                        Console.WriteLine("Local dac location: " + dacLocation);

                    // You may also download the dac from the symbol server, which is covered
                    // in a later section of this tutorial.
                }

更多的方法就请小伙伴自己去找找 API 了

本文只是一个简单的入门的博客，告诉大家有这个技术，因为这方向的调试技术需要涉及的技术特别多，也不是本渣能一篇博客能说明白的

本文代码放在github欢迎小伙伴访问

手把手教你如何构建 WPF 官方开源框架源代码

Thu, 03 Dec 2020 12:27:50 +0000

从去年微软就将 WPF 开源了，差不多现在所有 WPF 的源代码都开源了。在学习框架的时候，我会做一些改动，期望能构建一个自己的版本进行测试。但是作为一个特别大的框架，想要构建跑起来可不是直接在 VisualStudio 里面点击一下运行就完成了，需要做很多的准备才可以。本文将一步步教你如何构建 WPF 框架源代码

我不敢说每个版本的 WPF 框架的源代码我都能构建，在官方仓库 https://github.com/dotnet/wpf 我构建成功的版本是这个 commit 小伙伴可以尝试使用本文的方法，先切的这个 commit 按照我的方法来进行构建，成功了之后再做更新版本的尝试

阅读本文能让你了解如何构建WPF框架 https://github.com/dotnet/wpf源代码，但是不确保你一定能构建成功

构建 WPF 的步骤如下：

下载构建需要的依赖库
还原 NuGet 包
按照顺序构建 C++ 和 C# 代码，创建 NuGet 包

这里面对于咱国内的小伙伴，最坑的问题就是下载构建需要的库，需要的库如下

dotnet-sdk-5.0.100-preview.1.20155.7-win-x64.zip 安装
dotnet-runtime-5.0.0-preview.4.20220.15-win-x86.zip 安装
strawberry-perl-5.28.1.1-1-win64-x64.zip 放到 .netcoreeng\native\temp 文件夹
net-framework-48-ref-assemblies-0.0.0.1-win64-x64.zip 放到 .netcoreeng\native\temp 文件夹
dotnet-api-docs_netcoreapp3.0-0.0.0.2-win64-x64.zip 放到 .netcoreeng\native\temp 文件夹
msvcurt-c1xx-0.0.1.2-win64-x64.zip 放到 .netcoreeng\native\temp 文件夹
net-framework-472-iltools-0.0.0.1-win64-x64.zip 放到 .netcoreeng\native\temp 文件夹
dotnet-runtime-2.1.7-win-x86.zip 安装

上面说的 .netcoreeng\native\temp 文件夹就是在用户名下的如 C:\Users\lindexi\.netcoreeng\native\temp\ 文件夹

这些文件都是十分大的，同时有一些文件会下载放在系统的临时文件夹，如果一开始下载失败了，第二次不会进行校验，只会出现 IO 解压缩错误，此时就需要小伙伴清空自己的系统临时文件夹，用户临时文件夹和 C:\Users\lindexi\.netcoreeng\native\temp\ 文件夹

在进行构建的时候还需要让 VisualStudio 安装了差不多所有能装的负载，毕竟需要构建 C++ 这样的东西，这对 VisualStudio 版本也有要求。最低的 VisualStudio 要求是 16.4 版本

当前，我肯定不会一开始说这么劝退的方法，在本地构建的失败率太高了，即使是我全用梯子下载，也没有成功，因为有一点是在于构建的代码里面，微软的小伙伴认为网速都是特别快的，没有在一定的时间内下载完成就是失败。而我基本上每次都是下载到失败。同时失败之后下一次没有做校验，也就是除非我全部删除了重新下载，否则可能因为下载不完成构建一半翻车

一个简单的方法是利用 GitHub 的 Action 构建，感谢微软，微软收购了 GitHub 给了大量土豪的支持，所有小伙伴只要创建 GitHub 账号都能免费使用 GitHub 的 Action 构建代码。而构建的服务器可以选择 Windows 全环境服务器，在服务器里面安装了最新的 VisualStudio 和所有的负载，功能齐全，下载安装网速基本有 100M 一秒的速度。重要的是这么强大的服务器还是免费使用，不要钱，只要编写构建脚本就会自动执行

好，差不多广告费到手了，下面让我告诉大家如何使用 GitHub 的 Action 构建 WPF 的框架源代码

在开始之前先说为什么

原因一在于环境，因为 WPF 代码包含一部分 C++ 代码，这部分代码特别调环境。需要差不多将 VisualStudio 的全部功能安装才能。我就在这里翻车了，我就少安装了一个，然后就翻车了，但是很难猜到是少安装了，因为提示很诡异。虽然我就一句话，给 VisualStudio 按照全部功能，但是我预计你不会听我的

原因二在于网速，要下载的包还是大了一点，同时还原 NuGet 的服务器也没有国内源

刚好 GitHub 的 Action 都能满足条件，包含了全部环境，下载速度特别快

使用 GitHub 的 Action 的方法就是创建一个构建清单文件，放在 .github\workflows\ 文件夹里面。清单文件是 yml 格式，如 dotnetcore.yml 文件

这个清单文件的格式不是咱的重点，理论上小伙伴看了代码大概就能理解了，不需要去学习

name: .NET Core

on: [push]

jobs:
  build:

    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v1
    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: '5.x'
      
    - name: Build
      run: .\build.cmd -pack -ci -configuration Release -prepareMachine /p:Platform=x86

没错，将这个清单文件放在清单文件夹里面，如这个 commit 的做法就可以让 WPF 构建起来

上面的清单文件也是最简单的让 WPF 构建的代码了，核心代码是 .\build.cmd -pack -ci -configuration Release -prepareMachine /p:Platform=x86 通过这句代码就可以调用微软小伙伴写好的脚本进行构建

在日志里面看到输出构建了 nupkg 文件就是构建成功

2020-04-23T04:00:24.5493423Z   Successfully created package 'D:\a\wpf\wpf\artifacts\packages\Release\NonShipping\runtime.win-x86.Microsoft.DotNet.Wpf.GitHub.5.0.0-ci.nupkg'.
2020-04-23T04:00:40.3376680Z   Successfully created package 'D:\a\wpf\wpf\artifacts\packages\Release\NonShipping\Microsoft.DotNet.Arcade.Wpf.Sdk.5.0.0-ci.nupkg'.
2020-04-23T04:00:41.1278940Z   Successfully created package 'D:\a\wpf\wpf\artifacts\packages\Release\NonShipping\Microsoft.DotNet.Wpf.GitHub.5.0.0-ci.nupkg'.
2020-04-23T04:00:42.2993941Z   Successfully created package 'D:\a\wpf\wpf\artifacts\packages\Release\NonShipping\Microsoft.DotNet.Wpf.ProjectTemplates.5.0.0-ci.nupkg'.
2020-04-23T04:00:43.0266336Z   Successfully created package 'D:\a\wpf\wpf\artifacts\packages\Release\NonShipping\Microsoft.NET.Sdk.WindowsDesktop.5.0.0-ci.nupkg'.
2020-04-23T04:00:45.5485389Z 
2020-04-23T04:00:45.5486750Z Build succeeded.
2020-04-23T04:00:45.5488608Z     0 Warning(s)
2020-04-23T04:00:45.5489064Z     0 Error(s)
2020-04-23T04:00:45.5489325Z 
2020-04-23T04:00:45.5921119Z Time Elapsed 00:05:29.82

也就是最简单的构建 WPF 的方法就是先 Fork 官方仓库到自己的仓库，将 WPF 代码 Clone 到本地，切换 commit 到 f226a72ed5302737b14984cffdd6208731244038 版本，切换 commit 可以使用下面 Git 命令

git checkout f226a72ed5302737b14984cffdd6208731244038

然后新建一个分支，使用 Git 命令如下

git checkout -b 分支名

复制本文上面的清单文件的代码，在相对于 .git 文件夹的 .github\workflows\ 文件夹创建 dotnetcore.yml 文件，将上面的清单代码放入到 dotnetcore.yml 文件

使用 Git 创建 commit 或通过 VisualStudio 的团队管理创建 commit 推送到自己的 Fork 的仓库里面，此时将会触发 GitHub 的 Action 的自动构建

在构建完成的 WPF 的输出是 NuGet 包，在 artifacts\packages 文件夹

在构建成功之后，还请小伙伴试试切换 WPF 的源代码到最新，尝试构建一下

本地构建的方法相对来说比较复杂，虽然从上面的清单文件可以看到，其实构建的代码只有调用脚本一句话。但是本地需要先让环境搭建，如让 VisualStudio 安装全部功能等

本地构建的方法如下

先打开 VisualStudio 让 VisualStudio 安装全部的功能，特别是 C++ 的全部勾选

保持本地是系统是 Windows 10 最新版本

下载 Download the Windows Driver Kit (WDK) 安装，我不确定这是不是必须的

搭建好梯子，设置全局代理

通过 PowerShell 执行 .\build.cmd 脚本，注意此时不要添加任何后缀，这样将可以在输出信息里面快速知道是不是下载失败了

如果下载失败了，将会提示如解压缩失败等，此时请清空自己的系统临时文件夹，用户临时文件夹，和 .netcoreeng 文件夹。这里的 .netcoreeng 放在用户文件夹，如 C:\Users\lindexi\.netcoreeng\ 文件夹。清空 NuGet 缓存文件夹。调用 git clean -xdf 清空代码文件

可以通过梯子的输出找到当前需要下载的文件的链接，可以尝试做本地的代理，先用其他方式下载然后用 Fiddler 模拟路径提升下载速度

如果可以到输出下面代码，表示前面的下载工具应该完成

LINK : fatal error LNK1104: cannot open file 'MSVCURTD_netcore.LIB' [D:\a\wpf\wpf\src\Microsoft.DotNet.Wpf\src\DirectWriteForwarder\DirectWriteForwarder.vcxproj]

上面代码是因为没有指定 x86 的方式构建，在命令行运行 .\build.cmd -pack -ci -configuration Release -prepareMachine /p:Platform=x86 尝试构建

如果还是失败了，可以多次尝试上面的命令，先不要做任何的清理。或者先调用git clean -xdf 清理一下，然后继续调用上面命令

大概在尝试很多次，应该可以构建成功，之后就可以愉快打开 VisualStudio 了，在里面单独构建某个项目了。当然也不是所有的项目都能成功构建

在调用上面的脚本的命令里面，其实还有以下的调用方法，分别是进行 x86 和 x64 的构建，以及进行 Debug 和 Release 的构建

build.cmd -pack -ci -configuration $(Configuration) -prepareMachine /p:Platform=$(Platform)

请将上面代码的 $(Configuration) 替换为 Debug 或 Release 将 $(Platform) 替换为 x86 或 x64 进行构建

如果能生成官方的构建 ID 可以在命令行添加下面参数 /p:OfficialBuildId=$(BuildId) 这里的 BuildId 在官方仓库里面用的是 $(BUILD.BUILDNUMBER) 这是在 Azure Pipelines 的参数，大概的值的是 20190909.1 这样的值，可以自己随意给

上面参数的 -ci 是 arcade 提供的功能，用来启动 CI 构建

能构建官方开源代码就可以作出自己私有的版本，在使用上面命令构建完成之后，可以在 artifacts\packages 文件夹找到构建的 NuGet 包，这些文件可以私有发布，或者自己修改 Id 发布

现在微软的开源协议非常友好，允许小伙伴对源代码进行修改和发布

虽然可以进行自己的私有发布，当时我还是推荐将代码提到官方仓库，有官方的大佬帮忙看看代码是否合理。只要在官方的大佬认为代码不合理但是自己却觉得必须，或者官方发布太慢了，才使用自己的版本

原因是如果都用自己的版本，后续官方修了一些内容，将很难合并到自己的版本

本文提到的 GitHub 的 Action 请看 dotnet 部署 github 的 Action 进行持续集成

C# 为什么不建议对任意的 IEnumerable 反转

Thu, 03 Dec 2020 12:27:50 +0000

我想要反转一个枚举，但是代码审查没过，这是为什么

在 C# 里面可以使用 IEnumerable 表示枚举值，而我提供了一个库给小伙伴用，这个库包含了这个方法，需要在某个不知道从哪里来的枚举值进行反转然后处理业务

小伙伴说代码审查没过，原因是在他的设备上一运行就占用了 100G 的内存

我写的代码也很简单

        private static void Foo(IEnumerable<int> list)
        {
            foreach (var temp in list.Reverse())
            {
                // 业务
            }
        }

上面的代码有什么坑

虽然反转一个枚举可以使用 Reverse 方法，很方便，但是这个方法需要先将值进行 ToArray 然后再反转

而小伙伴可以通过下面代码写出一个有无限大的数组请看代码

        private static IEnumerable<int> WarellereleKeneaberecembe()
        {
            while (true)
            {
                yield return 0;
            }
        }

反转是需要知道这个值的最后一个是什么，按照上面的代码，对于一个有无限大的容量的数组，求最大的元素是哪个，其实就是无限大，刚好无限大在内存是无法表示的，所以就会不断申请内存计算

        static void Main(string[] args)
        {
            foreach (var temp in WarellereleKeneaberecembe().Reverse())
            {
                
            }
        }

        private static IEnumerable<int> WarellereleKeneaberecembe()
        {
            while (true)
            {
                yield return 0;
            }
        }

在想要写出 IEnumerable 反转之前，请先想一下上面的代码。特别是在做库的时候，小伙伴会传入的值会挖坑，所以我推荐反转需要知道这是有限数组

dotnet 在 OpenXML SDK 的 HasValue 是什么含义

Thu, 03 Dec 2020 12:27:50 +0000

在 OpenXML SDK 里面对于很多值，如字符串等的值，都包含一个 HasValue 属性。刚入门的小伙伴会认为这就是一个和可空类型一样的属性，表示这个属性是不是为空。其实这句话只是对一半，其实这个属性表示的是在重新定义的字符串参数里面的属性是否为空

在 OpenXML SDK 里面给很多基础类型都是自己新定义的，如 SingleValue 和 StringValue 等，这些定义都继承 OpenXmlSimpleType 类，而在 OpenXmlSimpleType 类就存在一个让刚入行的小伙伴会错误认为这是一个可空类型的 HasValue 属性

这个属性的命名刚好和可空类型相同，而刚好在 OpenXML SDK 里面存在大量的类型都是可能为空的。例如尝试获取文本的字体大小

    Int32Value fontSize = run.RunProperties.FontSize;

此时拿到了 fontSize 但是可能在 PPT 里面没有定义这个属性，也就是 fontSize 为空，此时如果没有判断就开始使用，将会在某些有趣的课件里面在这里炸掉

但是如果使用下面代码判断，将会如何？

    if (fontSize.HasValue)
    {
                
    }

哈哈，贺喜你踩到了这个 API 设计的坑，此时的 Int32Value 不是可空类型，也就是其实此时的 fontSize 是空，尝试获取他的属性将会炸掉

正确的做法是使用下面代码

if (fontSize != null)
{

}

那么这个 HasValue 的意思是什么？我将 OpenXmlSimpleType 的源代码写出来大家就知道了

        public virtual bool HasValue => TextValue != null;

没错，这个属性只是用来判断是否存在值，而不是判断自己本身是否是空

dotnet 用 ASP.NET Core 制作一个可以上传库文件的 NuGet 服务器

Thu, 03 Dec 2020 12:27:50 +0000

我在写一个有趣的 WPF 应用，我想要测试这个 WPF 应用的一个功能，这个功能就是一键点击自动推送 NuGet 包到服务器。我想要做一点自动化的测试，我需要有某个假装是 NuGet 的服务器用来接收我这个应用推送的 NuGet 包。用 ASP.NET Core 写一个假装的 NuGet 服务器，支持被 NuGet 推送包是特别简单的，本文就来和大家说说这个后台如何写

其实有现成的整个 NuGet 服务器，包含了包的列举和上传等功能，这就是 BaGet 项目，但是这个项目存在的问题是太大了，我想要做到自动测试里面去，又有很多有趣的逻辑需要写

那么自己从零开始写一个 NuGet 服务器，这个服务器只有一个功能就是接收 NuGet 推送的包，这个工作量大不大？在使用 ASP.NET Core 时只能说工作量特别小

下面让我用 3 分钟告诉大家如何在 asp dotnet core 里面写一个支持被推送 nuget 包的服务器

首先是创建一个空白的工程，此时这个功能请去掉 https 的逻辑，注意去掉 Startup.cs 的重定向逻辑。先跑通过了 http 之后小伙伴自己再去配置 https 哦

根据官方文档说的，默认的 NuGet 的上传文件就是通过发送一个 multipart form data 数据，发送到制定的源里面，例如我准备推送 ant-design-blazor.nupkg 库的时候，通过下面代码

nuget push -Source http://localhost:49614/api/v2/package AntBlazor.0.0.1.nupkg -ApiKey 123

将会向服务器 http://localhost:49614/api/v2/package 发送一个 multipart form data 数据，这个数据里面只包含了一个文件信息

在 asp dotnet core 可以通过下面代码接收 form 表单信息

        [HttpPut]
        public async Task<IActionResult> Push([FromForm]FilePackage package)
        {

        }

注意加上 FromForm 特性，如果没有加上特性那么将会返回客户端 415 Unsupported Media Type 信息

这里的 FilePackage 的定义如下

    public class FilePackage
    {
        public IFormFile Package { set; get; }
    }

此时从参数里面拿到的 package 属性就是客户端上传的对应的 NuGet 库

修改一下控制器的路径，这样才好假装这是一个 NuGet 服务器

    [ApiController]
    [Route("api/v2/[controller]")]
    public class PackageController : ControllerBase
    {
        [HttpPut]
        public async Task<IActionResult> Push([FromForm]FilePackage package)
        {
        	// 代码
        }
    }

这样就完成了制作一个假装的 NuGet 上传服务器了

其实如果不从参数里面获取客户端上传的 NuGet 库，还可以通过 HttpContext.Request.Form 拿到，请看代码

            var packageFile = package.Package;
            if (packageFile == null)
            {
                packageFile = HttpContext.Request.Form.Files.FirstOrDefault();
            }

而将 IFormFile 保存到本地也很简单，请看代码

            var file = Path.GetTempFileName();
            using (var stream = new FileStream(file, FileMode.OpenOrCreate))
            {
                await packageFile.CopyToAsync(stream);
            }

大概用不到3分钟就能完成一个假装的 NuGet 服务器

细心的小伙伴还发现了刚才的命令行有添加 ApiKey 信息，这个信息可以偷偷在 HttpContext.Request.Headers 拿到

             var key = HttpContext.Request.Headers["X-NuGet-ApiKey"];

本文代码放在 github 欢迎小伙伴访问

顺便广告一下 ant-design-blazor 这个使用 Blazor 的 ant 界面库，欢迎小伙伴关注

C# dotnet WPF 使用 OpenXml 解析 Excel 文件

Thu, 03 Dec 2020 12:27:50 +0000

在 2013 微软开源了 OpenXml 解析库，在微软的 Excel 文档，使用的文档格式就是国际规范的 OpenXml 格式。这个格式有很多版本，详细请看百度。因为表格文稿使用的是 OpenXml 在 .NET 开发可以非常简单将 Excel 文档进行解析，大概只需要两句话

本文通过一个简单的 WPF 程序告诉大家如何解析，这个简单的 WPF 程序简单到仅有一个按钮，在点击按钮时自动解析 Excel 文档的内容

用 OpenXML 能做什么？其实可以做的东西很多，例如在 WPF 或 UWP 或 Xamarin 等里面使用 OpenXML 解析读取 Excel 文件内容，读取 PPT 和 Word 等文档的内容，只要符合 OpenXML 格式就能进行读取

通过 NuGet 安装 Openxml 库，这个库支持跨平台，因为只是解析数据

然后在按钮点击的代码里面添加下面代码解析

using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    using (SpreadsheetDocument doc = SpreadsheetDocument.Open(fs, false))
    {

    }
}

大概这样就解析完成了，上面代码的 fileName 就是传入的文件，如下面代码

string fileName = @"f:\lindexi\FurlalloganarBerkojelfarwiwa.xlsx";

在 Excel 里面有多个标签，下面代码是获取第一个标签

WorkbookPart workbookPart = doc.WorkbookPart;
SharedStringTablePart sstpart = workbookPart.GetPartsOfType<SharedStringTablePart>().First();
SharedStringTable sst = sstpart.SharedStringTable;

WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
Worksheet sheet = worksheetPart.Worksheet;

如果读取格子里面内容，可以使用下面代码

var cells = sheet.Descendants<Cell>();
var rows = sheet.Descendants<Row>();

Debug.WriteLine("Row count = {0}", rows.LongCount());
Debug.WriteLine("Cell count = {0}", cells.LongCount());

// One way: go through each cell in the sheet
foreach (Cell cell in cells)
{
    if ((cell.DataType != null) && (cell.DataType == CellValues.SharedString))
    {
        int ssid = int.Parse(cell.CellValue.Text);
        string str = sst.ChildElements[ssid].InnerText;
        Debug.WriteLine("Shared string {0}: {1}", ssid, str);
    }
    else if (cell.CellValue != null)
    {
        Debug.WriteLine("Cell contents: {0}", cell.CellValue.Text);
    }
}

// Or... via each row
foreach (Row row in rows)
{
    foreach (Cell c in row.Elements<Cell>())
    {
        if ((c.DataType != null) && (c.DataType == CellValues.SharedString))
        {
            int ssid = int.Parse(c.CellValue.Text);
            string str = sst.ChildElements[ssid].InnerText;
            Debug.WriteLine("Shared string {0}: {1}", ssid, str);
        }
        else if (c.CellValue != null)
        {
            Debug.WriteLine("Cell contents: {0}", c.CellValue.Text);
        }
    }
}

如果想要了解解析的每个对象的内容，我推荐在对应的代码添加断点，如想要了解 row 的值等，可以如下图添加一个断点，然后通过局部变量窗口就可以看到每个变量的值

代码放在 github 欢迎小伙伴访问

如何添加断点请看 VisualStudio 断点调试详解

除了使用 OpenXML SDK 这个免费的库之外，还可以使用 EPPlus 这个收费或 LGPL 的库

更多请看 Office 使用 OpenXML SDK 解析文档博客目录

C# dotnet 高性能多线程工具 AsyncAutoResetEvent 异步等待使用方法和原理

Thu, 03 Dec 2020 12:27:50 +0000

在 C# 里面配合 dotnet 的 Task 可以作出 AsyncAutoResetEvent 高性能多线程工具，从命名可以看到 AsyncAutoResetEvent 的意思就是支持异步的自动线程等待事件，用于多线程竞争访问执行权，可以用在消费队列或用在限制有限线程执行的业务上

和框架自带的 AutoResetEvent 类一样的作用，表示线程同步事件在一个等待线程释放后收到信号时自动重置

和框架的不同在于 AsyncAutoResetEvent 使用的是异步等待方法，不会在线程池里面阻塞线程，可以让步线程，让线程去处理其他业务

适用

作用是支持使用方有多个线程方式访问执行权时，全部都会在 WaitOneAsync 里面阻塞，只有调用 Set 时才会释放，每调用一次释放一个

或者预先多次调用 Set 之后，仅有一个 WaitOneAsync 可以进入

线程在 WaitOneAsync 等待通过 await 而不是阻塞，可以回到线程池执行其他业务，这就是高性能的原因

如有一个线程专门用来制造数据，而有很多个线程需要处理这些数据，此时期望有数据的时候可以均衡自动分配给这些线程处理。没有数据的时候这些线程可以回到线程池里面执行其他业务

如我有并行的业务准备做，但是我期望只使用有限数量的线程去做，虽然我能给的业务量大于可以准备使用的线程数量，但是每次使用的线程数量都小于等于我限制的数量

如我有某个任务需要等待其他任务完成之后才能执行，但是可以等待的任务可以超过多个，也就是多个任务中只要有一个完成了，那么我这个任务就能执行。或者说只要曾经有等待的任务完成过，我的这个任务也能执行

注意，这个库不关注于单个任务的性能，因为会涉及返回线程池等，在 WaitOneAsync 可以进入之后还需要等待线程池调度才能继续，也就是如果 WaitOneAsync 可以进入，但是线程池没有线程可用，那么依然不会执行后续内容。这个库的高性能主要是对整体，通过不阻塞线程的方法最大程度提升性能

这个库开始的设计是用在 WPF 的多个动画播放完成以及对应的事件处理上，虽然本文会说到多线程但不意味真的需要使用多个线程处理。基于 WaitOneAsync 是用 await 会出让的原因，可以通过一个主线程玩出多线程的坑

使用方法

通过 NuGet 安装 dotnetCampus.AsyncWorkerCollection 库，此项目在 github 开源

使用 AsyncAutoResetEvent 仅提供两个方法，一个是 WaitOneAsync 另一个是 Set 方法

期望的用法是有很多线程通过 AsyncAutoResetEvent 对象的 WaitOneAsync 进行等待

        await asyncAutoResetEvent.WaitOneAsync();

然后在另一个线程创建数据或执行某些业务完成之后调用 Set 方法，每调用一次将会让一个在 WaitOneAsync 的线程继续往下执行

asyncAutoResetEvent.Set();

无论有多少个线程通过 WaitOneAsync 等待，实际上线程都因为使用了 await 而出让执行而不会阻塞，只有等待其他线程调用了 Set 方法，每调用一次将会有一个线程可以继续往下执行

可以使用一个单元测试作为例子

                // Arrange
                var asyncAutoResetEvent = new AsyncAutoResetEvent(false);
                var mock = new Mock<IFakeJob>();

                // Action
                asyncAutoResetEvent.Set();
                var task1 = Task.Run(async () =>
                {
                    await asyncAutoResetEvent.WaitOneAsync();
                    mock.Object.Do();
                });

                var task2 = Task.Run(async () =>
                {
                    await asyncAutoResetEvent.WaitOneAsync();
                    mock.Object.Do();
                });

                Task.WaitAny(task1, task2, Task.Delay(TimeSpan.FromSeconds(1)));

                // Assert
                mock.Verify(job => job.Do(), Times.Once);

细节如下

如果构造函数设置为 true 进入，那么第一个 WaitOneAsync 的线程将会持续执行，第二个 WaitOneAsync 的线程将会等待直到 Set 被调用
如果进行 WaitOneAsync 的调用次数小于 Set 调用次数，此时多余的 Set 将之后被记录一次。也就是当不存在任何一个线程在等待 WaitOneAsync 时，再调用 Set 多次，然后如果有多个线程再调用 WaitOneAsync 时，只有一个线程能继续执行，其他线程需要等待 Set 方法调用

原理

使用 TaskCompletionSource 支持进行 await 时出让执行，此时的线程会等待 TaskCompletionSource 被调用 SetResult 方法才会继续执行

在调用 WaitOneAsync 的时候，创建一个 TaskCompletionSource 返回给代码用来 await 因此此时 TaskCompletionSource 没有设置 SetResult 方法，也就是代码等待将会出让执行

在调用 Set 方法时才调用其中一个 TaskCompletionSource 的 SetResult 方法让其中一个等待的代码继续执行

    public class AsyncAutoResetEvent
    {
        /// <summary>
        /// 提供一个信号初始值，确定是否有信号
        /// </summary>
        /// <param name="initialState">true为有信号，第一个等待可以直接通过</param>
        public AsyncAutoResetEvent(bool initialState)
        {
            _isSignaled = initialState;
        }

        /// <summary>
        /// 异步等待一个信号，需要await
        /// </summary>
        /// <returns></returns>
        public Task WaitOneAsync()
        {
            lock (_locker)
            {
                if (_isSignaled)
                {
                    _isSignaled = false;
                    return CompletedSourceTask;
                }

                var source = new TaskCompletionSource<bool>();
                _waitQueue.Enqueue(source);
                return source.Task;
            }
        }

        /// <summary>
        /// 设置一个信号量，让一个waitone获得信号
        /// </summary>
        public void Set()
        {
            TaskCompletionSource<bool> releaseSource = null;
            lock (_locker)
            {
                if (_waitQueue.Any())
                {
                    releaseSource = _waitQueue.Dequeue();
                }

                if (releaseSource is null)
                {
                    if (!_isSignaled)
                    {
                        _isSignaled = true;
                    }
                }
            }

            releaseSource?.SetResult(true);
        }

        private static readonly Task CompletedSourceTask = Task.FromResult(true);

        private readonly Queue<TaskCompletionSource<bool>> _waitQueue =
            new Queue<TaskCompletionSource<bool>>();

        private bool _isSignaled;

        private readonly object _locker = new object();
    }

源代码请看 https://github.com/dotnet-campus/AsyncWorkerCollection/blob/480ba1159289eebf0e08996f866a4fa832099f4b/AsyncWorkerCollection/AsyncAutoResetEvent.cs

测试

此库其实在我的几个项目里面经过了一年的测试，大概在100w台设备上运行过，没有翻车

这样的库实际上单元测试作用不大……

感谢

此库 dotnet-campus/AsyncWorkerCollection: 多线程异步工具由多线程砖家头像用了一年的时间写的，因为自己业务使用也许没有测试出坑，于是开源出来，请小伙伴协助测试

C# dotnet 使用 OpenXml 解析 PPT 元素的坐标和宽度高度

Thu, 03 Dec 2020 12:27:50 +0000

在阅读本文之前，我期望你能了解基础的 PPT 解析内容，或看我的入门级博客。本文将告诉大家如何从 PPT 里面解析出通用元素的 x 和 y 的值，以及元素的宽度和高度的值

在开始之前请看 C# dotnet 使用 OpenXml 解析 PPT 文件在拿到 slidePart.Slide.CommonSlideData.ShapeTree 里面的元素，几乎所有元素都存在坐标和宽度高度，这里的元素我称为通用元素，也就是不是特定的如形状、图片元素

此时的元素应该是继承 OpenXmlElement 类，在这个类里面可以通过 GetFirstChild 找到 ShapeProperties 的值

            var shapeProperties = element.GetFirstChild<ShapeProperties>();

上面代码的 element 是 OpenXmlElement 类

拿到了 ShapeProperties 实际上就是 PPT 文件的 p:sppr 内容，在 PPT 里面将会用如下格式设置元素里面的值中 a:xfrm 就是 Transform2D 请看下面

<p:sppr>
    <a:xfrm>
        <a:off x="3292475" y="1300390">
        </a:off>
        <a:ext cx="6096000" cy="3429000">
        </a:ext>
    </a:xfrm>
    <a:prstgeom prst="rect">
        <a:avlst>
        </a:avlst>
    </a:prstgeom>
</p:sppr>

此时通过 var transform2D = shapeProperties.GetFirstChild<Drawing.Transform2D>(); 就能拿到 a:xfrm 的值

等等，这里的 Drawing.Transform2D 是什么意思，我在命名空间里面添加这个代码

using Presentation = DocumentFormat.OpenXml.Presentation;
using Drawing = DocumentFormat.OpenXml.Drawing;
using ShapeProperties = DocumentFormat.OpenXml.Presentation.ShapeProperties;

拿到 Transform2D 可以再获取 Offset 也就是 a:off 拿到 x 和 y 的大小

            var offset = transform2D.GetFirstChild<Drawing.Offset>();
            var offsetX = new Emu(offset.X.Value);
            var offsetY = new Emu(offset.Y.Value);

在 PPT 里面，通用元素的 x 和 y 值单位是 Emu 上面的类是我自己定义的，有可以抄的代码，请看 C# dontet Office Open XML Unit Converter 我定义了和像素转换的代码

可以通过 Extents 也就是 a:ext 获取元素的宽度和高度，请看代码

            var extents = transform2D.GetFirstChild<Drawing.Extents>();
            var extentWidth = new Emu(extents.Cx);
            var extentHeight = new Emu(extents.Cy);

ShapeProperties Class (DocumentFormat.OpenXml.Drawing.Pictures)

知道了元素的坐标如何在 UWP 中设置元素的坐标请看 win10 uwp 拖动控件

C# dotnet 使用 OpenXml 解析 PPT 里面的视频

Thu, 03 Dec 2020 12:27:50 +0000

本文告诉大家如何从 PPTX 文件里面解析出视频

我期望看到本文的小伙伴是了解 OpenXML 的，如果想要解析 Office 的文档，我推荐使用使用 OpenXML SDK 这个开源的库，更多入门级博客请看 C# dotnet 使用 OpenXml 解析 PPT 文件

我做了一个简单的 PPT 文件，这个文件里面只有一页，这一页上面有一个视频。做这个文件的作用是方便调试，本文将从这个文件里面拿到视频

            using (var presentationDocument =
                DocumentFormat.OpenXml.Packaging.PresentationDocument.Open(@"小视频.pptx", false))
            {
                var presentationPart = presentationDocument.PresentationPart;
                var slidePart = presentationPart.SlideParts.FirstOrDefault();

                // 忽略代码
            }

上面代码是打开解析文件，我拿到第一页，而获取页面的元素需要了解一点是 PPT 将所有元素存放 ShapeTree 而视频是不存在元素的，在 PPT 里面用 Picture 存放视频

<p:pic>
    <p:nvpicpr>
        <p:cnvpr id="4" name="视频">
            <a:hlinkclick action="ppaction://media" r:id="">
            </a:hlinkclick>
        </p:cnvpr>
        <p:cnvpicpr>
            <a:piclocks nochangeaspect="1">
            </a:piclocks>
        </p:cnvpicpr>
        <p:nvpr>
            <a:videofile r:link="rId2">
            </a:videofile>
            <p:extlst>
                <p:ext uri="{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}">
                    <p14:media r:embed="rId1" xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main">
                    </p14:media>
                </p:ext>
            </p:extlst>
        </p:nvpr>
    </p:nvpicpr>
</p:pic>

如上面代码，这就是视频元素其实也就是 Picture 元素，可以在 picture.NonVisualPictureProperties.ApplicationNonVisualDrawingProperties 找到 VideoFromFile 解析视频

                var picture = slidePart.Slide.CommonSlideData.ShapeTree.OfType<Picture>().FirstOrDefault();
                var videoFromFile = picture.NonVisualPictureProperties
                    .ApplicationNonVisualDrawingProperties
                    .GetFirstChild<VideoFromFile>();

而视频用的是 r:link 拿到对应的资源，在 PPT 里面，用 GetPartById 获取 ChildrenRelationshipParts 的资源，用 GetReferenceRelationship 拿到 ReferenceRelationshipList 的资源

在 PPT 里面的视频放在 ReferenceRelationshipList 使用下面代码拿到

           var openXmlPart = (DataPartReferenceRelationship) slidePart.GetReferenceRelationship(videoFromFile.Link.Value);

通过 GetStream 方法可以拿到压缩包里面的文件，此时不需要解压缩，新建文件写入就可以

                var stream = openXmlPart.DataPart.GetStream();
                var file = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "林德熙是逗比.mp4");
                File.WriteAllBytes(file, ReadAllBytes(stream));

代码放在 github 欢迎小伙伴访问

C# dontet Office Open XML Unit Converter

Thu, 03 Dec 2020 12:27:50 +0000

Here is my code to conver between OpenXML units.

Define

If you use csharp language version lower than 7.0, please remove the readonly keyword from the C# code below

    public readonly struct Cm
    {
        public Cm(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct Dxa
    {
        public Dxa(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct Emu
    {
        public Emu(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct FiftiethsOfAPercent
    {
        public FiftiethsOfAPercent(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct HalfPoint
    {
        public HalfPoint(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct Inch
    {
        public Inch(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct Mm
    {
        public Mm(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct Pixel
    {
        public Pixel(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

    public readonly struct Pt
    {
        public Pt(double value)
        {
            Value = value;
        }

        public double Value { get; }
    }

Convert

This is the code for converting different units of OpenXML

    public static class UnitConverter
    {
        public const double DefaultDpi = 96;

        #region Pixel

        public static Pixel ToPixel(this Inch inch) => inch.ToEmu().ToPixel();

        public static Inch ToInch(this Pixel pixel) => pixel.ToEmu().ToInch();

        #endregion

        #region Dxa

        public static Pt ToPt(this Dxa dxa)
        {
            return new Pt(dxa.Value / 20);
        }

        public static Dxa ToDxa(this Pt pt)
        {
            return new Dxa(pt.Value * 20);
        }

        public static Inch ToInch(this Dxa dxa)
        {
            return new Inch(dxa.Value / 72);
        }

        public static Dxa ToDxa(this Inch inch)
        {
            return new Dxa(inch.Value * 72);
        }

        #endregion

        #region Mm

        public static Cm ToCm(this Mm mm)
        {
            return new Cm(mm.Value / 10);
        }

        public static Mm ToMm(this Cm cm)
        {
            return new Mm(cm.Value * 10);
        }

        #endregion

        #region Pt

        public static Cm ToCm(this Pt pt)
        {
            return pt.ToEmu().ToCm();
        }

        public static Pt ToPt(this Cm cm)
        {
            return cm.ToEmu().ToPt();
        }

        public static Mm ToMm(this Pt pt)
        {
            return pt.ToCm().ToMm();
        }

        public static Pt ToPt(this Mm mm)
        {
            return mm.ToCm().ToPt();
        }

        public static Pt ToPt(this HalfPoint halfPoint)
        {
            return new Pt(halfPoint.Value / 2);
        }

        public static HalfPoint ToHalfPoint(this Pt pt)
        {
            return new HalfPoint(pt.Value * 2);
        }


        public static Pixel ToPixel(this Pt pt)
        {
            return new Pixel(pt.Value / 72 * DefaultDpi);
        }

        public static Pt ToPoint(this Pixel px)
        {
            return new Pt(px.Value * 72 / DefaultDpi);
        }

        #endregion

        #region Emu

        public static Emu ToEmu(this Inch inch)
        {
            return new Emu(inch.Value * 914400);
        }

        public static Inch ToInch(this Emu emu)
        {
            return new Inch(emu.Value / 914400);
        }

        public static Emu ToEmu(this Cm cm)
        {
            return new Emu(cm.Value * 360000);
        }

        public static Cm ToCm(this Emu emu)
        {
            return new Cm(emu.Value / 360000);
        }

        public static Emu ToEmu(this Mm cm)
        {
            return new Emu(cm.Value * 36000);
        }

        public static Dxa ToDxa(this Emu emu)
        {
            return new Dxa(emu.Value / 635);
        }

        public static Emu ToEmu(this Dxa dxa)
        {
            return new Emu(dxa.Value * 635);
        }

        public static Mm ToMm(this Emu emu)
        {
            return new Mm(emu.Value / 36000);
        }


        public static Emu ToEmu(this Pixel px)
        {
            return new Emu(px.Value * 914400 / DefaultDpi);
        }

        public static Pixel ToPixel(this Emu emu)
        {
            return new Pixel(emu.Value / 914400 * DefaultDpi);
        }

        public static Emu ToEmu(this Pt pt)
        {
            return new Emu(pt.Value * 12700);
        }

        public static Pt ToPt(this Emu emu)
        {
            return new Pt(emu.Value / 12700);
        }

        #endregion
    }

Test

The code in this article is not technical, but if you copy the code, it will reduce your time.

        private void AssertDoubleEqual(double a, double b)
        {
            Assert.AreEqual(true, Math.Abs(a - b) < 0.001);
        }

                var pt = new Pt(1);

                AssertDoubleEqual(20, pt.ToDxa().Value);
                AssertDoubleEqual(12700, pt.ToEmu().Value);
                AssertDoubleEqual(0.3527777777777777, pt.ToMm().Value);
                AssertDoubleEqual(0.035277777777777776, pt.ToCm().Value);
                AssertDoubleEqual(0.01388888888, pt.ToEmu().ToInch().Value);

                var mm = new Mm(1000);

                AssertDoubleEqual(100, mm.ToCm().Value);
                AssertDoubleEqual(39.370078740157, mm.ToEmu().ToInch().Value);
                AssertDoubleEqual(2834.64566929133, mm.ToPt().Value);
                AssertDoubleEqual(56692.913385826, mm.ToEmu().ToDxa().Value);
                AssertDoubleEqual(36000000, mm.ToEmu().Value);

See Office Open XML file formats - Wikipedia

English Metric Units and Open XML

Office Open XML Dashboard

Points, inches and Emus: Measuring units in Office Open XML – Lars Corneliussen

[译]Points、inches和EMUs：Office Open XML中的度量单位 - 知乎

Office Open XML 的测量单位

dotnet 基于 debian 创建一个 docker 的 sdk 镜像

Thu, 03 Dec 2020 12:27:50 +0000

我不能用官方的镜像，因为我需要在小伙伴构建的 debian 镜像上面安装 dotnet sdk 用来做构建，其实在 docker 里面需要找到一个个文件，然后复制代码

这是小伙伴做的一个 jenkins 的镜像 jenkins/slave 我需要在这个镜像基础上安装 dotnet 进行构建

FROM jenkins/slave

在安装 dotnet 之前需要通过官方 https://github.com/dotnet/dotnet-docker 找到对应的 docker 文件，这样可以进行复制，可以看到官方是引用下面代码 buildpack-deps:buster-scm 这个库

FROM buildpack-deps:buster-scm 

需要找到 buildpack-deps:buster-scm 的代码

找到这个库的代码 https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/buster/curl/Dockerfile 可以复制，但是这个库依赖 FROM buildpack-deps:buster-curl 这个库，通过 docker hub 找到 https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/buster/curl/Dockerfile 也可以复制

# https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/buster/curl/Dockerfile
# FROM debian:buster
RUN apt-get update && apt-get install -y --no-install-recommends \
        ca-certificates \
        curl \
        netbase \
        wget \
    && rm -rf /var/lib/apt/lists/*
 
RUN set -ex; \
    if ! command -v gpg > /dev/null; then \
        apt-get update; \
        apt-get install -y --no-install-recommends \
            gnupg \
            dirmngr \
        ; \
        rm -rf /var/lib/apt/lists/*; \
    fi
 
# FROM buildpack-deps:buster-curl
# https://github.com/docker-library/buildpack-deps/blob/99a1c33fda559272e9322b02a5d778bbd04154e7/buster/scm/Dockerfile
# procps is very common in build systems, and is a reasonably small package
RUN apt-get update && apt-get install -y --no-install-recommends \
        git \
        mercurial \
        openssh-client \
        subversion \
        \
        procps \
    && rm -rf /var/lib/apt/lists/*

使用 dotnet 官方地址下载速度太慢了，我请了小伙伴帮我下载，然后我将 dotnet-sdk-3.1.102-linux-x64.tar.gz 和 PowerShell.Linux.x64.7.0.0-rc.2.nupkg 放在 docker 文件相同文件夹

接下来是复制 dotnet 的代码

# https://raw.githubusercontent.com/dotnet/dotnet-docker/74c92451ecbd2876280ad51736a6eea4e98a1fb2/3.1/sdk/buster/amd64/Dockerfile
# FROM buildpack-deps:buster-scm
ENV \
    # Enable detection of running in a container
    DOTNET_RUNNING_IN_CONTAINER=true \
    # Enable correct mode for dotnet watch (only mode supported in a container)
    DOTNET_USE_POLLING_FILE_WATCHER=true \
    # Skip extraction of XML docs - generally not useful within an image/container - helps performance
    NUGET_XMLDOC_MODE=skip \
    # PowerShell telemetry for docker image usage
    POWERSHELL_DISTRIBUTION_CHANNEL=PSDocker-DotnetCoreSDK-Debian-10
 
# Install .NET CLI dependencies
RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        libc6 \
        libgcc1 \
        libgssapi-krb5-2 \
        libicu63 \
        libssl1.1 \
        libstdc++6 \
        zlib1g \
    && rm -rf /var/lib/apt/lists/*
 
# Install .NET Core SDK
# 不从 https://dotnetcli.azureedge.net 下载，从本地复制
RUN dotnet_sdk_version=3.1.102 \
#    && curl -SL --output dotnet.tar.gz https://dotnetcli.azureedge.net/dotnet/Sdk/$dotnet_sdk_version/dotnet-sdk-$dotnet_sdk_version-linux-x64.tar.gz \
    && dotnet_sha512='9cacdc9700468a915e6fa51a3e5539b3519dd35b13e7f9d6c4dd0077e298baac0e50ad1880181df6781ef1dc64a232e9f78ad8e4494022987d12812c4ca15f29' \
    && echo "$dotnet_sha512 dotnet.tar.gz" | sha512sum -c - \
    && mkdir -p /usr/share/dotnet \
    && tar -ozxf dotnet.tar.gz -C /usr/share/dotnet \
    && rm dotnet.tar.gz \
    && ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet \
    # Trigger first run experience by running arbitrary cmd
    && dotnet help
 
# 不从 https://pwshtool.blob.core.windows.net 下载，从本地复制
# Install PowerShell global tool
RUN powershell_version=7.0.0-rc.2 \
#    && curl -SL --output PowerShell.Linux.x64.$powershell_version.nupkg https://pwshtool.blob.core.windows.net/tool/$powershell_version/PowerShell.Linux.x64.$powershell_version.nupkg \
#   && powershell_sha512='59abcc11bd43fc8c1938a1854447c762092f03b5e2c6c354a82559eed6852e3920c5543c085fbe6fbe98871f96cd7409bb76b1537d3d8dee4e7432d578ec7603' \
#   && echo "$powershell_sha512  PowerShell.Linux.x64.$powershell_version.nupkg" | sha512sum -c - \
    && mkdir -p /usr/share/powershell \
    && dotnet tool install --add-source / --tool-path /usr/share/powershell --version $powershell_version PowerShell.Linux.x64 \
    && dotnet nuget locals all --clear \
    && rm /PowerShell.Linux.x64.$powershell_version.nupkg \
    && ln -s /usr/share/powershell/pwsh /usr/bin/pwsh \
    && chmod 755 /usr/share/powershell/pwsh \
    # To reduce image size, remove the copy nupkg that nuget keeps.

运行 docker build -t dotnet-sdk:3.0.102 . 就可以创建了

全部代码

FROM jenkins/slave

COPY dotnet-sdk-3.1.102-linux-x64.tar.gz dotnet.tar.gz
COPY PowerShell.Linux.x64.7.0.0-rc.2.nupkg /

# 使用国内源
RUN echo "" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian/ buster main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian/ buster main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian-security/ buster/updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian-security/ buster/updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian/ buster-updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian/ buster-updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian/ buster-backports main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian/ buster-backports main contrib non-free" >> /etc/apt/sources.list

# https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/buster/curl/Dockerfile
# FROM debian:buster
RUN apt-get update && apt-get install -y --no-install-recommends \
		ca-certificates \
		curl \
		netbase \
		wget \
	&& rm -rf /var/lib/apt/lists/*

RUN set -ex; \
	if ! command -v gpg > /dev/null; then \
		apt-get update; \
		apt-get install -y --no-install-recommends \
			gnupg \
			dirmngr \
		; \
		rm -rf /var/lib/apt/lists/*; \
	fi

# FROM buildpack-deps:buster-curl
# https://github.com/docker-library/buildpack-deps/blob/99a1c33fda559272e9322b02a5d778bbd04154e7/buster/scm/Dockerfile
# procps is very common in build systems, and is a reasonably small package
RUN apt-get update && apt-get install -y --no-install-recommends \
		git \
		mercurial \
		openssh-client \
		subversion \
		\
		procps \
	&& rm -rf /var/lib/apt/lists/*

# https://raw.githubusercontent.com/dotnet/dotnet-docker/74c92451ecbd2876280ad51736a6eea4e98a1fb2/3.1/sdk/buster/amd64/Dockerfile
# FROM buildpack-deps:buster-scm
ENV \
    # Enable detection of running in a container
    DOTNET_RUNNING_IN_CONTAINER=true \
    # Enable correct mode for dotnet watch (only mode supported in a container)
    DOTNET_USE_POLLING_FILE_WATCHER=true \
    # Skip extraction of XML docs - generally not useful within an image/container - helps performance
    NUGET_XMLDOC_MODE=skip \
    # PowerShell telemetry for docker image usage
    POWERSHELL_DISTRIBUTION_CHANNEL=PSDocker-DotnetCoreSDK-Debian-10

# Install .NET CLI dependencies
RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        libc6 \
        libgcc1 \
        libgssapi-krb5-2 \
        libicu63 \
        libssl1.1 \
        libstdc++6 \
        zlib1g \
    && rm -rf /var/lib/apt/lists/*

# Install .NET Core SDK
# 不从 https://dotnetcli.azureedge.net 下载，从本地复制
RUN dotnet_sdk_version=3.1.102 \
#    && curl -SL --output dotnet.tar.gz https://dotnetcli.azureedge.net/dotnet/Sdk/$dotnet_sdk_version/dotnet-sdk-$dotnet_sdk_version-linux-x64.tar.gz \
    && dotnet_sha512='9cacdc9700468a915e6fa51a3e5539b3519dd35b13e7f9d6c4dd0077e298baac0e50ad1880181df6781ef1dc64a232e9f78ad8e4494022987d12812c4ca15f29' \
    && echo "$dotnet_sha512 dotnet.tar.gz" | sha512sum -c - \
    && mkdir -p /usr/share/dotnet \
    && tar -ozxf dotnet.tar.gz -C /usr/share/dotnet \
    && rm dotnet.tar.gz \
    && ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet \
    # Trigger first run experience by running arbitrary cmd
    && dotnet help

# 不从 https://pwshtool.blob.core.windows.net 下载，从本地复制
# Install PowerShell global tool
RUN powershell_version=7.0.0-rc.2 \
#    && curl -SL --output PowerShell.Linux.x64.$powershell_version.nupkg https://pwshtool.blob.core.windows.net/tool/$powershell_version/PowerShell.Linux.x64.$powershell_version.nupkg \
#   && powershell_sha512='59abcc11bd43fc8c1938a1854447c762092f03b5e2c6c354a82559eed6852e3920c5543c085fbe6fbe98871f96cd7409bb76b1537d3d8dee4e7432d578ec7603' \
#   && echo "$powershell_sha512  PowerShell.Linux.x64.$powershell_version.nupkg" | sha512sum -c - \
    && mkdir -p /usr/share/powershell \
    && dotnet tool install --add-source / --tool-path /usr/share/powershell --version $powershell_version PowerShell.Linux.x64 \
    && dotnet nuget locals all --clear \
    && rm /PowerShell.Linux.x64.$powershell_version.nupkg \
    && ln -s /usr/share/powershell/pwsh /usr/bin/pwsh \
    && chmod 755 /usr/share/powershell/pwsh \
    # To reduce image size, remove the copy nupkg that nuget keeps.

我将本文用到两个资源 CSDN 如果没法下载请发我邮件

dotnet-sdk-3.1.102-linux-x64.tar.gz

PowerShell.Linux.x64.7.0.0-rc.2.nupkg

dotnet 用 NuGet 将自己的工具作为 dotnet tool 分发

Thu, 03 Dec 2020 12:27:50 +0000

我写了一个有趣的工具，我如何将这个工具给到小伙伴予力众生呢？只需要设定这个工具是 dotnet tool 工具就可以通过 NuGet 分发出去啦。几乎所有的 dotnet 开发者都能用上 NuGet 服务，也就是此工具可以被几乎所有的 dotnet 开发者下载使用。那么制作难度有多大呢？基本上有一个现成的项目前提下，只需两句代码，一句命令行，就能完成制作

本文分为两部分，第一部分就是如何打包一个 dotnet tool 工具，第二部分是如何分发这个工具

在开始之前，我推荐你先安装好 VisualStudio 工具，在 VisualStudio 2019 的帮助下，能够快速简单进行打包和发布

如何打包 dotnet tool 工具

其实 dotnet tool 工具没有任何黑科技，原理就是用 dotnet tool install 命令，这个命令将会通过后续传入的包的 id 从 NuGet 上寻找这个工具，下载到本地。此时要求工具本身不需要做安装包等类似的部署，而是直接复制文件过来就能使用的工具

工具的前提要求就是，这个工具本身通过复制文件的形式就能在设备上运行，无需部署

而 NuGet 包的本质就是一个压缩包，将这个工具压缩，然后修改为 NuGet 包，上传到 NuGet 上，这样就支持其他人从 NuGet 上下载这个工具的压缩包。那么工具和其他库的包有什么不同？其实就是在格式上标记这个包是一个工具包而不是一个库的包。关于这个工具包的更多细节请看 dotnet 手工打一个 dotnet tool 包

知道了这个原理之后咱就知道了，如果是 dotnet core 纯控制台工具，是可以在任何能运行 dotnet 的平台上运行的。而如果是 WPF .NET Core 那么就是能在 win7 sp1 和以上的系统上运行。如果是采用跨平台 UI 技术如 Avalonia 等，那么就能支持在对应平台上运行。这也就是没有限制工具一定只能作为控制台了

将一个现存的 dotnet net core 工具作为 dotnet tool 发布很简单，只有以下步骤

根据 Edi 的博客教你自制.NET Core Global Tools可以看到只需要在 VisualStudio 2019 里面双击项目，就可以进入编辑 csproj 文件了，当然右击编辑项目也可以。注意要能双击进去编辑 csproj 要求使用 SDK Style 格式的项目文件，本文也只对此格式的项目文件生效

在里面添加下面代码

<PackAsTool>true</PackAsTool>

<ToolCommandName>azureblobsync</ToolCommandName>

上面代码的 PackAsTool 就是告诉 VS 等工具这是一个 dotnet tool 工具，到时候将它输出为 NuGet 库，同时在 NuGet 库里面标记这是工具

第二句代码是 ToolCommandName 这里面的内容就是用来在安装工具之后，通过什么样的命令启动这个工具，换句话说就是安装工具用的是 NuGet 包的 Id 而和执行工具用的命令可以不相同

此时这个工具打包之后，在安装完成之后，在cmd里面启动这个工具就是通过 azureblobsync 这句命令了

在 VisualStudio 2019 里面右击项目，点击打包，此时就可以看到 VisualStudio 打出了一个 NuGet 包了。如果不够自信的话，可以先测试测试这个打出来的工具包

测试方法非必要，作为一个自信的程序员，自己写出来的工具怎么需要测试呢？反正有问题了再升级一个版本发布咯

等等，我打出来的 NuGet 包放在哪里？其实从 VisualStudio 的输出就可以看到类似下面代码

已成功创建包“D:\程序\dotnet 职业技术学院\dotnetCampus.NugetMergeFixTool\bin\Debug\NugetMergeFixTool.1.0.6.nupkg”

我要安装这个本地包可以如何做？

右击项目管理 Nuget 包

点击设置

点击添加一个本地的包，修改输出包的文件夹

设置完成之后打开cmd命令行输入下面代码安装自己的 NuGet 库

dotnet tool install -g NugetMergeFixTool 

如果安装成功了，通过 azureblobsync 命令试试能否打开自己的工具。注意请将上面的 NugetMergeFixTool 修改为升级上你打包出来的 NuGet 的 Id 哦，一般 NuGet 的 Id 就是 nuget 包的名字。而 azureblobsync 就是在上方给 csproj 设置的工具启动名了

如果觉得上面步骤太繁琐，也可以忽略，毕竟这只是测试使用而已。作为自信的程序员，代码不用测试就能发布（这是说笑的，小朋友不要模仿

分发工具

接下来我如何将我这个库上传到 NuGet 官方网站？首先打开 https://www.nuget.org/ 网站，点击 sign in 登录

有微软帐号的用微软帐号，没有微软帐号的，自己注册一个，注册步骤很简单，基本上看界面就会了

注册完成之后点击 Upload 上传自己刚才打出来的库

理论上只要不是有提示出错的，其他都可以忽略，点击上传之后就等待一小段时间，如去吃个饭。回来基本上就可以看到发布完成了，此时可以告诉小伙伴在命令行输入一段神奇的代码安装你的工具，然后使用一段有趣的代码启动你的工具

dotnet tool install -g NugetMergeFixTool // 这句代码安装工具
azureblobsync // 执行工具

注意将上面代码的 NugetMergeFixTool 和 azureblobsync 分别更换为你的 NuGet 包的 Id 和你的工具启动名

这就是 dotnet 工具的强大了，可以通过 dotnet 工具使用 NuGet 上超级多的工具

当然，程序员都喜欢自动化，如果是开源在 Github 的可以使用 dotnet 配置 github 自动打包上传 nuget 文件

同时包含 GitHub 自动用 Action 打包发布以及整个 dotnet tool 配置的代码请看 dotnet-campus/dotnetCampus.NugetMergeFixTool: 传说博哥的工具可以用来修复 git 合并的时候将 csproj 合并坏了的问题，也可以用来快速升级 NuGet 库

上面这个工具是一个适用于大团队里面合并代码冲突的快速修复工具，可以提升超级多的效率

更多博客

dotnet tool 安装失败因为对应的库不仅包含工具

Thu, 03 Dec 2020 12:27:50 +0000

在开发 dotnet tool 时，我将规范编码的库作为 dotnet tool 发布，但是在发布的时候本地进行安装提示DotnetToolReference 项目类型仅可包含 DotnetTool 类型的引用

因为我的库本身也是作为可被引用的项目库发布的，在发布的时候我选择的库是多个平台的。多个平台的框架的写法请看让一个 csproj 项目指定多个开发框架 - walterlv

但是这样写的多框架的包如果作为 dotnet tool 发布，那么将会在安装的时候有下面代码提示

error NU1212: dotnetCampus.EncodingNormalior 1.3.0 的项目包组合无效。DotnetToolReference 项目类型仅可包含 DotnetTool 类 型的引用
无法还原工具包。
工具“dotnetcampus.encodingnormalior”安装失败。此故障可能由以下原因导致:

* 你尝试安装预览版，但未使用 --version 选项来指定该版本。
* 已找到具有此名称的包，但是它不是 .NET Core 工具。
* 无法访问所需的 NuGet 源，这可能是由于 Internet 连接问题导致。
* 工具名称输入错误。

有关更多原因(包括强制包命名)，请访问 https://aka.ms/failure-installing-tool

英文版本请看下面

error NU1212: Invalid project-package combination for awesome-tool 1.0.0. DotnetToolReference project style can only contain references of the DotnetTool type

从 dotnet 手工打一个 dotnet tool 包可以知道一个工具包需要在 nuspec 文件里面包含下面代码

    <packageTypes>
      <packageType name="DotnetTool" />
    </packageTypes>

而在压缩包里面存在 Tools 文件夹，而这个文件夹里面有一个 DotnetToolSettings.xml 文件，如果这个要求不满足，那么在 dotnet core 3.1 的版本将安装失败

也就是调试方法是打开打包出来的 NuGet 包，因为本质 NuGet 包就是压缩文件，解压缩，然后看看是否不符合上面两个点，如果不符合那就是本文说的原因了

解决方法是将 csproj 设置为单框架项目，要求这是一个 dotnet core 框架，然后设置 PackAsTool 和 ToolCommandName 属性，详细请看 dotnet 用 NuGet 将自己的工具作为 dotnet tool 分发

如果我的库同时也是作为依赖库，显然这个方法是不成的，我找了很久没有找到在一个 csproj 里面能做出来的解决方法。但是我可以重新创建一个 csproj 文件，让这个 csproj 文件负责打包工具包。这个还请小伙伴看我的源代码，我原本的文件是 EncodingNormalior.csproj 文件，然后我将这个文件修改为 SDK Style 的格式，修改后请看 EncodingNormalior.csproj 但是这个源代码存在一个问题是需要作为 dotnet framework 4.6.1 的库。这和 dotnet tool 冲突

于是我在相同文件夹再创建一个 dotnetCampus.EncodingNormalior.csproj 就解决了

这个迁移的代码请看添加自动打包 by lindexi · Pull Request #27 · dotnet-campus/EncodingNormalior

dotnet tool install of local tool fails due to NU1212 · Issue #9775 · dotnet/sdk

.NET Core Global Tools and Gotchas

dotnet 手工打一个 dotnet tool 包

dotnet 用 NuGet 将自己的工具作为 dotnet tool 分发

让一个 csproj 项目指定多个开发框架 - walterlv

dotnet 通过 dotnetCampus.YamlToCsharp 将 YAML 多语言文件构建为代码

Thu, 03 Dec 2020 12:27:50 +0000

我在团队内的几乎所有 dotnet 项目，包括 UWP 和 WPF 桌面端以及 Xamarin 移动端和 ASP.NET Core 后端等需要用到多语言的项目，我的多语言都是通过 YAML 写的，这样相对来说在项目比较小的时候维护方便。但是 YAML 写的文件要读取需要用到 YAML 解析等，这部分的解析速度不够快，于是我就写了一个工具，用于在软件构建的时候自动将 YAML 多语言文件构建为代码。这样不仅能提升软件的执行速度，还能减少软件发布时需要带出去 YAML 解析库

用 YAML 做多语言有什么好处？其实在项目用的语言项不多的时候可读性还是很好的，维护起来也很清真

但是用 YAML 作为输出的缺点是需要在软件运行的时候解析这个 YAML 多语言文件，而解析 YAML 多语言文件需要 YAML 解析库，但是实际上我可以在软件构建的时候将 YAML 文件转换为 C# 代码，这样我就可以在软件运行的时候不需要解析这个 YAML 文件，提升我软件的运行速度

在客户端的应用，很多时候在软件运行第一个界面就需要用到多语言，而启动的时候文件读写最多的。如果此时还需要读取 YAML 文件，那么对软件启动速度还是很伤的。而刚好 dotnet 的一项技术就是 Roslyn 预编译技术，虽然本文用到的技术和 Roslyn 没有什么关系。但是可以在软件构建的时候将 YAML 转 C# 相当于将用户需要执行的时间放在构建时间上，基本上可以认定构建只需要一次，而用户端需要执行很多次，这部分节省的时间只要小伙伴不砍我就可以了

那么我如何在构建的时候将 YAML 转 C# 代码，放心我开源了一个工具，可以用来协助小伙伴从 YAML 生成 C# 代码

每个项目和框架使用的多语言风格都不相同，但是基本上都能作为一个字典的形式创建，也就是多语言项和多语言内容

也就是我需要将 YAML 转换为对应的 C# 的字典

在辅助构建项目里面添加 dotnetCampus.YamlToCsharp 库，然后可以在辅助构建多语言项目里面使用库里面的工具方法将 YAML 文件转换为 C# 代码文件

在 YamlFileToCsharpFile 类就提供了将 YAML 转换为 C# 的字典的方法，需要传入 YAML 文件和转换保存的 C# 代码文件地址，以及这个 C# 代码文件的类命名控件和类继承的接口和类名，以及返回多语言字典的方法

假设我的 YAML 文件为 C:\lindexi\1.yml 我期望将 1.yml 文件转换为 Foo.cs 文件，可以使用下面代码

var yamlFileToCsharpFile = new YamlFileToCsharpFile();
yamlFileToCsharpFile.ParseToCsharpFile(new FileInfo(@"C:\lindexi\1.yml"), new FileInfo("Foo.cs"));

此时默认创建的代码的命名空间是 dotnetCampus.Localizations 而返回多语言的方法是 GetLang 而类名则是传入的文件名

$@"//------------------------------------------------------------------------------
// <auto-generated>
//     此代码由工具生成。
//     运行时版本:4.0.30319.42000
//
//     对此文件的更改可能会导致不正确的行为，并且如果
//     重新生成代码，这些更改将会丢失。
// </auto-generated>
//------------------------------------------------------------------------------

using System.Collections.Generic;

namespace {classNamespace}
{{
    [System.CodeDom.Compiler.GeneratedCode(""dotnetCampus.YamlToCsharp"", ""1.0.0"")]
    public class {className} {interfaceName}
    {{
        public Dictionary<string, string> {methodName}()
        {{
            return {dictionary};
        }}
    }}
}}";

这个工具适用于在各个开发框架里面，因为这个工具不会被放入最终创建的项目，而是将这个工具生成的代码放入项目中。这个工具创建的代码使用的内容又全部是很基础的 C# 类的内容，虽然有一个特别的特性，但是这个特性是给 VisualStudio 用的，如果你有项目不认识这个特性，只要你提个 Issus 我就去优化

通过这个方式不仅能用上 YAML 简洁多语言配置，同时兼顾软件的运行性能

但是如何将这个库作为一个工具帮助你生成工具就需要你自己写额外的工具咯，因为这个框架使用的多语言都不同

这个库是开源的，请看 dotnet-campus/dotnetCampus.YamlToCsharp: 将 YAML 文件转 C# 代码

如何写一个构建时执行的工具，在构建中添加自己的步骤请看下面博客

如何创建一个基于命令行工具的跨平台的 NuGet 工具包 - walterlv

希沃白板如何解决手机端播放课件内视频出现黑屏闪退

Thu, 03 Dec 2020 12:27:50 +0000

使用希沃白板的手机端或微信小程序端播放视频时，会受到手机和微信浏览器的限制，能播放的视频格式有限，请在制作课件时转换好视频格式才进行直播等

我最近在使用希沃白板的云直播功能，希沃白板的云直播功能十分好用，特别是可以和学生互动的功能

但是有一些调皮的学生告诉我，用希沃白板的微信小程序观看时会出现软件黑屏和闪退，一开始我还以为是调皮的学生在骗我，后续才发现是视频或图片的格式不兼容的问题

本文可以解决以下问题

希沃白板学生端播放视频闪退
希沃白板学生端播放视频黑屏
希沃白板学生端播放一半白屏
希沃白板看不到图片
希沃白板图片空白
希沃白板图片变黑
希沃白板音频无法播放
希沃白板多媒体修复
希沃白板视频修复
希沃白板图片修复
希沃白板白屏修复
希沃白板视频没有全屏显示，只有四分之一大小

请到格式工厂官方主页 - 免费多功能的多媒体文件转换工具 http://www.pcgeshi.com/ 下载安装

将文件拖进去然后选择对应格式就可以

能支持格式视频：mp4 avi 图片:png 音频:mp4 尽管希沃白板PC端能支持更多格式，但手机端不能

请使用格式工厂将视频转换为mp4格式，即使原本就是mp4格式。原因是mp4格式有很多不同版本，当前手机端只支持H264版的mp4格式

使用格式工厂转换后如果图片依然不能显示，建议使用图片编辑工具或截图减少图片的宽度和高度（分辨率）即使图片本身是png也依然转换png格式

因为图片的宽度和高度太大时，或者压缩算法比较诡异时，在手机端微信端将会打不开，或者打开卡炸了

如果担心录制了半天之后，上传炸了，网络炸了或者学生端播放不了，可以在录制的同时，在后台开启一个屏幕录制软件，如希沃的剪辑师或bilibili直播软件或虎牙等。这个软件作为备份，如果希沃这边用不了，那么还能有备份的软件将录制的内容作为视频输出

这几天我都在找好用的适合教育的直播工具，找了很久发现就是希沃白板最好用了

欢迎加入希沃白板官方群 1047894869

如果想玩插件欢迎加入希沃白板插件群非官方 619366360

希沃白板如何解决手机端播放课件内视频出现黑屏闪退 - 分享汇 - 希沃论坛

应用商店的战略地位

Thu, 03 Dec 2020 12:27:50 +0000

应用商店在各大系统和平台上基本都有，最成功的是安卓和 ios 的应用商店。但现在应该需要加上微信了，在我看微信的小程序其实就是应用商店。微信其实算 os 了，微信提供了入口和流量，用户需要功能，用户进入应用商店下载安装应用。而真正的 os 本身就带有自己的应用商店，但为什么我认为这些应用商店没有真正落地，战略意义上不如微信

微信是 os 而微信小程序相当于应用商店，而小程序相当于应用。和真正的 os 的应用商店相比，微信的成功在于落地，符合中国国情。比如 ios 的应用商店，我想要下载一个新的应用，我需要做什么？首先我需要知道从哪里拿到找到这个应用，如链接等，但链接需要浏览器打开然后跳到应用商店。其次我需要点击下载，授权安装，等待安装，然后才能使用。微信的小程序是扫二维码然后打开小程序使用

对比一下 ios 的应用商店和微信的小程序，其实本质是相同的，最大的不同在于用户获取的成本，反过来说也对

而 ios 的应用商店为什么需要那么多步骤，特别是授权？因为国情，在 M 国，特别重视安全和用户隐私，而咱是反过来，这样也就是不断在抄苹果的安卓应用商店也是这样

微软的应用商店和 mac 的应用商店失败在哪？在于用户获取成本太高，在等待授权和下载这一步耗时太长。没有落地的原因在于没有符合中国国情，在中国访问海外资源的速度和延迟都是特别长的，依赖于特别长的延迟做实时应用本身都是逗比行为

论流量和入口，在单平台上微信肯定比不过平台系统，但是为什么微信更有优势，核心在于认知，技术上在于快。我能够一扫就用上小程序，和我需要很多步骤等半天才能用上，这两个不在一个等级上

我很少写非技术的博客，如果写这些虚的评论类的博客，我基本都是会写本质

假设我需要做一个应用商店，例如我需要在一个自己的设备上，如会议室用的大板上开发一个应用商店，我需要考虑什么？我建议可以照抄微信的小程序模式，至少在产品经理hold不住战略布局之前可以照抄。几乎所有的企业都是认为效率特别重要，那么应用商店不能做违背效率的事情。至于安全，这是必要的但不是重要的

点击链接直接跳应用商店（或不跳应用商店）帮你打开应用
搜寻应用立刻打开
应用商店核心在于保证稳定，反面例子是微软应用商店，如果你的做的应用所有用户都反馈不能安装那么这个应用做的再好也是渣所以一个不能稳定安装的应用商店会让整个技术推不起来

下面是技术细节

我想要发挥更强的性能，因为我的设备硬件性能很差，我需要减少在线应用的影响。我的应用的功能又很多，我可以如何做

公用库是好东西，无论是原生的应用还是前端的应用，都可以使用公共库和公共资源。如我整个应用的界面用的界面库和我的应用商店是相同的，意味着我能做到我的应用无需下载甚至加载界面库。我的样式都是公共样式，不仅可以让用户感觉应用的统一，还可以减少样式库的下载。代码库也能做到相当多的公用，如使用相同的版本的 Json.NET 时，可以使用相同的库文件。这样需要下载的内容越少，复用越多，整体下载速度也能越快

但公用库也是有问题的，必须保证公用库的文件不被修改，公用库文件是对的问题，同时提供修复公用库的方法。这方面可以参阅 win7 的 .NET 环境问题，可以认为整个 .NET 就是一个公用库，利用公用库可以让 .NET 程序的体积很小，大量代码都放在公用库，但在 win7 在国内会有很多盗版系统，这部分让很多 .NET 程序因为公用库损坏而不能使用

闪屏可以让用户觉得应用很快就打开，这一点 UWP 做的很好，没有一个win32应用能做到比 UWP 打开更快了，只要一点击在抬起时就显示欢迎界面，虽然此时离用户能用软件还有很远，但用户的感觉就是软件反馈很快。为了让用户觉得使用应用商店安装应用的成本很低也就是解决用户认知上，可以通过快速给用户下载一张欢迎界面图片打开应用，这样可以做到减少应用商店的存在，减少用户认知应用安装的成本

现在几乎所有有点名气的厂商都在做自己的应用分发渠道，也就是小程序，现在有微信小程序、迅雷小程序、百度小程序、支付宝小程序、360小程序等，整个中国的商业前景有一部分都在盯入口，如之前的百度入口到应用商店入口，到现在的小程序入口

如何让软件以 System 权限运行

Thu, 03 Dec 2020 12:27:50 +0000

本文只是告诉大家调试 System 运行软件时可以如何快速让一个应用以 System 权限运行。使用 PsExec 可以让软件以 System 账户运行

我最近开发的 WPF 小工具需要在用户端被一个 System 权限的服务运行，我想调试这个 System 权限运行的程序，此时快速的方法是通过 PsExec 运行程序，同时在程序里面输出文件日志

从官网 https://docs.microsoft.com/en-us/sysinternals/downloads/psexec 下载最新版的 PsExec 工具，通过管理员权限运行

假设需要运行的程序是 foo.exe 那么通过下面命令行可以让 foo.exe 以 System 权限运行

psexec -s foo.exe

那么用 system 帐号运行的程序使用下面代码返回的值有什么不同

System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)

使用 SYSTEM 账户将映射 C:\windows\system32\config\systemprofile\appdata 文件夹

dotnet serve 一句话开启文件服务器通过 HTTP 将文件共享给其他设备

Thu, 03 Dec 2020 12:27:50 +0000

在当前的 IT 领域，我推荐每个开发设备都应该安装 dotnet 这个工具，在 dotnet 这个工具上有大量开发者提供了无数好用的工具。本文要告诉小伙伴的工具是 natemcmaster 大佬提供了 serve 工具，可以用来开启本地文件服务器，使用非常简单。这个方案适合在 Windows 系统和 Linux 系统和 MAC 上使用，发布的 HTTP 服务可以在任何能访问到的设备上使用

默认小伙伴电脑已经安装了 dotnet 工具，如果还没有安装，请到官网下载安装

首次使用需要安装，请打开 cmd 控制台输入下面代码安装

dotnet tool install --global dotnet-serve

安装完成之后通过 cmd 控制台进入到需要发布共享的文件夹里面，如我需要发布 F:\lindexi\foo.txt 这个资源到我的笔记本 ubuntu 系统，我先进入到 F:\lindexi 文件夹

cd /d F:\lindexi

然后就是一句话开启文件服务器了

dotnet serve -p 1007

默认会使用 8080 端口，上面代码的 -p 就是指定端口为 1007 如果接受默认端口，那么可以使用 dotnet serve 开启服务器

此时用浏览器访问 http://127.0.0.1:1007 就可以看到文件了

等等，我还有个问题，我不想用 8080 端口，我也不想去想一个端口，毕竟我不知道哪个端口可以用，可以使用 -p 0 这样就能自动给一个随机端口

我还有一个问题，为什么在我的另一个设备上访问 ip 的方式拿不到？原因是上面的命令开启的是 localhost 的监听，想要让其他设备也能访问到，可以使用下面命令

dotnet serve -p 0 -a 0.0.0.0

上面代码的 -p 0 有仔细看文章的小伙伴就知道是用来做什么的，后续的 -a 0.0.0.0 的意思就是监听本地的所有 IP 地址，此时通过 ipconfig 或 Linux 下的 ifconfig 可以看到本地所在局域网内的 ip 地址，让其他设备通过 http://ip:端口 在浏览器打开就可以访问到了

在 Linux 下可以通过 wget 命令输入链接下载到文件，如我的设备上可以通过下面代码 wget -nc htp://172.18.134.16:1007/foo.txt 拿到我另一个设备的文件

那我不想要开启服务器了可以如何关闭？其实运行时有提示按下 ctrl+C 也就是复制键就可以关闭服务了，或者关闭控制台也可以关闭服务

这个命令工具特别适合用来暂时开启本地文件的共享，当然也适合用来做二次开发，用其他弱功能的脚本调用命令行让弱功能的脚本能做到开启本地服务

如果小伙伴想要了解这个工具是如何做的，请看源代码如果访问不了，那么请到 gitee.com 注册帐号点击新建项目，粘贴 https://github.com/natemcmaster/dotnet-serve 就可以将 github 的仓库同步到国内的 gitee 了

如果我还要让外网的其他小伙伴和我不在一个局域网的访问，可以怎么办？请看 dotnet core 通过 frp 发布自己的网站

在外网发布了，我就想使用 gzip 减少内容传输，此时可以添加 -z 命令

这个工具也适合前端的小伙伴开启本地服务器，看自己写的前端代码

dotnet 修复 C# 8.0 语法编译失败

Thu, 03 Dec 2020 12:27:50 +0000

在使用 using 等新语法时，在 VisualStudio 2019 会自动判断框架版本，如在 net 45 就不会自动使用最新版本的语法，需要修改项目文件

在使用 C# 8.0 之前，请在官网下载最新的 VisualStudio 2019 版本

如果在编译时提示

“Using 声明”在 C# 7.3 中不可用。请使用 8.0 或更高的语言版本

或

error CS8370: 功能“可为 null 的引用类型”在 C# 7.3 中不可用。请使用 8.0 或更高的语言版本。

解决方法是在 csproj 项目文件里面添加下面代码

  <PropertyGroup>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>

如果不知道写在哪，请看 csproj 文件

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net45</TargetFramework>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>

</Project>

asp dotnet core 提示 Cannot access a disposed object 解决方法

Thu, 03 Dec 2020 12:27:50 +0000

我在写一个简单的文件服务器，想要用来做客户端下载器的测试服务器，但是返回的方法提示 ObjectDisposedException: Cannot access a disposed object. Object name: ‘Cannot access a closed file.’ 原因是我的文件被释放

在开发端访问链接可以返回一些提示，如我使用下面代码做一个文件下载服务器

    [ApiController]
    public class FileDownloadController:ControllerBase
    {
        [HttpGet("download")]
        public IActionResult Download()
        {
            var file = @"F:\win10.14926.1000.160910-1529.RS_PRERELEASE_CLIENTPRO_OEMRET_X64FRE_ZH-CN.ISO";

            using var fileStream = new FileStream(file, FileMode.Open);

            return File(fileStream, MimeType, "win10.14926.1000.160910-1529.RS_PRERELEASE_CLIENTPRO_OEMRET_X64FRE_ZH-CN.ISO");
        }

        private const string MimeType = "application/octet-stream";
    }

上面代码我返回一个大的文件，但是访问 https://localhost:5001/download 会提示文件被释放

ObjectDisposedException: Cannot access a disposed object.
Object name: 'Cannot access a closed file.'.
System.IO.FileStream.BeginRead(byte[] array, int offset, int numBytes, AsyncCallback callback, object state)

ObjectDisposedException: Cannot access a disposed object. Object name: 'Cannot access a closed file.'.
System.IO.FileStream.BeginRead(byte[] array, int offset, int numBytes, AsyncCallback callback, object state)
System.IO.Stream+<>c.<BeginEndReadAsync>b__48_0(Stream stream, ReadWriteParameters args, AsyncCallback callback, object state)
System.Threading.Tasks.TaskFactory<TResult>.FromAsyncTrim<TInstance, TArgs>(TInstance thisRef, TArgs args, Func<TInstance, TArgs, AsyncCallback, object, IAsyncResult> beginMethod, Func<TInstance, IAsyncResult, TResult> endMethod)
System.IO.Stream.BeginEndReadAsync(byte[] buffer, int offset, int count)
System.IO.FileStream.ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
Microsoft.AspNetCore.Http.StreamCopyOperationInternal.CopyToAsync(Stream source, Stream destination, Nullable<long> count, int bufferSize, CancellationToken cancel)
Microsoft.AspNetCore.Mvc.Infrastructure.FileResultExecutorBase.WriteFileAsync(HttpContext context, Stream fileStream, RangeItemHeaderValue range, long rangeLength)
Microsoft.AspNetCore.Mvc.Infrastructure.FileStreamResultExecutor.ExecuteAsync(ActionContext context, FileStreamResult result)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeNextResultFilterAsync>g__Awaited|29_0<TFilter, TFilterAsync>(ResourceInvoker invoker, Task lastTask, State next, Scope scope, object state, bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.Rethrow(ResultExecutedContextSealed context)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.ResultNext<TFilter, TFilterAsync>(ref State next, ref Scope scope, ref object state, ref bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.InvokeResultFilters()
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeFilterPipelineAsync>g__Awaited|19_0(ResourceInvoker invoker, Task lastTask, State next, Scope scope, object state, bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeAsync>g__Awaited|17_0(ResourceInvoker invoker, Task task, IDisposable scope)
Microsoft.AspNetCore.Routing.EndpointMiddleware.<Invoke>g__AwaitRequestTask|6_0(Endpoint endpoint, Task requestTask, ILogger logger)
Microsoft.AspNetCore.Authorization.AuthorizationMiddleware.Invoke(HttpContext context)
Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware.Invoke(HttpContext context)

因为我在返回之前用了 using 也就是释放 FileStream 资源

在 C# 8.0 提供了让 using 放在对象创建之前，可以在对象作用范围结束自动释放对象，也就是下面代码是相同的

            using var fileStream = new FileStream(file, FileMode.Open);

            return File(fileStream, MimeType, "win10.14926.1000.160910-1529.RS_PRERELEASE_CLIENTPRO_OEMRET_X64FRE_ZH-CN.ISO");

// 和这个代码是相同的

            using (var fileStream = new FileStream(file, FileMode.Open))
            {
                return File(fileStream, MimeType, "win10.14926.1000.160910-1529.RS_PRERELEASE_CLIENTPRO_OEMRET_X64FRE_ZH-CN.ISO");
            }

在返回 File 方法之后将会释放 fileStream 但是在 asp dotnet core 返回给客户端的信息是在 Download 方法之后，也就是在结束 Download 方法之后读取 FileStream 内容，读取一个被释放的 FileStream 会提示不能读取文件

解决方法就是去掉 using 就可以了

最简单返回一个文件的方法是通过 PhysicalFile 方法，请看代码

        [HttpGet("download")]
        public IActionResult Download()
        {
            var file = @"F:\win10.14926.1000.160910-1529.RS_PRERELEASE_CLIENTPRO_OEMRET_X64FRE_ZH-CN.ISO";

            return PhysicalFile(file, MimeType);
        }

        private const string MimeType = "application/octet-stream";

在 PhysicalFile 处理了文件的自动释放等问题，使用很简单，但是我发现这货存在内存泄漏，请看 Maybe PhysicalFile will be memory leak

使用 PhysicalFile 等方法可以快速实现断点续传的功能

dotnet 用 gcdump 调试应用程序内存占用

Thu, 03 Dec 2020 12:27:50 +0000

在 Linux 等系统下，没有和 Windows 下这么好的 VisualStudio 支持。在客户端的环境，也不太好在用户端安装一个 VisualStudio 调试。在遇到需要在服务器端或客户端调试应用程序的内存占用时，可以尝试使用 dotnet 的 gcdump 工具进行调试，这个工具使用十分简单，功能也很强大

在运行这个工具之前要求设备上先安装 dotnet 环境，有了这个限制，在客户端调试其实不如搭建 VisualStudio 远程调试更好。当然本文主要是广告 gcdump 工具的，怎么能在这里拆台。在服务器端，只有安装了 dotnet 工具，同时不是 Windows 的服务器，不能使用 VisualStudio 远程调试技术前提下。或者不想使用 VisualStudio 抓内存，只是想拿到当前内存信息，有空了再分析。或者是自动化测试的时候，通过调用命令行获取进程的内存，然后自动化分析内存。此时通过 gcdump 都能很好的满足

使用 gcdump 能通过一句命令行调用获取指定 pid 进程的内存快照，将内存快照保存到文件，方便进行分析

在使用 gcdump 之前需要将 gcdump 作为全局工具安装，请在命令行输入下面代码

dotnet tool install --global dotnet-gcdump

安装完成之后通过下面命令拿到指定进程 ID 的应用的内存

dotnet gcdump collect -p <target-process-PID>

如准备一个测试用的 dotnet core 程序，可以在github下载我的测试代码

我在测试代码第一句话输出当前进程号，方便使用工具获取当前进程

            Console.WriteLine(Process.GetCurrentProcess().Id);

然后写出内存泄漏代码

            var list = new List<object>();
            while(true)
            {
                list.Add(new Lindexi());
                Task.Delay(TimeSpan.FromMilliseconds(100)).Wait();
            }

    class Lindexi
    {
        
    }

使用 dotnet run 运行代码，不需要开启 VisualStudio 就能进行编译运行代码，这也就是可以将 C# 代码当成复杂脚本来用，可以代替部分 PowerShell 功能

打开一个新的命令行，输入 dotnet gcdump collect -p 99 请将这句命令的 99 替换为应用的进程号

此时将会在命令行的工作文件夹写入 .gcdump 文件，打开 VisualStudio 拖入 .gcdump 文件就可以解析，通过多个 .gcdump 文件可以了解一段时间内创建的对象，通过单个 gcdump 文件可以分析在当前内存还有哪些对象

这是测试程序的分析，通过这个工具可以非常方便拿到某个进程的内存

更多关于 gcdump 命令：

-p 指定应用程序进程
-o 指定 gcdump 文件输出路径，默认为.\YYYYMMDD_HHMMSS_<pid>.gcdump文件
-v 传入 true 或 false 默认为 false 如果传入 true 将会输出更多调试信息
-t 超时时间，单位是秒，默认是30秒

这个项目完全开源，源代码放在github 小伙伴如果有问题欢迎到官方交流

Collecting and analyzing memory dumps

dotnet 进行二进制差分压缩文件

Thu, 03 Dec 2020 12:27:50 +0000

我需要对一个文件做二进制差分压缩，我有一个文件的起始点，在之后的每次更改我都记录文件的二进制的差分，这样就可以通过起始点和差分文件计算修改后的文件。通过二进制差分可以用来提高文件保存磁盘读写速度，也可以减少软件自动更新需要的文件大小

在 QQ 和 Chrome 等软件更新就使用这个技术，通过二进制差分方法下载差分文件，然后用差分文件和当前版本计算出新版本，将新版本写入文件。这样做的优势在于每次版本的二进制更改的内容都不多，此时可以减少进行 OTA 下载的文件大小

而在弱网的传输也是，这里的弱网是网络下载速度很慢的环境，需要更新某些文件。如游戏端的资源文件，在游戏端为了提升性能，会将资源文件合并为一个文件，在游戏需要更新时候，如果更新整个文件，下载的内容将会很多，在移动端也许用户使用的是流量下载。因此优化方法是读取这个资源的二进制差分文件，只下载之前二进制文件不存在的二进制内容，然后根据现有的二进制文件计算出新的版本的文件

本文使用的算法请看二进制数据差异算法用于减小OTA内容这些算法相关的也没有什么内容

和 BSDiff 这个二进制压缩算法相比，本文使用的方法更适合做 dotnet 的更新程序，测试效果将会更好。但是存在的缺点是如果文件比较大，那么计算出二进制差异文件的时间将会很长。这里说的计算时间指的是服务器端根据两个版本的文件，计算出二进制差异文件。在客户端下载了二进制差异文件，然后通过本地的文件计算出新的版本的文件的速度依然是很快的

本文的算法如果作为 .NET 软件的 OTA 自动更新使用，需要构建的时候开启确定性构建，请看 Roslyn 的确定性构建 - walterlv

可以在 csproj 添加下面代码

<Project>
 <PropertyGroup>
   <Deterministic>true</Deterministic>
 </PropertyGroup>
</Project>

本文代码放在 github 欢迎小伙伴访问

dotnet 单元测试注入文件读写

Thu, 03 Dec 2020 12:27:50 +0000

在进行文件读写时，如果进行单元测试，是需要很多设计，因为本地的文件可能因为单元测试之间的占用，以及还原数据，会影响业务。本文告诉大家使用注入的方式，让文件读写一个抽象的对象

单元测试文件读写的难点是构建出测试的文件，如要求文件的权限是用户不可读，如要求文件的长度很长，如要求文件的修改时间。而 System.IO.Abstractions 这个库提供了注入抽象的文件，所有属性都可以设置

首先安装 System.IO.Abstractions 库，这个库提供了 IFileSystem 接口，使用这个接口提供的文件读写方法代替静态类 File 等方法。这样通过注入 IFileSystem 接口，可以进行文件读写测试

Install-Package System.IO.Abstractions

在使用 System.IO.Abstractions 库进行注入，需要对代码进行一些修改，如将 File.ReadAllText 的代码修改为 fileSystem.File.ReadAllText 这里的 fileSystem 是 IFileSystem 进行注入

在进行单元测试的注入，可选的是构造注入等方法，通过注入的 IFileSystem 属性进行文件读写

    public class Foo
    {
        /// <inheritdoc />
        public Foo(IFileSystem fileSystem)
        {
            FileSystem = fileSystem;
        }

        public IFileSystem FileSystem { get; }
    }

之后的文件读写，大概修改如 File.ReadAllText 和 FileStream 代码

            IFileSystem fileSystem = FileSystem;

            File.ReadAllText("lindexi.txt");
            fileSystem.File.ReadAllText("lindexi.txt");

也就是将 File.ReadAllText 替换 fileSystem.File.ReadAllText 方法

            new FileStream("blog.lindexi.com", FileMode.Create);
            fileSystem.FileStream.Create("blog.lindexi.com", FileMode.Create);

此时进行单元测试注入，这里用 Mock 的方法创建一个抽象的对象

单元测试需要按照 System.IO.Abstractions.TestingHelpers 库

注入 IFileSystem 方法

            var mockFileSystem = new MockFileSystem(new Dictionary<string, MockFileData>()
            {
                {
                    "文件路径", new MockFileData("文件内容")
                },
                { "文件夹", new MockDirectoryData() }
            });

            var foo = new Foo(mockFileSystem);

在 MockFileSystem 支持设置文件或文件夹的属性，不需要存在实际的文件

如果需要虚拟更多接口，请使用 Mock 方法

WPF 从 dotnet core 3 到 dotnet 5 的变更

Thu, 03 Dec 2020 12:27:49 +0000

本文收藏我所了解的从 dotnet core 3 到 2020.11.10 发布的 dotnet 5 的 WPF 的变更

修复坑

应用资源的线程问题

App resource threading issue by SamBent · Pull Request #3577 · dotnet/wpf

DataGrid.Copy: fail silently if clipboard is locked by SamBent · Pull Request #3576 · dotnet/wpf

FixedPage SOM bugs by SamBent · Pull Request #3575 · dotnet/wpf

ClearType anti-aliasing by SamBent · Pull Request #3570 · dotnet/wpf

Reentrancy when closing ToolTip by SamBent · Pull Request #3568 · dotnet/wpf

修复多线程下的 HostVisual 多 UI 渲染问题

HostVisual threading by SamBent · Pull Request #3567 · dotnet/wpf

Avoid null item AutomationPeers by SamBent · Pull Request #3565 · dotnet/wpf

Vsp freeze by SamBent · Pull Request #3564 · dotnet/wpf

Ask-Mode: [release/5.0-rc2] Custom intermediate output paths shouldn’t break markup compilation by ryalanms · Pull Request #3542 · dotnet/wpf

移除校验程序集 Dll 功能，可以提升一点性能，而且因为升级框架之后程序集 dll 文件有一些更改

Remove VerifyWpfDllSet by agocke · Pull Request #3329 · dotnet/wpf

多绑定的判断问题

Fix range of for statement by Lelary · Pull Request #3221 · dotnet/wpf

修复 WM Pointer 消息因为使用屏幕坐标带来的兼容性问题，这个提交是对触摸应用来说十分重要的更改。偷偷说一下，这是我参加怂恿的提交

Fix raw stylus data to support per-monitor DPI by rladuca · Pull Request #2891 · dotnet/wpf

修复触摸相关问题，多窗口多线程问题

Fix PenIMC Activation Context Handling by rladuca · Pull Request #2890 · dotnet/wpf

性能提升

在上面修复坑上就有部分是能提升性能的，以下更改为完全为了提升性能

Use faster char based overload of String.IndexOf by davidwrighton · Pull Request #3278 · dotnet/wpf

调试优化

Move StackTrace to error branch by SamBent · Pull Request #3574 · dotnet/wpf

绑定调试优化

Add BindingFailed event for diagnostics of binding failures by spadapet · Pull Request #3505 · dotnet/wpf

更新过时的 API 调用以及修复判空

Temporarily suppress obsolete API errors to get WPF master building by ryalanms · Pull Request #3659 · dotnet/wpf

可能有坑的更改 https://github.com/dotnet/wpf/pull/3659/files#diff-2a913b21f14e90b5fcc2e41824a0f5df8dafdefb28f01104605bcdb62ceeb7b2R46

可空逻辑的特性支持，但是这个支持也许会有坑

Replace null comparisons on non-nullable types that now cause compilation errors, due to the .NET SDK update. by ryalanms · Pull Request #3649 · dotnet/wpf

构建优化

尽管官方说不会去做跨平台的时候，但是依然有一部分 MR 是用来适配在其他平台进行构建，但是当前依然无法在 Linux 平台完成整个 WPF 的构建

Fix the casing of ‘Shared’ in WpfSharedDir by FraGag · Pull Request #3594 · dotnet/wpf

Support PackageReferences in WPF projects by ryalanms · Pull Request #3585 · dotnet/wpf

Fix RuntimeFrameworkReferences for RTM builds by mmitche · Pull Request #3406 · dotnet/wpf

Add CPD strict dependencies for dotnet/installer by mmitche · Pull Request #3372 · dotnet/wpf

adding XamlRuntime msbuild property/metadata by stevenbrix · Pull Request #3332 · dotnet/wpf

Update guardian package by wtgodbe · Pull Request #3274 · dotnet/wpf

[master] Add internal feed build steps by mmitche · Pull Request #3267 · dotnet/wpf

Remove workarounds by wli3 · Pull Request #3248 · dotnet/wpf

Add SDL vars config file by mmitche · Pull Request #3234 · dotnet/wpf

Add the property for MicrosoftWindowsDesktopSdkImported by wli3 · Pull Request #3207 · dotnet/wpf

Recategorize dependencies by mmitche · Pull Request #3188 · dotnet/wpf

这个提交看起来是默认支持到 Win7 系统，默认通过 dotnet 构建的输出可执行版本是 Win7 系统支持版本

Setting default TargetPlatformVersion by sfoslund · Pull Request #3177 · dotnet/wpf

.NET Core WPF Build error on custom BaseIntermediateOutputPath #1718 by ryalanms · Pull Request #3120 · dotnet/wpf

Shuffle property location by wli3 · Pull Request #3111 · dotnet/wpf

这个更改有利于在其他平台进行构建

Replace hardcoded backslashes with Path.DirectorySeparatorChar and fix WinFX casing (daviddenis-stx, Nirmal4G, PaulEremeeff) by ryalanms · Pull Request #3101 · dotnet/wpf

Fix RuntimeFrameworkVersion logic by vatsan-madhavan · Pull Request #2817 · dotnet/wpf

这个也是有利于在其他平台进行构建

Make ArtifactsTmpDir platform-specific by vatsan-madhavan · Pull Request #2525 · dotnet/wpf

Remove usage of Microsoft.NETCore.App.Internal package. by jkoritzinsky · Pull Request #3791 · dotnet/wpf

安全性

Fixing Microsoft Security Advisory CVE-2020-0605 : .NET Core Remote Code Execution Vulnerability- Variant (.Net Core 3.1) by arpitmathur · Pull Request #3020 · dotnet/wpf

Fixing Microsoft Security Advisory CVE-2020-0605 : .NET Core Remote Code Execution Vulnerability- Variant (.Net 5.0) by arpitmathur · Pull Request #3019 · dotnet/wpf

Fixing Microsoft Security Advisory CVE-2020-0605 : .NET Core Remote Code Execution Vulnerability (3.1 Fixed PR) by rladuca · Pull Request #2428 · dotnet/wpf

Fixing Microsoft Security Advisory CVE-2020-0606 : .NET Core Remote Code Execution Vulnerability (3.0 Merge Fix) by rladuca · Pull Request #2429 · dotnet/wpf

Microsoft Security Advisory CVE-2020-0606 : .NET Core Remote Code Execution Vulnerability (5.0 PR) by arpitmathur · Pull Request #2430 · dotnet/wpf

完全开源

这是原本的 MIL 层的代码，以及触摸 PenIMC 底层代码

Open Sourcing WpfGfx and PenImc by vatsan-madhavan · Pull Request #2553 · dotnet/wpf

在这两个代码开放之后，我就水了 WPF 触摸底层 PenImc 是如何工作的和 WPF 从最底层源代码了解 AllowsTransparency 性能差的原因

文档和注释

理论上文档和注释不会影响行为

看起来我的提交里面水的文档和注释最多了

1228498 [ wpf ][ PoliCheck ] - Defect : Term “nuked” by ryalanms · Pull Request #3642 · dotnet/wpf

Update intellisense version by AdamYoblick · Pull Request #3640 · dotnet/wpf

update_intellisense_artifacts by AdamYoblick · Pull Request #3600 · dotnet/wpf

Remove or replace Policheck violations in code comments by ryalanms · Pull Request #3606 · dotnet/wpf

update intellisense artifacts by AdamYoblick · Pull Request #3581 · dotnet/wpf

Fix spelling errors in code comments by lindexi · Pull Request #2841 · dotnet/wpf

LOC CHECKIN dotnet/wpf 20200403 by v-chmart · Pull Request #2837 · dotnet/wpf

不知道用来干啥的更改

#include tuple to matrix_t.hpp by vatsan-madhavan · Pull Request #3056 · dotnet/wpf

Using constants for strings to keep the code consistent by lindexi · Pull Request #2907 · dotnet/wpf

官方的规划

尽管现在 WPF 所有权在 dotnet 基金会下

但是 WPF 还没全准备好接受来自社区的提交代码，只有在单元测试完成之后才敢接受。而 WPF 的单元测试部分是之前已经写好，但是没有开源。这部分单元测试的开源就是最近从 5 月开始做到现在的内容

当前进度会比原计划慢，客观原因相信大家也知道 However, the global COVID-19 pandemic has caused hiring to be slower than usual. 而在 dotnet 5 更新的时候构建部分还没完全跟上，因此暂时私有版本在 2020.11.12 还不能构建到 dotnet 5 版本

后续将会继续做的修坑和优化性能，然后接受来自社区的更改，走开源管理

更多细节请看官方仓库

Roslyn 解决 dotnet core 应用进程间引用找不到 runtimeconfig 依赖文件

Thu, 03 Dec 2020 12:27:49 +0000

我有一个强大的功能，这个功能就是在 Linux 下使用 GDI 转换 EMF 格式图片为 png 图片，但是有一些有趣的图片会让转换的进程炸掉。因此我就想让转换服务放在独立的进程，通过进程间调用，也就是命令行调用传入参数的方式，让另一个进程转换图片。而此时就会遇到一个问题，如何让这个进程也被构建，然后输出到输出路径

在 .NET Core 里面，如果想要让输出文件夹包含两个不同的进程入口文件，最简单的方法是让一个项目引用另一个项目。这个做法在 .NET Framework 里面很好用，因为此时将会在输出文件夹里面包含两个项目的输出文件。也就解决了如果让另一个进程也被构建的问题

不过在 dotnet core 里面将会存在一个文件，如果项目引用了一个输出为 exe 的项目，此时想要让这个可执行程序运行，将会遇到这样的坑，在 .NET Core 里面规定了可执行程序需要有两个配置文件，而默认项目引用将会缺少这两个配置文件

.deps.json
.runtimeconfig.json

在默认构建一个可执行程序，如 exe 程序的 .NET Core 项目，将可以在输出路径看到 xx.deps.json 文件和 xx.runtimeconfig.json 两个文件。如果没有这两个文件会如何？在运行可执行程序将会提示下面代码

A fatal error was encountered. The library 'hostpolicy.dll' required to execute the application was not found in 'C:\
Failed to run as a self-contained app. If this should be a framework-dependent app, add the C:\

提示找不到 The library 'hostpolicy.dll' required to execute the application was not found 的原因就是因为不存在 runtimeconfig.json 文件

那么这两个文件的作用是什么，请看深入理解.NET Core的基元: deps.json, runtimeconfig.json, dll文件 - LamondLu - 博客园

而如果我单个项目构建的时候，其实是可以在项目输出文件夹看到这两个配置文件。但是如果被引用了，那么将找不到这两个文件

解决方法就是在被引用的项目的 csproj 文件里面添加如下代码

     <Target Name="AddRuntimeDependenciesToContent" Condition=" '$(TargetFrameworkIdentifier)' == '.NETCoreApp'" BeforeTargets="GetCopyToOutputDirectoryItems" DependsOnTargets="GenerateBuildDependencyFile;GenerateBuildRuntimeConfigurationFiles" >
        <ItemGroup>
            <ContentWithTargetPath Include="$(ProjectDepsFilePath)" CopyToOutputDirectory="PreserveNewest" TargetPath="$(ProjectDepsFileName)" />

            <ContentWithTargetPath Include="$(ProjectRuntimeConfigFilePath)" CopyToOutputDirectory="PreserveNewest" TargetPath="$(ProjectRuntimeConfigFileName)" />
        </ItemGroup>
    </Target>

上面代码的含义是什么？其实就是将这两个配置文件加入到 ContentWithTargetPath 项，将会被其他项目放在输出文件夹里面

上面代码的 AddRuntimeDependenciesToContent 是一个随意的名字，小伙伴可以根据自己的需求随意更改

而核心的逻辑是在 BeforeTargets="GetCopyToOutputDirectoryItems" DependsOnTargets="GenerateBuildDependencyFile;GenerateBuildRuntimeConfigurationFiles" 这里

在 BeforeTargets 也就是说明这个 Target 在构建过程的执行时机是需要在 GetCopyToOutputDirectoryItems 执行之前，这个 GetCopyToOutputDirectoryItems 就是决定有哪些内容将会需要输出到最终输出文件夹里面。因此需要在他之前之前，给他设置需要输出的内容

然后在 DependsOnTargets="GenerateBuildDependencyFile;GenerateBuildRuntimeConfigurationFiles" 是因为在 GenerateBuildDependencyFile 之后才输出 .deps.json 文件，在 GenerateBuildRuntimeConfigurationFiles 才输出 .runtimeconfig.json 文件

如果没有写 DependsOnTargets 那么将会构建提示 error MSB3030 找不到复制文件

error MSB3030: 无法复制文件“C:\lindexi\bin\Release\netcoreapp3.1\lindexi.runtimeconfig.json”，原因是找不到该文件

而如果后续你觉得这个原本是输出为可执行文件的进程不想继续作为输出为 exe 了，将 OutputType 修改为库，那么请记得删除上面的代码，因此此时的输出里面将没有包含配置文件

更多关于 Roslyn 请看手把手教你写 Roslyn 修改编译

如果不想使用引用项目的方法，还有其他方法可以做到，让多个项目没有依赖，但是都能构建。请看三种方法设置 .NET/C# 项目的编译顺序，而不影响项目之间的引用 - walterlv

本文的方法存在的不足是，如果最后是作为框架依赖发布的，那么也许会遇到这样的问题，实际安装的库被作为框架的一部分，此时引用路径将会不相同。构建的项目里面依赖的是本地的 lib 文件的路径，而框架发布的项目使用的是 ref 的文件夹路径。如 GDI 库的实现里面，在运行的时候将会看到输出是找不到

dotnet ImageOptimizationProcess.dll
Error:
  An assembly specified in the application dependencies manifest (ImageOptimizationProcess.deps.json) was not found:
    package: 'Microsoft.Win32.SystemEvents', version: '4.7.0'
    path: 'lib/netstandard2.0/Microsoft.Win32.SystemEvents.dll'

原因是可执行项目输出的配置文件内容如下

      "System.Drawing.Common/4.7.0": 
       {
        "dependencies": 
        {
          "Microsoft.NETCore.Platforms": "3.1.0",
          "Microsoft.Win32.SystemEvents": "4.7.0"
        },
        "runtime": 
        {
          "lib/netstandard2.0/System.Drawing.Common.dll": 
          {
            "assemblyVersion": "4.0.0.1",
            "fileVersion": "4.6.26919.2"
          }
        },
        "runtimeTargets": 
        {
          "runtimes/unix/lib/netcoreapp3.0/System.Drawing.Common.dll": 
          {
            "rid": "unix",
            "assetType": "runtime",
            "assemblyVersion": "4.0.2.0",
            "fileVersion": "4.700.19.56404"
          },
          "runtimes/win/lib/netcoreapp3.0/System.Drawing.Common.dll": 
          {
            "rid": "win",
            "assetType": "runtime",
            "assemblyVersion": "4.0.2.0",
            "fileVersion": "4.700.19.56404"
          }
        }
      }

但是实际的 GDI 的库是作为框架共享的，放在 /usr/share/dotnet/shared/Microsoft.AspNetCore.App/3.1.6/System.Drawing.Common.dll 路径，因此找不到库，进程执行失败

dotnet 日志上报的 TracerId 和 SessionId 的意义

Thu, 03 Dec 2020 12:27:49 +0000

在做日志库设计的时候，我会特别考虑日志里面需要带上时间和 TracerId 和 SessionId 两个属性，本文告诉大家带上这两个属性的意义和优势

在开始之前，先需要了解为什么需要写日志。其实无论日志内容是什么，都会比没有写日志更好。但是比没有设计的日志，有经过设计的日志的价值更高，详细请看程序猿修养日志应该如何写

本文来聊聊一个更细的话题，日志里面的 TracerId 和 SessionId 两个属性的含义和作用，以及添加这两个属性的优势

首先假定咱这个大的应用是一个战斗集团，不是由单个进程组成的，他将包括了 WPF 客户端，以及 .NET 客户端服务，还有后台 ASP.NET Core 的服务集群等。当然如果我只是单个进程，那么此时使用 TracerId 和 SessionId 两个属性的作用不会很大

那么在一个由很多应用组成的战斗集团会遇到什么问题？最大的问题就是定责。也就是说我服务器端没有给我客户端预期的内容，究竟是我客户端发错信息了，还是复杂的服务器端凉凉了

日志里面如果有记录 TracerId 和 SessionId 两个属性，就可以比较方便定位链路，也就是调用顺序是从哪到哪的过程

什么是 TracerId 和 SessionId 属性？这是两个不同的属性，咱先聊聊 TracerId 属性

其实在我团队内，这个 TracerId 也叫 TracerTag 哈，或者叫 TracerTagList 应该会包含一整组的值

在我团队内的所有的组件库，都会引用一个叫 Core 的组件库。这个库有一个功能就是提供 Trace 追踪的功能，因为让所有的组件库记日志是不靠谱的，如我 A 应用的日志是记到文件去的，而 B 应用是需要过滤某些信息上报到日志服务上的。因此让所有组件库了解日志细节是不靠谱的，此时解决方法就是让所有组件库都走 Trace 追踪机制

说到 TracerId 就必须聊下追踪这个机制，什么是追踪机制？其实就是组件库以及非业务逻辑运行过程中，对外抛出的事件。这里说的事件不是 C# 里面的 event 哈，可以理解为通知。而此时上层应用，可以根据自己的需求，从 Trace 追踪里面过滤出自己需要的信息。如过滤出所有 Warning 的信息，记录日志。或者调试的时候将所有的信息输出在控制台等

使用追踪的优势在于所有的组件库都不会耦合日志业务，所有的组件库在各个应用里面都是通用的，因为组件库都是依赖追踪，而不依赖具体的日志定义

那么业务逻辑呢？刚才聊的都是组件库，其实业务也相同。例如我在 WPF 客户端里面，默认业务都是将日志记录到本地，但是有时候发现某个信息产品大佬想要知道，如用户点了 A 按钮，此时产品大佬想要知道有多少次点击等，于是就可以让上报埋点模块从追踪里面过滤出 A 按钮点击的事件，用来上报。这样做能大大减少业务埋点和业务模块的耦合

同时业务逻辑使用追踪还能做到在后续产品大佬加需求的时候，想要了解用户是通过哪个渠道点击了 A 按钮的时候，可以做到灵活配置

那么 TracerId 可以如何写？由业务发起方写入，基本上都是由 Guid 组成的字符串。然后传入 Trace 机制，传入到底层模块或其他业务模块，或传入到调用其他进程包括后台服务，其他模块在记录日志的时候，会额外添加被传入的 TracerId 的值

此时能做到的就是了解这个数据或调用是从哪里发起的，经过哪些步骤。例如我的 WPF 客户端，问了我的 OTA 自动更新服务说有没有更新，这是由用户点击客户端界面的更新按钮发起的。于是在用户点击按钮的逻辑里面，就生成了 Guid 作为 TracerId 记录日志。接着是调用客户端的更新模块，这个模块将会接收到上层传入的 TracerId 属性，在更新模块记录日志的时候都会加上 TracerId 属性。接着更新模块通过 IPC 进程间调用，调用了一个 .NET 服务，这个服务负责做软件自动更新，此时更新模块在调用本机服务的时候，将会传入 TracerId 属性。而在 .NET 服务里面，需要访问 ASP.NET Core 更新后台，在访问的时候将会传入给后台这个 TracerId 属性

这样做有什么好处？假如用户发起的点击按钮问有没有更新版本，此时界面显示没有更新版本。但是明明我已经发布了更新版本，请问此时问题出在哪？有 TracerId 就好定位了

先是看更新模块有没有调用本机服务，通过 TracerId 能确定更新模块的某次调用本机服务确实是由用户端发起的，而不是软件的定时更新模块发起的。然后在本机更新服务日志里面，查看有没有这个 TracerId 相关记录。如果没有相关记录，尽管本机更新服务有收到我这个客户端软件的查询更新的信息，但如果 TracerId 没对上，那么就可以证明 IPC 等模块存在锅

当然，如果用户端这里的所有日志都对上了，而看到本机更新服务从后台拿到的数据里面说没有更新可用，那么此时就可以通过 TracerId 去找 ASP.NET Core 后台的日志

例如在后台里面确实收到了信息，但是发现此时出发了限制CDN流量，通过 TracerId 可以了解到，这个 TracerId 就是被限制 CDN 流量的。这样就能了解问题所在

如果没有 TracerId 呢？那么在本机更新服务里面，写入了很多次请求客户端更新的数据，那么是否能证明这是用户点击的这一次发起的？如果在后台 CDN 限制下载流量服务里面说有某次请求更新，因为需要限制 CDN 流量而禁止更新，那么是否可以证明本次客户端查询更新失败的原因就是这个？其实都不能除非是用户量非常小，使用时间的方式定位

而 TracerId 大部分时候也会和 TracerTag 或 TracerTagList 配合，这是用来做什么的？其实这是用来找到调用树的，通过调用树可以了解调用的层次

依然使用刚才用户点击更新作为例子，在我当前的应用里面的 TracerTagList 大概内容如下

【TracerId】【更新界面】点击查询更新按钮
- 【TracerId】【更新界面】【更新模块】开始查询更新
- 【TracerId】【更新界面】【更新模块】【版本管理模块】读取软件版本号
- 【TracerId】【更新界面】【更新模块】【文件管理模块】读取软件安装路径
- 【TracerId】【更新界面】【更新模块】【IPC通讯模块】查找OTA服务通讯方式
  - 【TracerId】【更新界面】【更新模块】【IPC通讯模块】【发送模块】发送查询更新
【TracerId】【IPC通讯模块】【接收模块】收到消息
- 【TracerId】【IPC通讯模块】【队列模块】排队消息
【TracerId】【IPC通讯模块】【消息解析模块】解析消息
- 【TracerId】【IPC通讯模块】【消息解析模块】【更新模块】通知更新信息
  - 【TracerId】【IPC通讯模块】【消息解析模块】【更新模块】【更新界面】更新界面

加上 TracerTagList 的优势仅仅是让每条日志之间可以相对独立，比较适合在本机记录里面。通过时间线，可以只使用 TracerId 串起来，但是有 TracerTagList 能做到更方便看日志。因此 TracerTagList 是非必须的，只是有维护就更好

那么 SessionId 又是做什么的？其实 TracerId 仅仅能做到的是一条链路，而有些问题不是一条链路的问题，因此仅通过 TracerId 是做不到定位这部分问题的

在我团队这里，其实 SessionId 和 UserId 是不同的属性，因为我是做客户端开发的，客户端是不一定有登录，而且一个账号不一定只登录一个端。因此这里的 SessionId 在客户端发起的时候，更多的是一个进程。一个进程一个 SessionId 的值

如果我没有和其他进程和服务进行通讯，那么 SessionId 的作用不大，更好的方法是一个进程一个日志文件。只有在将日志上报到后台，以及和其他进程进行通讯的时候，才能用上 SessionId 的功能

依然使用上面的软件更新作为例子。假定我的业务设计是如果软件正在下载资源，此时不允许软件进行更新。因为如果在下载资源过程更新软件了，那么这个状态很难维护。当然，这是假设哈

此时如果软件更新查询是没有更新，因为软件边界也没做好，那么此时仅从后台能否找到原因是刚好此时正在下载资源的原因，确定是这个原因呢

其实也可以的，通过 SessionId 可以了解到这个进程之前做了哪些事情，当然也就包含了下载资源。而此时通过链路最终可以看到用户是通过什么途径下载资源的，例如用户其实是无意间触发的，此时就需要交互大佬协助了。如果是用户明确点击了下载资源的，那么是不是客户端部分没有处理好逻辑，或者写更新界面的小伙伴忘了这个业务

Roslyn 解决找不到 SolutionDir 属性

Thu, 03 Dec 2020 12:27:49 +0000

在旧版本的 csproj 格式也就是 Franken-proj 格式，可以使用 SolutionDir 拿到当前sln文件所在的文件夹，但是在 SDK Style 格式的项目文件，是拿不到这个属性的，本文告诉大家如何做到兼容之前的逻辑

其实不是 SDK Style 拿不到 SolutionDir 属性，而是因为没有使用 sln 加入构建

如我在一个项目里面的 csproj 文件添加下面代码

  <Target Name="KofegaheqallwhikaDalbedalkihi" AfterTargets="BeforeBuild">
    <Warning Text="Solution $(SolutionDir)"/>
  </Target>

如果我使用 dotnet 命令构建这个 csproj 文件，那么将会输出如下代码

 warning : Solution *Undefined*

如果我使用 dotnet 命令构建 sln 文件，那么可以输出 sln 所在的文件夹

这就是不同点

但是如果我只是想通过 dotnet 或 msbuild 命令构建 csproj 文件，而不构建 sln 文件，此时还需要使用 SolutionDir 属性。那么请在 sln 文件夹添加一个叫 Directory.Build.props 文件，这个文件可以设置这个文件夹里面的所有项目的构建

而 $(SolutionDir) 属性的含义也就是一个属性，因此只需要返回当前 sln 所在文件夹就可以

<Project>
  <PropertyGroup>
    <SolutionDir>$(MSBuildThisFileDirectory)</PackageOutputPath>
  </PropertyGroup>
</Project>

上面代码的 $(MSBuildThisFileDirectory) 就是获取当前文件所在的文件夹，而当前文件是放在和 sln 文件相同的文件夹，因此这个就是和 SolutionDir 等价

如果小伙伴不知道 Directory.Build.props 文件可以如何写，还请小伙伴看我的 github 仓库

关于 Directory.Build.props 文件的作用请看 Roslyn 使用 Directory.Build.props 文件定义编译

关于 MSBuildThisFileDirectory 等默认变量请看项目文件中的已知属性（知道了这些，就不会随便在 csproj 中写死常量啦） - walterlv

更多编译相关博客请看手把手教你写 Roslyn 修改编译

win10 uwp 不显示 SplashScreen 欢迎界面的方法

Thu, 03 Dec 2020 12:27:49 +0000

在 UWP 的应用，欢迎页面 SplashScreen 是用户第一个看到的界面，这个界面是由 ApplicationFrameHost 读取 UWP 配置的图片显示出来的，因此 UWP 才能做到点击应用瞬间启动

那么如果我不想显示启动界面 SplashScreen 的图片，可以如何做？有两个方法，第一个方法是比较推荐的，在应用程序如果能启动足够快，那么将不显示欢迎界面，如果启动不够快那么依然显示欢迎界面，这样用户就知道打开应用程序。另一个方法是无论应用程序启动多慢，都不显示欢迎界面。第二个方法是假的不使用初始屏幕的方法，只是不显示图片。也就是我没有找到任何一个有用的进入应用程序界面的方法

第一个可以使用的是编辑 Package.appxmanifest 文件，在 VisualStudio 选中 Package.appxmanifest 文件，然后按下 F7 进入编辑文本模式，此时将使用 xml 打开文件

在这个文件里面可以看到 uap:SplashScreen 的配置，这就是 UWP 的启动界面图片设置的值

在这一行添加如下代码

a:Optional="true" xmlns:a="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"

添加之后的代码如下

        <uap:SplashScreen a:Optional="true" xmlns:a="http://schemas.microsoft.com/appx/manifest/uap/windows10/5" Image="Assets\SplashScreen.png"/>

此时按照微软官方文档 uap:SplashScreen (Windows 10) - Windows UWP applications 说的，在应用程序启动足够快的时候，才不会显示欢迎页面的图片

Specifies whether an app should be launched without a splash screen. If true, the splash screen will not be shown if the app can launch fast enough. If there is a delay in the app launch time, the splash screen will be shown. If false, the splash screen will always be shown.

设置 a:Optional 的值是 true 那么将会让应用如果启动足够快就不显示欢迎界面，如果启动有延迟，那么将会依然显示欢迎界面。如果设置为 false 那么将会无论应用启动多快都显示启动图片

如果不知道怎么做，请看我放在github代码

另一个方法是删除 Package.appxmanifest 文件的 SplashScreen 配置，但是此时只是不使用欢迎界面图片，将会使用背景色，默认是白色作为初始屏幕

这个更改放在 github 欢迎小伙伴访问

Roslyn 读取 PackageReference 的版本号和内容

Thu, 03 Dec 2020 12:27:49 +0000

在写 msbuild 的预编译逻辑，如果想要拿到项目安装的 NuGet 库和版本，可以通过获取 PackageReference 的方法获取

获取方法是放在 Target 里面，如下面代码

    <Target Name="LabaijalacarDaqarheelu" BeforeTargets="Build">
        <ItemGroup>
            <PackageReferenceVersion Include="Name='%(PackageReference.Identity)' Version='%(PackageReference.Version)' PrivateAssets='%(PackageReference.PrivateAssets)'"></PackageReferenceVersion>
        </ItemGroup>
        <Warning Text="@(PackageReferenceVersion)"/>
    </Target>

上面代码使用 PackageReferenceVersion 获取项目所有的 PackageReference 然后使用 Warning 输出

为什么使用 Warning 输出，因为这样调试可以看到，默认的 dotnet 工具输出的 Waring 等级，关于 dotnet 的输出，请看 How to output the target message in dotnet build command line

另外上面的获取 ItemGroup 的某个 Item 的属性使用的是如何在 MSBuild 中正确使用 % 来引用每一个项（Item）中的元数据

项目文件的代码如下

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netcoreapp3.1</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="NewLife.RocketMQ" Version="1.3.2020.802" />
        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="3.1.6" PrivateAssets="all"></PackageReference>
    </ItemGroup>
    <Target Name="LabaijalacarDaqarheelu" BeforeTargets="Build">
        <ItemGroup>
            <PackageReferenceVersion Include="Name='%(PackageReference.Identity)' Version='%(PackageReference.Version)' PrivateAssets='%(PackageReference.PrivateAssets)'"></PackageReferenceVersion>
        </ItemGroup>
        <Warning Text="@(PackageReferenceVersion)"/>
    </Target>
</Project>

上面代码放在 github 在上面代码所在文件夹执行下面命令，可以看到输出

dotnet build

输出内容是

用于 .NET Core 的 Microsoft (R) 生成引擎版本 16.6.0+5ff7b0c9e
版权所有(C) Microsoft Corporation。保留所有权利。

  正在确定要还原的项目…
  所有项目均是最新的，无法还原。
  ChedarlelaNaykerkeargaini -> C:\lindexi\DealayhuneaWheluyearfair\bin\Debug\netcoreapp3.1\ChedarlelaNaykerkeargaini.dll
C:\lindexi\DealayhuneaWheluyearfair\ChedarlelaNaykerkeargaini.csproj(13,9): warning : Name='NewLife.RocketMQ' Version='1.3.2020.802' PrivateAssets='';Name='Microsoft.Extensions.Logging.Abstractions' Version='3.1.6' PrivateAssets='all'

已成功生成。

C:\lindexi\DealayhuneaWheluyearfair\ChedarlelaNaykerkeargaini.csproj(13,9): warning : Name='NewLife.RocketMQ' Version='1.3.2020.802' PrivateAssets='';Name='Microsoft.Extensions.Logging.Abstractions' Version='3.1.6' PrivateAssets='all'

如果将代码的 PackageReferenceVersion 放在 Target 外，如下面代码

    <ItemGroup>
        <PackageReferenceVersion Include="Name='%(PackageReference.Identity)' Version='%(PackageReference.Version)' PrivateAssets='%(PackageReference.PrivateAssets)'"></PackageReferenceVersion>
    </ItemGroup>
    <Target Name="LabaijalacarDaqarheelu" BeforeTargets="Build">
        <Warning Text="@(PackageReferenceVersion)"/>
    </Target>

使用命令行输入下面代码构建

dotnet build

那么此时的输出如下

C:\lindexi\QecoladeBafayearcur\QecoladeBafayearcur.csproj(13,9): warning : Name='%(PackageReference.Identity)' Version='%(PackageReference.Version)' PrivateAssets='%(PackageReference.PrivateAssets)'

可以看到没有内容，上面代码放在 github 请小伙伴自己使用命令行试试

更多编译相关请看手把手教你写 Roslyn 修改编译

其实在 msbuild 里，如果小伙伴读过吕水大大的帮助官方 NuGet 解掉 Bug，制作绝对不会传递依赖的 NuGet 包 - walterlv 那么贺喜，请试试下面的代码

<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
        <TargetFramework>netcoreapp3.1</TargetFramework>
    </PropertyGroup>

    <ItemGroup>
        <PackageReference Include="NewLife.RocketMQ" Version="1.3.2020.802" />
        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="3.1.6" PrivateAssets="all"></PackageReference>
    </ItemGroup>

    <Target Name="LaldalllayjeaCawerequrwai" BeforeTargets="CollectPackageReferences">
        <ItemGroup>
            <PackageReference Update="F123123" PrivateAssets="123" />
        </ItemGroup>
    </Target>

    <Target Name="LabaijalacarDaqarheelu" BeforeTargets="Build">
        <ItemGroup>
            <PackageReferenceVersion Include="Name='%(PackageReference.Identity)' Version='%(PackageReference.Version)' PrivateAssets='%(PackageReference.PrivateAssets)'"></PackageReferenceVersion>
        </ItemGroup>
        <Warning Text="@(PackageReferenceVersion)"/>
    </Target>

</Project>

对比上面的代码，其实添加了 LaldalllayjeaCawerequrwai 的代码，在这里面更新了一个随意的 NuGet 包，将 PrivateAssets 设置为 123 的值

    <Target Name="LaldalllayjeaCawerequrwai" BeforeTargets="CollectPackageReferences">
        <ItemGroup>
            <PackageReference Update="F123123" PrivateAssets="123" />
        </ItemGroup>
    </Target>

此时有什么锅？试试使用命令行构建

C:\lindexi\DealayhuneaWheluyearfair\ChedarlelaNaykerkeargaini.csproj(22,9): warning : Name='NewLife.RocketMQ' Version='1.3.2020.802' PrivateAssets='123';Name='Microsoft.Extensions.Logging.Abstractions' Version='3.1.6' PrivateAssets='123'

可以看到更新了一个 NuGet 库，但是全部的 NuGet 引用的 PrivateAssets 都被更改了

除了 PrivateAssets 还可以修改 Version 版本的值，也是全局

    <Target Name="LaldalllayjeaCawerequrwai" BeforeTargets="CollectPackageReferences">
        <ItemGroup>
            <PackageReference Update="Microsoft.Extensions.Logging.Abstractions" Version="3.1.6" PrivateAssets="123" />
        </ItemGroup>
    </Target>

此时所有的 NuGet 版本将被修改为 3.1.6 版本

此时将会提示 NewLife.RocketMQ 不包含 3.1.6 版本

Updated a PackageReference Version will update all of the PackageReference · Issue #12777 · dotnet/sdk

WPF 将 docx 的 Word 文件转换为 FlowDocument 显示

Thu, 03 Dec 2020 12:27:49 +0000

本文告诉大家如何将 docx 的 Word 文档在 WPF 中显示内容

本文源代码请看 ArtMalykhin/wpf-embedded-docx

在 Office 文档解析文档格式和协议咱可以了解到 Word 文档只是一个压缩文件里面的文件使用 xml 表示

因此需要做的是将 xml 转 FlowDocument 在 WPF 界面显示，大概做到的效果就是丢失很多样式和特效，然后文本形式加超链接在 WPF 显示的效果

详细请看 Show Word File in WPF - CodeProject

WPF SharpDx 性能优化方法

Thu, 03 Dec 2020 12:27:49 +0000

本文记录一些通用的 SharpDx 的性能优化方法

本文属于 SharpDx 系列博客，建议从头开始读

不要监听 ContentRendered 事件

监听了 Window 的 ContentRendered 事件将会降低整个 WPF 的渲染性能

关注硬件渲染

注意是否在 WPF 开启了硬件渲染，详细请看 WPF 渲染级别和 WPF 设置纯软件渲染

执行业务代码的耗时

在执行 SharpDx 的指导渲染逻辑，也就是告诉 SharpDx 应该画点还是画线的逻辑，在这个逻辑里面耦合了业务逻辑，业务逻辑本身的耗时将会让 SharpDx 的收集绘制指令的性能降低

_renderTarget.BeginDraw();

// 执行耗时的业务代码

_renderTarget.DrawEllipse(ellipse, brush, 1);

_renderTarget.EndDraw();

因此优先解决这部分业务代码，可选方案是让这部分代码先执行，执行完成之后再执行 SharpDx 的绘制逻辑

另一个方法就是让业务代码在另一个线程执行

这部分和具体业务相关

减少绘制数量

尽管使用 SharpDx 的绘制效率很高，但是假定需要执行的绘制命令特别多，此时也会降低性能，因此我的一个性能比较强的应用就预先计算出某些命令不会在界面可见，这部分就不参与渲染

如以下代码，这里的代码将会很多次的获取椭圆渲染

_renderTarget.BeginDraw();

for (int i = 0; i < 1000000; i++)
{
	var ellipse = GetEllipse(i);
	_renderTarget.DrawEllipse(ellipse, brush, 1);
}

_renderTarget.EndDraw();

而此时如果有一个方法可以判断某些矩形在界面是不可见的，如超过画面，那么过滤掉这部分命令，可以提升很多性能

   _renderTarget.BeginDraw();

   for (int i = 0; i < 1000000; i++)
   {
       var ellipse = GetEllipse(i);
       if (IsVisible(ellipse))
       {
           _renderTarget.DrawEllipse(ellipse, brush, 1);
       }
   }

   _renderTarget.EndDraw();

减少渲染命令是优化最强的方法

减少 Geometry 的绘制

在所有基础绘制命令，绘制 Geometry 是最吃显卡的，因此如果能使用基础图形，如线条或矩形等代替就不要使用 Geometry 绘制

图片优先 jpg 图片

大部分的显卡对于绘制 jpg 图片都有优化，可以认为 jpg 图片的渲染性能比较好。但是这不是说 jpg 的比 png 的好，因为影响图片的渲染性能有很多，如图片 dpi 和图片大小等

假设某些图片不关注透明等，同时这些图片是可以预先制作的，那么优先选 jpg 格式

Roslyn 打包 NuGet 包添加改动日志

Thu, 03 Dec 2020 12:27:49 +0000

默认的 NuGet 包支持在 releaseNotes 中添加更改日志，用户可以通过更改日志了解各个版本更新的内容。在 SDK Style 格式的 csproj 文件，可以读取本地的文本文件的内容作为 NuGet 包的改动日志

在我的团队的 CBB 基础库项目的文件规范，要求每个项目都会包含 README.md 和 CHANGELOG.md 文件，其中的 CHANGELOG.md 文件就是记录 API 变更等的改动记录文件

在更改日志写的比较好的项目是 Office 团队的 Open-XML-SDK 项目的 CHANGELOG.md 文件这个文件记录了每次 PR 包含的更改

在 SDK Style 里面让打包的 NuGet 添加改动日志的方法是设置 PackageReleaseNotes 属性的值，如下面代码

  <PropertyGroup>
    <PackageReleaseNotes># 1.0

  测试</PackageReleaseNotes>
  </PropertyGroup>

而在项目就包含了 CHANGELOG.md 文件

那么是否可以在 SDK Style 格式的项目文件里面读取项目的 CHANGELOG.md 或 RELEASE-NOTES.txt 的内容，作为 NuGet 包的 ReleaseNotes 内容？可以通过下面几个方法

  <PropertyGroup>
    <ChangeLogFile>$(MSBuildProjectDirectory)\CHANGELOG.md</ChangeLogFile>
    <PackageReleaseNotes>$([System.IO.File]::ReadAllText($(ChangeLogFile)))</PackageReleaseNotes>
  </PropertyGroup>

上面这个方法将会使用读取文件的方式，将 ChangeLogFile 的内容读取，然后将文本作为 PackageReleaseNotes 属性的内容。这里需要注意 ChangeLogFile 文件需要使用 Utf-8 编码

上面代码的 $(MSBuildProjectDirectory) 表示的是 csproj 项目文件所在的文件夹的路径，如果是期望获取当前的文件的文件夹，可以使用 $(MSBuildThisFileDirectory) 获取当前文件所在的文件夹。上面代码如果写在 csproj 文件，那么 $(MSBuildThisFileDirectory) 和 $(MSBuildProjectDirectory) 是相同的

另一个方法不是很靠谱，是通过 Target 读取文件的方式，这个方法不靠谱原因是 GenerateNuspec 不一定触发

<Target Name="PreparePackageReleaseNotesFromFile" BeforeTargets="GenerateNuspec">
  <ReadLinesFromFile File="../RELEASE-NOTES.txt" >
    <Output TaskParameter="Lines" ItemName="ReleaseNoteLines"/>
  </ReadLinesFromFile>
  <PropertyGroup>
    <PackageReleaseNotes>@(ReleaseNoteLines, '%0a')</PackageReleaseNotes>
  </PropertyGroup>
</Target>

上面代码读取 RELEASE-NOTES.txt 文件作为变更日志的内容

详细请看项目文件中的已知 NuGet 属性（使用这些属性，创建 NuGet 包就可以不需要 nuspec 文件啦

项目文件中的已知属性（知道了这些，就不会随便在 csproj 中写死常量啦） - walterlv

dotnet OpenXML 文本 Text Line Break 的作用

Thu, 03 Dec 2020 12:27:49 +0000

本文主要和小伙伴聊 a:br 这个标记的作用

在 OpenXML 的 <a:br/> 的定义是 Text Line Break 是放在文本的 <a:p> 的标记，用于表示换行

如 ECMA 376 文档的 21.1.2.2.1 所说，这个标记的作用是在一段内，将两个 TextRun 使用一个垂直的换行分割。这个元素可以具备当前的 rPr (RunProperties) 属性，可以用来设置换行的文本格式，用于在后续插入文本的时候使用正确的格式

在 OpenXML SDK 使用 DocumentFormat.OpenXml.Drawing.Break 表示，可以使用下面代码拿到

using DocumentFormat.OpenXml.Drawing;

public void Foo(Paragraph textParagraph)
{
   foreach (var openXmlElement in textParagraph)
   {
      if (openXmlElement is Break breakLine)
      {

      }
   }
}

在 Office 里面基本上段落的分割都是使用回车键，也就是你在 Word 里面按下回车键，那么将会创建新的段落。而 <a:br/> 的作用就是让文档可以在一个段落里面使用多行

更多请看 Office 使用 OpenXML SDK 解析文档博客目录

在 UWP 使用 XAML 的换行，请看 win10 uwp 在 xaml 让 TextBlock 换行

dotnet OpenXML 文本字体的选择规则

Thu, 03 Dec 2020 12:27:49 +0000

在 Office 的文本排版里面，会根据字符选择使用哪个字体插槽。也就是实际上在 Office 里面可以在一个文本段里面指定多个字体，会根据实际的字符使用不同的字体

在做 Office 解析的时候，在 OpenXML SDK 里面是没有找到表示字体的属性的，只能找到 LatinFont 和 EastAsianFont 和 ComplexScriptFont 和 SymbolFont 这几个

        public TextFontType LatinFont { get; set; } // latin
        public TextFontType EastAsianFont { get; set; } // ea
        public TextFontType ComplexScriptFont { get; set; } // cs
        public TextFontType SymbolFont { get; set; } // sym

而这每个里面都可以使用不同的字体，如下面的文档

<a:r>
   <a:rPr …>
     <a:cs typeface="Times New Roman"/>
     <a:latin typeface="songti"/>
   </a:rPr>
   <a:t>
 العربية 
   </a:t> 
</a:r>

可以看到这里包含了 a:cs 和 a:latin 分别表示 LatinFont 和 ComplexScriptFont 两个不同的插槽

那么具体的这个我也看不懂的文本应该使用 Times New Roman 还是使用宋体字体，这就需要使用下面这个表格的内容了

在 Office 里面将会根据字符的 Unicode 决定使用哪个字体插槽的字体

U+0000–U+007F latin font
U+0080–U+00A6 latin font
U+00A9–U+00AF latin font
U+00B2–U+00B3 latin font
U+00B5–U+00D6 latin font
U+00D8–U+00F6 latin font
U+00F8–U+058F latin font
U+0590–U+074F cs font
U+0780–U+07BF cs font
U+0900–U+109F cs font
U+10A0–U+10FF latin font
U+1200–U+137F latin font
U+13A0–U+177F latin font
U+1D00–U+1D7F latin font
U+1E00–U+1FFF latin font
U+1780–U+18AF cs font
U+2000–U+200B latin font
U+200C–U+200F cs font
U+2010–U+2029 latin font
U+2018–U+201F ea font
U+202A–U+202F cs font
U+2030–U+2046 latin font
U+204A–U+245F latin font
U+2670–U+2671 cs font
U+27C0–U+2BFF latin font
U+3099–U+309A ea font
U+D835 latin font
U+F000–U+F0FF sym font
U+FB00–U+FB17 latin font
U+FB1D–U+FB4F cs font
U+FE50–U+FE6F latin font
U+1D400–U+1D7FF latin font
其他 ea font

因此这和 C# dotnet 获取某个字符所在 Unicode 字符平面映射不相同

这是 ECMA-376 规定的

小伙伴如果不想自动动手写代码，可以参考我在 WPF 项目里面使用的代码，理论上你在 dotnet 的项目里面，能使用 C# 7.0 的语法就能使用

这是上层的使用方法，这里的 text 是输入的字符串

for (var i = 0; i < text.Length; i++)
{
   var c = text[i];

   TextType currentType = CharUnicodeRangeTextFontType.GetFontLang(c);
}

先定义一个枚举，表示当前的文本是什么，请看代码

        public enum TextType
        {
            /// <summary>
            /// 默认的文本 中文系 东亚字符
            /// </summary>
            EastAsian,
            /// <summary>
            /// 拉丁英文系
            /// </summary>
            Latin,
            /// <summary>
            /// 复杂脚本
            /// </summary>
            ComplexScript,

            /// <summary>
            /// 特殊符号
            /// </summary>
            Symbol,
        }

添加一个辅助类

   /// <summary>
    /// 文本内容范围判断类
    /// </summary>
    public class TextRangePattern
    {
        /// <summary>
        /// 创建文本内容范围判断类
        /// </summary>
        /// <param name="minChar"></param>
        /// <param name="maxChar"></param>
        public TextRangePattern(int minChar, int maxChar)
            : this((char)minChar, (char)maxChar)
        {

        }

        /// <summary>
        /// 创建文本内容范围判断类
        /// </summary>
        /// <param name="minChar"></param>
        /// <param name="maxChar"></param>
        public TextRangePattern(char minChar, char maxChar)
        {
            MinChar = minChar;
            MaxChar = maxChar;
        }

        /// <summary>
        /// 最小字符
        /// </summary>
        public char MinChar { get; }

        /// <summary>
        /// 最大字符
        /// </summary>
        public char MaxChar { get; }

        /// <summary>
        /// 是否输入的字符在范围内
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        public bool IsInRange(char c)
        {
            return !(c < MinChar || c > MaxChar);
        }
    }

接着就是创建 CharUnicodeRangeTextFontType 辅助类

    static class CharUnicodeRangeTextFontType
    {
        // 如果觉得下面的很多单词不知道是什么意思，请看 https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%B9%B3%E9%9D%A2%E6%98%A0%E5%B0%84

        private static TextRangePattern[] LatinFontTextRangePatternList { get; } =
        {
            // - U\+([\dA-F]+)–U\+([\dA-F]+).*
            new TextRangePattern(0x0000, 0x007F), // - U+0000–U+007F latin font 
            new TextRangePattern(0x0080, 0x00A6), // - U+0080–U+00A6 latin font 
            new TextRangePattern(0x00A9, 0x00AF), // - U+00A9–U+00AF latin font 
            new TextRangePattern(0x00B2, 0x00B3), // - U+00B2–U+00B3 latin font 
            new TextRangePattern(0x00B5, 0x00D6), // - U+00B5–U+00D6 latin font 
            new TextRangePattern(0x00D8, 0x00F6), // - U+00D8–U+00F6 latin font 
            new TextRangePattern(0x00F8, 0x058F), // - U+00F8–U+058F latin font 
            new TextRangePattern(0x10A0, 0x10FF), // - U+10A0–U+10FF latin font 
            new TextRangePattern(0x1200, 0x137F), // - U+1200–U+137F latin font 
            new TextRangePattern(0x13A0, 0x177F), // - U+13A0–U+177F latin font 
            new TextRangePattern(0x1D00, 0x1D7F), // - U+1D00–U+1D7F latin font 
            new TextRangePattern(0x1E00, 0x1FFF), // - U+1E00–U+1FFF latin font 
            new TextRangePattern(0x2000, 0x200B), // - U+2000–U+200B latin font 
            new TextRangePattern(0x2010, 0x2029), // - U+2010–U+2029 latin font
            new TextRangePattern(0x2030, 0x2046), // - U+2030–U+2046 latin font 
            new TextRangePattern(0x204A, 0x245F), // - U+204A–U+245F latin font 
            new TextRangePattern(0x27C0, 0x2BFF), // - U+27C0–U+2BFF latin font 
            new TextRangePattern(0xFB00, 0xFB17), // - U+FB00–U+FB17 latin font 
            new TextRangePattern(0xFE50, 0xFE6F), // - U+FE50–U+FE6F latin font
            new TextRangePattern(0xD835, 0xD835), // - U+D835        latin font
        };

        private static TextRangePattern[] ComplexScriptFontTextRangePatternList { get; } =
        {
            new TextRangePattern(0x0590, 0x074F), // - U+0590–U+074F cs font 
            new TextRangePattern(0x0780, 0x07BF), // - U+0780–U+07BF cs font 
            new TextRangePattern(0x0900, 0x109F), // - U+0900–U+109F cs font 
            new TextRangePattern(0x1780, 0x18AF), // - U+1780–U+18AF cs font 
            new TextRangePattern(0x200C, 0x200F), // - U+200C–U+200F cs font 
            new TextRangePattern(0x202A, 0x202F), // - U+202A–U+202F cs font 
            new TextRangePattern(0x2670, 0x2671), // - U+2670–U+2671 cs font 
            new TextRangePattern(0xFB1D, 0xFB4F), // - U+FB1D–U+FB4F cs font 
        };

        private static TextRangePattern[] EastAsianFontTextRangePatternList { get; } =
        {
            new TextRangePattern(0x2018, 0x201F), // - U+2018–U+201F ea font
            new TextRangePattern(0x3099, 0x309A), // - U+3099–U+309A ea font  
        };

        private static TextRangePattern[] SymbolFontTextRangePatternList { get; } =
        {
            new TextRangePattern(0xF000, 0xF0FF), // - U+F000–U+F0FF sym font 
        };

        private static (TextType textType, TextRangePattern[] fontTextRangePatternList)[] PatternList { get; } =
        {
            (TextType.Latin, LatinFontTextRangePatternList),
            (TextType.ComplexScript, ComplexScriptFontTextRangePatternList),
            (TextType.EastAsian, EastAsianFontTextRangePatternList),
            (TextType.Symbol, SymbolFontTextRangePatternList)
        };

        /// <summary>
        /// 根据传入的字符判断当前是哪个语言项
        /// </summary>
        /// <param name="ch"></param>
        /// <returns></returns>
        public static TextType GetFontLang(char ch)
        {
            // 按照 [dotnet OpenXML 文本字体的选择规则](https://blog.lindexi.com/post/dotnet-OpenXML-%E6%96%87%E6%9C%AC%E5%AD%97%E4%BD%93%E7%9A%84%E9%80%89%E6%8B%A9%E8%A7%84%E5%88%99.html)

            foreach (var (textType, fontTextRangePatternList) in PatternList)
            {
                if (fontTextRangePatternList.Any(temp => temp.IsInRange(ch)))
                {
                    return textType;
                }
            }

            // - 其他 ea font
            return TextType.EastAsian;
        }
    }

上面代码忽略 utf16 的字符

WPF 如何给 Grid 的某一行添加背景色

Thu, 03 Dec 2020 12:27:49 +0000

其实在 WPF 里面是不存在单独设置 Grid 的某一行的配色，但是想要达到这个视觉效果，可以通过 Border 配合做到

使用方法很简单，假设咱创建了一个简单的 WPF 的 Xaml 界面如下

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"></RowDefinition>
            <RowDefinition Height="*"></RowDefinition>
            <RowDefinition Height="*"></RowDefinition>
        </Grid.RowDefinitions>
    </Grid>

此时需要设置这个 Grid 的某一行的背景颜色，可以通过在这一行放一个 Border 同时设置这个元素的背景色做到

在 Grid 的某一行放某个元素的做法就是放下一个元素，指定这个元素放在 Grid 的哪一行，请看下面代码

        <Border Grid.Row="1" Background="Gray"></Border>

此时上面的代码就指定放在了 Grid 的第一行，注意上面代码是从第0行开始计算的。上面代码就设置了 Grid 的第1行存在一个只有背景的 Border 元素，因此视觉效果就是 Grid 的第一行背景色是灰色

在 Grid 的某个行列里面可以存放无数个元素，元素层级在没有指定 Canvas.ZIndex 时将会按照编写的顺序设置

因此想要让 Border 作为某一行的 Grid 的背景色，就需要将这个 Border 在对比这一行的其他元素最先写。因此最先写的元素就放在现实的最后面，可以理解为有一个画笔在画布上画，先画的图形将会在画面的最下方

看到这里小伙伴是不是也就理解了如何在 Grid 里面的某一列添加背景色呢。其实给 Grid 的列添加背景色和给行添加背景色的方法是差不多的

通过 Border 加上背景色的方法不仅可以满足视觉效果，也是相对来说性能比较好的方法。另外 Border 的背景支持画刷，也就是不知是纯色，还支持图片等。这部分就需要小伙伴自己玩一下

这个项目所有代码放在 github 欢迎小伙伴访问

WPF HandyControl 已支持给任意控件通过按下移动抬起封装点击事件

Thu, 03 Dec 2020 12:27:49 +0000

著名的 HandyControl 已经支持给任意控件通过按下移动抬起事件，封装点击事件

在 HandyControl 的这个 PR 添加了 InputClickHelper 类，这个类提供了使用控件的按下移动抬起事件封装为点击事件

使用方法：

Install-Package HandyControl

给任意控件 element 附加按下移动抬起封装点击事件，下面代码的 uiElement 是一个 UIElement 控件

HandyControl.Tools.InputClickHelper.AttachMouseDownMoveUpToClick(uiElement, UIElement_OnClicked);

        private void UIElement_OnClicked(object sender, EventArgs e)
        {
            
        }

此外，在 AttachMouseDownMoveUpToClick 方法还提供了按下过程中，用户移动鼠标或触摸触发的点击事件打断作为拖拽事件。使用方法如下

HandyControl.Tools.InputClickHelper.AttachMouseDownMoveUpToClick(uiElement, UIElement_OnClicked, UIElement_OnDragStarted);

        private void UIElement_OnDragStarted(object sender, EventArgs e)
        {
            
        }

UNO UnoConf 2020 在线会议了解全平台新开发框架零距离接触官方开发者

Thu, 03 Dec 2020 12:27:49 +0000

作为新一代的全平台开发框架 UNO 将在 2020 的 8 月 13 日进行线上举行 UnoConf 2020 在线会议，所有小伙伴都可以免费参加

参加链接： https://www.eventbrite.ca/e/unoconf-2020-livestream-tickets-106050903106

VisualStudio 解决首次调试 docker 的 vs2017u5 exists, deleting 太慢问题

Thu, 03 Dec 2020 12:27:49 +0000

首次调试需要下载一些有趣的内容用于辅助调试，这部分内容大概有 100 多 M 在 VS 里面需要在半天。本文告诉大家如何在外面使用其他强大的下载工具下载完成之后复制回去

本文特别参考了 visual studio 容器工具首次加载太慢 vsdbg\vs2017u5 exists, deleting 的解决方案 - microestc - 博客园的方法，在此基础上做一点补充

可以看到的输出窗口信息如下

1>Doubi -> D:\lindexi\Doubi\Doubi\bin\Debug\netcoreapp3.1\Doubi.dll
1>C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -NonInteractive -NoProfile -WindowStyle Hidden -ExecutionPolicy RemoteSigned -File "C:\Users\lindexi\AppData\Local\Temp\GetVsDbg.ps1" -Version vs2017u5 -RuntimeID linux-x64 -InstallPath "C:\Users\lindexi\vsdbg\vs2017u5"
1>Info: Using vsdbg version '16.6.20415.1'
1>Info: Using Runtime ID 'linux-x64'
1>Info: C:\Users\lindexi\vsdbg\vs2017u5 exists, deleting.

这里面有三个关键的信息

第一个是使用的 vsdbg 版本号，也就是 1>Info: Using vsdbg version '16.6.20415.1' 中的 16.6.20415.1 版本号，请记下

第二个是 Runtime ID 号。也就是 1>Info: Using Runtime ID 'linux-x64' 的 linux-x64 号，也请记下

最后是输出的文件路径，也就是 1>Info: C:\Users\lindexi\vsdbg\vs2017u5 exists, deleting. 的 C:\Users\lindexi\vsdbg\vs2017u5 路径，请记下

手动下载需要拼接下载路径，下载路径是 https://vsdebugger.azureedge.net/vsdbg-(你的版本号 .号换成-号)/vsdbg-(你的Runtime ID).zip 链接

根据上面所记的信息，这里的 vsdbg-(你的版本号 .号换成-号) 应该替换为 16.6.20415.1 版本号，同时将此版本的 . 号更改为 - 号，更改之后的内容如下 vsdbg-16-6-20415-1 这就是拼接的第一个版本号

然后再拼接上 Runtime ID 号，如上面记下的第二个关键信息，也就是 linux-x64 替换如下 vsdbg-linux-x64.zip 最后拼接的链接如下

https://vsdebugger.azureedge.net/vsdbg-16-6-20415-1/vsdbg-linux-x64.zip

打开自己收藏的强大的下载工具，如 dotnet FileDownloader 或 IDM 等工具下载此压缩包。对应上面链接，我下载之后放在 CSDN 欢迎小伙伴点击此链接下载。如有其他版本下载不了，可以邮件或 QQ 联系我，我可以帮你下载

下载完成之后，将压缩包解压到输出的文件路径，也就是刚才记住的第三个信息。如我的路径是 C:\Users\lindexi\vsdbg\vs2017u5 文件夹，解压缩时不带上压缩包名字

最终解压缩之后的 C:\Users\lindexi\vsdbg\vs2017u5 大概如下

接下来在 C:\Users\lindexi\vsdbg\vs2017u5 文件夹创建两个文件，分别是 success_version.txt 和 success_rid.txt 文件

在 success_version.txt 文件里面填写 VSDbg 版本号，也就是刚才记下的第一个信息，如我的是 16.6.20415.1 版本号

在 success_rid.txt 文件里面填写 Runtime ID 号，也就是刚才记下的第二个信息，如我的是 linux-x64 号

完成之后，如果此时的 VS 还在准备调试中，可以点击生成菜单，关闭这一次的生成，然后再继续生成。如果上面步骤没有错的话，应该很快就会看到 vs2017u5 exists, deleting 这一步骤很快就跳过了

跳过之后如果可以看到 linux-musl-x64 的下载，如以下输出内容

1>C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -NonInteractive -NoProfile -WindowStyle Hidden -ExecutionPolicy RemoteSigned -File "C:\Users\lindexi\AppData\Local\Temp\GetVsDbg.ps1" -Version vs2017u5 -RuntimeID linux-musl-x64 -InstallPath "C:\Users\lindexi\vsdbg\vs2017u5\linux-musl-x64"
1>Info: Using vsdbg version '16.6.20415.1'
1>Info: Using Runtime ID 'linux-musl-x64'

依然需要记下三个关键信息，和上面的差不多

第一个信息是版本号，也就是 1>Info: Using vsdbg version '16.6.20415.1' 的 16.6.20415.1 版本号，请记下

第二个是 Runtime ID 号。也就是 1>Info: Using Runtime ID 'linux-musl-x64' 的 linux-musl-x64 号，也请记下

第三个信息是输出路径，也就是 1>C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -NonInteractive -NoProfile -WindowStyle Hidden -ExecutionPolicy RemoteSigned -File "C:\Users\lindexi\AppData\Local\Temp\GetVsDbg.ps1" -Version vs2017u5 -RuntimeID linux-musl-x64 -InstallPath "C:\Users\lindexi\vsdbg\vs2017u5\linux-musl-x64" 的 C:\Users\lindexi\vsdbg\vs2017u5\linux-musl-x64 文件夹

对比上面的步骤，可以看到是放在 vs2017u5 的 linux-musl-x64 文件夹

注意第二个信息的是 linux-musl-x64 和上面步骤的 linux-x64 不相同

接下来拼接下载路径，和上面步骤差不多，下载路径是 https://vsdebugger.azureedge.net/vsdbg-(你的版本号 .号换成-号)/vsdbg-(你的Runtime ID).zip 链接

用记住的第一个信息替换版本号，如使用 16.6.20415.1 替换 vsdbg-(你的版本号 .号换成-号) 可以拿到 vsdbg-16-6-20415-1 版本号

使用记住的第二个信息替换 Runtime ID 号，如使用 linux-musl-x64 替换 vsdbg-(你的Runtime ID).zip 可以拿到 vsdbg-linux-musl-x64.zip 链接

拼接起来的链接大概如下，这个版本我放在 CSDN 上，点击此链接可以下载

https://vsdebugger.azureedge.net/vsdbg-16-6-20415-1/vsdbg-linux-musl-x64.zip

再次使用本地工具下载此压缩包，下载完成之后解压缩到记住的第三个信息对应的文件夹里面，如 C:\Users\lindexi\vsdbg\vs2017u5\linux-musl-x64 文件夹

解压缩完成之后，复制刚才创建的 success_version.txt 和 success_rid.txt 文件，放在 C:\Users\lindexi\vsdbg\vs2017u5\linux-musl-x64 文件夹，请自行替换为具体你的路径

打开 success_version.txt 文件，替换内容为刚才记住的第一个信息，基本上内容应该是一样的，也就是替换前后内容实际上没有变化

最后需要重启一下 VisualStudio 哦，千万记得重启

dotnet 使用完全对象引用相等判断

Thu, 03 Dec 2020 12:27:49 +0000

默认在列表以及字典哈希这些都会先看对象是否有自己实现的等于判断，如果有就调用对象的。因此对象可以做到两个不同的对象返回相等。而如果需要判断对象引用相等，也就是只有相同的对象才返回相等，此时需要用到 ReferenceEquals 方法。这个判断方法是最快的判断相等的方法，只有在传入的两个参数是相同的对象的时候才会返回 true 的值

那么如何将这个引用相等放在列表或字典哈希等的判断里面？可以看到字典等的构造函数都有重载方法，要求传入 IEqualityComparer 接口，于是可以做如下实现

    class ReferenceEqualsComparer<T> : ReferenceEqualsComparer, IEqualityComparer<T>
    {
        /// <inheritdoc />
        public bool Equals(T x, T y) => ((IEqualityComparer) this).Equals(x, y);

        /// <inheritdoc />
        public int GetHashCode(T obj) => obj.GetHashCode();
    }

    class ReferenceEqualsComparer : IEqualityComparer
    {
        /// <inheritdoc />
        bool IEqualityComparer.Equals(object x, object y) => ReferenceEquals(x, y);

        /// <inheritdoc />
        public int GetHashCode(object obj) => obj?.GetHashCode()??0;
    }

对于字典可以这样使用

        private Dictionary<Lindexi, string> LindexiShiDoubi { get; } =
            // 这里需要使用完全相等的判断，对象完全相等
            new Dictionary<Lindexi, string>(new ReferenceEqualsComparer<Lindexi>());

对于哈希可以这样使用

private HashSet<Lindexi> Lindexi { get; } = new HashSet<Lindexi>(new ReferenceEqualsComparer<Lindexi>());

这样所有进行判断的 Contains 或 ContainsKey 都使用对象引用判断，只有传入和内存里面存放相同的对象才能判断存在

Roslyn 禁止 sdk style csproj 默认引用 Compile 代码文件

Thu, 03 Dec 2020 12:27:49 +0000

默认在 SDK Style 的 csproj 文件将会引用所有的 .cs 文件到 Compile 项，如果是 WPF 项目还会添加 xaml 的引用。如果想要自己手动设置，让一些项不默认引用，需要添加属性 EnableDefaultCompileItems 告诉 msbuild 不要默认引用

禁止 .cs 文件作为 Compile 的默认引用方法

<PropertyGroup>
    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
</PropertyGroup>

如果没有禁止，将会使用如下引用

<Compile Include="**\*.cs" />

禁止 xaml 文件作为 Page 的默认引用

<PropertyGroup>
    <EnableDefaultPageItems>false</EnableDefaultPageItems>
</PropertyGroup>

禁止创建默认特性

<PropertyGroup>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
</PropertyGroup>

关于默认特性创建请看解决从旧格式的 csproj 迁移到新格式的 csproj 格式 AssemblyInfo 文件值重复问题

禁止图片等作为 None 默认引用

<PropertyGroup>
    <EnableDefaultNoneItems>false</EnableDefaultNoneItems>
</PropertyGroup>

禁止所有默认引用

<PropertyGroup>
    <EnableDefaultItems>false</EnableDefaultItems>
</PropertyGroup>

从以前的项目格式迁移到 VS2017 新项目格式

WPF 两个 Topmost 的窗口如何设置谁在最上方

Thu, 03 Dec 2020 12:27:49 +0000

我需要有两个层级最高的窗口，但是要求某个窗口在另一个的上方，同时这两个窗口在所有其他的应用程序窗口的上方

需要用到 SetWindowLong 的 win32 方法的设置，假设我有 A 和 B 两个窗口，我需要让这两个窗口都是 Topmost 同时 A 在 B 的上方

大概逻辑如下

            B.Loaded += (sender, args) =>
            {
                A.Topmost = false;
                A.Topmost = true;

                B.Dispatcher.InvokeAsync(() =>
                {
                    Win32.User32.SetWindowLongPtr(new WindowInteropHelper(A).Handle,
                        Win32.GetWindowLongFields.GWL_HWNDPARENT, new WindowInteropHelper(B).Handle);
                });
            };

为什么需要在 B 的 Loaded 之后，原因是为了窗口实际创建出来，拿到句柄

为什么还需要做延迟一拍设置，因为立刻设置可能和控件初始化冲突，如 Popup 刚好弹出，将不会收起。注意这是在一个特别复杂的项目里面才发现这个坑，我创建空白项目没有发现这个坑

这里的 SetWindowLongPtr 是 SetWindowLong 方法，只是封装了 x86 和 x64 的代码

关于 GWL_HWNDPARENT 的定义如下

    public enum GetWindowLongFields
    {
      GWL_USERDATA = -21, // 0xFFFFFFEB
      GWL_EXSTYLE = -20, // 0xFFFFFFEC
      GWL_STYLE = -16, // 0xFFFFFFF0
      GWL_ID = -12, // 0xFFFFFFF4
      GWL_HWNDPARENT = -8, // 0xFFFFFFF8
      GWL_HINSTANCE = -6, // 0xFFFFFFFA
      GWL_WNDPROC = -4, // 0xFFFFFFFC
    }

设置两个窗口有关联和 WPF 的设置 Owner 几乎等价，只是这个 win32 方法可以在复杂项目也设置上去

C# dotnet 提示找不到 CompositionContainer 类的解决方法

Thu, 03 Dec 2020 12:27:49 +0000

在构建提示 Error CS0012 和 Error CS0246 说找不到 CompositionContainer 类，原因是没有引用 System.ComponentModel.Composition 库

在构建的时候有如下提示

0>MainWindow.xaml.cs(51,59): Error CS0246: The type or namespace name 'CompositionContainer' could not be found (are you missing a using directive or an assembly reference?)
0>MainWindow.xaml.cs(51,35): Error CS0012: The type 'CompositionContainer' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.ComponentModel.Composition, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.

原因是没有引用 System.ComponentModel.Composition 库，双击项目编辑 csproj 项目，添加下面代码

    <ItemGroup>
        <Reference Include="System.ComponentModel.Composition"/>
    </ItemGroup>

要求 csproj 是 sdk 风格的，如果不是，请右击引用，添加引用，找到 System.ComponentModel.Composition 勾选

WPF 开机启动因为触摸初始化锁住界面显示

Thu, 03 Dec 2020 12:27:49 +0000

现象是设置 WPF 开机启动的时候，概率界面不显示，进程已经起来，同时占用内存极小。通过 dump 或附加调试可以看到主进程带等待触摸线程的回应

在我的某个有趣的设备上，这个设备开机启动的时候将会比较慢初始化完成 USB 设备，或者说是 HID 触摸屏设备

此时测试小伙伴告诉我说测试了几百次，会发现有一次某个开机启动的 WPF 应用起不来了

我使用 dnspy 附加调试看到了主线程其实执行了，但是在一个锁里面等待，如下图

实际上的进入锁的代码是没有意义的，需要看是业务上哪里进入了锁

从调用堆栈里面，如下图，可以看到是 PenThreadWorker.WorkerGetTabletsInfo 方法在等待锁

通过 WPF 触摸到事件可以了解到这是在等待触摸线程执行

这是在 dnspy 断点不够准，实际的代码是 getTablets.DoneEvent.WaitOne();

也就是这个是在等待一个锁，这个会在什么时候释放，会在 Stylus Input 线程执行完成之后释放，那么 Stylus Input 线程在做什么呢

这个 Stylus Input 线程在等待触摸消息，这就有趣了。主线程在等待触摸线程执行获取 Tablet 信息，而触摸线程在等待主线程初始化完成之后可以获取触摸消息

因此主线程等不到触摸线程执行获取触摸信息完成，也就是主线程被锁住

那为什么刚好主线程需要等待触摸获取信息？原因是刚好在开机的时候收到了 OnDeviceChange 消息，因此就会需要调用 WispLogic 的 WispTabletDevices 属性的获取，从本文下方的详细的主线程堆栈可以看到

因此解决方法是禁用 WPF 启动的时候初始化触摸，禁用方法通过 AppSwitch 禁用 WPF 内置的触摸让 WPF 程序可以处理 Windows 触摸消息 - walterlv

这个解决方法的缺点是会干掉多指触摸，不过没关系，咱可以使用消息解决这个问题。通过监听 Windows 触摸消息加上 WPF 模拟触摸设备就能继续做多指触摸了

更多触摸相关请看 WPF 触摸相关

此问题已报告官方，请看 The main thread of the WPF application that starts automatically at boot will forever wait for the touch thread to execute · Issue #3147 · dotnet/wpf 求点赞

详细的主线程堆栈

 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext) (IL≈0x0014, Native=0x6EC56B10+0x21)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext) (IL≈0x0000, Native=0x6EC56AD0+0x28)
 	mscorlib.dll!System.Threading.WaitHandle.WaitOne() (IL=epilog, Native=0x6EC56AB0+0x12)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.WorkerGetTabletsInfo() (IL≈0x002F, Native=0x6C420C30+0xBE)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL=epilog, Native=0x6C439AB8+0x64)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.OnDeviceChange() (IL≈0x000F, Native=0x6C3E9830+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.HandleMessage(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x004C, Native=0x6C3E85C0+0x73)
 	PresentationFramework.dll!System.Windows.SystemResources.InvalidateTabletDevices(MS.Internal.Interop.WindowMessage msg, System.IntPtr wParam, System.IntPtr lParam) (IL=epilog, Native=0x6B3EA58C+0x9D)
 	PresentationFramework.dll!System.Windows.SystemResources.SystemThemeFilterMessage(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0094, Native=0x6AC6FC60+0x96)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	WindowsBase.dll!System.Windows.Threading.DispatcherSynchronizationContext.Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6C9DB400+0x23)
 	mscorlib.dll!System.Threading.SynchronizationContext.InvokeWaitMethodHelper(System.Threading.SynchronizationContext syncContext, System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) (IL=epilog, Native=0x6EC55D30+0x14)
 	PresentationCore.dll!MS.Win32.Penimc.UnsafeNativeMethods.CreatePimcManager() (IL=0x0022, Native=0x6C422318+0x53)
 	PresentationCore.dll!MS.Win32.Penimc.UnsafeNativeMethods.UnsafeNativeMethods() (IL=prolog, Native=0x6C422288+0x21)
 	PresentationCore.dll!System.Windows.Input.PenThreadWorker.PenThreadWorker() (IL≈0x004C, Native=0x6C42080C+0xCB)
 	PresentationCore.dll!System.Windows.Input.PenThreadPool.GetPenThreadForPenContextHelper(System.Windows.Input.PenContext penContext) (IL≈0x005B, Native=0x6C42067C+0xE5)
 	PresentationCore.dll!System.Windows.Input.PenThreadPool.GetPenThreadForPenContext(System.Windows.Input.PenContext penContext) (IL=epilog, Native=0x6C4205A8+0x84)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTabletsImpl() (IL≈0x0009, Native=0x6C439AB8+0x2D)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.UpdateTablets() (IL=0x0042, Native=0x6C439A24+0x5A)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispTabletDeviceCollection.WispTabletDeviceCollection() (IL≈0x003D, Native=0x6BF31B38+0xC2)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.WispTabletDevices.get() (IL=0x000E, Native=0x6BF5DF4C+0x20)
 	PresentationCore.dll!System.Windows.Input.StylusWisp.WispLogic.RegisterHwndForInput(System.Windows.Input.InputManager inputManager, System.Windows.PresentationSource inputSource) (IL≈0x0032, Native=0x6BF5DD50+0x8F)
 	PresentationCore.dll!System.Windows.Interop.HwndStylusInputProvider.HwndStylusInputProvider(System.Windows.Interop.HwndSource source) (IL=0x005A, Native=0x6BF5DBCC+0xF8)
 	PresentationCore.dll!System.Windows.Interop.HwndSource.Initialize(System.Windows.Interop.HwndSourceParameters parameters) (IL=0x0253, Native=0x6BF5C4C8+0x433)
 	PresentationFramework.dll!System.Windows.Window.CreateSourceWindow(bool duringShow) (IL=0x0082, Native=0x6AC1C0F4+0x1E0)
 	PresentationFramework.dll!System.Windows.Window.CreateSourceWindowDuringShow() (IL=epilog, Native=0x6ACBB474+0xF)
 	PresentationFramework.dll!System.Windows.Window.SafeCreateWindowDuringShow() (IL=epilog, Native=0x6AC1D7B4+0x41)
 	PresentationFramework.dll!System.Windows.Window.ShowHelper(object booleanBox) (IL=0x003B, Native=0x6AC1D644+0x78)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.DispatcherOperation.InvokeImpl() (IL≈0x007A, Native=0x6C9DE6D0+0xD2)
 	WindowsBase.dll!System.Windows.Threading.DispatcherOperation.InvokeInSecurityContext(object state) (IL=epilog, Native=0x6C9DE690+0x3C)
 	mscorlib.dll!System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state, bool preserveSyncCtx) (IL≈0x0079, Native=0x6EC82DC0+0xE5)
 	mscorlib.dll!System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state, bool preserveSyncCtx) (IL=epilog, Native=0x6EC82DA0+0x16)
 	mscorlib.dll!System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state) (IL=epilog, Native=0x6EC82D30+0x41)
 	WindowsBase.dll!MS.Internal.CulturePreservingExecutionContext.Run(MS.Internal.CulturePreservingExecutionContext executionContext, System.Threading.ContextCallback callback, object state) (IL=epilog, Native=0x6C9DE480+0x63)
 	WindowsBase.dll!System.Windows.Threading.DispatcherOperation.Invoke() (IL=0x0020, Native=0x6C9DE340+0x4E)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.ProcessQueue() (IL=0x00F6, Native=0x6C9DA870+0x165)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.WndProcHook(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL=0x0090, Native=0x6C9DAB70+0x5A)
 	WindowsBase.dll!MS.Win32.HwndWrapper.WndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled) (IL≈0x0030, Native=0x6C9DC1F0+0x9B)
 	WindowsBase.dll!MS.Win32.HwndSubclass.DispatcherCallbackOperation(object o) (IL≈0x0036, Native=0x6C9DC170+0x6B)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate callback, object args, int numArgs) (IL≈0x0077, Native=0x6C9DC010+0x52)
 	WindowsBase.dll!System.Windows.Threading.ExceptionWrapper.TryCatchWhen(object source, System.Delegate callback, object args, int numArgs, System.Delegate catchHandler) (IL≈0x0002, Native=0x6C9DBF70+0x34)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.LegacyInvokeImpl(System.Windows.Threading.DispatcherPriority priority, System.TimeSpan timeout, System.Delegate method, object args, int numArgs) (IL≈0x00BB, Native=0x6C9DA450+0x131)
 	WindowsBase.dll!MS.Win32.HwndSubclass.SubclassWndProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam) (IL=0x0130, Native=0x6C9DB9C0+0xEE)
 	[ToNative]
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.PushFrameImpl(System.Windows.Threading.DispatcherFrame frame) (IL≈0x0040, Native=0x6C9D84CC+0xB1)
 	WindowsBase.dll!System.Windows.Threading.Dispatcher.PushFrame(System.Windows.Threading.DispatcherFrame frame) (IL=epilog, Native=0x6C9D8124+0x4A)
 	PresentationFramework.dll!System.Windows.Application.RunDispatcher(object ignore) (IL=0x0024, Native=0x6ABF4E70+0x5A)
 	PresentationFramework.dll!System.Windows.Application.RunInternal(System.Windows.Window window) (IL=0x00EE, Native=0x6ABF4CEC+0x74)
 	PresentationFramework.dll!System.Windows.Application.Run(System.Windows.Window window) (IL=epilog, Native=0x6ABF4ADC+0x2B)
 	PresentationFramework.dll!System.Windows.Application.Run() (IL=epilog, Native=0x6ABF46C8+0x1C)
 	Lindexi.WPF.exe!Lindexi.Program.Initialize() (IL≈0x000E, Native=0x0592A0A0+0x54)
 	Lindexi.WPF.exe!Lindexi.Program.Main(string[] args) (IL=0x001C, Native=0x00DF0448+0x42)

触摸 Stylus Input 线程堆栈

>	PresentationCore.dll!System.Windows.Input.PenThreadWorker.ThreadProc() (IL≈0x00AF, Native=0x6C421E44+0x176)
 	mscorlib.dll!System.Threading.ThreadHelper.ThreadStart_Context(object state) (IL=epilog, Native=0x6EC56060+0x9D)
 	mscorlib.dll!System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state, bool preserveSyncCtx) (IL≈0x0079, Native=0x6EC82DC0+0xE5)
 	mscorlib.dll!System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state, bool preserveSyncCtx) (IL=epilog, Native=0x6EC82DA0+0x16)
 	mscorlib.dll!System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state) (IL=epilog, Native=0x6EC82D30+0x41)
 	mscorlib.dll!System.Threading.ThreadHelper.ThreadStart() (IL=epilog, Native=0x6EC56014+0x44)

Unity3D 2019 设置的 Playmode tint 有何作用

Thu, 03 Dec 2020 12:27:49 +0000

在 Unity3D 编辑器点击运行的时候，此时对整个面板修改的值仅在本次运行生效，当运行结束之后就会回到原来的值。因此为了避免调了半天实际上是在运行模式调的值，咱可以修改 Unity3D 编辑器的界面，让咱可以知道当前是 Unity3D 运行模式

点击 Edit 的 Preferences 然后进入 Colors 界面

此时可以看到 General 的 PlayMode tine 选项

这个选项可以选择一个颜色，这个颜色指的是 Unity3D 在运行模式时编辑器显示的主题颜色

修改这个颜色，然后关闭 Perferences 窗口，回到 Unity3D 编辑器，尝试点击运行

此时就可以看到编辑器的颜色都更改了，这样就比较方便解决了没有意识到当前 Unity3d 进入了运行模式

如果调残了怎么办？在 Perferences 的最下方有个 Use Defaults 按钮，点击这个按钮就会还原为默认的配色

有了这个还原功能，小伙伴就能随意的修改颜色

Unity3d 2019.3 通过 Ctrl 键让移动是固定步距

Thu, 03 Dec 2020 12:27:49 +0000

默认在 Unity3d 通过 w 的移动的时候，是根据鼠标的移动距离移动物体，此时做对齐就不好玩了。通过按下 ctrl 键盘，然后再拖动物体移动，此时就可以设置移动是固定的步频

而如何修改默认的步频？可以通过点击 edit 的 Snap Settings 打开设置面板，此时从面板里面设置各个方向的步距

此时设置的值就是按下 ctrl 的时候移动的最小距离，也是移动的固定距离

除了移动之外，还可以设置缩放的每次固定大小，和旋转的固定大小

Unity 2019.3 将 RenderTexture 绑定到相机和物体作出镜子效果

Thu, 03 Dec 2020 12:27:49 +0000

在 Unity 的 RenderTexture 是一个特殊的纹理，这个纹理是渲染器纹理，可以用于关联摄像机画面和物体，做到在物体上附加某个摄像机画面的纹理

这个 RenderTexture 比较特殊，一方面是获取某个相机的画面，另一个方面是作为纹理放在某个物体上

首先右击创建，创建一个渲染器纹理

接着将这个渲染器纹理改一下名字，如修改为 RenderTexture1 的名字

接着创建一个相机，这个相机的内容将会作为 RenderTexture1 的内容，做法是选择摄像机，拖动 RenderTexture1 放在目标纹理上，请看下图

然后将这个 RenderTexture1 拖放到物体上，如一个 Cube 上，此时这个 Cube 就会显示相机的内容

现在可以看到的效果如下图，下图选中的摄像机的画面将会作为纹理贴到立方体上

实在不知道怎么做的，不妨看看我的视频 Unity 2019.3 将 RenderTexture 绑定到相机和物体作出镜子效果_一起学精彩视频_虎牙视频

收到零哥的邀请，我将视频放到了虎牙，放心，没有任何广告，只是讲得比较渣

更多请看 RenderTexture

Unity RenderTexture的应用 - 简书

C# dotnet 本地代码构建没问题，但 CI 自动构建失败可能的原因

Thu, 03 Dec 2020 12:27:49 +0000

本地构建能通过至少代码上的问题不大，本文列举了一些可能的原因，小伙伴可以按照顺序依次查看代码和配置

代码分支

默认的 CI 和 CD 构建的分支应该是主分支或开发分支，而此时服务器构建的代码的版本也许和本地调试的代码的分支不相同

例如服务器上的运行 CI CD 的 git 仓库分支是 master 分支，而本地开发使用的是个人分支 t/lindexi/doubi 而此时有另一个小伙伴更改了 A 文件的代码，在代码里面更改了 API 接口

而我在 B 文件开发，调用了原本 A 文件的原本的接口，此时一定我本地是能构建通过的，而我本地的这个分支在服务器上 CI 也是能通过的。但是在合并到 master 之后进行 CI CD 就会炸了

因此，如果发现服务器 CI CD 构建失败了，请尝试拉取服务器的构建分支，如 master 分支，尝试在本地构建

NuGet 源

基本上只会在项目刚配置的时候翻车，如果本地使用了私有的 NuGet 源，而服务器没有这个源，那么将拉包失败，构建不通过

因此判断是否此问题应该想看构建输出日志，如果是服务器报告说还原 NuGet 失败，找不到 xx 包。那么第一可能是 nuget.org 连接不上，第二可能就是本地使用了私有源没有配上服务器

第一个问题的解决方法一般只有等咯。但是在等的过程不妨看看是否是第二个可能，本地实际上使用了私有源

自己搭建一个 NuGet 服务器是十分简单的，我使用了 BaGet 搭建了一个私有源，我本地全局配置了这个私有源。但是服务器上使用 docker 构建，而 docker 每次都是全新的环境，除非做这个构建镜像的时候加上了配置，否则服务器上是没有全局配置的。因此服务器找不到放在私有源的 NuGet 包，服务器就拉不到包，也就构建失败了

这个问题解决方案很简单，就是项目级配置用到的私有源，配置方法请看 VisualStudio 给项目添加特殊的 Nuget 的链接

用 docker 做构建服务器的一个不足是没有了 NuGet 的本地缓存，每次都需要访问服务器，因此有一个内网的私有服务器还是能提升一些效率

WPF 新建用户控件提示 Error MC3000 首个 xaml 字符不合法

Thu, 03 Dec 2020 12:27:49 +0000

在 WPF 新建用户用户控件时，偶尔的 VS 版本会逗你，给你创建了一个编码不对或偷偷给你的文件第一个字符添加了一个不可见字符，此时将会构建不通过

在构建的时候提示下面代码

Error MC3000: 'Data at the root level is invalid. Line 1, position 1.' XML is not valid. (1, 1)

此时的原因要么是编码的原因，要么是偷偷写入了第一个看不见的字符

如果是编码原因可以尝试使用我的 VS 插件，点击 Encoding normalize tool 下载安装，之后就可以在插件这里转换某个文件的编码

第二个方案是在修复 Utf8 之后依然不让通过，可以尝试新建一个 xml 文件

然后复制 xaml 文件的内容到这个 xml 文件里面，复制 xaml 文件名，删除 xaml 文件，重命名 xml 文件为 xaml 文件名

注意 csproj 文件里面需要保持 xaml 文件的引用关系，如使用 Page 引用同时设置构建

如下代码放在 csproj 表示让所有 xaml 文件使用页面形式构建

    <Compile Update="**\*.xaml.cs">
      <DependentUpon>%(Filename)</DependentUpon>
    </Compile>
    <Page Include="**\*.xaml">
      <SubType>Designer</SubType>
      <Generator>MSBuild:Compile</Generator>
    </Page>

如需要特定某个文件可使用如下代码

    <Compile Update="Foo.xaml.cs">
      <DependentUpon>Foo.xaml</DependentUpon>
    </Compile>
    <Page Include="Foo.xaml">
      <SubType>Designer</SubType>
      <Generator>MSBuild:Compile</Generator>
    </Page>

Unity3D 判断点击命中物体对象和命中环境

Thu, 03 Dec 2020 12:27:49 +0000

我想要做到点击物体的时候显示一些内容，而点击环境或其他游戏物体的时候隐藏一些内容

本文的脚本都是附加到预置体 Prefab 里面

一个大的空对象包含很多小的物体，在大的空对象上面添加一个脚本，这个脚本核心就是通过 Update 方法里面拿到鼠标点击，判断当前是不是点击这个对象

如下代码放在 SolideCubeElement.cs 代码文件里面

    public bool IsClickedSelf { set; get; }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (IsClickedSelf)
            {
            	// 点击到物体
            }
            else
            {
                // 点击到环境
            }

            IsClickedSelf = false;
        }
    }

接下来在对应的能响应点击的物体上面添加如下脚本

    public GameObject mainElement;

    private void OnMouseDown()
    {
        var element = mainElement.GetComponent<SolideCubeElement>();
        element.IsClickedSelf = true;
    }

分别绑定脚本和给物体上面的脚本设置 mainElement 为这个大的空对象

在用户点击物体可以触发 OnMouseDown 方法，在这个方法里面设置 SolideCubeElement 的 IsClickedSelf 属性，刚好 OnMouseDown 会比 Update 方法先进入鼠标点击，此时就可以让空物体判断当前是不是点击到物体

unity中的获取点击对象_游戏_liuzhongchao123的博客-CSDN博客

【Unity 3D学习】获取鼠标点击所对应的GameObject_游戏_既然选择了远方，便只顾风雨兼程！-CSDN博客

Unity在游戏中鼠标点击选中GameObject物体并打印其名字_游戏_w8ed-CSDN博客

unity中使用SetActive()和gameobject实例化的陷坑总结_游戏_wdear0401的博客-CSDN博客

WPF dotnet core 的 Blend SDK Behaviors 库

Thu, 03 Dec 2020 12:27:49 +0000

之前版本是通过安装 Blend SDK 支持 Behaviors 库的，但是这个方法都是通过引用 dll 的方式，不够优雅。在升级到 dotnet core 3.0 的时候就需要使用 WPF 官方团队开源的 Microsoft.Xaml.Behaviors.Wpf 库代替

先通过 NuGet 安装 Microsoft.Xaml.Behaviors.Wpf 库

或者在 csproj 添加下面代码

      <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf">
          <Version>1.1.19</Version>
      </PackageReference>

将代码里面的引用 System.Windows.Interactivity 库的内容做替换

将 xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity" 替换为 xmlns:i="http://schemas.microsoft.com/xaml/behaviors" 就可以了，这样就能解决找不到 System.Windows.Interactivity 无法构建成功

c# - How to add System.Windows.Interactivity to project? - Stack Overflow

SublimeText 配置跳转回上个光标坐标

Thu, 03 Dec 2020 12:27:49 +0000

在 VisualStudio 可以通过 ctrl+- 的功能，跳转到上个光标所在的坐标。如在多个方法之间跳转，可以通过这个快捷键快速实现。在 SublimeText 可以在菜单的 Goto 里面找到 Jump Back 功能，这个功能就是对应 VisualStudio 的跳转回上个光标的功能，也就是向后定位功能

对应的 SublimeText 的快捷键是 alt+- 和 VS 不相同，可以在 SublimeText 的 Preferences 的 Key Bindings 里面添加下面代码修改快捷键

    { "keys": ["ctrl+-"], "command": "jump_back" },

这个快捷键是向后跳转，而向后跳转之后想要向前跳可以使用 alt+shift+- 快捷键，这对应 VS 的 ctrl+shift+- 快捷键，可以通过下面代码配置和 VS 相同

    { "keys": ["ctrl+shift+-"], "command": "jump_forward" },

VisualStudio 如何快速添加一个 Git Tag 推送

Thu, 03 Dec 2020 12:27:49 +0000

在 VisualStudio 的团队管理功能，提供了方便的添加 Tag 的方法，可以新建一个 Tag 添加 Tag 信息，同时推送某个特定的 Tag 到服务器。配合推 Tag 打包 NuGet 的方法，将可以让整套工具用起来特别爽，完全本地化打 Tag 推送就完成了 NuGet 服务器打包推送

进入团队管理界面，我用的英文版的，但是按钮在中文版也没有变化。我的 VisualStudio 是 2019 的

点击 Tags 进入标记界面

此时可以通过点击新建Tag按钮新建一个 Tag 给他版本号和信息，请看下图

点击创建按钮就可以完成了创建，上面代码只有 Tag 号是必须的，而信息是不必须的。当然有信息可以协助小伙伴更好了解这个 Tag 对应的功能

此时就可以看到刚才新建的 Tag 了，右击这个新建的 Tag 号就可以找到推送按钮，点击推送按钮就可以将 Tag 推送到服务器了

熟悉这个方法可以快速给代码添加一个 Tag 号

配合 dotnet 配合 Gitlab 做自动推 Tag 时打包 NuGet 包可以特别方便打 Tag 打包推送

为什么需要推送 Tag 才能打包？原因是为了解决回退到某个版本发现有一个坑，这个坑是因为某个依赖库的版本问题，此时我期望最小改动，我虽然能拿到这个库的代码，但是我很难知道我这个版本安装的 NuGet 库对应依赖库的哪个 commit 的代码

所以看到了我上面的坑，小伙伴大概也就能知道为什么我期望将 Tag 和 NuGet 包关联了

小伙伴本地打包第一次，发现翻车了，想要第二次打包，但是此时的版本号就重叠了，需要经过黑科技删除 NuGet 缓存重新构建，此时的效率特别低
小伙伴在这次 commit 写的代码是他认为发布的时候将会添加的公开方法，但是实际上最后发布的时候更改了公开方法，此时回滚到这个 commit 虽然能下载到 NuGet 库，但是发现 L 库的公开方法不匹配，构建失败

更多请看 VisualStudio 2019 新创建项目添加 git 仓库

WPF 为何不要重写默认 string 字符串的 DataTemplate 数据模版

Thu, 03 Dec 2020 12:27:49 +0000

在 WPF 中可以通过 DataTemplate 给任意的类型重写这个类型在界面显示的数据模版，我想要让小伙伴的界面都有相同的样式，此时我就尝试重写字符串的数据模版，但是我就踩到了一个坑

重写默认样式的时候需要小心，我更多是建议小伙伴写样式，然后通过 Style 获取静态资源，而不是重写默认样式。补充一下细节，什么是默认样式？在 WPF 中，如果没有给对应的资源一个 Key 的值，那么将会做到某个指定类型的默认样式

将重写默认样式替换为重写默认数据模版也是相同的

对比下面两句代码就知道什么是默认数据模版

<!-- 下面是默认数据模版，对所有的字符串类型生效 -->
<DataTemplate DataType="{x:Type system:String}"><Grid/></DataTemplate>

<!-- 下面是数据模版静态资源，需要通过 key 获取 -->
<DataTemplate x:Key="DataTemplate" DataType="{x:Type system:String}"><Grid/></DataTemplate>

为什么说不要重写默认的字符串类型的数据模版？因为存在以下的坑，尝试添加下面的代码，运行代码就能看到下图效果

        <StackPanel>
            <StackPanel.Resources>
                <ResourceDictionary>
                    <DataTemplate DataType="{x:Type system:String}">
                        <TextBlock Text="{Binding}" />
                    </DataTemplate>
                </ResourceDictionary>
            </StackPanel.Resources>
            <TextBlock Margin="10,10,10,10" FontWeight="Bold" Text="重写模版" />
            <Label>Normal Text</Label>
            <Label>Access _Text</Label>
            <Label ContentStringFormat="Formatted {0}">Text</Label>
            <Label ContentStringFormat="Formatted Access {0}">_Text</Label>
        </StackPanel>

我在代码中实际上是写了对比的两列，其中一列使用了默认数据模版，另一列没有，运行效果如下

上面代码通过 <DataTemplate DataType="{x:Type system:String}"> 的代码重写了默认的字符串样式，注意 system:String 在使用之前需要引用命名空间 xmlns:system="clr-namespace:System;assembly=mscorlib" 在 WPF 的资源定义里面，将会影响这个容器里面的所有元素。也就是这个容器里面的所有元素的默认的字符串的数据模版就是资源定义的内容，而这个定义会挖以下的坑

这个重写的数据模版将不会转换下划线的快捷键定义，在 WPF 中，在 Button 和 Label 等控件里面，如果在某个字符前面添加下划线，那么表示按下 alt 键的时候，对应的快捷键出发的元素，这是 Windows 的通用菜单快捷键定义。而重写的数据模版里面没有处理下划线转换快捷键，所以这个功能就没有了

在阅读 WPF 的开源的代码可以知道，在 WPF 中的 ContentPresenter.cs 使用了 AccessTextContentTemplate 和 StringContentTemplate 和 FormattingStringContentTemplate 等值用来处理不同的数据，重写数据模版将会干掉上面的功能

这也就是 ContentStringFormat 在重写字符串数据模版被干掉的原因

上面代码放在 github 欢迎小伙伴访问

win10 uwp 使用 OCR 光学字符识别

Thu, 03 Dec 2020 12:27:49 +0000

在 UWP 里面可以很方便通过 Windows.Media.Ocr.OcrEngine 识别图片的字符，其实老周有写过这一篇技术博客，今天有小伙伴在问如何实现，我还以为老周的博客过时了，于是重新复制老周的代码跑了一次，然后就通过了

在老周的【Win10 应用开发】OCR识别博客还是 UAP 的代码，此时 UWP 还没发布，不过在 UWP 发布之后也没有改这部分的 API 也就是可以直接复制代码运行

欢迎小伙伴新建一个 UWP 应用，在某个按钮的点击事件里面复制下面的代码

        private async void Button_OnClick(object sender, RoutedEventArgs e)
        {
            var picker = new Windows.Storage.Pickers.FileOpenPicker();
            picker.FileTypeFilter.Add(".png");
            // 选择文件
            var imgFile = await picker.PickSingleFileAsync();

            if(imgFile != null)
            {
                using (var inStream = await imgFile.OpenReadAsync())
                {
                    // 解码图片
                    var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(Windows.Graphics.Imaging.BitmapDecoder.PngDecoderId, inStream);

                    // 获取图像
                    var swbmp = await decoder.GetSoftwareBitmapAsync();
                    // 准备识别
                    Windows.Globalization.Language lang = new Windows.Globalization.Language("zh-CN");
                    // 判断是否支持简体中文识别
                    if (Windows.Media.Ocr.OcrEngine.IsLanguageSupported(lang))
                    {
                        var engine = Windows.Media.Ocr.OcrEngine.TryCreateFromLanguage(lang);
                        if (engine != null)
                        {
                            var result = await engine.RecognizeAsync(swbmp);
                            if (result != null)
                            {
                                var dialog = new Windows.UI.Popups.MessageDialog($"识别内容 {result.Text}");
                                await dialog.ShowAsync();
                            }
                        }
                    }
                    else
                    {
                        var dialog = new Windows.UI.Popups.MessageDialog("不支持简体中文的识别。");
                        await dialog.ShowAsync();
                    }
                }
            }
        }

上面代码和老周的博客有一点不同的是我添加了很多命名空间，这样大概复制上面代码就可以跑起来了

代码的主要逻辑是 var engine = Windows.Media.Ocr.OcrEngine.TryCreateFromLanguage(lang); 创建识别引擎，然后通过 var result = await engine.RecognizeAsync(swbmp); 解析文本

更多细节还请看老周的【Win10 应用开发】OCR识别 - 东邪独孤 - 博客园

本文代码放在 github 其实代码是一个新建的项目，也就加上一个按钮，在按钮里面添加上面代码

win10 uwp 如何修改 Flyout 的宽度或高度

Thu, 03 Dec 2020 12:27:49 +0000

本文告诉大家如何修改 Flyout 的尺寸

在堆栈有小伙伴问如何修改 Flyout 的宽度，他看到宽度会使用第一个元素的大小而不是最大的

<AppBarButton>
    <AppBarButton.Flyout>
        <Flyout>
            <ListView>
                <x:String>Short</x:String>
                <x:String>Very very very long</x:String>
                <x:String>Short</x:String>
                <x:String>Short</x:String>
                <x:String>Short</x:String>
                <x:String>Short</x:String>
                <x:String>Short</x:String>
                <x:String>Short</x:String>
            </ListView>
        </Flyout>
    </AppBarButton.Flyout>
</AppBarButton>

大概他的代码运行的界面如下

可以通过两个方法修改 Flyout 的宽度或高度

第一个方法是通过修改 Flyout 的里元素宽度和高度的方式，如下面代码

    <AppBarButton Margin="10,10,10,10">
        <AppBarButton.Flyout>
            <Flyout>
                <ListView Width="500">
                    <x:String>Short</x:String>
                    <x:String>Very very very long</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                </ListView>
            </Flyout>
        </AppBarButton.Flyout>
    </AppBarButton>

上面代码就是将 ListView 设置一个宽度，这样默认就会使用这个元素的宽度作为 Flyout 的宽度，我将代码放在 github 欢迎小伙伴访问

如果此时的窗口的大小变小了，那么 Flyout 也会自动修改自己的宽度和高度，可以使用FlyoutPresenterStyle属性修改

    <AppBarButton Margin="10,10,10,10">
        <AppBarButton.Flyout>
            <Flyout>
                <Flyout.FlyoutPresenterStyle>
                    <Style TargetType="FlyoutPresenter">
                        <Setter Property="MinWidth" Value="500"></Setter>
                    </Style>
                </Flyout.FlyoutPresenterStyle>
                <ListView >
                    <x:String>Short</x:String>
                    <x:String>Very very very long</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                    <x:String>Short</x:String>
                </ListView>
            </Flyout>
        </AppBarButton.Flyout>
    </AppBarButton>

上面代码通过 MinWidth 设置了最小需要的宽度，如果想要设置高度相信小伙伴也知道如何修改

上面代码有一个细节是需要设置 TargetType="FlyoutPresenter" 才可以

上面代码也放在 github 欢迎小伙伴访问

如果是后台代码写的，也可以设置 FlyoutPresenter 的值

private void Flyout_Opened(object sender, object e)
{         
    Flyout f = sender as Flyout;
    Style s = new Windows.UI.Xaml.Style { TargetType = typeof(FlyoutPresenter) };
    s.Setters.Add(new Setter(MinHeightProperty, "200"));        
    s.Setters.Add(new Setter(MinWidthProperty, "200"));
    f.FlyoutPresenterStyle = s;
}

我推荐使用 Flyout 这个控件解决了很多 Popup 的坑

Unity3D 用对象创建对象

Thu, 03 Dec 2020 12:27:49 +0000

在 Unity3d 中会用到从一个游戏对象复制出一个新的游戏物体的方式，如制作射击游戏的子弹等。在 Unity3d 中可以使用 GameObject.Instantiate 的方式从一个 GameObject 里面创建一个和这个 GameObject 一样的对象

一般此时游戏对象都是使用模板对象，在 Unity3d 里面制作一个模板是十分简单的，只需要在 Hierarchy 里面的物体拖动放到 Assets 文件夹里面就可以了

拖放进去的模板对象推荐给他一个命名，这样才方便查找

先点击 Hierarchy 然后点击菜单的 GameObject 的创建，创建一个立方体。接下来将这个立方体拖动放到 Assets 文件夹，删除 Hierarchy 里面的立方体。等等，是不是有更加简洁的步骤？没错，在 Assets 文件夹里面右击也是可以创建的，只是在 Hierarchy 创建的时候可以方便看到对象在游戏中显示的好看还是不好看

新建一个 C# 代码，可以命名为 Create 在这个代码里面将会判断如果用户点击了按键，将会创建一个 Cube 立方体

在 Unity3d 中判断用户按键的方式请看 Unity3d 连续按键处理和单次按键处理

从 VisualStudio 打开代码，或者右击刚才创建出来的代码文件点击 Open 都可以

在 C# 代码里面添加一个公开的字段，这个字段叫 Cube 用来在 Unity3d 界面给他赋值

    public GameObject Cube;

创建出来的代码还需要放在某个 GameObject 里面才能运行，本文将这个代码放在相机里面，放在相机可以通过拖动代码文件，放在相机对象上面，此时可以在相机里面看到如下图

可以在相机的 Component 看到有脚本代码，所以反过来点击 Add Component 添加代码也是可以的

在这个代码里面可以看到刚才定义的字段 Cube 在界面显示，将刚才放在 Assets 的 Cube 对象拖动放在这个字段上去，这样就在 Unity 上绑定了游戏对象了

也就是在脚本执行的时候，这个 Cube 字段就会被框架赋值，给的值就是在 Unity 界面拖动过去的对象

接下来就是编辑 Update 的方法了，在判断到用户点击了鼠标，就根据字段创建一个新的游戏对象，这里创建的游戏对象默认都会自动添加到游戏画面中

    void Update()
    {
        if (Input.GetButtonDown("Fire1"))
        {
            // 鼠标左键
            var cube = GameObject.Instantiate(Cube);
        }
    }

此时就完成了创建，保存代码，在 Unity3d 里面点击开始游戏，然后点击一下鼠标。此时可能还看不到这个 cube 对象，可能的原因就是这个 Cube 不在相机范围内。可以通过点击一下暂停按钮看看是不是 Cube 放在了相机范围外

如果想要设置这个 Cube 在相机可见范围里面，简单做法是放在相机前面，我的相机是面向 z 轴的，如下图我的相机设置如下，那么如何设置创建出来的物体的坐标在我的相机前面

可以通过物体的 transform 属性进行移动物体，可以先移动到相机所在的地方，然后再次移动到相机前面

        if (Input.GetButtonDown("Fire1"))
        {
            // 鼠标左键
            var cube = GameObject.Instantiate(Cube);
            cube.transform.Translate(transform.position);
            cube.transform.Translate(0, 0, 10);
        }

这样就完成了代码啦

本文代码放在github欢迎小伙伴访问

WPF 和 ASP.NET Core 通过 elastic APM 上报信息

Thu, 03 Dec 2020 12:27:49 +0000

我的运维小伙伴搭建了 elastic 平台，我有一个 ASP.NET Core 后台和一个 WPF 客户端，我想要让这两个应用的数据都上报，可以使用 Elastic.Apm 库上报

先使用 ASP.NET Core 为例子，本文不包含任何 elastic 服务器搭建

只需要安装一个 NuGet 库加上10行代码就能完成

通过 NuGet 安装 Elastic.Apm.NetCoreAll 库

打开 appsettings.json 文件，添加以下配置

{
  "Logging": 
  {
    "LogLevel": 
    {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information",
      "Elastic.Apm": "Debug"
    }
  },
  "AllowedHosts": "*",

  "ElasticApm":
   {
      "ServerUrls":  "http://es-apm.lindexi.com",
      "SecretToken":  "",
      "ServiceName": "lindexishidoubi",
      "TransactionSampleRate": 1.0
    }
}

其中包括在 Logging 里面的 "Elastic.Apm": "Debug" 和 "ElasticApm" 的值，一般的 ServerUrls 等值是不需要修改的，多个应用使用相同的值

需要自定义的值有两个，第一个是 “Elastic.Apm”: “Debug” 请根据自己的需求填写，可以选的值是 Critical, Error, Warning, Info, Debug, Trace第二个是 “ServiceName”: “lindexishidoubi”, 请替换为你的应用名

接下来打开 Startup.cs 代码文件，添加命名空间

using Elastic.Apm.NetCoreAll;

然后在 Configure 添加下面代码

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
          app.UseAllElasticApm(Configuration);
          // 忽略代码
}

上报的数据将会自动包含链路数据以及接口耗时

如果有自定义的信息，如主机信息，自定义信息上报可以通过 GlobalLabels 上报，所有加在这个列表里面的值每次都会上传

如果是 WPF 接入，基本上用来上报异常信息，可以通过下面代码上报

var transaction = Elastic.Apm.Agent
        .Tracer.StartTransaction("lindexi", ApiConstants.TypeRequest);
try
{
    
}
catch (Exception e)
{
    transaction.CaptureException(e);
    throw;
}
finally
{
    transaction.End();
}

在 WPF 使用需要先安装 Elastic.Apm 库

WPF 打包为 UWP 应用构建失败 MSB3270 不匹配 AMD64 架构

Thu, 03 Dec 2020 12:27:49 +0000

在使用 dotnet core 3.1 的 WPF 打包为 UWP 应用的时候，如果没有设置 PublishProfiles 那么将会在构建 x64 提示所生成项目的处理器架构“AMD64”与引用的处理器架构“x86”不匹配

在我使用下面命令打包的时候，如果我将 Platform 设置为 x86 那么什么问题都没有，如果我设置为 x64 就会发现构建失败，请看 https://github.com/dotnet-campus/TranslationTool/runs/504702520?check_suite_focus=true

msbuild TranslationTool.sln /p:Platform=x64 /p:Configuration=Debug /p:UapAppxPackageBuildMode=StoreOnly /p:AppxBundle=Never /p:PackageCertificateKeyFile=TranslationTool.Package_TemporaryKey.pfx /p:PackageCertificatePassword="123"

可以看到的英文提示如下

(ResolveAssemblyReferences target) ->   
C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin\Microsoft.Common.CurrentVersion.targets(2106,5): error MSB3270: There was a mismatch between the processor architecture of the project being built "AMD64" and the processor architecture of the reference "D:\a\TranslationTool\TranslationTool\Code\TranslationTool.WPF\bin\x86\Debug\netcoreapp3.1\win-x86\TranslationTool.WPF.dll", "x86". This mismatch may cause runtime failures. Please consider changing the targeted processor architecture of your project through the Configuration Manager so as to align the processor architectures between your project and references, or take a dependency on references with a processor architecture that matches the targeted processor architecture of your project. [D:\a\TranslationTool\TranslationTool\Code\TranslationTool.Package\TranslationTool.Package.wapproj]

中文提示如下

(ResolveAssemblyReferences 目标) ->
  C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin\Microsoft.Common.CurrentVersion.ta
rgets(2106,5): error MSB3270: 所生成项目的处理器架构“AMD64”与引用“D:\lindexi\TranslationTool\Code\TranslationTool.WPF\bin
\x86\Debug\netcoreapp3.1\win-x86\TranslationTool.WPF.dll”的处理器架构“x86”不匹配。这种不匹配可能会导致运行时失败。请 考虑通过配置管理器更改您的项目的目标处理器架构，以使您的项目
与引用间的处理器架构保持一致，或者为引用关联一个与您的项目的目标处理器架构相符的处理器架构。

解决方法是添加 PublishProfiles 文件，请看 dotnet-campus/TranslationTool@1650f7a

原因是在使用 .NET Core 3.1 的桌面应用需要修改使用独立发布，也需要指定不同的文件夹

除了在 WPF 项目添加 PublishProfiles 文件，还需要在打包项目添加代码

    <ProjectReference Include="..\lindexi\林德熙博客.csproj">
      <SkipGetTargetFrameworkProperties>True</SkipGetTargetFrameworkProperties>
      <TrustLevel>Full</TrustLevel>
      <PublishProfile Condition="'$(Configuration)|$(Platform)'=='Release|x86'">Properties\PublishProfiles\SelfContainedWin86.pubxml</PublishProfile>
      <PublishProfile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Properties\PublishProfiles\SelfContainedWin64.pubxml</PublishProfile>
      <PublishProfile Condition="'$(Configuration)|$(Platform)'=='Debug|x86'">Properties\PublishProfiles\SelfContainedWin86Debug.pubxml</PublishProfile>
      <PublishProfile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Properties\PublishProfiles\SelfContainedWin64Debug.pubxml</PublishProfile>
    </ProjectReference>

如果使用 msbuild 命令行打包桌面应用为 UWP 应用请看

使用 msbuild 命令行编译 UWP 程序

如何使用 Github 的自动构建请看

Continuous integration and deployment for desktop apps with GitHub Actions

microsoft/github-actions-for-desktop-apps: This repo contains a sample WPF application to demonstrate how to create CI/CD pipelines using GitHub Actions.

如何在 VS 打包请看

UWP 打包 win32 应用添加防火墙例外

本文链接的是 Github Action 是在 Github 上自动构建的服务，可以用来持续集成，可以用来做 NuGet 包

dotnet 部署 github 的 Action 进行持续集成

WPF 已知问题全屏透明窗口弹出子窗口会闪烁

Thu, 03 Dec 2020 12:27:49 +0000

在 WPF 中通过设置 WindowStyle 为 None 以及 WindowState 为 Maximized 进入全屏，同时设置 AllowsTransparency 支持透明，此时弹出一个设置 WindowStyle 是 None 的子窗口，用 VisualStudio 2019 运行将会看到子窗口先显示出来，然后回到主窗口下面，然后再显示到主窗口上面

其实此问题我没有复现

此问题步骤十分简单，但是有要求是在 VisualStudio 2019 附加的基础上，如果单独运行预计没有此问题。此问题在 .NET Framework 4.5-4.8 以及 .NET Core 3.1 都复现

步骤：

给 MainWindows 如下设置

WindowStyle="None" AllowsTransparency="True"
        WindowState="Maximized" 

给主窗口添加一个按钮

        <Button Content="Show sub window" HorizontalAlignment="Center" VerticalAlignment="Center" Click="Button_OnClick"/>

点击按钮显示一个子窗口

        private void Button_OnClick(object sender, RoutedEventArgs e)
        {
            var window = new Window()
            {
            };

            window.Show();
        }

通过 VisualStudio 2019 运行项目，可以看到在点击按钮的时候，先显示了子窗口然后子窗口到主窗口下方，等一下又回到主窗口上方。也就是子窗口显示一下然后不显示，可以看到出现闪烁

注意，此时如果没有在 VisualStudio 2019 附加调试，那么不会看到子窗口闪烁

解决方法有两个

第一个方法是去掉主窗口的 AllowsTransparency 属性

第二个方法是设置子窗口的 Owner 为主窗口

        private void Button_OnClick(object sender, RoutedEventArgs e)
        {
            var window = new Window()
            {
                Owner = this
            };

            window.Show();
        }

本文代码放在 github 欢迎小伙伴访问

此问题已经报告微软，请看 The Child window displayed behind the main window, and then the child window is displayed again in front of the main window · Issue #2761 · dotnet/wpf

win10 uwp 如何给 DropDownButton 一个很小的宽度

Thu, 03 Dec 2020 12:27:49 +0000

在 UWP 的 Microsoft.UI.Xaml 提供了一个带下箭头的按钮，这就是 DropDownButton 这个按钮继承 Button 按钮，基本表现相同，但是如果给这个按钮一个很小的宽度，将会看不到下箭头图片

原因是如果最小宽度那么下箭头将没有足够空间显示，虽然左边依然有空白地方，但是空白地方有最小宽度要求

解决方法是通过 Padding 属性，让整个按钮的内容移动，让空白地方移动到按钮外，让下箭头移动到可以显示的地方

<DropDownButton Margin="10,10,10,10" Width="17" Height="30" Padding="-15,0,0,0"></DropDownButton>

上面代码核心就是 Padding="-15,0,0,0" 通过 Padding 可以设置按钮的左上右下各个内容边距的值

现在看起来的效果如下图

更多关于 DropDownButton 请看 DropDownButton Class - Windows UWP applications

这是在堆栈网小伙伴问的问题，请看 c# - Change the width of DropDownButton in UWP - Stack Overflow

本文源代码放在github 欢迎小伙伴访问

WPF dotnet 使用本机映像 native 优化 dotnet framework 二进制文件

Thu, 03 Dec 2020 12:27:49 +0000

在 2017 我在社区问了一个问题，如何让 .NET Framework 的 WPF 等程序使用 .NET Native 构建以提升速度。在 2019.06 的时候，强大的微软提供了一个好用的库，支持将 .NET Framework 的桌面应用构建时添加 native images 本机映像支持

咱可以通过预编译咱的二进制文件来提升 .NET Framework 应用的启动时间。推荐使用技术用来在大型的应用的打包和分发上或上架到微软应用商店。微软官方测试表示这个技术大概能提升 20% 的性能。这项技术用到了 ReadyToRun 技术，详细请看 coreclr/readytorun-overview.md at master · dotnet/coreclr

微软将这个本机映像编译器作为一个 NuGet 库发布，可以从 https://www.nuget.org/packages/Microsoft.DotNet.Framework.NativeImageCompiler 下载。这个库适用于 .NET Framework 大于等于 4.6.2 的应用。这个包的作用是在构建时添加一个步骤，这个步骤的作用是构建本机映像二进制文件。这个优化将会在应用在安装了 .NET Framework 4.7.2 和以上的设备运行时被使用，而之前的版本的设备将继续使用 MSIL 代码执行，换句话说，想要使用这个特性优化的，只有运行在安装了 .NET Framework 4.7.2 和以上的设备，对之前的设备依然运行优化之前的代码

在 Windows 10 的 Windows 10 April 2018 （1803 10.0.17134）更新包含了 .NET Framework 4.7.2 的预安装。咱也可以手动在 Windows 7 以上的设备或 Windows Server 2008 R2 以上的设备安装 .NET framework 4.7.2 版本

如果想要用本机映像优化技术优化打包的项目，将使用 UWP 打包 Win32 应用，请记得选择 UWP 的最低版本是基于 Windows Anniversary Update （1607 10.0.14393）版本

如何创建本机映像

需要对咱的项目进行以下配置：

设置目标的框架平台是 4.6.2 或以上
配置目标平台是 x86 或 x64 换句话说是不要设置为 AnyCpu 的
添加一个神奇的 NuGet 库
使用 Release 构建

设置目标的框架平台是 4.6.2 或以上

在设置 .NET Framework 到 4.6.2 或以上之前，需要先安装 .NET Framework 4.6.2 开发者工具包。这个工具包可以在 VisualStudio 安装器里面作为一个工作负载进行安装:

或者从 https://dotnet.microsoft.com/download/visual-studio-sdks 下载安装

配置目标平台是 x86 或 x64 平台

本机映像编译器需要根据给定的平台优化代码。为了使用本机映像编译器就需要配置自己的项目特别为 x86 或 x64 构建

如果一个解决方案里面包含了多个项目，只需要设置入口项目，也就是启动项目作为 x86 或 x64 进行构建。其他的被引用的项目将会根据主项目的配置进行优化，即使这些项目设置是 AnyCPU 平台

设置项目方法如下：

右击解决方案，选择配置方案管理器
下拉平台里面的入口项目的配置，点击新建按钮
在新建项目平台弹出界面里面，新建 x86 和 x64 平台，请确保勾选了从 AnyCPU 复制选项

中文版界面请看下图

注意，设置为 AnyCPU 不支持使用本机映像编译器构建

添加 NuGet 包

这个本机映像编译器是通过 NuGet 包分发，可以通过在 WPF 或 WinForms 等项目添加 Microsoft.DotNet.Framework.NativeImageCompiler 库的方式让项目使用本机映像编译器优化。可以在 PowerShell 中输入下面代码安装

PM> Install-Package Microsoft.DotNet.Framework.NativeImageCompiler -Version 1.0.0

创建一个 Release 构建

在上一步安装的 NuGet 库将作为一个附加的工具在构建项目时运行。这个工具将会在相同的输出二进制文件里面添加二进制代码。为了确认这个工具已经优化了咱的二进制文件，可以通过在构建时的输出寻找下面代码

Native image obj\x86\Release\\R2R\DesktopApp1.exe generated successfully.

默认在 VisualStudio 输出中是看不到上面代码，需要打开开发者命令行工具，也就是告诉 Cortana 打开开发者命令行工具，在命令行工具里面输入下面代码构建

msbuild /p:configuration="release"

此时将可以在输出看到 RunNgenR2R 任务

RunNgenR2R:
  正在创建目录“obj\Release\net462\\R2R”。
  C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\build\net462\..
  \..\tools\NgenR2R.exe "@obj\Release\net462\\R2R\WenabemchicargeQunallburhawwi.rsp"
  Microsoft (R) CLR Native Image Generator - Version 4.8.3761.0
  Copyright (c) Microsoft Corporation.  All rights reserved.

  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\mscorlib.dll
  Loading C:\lindexi\WenabemchicargeQunallburhawwi\WenabemchicargeQunallburhawwi\obj\Release\net462\
  WenabemchicargeQunallburhawwi.exe
  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\PresentationFramework.dll
  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\WindowsBase.dll
  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\System.Xaml.dll
  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\PresentationCore.dll
  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\System.dll
  Loading C:\Users\lindexi\.nuget\packages\runtime.win10-x86.microsoft.dotnet.framework.nativeimagecompiler\1.0.0\tools\r
  ef\UIAutomationTypes.dll
  Native image obj\Release\net462\\R2R\WenabemchicargeQunallburhawwi.exe generated successfully.

本文代码放在 github 欢迎小伙伴访问

详细请看官方文档

FAQ

Q: 如果这个新构建出来的二进制文件在没有安装 .NET Framework 4.7.2 或以上的设备上运行会如何？

A: 这个优化的二进制文件的优化只有在安装 .NET Framework 4.7.2 或以上的设备才能运行优化版，而对于没有安装 .NET Framework 4.7.2 或以上的设备会执行 MSIL 代码版，也就是此优化只对 4.7.2 或以上的设备有效

Q: 使用中遇到问题或反馈可以在哪里反馈？

A: 可以点击 VisualStudio 的右上角的反馈按钮反馈，详细请看如何报告 Visual Studio 的问题

Q: 这个优化的本机映像对原有的二进制文件影响是什么？

A: 这个优化的二进制文件将包含托管代码和本机代码，会让最终输出的文件更大

Q: 我是否可以在项目中使用这个技术？

A: 这个版本包含了 Go Live license 也就是咱现在就能用

什么是 Go Live license 请看 Roslyn ships v1.0-rc2 with “Go-Live” license

本文开始说的我问的问题是 How to compile WPF with .net Native - Stack Overflow

更多请看

UWP 上架失败因为没有添加隐私策略

Thu, 03 Dec 2020 12:27:49 +0000

在使用 UWP 上架之前需要经过微软的审核，在美国很看重个人隐私，因此需要在两个地方都填写上隐私策略。第一个是应用商店里面，第二个是应用程序里面

如果是个人开发者，我的推荐是在 github 或 gitee 创建一个叫隐私策略的文件，复制这个链接填写在应用商店管理的属性上，请看下图

如何写隐私策略请看 win10 uwp 隐私声明注意修改软件名

然后打开代码，在代码里面添加一个叫 PrivacyPolicyURL 的静态属性，将隐私策略放在这个属性，然后写一个文本超链接用于打开

public static class PrivacyPolicy
{
	public static string PrivacyPolicyURL { get; } = "https://github.com/lindexi/UWP/blob/master/uwp/src/%E9%9A%90%E7%A7%81%E7%AD%96%E7%95%A5/Privacy%20Policy.md";
}

在界面添加超链接

                <TextBlock>
                    <Hyperlink NavigateUri="https://github.com/lindexi/UWP/blob/master/uwp/src/%E9%9A%90%E7%A7%81%E7%AD%96%E7%95%A5/Privacy%20Policy.md">隐私策略</Hyperlink>
                </TextBlock>

修改之后请重新上传新的包

如果此时发现无法上传新的包，而在认证里面有附加了联系的邮件地址，如文章最后附加的微软给我的信息，可以看到微软告诉我说联系 reportapp@microsoft.com 邮件

可以通过谷歌翻译的方式告诉微软的大佬说我的应用已经更新了，里面填写了隐私声明了。小窍门，即使咱之前已经写过了，也是要给他一点面子，还是说咱改了软件了，感谢你的提示。另外在发邮件的时候记得附加自己应用的 Id 哦，如可以这样写

主题: I update my application 9NBLGGH562R2 and please review it

正文:

Hi,
 
My applicaion(App Id: 9NHNXT3Q2X7F) was publish fail and I have changed my app now, and please review it.

Thank you.

请将 App id 替换为你的应用 Id 如何找到自己的应用 Id 请看下面

可以找到应用号

下面是微软发给我的信息

Please take the following action

We reviewed your submission and identified some changes that are needed before we can publish or update the app. Please make these changes and resubmit your app. For more information, contact reportapp@microsoft.com Please include your app ID so we can act quickly.

App Policies: 10.5.1 Personal Information

Notes To Developer

Because the app accesses personal information, a working link to a privacy policy must be provided.
Location where privacy policy was missing: 
Metadata: OK 
In-product: Needs attention
 
For metadata include the privacy policy URL during app submission under the Properties section in the “Privacy Policy URL” field.
 
For in-product include the privacy policy URL under the settings section.
 
For additional assistance with updating the privacy policy URL, please contact Developer Support via Dev Center or here: http://aka.ms/storesupport
 
Personal information the app accesses includes:
Photos (Picture gallery)
Documents (device folders and files)
Please Note

    Your current certification results might differ from earlier submissions because Microsoft Store policy requirements can change over time. When policies change, we might re-test according to the new requirements regardless of the submission type. Please always rely on your most recent certification results.

为什么我的图床应用需要写隐私策略，因为我访问了 Photos 文件夹和 Documents 文件夹

UWP 打包 win32 应用添加防火墙例外

Thu, 03 Dec 2020 12:27:49 +0000

我想要将一个 WPF 应用打包为 UWP 应用，然后用我自己的商店发布，在做 UWP 安装包的小伙伴会问如何和 nsis 一样添加防火墙例外

应用没有在安装添加例外，会在应用开放服务监听端口提示 Windows Defender 防火墙已组织所有共用网络和专用网络上的 xx 的某些功能，如果用户没有点击允许访问，那么一些功能访问可能会因为防火墙不让用，用 nsis 添加防火墙例外建议是添加一个应用可以通过

我的 WPF 程序是 WPF 程序加上 asp dotnet core 程序，我这是将 asp dotnet core 作为客户端使用，主要作用是 ipc 也就是进程通讯，用这个方法没有什么好处，下次有小伙伴要用，我推荐 dotnet-campus/dotnetCampus.IPC.WCF 一个基于WCF适用于C#项目进行IPC通信的库

在我的例子里，我用一个纯 asp dotnet core 代替，请看 github 的 Main\NarhedeachawhearWeargijawgowe 项目，这个项目是这样创建的。先用 dotnet new webapi -o NarhedeachawhearWeargijawgowe 创建空白项目，然后打开 Program.cs 文件，添加下面代码

webBuilder.UseUrls("http://0.0.0.0:12307");

这样就可以让这个应用在电脑上开启防火墙会提示用户是否允许让这个应用访问

我推荐用 UWP 打包的 win32 程序都在另一个启动器项目里面运行，这样就能做到我不需要改动原有的 win32 项目的代码，我可以给任意第一个win32应用打包上架到应用商店

方法是我创建一个 net461 的控制台项目，创建方法是通过 dotnet new console -o DalljalfonafearBairyekeregu 创建一个空白的控制台项目，然后打开 csproj 文件，更改下面代码

<Project Sdk="Microsoft.NET.Sdk">


    <PropertyGroup>
        <OutputType>WinExe</OutputType>
        <TargetFramework>net461</TargetFramework>
      
    </PropertyGroup>

    <ItemGroup>
        <None Include="..\Main\NarhedeachawhearWeargijawgowe\bin\Debug\netcoreapp3.1\**\**">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
        </None>
    </ItemGroup>


</Project>

上面代码将 OutputType 修改为 WinExe 的作用是让这个控制台项目不会显示黑框，而 net461 的版本是为了在打包项目引用

用 net461 而不是 47 的原因是打包项目现在用的是 .NET Core 5 不能引用 47 而用 .NET Core 需要设置独立部署这样打包的应用很大

上面代码的 ItemGroup 的内容就是引用另一个应用的所有文件夹，这里的 CopyToOutputDirectory 设置将所有文件输出，这样就能在打包时输出应用

打开 DalljalfonafearBairyekeregu 也就是启动器项目的 Program.cs 文件，给这个文件添加下面代码

        static void Main(string[] args)
        {
            var file = Path.Combine(Assembly.GetExecutingAssembly().Location, @"..\NarhedeachawhearWeargijawgowe.exe");
            Process.Start(file);
        }

这样就能调用实际的应用

关于启动器代码请看 github 的 DalljalfonafearBairyekeregu 文件

这个项目的细节是 WinExe 和 net461 的设置，还有 Main 里面记得调用原先的应用

创建打包项目 JadallhearfairBarwalbegear 这个项目需要右击应用程序，添加启动器的引用

如果是一个不需要添加防火墙例外的应用，这样做就完成了

需要添加防火墙例外的需要右击 Package.appxmanifest 查看代码，添加下面代码

    <Extensions>
        <desktop2:Extension Category="windows.firewallRules">
            <desktop2:FirewallRules Executable="DalljalfonafearBairyekeregu\NarhedeachawhearWeargijawgowe.exe">
                <desktop2:Rule Direction="in" IPProtocol="TCP" Profile="all"/>
                <desktop2:Rule Direction="in" IPProtocol="UDP"
                               Profile="all"/>
                <desktop2:Rule Direction="out"
                               IPProtocol="TCP"
                               Profile="all"/>
                <desktop2:Rule Direction="out"
                               IPProtocol="UDP"
                               Profile="all"/>
            </desktop2:FirewallRules>
        </desktop2:Extension>
    </Extensions>

上面代码需要添加命名空间

  xmlns:desktop2="http://schemas.microsoft.com/appx/manifest/desktop/windows10/2"

详细代码请看 github 的 JadallhearfairBarwalbegear\Package.appxmanifest 文件

上面代码的细节是需要放在 Extensions 里面，而 Executable 的路径是放在启动器文件夹里面，如果输入的文件找不到在点击发布提示没有文件

添加防火墙规则建议添加 tcp 和 udp 和出站入站请看上面代码，通过 Profile 可以设置文件例外可以访问端口

用上面方法可以给win32应用，不管这个应用是不是咱的，打包为 UWP 应用

打包为 UWP 应用可以用自己做的应用商店发布，自动更新

如何自己做一个 UWP 应用商店，请看加强版在国内分发 UWP 应用正确方式通过win32安装UWP应用

如果你看代码不知道如何打包，我推荐你从github下载我的代码，用 VisualStudio 2019 打开，先使用 dotnet build 构建 Main\NarhedeachawhearWeargijawgowe 代码

然后双击 Package.appxmanifest 点击打包，创建一个你自己的证书，然后右击 JadallhearfairBarwalbegear 项目发布，试试发布后的项目。如果成功那么再将这个项目修改为你需要的项目

从法律上，更改非自己的应用然后发布是不合法的，但是在中国一堆盗版软件，这个可以忽略，等你的应用商店做起来之后再找对应的公司讨论

Unity3d 修改编辑界面控制图标大小修改相机图标显示大小

Thu, 03 Dec 2020 12:27:49 +0000

在 Unity3d 会显示一些控制图标，如相机图标和光照图标。而在编辑界面我发现这些图标太大了，影响我编辑，可以通过界面控制修改图标显示大小

在用户端玩游戏的小伙伴是看不到编辑端的控制图标的，但是在开发游戏我会发现图标太大了挡住界面或图标太小看不到，此时可以通过界面的 Gizmos 点击设置

点击之后修改 3d 图标大小就可以修改 Unity3d 相机图标显示大小

这个控制让我找了半天，于是水了一篇博客

而 Gizmos 有什么用？请看 unity中辅助类Gizmos说明_天行九歌-CSDN博客

Unity3d 连续按键处理和单次按键处理

Thu, 03 Dec 2020 12:27:49 +0000

某个按键按下不放叫连续按键，而仅在按下的首次处理叫单次按键处理。用途是在游戏中控制移动，例子是可以将用户点击鼠标左键时向前走一步，而点击鼠标右键时，只要按住不放就连续后退

在 unity3d 中，通过 Input 静态类可以拿到用户的输入，而按键的输入统一可以作为某个功能的输入，如鼠标的左键对应的是 “Fire1” 而鼠标的右键对应的是 “Fire2” 而鼠标的滚轮用的是 Fire3 使用方法如下

        if (Input.GetButtonDown("Fire1"))
        {
            // 鼠标左键
        }
        else if (Input.GetButton("Fire2"))
        {
            // 鼠标右键
        }

另一个方法是使用 Input.GetMouseButtonDown 传入数值的方法，如传入 0 就是鼠标左键，传入 1 就是鼠标右键

        if (Input.GetMouseButtonDown(0))
        {
            // 鼠标左键
        }
        else if(Input.GetMouseButton(1))
        {
            // 鼠标右键
        }

我推荐使用 Fire 的方法获取

从上面的代码小伙伴可以看到我获取鼠标左键和获取右键用的方法不相同，在 Unity3d 里面通过了以下方法

GetButton 如果传入的虚拟按钮被按下，那么返回 true 值
GetButtonDown 在虚拟按钮被按下的一帧，返回 true 值

不同就在于 GetButtonDown 只有在虚拟按钮被按下的一帧，返回 true 值，而之后就没有返回 true 值了，也就是获取到是按下一次。而 GetButton 只要按钮被按下就返回 true 可以用来做连续点击

在脚本的 Update 方法里面方式使用 GetButtonDown 作为相机向前移动，而 GetButton 作为相机向后移动，此时可以做到鼠标左键点击向前走一步，安装鼠标左键没有反应，而点击鼠标右键时，只要按住不放就连续后退

创建一个简单的游戏用来说明一下连续按键控制和单次按键控制的不同，接下来的部分是给入门的小伙伴准备的

首先创建简单的界面，如我随意搭的界面

搭建界面的方法就是右击创建 3d object 如下面图片

接着看界面你也就知道如何搭界面出来了，当然如果想要做游戏开发，很多时候都需要美工或在网上找一些素材，很少有自己画的

接下来右击创建一个 C# 脚本

我这个布局是 Tall 布局，我比较喜欢这个布局，在 Unity3d 的右上角点击 Layout 然后选择 Tall 就可以

右击创建的 C# 脚本，用 VisualStudio 编辑，也就是点击 Open C# project 按钮

在 VisualStudio 添加下面代码

    // Start is called before the first frame update
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {
        var z = 0f;

        if (Input.GetButtonDown("Fire1"))
        {
            z = 1f;
        }
        else if (Input.GetButton("Fire2"))
        {
            z = -0.1f;
        }

        transform.Translate(new Vector3(0, 0, z) * 0.5f);
    }

在 Unity3d 控制物体或相机移动的方法是创建一个 C# 脚本在这个 C# 脚本里面通过 transform 字段的方法移动。在 Unity3d 里面相机也是普通的物体，移动相机和移动普通物体方法相同。如上面代码就定义了鼠标点击移动物体，现在的脚本还没有绑定到某个物体上，也就是这个脚本的作用就是用来移动绑定的物体

现在将这个脚本拖放到相机上面，或者点击相机，点击 Inspector 的 Add Component 按钮，搜寻刚才创建的脚本名。这样就完成了脚本和物体的绑定，尝试点击运行游戏，此时可以做到点击鼠标左键时向前走一步，而点击鼠标右键时，只要按住不放就连续后退

本文代码放在github欢迎小伙伴访问

Unity输入系统 - 知乎

unity中Input.GetAxis()用法_天行九歌-CSDN博客

VisualStudio 各版本 msbuild 路径

Thu, 03 Dec 2020 12:27:49 +0000

本文收藏 msbuild 所在路径

通过 vswhere.exe 工具找到路径，可以解决多个版本的 vs 不知道使用哪个

"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" -latest -prerelease -products * -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe

VisualStudio 2019 企业版

C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin\MSBuild.exe

社区版

C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin\MSBuild.exe

专业版

C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\MSBuild\Current\Bin\MSBuild.exe

win10 uwp 在 VisualStudio 打包测试完成自动上传到应用商店

Thu, 03 Dec 2020 12:27:49 +0000

在 VisualStudio 2019 提供了在运行测试程序之后，自动将生成的包上传到合作伙伴应用商店。我的应用运行一次自动测试需要半个钟，有这个功能我就不需要在电脑等待半个钟然后去网页上传包，而是可以让 VisualStudio 2019 自动在测试完成之后上传。在勾选通过时需要填写用户信息和租户信息和密码，本文告诉大家如何拿到这些数据填写

在勾选 Windows 应用认证工具包验证之后，自动提交到应用商店。需要填写用户 ID 租户ID和密码，需要在创建 Azure AD 才能拿到信息

打开合作伙伴页面 https://partner.microsoft.com 点击右上角的设置图标

点击开发人员设置，点击租户。如果没有公司创建 Azure AD 那么点击新建 Azure AD 添加帐号

新建完成之后，点击右上角退出登录，然后重新用刚才注册的帐号登录

lindexi@lindexi.onmicrosoft.com

输入刚才写的密码

默认会关联到当前用户

点击设置，点击开发人员设置，点击用户，在用户界面可以新建应用

点击添加 Azure AD 应用，点击新建应用

填写必要的信息

这里的答复 URL 是在让用户通过这个链接登录，而 App ID URI 是用来单点登录。这两个属性在 VisualStudio 上传都用不到，所以随意写，例如写我的博客

下面的角色建议全选

点击保存

点击用户，可以看到刚才创建的应用，点击刚才创建的应用

记下租户 ID 和客户端 ID 到记事本

点击新密钥

将密钥复制到记事本

返回 VisualStudio 界面

输入刚才记事本记录的值点击确定，然后点击启动 Windows 应用程序认证包

这样就会在认证完成之后自动上传

在用户界面可以删除创建的应用，我将刚才的应用删除了，所以逗比小伙伴不用去测试用我的密钥

WPF 图片移除视觉树内存泄漏

Thu, 03 Dec 2020 12:27:49 +0000

本文告诉大家一个已知问题，在保存图片元素对象时，如果在图片移除视觉树之后再设置图片源为空，那么原有的图片源依然被图片元素引用不会释放

如写一个按钮，在点击事件里面创建 RenderTargetBitmap 加入到新建的图片元素，然后在下次点击事件时，将图片元素从视觉树移除之后设置图片源为空

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            // 每次点击此按钮会将当前呈现的图片移除视觉树，再将其Source属性设置为null。
            // 然后新建一个Image控件，并将其Source属性设置为RenderTargetBitmap对象，再呈现出来。
            // 再次过程中，RenderTargetBitmap对象从来不会被回收，造成内存泄露。
            // 可以从资源管理其中观察到程序的内存持续上涨的现象。

            // Remove the current Image control from the  visual tree and set source is null when click button.
            // Then new a image control and add source to the RenderTargetBitmap object and show it.
            // You can see the gc never delete the RenderTargetBitmap object that make  memory leak.


            var oldBorder = RootGrid.Children.OfType<Border>().LastOrDefault();
            if (oldBorder != null)
            {
                var oldImage = (Image)oldBorder.Child;


                // 如果在Image控件移除视觉树之前将其Source属性设为null，并调用UpdateLayout方法。
                // 则RenderTargetBitmap对象可被回收，不会导致内存泄露。
                // 取消注释下面的代码可以观察到上述现象。
                // In order to solve it , you should set the image.Source is null and use UpdateLayout.
                // The below code can solve it.
                // oldImage.Source = null;
                // oldImage.UpdateLayout();

                // 将当前的Image控件移除视觉树。
                // Remove the current Image control from the  visual tree.
                RootGrid.Children.Remove(oldBorder);
                oldImage.Source = null;
                Borders.Add(oldBorder);
            }

            var bitmap = new RenderTargetBitmap(1024, 1024, 96, 96, PixelFormats.Default);

            var image = new Image { Source = bitmap };
            var border = new Border { Child = image };
            RootGrid.Children.Add(border);

            // 为了便于观察内存的变化，每次操作后都会进行垃圾回收。
            // In order to facilitate changes in memory, after each operation will be garbage collection
            GC.Collect();
        }

        public static readonly List<Border> Borders = new List<Border>();

上面代码本身的 Image 元素就是内存泄漏的，因为 Image 元素被 Border 引用，加入到静态数组

但是 RenderTargetBitmap 也内存泄漏，虽然在图片移除视觉树之后设置 oldImage.Source = null; 也就是从代码上没有任何对象引用 RenderTargetBitmap 类，但是此类还是内存泄漏了

解决方法是在移除视觉树之前设置为空，同时调用 UpdateLayout 方法，或者在下一次 Dispatcher 将图片移除视觉树

     oldImage.Source = null;
     oldImage.UpdateLayout();

我在 github 给微软报了这个问题，求点赞

Known issus: WPF Image memory leak when remove image from visual tree · Issue #2397 · dotnet/wpf

为什么会出现内存泄漏？原因是在图片继承的 UIElement 的布局方法会调用 OnRender 方法，而图片通过 DrawContext 的方式绘制了 Source 但是这个 DrawContext 的上下文被 UIElement 保存到 _drawingContent 字段

因为在调用 DrawContext 绘制图片时，将图片转换为MIL资源存放在 RenderData 类，而绘制完成之后将对应的值放在 _drawingContent 字段，也就是在 _drawingContent 引用了图片资源

此时设置图片的源为空，如果图片还在视觉树上，那么将会再次触发 OnRender 方法，在 OnRender 方法里面将会更新 RenderData 对图片源的引用

但是如果图片是被移除视觉树之后设置图片的源为空，那么不会再次触发 OnRender 方法，这样在 RenderData 存在对图片源的引用，此时将不会释放内存。如果在设置图片的源为空，然后不等待 OnRender 方法执行就将图片移除视觉树也是会内存泄漏。所以需要设置图片的源为空，然后调用 UpdateLayout 方法执行 OnRender 方法

其实这个内存泄漏问题很小，原因是如果 Image 元素对象没有被引用，那么图片就可以被释放，此时图片的源也可以释放

但是如果是一个大的做虚拟化的列表，此时在不可见的图片设置源为空，同时移除视觉树，此时图片的对象依然引用，虽然从代码上没有对图片源的引用，但是图片源依然在内存。也就是这个问题需要在做虚拟化列表时，注意对图片的移除视觉树

现在 WPF 开源了，有很多问题都可以从底层修改，欢迎大家关注WPF官方开源仓库欢迎组队格式代码

其实我没有在本地编译成功 WPF 项目，所以干的最多的只是格式代码

TotalCommander 设置 VisualStudio 开发者命令行

Thu, 03 Dec 2020 12:27:49 +0000

在使用 TotalCommnader 可以设置工具的快捷图标，可以用来启动一些工具。而在进行开发，需要使用的命令行推荐使用 VisualStudio 开发命令行，因为在开发者命令行 Developer Command Prompt 提供了很多预定义的命令，包括 NuGet 和 MSBuild 这些命令

在TotalCommander的工具右击点击更改

点击添加按钮

此时通过开始菜单，搜寻 Developer Command Prompt 右击打开所在文件夹，可以找到快捷方式

右击快捷方式找到启动项

%comspec% /k "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\VsDevCmd.bat"

我是使用 VisualStudio 2019 企业版，如果是其他的版本，那么上面的代码和我不相同

这里的 %comspec% 的意思就是 cmd.exe 也就是通过命令行执行脚本

复制上面的代码放在 TotalCommnader 将 %comspec% 和参数分开

此时在 TotalCommnader 进入文件夹，可以点击命令行图标进入开发者命令行，同时自动设置了命令行当前文件夹是进入的文件夹

对熟悉 PowerShell 的小伙伴，可以将命令行修改为 PowerShell 命令

还是和上面步骤相同，找到 PowerShell 版本的 Developer PowerShell for VS 2019 快捷方式，右击属性可以看到下面代码

C:\Windows\SysWOW64\WindowsPowerShell\v1.0\powershell.exe -noe -c "&{Import-Module """C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"""; Enter-VsDevShell e847a152}"

注意我使用 VisualStudio 2019 企业版，如果是其他的版本，那么上面的代码和我不相同

将上面代码的 C:\Windows\SysWOW64\WindowsPowerShell\v1.0\powershell.exe 和参数放在工具的命令和参数，同时参数需要加上 ; cd %P 才能让 PowerShell 跳转到文件夹

这里的 ; cd %P 是通过 ; 让 PowerShell 执行多语句，而 %P 是 TotalCommander 的命令会替换为当前文件夹

-noe -c "&{Import-Module """C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"""; Enter-VsDevShell e847a152}"  ; cd %P

需要注意上面的命令需要用你自己的路径，不要直接复制上面代码

VisualStudio 调试内存泄漏方法

Thu, 03 Dec 2020 12:27:49 +0000

虽然在写 .NET 程序，很难做到内存泄漏，但是一个软件做的很大时会发现还是有一点点的内存泄漏。本文告诉大家如何通过 VisualStudio 调试内存泄漏，这个方法适合进行日常优化

在调试内存泄漏时，最简单的方法时通过内存使用率进行调试。核心方法是查看内存中有哪些对象占用了大量内存，其次是查看内存中有哪些不用的对象还在内存

第一个方法，查看对象占用的方法我做了一个课件视频，点击下面图片就可以播放

上面的方法适合在不了解任何业务时，同时软件存在明显的内存泄漏时的调试。当然，如果不是存在明显的内存泄漏，也很少有小伙伴会进行优化。但是如果现在想要进行更多的优化内存，请尝试使用核心方法二。必须要在进行方法一之后，发现还不满足需求时才进行方法二的优化，因为使用方法二查看内存中有哪些不用的对象还在内存，这个方法要求是了解业务，知道哪些对象已经被执行过了，不需要放在内存，在知道了这部分内存可以被释放之后还需要更改一些业务代码，如果此时的业务不够熟悉，可能有哪些地方是需要引用这个对象的，那么就会修改出坑，此时就有机会可以去和测试小姐姐聊聊天了

用一个简单的代码作为本文调试用的项目

    class Program
    {
        static void Main(string[] args)
        {
            Do();

            // 其他业务
            for (int i = 0; i < int.MaxValue; i++)
            {
                Console.WriteLine("欢迎访问我博客 https://blog.lindexi.com 里面有大量 UWP WPF 博客");
                Task.Delay(TimeSpan.FromSeconds(10));
            }
        }

        private static void Do()
        {
            var business = new Business();
            business.Do();
        }

        public static event Action Foo;
    }

    class Business
    {
        public void Do()
        {
            Program.Foo += Do;
        }
    }

熟悉 C# 的小伙伴很快就发现了内存泄漏的代码 Program.Foo += Do 只要在 C# 中将对象加入到一个长时间生效的对象，也就是将一个生效时间比较短的对象加入到一个生效时间比较长的对象，那么这个对象将会直到生效时间最长的对象被释放时才可以被释放。而静态的对象的生效时间时整个应用到结束的时间，所以任何被静态对象引用的对象都不会被释放

在代码中，将 Do 方法加入到静态的 Foo 事件，此时 Program 对象将会引用 Business 对象，因为加入的是静态的事件，在应用程序退出或 AppDomain 卸载之前这个静态依然有效。于是 Business 对象需要等待 Program 的 Foo 对象释放才可以释放，但 Foo 不会释放，此时就算内存泄漏。但是需要注意此时说不定是业务需要这样做，也就是需要初始化这个模块进行监听事件，在进行优化之前请确定了解这部分的业务。假设业务上需要在执行 Business 的 Do 方法之后，就不再需要 Business 的任何代码，也就是 Business 现在也不需要在内存中存在，在知道这部分业务时，就可以在执行完成 Business 的业务完成之后添加断点。建议将断点放在离具体业务执行完成之后的比较后的时间，或者在业务执行完成之后，等待一会通过 VisualStudio 的全部中断进入断点，因为对象回收是依赖GC的，在业务执行完成之后立刻添加断点可能此时的对象没有任何引用但是没有被gc回收

第一步运行相应的业务，然后等待一下进入断点，进入断点的方法可以是业务执行之后的后面的逻辑添加断点或者 VisualStudio 点击全部中断

第二步是点击内存使用率，点击截取快照

第三步是打开快照堆视图，尝试搜业务用到的类的名，看是否这些类还在内存中

如果找到了对应的类还在内存中，通过查看是哪个对象引用了这个对象，一步步找到引用的代码。此时可以通过在对应的引用的代码的赋值里面添加断点，如果熟悉业务，那么就直接在业务执行完成之后进行清理，如果和本金鱼一样忘记了代码，通过断点可以找到是哪里设置进来的

基本的执行清理就是取消对象的引用，如事件可以使用 -= 方法，列表可以使用 Remove 方法，直接对象引用可以设置为 null 的方法

本文代码放在 github 欢迎小伙伴访问，尝试调试这个项目的内存泄漏

如果确实需要使用到静态的事件，但是不想要每次都手动释放，可以尝试弱事件，请看.NET/C# 利用 Walterlv.WeakEvents 高性能地定义和使用弱事件 - walterlv

而对象引用或列表引用，可以尝试使用弱引用设计一个 .NET 可用的弱引用集合（可用来做缓存池使用） - walterlv

另外，在调试时可能会发现，内存中有很多诡异的数组占用了很多内存，而这部分数组或列表的组成都会很迷，如开始的课件视频说到的内容，请看下面代码

    class Business
    {
        public Business()
        {
            NumberList = new List<int>(1000);
        }

        public void Do()
        {
            Program.Foo += Do;
        }

        public List<int> NumberList { get; }
    }

如果此时进行内存快照，可以在堆视图看到了存在List<int>对象，而这个对象占用了很多内存，但是 Business 对象的大小很小，但是非独占大小比较大。这就是在定义通用的类型的引用时，假设我定义了 100 个不同的类，这些类里面都会定义 List<int> 那么在堆视图可以看到 List<int> 的计数很多，同时占用的内存很多，但是很难直到这些对象是属于哪个模块，请看下图

尝试调试这个版本的代码可以看到堆视图里面存在 List<int> 的对象，再尝试对比调试这个版本的代码在这个版本里面写了 BusinessNumber 类，也就是给 List<int> 元素命名，此时在堆视图里面可以看到是 BusinessNumber 对象的占用内存

通过在代码给元素命名，也就是继承基础的数组等，这样可以在调试内存泄漏时，将不同的业务分开。解决在调试内存时看到大量的都是如 List<int> 的元素

更多调试方法请看 dotnet 代码调试方法

特别感谢 Dotnet9 小伙伴指出本文错误

VisualStudio 命令行编译 build 通过 rebuild 不通过

Thu, 03 Dec 2020 12:27:49 +0000

在使用命令行编译项目，发现使用 build 可以编译通过，但是通过 rebuild 编译提示找不到项目，明明在对应的文件夹存在项目输出的 dll 文件，但是会提示找不到

在命令行编译的 build 和 rebuild 的不同在于使用 build 会用上次编译的内容，如果没有文件更改，那么这个项目不会重新编译。同时会从缓存拿到项目依赖顺序，获取上次编译的项目信息。而 rebuild 会先执行 clean 清理，会清理缓存重新创建项目依赖顺序

而如果 build 能通过而 rebuild 不能通过，此时请尝试清理整个项目仓库的 bin 和 obj 文件夹。在使用 git 管理的项目可以使用下面命令快速清理

git clean -xdf

在执行上面命令之前请先提交本地文件

清理完成之后再次使用 build 命令，关于 msbuild 命令行请看 MSBuild 常用参数

如果清理完成发现通过 build 命令不通过，注意这里的不通过不是因为 nuget 没还原而没通过，那么证明现在的代码是因为依赖上次编译的内容。此时可以清理完成在 VisualStudio 打开，看错误列表内容

如果清理完成发现通过 build 命令能通过，同时用 rebuild 命令如果没有添加 /m 命令也就是并行编译没有问题，而添加了 /m 命令并行重新编译就不通过，提示某些项目的 dll 找不到，那么可能是引用项目不对

如果使用的项目是旧项目格式，不是 sdk style 格式的 csproj 文件，那么在引用项目时需要添加项目的 Guid 值。要求引用的 Guid 和项目声明的相同，和 sln 里面使用的相同

在项目文件里面，可以用记事本工具打开，可以找到 ProjectGuid 属性

    <ProjectGuid>{7478AF9C-E871-48D0-A61E-EA5331654412}</ProjectGuid>

而在其他项目引用就需要这样写

    <ProjectReference Include="..\lindexi\BitStamp.csproj">
      <Project>{a4181b72-65a2-4625-a355-7dea615baa53}</Project>
      <Name>BitStamp</Name>
    </ProjectReference>

如上面这样写，在多线程编译会关联找不到 BitStamp 项目，原因是引用的项目的 Guid 和项目的不相同，这样就无法在编译时找到引用顺序，也就是项目没有按照顺序编译也找不到对应项目

解决方法是通过在引用右击添加引用，将项目引用取消勾选，点击确定。再右击添加引用，重新引用项目就可以

通过这一步可以在 git 等工具看到 csproj 被修改，也就是引用的 Project 属性被修改。如果这样也不成，可能是 sln 里面使用的值不对。解决方法是重新创建一个解决方案，将项目添加到解决方案，删除之前的解决方案

注意重新创建解决方案不要在原因解决方案移除项目，如果在原有解决方案移除项目将会在被移除的项目从所有引用的项目移除

msbuild 修改 VisualStudio 文件复制到输出目录的路径

Thu, 03 Dec 2020 12:27:22 +0000

在默认的 VisualStudio 可以右击任意的文件，让这个文件在编译时复制到输出目录，但是这个选项将会在复制到输出目录时带上这个文件所在 VisualStudio 的文件夹结构。本文告诉大家几个方法让 VisualStudio 的文件可以在编译时输出到自定义的任意路径

文件夹到文件夹

将整个文件夹内容输出到自定义文件夹可以使用写一个 Target 的方法

如我需要将 VisualStudio 的 dll 文件夹的内容全部输出到输出目录，而不是输出到输出目录下的 Dll 文件夹，可以使用下面代码

    <Target Name="CopyReferenceDll" AfterTargets="Build">
        <ItemGroup>
            <ReferenceDll Include="Dll\*.dll">
            </ReferenceDll>
        </ItemGroup>
        <Copy SourceFiles="@(ReferenceDll)" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="True"></Copy>
    </Target>

将上面代码复制到 csproj 文件里面，放在 </Project> 之前就可以做到将 VisualStudio 里面的 Dll 文件夹的 dll 文件复制到输出文件夹

至于需要输出其他文件到其他文件夹的，看上面的代码修改就可以了，如果不知道如何修改请联系我

用 Link 修改路径

通过修改文件链接的地址，这个方法只能输出到输出文件夹内某个文件夹下

    <ItemGroup>
      <None Update="Dll\*.dll" Link="%(Filename)%(Extension)">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      </None>
    </ItemGroup>

此时的 Dll 文件夹的 dll 文件，将会重新链接到 *.dll 路径而不是 Dll\*.dll 但是此时会在 VisualStudio 看到项目的根文件夹存在很多 dll 文件

如果不想看到这些文件通过 Visible 属性

    <ItemGroup>
      <None Update="Dll\*.dll" Link="%(Filename)%(Extension)" Visible="false">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      </None>
    </ItemGroup>

通过 ContentWithTargetPath 项

将原本的 None 替换为 ContentWithTargetPath 项，这个项提供 TargetPath 属性，设置输出的文件

    <ItemGroup>
        <ContentWithTargetPath Include="Dll\*.dll">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
            <TargetPath>%(Filename)%(Extension)</TargetPath>
        </ContentWithTargetPath>
    </ItemGroup>

这个方法底层也是调用了 Copy 命令

适合文件到文件的方式，将 %(Filename)%(Extension) 替换为具体文件，如将某个文件复制到指定的路径，这样写清真很多，请看代码

    <ItemGroup>
        <ContentWithTargetPath Include="Dll\lindexi.dll">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
            <TargetPath>lindexi.dll</TargetPath>
        </ContentWithTargetPath>
    </ItemGroup>

本文用到了 %(Filename) 以及 Copy 和 Target 等，这些可以在我博客看到如何使用

Roslyn 如何使用 MSBuild Copy 复制文件

c# - Visual Studio: How to “Copy to Output Directory” without copying the folder structure? - Stack Overflow

Mobius 一个运行在 .NET Core 上的 .NET 运行时

Thu, 03 Dec 2020 12:27:15 +0000

一个 .NET 应用仅仅只是一块在 .NET 运行时上面运行的二进制代码。而 .NET 运行时只是一个能执行这项任务的程序。当前的 .NET Framework 和 .NET Core 运行时采用 C++ 编写，而 Mobius 是一个使用 C# 重写的 .NET 运行时，重写包括 JIT 编译和 GC 等，这些逻辑都将和 C++ 无关

原文：Mobius – .NET runtime running on .NET Core – TooSlowException

我看到这个有趣的项目的时候就想试试安利一下大家，这个项目特别适合用来了解 GC （Garbage Collector 垃圾收集）和 JIT （Just-In-Time Compiler 即时编译器）的算法

让 C# 编写一个 .NET 运行时和编写一个运行在这个运行时上的 .NET 应用是否有可能呢？换句话是不要 Native 的本机代码或 C++ 代码，所有的代码都是通过 C# 编写是否有可能？这看起来是一个无穷的递归，用 .NET 写 .NET 的运行时运行在 .NET 的运行时上。这是不是就是将一个 .NET 运行时运行在另一个 .NET 运行时上？

作者kkokosa决定开始试试水，这就是做 Mobius 运行时想法的原因。这个想法听起来很奇怪，连作者都不抱期望在一个世纪内将这个想法投入使用。不过作者的想法是想要了解如果写出整个 .NET 运行时需要多少的代码量。同时作者也发现了其实这个想法的作用其实很小，即使想象现在有一个 NuGet 包在安装完成之后就可以添加到咱的应用上，此时的这个包就包含了完整的运行时代码，其实好像也不能做什么

原理

其实这个想法在其他的领域也有人尝试过，最著名的不过是 RVM —— 用 Java 编写的 JVM 虚拟机。虽然他需要使用 C 的引导启动，但是能做到自己托管自己，完全由 Java 运行的虚拟机同时不需要其他的虚拟机。这看起来非常和作者想象的 Mobius 非常接近

这个想法不止作者一个人在想，其实也有小伙伴在 Github 上发布了一个 issus 说能否使用 C# 写 JIT 和 GC 的逻辑

基于这些考虑，可以看到开发 Mobius 的原因如下：

用于实验和研究的框架。使用 C# 和 .NET 编写的运行时，咱可以更简易和快速的了解整个原型，比如对 JIT 或 GC 模块的更改。咱可以使用熟悉的语言如 F# 等去编写整个 .NET 的底层
用于学习。在写这个框架或参与开发的时候，可以从里面学到很多运行时的做法。这也是可以用到很多现代化的 C# 特性的项目，使用更底层的 API 如 Span staclallock Unsafe 等
提升性能。这显然是很有争议的一点。在另一个托管的运行时上面运行另一个运行时看起来就和高性能没有关联。但是如果应用是热启动，那么意味着此时运行的代码生成质量可以依托对CPU的优化，可以达到比本机代码更好的性能。使用 C# 开发理论上可以使用更加稳健的优化。同样用 C# 写 GC 也能有相同的提升
用于玩闹。对于很多人来说，例如德熙看着这个项目一步步搭建起来是十分有趣的

如上面说的，其实都不是很强的理由，为什么要用 .NET 去写 .NET 运行时。大多数情况下，人们会认为使用 C++ 开发和使用 C# 开发不是对立的，两者的差别不是很大。作者非常同意这个观点，这就是为什么作者其实是将这个项目当成一个玩具和实验的项目

先抛开是否有必要做这样的事情，请让咱想想这个项目可以如何做

基本设计原理

首先，要理解的最重要的事情是 Mobius 仍然会将咱的应用程序编译为本地 Native 代码。以这种方式，最终应用程序将以(几乎)本机代码速度运行。不同之处在于托管的基础设施，如 GC 和类型系统、JIT编译器是作为托管代码运行的。这意味着这些代码也被 JIT 编译

如上图，我们有两层JIT构建的代码和底层实际运行时的本地 Native 代码。从图片看起来中间的这一层 .NET Core 基础设施的 Mobius 层是多余的。如果这一层是使用无分配对象的方式写的，那么不需要任何的 GC 方法。在预热之后，对 JIT 的调用也将会很少。这就允许咱假设在一个正常运行的应用程序中，大部分在 Mobius 层的内容都是经过了 JIT 编译优化完成之后运行的，这包括了常用的对 .NET Core 代码的 JIT 构建的代码，这将十分接近 .NET Core 的原生调用

从上面的图看，其实 Mobius 的多余还是很明显。一个可以想的方法是在两个运行时之间共享基础设施

重写整个类型系统并不是一件很有趣的事情。我们甚至可以考虑在 Mobius 中重用相同的 GC 垃圾回收，所以使用 Mobius 给 .NET 应用提供对象将看起来不错。虽然上面的方法请看起来不错，但依然存在两个问题：

这大大减少了 Mobius 框架需要研究的功能。因为没有重新研究一遍 GC 和 JIT 算法，我们将被迫考虑如何合并现有的技术
在 .NET 运行时里面 JIT 和 GC 和类型系统都有比较大的耦合。除了在 Mobius 实现相同的机制之外没有其他方法，将会受限于当前的方法

基于这个原因，作者认为 .NET Core 运行时应该只提供很少量的运行时服务给到 Mobius 框架，提供的服务主要只是调用 Jit 编译代码

当前状态

当前作者还是试验可行性，正在做的是让最简单的 C# 应用能玩起来

private static int Main(string[] args)
{
   int num = 1;
   int num2 = 2;
   return num + num2;
}

通过一些可行性的测试，作者看到了曙光，应该是能做出来的。目前所有需要的机制都已就绪，包括：即使编译的基础支持，通过托管调用 JIT 代码，通过 JIT 代码调用 Mobius 框架。但是因为测试可行性的项目代码写的糟，还需要一点时间对代码进行重构，完善并实现大量的元数据处理，去掉一些硬编码值

现在这个可行性项目只是能做到运行当前这个简单的应用而已，运行的时候通过完全的 CIL 指令和没有任何的异常处理，同时只有 GC 的存根

在下一篇系列文章中，作者将介绍Mobius实现最底层部分的更多细节和代码片段

逗比注：

如果本文看的不错，想要参与开发，我觉得在这之前需要先读一下农夫的书，请看《.NET 底层入门》这本书

另外上面说的玩具什么的只是原作者谦虚的说法，其实这个玩法是可行的，在 Github 有小伙伴在讨论，请看 Port JIT and GC to C# 这个链接

Mac 升级到 dotnet 5 构建 Xamarin 应用失败 error MSB4186 静态方法调用语法无效

Thu, 03 Dec 2020 09:09:54 +0000

我昨天将 Mac 构建机器也升级到了 dontet 5 最新版。但是在升级之后，所有的 Xamarin 项目都在 Mac 版本的 VisualStudio 构建不通过，提示 error MSB4186: 静态方法调用语法无效。解决方法就是将 VisualStudio 更新到最新版本

在升级到 dotnet 5 之后，在 Mac 设备上使用 Mac 版本的 VisualStudio 构建 Xamarin 项目将提示如下代码

/usr/local/share/dotnet/sdk/5.0.100/Sdks/Microsoft.NET.Sdk/targets/Microsoft.NET.TargetFrameworkInference.targets(54,5): error MSB4186: 静态方法调用语法无效:“[MSBuild]::GetTargetFrameworkIdentifier(‘$(TargetFramework)’)”。Method ‘[MSBuild]::GetTargetFrameworkIdentifier’ not found. 静态方法调用应采用以下形式:$([FullTypeName]::Method())，例如 $([System.IO.Path]::Combine(a, b))。请检查确保所有参数均已定义、其类型正确无误，并且按正确的顺序指定

解决方法就是将 VisualStudio 更新到最新版本

WPF 手绘对称图形控件

Thu, 03 Dec 2020 09:01:53 +0000

本文来安利大家一个我刚做的控件，这个控件支持触摸下多指进行笔迹绘制，绘制过程中将会对称显示出水平和垂直翻转的笔迹。可以用来绘制对称图形。当然了，本文还会告诉大家这个控件是如何制作的

啥都不用说，先来一张图

我将这个控件在GitHub上完全开源，代码放在 https://github.com/lindexi/uwp

虽然这是放在 UWP 仓库的控件，但现在只支持 WPF 框架

下面来告诉大家如何使用这个控件

在 dotnet 里面的使用控件的套路都是第一步安装 NuGet 第二步引用命名空间，第三步使用控件

安装 NuGet 库

在 NuGet 控制台输入下面命令就可以安装这个库

Install-Package Lindexi.Control.WPFFlipDrawingCanvas -Version 1.0.0

如果是 SDK 风格的 csproj 文件格式，可以在此文件添加下面代码安装

    <ItemGroup>
        <PackageReference Include="Lindexi.Control.WPFFlipDrawingCanvas" Version="1.0.0" />
    </ItemGroup>

使用控件

先在 XAML 中添加下面代码，添加命名空间

        xmlns:wpfFlipDrawingCanvas="clr-namespace:Lindexi.Control.WPFFlipDrawingCanvas;assembly=WPFFlipDrawingCanvas"

接着就可以使用这个控件

            <wpfFlipDrawingCanvas:FlipDrawingCanvas x:Name="FlipDrawingCanvas"></wpfFlipDrawingCanvas:FlipDrawingCanvas>

现在尝试运行代码就可以看到界面上有一个可以手绘的控件

本文代码放在 github 欢迎小伙伴访问

制作方法

那么这个控件是如何制作的，在 WPF 里面如何进行多指的书写？在 WPF 中如何让控件进行水平和垂直的翻转？了解了这两个问题，就可以很简单制作这个控件

我有一篇博客，告诉大家如何在 WPF 中使用简单的代码制作一个支持多指笔迹的控件，请看 WPF 最简逻辑实现多指顺滑的笔迹书写

在 WPF 中实现翻转特别简单，只需要让缩放作为负数就可以了，如下面代码

<Button Content="欢迎访问我博客 https://blog.lindexi.com 里面有大量 UWP WPF 博客" Padding="5">
  <Button.RenderTransform>
    <ScaleTransform ScaleX="-1" />
  </Button.RenderTransform>
</Button>

详细请看 How to: Flip a UIElement Horizontally or Vertically - WPF .NET Framework

我这个控件很简单，因此去安装一个 NuGet 有点坑，所以我更推荐你去抄抄我的代码哈

如果发现看不懂我的代码，证明还没入门，欢迎加入入门级的群： 874752819 进群之后和群主说是德熙推荐过来的，群主就会看心情给你退回进群费

想要更进阶的交流，还请加入进群费更贵的 858784803 群，当然了进群之后告诉群主说你是我推荐过来的，也许群主想不开会给你发一个红包，或者给我发一个红包

以上两个群的进群费和我没一毛钱关系……

如何给 CI CD 服务器搭建上 .NET 5 构建和运行环境

Thu, 03 Dec 2020 08:22:30 +0000

在 2020.11.10 官方正式发布了 .NET 5 正式版。而我花了一周的时间进行踩坑和预研，本文将告诉大家如何在自动化服务器上搭建 dotnet 5 的构建和运行环境

在上一篇博客里面，我因为 NuGet 版本的问题，不得在 2020.11.13 回滚了 CI 服务器。但是刚好就在那天，大法更新了 NuGet 到 5.8 的版本。按照我一个小伙伴的说法，全网首个支持 .NET 5 的 NuGet 已正式发布

这是上次的博客刚刚我从服务器回滚了 dotnet 5 的环境

这是 NuGet 5.8 发布页面

好的，现在进入搭建服务器状态。我有多个不同类型的服务器需要搭建，包括用来跑 GitLab Runner 的虚拟机，以及用来接入运维团队 devops 的 docker 服务器（准确来说 docker 不是服务器）两个不同类型的服务器。这两个不同类型的服务器分别是 Windows 和 Linux 系统

虚拟机篇

虚拟机上是跑在 Windows 系统的，毕竟还是 Windows 更加强大，很多东西都依然需要在 Windows 下才能完成

在从官方下载全网首个支持 .NET 5 的 NuGet 版本，官方下载地址是 https://dist.nuget.org/win-x86-commandline/v5.8.0/nuget.exe 如果链接失效，请到 NuGet Gallery Downloads 找到最新版本下载

或者从我上传的 CSDN 上下载，地址是 https://download.csdn.net/download/lindexi_gd/13116888

这个版本的 NuGet 被包含在 VS 16.8 和 .NET 5 SDK 里面，但是我依然需要独立的 NuGet 执行文件来辅助构建古老的项目

将下载的独立的 NuGet 放在一个文件夹，然后将这个文件夹设置到环境变量的 Path 里面。这一步相对复杂，我也不打算多说…… 因为真不是必要的，除非你也有古老的项目需要支持

下一步就是去下载 VS 了，我使用的是专业版来进行构建，和微软的销售聊了，其实不需要使用企业版来作为构建服务器的构建工具，使用专业版就可以了。但是我团队的规模在这里，依然还是需要购买一定量的企业版，同时也禁止使用社区版

安装完成之后，在服务器上的 VS 登陆构建机器人的账号，这个账号是一个订阅账号，登录了就自动激活了许可了

理论上此时的 dotnet 5 将会被 VS 16.8 自动带入，也就是意味着啥都不用了，部署就此完成，十分简单

docker

默认官方有将 docker 放在 docker hub 上，请到 .NET - Docker Hub 拉取最新版本即可

如果和我当前的团队一样，运维小伙伴要求 docker 一定要基于别的 base image 的，才需要进行下面步骤。本来我是想拿着官方的 docker 然后安装运维小伙伴的工具软件，但是看到他的一大堆软件和安装步骤，就把我劝退了。我问，为什么不写个自动化脚本来安装。运维小伙伴说，这东西一年也没更新几次，写个脚本要好几天也不好调试……

于是我就反过来，不是在基于官方的 docker 来做，而是基于运维小伙伴的 docker 来做，在运维小伙伴的 docker 上加上 dotnet 的支持

我需要制作两个不同的 docker 一个用来做构建，一个用来作为运行时

从官方可以找到 docker file 的源代码，请看 https://github.com/dotnet/dotnet-docker 基本只需要找对系统然后抄代码就可以了

只是因为我这边的运营商很小气，很难将文件拉下来，因此就需要在外面将 dotnet 和 PowerShell 拉下来，然后将 curl 远程下载的逻辑替换为使用本地的文件

这里我使用dotnet职业技术学院的下载库制作的下载器进行下载，这是一个在 GitHub 完全开源的仓库，请看 https://github.com/dotnet-campus/dotnetCampus.FileDownloader

以下是构建服务器的 dcokerfile 内容

先基于团队的基础镜像

FROM registry.lindexidoubi.com/foo/dotnet-docker-base:debian

然后将本地文件拷贝进入

COPY dotnet-sdk-5.0.100-linux-x64.tar.gz dotnet.tar.gz
COPY PowerShell.Linux.x64.7.1.0.nupkg /

在拷贝的时候就将 dotnet-sdk-5.0.100-linux-x64.tar.gz 从命名为 dotnet.tar.gz 文件

接着添加一下国内源

# 使用国内源
RUN echo "" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian/ buster main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian/ buster main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian-security/ buster/updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian-security/ buster/updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian/ buster-updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian/ buster-updates main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb http://ftp.cn.debian.org/debian/ buster-backports main contrib non-free" >> /etc/apt/sources.list \
    && echo "deb-src http://ftp.cn.debian.org/debian/ buster-backports main contrib non-free" >> /etc/apt/sources.list

然后加上必备的环境

# https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/buster/curl/Dockerfile
# FROM debian:buster
RUN apt-get update && apt-get install -y --no-install-recommends \
		ca-certificates \
		curl \
		netbase \
		wget \
	&& rm -rf /var/lib/apt/lists/*

RUN set -ex; \
	if ! command -v gpg > /dev/null; then \
		apt-get update; \
		apt-get install -y --no-install-recommends \
			gnupg \
			dirmngr \
		; \
		rm -rf /var/lib/apt/lists/*; \
	fi

# FROM buildpack-deps:buster-curl
# https://github.com/docker-library/buildpack-deps/blob/99a1c33fda559272e9322b02a5d778bbd04154e7/buster/scm/Dockerfile
# procps is very common in build systems, and is a reasonably small package
RUN apt-get update && apt-get install -y --no-install-recommends \
		git \
		mercurial \
		openssh-client \
		subversion \
		\
		procps \
	&& rm -rf /var/lib/apt/lists/*

下面就是从 dotnet 仓库抄配置代码

# https://github.com/dotnet/dotnet-docker/blob/0c3cedc7cc5c6679edbba3a0fdf717caeefe02bb/src/sdk/5.0/buster-slim/amd64/Dockerfile
# FROM buildpack-deps:buster-scm
ENV \
    # Unset ASPNETCORE_URLS from aspnet base image
    ASPNETCORE_URLS= \
    DOTNET_SDK_VERSION=5.0.100 \
    # Enable correct mode for dotnet watch (only mode supported in a container)
    DOTNET_USE_POLLING_FILE_WATCHER=true \
    # Skip extraction of XML docs - generally not useful within an image/container - helps performance
    NUGET_XMLDOC_MODE=skip \
    # PowerShell telemetry for docker image usage
    POWERSHELL_DISTRIBUTION_CHANNEL=PSDocker-DotnetSDK-Debian-10

# Install .NET CLI dependencies
RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        libc6 \
        libgcc1 \
        libgssapi-krb5-2 \
        libicu63 \
        libssl1.1 \
        libstdc++6 \
        zlib1g \
    && rm -rf /var/lib/apt/lists/*

将原本 dotnet 仓库里面的通过 curl 下载的逻辑替换为使用本地文件，使用本地文件也就是不需要下载就可以了，因为文件在第一步就从本地复制，请看下面

# Install .NET SDK
# 不从 https://dotnetcli.azureedge.net 下载，从本地复制
RUN dotnet_sdk_version=5.0.100 \
#    && curl -SL --output dotnet.tar.gz https://dotnetcli.azureedge.net/dotnet/Sdk/$DOTNET_SDK_VERSION/dotnet-sdk-$DOTNET_SDK_VERSION-linux-x64.tar.gz \
    && dotnet_sha512='bec37bfb327c45cc01fd843ef93b22b556f753b04724bba501622df124e7e144c303a4d7e931b5dbadbd4f7b39e5adb8f601cb6293e317ad46d8fe7d52aa9a09' \
    && echo "$dotnet_sha512 dotnet.tar.gz" | sha512sum -c - \
    && mkdir -p /usr/share/dotnet \
    && tar -ozxf dotnet.tar.gz -C /usr/share/dotnet \
    && rm dotnet.tar.gz \
    && ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet \
    # Trigger first run experience by running arbitrary cmd
    && dotnet help

# 不从 https://pwshtool.blob.core.windows.net 下载，从本地复制
# Install PowerShell global tool
RUN powershell_version=7.1.0 \
#    && curl -SL --output PowerShell.Linux.x64.$powershell_version.nupkg https://pwshtool.blob.core.windows.net/tool/$powershell_version/PowerShell.Linux.x64.$powershell_version.nupkg \
#   && powershell_sha512='59abcc11bd43fc8c1938a1854447c762092f03b5e2c6c354a82559eed6852e3920c5543c085fbe6fbe98871f96cd7409bb76b1537d3d8dee4e7432d578ec7603' \
#   && echo "$powershell_sha512  PowerShell.Linux.x64.$powershell_version.nupkg" | sha512sum -c - \
    && mkdir -p /usr/share/powershell \
    && dotnet tool install --add-source / --tool-path /usr/share/powershell --version $powershell_version PowerShell.Linux.x64 \
    && dotnet nuget locals all --clear \
    && rm /PowerShell.Linux.x64.$powershell_version.nupkg \
    && ln -s /usr/share/powershell/pwsh /usr/bin/pwsh \
    && chmod 755 /usr/share/powershell/pwsh \
    # To reduce image size, remove the copy nupkg that nuget keeps.
    && find /usr/share/powershell -print | grep -i '.*[.]nupkg$' | xargs rm

这样就完成了构建服务器的 dcokerfile 了，下一步只是需要用这个文件构建 docker image 就可以了

而运行时服务器的搭建也差不多，只是因为运行时的 dotnet 很小，不需要在外面下载，因此可以更愉快的抄代码

FROM registry.lindexidoubi.com/foo/dotnet-docker-base:debian-security
USER root
# https://github.com/dotnet/dotnet-docker/blob/master/3.1/runtime-deps/buster-slim/amd64/Dockerfile
RUN yum update -y
RUN yum install -y  \
        ca-certificates \
        \
# .NET Core dependencies
        libc6 \
        libgcc1 \
        libgssapi-krb5-2 \
        libicu63 \
        libssl1.1 \
        libstdc++6 \
        zlib1g \
        # GDI
        libc6-dev \
        libgdiplus \
    && rm -rf /var/lib/apt/lists/*

# Configure web servers to bind to port 8080 when present
# 无管理员权限运行 80 提示 System.Net.Sockets.SocketException (13): Permission denied https://github.com/dotnet/aspnetcore/issues/4699
ENV ASPNETCORE_URLS=http://+:8080 \
    # Enable detection of running in a container
    DOTNET_RUNNING_IN_CONTAINER=true

RUN rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm && \
    yum install -y aspnetcore-runtime-5.0

USER cloud

我比官方更多的逻辑是额外安装了 GDI+ 的库

可以看到搭建 docker 的步骤比虚拟机的步骤多太多了，但这是因为我不能拉官方的 docker 来用而已，如果能拉官方的，那就只需要两句话就完成了

我在做 docker 服务器的时候，因为本地磁盘空间不足，翻车了，请看 dotnet 制作 docker 提示 Insufficient space in download directory 磁盘空间不足

开源实战

Thu, 03 Dec 2020 08:22:30 +0000

本文记录我参与的开源项目

dotnet runtime

日志库减少不必要的对象创建和静态对象

Reduce creation of static objects by lindexi · Pull Request #36867 · dotnet/runtime

修复 MAC 下删除应用程序，然后调用 Process Start 失败

详细请看 dotnet core 在 MAC 系统下删除应用程序自己后调 Process Start 方法将会抛出 Win32 异常

Ignore the executable file be deleted in Process Start by lindexi · Pull Request #40748 · dotnet/runtime

文档

代码审查

Nullability annotations for HttpListener by pgovind

链接 Nullability annotations for HttpListener by pgovind · Pull Request #41189 · dotnet/runtime

有多余的判断逻辑，使用 s!.Length 不如使用原先拿到的 l 判断

有优化的写法，有两个小伙伴给我点赞

SourceYard

主要开发者

制作 NuGet 源代码包的工具，使用 NuGet 将源代码分发给小伙伴，可以直接安装此 NuGet 获取源代码

WPF

水到非官方开发者了，但大部分都是修改文档和注释

Replace IsAssignableFrom to is pattern by lindexi · Pull Request #101 · dotnet/wpf

We use language keywords instead of BCL types by lindexi · Pull Request #102 · dotnet/wpf

Update the docs link by lindexi · Pull Request #3078 · dotnet/wpf

Remove special vs version on the link by lindexi · Pull Request #3160 · dotnet/wpf

Fix XmlNsInfo comment typo by lindexi · Pull Request #3742 · dotnet/wpf

Remove the custom HashSet class by lindexi · Pull Request #3738 · dotnet/wpf

Use Array.Empty instead of creating list in ResourceDictionaryDiagnostics by lindexi · Pull Request #3851 · dotnet/wpf

代码审查

https://github.com/dotnet/wpf/pull/3092#issuecomment-640955984

Add BindingFailed event for diagnostics of binding failures by spadapet · Pull Request #3505 · dotnet/wpf

[release/5.0] Support Source Generators in WPF projects by ryalanms · Pull Request #3846 · dotnet/wpf

OpenXML SDK

水到非官方开发者了

Xamarin Forms

修坑

Fix the memory leak problem of ListViewRenderer headerRenderer by lindexi · Pull Request #11699 · xamarin/Xamarin.Forms

samples

https://github.com/dotnet/samples/pull/299

https://github.com/dotnet/samples/pull/308

https://github.com/dotnet/samples/pull/516

https://github.com/dotnet/samples/pull/517

https://github.com/dotnet/samples/pull/518

https://github.com/dotnet/samples/pull/524

https://github.com/dotnet/samples/pull/539

https://github.com/dotnet/samples/pull/541

https://github.com/dotnet/samples/pull/542

https://github.com/dotnet/samples/pull/561

https://github.com/dotnet/samples/pull/602

https://github.com/dotnet/samples/pull/634

https://github.com/dotnet/samples/pull/745

Fix compile by lindexi · Pull Request #741 · dotnet/samples

Fix align by lindexi · Pull Request #654 · dotnet/samples

Fix code format by lindexi · Pull Request #696 · dotnet/samples

Fix code format by lindexi · Pull Request #854 · dotnet/samples

Environment.FailFast Method (System)

Fix code format by lindexi · Pull Request #1011 · dotnet/samples

Fix code format by lindexi · Pull Request #1065 · dotnet/samples

Assembly.GetType Method (System.Reflection)

dotnet docs

Update inheritance.md by lindexi · Pull Request #10669 · dotnet/docs

Fix typo by lindexi · Pull Request #9499 · dotnet/docs

nuget

Update nuspec.md by lindexi · Pull Request #1316 · NuGet/docs.microsoft.com-nuget

visualstudio-docs

Fix code by lindexi · Pull Request #2309 · MicrosoftDocs/visualstudio-docs

Fix code by lindexi · Pull Request #2503 · MicrosoftDocs/visualstudio-docs

winrt-api

Fix code format by lindexi · Pull Request #773 · MicrosoftDocs/winrt-api

Fix code format by lindexi · Pull Request #772 · MicrosoftDocs/winrt-api

windows-uwp

Fix align by lindexi · Pull Request #1357 · MicrosoftDocs/windows-uwp

Fix format by lindexi · Pull Request #1423 · MicrosoftDocs/windows-uwp

xamarin-docs.zh-cn

HandyControl

Improve Deque initialization performance by lindexi · Pull Request #435 · HandyOrg/HandyControl

Add InputClickHelper by lindexi · Pull Request #414 · HandyOrg/HandyControl

Make the locker as readonly by lindexi · Pull Request #413 · HandyOrg/HandyControl

Use const replace magic number by lindexi · Pull Request #412 · HandyOrg/HandyControl

Avalonia

Fix 1533 Avoid throwing exception in TryReadDouble by lindexi · Pull Request #1534 · AvaloniaUI/Avalonia

Improve tiny performance by lindexi · Pull Request #1472 · AvaloniaUI/Avalonia

Dispatcher’s InvokeAsync check action is null #1400 by lindexi · Pull Request #1401 · AvaloniaUI/Avalonia

add some comment by lindexi · Pull Request #1396 · AvaloniaUI/Avalonia

JasonStein Notepads

Added zh-CN translation by lindexi · Pull Request #32 · JasonStein/Notepads

Orleans.MultiClient

https://github.com/OrleansContrib/Orleans.MultiClient/pull/3

Castle.Core

Update date by lindexi · Pull Request #523 · castleproject/Core

NewLife.RocketMQ

文档

加上 PackageProjectUrl 链接 by lindexi · Pull Request #14 · NewLifeX/NewLife.RocketMQ

MultiTouchVista

Format doc by lindexi · Pull Request #2 · nesherhh/MultiTouchVista

Format doc by lindexi · Pull Request #1 · nesherhh/MultiTouchVista

JitBench

Fix the link by lindexi · Pull Request #93 · aspnet/JitBench

dotnet iot

代码审查 Fixing DHT issues, adding and adjusting documentation by Ellerbach · Pull Request #1164 · dotnet/iot

鸿蒙的文档

相机开发示例开发2 链接失效 · Issue #I1UW33 · OpenHarmony/docs - Gitee.com

使用 IOC 控制反转和 DI 依赖注入的意义

Thu, 03 Dec 2020 08:22:30 +0000

其实我的标题没写对，这个话题我是聊不下去的。本文只和小伙伴聊聊为什么使用容器注入，优缺点是什么。我通过问问题的方式让小伙伴了解这么做的意义

在开始之前我就可以告诉小伙伴使用容器注入的缺点了，尽管这很有争议

内存泄漏
降低性能

那是否 IOC 控制反转意味着一定需要配合 DI 依赖注入？答案是不一定的，还有好多有趣的手段

那 DI 依赖注入和容器注入有什么关联？其实容器注入是依赖注入的一个核心方法，也就是现在用的最多的方法

那什么是容器注入呢？其实容器注入相当于创建一个容器数组，然后当某个类需要依赖其他的类的时候，被依赖的类会提前放在容器里面，在被需要的时候从容器里面拿出来

还有一个问题是依赖注入是否和具体框架相关？用于解决什么问题？

上面这个是送命题…… 原因是难以有一个能说服大部分小伙伴的答案。我尝试回答第一个问题，尽管依赖注入和设计模式几乎是等同的概念，这仅仅只是一个通用的工程上的设计方案，和具体的产品或技术方案没有关系。但是抛开具体的业务和技术方案讲依赖注入是十分空泛的而且几乎没有什么意义

那么 IOC 控制反转和 DI 依赖注入是想要解决什么问题？这个问题也不好回答，尽管从字面意思上是为了解决模块耦合，但事实的作用将会复杂很多。我尝试通过问一些问题看小伙伴能否了解这样做的意义

首先依赖注入肯定是建在面向对象上面的。那么面向对象的一个特点，多态，可以如何实现？

假定有某个接口有三个不同的实现类，那么请问我在使用的时候，具体使用哪个？

上面这个题目也是送命题哈。标准的答案是业务决定。那问题来了，请问业务决定的时候如何送到具体的使用方？

来一个具体的业务的例子，这样问题会清晰一些

相信小伙伴都用过 PPT 幻灯片这个软件，假设咱现在要做一个和 PPT 软件差很多的软件，例如希沃白板。在开始设计的时候，可以发现这个软件有两个模式，编辑模式和播放模式

而在 PPT 软件上面的形状元素在这两个模式下的拖动表现是不相同的，那么可以如何实现呢？

最简单的实现方式就是通过 if else 的方法啦

if (编辑模式)
{
  // 执行编辑模式业务
}
else if (播放模式)
{
  // 执行播放模式业务
}

但小伙伴会发现这样的设计不优雅，因为如果后续产品大佬说要添加一个新的模式叫演示模式，这个模式的形状元素拖动的表现和前面两个都不同，此时就不好玩了

if (编辑模式)
{
  // 执行编辑模式业务
}
else if (播放模式)
{
  // 执行播放模式业务
}
else if (演示模式)
{
  // 执行演示模式业务
}

过几天产品大佬再加几个新的模式，很快这段代码就是神坑了

于是小 A 想到了一个设计，那就是将拖动业务作为一个接口，而具体的编辑模式和播放模式等都有继承这个接口的实现

interface 拖动业务接口
{

}

class 编辑模式下的拖动业务 : 拖动业务接口
{

}

class 播放模式下的拖动业务 : 拖动业务接口
{

}

class 演示模式下的拖动业务 : 拖动业务接口
{

}

class 形状元素
{
  public 拖动业务接口 拖动业务 { set; get; }
}

看起来很清真，因为在形状里面的业务代码可以写成如下

拖动业务.执行业务();

一句话就完成了

但是真的是一句话就完成了？执行上面代码将会告诉你，你没有对象

请问是谁给形状元素的拖动业务属性赋值？

这就是问题所在了，小伙伴想想应该是谁给拖动业务这个属性赋值？

难道是创建形状元素对应的业务？好，假定是一个叫页面的类将会创建形状元素那么代码需要如何写？

class 页面
{
  void 创建形状元素()
  {
    拖动业务接口 拖动业务 = null;
    if (编辑模式)
    {
      拖动业务 = new 编辑模式下的拖动业务();
    }
    else if (播放模式)
    {
      拖动业务 = new 播放模式下的拖动业务();
    }
    else if (演示模式)
    {
      拖动业务 = new 演示模式下的拖动业务();
    }

    形状元素 元素 = new 形状元素();
    元素.拖动业务 = 拖动业务;
  }
}

上面代码就有趣了，只是将原本写在形状元素的代码放在页面这个类里面…… 代码依然是神坑

如果是你的话，会如何设计？

假定除了拖动业务之外，还有其他业务呢？例如元素的点击业务在不同的模式也是表现不相同的有不同的业务。如果每个业务都来一次判断和赋值，那么有趣不？

再假定除了页面会创建形状之外，还有其他类也需要创建形状，例如画板这个类也需要。此时是否画板这个类也需要复制暂停页面里面创建形状的逻辑？

小伙伴说，不慌，我有工厂模式

什么是工厂模式？其实就是不写 new 形状元素() 而是通过一个叫 形状元素工厂 的类创建出 形状元素 这个对象

此时相当于将复杂的创建形状元素放在了工厂里面，在一个工厂里面写判断逻辑

class 形状元素工厂
{
  public 形状元素 创建形状元素()
  {
    拖动业务接口 拖动业务 = null;
    if (编辑模式)
    {
      拖动业务 = new 编辑模式下的拖动业务();
    }
    else if (播放模式)
    {
      拖动业务 = new 播放模式下的拖动业务();
    }
    else if (演示模式)
    {
      拖动业务 = new 演示模式下的拖动业务();
    }

    形状元素 元素 = new 形状元素();
    元素.拖动业务 = 拖动业务;

    return 元素;
  }
}

看起来确实能解决上面这个问题，但我又给你挖一个坑

产品大佬说，我还要做一个叫图片元素的业务，这个图片元素也是需要有和形状一样的拖动业务的

有趣不，如果用解决形状元素的问题来解决图片元素的问题，那么是不是咱需要创建一个叫图片元素工厂的类，然后写出和形状元素差不多的逻辑

class 图片元素工厂
{
  public 图片元素 创建图片元素()
  {
    拖动业务接口 拖动业务 = null;
    if (编辑模式)
    {
      拖动业务 = new 编辑模式下的拖动业务();
    }
    else if (播放模式)
    {
      拖动业务 = new 播放模式下的拖动业务();
    }
    else if (演示模式)
    {
      拖动业务 = new 演示模式下的拖动业务();
    }

    图片元素 元素 = new 图片元素();
    元素.拖动业务 = 拖动业务;

    return 元素;
  }
}

class 图片元素
{
  public 拖动业务接口 拖动业务 { set; get; }
}

然后产品大佬说想要做很多元素，如视频元素等等。然后产品大佬又说，我需要让图片和形状元素都支持修改颜色的业务，当然这个修改颜色的业务在不同的模式是不同的业务逻辑

理一下产品大佬的需求有复杂

演示模式
编辑模式
播放模式
形状元素
图片元素
视频元素
拖动业务
点击业务
修改颜色业务

这就有趣了，即使咱想写一个叫元素的基类也做不到了。因为上面的几个业务里面并非都可以放在基类里面，如修改颜色业务，因为视频不具备这样的业务功能。而形状和图片没有任何可以再继承的基类

但是聪明的小伙伴会想出一个有趣的设计方案，那就是根据元素所继承的接口给予对应的业务类，而所有的元素创建工厂里面都有加工基础元素的工厂

class 图片元素工厂
{
  public 图片元素 创建图片元素()
  {
    图片元素 元素 = new 图片元素();

    元素加工厂.加工元素(元素);

    return 元素;
  }
}

那元素加工厂是什么？其实就是将刚才那些有趣的具体业务代码进行注入的类。当然在此之前，咱需要让元素有一个基类，同时让元素有接口可以继承。接口是用来做什么的？用来表明元素具备某个业务，看了下面代码就知道

class 元素基类
{

}

interface 可拖动元素接口
{
  拖动业务接口 拖动业务 { set; get; }
}

class 图片元素 : 元素基类, 可拖动元素接口
{
  public 拖动业务接口 拖动业务 { set; get; }
}

如上面代码只要元素继承了可拖动元素接口那么元素就包含了拖动业务这个属性，因此可以在元素加工厂里面通过此判断

static class 元素加工厂
{
  public static void 加工元素(元素基类 元素)
  {
    if (元素 is 可拖动元素接口 可拖动元素)
    {
      拖动业务接口 拖动业务 = null;
      if (编辑模式)
      {
        拖动业务 = new 编辑模式下的拖动业务();
      }
      else if (播放模式)
      {
        拖动业务 = new 播放模式下的拖动业务();
      }
      // 忽略其他代码
      可拖动元素.拖动业务 = 拖动业务;
    }
  }
}

此时无论来多少个元素，不管这些元素存在多有趣的业务，都可以通过优化元素加工厂通过判断接口给对应的属性的方法

其实上面的代码基本上也算完成了一个依赖注入容器了，只是上面的元素加工厂会耦合太多的业务了。因为各个业务都需要更改这个类的内容。那是否可以将这个类的一部分逻辑放在具体的业务里面呢？例如下面代码

static class 元素加工厂
{
  public static void 加工元素(元素基类 元素)
  {
    foreach (var 元素过滤 in 元素过滤列表)
    {
      元素过滤.过滤(元素);
    }
  }

  public static List<元素过滤> 元素过滤列表 { get; } = new List<元素过滤>();
}

abstract class 元素过滤
{
  public abstract void 过滤(元素基类 元素);
}

abstract class 元素过滤<T> : 元素过滤
{
  public override void 过滤(元素基类 元素)
  {
    if (元素 is T t)
    {
      过滤(t);
    }
  }

  protected abstract void 过滤(T t);
}

上面代码是什么意思呢？其实就是允许具体的业务给元素加工厂的元素过滤列表添加元素过滤进行给元素注入依赖

如上面的拖动业务，可以在具体的拖动业务模块初始的代码里面这样写

class 拖动业务元素过滤 : 元素过滤<可拖动元素接口>
{
  protected override void 过滤(可拖动元素接口 可拖动元素)
  {
    拖动业务接口 拖动业务 = null;

    // 忽略代码

    可拖动元素.拖动业务 = 拖动业务;
  }
}

void 拖动业务模块()
{
  元素加工厂.元素过滤列表.Add(new 拖动业务元素过滤());
}

于是各个业务模块就可以将自己的逻辑写在自己的模块里面，即使有再多的业务都不会让元素加工厂包含这部分的业务代码

其实上面的代码已经算是一个依赖注入容器了，同时实现的是属性注入的方式

回到开始的问题，请问依赖注入解决了什么问题？

随着咱不断复杂的业务逻辑，如何拆分才能降低耦合？如何更好利用面向对象的多态？

更工程化的问题还包含了如何可以让业务更好的支持自动化测试

如上面的代码，我期望在单元测试的时候支持测试元素在拖动的业务，我期望传入一个虚拟的拖动业务逻辑以进行无 UI 和交互的自动化测试，能不能做到？其实非常方便，通过在元素加工厂的元素过滤列表里面注入用于测试的虚拟的类的元素过滤就可以完成这项业务

class 虚拟的拖动业务 : 拖动业务接口
{
}

class 虚拟的拖动业务元素过滤 : 元素过滤<可拖动元素接口>
{
  protected override void 过滤(可拖动元素接口 可拖动元素)
  {
    拖动业务接口 拖动业务 = new 虚拟的拖动业务();

    可拖动元素.拖动业务 = 拖动业务;
  }
}

请小伙伴尝试再读一遍，不要被我带节奏，想想还有什么方法也能解决上面的问题

手把手教你构建 WPF 框架的私有版本

Thu, 03 Dec 2020 08:22:30 +0000

在上一篇博客告诉了大家如何让 GitHub 的 Action 协助咱构建 WPF 官方源代码，但是上一篇博客只是构建成功而已，构建的输出内容还是拿不到。本文将告诉大家如何让 WPF 框架的源代码构建之后输出到私有的 NuGet 源上，方便构建出私有分支版本

在上一篇博客手把手教你如何构建 WPF 官方开源框架源代码告诉大家为什么我推荐使用 GitHub 的 Action 进行构建，尽管进行本地构建也可以。但是本文则是再次建议使用 GitHub 的 Action 进行打包推送

为什么推荐使用 GitHub 的 Action 进行打包推送？原因是这部分是自动化的，对于发布的正式包，越少有人工的参与，那么在打包发布的坑将会越少。自动化不仅可以减少人工的成本，同时可以减少发布的坑。另外自动化的工具有很多，为什么我推荐使用 GitHub 的 Action 做？原因在于被微软收购的 GitHub 十分有钱，免费可以使用，性能强劲。另外这个 GitHub 的 Action 的构建服务器部署在国外，下载 WPF 构建需要的依赖库的速度非常快

假定咱给 WPF 框架写了一点诡异的代码，这部分代码官方是绝对不接收的，例如在 Application 基类的构造函数写出下面代码

Console.WriteLine("林德熙是逗比");

这个版本的 WPF 框架只能做私有发布了，在手把手教你如何构建 WPF 官方开源框架源代码告诉大家如何进行构建，那么现在就需要将构建完成的 NuGet 库发布到私有仓库里面

我推荐使用 myget 这个免费的私有的仓库，这个免费的仓库允许上传私有的 nuget 库，创建自己的私有源

打开 https://www.myget.org 官网，点击 Sign Up 注册，填写自己的用户名邮箱密码等，点击创建账号，再去邮箱的垃圾堆找到确定邮件，点击确定

接下来点击创建一个私有源

给自己的私有源一个链接

可以设置为公开的或私有的

此时就可以拿到一个用于 NuGet 推送的链接和 ApiKey 了

回到 WPF 仓库的 .github\workflows\dotnetcore.yml 文件，此时给他添加构建之后推送的代码

    - name: Push
      run: nuget push .\artifacts\packages\Release\NonShipping\*.nupkg -Source https://www.myget.org/F/lindexi/api/v2/package -ApiKey d82d56b1-ee09-4dca-a7bb-315d4aa01ff5 -SkipDuplicate -NoSymbols 

在 WPF 构建完成之后，将在 artifacts\packages 文件夹创建 NuGet 包，而上面代码就是将对应的 NuGet 包推送到 https://www.myget.org/F/lindexi/api/v2/package 仓库，可以注意到这个仓库的链接就是刚才在 myget 创建的私有链接

因为这是一个私有链接，需要使用到特殊的 ApiKey 在刚才的管理界面能找到对应的字符串，后面的 -SkipDuplicate 表示如果服务器上面已经存在相同的版本，那么跳过而不报错。这里的 -NoSymbols 参数表示的是没有包含带符号的 NuGet 包，如果没有加上这个参数，默认 NuGet 会尝试寻找 snupkg 文件，但是这里是没有创建的，将会提示找不到文件

此时的 dotnetcore.yml 文件的全部代码如下

name: .NET Core

on: [push]

jobs:
  build:

    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v1
    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: '5.x'
    - name: Build
      run: .\build.cmd -pack -ci -configuration Release -prepareMachine /p:Platform=x86
    - name: Push
      run: nuget push .\artifacts\packages\Release\NonShipping\*.nupkg -Source https://www.myget.org/F/lindexi/api/v2/package -ApiKey d82d56b1-ee09-4dca-a7bb-315d4aa01ff5 -SkipDuplicate -NoSymbols 

将代码推送到 GitHub 上，触发 Action 自动构建，默认构建完成将会推送。可以看我的这一次 commit 和对应的 Action 的构建因为 Github 的构建会保存日志一段时间，会自动清理太古老的日志，所以我下面贴上构建成功的日志

返回自己的私有 NuGet 仓库，就可以看到刚才上传的 NuGet 文件

这就是通过 GitHub 的 Action 加上 myget 的构建私有版本的方法，当然如果只是想要让 NuGet 库可以下载，还可以用到 GitHub 的 Artifact 功能

什么是 Arifact 功能？大概就是存放输出文件的功能，这个功能可以将某个输出的文件夹压缩为 zip 包存储起来的功能，因为是将文件夹压缩为 zip 的，就不需要处理单独的某个包，也和具体的输出格式没有关系

使用方法是将上面的 NuGet 的 Push 的代码去掉，替换为 Artifact 的方法

    - name: Push
      uses: actions/upload-artifact@v1
      with:
        name: WPF
        path: ./artifacts/packages/Release/NonShipping

使用上面代码构建完成之后，将会创建 WPF.zip 包，这个文件包含了 /artifacts/packages/Release/NonShipping 文件夹的内容。现在 dotnetcore.yml 的代码请看下面

name: .NET Core

on: [push]

jobs:
  build:

    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v1
    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: '5.x'
    - name: Build
      run: .\build.cmd -pack -ci -configuration Release -prepareMachine /p:Platform=x86
    - name: Push
      uses: actions/upload-artifact@v1
      with:
        name: WPF
        path: ./artifacts/packages/Release/NonShipping

推送到服务器的构建效果请看下图

此时通过梯子下载输出的 zip 包，然后本地解压缩，这样就可以拿到输出文件了

虽然我还没有想好给 WPF 的私有版本添加什么功能，但是想想能做一个私有的版本，也就是相当于真的可以使用了这个源代码，可以让源代码发挥除了了解框架的功能之外，还多了定制的功能

有个小伙伴说现在很多小伙伴都有空没事干，不如去造一个跨平台的 WPF 框架

但是过了很久，其实他连项目都没开起来，于是我就想问他是不是还活着

特别感谢微软提供的 GitHub 平台免费的构建服务器，这样可以让我很低成本的上手。能够自己对框架源代码定制化，才能认为这个框架是真正的可用的开源项目

本文代码放在 github 欢迎小伙伴访问

更多博客

XP 源代码如何在清空回收站时修改回收站图标

Thu, 03 Dec 2020 08:22:29 +0000

本文来聊聊在 XP 系统里面，是如何在清空回收站的时候修改回收站图标的

声明我没有拿到微软泄露 XP 系统的源代码，以下逻辑都是我瞎说的，微软才不会写出如此逗比的代码

在 bitbuck.c 文件里面有 SHUpdateRecycleBinIcon 的实际实现，而这个方法实际上只是调用了 UpdateIcon 方法而已。大概的代码如下

STDAPI_(void) SHUpdateRecycleBinIcon()
{
    UpdateIcon(!回收站是不是空的());
}

在 UpdateIcon 方法里面，先从注册表拿到回收站的图标，因为回收站的图标是可以让用户定制的

通过传入是否回收站是空的，获取不同的图标

拿到图标之后，调用 SHUpdateImage 方法将图标设置给回收站

这就是在 XP 系统里面的逻辑。上面代码也说明了 BitBucket 打不过 GitHub 的原因了，因为在 XP 上就是垃圾桶

感谢工具人少珺的协助

WPF 简易手绘笔迹支持回放的方法

Thu, 03 Dec 2020 08:22:29 +0000

手绘笔迹实际上就是需要支持回放的，手绘笔迹指的是在应用程序里面支持回放出手绘出来的笔迹。本文来告诉大家一个简易的方法

啥都不说，先来一张图

在抬手的时候绘制出刚才所画的笔迹，做动画画出笔迹，就和手绘差不多的效果

下面来告诉大家核心的原理

在 WPF 中，可以使用一个叫路径动画的功能，通过这个功能可以传入一个 Path 路径就能动画出这个轨迹

在 WPF 中，笔迹的底层绘制是使用 Geometry 进行绘制。而刚好 Geometry 就是 Path 的数据层，也就是手绘出来的笔迹可以拿到 Geometry 然后创建出 Path 路径进行轨迹动画

在 WPF 中，有 OpacityMask 可以实现蒙层，这个蒙层的功能就是只要蒙层里面有非透明的像素部分，将会显示原本元素上的这部分像素。这个蒙层是做刮刮卡的好工具，大概效果如下图

依靠上面三个机制就能实现手绘笔迹支持回放轨迹的动画功能

当然，第一步是需要支持笔迹书写的功能，这部分功能还请看 WPF 最简逻辑实现多指顺滑的笔迹书写这篇博客的内容

而第二步就是构建出路径动画出来，在开始下面代码之前，还需要在 WPF 最简逻辑实现多指顺滑的笔迹书写这篇博客先抄笔迹的实现代码，大概 150 行不到就可以完成了

对之前代码做一点更改，在手指抬起的时候触发一下动画。在触发动画之前需要保存这个笔迹，用来给动画使用，如下面代码

        private void MainWindow_StylusUp(object sender, StylusEventArgs e)
        {
            _currentStroke = StrokeVisualList[e.StylusDevice.Id].Stroke;
            StrokeVisualList.Remove(e.StylusDevice.Id);
            StartAnimation();
        }

        private Stroke _currentStroke;

在 StartAnimation 方法里面将会播放动画，在开始写这部分代码之前，还需要做一点准备的知识。动画放在 XAML 编写框架将会比较简单，如下面代码

    <Window.Resources>
        <Storyboard x:Key="StrokePointAnimation" AutoReverse="False">
            <PointAnimationUsingPath Storyboard.TargetName="StrokePointGeometry" Storyboard.TargetProperty="Center" />
        </Storyboard>
    </Window.Resources>

        <Grid Grid.Row="0" x:Name="StrokeGrid">
            <Path Fill="Transparent">
                <Path.Data>
                    <EllipseGeometry x:Name="StrokePointGeometry" RadiusX="{Binding StrokePointThickness}"
                                     RadiusY="{Binding StrokePointThickness}" />
                </Path.Data>
            </Path>
        </Grid>

如上面代码，将会使用动画移动 Path 元素，作用是修改 StrokePointGeometry 的中心点的坐标，修改坐标做路径动画

上面代码的重点是 PointAnimationUsingPath 这句代码，让 StrokePointGeometry 的中心点的坐标做 Path 动画

定义完成动画的框架之后，需要在后台代码先获取这个定义的动画框架的资源，如下面代码

        private Storyboard GetAnimationStoryboard()
        {
            _storyboard = Resources["StrokePointAnimation"] as Storyboard;
            return _storyboard;
        }
        private Storyboard _storyboard;

上面代码有很大的优化空间，还请大家忽略这部分细节，咱继续开发动画部分的逻辑

在刚才保存的 _currentStroke 里面获取 Geometry 的方法十分简单，请看下面代码

        private Geometry GetCurrentGeometry()
        {
            return _currentStroke.GetGeometry();
        }

在拿到 Geometry 就可以开始路径动画了，请看下面代码

        private void StartAnimation()
        {
            var geometry = GetCurrentGeometry();

            var storyboard = GetAnimationStoryboard();
            if (storyboard.Children[0] is PointAnimationUsingPath pointAnimationUsingPath)
            {
                pointAnimationUsingPath.PathGeometry = geometry.GetFlattenedPathGeometry();
                pointAnimationUsingPath.Duration = TimeSpan.FromMilliseconds(3000);
            }

            storyboard.Begin();
        }

可以看到代码非常简单，只是当前运行的时候啥都看不到，因为在 XAML 中的 Path 的颜色被我设置为透明。现在为了调试方便，咱将这个颜色修改一下，如下面代码所示

        <Grid Grid.Row="0" x:Name="StrokeGrid">
            <Path Fill="Red">
                <Path.Data>
                    <EllipseGeometry x:Name="StrokePointGeometry" RadiusX="{Binding StrokePointThickness}"
                                     RadiusY="{Binding StrokePointThickness}" />
                </Path.Data>
            </Path>
        </Grid>

为了做到如本文一开始给大家看的效果，需要添加一点代码，在做动画的时候，顺便如做刮刮卡一样的功能，让上面这个红点经过的路径的蒙层显示出后面的内容。而刚好这个点的轨迹就是笔迹的几何，因此只需要在笔迹上面放一个蒙层，然后在点做动画的时候实时更改这个蒙层就可以

为了拿到点在做动画的时候的值，可以使用如下代码注册事件

        private void RegisterStoryboardHandler()
        {
            var descriptor =
                DependencyPropertyDescriptor.FromProperty(System.Windows.Media.EllipseGeometry.CenterProperty,
                    typeof(EllipseGeometry));
            descriptor.RemoveValueChanged(StrokePointGeometry, StrokeAnimating);
            descriptor.AddValueChanged(StrokePointGeometry, StrokeAnimating);
        }

这里的 StrokeAnimating 方法就是做蒙层的方法，请看代码

        private bool _isFirst = true;

        private void StrokeAnimating(object sender, EventArgs e)
        {
            var animatedStrokeGrid = StrokeGrid;
            if (_isFirst)
            {
                _isFirst = false;
                // 设置背景这句话是重要的哦，否则Grid不会撑开宽度和高度
                animatedStrokeGrid.Background = Brushes.Transparent;

                var mask = new DrawingBrush
                {
                    TileMode = TileMode.None, Stretch = Stretch.None, AlignmentX = AlignmentX.Left,
                    AlignmentY = AlignmentY.Top
                };
                var geoMask = new GeometryGroup {FillRule = FillRule.Nonzero};
                mask.Drawing = new GeometryDrawing {Geometry = geoMask, Brush = Brushes.Black};
                geoMask.Children.Add(new RectangleGeometry(new Rect(0, 0, 1, 1)));

                animatedStrokeGrid.OpacityMask = mask;
            }

            var group = (GeometryGroup) ((GeometryDrawing) ((DrawingBrush) animatedStrokeGrid.OpacityMask).Drawing)
                .Geometry;
            var center = StrokePointGeometry.Center;
            var x = StrokePointGeometry.RadiusX;
            var y = StrokePointGeometry.RadiusY;
            group.Children.Add(new System.Windows.Media.EllipseGeometry(center, x, y));
        }

如上面代码，在 StrokeGrid 上面添加一个 DrawingBrush 作为 OpacityMask 的内容，此时在 OpacityMask 上面的任何绘制，都会修改蒙层的内容

这就是整个的实现方法了

而有很多细节需要继续处理的，包括笔迹的颜色，以及动画的速度。动画的速度是靠时间决定的，也就是需要计算不同长度的几何笔迹所需的时间等。还有做动画的圆点的宽度和高度以及笔迹粗细。如果这是作为文档的，还需要考虑笔迹的保存等内容，而在给用户写的时候，还需要考虑撤销重做。更高级一点的是需要考虑一下音效等

以上其实就是来画手绘软件的手绘部分的 WPF 版的大概实现方法了，这是在 2018 的时候邵猛哥和我吹的时候告诉我的一个方法，详细请看 UWP 手绘视频创作工具技术分享系列

本文的代码放在 github 欢迎小伙伴访问

上海展盟网络科技有限公司的 gamebox 组件注入进程导致软件崩溃

Thu, 03 Dec 2020 08:22:29 +0000

在某些用户的设备上，会发现自己的软件会在启动之后过一段时间就崩溃了，一个可能的原因是自己的软件被其他广告软件注入了，如上海展盟网络科技有限公司的 gamebox 组件

一个已知问题是海展盟网络科技有限公司的 gamebox 组件将会进行进程注入，在一些软件的进程上，会因为 gamebox_shell.dll 访问了不可访问的内存后，引发 C0000005 错误被系统强行结束

因此如果软件崩溃了，可以尝试拿到 dump 文件，看是否有 gamebox_shell.dll 的存在，如果有，那么也许就是此问题了。调试方法如下

先下载微软极品工具箱 ProcDump

然后使用以下命令启动 procdump 程序

 procdump -ma -a 进程PID

上面的进程PID 可在软件启动后拼手速快速输入

拿到完整的几百兆的 DUMP 文件后，下载到开发人员计算机上“使用本机调试”

此时也许可以发现异常堆栈出在 gamebox_shell.dll 中，如下图

或者尝试在用户的电脑上尝试找到 %appdata%\Heinote\gamebox 文件夹是否存在，如果存在，也许就是小黑记事本带了上海展盟网络科技有限公司的 gamebox_shell.dll 组件，此时尝试删除此软件和对应的文件。如果软件能正常，那么证明是此问题

以下是确定会带上海展盟网络科技有限公司的 gamebox 组件，同时会影响其他软件的软件：

可能还有更多软件会有此问题，因为他们贴了个合作方链接

以下是可能未确定是否会导致问题的软件列表：

蓝光护眼大师（卸载之后，需要手动删除 %appdata%\Heinote\gamebox 文件夹，是其中的迷你新闻带入）

以上这几个软件也许会让自己的软件在运行过程中没有处理好的情况下崩溃，本质来说和以上这些软件没有很大的关系，是自己的软件没有处理好。但是自己的软件要处理好，还是有一些难度的

细节

以下是给开发者看的内容

gamebox_shell.dll 是小黑记事本官方组件；
gamebox_shell.dll 不是使用 dll 注入技术完成的注入，而是 Shell 的 Icon Overlay 扩展，任何应用程序试图获取图标/缩略图时会自动将其加载到应用程序进程中；（目前尚不清楚其作为 Icon Overlay 的作用/目的）
gamebox_shell.dll 加载到程序中的崩溃代码不在获取图标/缩略图中，而是在额外执行的后台线程中；（目前尚不清楚其在后台线程执行的操作）
目前仅在 .NET Framework + WPF 的组合下才会崩溃，其他组合（.NET Core + WPF，.NET Core + 控制台，.NET Framework + 控制台，C++）都不会崩溃

通过 ShellExView 工具可以了解到 gamebox_shell.dll 使用 Shell 的 Icon Overlay 扩展进行注入，如图

默认从官网下载的小黑记事本软件不会带上 gamebox_shell.dll 组件，只有在触发了小黑记事本的自动更新之后，通过它下载的 Heinoteupdate_gw_001.exe 才带上了 gamebox_shell.dll 组件。通过下载的文件的软件签名可以了解到这两个包都是存在官方签名的

在桌面上留至少一个文件夹，然后使用 .NET Framework + WPF 的应用程序，尝试获取桌面图标，此时将会被注入，然后应用程序闪退。最简 demo 放在 github 欢迎小伙伴下载

和展盟网络科技的小伙伴沟通之后，了解到这是旧版本的问题，将会在 3.2.2.1 新版本解决

解决方法

以下方法任选一项

尝试更新快压到 3.2.2.1 新版本
删除和卸载 gamebox_shell.dll 相关软件
使用 ShellExView 工具删除 gamebox_shell.dll 组件
使用跨进程方式获取桌面图标

WPF 自己封装 Skia 差量绘制控件

Thu, 03 Dec 2020 08:22:29 +0000

使用 Skia 能做到在多个不同的平台使用相同的一套 API 绘制出相同界面效果的图片，可以将图片绘制到应用程序的渲染显示里面。在 WPF 中最稳的方法就是通过 WriteableBitmap 作为承载绘制。本文告诉大家如何封装一个支持差量绘制的控件，默认的绘制方法都是每次都是不保存上次绘制的内容，而且清空画布，重新绘制。这样的绘制方法显然效率不够高

在上一篇博客里面告诉大家如何在 WPF 中使用 Skia 绘制，请看 WPF 使用 Skia 绘制 WriteableBitmap 图片

而这样的绘制方式意味着每次都需要重新绘制画布，而不能在原有上一次绘制的基础上绘制新的内容。其实在 Skia 的 SKSurface 是不需要每次绘制完成就释放，可以保存他的值

只是需要注意和 WriteableBitmap 图片一起使用时，需要在绘制之前调用 Lock 方法，在绘制完成之后调用 Unlock 方法

此时就可以实现在相同的 SKSurface 上重复上次绘制的内容。而如果能了解绘制的界面范围的话，可以使用 WriteableBitmap 的 AddDirtyRect 方法，通过这个方法可以让 WPF 层仅更新指定范围的内容

虽然 Skia 和 WPF 两个的绘制效率都很高，但是在 WriteableBitmap 里面一定存在内存和显存的拷贝，这部分虽然在 DirtyRect 很小的时候几乎不耗性能，但是如果是在 4k 下完全重新绘制，还是稍微有点伤的。只是稍微有点

在使用 WriteableBitmap 作为 Skia 的承载，就需要再来一步，让 WriteableBitmap 在界面绘制。在 WPF 中最简单的绘制 WriteableBitmap 的方法就是使用 Image 控件了

下面写一个继承 Image 控件的 SkiaCanvas 控件

这个控件十分简单，在 Loaded 事件里面将会创建 WriteableBitmap 和 SKSurface 两个字段，请看代码

    public class SkiaCanvas : Image
    {
        public SkiaCanvas()
        {
            Loaded += SkiaCanvas_Loaded;
        }

        private void SkiaCanvas_Loaded(object sender, RoutedEventArgs e)
        {
            var writeableBitmap = new WriteableBitmap(PixelWidth, PixelHeight, 96, 96, PixelFormats.Bgra32,
                BitmapPalettes.Halftone256Transparent);

            _writeableBitmap = writeableBitmap;

            var skImageInfo = new SKImageInfo()
            {
                Width = PixelWidth,
                Height = PixelHeight,
                ColorType = SKColorType.Bgra8888,
                AlphaType = SKAlphaType.Premul,
                ColorSpace = SKColorSpace.CreateSrgb()
            };

            SKSurface surface = SKSurface.Create(skImageInfo, writeableBitmap.BackBuffer);
            _skSurface = surface;

            Source = writeableBitmap;
        }

        private WriteableBitmap _writeableBitmap = null!; // 这里的 null! 是 C# 的新语法，是给智能分析用的，表示这个字段在使用的时候不会为空
        private SKSurface _skSurface = null!; // 实际上 null! 的含义是我明确给他一个空值，也就是说如果是空也是预期的

        public int PixelWidth => (int) Width;
        public int PixelHeight => (int) Height;
    }

也就是说在使用 SkiaCanvas 控件的时候，需要先设置他的宽度和高度，也不支持后续更改哈

在创建完成了 SKSurface 字段，就可以通过调用他的绘制方法在 WriteableBitmap 上绘制内容。不过在绘制之前需要调用 Lock 等方法，在输入绘制命令完成之后需要调用更新的代码，这部分代码可以封装一个方法

        public void Draw(Action<SKCanvas> action)
        {
            Draw(canvas =>
            {
                action(canvas);
                return null;
            });
        }

        public void Draw(Func<SKCanvas, Int32Rect?> draw)
        {
            var writeableBitmap = _writeableBitmap;
            writeableBitmap.Lock();

            var canvas = _skSurface.Canvas;
            var dirtyRect = draw(canvas);
            canvas.Flush();

            dirtyRect ??= new Int32Rect(0, 0, PixelWidth, PixelHeight);

            writeableBitmap.AddDirtyRect(dirtyRect.Value);
            writeableBitmap.Unlock();
        }

也就是调用 Draw 方法，传入具体的绘制逻辑就可以完成绘制了。这部分的绘制逻辑有一个优势在于不需要等待绘制时机，随时都可以进行绘制。而 WPF 将会在框架层的绘制命令收集时自动更新和收集。或者换句话说，这里的绘制逻辑有坑在于不能做到对准界面更新

上面这个方法是提供差量更新的，也就是每次绘制的内容都会在上一次画布的基础上继续绘制

下面写一点代码试试，在鼠标划过应用时，绘制出鼠标划过的点，将这些点连为线

如果没有差量更新，也就是需要咱自己去存放记录之前鼠标划过哪些点，在有差量更新的辅助就可以只记录上一次的一个点

在 XAML 代码添加如下代码

    <Grid MouseMove="UIElement_OnMouseMove">
        <Grid.RowDefinitions>
            <RowDefinition></RowDefinition>
            <RowDefinition Height="Auto"></RowDefinition>
        </Grid.RowDefinitions>
        <local:SkiaCanvas x:Name="Image" Width="1920" Height="1080" Margin="10,10,10,10"></local:SkiaCanvas>
    </Grid>

上面代码给 SkiaCanvas 一个固定的宽度和高度，为什么需要给他这个值，在上文告诉了大家

接下来在 UIElement_OnMouseMove 方法，也就是 Grid 容器收到的鼠标划过的事件，将划过的点作为线段在画布中

        private void Draw(Action<SKCanvas> action)
        {
            Image.Draw(action);
        }

        private void UIElement_OnMouseMove(object sender, MouseEventArgs e)
        {
            var position = e.GetPosition(this);

            Draw(canvas =>
            {
                using var skPaint = new SKPaint() {Color = new SKColor(0, 0, 0), TextSize = 100};
                canvas.DrawLine(new SKPoint((float) _lastPosition.X, (float) _lastPosition.Y),
                    new SKPoint((float) position.X, (float) position.Y), skPaint);
            });

            _lastPosition = position;
        }

        private Point _lastPosition = new Point(0, 0);

可以看到逻辑十分简单，如果我需要让画布重新绘制，可以调用 Clear 方法，请看代码

        private void Button_OnClick(object sender, RoutedEventArgs e)
        {
            Draw(canvas =>
            {
                canvas.Clear();
                using var skPaint = new SKPaint() {Color = new SKColor(0, 0, 0), TextSize = 100};
                canvas.DrawLine(10, 10, 100, 100, skPaint);
            });
        }

因此这个控件就支持重新绘制和差量更新绘制内容的功能

如果每次都能返回具体更新的范围，那么这个控件的绘制效率还是不错的

本文的代码放在 github 欢迎小伙伴访问

更多 WPF 渲染请看渲染相关

WPF 底层从手指触摸屏幕到笔迹在屏幕显示中间的步骤

Thu, 03 Dec 2020 08:22:29 +0000

整个 WPF 就是一个UI框架，一个 UI 框架最重要的是交互和显示部分，而书写这个功能将会完全贯穿 WPF 整个框架的功能。本文非入门级博客，本文包含了大量链接博客，阅读本文你将会了解从用户手指触摸屏幕到最终屏幕打印出笔迹的应用程序执行的步骤

本文实际内容不多，但是如果加上链接的博客，那么总内容将会非常多，还请小伙伴仔细阅读本文链接的博客

从软件的角度上，可以将触摸屏看成是一个软件制作的驱动组件，因此就可以规避复杂的硬件带来的问题。当前的触摸是有 HID 标准的，任何走标准 HID 设备的硬件设备，只要实现得对，咱上层软件是不需要关注硬件的细节的。更多有关协议部分请看 Windows 的 Pen 协议

规避了硬件设备，此时咱就不需要画精力去了解硬件设备的收集触摸点的机制，以及封装数据和系统的解包是如何做的

在 WPF 的触摸在系统最底层使用的是 RealTime Stylus 机制实现，这个机制能达到比 WM_Touch 触摸消息快非常多倍的接收速度，基本可以认为硬件设备发送到系统瞬间就到应用程序上，中间过程仅有发生几次锁和读取内存数据的时间。从 RealTime Stylus 到 WPF 框架经过 PenIMC 模块，请看 WPF 触摸底层 PenImc 是如何工作的

而 WPF 尽管可以在 Stylus Input 线程使用 PenThreadWorker 通过 RealTime Stylus 机制快速获取触摸点，但是 WPF 为了让业务逻辑更好实现，此时将会在在主线程触发 Touch 或 Stylus 事件。因此如果监听 Touch 等这些事件，那么将需要等待线程切换和等待主线程忙碌。因此高性能的笔迹实现推荐通过 StylusPlugIn 的方法，在触摸线程获取触摸点，详细请看 WPF 高速书写 StylusPlugIn 原理

从 WPF 使用 PenIMC 在 WISPTIS 服务获取 RealTime Stylus 到 StylusPlugIn 收到消息或在 Touch 等事件收到消息，请看 WPF 触摸到事件

这就是需要涉及整个 WPF 的命中测试以及触摸输入机制，这也就是从手指触摸到屏幕到 WPF 框架将信息给业务层的步骤。还请小伙伴阅读本文的链接博客，本文接下来来和小伙伴聊聊下半部分的逻辑

在业务层收到了触摸的信息，如何转换为笔迹对象？首先笔迹的本质绘制就是将输入的离散的点，绘制成为 Geometry 几何加入到 WPF 的渲染中

在 WPF 中提供了 Stroke 类用于协助以上计算，通过给 Stroke 输入离散的点，可以通过调用 Stroke 的 Draw 方法，向某个 DrawingContext 绘制出 Geometry 的笔迹内容。这部分的逻辑很简单，请看 WPF 最简逻辑实现多指顺滑的笔迹书写

在绘制到某个 Visual 里面之后，需要将 Visual 加入到 WPF 的视觉树中，在 WPF 的渲染机制里面，将会依据视觉树上的元素的更改刷新视觉树的渲染内容。这部分细节请看 WPF 渲染原理

而此时离屏幕渲染依然还有一段路线，在 WPF 通过 MIL 层，给出 Geometry 的绘制原语之后，将会和 WPF 界面的其他元素，如按钮文字等等在渲染线程合成为 DirectX 渲染图元，交给 DirectX 底层执行绘制。而其实在进行输出渲染图元这个步骤就算是进入了 DirectX 渲染管线部分，后续渲染管线的工作请看细说图形学渲染管线

但事实上不是 WPF 将绘制原语准备好之后，就会调用绘制调用 Draw Call 指令，显卡就会进行工作，为了让整体效率最高，系统层或者说 DirectX 将会打包多个 Draw call 指令，一次交给 GPU 去渲染

而经过了渲染管线之后是否就能在屏幕上实际显示？其实不然，还需要经过 DWM 桌面窗口管理器的调度，将多个窗口的画面合成之后在交给显卡的缓冲区，等待屏幕刷新

这就是整个的步骤

从这个步骤了解上，可以理解高性能笔迹原理的内容

那开发者端能控制的部分包括哪些？首先是获取触摸的逻辑，可以选择从上层的 Touch 或 Stylus 事件获取触摸消息，也可以选择从底层的 StylusPlugIn 获取，当然也可以选择禁用实时触摸通过 WM_Touch 消息获取触摸。不过采用 WM_Touch 就需要使用 WPF 模拟触摸设备的方法

如果硬件触摸框是可以定制的，那么也可以通过 USB 读取 HID 的方式拿到触摸框原始信息

其次就是如何绘制笔迹的方式，此时可以利用 WPF 框架提供的笔迹绘制算法，在完全开源的 WPF 框架里面，可以看到有一个大文件夹很多代码用来实现一个看起来比较顺滑的笔迹。小伙伴也可以去抄 WPF 的源代码自己魔改

然后笔迹的绘制方式基本上可以选 Geometry 或 Image 的方式，加入到视觉树中，或者重绘已有位图的方式

接着在进入 DX 渲染管线部分，可以使用 WPF 的 Effect 机制，通过 HLSL 对画面显示进行优化，这部分属于像素着色器的知识

WPF 框架全构建环境虚拟机硬盘分享

Thu, 03 Dec 2020 08:22:29 +0000

现在 WPF 完全开源了，咱可以构建自己私有的版本。我分享一个虚拟机硬盘给你，只要你下载下来，通过 VMWare 导入，即可无需任何配置，拿到一个能构建 WPF 官方源代码的全构建环境。可以用来只做你的定制版的 WPF 框架

现在 WPF 完全开源，但是构建的过程中需要用到很多工具，这些工具和 VS 环境相对来说需要一段时间才能拉下来，再加上每个小伙伴有趣的定制，也许会忘记安装复杂的 C++ 环境。因此我就拜托了太子帮我做一个虚拟机，我在虚拟机里面添加了 WPF 框架的全构建环境，同时构建 WPF 源代码通过之后，将硬盘保存起来，只需要 VMWare 导入此硬盘即可拿到全构建环境

百度网盘链接

链接：https://pan.baidu.com/s/1_p5xdtG1wayI7tzqGfCL2w

提取码：gk99

如果百度下载太慢，可以尝试开启 P2P 模式：

或者可以尝试使用磁力链接1 或磁力链接2 用 BT 软件下载

在 VMWare 最新版本，版本最低是 15.5 版本，导入虚拟机硬盘，然后启动虚拟机。此时将会打开一个 win10 系统，这个系统里面将包含社区版的 VS 以及构建 WPF 需要的工具包。如需独立下载 WPF 构建套件，请点击 WPF 构建套件 .tools 3.1.7z 下载完成之后解压缩文件到 WPF 仓库的 .tools 文件夹里面

这个系统的用户名是 dotnet-wpf 密码是 wpf 进入之后，里面仅有 WPF 源代码和构建环境

完全的 WPF 仓库放在 C:\Code\WPF 这个仓库已经构建通过

构建命令是 build.cmd -pack -ci -configuration Release -prepareMachine /p:Platform=x86 在 artifacts\packages\Release 文件夹可以找到构建完成输出文件

附磁力链接地址，如第一个用户找不到，可以添加 torrent.walterlv.com:36690 用户

// 磁力链接1 纯硬盘文件 58G 文件

magnet:?xt=urn:btih:6B489EEDA460298F10498D13C48D9B46FE175F1D&dn=Windows_10_x64_for_WPF&tr=http%3a%2f%2ftorrent.walterlv.com%3a36690%2fannounce&tr=udp%3a%2f%2ftracker.opentrackr.org%3a1337%2fannounce&tr=http%3a%2f%2fp4p.arenabg.com%3a1337%2fannounce&tr=http%3a%2f%2ftracker3.itzmx.com%3a6961%2fannounce&tr=http%3a%2f%2ftracker1.itzmx.com%3a8080%2fannounce&tr=http%3a%2f%2ftracker.zerobytes.xyz%3a1337%2fannounce&tr=http%3a%2f%2ftracker.nyap2p.com%3a8080%2fannounce&tr=http%3a%2f%2fopentracker.i2p.rocks%3a6969%2fannounce&tr=http%3a%2f%2fh4.trakx.nibba.trade%3a80%2fannounce&tr=udp%3a%2f%2fexplodie.org%3a6969%2fannounce&tr=http%3a%2f%2fvps02.net.orel.ru%3a80%2fannounce&tr=http%3a%2f%2ftrun.tom.ru%3a80%2fannounce&tr=http%3a%2f%2ftracker2.dler.org%3a80%2fannounce&tr=http%3a%2f%2ftracker.yoshi210.com%3a6969%2fannounce&tr=http%3a%2f%2ftracker.ygsub.com%3a6969%2fannounce&tr=http%3a%2f%2ftracker.sloppyta.co%3a80%2fannounce&tr=http%3a%2f%2ftracker.skyts.net%3a6969%2fannounce&tr=http%3a%2f%2ftracker.lelux.fi%3a80%2fannounce&tr=http%3a%2f%2ftracker.gbitt.info%3a80%2fannounce&tr=http%3a%2f%2ftracker.dler.org%3a6969%2fannounce&tr=http%3a%2f%2ftracker.bt4g.com%3a2095%2fannounce&tr=http%3a%2f%2ft3.leech.ie%3a80%2fannounce&tr=http%3a%2f%2ft2.leech.ie%3a80%2fannounce&tr=http%3a%2f%2ft1.leech.ie%3a80%2fannounce&tr=http%3a%2f%2ft.overflow.biz%3a6969%2fannounce&tr=http%3a%2f%2ft.nyaatracker.com%3a80%2fannounce&tr=http%3a%2f%2fretracker.sevstar.net%3a2710%2fannounce&tr=http%3a%2f%2fpow7.com%3a80%2fannounce&tr=http%3a%2f%2fopen.acgtracker.com%3a1096%2fannounce&tr=http%3a%2f%2fopen.acgnxtracker.com%3a80%2fannounce&tr=http%3a%2f%2fmail2.zelenaya.net%3a80%2fannounce&tr=http%3a%2f%2faaa.army%3a8866%2fannounce&tr=http%3a%2f%2ftracker4.itzmx.com%3a2710%2fannounce&tr=http%3a%2f%2ftracker2.itzmx.com%3a6961%2fannounce&tr=http%3a%2f%2ftracker.shittyurl.org%3a80%2fannounce&tr=http%3a%2f%2ft.acg.rip%3a6699%2fannounce

// 磁力链接2 压缩档 7z 压缩 22G 文件

magnet:?xt=urn:btih:2580F4E5E2B56FEC2B64B48585B6F9DD8B9D1B76&dn=Windows_10_x64_for_WPF.7z&tr=http%3a%2f%2ftorrent.walterlv.com%3a36690%2fannounce&tr=udp%3a%2f%2ftracker.opentrackr.org%3a1337%2fannounce&tr=http%3a%2f%2fp4p.arenabg.com%3a1337%2fannounce&tr=http%3a%2f%2ftracker3.itzmx.com%3a6961%2fannounce&tr=http%3a%2f%2ftracker1.itzmx.com%3a8080%2fannounce&tr=http%3a%2f%2ftracker.zerobytes.xyz%3a1337%2fannounce&tr=http%3a%2f%2ftracker.nyap2p.com%3a8080%2fannounce&tr=http%3a%2f%2fopentracker.i2p.rocks%3a6969%2fannounce&tr=http%3a%2f%2fh4.trakx.nibba.trade%3a80%2fannounce&tr=udp%3a%2f%2fexplodie.org%3a6969%2fannounce&tr=http%3a%2f%2fvps02.net.orel.ru%3a80%2fannounce&tr=http%3a%2f%2ftrun.tom.ru%3a80%2fannounce&tr=http%3a%2f%2ftracker2.dler.org%3a80%2fannounce&tr=http%3a%2f%2ftracker.yoshi210.com%3a6969%2fannounce&tr=http%3a%2f%2ftracker.ygsub.com%3a6969%2fannounce&tr=http%3a%2f%2ftracker.sloppyta.co%3a80%2fannounce&tr=http%3a%2f%2ftracker.skyts.net%3a6969%2fannounce&tr=http%3a%2f%2ftracker.lelux.fi%3a80%2fannounce&tr=http%3a%2f%2ftracker.gbitt.info%3a80%2fannounce&tr=http%3a%2f%2ftracker.dler.org%3a6969%2fannounce&tr=http%3a%2f%2ftracker.bt4g.com%3a2095%2fannounce&tr=http%3a%2f%2ft3.leech.ie%3a80%2fannounce&tr=http%3a%2f%2ft2.leech.ie%3a80%2fannounce&tr=http%3a%2f%2ft1.leech.ie%3a80%2fannounce&tr=http%3a%2f%2ft.overflow.biz%3a6969%2fannounce&tr=http%3a%2f%2ft.nyaatracker.com%3a80%2fannounce&tr=http%3a%2f%2fretracker.sevstar.net%3a2710%2fannounce&tr=http%3a%2f%2fpow7.com%3a80%2fannounce&tr=http%3a%2f%2fopen.acgtracker.com%3a1096%2fannounce&tr=http%3a%2f%2fopen.acgnxtracker.com%3a80%2fannounce&tr=http%3a%2f%2fmail2.zelenaya.net%3a80%2fannounce&tr=http%3a%2f%2faaa.army%3a8866%2fannounce&tr=http%3a%2f%2ftracker4.itzmx.com%3a2710%2fannounce&tr=http%3a%2f%2ftracker2.itzmx.com%3a6961%2fannounce&tr=http%3a%2f%2ftracker.shittyurl.org%3a80%2fannounce&tr=http%3a%2f%2ft.acg.rip%3a6699%2fannounce

如不知道如何使用磁力链接…… 请使用百度网盘，如百度网盘链接炸了，请发邮件给我

一些问答

是不是在 2020 我才可以看到 WPF 的源代码，之前不可以？

答：不是的，在 2016 的时候 WPF 就开放了源代码，但开放源代码不等于开源，仅仅只是让你可以看到源代码

仅开放源代码是不是不能构建通过？

答：也可以，在 2017 的时候德熙魔改一点代码构建通过了，也做了私有的版本。但因为我的技术有限，此时的私有版本必须依赖原有的 WPF 框架

现在 WPF 是否完全开源？

答：是的，全部框架代码以及构建方法完全开源。现在是 2020.07 官方关于测试部分还没有完全开源，但是测试部分不影响咱构建私有版本

是否可以基于 WPF 开发自己的 UI 框架？

答：是的，没有任何法务问题。可以改现有的 WPF 框架作为自己的私有的 UI 框架，同时这个 UI 框架你可以对外发布获取商业价值。仅有一点不能做的是在这个 UI 框架上面声明微软相关商标

现在WPF是否属于微软的？

答：不是的，现在 WPF 属于 dotnet 基金会，微软只是其中一个成员。其实咱很难理解微软的做法，辛苦开发了这么久的框架，就完全开源出去了，属权也让出去了

如果添加了自己的代码的私有版本，是否后续难以维护？

答：如果是小功能，或独立模块，之后合并官方的更改难度不大。如果你还能提回官方的话，那就更好了

为什么我提到官方的 MR 还没有被合并，是不是 WPF 不维护了？

答：不是的，如上面的回答，现在 WPF 的测试部分还没有开源。在测试没有准备好之前，来自社区的 PR 暂时只合并没有 IL 更改的代码。官方没有合并代码不意味着你不能使用你的代码，依然可以构建自己的私有版本

WPF 用 AvalonEdit 开发简单的代码编辑器支持高亮自动提示

Thu, 03 Dec 2020 08:22:29 +0000

用 WPF 开发一个代码编辑器的难度很低，因为行业里面有很多小伙伴开发过，这些小伙伴将自己的代码开源了，发布到 NuGet 上，所以让我开发一个代码编辑器的难度实在太低。在不要有奇特的要求情况下，通过 AvalonEdit 可以快速开发出自己想要的代码编辑器

第一步通过 NuGet 安装 AvalonEdit 打开 xaml 界面，添加控件，此时可以在界面设置代码高亮方式等

        <avalonEdit:TextEditor
            xmlns:avalonEdit="http://icsharpcode.net/sharpdevelop/avalonedit"
            Name="TextEditor"
            SyntaxHighlighting="C#"
            FontFamily="Consolas"
            FontSize="10pt" 
            LineNumbersForeground="Black" 
            ShowLineNumbers="True">
            <avalonEdit:TextEditor.Options>
                <avalonEdit:TextEditorOptions ShowSpaces="True" >
                    <avalonEdit:TextEditorOptions.ColumnRulerPosition>
                        <system:Int32>10</system:Int32>
                    </avalonEdit:TextEditorOptions.ColumnRulerPosition>
                </avalonEdit:TextEditorOptions>
            </avalonEdit:TextEditor.Options>
        </avalonEdit:TextEditor>

下面是详细一点的参数含义

第二句话的 xmlns:avalonEdit="http://icsharpcode.net/sharpdevelop/avalonedit" 是命名空间

设置 AvalonEdit 进行代码高亮，可以自定义高亮颜色等，设置对 C# 代码进行高亮方法是 SyntaxHighlighting="C#" 而对 xml 高亮的方法自然就是将 C# 修改为 XML 请看代码

            SyntaxHighlighting="XML"

设置 AvalonEdit 的代码字体和大小分别是 FontFamily 和 FontSize 属性

很多代码编辑器都有行号，通过 ShowLineNumbers 属性让自己用 WPF 写的代码编辑器可以显示行号

ShowLineNumbers="True"

作为代码编辑器，还有一项功能是需要将空格用 · 显示，通过设置 TextEditorOptions 的方法

            <avalonEdit:TextEditor.Options>
                <avalonEdit:TextEditorOptions ShowSpaces="True" >
                    <avalonEdit:TextEditorOptions.ColumnRulerPosition>
                        <system:Int32>10</system:Int32>
                    </avalonEdit:TextEditorOptions.ColumnRulerPosition>
                </avalonEdit:TextEditorOptions>
            </avalonEdit:TextEditor.Options>

代码对齐很重要，最简单的代码对齐就是继承上一行的空格数量，通过下面属性让 AvalonEdit 支持设置继承上一行的行首空格

            <avalonEdit:TextEditor.Options>
                <avalonEdit:TextEditorOptions ShowSpaces="True" WordWrapIndentation="4" InheritWordWrapIndentation="true">
                    <avalonEdit:TextEditorOptions.ColumnRulerPosition>
                        <system:Int32>10</system:Int32>
                    </avalonEdit:TextEditorOptions.ColumnRulerPosition>
                </avalonEdit:TextEditorOptions>
            </avalonEdit:TextEditor.Options>

作为代码编辑器，如何能不自动提示？自动提示也就是用户输入特殊字符时，如空格和 . 提示用户可以输入的内容

在用户输入特殊字符触发特定事件可以通过下面代码

        public MainWindow()
        {
            InitializeComponent();
            TextEditor.TextArea.TextEntered += TextAreaOnTextEntered;
        }

        private void TextAreaOnTextEntered(object sender, TextCompositionEventArgs e)
        {
            if (e.Text == ".")
            {
            }
        }

上面代码将会在用户输入 . 进入判断

在 AvalonEdit 通过 CompletionWindow 类做到代码自动补全，需要先自己继承 ICompletionData 接口创建提示数据

    public class CompletionData : ICompletionData
    {
        public CompletionData(string text)
        {
            Text = text;
        }

        public ImageSource Image => null;

        public string Text { get;  }

        public object Content => Text;

        public object Description => "Description for " + this.Text;

        /// <inheritdoc />
        public double Priority { get; }

        public void Complete(TextArea textArea, ISegment completionSegment,
            EventArgs insertionRequestEventArgs)
        {
            textArea.Document.Replace(completionSegment, Text);
        }
    }

基本上看到参数大家都理解这是用来做什么

创建CompletionWindow然后显示代码如下

        private void TextAreaOnTextEntered(object sender, TextCompositionEventArgs e)
        {
            if (e.Text == ".")
            {
                _completionWindow = new CompletionWindow(TextEditor.TextArea);

                var completionData = _completionWindow.CompletionList.CompletionData;
                completionData.Add(new CompletionData("林德熙是逗比"));
                _completionWindow.Show();

                _completionWindow.Closed += (o, args) => _completionWindow = null;
            }
        }

        private CompletionWindow _completionWindow;

大概的效果如下

本文的代码放在 github 欢迎小伙伴访问

WPF 开启Pointer消息存在的坑

Thu, 03 Dec 2020 08:22:29 +0000

本文记录在 WPF 开启 Pointer 消息的坑

屏幕键盘

启用了Pointer之后，调用Textbox.Focus()，起不来屏幕键盘，必须点在它之上才行，触摸在它之上才行

使用屏幕绝对坐标而不是窗口坐标

默认 Pointer 消息是使用屏幕绝对坐标而不是窗口坐标

可能存在获取 Stylus 事件时触摸点不准，此时可以通过获取 Touch 代替，详细请看 WPF will have a touch offset after trun on the WM_Pointer message · Issue #3360 · dotnet/wpf 此问题应该在 Fix raw stylus data to support per-monitor DPI by rladuca · Pull Request #2891 · dotnet/wpf 修复

开启 Pointer 消息之后无法隐藏触摸反馈点

开启 Pointer 消息之后，调用 Stylus.IsPressAndHoldEnabled="False" 无效

在没有开启 Pointer 消息，将会在 System.Windows.Interop.HwndSource 的 Initialize 方法通过判断是否开启 Pointer 消息执行 HwndStylusInputProvider 逻辑

            if (StylusLogic.IsStylusAndTouchSupportEnabled)
            {
                // Choose between Wisp and Pointer stacks
                if (StylusLogic.IsPointerStackEnabled)
                {
                	// 开启 Pointer 的逻辑
                    _stylus = new SecurityCriticalDataClass<IStylusInputProvider>(new HwndPointerInputProvider(this));
                }
                else
                {
                    _stylus = new SecurityCriticalDataClass<IStylusInputProvider>(new HwndStylusInputProvider(this));
                }
            }

在 HwndStylusInputProvider 将会读取 IsPressAndHoldEnabledProperty 属性，然后使用 WM_TABLET_QUERYSYSTEMGESTURESTATUS 返回 1 的方式告诉系统不显示触摸反馈点。也就是 WPF 隐藏触摸反馈点是通过 How do I disable the press-and-hold gesture for my window 的方法

如果不设置 Stylus.IsPressAndHoldEnabled="False" 也可以自己手动监听消息，在消息 WM_TABLET_QUERYSYSTEMGESTURESTATUS 里面返回 1 就可以告诉系统不显示触摸反馈点

       private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam, ref bool handled)
        {
            const int WM_TABLET_DEFBASE =0x02C0;
            const int WM_TABLET_QUERYSYSTEMGESTURESTATUS = WM_TABLET_DEFBASE + 12;
            const int WM_TABLET_FLICK = WM_TABLET_DEFBASE + 11;

            if (msg == WM_TABLET_QUERYSYSTEMGESTURESTATUS)
            {
                uint flags = 0;

                flags |= TABLET_PRESSANDHOLD_DISABLED;
                flags |= TABLET_TAPFEEDBACK_DISABLED;
                flags |= TABLET_TOUCHUI_FORCEON;
                flags |= TABLET_TOUCHUI_FORCEOFF;
                flags |= TABLET_FLICKS_DISABLED;

                handled = true;
                return new IntPtr(flags);
            }
            else if (msg == WM_TABLET_FLICK)
            {
                handled = true;
                return new IntPtr(1);
            }

            return IntPtr.Zero;
        }

        private const uint TABLET_PRESSANDHOLD_DISABLED = 0x00000001;
        private const uint TABLET_TAPFEEDBACK_DISABLED = 0x00000008;
        private const uint TABLET_TOUCHUI_FORCEON = 0x00000100;
        private const uint TABLET_TOUCHUI_FORCEOFF = 0x00000200;
        private const uint TABLET_FLICKS_DISABLED = 0x00010000;

但如果开启了 Pointer 消息，那么这个机制将会无效，即使依然是手动监听消息，如 https://github.com/lindexi/lindexi_gd/tree/81b2a63a/KemjawyecawDurbahelal 的代码，也是无效的

问题报告给了 WPF 官方，请看 WPF can not work well with set IsPressAndHoldEnabled to false when enable pointer message · Issue #3379 · dotnet/wpf 但预计不会在 WPF 中修复，原因是这是 Windows 的 WM_Pointer 机制的坑，和 WPF 其实没有关系

另一个解决方法是在关闭系统全局触摸反馈点，关闭方法请看 3 Ways to Enable or Disable Touch Feedback in Windows 10

How do I disable the press-and-hold gesture for my window

WM_TABLET_QUERYSYSTEMGESTURESTATUS message (Tpcshrd.h)

WM_TABLET_FLICK message (Tpcshrd.h)

c# - Calling SetGestureConfig method affects onmousemove override of control - Stack Overflow

SetGestureConfig 函数-中文整理_Augusdi的专栏-CSDN博客

WPF 源代码资源字典 ResourceDictionary 设置 Source 属性的逻辑

Thu, 03 Dec 2020 08:22:28 +0000

本文来和大家聊聊在 WPF 里面在给 ResourceDictionary 设置 Source 属性时，在 WPF 框架里面做了哪些逻辑

默认添加 Source 时都是指定 WPF 自身的 XAML 资源字典，用途就是指定 XAML 字典作为此控件的资源字典

而默认的 XAML 资源字典使用 Page 形式进行构建，构建之后作为二进制的 Baml 文件被打入程序集中作为程序集资源，在 dotnet 里面有专门的程序集 System.IO.Packaging 来解析程序集资源

而给 Source 属性赋值的时候，给的是一个 Uri 类型的变量，那么资源字典 ResourceDictionary 是如何通过 Uri 拿到对应的内容的？其实在 WPF 的 ResourceDictionary 的 Source 属性赋值里面有很长的一段逻辑，如下面代码，请大家快速跳过，这些代码只是用来告诉大家，在 WPF 里面使用了很多代码来处理这部分逻辑

        public Uri Source
        {
            get
            {
                return _source;
            }
            set
            {
                if (value == null || String.IsNullOrEmpty(value.OriginalString))
                {
                    throw new ArgumentException(SR.Get(SRID.ResourceDictionaryLoadFromFailure, value == null ? "''" : value.ToString()));
                }

                ResourceDictionaryDiagnostics.RemoveResourceDictionaryForUri(_source, this);

                ResourceDictionarySourceUriWrapper uriWrapper = value as ResourceDictionarySourceUriWrapper;

                Uri sourceUri;

                // If the Uri we received is a ResourceDictionarySourceUriWrapper it means
                // that it is being passed down by the Baml parsing code, and it is trying to give us more
                // information to avoid possible ambiguities in assembly resolving. Use the VersionedUri
                // to resolve, and the set _source to the OriginalUri so we don't change the return of Source property.
                // The versioned Uri is not stored, if the version info is needed while debugging, once this method 
                // returns _reader should be set, from there BamlSchemaContext.LocalAssembly contains the version info.
                if (uriWrapper == null)
                {
                    _source = value;
                    sourceUri = _source;
                }
                else
                {
                    _source = uriWrapper.OriginalUri;
                    sourceUri = uriWrapper.VersionedUri;
                }
                
                Clear();
                
                
                Uri uri = BindUriHelper.GetResolvedUri(_baseUri, sourceUri);

                WebRequest request = WpfWebRequestHelper.CreateRequest(uri);
                WpfWebRequestHelper.ConfigCachePolicy(request, false);
                ContentType contentType = null;
                Stream s = null;

                try
                {
                     s = WpfWebRequestHelper.GetResponseStream(request, out contentType);
                }
                catch (System.IO.IOException)
                {
                     // 忽略细节处理的代码
                }

                // MimeObjectFactory.GetObjectAndCloseStream will try to find the object converter basing on the mime type.
                // It can be a sync/async converter. It's the converter's responsiblity to close the stream.
                // If it fails to find a convert, this call will return null.
                System.Windows.Markup.XamlReader asyncObjectConverter;
                ResourceDictionary loadedRD = MimeObjectFactory.GetObjectAndCloseStream(s, contentType, uri, false, false, false /*allowAsync*/, false /*isJournalNavigation*/, out asyncObjectConverter)
                                            as ResourceDictionary;

                if (loadedRD == null)
                {
                    throw new InvalidOperationException(SR.Get(SRID.ResourceDictionaryLoadFromFailure, _source.ToString()));
                }

                // ReferenceCopy all the key-value pairs in the _baseDictionary
                _baseDictionary = loadedRD._baseDictionary;

                // ReferenceCopy all the entries in the MergedDictionaries collection
                _mergedDictionaries = loadedRD._mergedDictionaries;

                // ReferenceCopy all of the deferred content state
                CopyDeferredContentFrom(loadedRD);

                // Take over the deferred resource references
                MoveDeferredResourceReferencesFrom(loadedRD);

                // Copy over the HasImplicitStyles flag
                HasImplicitStyles = loadedRD.HasImplicitStyles;

                // Copy over the HasImplicitDataTemplates flag
                HasImplicitDataTemplates = loadedRD.HasImplicitDataTemplates;

                // Copy over the InvalidatesImplicitDataTemplateResources flag
                InvalidatesImplicitDataTemplateResources = loadedRD.InvalidatesImplicitDataTemplateResources;

                // Set inheritance context on the copied values
                if (InheritanceContext != null)
                {
                    AddInheritanceContextToValues();
                }

                // Propagate parent owners to each of the acquired merged dictionaries
                if (_mergedDictionaries != null)
                {
                    for (int i = 0; i < _mergedDictionaries.Count; i++)
                    {
                        PropagateParentOwners(_mergedDictionaries[i]);
                    }
                }

                ResourceDictionaryDiagnostics.AddResourceDictionaryForUri(uri, this);

                if (!IsInitializePending)
                {
                    // Fire Invalidations for the changes made by asigning a new Source
                    NotifyOwners(new ResourcesChangeInfo(null, this));
                }
            }
        }

大概整理一下的在 Source 的 set 方法里面的逻辑大概如下

// 前置属性判断

// 清空当前资源字典的所有元素
Clear();

// 解析 Uri 获取资源
ResourceDictionary loadedRD = xx; // 这里的 loadedRD 就是 loadedR(esource)D(ictionary) 的意思

// 取出资源字典的值
_baseDictionary = loadedRD._baseDictionary;

// 取出资源字典加载的其他资源字典
_mergedDictionaries = loadedRD._mergedDictionaries;

// 其他杂项状态处理

可以看到上面代码的逻辑步骤其实很少，核心的逻辑就是解析 Uri 获取资源这部分

在开始获取资源之前，需要先将 Uri 转换为绝对路径，也就是说在 XAML 中写的 Uri 将会被补全

     _source = value;
     sourceUri = _source;
     Uri uri = BindUriHelper.GetResolvedUri(_baseUri, sourceUri);

这里拿到 uri 之后，通过调用 WpfWebRequestHelper 的方法拿到资源的 Stream 对象

WebRequest request = WpfWebRequestHelper.CreateRequest(uri);
WpfWebRequestHelper.ConfigCachePolicy(request, false);
ContentType contentType = null;
Stream s = null;

try
{
    s = WpfWebRequestHelper.GetResponseStream(request, out contentType);
}
catch
{
	// 忽略细节代码
}

看到了 WebRequest 请不要激动，这不代表一定会从网络上读取哦

因为这个 WebRequest 是使用 WpfWebRequestHelper 的 CreateRequest 拿到的 WebRequest 不一定是一个走网络的 WebRequest 哦，在 WpfWebRequestHelper 的 CreateRequest 方法里面，会根据 Uri 进行判断，假定是获取到一个在应用本地资源的路径，那么将使用 PackWebRequestFactory.CreateWebRequest 返回一个基于 System.IO.Packaging 的 PackWebRequest 对象。否则就是真的走网络了，因此给资源字典设置一个网络上的 Url 也是可以的

在 PackWebRequest 里面，其实就是一个继承了 WebRequest 的类，这个类的命名空间是 System.IO.Packaging 但是放在 PresentationCore 里面，是逻辑上属于 System.IO.Packaging 程序集，但实际上在 PresentationCore 程序集

在 PackWebRequest 通过重写 WebRequest 的方法，实现了实际上没有走网络，而是返回了 PackWebResponse 对象，在 PackWebResponse 里面就是读取程序集的资源作为 Stream 返回

因此调用 WpfWebRequestHelper 的 CreateRequest 方法创建的 WebRequest 在传入的是 uri 是一个本地的资源字典的时候，就是读取本地程序集资源返回 Stream 对象

读取到 Stream 之后需要进行解析，如下面代码

ResourceDictionary loadedRD = MimeObjectFactory.GetObjectAndCloseStream(s, contentType, uri, false, false, false /*allowAsync*/, false /*isJournalNavigation*/, out asyncObjectConverter) as ResourceDictionary;

此时拿到了 loadedResourceDictionary 也就是 loadedRD 变量，下一步就是取出里面的值

                // ReferenceCopy all the key-value pairs in the _baseDictionary
                _baseDictionary = loadedRD._baseDictionary;

                // ReferenceCopy all the entries in the MergedDictionaries collection
                _mergedDictionaries = loadedRD._mergedDictionaries;

此时就完成了资源字典的从 Uri 加载了

在资源字典里面，包含了两层内容，第一层的内容就是在这个资源字典里面定义的资源，这些资源放在了 private Hashtable _baseDictionary 里面。第二层内容就是 private ObservableCollection<ResourceDictionary> _mergedDictionaries 被这个资源字典合并的其他资源字典里面

因此在 WPF 中寻找资源是先从自己的 _baseDictionary 尝试获取资源，如获取不到在从 _mergedDictionaries 里面获取，如下面代码

        private object GetValueWithoutLock(object key, out bool canCache)
        {
            object value = _baseDictionary[key];
            if (value != null)
            {
                OnGettingValuePrivate(key, ref value, out canCache);
            }
            else
            {
                canCache = true;

                //Search for the value in the Merged Dictionaries
                if (_mergedDictionaries != null)
                {
                    for (int i = MergedDictionaries.Count - 1; (i > -1); i--)
                    {
                        // Note that MergedDictionaries collection can also contain null values
                        ResourceDictionary mergedDictionary = MergedDictionaries[i];
                        if (mergedDictionary != null)
                        {
                            value = mergedDictionary.GetValue(key, out canCache);
                            if (value != null)
                            {
                                break;
                            }
                        }
                    }
                }
            }

            return value;
        }

从上面代码可以看到，获取的时候是优先从 _baseDictionary 获取的。获取不到在从 MergedDictionaries 里面获取，最后添加的资源字典最先寻找。也就是说存在 Key 重复的资源的时候，会先从资源字典本身寻找，如果找不到就从合并的其他字典的最后一个资源字典开始寻找

这就是 WPF 资源字典设置的逻辑

当前整个 WPF 源代码都是开源的，请看 https://github.com/dotnet/wpf/

更多资源字典相关请看

WPF 已知问题窗口在屏幕外创建将不会刷新渲染

Thu, 03 Dec 2020 08:22:28 +0000

本文告诉大家一个 WPF 的已知问题，如果窗口在创建的时候，设置在屏幕外，那这个窗口将不会进行实际的渲染，将这个窗口从屏幕外移到屏幕内的时候，将会出现窗口内容的一次闪烁。换句话说就是存在窗口内容的重渲染

什么是窗口在屏幕外创建？简单说法就是窗口不在屏幕内，如窗口的 Top 或 Left 太大或太小等，如下面代码创建窗口，而我的屏幕没有那么大，因此窗口就显示在我的屏幕外

        private async void Button_OnClick(object sender, RoutedEventArgs e)
        {
            var window = new Window()
            {
                Background = Brushes.Gray,
                Height = 200,
                Width = 200,
                Top = 100000 // 手动高亮，我的屏幕没有那么大
            };

            window.Show();

            await Dispatcher.Yield();
            window.Top = 200;
        }

运行如上面代码，可以看到在 window.Top = 200; 调用的时候，将窗口从屏幕外移动到屏幕内时，窗口的背景从白色切换为灰色。如果你看不到，只能证明你的电脑性能太好了，换个渣设备试试

本文代码放在 github 欢迎小伙伴访问

如果你将设置窗口的位置，也就是设置 Top = 100000 // 手动高亮，我的屏幕没有那么大 放在 Show 之后的一个 Render 内，那么依然窗口闪烁

        private async void Button_OnClick(object sender, RoutedEventArgs e)
        {
            var window = new Window()
            {
                Background = Brushes.Gray,
                Height = 200,
                Width = 200,
            };

            window.Show();

            // 设置为 Render 优先级，那么用户将看到窗口显示然后消失
            //await Dispatcher.Yield(DispatcherPriority.Render);

            // 设置为 Normal 优先级，那么窗口依然没有渲染
            await Dispatcher.Yield(DispatcherPriority.Normal);

            window.Top = 100000; // 手动高亮，我的屏幕没有那么大

            await Task.Delay(TimeSpan.FromSeconds(1));
            window.Top = 200;
        }

如果放在 Render 外，此时用户就可以先看到窗口显示在屏幕上，然后窗口再消失，依然可以看到窗口闪烁。但是如果窗口能足够卡，也许此时很多设备都是看不到这个创建的窗口

dotnet 开发的单代码仓库和多代码仓库的优劣

Thu, 03 Dec 2020 08:22:28 +0000

在很多大团队开发的时候，将需要用到很多项目的组合开发一个软件，一个软件需要用到的项目有很多个，很少会用到一个项目就能做到。但多个项目一起开发，在配置管理和团队管理有不同的策略，一个就是让项目拆分为多个代码仓库，另一个就是将这些项目合在一个代码仓库。两个策略不能说哪个更好，本文和大家分享我所在的团队和我参与的其他团队的策略

单代码仓库的优势在于管理方便，将所有的项目都放在一个代码仓库里面，此时团队所有成员都可以方便了解所有的代码，可以减少很多重复的代码的编写。我参与的最大的一个单代码仓库的项目就是 dotnet runtime 这个 dotnet 的最基础库。在2018的时候，微软官方采用了多代码仓库的方法，此时官方遇到的问题是多个代码仓库之间的同步，同步包括引用同步以及发布同步都存在比较大的管理问题

因为 dotnet runtime 是支持全球任何开发者进行贡献，这些开发者之间属于不同的公司，沟通的难度比较高。此时带来的问题是引用同步的问题，如我的一个坑我需要在 CoreClr 先开启某个 API 然后在 Library 库使用这个 CoreCLR 的接口进行修复。此时我需要等待 CoreCLR 的合并然后等待发布，然后等待官方合入 Library 库，接着在 Library 库修复这个问题。如果坑的是我一次发现这样的开启的接口实际修复不了，需要再来一次，这就会哭了

我就尝试过这样玩了一次，经过了从超级长的时间，最后我放弃了

于是为了解决以上的问题，官方就将多个仓库合为一个 dotnet runtime 代码仓库。在合并之后又遇到了一些问题，此时的代码需要有强的代码审查解决耦合的问题。但是当前也逐渐的，整个 dotnet runtime 仓库的耦合度也相比之前大了一点，这个耦合度不好衡量，因此这句话也只是我认为的

另一个问题是在于 commit 的内容上，现在整个 PR 和 commit 的历史有包含了各个模块的逻辑，相对来说比较乱。虽然不是很多小伙伴都会关注这部分的内容

而相对于官方仓库有强大的程序员进行代码审查和解决大量的耦合问题，我所在的团队，有一个代号是 EN 的软件，这个软件里面开始有用到很多基础库，有一个代号是 EUI 的基础库是一个界面库，这个界面库被合到了 EN 的主代码仓库里面。合到主代码仓库是为了解决开发的时候进行频繁的改动的开发难度问题，小伙伴都知道 UI 是不断改改改的，如果改动的 UI 会涉及部分的业务逻辑的使用，例如我的某个业务逻辑用到了某个新的按钮的时候，此时如果按钮的样式定义在 UI 库里面和按钮的动画和一些有趣的逻辑都定义在UI库里面，在进行业务开发的时候就需要有部分是在进行 UI 库的更改。在进行新控件开发时是符合开发规范的，因此不知道这个新控件的业务边界，也为了更好的敏捷，因此不断根据业务更改是符合预期的。但是如果是多个代码仓库，就会存在这样的问题，在更改UI库时，需要同步到主代码仓库，而调试的时候更是坑。于是就决定将EUI这个库合入到主代码仓库里面

在合入之后经过了一段时间的开发，就发现了整个EUI库不能成为基础库了，这个库耦合了大量的业务逻辑等，也再也拆不出去了

此时其他的软件，如代号是 MH 的软件，和 CM 的软件，此时需要使用 EUI 库就做不到了

而 EN 这个软件还用到了其他组件库，如 Core 基础库，这个基础库就在独立的代码仓库里面，因为 Core 基础库是被很多个团队的很多个软件所使用的，被定义为所有项目都引用的基础库。此时如果想要将这个基础库合入到某个项目的代码仓库，是无法撕的决策，因为合到哪个代码仓库好？如合到你的团队的某个软件的代码仓库，那如果耦合了你的软件的业务我可不同意。我想要更改基础库的功能，我需要去你的团队项目去提代码合并，去占用你的团队开发者的代码审查时间，需要构建你的团队的代码创建 NuGet 库等，想想就了解这是一个坑

多个代码仓库的优势在于复用，如果有多个团队和多个软件，此时拆分代码仓库可以提升整体的效率。多个软件可以复用更多的逻辑，多个软件不会污染基础库。但是多个代码仓库一定会降低单个软件项目的开发效率，但长远说也许效率是提升的。为什么说长远说是提升的，因为分多个代码仓库就一定从逻辑上解决了耦合的问题，都不在相同的代码仓库，此时的耦合很难做到。不过也存在的问题是会有一些重复的代码，因为代码是放在不同的仓库里面，有些逻辑也许小伙伴们不知道，于是就将功能重复的实现多次

多个代码仓库的优势在于让代码独立，方便作为组件库。可以让多个软件的业务逻辑不会污染组件库，或者说组件库同时被多个软件的业务逻辑污染而做到通用。这句话需要用一个例子说明，我有组件库 Core 库，这个基础库的代码将会被超级多的项目使用，而这些项目除了共同点是 dotnet 的之外，有超级多的不同。如框架上有 .NET Framework 和 .NET Core 而 .NET Framework 有从 3.5 到 4.8 的不同版本，当然现在最低是 .NET 4.5 的支持了。而开发框架上有 WPF 和 WinForms 和 Xamarin 和 ASP.NET Core 和 Unity3D 等。业务范围是有教育、企业和游戏等，此时可以看到各个业务都会期望有底层库的支持。小伙伴可以了解到移动端的需求和 ASP.NET Core 的需求是不相同，而 Unity3D 又有不同的需求，需求不同在于移动端要求极高的启动性能，也就是任何需要占用启动过程的依赖注入就需要被拖出去扔掉。而移动端不看重运行时的依赖注入反射耗时，此时就和服务器端冲突，因为服务器端无视启动性能，但是要求每次对象创建的速度足够快。而游戏端要求对象创建数量的控制和内存的控制和垃圾回收次数，这两个刚好在移动端和服务器端都是不看重的。这几个需求合在一起就会让这个 Core 基础库不断磨，做到极高的启动性能，极高的对象创建速度，极低的对象创建和内存占用

用一个小的例子说明，我的基础库包含了日志模块，所有的项目都可以使用相同的日志接口模型，特别是其他基础库，此时可以在最顶层按照自己的需求定制日志。如果我的设计不够通用，如果我的这个 Core 基础库放在了某个软件的代码仓库里面，此时的设计理论上就会很难照顾到其他的项目。例如我就会尝试写了一段字符串序列化方法，只是用于我这个客户端业务的日志，而忽略了服务器端的格式规范。又例如我是将 Core 基础库放到某个服务端的软件代码仓库里面，这个服务端因为无视软件启动性能，可以在日志初始化的时候创建文件和文件夹，初始化日志服务器等。此时的 Core 基础库被用在客户端就发现日志模块占用了太多的启动性能

将基础库作为单独的代码仓库的优势就在于这里，尽管有自己的软件的业务需求，期望加入到基础库里面，但不同的团队都会去按照自己的需求去磨这个基础库，很少有完全冲突的需求，这些冲突都能找到解决方法，于是整个基础库就会不断强大

在多个团队都会使用相同的基础库，就会在代码审查的时候找到一些业务耦合，此时分开的多个代码仓库就可以让代码的质量更高。这句话说起来其实有点比较难理解，但是我也不敢在这里将某个团队项目作为例子在这里聊

但基础库分为多个代码仓库也如开始聊的，会存在开发效率的降低，包括代码引用的同步和调试的难度。我所在的团队了解决这几个问题，于是设计了一些规范，如通过推 Tag 打包的方法，详细请看 dotnet CBB 为什么决定推送 Tag 才能打包

多个代码仓库的代码引用问题是指我的某个功能需要多个代码仓库的多个库配合做到，例如我有功能需要 A 和 B 和 C 三个库同时更改才能做到，此时是 A 引用 B 而 B 引用 C 库，那么如何管理好这些同步依赖？我更改了 A 库，然后我在本地让 B 引用了 A 的我的本地开发路径，我更改了代码，调试完成，然后上传代码？这样做的坑在于这段代码将只有我才能构建通过，因为小伙伴没有我的本地开发路径

那换个方法，我让 B 引用了 A 的我的本地开发路径，但是我不上传 csproj 文件的更改？这个方法的坑在于如果有 API 变更，这个 commit 是构建不通过的，因为此时的 B 依然使用 A 的旧版本。而 commit 构建不通过对于回溯是神坑

于是一个解决方法是在更改 A 之后打包 NuGet 包让 B 引用，这个解决方法有两个坑是谁的 NuGet 包和如何回溯 NuGet 包对应的代码。解决这两个问题可以使用 Tag 号和 NuGet 版本号关联的方法解决。通过在本地创建 Tag 号推送服务器，让服务器触发打包，打出来的 NuGet 包对应 Tag 号，此时就能满足让服务器打包以及使用 Tag 关联代码和 NuGet 包版本。当然另一个方法是修改版本号文件，服务器打包 NuGet 之后自动创建 Tag 号

而多个代码仓库的调试问题可以通过一个强大的 VisualStudio 插件解决，请看 dotnet-campus/DllReferencePathChanger: VS DLL引用替换插件

这个插件能做到将 NuGet 引用替换为本地的开发路径，也就是我原先使用了 NuGet 引用了 A 库，我可以利用这个插件将 NuGet 引用替换为 csproj 的本地代码引用，此时就适合进行复杂的调试和大量的 API 更改

而这个插件的不足在于如果我只是想进行快速的调试底层库，用这个插件的效率不够，于是此时可以使用另一个工具 dotnet-campus/UsingMSBuildCopyOutputFileToFastDebug: 通过复制输出文件让 VisualStudio 外部启动快速调试底层库 Using MSBuild Copy Output File To Fast Debug

但无论这几个开发工具做的多好，对单个项目的开发效率都无法和单代码仓库相比

因此我的推荐是按照团队的规模和软件数量决定，将一部分足够独立的逻辑作为单独的代码仓库，而其他的都合在一起

读书笔记 dotnet 什么时候进行垃圾回收

Thu, 03 Dec 2020 08:22:28 +0000

是否有小伙伴好奇如果没有在代码调用垃圾回收，那么框架会在什么时候调用垃圾回收。本文是读还没出版的伟民哥翻译的 .NET内存管理宝典 - 提高代码质量、性能和可扩展性这本书的笔记

当前是 2020年9月本文的知识最新就是当前的时间，因为 dotnet 的更新速度十分快，当前由 dotnet 基金会维护整套 dotnet 开源项目。从编译器到运行时全部都是开源的，采用最友好的 MIT 开源协议，每个项目都会附带完全的构建脚本

在阅读到了伟民哥翻译的《.NET内存管理宝典 - 提高代码质量、性能和可扩展性》这本书，我了解到了更多的关于 dotnet 内存的细节，下面请让我给大家分享一下

是否有小伙伴好奇如果没有在代码调用垃圾回收，那么框架会在什么时候调用垃圾回收

在回答这个问题之前需要了解为什么需要进行垃圾回收？这是一个简单的问题，就是咱的内存不是无限量的，需要将不需要使用的内存回收。那么什么是不需要的内存？在 .NET 里面将会给对象分配一定的内存空间，这个类型在不被使用的时候，也就是没有任何代码或线程引用到这个对象的时候，那么这个对象占用的内存就可以回收，因为这个对象不会再被使用

那为什么垃圾回收不是立即的，有一个对象不被使用的时候就回收他的内存？因为框架不知道，一个对象啥时候不被使用是无法在运行时框架立刻知道的，除非是和 C++ 一样手动调用释放内存，或者和 Rust 语言一样对机器友好等。但是如小伙伴所了解这两个语言对开发者不够友好，而对开发者友好的 C# 语言是很难做到这一点，因此就做不到框架立刻知道对象不被使用。所以做不到立刻回收

那么刚才说的 C# 语言很难做到这一点，如果你足够强大，写出的代码能做到这一定，是否就可以立即回收内存？其实也不对，虽然你很强大，但是还有一个坑是内存碎片。内存碎片是因为不同的对象的占用的内存不一样大，而不同的对象被回收的时间不相同，这样就会让一段连续的内存空间，在程序不断使用，被分为很多段。也就是说内存有足够的空闲空间，但是分配不给一个新的对象的需要的空间，因为所有的足够的空闲空间都不连续

因此即使是需要手动释放内存的 C++ 和对机器十分友好的 Rust 语言也都存在这样的问题，在将对象占用的内存释放，还是不够的，需要在合适的时候减少内存的碎片。相对来说，这一点 .NET 的优化会比 C++ 和 Rust 等语言做的好非常多，当然上面这句话也需要看使用的开发者，如果有一个逗比足够逗比，大概有我这么逗比，那么依然可以让 .NET 做的足够渣

刚才为什么说需要在合适的时候减少内存的碎片，而不是说立即？想要回答这个问题，还需要小伙伴有一定的 C++ 基础或 C 的基础，因为在 .NET 系里面，是很难了解到有这样的坑的。在 C 和 C++ 里面最强的就是指针，但是这也是坑的地方。假如我需要减少内存碎片，那么最简单的方法就是压缩内存，压缩的方法就是将所有在使用的对象移动内存空间，让这些对象放在一起，此时空闲的内存空间和在使用的内存空间就分开了，此时也就没有了内存碎片。但是这个方法存在的问题是什么？对象的内存空间地址更改了，而在 C 和 C++ 里面的指针指向的如果是原先的对象的内存地址，在内存压缩时修改了对象的内存地址，这就好玩了，意味着原先的指针都不能使用了。这就是 C 等语言的坑，因为指针也是一个简单的数值，也许会被作为某个变量存放，也许会被作为某个数组里面的元素，或者结构体等使用，因此想要在对象修改内存地址之后，更改完所有的引用的指针是特别难的，因此你无法了解这个值表示的单位是什么，是内存地址还是一个货币。而为什么在 .NET 系里面，是很难了解到有这样的坑，是因为在 .NET 里面不会给你存放某个对象的内存地址，也就是没有简单的指针给你使用。而如果有使用指针，将需要告诉运行时，这个对象被我指针引用了，此时运行时将会帮你固定这个对象，不要去垃圾回收移动这个对象。或者垃圾回收之后可以通过运行时更改对所有的指针

当然了，只要涉及到了 C++ 那将会很复杂，上文说法仅仅只是为了说明 dotnet 垃圾回收的难点，对于 C++ 描述部分是十分片面或者说不对的

继续返回 C# 和 VB 这些语言，因为垃圾回收压缩内存减少碎片修改对象的内存地址对这些高级语言基本没影响，那为什么不立刻执行？原因是有性能影响，在进行压缩回收的时候，需要移动对象，而如果对象的内存移动了，那么就需要更新对这个对象的引用。而如果应用程序还在运行，更新对某个对象的引用，是无法一次性完成的，这就会出现在某些代码访问的还是被移动对象的旧内存空间，而有些代码访问的是被移动对象的新的内存空间。如果此时都是只读，那么没有问题。如果有线程尝试写入就有趣了，如果写入到了对象的旧内存空间，那么相当于没有写入

为了解决这个问题，就需要在进行压缩回收的时候暂停所有的线程，在回收完成才能让线程继续执行。因为线程被暂停了，所以对线程来说好像回收是一瞬间完成的，所有的代码使用的对象的内存空间都被更新了

因为在回收的时候执行压缩回收需要暂停线程，将会降低应用的性能。这就是为什么很多 U3D 游戏在玩家玩的时候都不进行内存回收的原因，假定你在点击开枪的时候，应用进行回收，所有的线程都被暂停，那么你砸不砸桌子

是否间隔一段时间就调用垃圾回收比较好？或者说垃圾回收的时间是多少？其实这个问题是无法回答的，在回答之前先了解设计垃圾回收的决策

• GC应该要经常发生，从而足以避免托管堆包含大量垃圾，导致不必要的内存使用
• GC应该不要太过于频繁地发生，以避免降低性能
• GC应该是高效的。如果GC只回收了少量的内存，则浪费了性能
• 每次GC应该要很快执行。许多业务具有低延迟的要求
• 应该能够进行自我调整以满足不同的内存使用模式，开发人员不应该需要知道很多关于GC实现良好的内存利用率的知识，因为很多像我这样的逗比都会自认为了解.NET的内存管理而让实际的GC执行更差

在考虑了上面这些决策，就可以回答垃圾回收的时间是多少这个问题了，假如我的应用程序啥都不做，此时是否还需要回收垃圾？此时不需要。如果我的应用程序是刚好此时空闲了，那么是否在我开始垃圾回收时就开始忙碌了？按照上面的决策可以看到，垃圾回收是尽可能少的调用，以及调用的时候要让垃圾回收执行足够快

想要设计出这样的 GC 方法是十分有难度的，不够世界上强大的开发者很多，现在的 .NET 垃圾回收机制就是艺术品，里面有大量巧妙的设计

如在开源的仓库里面可以看到下面的代码

enum gc_reason
{
    // 小对象分配(AllocSmall)- 在对象分配期间，第 0 代的预算已用完。 这是最常见的情况，在第 0 代分配预算超出的情况下触发
    reason_alloc_soh = 0,
    // 显式诱导GC，没有关于压缩和阻塞的选项
    reason_induced = 1,
    // 操作系统发出内存不足通知信号
    reason_lowmemory = 2,
    reason_empty = 3,
    // 大对象分配(AllocLarge)- 在大对象分配期间，LOH 的预算已用完
    reason_alloc_loh = 4,
    // 慢速路径上的小对象分配(OutOfSpaceSOH)- 在SOH中的“慢速路径”对象分配过程中，分配器空间不足，即使经过一些段重组，甚至可能已经运行了GC，仍然没有所需的可用空间。在具有较大虚拟内存空间的64位运行时中，这应该是一个相当罕见的原因。但是，即使在64位运行时，这种情况也可能发生在工作站GC中
    reason_oos_soh = 5,
    // 慢速路径(OutOfSpaceLOH)上的大对象分配 - 在LOH中的“慢速路径”对象分配期间，分配器空间不足。与OutOfSpaceSOH类似，它应该并不常见
    reason_oos_loh = 6,
    // 没有阻塞的显式诱导GC
    reason_induced_noforce = 7, // it's an induced GC and doesn't have to be blocking.
    reason_gcstress = 8,        // this turns into reason_induced & gc_mechanisms.stress_induced = true
    reason_lowmemory_blocking = 9,
    // 应该进行压缩的显式诱导GC，但仅限SOH，请记住通过其他设置显式启用LOH压缩
    reason_induced_compacting = 10,
    // 主机发出内存不足通知信号
    reason_lowmemory_host = 11,
    reason_pm_full_gc = 12, // provisional mode requested to trigger full GC
    reason_lowmemory_host_blocking = 13,
    reason_bgc_tuning_soh = 14,
    reason_bgc_tuning_loh = 15,
    reason_bgc_stepping = 16,
    reason_max
};

上面代码是放在 C++ 层的运行时，用于运行时使用，当前垃圾回收是基于什么理由。上面代码的具体意思是什么，在伟民哥翻译的《.NET内存管理宝典 - 提高代码质量、性能和可扩展性》用来几章来讲本文的问题

更详细还需要等伟民哥翻译的《.NET内存管理宝典 - 提高代码质量、性能和可扩展性》发布

WPF 漂亮的现代化控件新 ModernWPF 界面库

Thu, 03 Dec 2020 08:22:28 +0000

这是一个在 GitHub 上完全开源的库，有十分漂亮的界面，整个都是 Win10 风，界面部分和默认 UWP 相近

这个库支持了 .NET Framework 4.5 和以上的版本，以及 .NET Core 3.0 和以上的版本，可以在 Windows Vista SP2 和以上的系统运行

界面如下

使用方法简单，从 NuGet 上安装 ModernWpfUI 库，然后打开 App.xaml 添加下面代码

<Application
    ...
    xmlns:ui="http://schemas.modernwpf.com/2019">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ui:ThemeResources />
                <ui:XamlControlsResources />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>
</Application>

更多请到 GitHub 的仓库：Kinnara/ModernWpf: Modern styles and controls for your WPF applications

非技术在线教育与电信行业的发展

Thu, 03 Dec 2020 08:22:28 +0000

今天在去买菜的时候，听到旁边有个移动的小哥哥在向一位大叔叔推荐办理移动带宽升级业务，他说到一句话，你升级一下带宽，你的小孩上在线课程的时候多顺哇。本来是没当回事，只是无聊的时候想到这一点，我认为这里是一个大的利益链，于是写博客记一下

现在是 2020.08.30 我想看看是否我认为的是对的

本文不聊任何技术，也不聊任何音视频相关的技术哈，只是想聊聊利益链的关系

在电信行业，如移动和电信等，宽带业务有两个方向，一个就是拉新，一个就是办理宽带升级。而现在几乎所有人都有宽带，而拉新也就是去向其他电信厂商抢生意，看起来很难。而宽带升级呢？其实很多小伙伴都认为自己的带宽是足够的，只是延迟没有优化好

现在看起来电信行业的小伙伴，如我今天遇到的移动的小哥哥有了新的理由，也就是小孩的在线教育所需要的带宽问题。其实这个应该是在暑假开始的时候就研究出的，因为现在准备开学了，开学了之后在线教育将会少很多

那么在线教育和电信行业有什么关系？其实就是有一个矛盾点是在线教育需要的网络带宽与当前所使用的带宽速度的矛盾

隔壁家的小孩能流畅看高清的在线教育直播视频，而我的只能一卡一卡看不到直播，而现在给小孩教育投资都会投入很大。因此在线教育的火将会推动电信行业的发展。因为现有的网络撑不住这么多的直播，因此电信行业将会推出新套餐，而此时用户是买单。用户买单也就是电信行业有了更多收入，有了更多的收入将会投基础设施

这是一个利益链的关系，也就是在线教育，这个教育将会和电信关联

而电信行业推动通讯的发展本身就是政治正确

所以大概结论就是：

一定会存在，同时会继续存在的在线教育
如果阻挠在线教育，将会遇到电信等利益链的阻力

反过来说，也就是我认为在线教育会成，其中一个原因是有电信行业的支持

而电信行业的力量是很大的，因此如果想要阻挠在线教育的发展，那么光电信行业的大佬就有足够大的阻力的

有趣的是电信行业掌握了海量的宣传渠道，因此你所能听到的，基本上将都是说在线教育的好处的

WPF 使用 Skia 绘制 WriteableBitmap 图片

Thu, 03 Dec 2020 08:22:28 +0000

本文告诉大家如何在 WPF 中使用 SkiaSharp 调用 Skia 这个全平台底层渲染框架，使用绘制命令在 WriteableBitmap 图片上绘制内容

谷歌提出了 Skia 全平台渲染框架，这是一个很底层的框架，详细请看 google/skia: Skia is a complete 2D graphic library for drawing Text, Geometries, and Images.

而 SkiaSharp 是 mono 组织对 Skia 的 .NET 封装库，可以完全用到 Skia 的底层渲染能力，详细请看 mono/SkiaSharp: SkiaSharp is a cross-platform 2D graphics API for .NET platforms based on Google’s Skia Graphics Library. It provides a comprehensive 2D API that can be used across mobile, server and desktop models to render images.

那么如何在 WPF 使用 SkiaSharp 绘制出 WriteableBitmap 在 WPF 中使用？其实 WriteableBitmap 是将一个数组里面的像素在屏幕显示，而 SKSurface 可以从一个像素数组开始创建，创建的时候需要规定这个数组对应的图片的格式，包括图片的大小以及 RGB 像素格式

使用下面代码创建一个简单的界面，在这个界面里面点击按钮将会给 Image 控件赋值使用 Skia 创建的图片

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition></RowDefinition>
            <RowDefinition Height="Auto"></RowDefinition>
        </Grid.RowDefinitions>
        <Image x:Name="Image" Margin="10,10,10,10"></Image>
        <Button Margin="10,10,10,10" Grid.Row="1" Content="使用Skia绘制" Click="Button_OnClick"></Button>
    </Grid>

在 WPF 里面创建一个 WriteableBitmap 可以使用如下代码

        private WriteableBitmap CreateImage(int width, int height)
        {
            var writeableBitmap = new WriteableBitmap(width, height, 96, 96, PixelFormats.Bgra32, BitmapPalettes.Halftone256Transparent);
            return writeableBitmap;
        }

为什么需要创建一个方法来创建，原因是参数 PixelFormats.Bgra32 和 BitmapPalettes.Halftone256Transparent 将会和后续的 Skia 创建相关

在 Skia 里面和 D2D 一样有 Surface 的概念，也就是可以将绘制命令输入到 Skia 绘制到 Surface 上，而绘制内容将会作为像素数组放在传入的数组里面

小伙伴是否还记得 WPF 使用不安全代码快速从数组转 WriteableBitmap 的方法，其实 Skia 在 WriteableBitmap 绘制的本质就是这样

在开始绘制之前需要调用 WriteableBitmap 的 Lock 方法，接着在绘制完成之后，需要调用 AddDirtyRect 和 Unlock 方法

大概的绘制代码如下

        private void UpdateImage(WriteableBitmap writeableBitmap)
        {
            int width = (int)writeableBitmap.Width,
                height = (int)writeableBitmap.Height;
            writeableBitmap.Lock();
            var skImageInfo = new SKImageInfo()
            {
                Width = width,
                Height = height,
                ColorType = SKColorType.Bgra8888,
                AlphaType = SKAlphaType.Premul,
                ColorSpace = SKColorSpace.CreateSrgb()
            };

            using (var surface = SKSurface.Create(skImageInfo, writeableBitmap.BackBuffer))
            {
                SKCanvas canvas = surface.Canvas;
                canvas.Clear(new SKColor(130, 130, 130));
                canvas.DrawText("SkiaSharp on Wpf!", 50, 200, new SKPaint() { Color = new SKColor(0, 0, 0), TextSize = 100 });
                canvas.DrawText("https://blog.lindexi.com", new SKPoint(50, 500), new SKPaint(new SKFont(SKTypeface.FromFamilyName("微软雅黑")))
                {
                    Color = new SKColor(0, 0, 0),
                    TextSize = 20
                });
            }
            writeableBitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));
            writeableBitmap.Unlock();
        }

绘制界面大概如下

本文的代码放在 github 欢迎小伙伴访问

更多使用方法还需要小伙伴自己去玩

当前可以使用 SkiaSharp 支持 Window 端和 Linux 端以及 macOS 和 iOS 和安卓端的绘制，其中 Xamarin 中集成 Skia 的成熟度是最高的

WPF 使用基于 Chromium 内核的 Microsoft Edge 封装的 WebView2 控件

Thu, 03 Dec 2020 08:22:28 +0000

现在是 2020.08.23 当前这个技术依然是预览版，使用 WebView2 只需要通过 NuGet 安装库，可以支持 Win7 和 Win8 和 Win10 系统，无 IE 依赖。内核使用 Chromium 内核，顶层技术是 Microsoft Edge 封装

创建一个 WPF 项目，项目框架要求最低版本是 .NET Framework 4.6.2 或以上，或 .NET Core 3.0 以上版本

使用 NuGet 搜 Microsoft.Web.WebView2 勾选预览版

打开 MainWindow.xaml 添加命名空间

xmlns:wv2="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"

添加之后的 MainWindow.xaml 文件内容大概如下

<Window x:Class="Lindexi.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:wv2="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"
        mc:Ignorable="d"
        Title="LindexiDoubi"
        Height="450" Width="800">

    <Grid>

    </Grid>
</Window>

在 Grid 添加 WebView2 控件，如下面代码

<Grid>
    <wv2:WebView2 Name="webView"
                  Source="http://blog.lindexi.com/"/>
</Grid>

此时运行项目，即可看到打开了内嵌的浏览器以及自动跳转我的博客

更多使用方法请看官方文档适用于 WPF 应用的 Microsoft Edge Web 视图2 - Microsoft Edge Development

C# dotnet 使用判断文件夹存在的方法判断一个文件路径会怎样

Thu, 03 Dec 2020 08:22:28 +0000

假定我有一个文件的路径，我将这个文件路径放在文件夹判断方法里面，请问此时返回的是存在还是不存在？答案是返回不存在

如下面测试代码，这里的 GelteajoutrerebaKoutigasremawcho.dll 就是程序集，也就是文件是存在的，那么放在 DirectoryInfo 判断输出的内容是否存在

namespace GelteajoutrerebaKoutigasremawcho
{
    class Program
    {
        static void Main(string[] args)
        {
            DirectoryInfo dir = new DirectoryInfo(@"GelteajoutrerebaKoutigasremawcho.dll");
            Console.WriteLine(dir.Exists);
            
            var file = new FileInfo(@"GelteajoutrerebaKoutigasremawcho.dll");
            Console.WriteLine(file.Exists);
        }
    }
}

输出是 False True 也就是判断文件夹不存在，判断文件存在

代码放在 github 欢迎小伙伴访问

通过公开的自动构建发布开源项目的库的安全意义

Thu, 03 Dec 2020 08:22:28 +0000

这是比较有争议的内容，为什么我推荐开源项目的库应该采用开源的 CI 公开进行发布。本文主要来聊安全的问题，本文的观点没法完全让小伙伴信服，只能说是我自己的看法

安全的问题说的是什么问题？假定我在网上找到了一个库，这个库有一个二进制的发布，如 NuGet 包。此时尽管有代码，请问我是否可以信任这个二进制的发布的库

这里涉及到的一个问题是，我无法了解到这个二进制的库是否真的从这个开源仓库里面构建出来。我无法了解到这个二进制的库是否没有添加了后门才发布

而如果此时我可以看到这个库的这个版本是通过公开的自动构建的方式构建的，那么我会更信任这个二进制发布的库

而我也可以通过相同的方式自行构建自己的一份二进制文件

一个开源的项目的代码是有很多小伙伴去 review 的，因此我可以相对信任这个开源的项目里面应该是很少会存在有意添加的后门。或者我可以认为网络上充满正义而技术强大的小伙伴会给出警告

因此相对于闭源的项目，开源项目的安全性都会更高

而对于二进制的库，假定无法了解他的制作来源，那么对此的信任度将会比较低。例如这是一个官方作者没有发布的库，而是由第三方开发者发布的库。或者这个库里面的实际代码和开源项目不匹配，或者在发布的时候被添加了后门等

或者我期望自行发布，而没有自动构建的存在，我需要用更多的精力才能让发布自己的二进制版本

但是否仅有二进制的库就不能保证安全？其实不然，因为可以通过反编译的方法，依然可以阅读到相应的代码。但是相对于开源的代码来说，阅读反编译的逻辑将会缺少交流。你阅读过这份代码，但是我没有。你发现了问题不采用，而我不知道

而采用公开的自动构建发布是否能保证安全？依然不能，因为有强大的程序员是可以无意给你挖一个深坑，即使开源代码，你也不知道其实埋了后门。或者没有精力去阅读

因此有公开的自动构建的发布的逻辑的优势在于：

其他开发者可以了解到发布的二进制包的制作过程
其他开发者可以方便在此基础上做二次发布，自己发布的相对放心

讲师培训多米诺原则

Thu, 03 Dec 2020 08:22:28 +0000

我饿了，然后我要开车

我总是认为其他人无法理解我的思路，以及我的方案，我总是认为自己的思路很快

但实际上是这样？

其实仅是表达的问题，有太多默认的知识没有被说出来

我饿了，然后我要开车。

逻辑是什么？为什么要开车？

我饿了，我没力气走路了，接下来我想用最快的速度到达餐厅，所以我要开车。

点出中间的步骤，听众的逻辑就清晰

通过 cmd 批处理文件将 16 进制转 10 进制数字

Thu, 03 Dec 2020 08:22:28 +0000

我在用户的电脑上通过 spyxx 找到某个进程的 id 都是在 spyxx 使用 16 进制显示，而任务管理器使用 10 进制显示，用户的电脑没有计算器。我如何使用 bat 或 cmd 等批处理文件快速将十六进制的数字转换为十进制的数字

创建一个文本文件，修改后缀名为 cmd 文件

使用如下代码即可创建一个变量，在变量里面设置十六进制，此时输出就是 10 进制字符串

set /A hex=0x0b12
echo %hex%

请将 0x0b12 替换为你需要转换的十六进制数字

别忘了添加 pause 暂停哦

相信小伙伴能记住上面的代码，这样就可以在用户这边用记事本写了

C# dotnet 使用 TaskCompletionSource 让事件转异步方法

Thu, 03 Dec 2020 08:22:28 +0000

咱今天来聊聊一个毁灭世界的故事，哦，不，是一个使用 TaskCompletionSource 让偷核武器，哦，又说错了，是让事件转换为异步的方法，让咱可以在一个方法里面顺序写下毁灭世界的逻辑

故事的背景是这个世界上的核导弹的发射是只要有密码就能发射，而刚好咱有一个强大的黑客团队可以窃取到密码。咱想要写一个方法，这个方法可以按照顺序发布一些指令，包括让黑客团队窃取密码，然后发射导弹，等待世界毁灭

因为黑客团队都很神秘，请动黑客团队去窃取密码之后，不会从原先的方法返回。而是黑客团队为了安全性（世界都要毁灭了，哪来的安全性）会通过比特信告诉你，拿到密码了。等等，什么是比特信？这是一个超级高加密的匿名的邮箱 P2P 服务，反正对咱程序来说就是一个事件，定义如下

    static class BtcMessage
    {
        public static event EventHandler KeyReceived;
    }

    static class HackTeam
    {
        public static void PeekKey()
        {

        }
    }

如上面的定义，黑客团队 HackTeam 有一个公开的方法是窃取密码，具体做啥，神秘的黑客可不会告诉咱。只是知道在完成之后，咱 BtcMessage 的 KeyReceived 事件将会触发。咱可以进行下一步的行动

下一步就是发射导弹了，尽管发射的过程很复杂，但对咱来说也是一个函数调用的事情

    static class Missiles
    {
        public static void Fire()
        {

        }
    }

发射完成导弹之后，是不是这个世界就毁灭了？还不是，还需要等待导弹落地，爆炸，然后等待生态环境凉凉…… 没关系，最后这个世界会告诉咱世界已经毁灭了，因为这个世界是有意识的

    static class World
    {
        public static event EventHandler Broke;
    }

好，那么咱的逻辑可以如何组织。第一步让黑客团队获取密码，等待 BtcMessage 事件回调。在 BtcMessage 事件触发之后调用导弹发射。然后等待世界触发毁灭事件

按照最简单的逻辑应该是这样写的，本来是想做个 WPF 程序，点击按钮就执行毁灭世界的。不过看看还是控制台简单

        static void Main(string[] args)
        {
            World.Broke += (sender, eventArgs) =>
            {
                Console.WriteLine("Hello World!");
            };

            BtcMessage.KeyReceived += (sender, eventArgs) =>
            {
                Missiles.Fire();
            };

            HackTeam.PeekKey();
        }

可以看到代码不清真，因为都是倒过来写的，不倒过来也不成，因为如果在动作执行之后再监听事件，说不定事件就执行完成了

这就需要标题的 TaskCompletionSource 出场了，这个类的作用就是支持等待，同时可以被设置完成，很不好理解。写写代码就知道了

添加了 TaskCompletionSource 的写法如下

            HackTeam.PeekKey();

            await btcReceivedTask.Task;

            Missiles.Fire();

            await worldBrokeTask.Task;

            Console.WriteLine("Hello World!");

是的按照顺序了写下来了，但是 btcReceivedTask 和 worldBrokeTask 是什么？这是先准备好的 TaskCompletionSource 对象

            var btcReceivedTask = new TaskCompletionSource<bool>();
            var worldBrokeTask = new TaskCompletionSource<bool>();

            BtcMessage.KeyReceived += (sender, eventArgs) =>
            {
                btcReceivedTask.SetResult(true);
            };

            World.Broke += (sender, eventArgs) =>
            {
                worldBrokeTask.SetResult(true);
            };

为什么需要使用 TaskCompletionSource<bool> 是因为 TaskCompletionSource 只有泛形的版本，而 SetResult 方法一调用，将会让等待的代码继续往下执行

也就是在代码执行到 await btcReceivedTask.Task; 的时候，将会进入等待。在 btcReceivedTask.SetResult 方法被调用之后，才会继续执行 await btcReceivedTask.Task; 之后的代码

于是在 TaskCompletionSource 的辅助之后的代码，写毁灭世界的逻辑请看来就清真了

当然，一开始的代码还可以封装一下，咱可以封装出等待任意事件的触发作为异步的代码

例如封装一个世界被毁灭的等待任务

    public class WorldBrokeTask
    {
        public WorldBrokeTask()
        {
            World.Broke += World_Broke;
        }

        private void World_Broke(object sender, EventArgs e)
        {
            World.Broke -= World_Broke;
            TaskCompletionSource.SetResult(true);
        }

        public Task WaitWorldBroke()
        {
            return TaskCompletionSource.Task;
        }

        private TaskCompletionSource<bool> TaskCompletionSource { get; } = new TaskCompletionSource<bool>();
    }

这个封装可以协助咱准备监听是哪一次的世界毁灭，这样咱就不需要处理具体的事件监听逻辑。如一开始的代码其实存在一个坑就是当在毁灭世界之后，下一次世界毁灭的时候，又会触发事件。如果不是创建方法，那么很难做到只监听一次

通过封装之后的使用如下

    var worldBrokeTask = new WorldBrokeTask();

    HackTeam.PeekKey();

    await btcReceivedTask.Task;

    Missiles.Fire();

    await worldBrokeTask.WaitWorldBroke();

    Console.WriteLine("Hello World!");

可以看到创建出来 WorldBrokeTask 然后接着等待就可以了，代码很简单

通过本文的例子相信大家也掌握了毁灭世界，哦，不，使用 TaskCompletionSource 封装事件为异步的方法

当然本文也回答了一个问题，是否使用 await 就存在线程的切换。其实可以不用切换线程

更多请看

WPF 使用 Resharper 更改命名空间后生成文件引用找不到的命名空间

Thu, 03 Dec 2020 08:22:28 +0000

在 Resharper 更改全部命名空间之后，在 xx.g.cs 文件里面的 using 用了一个之前的命名空间，但是代码里面没有地方使用，此时构建不通过，原因是 xaml 里面存在引用

在安装 Resharper 之后，可以右击某个文件夹或项目，点击 Refactor -> AdjustNamespaces 批量更改命名空间

尽管 Resharper 会将大量的 xaml 的元素改对了命名空间，但是有些没有用到的标签就没有改全

如下面代码

<Window x:Class="Lindexi.Doubi.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Lindexi.DoubiDemo"
        mc:Ignorable="d"
        ResizeMode="NoResize"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <Border Background="Gray" Width="100" Height="100" Margin="10,10,10,10" >
            <Button Click="Button_OnClick">点击</Button>
        </Border>
    </Grid>
</Window>

这里的 local="clr-namespace:Lindexi.DoubiDemo" 没有用到，我将命名空间从 Lindexi 修改为 Lindexi.Doubi 但是这里没有更改，而在生成的 MainWindow.g.cs 文件会根据 xaml 的命名空间引用添加 using 代码

因此在 g.cs 文件会创建下面代码

using Lindexi.DoubiDemo;

构建的时候提示找不到类或命名空间

>obj\Debug\net45\MainWindow.g.cs(12,18): Error CS0234: The type or namespace name 'DoubiDemo' does not exist in the namespace 'Lindexi' (are you missing an assembly reference?)

解决方法有两个

第一个解决方法就是删除 xaml 里面的这些引用，可以全局搜寻，替换字符串

第二个方法是自己写一个空白的命名空间，因为如果 xaml 太多的话，需要改很久，写一个空白的命名空间就可以

namespace Lindexi.DoubiDemo
{

}

WPF 设置 WS_EX_TRANSPARENT 触摸失效

Thu, 03 Dec 2020 08:22:28 +0000

调用 SetWindowLong 方法给 GWL_EXSTYLE 设置 WS_EX_TRANSPARENT 让窗口透明，此时应用程序只能收到鼠标消息但收不到触摸消息

最简单的 demo 是在 Load 事件添加下面代码

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            IntPtr hwnd = new WindowInteropHelper(this).Handle;
            var extendedStyle = GetWindowLong(hwnd, GWL_EXSTYLE);
            SetWindowLong(hwnd, GWL_EXSTYLE, extendedStyle | WS_EX_TRANSPARENT);
        }

此时可以发现窗口的 MouseDown 能收到，但是 TouchDown 事件收不到

最简单的 demo 放在 github 欢迎小伙伴访问

此问题报告为官方，请看 WPF can not receive the touch message when set WS_EX_TRANSPARENT to window

因为小伙伴很少会用到这个方法设置透明，因此此问题影响很小

正规的透明设置方法请看 WPF 制作高性能的透明背景异形窗口（使用 WindowChrome 而不要使用 AllowsTransparency=True） - walterlv

dotnet 配置 Gitlab 的 CI 找不到 Runner 或找错的可能原因

Thu, 03 Dec 2020 08:22:28 +0000

使用 Gitlab 的 CI 但是任务没有执行，提示找不到 Runner 或者找错了 Runner 服务器，请看本文，从上到下看，是否有坑

公共Runner冲突

默认会使用全局共享的 Shared Runners 服务器，此时定位方法是通过某次 CI 运行的时候的运行服务器名字，确定是否自己的 Runner 服务器

如上图采用的是 dotnet-campus 的服务器

如需要禁用全局共享的 Runner 服务器，打开仓库的 CI 设置页面，禁用 Shared Runners 就可以

没有开启 Piplines 权限

打开仓库设置的 General 配置

确定下面权限打开

配置的Tag和Runner的Tag不匹配

在GitLab的Runner可以添加 Tag 配置，表示这个 Runner 属于哪一类，请不要将 Tag 概念和 Git Tag 弄混

如果在 Runner 设置了特殊的 Tag 同时要求 ci.yml 文件的配置使用相同的 Tag 才能执行，这个 Tag 的作用大概是：我有一组 Linux 的服务器和一组 win 服务器，我如何指定当前任务在哪个类型的服务器上运行？就是通过 Tag 指定。默认的 Runner 没有指定 Tag 时，可以让所有任务执行，如下图

而如下图的 Runner 指定了 Tag 是 dev 也就是要求在配置文件指定在 dev 的服务器上运行

C# dotnet 在内存中的 double 的 NAN 和正负无穷二进制是如何存

Thu, 03 Dec 2020 08:22:28 +0000

我就好奇无穷大和 NAN 在 C# 的二进制是如何表示的

揭开谜底

NAN: 00,00,00,00,00,00,F8,FF

正无穷 PositiveInfinity : 00,00,00,00,00,00,F0,7F

负无穷 NegativeInfinity : 00,00,00,00,00,00,F0,FF

测试方法如下

        static void Main(string[] args)
        {
            MemoryStream stream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(stream);

            double db = double.NaN;
            writer.Write(db);

            Console.WriteLine(string.Join(",", stream.ToArray().Select(b => b.ToString("X2"))));

            stream.Seek(0, SeekOrigin.Begin);
            db = double.PositiveInfinity;
            writer.Write(db);
            Console.WriteLine(string.Join(",", stream.ToArray().Select(b => b.ToString("X2"))));

            stream.Seek(0, SeekOrigin.Begin);
            db = double.NegativeInfinity;
            writer.Write(db);
            Console.WriteLine(string.Join(",", stream.ToArray().Select(b => b.ToString("X2"))));
        }

这个值不是乱存的，有标准，请看 IEEE 754 - Wikipedia

是不是还有更简单的方法拿到某个变量的内存里面的值存放方法？试试下面代码

double d = double.NaN;
Span<byte> sp = new Span<byte>(&d, sizeof(double));

试试看下 sp 的值

感谢 （￣▽￣） 小伙伴提供的方法

二阶熵

Thu, 03 Dec 2020 08:22:28 +0000

小伙伴都知道熵是代表某个系统的混乱程度，而熵值本身是没有啥可以进行衡量的。本文所说的二阶熵仅是一个定义，方便后续我的吹水，用来表示一个混乱的等级

为什么会用到这个有趣的定义？因为我需要描述我创建的系统的混乱程度，而这个系统是用来描述人工智能的。此时小伙伴千万不要认为有多高大上，毕竟我这里所说人工智能仅仅只是沾边的概念，本文不会涉及到这些复杂的公式和内容

在开始之前，需要聊聊什么是混乱。可以用计算机领域的事情做描述。计算机的内存的值可以认为是一个系统，当然此系统非计算机的运行系统，仅仅只是类似物理描述里面用的系统这个词。在咱还没开机的时候，此时的内存全部都是零，没有值。此时的内存这个系统是很有秩序的，一点都不混乱

在开机之后，咱会运行很多程序，这些程序会不断写内存，此时内存里面就不是全零的值了。如果完全脱离了运行的程序等，仅仅看内存这个系统的混乱程度，此时可以看到开机之后内存这个系统的熵值变大。此时脱离了运行的程序等，看起来的内存的值是无序混乱的

但是此时的混乱程度我称为一阶无序，即一阶熵

因为如果此时能理解程序和计算机系统的规则，就可以知道内存里面的值的含义，此时内存就不是无序的

但是这仅仅只是描述静态的事情，小伙伴都知道在计算机领域，如果使用纯软件脱离外界交互，是无法作出真正随机的。也就是如果这个设备没有受到外界干扰，也没有和外界交互，也没有做随机数的硬件等，此时计算机所做的事情理论上都是可以预测的

也就是尽管整个内存的值系统是混乱的，但是这个混乱是按照一定的程序规则混乱的，属于可以进行预测的混乱。因此此时虽然熵变大，但依然属于一阶熵。无论整个内存的值变的多混乱，仅仅只是让一阶熵增加，达不到二阶熵

而如果此时电脑前坐了一个人，这个人正在使用QQ聊天，此时即使能理解程序，也无法推算出这个人下一时刻会用什么程序输入什么内容，他会在什么时候敲击键盘等。尽管从内存的值的角度，依然混乱程序和之前差不多，但是已经有了本质的差别。在于无法通过理解应用程序和计算机系统等了解内存的值的混乱变化，这就是二阶无序，也就是二阶熵

这是属于动态的熵的变化达到二阶，或者说短暂达到了二阶。在存在人为干涉的时候，短暂让内存的值出现了不可预知的混乱。但是很快在人类没有继续干涉的时候，整个计算机内存的值又处于可以被解读的状态，此时就从二阶熵回到了一阶熵

而另一个进入二阶熵的方法则是如系统损坏，整个内存被一个无法规则化的方式写入，此时也无法描述内存的值的意义，此时也达到静态的二阶熵

因此一阶熵的定义是，尽管整个系统是无序的，但是能够找到某些规则用来描述这个无序

而二阶熵的定义是，整个系统是无序的，存在混乱的规则用来描述这个无序的系统

这一点需要注意的是存在混乱的规则表达的是和不存在规则差不多，假设你能找到某个规则，即使这个规则特别复杂分支条件非常多，那么这个系统就不满足二阶熵。而是只能找到一个混乱的规则，这句话其实和找不到规则是差不多的。含义上可以和无穷大的规则一样理解，无论你找到一个多大的数，无穷大都比这个数大。那么无穷大是否存在，存在，但是能否找出无穷大这个数，不能。大概存在混乱的规则说的就是这个

本身智能就是混乱的，本文说的人工智能主要说的是思维方面，不包含工具方面。我认为要做出一个存在智能的系统，必须让这个系统满足至少是二阶熵，不然仅是工具

可以将当前的神经网络拆出来看，在一个固定层数和个数的神经网络，嗯，其实连接是否不固定是没有意义的，因为本质上全连接的网络都包含这些网络。原因是这些网络相当于一个全连接的网络存在某些连接的值是 0 也就是连接断开

假定这些神经网络的参数就是内存里面的值，现在很难理解这些参数的含义，那么可以认为在训练过程内存的值这个系统的熵在增加，但咱不讨论是否在不断往混乱变化。但是依然存在一个规则，这个规则存在于这个神经网络里面，理论上这个规则是能够让人类可以知道的，用来描述这些参数的含义。因此这个神经网络的复杂程度仅仅达到一阶熵

对比刚才坐在电脑前的人的干预让计算机的内存进入了二阶熵大概可以猜到我想说什么了，这部分神经网络如果按照我的理论，是做不出思维的

那么通过什么方式可能进入二阶熵，按照定义，需要让规则本身也是混乱的。也就是需要一个无法描述规则的网络所使用的参数，这些参数才属于二阶无序，也就是这些参数在内存中达到二阶熵

也就是我如果假定二阶熵才有可能做出思维这个理论是对的，那么我想要做出一个有思维的人工智能，我至少需要有一个本身是混乱的人工智能框架或算法

当然这句话反过来不对，只能说根据现有推测条件。根据现有思维的存在干涉了计算机，存在了不可预知，动态进入二阶熵。反过来认为思维需要至少达到二阶熵。而符合二阶熵是否就能做出思维？请问一个系统混坏的电脑能做什么，此时他的内存的值应该就达到了二阶熵

那么这个二阶熵是否和人工智能的思维有关系，这个假设是不是对的

也许只要在几十年过去，我也许才能大概知道

我很少写一些纯理论的博客，基本上都是先写代码，没有任何能说的出来的依据，也没有任何能简单说的明白的理论。但是这个二阶熵我和很多小伙伴来来回回讨论了很多次，终于算比较明白的一个纯理论的定义。这个定义其实没什么用，也许有其他小伙伴也有差不多的定义，只是我不知道

C# dotnet 创建对象附加属性定义支持附加任意类型

Thu, 03 Dec 2020 08:22:28 +0000

在 dotnet 中，通过 dotnetCampus.ClrAttachedProperty 库，可以实现给任意对象附加任意属性。以及实现创建对象的附加属性定义，使用相同的附加属性定义才能访问相同的附加属性值。在使用过 WPF 的小伙伴一定对附加属性不陌生，在 WPF 框架中很强大的一个功能就是附加属性，而针对于 WPF 框架外的 dotnet 其实也能做到相同的设计，支持定义对象附加属性

在 dotnet 给任意对象附加任意属性的库和大家介绍了 dotnetCampus.ClrAttachedProperty 库的一般用法，而本文就来告诉大家如何定制和 WPF 一样功能的附加属性

没有用过 WPF 的小伙伴也没关系，因为用过 WPF 的小伙伴应该是看到 API 就瞬间明白用法和优势，没有用过 WPF 的小伙伴就先来听听我吹一下

附加属性有什么用？附加属性可以是某个业务附加都某些对象上的业务属性，这些业务属性仅在此业务中生效

实际的例子如下，假设人具有以下属性定义

名字
性别

但是此时银行部门期望给人添加一个业务属性，就是银行卡属性。显然，从设计的角度不应该给人添加银行卡属性，需要通过额外的手段定义

而通过额外的手段定义就存在对象回收的问题，如果某个人穿越了，被 GC 了，那么附加到这个人上的附加属性银行卡属性期望也能被自动 GC 回收。而如果这个人依然还在浪，那么就期望银行卡属性不要被回收

刚好 WPF 的附加属性重点就是做这个事情，而 dotnetCampus.ClrAttachedProperty 库就是对此过程的封装，提供了 AttachedProperty 对象，可以用来定义附加属性

假设定义银行业务，给银行业务定义附加属性，表示银行卡属性

class Bank
{
	public static readonly AttachedProperty<int> IdProperty = new AttachedProperty<int>();
}

此时获取某个人的银行卡属性的值可以使用下面代码

var id = Bank.IdProperty.GetValue(boy);

也就是仅在 Bank 业务范围内才能拿到某个人的银行卡属性。原因是必须通过 Bank.IdProperty 附加属性才能获取对应的银行卡属性，如果拿不到 Bank.IdProperty 附加属性，那么将不能访问银行卡属性

更进一步的，期望对银行卡业务进行一些封装，如限制了设置银行卡属性的需求，此时可以让 IdProperty 成为私有，请看如下代码

    class Bank
    {
        public void SetId(Person person, int id)
        {
            if (person.Name == "德熙")
            {
                throw new ArgumentException("德熙和狗不能办理银行卡");
            }

            IdProperty.SetValue(person, id);
        }

        public int GetId(Person person)
        {
            return IdProperty.GetValue(person);
        }

        private static readonly AttachedProperty<int> IdProperty = new AttachedProperty<int>();
    }

如果有更多需求，如不同的银行实例之间能用到的银行卡是完全独立的，此时可以将 IdProperty 修改为成员属性

    class Bank
    {
        public AttachedProperty<int> IdProperty { get; } = new AttachedProperty<int>();
    }

var person = new Person();
var bank1 = new Bank();
var bank2 = new Bank();

bank1.IdProperty.SetValue(person, 100);
bank2.IdProperty.SetValue(person, 200);

Assert.AreEqual(100, bank1.IdProperty.GetValue(person));
Assert.AreEqual(200, bank2.IdProperty.GetValue(person));

如上面代码，两个不同的银行对象的 IdProperty 是两个不同的对象，此时对相同的对象的附加属性访问到的是两个不同的附加属性。进行附加属性的设置和获取都不会相互影响

如果我开的是瞬间的银行，我只是定义局部变量，也是可以定义 AttachedProperty 局部变量。此时只有拿到相同的 AttachedProperty 对象才能访问对象的相同的附加属性的值

但是使用这些附加属性时需要小心。垃圾回收的机制，即使是定义局部变量的附加属性，附加到对象的属性的值，最短的存活将会是在附加到的对象被回收之后。换句话说是即使 AttachedProperty 的对象已经被回收了，但是不意味着此时通过 AttachedProperty 附加到对象的属性值也会被回收，而是需要在被附加到的对象被回收之后才会被回收

这个库提供了两个不同版本的 NuGet 库，其中一个包是传统的 Dll 引用包。另一个包是使用 SourceYard 打出来的源代码包，源代码包安装之后将会引用源代码

安装传统的 Dll 引用包的方式如下

dotnet add package dotnetCampus.ClrAttachedProperty --version 1.0.0

安装源代码包的方式如下

dotnet add package dotnetCampus.ClrAttachedProperty.Source --version 1.0.0

在使用的时候两个包只需要选其中一个就可以

另外这是一个完全开源的项目，放在 github 欢迎小伙伴参与

dotnet 职业技术学院

Office 使用 OpenXML SDK 解析文档博客目录

入门

PPT 解析

元素解析

文本解析

形状

颜色

通用知识

工具

例子

收藏

第三方工具

Add-in Express

Xamarin iOS 部署应用提示 iOS code signing key 失败

dotnet OpenXML 从文档生成创建文档的代码的库

WPF 列表右键菜单比较符合 MVVM 的命令绑定方法

Xamarin.Forms 选取文件 让用户选择本地文件

Xamarin 和 WPF 的控件和属性的替换

控件

Panel

StackPanel

TextBlock

TextBox

Button

Xamarin 构建安卓失败 因为路径太长

Xamarin 构建提示 error APT2260 resource 找不到资源

Xamarin 解决创建空白项目编译提示 linking references 找不到资源

Xamarin iOS 切换开发者账号之后的签名标识和预配配置文件更新方法

Xamarin.Forms 按钮样式 圆角按钮

Xamarin Forms WPF 干掉默认的窗口导航条

C# 写一个24点计算程序

C# 反射判断属性是抽象继承

抽象

虚属性

重写

C# 纯控制台创建一个全屏窗口

C# 里面很少人知道但很好用的 Tuple 转换

dotnet C# 使用阿里函数计算服务

dotnet C# 图片等比限制最大和最小大小缩放算法

dotnet C# 如何不联网下快速获取一段url链接里面读取文件名

dotnet C# 如何让 Json 序列化数组时序列化继承类的属性

dotnet CBB 为什么决定推送 Tag 才能打包

从 DX 层面讲 WPF 渲染卡顿

从 gitlab 配置管理聊聊团队项目管理

让 snoop 支持 .NET Core WPF 调试

开源公共组件仓库的更新日志应该如何写

更新日志是什么？

为何要提供更新日志？

哪些人需要更新日志？

怎样制作高质量的更新日志？

如何减少维护更新日志的精力？

添加更改链接

asp dotnet core 不正经的提升效率的单元测试方法

CUnit 中文命名单元测试

利用原有依赖注入

asp dotnet core 从零开始创建一个 WebApi 服务

VisualStudio

设置访问端口

发布应用

docker 发布

Xamarin iOS 部署版本大于手机的系统版本

Xamarin iOS 部署项目提示 Failed to register bundle identifier 失败

Xamarin XamlCTask 任务不支持 ValidateOnly 参数

Xamarin 使用 GTK 提示找不到 libglib-2.0-0.dll 找不到

Xamarin 从零开始部署 iOS 上的 Walterlv.CloudKeyboard 应用

Xamarin Forms 进度条控件

Xamarin Forms 4.7 支持更简化的 Grid 行列布局写法

Xamarin Forms 构建 WPF 版项目失败提示 XamlC error XFC0000 错误

为什么使用 GUID 做文件名不是好主意

文件名冲突

文件长度

文件名更短

更高的性能

安全性不变

为何 WPF 对 vcruntime140 有引用

为何 C# 的指针不是可空类型

为什么 WPF 软件在 win7 启动时会尝试调起 wisptis 进程

WPF 从零手动创建承载 Xamarin Forms 项目

WPF 绑定继承的样式提示 只能根据带有基类型 IFrameworkInputElement 的目标类型的 Style 样式

Xamarin.Forms 选取文件让用户选择本地文件

Xamarin 构建安卓失败因为路径太长

Xamarin.Forms 按钮样式圆角按钮

WPF 绑定继承的样式提示只能根据带有基类型 IFrameworkInputElement 的目标类型的 Style 样式

程序猿修养给属性一个单位

编程思想定义过滤的方式解耦

程序猿修养使用 NuGet 发射卫星只需要三步

程序猿修养从安装 dotnet 开始

asp dotnet core 记一次应用拒绝响应调试开启线程等待同步用光线程池

dotnet 双缓存数据结构设计下载库的文件写入缓存框架

Office 文档文本排版布局中华人民共和国国家标准标点符号用法

推荐官方开源 PInvoke 库包含大量 win32 封装