春暖花开

windows10企业版 LTSC 安装官方便签

Thu, 18 Apr 2024 14:25:41 +0800

平时很喜欢windows10的“便签”应用，而平常没做完的工作需要第二天继续完成。我比较喜欢使用便签来提醒自己。

但 windows10企业版 LTSC默认不带 “便签”应用。经过各方查询，最终安装成功。

具体步骤：

1、下载自带应用

打开 https://store.rg-adguard.net/ 网址，

左侧选择 PackageFamilyName ，右侧输入 Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe，点击搜索。

选择 Microsoft.MicrosoftStickyNotes_3.7.106.0_neutral_~_8wekyb3d8bbwe.appxbundle 下载。注意要是[.appxbundle]格式。

2、以管理员身份打开 Powershell,

先使用:

cd 安装软件目录路径

以下是我的便签appxbundle文件路径，请根据您的实际情况修改。

cd D:\Users\MG\Downloads

进入安装目录。

3、执行安装命令。

Add-AppPackage Microsoft.MicrosoftStickyNotes_3.7.106.0_neutral___8wekyb3d8bbwe.AppxBundle

在安装时，如出现了错误。提示以下内容：

解决方法如下：

查看错误信息，是哪个框架没有安装，例如上面的错误提示：Microsoft.NET.Native.Framework.2.2 没有安装。那就先安装这个框架。

在上面打开的 https://store.rg-adguard.net/ 网站中找到以下3个软件(注：我的系统是X64，请注意您的操作系统类型)：

Microsoft.NET.Native.Framework.2.2_2.2.29512.0_x64__8wekyb3d8bbwe.Appx
Microsoft.NET.Native.Runtime.2.2_2.2.28604.0_x64__8wekyb3d8bbwe.Appx
Microsoft.VCLibs.140.00_14.0.33519.0_x64__8wekyb3d8bbwe.Appx

以上3个软件，可能版本号不同，但前面是一样，并且是.Appx格式的。

安装框架成功后，返回地3步进行安装“便签”应用。

安装完成后，重启电脑，即可使用“便签”应用了。

Z-BlogPHP 显示错误 Undefined array key "pro" 临时解决办法

Tue, 16 Apr 2024 16:33:53 +0800

今天将博客整站换了99一年的阿里云：2核2G云服务器，使用了宝塔推荐的PHP8.0版本。但某些文章打开或显示错误。

提示：Undefined array key "pro" 错误。

百度了一圈没有找到解决办法。在官方论坛里也没找到解决办法。

最后，对比了一下原服务器的宝塔PHP版本发现，PHP是7.4版本。

将PHP版本切换到7.4解决此问题。

使用的是主题：拓源纯净主题

如果您也遇到这个问题可以试一下这个临时解决办法。

PS：引发问题可能是PHP版本某些变量不一样所导致。只能等拓源大佬修复这个BUG。

Stable Diffusion 的 Controlnet基础知识

Tue, 16 Apr 2024 15:12:50 +0800

ControlNet是一个用于深度神经网络的控制技术，它可以通过操作神经网络块的输入条件来控制神经网络的行为。在这里，“网络块”是指常用的神经层集合，例如“resnet”块、“conv-bn-relu”块、多头注意力块等。通过克隆神经网络块的参数并应用零卷积连接层来实现ControlNet的目标。

设计原理

从文生图，到图生图，到局部重绘，到controlnet，我们从更多的维度上试图控制扩散模型的输出结果

约束分类

一、线条约束

canny边缘检测：精准的边缘检测
had边缘检测：保留轮廓细节的边缘检测
M-LSD边缘检测：对直线进行检测(主要针对建筑)
伪涂鸦:粗线条大概还原
涂鸦:可以自己创建画板，进行涂鸦，在生成图片

二、姿势约束

openpose姿态检测：对身体的骨骼进行
openpose姿态+手部检测：加上了手部骨骼，师徒解决手的问题

三、深度约束

Mida深度估算
LeRes深度估算
法线贴图

四、物品类型约束

语义分割：大江户战士(B站)

五、色彩约束

color模式

六、风格约束

clip_version

参数

反色模式

低显存优化

无提示词模式

预处理器:把图片特征处理出来

模型:让stable diffusion模型学会理解某一类图片

权重:在多大程度上，特征图片影像生成的图片(一般0.6-1.1)

引导时机

引导介入时机:从哪里开始引导
引导退出时机:从哪里退出引导

预处理器分辨率(Annotator resolution)

阈值

low threshold
high threshold

画面缩放模式

一般情况下，我们要求controlnet用图和生成的图分辨率一致

分类

信封模式(裁切原图)
缩放模式(扩展原图)
仅调整大小(缩放)

画布模式

创建空白画布
画布宽度
画布高度

预览

预览预处理结果
隐藏预处理预览

建筑推荐的预处理器

Canny(边缘检测):接近淘汰

Depth(图片深度信息)

depth_leres(LeReS 深度图估算)
depth_midas(MiDaS 深度图估算)
depth_zoe(ZoE 深度图估算)→常用

→对应模型

control_v11f1p_sd15_depth

Lineart(线稿分析)

