# wpf开发系列

# nuget工具篇

### nuget包工具命令

```
//删除包
dotnet nuget delete -s https://nuget.lingyanspace.com/v3/index.json LingYanAutoUpdate 1.0.0 -k nugetlingyanspace --non-interactive


```

# 打包篇

## inno 

### 中文环境【ChineseSimplified.isl】

[ChineseSimplified.isl](https://book.lingyanspace.com/attachments/2)

### isl环境中文

```
Name: "english"; MessagesFile: "compiler:Default.isl"
Name: "chinesesimplified"; MessagesFile: "compiler:Languages\ChineseSimplified.isl"
```

# 基础篇

### 依赖属性propdb

```c#
        public int MyProperty
        {
            get { return (int)GetValue(MyPropertyProperty); }
            set { SetValue(MyPropertyProperty, value); }
        }

        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty MyPropertyProperty =
            DependencyProperty.Register("MyProperty", typeof(int), typeof(ownerclass), new PropertyMetadata(0));
```

### 附加属性propa

```c#
    public static int GetMyProperty(DependencyObject obj)
    {
        return (int)obj.GetValue(MyPropertyProperty);
    }

    public static void SetMyProperty(DependencyObject obj, int value)
    {
        obj.SetValue(MyPropertyProperty, value);
    }

    // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty MyPropertyProperty =
        DependencyProperty.RegisterAttached("MyProperty", typeof(int), typeof(ownerclass), new PropertyMetadata(0));
```

## xaml资源键类型

<table id="bkmrk-%E5%AE%9A%E4%B9%89%E6%96%B9%E5%BC%8F-%E4%BC%98%E7%82%B9-%E7%BC%BA%E7%82%B9-%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF-%E6%99%AE%E9%80%9A%E5%AD%97%E7%AC%A6"><thead><tr><th>定义方式</th><th>优点</th><th>缺点</th><th>适用场景</th></tr></thead><tbody><tr><td>**普通字符串键**</td><td>简单直观，易于使用</td><td>命名冲突风险，无法跨程序集共享</td><td>小型项目，局部资源</td></tr><tr><td>**类型键**</td><td>自动应用，无需显式引用</td><td>灵活性较低</td><td>全局样式，基础样式复用</td></tr><tr><td>**静态资源键**</td><td>强类型支持，可维护性高</td><td>定义稍复杂</td><td>大型项目，组件化开发</td></tr><tr><td>**`ComponentResourceKey`**</td><td>跨程序集支持，语义化标识</td><td>定义和使用复杂</td><td>组件库开发，主题或样式库</td></tr><tr><td>**动态资源键**</td><td>动态绑定，灵活性高</td><td>性能开销</td><td>主题切换，多语言支持</td></tr></tbody></table>

```nginx
//普通字符串键
<Style x:Key="MyButtonStyle" TargetType="Button" />

//类型键（隐式样式）
<Style TargetType="Button">
    <Setter Property="Background" Value="LightBlue" />
</Style>

//静态资源键
public static class ResourceKeys
{
    public static readonly string CloseButtonStyle = "CloseButtonStyle";
}

<Style x:Key="{x:Static local:ResourceKeys.CloseButtonStyle}" TargetType="Button" />

//组件资源键ComponentResourceKey

    public partial class DataTemplateKeys
    {
        public static ComponentResourceKey ItemClose => new ComponentResourceKey(typeof(DataTemplateKeys), "S.DataTemplate.Item.Close");
    }
<DataTemplate x:Key="{ComponentResourceKey ResourceId=S.DataTemplate.Item.Close, TypeInTargetAssembly={x:Type local:DataTemplateKeys}}">

//静态资源键与组件资源键结合

public static class ResourceKeys
{
    public static readonly ComponentResourceKey CloseButtonStyleKey = new ComponentResourceKey(typeof(ResourceKeys), "CloseButtonStyle");
}

<Style x:Key="{x:Static local:ResourceKeys.CloseButtonStyleKey}" TargetType="Button" />

//动态资源键
<Button Style="{DynamicResource MyButtonStyle}" />
```

# 编译篇

### 编译后事件

```c#
:: 检查Lib、Dll文件夹路径是否存在
IF NOT EXIST "$(TargetDir)libs" (
    MD "$(TargetDir)libs"
)

:: 将指定的dll、xml、pdb、config文件移动到libs文件夹
move "$(TargetDir)*.dll" "$(TargetDir)libs"
move "$(TargetDir)*.xml" "$(TargetDir)libs"
move "$(TargetDir)*.pdb" "$(TargetDir)libs"
move "$(TargetDir)*.config" "$(TargetDir)libs"

:: 将runtimes文件夹移动到libs文件夹
move "$(TargetDir)runtimes" "$(TargetDir)libs"

:: 把主程序的相关文件从libs转移出来
move "$(TargetDir)libs\NLog.config" "$(TargetDir)NLog.config"
move "$(TargetDir)libs\$(ProjectName).exe.config" "$(TargetDir)$(ProjectName).exe.config"
move "$(TargetDir)libs\$(ProjectName).exe.xml" "$(TargetDir)$(ProjectName).exe.xml"
move "$(TargetDir)libs\$(ProjectName).pdb" "$(TargetDir)$(ProjectName).pdb"
```

### 加扫描文件夹

```
 <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <!-- 添加对libs文件夹的搜索路径 -->
      <probing privatePath="libs"/>      
    </assemblyBinding>
  </runtime>
```

# 扩展篇

### HttpCilent发送文件有进度

```
try
            {
                var lcaolSelectTeam = await this.ToGetSelectTeam();
                if (lcaolSelectTeam.Code != 20000)
                {
                    throw new Exception(lcaolSelectTeam.Message);
                }
                var localToken = await this.ToGetUserToken();
                if (localToken.Code != 20000)
                {
                    throw new Exception(localToken.Message);
                }
                var taskworkFloderBody = await this.ToGetTaskworkProxyFloder();
                if (taskworkFloderBody.Code != 20000)
                {
                    throw new Exception(taskworkFloderBody.Message);
                }
                var rootTaskworkFloder = taskworkFloderBody.Data.PathCombine(teamTaskwrokId.ToString());
                HttpClientHandler handler = new HttpClientHandler();
                ProgressMessageHandler progressMessageHandler = new ProgressMessageHandler(handler);
                progressMessageHandler.HttpSendProgress += (sender, e) =>
                {
                    action.Invoke(e.ProgressPercentage);
                };
                using (HttpClient httpClient = new HttpClient(progressMessageHandler))
                {
                    httpClient.BaseAddress = new Uri("https://lycg.lingyanspace.com/");
                    httpClient.DefaultRequestHeaders.Add("Authorization", localToken.Data);
                    using (var multipartFormData = new MultipartFormDataContent())
                    {
                        var bom = rootTaskworkFloder.PathCombine("bom").FileCombine("default.json");
                        if (File.Exists(bom) && needUploadCloudModel.BOM)
                        {
                            AddFile(multipartFormData, "bom", bom);
                        }
                        var bIfc = rootTaskworkFloder.PathCombine("bifc").FileCombine("default.ifc");
                        if (File.Exists(bIfc) && needUploadCloudModel.BIFC)
                        {
                            AddFile(multipartFormData, "bIfc", bIfc);
                        }
                        var nc1Files = Directory.GetFiles(rootTaskworkFloder.PathCombine("nc1"), "*.nc1", SearchOption.TopDirectoryOnly).ToList();
                        if (nc1Files != null && nc1Files.Count > 0 && needUploadCloudModel.NC1)
                        {
                            nc1Files.ForEach(f =>
                            {
                                AddFile(multipartFormData, "nc1Files", f);
                            });
                        }
                        var dxfFiles = Directory.GetFiles(rootTaskworkFloder.PathCombine("dxf"), "*.dxf", SearchOption.TopDirectoryOnly).ToList();
                        if (dxfFiles != null && dxfFiles.Count > 0 && needUploadCloudModel.DXF)
                        {
                            dxfFiles.ForEach(f =>
                            {
                                AddFile(multipartFormData, "dxfFiles", f);
                            });
                        }
                        var aifcFiles = Directory.GetFiles(rootTaskworkFloder.PathCombine("aifc"), "*.ifc", SearchOption.TopDirectoryOnly).ToList();
                        if (aifcFiles != null && aifcFiles.Count > 0 && needUploadCloudModel.AIFC)
                        {
                            aifcFiles.ForEach(f =>
                            {
                                AddFile(multipartFormData, "aifcFiles", f);
                            });
                        }
                        var pifcFiles = Directory.GetFiles(rootTaskworkFloder.PathCombine("pifc"), "*.ifc", SearchOption.TopDirectoryOnly).ToList();
                        if (pifcFiles != null && pifcFiles.Count > 0 && needUploadCloudModel.PIFC)
                        {
                            pifcFiles.ForEach(f =>
                            {
                                AddFile(multipartFormData, "pifcFiles", f);
                            });
                        }
                        var drawingFiles = Directory.GetFiles(rootTaskworkFloder.PathCombine("drawing"), "*.pdf", SearchOption.TopDirectoryOnly).
                            Concat(Directory.GetFiles(rootTaskworkFloder.PathCombine("drawing"), "*.dwg", SearchOption.TopDirectoryOnly)).ToList();
                        if (drawingFiles != null && drawingFiles.Count > 0 && needUploadCloudModel.Drawing)
                        {
                            drawingFiles.ForEach(f =>
                            {
                                AddFile(multipartFormData, "drawingFiles", f);
                            });
                        }
                        var response = await httpClient.PutAsync($"/api/Team/UploadTeamTaskworkBatchData?teamId={lcaolSelectTeam.Data.Id}&teamTaskwrokId={teamTaskwrokId}", multipartFormData);
                        if (response.IsSuccessStatusCode)
                        {
                            var data = await response.Content.ReadAsStringAsync();
                            var jsonBody = JsonConvert.DeserializeObject<ResponceBody<string>>(data);
                            return jsonBody;
                        }
                        else
                        {
                            throw new Exception(await response.Content.ReadAsStringAsync());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return new ResponceBody<string>(40000, ex.Message, null);
            }
```

### 编号排序

```

    public class StringSortComparer : IComparer<string>
    {
        public bool MatchCase { get; }
        public StringSortComparer(bool matchCase)
        {
            MatchCase = matchCase;
        }
        private int CharCompare(char a, char b, bool matchCase)
        {
            char _a = char.MinValue, _b = char.MinValue;
            if (matchCase) { _a = a; _b = b; }
            else { _a = char.ToUpper(a); _b = char.ToUpper(b); }
            if (_a > _b) return 1;
            if (_a < _b) return -1;
            return 0;
        }
        public int Compare(string x, string y)
        {
            // 如果 y 为空，则 y 应该排在最后面
            if (string.IsNullOrEmpty(y)) return -1;
            // 如果 x 为空，而 y 不为空，则 x 应该排在 y 之前
            if (string.IsNullOrEmpty(x)) return 1;
            int len;
            if (x.Length > y.Length) len = x.Length;
            else len = y.Length;
            string numericx = "";
            string numericy = "";
            for (int i = 0; i < len; i++)
            {
                char cx = char.MinValue;
                char cy = char.MinValue;
                if (i < x.Length) cx = x[i];
                if (i < y.Length) cy = y[i];
                if (cx >= 48 && cx <= 57) numericx += cx;
                if (cy >= 48 && cy <= 57) numericy += cy;
                if (i == len - 1)
                {
                    if (numericx.Length > 0 && numericy.Length > 0)
                    {
                        if (decimal.Parse(numericx) < decimal.Parse(numericy)) return -1;
                        if (decimal.Parse(numericx) > decimal.Parse(numericy)) return 1;
                    }
                    return CharCompare(cy, cy, MatchCase);
                }
                if ((cx >= 48 && cx <= 57) && (cy >= 48 && cy <= 57)) continue;
                if (numericx.Length > 0 && numericy.Length > 0)
                {
                    if (decimal.Parse(numericx) < decimal.Parse(numericy)) return -1;
                    if (decimal.Parse(numericx) > decimal.Parse(numericy)) return 1;
                }
                if (CharCompare(cx, cy, MatchCase) == 0) continue;
                return CharCompare(cx, cy, MatchCase);
            }
            return 0;
        }
    }
```

### 下载文件进度

```
 public class HttpHelper
    {
        /// <summary>
        /// 下载单个文件
        /// </summary>
        /// <param name="action"></param>
        /// <param name="netWrokUrl"></param>
        /// <param name="localUrl"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static async Task<long> DownloadSingleFile(Action<double> action, string netWrokUrl, string localUrl)
        {
            long totalBytesReceived = 0;
            var progress = new Progress<HttpDownloadProgress>(p =>
            {
                if (p.TotalBytesToReceive.HasValue)
                {
                    totalBytesReceived = (long)p.BytesReceived;
                    double percent = (double)p.BytesReceived / p.TotalBytesToReceive.Value * 100.0;
                    action.Invoke(percent);
                }
                else
                {
                    LoggerHelper.DefaultLogger($"特殊情况：{netWrokUrl}的TotalBytesToReceive无值");
                }
            });
            var fileBytes = await new HttpClient().GetByteArrayAsync(new Uri(netWrokUrl), progress, CancellationToken.None);
            if (File.Exists(localUrl))
            {
                File.Delete(localUrl);
            }
            await localUrl.SaveLocalFileAsync(new MemoryStream(fileBytes));
            return totalBytesReceived;
        }
        private static async Task<long> DownloadSingleFile(Action<long, long> progressAction, string networkUrl, string localUrl, long totalBytes)
        {
            long bytesReceived = 0;
            var progress = new Progress<HttpDownloadProgress>(p =>
            {
                bytesReceived = (long)p.BytesReceived;
                progressAction(bytesReceived, totalBytes);
            });
            using (var httpClient = new HttpClient())
            {
                var fileBytes = await httpClient.GetByteArrayAsync(new Uri(networkUrl), progress, CancellationToken.None);
                if (File.Exists(localUrl))
                {
                    File.Delete(localUrl);
                }
                using (var fileStream = new FileStream(localUrl, FileMode.CreateNew))
                {
                    await fileStream.WriteAsync(fileBytes, 0, fileBytes.Length);
                }
                return bytesReceived;
            }
        }
        /// <summary>
        /// 下载文件集合
        /// </summary>
        /// <param name="overallProgressAction"></param>
        /// <param name="files"></param>
        /// <returns></returns>
        public static async Task DownloadMultipleFiles(Action<double> overallProgressAction,Dictionary<string, string> files)
        {
            var downloadTasks = new List<Task<long>>();
            long totalFileSize = 0;
            Dictionary<string, long> fileSizes = new Dictionary<string, long>();
            // 首先，预估所有文件的大小（可以通过HEAD请求或是其他方式获取）
            using (var httpClient = new HttpClient())
            {
                foreach (var file in files)
                {
                    var response = await httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, file.Key));
                    long contentLength = response.Content.Headers.ContentLength ?? 0;
                    fileSizes[file.Key] = contentLength;
                    totalFileSize += contentLength;
                }
            }
            // 存储每个文件的已接收字节
            Dictionary<string, long> receivedBytes = new Dictionary<string, long>();
            foreach (var file in files)
            {
                string networkUrl = file.Key;
                string localUrl = file.Value;
                Task<long> downloadTask = DownloadSingleFile(
                    (bytesReceived, totalBytes) =>
                    {
                        receivedBytes[networkUrl] = bytesReceived;
                        // 计算总体进度
                        long totalReceived = 0;
                        foreach (var received in receivedBytes.Values)
                        {
                            totalReceived += received;
                        }
                        double overallProgress = (double)totalReceived / totalFileSize * 100.0;
                        overallProgressAction(overallProgress);
                    },
                    networkUrl,
                    localUrl,
                    fileSizes[networkUrl]
                );
                downloadTasks.Add(downloadTask);
            }
            // 等待所有下载任务完成
            long[] results = await Task.WhenAll(downloadTasks);
        }
    }
```

### 下载byte

```
 public static class HttpClientExtension
    {
        private const int BufferSize = 262144;

        public static async Task<byte[]> GetByteArrayAsync(this HttpClient client, Uri requestUri, IProgress<HttpDownloadProgress> progress, CancellationToken cancellationToken)
        {
            if (client == null)
            {
                throw new ArgumentNullException(nameof(client));
            }

            using (var responseMessage = await client.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))
            {
                responseMessage.EnsureSuccessStatusCode();

                var content = responseMessage.Content;
                if (content == null)
                {
                    return Array.Empty<byte>();
                }

                var headers = content.Headers;
                var contentLength = headers.ContentLength;
                using (var responseStream = await content.ReadAsStreamAsync().ConfigureAwait(false))
                {
                    var buffer = new byte[BufferSize];
                    int bytesRead;
                    var bytes = new List<byte>();

                    var downloadProgress = new HttpDownloadProgress();
                    if (contentLength.HasValue)
                    {
                        downloadProgress.TotalBytesToReceive = (ulong)contentLength.Value;
                    }
                    progress?.Report(downloadProgress);

                    while ((bytesRead = await responseStream.ReadAsync(buffer, 0, BufferSize, cancellationToken).ConfigureAwait(false)) > 0)
                    {
                        bytes.AddRange(buffer.Take(bytesRead));

                        downloadProgress.BytesReceived += (ulong)bytesRead;
                        progress?.Report(downloadProgress);
                    }

                    return bytes.ToArray();
                }
            }
        }
    }
    public struct HttpDownloadProgress
    {
        public ulong BytesReceived { get; set; }

        public ulong? TotalBytesToReceive { get; set; }
    }
```