Lineart_anime(动漫线稿提取)
Lineart_coarse(粗略线稿提取)
Lineart_realistic(写实线稿提取)→常用
Lineart_standard(from white bg & black line)

→对应模型

control_v11p_sd15s2_lineart_anime

control_v11p_sd15_lineart

Mlsd(直线线条检测)

Seg(语义分析)

seg_ofade20k(语义分割 - OneFormer 算法 - ADE20k协议)
seg_ofcoco(语义分割 - OneFormer算法 - COCO协议)
seg_ufade20k(语义分割 - UniFormer 算法 - ADE20k协议)

→对应模型

control_v11p_sd15_seg

总结：

深度图是为了区别建筑的前后体量关系
线稿是为了控制形体轮廓的生成
语义分割是为了生成建筑的区域
弄清楚三者控制的项目，以及掌握起始与终止步数的原理，才能更好的生成我们想要的图片

提示词

在生成建筑图时

使用建筑模型：使用自然语言(像小作文一样的话语) 会更好的生成建筑图
使用人物模型：使用单词(只输入关键词) 会更好的生成建筑图

线稿图使用结论

对于线稿图

线稿不是越细致越好，避免涂抹阴影，只留轮廓线和结构线

对于Controlnet

Canny尽量不要在使用
模式选择：自由模式>均衡模式>以提示词为主
推荐使用：lineart>mlsd>normalbae>scrible>softedge

Reference预处理

reference_adain(仅参考输入图-自适应实例规范)
reference_adain+attn(仅参考输入图-自适应实例规范+Attention链接)
reference_only(仅参考输入图)

概要

它没有模型，只需要更新Controlnet到最新版本，预处理器里就会有三个选项
底模非常重要，因为它会识别并根据底模数据来生成新的图，如果底模不合适，会出来过曝或者过暗的图片

概要

生成的图片质量：reference_adain+attn>reference_adain>reference_only
生成图片的与参考图的相似度：均衡>自由模式>提示词为主
均衡模式下，参数越低，越接近设计底图，参数越高，越接近参考图

Stable Diffusion 学习笔记

Tue, 16 Apr 2024 14:05:52 +0800

Stable Diffusion 是一款由 Stability AI 开发的开源人工智能（AI）绘画工具，专注于基于文本输入生成高质量、高分辨率的图像。自2023年以来，它已成为AI生成内容（AIGC）领域内非常热门且具有影响力的项目之一，因其强大的图像生成能力和广泛的应用潜力而受到广泛关注。以下是关于 Stable Diffusion 的详细介绍：

核心技术

潜在扩散模型（Latent Diffusion Models, LDMs）

Stable Diffusion 基于潜在扩散模型（LDMs），这是一种结合了扩散模型与变分自编码器（VAEs）思想的深度学习架构。LDMs 将扩散过程从原始的像素空间转移到一个低维的、更具表征能力的隐空间，以此来简化计算、减少内存需求，并使模型更聚焦于语义信息。

扩散过程

扩散模型利用逆向的随机过程来逐步从纯噪声中生成清晰图像。Stable Diffusion 实现这一过程的具体方法是对高斯噪声进行迭代扩散，利用 Langevin 动力学模拟粒子在能量场中的运动，通过一系列微小的步骤逐渐构造出目标图像。模型在训练过程中学习如何从初始噪声状态逐渐还原出真实数据分布。

关键特性：

温度参数（Temperature）：在扩散过程中引入温度参数 T 来控制分布的扩散程度。随着训练的进行，T 逐渐降低，使得分布逐渐收缩，从而提高采样的质量和图像的保真度。

迭代去噪：模型执行一系列去噪步骤，在每个步骤中通过一个 U-Net 结构或其他类型的神经网络来估计并去除噪声，逐步恢复图像的细节和清晰度。这种设计有助于模型在保持生成图像多样性的同时，对条件控制（如文本描述）做出更准确的响应。

文本编码

Stable Diffusion 使用先进的文本编码器，如 OpenCLIP，将用户提供的自然语言文本转化为向量表示。这种向量能够捕获文本的语义信息，并与图像空间对齐，使得模型能够在生成图像时精确地遵循文本描述。

特点与优势

高质量图像生成：Stable Diffusion 能够生成细节丰富、高清、逼真的图像，其生成效果显著优于早期的粗陋玩具模型，展现出高度的艺术性和专业级视觉质量。

文本驱动：用户只需提供一段文本描述，即可指导 Stable Diffusion 生成与其描述相符的图像，实现了从文本到图像的高效跨模态转换。

开源与可部署：作为一个开源项目，Stable Diffusion 拥有广泛的社区支持，允许任何人免费下载、部署和使用，促进了技术的普及和创新应用的发展。

灵活性与适应性：不仅适用于个人创意表达、数字艺术创作，还能够在计算机视觉、视频游戏、虚拟现实、广告设计等多个领域找到应用，展现了极高的应用灵活性和适应性。

应用与扩展

围绕 Stable Diffusion，开源社区构建了众多集成应用和衍生项目，如 Stable Diffusion WebUI、ComfyUI、Fooocus 等，这些项目提供了用户友好的界面和便捷的功能，使得非技术用户也能轻松利用 Stable Diffusion 进行创作。此外，模型分享和定制化训练也促进了 Stable Diffusion 在特定场景下的专业化应用。

综上所述，Stable Diffusion 是一款基于前沿扩散模型技术的文本到图像生成工具，以其高质量图像生成能力、文本驱动特性、开源属性以及广泛的应用前景，在AI绘画和AIGC领域占据重要地位。随着技术的持续发展和社区支持的不断壮大，Stable Diffusion 有望继续推动相关领域的创新与进步。

个人笔记：

模型分类：

VAE：

全名Variational autoencoder,中文名变分自编码器

作用：滤镜+微调

emdding：

又名textual inversion，中文名嵌入or文本反转，通俗理解：提示词打包，可以将一段非常长的描述词打包成一个词直接调用。

下载：https://civitai.com/

Lora：

全称Low-Rank Adaptation of Large Language Models，直译为大语言模型的低阶适应，这是微软的研究人员为了解决大语言模型微调而开发的一项技术。

只要是图片特征几乎都可以训练，无论是动作、画风、物品细节、人物细节。

下载：https://civitai.com/

hypernetworks：

可以理解为是低配版的Lora

检查下载的文件是什么模型：https://spell.novelai.dev/

提示词基础知识

正面提示词(想要什么写什么):

masterpiece, best quality, 8k, highres,

反面提示词(不想要什么写什么):

((nsfw)), lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry

分类思路

比如描述一个女孩可分为:

画质:masterpiece,best quality,8k,highres,

主题:photo of girl

人物属性描写:头发长短，头发颜色，身材胖瘦...

人物衣服:西服，太阳镜，帽子，高跟鞋...

背景:街道，森林，城市，卧室，厨房...

画风:现实...

镜头:全身，半身，大头贴

其他:太阳，冬天，温暖...

PS:只能用英语，并用","隔开

书写格式

一、内容

(1).单词:案例：1boy,handsome,sitting,sofa

(2).词组:案例：1handsome boy,sitting on the sofa

(3).短语:案例：1handsome boy is sitting on the sofa

二、分割

1.不同的关键词tag之间，需要使用英文逗号分割，逗号前后有空格或者换行是不碍事的。

2.两个词之间的空格有变化的

3.越在前面的提示词权重越高，所以主体应该放在前面

4.,+空格是有效果的

5.描述同一类别的内容，会分别/混合出现

三、增强/减弱

1.(提示词:权重数值)

数值从0.1~100，默认状态是1，低于1就是减弱，大于1就是加强

(loli),(one girl:1.21),(cat ears:1.1)

2.(提示词)或[提示词]

每套一层()括号增强1.1倍，每套一层[]减弱1.1倍，也就是套两层是1.1*1.1=1.21倍，套三层是1.331倍，套4层是1.4641倍

((loli)),((one girl)),(cat ears),[flower hairpin]

四、混合

1.用 AND 把多种要素强制融合画进去：

1cat AND 1dog

2.可以 : 数字增加权重：

1cat:1.5 AND 1dog AND 1tiger

五、渐变

1.[关键词1:关键词2:数字],[from:to:when]

数字大于1理解为第X步前为关键词1，第X步后变成关键词2

1man:flower:20

数字小于1理解为总步数的百分之X前为关键词1，之后变成关键词2

1man:flower:0.5

2.[关键词:数字],[to:when]：从XX比例/步开始画

flower:20
[flower:0.5]

3.[关键词::数字],[from::when]：到XX比例/步截止画

[flower::0.5]
[flower::20]

六、交替验算

语法：[关键词1|关键词2]

轮流使用关键词生成,某物与某物的交替演算，跟偏向与前面那个词

[cat|dog]

七、embedding

有些提示词其实是embedding

八、lora/hypernetwork

文生图参数

一、宽度高度

分辨率大小如何设置？

过小的分辨率会导致图片生成质量低
分辨率至少有一个参数(宽度或高度)在512-768之间

如何生成大图？

建议先生成小图，在用高清修复进行放大

宽度高度和性能的关系？

分辨率越大，显存占用就越大，生成时间变慢

人物比例不协调咋办？

分辨率设置不合理会导致

点击上下箭头按钮

交换宽高

二、生成多张

生成批次

每次生成(每批数量)张
种子每次随机：如果随机种子固定，则每次种子数+1

每批数量

同时生成多张，每张种子数+1
拉高容易爆显存

提示词相关性

定义：Classifier-free guidance(CFG) scale (CGF指数) 用来调节文本提示对扩散过程的引导程度。数值较高时会向你的提示进行生成

技巧：

CFG为0-1时，图像崩坏
CFG处于2-6时，生成图像比较有想象力
CFG处于7-12效果较好，既有创意也有能遵循我们的文本提示
CFG处于10-15时，提示词更多影响作品，对比度饱和度上升
CFG处于18-30时，画面逐渐崩坏，拉高采样迭代步数可以降低崩坏程度

随机种子

简单理解：生成不同的噪点图

内置插件

一、XYZ对照工具

语法：

每次增加1

1-5=1,2,3,4,5

不同步长的方法

1-5(+2)=1,3,5
10-5(-3)=10,7
1-3(+0.5)=1,1.5,2,2.5,3

规定范围内分多少个

1-10[5] = 1,3,5,7,10
0.0-1.0[6] = 0.0,0.2,0.4,0.6,0.8,1.0

二、提示词矩阵

语法：

正常提示词|改变提示词1|改变提示词2|改变提示词3....

a busy city street in a modern city|illustration|cinematic lighting

a busy city street in a modern city
a busy city street in a modern city, illustration
a busy city street in a modern city, cinematic lighting
a busy city street in a modern city, illustration, cinematic lighting

批量生成

每一行为一张图。每个参数用--作为开头，空格作为分割

可控制参数

"sd_model",
"prompt",
"negative_prompt",
"seed",
"subseed_strength",
"subseed",
"seed_resize_from_h",
"seed_resize_from_w",
"sampler_index",
"sampler_name",
"batch_size",
"n_iter",
"steps",
"cfg_scale",
"width",
"height",
"restore_faces",
"tiling",
"do_not_save_samples",
"do_not_save_grid",
"outpath_samples",
"outpath_grids",
"prompt_for_display",
"styles",

案例

--prompt "photo of sunset"
--prompt "photo of sunset" --negative_prompt "orange,pink,red,sea,water,lake" --width 1024 --height 768 --sampler name "DPM++ 2M Karras" --steps 10 --batch_size 2 --cfg_scale 3 --seed 9
--prompt "photo of winter mountains" --steps 7 --sampler_name "DDIM"
--prompt "photo of winter mountains" --width 1024

拓源纯净主题tpure 修改站长简介 [图标]

Fri, 20 Jan 2023 13:41:57 +0800

问题：我需要把微博图标修改成B站的图标。

拓源纯净主题tpure 修改站长简介 [图标]

1.先根据以下步骤生成要添加的图标。

拓源纯净主题添加导航栏目图标的方法

2.在阿里矢量图找到B站图标，并记录 Unicode(16进制) 名称。

3.找到 ..\zb_users\theme\tpure\style\style.css 文件内容：

p a.weibo{border:1px solid #e6162d}.sideuserlink 
p a.weibo::after{content:"\e612";font-size:32px;color:#e6162d}.sideuserlink

修改里面的“#e6162d”颜色信息和 "\e612"Unicode(16进制) 名称信息。

修改后内容

p a.weibo{border:1px solid #00AEEC}.sideuserlink 
p a.weibo::after{content:"\a25";font-size:32px;color:#00AEEC}.sideuserlink

4.找到..\zb_users\theme\tpure\language\下的 zh-cn.php和zh-tw.php里面的“微博”，改成“Bilibili”。

5.最后把 style.css、zh-cn.php和zh-tw.php文件上传到网站并覆盖。(注意先备份一份原始文件)

6.进入后台→主题设置→侧栏设置→保存设置→打开首页按ctrl+F5 强制刷新即可。

群晖NAS 部署webdav 文件大小解除限制

Thu, 19 Jan 2023 14:41:08 +0800

在公司群晖NAS部署了webdav，但在家里的Windows10系统映射网络磁盘，复制资料会显示“0x800700DF: 文件大小超过允许的限制，无法保存”。

解决方法

只需要修改注册表后重启电脑。

步骤：

1.运行（组合键win+R）

2.打开注册表（键入regedit）

3.复制路径粘贴在顶部 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters

4.在右窗格中，右键单击 FileSizeLimitInBytes值，然后单击修改。

如果看不到FileSizeLimitInBytes值，右键单击右窗格中的空白区域，单击新建，单击DWORD 值，键入FileSizeLimitInBytes，然后单击OK.

十六进制下输入ffffffff（最大值），或者十进制下输入4294967295（最大值）

退出注册表编辑器，并重新启动电脑。

C# 集合数据处理的常用方法

Sun, 20 Jan 2019 19:34:27 +0800

集合（Collection）类是专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。

集合（Collection）类服务于不同的目的，如为元素动态分配内存，基于索引访问列表项等等。这些类创建 Object 类的对象的集合。在 C# 中，Object 类是所有数据类型的基类。

所有集合都实现了IEnumerable接口，在这个接口中已经有了Where方法，使用扩展方法添加自己的MyWhere方法：

using System;
using System.Collections.Generic;

namespace 集合扩展方法
{
    class Program
    {
        static void Main(string[] args)
        {

            int[] nums = { 5, 5, 6, 9, 5, 2, 3, 6, 4, 12, 15, 4, 6, 18, 2, 3, 5, 6, 4, 8 };//整型数组
            IEnumerable<int> r = nums.MyWhere(i => i > 8);//调用扩展方法，判断 i是否大于8
            foreach (var item in r)//循环
            {
                Console.WriteLine(item);//输出
            }
            string[] strs = { "今天天气很好！", "吃过饭了吗？", "今天去哪里玩？", "明天去吃火锅！", "下个月去旅游。", "钱包里还有多少钱？", "今年多大了？" };//字符串数组
            IEnumerable<string> str = strs.MyWhere(s => s.Contains("？"));//判断字符串是否包含"？"
            foreach (var item in str)//循环
            {
                Console.WriteLine(item);//输出
            }
            Console.ReadKey();
        }
    }
    static class JiHe//静态类
    {
        public static IEnumerable<T> MyWhere<T>(this IEnumerable<T> data, Func<T, bool> func)// 扩展方法，返回 IEnumerable 类型
        {
            List<T> resultList = new List<T>();//声明泛型List
            foreach (var item in data)//循环
            {
                if (func(item))//调用Func委托，判断
                {
                    resultList.Add(item);//添加元素到List列表
                }
            }
            return resultList;//返回
        }
    }
}

生成结果：

集合常用扩展方法：

using System;
using System.Collections.Generic;
using System.Linq;

namespace 常用
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>();//列表
            list.Add(5);//添加元素
            list.Add(7);//添加元素
            list.Add(3);//添加元素
            list.Add(10);//添加元素
            list.Add(25);//添加元素
            list.Add(17);//添加元素
            list.Add(11);//添加元素

            int max = list.Max();//求最大值
            int min = list.Min();//求最小值
            int sum = list.Sum();//求总和
            double avg = list.Average();//求平均值
            Console.WriteLine("最大值: {0}\r\n最小值: {1}\r\n总和: {2}\r\n平均值: {3}\r\n",max,min,sum,avg);//输出
            Console.ReadKey();
        }
    }
}

生成结果：

集合OrderBy扩展方法：

using System;
using System.Collections.Generic;
using System.Linq;

namespace 集合OrderBy
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>();//列表
            list.Add(5);//添加元素
            list.Add(7);//添加元素
            list.Add(3);//添加元素
            list.Add(10);//添加元素
            list.Add(25);//添加元素
            list.Add(17);//添加元素
            list.Add(11);//添加元素

            IEnumerable<int> r = list.OrderBy(i => i);//降序排序
            foreach (var item in r)//循环
            {
                Console.WriteLine(item);//输出
            }
            Console.ReadKey();
        }
    }
}

生成结果：

集合自带的Where扩展方法：(对数据按照lambda表达式进行过滤)

using System;
using System.Collections.Generic;
using System.Linq;

namespace 集合Where
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>();//列表
            list.Add(5);//添加元素
            list.Add(7);//添加元素
            list.Add(3);//添加元素
            list.Add(10);//添加元素
            list.Add(25);//添加元素
            list.Add(17);//添加元素
            list.Add(11);//添加元素

            IEnumerable<int> r = list.Where(i => i > 5);//通过IEnumerable接口实现Where扩展方法，i => i > 5 是 lambda表达式
            foreach (var item in r)//循环
            {
                Console.WriteLine(item);//输出
            }
            Console.ReadKey();
        }
    }
}

生成结果：

集合自带的Select扩展方法：(对集合的数据按照lambda表达式进行处理，生成一个新的集合。集合长度一样。)

using System;
using System.Collections.Generic;
using System.Linq;

namespace 集合Select
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>();//列表
            list.Add(5);//添加元素
            list.Add(7);//添加元素
            list.Add(3);//添加元素
            list.Add(10);//添加元素
            list.Add(25);//添加元素
            list.Add(17);//添加元素
            list.Add(11);//添加元素

            IEnumerable<int> r = list.Select(i => i * 2);//将所有元素 * 2，保存到新表中，元素list表元素不变。
            foreach (var item in r)//循环
            {
                Console.WriteLine(item);//输出
            }
            Console.ReadKey();
        }
    }
}

生成结果：

First、FirstOrDefault、Single、SingleOrDefault扩展方法：

using System;
using System.Linq;

namespace 集合扩展方法1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] strs1 = { };//没有元素的数组
            string[] strs2 = { "A" };//一个元素的数组
            string[] strs3 = { "A", "B" };//大于一个元素的数组

            //string s1 = strs1.First();//抛异常，集合不能为null。
            string s2 = strs2.First();//First 获取集合中的第一个元素，如果集合中一个元素都没有，则抛异常。
            string s3 = strs3.First();//First 获取集合中的第一个元素，如果集合中一个元素都没有，则抛异常。
            Console.WriteLine("s2 获取：" + s2);//输出
            Console.WriteLine("s3 获取：" + s3);//输出

            string s4 = strs1.FirstOrDefault();//FirstOrDefault 获取集合中的第一个元素，如果集合内没有元素，则返回集合类型的默认值。
            string s5 = strs2.FirstOrDefault();
            string s6 = strs3.FirstOrDefault();
            Console.WriteLine("s4 获取：" + s4);//输出
            Console.WriteLine("s5 获取：" + s5);//输出
            Console.WriteLine("s6 获取：" + s6);//输出

            //string s7 = strs1.Single();//抛异常
            string s8 = strs2.Single();//获取集合中的唯一一个元素，如果集合中没有元素或者多余一个元素，则抛异常
            //string s9 = strs3.Single();//抛异常
            Console.WriteLine("s8 获取：" + s8);//输出

            string s10 = strs1.SingleOrDefault();//获取集合中的唯一一个元素，如果集合中没有元素则返回null。如果集合内多余一个元素，则抛异常。
            string s11 = strs2.SingleOrDefault();//获取第一个元素
            //string s12 = strs3.SingleOrDefault();//抛异常

            Console.WriteLine("s10 获取：" + s10);//输出
            Console.WriteLine("s11 获取：" + s11);//输出

            Console.ReadKey();
        }
    }
}

生成结果：

以上方法可以组合使用!

例如：

int r = list.Where(i => i > 5).Select(a=>a*2).OrderBy(o=>o).First();//获取大于5的数值，将数值 * 2，降序排列，获取第一个值。

C# lambda表达式学习

Fri, 18 Jan 2019 11:05:30 +0800

Lambda 表达式是一种可用于创建委托或表达式目录树类型的匿名函数。通过使用 lambda 表达式，可以写入可作为参数传递或作为函数调用值返回的本地函数。 Lambda 表达式对于编写 LINQ 查询表达式特别有用。

"Lambda表达式"是一个匿名函数，是一种高效的类似于函数式编程的表达式，Lambda简化了开发中需要编写的代码量。它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型，支持带有可绑定到委托或表达式树的输入参数的内联表达式。所有Lambda表达式都使用Lambda运算符=>，该运算符读作"goes to"。Lambda运算符的左边是输入参数(如果有)，右边是表达式或语句块。Lambda表达式x => x * x读作"x goes to x times x"。可以将此表达式分配给委托类型.

使用Lambda表达式简化委托：

using System;

namespace lambda入门
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<int> a1 = delegate (int i) { Console.WriteLine("Action委托，使用匿名委托结果:" + i * 1); };//使用匿名委托。
            //Action 泛型委托，没有返回值，参数为 int 类型。 
            a1(5);//调用

            Action<int> a2 = (int i) => { Console.WriteLine("Action委托，使用lambda表达式1结果:" + i * 2); };//lambda表达式
            a2(5);

            Action<int> a3 = (i) => { Console.WriteLine("Action委托，使用lambda表达式2结果:" + i * 3); };//可以省略 参数类型
            a3(5);

            Action<int> a4 = i => { Console.WriteLine("Action委托，使用lambda表达式3结果:" + i * 4); };//只有一个参数，可以省略 参数括号。
            a4(5);

            Func<string, int, string> f1 = delegate (string s, int i) { return "Func委托，使用匿名委托结果:f1" + s + i; };//使用匿名委托。
            //Func泛型委托，有返回值，最后一个参数类型是返回值类型。 
            Console.WriteLine(f1("字符串", 1));

            Func<string, int, string> f2 = (string s, int i) => { return "Func委托，使用lambda表达式1结果:f2" + s + i; };//lambda表达式
            Console.WriteLine(f2("字符串", 2));

            Func<string, int, string> f3 = (s, i) => { return "Func委托，使用lambda表达式2结果:f3" + s + i; };//可以省略 参数类型,多个参数不可省略括号
            Console.WriteLine(f3("字符串", 3));

            Func<string, int, string> f4 = (s, i) => "Func委托，使用lambda表达式3结果:f4" + s + i;//只有一句返回值 可以省略 大括号和 return。
            Console.WriteLine(f4("字符串", 4));

            Func<int, int> f5 = i => i + 5;//只有一个参数可以省略参数小括号， 返回值 大括号和retur，可省略。
            Console.WriteLine("Func委托，使用lambda表达式4结果: f4" + f5(5));

            Console.ReadKey();
        }
    }
}

生成结果：

使用Lambda表达式写出GetMax泛型方法：

比较整型数组大小和类的大小。

using System;

namespace Lambda表达式GetMax
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] nums = { 5, 8, 9, 6, 6, 4, 7, 8, 10, 16, 14, 13 };//整型数组
            int max1 = GetMax(nums, compareFunc);//调用compareFunc方法
            int max2 = GetMax(nums, delegate (int i1, int i2) { return i1 > i2; });//匿名委托
            int max3 = GetMax(nums, (i1, i2) => { return i1 > i2; });//Lambda 省略参数类型。
            int max4 = GetMax(nums, (i1, i2) => i1 > i2);//Lambda 省略参数类型,只有一句返回值，可省略 大括号和return。
            Console.WriteLine("max1结果：" + max1);//输出
            Console.WriteLine("max2结果：" + max2);//输出
            Console.WriteLine("max3结果：" + max3);//输出
            Console.WriteLine("max4结果：" + max4);//输出

            //比较两个类的大小。
            Person[] ps = new Person[] { new Person("小白", 18), new Person("小黑", 15), new Person("小黄", 20) };//Person数组
            Person p = GetMax(ps, (p1, p2) => p1.Age > p2.Age);//调用泛型方法。比较年龄大小
            Console.WriteLine("姓名:"+p.Name+" 年龄:"+p.Age);//输出

            Console.ReadKey();
        }
        static bool compareFunc(int i1, int i2)//判断方法
        {
            return i1 > i2;//返回比较大小
        }
        static T GetMax<T>(T[] objs, Func<T, T, bool> compareFunc)//泛型方法
        {
            T max = objs[0];
            for (int i = 0; i < objs.Length; i++)//循环
            {
                if (compareFunc(objs[i], max))//调用Func委托，结果返回比较大小.
                {
                    max = objs[i];
                }
            }
            return max;//返回
        }
        class Person//类
        {
            public string Name { get; set; }//姓名属性
            public int Age { get; set; }//年龄属性

            public Person(string name, int age)//构造函数
            {
                this.Name = name;//赋值
                this.Age = age;//赋值
            }
        }
    }
}

生成结果：

C# 扩展方法

Wed, 16 Jan 2019 16:26:20 +0800

在C#3.0中引入了“扩展方法”，既有静态方法的优点，又使调用它们的代码的可读性得到了提高。在使用扩展方法时，可以像调用实例方法那样调用静态方法。

扩展方法的基本原则：

(1).C#只支持扩展方法，不支持扩展属性、扩展事件、扩展操作符等。

(2).扩展方法（第一个参数前面是this的方法）必须在非泛型的静态类中声明，扩展方法必须有一个参数，而且只有第一个参数使用this标记。

(3).C#编译器查找静态类中的扩展方法时，要求这些静态类本身必须具有文件作用域。

(4).C#编译要求“导入”扩展方法。（静态方法可以任意命名，C#编译器在寻找方法时，需要花费时间进行查找，需要检查文件作用域中的所有的静态类，并扫描它们的所有静态方法来查找一个匹配）

(5).多个静态类可以定义相同的扩展方法。

(6).用一个扩展方法扩展一个类型时，同时也扩展了派生类型。

扩展方法声明：

(1).必须在一个非嵌套的、非泛型的静态类中（所以必须是一个静态方法）

(2).至少有一个参数。

(3).第一个参数必须附加this关键字做前缀。

(4).第一个参数不能有其他任何修饰符（如ref或out）。

(5).第一个参数的类型不能是指针类型。

扩展方法原理解析：

“扩展方法”是C#独有的一种方法，在扩展方法中会使用ExtensionAttribute这个attribute。

C#一旦使用this关键字标记了某个静态方法的第一个参数，编译器就会在内部向该方法应用一个定制的attribute，这个attribute会在最终生成的文件的元数据中持久性的存储下来，此属性在System.Core dll程序集中。

任何静态类只要包含了至少一个扩展方法，它的元数据中也会应用这个attribute，任何一个程序集包含了至少一个符合上述特点的静态类，它的元数据也会应用这个attribute。如果代码用了一个不存在的实例方法，编译器会快速的扫描引用的所有程序集，判断它们哪些包含了扩展方法，然后，在这个程序集中，可以扫描包含了扩展方法的静态类。

如果同一个命名空间中的两个类含有扩展类型相同的方法，就没有办法做到只用其中一个类中的扩展方法。为了通过类型的简单名称（没有命名空间前缀）来使用类型，可以导入该类型所有在的命名空间，但这样做的时候，你没有办法阻止那个命名空间中的扩展方法也被导入进来。

将字符串输出3次：

using System;

namespace 扩展方法
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "小道博客";//字符串
            Console.WriteLine(KZFF.R(s,3));//输出 正常调用静态类的静态方法
            Console.WriteLine(s.R(3));//输出 调用扩展方法
            Console.ReadKey();
        }
    }
    public static class KZFF//静态类
    {
        public static string R(this string s, int count)//扩展方法，必须是静态方法
        {
            string result = "";//字符串
            for (int i = 0; i < count; i++)//循环
            {
                result += s;//相加
            }
            return result;//返回
        }
    }
}

生成结果：

枚举类型的扩展方法：

using System;

namespace 枚举类型扩展方法
{
    public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };//枚举
    class Program
    {
        static void Main(string[] args)
        {
            var g1 = Grades.F;//声明
            var g2 = Grades.D;//声明
            var g3 = Grades.B;//声明
            var g4 = Grades.A;//声明
            Console.WriteLine("g1 {0} 通过!", g1.Passing() ? "可以" : "不可以");//调用 扩展方法，使用三元表达式判断
            Console.WriteLine("g2 {0} 通过!", g2.Passing() ? "可以" : "不可以");//调用 扩展方法，使用三元表达式判断
            Console.WriteLine("g3 {0} 通过!", g3.Passing() ? "可以" : "不可以");//调用 扩展方法，使用三元表达式判断
            Console.WriteLine("g4 {0} 通过!", g4.Passing() ? "可以" : "不可以");//调用 扩展方法，使用三元表达式判断
            Console.ReadKey();
        }
    }
    public static class Extesions//静态类
    {
        public static Grades minPassing = Grades.C;//静态字段
        public static bool Passing(this Grades grades)//扩展方法(静态方法)
        {
            return grades >= minPassing;//返回 判断结果
        }
    }
}

生成结果：

以上节选自《博客园》

C# 委托复习

Tue, 15 Jan 2019 15:00:00 +0800

今天复习一下委托，由于很长时间没有使用和复习委托，乍一看完全什么也不记得了，脑子里一点影响也没有了。于是看了看前面委托的文章和传智的视频。才慢慢迷迷糊糊的想起来一点。敲敲代码就记起来了大概了，看来还是要多复习和多敲代码才行。

使用委托直接调用和使用方法调用委托调用方法：

如果方法的签名和委托签名一样可以传值。

using System;

namespace 委托复习
{
    public delegate void DelSay(string name); //声明委托类型
    class Program
    {
        static void Main(string[] args)
        {
            DelSay d = new DelSay(SayC);//声明委托对象
            //DelSay d = SayC;  声明委托对象  语句简写
            Console.WriteLine("————使用委托直接调用————");
            d("张三");//委托调用
            Console.WriteLine("————使用方法调用委托调用————");
            Test("Tom",SayE);//通过调用方法 调用委托。参数为，字符串 和 方法
            Console.ReadKey();
        }
        public static void Test(string name,DelSay del)//方法，参数为 字符串 和委托。委托可以简写 DelSay d = SayC; 可以直接传方法
        {
            del(name);//调用委托
        }
        public static void SayC(string name)//中文打招呼 方法
        {
            Console.WriteLine("你好！"+name);//输出
        }
        public static void SayE(string name)//英文打招呼 方法
        {
            Console.WriteLine("Hello!"+name);//输出
        }
    }
}

生成结果：

匿名方法：

using System;

namespace 匿名
{
    public delegate string DelProStr(string name); //声明委托类型
    class Program
    {
        static void Main(string[] args)
        {
            string[] names = {"ABCdEfgh","IjklMnOPq","RSTuvwXYz" };//字符串数组
            ProStr(names,delegate(string name) //方法，匿名方法
            {
                return name.ToUpper();//转为大写字母
                //return name.ToLower();//转为小写字母
                //return "\"" + name + "\"";//转为加 双引号
            });
            for (int i = 0; i < names.Length; i++)//循环输出
            {
                Console.WriteLine(names[i]);//输出
            }
            Console.ReadKey();
        }
        public static void ProStr(string[] name,DelProStr del)//方法 参数：字符串数组 和 委托
        {
            for (int i = 0; i < name.Length; i++)//循环
            {
                name[i] = del(name[i]);//调用委托里面的方法
            }
        }
    }
}

生成结果：

泛型委托：

using System;

namespace 泛型委托
{
    class Program
    {
        public delegate int DelCompare<T>(T t1, T T2);//声明委托类型(泛型)
        static void Main(string[] args)
        {
            int[] nums = { 1, 2, 3, 5, 6, 8, 9, 5, 1, 2, 3, 6, 5, 18, 8, 9, 2 };//整型数组
            int maxInt = GetMax<int>(nums, Compare1);//调用方法 参数：整型数组 和 Compare1方法
            Console.WriteLine("整型数组最大值：" + maxInt);//输出

            string[] strs = {"sadaqw","12e32wfwe32","dsfwq","dgdf25e","sdwq23" };//字符串数组
            string maxStr = GetMax<string>(strs, delegate (string s1, string s2)//调用方法 参数：字符串数组 和 匿名委托
            {
                return s1.Length - s2.Length;//返回 字符串长度 相减结果
            });
            Console.WriteLine("字符串数组最大值：" + maxStr);//输出
            Console.ReadKey();
        }
        public static T GetMax<T>(T[] nums, DelCompare<T> del)//泛型方法
        {
            T max = nums[0];//最大值
            for (int i = 0; i < nums.Length; i++)//循环
            {
                if (del(max, nums[i]) < 0)//调用 委托方法 判断 返回值是否小于0
                {
                    max = nums[i];//赋值
                }
            }
            return max;//返回
        }
        public static int Compare1(int n1, int n2)//整型最大值判断 方法
        {
            return n1 - n2;//返回整型 数组相减结果
        }
    }
}

生成结果：

使用委托窗体传值：

窗体一：

using System;
using System.Windows.Forms;

namespace 窗体传值
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)//按钮单击事件
        {
            Form2 f2 = new Form2(showLabel);//实例化 窗体二 传入方法
            f2.Show();//打开窗体二
        }
        public void showLabel(string str)//方法
        {
            label1.Text = str;//标签显示
        }
    }
}

窗体二：

using System;
using System.Windows.Forms;

namespace 窗体传值
{
    public delegate void Del(string str);//委托类型
    public partial class Form2 : Form
    {
        public Del _del;//委托字段
        public Form2(Del del)//使用委托接收方法
        {
            this._del = del;//赋值方法
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)//按钮单击事件
        {
            this._del(textBox1.Text);//调用委托方法。
        }
    }
}

生成结果：

春暖花开

windows10企业版 LTSC 安装官方便签

Z-BlogPHP 显示错误 Undefined array key "pro" 临时解决办法

Stable Diffusion 的 Controlnet基础知识

设计原理

参数

建筑推荐的预处理器

提示词

Reference预处理

Stable Diffusion 学习笔记

核心技术

潜在扩散模型（Latent Diffusion Models, LDMs）

扩散过程

关键特性：

文本编码

特点与优势

应用与扩展

个人笔记：

模型分类：

提示词基础知识

分类思路

书写格式

文生图参数

提示词相关性

随机种子

内置插件

批量生成

拓源纯净主题tpure 修改 站长简介 [图标]

群晖NAS 部署webdav 文件大小解除限制

C# 集合数据处理的常用方法

C# lambda表达式学习

C# 扩展方法

C# 委托复习

拓源纯净主题tpure 修改站长简介 [图标]