dotnet 职业技术学院

使用FFMpeg.AutoGen播放视频

Tue, 22 Oct 2024 01:12:03 +0000

前面我们已经简单介绍过FFMpeg.AutoGen，今天来看下怎么使用它来实现MP4视频格式的播放。

说明：ffmpeg软解码和硬解码

软解码：指的是使用CPU进行对封装的音视频数据做解码。其优势是有更好的兼容性，不依赖GPU的算力，也不存在内存和显存直接的数据交换，在CPU的性能比较好的机器上能有更好的综合性能表现。如果代码实现过程中需要对解码出来的数据做二次处理，那么更推荐使用软解码。

硬解码：指的是使用GPU进行对封装的音视频数据做解码。使用硬解码过程中，主要消耗GPU资源。其优势是能充分使用显卡资源，提升视频播放的流畅度。如果GPU性能比较差的机器，用软解码或能获得更好的视频播放体验。

环境准备

安装FFMpeg.AutoGen nuget包，版本只需要跟FFMpge版本号对应上就好。ffmpeg版本需要注意x86和x64的版本。
开启”允许使用unsafe编译代码”

本示例是基于”FFmpeg.AutoGen 6.1.0.1”和”FFmpeg 6.0”版本，以软解码实现方式进行演示

实现步骤

初始化解码上下文

由于ffmpeg是非托管代码实现，其中的内存需要我们手动释放。为了方便的管理这些对象，我们自定义一个解码上下文的类，主要用于内存复用和释放。具体定义如下：

/// <summary>
/// 解码上下文
/// </summary>
public unsafe class MediaCodecContext
{
    /// <summary>
    /// 视频播放总时长，单位为秒
    /// </summary>
    public double Duration;
    /// <summary>
    /// 时间基
    /// </summary>
    public AVRational AVStreamTimeBase;
    /// <summary>
    /// 帧率
    /// </summary>
    public int Fps;
​
    /// <summary>
    /// 缩放比
    /// </summary>
    public double Scale;
​
    /// <summary>
    /// 
    /// </summary>
    public int Width;
​
    /// <summary>
    /// 
    /// </summary>
    public int Height;
​
    /// <summary>
    /// 视频流的索引
    /// </summary>
    public int VideoStreamIndex;
​
    /// <summary>
    /// 音频流的索引
    /// </summary>
    public int AudioStreamIndex;
​
    /// <summary>
    /// 
    /// </summary>
    public int PixelFormat;
​
    /// <summary>
    /// 音/视频上下文
    /// </summary>
    public AVFormatContext* FormatContext;
​
    /// <summary>
    /// 视频解码器上下文
    /// </summary>
    public AVCodecContext* VideoCodecContext;
​
    /// <summary>
    /// 音频解码上下文
    /// </summary>
    public AVCodecContext* AudioCodecContext;
​
    /// <summary>
    /// 复用数据包
    /// </summary>
    public AVPacket* Packet;
​
    /// <summary>
    /// 加载的文件路径
    /// </summary>
    public string FileName = string.Empty;
​
    /// <summary>
    /// 当前播放的索引
    /// </summary>
    public int CurrentFrameIndex;
​
    /// <summary>
    /// 释放资源占用,重置上下文
    /// </summary>
    public void Free()
    {
        var packet = Packet;
        if (packet != null)
        {
            ffmpeg.av_packet_unref(packet);
            ffmpeg.av_packet_free(&packet);
            Packet = packet;
        }
​
        var videoCodecContext = VideoCodecContext;
        if (videoCodecContext != null)
        {
            ffmpeg.avcodec_free_context(&videoCodecContext);
            VideoCodecContext = videoCodecContext;
        }
​
        var audioCodecContext = AudioCodecContext;
        if (audioCodecContext != null)
        {
            ffmpeg.avcodec_free_context(&audioCodecContext);
            AudioCodecContext = audioCodecContext;
        }
​
        var formatContext = FormatContext;
        if (formatContext != null)
        {
            ffmpeg.avformat_close_input(&formatContext);
            ffmpeg.avformat_free_context(formatContext);
            FormatContext = formatContext;
        }
        CurrentFrameIndex = 0;
        AudioStreamIndex = -1;
        VideoStreamIndex = -1;
    }

查找并打开解码器

/// <summary>        
/// 打开文件，读取音/视频流，获取解码器，打开解码器
/// </summary>
/// <param name="filePath"></param>
public unsafe bool Open()
{
    //分配解码上下文，该上下文贯穿整个解码过程，包含封装格式，音视频流信息，时长等
    var formatContext = ffmpeg.avformat_alloc_context();
    //打开文件，并读取文件头部
    var res = ffmpeg.avformat_open_input(&formatContext, _context.FileName, null, null);
    if (res != 0)
    {
        //打开失败，释放资源
        ffmpeg.avformat_free_context(formatContext);
        //Log.Error($"avformat_open_input:{res}");
        return false;
    }
​
    //查找音/视频流
    if ((res = ffmpeg.avformat_find_stream_info(formatContext, null)) != 0)
    {
        ffmpeg.avformat_free_context(formatContext);
        //Log.Error($"avformat_find_stream_info:{res}");
        return false;
    }
​
    //枚举音/视频流
    AVStream* videoStream = null, audioStream = null;
    for (var i = 0; i < formatContext->nb_streams; i++)
    {
        var codecpar = formatContext->streams[i]->codecpar;
        if (codecpar->codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
        {
            videoStream = formatContext->streams[i];
            _context.VideoStreamIndex = i;
        }
        else if (codecpar->codec_type == AVMediaType.AVMEDIA_TYPE_AUDIO)
        {
            audioStream = formatContext->streams[i];
            _context.AudioStreamIndex = i;
        }
    }
​
    if (videoStream == null && audioStream == null)
    {
        ffmpeg.avformat_free_context(formatContext);
        //Log.Warn($"ffmpeg:检测不到音视频流");
        return false;
    }
​
    if (audioStream != null)
    {
        // 初始化音频解码器
        if (!InitializeAudioDecoder(audioStream->codecpar))
        {
            ffmpeg.avformat_free_context(formatContext);
            //Log.Error($"ffmpeg:初始化音频解码器失败");
            return false;
        }
    }
​
    if (videoStream != null)
    {
        // 初始化视频解码器
        if (!InitializeVideoDecoder(videoStream->codecpar))
        {
            ffmpeg.avformat_free_context(formatContext);
            //Log.Error($"ffmpeg:初始化视频解码器失败");
            return false;
        }
    }
    
    //初始化解码过程中的复用数据包，为av_packet申请内存，用于存放每一帧的封装的数据包
    var packet = ffmpeg.av_packet_alloc();
    var fps = videoStream->avg_frame_rate.num / videoStream->avg_frame_rate.den;
​
    #region 初始化上下文
​
    _context.FormatContext = formatContext;
    _context.Duration = videoStream->duration * ffmpeg.av_q2d(videoStream->time_base);
    _context.Packet = packet;
    _context.Fps = fps;
    _context.Scale = 1;
​
    #endregion
​
    return true;
}
​
/// <summary>
/// 初始化视频解码器
/// </summary>
/// <param name="codecParameter"></param>
/// <returns></returns>
private unsafe bool InitializeVideoDecoder(AVCodecParameters* codecParameter)
{
    //查找解码器
    var codec = ffmpeg.avcodec_find_decoder(codecParameter->codec_id);
    //为解码器分配一个上下文
    var codecContext = ffmpeg.avcodec_alloc_context3(codec);
    //填充解码器上下文参数
    var res = ffmpeg.avcodec_parameters_to_context(codecContext, codecParameter);
    if (res != 0)
    {
        //释放上下文资源
        ffmpeg.avcodec_free_context(&codecContext);
        return false;
    }
    //打开解码器
    res = ffmpeg.avcodec_open2(codecContext, codec, null);
    if (res != 0)
    {
        ffmpeg.avcodec_free_context(&codecContext);
        return false;
    }
​
    _context.VideoCodecContext = codecContext;
    _context.Width = codecParameter->width;
    _context.Height = codecParameter->height;
    _context.PixelFormat = codecParameter->format;
​
    return true;
}
​
//初始化音频解码器(暂不做实现)
private unsafe bool InitializeAudioDecoder(AVCodecParameters* codecParameter)
{
    //音频暂不做实现
    return true;
}

读取帧数据，并进行解码和转码

/// <summary>
/// 读取视频帧数据
/// </summary>
/// <returns></returns>
private unsafe VideoFrame ReadVideoFrame()
{
    var data = new VideoFrame();
    //将av_packet数据发送给解码器
    var res = ffmpeg.avcodec_send_packet(_context.VideoCodecContext, _context.Packet);
    //为av_frame结构体分配内存
    var frame = ffmpeg.av_frame_alloc();
    frame->width = _context.Width;
    frame->height = _context.Height;
    frame->format = _context.PixelFormat;
    //根据像素的宽高，给av_frame分配实际占用的内存
    ffmpeg.av_frame_get_buffer(frame, 0);
    //将解码后的数据填充到av_frame
    res = ffmpeg.avcodec_receive_frame(_context.VideoCodecContext, frame);
    if (res != 0)
    {
        data.State = FrameState.Continue;
        //减少av_frame的引用计数，防止内存泄露
        ffmpeg.av_frame_unref(frame);
        //释放av_frame的内存占用
        ffmpeg.av_frame_free(&frame);
        //减少av_packet的引用计数，防止内存泄露
        ffmpeg.av_packet_unref(_context.Packet);
        return data;
    }
​
    _context.CurrentFrameIndex++;
​
    var scale = _context.Scale;
    //将原始帧转码成BGRA，方便使用WPF进行渲染
    AVFrame* originalFrame = ConvertToBGRA(frame, (int)(scale * _context.Width), (int)(scale * _context.Height));
    //将av_frame转成二进制，传递给wpf
    var pixels = CropFrameToPixels(originalFrame, originalFrame->linesize[0], new Int32Rect(0, 0, originalFrame->width, originalFrame->height));
    //显示用的二进制像素数据    
    data.Pixels = pixels;
    //每一行像素所占用的字节数
    data.Pitch = originalFrame->linesize[0];
    //像素宽度
    data.Width = originalFrame->width;
    //像素高度
    data.Height = originalFrame->height;
    data.State = FrameState.OK;
    //释放av_frame的内存占用
    ffmpeg.av_frame_unref(frame);
    ffmpeg.av_frame_free(&frame);
    ffmpeg.av_frame_unref(originalFrame);
    ffmpeg.av_frame_free(&originalFrame);
    ffmpeg.av_packet_unref(_context.Packet);
    return data;
}
​
/// <summary>
/// 视频帧数据结构
/// 定义为结构体是为了提升性能
/// </summary>
public struct VideoFrame : IMediaFrame
{
    /// <summary>
    /// 渲染数据的宽度
    /// </summary>
    public int Width;
​
    /// <summary>
    /// 渲染数据的高度
    /// </summary>
    public int Height;
​
    /// <summary>
    /// 渲染数据的像素信息
    /// 视频数据表示 Pixels，音频数据表示 pcm
    /// </summary>
    public byte[] Pixels;
​
    /// <summary>
    /// 每行占用的字节数
    /// </summary>
    public int Pitch;
​
    /// <summary>
    /// 当前帧的状态
    /// </summary>
    public FrameState State { get; set; }
}

转码成可显示的数据格式

大部分音视频数据解码出来后都是YUV格式的，我们需要将他们转码成BRGA格式，方便我们使用WPF进行渲染。

/// <summary>
/// 转码成BGRA
/// </summary>
/// <param name="input"></param>
/// <param name="outputWidth"></param>
/// <param name="outputHeight"></param>
/// <returns></returns>
public unsafe AVFrame* ConvertToBGRA(AVFrame* input, int outputWidth, int outputHeight)
{
    //创建转码上下文
    SwsContext* swsContext = ffmpeg.sws_getContext(input->width, input->height, (AVPixelFormat)input->format, outputWidth, outputHeight, AVPixelFormat.AV_PIX_FMT_BGRA, ffmpeg.SWS_FAST_BILINEAR, null, null, null);
    AVFrame* output = ffmpeg.av_frame_alloc();
    output->format = (int)AVPixelFormat.AV_PIX_FMT_BGRA;
    output->width = outputWidth;
    output->height = outputHeight;
    var res = ffmpeg.av_frame_get_buffer(output, 0);
    //开始转码
    res = ffmpeg.sws_scale(swsContext, input->data, input->linesize, 0, input->height, output->data, output->linesize);
    //释放资源
    ffmpeg.sws_freeContext(swsContext);
    return output;
}
​
/// <summary>
/// 裁剪帧到像素集合
/// </summary>
/// <param name="srcFrame">原始BGRA帧</param>
/// <param name="targetLineSize">裁剪后，一行包含多少像素</param>
/// <param name="region">裁剪的区域大小</param>
/// <returns></returns>
public unsafe byte[] CropFrameToPixels(AVFrame* srcFrame, int targetLineSize, Int32Rect region)
{
    int frameStride = srcFrame->linesize[0];
    var size = targetLineSize * region.Height;
    byte[] pixels = new byte[size];
    for (int height = 0; height < region.Height; ++height)
    {
        int srcStartIndex = (height + region.Y) * frameStride + region.X * 4;
        int targetStartIndex = height * targetLineSize;
        var srcStartPointer = &srcFrame->data[0][srcStartIndex];
        Marshal.Copy((IntPtr)srcStartPointer, pixels, targetStartIndex, targetLineSize);
    }
    return pixels;
}

渲染播放

在WPF中，我们可以通过使用WriteableBitmap来实现对BGRA数据格式的显示。

//自定义播放器
public MediaPlayer()
{
    _child = new DrawingVisual();
    AddVisualChild(_child);
}
​
protected override Visual GetVisualChild(int index)
{
    return _child;
}
​
protected override int VisualChildrenCount => 1;
​
//需要渲染的帧，这里复用提升性能
private WriteableBitmap _frame;
​
/// <summary>
/// 绘制视频帧
/// </summary>
/// <param name="data"></param>
private void Draw(VideoFrame data)
{
    using (var drawingContext = _child.RenderOpen())
    {
        if (_frame == null || _frame.Width != data.Width || _frame.Height != data.Height)
        {
            _frame = new WriteableBitmap(data.Width, data.Height, 96, 96, PixelFormats.Pbgra32, null);
        }
​
        if (_frame.TryLock(new Duration(TimeSpan.FromMilliseconds(50))))
        {
            try
            {
                _frame.WritePixels(new Int32Rect(0, 0, data.Width, data.Height), data.Pixels, data.Pitch, 0);
                drawingContext.DrawImage(_frame, new Rect(0, 0, data.Width, data.Height));
            }
            catch (Exception ex)
            {
​
            }
            finally
            {
                _frame.Unlock();
            }
        }
    }
}

播放控制

要想视频动起来，我们就需要写一个循环，让他针对每一帧进行播放，示例代码如下：

Task.Factory.StartNew(() =>
{
    _decoder.Load(filename);
    if (!_decoder.Open())
    {
        _decoder.Close();
        return;
    }
    IsPlaying = true;
    var startTime = Environment.TickCount;
    var delaySpan = 1000 / _decoder.Fps;
​
    while (IsPlaying)
    {
        _decoder.SetDisplaySize(RenderSize.Width, RenderSize.Height);
        var data = _decoder.ReadFrame();
        if (data.State == FrameState.OK)
        {
            if (data is VideoFrame videoFrame)
            {
                Dispatcher.InvokeAsync(() =>
                {
                    Draw(videoFrame);
                });
            }
            else
            {
                continue;
            }
        }
        else if (data.State == FrameState.Over)
        {
            if (data is VideoFrame videoFrame)
            {
                Dispatcher.InvokeAsync(() =>
                {
                    Draw(videoFrame);
                });
            }
            else
            {
                break;
            }
        }
        else
        {
            continue;
        }
​
        var decodeTime = Environment.TickCount - startTime;
        var delay = Math.Max(0, delaySpan - decodeTime);
        Thread.Sleep(delay);
        startTime = Environment.TickCount;
    }
    _decoder.Close();
    IsPlaying = false;
});

写在最后

示例代码并非完整代码，大家在实现视频播放功能的时候，还是需要考虑不少细节，上述代码仅供参考！过程中还有什么疑问可以在评论区留言。

博客地址：https://huchengv5.github.io/

微信公众号：

欢迎转载分享，如若转载，请标注署名。

适用于.NET的FFMpeg.AutoGen简介

Fri, 18 Oct 2024 01:12:03 +0000

ffmpeg在音视频领域还是有种非常重要的作用，主要用于对音视频的编解码。

如果我们需要处理一些音频，视频文件的话，那很有可能需要用到它了。 ffmpeg在音视频领域还是有种非常重要的作用，主要用于对音视频的编解码。
如果我们需要处理一些音频，视频文件的话，那很有可能需要用到它了。
FFMpeg.AutoGen是基于LGPL的开源协议，可以为C#语言，提供与C++等价的编码体验，其封装的ffmpeg相关的api的命名规范也完全照搬了C++相关的Api。

这大大降低了api的使用难度和学习成本。
优势：提供了丰富的API，使用起来灵活方便，功能强大。
劣势：需要对ffmpeg相关的api有所了解，并且能熟练使用C# unsafe 语法的使用。

FFMpeg.AutoGen项目地址：Ruslan-B/FFmpeg.AutoGen: FFmpeg auto generated unsafe bindings for C#/.NET and Core (Linux, MacOS and Mono). (github.com)。

FFMpeg.AutoGen 提供了不同版本的nuget包，如：6.1.0，5.1.2.3，该主体版本号是对应ffmpeg的版本号。

所以我们在开发的过程中，需要安装与ffmpeg版本对应的FFMpeg.AutoGen nuget包（ffmpeg版本也需要考虑x86，x64的平台相关性），这点非常重要，否则会导致ffmpeg的相关api无法正常调用。

下期我们来讲讲，如何通过使用FFMpeg.AutoGen，实现mp4的视频播放功能。

博客地址：https://huchengv5.github.io/

微信公众号：

欢迎转载分享，如若转载，请标注署名。

WPF如何实现“不用写转换器的Binding

Mon, 14 Oct 2024 01:12:03 +0000

Xaml中的Binding语法是WPF的中的灵魂，但是很多业务场景下，我们都需要通过IValueConverter接口来实现一个转换器。

这种实现方式会导致我们编码的过程中会存在越来越多的转换器，每写一个转换器，命名或许都是个头疼的问题。尤其是针对多路Binding的时候，xaml的代码编写量会比较多，严重降低编码效率。

为了优化转化器的使用，我们可以通过Xaml扩展，自定义一个Binding的扩展方法。暂且命名为“XBinding”。

具体实现思路如下：

我们自定义一个Binding，该Binding本质还是原来的那个Binding，只是我们在原来的Binding的基础上做了一些逻辑精简。Binding所使用的转换器为IMultiValueConverter。考虑到Button按钮还存在Command的Binding场景，所以在XBinding中也增加了对Command的支持。

具体实现看代码：

XBinding扩展代码实现

[ContentProperty("Bindings")]
public class XBinding : MarkupExtension
{
    public XBinding()
    {
​
    }
    public string Method { get; set; }
​
    [ConstructorArgument("Path")]
    /// <summary>
    /// 
    /// </summary>
    public string Path { get; set; }
​
    /// <summary>
    /// 多路绑定使用
    /// </summary>
    public MultiBinding Bindings { get; set; }
​
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        if (Method == null)
        {
            throw new ArgumentNullException("method");
        }
​
        IProvideValueTarget provideValueTarget = (IProvideValueTarget)serviceProvider.GetService(typeof(IProvideValueTarget));
        var rootObjectProvider = (IRootObjectProvider)serviceProvider.GetService(typeof(IRootObjectProvider));
        var rootObject = rootObjectProvider?.RootObject;
        if (rootObject != null)
        {
            MethodInfo method = rootObject.GetType().GetMethod(Method);
            bool isCommand = false;
            var targetObj = provideValueTarget.TargetObject;
            if (targetObj is CommandBinding)
            {
                throw new NotSupportedException("XBinding不支持CommandBinding");
            }
            else
            {
                var targetProperty = provideValueTarget.TargetProperty as DependencyProperty;
                if (targetProperty != null && targetProperty.PropertyType == typeof(ICommand))
                {
                    isCommand = true;
                }
            }
​
            if (Bindings != null)
            {
                Bindings.Converter = new XBindingMultiValueConverter() { Target = rootObject, ConvertMethod = method, IsCommand = isCommand };
                return Bindings.ProvideValue(serviceProvider);
            }
            else
            {
                var multiBinding = new MultiBinding() { Converter = new XBindingMultiValueConverter() { Target = rootObject, ConvertMethod = method, IsCommand = isCommand } };
                multiBinding.ConverterParameter = ConverterParameter;
                string[] propertyPaths;
                if (string.IsNullOrWhiteSpace(Path))
                {
                    multiBinding.Bindings.Add(new Binding());
                }
                else
                {
                    propertyPaths = Path.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                    foreach (var propertyPath in propertyPaths)
                    {
                        multiBinding.Bindings.Add(new Binding(propertyPath));
                    }
                }
​
                return multiBinding.ProvideValue(serviceProvider);
            }
        }
​
        return null;
    }
​
    #region Binding Properties
​
    [DefaultValue(BindingMode.Default)]
    public BindingMode Mode { get; set; }
​
    [DefaultValue("")]
    public RelativeSource RelativeSource { get; set; }
​
    public object Source { get; set; }
​
    [DefaultValue("")]
    public string ElementName { get; set; }
​
    [DefaultValue("")]
    public string StringFormat { get; set; }
​
    [DefaultValue("")]
    public object ConverterParameter { get; set; }
​
    #endregion
}

多路绑定的转换器实现：

/// <summary>
    /// 多路绑定
    /// </summary>
    internal class XBindingMultiValueConverter : IMultiValueConverter
    {
        /// <summary>
        /// 要执行多路转换的实例对象
        /// </summary>
        internal object Target { get; set; }
​
        /// <summary>
        /// 转换的方法
        /// </summary>
        internal MethodInfo ConvertMethod { get; set; }
​
        /// <summary>
        /// 反转转换的方法
        /// </summary>
        internal MethodInfo ConvertBackMethod { get; set; }
​
        /// <summary>
        /// 是否为Command
        /// </summary>
        internal bool IsCommand { get; set; }
​
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if (ConvertMethod != null)
            {
                if (IsCommand)
                {
                    return new XCommand((p) =>
                    {
                        if (p is object[] objs)
                        {
                            Execute(objs, parameter, targetType);
                        }
                        else
                        {
                            Execute(new object[1] { p }, parameter, targetType);
                        }
                    });
                }
                else
                {
                    return Execute(values, parameter, targetType);
                }
            }
            else
            {
#if DEBUG
                //throw new ArgumentNullException(nameof(ConvertMethod));
#endif
                return DependencyProperty.UnsetValue;
            }
        }
​
        private object Execute(object[] values, object parameter, Type targetType)
        {
            var parameterCount = ConvertMethod.GetParameters().Length;
            if (parameterCount == 0)
            {
                return ConvertMethod.Invoke(Target, new object[] { });
            }
            else
            {
                var count = Math.Min(parameterCount, values.Length + 1);
                var objs = new object[count];
                if (values == null)
                {
                    return ConvertMethod.Invoke(Target, objs);
                }
                else
                {
                    for (int i = 0; i < count; i++)
                    {
                        if (i == values.Length)
                        {
                            objs[i] = parameter;
                        }
                        else if (i > values.Length)
                        {
                            //默认null
                        }
                        else
                        {
                            if (values[i] != DependencyProperty.UnsetValue)
                            {
                                objs[i] = values[i];
                            }
                        }
                    }
​
                    if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
                    {
                        if (targetType.IsValueType)
                        {
                            return Activator.CreateInstance(targetType);
                        }
                        else
                        {
                            return null;
                        }
                    }
                    else
                    {
                        //无法转换类型
                        return ConvertMethod.Invoke(Target, objs);
                    }
                }
            }
        }
​
        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            if (ConvertBackMethod != null)
            {
                var objs = new object[] { value };
                return (object[])ConvertBackMethod.Invoke(Target, objs);
            }
            else
            {
                throw new ArgumentNullException(nameof(ConvertBackMethod));
            }
        }
    }

ICommand的实现：

/// <summary>
/// 表示XBinding所支持的ICommand
/// </summary>
public class XCommand : ICommand
{
    private readonly Action<object> _execute;
​
    private readonly Func<bool> _canExecute;
​
    public XCommand(Action<object> execute) : this(execute, null)
    {
​
    }
​
    public XCommand(Action<object> execute, Func<bool> canExecute)
    {
        if (execute == null)
        {
            throw new ArgumentNullException("execute");
        }
​
        _execute = execute;
        _canExecute = canExecute;
    }
​
    public event EventHandler CanExecuteChanged;
​
    public bool CanExecute(object parameter)
    {
        return _canExecute == null ? true : _canExecute();
    }
​
    public void Execute(object parameter)
    {
        if (_execute != null)
        {
            _execute(parameter);
        }
    }
}

具体使用方法：

    // 参考语法
    // 单路绑定：
    PlayStatus="{XBinding Path=IsSpeaking,Method=GetExpectPlayStatus}"
    // 多路绑定：
     PlayStatus="{XBinding Path=IsSpeaking Sex,Method=GetExpectPlayStatus}"
    <SvgaPlayerControl.SourceUri>
      <XBinding Method = "GetSpeakingSvga" >
        < MultiBinding >
            < Binding Path="IsSpeaking"/>
            <Binding Path = "Player.Sex" />
            < Binding RelativeSource="{RelativeSource AncestorType=SvgaPlayerControl}"/>
        </MultiBinding>
      </XBinding>
     </SvgaPlayerControl.SourceUri>

对应的Mothod需要在xaml对应的cs代码中编写。

结合以上代码，XBinding就可以应用到我们Xaml中了，对开发效率的提升还是有不少的。当然了，如果可以梳理一些通用转换器，那效率会更高。针对灵活处理的转换器，那么可以试试XBinding。

博客地址：https://huchengv5.github.io/

微信公众号：

欢迎转载分享，如若转载，请标注署名。

共享内存的基本用法

Fri, 08 Mar 2024 01:12:03 +0000

共享内存是一种通信效率非常高的进程通信方案，在某些场景下非常适用。如：跨进程间播放音视频资源。

在.NET中，MemoryMappedFile就可以帮助我们完成这项工作。

共享内存打开与创建

我们可以通过MemoryMappedFile.OpenExisting来打开一个已存在的共享内存块，mapName作为唯一标识。如果打开的内存块标识不存在，则会抛出异常。

var memoryMappedFile = MemoryMappedFile.OpenExisting(mapName);

我们也可以通过MemoryMappedFile.CreateOrOpen来打开或者创建一个共享内存块，如果共享内存不存在则会自动创建一个。

var memoryMappedFile = MemoryMappedFile.CreateOrOpen(mapName, capacity, MemoryMappedFileAccess.ReadWrite);

共享内存数据读写

共享内存的数据读取可以有两种方式：

通过流式读写

我们可以通过创建一个内存视图流来进行读写。基本使用方法和传统Stream类是一样的。

var streamWriter = _memoryMappedFile.CreateViewStream()

随机访问

随机访问的方式相对来讲会更灵活，但是需要自己控制数据读写的位置。可以通过传入的position来控制开始读写的位置。

var accessor = _memoryMappedFile.CreateViewAccessor();

基于流式读取的完整示例

    public enum ShareMemoryChannelFlag
    {
        /// <summary>
        /// 数据新写入的，尚未被读取
        /// </summary>
        Unread = 0,
        /// <summary>
        /// 数据已经被读取过
        /// </summary>
        Read = 1,
        /// <summary>
        /// 该内存块已经被关闭
        /// </summary>
        Close = 2,
    }

    /// <summary>
    /// 共享内存管道
    /// </summary>
    internal class ShareMemoryChannel : IDisposable
    {
        /// <summary>
        /// 以只读的模式初始化内存通道
        /// </summary>
        /// <param name="channelName"></param>
        public ShareMemoryChannel(string channelName)
        {
            if (string.IsNullOrEmpty(channelName))
            {
                throw new ArgumentException("channelName invalid!");
            }

            ChannelName = channelName;
        }

        /// <summary>
        /// 以可读可写的方式初始化内存通道
        /// </summary>
        /// <param name="channelName"></param>
        /// <param name="capacity"></param>
        public ShareMemoryChannel(string channelName, long capacity) : this(channelName)
        {
            //最小大小必须能容纳通信协议的字节大小            
            if (capacity > sizeof(int))
            {
                Capacity = capacity;
            }
            else
            {
                throw new ArgumentException("capacity must more then four!");
            }
        }

        private MemoryMappedFile _memoryMappedFile;

        /// <summary>
        /// 管道名称
        /// </summary>
        public string ChannelName { get; }

        /// <summary>
        /// 最大容量
        /// </summary>
        public long Capacity { get; }

        /// <summary>
        /// 表示
        /// </summary>
        public bool IsCapacityValid
        {
            get
            {
                if (Capacity > 4)
                {
                    return true;
                }
                return false;
            }
        }

        /// <summary>
        /// 是否已经释放
        /// </summary>
        public bool IsDisposed { get; private set; }

        /// <summary>
        /// 读取数据
        /// </summary>
        /// <returns></returns>
        public byte[] Read(bool isReadOnlyChanged = true)
        {
            if (IsDisposed)
            {
                throw new InvalidOperationException("无法访问已释放的资源");
            }

            if (_memoryMappedFile == null)
            {
                //用来控制是不是可以写入数据。读写数据会存在数据同步问题，这里简单的示例，不做同步逻辑。
                if (IsCapacityValid)
                {
                    _memoryMappedFile = MemoryMappedFile.CreateOrOpen(ChannelName, Capacity, MemoryMappedFileAccess.ReadWrite);
                }
                else
                {
                    _memoryMappedFile = MemoryMappedFile.OpenExisting(ChannelName);
                }
            }

            if (_memoryMappedFile == null)
            {
                //net core 可以用 Array.Empty<Byte>()
                return new byte[0];
            }
            using (var stream = _memoryMappedFile.CreateViewStream())
            {
                var flag = (ShareMemoryChannelFlag)stream.ReadByte();

                bool isUnread = flag == ShareMemoryChannelFlag.Unread;

                if (isUnread)
                {
                    //将未读标记改成已读
                    stream.Position = 0;
                    stream.WriteByte((int)ShareMemoryChannelFlag.Read);
                }

                if (!isReadOnlyChanged || (isUnread && isReadOnlyChanged))
                {
                    var len = sizeof(int);
                    byte[] bufferSize = new byte[len];
                    stream.Read(bufferSize, 0, len);
                    var length = BitConverter.ToInt32(bufferSize, 0);
                    var buffer = new byte[length];
                    stream.Read(buffer, 0, length);
                    return buffer;
                }
            }
            //net core 可以用 Array.Empty<Byte>()
            return new byte[0];
        }

        /// <summary>
        /// 写入数据
        /// </summary>
        /// <param name="bytes"></param>
        public bool Write(byte[] bytes)
        {
            if (IsDisposed)
            {
                throw new InvalidOperationException("无法访问已释放的资源");
            }

            if (_memoryMappedFile == null)
            {
                _memoryMappedFile = MemoryMappedFile.CreateOrOpen(ChannelName, Capacity, MemoryMappedFileAccess.ReadWrite);
            }

            if (_memoryMappedFile == null || bytes == null || bytes.Length == 0)
            {
                return false;
            }

            using (var streamWriter = _memoryMappedFile.CreateViewStream())
            {
                streamWriter.WriteByte((int)ShareMemoryChannelFlag.Unread);
                var bufferSize = BitConverter.GetBytes(bytes.Length);
                streamWriter.Write(bufferSize, 0, bufferSize.Length);
                streamWriter.Write(bytes, 0, bytes.Length);
                streamWriter.Flush();
                return true;
            }
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (_memoryMappedFile != null)
            {
                _memoryMappedFile.Dispose();
                _memoryMappedFile = null;
                IsDisposed = true;
            }
        }
    }

共享内存的优缺点

优点：

高效性：共享内存允许多个进程直接访问同一块内存区域，避免了数据复制的开销。这使得数据传输速度更快，适用于需要高性能和低延迟的应用程序。
简单性：使用共享内存进行通信相对简单，可以通过读写共享内存来实现进程之间的数据交换，而不需要复杂的通信协议或消息传递机制。
容量大：共享内存可以提供较大的数据容量，因为它利用系统内存资源而不受进程内存限制的约束。这使得共享内存适用于处理大规模数据集或大量数据的应用程序。
实时性：由于共享内存直接映射到物理内存中，因此可以实时地进行数据读写操作。这对于需要实时响应和数据同步的应用程序非常重要。

缺点：

同步问题：由于多个进程可以同时访问共享内存，因此需要采取适当的同步机制来确保数据的一致性和正确性。否则，可能会导致数据竞争和不确定的结果。
数据变更：数据写入没有高效的数据通知，必须业务方自己实现该逻辑。
资源占用：初始化的时候必须指定一个内存块大小，某些场景下可能会导致内存资源的浪费。

博客地址：https://huchengv5.github.io/

微信公众号：

欢迎转载分享，如若转载，请标注署名。

IMultiValueConverter的Values直接返回会怎样？

Wed, 23 Aug 2023 01:12:03 +0000

IMultiValueConverter的Values直接返回会怎样？

IMultiValueConverter接口，我们在写wpf程序的时候应该是比较熟悉了，这个接口主要用于实现多路数据绑定转换器。

如果我们写了一个转换器，继承至IMultiValueConverter,直接将传入的值返回，会出现什么结果？示例代码如下：

//...省略... 转换器礼逻辑
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
  return values;
}

//...省略...  绑定逻辑      
<Button.CommandParameter>
  <MultiBinding Converter="{StaticResource MultiValueConverter}">
  <Binding Path="P1"/>
  <Binding Path="P2"/>
  <Binding Path="P3"/>
  </MultiBinding>
</Button.CommandParameter>
//...省略...

当我们从CommandParameter获取相关的参数值的时候，我们发现参数的数量为0!

我们的参数明明没有做任何修改，为什么会变成了0? 正常不应该是数组长度为3的数组吗?

通过查看源代码发现，原来转换器里面的Values被清空了。

源代码位置：MultiBindingExpression -> TransferValue() 方法。

部分源代码如下所示：

   //...省略...  this._tempValues 表示原始的数据 obj2 表示转换后的数据
   obj2 = this.Converter.Convert(this._tempValues, base.TargetProperty.PropertyType, this.ParentMultiBinding.ConverterParameter, culture);
   //...省略...  这里把原始数据清理掉了
   Array.Clear(this._tempValues, 0, this._tempValues.Length);
   //……省略……

所以要解决这个问题，我们可以修改下转换器：

//...省略... 转换器礼逻辑
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
  return values.Clone();
}

这样就可以解决上述问题了。

使用VisualStudio同时调试多个进程

Wed, 09 Aug 2023 01:12:03 +0000

如何使用VisualStudio同时调试多个进程？

通常来讲，要同时调试多个进程，对于VisualStudio来讲是一件很简单的事情，我们只需要附加到进程就可以了！

在菜单中可以找到：“调试”->”附加到进程”，选择进程名称附加即可！

图片

但是这种情况下，如果我们修改了代码，visualstudio经常会提示重启调试器，大大降低了我们调试的工作效率。

当然，我们也可以通过取消调试其他的进程，再单独附加到某一个进程进行调试。在菜单中找到：”调试”->”全部拆离”,进行取消。取消后再附加到另外一个进程，部分情况下调试也是没问题的。

如果我们想要同时调试多个进程，而又不想动不动就重新启动进程，我们可以怎么做呢？

我们可以在vs启动的下拉选项中，打开下方的配置启动项目选项中进入到配置页面，选择多个启动项目，并选择需要启动的项目名，将操作改成启动。如下图所示：

图片

如果进程启动需要传入一些参数，可以在项目的属性页面中，选中调试选项卡，

图片

，打开调试启动配置UI，在命令行参数选项输入需要的参数。

图片

如果参数是动态的，那么我们可以直接在代码里面去完成参数的传递，这里就不展开了。微信公众号：

欢迎转载分享，如若转载，请标注署名。

WPF-如何实现图片按像素拉伸

Mon, 22 May 2023 01:12:03 +0000

WPF中的图片组件，本身是支持不同的拉伸效果。具体如下：

        None,   //不做拉伸
        Fill,   //完全填充（会变形）
        Uniform,    //等比缩放，不会变形
        UniformToFill   //等比缩放，并完全填充。不会变形，但是长的部分会被裁剪

但是，如果我们要实现像QQ或者微信这样子的聊天气泡功能，直接使用图片组件就无法满足要求了。

我们可以观察下微信的聊天气泡，他的宽度和高度可以根据我们输入的内容自动调整，并且背景图片也不会存在变形的问题。

今天我们就用WPF来实现这个功能！

要实现不变形的拉伸功能，我们可以针对1个像素来进行拉伸，这样拉伸出来的图片，除了拉伸区域的像素都是一样的，其它区域还是保留了原来的图片的外观。

这里主要需要用到CroppedBitmap类，该类主要用于裁剪，可以对BitmapImage进行裁剪。

微信聊天气泡这种场景，它需要支持水平和垂直的方向的拉伸效果，我们可以利用CroppedBitmap，将原始图片裁剪成9张图，渲染的时候，我们分别将9张图渲染到对应的位置。拉伸的区域就是9张图中的上面中间位置，下面中间位置，左边中间位置，右边中间位置以及最中间的位置。这几张图片，都按1个像素进行裁剪，这样就不会出现拉伸的图片了。

关键代码：

        
        private ImageSource GetCroppedBitmap(double x, double y, double width, double height)
        {
            return new CroppedBitmap(ImageSource, new Int32Rect((int)x, (int)y, (int)width, (int)height));
        }

        /// <summary>
        /// 获取水平偏移像素值
        /// </summary>
        /// <returns></returns>
        private int GetStretchHeight()
        {
            return (int)(RenderSize.Height - ImageSource.PixelHeight);
        }

        /// <summary>
        /// 获取垂直位置的偏移像素值
        /// </summary>
        /// <returns></returns>
        private int GetStretchWidth()
        {
            return (int)(RenderSize.Width - ImageSource.PixelWidth);
        }

        /// <summary>
        /// 水平拉伸是否可用
        /// </summary>
        private bool IsHorizontalStretchEnabled
        {
            get
            {
                if (HorizontalOffset > 0 && HorizontalOffset < ImageSource.PixelWidth)
                {
                    return true;
                }
                return false;
            }
        }

        /// <summary>
        /// 垂直拉伸是否可用
        /// </summary>
        private bool IsVerticalStretchEnabled
        {
            get
            {
                if (VerticalOffset > 0 && VerticalOffset < ImageSource.PixelHeight)
                {
                    return true;
                }
                return false;
            }
        }

        //绘制水平+垂直拉伸的方法
        protected override void OnRender(DrawingContext drawingContext)
        {
            var stretchHeight = GetStretchHeight();
                    if (stretchHeight < 0) stretchHeight = 0;
                    var stretchWidth = GetStretchWidth();
                    if (stretchWidth < 0) stretchWidth = 0;

                    if(stretchHeight==0 && stretchWidth == 0)
                    {
                        drawingContext.DrawImage(ImageSource, new Rect(0, 0, ImageSource.PixelWidth, ImageSource.PixelHeight));
                        return;
                    }

                    //这个需要9张图
                    //左上，左中，左下，右上，右中，右下，水平中，垂直中
                    var leftTop = GetCroppedBitmap(0, 0, HorizontalOffset, VerticalOffset);
                    var leftBottom = GetCroppedBitmap(0, VerticalOffset + 1, HorizontalOffset, ImageSource.PixelHeight - VerticalOffset - 1);
                    var rightTop = GetCroppedBitmap(HorizontalOffset + 1, 0, ImageSource.PixelWidth - HorizontalOffset - 1, VerticalOffset);
                    var rightBottom = GetCroppedBitmap(HorizontalOffset + 1, VerticalOffset + 1, ImageSource.PixelWidth - HorizontalOffset - 1, ImageSource.PixelHeight - VerticalOffset - 1);
                    //最中间的
                    var center = GetCroppedBitmap(HorizontalOffset, VerticalOffset, 1, 1);
                    var leftCenter = GetCroppedBitmap(0, VerticalOffset, HorizontalOffset, 1);
                    var rightCenter = GetCroppedBitmap(HorizontalOffset + 1, VerticalOffset, ImageSource.PixelWidth - HorizontalOffset - 1, 1);
                    var topCenter = GetCroppedBitmap(HorizontalOffset, 0, 1, VerticalOffset);
                    var bottomCenter = GetCroppedBitmap(HorizontalOffset, VerticalOffset + 1, 1, ImageSource.PixelHeight - VerticalOffset - 1);

                    //------------------------------- 上面的逻辑是切图，下面的逻辑是绘制 -----------------------------------


                    drawingContext.DrawImage(leftTop, new Rect(0, 0, HorizontalOffset, VerticalOffset));

                    drawingContext.DrawImage(rightTop, new Rect(HorizontalOffset + stretchWidth, 0, ImageSource.PixelWidth - HorizontalOffset - 1, VerticalOffset));

                    if (stretchHeight > 0)
                    {
                        drawingContext.DrawImage(leftCenter, new Rect(0, VerticalOffset, HorizontalOffset, stretchHeight));
                        drawingContext.DrawImage(rightCenter, new Rect(HorizontalOffset + stretchWidth, VerticalOffset, ImageSource.PixelWidth - HorizontalOffset - 1, stretchHeight));
                    }

                    if (stretchWidth > 0)
                    {
                        drawingContext.DrawImage(topCenter, new Rect(HorizontalOffset, 0, stretchWidth, VerticalOffset));
                        drawingContext.DrawImage(bottomCenter, new Rect(HorizontalOffset, VerticalOffset + stretchHeight, stretchWidth, ImageSource.PixelHeight - VerticalOffset - 1));
                    }

                    if (stretchHeight > 0 && stretchWidth > 0)
                    {
                        drawingContext.DrawImage(center, new Rect(HorizontalOffset, VerticalOffset, stretchWidth, stretchHeight));
                    }

                    drawingContext.DrawImage(leftBottom, new Rect(0, VerticalOffset + stretchHeight, HorizontalOffset, ImageSource.PixelHeight - VerticalOffset - 1));
                    drawingContext.DrawImage(rightBottom, new Rect(HorizontalOffset + stretchWidth, VerticalOffset + stretchHeight, ImageSource.PixelWidth - HorizontalOffset - 1, ImageSource.PixelHeight - VerticalOffset - 1));
        }

        //仅支持水平方向拉伸
        protected override void OnRender(DrawingContext drawingContext)
        {
            var stretchWidth = GetStretchWidth();

                    if (stretchWidth <= 0)
                    {
                        drawingContext.DrawImage(ImageSource, new Rect(0, 0, ImageSource.PixelWidth, ImageSource.PixelHeight));
                        return;
                    }

                    var left = GetCroppedBitmap(0, 0, HorizontalOffset, ImageSource.PixelHeight);
                    var center = GetCroppedBitmap(HorizontalOffset, 0, 1, ImageSource.PixelHeight);
                    var right = GetCroppedBitmap(HorizontalOffset + 1, 0, ImageSource.PixelWidth - HorizontalOffset - 1, ImageSource.PixelHeight);

                    drawingContext.DrawImage(left, new Rect(0, 0, HorizontalOffset, ImageSource.PixelHeight));
                    
                    if (stretchWidth > 0)
                    {
                        drawingContext.DrawImage(center, new Rect(HorizontalOffset, 0, stretchWidth, ImageSource.PixelHeight));
                    }
                    else
                    {
                        stretchWidth = 0;
                    }

                    drawingContext.DrawImage(right, new Rect(HorizontalOffset + stretchWidth, 0, ImageSource.PixelWidth - HorizontalOffset - 1, ImageSource.PixelHeight));
        }

        //仅支持垂直方向拉伸
        protected override void OnRender(DrawingContext drawingContext)
        {
            var stretchHeight = GetStretchHeight();

                    if (stretchHeight <= 0)
                    {
                        drawingContext.DrawImage(ImageSource, new Rect(0, 0, ImageSource.PixelWidth, ImageSource.PixelHeight));
                        return;
                    }

                    //裁剪还是按原始图片尺寸来裁剪，这里的原始图片尺寸是按dpi 96计算的
                    var top = GetCroppedBitmap(0, 0, ImageSource.PixelWidth, VerticalOffset);
                    var center = GetCroppedBitmap(0, VerticalOffset, ImageSource.PixelWidth, 1);
                    var bottom = GetCroppedBitmap(0, VerticalOffset + 1, ImageSource.PixelWidth, ImageSource.PixelHeight - VerticalOffset - 1);

                    //这里用 PixelWidth，而不是 Width，主要是因为显示的时候，要按图片的解码尺寸来显示，否则图片就会变大或者变小，这个是由DPI决定的
                    drawingContext.DrawImage(top, new Rect(0, 0, ImageSource.PixelWidth, VerticalOffset));

                    //超长才需要显示拉伸部分的图片
                    if (stretchHeight > 0)
                    {
                        drawingContext.DrawImage(center, new Rect(0, VerticalOffset, ImageSource.PixelWidth, stretchHeight));
                    }
                    else
                    {
                        stretchHeight = 0;
                    }
                    drawingContext.DrawImage(bottom, new Rect(0, VerticalOffset + stretchHeight, ImageSource.PixelWidth, ImageSource.PixelHeight - VerticalOffset - 1));
        }

        //测量布局大小，这里要记得重写下。这个版本不支持不同尺寸的分辨率，可以通过计算缩放比来实现
        private Size MeasureCore(Size size, ImageSource imgSource)
        {
            if (imgSource == null) return size;

            Size naturalSize;

            if (IsHorizontalStretchEnabled && IsVerticalStretchEnabled)
            {
                naturalSize = new Size(size.Width, size.Height);
            }
            else if (IsHorizontalStretchEnabled)
            {
                naturalSize = new Size(size.Width, imgSource.PixelHeight);
            }
            else if (IsVerticalStretchEnabled)
            {
                naturalSize = new Size(imgSource.PixelWidth, size.Height);
            }
            else
            {
                return size;
            }

            return naturalSize;
        }

以上代码就可以实习水平拉伸，垂直拉伸或者水平+垂直拉伸的功能了。目前的测试代码还不支持不同分辨率的图片，demo中的计算是使用了ImageSource的宽高。如果需要支持任意分辨率，可以按渲染的宽高和图片的实际宽高做个比例缩放运算即可。

微信公众号：

欢迎转载分享，如若转载，请标注署名。

WPF-缩放动画和平移动画叠加后会发生什么？

Wed, 22 Mar 2023 01:12:03 +0000

WPF实现边平移，边缩放的动画效果，它的平移坐标应该怎么计算？

我们可以写个小Demo测试下：

    <Grid>
        <!-- 只做平移，不做缩放 -->
        <Border Height="100" Width="100" HorizontalAlignment="Left" VerticalAlignment="Top" Background="#7100FFFF">
            <Border.RenderTransform>
                <TransformGroup>
                    <TranslateTransform X="200" Y="100"/>
                </TransformGroup>
            </Border.RenderTransform>
        </Border>

        <!-- 1.5倍平移缩放后的对象 -->
        <Border Height="100" Width="100" HorizontalAlignment="Left" VerticalAlignment="Top" Background="#71FF0000">
            <Border.RenderTransform>
                <TransformGroup>
                    <TranslateTransform X="200" Y="100"/>
                    <ScaleTransform CenterX="50" CenterY="50" ScaleX="1.5" ScaleY="1.5"/>
                </TransformGroup>
            </Border.RenderTransform>
        </Border>
        
        <!-- 缩放后的大小和位置，通过Margin值，用于观察它的坐标位置 -->
        <Border Height="150" Width="150" HorizontalAlignment="Left" VerticalAlignment="Top" Background="#77777777" Margin="275,125,0,0">

        </Border>
    </Grid>

运行以上demo代码后，我们可以看到他们的坐标值：

正常平移后，它的坐标是：(200，100)。
平移缩放后，它的坐标是：(275,125)。

我们来观察下这两组数据，做以下两种假设：

元素缩放后，平移的坐标值不会随着缩放的比例而发生变化。
元素缩放后，平移的坐标值，会跟随缩放的比例发生变化。

如果是第一种情况，我们来计算下，它平移后的值应该是多少：


//元素的宽度和高度值为100，缩放1.5倍之后为150。按左上角做平移后，它的理论值应该为：

//计算公式： 目标位置 = 平移量  - （缩放后的宽高 - 原始宽高）/ 2
double offsetX = 200 - (150 - 100) / 2 = 175 ;
double offsetY = 100 - (150 -100) / 2 = 75 ;

通过上述计算得出的坐标点为：(175,75)，显然跟实际结果不一致。

再来看下第二种假设：

//元素的宽度和高度值为100，缩放1.5倍之后为150。按左上角做平移后，它的理论值应该为：

//目标位置 = 平移量 * 缩放比 - （缩放后的宽高 - 原始宽高）/ 2
double offsetX = 200 * 1.5 - (150 - 100) / 2 = 275 ;
double offsetY = 100 * 1.5 - (150 - 100) / 2 = 125 ;

通过上述计算得出的坐标点为：(275,125)，跟实际结果完全一致。

为了确定数据的准确性，我们可以增加几组数据做下测试对比，这里就省略了~

最终得出结论：平移和缩放两种变化叠加的时候，平移变换的偏移量也会跟着做缩放。

已知起始坐标和终止坐标的情况下，我们可以通过以下公式来计算偏移量：

        /// <summary>
        /// 获取缩放后所需要平移的值
        /// </summary>
        /// <param name="offset">缩放前需要平移的值</param>
        /// <param name="scale">缩放的倍数</param>
        /// <param name="elementWidthOrHeight">元素的宽或高</param>
        /// <returns></returns>
        private double GetScaleTranslateOffset(double offset, double scale, double elementWidthOrHeight)
        {
            //平移量 = （ 目标位置 + （缩放后的宽高 - 原始宽高）/ 2 ）/ 缩放比
            //平移量 = （ 目标位置 + （缩放比 -1）* 宽高 / 2 ）/ 缩放比
            return (offset + (scale - 1) * elementWidthOrHeight / 2) / scale;
        }

总结：

    目标位置 = 平移量 * 缩放比 - (缩放比 -1) * 宽高 / 2
    平移量 = （目标位置 + (缩放比 -1) * 宽高 / 2 ）/ 缩放比

微信公众号：

欢迎转载分享，如若转载，请标注署名。

WPF如何使用外部字体

Thu, 16 Mar 2023 01:12:03 +0000

当我们所使用的字体，系统不存在怎么办？

一种方式就是给系统安装该字体，这种方式安装的字体能够全局生效。

控制面板中可以看到本机已经安装了哪些字体：

第二种方法就是免安装，直接加载字体资源。

一. 全局安装：

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern int WriteProfileString(string lpszSection, string lpszKeyName, string lpszString);

        [DllImport("gdi32")]
        public static extern int AddFontResource(string lpFileName);

        /// <summary>
        /// 安装字体
        /// </summary>
        /// <param name="fontFilePath">字体文件全路径</param>
        /// <returns>是否成功安装字体</returns>
        /// <exception cref="UnauthorizedAccessException">不是管理员运行程序</exception>
        /// <exception cref="Exception">字体安装失败</exception>
        public static bool InstallFont(string fontFilePath)
        {
            try
            {
                System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent();

                System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity);
                //判断当前登录用户是否为管理员
                if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator) == false)
                {
                    throw new UnauthorizedAccessException("当前用户无管理员权限，无法安装字体。");
                }
                //获取Windows字体文件夹路径
                string fontPath = Path.Combine(System.Environment.GetEnvironmentVariable("WINDIR"), "fonts", Path.GetFileName(fontFilePath));
                //检测系统是否已安装该字体
                if (!File.Exists(fontPath))
                {                    
                    File.Copy(fontFilePath, fontPath); //font是程序目录下放字体的文件夹
                    AddFontResource(fontPath);
                    //安装字体
                    WriteProfileString("fonts", Path.GetFileNameWithoutExtension(fontFilePath) + "(TrueType)", Path.GetFileName(fontFilePath));
                }
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format($"[{Path.GetFileNameWithoutExtension(fontFilePath)}] 字体安装失败！原因：{ex.Message}"));
            }
            return true;
        }

这种方案需要管理员权限才能安装，并且安装的字体路径在不同（win7,win10,win11）的操作系统里面不尽相同。整个安装过程相对会麻烦一些，卸载软件的时候，还得考虑需不需要卸载我们软件安装的字体。于是我们有了第二种方案，免安装使用字体！

字体引入方式：

<TextBlock Text="text1">
    <TextBlock.FontFamily>
        <FontFamily>/程序集名称;component/Font/字体文件名#字体名称</FontFamily>
    </TextBlock.FontFamily>
</TextBlock>

textBlock.FontFamily=new FontFamily(new Uri("/程序集名称;component/Font/字体文件名"),"字体名称")

这里需要注意下，引入字体的路径是字体文件的相对或绝对路径，通过#号连接字体名称来引入。

关注我，了解更多技术分享，微信公众号：

欢迎转载分享，如若转载，请标注署名。

Nuget包的版本规范

Wed, 15 Mar 2023 01:12:03 +0000

我们通常在制作NuGet包的时候，会给包一个版本号，但是NuGet包的版本号后面为啥还有-alpha这样子字符呢？

这不得不提下，关于NuGet的版本号规范。

版本号定义

Major.Minor.Patch[-Suffix] （[options] 方括号的内容表示可选项，非必填）

语义说明：

  Major：主版本号，重大更改
  Minor：次版本号，新增功能，但可向后兼容
  Patch：修订号，仅可向后兼容的 bug 修复
  -Suffix（可选）：表示预发布版本，可以是任何文本。以下是推荐的写法
    -alpha：Alpha 版本，通常用于在制品和试验品。
    -beta：Beta 版本，通常指可用于下一计划版本的功能完整的版本，但可能包含已知 bug。
    -rc：候选发布，通常可能为最终（稳定）版本，除非出现重大 bug。

版本号示例

0.89
0.0-alpha
2.4-rc
25.4-beta
25.312-prerelease

版本范围

版本范围主要是用于我们制作nuget包时，包的版本依赖限制。

.nuspec 文件中的引用

<dependency> 元素中的 version 属性描述了依赖项可接受的范围版本。

<!-- Accepts any version 6.1 and above. -->
<dependency id="ExamplePackage" version="6.1" />

<!-- Accepts any version above, but not including 4.1.3. Could be
     used to guarantee a dependency with a specific bug fix. -->
<dependency id="ExamplePackage" version="(4.1.3,)" />

<!-- Accepts any version up below 5.x, which might be used to prevent pulling in a later
     version of a dependency that changed its interface. However, this form is not
     recommended because it can be difficult to determine the lowest version. -->
<dependency id="ExamplePackage" version="(,5.0)" />

<!-- Accepts any 1.x or 2.x version, but not 0.x or 3.x and higher. -->
<dependency id="ExamplePackage" version="[1,3)" />

<!-- Accepts 1.3.2 up to 1.4.x, but not 1.5 and higher. -->
<dependency id="ExamplePackage" version="[1.3.2,1.5)" />

参考文献：https://learn.microsoft.com/zh-cn/nuget/concepts/package-versioning。

微信公众号：

欢迎转载分享，如若转载，请标注署名。

使用BaGet快速搭建nuget服务

Tue, 07 Mar 2023 01:12:03 +0000

BaGet是基于asp.net core编写的一个轻量级的nuget管理服务，安装部署非常简单。

环境准备

命令终端运行（自我寄宿）

解压BaGet.zip
打开cmd命令行，输入dotnet BaGet.dll即可运行

以服务的方式运行

使用nssm进行安装，点击查看具体操作方法
通过windows任务计划

这里推荐第一种方式

配置Visual Studio中的Nuget配置

在Visual Studio 包管理器中，添加http://192.168.1.221:5000/v3/index.json这样子的链接。IP地址可以根据实际部署的IP或者域名进行修改。

使用浏览器打开Nuget管理页面

通过浏览器，输入我们配置的Url http://192.168.1.221:5000/，打开即可。

微信公众号：

欢迎转载分享，如若转载，请标注署名。

如何动态加载程序集

Fri, 03 Mar 2023 05:12:03 +0000

上一篇文章《如何构建多平台Nuget包》提到动态加载程序集。

今天就来看下，使用C#如何动态加载程序集。

程序集的加载，默认是从当前目录下查找，如果当前目录查找不到，然后再去系统目录中查找，依然查找不到就会从环境变量中查找，如果依然找不到，则会抛出一个异常FileNotFoundException。

托管代码中，AppDomain.CurrentDomain.AssemblyResolve事件可以帮助我们去监听程序集加载失败，并请求重新加载程序集，我们可以在这里事件中去处理程序集的查找工作。

具体示例代码如下：

    /// <summary>
    /// 托管代码加载器
    /// </summary>
    public class AssemblyLoader
    {
        /// <summary>
        /// 根据runtimes的文件动态加载程序集(C++的设置方法：Win32.SetDllDirectory(filename))
        /// </summary>
        public static void ImportFromRuntimes()
        {
            AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
        }

        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
        {
            var index = args.Name.IndexOf(',');
            if (index != -1)
            {
                var assemblyName = args.Name.Substring(0, index);
                return Load($"{assemblyName}.dll");
            }

            return null;
        }

        private static Assembly Load(string assemblyName)
        {
            string filename;

            if (Environment.Is64BitProcess)
            {
                filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"runtimes\win-x64\native", assemblyName);
            }
            else
            {
                filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"runtimes\win-x86\native", assemblyName);
            }

            if (File.Exists(filename))
            {
                return Assembly.LoadFrom(filename);
            }
            else
            {
                return null;
            }            
        }
    }

    //在应用程序启动的时候，执行该方法即可。
    AssemblyLoader.ImportFromRuntimes();

但是这里需要注意的是，程序集加载失败会触发该事件。如果是程序集本身可以加载，但是因为目标平台不对则会引发异常，并不会触发该事件。如：System.BadImageFormatException。

.NET CORE 项目本身包含该机制，可以自动查找。.NET Framework 需要手动添加。

微信公众号：

欢迎转载分享，如若转载，请标注署名。

如何使用ffmpeg进行录屏

Fri, 03 Mar 2023 01:12:03 +0000

录屏软件，我们去网上下载，发现有很多软件都是要收费的！但是录屏功能很难做吗？为啥都需要收费呢？

于是我整了个小demo，用于实现基础的屏幕录制功能。

思路很简单，考虑到FFMpeg.exe是一个非常成熟的音视频处理软件，而且是开源的。我们完全可以基于FFMpeg.exe来实现我们的要求。

使用FFMpeg录屏通常有两种方式：

基于 gdigrab (使用CPU录制)
基于DirectShow （使用显卡录制）

考虑到gdigrab方式实现更简单，更轻量，兼容性也更好，所以我们采用gdigrab方案。DirectShow方案需要额外下载screen-capture-recorder!

基于该方法，主要核心就是ffmpeg的命令编写，具体命令如下：

ffmpeg -f gdigrab -framerate 30 -offset_x 0 -offset_y 0 -video_size 1920x1080 -i desktop -r 30 -vcodec libx264 -pix_fmt yuv420p -y "output.mp4"

命令解说：

//注意：ffmpeg 的命令输入，也需要考虑输入顺序的。先指定输入参数，再指定输出参数。

// -f 表示指定文件格式或采集数据的设备，如果是 DirectShow 方案，就需要指定为 screen-capture-recorder。
    //对于输入，如果不指定-f, ffmpeg 会根据输入数据，来判断数据的封装格式.
    //对于输出，如果不指定-f， ffmpeg 也可以通过输出文件名进行推导.
    //ffmpeg -formats 可以列出所有的formats

// -framerate 指定录制的视频帧率

// -offset_x -offset_y 指定录制的区域左上角坐标

// -video_size 指定录制的视频尺寸

// -i 指定从哪儿采集数据，它是一个文件索引号。这里是指定输入的视频源。 （i 表示input，不一定是表示视频文件，表示输入。如也可以是音频文件输入等）

// -r 指定帧率

// -vcodec 指定编码格式。 libx264 这种格式录制出来的视频，清晰度更清晰，占用的文件大小更小，推荐使用。

// -pix_fmt 像素格式，常规使用yuv420p

// -y 表示强制覆盖，如果输出文件已经存在，就覆盖

// 输出文件路径。这里需要注意下：输出文件路径带上 双引号 ，防止不合法路径将命令拆分了。

为了更方便代码实现相关编码，下面贴上核心代码（附加音视频合并的示例代码）：

    /// <summary>
    /// 视频录制命令构建类
    /// </summary>
    public class FFMpegScreenRecordArgs : FFMpegArgs
    {
        public int Framerate { get; set; }

        public int Rate { get; set; }

        public Rect Region { get; set; }

        public VideoCodec Codec { get; set; }

        public PixelFormat PixelFormat { get; set; }

        public string SavePath { get; set; }

        public override string ToArgs()
        {
            ArgsBuilder.SetRecordDevice();
            ArgsBuilder.SetFramerate(Framerate);
            ArgsBuilder.SetRecordRect((int)Region.Left, (int)Region.Top);
            ArgsBuilder.SetVideoSize((int)Region.Width, (int)Region.Height);
            ArgsBuilder.SetInput();
            ArgsBuilder.SetRate(Rate);
            ArgsBuilder.SetCodec(Codec);
            ArgsBuilder.SetPixFarmat(PixelFormat);
            return $"{ArgsBuilder.GetArgs()} -y {SavePath}\"";
        }
    }

    /// <summary>
    /// 音视频合成构建类
    /// </summary>
    public class FFMpegAVSynthesisArgs : FFMpegArgs
    {
        public string InputAudioPath { get; set; }
        public string InputVideoPath { get; set; }
        public string OutputVideoPath { get; set; }

        public override string ToArgs()
        {
            this.ArgsBuilder.SetInput(InputAudioPath);
            this.ArgsBuilder.SetInput(InputVideoPath);
            this.ArgsBuilder.SetCodec(AudioCodec.copy);
            this.ArgsBuilder.SetCodec(VideoCodec.copy);

            return $"{ArgsBuilder.GetArgs()} \"{OutputVideoPath}\"";
        }
    }

    //基础命名构建类
    public class FFmpegArgsBuilder
    {
        protected readonly List<string> Args = new List<string>();
        public FFmpegArgsBuilder AddArg<T>(string Key, T Value)
        {
            Args.Add($"-{Key} {Value}");

            return this;
        }

        public virtual string GetArgs()
        {
            return string.Join(" ", Args);
        }

        public void Reset()
        {
            Args.Clear();
        }

        #region args

        public FFmpegArgsBuilder SetRecordRect(int x, int y)
        {
            AddArg("offset_x", x);
            AddArg("offset_y", y);
            return this;
        }

        public FFmpegArgsBuilder SetVideoSize(int width, int height)
        {
            AddArg("video_size", $"{width}x{height}");
            return this;
        }

        public FFmpegArgsBuilder SetInput(string input = "desktop")
        {
            AddArg("i", input);
            return this;
        }

        public FFmpegArgsBuilder SetFramerate(int framerate)
        {
            AddArg("framerate", framerate);
            return this;
        }

        public FFmpegArgsBuilder SetRate(int rate)
        {
            AddArg("r", rate);
            return this;
        }

        public FFmpegArgsBuilder SetRecordDevice(string device = "gdigrab")
        {
            AddArg("f", device);
            return this;
        }

        public FFmpegArgsBuilder SetCodec(VideoCodec codec)
        {            
            AddArg("vcodec", codec);
            return this;
        }

        public FFmpegArgsBuilder SetCodec(AudioCodec audioCodec)
        {
            AddArg("acodec", audioCodec);
            return this;
        }

        public FFmpegArgsBuilder SetPixFarmat(PixelFormat x)
        {
            AddArg("pix_fmt", x);
            return this;
        }
        
        #endregion
    }

    //像素格式
    public enum PixelFormat
    {
        ///<summary>
        /// yuv420p
        ///</summary>
        yuv420p,
        //……省略……
    }

    //编码格式
    public enum VideoCodec
    {
        ///<summary>
        ///      libx264
        ///</summary>
        libx264,

        ///<summary>
        ///      copy
        ///</summary>
        copy,
        //……省略……
    }

    /// <summary>
    ///     Audio codec ("ffmpeg -codecs")
    /// </summary>
    public enum AudioCodec
    {
        ///<summary>
        ///      copy
        ///</summary>
        copy,
    }

其它文献：

https://www.cnblogs.com/tuyile006/p/12572656.html
https://www.jianshu.com/p/f15fe6f7202f
https://blog.csdn.net/a457636876/article/details/107857674

微信公众号：

欢迎转载分享，如若转载，请标注署名。

诡异的Visual Studio编译错误

Thu, 02 Mar 2023 01:12:03 +0000

诡异的Visual Studio编译错误，非代码级编译错误！

使用Visual Studio 2022 17.5.1版本编译项目的时候，意外发现时不时会出现System.ArgumentException: 路径中具有非法字符的编译错误。但后续编译一切正常，重启Visual Studio后，发现有的项目无法正常加载了！

除了这种情况以外，还会提示其它错误：“Persistence = ProjectFileWithInterceptionViaSnapshot”没有项目属性提供程序。。

通过检查代码，一路狂飙，看着都没有啥毛病啊！

最终在对比文件修改区别，逐个排除最终发现：csproj文件经过xml格式化工具格式化过，格式化以后，visual studio在解析的时候不能正常工作，导致内部出现异常，从而引发奇奇怪怪的问题。

最终发现是因为格式化的过程中，导致标签内容出现了较多不需要的空格和换行。如：

        <Content Include="$(MSBuildThisFileDirectory)..\..\runtimes\win-x86\native\CefSharp.dll">
            <CopyToOutputDirectory>
                PreserveNewest
            </CopyToOutputDirectory>
            <Link>
                runtimes\win-x86\native\CefSharp.dll
            </Link>
            <Visible>
                false
            </Visible>
        </Content>

修正后

        <Content Include="$(MSBuildThisFileDirectory)..\..\runtimes\win-x86\native\CefSharp.dll">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
            <Link>runtimes\win-x86\native\CefSharp.dll</Link>
            <Visible>false</Visible>
        </Content>

按修正后的重新编译，一切恢复正常！

以上问题尚不确定到底是编译器的BUG，还是什么原因，如果有遇上，可以尝试通过上述方法尝试解决！

微信公众号：

欢迎转载分享，如若转载，请标注署名。

如何构建多平台nuget包

Fri, 10 Feb 2023 01:12:03 +0000

虽然C#可以直接编译成AnyCPU，可以直接在x86，x64，ARM平台运行。

但是实际项目中，我们可能避免不了会引用一些外部的依赖库，而这些外部依赖库又不能编译成 AnyCPU!

通常解决这种问题可以通过进程隔离来解决，也可以通过动态加载程序集来解决。

所以采用动态程序集加载的方式的话，我们的nuget包就需要同时把 x86,x64,arm相关的运行库同时打包进去了。

之前我们已经讲过，如何手动构建nuget包,如果还不太清楚的小伙伴，可以回顾下手动构建nuget包。

构建多平台nuget包之前，需要先了解一些基础知识：

手动创建nuget包的基本方法
nuget的目录结构
csproj的结构的基础
编译过程

这里不做详细描述~

Nuget包的基础结构

├─ Build
│  ├─net462
│  │    └─*.props
│  │    └─*.targets
│  └─netstandard1.3
├─lib
│  ├─net462
│  └─netstandard1.3
└─runtimes
    ├─win-arm64
    │  └─native
    ├─win-x64
    │  └─native
    └─win-x86
        └─native

说明：

Build 文件夹，存放用于参与编译的配置文件。包含*.props和*.targets格式文件。*.props通常用于设置csproj文件中特定的属性，可以理解为一个普通类的属性，这个属性值可以先设置，用不用就不关它事情。*.targets通常用于执行某个操作，可以理解为一个普通类里面的方法，可以使用其它属性执行某个操作。需要注意的是：上述描述主要是为了方便理解，普通属性的设置也可以存放在*.targets文件中。
lib 文件夹，存放参与编译的相关（动态/静态）链接库，可同时存放多个。编译时，默认情况下，该文件夹的文件会自动拷贝到输出目录下。
runtimes 文件夹，存放运行时所依赖的相关（动态/静态）链接库。该文件夹的结构请参考上述结构来存放。虽然该结构并不是nuget包里面的强制要求，但是按照这种结构会比较规范。尤其是在.NET CORE的应用中，运行时将会自动再该结构中查找对应的依赖库。

细心的朋友会发现，这个结构和上一次的结构会有什么区别？

是的，多了Build目录！所以这次构建多平台nuget包，就需要用到它。

要想同时支持多平台，就需要在AnyCPU的条件编译下，将Nuget包内部的文件，动态输出到指定的目录。程序运行的时候，再动态加载该文件即可。

Nuget包内部文件组织步骤

这里以.net framework net45为例，命名为nuget.test其它框架下修改对应的框架名称即可：

分别创建 build->net45, lib->net45, runtimes->win-x86, runtimes->win-x64等文件夹
将需要打包的文件分别拖动到对应的文件夹中。
创建nuget.test.targets文件

编辑该文件，输入以下内容：

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <ItemGroup Condition="'$(Platform)' == 'AnyCPU' Or '$(Platform)' == 'Any CPU'">
        <Content Include="$(MSBuildThisFileDirectory)..\..\runtimes\win-x86\native\CefSharp.Wpf.dll">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
            <Link>runtimes\win-x86\native\CefSharp.Wpf.dll</Link>
            <Visible>false</Visible>
        </Content>
        <Content Include="$(MSBuildThisFileDirectory)..\..\runtimes\win-x64\native\CefSharp.Wpf.dll">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
            <Link>runtimes\win-x64\native\CefSharp.Wpf.dll</Link>
            <Visible>false</Visible>
        </Content>
    </ItemGroup>
</Project>

上面这段配置的主要目的，是根据编译器的条件编译，把nuget包中不同平台下的文件，复制到输出目录。

上述配置简要说明：

$(Platform) 表示编译平台：x86,x64,Any CPU,ARM64
$(MSBuildThisFileDirectory) 表示当前文件所在的目录，这里是指 nuget.test.targets 文件所在的目录绝对路径。
Content 表示项目内容
CopyToOutputDirectory 复制到输出目录
    PreserveNewest        较新才复制
    Always               总是复制
    Never                 从不
Link                  需要输出的文件目录位置，以输出目录作为根目录。

有这段配置文件后，编译的时候就会根据条件编译配置，自动把文件添加到输出目录中。x86，x64的条件编译的方法也是一样的，大家可以自行补充。

注意事项：

一个nuget包的*.targets和*.props文件只能创建一个
*.targets和*.props 前缀文件名需要和包名一致
配置文件中的格式不能有无故的换行，空格。参见：诡异的编译错误

根据上述方法，可以尝试打一个多平台的nuget包了。

微信公众号：

欢迎转载分享，如若转载，请标注署名。

csproj标签的简单介绍

Sat, 14 Jan 2023 01:12:03 +0000

介绍几个常用的csproj Property!

<!--csproj框架引用-->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <!--支持的编译平台，配置了此选项，可以在配置管理里面配置它到底是x86还是x64或者AnyCPU-->
    <Platforms>AnyCPU;x86;x64</Platforms>
    <!--当前项目按什么来编译-->
    <PlatformTarget>x86</PlatformTarget>
    <!--版本，打nuget包也会认这个版本号-->
    <Version>1.0.0</Version>
    <FileVersion>1.0.0</FileVersion>
    <!--编译输出类型：Library 类库，WinExe 应用程序-->
    <OutputType>Library</OutputType>
    <!--是否启用WPF，Winform同理-->
    <UseWPF>true</UseWPF>
    <!--是否生成 AssemblyInfo.cs，如果需要手动添加就设置为False。因为 Microsoft.NET.Sdk 里面已经包含了该配置-->
    <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
    <!--打nuget包时可能会用到该选项。如果csproj没有显示的包含Compile的项，提示重复的Compile。可以尝试添加此项-->
    <IncludePackageReferencesDuringMarkupCompilation>False</IncludePackageReferencesDuringMarkupCompilation>
    <!--目标框架类型-->
    <TargetFramework>net452</TargetFramework>
    <!--基础输出目录-->
    <BaseOutputPath>..</BaseOutputPath>
    <!--输出目录-->
    <OutputPath>$(BaseOutputPath)\$(Configuration)\</OutputPath>
    <!--是否将framework版本追加到目录，如 自动创建 net452 文件夹-->
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
    <!--是否将运行标识追加到目录，如 自动创建 x86 文件夹-->
    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
    <!--应用程序图标-->
    <ApplicationIcon>ico_test_48.ico</ApplicationIcon>
  </PropertyGroup>
  <!--框架引用-->
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <!--项目引用-->
  <ItemGroup>
    <ProjectReference Include="..\A\B.csproj" />
  </ItemGroup>
  <!--包引用-->
  <ItemGroup>
    <PackageReference Include="System.Data.SQLite">
      <Version>1.0.115.5</Version>
    </PackageReference>
  </ItemGroup>
</Project>

微信公众号：

欢迎转载分享，如若转载，请标注署名。

Window.Owner的几个注意事项

Fri, 13 Jan 2023 01:12:03 +0000

Window.Owner的几个注意事项！

Owner不能设置自己，否则会引发异常
ShowDialog的话，关闭的时候，需要将Owner设置为null，否则会出现闪一下的问题。
关闭父级窗口时候，子窗口也同步关闭，但不会触发Closeing事件

欢迎转载分享，如若转载，请标注署名。

博客链接2：https://huchengv5.github.io/

微信公众号：

Application.Current正确获取主窗口

Thu, 12 Jan 2023 01:12:03 +0000

Application.Current.MainWindow用于获取主窗口，相信不少同学有这么用过。但是这种方式，可靠吗？

正常情况下，这种方式是可以获取到主窗口的。因为常规的操作，应用程序启动的时候，就会启动一个默认的MainWindow（当然我们也可以手动启动这个主窗口）。

这个时候，通过Application.Current.MainWindow获取这个主窗口，并不会有什么问题。

但是，如果我们的主窗口存在关闭，再打开其它的窗口，这个时候去获取主窗口就不一定是它了。

因为主窗口我们通常知道它是什么数据类型，所以我们可以通过指定窗口类型的方式来获取我们需要的主窗口。

        public static Window GetWindow<T>() where T : Window
        {
            if (Application.Current == null || Application.Current.Windows == null)
                return null;
            for (int i = 0; i < Application.Current.Windows.Count; i++)
            {
                if (Application.Current.Windows[i] is T window)
                {
                    return window;
                }
            }
            return null;
        }

通过上述方法，我们就可以获取指定类型的窗口了。用这种方式获取对应的窗口，相对来讲会比较稳妥。但是如果有多个相同类型的窗口，那就需要改造一下了。

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

Path.Combine容易被忽略的细节

Sat, 07 Jan 2023 01:12:03 +0000

Path.Combine这个方法是很常用的一个方法，通常用它来拼接路径。尤其是存在对路径有跨平台的场景，更应该使用它来处理路径拼接。

那Path.Combine会存在怎么样的一个问题呢？

private class TestClass
{
    public void Test()
    {
        var result= Path.Combine("C:\Users\Desktop\tmp","/image.png")        
    }
}

以上代码中 result 结果会是什么呢？

result = C:\Users\Desktop\tmp/image.png 吗？

实际上，结果是 /image.png。

为什么会这样子？

看下微软的注解：

    此方法旨在将单个字符串连接到表示文件路径的单个字符串中。 但是，如果第一个以外的参数包含根路径，则忽略以前的任何路径组件，并且返回的字符串以该根路径组件开头。 作为 方法的 Combine 替代方法，请考虑使用 Join 或 TryJoin 方法。

有这段注解应该就很好理解了，因为我们需要拼接的字符串中，以/或’\‘开头，那么它将忽略前面的参数。

所以我们在处理路径拼接的时候，一定要注意下这种场景，它会导致隐藏的BUG。

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

RichTextBox如何显示省略号？

Tue, 03 Jan 2023 01:12:03 +0000

RichTextBox是个很强大的文本组件，它可以用于显示各种复杂的富文本。

通常用富文本显示内容，通常是可以支持滚动显示，所以常规场景下是用不到省略号的。但是也不乏有些场景需要用到省略号。比如：文本内容的简述。

下面来分享一种比较简单的实现方法，来实现富文本省略号逻辑。

我们都知道WPF里面有TextBlock组件，它是一个相对比较轻量的文本组件，使用频率也是比较高的。它可以支持直接文本，也可以直接内联（Inlines)文本,如：Run标签。TextBlock本身也支持TextTrimming,可以用来显示省略号。

所以呢，要让RichTextBox来支持省略号的思路就比较简单，只需要在它的段落里面，内嵌TextBlock即可。

处理前的流文本示例：

<FlowDocument xml:space="preserve" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
    <Paragraph>        
            <Run Foreground="red">[红包]</Run>
            <Run Foreground="green">恭喜发财,大吉大利</Run>       
    </Paragraph>
</FlowDocument>

处理后的流文本示例：

<FlowDocument xml:space="preserve" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
    <Paragraph>
        <TextBlock TextTrimming="CharacterEllipsis" Foreground="blue">
            <Run Foreground="red">[红包]</Run>
            <Run Foreground="green">恭喜发财,大吉大利</Run>            
        </TextBlock>
    </Paragraph>
</FlowDocument>

以上方法，就可以简单的实现省略号的功能了，后面我会再分享一个组件，用来支持 html转RichTextBox。

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

如何显示灰色特效

Mon, 05 Dec 2022 01:12:03 +0000

最近大家有没有发现，很多App的首页变成灰白色了。这种灰白色很多时候用于纪念，哀悼等。那么使用WPF如何来做到这种效果呢？

要实现的这种效果，我们会发现，它其实不仅仅是要针对图片，而是要针对整个窗口来实现灰白色。

如果只是针对图片的话，我可以可以对图片进行灰阶转换，即可达到灰色效果。

以下是图片转灰阶的代码，当然方法不仅仅是这一种：

                //……省略……
                FormatConvertedBitmap grayImage = new FormatConvertedBitmap();
                grayImage.BeginInit();
                grayImage.Source = originImage as BitmapSource;
                grayImage.DestinationFormat = PixelFormats.Gray32Float;
                grayImage.EndInit();          
                //……省略……      

上述方法也可以直接在xaml里面表示。

    <Image.Source>
      <FormatConvertedBitmap DestinationFormat="Gray32">
        <FormatConvertedBitmap.Source>
          <BitmapImage UriSource="Images\1.png" />
        </FormatConvertedBitmap.Source>
      </FormatConvertedBitmap>
    </Image.Source>

如果我们想针对整个窗口应用这种灰色的效果，那我们可以用着色器特效（ShaderEffect）来实现。

说明：

*.fx格式文件：是一种应用特效效果文件，也叫渲染管线的配置文件。编写该文件语言名为高阶着色器语言（High Level Shader Language，简称HLSL），由微软拥有及开发的一种语言。
*.ps格式文件：是通过*.fx文件编译出来的文件，该文件是通过ShaderEffect所指定的原始文件。通过ShaderEffect类，将其应用于WPF。

灰阶相关 fx,ps等文件已有大佬写好了，我们直接拿来用即可跳转下载。相关解释，会在注释中说明。

渲染管线配置文件（*.fx）


//sampler2D 2D纹理采样器
//s0中，s表示取样器，0是表示取样器的子组件编号
sampler2D implicitInput : register(s0);
//c 表示缓冲区偏移量
float factor : register(c0);

//TEXCOORD 表示纹理坐标；COLOR 漫反射/镜面反射颜色
float4 main(float2 uv : TEXCOORD) : COLOR
{
    //返回纹理implicitInput在uv位置的颜色。
    float4 color = tex2D(implicitInput, uv);
    //将颜色转成灰阶
    float gray = color.r * 0.3 + color.g * 0.59 + color.b *0.11;    
    
    float4 result;    
    result.r = (color.r - gray) * factor + gray;
    result.g = (color.g - gray) * factor + gray;
    result.b = (color.b - gray) * factor + gray;
    result.a = color.a;
    
    return result;
}

应用WPF中特效类

    //灰阶特效
    public class GrayscaleEffect : ShaderEffect
    {
        //将像素着色器映射到灰阶着色器
        private static PixelShader _pixelShader = new PixelShader() { UriSource = new Uri(@"pack://application:,,,/GrayscaleEffect;component/GrayscaleEffect.ps") };

        public GrayscaleEffect()
        {
            PixelShader = _pixelShader;
            //更新着色器的值
            UpdateShaderValue(InputProperty);
            //该属性可以不要，该熟悉用于彩色到灰色过渡效果
            UpdateShaderValue(DesaturationFactorProperty);
        }

        public static readonly DependencyProperty InputProperty = ShaderEffect.RegisterPixelShaderSamplerProperty("Input", typeof(GrayscaleEffect), 0);
        public Brush Input
        {
            get { return (Brush)GetValue(InputProperty); }
            set { SetValue(InputProperty, value); }
        }

        public static readonly DependencyProperty DesaturationFactorProperty = DependencyProperty.Register("DesaturationFactor", typeof(double), typeof(GrayscaleEffect), new UIPropertyMetadata(0.0, PixelShaderConstantCallback(0), CoerceDesaturationFactor));

        //用于调节过渡效果
        public double DesaturationFactor
        {
            get { return (double)GetValue(DesaturationFactorProperty); }
            set { SetValue(DesaturationFactorProperty, value); }
        }

        private static object CoerceDesaturationFactor(DependencyObject d, object value)
        {
            GrayscaleEffect effect = (GrayscaleEffect)d;
            double newFactor = (double)value;

            if (newFactor < 0.0 || newFactor > 1.0)
            {
                return effect.DesaturationFactor;
            }

            return newFactor;
        }
    }

在WPF里面的使用示例:

        <!--effect 代表GrayscaleEffect所在的命名空间-->
        <Grid.Effect>
            <effect:GrayscaleEffect/>
        </Grid.Effect>

需要应用到哪个根元素上，就将该特效给对应元素的 Effect 赋值即可。

这种实现方法，性能还是很不错的，如果想对Shader有更深入的认识，可以阅读《DirectX 3D HLSL 高级实例精讲》.

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

位的基础运算

Thu, 24 Nov 2022 01:12:03 +0000

通过使用二进制位（bit)来做开关，是个不错的选择。

使用二进制作为开关，主要是针对不同的位进行赋值1或者0。

在实现这个功能之前，先来复习几个知识点：

位逻辑非运算（~）： 1变0，0变1
逻辑与运算（&）：位逻辑与运算将两个运算对象按位进行与运算。 0&0=0，0&1=0，1&0=0，1&1=1.
逻辑或运算（|）：位逻辑或运算将两个运算对象按位进行与运算 0|0=0，0|1=1，1|0=1，1|1=1。

现在我们来使用他们实现位开关：

    public class BitOperator
    {
        /// <summary>
        /// 设置指定位的值
        /// </summary>
        /// <param name="flag">标志数</param>
        /// <param name="index">从低到高位的索引值</param>
        /// <param name="onOff">1 true 或 0 false</param>
        /// <returns></returns>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        public static int SetFlag(int flag, int index, bool onOff)
        {
            if (onOff)
            {
                return flag | (1 << index);
            }
            else
            {
                return flag & ~(1 << index);
            }
        }

        /// <summary>
        /// 获取指定位的值
        /// </summary>
        /// <param name="flag">标志数</param>
        /// <param name="index">从低到高位的索引值</param>
        /// <returns></returns>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        public static bool GetFlagBitValue(int flag, int index)
        {
            return (flag & (1 << index)) != 0;
        }
    }

以上就是完整代码，要用来做一些开关的功能还是非常实用的。虽然现在内存比较大，可能都很少用这种方式。但是用它来判断全关还是非常方便的。

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

WebView2的踩坑记

Tue, 08 Nov 2022 01:12:03 +0000

对于桌面应用，用来显示Web页面的方式有很多种。比如说：WebBrowser、Cef Sharp、NWJS、WebView2等。CEF应该是最常用的一种页面嵌入方案。

微软原来推出过WebView，实在是过于拉跨，于是现在有了WebView2。

WebView2已经在项目上用上了，这里记录下它目前存在的几个坑。

一、Win7系统下，兼容性不够好

Win7系统下，不支持背景透明，背景设置透明会抛出异常。
Win7系统下，不支持父级窗口透明，否则会出现页面渲染不出来的问题。
反馈页面：https://github.com/MicrosoftEdge/WebView2Feedback/issues/2782

二、以管理员权限运行

无法打开上传对话框

三、WebView2的层级问题

WebView2的层级是置顶的，到导致内嵌WebView2只能在最顶层

EnsureCoreWebView2Async 一直处于等待状态

当WebView2不在视觉树上时，该方法将一直阻塞。WebView2的进程也不会创建出来。

因为ssl证书不可用导致页面无法访问问题

     private void CoreWebView2_ServerCertificateErrorDetected(object sender, CoreWebView2ServerCertificateErrorDetectedEventArgs e)
     {
         //此处可以加一些条件判断
         e.Action = CoreWebView2ServerCertificateErrorAction.AlwaysAllow;
     }

关闭智能拦截器

 //该属性默认为True，该属性只有高版本(1.0.1414,1.0.1466或以上)才支持
 //参见：https://learn.microsoft.com/zh-cn/microsoft-edge/webview2/release-notes?tabs=dotnetcsharp
 CoreWebView2Settings.IsReputationCheckingRequired =false;

一些奇怪的异常

异常来自 HRESULT:0x8007139F Microsoft.Web.WebView2.Core.Raw.ICoreWebView2Controller.MoveFocus(COREWEBVIEW2_MOVE_FOCUS_REASON reason)

尝试解决方法：

     protected override IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
     {
         if (!isCoreWebView2Initialized) return IntPtr.Zero;
         return base.WndProc(hwnd, msg, wParam, lParam, ref handled);
     }

(异常来自 HRESULT:0x8007139F) Microsoft.Web.WebView2.Core.Raw.ICoreWebView2Controller.set_Bounds(tagRECT Bounds)

尝试解决方法：

     protected override void OnWindowPositionChanged(Rect rcBoundingBox)
     {
         try
         {
             //如果没有初始化，就不执行操作
             // isCoreWebView2Initialized 是表示 EnsureCoreWebView2Async 方法是否已经执行完成
             if (!isCoreWebView2Initialized) return;

             //已经释放了，就不要再执行了
             if (!IsDisposed && IsLoaded)
             {
                 base.OnWindowPositionChanged(rcBoundingBox);
             }
         }
         catch (InvalidCastException ex)
         {
             if (ex.HResult == -2147467262)
             {
                 //do something
             }
         }
         catch (COMException ex2)
         {
             if (ex2.HResult == -2147019873)
             {
                 //do something
             }
         }
     }

The WebView control is no longer valid because the browser process crashed.To work around this, please listen for the CoreWebView2.ProcessFailed event to explicitly manage the lifetime of the WebView2 control in the event of a browser failure.https://docs.microsoft.com/en-us/dotnet/api/microsoft.web.webview2.core.corewebview2.processfailed(异常来自 HRESULT:0x80131509) Microsoft.Web.WebView2.Wpf.WebView2.VerifyBrowserNotCrashed()

目前观察该问题不会有什么影响，WebView可以自行恢复。
WebView2.Dispose引发调用线程无法访问此对象，因为另一个线程拥有该对象。因为WebView内部存在异步调用，要考虑线程的问题（通常GC线程调用Dispose的话，会有该问题）。

reject is not a funtion

H5调用C#的时候，会出现reject is not a funtion异常，已经类似或者相似的异常。这种情况，大部分原因是因为大小写问题。js是命名规范是小驼峰式，而C#是大驼峰式。这就会导致调用的时候，js找错了对象，导致无法识别该方法。解决方案：统一修改为小驼峰式（大驼峰依然会存在问题）

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

async await后的执行线程会是什么？

Tue, 25 Oct 2022 01:12:03 +0000

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

Mutex释放锁，从不同步的代码块中调用了对象同步方法？

Mon, 24 Oct 2022 01:12:03 +0000

从不同步的代码块中调用了对象同步方法？

这个异常提示，读起来晦涩难懂，感觉有必要解释下这句话是什么意思。

这里所说的不同步的代码块，指的是在不同的线程上运行的代码块。

对象同步方法知道是，对象的方法是同步的，应该是在同一个线程上下文中执行。

所以，总的来讲，就是说：本应该在同一个线程调用的方法，现在是在不同的线程上调用，从而引发此异常。

解决思路

针对这类问题的解决思路，就是把不同的代码块，放到同步代码块中，也就是同一个线程中调度。

具体实现方式可以有多种：

使用固定一个线程调用
使用同步上下文进行线程同步

第一种方案相对来讲，实现起来比较简单。我们可以直接开一个线程，将调用代码块，post该线程上执行即可。

以Mutex为例：

    public class ProcessMutex
    {
        public ProcessMutex(string key)
        {
            Key = key;
        }

        private Mutex mutex;
        public string Key { get; }

        public async Task WaitOneAsync()
        {
            await SingleThread.RunAndWaitAsync(() =>
            {
                if (!Mutex.TryOpenExisting(Key, out mutex))
                {
                    mutex = new Mutex(false, Key);
                }
                mutex.WaitOne();
            });
        }

        public async Task Dispose()
        {
            await SingleThread.RunAndWaitAsync(() =>
            {
                if (mutex != null)
                {
                    mutex.ReleaseMutex();
                    mutex.Dispose();
                }
            });
        }
    }

    //SingleThread.RunAndWaitAsync 就是额外开启的一个常驻线程。当然，这里也可以用UI线程。

第二种方法通过使用SynchronizationContext来实现上下文同步

在WPF里面，上下文同步的使用方法和winform稍微有点区别。
WPF本身有实现System.Windows.Threading.DispatcherSynchronizationContext，该上下文可以通过SynchronizationContext.Current来获得。

但是，该上下文只能在UI线程上获取，因为UI线程是个常驻线程。如果是在多线程中，SynchronizationContext.Current将为null。

这个时候需要通过手动设置的方式进行注入：

//为当前上下文进行赋值操作
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());

//需要让当前线程等待（不让线程退出）
//……省略

线程同步的更详细用法，可以参考以下博客： C# dotnet 自己实现一个线程同步上下文

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

Xaml文件如何省去命名空间的前缀

Fri, 30 Sep 2022 01:12:03 +0000

平常开发过程中，我们自定义的控件/组件，在使用的过程中，都需要加上命名空间的前缀，否则的话编译就会出错。

这让我们开发过程中，就显得比较麻烦。那有没有方法可以省去这个前缀呢?跟框架自带的组件一样使用？

方法比较简单，就是在我们程序集的声明中，增加如下声明。

[assembly: XmlnsDefinition(“http://schemas.microsoft.com/winfx/2006/xaml/presentation”,”命名空间”, AssemblyName = “程序集名称”)]

这个声明在AssemblyInfo.cs文件中

如果是使用dotnet core或者Microsoft.NET.Sdk，可以通过 false 来关闭自动生成的AssemblyInfo,手动来创建这个文件。

使用前

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:ui="clr-namespace:xxxxx.UI"

<Grid ui:XXXProperty.XXX="aaa">

</Grid>

使用后，

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
//xmlns:ui="clr-namespace:xxxxx.UI"

<Grid XXXProperty.XXX="aaa">

</Grid>

通过这种方式，我们的编码效率又能得到小步提升了。

这里需要注意下，因为改逻辑是放在AssemblyInfo.cs文件中，使用之前，一定要记得先编译下这个库才会有智能提示出来。

欢迎转载分享，如若转载，请标注署名。

博客链接1：https://huchengv5.gitee.io/

博客链接2：https://huchengv5.github.io/

微信公众号：

手动升级csproj踩坑

Wed, 24 Aug 2022 01:12:03 +0000

因为项目原因，还使用着比较原始的.NET Framework框架，但因为某种原因，暂时不让升级到.NET 6。为了能够解锁更多Visual Studio 2022的功能，尝试手动修改csproj文件。

这个过程中，也会遇到不少坑，再次做个记录。

一、类库中包含了 `App.xaml`

错误输出：

C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\amd64\Microsoft.Common.CurrentVersion.targets(2302,5): warning MSB3270: 所生成项目的处理器架构“MSIL”与引用“D:\work\project\xxx\Utils\xxx\\..\..\Debug\xxx.dll”的处理器架构“x86”不匹配。这种不匹配可能会导致运行时失败。请考虑通过配置管理器更改您的项目的目标处理器架构，以使您的项目与引用间的处理器架构保持一致，或者为引用关联一个与您的项目的目标处理器架构相符的处理器架构。 1>C:\Program Files\dotnet\sdk\6.0.301\Sdks\Microsoft.NET.Sdk.WindowsDesktop\targets\Microsoft.WinFX.targets(223,9): error MC1002: 库项目文件无法指定 ApplicationDefinition 元素。 1>C:\Program Files\dotnet\sdk\6.0.301\Sdks\Microsoft.NET.Sdk.WindowsDesktop\targets\Microsoft.WinFX.targets(223,9): error BG1003: 项目文件包含无效的属性值。

解决方法：

删除类库中的 App.xaml，因为`Microsoft.NET.Sdk`中已经包含了对它编译方式的定义。

二、AssemblyAttribute 提示重复

因为 Microsoft.NET.Sdk 中已经包含了对它的定义，我们只需要在csproj中，将自动生成AssemblyInfo文件关闭。

<GenerateAssemblyInfo>false</GenerateAssemblyInfo>

三、生成事件批处理报错

事件编译，新旧不一样，需要修改。把bat批处理复制到IDE里面自动生成即可

旧的csproj形式

  <PropertyGroup>
    <PreBuildEvent>if  "$(PlatformName)" == "x64"  (xcopy /E /Y "$(ProjectDir)libs\x64\*.*" "$(ProjectDir)libs\") else (xcopy /E /Y "$(ProjectDir)libs\x86\*.*" "$(ProjectDir)libs\")</PreBuildEvent>
  </PropertyGroup>

新的csproj方式

	<Target Name="PreBuild" BeforeTargets="PreBuildEvent">
	  <Exec Command="if  &quot;$(PlatformName)&quot; == &quot;x64&quot;  (xcopy /E /Y &quot;$(ProjectDir)libs\x64\*.*&quot; &quot;$(ProjectDir)libs\&quot;) else (xcopy /E /Y &quot;$(ProjectDir)libs\x86\*.*&quot; &quot;$(ProjectDir)libs\&quot;)" />
	</Target>

主意看两端批处理的表示方式，可以很明显的看出来，相关的配置已经完全不一样了。

四、命令行无法构建x64的原因

错误提示

...省略... project.assets.json 没有 net452/win7-x64 的目标 ...省略... 可能需要在项目 RuntimeIdentifiers 中包括 “win7-x64”.

这个错误的主要原因是因为nuget包还原的时候，默认是按 win7-x86 来还原的。我们可以在project.assets.json文件里面找到这个配置项。要解决这个问题，我们就需要在还原nuget包的时候，告诉编译器我们是按win7-x64来做编译。

具体如下：

dotnet restore -r win7-x64

五、.NET Framework v4.5.2 基于netstandar无法编译通过

netstandar 不支持.net framework v4.5.2，升级到.net framework v4.6.1 以上即可。

六、动态库的引用差异

.NET6中不需要额外引用System.Web.dll，直接Using System.Web的命名空间即可
System.Windows.Form.MenuItem 使用 ToolStripMenuItem 代替
System.Windows.Interactivity.dll使用System.Windows.Interactivity.WPF nuget包代替
System.Drawing.dll 使用 System.Drawing.Common nuget包代替
NotifyIcon.ContextMenu 使用 NotifyIcon.ContextMenuStrip 代替
ContextMenu 使用 ContextMenuStrip 代替

关于手动升级到新版的csproj文件格式，网上有较多教程，我这边就不列出来了。主要有两种方式：

通过工具升级
手动修改csproj文件

本博客会持续更新~

博客链接1

博客链接2

手动构建nuget包

Fri, 19 Aug 2022 01:12:03 +0000

在.net core 的版本上，visual studio 已经提供了自动打包的功能。当然，在.NET Framework的版本上也是可以的，不过需要收到修改proj文件才行，这里先不做讨论。

在Visual Studio不具备一键打包的功能时，我们可以使用第三方软件来实现nuget包的打包。

在Microsoft Store商城，搜索安装nuget package explorer。

创建一个新的包，Create a new package

通过右键菜单增加对应的目录和文件。

目录参考以下方式：


├─lib
│  ├─net462
│  └─netstandard1.3
└─runtimes
    ├─win-arm64
    │  └─native
    ├─win-x64
    │  └─native
    └─win-x86
        └─native

左侧是可视化的包信息配置，按需求填写即可，依赖性也可以在这里添加。

添加好后，保存就可以了。

常用git命令汇总

Fri, 19 Aug 2022 01:10:03 +0000

记录下，纯备忘！

常用参数解释

 -a , --all 所有    
 -d , --delete 删除  
 -D , --delete --force 强制删除  
 -m , --move 移动或者重命名
 -M ， --move --force 强制移动或重命名  
 -r , --remote 远程

创建仓库

git clone https://xxxx.git

指定名称和邮箱

git config --global user.name "name"

git config --global user.email 'xxx@xxx.com'

签出

git checkout branchname //签出分支

git checkout -b <branchname> //新建分支并签出

拉取

git pull

查看状态

git status

添加到提交

git add xxx

git add . $\color{#608B4E}{//添加所有修改文件}$

提交

git commit -m xxxx

推送

git push

强推

git push --force

git branch //查看本地分支

git branch -r //查看远程所有分支 git branch -a //查看本地和远程所有分支 git branch //新建分支 git branch -d //删除本地分支 -D 强制删除 git branch -d -r //删除远端分支 git branch -m //重命名本地分支

删除本地已合并的分支

git branch --merged | xargs git branch -d

先执行远程获取

git fetch -p （-p 表示 prune，删除远程分支已经删除的本地分支） grep -v 用于排除关键字，检查此命令输出的branch名字是否合理，调整次命令直至筛选出需要删掉的branch

"git branch --remote"

每行输出以“origin/”开头，命令”cut -b 10-“用于删除此前缀

git branch --remote --merged origin/master | grep -v 'master' | cut -b 10- | xargs

执行远程删除，务必确保要删除的分支是可以删除的

git branch --remote --merged origin/master | grep -v 'master' | cut -b 10- | xargs git push --delete origin

如何正确获取系统版本号

Wed, 06 Jul 2022 01:10:03 +0000

细心的同学会发现，我们通过内置函数Environment.OSVersion获取到的系统版本号会存在不同的系统版本，版本号是一样的情况。代替的方案可以通过windows api 来获取内置版本号。

实现方法比较简单，就不做描述，以下是完整可用的代码。

    public class Win32
    {
        [DllImport("ntdll.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr RtlGetNtVersionNumbers(ref int dwMajor, ref int dwMinor, ref int dwBuildNumber);
    }

    public class EnvironmentEx
    {
        /// <summary>
        /// 获取系统版本号
        /// </summary>
        public static string OSVersion
        {
            get
            {
                try
                {
                    int dwMajor = 0, dwMinor = 0, dwBuildNumber = 0, buildNum = 0;

                    Win32.RtlGetNtVersionNumbers(ref dwMajor, ref dwMinor, ref dwBuildNumber);

                    if (dwBuildNumber != 0)
                    {
                        var bytes = ByteConvert.IntToBytes(dwBuildNumber);

                        buildNum = ByteConvert.BytesToInt(new byte[] { bytes[0], bytes[1], 0, 0 }, 0);
                    }

                    return $"{dwMajor}.{dwMinor}.{buildNum}";
                }
                catch (Exception)
                {
                    return Environment.OSVersion.ToString();
                }
            }
        }
    }

    public class ByteConvert
    {
        public static int BytesToInt(byte[] src, int offset)
        {
            if (src == null) return 0;
            int value;
            value = (src[offset] & 0xFF)
                    | ((src[offset + 1] & 0xFF) << 8)
                    | ((src[offset + 2] & 0xFF) << 16)
                    | ((src[offset + 3] & 0xFF) << 24);
            return value;
        }

        public static byte[] IntToBytes(int value)
        {
            byte[] src = new byte[4];
            src[3] = (byte)((value >> 24) & 0xFF);
            src[2] = (byte)((value >> 16) & 0xFF);
            src[1] = (byte)((value >> 8) & 0xFF);//高8位
            src[0] = (byte)(value & 0xFF);//低位
            return src;
        }
    }

FrameworkElement.DataContext莫名被重置为null

Wed, 29 Jun 2022 01:10:03 +0000

当我们在开发自定义的组件的时候，有没有遇到过这种场景，我们明明没有给FrameworkElement.DataContext属性赋null值，为什么他变成null了？

出现这种问题，可能有以下几种场景：

调试的对象不是同一个对象
异步代码出现不按常规顺序赋值
数据绑定，更改了其数值
数据模版或者样式应用，导致数据被重置

前面几种很好理解，调试的过程中也比较容易发现。这次就简单的来说下第四种场景。

先来看个堆栈：

从堆栈信息里面，我们可以发现，MeasureCore里面调用了ApplyTemplate的代码。

这个是ContentPresenter的部分源代码：

        private void EnsureTemplate()
        {
            DataTemplate oldTemplate = Template;
            DataTemplate newTemplate = null;

            for (_templateIsCurrent = false; !_templateIsCurrent; )
            {                
                _templateIsCurrent = true;
                newTemplate = ChooseTemplate();
                
                if (oldTemplate != newTemplate)
                {
                    Template = null;
                }

                if (newTemplate != UIElementContentTemplate)
                {                    
                    this.DataContext = Content;
                }
                else
                {
                    this.ClearValue(DataContextProperty);
                }
            }

            Template = newTemplate;
            if (oldTemplate == newTemplate)
            {
                StyleHelper.DoTemplateInvalidations(this, oldTemplate);
            }
        }

在首次应用模版的时候，DataContext会被重新赋值。所以就会出现不符合预期的现象。

解决这个问题的办法也很简单，就是在FrameworkElement.ApplyTemplate后，再给DataContext赋值就可以了。

git用ssh的方式进行连接

Tue, 14 Jun 2022 01:10:03 +0000

git做代码管理用Http的方式有诸多限制，用SSH的方式就比较省事。

git如何开启SSH？

方法很简单，关键的命令：ssh-keygen -t rsa -C “配置自己邮箱”

通过git brash ，打开 git 命令行工具，输入以上命令，一路回车。工具会在当前用户下创建三个ssh的授权文件，分别是：id_rsa，id_rsa.pub，known_hosts。
pub结尾是公钥，我们用记事本打开，并复制里面的内容。
在gitlab中，我的头像那儿点开，找到Settings，再找到SSH Keys选项卡，将刚才生成的公钥粘贴进去。
接下来就可以直接用ssh的方式进行拉取推送了

内容比较简单，纯粹做个备忘！

PropertyPath的表示形式

Fri, 10 Jun 2022 01:10:03 +0000

WPF的PropertyPath设计虽然灵活，但是不得不说，真的很不好用！今天就纯粹做下备忘~

PropertyPath一般我们在写动画或者绑定的时候会用的比较多，因为它可以接受一个字符串的参数，所以我们可以给它指定任意的字符串。

也正因为如此，所以它的输入合不合法，我们就不好去做检查了！

再此，例举几种常用的方法示例:

(UIElement.RenderTransform).(TransformGroup.Children)[0].(TranslateTransform.X)
(UIElement.RenderTransform).(TranslateTransform.X)

认识asyncawait，如何自己动手编写可等待的任务？

Mon, 27 Dec 2021 11:10:03 +0000

C#里面的async/await语法简直好用的不要不要的。但是，如果我想让这种异步状态机，能工作在我自定义的线程里面要怎么办呢？

要让编译器识别async await 语法首先需要具备以下条件：
1、可等待的对象，需要实现T GetAwaiter();方法。注意：T可以是任何类型，不一定是object类型。

可等待对象无返回值需要满足的条件： 1）、继承接口INotifyCompletion或实现void OnCompleted(Action continuation);方法。
2）、实现bool IsCompleted { get; }属性。 3）、实现void GetResult();方法。

可等待对象带返回值需要满足的条件： 1）、继承接口INotifyCompletion或实现void OnCompleted(Action continuation);方法。
2）、实现bool IsCompleted { get; }属性。 3）、实现T GetResult();方法。T可以是任意类型。

具备上述条件，你的代码就可以顺利编译通过了。但是此时的代码，还不能工作，因为你还没有给状态机增加状态！

为了增加这个状态，我们增加一个方法void ReportCompleted(T result);，用来更改状态机的状态值，表示我们要执行的异步操作是否已完成。

具体代码，如下所示：

相关的接口定义:

    /// <summary>
    /// 带返回值的可等待对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IAwaitable<T> : INotifyCompletion
    {
        bool IsCompleted { get; }
        T Result { get; }
        T GetResult();
        void ReportCompleted(T result);
    }

    /// <summary>
    /// 不带返回值的可等待对象
    /// </summary>
    public interface IAwaitable : INotifyCompletion
    {
        bool IsCompleted { get; }
        void GetResult();
        void ReportCompleted();
    }

    /// <summary>
    /// 获取可等待者
    /// </summary>
    public interface IAwaiter
    {
        IAwaitable GetAwaiter();
    }

    /// <summary>
    /// 获取可等待者
    /// </summary>
    public interface IAwaiter<T>
    {
        IAwaitable<T> GetAwaiter();
    }

    /// <summary>
    /// 不带返回值的可等待的任务
    /// </summary>
    public class AwaitableTask : IAwaiter
    {
        public AwaitableTask()
        {
            AwaitableObject = new AwaitableObject();
        }

        /// <summary>
        /// 获取可等待的对象
        /// </summary>
        public IAwaitable GetAwaiter()
        {
            return AwaitableObject;
        }

        /// <summary>
        /// 实现相关接口的可等待的对象
        /// </summary>
        public AwaitableObject AwaitableObject { get; private set; }
    }

    /// <summary>
    /// 带返回值的可等待的任务
    /// </summary>
    public class AwaitableTask<T> : IAwaiter<T>
    {
        public AwaitableTask()
        {
            AwaitableObject = new AwaitableObject<T>();
        }

        public IAwaitable<T> GetAwaiter()
        {
            return AwaitableObject;
        }

        public AwaitableObject<T> AwaitableObject { get; private set; }
    }

    /// <summary>
    /// 不带返回值的可等待的状态对象
    /// </summary>
    public class AwaitableObject : Awaitable, IAwaitable
    {
        public void GetResult()
        {

        }
    }

    /// <summary>
    /// 带返回值的可等待的状态对象
    /// </summary>
    public class AwaitableObject<T> : Awaitable, IAwaitable<T>
    {
        public T Result { get; private set; }

        public T GetResult()
        {
            return Result;
        }

        public void ReportCompleted(T result)
        {
            Result = result;
            ReportCompleted();
        }
    }

    /// <summary>
    /// 可等待的抽象类，状态机的具体实现
    /// </summary>
    public abstract class Awaitable
    {
        private Action _continuation;

        private readonly object _locker = new object();

        public bool IsCompleted { get; private set; }

        public void OnCompleted(Action continuation)
        {
            //因为此处调用和ReportCompleted，可能不在一个线程上，会出现时机问题
            lock (_locker)
            {
                if (IsCompleted)
                {
                    continuation?.Invoke();
                }
                else
                {
                    _continuation += continuation;
                }
            }
        }

        //用于通知，当前任务已经完成。
        public void ReportCompleted()
        {
            lock (_locker)
            {
                IsCompleted = true;
                var continuation = _continuation;
                _continuation = null;
                continuation?.Invoke();
            }
        }

        //重置状态，让状态机恢复可等待
        public void Reset()
        {
            lock (_locker)
            {
                _continuation?.Invoke();
                IsCompleted = false;
                _continuation = null;
            }
        }
    }

示例：

    public class TestElement : UIElement
    {
        //实例化一个可等待任务
        AwaitableTask _awaitableTask = new AwaitableTask();

        /// <summary>
        /// 指定的资源的路径
        /// </summary>
        public string SourceUri
        {
            get { return (string)GetValue(SourceUriProperty); }
            set { SetValue(SourceUriProperty, value); }
        }

        private ImageSource gifSource;

        public static readonly DependencyProperty SourceUriProperty = DependencyProperty.Register(nameof(SourceUri), typeof(string), typeof(TestElement), new PropertyMetadata(string.Empty, async (s, e) =>
        {
            var loc = s as TestElement;
            loc.gifSource = await LoadGifSourceAsync(e.NewValue as string);
            loc._awaitableTask.AwaitableObject?.ReportCompleted();
        }));

        public static async Task<ImageSource> LoadGifSourceAsync(string url)
        {
            await Task.Delay(500);
            return new BitmapImage(new Uri(url));
        }

        /// <summary>
        /// 等待源数据加载完成，对外开放的方法
        /// </summary>
        /// <returns></returns>
        public async Task WaitForLoaded()
        {
            await _awaitableTask;
        }

        public bool Do()
        {
            if (gifSource != null)
                return true;            
            return false;
        }
    }

    public class TestClass
    {
        public TestClass()
        {
            TestForNotWait();
            TestForWait();
        }


        public async void TestForWait()
        {
            TestElement testElement = new TestElement
            {
                SourceUri = @"D:\Users\huc\Pictures\Saved Pictures\1.jpeg"
            };
            await testElement.WaitForLoaded();
            Console.WriteLine("TestForWait Result:" + testElement.Do());
        }

        public void TestForNotWait()
        {
            TestElement testElement = new TestElement
            {
                SourceUri = @"D:\Users\huc\Pictures\Saved Pictures\1.jpeg"
            };

            Console.WriteLine("TestForNotWait Result:" + testElement.Do());            
        }
    }
        

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

如何开启大内存？

Mon, 27 Dec 2021 01:10:03 +0000

正常情况下，一个x86的应用，最多能使用多少内存呢？

解答

x86应用程序在不同场景下，分别可支持2GB、3GB、4GB的虚拟内存寻址。默认寻址空间为：2GB。如果开启了大内存，在x64的操作系统上，最高可支持到4GB虚拟内存。在x86操作系统上，可支持3GB虚拟内存，此时系统占用1GB。

开启4G内存方法

开启4GB虚拟内存的方法（仅支持Framework4.5以上，C#适用）：
1）、使用 AnyCpu ，首选 32bit。
2）、使用Visual Studio 命令行工具。命令：editbin.exe /largeaddressaware temp\Release\test.exe 。
3)、检查方法：
a)、使用批处理 dumpbin.exe /headers temp\Release\test.exe。
b)、使用C#代码

    public Characteristics CheckPE(String path)
	        {           
        	    var file = new FileInfo(path);
            	var peHeaders = new PEHeaders(file.OpenRead());
            	return peHeaders.CoffHeader.Characteristics;  //包含 largeaddressaware，表示成功了。
	        }

优点：针对x64操作系统，完美的解决了内存不足的问题，将可内存做了翻倍处理。
缺点：针对x86操作系统无效；需要Framework4.5以上版本。

C++的解决方案，请参考下图开启：

开启3GB虚拟内存方法：

命令行工具：bcdedit /set IncreaseUserVa 3072 //(3072=1024 *3=3GB)
检查是否成功：bcdedit
关闭3GB：bcdedit /deletevalue IncreaseUserVA

优点：解决应用程序内存不足问题。
缺点：操作系统可用内存降低，降低系统稳定性。
结论：非极端情况下，并不推荐开启3GB内存，对系统稳定性会有一定的影响。不适合强制给用户开启，仅适用于个人使用。

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

【WPF】如何进行全局异常处理？

Thu, 16 Dec 2021 02:10:03 +0000

.NET处理异常比较简单，一般有三种方式全局处理异常。

    AppDomain.CurrentDomain.UnhandledException += ExceptionProxy.CurrentDomainOnUnhandledException;
    Current.DispatcherUnhandledException += ExceptionProxy.DispatcherOnUnhandledException;
    TaskScheduler.UnobservedTaskException += ExceptionProxy.TaskSchedulerOnUnobservedTaskException;

DispatcherOnUnhandledException的异常处理比较简单，只需要设置dispatcherUnhandledExceptionEventArgs.Handled = true;即可。

CurrentDomainOnUnhandledException的异常相对就麻烦一些，需要在配置文件中进行配置。

在启动进程的 app.config 配置文件中，添加以下配置项即可。

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
  </startup>
  <runtime>
    <!--禁用执行FIPS政策,防止MD5加密算法抛异常-->
    <!--<enforceFIPSPolicy enabled="false" />-->
    
    <!--忽略未处理的异常，此时运行时不会退出-->
    <legacyUnhandledExceptionPolicy enabled="1" />
  </runtime>
</configuration>

加了上述配置后,unhandledExceptionEventArgs.IsTerminating就会变成false了。

DispatcherOnUnhandledException 是表示UI相关的异常。CurrentDomainOnUnhandledException通常表示非UI的异常。UnobservedTaskException一般不用处理，Task会把异常吞掉。

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

【WPF】如何手动释放图片资源？

Thu, 16 Dec 2021 01:10:03 +0000

图片是一种比较占内存的资源，尤其是高分辨率的图片。当我们的图片控件隐藏了，不需要显示的时候，这个时候图片还逗留在内存中，就太浪费资源了。

如果我们用默认的图片控件Image，隐藏的时候可以给图片的Source置空，显示的时候再给Source重新赋值。

如果不改变Source，我们用自定义的图片组件来实现的话呢！

基本思路:在图片隐藏的时候，执行空绘制，以释放对图片源（BitmapImage）的引用。

            //……省略
            //重写事件
            VisibilityProperty.OverrideMetadata(typeof(ImageControl), new FrameworkPropertyMetadata((s, e) =>
            {
                //do something
            }, (sender, value) =>
            {
                var visibility=(Visibility)value;
                switch (visibility)
                {
                    //如果图片隐藏了，释放图片资源
                    case Visibility.Hidden:
                    case Visibility.Collapsed:
                        imageControl.IsDisposing = true;
                        //使绘制区域无效
                        imageControl.Measure(new Size(0, 0));
                        imageControl.Arrange(new Rect(0, 0, 0, 0));
                        break;
                    case Visibility.Visible:
                        imageControl.IsDisposing = false;
                        //重绘
                        imageControl.InvalidateVisual();
                        break;
                }
                return visibility;
            }));

            //……省略

        //渲染的时候，不执行操作
        protected override void OnRender(DrawingContext drawingContext)
        {
            if (IsDisposing) return;
            //省略
        }

上述逻辑，也可以在Loaded Unloaded事件中执行。

通过上述方法，就可以实现图片资源的引用释放，垃圾回收器可正常回收该图片资源，这样就可以不用一直占用着内存了。

注意：使用BitmapImage的时候，如果是通过Stream的方式指定，需要把BitmapImage.CacheOption设置为BitmapCacheOption.OnLoad，并释放流，否则就会出现内存泄漏。

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

【WPF】DependencyProperty 回调用途

Wed, 15 Dec 2021 01:10:03 +0000

当我们在定义一个依赖属性的时候，通常是需要重写属性元数据，以便做我们想做的工作。

声明一个依赖属性的示例：

    public static readonly DependencyProperty MyProperty = DependencyProperty.Register(nameof(My), typeof(string), typeof(MyControl), new PropertyMetadata(null,     
    PropertyChangedCallback, OnCoerceValueCallback)，ValidateValueCallback);

PropertyChangedCallback 表示属性变更后的回调，通常用于属性值被改变后，执行对应的业务逻辑。 CoerceValueCallback 表示属性变更前的回调，通常用来做数据类型转换。（当然也可以做些其它的事情） ValidateValueCallback 表示数据验证回调，通常用来验证数据的有效性。

调用顺序：ValidateValueCallback -> OnCoerceValueCallback -> PropertyChangedCallback。

针对 CoerceValueCallback 举个例子：

我们通常在xaml代码中，会给Image.Source赋个值，并且是纯字符串。但是，我们的Image控件都能很好的把字符串转成我们要到对象ImageSource。转换的过程，总不可能把这个工作交给xaml解析器吧，那不然这个解析器，还不得炸锅了~

所以呢，依赖属性元数据里面，使用 CoerceValueCallback，可以帮助我们在数据改变之前，做一些想做的操作，通常可以用它来做一些数据类型转换。

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

【WPF】如何绑定到数组数据源上指定索引的项上

Wed, 29 Sep 2021 01:10:03 +0000

WPF的绑定机制提供了非常便利的数据更新途径，在实际业务中，我们可以会遇到我们的UI组件，需要绑定到数据源上的某个数组中的指定的索引项。这种场景相对来讲是比较少用……

实际上，使用起来还是非常简单的，只需要再我们绑定的数据属性上，增加索引编号即可。

前端示例代码：

   <Window x:Class="WpfApp3.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:WpfApp3"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <!--此处代码是关键-->
        <TextBlock Text="{Binding [0].Name}"/>
    </Grid>
</Window>

后端测试代码：

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

        public MainWindow()
        {
            InitializeComponent();

            TestProperty[] testProperties = new TestProperty[2];

            testProperties[0] = new TestProperty
            {
                Name = "我是第一个，哈哈！"
            };

            testProperties[1] = new TestProperty
            {
                Name = "我是第二个"
            };

            this.DataContext = testProperties;
        }

启动后效果如图所示：

绑定已经成功工作了，这里需要注意，如果索引不存在，该绑定也不会出现异常，只是保持默认值显示，此时的绑定也是同样生效的。

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

【WPF】log4net通过代码实现自定义配置

Mon, 27 Sep 2021 01:10:03 +0000

大家在使用log4net的时候，常规的用法都是在配置文件里面进行设置。但是配置文件里面的配置项非常多，不利于记忆，所以说我们希望他能直接在代码中设置。

于是，我写了个自定义日志配置的方法，核心的配置对象为RollingFileAppender,只需要对他进行设置就可以了。

下面给大家展示下，基于使用场景下的日志服务示例。

    public class LogService
    {
        private static readonly ConcurrentDictionary<string, ILog> _loggerContainer = new ConcurrentDictionary<string, ILog>();

        public const string Logger_Key_Default = "default";
        public const string Logger_Key_Crash = "crash";

        static LogService()
        {
            //初始化默认的日志服务
            GetOrAddLogger(Logger_Key_Default, new LoggerConfiguration().SetDefaultValue(Logger_Key_Default));
            GetOrAddLogger(Logger_Key_Crash, new LoggerConfiguration().SetDefaultValue(Logger_Key_Crash));
        }

        /// <summary>
        /// 日志统一处理事件
        /// </summary>
        /// <param name="action"></param>
        protected static void DoLog(Action action)
        {
            SingleThreadPool.Default.Post(() =>
            {
                action();
            });
        }

        private static ILog GetOrAddLogger(string key, LoggerConfiguration loggerConfiguration)
        {
            return _loggerContainer.GetOrAdd(key, new Func<string, ILog>((pKey) =>
            {
                var loggerName = loggerConfiguration.GetFileNameFunc();
                Hierarchy repository = (Hierarchy)LogManager.GetRepository();
                Logger logger = repository.LoggerFactory.CreateLogger(repository, loggerName);
                logger.Hierarchy = repository;
                logger.Parent = repository.Root;
                logger.Level = loggerConfiguration.LogLevel;
                logger.Additivity = false;
                logger.AddAppender(GetFileAppender(loggerConfiguration));
                logger.Repository.Configured = true;
                return new LogImpl(logger);
            }));
        }

        private static ILog GetLoggerFromKey(string key)
        {
            if (_loggerContainer.ContainsKey(key))
            {
                return _loggerContainer[key];
            }
            return default(ILog);
        }

        private static RollingFileAppender GetFileAppender(LoggerConfiguration logConfiguration)
        {
            var appender = new RollingFileAppender
            {
                LockingModel = new FileAppender.MinimalLock(),
                Name = "RollingFileAppender",
                File = logConfiguration.SavePath,
                AppendToFile = true,
                MaxSizeRollBackups = logConfiguration.MaxSizeRollBackUps,
                MaximumFileSize = logConfiguration.MaximumFileSize,
                StaticLogFileName = true,
                RollingStyle = RollingFileAppender.RollingMode.Size,
                DatePattern = logConfiguration.DatePattern
            };
            PatternLayout layout = new PatternLayout(logConfiguration.LayoutPattern);
            appender.Layout = layout;
            layout.ActivateOptions();
            appender.ActivateOptions();
            return appender;
        }

        #region 公开事件

        public static void Warn(object msg, Exception ex = null)
        {
            DoLog(() =>
            {
                GetLoggerFromKey(Logger_Key_Default)?.Warn(msg, ex);
            });
        }

        public static void Info(object msg, Exception ex = null)
        {
            DoLog(() =>
            {
                GetLoggerFromKey(Logger_Key_Default)?.Info(msg, ex);
            });
        }

        public static void Debug(object msg, Exception ex = null)
        {
            DoLog(() =>
            {
                GetLoggerFromKey(Logger_Key_Default)?.Debug(msg, ex);
            });
        }

        public static void Error(object msg, Exception ex = null)
        {
            DoLog(() =>
            {
                GetLoggerFromKey(Logger_Key_Default)?.Error(msg, ex);
            });
        }

        public static void Crash(object msg, Exception ex = null)
        {
            DoLog(() =>
            {
                GetLoggerFromKey(Logger_Key_Crash)?.Error(msg, ex);
            });
        }

        #endregion
    }

    public class LoggerConfiguration
    {
        public LoggerConfiguration SetDefaultValue(string key)
        {
            LayoutPattern = "%date% %message%newline";
            DatePattern = "yyyyMMdd";
            MaxSizeRollBackUps = 20;
            MaximumFileSize = "50MB";
            LogLevel = Level.All;
            GetFileNameFunc = new Func<string>(() =>
             {
                 return $"{key}_{Process.GetCurrentProcess().ProcessName}_{Process.GetCurrentProcess().Id}_{DateTime.Now.ToString("yyyyMMdd")}.log";
             });
            SavePath = $"{CoreValue.Instance.MizPCTempFilePath}/log/{GetFileNameFunc()}";
            return this;
        }

        public string LayoutPattern { get; set; }

        public string DatePattern { get; set; }

        public int MaxSizeRollBackUps { get; set; }

        public string MaximumFileSize { get; set; }

        public Level LogLevel { get; set; }

        public string SavePath { get; set; }

        public Func<string> GetFileNameFunc { get; set; }
    }

欢迎转载分享，请关注微信公众号，将同步更新博客，方便查看！

【WPF】剪切板设置文本抛 0x800401D0 异常

Fri, 17 Sep 2021 12:10:03 +0000

在WPF中，剪切板是一个静态类，设置剪切板很简单。如：将文本添加到剪切板，只需要调用下Clipboard.SetText(Text);就行了。

但是当你在复制的时候，你会发现，它抛出异常了，System.Runtime.InteropServices.COMException:"OpenClipboard失败（异常来自HRESULT:0x800401D0）(CLIPBRD_E_CANT_OPEN))"。好了，看到这里一脸懵逼，winform都不会啊,这么简单的一句代码。

经过了解发现，原来这个异常是因为设置剪切板的操作还没有执行完，又收到新的设置到剪切板事件操作，于是它就挂给你看了。

简单粗暴的解决方法：

        public void CopyToClipboard(string txt)
        {
            try
            {                
                Clipboard.SetText(txt);
                Task.Delay(100).Wait();
            }
            catch (Exception ex)
            {
                L.error(ex.Message);
            }
        }

复制的时候，让他稍微等一等，可以大幅降低崩溃的概率。

ScrollView实现翻页的基础操作事件

Tue, 14 Sep 2021 01:10:03 +0000

逻辑分页是非常常用的一种性能优化的技术手段。虽然像ListView,ListBox有提供虚拟化的技术，能让我们加载大量数据而不会出现卡顿。但是……

实际上，虚拟化技术即便是开启后，我们在快速浏览和滚动或者是初始化加载数据的时候，会出现明显的卡顿，这并不符合我们的实际业务需要。因此，实现逻辑分页是非常有必要的。

实现逻辑分页也比较简单，主要是通过ScrollView来实现滚动加载，通常用于垂直滚动，分别可以像上滚动和像下滚动，水平滚动我们就不去考虑了。

常规的分页逻辑判断代码如下：

        //向上滚动
        if (e.VerticalOffset < 10 && e.VerticalChange < 0)
        {
            //do something
        }

        //向下滚动
        if ((e.ExtentHeight - (e.VerticalOffset + e.ViewportHeight)) < 10)
        {
            //do something
        }

        //滚动条是否可见，可用于针对数据模版不确定的场景，动态需要计算初始分页的条数。
        bool IsScrollBarVisible
        {
            get
            {
                return scrollViewer != null && scrollViewer.ExtentHeight > scrollViewer.ViewportHeight;
            }
        }

为了方便实现分页逻辑，我写了一个基于ItemsControl和ScrollViewer的基类，方便实现我们的分页逻辑：

/// <summary>
    /// 提供逻辑分页的基础实现
    /// 目标对象：ItemsControl
    /// </summary>
    public abstract class LogicPagingOperator : IDisposable
    {
        public LogicPagingOperator(ItemsControl itemsControl, int pageCapacity = 10)
        {
            ItemsSource = new ObservableCollection<object>();
            Initialize(itemsControl, pageCapacity);
        }

        protected int _pageCapacity;
        protected ScrollViewer ScrollViewer;
        protected ItemsControl ItemsControl;
        public IList OriginalSource { get; private set; }
        protected readonly ObservableCollection<object> ItemsSource;

        /// <summary>
        /// 当前页
        /// </summary>
        protected int PageIndex
        {
            get; set;
        }

        /// <summary>
        /// 逻辑源数据是否已经全部加载完成
        /// </summary>
        public bool IsLoaded
        {
            get; protected set;
        }

        private void Initialize(ItemsControl itemsControl, int pageCapacity)
        {
            ItemsControl = itemsControl;
            if (pageCapacity < 1)
            {
                ExceptionHelper.ThrowForDebug(new ArgumentException("无效的LogicPagingOperatorBase.PageCapacity值，值不能小于1"));
                pageCapacity = 1;
            }
            PageCapacity = pageCapacity;
            PageIndex = -1;
            ItemsControl.Loaded += ItemsControl_Loaded;
            ItemsControl.Unloaded += ItemsControl_Unloaded;
        }

        private void InnerReset()
        {
            ItemsSource.Clear();
            PageIndex = -1;
            IsLoaded = false;
        }

        public void SetItemsSource(IEnumerable value)
        {
            if (value == null)
            {
                OriginalSource = null;
                InnerReset();
                return;
            }

            if (value is IList list)
            {
                UnregistryNotifyCollectionChanged();

                InnerReset();

                OriginalSource = list;

                LoadNext();

                RegistryNotifyCollectionChanged();

                ItemsControl.ItemsSource = ItemsSource;
            }
            else
            {
                throw new NotSupportedException("只支持IList集合");
            }

        }

        /// <summary>
        /// 每逻辑页显示的数量
        /// </summary>
        public int PageCapacity
        {
            get
            {
                return _pageCapacity;
            }
            set
            {
                _pageCapacity = value;

                InnerReset();

                if (ItemsControl != null && ItemsControl.IsLoaded)
                {
                    LoadNext();
                }
            }
        }

        #region 数据加载

        /// <summary>
        /// 加载下一页
        /// </summary>
        public void LoadNext()
        {
            if (OriginalSource == null)
            {
                return;
            }

            if (IsLoaded)
            {
                return;
            }

            PageIndex++;
            OnLoadNext(OriginalSource);
        }

        protected virtual void OnLoadNext(IList list)
        {

        }

        #endregion

        #region 数据源变更处理

        void UnregistryNotifyCollectionChanged()
        {
            if (OriginalSource is INotifyCollectionChanged notifyCollectionChanged)
            {
                notifyCollectionChanged.CollectionChanged -= NotifyCollectionChanged_CollectionChanged;
            }
        }

        void RegistryNotifyCollectionChanged()
        {
            if (OriginalSource is INotifyCollectionChanged notifyCollectionChanged)
            {
                notifyCollectionChanged.CollectionChanged -= NotifyCollectionChanged_CollectionChanged;
                notifyCollectionChanged.CollectionChanged += NotifyCollectionChanged_CollectionChanged;
            }
        }

        void NotifyCollectionChanged_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    OnSourceAdd(e);
                    break;
                case NotifyCollectionChangedAction.Remove:
                    OnSourceRemove(e);
                    break;
                case NotifyCollectionChangedAction.Replace:
                    OnSourceReplace(e);
                    break;
                case NotifyCollectionChangedAction.Move:
                    OnSourceMove(e);
                    break;
                case NotifyCollectionChangedAction.Reset:
                    OnSourceClear(e);
                    break;
                default:
                    break;
            }
        }

        protected virtual void OnSourceAdd(NotifyCollectionChangedEventArgs e)
        {
            if (e.NewStartingIndex < ItemsSource.Count && e.NewStartingIndex > -1)
            {
                ItemsSource.Insert(e.NewStartingIndex, e.NewItems[0]);
            }
            else
            {
                foreach (var item in e.NewItems)
                {
                    ItemsSource.Add(item);
                }
            }
        }

        protected virtual void OnSourceRemove(NotifyCollectionChangedEventArgs e)
        {
            if (e.OldStartingIndex >= 0 && e.OldStartingIndex < ItemsSource.Count)
                ItemsSource.RemoveAt(e.OldStartingIndex);
        }

        protected virtual void OnSourceMove(NotifyCollectionChangedEventArgs e)
        {
            OnSourceRemove(e);
            OnSourceAdd(e);
        }

        protected virtual void OnSourceReplace(NotifyCollectionChangedEventArgs e)
        {
            if (e.NewStartingIndex < ItemsSource.Count && e.NewStartingIndex >= 0 && e.NewItems != null)
            {
                ItemsSource[e.NewStartingIndex] = e.NewItems[0];
            }
        }

        protected virtual void OnSourceClear(NotifyCollectionChangedEventArgs e)
        {
            ItemsSource.Clear();
            PageIndex = -1;
        }

        #endregion

        #region 滚动条逻辑处理

        void FindScrollView(ItemsControl itemsControl)
        {
            if (itemsControl != null && ScrollViewer == null)
            {
                ScrollViewer = itemsControl.VisualAncestor<ScrollViewer>();
                if (ScrollViewer == null)
                {
                    ScrollViewer = itemsControl.VisualDescendant<ScrollViewer>();
                }
            }
        }

        void RegistryScrollChanged(ScrollViewer scrollViewer)
        {
            if (scrollViewer != null)
            {
                scrollViewer.ScrollChanged -= ScrollViewer_ScrollChanged;
                scrollViewer.ScrollChanged += ScrollViewer_ScrollChanged;
            }
        }

        void UnregistryScrollChanged()
        {
            if (ScrollViewer != null)
            {
                ScrollViewer.ScrollChanged -= ScrollViewer_ScrollChanged;
            }
        }

        void ScrollViewer_ScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            OnScrollChanged(e);
        }

        protected virtual void OnScrollChanged(ScrollChangedEventArgs e)
        {

        }

        #endregion

        #region 事件处理

        private void ItemsControl_Unloaded(object sender, System.Windows.RoutedEventArgs e)
        {
            UnregistryNotifyCollectionChanged();
            UnregistryScrollChanged();
            OnUnloaded();
        }

        private void ItemsControl_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            FindScrollView(ItemsControl);
            RegistryNotifyCollectionChanged();
            RegistryScrollChanged(ScrollViewer);
            OnLoaded();
        }

        protected virtual void OnLoaded()
        {

        }

        protected virtual void OnUnloaded()
        {

        }

        #endregion

        public void Dispose()
        {
            ItemsSource.Clear();
            ItemsControl = null;
        }
    }

觉得文章好，请点个赞，给点动力^_^

如何在Canvas上实现元素按中心点坐标作为相对坐标

Fri, 10 Sep 2021 03:10:03 +0000

这个问题，相信大部分同学都知道，实现这个效果，只需要对Canvas上的子元素进行坐标换算。

先看下常规的做法，可能是：

//frameworkElement
Canvas.SetLeft(frameworkElement,left - frameworkElement.ActualWidth/2);
Canvas.SetTop(frameworkElement,top - frameworkElement.ActualHeight/2);

但是这种方法，虽然可以实现，但是它不太好放到xaml上去实现，也没有那么方便。

当然微软也会遇到这样的一个问题，所以他们偷偷的实现了一种方法来实现这种逻辑，但是：就不告诉你。

没关系，微软不告诉你，我告诉你。请看具体实现：

前台xaml演示代码

    <Canvas>
        <Rectangle Height="100" Width="150" Fill="Red" Margin="-100000"/>
    </Canvas>

显示效果：

聪明的小伙伴可以发现，其实实现这个功能非常简单，只需要在Margin上设置一下属性值为-100000即可。

是不是很黑科技呢？

WPF程序出现花屏，怎么办

Tue, 20 Jul 2021 03:10:03 +0000

同样的，Win10操作系统更新后，软件花屏了！

WPF为啥还能出现花屏呢？

花屏是个什么现象？即：WPF的界面不能正确渲染或及时刷新，导致整个界面会出现严重的残影，严重影响使用。

如果存在花屏，可出现步骤：

快速拖动窗口
窗口自动收起和展开
更改窗口大小
其他各种操作……

出现花屏的原因有多种，有可能是WPF的渲染线程挂了，也有可能是驱动问题。

这里主要描述驱动问题导致的花屏如何解决！

我们都知道，WPF的渲染，除了使用CPU渲染以外，还可以基于direct x进行渲染，以加快渲染速度。这个过程叫：硬件加速。如果显卡驱动存在兼容性问题，那么硬件加速很有可能会出现异常情况，比如说花屏。

解决此问题的思路也比较简单，关闭硬件加速或更新显卡驱动。

如果更新显卡驱动无效，那么我们可以在软件中关闭硬件加速。

我们在程序启动时候，加入如下代码：

//RenderMode.Default 会根据系统情况决定是否需要启用硬件加速。通常情况下都是打开状态，除非硬件不支持或者 direct x 版本不支持。
//开启硬件加速：WPF的程序界面，在硬件层呈现。
//关闭硬件加速：WPF的程序界面，在软件中呈现。
System.Windows.Media.RenderOptions.ProcessRenderMode = System.Windows.Interop.RenderMode.SoftwareOnly;

根据业务要求，也可以将此更改作为配置项处理，如果出现花屏，可尝试关闭硬件加速。

md5加密异常处理

Tue, 20 Jul 2021 02:10:03 +0000

操作系统更新后，软件出现各种bug~ 乍一看，md5加密算法跪了！

为啥会出现md5算法崩溃呢？

原因是操作系统开启了FIPS，而md5并不是FIPS（Federal Information Processing Standards 即（美国）联邦信息处理标准）中的一个部分，这就导致了异常的发生！

要解决这个问题，思路很简单：关闭FIPS或者本软件关闭FIPS。

所以解决方案可以有以下几种：

一、到系统的组策略安全设置中把FIPS禁用掉

按 WIN+R（或点击开始-运行），并输入gpedit.msc后确定，启动组策略编辑器。
左侧列表中找到计算机配置 - Windows设置 - 安全设置 - 本地策略 - 安全选项，并在右侧找到“系统加密：将FIPS兼容算法用于加密、哈希和签名”，设置为禁用。

二、修改注册表

按WIN+R（或点击开始-运行），并输入后确定，启动注册表编辑器。
浏览到HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FipsAlgorithmPolicy，将Enabled的值改为0。

三、修改程序运行时配置项

如果进程所在项目，没有存在app.config文件，那么先新建app.config。
在runtime节点中添加<enforceFIPSPolicy enabled="false"/>配置项目。

<!--关闭FIPS配置项-->
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <startup useLegacyV2RuntimeActivationPolicy="true">
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
  </startup> 
  <runtime>
    <enforceFIPSPolicy enabled="false" />   
  </runtime>
</configuration>

以上就是解决md5算法崩溃的方法，请笑纳！

【WPF】小备忘

Tue, 08 Jun 2021 02:10:03 +0000

就做个备忘录~

如果跨程序集，样式的引用需要全路径，application、、、开头
如果是静态类，在xaml上无法使用，智能提示也不能显示的。除非使用静态类的使用方法
附加属性的绑定，要加括号，否则会出现 UnsetValue。属性名绑定错误，也同样会出现 unsetvalue，因为他确实是没有设置值。没加括号是表示属性路径错误。
附加属性要注意类型，是属于谁的附加属性。
附加属性必须要声明Get,Set静态方法，否则绑定无法使用
popup 不能嵌套使用？
BitmapImage 跨线程调用后，不能给主线程用？冻结就可以了，冻结会把dispatcher置空
CEF 音视频支持的问题 80以上版本可支持（需要额外自己编译）
CEF可通过给CefBrower设置IDialogHandler可不显示打开文件对话框
浏览器文件上传是不能直接访问本地文件的，是把文件加载到内存给浏览器使用，简单给本地路径是不行的
DragMove 会导致 e.GetPosition 坐标错乱
依赖性属性绑定，不能在属性里面写逻辑，必须要在PropertyChanged里面写，否则属性里面写的逻辑，绑定的时候不会生效

【WPF】为异步UI添加交互能力

Tue, 08 Jun 2021 02:10:03 +0000

前面的文章我们提及过，异步UI的基础实现。基本思路主要是开启新的UI线程，并通过VisualTarget将UI线程上的Visual(即RootVisual)连接到主线程上的UI上即可渲染显示。

但是，之前的实现访问是没有交互能力的，视觉树上的UI并不能实现鼠标事件。那么今天我们就把交互的工作也给完成了。

实现交互能力的核心在于PresentationSource，它是完成交互功能的核心。它提供了交互源，它是一个抽象类，不能直接使用。我们需要通过继承它来实现交互逻辑。

具体代码如下：

        public class VisualTargetPresentationSource : PresentationSource
        {
            public VisualTargetPresentationSource(HostVisual hostVisual)
            {
                _visualTarget = new VisualTarget(hostVisual);
            }

            public override Visual RootVisual
            {
                get
                {
                    return _visualTarget.RootVisual;
                }

                set
                {
                    Visual oldRoot = _visualTarget.RootVisual;

                    _visualTarget.RootVisual = value;
                    
                    //此处是关键代码，通过根的时间通知，触发Load事件。通知视觉树，元素已经加载。
                    //元素加载后，IsVisible会变成True，命中测试才能开始工作
                    RootChanged(oldRoot, value);
                }
            }

            public override bool IsDisposed
            {
                get
                {
                    return false;
                }
            }

            protected override CompositionTarget GetCompositionTargetCore()
            {
                return _visualTarget;
            }

            private VisualTarget _visualTarget;
        }

有了上述代码，我们的异步UI具备了交互能力。但是此时，我们用鼠标点击元素，依然是不会有动作发生的。

因为我们的UI是在异步线程上，它的功能受到一定的阉割，它并不能直接响应鼠标或者键盘事件。所以我们需要通过VisualHost来做路由事件的传递。

请看完整的示例：

 //异步UI容器
    public class AsyncUIContainer : UIElement
    {
        public AsyncUIContainer()
        {
            Initialize();
        }

        private HostVisual hostVisual;

        private Grid RootVisual;

        private DispatcherUIThread dispatcherUIThread;

        /// <summary>
        /// 
        /// </summary>
        private void Initialize()
        {
            hostVisual = new HostVisual();

            dispatcherUIThread = new DispatcherUIThread();

            dispatcherUIThread.Start();

            dispatcherUIThread.Dispatcher.Invoke(() =>
            {
                RootVisual = new Grid();

                new VisualTargetPresentationSource(hostVisual)
                {
                    RootVisual = RootVisual
                };
            });
      
            AddVisualChild(hostVisual);
        }

        public void UpdateRootLayout(Action<Grid> action)
        {
            if (action != null)
            {
                RootVisual.Dispatcher.Invoke(() =>
                {
                    action(RootVisual);
                });
            }
        }

        #region override

        private UIElement _hitElement;

        protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
        {
            RootVisual.Dispatcher.Invoke(() =>
            {
                _hitElement = (UIElement)RootVisual.InputHitTest(hitTestParameters.HitPoint);
            });

            if (_hitElement != null)
            {
                return new PointHitTestResult(this, hitTestParameters.HitPoint);
            }
            else
            {
                return null;
            }
        }

        //此处是用来做路由事件转发，用于触发UI线程上的元素事件
        protected override void OnMouseDown(MouseButtonEventArgs e)
        {
            base.OnMouseDown(e);
            if (_hitElement != null)
            {
                _hitElement.Dispatcher.Invoke(() => _hitElement.RaiseEvent(e));
            }
        }

        //重写布局系统，让多线程UI元素能正常布局
        protected override Size MeasureCore(Size availableSize)
        {
            if (availableSize.Height > 0 && availableSize.Width > 0 && !(double.IsInfinity(availableSize.Height) || double.IsInfinity(availableSize.Width)))
            {
                RootVisual.Dispatcher.Invoke(() =>
                {
                    RootVisual.Measure(availableSize);
                });
                return availableSize;
            }
            else
            {
                var minSize = new Size(200, 200);
                RootVisual.Dispatcher.Invoke(() =>
                {
                    RootVisual.Measure(minSize);                  
                });
                return minSize;
            }
        }

        //重写布局系统，让多线程UI元素能正常布局
        protected override void ArrangeCore(Rect finalRect)
        {
            base.ArrangeCore(finalRect);

            RootVisual.Dispatcher.Invoke(() =>
            {
                RootVisual.Arrange(finalRect);
            });

            RenderSize = finalRect.Size;
        }

        //指定起Visual的数量
        protected override int VisualChildrenCount => 1;

        //指定需要渲染的Visual对象
        protected override Visual GetVisualChild(int index)
        {
            return hostVisual;
        }

        public void Dispose()
        {
            dispatcherUIThread?.Dispose();
        }
        #endregion

        public class VisualTargetPresentationSource : PresentationSource
        {
            public VisualTargetPresentationSource(HostVisual hostVisual)
            {
                _visualTarget = new VisualTarget(hostVisual);
            }

            public override Visual RootVisual
            {
                get
                {
                    return _visualTarget.RootVisual;
                }

                set
                {
                    Visual oldRoot = _visualTarget.RootVisual;

                    _visualTarget.RootVisual = value;

                    RootChanged(oldRoot, value);
                }
            }

            public override bool IsDisposed
            {
                get
                {
                    return false;
                }
            }

            protected override CompositionTarget GetCompositionTargetCore()
            {
                return _visualTarget;
            }

            private VisualTarget _visualTarget;
        }
    }

到这里，你就可以愉快的玩耍了。下期我们再实现异步UI在XAML上的编辑能力，可以在xaml中添加普通的xaml代码一样简单使用。

【asp.net core】使用FFMpeg进行视频截图

Sat, 16 Jan 2021 02:10:03 +0000

FFMpeg的nuget包有好几种，这里选择了使用FFMpeg命令行的封装包Xabe.FFmpeg。因为Xabe.FFmpeg实际上也是通过调用FFMpeg.exe文件，通过命令行传参的方式实现，所以在使用之前，需要先下载FFMpeg文件，并将bin目录加入到系统的环境变量。

具体代码如下：

        public static async Task SnapshotFromVideoAsync(string inputFileName, string outFileName, int minWidthOrHeight, TimeSpan timeSpan)
        {
            var mediaInfo = await Xabe.FFmpeg.FFmpeg.GetMediaInfo(inputFileName);
            
            var stream = mediaInfo.VideoStreams.FirstOrDefault();
            if (stream != null && !string.IsNullOrWhiteSpace(stream.Ratio))
            {
                var widthHeightRatio = stream.Ratio.Split(':');
                if (widthHeightRatio.Length == 2)
                {
                    var size = MediaHandler.GetThumbSize(stream.Ratio, minWidthOrHeight);
                    var conversion = Xabe.FFmpeg.FFmpeg.Conversions.New();
                    conversion.AddStream(stream.SetOutputFramesCount(1).SetSeek(timeSpan));
                    conversion.SetOutput(outFileName);
                    conversion.SetOverwriteOutput(true);
                    conversion.AddParameter($"-s {size.Width}x{size.Height}");
                    await conversion.Start();
                }
            }
        }

方法二，不需要GetMediaInfo，直接截图。

        public async Task SnapshotImage(string inputFileName, string outFileName, TimeSpan position)
        {
            try
            {
                await FFmpeg.Conversions.New()
                .Start($" -i {inputFileName} -y -f image2 -ss {position.TotalSeconds} -t 0.001 {outFileName}");
            }
            catch (Exception e)
            {
                
            }
        }

有些视频开头可能会存在黑屏的情况，这种情况下需要通过算法去判断，当前帧是否为黑场帧。这里暂时没有去做实现！

【asp.net core】使用EF Core创建初始数据库

Sat, 16 Jan 2021 02:10:03 +0000

直接通过代码创建数据库初始表。

        private static void CreateDbIfNotExists(IWebHost host)
        {
            using (var scope = host.Services.CreateScope())
            {
                var services = scope.ServiceProvider;
                try
                {
                    var context = services.GetRequiredService<MediaContext>();
                    context.Database.EnsureCreated();
                }
                catch (Exception ex)
                {
                    var logger = services.GetRequiredService<ILogger<Program>>();
                    logger.LogError(ex, "An error occurred creating the DB.");
                }
            }
        }


        //MediaContext:DbContext
        //省略其他，重写创建模型方法
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            //映射创建表，如果表已经存在就不会再创建。
            modelBuilder.Entity<User>().ToTable("Tbl_User");
            modelBuilder.Entity<Attachment>().ToTable("Tbl_Attachment");
            modelBuilder.Entity<Role>().ToTable("Tbl_Role");
            modelBuilder.Entity<AlbumDetail>().ToTable("Tbl_AlbumDetail");
            modelBuilder.Entity<Album>().ToTable("Tbl_Album");
            modelBuilder.Entity<AlbumDetailModel>().ToView("V_AlbumDetail");
            modelBuilder.Entity<AlbumModel>().ToView("V_Album");
            try
            {
                //视图不能直接映射创建，所以这里直接用SQL语句来创建
                Database.ExecuteSqlRaw("CREATE VIEW \"V_Album\" AS select album.*,att.RemoteDomain,att.RelativePath from Tbl_Album album left join Tbl_Attachment att on album.ThumbnailId = att.Id WHERE NOT EXISTS (SELECT * FROM sqlite_master s WHERE s.type = 'view' AND name = 'V_Album')");

                Database.ExecuteSqlRaw("CREATE VIEW \"V_AlbumDetail\" AS select ad.*,( fa.RemoteDomain||'/' ||fa.RelativePath ) as Url, (ta.RemoteDomain||'/' ||ta.RelativePath ) as Thumbnail from Tbl_AlbumDetail ad inner join Tbl_Attachment fa on ad.AttachmentId=fa.Id inner join Tbl_Attachment ta on ad.ThumbnailId =ta.Id WHERE NOT EXISTS (SELECT * FROM sqlite_master s WHERE s.type = 'view' AND name = 'V_AlbumDetail')");

            }
            catch
            {

            }
        }

【asp.net core】如何寄宿到Windows Service服务

Sat, 16 Jan 2021 01:10:03 +0000

在传统的宿主寄宿方式下，我们是打开一个控制台程序，并会出现控制台的界面，着实不好看，而且还不好自己自启动。今天我们就来把asp.net core寄宿到windows服务中。

寄宿到windows服务中，微软提供了贴心的扩展包：Microsoft.AspNetCore.Hosting.WindowsServices。我们先通过nuget进行安装。

安装好后，只需要在程序启动的过程中调用扩展方法RunAsService。这里要注意，RunAsService的参数是IWebHost类型，所以在构建host的时候，要注意使用WebHost。具体实现如下：

        //创建webhost
        private static IWebHostBuilder CreateWebHostBuilder(string[] args)
        {
            return WebHost.CreateDefaultBuilder(args).UseUrls("http://0.0.0.0:5000").UseKestrel(opt =>
             {
                 opt.Limits.MaxRequestBodySize = int.MaxValue;

             }).UseStartup<Startup>();
        }

        public static void Main(string[] args)
        {
            var host = CreateWebHostBuilder(args).Build();

            bool isService = !(Debugger.IsAttached || args.Contains("--console"));
            if (isService)
            {
                if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                {
#pragma warning disable CA1416 // 验证平台兼容性
                    //以后台服务的方式运行
                    host.RunAsService();
#pragma warning restore CA1416 // 验证平台兼容性
                }
                else
                {
                    host.Run();
                }
            }
            else
            {
                host.Run();
            }
        }

程序构建好后，就可以通过cmd命令进行安装了。

具体命令：sc create servername binpath= [your exe path] start= auto。

这里要注意，cmd需要以管理员权限运行。

安装好后，到这里我们就可以尝试启动服务了。

打开浏览器，我们会发现服务器返回500的错误，表示服务器内部错误！！

可能原因是工作目录不正确，因为Windows服务的工作目录默认是在System32下面，所以我们需要在host构建之前设置当前的工作目录，代码如下所示：

        public static void Main(string[] args)
        {
            //此处增加工作目录的设置，如果不做相关设置，那么服务将无法正常启动。
            var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
            var pathToContentRoot = Path.GetDirectoryName(pathToExe);
            Directory.SetCurrentDirectory(pathToContentRoot);  
            //工作目录设置完成后再构建Host
            var host = CreateWebHostBuilder(args).Build();

            bool isService = !(Debugger.IsAttached || args.Contains("--console"));
            if (isService)
            {
                if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                {
#pragma warning disable CA1416 // 验证平台兼容性
                    //以后台服务的方式运行
                    host.RunAsService();
#pragma warning restore CA1416 // 验证平台兼容性
                }
                else
                {
                    host.Run();
                }
            }
            else
            {
                host.Run();
            }
        }

以上操作后，我们的站点就可以通过服务的方式运行了，只要电脑打开了，服务就自动运行了，也不会出现黑色的控制台界面了。

【asp.net core】如何开启JWT令牌

Thu, 10 Dec 2020 01:10:03 +0000

JWT令牌授权认证，本文就不多说了，网上有大量的资料。本文只说说，JWT令牌如何在ASP.NET CORE中开启。

阅读本文之前，你也可以先参考以下资料：

JWT在asp.net core 2.2的版本框架就已经存在了，现在已经发展到.net 5了。本文主要针对.NET 5的版本进行阐述。

开启JWT主要需要包含以下几个步骤：

程序启动过程中，注册JWT中间件
生成Token，并返回给客户端
标记授权访问
携带Token进行访问服务器的API

具体通过代码来看看以下的几个步骤：

一、注册`JWT`中间件

打开Startup.cs文件，定位到方法ConfigureServices(IServiceCollection services)，将JWT验证服务注册到服务集合。

        /// <summary>
        /// JWT Token构建所需要的参数
        /// </summary>
        public class JWTTokenParamter
        {
            public JWTTokenParamter()
            {
                ExpirationInterval = TimeSpan.FromMinutes(30);
            }

            /// <summary>
            /// Token加密用的私钥，该私钥不能泄露出去
            /// </summary>
            public string SecretKey { get; set; }

            /// <summary>
            /// Token密钥颁发者
            /// </summary>
            public string Issuer { get; set; }

            /// <summary>
            /// Token接收者
            /// </summary>
            public string Audience { get; set; }

            /// <summary>
            /// Token距离生效时间的过期时间间隔，默认30分钟
            /// </summary>
            public TimeSpan ExpirationInterval { get; set; }
        }

        //以下代码在 Startup.cs 类中

        //引入命名空间
        using Microsoft.AspNetCore.Authentication.JwtBearer;
        using Microsoft.IdentityModel.Tokens;

        //注入和配置中间件服务   
        public void ConfigureServices(IServiceCollection services)
        {
            //从配置文件 appsettings.json 中读取JWT相关的配置项
            var token = Configuration.GetSection("JWTTokenParamter").Get<JWTTokenParamter>();
            
            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>
            {
                options.SaveToken = true;
                options.TokenValidationParameters = new TokenValidationParameters()
                {
                    ValidateIssuer = false,//是否验证Issuer
                    ValidateAudience = false,//是否验证Audience
                    ValidateLifetime = false,//是否验证失效时间
                    ClockSkew = TimeSpan.FromMinutes(30),
                    ValidateIssuerSigningKey = false,//是否验证SecurityKey
                    ValidAudience = token.Audience,//Audience
                    ValidIssuer = token.Issuer,//Issuer，这两项和前面签发jwt的设置一致
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(token.SecretKey))//拿到SecurityKey
                };
            });

            //省略其它代码
        }

        //配置中间件管道。注意，中间件管道是有顺序的，所以这边贴完整代码
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            //app.UseHttpsRedirection();
            //开启令牌验证，注意和UseAuthorization区分
            app.UseAuthentication();
            app.UseRouting();
            app.UseCors();
            //开启身份授权，开启后Authorize特性才会生效，否则会报错。.net5已经把身份授权集成到框架了，net core 2.2不需要此项
            app.UseAuthorization();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

appsettings.json中的token配置节点示例：

  "JWTTokenParamter": {
    "SecretKey": "123456123456123456",
    "Issuer": "a",
    "Audience": "a",
    "ExpirationInterval": "0.00:30:00"
  },

二、生成`Token`

生成Token的过程，请参考什么是 JWT？。此处就不赘述了，直接贴代码。

        /// <summary>
        /// 创建JWT令牌
        /// </summary>
        /// <param name="tokenParamter"></param>
        /// <param name="claims">自定义的TOKEN负载的信息</param>
        /// <returns></returns>
        public static string CreateJWTToken(JWTTokenParamter tokenParamter, Claim[] claims)
        {
            //声明一个对称密钥
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(tokenParamter.SecretKey));
            //以HmacSha256进行加密，生成签名凭证
            var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
            
            var notBeforeTime = DateTime.Now;  //生效时间
            //生成JWT令牌Token
            var jwtToken = new JwtSecurityToken(tokenParamter.Issuer, tokenParamter.Audience, claims, notBeforeTime, notBeforeTime + tokenParamter.ExpirationInterval, credentials);
            //将Token转成Json
            return new JwtSecurityTokenHandler().WriteToken(jwtToken);
        }        

生成Token的过程，一般都是在登录的环节，用户身份验证通过后，生成Token返回给客户端。调用部分的代码，这里就不做演示了。

三、标记授权访问

到这里，我们的api调用还不会执行JWT身份验证，需要在控制器上标记需要启用授权认证。方法很简单，只需要在控制器上增加[Authorize]的特性标签即可。

    [ApiController]
    //在此处增加需要授权访问的特性标签
    [Authorize]
    [EnableCors]
    [Route("[controller]")]
    public class TestController : ControllerBase
    {
        [HttpGet]
        public string Get()
        {
            
            return "your code";
        }
    }

这里的 [Authorize] 不仅仅是可以给控制器上使用，也可以直接在方法上使用，执行效果一致的。如下所示：

    [ApiController]    
    [EnableCors]
    [Route("[controller]")]
    public class TestController : ControllerBase
    {
        //在此处增加需要授权访问的特性标签
        [Authorize]
        [HttpGet]
        public string Get()
        {
            
            return "your code";
        }
    }

所以开启授权验证，可以根据实际业务需要，很方便的开启和关闭。

四、携带`Token`进行访问服务器的`API`

最后我们要让我们能正常访问web api，我们需要在http的请求头部增加授权认证的token。因为我们使用的是Bearer的JWT认证，所以我们在附带头部信息的时候，需要以Bearer 开头（注意后面需要追加空格），如Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1lIjoiYWRtaW4iLCJuYmYiOjE2MDc1MDA3MzQsImV4cCI6MTYwNzUwMjUzNCwiaXNzIjoiYSIsImF1ZCI6ImEifQ.kD55oXqgRmsfW7o3V1QBjXOOuh7H1YLEdkSeykV_ozg。

完整的Header添加Key为Authorization项，Value为Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1lIjoiYWRtaW4iLCJuYmYiOjE2MDc1MDA3MzQsImV4cCI6MTYwNzUwMjUzNCwiaXNzIjoiYSIsImF1ZCI6ImEifQ.kD55oXqgRmsfW7o3V1QBjXOOuh7H1YLEdkSeykV_ozg 即可。

我们以js的调用方法为例：

    await fetch("http://127.0.0.1:5000/login", {
        headers: {
          Authorization: "Bearer " + localStorage.getItem("token"),
        },
      })

这里的token是从本地存储中读取，登录成功后，我们需要将token存储起来，方便后续的接口调用携带。

我们测试的过程中，可以使用PostMan来进行测试，当我们给头部携带Token后，可以正常返回结果。

如果没有携带Token，则请求返回 401 Unauthorized

到这里，JWT基础的开启就完成了，大家还有什么疑问，欢迎在评论区留言。

【asp.net core】如何开启允许跨域访问?

Mon, 07 Dec 2020 02:04:03 +0000

有时候我们在做web前端和后台联调的时候会发现前端无法访问后台。因为现在的前端开发大多数都是大前端开发模式，所有前端访问asp.net core后台属于跨域请求。现在我们来看看怎么开启跨域访问。

asp.net core的框架提供了高扩展性，高灵活性，开启跨域请求也比较简单，主要是针对以下位置做修改：

服务中注册Http访问策略
引入app.cors
控制器中开启跨域访问

服务中注册Http访问策略

找到startup.cs文件，并在ConfigureServices方法中添加以下代码：

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddCors(options =>
            {
                options.AddDefaultPolicy(
                    builder =>
                    {
                        builder.WithOrigins("*")
                            .AllowAnyHeader()
                            .AllowAnyMethod().AllowAnyOrigin();
                    });
            });
            //省略...
        }

引入app.cors

找到startup.cs文件，并在Configure方法中添加以下代码：

 public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();
            app.UseRouting();
            //app.UseCors 核心代码 start
            app.UseCors();
            //app.UseCors 核心代码 end
            app.UseAuthorization();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

这里要特别注意，app.UseCors必须放在app.UseRouting()和app.UseAuthorization()中间。

控制器中开启跨域访问

找到对应的控制器，添加特性标签EnableCors。

    [EnableCors]
    [ApiController]
    [Route("[controller]")]
    public class LoginController : ControllerBase
    {
        private readonly ILogger<LoginController> _logger;

        public LoginController(ILogger<LoginController> logger)
        {
            _logger = logger;
        }

        [HttpGet]
        public bool Get()
        {
            return true;
        }
    }

详情请阅读微软官方文档，点我跳转！

【Web前端】基础入门之环境部署

Sat, 21 Nov 2020 07:44:03 +0000

随着网络的发展，web应用已经是大势所趋，桌面客户端的市占率越来越低，就业也越来越难。想保住饭碗就必须要跟上时代，转行！！Web前端是目前主流的技术方向，也是各大企业迫切的岗位，接下来就开始转行之旅了。

刚进入Web前端行列，你会发现这个世界跟以往写客户端有比较大的区别；比如，开发软件不一样，需要知道的知识面不一样，使用习惯不一样等等。

目前主流的web前端框架react已经是热火朝天，今天就以搭建react脚手架环境开始学起。

常用工具科普

Web前端需要依赖各种不同的技术支撑，包含有包管理器，node服务，webpack打包服务，Bable ES6编译，common.js规范等等。

nvm 管理工具

nvm 是用于管理node.js的版本以及npm的对应版本的工具。它可以帮助您下载安装node.js以及版本的切换，下载对应版本的node.js后，也会同时下载对应版本的npm工具。

npm 包管理工具

npm 是随同node.js一起安装的包管理工具，能解决NodeJS代码部署上的很多问题，常见的使用场景有以下几种：

允许用户从NPM服务器下载别人编写的第三方包到本地使用。
允许用户从NPM服务器下载并安装别人编写的命令行程序到本地使用。
允许用户将自己编写的包或命令行程序上传到NPM服务器供别人使用。

yarn 包管理工具

Yarn 是类似于npm的包管理工具，效率更高，速度更快，更推荐使用。

环境部署

根据上文链接，先将nvm（nvm-setup.exe）,yarn (yarn-1.22.5.msi) 等软件下载到本地（本次部署是基于windows操作系统），并安装。
打开 cmd 命令行，输入nvm检查是否安装成功（yarn可以输入yarn -v 查看是否安装成功）。如果提示命令不存在，则重启操作系统后重试。因为要加入到环境变量，如果环境变量变更没有通知系统是需要重启电脑才能生效的。
使用 nvm 安装 node.js。输入命令nvm install [node版本号或用 stable 表示最新]。安装过程中，会同步安装npm。（如果安装失败，需要多重试几次，因为网络原因经常会出现失败的情况。如果nvm不是最新版本，建议升级到最新版本后重试。）
安装成功后，使用命令nvm use [node版本号]即可。这里需要注意，如果没有使用命令去指定node的版本，node和npm的命令都不能被启用。也就是说，命令将无法识别。可以通过nvm list 或 nvm ls查看已安装的node版本,当前使用的版本会标明。如果要切换node版本，只需要使用nvm use [node版本号]就可以完成版本切换。

好了，到这里，最基本的环境就准备好了。接下来我们尝试搭建一个reactapp脚手架。

找一个空的文件夹目录，打开vs code软件,并通过菜单Terminal进入到终端命令行界面。输入以下命令：yarn create react-app myapp 或 npm init react-app myapp 进行创建reactapp脚手架。这里需要注意，myapp的命名只能是小写字母，否则会报错；如果执行该命令时，没有指定node版本，node指令将无法识别，命令执行报错，此时需要先指定node版本。将myapp作为工作目录，切换到该工作目录 cd myapp，没有切换到工作目录，命令无法执行。
创建好了后，使用命令yarn或npm install初始化和安装相关依赖包。如果该步骤没有执行，那么脚本中的命令将无法识别;使用npm初始化还可能会存在一些警告，可以通过命令npm audit fix来修复。
通过命名yarn init或npm init 创建默认的打包配置文件package.json，该文件包含了项目的一些基础描述。
使用命令yarn start或npm start启动项目。

最后再说一下，当你安装了yarn你会发现，使用npm指令的时候，实际上调用了yarn指令，所以后续的命令主要是针对yarn来进行学习使用。

WPF 文本和形状识别

Tue, 17 Nov 2020 03:00:03 +0000

WPF中，如何针对笔迹，实现文本和形状的智能识别功能？

文本识别常规有两种方法：

Microsoft.Ink.Recognizers
System.Windows.Ink.InkAnalyzer

在使用前，需要添加第三方dll库

IACore.dll
IALoader.dll
IAWinFX.dll
Microsoft.Ink.Analysis.dll
Microsoft.Ink.dll

以上依赖库，可自行网上下载。

以上两种方法的识别效果对比：

InkAnalyzer

该方法可识别文本和形状，多词文本识别尚可，但单个文本识别效果较差，故推荐使用此方法做形状识别。

Recognizer

只能做文本识别，单字和多字识别效果都挺好，跟windows自带的虚拟键盘识别效果差不多。

具体代码：

    //Recognizer 的实现

    public enum RecognizeLanguage
    {
        SimplifiedChinese = 0x0804,
        TraditionalChinese = 0x7c03,
        English = 0x0809
    }

    //识别文本
    public static string RecognizeText(StrokeCollection strokes, RecognizeLanguage language)
    {
        if (strokes == null || strokes.Count == 0)
            return string.Empty;

        var stream = new MemoryStream();

        strokes.Save(stream);

        using (var inkstorage = new Microsoft.Ink.Ink())
        {
            inkstorage.Load(stream.ToArray());

            var recognizers = new Recognizers();

            using (var recContext = recognizers.GetDefaultRecognizer((int)language).CreateRecognizerContext())
            {
                recContext.RecognitionFlags = RecognitionModes.None;
                    
                recContext.Strokes = inkstorage.Strokes;

                var recogResult = recContext.Recognize(out var statusResult);

                inkstorage.Strokes.Dispose();

                recContext.Strokes.Dispose();
                    
                return statusResult == RecognitionStatus.NoError ? recogResult.TopAlternate.ToString() : string.Empty;
                }
            }
        }


        //InkAnalyzer的实现
        //识别文本
        public static string RecognizeText(StrokeCollection strokes, RecognizeLanguage language)
        {
            if (strokes == null || strokes.Count == 0)
                return null;

            var analyzer = new InkAnalyzer();
            analyzer.AddStrokes(strokes);
            analyzer.SetStrokesType(strokes, StrokeType.Drawing);
            analyzer.SetStrokesLanguageId(strokes, (int)language);

            string recognizedString = string.Empty;

            if (analyzer.Analyze().Successful)
            {

                recognizedString = analyzer.GetRecognizedString();
            }
            analyzer.Dispose();

            return recognizedString;
        }

        //识别形状
        public static ShapeRecognizeResult RecognizeShape(StrokeCollection strokes)
        {
            if (strokes == null || strokes.Count == 0)
                return default;

            var analyzer = new InkAnalyzer();
            analyzer.AddStrokes(strokes);
            analyzer.SetStrokesType(strokes, StrokeType.Drawing);

            AnalysisAlternate analysisAlternate = null;
            var sfsaf = analyzer.Analyze();
            if (sfsaf.Successful)
            {
                var alternates = analyzer.GetAlternates();
                if (alternates.Count > 0)
                {
                    analysisAlternate = alternates[0];
                }
            }

            analyzer.Dispose();

            if (analysisAlternate != null && analysisAlternate.AlternateNodes.Count > 0)
            {
                var node = analysisAlternate.AlternateNodes[0] as InkDrawingNode;

                return new ShapeRecognizeResult(node.Centroid, node.HotPoints, analysisAlternate.RecognizedString);
            }

            return default;
        }

    public class ShapeRecognizeResult
    {
        public ShapeRecognizeResult(Point centroid, PointCollection hotPoints,string shapeType)
        {
            Centroid = centroid;
            HotPoints = hotPoints;
            ShapeType = shapeType;
        }

        public string ShapeType { get; }

        public Point Centroid { get; }

        public PointCollection HotPoints { get; }
    }

以上就是文本和形状识别的基础实现，如果要扩展可自行添加代码。如直线识别，表格识别等。

WPF 通过Clip属性进行擦除的算法

Tue, 17 Nov 2020 02:00:03 +0000

WPF中，UIElement都有个Clip通用属性，我们可以通过该属性对元素进行裁剪。现在我们就通过裁剪的方法，来实现擦除功能。

擦除功能实现包含几个部分：

擦除初始化
相同坐标系和不同坐标系之间的擦除
元素旋转后的擦除
擦除完成后，移除元素
撤消重做的实现

具体修改方法如下所示：

一、Geometry合并算法

		//连接俩个矩形，形成一个新的Geometry
    	Geometry ExcludeWithGeometry(RawRect rect1, RawRect rect2)
        {
            if (rect1.Left <= rect2.Left && rect1.Top <= rect2.Top)
            {
                return CombineGeometry(rect1, rect2);
            }
            else if (rect2.Left < rect1.Left && rect2.Top < rect1.Top)
            {
                return CombineGeometry(rect2, rect1);
            }
            else if (rect1.Left <= rect2.Left && rect1.Bottom >= rect2.Bottom)
            {
                return CombineGeometry2(rect1, rect2);
            }
            else if (rect2.Left < rect1.Left && rect2.Bottom > rect1.Bottom)
            {
                return CombineGeometry2(rect2, rect1);
            }

            return null;
        }

		//左边到右边，上面到下面的连续绘制
        Geometry CombineGeometry(RawRect rect1, RawRect rect2)
        {
            
            var streamGeometry = new StreamGeometry();
            var streamGeometryContext = streamGeometry.Open();
            streamGeometryContext.BeginFigure(rect1.TopLeft, true, true);
            streamGeometryContext.LineTo(rect1.TopRight, true, true);
            streamGeometryContext.LineTo(rect2.TopRight, true, true);
            streamGeometryContext.LineTo(rect2.BottomRight, true, true);
            streamGeometryContext.LineTo(rect2.BottomLeft, true, true);
            streamGeometryContext.LineTo(rect1.BottomLeft, true, true);
            streamGeometryContext.Close();
            return streamGeometry;
        }

		//
        Geometry CombineGeometry2(RawRect rect1, RawRect rect2)
        {            
            var streamGeometry = new StreamGeometry();
            var streamGeometryContext = streamGeometry.Open();
            streamGeometryContext.BeginFigure(rect1.TopLeft, true, true);
            streamGeometryContext.LineTo(rect2.TopLeft, true, true);
            streamGeometryContext.LineTo(rect2.TopRight, true, true);
            streamGeometryContext.LineTo(rect2.BottomRight, true, true);
            streamGeometryContext.LineTo(rect1.BottomRight, true, true);
            streamGeometryContext.LineTo(rect1.BottomLeft, true, true);
            streamGeometryContext.Close();
            return streamGeometry;
        }

		//表示一个矩形，该矩形可旋转。
		//之所以需要这个矩形类，主要是要让它支持旋转。自带的Rect是会自动将点集校正成正矩形的。
        struct RawRect
        {
            public double Left => TopLeft.X;

            public double Top => TopLeft.Y;

            public double Bottom => BottomRight.Y;

            public double Right => BottomRight.X;

            public Point TopLeft { get; set; }

            public Point TopRight { get; set; }

            public Point BottomRight { get; set; }

            public Point BottomLeft { get; set; }
        }

二、擦除实现部分代码

		//启动擦除

		//将CurrentSlide的坐标转换成指定元素上，包含旋转。
		//然后调用Geometry合并算法进行合并
		//area 表示擦除的矩形面积，element表示要擦除的对象，CurrentSlide表示画布（即element容器）
        var topLeft = CurrentSlide.TranslatePoint(area.TopLeft, element);
        var topRight = CurrentSlide.TranslatePoint(area.TopRight, element);
        var bottomLeft = CurrentSlide.TranslatePoint(area.BottomLeft, element);
        var bottomRight = CurrentSlide.TranslatePoint(area.BottomRight, element);
				
        if (element.Clip == null)
        {
			//初始化Element的Clip Geometry。
            element.Clip = new RectangleGeometry(new Rect(element.Bounds.X - element.X, element.Bounds.Y - element.Y, element.Bounds.Width, element.Bounds.Height));
        }
        else
        {
			//合并矩形
            StreamGeometry streamGeometry = new StreamGeometry();
            var cxt = streamGeometry.Open();
            cxt.BeginFigure(topLeft, true, true);
            cxt.LineTo(topRight, false, true);
            cxt.LineTo(bottomRight, false, true);
            cxt.LineTo(bottomLeft, false, true);
            cxt.Close();

            var geo = Geometry.Combine(element.Clip, streamGeometry, GeometryCombineMode.Exclude, null);

            element.Clip = geo;
        }


		//持续擦除
		//_lastElementRawRect 是记录上一次擦除的矩形位置的字典

		var leftTop = CurrentSlide.TranslatePoint(new Point(position.X - _area.Width / 2, position.Y - _area.Height / 2), element);
        var leftBottom = CurrentSlide.TranslatePoint(new Point(position.X - _area.Width / 2, position.Y + _area.Height / 2), element);
        var rightTop = CurrentSlide.TranslatePoint(new Point(position.X + _area.Width / 2, position.Y - _area.Height / 2), element);
        var rightBottom = CurrentSlide.TranslatePoint(new Point(position.X + _area.Width / 2, position.Y + _area.Height / 2), element);
        var newrect = new RawRect() { TopLeft = leftTop, BottomLeft = leftBottom, BottomRight = rightBottom, TopRight = rightTop };

        var lastRawRect = _lastElementRawRect[element];
        var geo = ExcludeWithGeometry(lastRawRect, newrect);
        if (geo == null)
         {
            StreamGeometry streamGeometry = new StreamGeometry();
            var cxt = streamGeometry.Open();
            cxt.BeginFigure(leftTop, true, true);
            cxt.LineTo(rightTop, false, true);
            cxt.LineTo(rightBottom, false, true);
            cxt.LineTo(leftBottom, false, true);
            cxt.Close();
            element.Clip = Geometry.Combine(element.Clip, streamGeometry, GeometryCombineMode.Exclude, null);
        }
        else
            element.Clip = Geometry.Combine(element.Clip, geo, GeometryCombineMode.Exclude, null);

            _lastElementRawRect[element] = newrect;

三、全部擦除后移除元素

        /// <summary>
        /// 通过此属性来判断是否擦除完成，擦除完成后即可从容器中移除
        /// </summary>
        public bool IsErased
        {
            get
            {
                if (Clip == null) return false;

                if (Clip.FillContainsWithDetail(GetVisualGeometry(this)) == IntersectionDetail.Empty)
                {
                    return true;
                }

                return false;
            }
        }

        /// <summary>
        /// 表示透明度的值，默认为 0
        /// </summary>
        private readonly byte _alpha = 0;

        private Geometry GetVisualGeometry(Visual rootVisual)
        {
            Geometry visualGeometry = Geometry.Empty;
            var drawing = VisualTreeHelper.GetDrawing(rootVisual);
            var visualCount = VisualTreeHelper.GetChildrenCount(rootVisual);
            if (drawing == null)
            {
                for (int i = 0; i < visualCount; i++)
                {
                    var visual = VisualTreeHelper.GetChild(rootVisual, i) as Visual;
                    if (visual != null)
                        GetVisualGeometry(visual);
                }
            }
            else
            {
                foreach (var drawingItem in drawing.Children)
                {
                    CombineVisualGeometry(ref visualGeometry, drawingItem);
                }
            }
            return visualGeometry;
        }

        private void CombineVisualGeometry(ref Geometry targetGeometry, Drawing drawing)
        {
            if (drawing is GeometryDrawing geometryDrawing)
            {
                if (!IsColorTransparent(geometryDrawing.Brush))
                {
                    targetGeometry = Geometry.Combine(targetGeometry, geometryDrawing.Geometry, GeometryCombineMode.Union, null);
                }
                if (!IsColorTransparent(geometryDrawing.Pen.Brush))
                {
                    var outlineGeometry = geometryDrawing.Geometry.GetWidenedPathGeometry(geometryDrawing.Pen);
                    targetGeometry = Geometry.Combine(targetGeometry, outlineGeometry, GeometryCombineMode.Union, null);
                }
            }
            else if (drawing is ImageDrawing imageDrawing)
            {
                targetGeometry = Geometry.Combine(targetGeometry, new RectangleGeometry(imageDrawing.Rect), GeometryCombineMode.Union, null);
            }
            else if (drawing is VideoDrawing videoDrawing)
            {
                targetGeometry = Geometry.Combine(targetGeometry, new RectangleGeometry(videoDrawing.Rect), GeometryCombineMode.Union, null);
            }
            else if (drawing is GlyphRunDrawing glyphRunDrawing)
            {
                if (!IsColorTransparent(glyphRunDrawing.ForegroundBrush))
                {
                    var glyphRunGeometry = glyphRunDrawing.GlyphRun.BuildGeometry();

                    targetGeometry = Geometry.Combine(targetGeometry, glyphRunGeometry, GeometryCombineMode.Union, null);
                }
            }
            else if (drawing is DrawingGroup drawingGroup)
            {
                foreach (var subDrawing in drawingGroup.Children)
                {
                    CombineVisualGeometry(ref targetGeometry, subDrawing);
                }
            }
            else
            {
                throw new NotImplementedException();
            }
        }

        /// <summary>
        /// 画刷是否为透明色
        /// </summary>
        /// <param name="brush"></param>
        /// <returns></returns>
        private bool IsColorTransparent(Brush brush)
        {
            var solidColorBrush = brush as SolidColorBrush;
            if (solidColorBrush != null)
            {
                return IsSolidColorBrushTransparent(solidColorBrush);
            }
            var linearGradientBrush = brush as LinearGradientBrush;

            if (linearGradientBrush != null)
            {
                return IsLinearGradientBrushTransparent(linearGradientBrush);
            }
            var radialGradientBrush = brush as RadialGradientBrush;
            if (radialGradientBrush != null)
            {
                return IsRadialGradientBrushTransparent(radialGradientBrush);
            }
            return false;
        }
        /// <summary>
        /// 单一色是否透明
        /// </summary>
        /// <param name="solidColorBrush"></param>
        /// <returns></returns>
        private bool IsSolidColorBrushTransparent(SolidColorBrush solidColorBrush)
        {
            if (solidColorBrush.Color.A <= _alpha)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 径向渐变色是否透明
        /// </summary>
        /// <param name="radialGradientBrush"></param>
        /// <returns></returns>
        private bool IsRadialGradientBrushTransparent(GradientBrush radialGradientBrush)
        {
            return IsColorTransparent(radialGradientBrush.GradientStops);
        }

        /// <summary>
        /// 线性渐变色是否透明
        /// </summary>
        /// <param name="linearGradientBrush"></param>
        /// <returns></returns>
        private bool IsLinearGradientBrushTransparent(GradientBrush linearGradientBrush)
        {
            return IsColorTransparent(linearGradientBrush.GradientStops);
        }

        /// <summary>
        /// 颜色是否为透明色
        /// </summary>
        /// <param name="gradientStops"></param>
        /// <returns></returns>
        private bool IsColorTransparent(GradientStopCollection gradientStops)
        {
            return gradientStops.All(gradientStop => gradientStop.Color.A <= _alpha);
        }

撤销重做就不做示例了，比较简单。

注意事项：通用代码贴出了完整代码，业务方面代码只贴出了核心部分代码，剩余部分同学们可根据自己实际情况修改

DotNet Core切回到.net framework

Tue, 17 Nov 2020 01:30:03 +0000

我们用donet core做项目，发现有些依赖库必须得用.net framework才能正常运行，此时想切回来怎么办？

方法非常简单，只需要更改解决方案中的项目文件即可。

具体修改方法如下所示：

	<PropertyGroup>
		<OutputType>WinExe</OutputType>
        <!--此处只需要将TargetFramework修改成想要的.net framework版本即可-->
		<TargetFramework>net472</TargetFramework>
		<UseWPF>true</UseWPF>
    <UseWindowsForms>true</UseWindowsForms>
		<Platforms>AnyCPU;x64;x86</Platforms>
		<ApplicationIcon>app_logo.ico</ApplicationIcon>
	</PropertyGroup>

注意事项：修改版本会导致C#的语法版本降低，部分使用了高级特性的语法将无法编译通过。此时需要通过手动方式进行修改。

网站收藏

Mon, 19 Oct 2020 02:30:03 +0000

有些网站的内容不错，收藏一下，方便查找。此文章纯属外链收藏，经常更新！

C# 如何给文件夹赋予权限，以解决权限不足问题

Wed, 30 Sep 2020 05:30:03 +0000

我们知道，windows操作系统系统盘的权限控制是比其它磁盘更严格的。我们应用程序如果想在C盘下进行文件读写，大部分需要管理员权限才行（像appdata这种目录除外）。

如果你的应用程序必须在安装目录下进行数据的读写，同时用户权限并不是管理员，我们该怎么办？

能想到的办法当然很简单，没有权限就给它赋予权限呗！

先来看一段代码：

        /// <summary>
        ///为文件夹添加users，everyone用户组的完全控制权限
        /// </summary>
        /// <param name="dirPath"></param>
        static bool AddSecurityControll2Folder(string dirPath)
        {
            try
            {
                //获取文件夹信息
                var dir = new DirectoryInfo(dirPath);
                //获得该文件夹的所有访问权限
                var dirSecurity = dir.GetAccessControl(AccessControlSections.All);
                //设定文件ACL继承
                var inherits = InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit;
                //添加ereryone用户组的访问权限规则 完全控制权限
                var everyoneFileSystemAccessRule = new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow);
                //添加Users用户组的访问权限规则 完全控制权限
                //FileSystemAccessRule usersFileSystemAccessRule = new FileSystemAccessRule("Users", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow);
                dirSecurity.ModifyAccessRule(AccessControlModification.Add, everyoneFileSystemAccessRule, out bool isModified);
                //dirSecurity.ModifyAccessRule(AccessControlModification.Add, usersFileSystemAccessRule, out bool isModified);
                //设置访问权限
                dir.SetAccessControl(dirSecurity);

                return isModified;
            }
            catch (Exception)
            {
                return false;
            }
        }

以上代码就可以用来修改文件夹的权限。

但是，我们的软件不是以管理员权限运行的话，此处的代码执行根本就没有用啊!在忽悠我么？

那是当然，如果不是管理员就能正常执行，这才奇怪了不是？那还要权限干嘛呢？

所以解决方法，我们只需要将修改文件夹权限的时机做个修改，我们放到安装的时候再执行就好了。

至于大家用什么方式打安装包，就用那种方式打，把权限控制的逻辑写进去就可以了。

WPF 获取触摸面积的几种方法

Wed, 30 Sep 2020 02:30:03 +0000

WPF中有单独的触摸事件，也可以开启触摸消息。系统为了兼容老的应用程序，触摸消息会模拟成鼠标事件传递。某些应用场景，我们必须得获取到触摸面积才好开展我们的业务。下面整理几种获取触摸面积的方法。

WPF中提供的触摸事件有Touch事件,Stylus事件或者通过StylusPlugIns注入。

一、通过触摸事件获取

在Touch事件中，可以通过参数TouchEventArgs获取。

//这个是Touch事件传递的参数
TouchEventArgs e;

var area = e.GetTouchPoint(null).Bounds;
//或者
var area = e.TouchDevice.GetTouchPoint(null).Bounds;

获取触摸的边界值，触摸面积也就是Size值。

二、通过触摸点获取

如果是通过Stylus事件或者StylusPlugIns，可以从StylusPoint中获取。

        //通过这种方式获取触摸点集
        var stylusPoints= e.GetStylusPoints(null);
        //stylusPointProperty 参数可以是 StylusPointProperties.Height 或者 StylusPointProperties.Width

        public static double GetStylusPointProperty(StylusPoint stylusPoint, StylusPointProperty stylusPointProperty)
        {
            double value = 0.0;
            //这里没有做限制是高度或者宽度属性，只做演示，可以自己加逻辑
            if (stylusPoint.HasProperty(stylusPointProperty))
            {
                value = stylusPoint.GetPropertyValue(stylusPointProperty);

                StylusPointPropertyInfo propertyInfo = stylusPoint.Description.GetPropertyInfo(stylusPointProperty);

                if (!DoubleUtil2.AreClose(propertyInfo.Resolution, 0.0))
                {
                    value /= propertyInfo.Resolution;
                }
                else
                {
                    value = 0.0;
                }

                //属性值的单位
                if (propertyInfo.Unit == StylusPointPropertyUnit.Centimeters)
                {
                    value /= 2.54;
                }
                
                value *= 96.0;
            }

            return value;
        }

带撤销步数限制的撤消重做功能实现

Tue, 29 Sep 2020 07:20:03 +0000

撤消重做我们业务中非常常用的功能，我这里写个带限制步数的撤销操作功能的基础实现。

先来了解下撤销重做操作的基本思路。

撤销的操作往往是先撤回最近的操作，重做则是重做最近一次的撤销操作。所以，撤销重做功能都是符合先进后出的逻辑。所以我们在选择的时候，可以直接采用栈来做实现。
为了避免撤销操作和重做操作的不一致性，我们需要定义一个对象，能够同时用于撤销和重做的具体操作行为，这样我们在做撤销和重做的操作时，就不至于会出现对不上的情况。
如果要实现撤销步数限制，那么我们就需要在撤销步数达到最大时，删除最前面多余的撤销步数。

撤销重做栈的实现

因为业务需要，我们这个栈需要提供删除超出的撤销操作，具体方法如下：

    /// <summary>
    /// 包含栈对象的节点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkedStackNode<T>
    {
        public LinkedStackNode(T value)
        {
            Value = value;
        }

        /// <summary>
        /// 下一个节点对象
        /// </summary>
        public LinkedStackNode<T> Next { get; internal set; }

        /// <summary>
        /// 上一个节点对象
        /// </summary>
        public LinkedStackNode<T> Pre { get; internal set; }

        /// <summary>
        /// 包含对象的值
        /// </summary>
        public T Value { get; }
    }

    /// <summary>
    /// 链表实现的栈，非线程安全
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkedStack<T>
    {
        public LinkedStack(int capacity)
        {
            _capacity = capacity;
        }

        /// <summary>
        /// 根节点
        /// </summary>
        private LinkedStackNode<T> _root;

        /// <summary>
        /// 叶子节点
        /// </summary>
        private LinkedStackNode<T> _leaf;

        /// <summary>
        /// 最大容量
        /// </summary>
        private int _capacity;

        /// <summary>
        /// 获取或设置<see cref="LinkedStack{T}"/>允许容纳的最大数量
        /// </summary>
        public int Capacity
        {
            get
            {
                return _capacity;
            }
            set
            {
                _capacity = value;
                if (_capacity < Count)
                {
                    RemoveLastOf(Count - _capacity);
                }
            }
        }

        /// <summary>
        /// <see cref="LinkedStack{T}"/>所包含<see cref="LinkedStackNode{T}"/>数量
        /// </summary>
        public int Count { get; private set; }

        /// <summary>
        /// 移除并返回顶端的<see cref="LinkedStackNode{T}"/>对象
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            if (_leaf == null)
                throw new Exception("当前栈为空");

            var value = _leaf.Value;
            var pre = _leaf.Pre;
            if (pre != null)
            {
                pre.Next = null;
            }

            _leaf = pre;

            Count--;

            return value;
        }

        /// <summary>
        /// 移除并返回顶端的<see cref="LinkedStackNode{T}"/>对象
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool TryPop(out T t)
        {
            if (_leaf == null)
            {
                t = default;
                return false;
            }
            t = Pop();
            return true;
        }

        /// <summary>
        /// 在栈顶端插入一个隶属于<see cref="LinkedStackNode{T}"/>的对象
        /// </summary>
        /// <param name="t"></param>
        public void Push(T t)
        {
            var node = new LinkedStackNode<T>(t);

            if (_root == null)
            {
                _root = node;
                _leaf = node;
            }
            else
            {
                if (_root.Next == null)
                {
                    _root.Next = node;
                    node.Pre = _root;
                    _leaf = node;
                }
                else
                {
                    _leaf.Next = node;
                    node.Pre = _leaf;
                    _leaf = node;
                }
            }

            if (Capacity - Count > 1)
            {
                Count++;
                return;
            }
            else
            {
                RemoveLastOf(1);
            }
        }

        /// <summary>
        /// 返回顶端的<see cref="LinkedStackNode{T}"/>对象并不进行移除
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            if (_leaf == null)
                throw new Exception("当前栈为空");

            return _leaf.Value;
        }

        /// <summary>
        /// 返回顶端的<see cref="LinkedStackNode{T}"/>对象并不进行移除
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool TryPeek(out T t)
        {
            if (_leaf == null)
            {
                t = default;
                return false;
            }
            t = Peek();
            return true;
        }

        /// <summary>
        /// 从栈底端移除节点
        /// </summary>
        /// <param name="count">需要移除的对象数量</param>
        /// <returns></returns>
        int RemoveLastOf(int count)
        {
            var c = Math.Min(count, Count);
            var current = _root;
            for (int i = 0; i < c; i++)
            {
                current = current.Next;
            }

            current.Pre = null;
            _root = current;
            Count -= c;
            return c;
        }
    }

定义可撤销操作接口IUndoable

    /// <summary>
    /// 表示可撤销的
    /// </summary>
    public interface IUndoable
    {
        /// <summary>
        /// 恢复
        /// </summary>
        void Redo();

        /// <summary>
        /// 撤销
        /// </summary>
        void Undo();
    }

定义撤销重做操作

    internal class UndoableOperator
    {
        internal UndoableOperator()
        {
            _redoCommandStack = new LinkedStack<IUndoable>(_defaultCapacity);
            _undoCommandStack = new LinkedStack<IUndoable>(_defaultCapacity);
        }

        readonly LinkedStack<IUndoable> _redoCommandStack;
        readonly LinkedStack<IUndoable> _undoCommandStack;

        /// <summary>
        /// 默认支持撤销重做的步数
        /// </summary>
        const int _defaultCapacity = 100;

        private int capacity = _defaultCapacity;

        public int Capacity
        {
            get
            {
                return capacity;
            }
            set
            {
                capacity = value;

                _redoCommandStack.Capacity = value;
                _undoCommandStack.Capacity = value;
            }
        }

        public bool CanUndo
        {
            get
            {
                return _undoCommandStack.Count > 0;
            }
        }

        public bool CanRedo
        {
            get
            {
                return _redoCommandStack.Count > 0;
            }
        }

        /// <summary>
        /// 插入一个新的操作
        /// </summary>
        /// <param name="undoable"></param>
        public void Insert(IUndoable undoable)
        {
            _undoCommandStack.Push(undoable);
        }

        /// <summary>
        /// 执行一个可撤销操作
        /// </summary>
        internal void Undo()
        {
            if (_undoCommandStack.TryPop(out IUndoable cmd))
            {
                cmd.Undo();
                _redoCommandStack.Push(cmd);
            }
        }

        /// <summary>
        /// 执行一个可恢复操作
        /// </summary>
        internal void Redo()
        {
            if (_redoCommandStack.TryPop(out IUndoable cmd))
            {
                cmd.Redo();
                _undoCommandStack.Push(cmd);
            }
        }
    }

这里没有使用框架自带的栈，真正业务上可以使用System.Collections.Concurrent.ConcurrentStack，线程安全栈来代替以上链表栈。

到这里，撤销重做的功能就基本实现了，只需要在实际业务上稍微做些封装就可以工作了。

WPF 实现屏幕截图

Tue, 29 Sep 2020 06:35:03 +0000

屏幕截图指的是截取当前系统桌面的展示的所有内容，截取屏幕可以供我们完成冻结桌面的业务。

具体方法如下：

        /// <summary>
        /// 屏幕截图
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <returns></returns>
        public static BitmapSource CaptureScreen(int x, int y, int width, int height)
        {
            var bitmap = new Bitmap(width, height);
            using var graphics = Graphics.FromImage(bitmap);
            graphics.CopyFromScreen(x, y, 0, 0, new Size(width, height));
            //BitmapToBitmapSource方法，请参阅：https://huchengv5.gitee.io/post/Bitmap%E4%B8%8EBitmapSource%E7%9A%84%E4%BA%92%E8%BD%AC.html
            return ImageHelper.BitmapToBitmapSource(bitmap);
        }

        /// <summary>
        /// 以当前dpi放大比例截屏
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <returns></returns>
        public static BitmapSource CaptureScreenWithCurrentDpi(int x, int y, int width, int height)
        {
            //GetDpiRatio方法，请参阅：https://huchengv5.gitee.io/post/WPF-%E5%A6%82%E4%BD%95%E8%8E%B7%E5%8F%96%E7%B3%BB%E7%BB%9FDPI.html
            var ratio = DpiHelper.GetDpiRatio();
            return CaptureScreen(x, y, width / (int)ratio, height / (int)ratio);
        }   

WPF 如何获取系统DPI

Tue, 29 Sep 2020 05:35:03 +0000

Windows10支持设置系统桌面的缩放比，有些软件没有做处理，会导致界面很难看。

通过下面的方法，可以获取当前系统的DPI值，可根据dpi动态做些业务调整。

        //获取当前dpi的缩放比
        public static double GetDpiRatio(Window window)
        {
            var currentGraphics = Graphics.FromHwnd(new WindowInteropHelper(window).Handle);
            //96是100%的dpi
            return currentGraphics.DpiX / 96;
        }      

WPF 如何通过位图创建鼠标指针图标

Tue, 29 Sep 2020 04:35:03 +0000

系统自带的图标很无趣？没事，用图片换个风格试试！！

请看代码：

        private static Cursor CreateMyCursor(BitmapSource source, int width, int height)
        {
            const int f = 4;
            var bmp = new Bitmap(width, height);
            Graphics g = Graphics.FromImage(bmp);
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            var pen = new System.Drawing.Pen(System.Drawing.Brushes.Black, 2.0F);
            g.DrawRectangle(pen, new Rectangle(f, f, width - 2 * f, width - 2 * f));
            g.Flush();
            g.Dispose();
            pen.Dispose();
            return BitmapCursor.CreateBmpCursor(bmp);
        }

        public class BitmapCursor : SafeHandle
        {
            public override bool IsInvalid
            {
                get
                {
                    return handle == (IntPtr)(-1);
                }
            }

            public static Cursor CreateBmpCursor(Bitmap cursorBitmap)
            {

                var c = new BitmapCursor(cursorBitmap);

                return CursorInteropHelper.Create(c);
            }

            protected BitmapCursor(Bitmap cursorBitmap)
                : base((IntPtr)(-1), true)
            {
                handle = cursorBitmap.GetHicon();
            }

            protected override bool ReleaseHandle()
            {
                bool result = DestroyIcon(handle);

                handle = (IntPtr)(-1);

                return result;
            }

            [DllImport("user32")]
            private static extern bool DestroyIcon(IntPtr hIcon);
        }

Bitmap与BitmapSource的互转

Tue, 29 Sep 2020 03:35:03 +0000

使用WPF过程中，有些时候需要调用系统的一些接口，必须传入GDI+所支持的图片类型，也是winform支持的图片类型，这个时候我们就需要做一个转换了。

请看主要代码，图片格式看情况自行设定。通常使用jpg比较好，省空间；如果支持透明就用png吧。

        public static Bitmap BitmapSourceToBitmap(BitmapSource source)
        {
            if (source == null) return null;
            using var stream = new MemoryStream();
            var jpegBitmapEncoder = new JpegBitmapEncoder();
            jpegBitmapEncoder.Frames.Add(BitmapFrame.Create(source));
            jpegBitmapEncoder.Save(stream);
            var bmp = new Bitmap(stream);
            return bmp;
        }

        public static BitmapSource BitmapToBitmapSource(Bitmap bitmap)
        {
            if (bitmap == null) return null;
            var ms = new MemoryStream();
            bitmap.Save(ms, ImageFormat.Png);
            var image = new BitmapImage();
            image.BeginInit();
            //有些格式你会发现打不开，因为像素有丢失，没关系加上这个配置即可。
            //image.CreateOptions=BitmapCreateOptions.IgnoreColorProfile;
            image.StreamSource = ms;
            image.EndInit();
            return image;
        }

最简函数的执行过程？

Mon, 28 Sep 2020 08:35:03 +0000

写了这么久的代码，你了解代码的执行过程吗？执行一行代码都干了些啥？简单的赋值到底是在干什么？来来，今天带大家入个门，修行就靠自己了。

不同的编译器编译后的执行效果不一样，这里以C语言编译结果为例。

我们先贴一段常规C代码

int m=10;
int main()
{
    int i=4;
    int j=5;
    m = fun(i,j);
    return 0;
}

int fun(int a,int b)
{
    int c = 0;
    c = a + b;
    return c;
}

计算机执行这段代码，都干了些啥？先来了解点常规知识

计算器的核心处理器是CPU,一个CPU有多个核心，一个核心里面包含有多种寄存器。

在这个案例中，主要会使用到 eip寄存器，ebp寄存器，esp寄存器。

eip寄存器：用于执行计算机指令的寄存器。如：mov，ret，add等。
ebp寄存器：指针始终指向栈顶端的寄存器，指针会根据栈的空间的变化而自动变化。
esp寄存器：指针指向栈底的寄存器，指针会随着作用域变化而变化。

程序启动时候，将会在内存中申请一个连续的内存地址，这个连续内存地址为栈区（这里的数据类型都是值类型）。该栈区包含有：代码区，静态区，动态区。

代码区：用于存储代码的区域，主要用于执行计算机指令。
静态数据区：用于存储代码全局成员变量，可供不同方法使用的全局成员变量或其他全局对象。
动态数据区：用于存储代码动态执行过程中产生的数据。

初始栈区如下图所示：

程序启动时，将执行第一条指令，也就是进入到main函数。这个时候，esp寄存器所指向的地址将会在动态数据区保存起来，esp的指针同时也指向该地址。ebp指针也同样指向该地址，因为栈目前就只有一个数据。

紧接着，执行下面的两条赋值指令，此时，变量i和j将会在栈中做初始化。i和j的值会依次入栈。如下图所示：

紧接着要准备执行fun函数了。

执行fun函数，先将参数a,b的值进行入栈，入栈顺序是先入最右侧的参数，再入左侧的参数，此处先入b，再入a参数的值。

由于fun函数是有返回值的，所以栈区为返回值预留一个位置，此时还没有值。位置的大小由数据类型决定。

为了能够正确取到返回值，需要将返回值的地址记录下来，于是进行地址入栈操作。

返回值地址记录了以后，接下来要进入到fun函数的作用域了。为了确保函数可以跳出到先前作用域，并且后续能够清空无效的栈区，这里会记录作用域边界的指针地址，也就是前面提到的esp指向的指针地址。

后面的操作跟前面的步骤一致，将fun的变量c入栈。

后面紧接着执行a+b的指令，此时会将返回值传递给c。

这里要注意：a,b是属于main函数的作用域，它是从main函数传递给fun函数的参数值，也是属于“形参”的范畴，而i,j是属于实参。

因为a,b的指针位置都已经知道了，栈顶就是c的地址，在执行a + b指令后，将计算结果存储在C的位置。

因为代码区存储了函数的执行指令，ebp记录了作用域范围内的首地址，内部使用的变量会有相应的偏移量。根据首地址和偏移量就能找到他们的内存地址。

再把C的值赋值给fun函数的返回值，思路如同a+b。

到这里，fun函数的执行完了，接下来程序代码将返回到main函数中继续执行。

现在还需要做两件事：

1、恢复main函数栈。

2、跳转到fun函数的返回地址处继续执行给m赋值的操作。

现在开始恢复到main函数栈，根据前面记录的fun函数执行后的返回地址，ebp寄存器指针指向到返回地址（之前的地址从栈中移除），esp寄存器自动退位到该作用域的栈顶位置。

此时，过程如下图所示：

此时，fun函数执行的返回值需要赋值给m，此时会将fun函数的返回地址给到eip指令寄存器，并调用赋值指令。执行完后，fun函数执行返回地址将出栈。fun函数的作用域地址将会被回收。

a,b是形参，fun函数执行完成后，a,b已经不再需要了，从栈中移除。

剩下的就只有main函数的变量了，最后执行return 0的指令，执行完成后就将main函数的栈也清空了。这个时候的返回值，没有需要跳转的返回地址，就直接退出main函数了。

一个简单的函数执行过程就结束了。

以上内容，如果有错误还请在评论区指出。

WPF 界面异常卡死？Dispatcher的死锁

Mon, 28 Sep 2020 06:35:03 +0000

前面我们有提到过多线程UI，不知道小伙伴们在用的时候有没有遇到过界面卡死的情况？或者在做其他业务的时候，使用过Dispatcher.Invoke导致卡死？

针对上面的问题，我们来举个导致卡死的例子！

就以我们此前写的多线程UI为例，贴上部分代码：

            //启动主线程以外的UI线程
            DispatcherUIThread dispatcherUIThread = new DispatcherUIThread();
            dispatcherUIThread.Start();
            //调度到UI线程上执行某个操作
            dispatcherUIThread.Dispatcher.Invoke(() =>
            {
                int j = 00;
                //再次调度到主线程，执行某个操作
                Dispatcher.Invoke(() =>
                {
                    int i = 0;
                });
            });

在程序启动的时候，我们调用上述代码，即可导致窗体卡死。

为什么会导致卡死？

这个问题的原因还有点复杂，为了简化描述，这里不会讲的太详细，大致讲下思路。

我们先来看下整个调用过程：

主线程 -> UI线程 -> 主线程。

以上代码会涉及到两个线程，并且会做线程切换。

WPF的线程调度中，有个上下文同步对象 DispatcherSynchronizationContext，继承自SynchronizationContext。

当我们在调用Dispatcher.Invoke的时候，代码内部首先会做上下文切换（注意，这个上下文切换是WPF内部实现的）。

这里贴上部分代码：

                SynchronizationContext oldSynchronizationContext = SynchronizationContext.Current;

                try
                {
                    DispatcherSynchronizationContext newSynchronizationContext;
                    if(BaseCompatibilityPreferences.GetReuseDispatcherSynchronizationContextInstance())
                    {
                        newSynchronizationContext = _defaultDispatcherSynchronizationContext;
                    }
                    else
                    {
                        if(BaseCompatibilityPreferences.GetFlowDispatcherSynchronizationContextPriority())
                        {
                            newSynchronizationContext = new DispatcherSynchronizationContext(this, priority);
                        }
                        else
                        {
                            newSynchronizationContext = new DispatcherSynchronizationContext(this, DispatcherPriority.Normal);
                        }
                    }
                    SynchronizationContext.SetSynchronizationContext(newSynchronizationContext);

                    callback();
                    return;
                }
                finally
                {
                    SynchronizationContext.SetSynchronizationContext(oldSynchronizationContext);
                }

切换完成以后，开始执行InvokeImpl，

InvokeImpl执行过程中，将会把Dispatcher对象以DispatcherOperation对象封送过去

并通过异步方式InvokeAsyncImpl将委托加入到执行队列中。

如下所示：

//operation 为 DispatcherOperation 对象。
operation._item = this._queue.Enqueue(operation.Priority, operation);

//省略…

封送完成后，接下来将会等待操作执行完成

operation.Wait();

走到这里，代码 int j = 00;已经可以执行了。

接下来，我们发现又出现了一个Dispatcher,按照上面的步骤，再执行一遍。

最后，主线程和UI线程均处于 Wait() 状态。也就是说，主线程在等UI线程返回结果，UI线程再等主线程返回结果。于是就一直等下去，然后就没有然后了……

如何解决？

要解决这个问题，我们有两种方法：

1、避免递归出现上下文切换。

2、如果一定要这么调用，那么就需要在Invoke的地方修改成异步调用方法。

修改上述代码，再次执行：

            //启动主线程以外的UI线程
            DispatcherUIThread dispatcherUIThread = new DispatcherUIThread();
            dispatcherUIThread.Start();
            //调度到UI线程上执行某个操作
            dispatcherUIThread.Dispatcher.Invoke(() =>
            {
                int j = 00;
                //再次调度到主线程，执行某个操作
                //此处修改为异步队列，异步队列是不需要等待返回，那么函数会先返回到原有的上下文以后，再执行异步队列中的函数
                Dispatcher.InvokeAsync(() =>
                {
                    int i = 0;
                });
            });

程序可正常启动。

WPF 依赖项属性的AddOwner与OverrideMetadata区别

Mon, 28 Sep 2020 05:35:03 +0000

WPF中的依赖项属性的AddOwner与OverrideMetadata有何区别？什么情况下使用AddOwner?什么情况下使用OverrideMetadata呢？

依赖项属性是WPF框架中非常核心的属性，相比传统属性提供了丰富的功能。如：内置绑定支持，渲染行为支持，动画支持等等。

1、 `DependencyProperty.AddOwner`

顾名思义，AddOwner，就是给当前的依赖项属性添加“所有者”或者“拥有者”。也就是说，它的主要作用是给新的类型，定义相同的依赖项属性，从而省去了我们自己通过DependencyProperty.Registry方式进行注册。实际上两者的效果是差不多的，都是给指定的类型定义一个依赖项属性。

AddOwner 接受的参数是 Type ,通过AddOwner方法，只需要传入我们注册依赖项属性的类型就可以了。

举例：

假设我们要给TestClass定义一个Background依赖项属性。而TestClass也是继承自FrameworkElement，同时假设他的Background属性的作用和Border的Background属性是相同的。

那么这个时候，我们完全没有必要重新去注册一个依赖项属性，直接用Border.BackgroundProperty.AddOwner(typeof(TestClass))即可。

所以我们在使用AddOwner方法时，是我们想要注册的属性，在现有的依赖项属性中已经存在注册了，并且两者的行为功能一致的情况下即可使用。

2、 `DependencyProperty.OverrideMetadata`

同样的，OverrideMetadata从字面上看，是重写元数据。它主要是用于现有的依赖项属性的元数据进行修改。

实际上，OverrideMetadata内部的实现是一个委托链，当我们在重写它的时候，它只是在委托链上增加了一个委托方法。当我们方法在执行的时候，我们最终的实现方法，会覆盖部分已定义的功能实现。

所以，OverrideMetadata主要使用场景在于，我们要修改依赖项属性的一些默认行为。

我们在使用OverrideMetadata方法的过程中，需要注意，元数据需要跟积累的元数据类型相同。

如基类元数据类型是FrameworkPropertyMetadata,那我们重写的时候也必须是这个类型。默认情况下是PropertyMetadata。这种情况下会导致错误，需要注意一下。

3、两者区别

AddOwner是OverrideMetadata和添加PropertyFromName哈希表的合集，OverrideMetadata是把当前元数据和继承体系中最近的父类的依赖属性的元数据PropertyChangedCallback进行合并，CoerceCallback进行取舍。AddOwner调用的过程中会调用OverrideMetadata方法。

部分参考代码：

        //AddOwner部分代码
        public DependencyProperty AddOwner(Type ownerType, PropertyMetadata typeMetadata)
        {
            if (ownerType == null)
            {
                throw new ArgumentNullException("ownerType");
            }
            FromNameKey key = new FromNameKey(this.Name, ownerType);
            lock (Synchronized)
            {
                if (PropertyFromName.Contains(key))
                {
                    throw new ArgumentException(MS.Internal.WindowsBase.SR.Get("PropertyAlreadyRegistered", new object[] { this.Name, ownerType.Name }));
                }
            }
            if (typeMetadata != null)
            {
                this.OverrideMetadata(ownerType, typeMetadata);
            }
            lock (Synchronized)
            {
                PropertyFromName.set_Item(key, this);
            }
            return this;
        }


        public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata)
        {
            //省略
            //部分代码
            DependencyObjectType dType = DependencyObjectType.FromSystemType(forType);
            PropertyMetadata baseMetadata = this.GetMetadata(dType.BaseType);
            //合并PropertyMetaChanged的事件
            if (baseMetadata.PropertyChangedCallback != null)
            {
                Delegate[] invocationList = baseMetadata.PropertyChangedCallback.GetInvocationList();
                if (invocationList.Length > 0)
                {
                    System.Windows.PropertyChangedCallback a = (System.Windows.PropertyChangedCallback) invocationList[0];
                    for (int i = 1; i < invocationList.Length; i++)
                    {
                        a = (System.Windows.PropertyChangedCallback) Delegate.Combine(a, (System.Windows.PropertyChangedCallback) invocationList[i]);
                    }
                    a = (System.Windows.PropertyChangedCallback) Delegate.Combine(a, this._propertyChangedCallback);
                    this._propertyChangedCallback = a;
                }
            }
            if (this._coerceValueCallback == null)
            {
                //委托直接覆盖
                this._coerceValueCallback = baseMetadata.CoerceValueCallback;
            }
            if (this._freezeValueCallback == null)
            {
                this._freezeValueCallback = baseMetadata.FreezeValueCallback;
            }
            //省略
        }

总的来讲，如果是需要给依赖项属性添加新的数据类型，就可以直接用AddOwner;如果是想要更改默认的行为，那么可以用OverrideMetadata;如果要定义的依赖项属性框架没有提供，那么就重新注册一个即可。

WPF 截图功能的实现

Mon, 28 Sep 2020 04:35:03 +0000

WPF截图功能，网上很多，但是面对Visual不在视觉树上面怎么截图呢？

思路很简单，我们只需要在截图前，将Visual做个提前布局即可。

我们在截图的过程中，会发现没有在视觉树上的元素的实际大小是0，这个时候我们就无法正确的截图。所以这种情况下，我们要么选择高宽属性进行赋值，要么由外部参数来决定到底需要设置多大的宽高。

如果元素存在一定的缩放，还需要将缩放比考虑进去。

具体代码如下：

        public static BitmapSource Snap(this FrameworkElement element, double scale, int desiredHeight, int desiredWidth)
        {
            var width = (int)(element.ActualWidth);
            if (width == 0)
            {
                width = desiredWidth;
            }

            var height = (int)(element.ActualHeight);
            if (height == 0)
            {
                height = desiredHeight;
            }

            if (!element.IsLoaded)
            {
                element.Arrange(new Rect(0, 0, width, height));
                element.Measure(new Size(width, height));
            }

            var scaleWidth = (int)(width * scale);
            var scaleHeight = (int)(height * scale);

            var bitmap = new RenderTargetBitmap(scaleWidth, scaleHeight, 96.0, 96.0, PixelFormats.Pbgra32);
            var rectangle = new Rectangle
            {
                Width = scaleWidth,
                Height = scaleHeight,

                Fill = new VisualBrush(element)
                {
                    Viewbox = new Rect(0, 0, width, height),
                    ViewboxUnits = BrushMappingMode.Absolute,
                }
            };

            rectangle.Measure(new Size(scaleWidth, scaleHeight));
            rectangle.Arrange(new Rect(new Size(scaleWidth, scaleHeight)));

            bitmap.Render(rectangle);
            return bitmap;
        }

其他细节，各位看官可自行优化。比如:DPI。

WPF 手把手教你写跨线程UI控件

Mon, 28 Sep 2020 03:35:03 +0000

多线程UI，是winform里面是一件非常简单的事情，然而在WPF里面，想要做到跨线程的UI渲染，可就没那么简单了。

我们知道，在Winform中，我们只需要在多线程里直接new一个新的窗口就可以实现多线程UI了。这对我们解决UI卡顿的问题有一定的帮助。

今天我们重点来学习一下，在WPF程序中，怎么去实现一个跨线程UI控件。

基本思路

在WPF中，负责线程调度的管理器是Dispatcher,UI线程必须要在主线程中执行，而且主线程必须是单线程实例。

UI线程实际上是运行在一个消息循环机制中，有DispatcherFrame以及消息处理，转发等机制。

所以我们要实现多线程UI，首先需要有一个专门的UI消息处理线程；其次需要将多线程上的UI渲染合并到现有主线程上去，以便可以加载到其他的主线程UI窗体上。

具体实现方法

定义UI线程，直接看代码

    /// <summary>
    /// 管理 DynamicRenderer 线程
    /// </summary>
    public class DispatcherUIThread : IDisposable
    {
        /// <summary>
        /// 启动新的线程
        /// </summary>
        public void Start()
        {
            _syncThreadStartResetEvent = new AutoResetEvent(false);
            var dynamicRendererThread = new Thread(InternalRunning)
            {
                Priority = ThreadPriority.Highest,
                IsBackground = true,
            };
            //设置线程为单线程
            dynamicRendererThread.SetApartmentState(ApartmentState.STA);
            dynamicRendererThread.Start();
            //等待Dispatcher已启动
            _syncThreadStartResetEvent.WaitOne();
            _syncThreadStartResetEvent.Dispose();
            _syncThreadStartResetEvent = null;
        }

        private AutoResetEvent _syncThreadStartResetEvent;

        /// <summary>
        /// 运行笔的线程
        /// </summary>
        public Dispatcher Dispatcher { get; private set; }

        [SecurityCritical]
        private void InternalRunning()
        {
            Dispatcher = Dispatcher.CurrentDispatcher;
            _syncThreadStartResetEvent.Set();
            //开启消息循环
            Dispatcher.Run();
        }

        /// <inheritdoc />
        public void Dispose()
        {
            Close();
            Dispatcher = null;
        }

        /// <summary>
        /// 关闭线程
        /// </summary>
        public void Close()
        {
            Dispatcher.InvokeShutdown();
        }
    }

对此段代码有不明白的，请在评论区留言。

跨线程UI合并

跨线程UI合并需要用到俩个关键类：HostVisual和VisualTarget。

HostVisual：用于承载多线程UI的子元素宿主，该Visual处于主线程上。 VisualTarget：用于衔接主线程和多线程UI的边界处理器。

代码如下：

    //异步UI容器
    public class AsyncUIContainer : UIElement
    {
        public AsyncUIContainer()
        {
            Initialize();
        }

        HostVisual hostVisual;
        ContainerVisual Container;
        Rect _hitTestRect = Rect.Empty;

        /// <summary>
        /// 
        /// </summary>
        void Initialize()
        {
            //定义主线程UI宿主
            hostVisual = new HostVisual();
            //开启UI线程
            var thread = new DispatcherUIThread();
            thread.Start();

            thread.Dispatcher.Invoke(() =>
            {
                //在新的UI线程中，初始化Visual容器
                Container = new ContainerVisual();
                //先此线程的UI和主线程UI衔接
                new VisualTarget(hostVisual)
                {
                    RootVisual = Container
                };
            });
            //将UI宿主，添加到视觉树
            AddVisualChild(hostVisual);
        }

        //因为是多线程上的UI，所以需要使用该UI所在线程才可调度
        public Dispatcher UIDispatcher
        {
            get
            {
                return Container.Dispatcher;
            }
        }

        public VisualCollection Children
        {
            get
            {
                return Container.Children;
            }
        }

        //重写命中测试，让多线程UI能够响应基础输入
        protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
        {
            if (_hitTestRect.Contains(hitTestParameters.HitPoint))
            {
                return new PointHitTestResult(this, hitTestParameters.HitPoint);
            }

            return base.HitTestCore(hitTestParameters);
        }

        //重写布局系统，让多线程UI元素能正常布局
        protected override Size MeasureCore(Size availableSize)
        {
            if (availableSize.Height > 0 && availableSize.Width > 0 && !(double.IsInfinity(availableSize.Height) || double.IsInfinity(availableSize.Width)))
            {
                return availableSize;
            }

            return new Size(200, 200);
        }

        //重写布局系统，让多线程UI元素能正常布局
        protected override void ArrangeCore(Rect finalRect)
        {
            base.ArrangeCore(finalRect);

            RenderSize = finalRect.Size;
            _hitTestRect = finalRect;
        }

        //指定起Visual的数量
        protected override int VisualChildrenCount => 1;
        //指定需要渲染的Visual对象
        protected override Visual GetVisualChild(int index)
        {
            return hostVisual;
        }
    }

基础实现方法就差不多了，大家可以根据自己需要进行魔改。

如何使用

多线程的UI控件我们已经写好了，我们只需要将AsyncUIContainer添加到我们的Xaml中。

对于其子元素，我们需要在后台代码中添加（想要在Xaml中添加也可以，需要自己实现Xaml扩展代码，让其支持直接在xaml中编辑）。

            asyncUIContainer.UIDispatcher.InvokeAsync(() =>
            {
                var Rectangle = new Rectangle()
                 {
                    Fill=Brushes.Red,
                    Height=400,
                    Width=400,
                 };

                //这里必须调用Arrange方法，否则界面不会渲染。
                //如果使用DrawingVisual,那么需要调用DrawingVisual的RenderOpen()方法，并主动调用渲染的绘制原语才可正常渲染。
                //下面是个DrawingVisual的例子
                //public void Draw()
                //{
                //    using var drawingContext = RenderOpen();
                //    drawingContext.DrawGeometry(_fillBrush, null, DrawingGeometry);
                //}

                rectangle.Arrange(new Rect(0, 0, 400, 400));
                asyncUIContainer.Children.Add(rectangle);
            });

通过以上就可以显示我们的多线程UI了。

在实际业务中，如果有遇到卡主线程UI的场景，便有用武之地了。

WPF 如何解决窗口全屏导致的像素偏差

Mon, 28 Sep 2020 02:35:03 +0000

工作忙，博客都忘了写。很多零散的知识点，虽然比较陈旧，发现还是很多人没有遇到过。今天就分享一下，WPF的窗体全屏过程中出现的像素偏差问题的解决方法。

什么是WPF窗体全屏像素偏差？

WPF窗体全屏像素偏差指的是我们的窗体全屏后，左上角的坐标（0，0）并不能在显示区域中显示出来。

怎么出现？

我们新建一个WPF项目，添加一个新的窗体（如：MainWindows.xaml），设置窗体属性WindowState="Maximized",AllowsTransparency="True",WindowStyle="None"。

这几项属性的设置，表示自定义的全屏窗体（这里要注意，一定要设置允许背景透明选项，设置此属性才会引发像素偏差问题）。

这个时候，我们在窗体中定义一个Border,并设置边框粗细和颜色。

    <Border BorderBrush="Red" BorderThickness="1"/>

运行查看显示效果：

我们会发现，窗体看不到红色的边框（比较简单，这儿就不贴图了）。

通过snoop工具我们可以发现，窗口的大小并不是全屏大小，实际上会大于我们的分辨率大小。

以本机1920*1080分辨率 125%DPI 为例。

窗口期望大小为：（1536 * 864）

窗体实际大小为：（1548.800… * 876.800…）

窗口的实际大小是大于期望大小的，我们的红框就自然而然看不到了！

为什么会这样？

因为窗体默认的ResizeMode是CanResize，系统会自动调整窗体大小。

默认窗体都是带有标题栏，系统会根据标题栏去计算客户区的大小，而CanResize的设置主要是用于带有标题栏的场景。

所以在这种情况下，系统渲染的窗体大小，实际上会大于我们期望的窗体大小。

系统的计算逻辑，如果有兴趣，大家可深入研究！

如何解决？

解决方法其实很简单，我们只需要将ResizeMode修改为NoResize即可解决此问题。

显示效果：

WPF 如何处理VisualBrush停止更新问题

Mon, 28 Sep 2020 01:35:03 +0000

工作忙，博客都忘了写。很多零散的知识点，虽然比较陈旧，发现还是很多人没有遇到过。今天就分享一下，WPF 如何处理VisualBrush停止更新问题。

WPF的VisualBrush相信很多同学都有用过，他可以很方便的将我们的Visual作为背景显示到另外一个Visual上面。

通常情况下，我们的VisualBrush都是在当前界面上实时显示的，这种情况，他可以工作的很好。但是如果我们需要镜像的Visual不在视觉树上面呢？

实际应用场景举例

我们需要做一个带有预览功能的控件，分别表示WPF对于的不同的画布（Slide)页面。而当前显示的页面（Slide)只有一个,但是作为预览页面来讲，他需要显示所有的页面。

实现方法简单的有以下两种：

使用VisualBrush做动态跟踪。
截图。

截图方案存在以下缺点：

截图本身性能差
需要经常刷新
占用内存

所以我们就不用截图方案了。

用VisualBrush我们会发现未在视觉树上的预览图和我们实际的Visual显示可能会不一致。

不在视觉树上如图所示：

在视觉树上以后，如图所示：

我们会发现，缩略图显示的并不是整个画布的全貌，而是里面的部分放大的显示效果。

这里的主要原因是因为画布的宽度和高度是Double.NaN。所以VisualBrush也是根据可渲染的子元素来进行布局计算，显示的内容就不一致。

解决方法

解决此问题有两种思路：

给画布设置固定的宽高值。
给画布添加一个宽高正确的子元素。

另外对于画刷不更新的问题，这里就不贴图了。解决思路也很简单，只需要对目标背景重新赋值即可解决。

    //item表示一个包含Slide的对象，给预览控件做绑定的
    var tmp = item.Slide;
    item.Slide = null;
    item.Slide = tmp;

如有遇到其他问题，请在评论区留言。

UWP 如何获取窗口句柄

Tue, 07 Jul 2020 14:35:03 +0000

我们知道，Winform或者WPF都有句柄。只不过WPF的句柄只有Window窗体才有，并且需要通过额外的方法来获取。然而，UWP程序竟然没有提供类似WPF获取句柄的方法。难道UWP就没有窗口句柄吗？今天我们就来看下如何获取UWP的窗口句柄。

先来看下WPF获取窗口句柄的方法：

//引入命名空间
using System.Windows.Interop;

//获取句柄，this表示一个window实例
new WindowInteropHelper(this).Handle

WPF获取窗口句柄看似挺简单的，只需要使用WindowInteropHelper对象即可获取。

再来看下UWP中获取窗口句柄的方法：

    //定义获取窗口句柄的接口

    [ComImport, Guid("45D64A29-A63E-4CB6-B498-5781D298CB4F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface ICoreWindowInterop
    {
        IntPtr WindowHandle { get; }
        bool MessageHandled { set; }
    }

    //获取窗口句柄
    //获取当前线程的活动窗口，这里要使用动态类型解析，不然后面无法强转

    public IntPtr GetCurrentWindowHandle()
    {
        dynamic corewin = Windows.UI.Core.CoreWindow.GetForCurrentThread();
        var interop = (ICoreWindowInterop)corewin;
        return interop.WindowHandle;
    }
    

很明显可以看出，UWP获取窗口句柄的方法，比使用WPF获取窗口句柄的方法复杂的多。

下面推荐个查看窗口句柄的实用工具，可以帮助我们辅助测试

句柄小助手，点击此处下载

Inno Setup基本用法

Tue, 07 Jul 2020 13:35:03 +0000

Inno Setup 是个简单又强大的打包工具，能通过向导方式生成安装脚本，也可通过自定义编写脚本的方法增加强调的功能。今天我们就先讲讲，通过向导的方式来进行打包。

通过向导来生成安装脚本

开始制作安装脚本

设置软件基本信息，包含：软件名称，版本号，公司名称，公司站点

设置安装的默认目录位置，是否需要自定义目录。默认是在Program Files目录下

选择需要添加到安装包的文件列表，并指定启动文件路径

创建快捷方式

添加许可条例内容

设置以什么权限运行安装脚本，默认以管理员权限运行

选择语言，可惜就是没有简体中文

设置输出目录

使用预定义宏，开启就好

向导完成，可以进入到脚本页面了，这个时候如果需要更加强大的功能，可以自己修改脚本文件

根据向导，我们就生成好了安装脚本。我们只需要点击菜单栏上的编译[Build -> Compile]进行打包，通过Run来设定安装还是卸载来执行安装或者卸载操作。

Inno Setup 提供了丰富的帮助文档，可以在Help菜单中查看。

通过向导的方式进行打包非常简单，大家只需要根据向导的步骤，一步一步操作就可以完成打包了。如果针对一些额外的操作，如写注册表，环境变量，安装服务等，这个时候我们可以通过修改脚本来实现。

这里我简单列举几个项给予说明：

[Languages] 表示安装界面要显示的语言。

[Tasks] 表示安装过程中，要执行的操作。如桌面快捷方式，开始菜单栏等。

[Files] 需要添加到安装包中的文件集合

[Run] 表示安装的过程中，需要执行的操作。这里可以执行我们自己编写的安装脚本或者程序。

[UninstallRun] 表示卸载时执行。这里可以执行我们自己编写的卸载脚本或者程序。

C# 如何解决文件写权限不可访问

Tue, 07 Jul 2020 12:35:03 +0000

实际业务中，我们可能会遇到我们的安装包将程序安装在C盘Program Files目录下后，有些文件要修改或者新增会导致拒绝访问的异常。
但是我们又不想把数据放临时文件夹AppData中,那么如何解决这个问题呢？

Windows系统本身有着安全策略，在系统文件夹下是不允许随便对文件进行写操作的，除非是有管理员权限或者赋予了写的权限。

要解决以上问题，我们有两种方式：

直接给定文件或文件夹，设置权限
安装的时候，将需要进行写操作的文件或者文件夹赋予足够的控制权限

直接针对文件夹进行权限的方法如下图所示：

只需要添加EveryOne用户，并勾选完全控制，保存即可（也可以添加Users设置为完全控制）。

这种方法比较简单，我们不过多解说。主要看下我们如何通过软件代码的方式来使之生效。

具体实现如下：

/// <summary>
        ///为文件夹添加users，everyone用户组的完全控制权限
        /// </summary>
        /// <param name="dirPath"></param>
        static bool AddSecurityControll2Folder(string dirPath)
        {
            try
            {
                //获取文件夹信息
                DirectoryInfo dir = new DirectoryInfo(dirPath);
                //获得该文件夹的所有访问权限
                DirectorySecurity dirSecurity = dir.GetAccessControl(AccessControlSections.All);
                //设定文件ACL继承
                InheritanceFlags inherits = InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit;
                //添加ereryone用户组的访问权限规则 完全控制权限
                FileSystemAccessRule everyoneFileSystemAccessRule = new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow);
                //添加Users用户组的访问权限规则 完全控制权限
                //FileSystemAccessRule usersFileSystemAccessRule = new FileSystemAccessRule("Users", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow);
                dirSecurity.ModifyAccessRule(AccessControlModification.Add, everyoneFileSystemAccessRule, out bool isModified);
                //dirSecurity.ModifyAccessRule(AccessControlModification.Add, usersFileSystemAccessRule, out bool isModified);
                //设置访问权限
                dir.SetAccessControl(dirSecurity);

                return isModified;
            }
            catch (Exception)
            {
                return false;
            }
        }

注意:

执行权限更改时，需要依赖管理员权限，所以我们在修改权限的时候，直接调用以上代码是会抛异常的。 如果我们的应用程序不具备管理员权限，那么我们不应该在应用程序中直接去修改它。我们可以在安装的时候，对它进行权限更改，因为安装的时候，可以以管理权限运行安装。

在下个篇章，将以Inno Setup安装工具简单描述下，如何在安装模式下，赋予权限。

UWP 模拟鼠标或指针操作的实现方法

Tue, 07 Jul 2020 06:35:03 +0000

此前我们将了win32传统的模拟鼠标的方法，今天我们再来看下在UWP应用程序中，如何模拟鼠标事件。

在UWP应用中，要模拟鼠标或者触摸事件，微软有特意提供相应的方法给我们使用。在命名空间Windows.UI.Input.Preview下。先来看下如何使用它：

        //关闭模拟器
        public static void Dispose()
        {
            if (_inputInjector == null) return;

            _inputInjector.UninitializeTouchInjection();
            _inputInjector = null;
        }

        //模拟鼠标左键单击
        public static void LeftButtonMouseDown()
        {
            Dispose();
            //尝试创建一个注入器
            _inputInjector = InputInjector.TryCreate();
            //初始化触摸注入器
            _inputInjector.InitializeTouchInjection(InjectedInputVisualizationMode.Default);
            //注入鼠标操作
            _inputInjector.InjectMouseInput(new List<InjectedInputMouseInfo>
                         {
                            new InjectedInputMouseInfo()
                            {
                                MouseOptions=InjectedInputMouseOptions.LeftDown
                            }
                         });
        }

        //模拟触摸操作
        public static void PointerPressed(uint pointerId, Point position, Windows.Foundation.Rect rect)
        {
            
            Dispose();

            _inputInjector = InputInjector.TryCreate();

            if (_inputInjector != null)
            {
                _inputInjector.InitializeTouchInjection(InjectedInputVisualizationMode.Default);

                //获取当前窗体的边界值
                Windows.Foundation.Rect appBounds = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().VisibleBounds;

                List<InjectedInputTouchInfo> touchData =
                    new List<InjectedInputTouchInfo>
                    {
                        new InjectedInputTouchInfo
                        {
                            //设置触摸范围
                            Contact =new InjectedInputRectangle{
                                Bottom= (int)rect.Bottom,
                                Left=(int) rect.Left,
                                Top=(int) rect.Top,
                                Right=(int) rect.Right
                            },
                            PointerInfo = new InjectedInputPointerInfo
                            {
                                PointerId = pointerId,
                                //设置属性值
                                PointerOptions =   
                                InjectedInputPointerOptions.PointerDown|                             
                                InjectedInputPointerOptions.InContact |
                                InjectedInputPointerOptions.CaptureChanged,
                                TimeOffsetInMilliseconds = 0,
                                //设置触摸坐标，这里需要考虑下多屏情况
                                PixelLocation = new InjectedInputPoint
                                {
                                    PositionX = (int)appBounds.Left+ (int)position.X ,
                                    PositionY = (int)appBounds.Top+ (int)position.Y
                                }
                        },
                        //设置压感值
                        Pressure = 0.5,
                        TouchParameters =
                            InjectedInputTouchParameters.Pressure |
                            InjectedInputTouchParameters.Contact
                    }
                };

                //触发触摸按下操作
                _inputInjector.InjectTouchInput(touchData);

                //触发抬起操作
                touchData = new List<InjectedInputTouchInfo>
                {
                    new InjectedInputTouchInfo
                    {
                        PointerInfo = new InjectedInputPointerInfo
                        {
                            PointerId = pointerId,
                            PointerOptions = InjectedInputPointerOptions.PointerUp
                        }
                    }
                };
                
                _inputInjector.InjectTouchInput(touchData);
            }
        }

说明：

InjectedInputMouseInfo 表示鼠标的相关操作参数，具体参数根据不同的鼠标定义而不同。触发鼠标按下事件时，鼠标是以当前鼠标的坐标作为传递值，如果需要新的坐标位置，可通过DeltaX和DeltaY参数来传递坐标的偏移量。使用该方法时，要注意多屏情况，避免触摸的点不是想要的坐标点。 在模拟触摸按下操作时，会同时触发抬起操作，即便是没有发送抬起信息。

通过以上方法，我们就可以模拟触摸相关的模拟动作了。但是放到UWP程序中运行时，我们会发现程序会报错：拒绝访问！！ 这是因为UWP的安全策略问题，不允许使用，所以我们需要告诉程序，需要开启该功能。

开启方法：

在启动项目中，以文本方式打开Package.appxmanifest文件。在文件命名空间中添加xmlns:restcap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"命名空间的引用。在Capabilities节点中添加<restcap:Capability Name="inputInjectionBrokered" />。这里注意，是设置为inputInjectionBrokered的属性值。

<?xml version="1.0" encoding="utf-8"?>

<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  
  xmlns:restcap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"

  IgnorableNamespaces="uap mp">

	<!-- 此处省略………… -->

	<Capabilities>
		<Capability Name="internetClient" />

		<restcap:Capability Name="inputInjectionBrokered" />

	</Capabilities>
</Package>

参考文献： https://docs.microsoft.com/en-us/windows/uwp/design/input/input-injection

C# 虚拟鼠标的实现方法

Tue, 07 Jul 2020 03:35:03 +0000

之前的篇章里面，我们讲过了虚拟键盘的使用，本篇补充一下虚拟鼠标的使用。

虚拟鼠标在不同的使用环境下，需要使用不同的实现方法。如在模拟鼠标移动时，我们会存在两种情况：

模拟鼠标移动，真实鼠标并不做移动
模拟鼠标移动，鼠标也要跟随移动

在传统的win32应用中，可以有以下两种方式实现：

使用mouse_event方法，实现模拟硬件鼠标操作
使用SendMessage方法，通过给指定的窗口或控件句柄发送消息，模拟鼠标操作

二者区别

mouse_event

鼠标,键盘等外设接入主机，实际就相当于接入了IO设备。而mouse_event事件，则不是简单的发消息，它是向I/O队列插入鼠标事件；所以该事件可以模拟硬件的具体的各种操作。
例如：我们在通过mouse_event移动鼠标时，鼠标的Cursor图标也会跟着做偏移,跟我们直接操作鼠标的效果是一致的。
然而对于具体的窗口或者控件的事件的触发，就必须要求在模拟操作之前，需要触发的控件或者窗口需要先捕获焦点。

具体实现方法如下：

      //引用user32.dll，指定 mouse_event 的方法
      [DllImport("user32.dll")]
      private static extern void mouse_event(int dwFlags, int dx, int dy, int dwData, int dwExtraInfo);

      //模拟鼠标点击
      public static void MouseDown(int x, int y)
      {
            //模拟鼠标按下操作
            mouse_event(MouseMessage.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0);
      }
      
      //相关动作枚举值

      public enum MouseMessage
      {
            //移动鼠标 
            MOUSEEVENTF_MOVE = 0x0001,      
            //模拟鼠标左键按下 
            MOUSEEVENTF_LEFTDOWN = 0x0002, 
            //模拟鼠标左键抬起 
            MOUSEEVENTF_LEFTUP = 0x0004, 
            //模拟鼠标右键按下 
            MOUSEEVENTF_RIGHTDOWN = 0x0008, 
            //模拟鼠标右键抬起 
            MOUSEEVENTF_RIGHTUP = 0x0010, 
            //模拟鼠标中键按下 
            MOUSEEVENTF_MIDDLEDOWN = 0x0020, 
            //模拟鼠标中键抬起 
            MOUSEEVENTF_MIDDLEUP = 0x0040, 
            //标示是否采用绝对坐标 
            MOUSEEVENTF_ABSOLUTE = 0x8000, 
      }

参数说明：

dx：指定鼠标沿x轴的绝对位置或者从上次鼠标事件产生以来移动的数量，依赖于MOUSEEVENTF_ABSOLUTE的设置。给出的绝对数据作为鼠标的实际X坐标；给出的相对数据作为移动的mickeys数。一个mickey表示鼠标移动的数量，表明鼠标已经移动。

dy：指定鼠标沿y轴的绝对位置或者从上次鼠标事件产生以来移动的数量，依赖于MOUSEEVENTF_ABSOLUTE的设置。给出的绝对数据作为鼠标的实际y坐标，给出的相对数据作为移动的mickeys数。

dwData：如果dwFlags为MOUSEEVENTF_WHEEL，则dwData指定鼠标轮移动的数量。正值表明鼠标轮向前转动，即远离用户的方向；负值表明鼠标轮向后转动，即朝向用户。一个轮击定义为WHEEL_DELTA，即120。

如果dwFlagsS不是MOUSEEVENTF_WHEEL，则dWData应为零。

dwExtralnfo：指定与鼠标事件相关的附加32位值。应用程序调用函数GetMessageExtraInfo来获得此附加信息。

返回值：无。

程序中我们直接调用mouse_event函数就可以了 mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 500, 500, 0, 0);

1、这里是鼠标左键按下和松开两个事件的组合即一次单击： mouse_event (MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 )

2、模拟鼠标右键单击事件： mouse_event (MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0 )

3、两次连续的鼠标左键单击事件 构成一次鼠标双击事件： mouse_event (MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 ) mouse_event (MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 )

4、使用绝对坐标 MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 500, 500, 0, 0

需要说明的是，如果没有使用MOUSEEVENTF_ABSOLUTE，函数默认的是相对于鼠标当前位置的点，如果dx，和dy，用0，0表示，这函数认为是当前鼠标所在的点。５、直接设定绝对坐标并单击 mouse_event(MOUSEEVENTF_LEFTDOWN, X * 65536 / 1024, Y * 65536 / 768, 0, 0); mouse_event(MOUSEEVENTF_LEFTUP, X * 65536 / 1024, Y * 65536 / 768, 0, 0); 其中X，Y分别是你要点击的点的横坐标和纵坐标

sendmessage

通过PostMessage或者SendMessage发送消息的方式实现的模拟动作，实际上只是简单调用了该句柄下的消息回调函数而已。
之所以给具体控件发送点击事件有效，因为在A程序的代码中，有对鼠标点击事件的逻辑处理。发送该消息，A程序就进入了该控件的消息处理回调函数中。我们的应用程序，如winform，wpf都是基于消息循环机制，相当于我们模拟的动作，是给消息循环插入消息，程序通过循环获取相关的消息后，执行相应操作并得到对应的结果。所以该操作，必须要指定窗口句柄，系统才知道需要将消息发送至哪里。

具体代码如下：

        /// <summary>
        /// 
        /// </summary>
        /// <param name="hWnd">handle to destination window</param>
        /// <param name="Msg">message</param>
        /// <param name="wParam">first message parameter</param>
        /// <param name="lParam">second message parameter</param>
        /// <returns></returns>
        [DllImport("user32.dll", EntryPoint = "SendMessage")]


        private static extern int SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

        public static int LogicMouseDown(IntPtr hWnd)
        {
            return SendMessage(hWnd, WMessages.WM_LBUTTONDOWN, IntPtr.Zero, IntPtr.Zero);
        }

      public enum WMessages
       {
            //创建一个窗口   
            WM_CREATE = 0x01,   
            //当一个窗口被破坏时发送   
            WM_DESTROY = 0x02,   
            //移动一个窗口   
            WM_MOVE = 0x03,   
            //改变一个窗口的大小   
            WM_SIZE = 0x05,   
            //一个窗口被激活或失去激活状态   
            WM_ACTIVATE = 0x06,   
            //一个窗口获得焦点   
            WM_SETFOCUS = 0x07,   
            //一个窗口失去焦点   
            WM_KILLFOCUS = 0x08,   
            //一个窗口改变成Enable状态   
            WM_ENABLE = 0x0A,   
            //设置窗口是否能重画   
            WM_SETREDRAW = 0x0B,   
            //应用程序发送此消息来设置一个窗口的文本   
            WM_SETTEXT = 0x0C,   
            //应用程序发送此消息来复制对应窗口的文本到缓冲区   
            WM_GETTEXT = 0x0D,   
            //得到与一个窗口有关的文本的长度（不包含空字符）   
            WM_GETTEXTLENGTH = 0x0E,   
            //要求一个窗口重画自己   
            WM_PAINT = 0x0F,   
            //当一个窗口或应用程序要关闭时发送一个信号   
            WM_CLOSE = 0x10,   
            //当用户选择结束对话框或程序自己调用ExitWindows函数   
            WM_QUERYENDSESSION = 0x11,   
            //用来结束程序运行   
            WM_QUIT = 0x12,   
            //当用户窗口恢复以前的大小位置时，把此消息发送给某个图标   
            WM_QUERYOPEN = 0x13,   
            //当窗口背景必须被擦除时（例在窗口改变大小时）   
            WM_ERASEBKGND = 0x14,   
            //当系统颜色改变时，发送此消息给所有顶级窗口   
            WM_SYSCOLORCHANGE = 0x15,   
            //当系统进程发出WM_QUERYENDSESSION消息后，此消息发送给应用程序，通知它对话是否结束   
            WM_ENDSESSION = 0x16,   
            //当隐藏或显示窗口是发送此消息给这个窗口   
            WM_SHOWWINDOW = 0x18,   
            //发此消息给应用程序哪个窗口是激活的，哪个是非激活的   
            WM_ACTIVATEAPP = 0x1C,   
            //当系统的字体资源库变化时发送此消息给所有顶级窗口   
            WM_FONTCHANGE = 0x1D,   
            //当系统的时间变化时发送此消息给所有顶级窗口   
            WM_TIMECHANGE = 0x1E,   
            //发送此消息来取消某种正在进行的摸态（操作）   
            WM_CANCELMODE = 0x1F,   
            //如果鼠标引起光标在某个窗口中移动且鼠标输入没有被捕获时，就发消息给某个窗口   
            WM_SETCURSOR = 0x20,   
            //当光标在某个非激活的窗口中而用户正按着鼠标的某个键发送此消息给//当前窗口   
            WM_MOUSEACTIVATE = 0x21,   
            //发送此消息给MDI子窗口//当用户点击此窗口的标题栏，或//当窗口被激活，移动，改变大小   
            WM_CHILDACTIVATE = 0x22,   
            //此消息由基于计算机的训练程序发送，通过WH_JOURNALPALYBACK的hook程序分离出用户输入消息   
            WM_QUEUESYNC = 0x23,   
            //此消息发送给窗口当它将要改变大小或位置   
            WM_GETMINMAXINFO = 0x24,   
            //发送给最小化窗口当它图标将要被重画   
            WM_PAINTICON = 0x26,   
            //此消息发送给某个最小化窗口，仅//当它在画图标前它的背景必须被重画   
            WM_ICONERASEBKGND = 0x27,   
            //发送此消息给一个对话框程序去更改焦点位置   
            WM_NEXTDLGCTL = 0x28,   
            //每当打印管理列队增加或减少一条作业时发出此消息    
            WM_SPOOLERSTATUS = 0x2A,   
            //当button，combobox，listbox，menu的可视外观改变时发送   
            WM_DRAWITEM = 0x2B,   
            //当button, combo box, list box, list view control, or menu item 被创建时   
            WM_MEASUREITEM = 0x2C,   
            //此消息有一个LBS_WANTKEYBOARDINPUT风格的发出给它的所有者来响应WM_KEYDOWN消息    
            WM_VKEYTOITEM = 0x2E,   
            //此消息由一个LBS_WANTKEYBOARDINPUT风格的列表框发送给他的所有者来响应WM_CHAR消息    
            WM_CHARTOITEM = 0x2F,   
            //当绘制文本时程序发送此消息得到控件要用的颜色   
            WM_SETFONT = 0x30,   
            //应用程序发送此消息得到当前控件绘制文本的字体   
            WM_GETFONT = 0x31,   
            //应用程序发送此消息让一个窗口与一个热键相关连    
            WM_SETHOTKEY = 0x32,   
            //应用程序发送此消息来判断热键与某个窗口是否有关联   
            WM_GETHOTKEY = 0x33,   
            //此消息发送给最小化窗口，当此窗口将要被拖放而它的类中没有定义图标，应用程序能返回一个图标或光标的句柄，当用户拖放图标时系统显示这个图标或光标   
            WM_QUERYDRAGICON = 0x37,   
            //发送此消息来判定combobox或listbox新增加的项的相对位置   
            WM_COMPAREITEM = 0x39,   
            //显示内存已经很少了   
            WM_COMPACTING = 0x41,   
            //发送此消息给那个窗口的大小和位置将要被改变时，来调用setwindowpos函数或其它窗口管理函数   
            WM_WINDOWPOSCHANGING = 0x46,   
            //发送此消息给那个窗口的大小和位置已经被改变时，来调用setwindowpos函数或其它窗口管理函数   
            WM_WINDOWPOSCHANGED = 0x47,   
            //当系统将要进入暂停状态时发送此消息   
            WM_POWER = 0x48,   
            //当一个应用程序传递数据给另一个应用程序时发送此消息   
            WM_COPYDATA = 0x4A,   
            //当某个用户取消程序日志激活状态，提交此消息给程序   
            WM_CANCELJOURNA = 0x4B,   
            //当某个控件的某个事件已经发生或这个控件需要得到一些信息时，发送此消息给它的父窗口    
            WM_NOTIFY = 0x4E,   
            //当用户选择某种输入语言，或输入语言的热键改变   
            WM_INPUTLANGCHANGEREQUEST = 0x50,   
            //当平台现场已经被改变后发送此消息给受影响的最顶级窗口   
            WM_INPUTLANGCHANGE = 0x51,   
            //当程序已经初始化windows帮助例程时发送此消息给应用程序   
            WM_TCARD = 0x52,   
            //此消息显示用户按下了F1，如果某个菜单是激活的，就发送此消息个此窗口关联的菜单，否则就发送给有焦点的窗口，如果//当前都没有焦点，就把此消息发送给//当前激活的窗口   
            WM_HELP = 0x53,   
            //当用户已经登入或退出后发送此消息给所有的窗口，//当用户登入或退出时系统更新用户的具体设置信息，在用户更新设置时系统马上发送此消息   
            WM_USERCHANGED = 0x54,   
            //公用控件，自定义控件和他们的父窗口通过此消息来判断控件是使用ANSI还是UNICODE结构   
            WM_NOTIFYFORMAT = 0x55,   
            //当用户某个窗口中点击了一下右键就发送此消息给这个窗口   
            // WM_CONTEXTMENU = ??,   
            //当调用SETWINDOWLONG函数将要改变一个或多个 窗口的风格时发送此消息给那个窗口   
            WM_STYLECHANGING = 0x7C,   
            //当调用SETWINDOWLONG函数一个或多个 窗口的风格后发送此消息给那个窗口   
            WM_STYLECHANGED = 0x7D,   
            //当显示器的分辨率改变后发送此消息给所有的窗口   
            WM_DISPLAYCHANGE = 0x7E,   
            //此消息发送给某个窗口来返回与某个窗口有关连的大图标或小图标的句柄   
            WM_GETICON = 0x7F,   
            //程序发送此消息让一个新的大图标或小图标与某个窗口关联   
            WM_SETICON = 0x80,   
            //当某个窗口第一次被创建时，此消息在WM_CREATE消息发送前发送   
            WM_NCCREATE = 0x81,   
            //此消息通知某个窗口，非客户区正在销毁    
            WM_NCDESTROY = 0x82,   
            //当某个窗口的客户区域必须被核算时发送此消息   
            WM_NCCALCSIZE = 0x83,   
            //移动鼠标，按住或释放鼠标时发生   
            WM_NCHITTEST = 0x84,   
            //程序发送此消息给某个窗口当它（窗口）的框架必须被绘制时   
            WM_NCPAINT = 0x85,   
            //此消息发送给某个窗口仅当它的非客户区需要被改变来显示是激活还是非激活状态   
            WM_NCACTIVATE = 0x86,   
            //发送此消息给某个与对话框程序关联的控件，widdows控制方位键和TAB键使输入进入此控件通过应   
            WM_GETDLGCODE = 0x87,   
            //当光标在一个窗口的非客户区内移动时发送此消息给这个窗口 非客户区为：窗体的标题栏及窗 的边框体   
            WM_NCMOUSEMOVE = 0xA0,   
            //当光标在一个窗口的非客户区同时按下鼠标左键时提交此消息   
            WM_NCLBUTTONDOWN = 0xA1,   
            //当用户释放鼠标左键同时光标某个窗口在非客户区十发送此消息    
            WM_NCLBUTTONUP = 0xA2,   
            //当用户双击鼠标左键同时光标某个窗口在非客户区十发送此消息   
            WM_NCLBUTTONDBLCLK = 0xA3,   
            //当用户按下鼠标右键同时光标又在窗口的非客户区时发送此消息   
            WM_NCRBUTTONDOWN = 0xA4,   
            //当用户释放鼠标右键同时光标又在窗口的非客户区时发送此消息   
            WM_NCRBUTTONUP = 0xA5,   
            //当用户双击鼠标右键同时光标某个窗口在非客户区十发送此消息   
            WM_NCRBUTTONDBLCLK = 0xA6,   
            //当用户按下鼠标中键同时光标又在窗口的非客户区时发送此消息   
            WM_NCMBUTTONDOWN = 0xA7,   
            //当用户释放鼠标中键同时光标又在窗口的非客户区时发送此消息   
            WM_NCMBUTTONUP = 0xA8,   
            //当用户双击鼠标中键同时光标又在窗口的非客户区时发送此消息   
            WM_NCMBUTTONDBLCLK = 0xA9,   
            //WM_KEYDOWN 按下一个键   
            WM_KEYDOWN = 0x0100,   
            //释放一个键   
            WM_KEYUP = 0x0101,   
            //按下某键，并已发出WM_KEYDOWN， WM_KEYUP消息   
            WM_CHAR = 0x102,   
            //当用translatemessage函数翻译WM_KEYUP消息时发送此消息给拥有焦点的窗口   
            WM_DEADCHAR = 0x103,   
            //当用户按住ALT键同时按下其它键时提交此消息给拥有焦点的窗口   
            WM_SYSKEYDOWN = 0x104,   
            //当用户释放一个键同时ALT 键还按着时提交此消息给拥有焦点的窗口   
            WM_SYSKEYUP = 0x105,   
            //当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后提交此消息给拥有焦点的窗口   
            WM_SYSCHAR = 0x106,   
            //当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后发送此消息给拥有焦点的窗口   
            WM_SYSDEADCHAR = 0x107,   
            //在一个对话框程序被显示前发送此消息给它，通常用此消息初始化控件和执行其它任务   
            WM_INITDIALOG = 0x110,   
            //当用户选择一条菜单命令项或当某个控件发送一条消息给它的父窗口，一个快捷键被翻译   
            WM_COMMAND = 0x111,   
            //当用户选择窗口菜单的一条命令或//当用户选择最大化或最小化时那个窗口会收到此消息   
            WM_SYSCOMMAND = 0x112,   
            //发生了定时器事件   
            WM_TIMER = 0x113,   
            //当一个窗口标准水平滚动条产生一个滚动事件时发送此消息给那个窗口，也发送给拥有它的控件   
            WM_HSCROLL = 0x114,   
            //当一个窗口标准垂直滚动条产生一个滚动事件时发送此消息给那个窗口也，发送给拥有它的控件   
            WM_VSCROLL = 0x115,   
            //当一个菜单将要被激活时发送此消息，它发生在用户菜单条中的某项或按下某个菜单键，它允许程序在显示前更改菜单   
            WM_INITMENU = 0x116,   
            //当一个下拉菜单或子菜单将要被激活时发送此消息，它允许程序在它显示前更改菜单，而不要改变全部   
            WM_INITMENUPOPUP = 0x117,   
            //当用户选择一条菜单项时发送此消息给菜单的所有者（一般是窗口）   
            WM_MENUSELECT = 0x11F,   
            //当菜单已被激活用户按下了某个键（不同于加速键），发送此消息给菜单的所有者   
            WM_MENUCHAR = 0x120,   
            //当一个模态对话框或菜单进入空载状态时发送此消息给它的所有者，一个模态对话框或菜单进入空载状态就是在处理完一条或几条先前的消息后没有消息它的列队中等待   
            WM_ENTERIDLE = 0x121,   
            //在windows绘制消息框前发送此消息给消息框的所有者窗口，通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置消息框的文本和背景颜色   
            WM_CTLCOLORMSGBOX = 0x132,   
            //当一个编辑型控件将要被绘制时发送此消息给它的父窗口通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置编辑框的文本和背景颜色   
            WM_CTLCOLOREDIT = 0x133,              
            //当一个列表框控件将要被绘制前发送此消息给它的父窗口通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置列表框的文本和背景颜色   
            WM_CTLCOLORLISTBOX = 0x134,   
            //当一个按钮控件将要被绘制时发送此消息给它的父窗口通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置按纽的文本和背景颜色   
            WM_CTLCOLORBTN = 0x135,   
            //当一个对话框控件将要被绘制前发送此消息给它的父窗口通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置对话框的文本背景颜色   
            WM_CTLCOLORDLG = 0x136,   
            //当一个滚动条控件将要被绘制时发送此消息给它的父窗口通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置滚动条的背景颜色   
            WM_CTLCOLORSCROLLBAR = 0x137,   
            //当一个静态控件将要被绘制时发送此消息给它的父窗口通过响应这条消息，所有者窗口可以 通过使用给定的相关显示设备的句柄来设置静态控件的文本和背景颜色   
            WM_CTLCOLORSTATIC = 0x138,   
            //当鼠标轮子转动时发送此消息个当前有焦点的控件   
            WM_MOUSEWHEEL = 0x20A,   
            //双击鼠标中键   
            WM_MBUTTONDBLCLK = 0x209,   
            //释放鼠标中键   
            WM_MBUTTONUP = 0x208,   
            //移动鼠标时发生，同WM_MOUSEFIRST   
            WM_MOUSEMOVE = 0x200,   
            //按下鼠标左键   
            WM_LBUTTONDOWN = 0x201,   
            //释放鼠标左键   
            WM_LBUTTONUP = 0x202,   
            //双击鼠标左键   
            WM_LBUTTONDBLCLK = 0x203,   
            //按下鼠标右键   
            WM_RBUTTONDOWN = 0x204,   
            //释放鼠标右键   
            WM_RBUTTONUP = 0x205,   
            //双击鼠标右键   
            WM_RBUTTONDBLCLK = 0x206,   
            //按下鼠标中键   
            WM_MBUTTONDOWN = 0x207,   
            
            WM_USER = 0x0400,   
            MK_LBUTTON = 0x0001,   
            MK_RBUTTON = 0x0002,   
            MK_SHIFT = 0x0004,   
            MK_CONTROL = 0x0008,   
            MK_MBUTTON = 0x0010,   
            MK_XBUTTON1 = 0x0020,   
            MK_XBUTTON2 = 0x0040,
           //…………
       }

参数说明：

hWnd：目标窗体或者控件的句柄 msg: 具体要发送的消息 wParam:附加的第一个消息参数，如传递的坐标信息，具体参数请查阅微软官方资料 lParam:附加的第二个消息参数，具体参数请查阅微软官方资料

总结

模拟键盘和鼠标的一些消息或操作，在某些业务场景里面确实会存在。通过不同的业务场景，需要选择不同的方式进行处理解决。如果我们需要对某个程序控制，我们选择sendmessage方法。如果我们是要针对整个系统级别的模拟控制，那我们可以选择mouse_event方法。 sendmessage方法依赖于具体的窗体句柄参数，以及逻辑焦点（有些控件没有具体的句柄，如WPF控件，这个时候需要依赖于逻辑焦点）。mouse_event则需要依赖具体的窗体焦点。

需要注意的是：以上方法并不适用于UWP应用程序，UWP存在较高的安全控制策略，不允许直接模拟实现。下文我们会告诉大家，如何在UWP应用程序中模拟鼠标操作。

如何通过docker容器将ASP.NET Core站点部署到CentOS

Thu, 28 May 2020 12:35:03 +0000

上一篇我们讲了如何将asp.net core部署到linux系统上，这次我们以docker容器的方式把我们的站点部署到linux系统中

使用Docker来部署，其实比我们常规的部署方式更简单。因为Docker的存在，本来就是把复杂的事情简单化，让我们可以“一次部署，处处可用”。

如果你是使用windows操作系统，首先记得先安装好docker for windows，不清楚怎么安装可以自行查阅资料。

创建dockerfile

在上一次我们创建的asp.net core web项目中，我们在发布的目标文件夹根目录中创建一个Dockerfile的文件（就是一个文本文件没有扩展名），具体内容如下：

#从docker hub中拉取asp.net runtime基础镜像
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1
#将当前目录下的文件，拷贝到容器中的app目录下
COPY . /app 
#设置app为工作目录
WORKDIR /app
#暴露TCP端口5100
EXPOSE 5100/tcp
#设置程序启动入口函数库名，第一个参数表示执行命令的程序名，第二个函数表示带有主函数入口文件名
ENTRYPOINT ["dotnet","LinuxWebForTest.dll"]

特别注意：程序入口函数库文件名，一定是以dll作为入口函数库，不能以exe文件或者不带扩展名的文件名称作为入口函数库

如果入口函数指定错误，则会出现以下提示：

  ```txt
  It was not possible to find any installed .NET Core SDKs
  Did you mean to run .NET Core SDK commands? Install a .NET Core SDK from:
        https://aka.ms/dotnet-download
  ```

通过Dockerfile构建镜像

我们打开asp.net core web的根目录（也就是dockerfile所在目录），在资源管理器上方输入cmd命令，打开cmd命令窗口

登录docker仓库服务器，以上次构建的私有仓库为例

   > docker login 192.168.1.110:5000
   //之前已经登录过，所以直接从缓存里面查找用户和密码信息，自动登录
   Authenticating with existing credentials...
   Login Succeeded
   //如果没有登录过，输入用户名，密码进行登录。可参见：https://huchengv5.github.io//post/%E6%90%AD%E5%BB%BAdocker%E7%A7%81%E6%9C%89%E4%BB%93%E5%BA%93.html 中的登录部分。

构建镜像

   > docker build -t 192.168.1.110:5000/aspnetcoreapp:v1 .

   //执行过程
   Sending build context to Docker daemon  4.631MB
   Step 1/5 : FROM mcr.microsoft.com/dotnet/core/aspnet:3.1
   ---> bc877ac43e02
   Step 2/5 : COPY . /app
   ---> eaa31c882445
   Step 3/5 : WORKDIR /app
   ---> Running in f8db2aff9c73
   Removing intermediate container f8db2aff9c73
   ---> 97f999072fc2
   Step 4/5 : EXPOSE 5100/tcp
   ---> Running in ddeb5c939269
   Removing intermediate container ddeb5c939269
   ---> fbabdcf7447b
   Step 5/5 : ENTRYPOINT ["dotnet","LinuxWebForTest.dll"]
   ---> Running in 0d60745c61ea
   Removing intermediate container 0d60745c61ea
   ---> d2517be5dbd8
   Successfully built d2517be5dbd8
   Successfully tagged 192.168.1.110:5000/aspnetcoreapp:v1

我们可以通过docker images来查看我们构建的镜像。

   > docker images
   REPOSITORY                             TAG                 IMAGE ID            CREATED             SIZE
   192.168.1.110:5000/aspnetcoreapp       v1                  26070ec7870f        18 hours ago        212MB
   linuxwebfortest                        dev                 8485a72fcf26        25 hours ago        207MB
   docker101tutorial                      latest              c57c605dedaa        3 days ago          25.1MB
   192.168.1.110:5000/python              test                f4df7f234e59        7 days ago          78.9MB
   python                                 alpine              f4df7f234e59        7 days ago          78.9MB
   mcr.microsoft.com/dotnet/core/aspnet   3.1                 bc877ac43e02        8 days ago          207MB
   mcr.microsoft.com/dotnet/core/aspnet   3.1-buster-slim     bc877ac43e02        8 days ago          207MB
   node                                   12-alpine           7a48db49edbf        4 weeks ago         88.7MB
   nginx                                  alpine              89ec9da68213        4 weeks ago         19.9MB
   registry                               latest              708bc6af7e5e        4 months ago        25.8MB

### 命令说明：

   docker build 构建镜像

   -t (tag) 指定镜像tag

   192.168.1.110:5000 镜像指定的仓库地址，会作为镜像名称的一部分，但这部分不能乱填

   aspnetcoreapp 镜像名称，可以任意填写

   v1 对应的标签，这里是表示仓库 192.168.1.110:5000 下的 aspnetcoreapp 镜像的 v1 版本

   最后面有个 . ，表示的是当前目录下的dockerfile文件，也可以通过 -f 显示指定dockerfile的文件路径

推送镜像

镜像构建好后，我们需要将镜像推送到我们的私有仓库中
```
   > docker push 192.168.1.110:5000/aspnetcoreapp:v1
```
基本语法：docker push <镜像完整名称>

启动容器

镜像推送到服务器以后，我们需要进入到服务器，将镜像运行到容器中。（镜像就相当于是原始文件，容器可以理解为加载镜像文件后运行的程序实例）

   docker run -p 8000:5100 192.168.1.110:5000/aspnetcoreapp:v1

执行成功效果如下：

   warn: Microsoft.AspNetCore.DataProtection.Repositories.FileSystemXmlRepository[60]
         Storing keys in a directory '/root/.aspnet/DataProtection-Keys' that may not be persisted outside of the container. Protected data will be unavailable when container is destroyed.
   warn: Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager[35]
         No XML encryptor configured. Key {e0fd53e8-940f-4e70-b192-2b16c0f684dc} may be persisted to storage in unencrypted form.
   warn: Microsoft.AspNetCore.Server.Kestrel[0]
         Overriding address(es) 'http://+:80'. Binding to endpoints defined in UseKestrel() instead.
   info: Microsoft.Hosting.Lifetime[0]
         Now listening on: http://0.0.0.0:5100
   info: Microsoft.Hosting.Lifetime[0]
         Application started. Press Ctrl+C to shut down.
   info: Microsoft.Hosting.Lifetime[0]
         Hosting environment: Production
   info: Microsoft.Hosting.Lifetime[0]
         Content root path: /app

参数说明：

   docker run：启动一个容器实例
   -p 8000:5100：将本地端口8000映射到容器端口5100
   192.168.1.110:5000/aspnetcoreapp:v1： 表示完整的镜像路径

我们也可以通过 -d 参数启动后台运行，也可以通过设置 --restart=always 使其自动启动，小伙伴们可以自行尝试下。

使用浏览器，外部验证是否可以正常访问

使用浏览器打开：http://192.168.1.110:8000。如果能正常打开，那么恭喜你已经成功了。

Docker的最简易的部署就到这里了，基本思路有了，更复杂点的部署也会有个基本的思路了。

如何将Asp.net Core站点部署到CentOS

Wed, 27 May 2020 12:35:03 +0000

我们要想在linux系统中运行asp.net core程序，有两种方式：

直接部署在linux系统中
通过docker镜像部署在linux系统中

今天就来看下，如何直接把asp.net core应用站点部署到CentOS中！

安装.NET Core SDK

添加微软包地址到rpm（安装升级RPM包）

#其中i表示安装，v表示显示安装过程，h表示显示进度，U是表示升级包

rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm

更新rpm包

rpm update

检查net core版本

更新完以后，默认会安装最新版的NET Core SDK,可以通过以下命令查看版本

dotnet --info

安装成功的话，就会出现以下提示：

手动安装.net core sdk

如果觉得版本不是自己想要的，也可以手动安装，如：

yum install dotnet-sdk-3.1

说明：rpm和yum都是包管理器，rpm只能管理rpm的包，不能解决依赖问题；yum是可以把依赖的包一并安装

发布asp.net core到linux系统

asp.net core程序发布到本地文件夹

通过visual studio 发布菜单，将asp.net core应用程序发布到本地应用程序文件夹。

选择linux x64环境，前面已经安装了SDK，建议直接框架依赖。

默认是保存到Release下的publish目录里面，发布后可以直接点击链接导航到目标文件夹。

上传到linux系统

通过XShell，将文件上传到CentOS中的/data/sites/yourapp目录下，其中yourapp可以自己随便命名和创建。

//递归创建目录 -p 表示递归创建
 mkdir -p /data/sites/yourapp

在XShell上点击新建传输，直接将windows文件夹中的文件拖动到linux文件夹中即可，如下图所示

下面会显示传输进度。

如果上传不成功，需要给文件夹设置权限

sudo mkdir -p /data/sites/yourapp
// 修改权限为当前登录用户，否则无法上传
sudo chown -R 用户:用户组 /data

启动应用程序

文件上传上去后，我们进入的Linux系统中，先切换目录到/data/sites/yourapp，再通过dotnet yourapp.dll命令来启动应用程序。

# cd /data/sites/yourapp
//如果当前用户权限不足，在前面加 sudu 提权
# dotnet yourapp.dll

如果我们执行命名后，提示如下界面，表示服务启动成功

// 主机环境：Production
Hosting environment: Production
// 根目录
Content root path: /data/sites/yourapp
// 侦听地址和端口
Now listening on: http://0.0.0.0:5100
// 提示关闭技巧，Ctrl+C 可以关闭此主机
Application started. Press Ctrl+C to shut down.

yourapp 可自行重命名成自己的应用程序启动文件名

将应用程序修改成常驻服务

前面通过命名启用站点的方式，很容易被关闭，只要控制台被关闭，服务就会被关闭。而且运行在控制台模式下，无法执行其它操作。

接下来我们把它修改成常驻服务：

定位到文件夹 /etc/systemd/system，输入命令

//创建dotnet寄宿服务配置文件kestrel-dotnet.service，并进入编辑状态
sudo vi kestrel-dotnet.service

// 按 i 将编辑器转换为输入模式
// 将以下内容 copy 到当前编辑器中
[Unit]
Description=Example .NET Web Site running on Centos

[Service]
WorkingDirectory=/data/sites/yourapp
ExecStart=/usr/bin/dotnet yourapp.dll
Restart=always
# Restart service after 10 seconds if the dotnet service crashes:
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-example
User=root
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

// 按 esc 键推出编辑模式，输入命令 :wq! 保存并退出

执行以上命令后，我们还需要注册和启动服务

// 注册服务
sudo systemctl enable kestrel-dotnet.service
// 启动服务
sudo systemctl start kestrel-dotnet.service

以上命令执行完成后，我们就完成了常驻服务了。

这个时候，我们可以用浏览器打开我们刚部署的站点，如：http://192.168.1.110:5100。

如果可以正常访问就表示部署完成了。如果不能正常访问，我们可以通过以下几种方式来判断服务是否正常。

外部浏览器无法访问服务排查方法

查看服务是否正在运行

//服务未启动，外部肯定无法访问服务器，需要查看服务是否在线
//通过以下命令，查看`kestrel-dotnet.service`是否存在,如果不存在则重启服务
//查看`kestrel-dotnet.service`是否存在

# systemctl | grep running

//如果不存在，启动服务
# systemctl start kestrel-dotnet.service

查看端口是否正在监听

//如果服务存在，但是应用程序监听错误，也会导致外部无法访问
//查看本机的监听端口是否正常开启，如果没有正常开启，检查站点服务是否启动异常
# netstat -nao

查看本地是否可访问

//先排查本机服务是否能正常访问，如果本机能正常访问，表示本地服务正常。那就需要从其它因素考虑原因。
//尝试请求服务，如果有响应，表示服务正常
# curl http://192.168.1.110:5100

查看端口是否添加到防火墙白名单

//如果端口没有对外暴露，外部应用程序是无法访问的。这种情况，就是本机能正常访问，而外部无法访问很常见的因素
//检查防火墙对外暴露端口，是否包含自己部署的应用程序端口号
# firewall-cmd --zone=public --list-ports
//添加端口到白名单
# firewall-cmd --add-port=5100/tcp
//添加成功后，再重新访问，查看请求是否正常

以上就是将asp.net core部署到linux系统中的过程，我们终于可以真正体验跨平台的乐趣了。

下一篇我们再来看看，如果将asp.net core站点，通过docker部署到linux系统中。

搭建docker私有仓库

Tue, 26 May 2020 13:35:03 +0000

前面有提到如何安装docker，今天我们来聊下docker仓库。

docker官方默认有提供公共仓库，大家只需要前往docker官网进行注册帐号即可使用。官方网站：https://www.docker.com/，默认仓库地址：registry.hub.docker.com。
我们在使用docker的时候，如果没有指定仓库地址，默认也是使用docker官方的仓库。

作为企业用户，我们都需要搭建自己的私有仓库，这点非常重要，现在我们来搭建自己的docker仓库。

registry 的搭建

Docker 官方提供了一个搭建私有仓库的镜像 registry ，只需把镜像下载下来，运行容器并暴露5000端口，就可以使用了。

拉取官方私有仓库的镜像registry

docker pull registry

镜像拉取下来了以后，我们可以通过下面命令查看下镜像是否可以看的到

docker images

Registry服务默认会将上传的镜像保存在容器的/var/lib/registry，我们将主机的/opt/registry目录挂载到该目录，即可实现将镜像保存到主机的/opt/registry目录了，当然也可以换成其它的目录。

启动仓库

# docker run -itd -v /data/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry:latest 

参数说明

-itd：在容器中打开一个伪终端进行交互操作，并在后台运行；
-v：把宿主机的/data/registry目录绑定到容器/var/lib/registry目录(这个目录是registry容器中存放镜像文件的目录)，来实现数据的持久化；
-p：映射端口；访问宿主机的5000端口就访问到registry容器的服务了；
–restart=always：这是重启的策略，假如这个容器异常退出会自动重启容器；
–name registry：创建容器命名为registry，可以随便命名；
registry:latest：这个是刚才pull下来的镜像；

查看仓库

查看仓库列表有两种方法：通过命令查看和通过浏览器查看。

通过命令的方式：

# curl http://127.0.0.1:5000/v2/_catalog

通过浏览器打开的方式：

浏览器打开：http://127.0.0.1:5000/v2/_catalog

为仓库设置用户名密码

//切换到opt文件夹
# cd /opt/
//创建auth文件夹
# mkdir auth
//切换到auth文件夹
# cd /opt/auth
//生成密钥文件到htpasswd文件中
# echo "user:username passwd:password" >htpasswd
//使用registry镜像生成用户名和密码文件
# docker run --entrypoint htpasswd registry:latest -Bbn username password >auth/htpasswd
//查看密钥
# cat auth/htpasswd 
# ..生成的密钥..
//启动docker容器
# docker run -itd -v /data/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry:latest 

登录仓库

为了测试我们的私有仓库的搭建是否正常，我们可以在我们本机电脑上登录仓库测试（先在windows上面安装docker desktop，新建asp.net core项目勾选启动docker，visual studio就可以自动安装）。 docker安装好后，打开 cmd就可以输入docker命令了。登录命令如下所示：

//登录指定仓库地址
docker login ip:port -u username -p password
//登录成功
Login Succeeded

登录命令也可以分布来写，先登录到服务器，再输入用户名和密码。

如果仓库帐号正常，即可正常登录，返回：successed。

上传镜像

用户登录成功后，我们就可以尝试上传一个本地镜像到私有仓库了。 docker镜像上传之前，需要先给镜像打个tag，打完tag只会，就可以直接push到服务器上。

具体命令如下：

docker tag python 192.168.1.110:5000/python:test

参数说明：

python：指的是本地镜像。
192.168.1.110:5000/python：指的是仓库地址和镜像名称。
test：镜像标签。

//上传镜像到私有仓库
docker push 192.168.1.110:5000/python:test
//上传成功，返回的结果
The push refers to repository [192.168.1.110:5000/python]
a7d85ab87af8: Pushed                                                                                      7a82840eb682: Pushed                                                                                                    df897d49f46c: Pushed                                                                                                    a539b76feca4: Pushed                                                                                                    3e207b409db3: Pushed                                                                                                    test: digest: sha256:bbf059ab305cee6a2e5b3f28d5f7d0a51354093798b256f4c23d12c203db68c3 size: 1368

测试成功，我们最后再通过打开浏览器：http://127.0.0.1:5000/v2/_catalog，查看下仓库镜像是否已经上传成功。

docker可能会存在没有启动的情况，这个时候我们可以通过下面的命令进行启动或者停止

//docker启动       

# systemctl start docker
# service docker start

//重启docker服务

# systemctl restart  docker
# sudo service docker restart

//关闭docker    

# systemctl stop docker
# service docker stop

//查看是否启动成功

docker ps -a

在启动私有仓库中的镜像时，docker run 指令默认会以 https 启动，这个时候就需要在daemon.json中配置

//创建daemon.json配置文件,存放路径：/etc/docker/daemon.json
# vi daemon.json

输入以下内容：
{
  //配置仓库镜像，可配置国内加速镜像请求地址
  "registry-mirrors": [],
  //重定向到http，配置需要通过http请求的地址
  "insecure-registries": [
    "192.168.1.110:5100"
  ],
  "debug": false,
  "experimental": false
}

好了，私有仓库到这里就基本搭建好了，后面我们就可以考虑新建dockerfile，将我们的asp.net core程序打包成docker镜像了。

Linux系统中部署docker容器

Tue, 26 May 2020 12:35:03 +0000

Asp.Net core支持了跨平台以后，我们不得不使用跨平台的方案做部署。通常服务器我们都会选择使用linux，那么部署在linux系统中，我们主流的云部署方案是使用docker容器技术。今天来给大家分享下，如何在CentOS系统中部署docker容器。

在CentOS中，常用的包管理器是yum,我们需要完成软件的安装离不开包管理器。
sudo语法表示获取管理员权限，该方法不需要知道用户名和密码即可提权。

卸载旧版本（如果有）

$ sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine

按下回车即可，就可以卸载掉旧版本。

首次安装

安装所需的软件包。yum-utils 提供了 yum-config-manager ，并且 device mapper 存储驱动程序需要 device-mapper-persistent-data 和 lvm2。

$ sudo yum install -y yum-utils device-mapper-persistent-data lvm2

安装docker前，我们需要指定docker的仓库地址，用来下载和更新docker。
引用的仓库地址：https://download.docker.com/linux/centos/docker-ce.repo

$ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

安装最新版本

$ sudo yum install docker-ce docker-ce-cli containerd.io

安装指定版本

//查看docker版本信息，然后通过指定下面列举的版本号进行安装

$ yum list docker-ce --showduplicates | sort -r

docker-ce.x86_64  3:18.09.1-3.el7                     docker-ce-stable
docker-ce.x86_64  3:18.09.0-3.el7                     docker-ce-stable
docker-ce.x86_64  18.06.1.ce-3.el7                    docker-ce-stable
docker-ce.x86_64  18.06.0.ce-3.el7                    docker-ce-stable

版本号规则：通过其完整的软件包名称安装特定版本，该软件包名称是软件包名称（docker-ce）加上版本字符串（第二列），从第一个冒号（:）一直到第一个连字符，并用连字符（-）分隔。例如：docker-ce-18.09.1。

$ sudo yum install docker-ce-18.09.1 docker-ce-cli-18.09.1 containerd.io

安装完成后，启动docker

$ sudo systemctl start docker

安装docker的方法，网上有很多资料，这里主要也是实践一下，并且将docker部署的整个流程给串起来。

docker已经安装完成了，在实际使用docker前，我们需要为docker准备一个私有仓库，这样我们做的镜像就可以放到我们自己的服务器里面了。

下一篇我们再来探讨，如何建立私有仓库。

asp.net core 基础（附带解决Edge浏览器IP地址无法访问问题）

Thu, 21 May 2020 12:35:03 +0000

Asp.Net core不同于以往的asp.net，它不仅仅可以寄宿在IIS上，还可以寄宿到windows后台服务中，或者Kestrel中。不过本次篇幅不讲解寄宿方式，而是来聊下asp.net core基本启动部署的基础知识。

访问方式

asp.net core 包含有http和https两种方式模式，开发模式下会有开发证书供给https协议使用。

我们在部署的过程中，默认http访问请求会跳转到https访问，如果不想启用https，只需要在Startup文件中，删除app.UseHttpsRedirection()即可。

启动配置项

无论我们是新建MVC模版，还是WebAPI模版，我们的asp.net core的启动模式都是一样的。只是带不带View和resetfull的规范约束的区别。

asp.net core 提供了两种方式修改我们需要监听的URL：

配置文件Properties.lanuchSettings.json中
后台代码Program.cs或其它注入位置

默认情况下，asp.net core默认会以localhost做为端口监听范围，这种情况下，只有使用localhost才能访问我们的服务。

配置文件如下所示：

{
  "$schema": "http://json.schemastore.org/launchsettings.json",
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:51340",
      "sslPort": 44332
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "launchUrl": "api/MartixService",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "myproject": {
      "commandName": "Project",
      "launchBrowser": true,
      "launchUrl": "api/MartixService",
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

从配置文件中我们可以看到，主要有三种方式寄宿：IIS,IIS Express,Project。

IIS：部署到IIS时，会用到的配置项。

IIS Express：开发环境下，使用IIS Express调试时，会用到的配置项。

Project：开发环境下，直接启动项目编译后的exe时，会用到的配置项。

部分节点说明：

sslPort：表示启用https时访问的端口地址
commandName：表示启动的寄宿进程名
launchBrowser：是否启动浏览器
launchUrl：启动的默认路由地址，服务启动后默认跳转路由地址
applicationUrl：启动的URL地址，服务启动时会引用该配置
ASPNETCORE_ENVIRONMENT：表示asp.net运行环境，Development表示开发环境 ASPNETCORE_ENVIRONMENT中的Development的使用主要可以用于开发模式下的一些额外处理，如异常处理。
具体代码如下：

    //开发环境下，注入异常处理模块
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

服务监听有几种方式：

使用0.0.0.0，监听本地IP4所有地址。如：http://0.0.0.0:5000
使用*,监听本地IP6所有地址。如：http://*:5000
使用固定IP地址，监听本机地址。如：http://127.0.0.1:5000
监听本地地址。如：http://localhost:5000

默认情况下是监听localhost地址。

以上配置项，我们在开发模式下，通常都可以正常生效，当我们发布程序后，直接运行启动程序，我们会发现无论怎么修改配置项，始终是监听localhost本地地址。这是因为，我们发布的程序已经不是开发环境下了，这种情况下我们就需要通过后台代码来设置。

后台代码设置监听

后台代码设置URL也很简单，只需要在程序启动的时候，通过WebBuilder调用UseUrls方法，即可将启动的URL配置进去。上代码：

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

UseKestrel表示使用Kestrel服务器，也可以不写。

以上方式配置完成后，你用微软的Edge浏览器请求web api时，可能会出现网络无法访问的情况！这种情况下，可以直接打开F12启动调试模式，查看网络通信情况。

网络返回 200 0K，但是没有数据返回！

继续看，我们会发现，Edge浏览器有做访问限制。

在局域网环境下，我们使用其它浏览器（包括IE浏览器）尝试，都可以正常访问，基本可以确定是Edge浏览器访问权限设置问题。

下面先附上谷歌浏览器访问的情况：

解决Edge浏览器无法访问的问题

根据前面的内容，我们已经确定是浏览器的问题，那么针对这个问题要如何解决呢？

首先看到错误提示CONSOLE21301: serviceWorker.getRegistrations 由于 ms-appx-web://microsoft.microsoftedge/assets/errorpages/dnserror.html?ErrorStatus=0x800C0005&NetworkStatusSupported=1 中的不安全上下文或主机限制而被拒绝。

是因为Edge浏览器做了ip访问的限制，我们可以通过解除该限制，让浏览器正常访问。

具体方法如下：

先打开PowerShell,获取Edge浏览器的app id。

PowerShell中输入命令：Get-StartApps，找到Microsoft Edge以及其AppID。本机版本是：Microsoft.MicrosoftEdge_8wekyb3d8bbwe!MicrosoftEdge。
以管理员身份运行cmd，输入命令：CheckNetIsolation LoopbackExempt -a -n=Microsoft.MicrosoftEdge_8wekyb3d8bbwe

CheckNetIsolation LoopbackExempt 用法:

   CheckNetIsolation LoopbackExempt [operation] [-n=] [-p=]
      操作列表:
          -a  -  向环回免除列表中添加 AppContainer 或程序包系列。
          -d  -  从环回免除列表中删除 AppContainer 或程序包系列。
          -c  -  清除环回免除的 AppContainer 和程序包系列的列表。
          -s  -  显示环回免除的 AppContainer 和程序包系列的列表。

      参数列表:
          -n= - AppContainer 名称或程序包系列名称。
          -p= - AppContainer 或程序包系列安全标识符(SID)。
          -?  - 显示 LoopbackExempt 模块的此帮助消息。

执行结果：

我们在用Edge浏览器重新输入我们之前输入的URL，此次访问，就可以正常获取数据了。如下所示：

起初以为是asp.net core的寄宿问题，经过调查最终才发现，原来都是Edge惹的祸！！

启动报错Unable to configure HTTPS endpoint. No server certificate was specified

因为.net core默认是使用https协议，使用Kestrel web服务器没安装证书就会报错。所以只需要打开cmd命令行，执行以下命令就可以安装开发测试证书。

打开cmd命令，执行dotnet dev-certs https --trust。

重新编译和重启站点即可。

Linux实体机设置静态IP地址

Wed, 20 May 2020 12:35:03 +0000

Linux操作系统装好了以后，最大的问题就是要先让它能联网，不能联网很多事情都做不了！所以今天我们来聊聊，联网的事儿！

习惯windows系统的朋友们，对linux机制是一脸懵逼。在windows系统中，提供丰富的界面给我们操作，然而在linux系统中，基本没有界面可操作，通常是通过linux命令来达到目的。

修改IP主要需要了解以下内容：

需要用到的命令
网卡信息存放位置
网卡信息的属性对应的含义
检查网络是否可正常访问外网

需要用到的命令

cd [dir] //切换目录，如： cd etc/dev/ ,切换 ../etc/dev 为当前目录。
ls //查看文件列表。
ifconfig //查看网络状态
vi/vim //编辑文本
cat //查看文本内容
service network restart //重启网卡

网卡信息存放位置

网络相关的信息，存放在 /etc/sysconfig/network-scripts/目录下，我们可以通过cd命令，切换到该目录下，然后使用ls查看该目录下的内容。

我们可以看到ifcfg-enp1s0或者ifcfg-eth0这样的文件，这中文件就是网卡配置文件。

为什么是enp1s0或eth0?

enp1s0 : en代表以太网卡,p1s0代表PCI接口的物理位置为(1, 0), 其中横坐标代表bus，纵座标代表slot。

eth0 ： eth是Ethernet的前三个字母，代表以太网。0代表是第一块网卡。

所以看到上述两种方式的配置文件，就是网卡相关信息的描述文件。之所以会存在两种不同的表示方法，取决于使用的linux版本。新版本使用enp1s0这种方式，旧版本使用eth0这种方式。

wlan0 ：wlan表示无线网络，命令逻辑如何eth0。

编辑网卡配置文件

此处以enp1s0为例，通过命令进入到/etc/sysconfig/network-scripts/目录下，通过命令vi ifcfg-enp1s0，打开并编辑enp1s0文件。

先看下参数及含义：

DEVICE=eth0　　　　#设定物理设备别名（除了动态分配的PPP设备，这里是一个逻辑名）

HWADDR=00:11:22:33:44:55　　　　#指定MAC地址，不能和MACADDR一起使用

MACADDR=AA:BB:CC:DD:EE:FF　　　　#覆盖物理分配的MAC地址，不能和HWADDR一起使用

TYPE=Ethernet　　　　#网卡协议类型，以太网或者无线网或虚拟网卡

UUID=9420c638-16e9-41a1-bf59-325c6f601871 #网卡的UUID

ONBOOT=no　　　　#系统启动时是否自动加载该网卡yes/no

NM_CONTROLLED=yes #network manger的参数，实时生效，修改后无需要重启网卡立即生效

BOOTPROTO=dhcp　　　　#获取地址协议[static]、[bootp]、[dhcp]

IPADDR=192.168.1.254　　　　#IP地址

NETMASK=255.255.255.0　　　　#IP对应的子网掩码

GATEWAY=192.168.1.1　　　　#IP对应的网关地址

DNS1=8.8.8.8　　　　#指定DNS1地址

DNS2=8.8.4.4　　　　#制定DNS2地址

BROADCAST=192.168.1.255　　　　#IP对应的广播地址

NETWORK=192.168.1.0　　　　#对应的网络地址

USERCTL=yes　　　　#非root用户是否允许控制这个设备

SRCADDR=192.168.1.254　　　　#指定为发出去的数据包的源IP地址

PEERDNS=yes　　　　#是否以此修改 [ /etc/resolv.conf ]

DHCP_HOSTNAME=hostname　　　　#DHCP接收IP地址前可指定主机名

MASTER=bond0　　　　#以太网接口被连接到这个接口

SLAVE=yes　　　　#这个设备是否由指定在MASTER字段中的频道绑定接口控制

参数很多，我们重点关注以下几个属性即可：

BOOTPROTO=static #修改为手动指定的静态IP地址
IPADDR=192.168.1.110 #设置静态IP地址
GATEWAY=192.168.1.1 #设置默认网关
ONBOOT=yes #启用网卡

vi命令进入编辑模式后，直接通过键盘方向键可以移动到要编辑的位置，换行可进入插入模式。编辑需要修改的选项后，使用:wq（保存并退出）命令退出编辑模式。

DNS可以不用设置，可自动获取DNS。

设置完成后，使用service network restart命令重启网卡。

检查网络是否正常

我们可以通过ifconfig命令，查看当前网卡的状态，查看设置是否生效，示例显示内容如下图所示：

我们在使用该命令时可能会存在 commad not found!

可能原因有两个：

没有安装ifconfig工具
没有将ifconfig加入到环境变量

参考：https://blog.csdn.net/dong_alex/article/details/80873733。

跟windows一样，我们可以用ping命令来检查网络是否正常，我们以百度为例：

命令：ping www.baidu.com -t 结果跟windows系统使用方法大体一致，通过这种方式就可以检查网络是否正常。

网络能正常访问后，我们就可以真正的开始玩耍了!

实用工具

通过在linux环境下，我们都需要远程控制linux主机。推荐个实用工具：XShell,可以通过SSH连接到linux。也可以下载XManager套件。

XShell不仅仅可以支持远程登录和控制，还可以很方便的完成文件的上传和下载（sftp）。

软件使用就不在此赘述。

使用U盘安装Linux（CentOS）操作系统

Tue, 19 May 2020 12:35:03 +0000

随着.NET推出了.net core以后，开始支持跨平台，拥有一台linux的服务器似乎变得很有必要。今天我们来看看，如何在我们的PC电脑上，安装Linux操作系统。

本文以Linux CentOS 7 为例!

安装过Windows操作系统的小伙伴们都知道，想要通过U盘安装Linux，首先就必须得有个启动U盘。启动U盘需要事先安装引导程序才可安装操作系统。

常用的U盘启动工具有：大白菜、老毛桃、UltraISO（软碟通）等。本文以软碟通为例！

准备工作：

下载 CentOS 7 操作系统ISO镜像
下载UltraISO U盘启动制作工具
准备一个大于4GB的USB 2.0 U盘（3.0或以上的U盘会导致无法检测到USB驱动器的问题）

先下载U盘启动工具UltraISO，并打开，打开界面如下：

准备一个的U盘，并插入到电脑中，并将本地目录选中到CentOS ISO镜像

点击上方菜单启动->写入硬盘映像,弹出制作配置对话框：

写入方式选择 USB-HDD 或 USB-HDD+

点击格式化，先将U盘格式化成FAT32格式

点击写入即可完成启动盘制作，如果刻录成功，消息栏中会显示已成功刻录。

U盘制作好后，将U盘插入到需要重装系统的电脑中，进入BIOS，设置U盘启动（不同电脑BIOS设置不一样，这里省略）

通过USB引导，进入到安装界面

按Tab键或者字母 e 进入编辑页面

修改USB驱动器的名称，改成我们U盘的名称。 vmlinuz initrd=initrd.img inst.stage2=hd:LABEL=CentOS\x207\x20x86_64 rd.live.check quiet

改成

vmlinuz initrd=initrd.img inst.stage2=hd:LABEL=[U盘名称，区分大小写] quiet

如果不更改U盘名称，引导系统无法找到操作系统，导致无法进行安装，U盘名称区分大小写。

如果不知道U盘名称，可以修改为：vmlinuz initrd=initrd.img linux dd quiet,退出该页面后，会进入选择硬盘驱动器的界面。

该示例是无法找到USB驱动器，是因为USB是3.0接口，引导程序不支持3.0接口，需要用USB2.0的U盘重新制作启动盘。切记切记！！

设置好后，我们就可以进入linux安装程序界面了

选择简体中文

设置安装位置

如果磁盘空间不足，勾选我想让额外空间可用，删除不需要的文件即可。

设置IP地址

点击“配置“按钮

设置开机的时间网卡自动启动，点击“常规”—选中“可用时自动链接到这个网络”

选择“IPV4 设置“，在方法（M）：中选择”手动“，然后点击”Add”按钮

配置好后点击完成

选择自动分区，此时就可以点击开始安装进行安装了

安装完成后，设置Root密码

输入密码后，点击完成

最后重启系统即可进入linux系统了

现在就可以尽情的玩耍了

Linux安装首次告捷，本文到此结束！

UWP InkCanvas 高级用法

Sat, 16 May 2020 12:35:03 +0000

前面已经介绍了InkCanvas基础用法，现在来看看InkCanvas的一些高级用法！

这里先介绍下InkCanvas的一些处理对象和事件：

属性`InkCanvas.InkPresenter`

InkCanvas关联的核心对象，包含事件的输入处理，笔迹的绘制参数设置，事件传递等操作。

属性`InkCanvas.InkPresenter.IsInputEnabled`

InkPresenter是否处理输入事件。如果为true,则自动处理事件，事件将不会传递给Pointer相关系列事件。

属性`InkCanvas.InkPresenter.InputDeviceTypes`

设置需要处理的设备类型，如鼠标，触控笔，手等。

属性`InkCanvas.InkPresenter.StrokeContainer`

InkStroke容器，在未启用自定义干操作时，该容器会自动实例化，并将笔迹填充到该容器。如果启用自定义干操作时，该属性为null,并且不允许实例化。

属性`InkCanvas.InkPresenter.StrokeInput`

笔迹输入处理对象，提供Stroke绘制过程中的事件处理。

事件`InkCanvas.InkPresenter.StrokesCollected`

当湿笔迹生成完成后触发（即鼠标抬起或者触摸抬起时触发）。我们可以通过该事件，将湿笔迹转成干笔迹。

事件`InkCanvas.PointerPressed`

当指针按下时触发。当现在的模式是由InkCanvas自己处理书写逻辑（即未启用自定义干操作）并且设置了InkCanvas.InkPresenter.IsInputEnabled = true时，事件不会被触发。如果启用了自定义干操作或者设置InkCanvas.InkPresenter.IsInputEnabled = false时，事件将会被触发。

事件`InkCanvas.PointerMoved`

事件`InkCanvas.PointerReleased`

事件`WetStrokeStarting`

当湿笔迹准备绘制时触发。该事件需要通过var coreWetStrokeUpdateSource = CoreWetStrokeUpdateSource.Create(InkCanvas.InkPresenter)方法获取可注册事件的对象。该事件可以用于处理一些业务逻辑，比如动态笔迹绘制前，是否智能启用擦除模式。

事件`WetStrokeCanceled`

当湿笔迹绘制被取消时触发。该事件需要通过var coreWetStrokeUpdateSource = CoreWetStrokeUpdateSource.Create(InkCanvas.InkPresenter)方法获取可注册事件的对象。暂未找到取消方法，在WetStrokeStarting事件中设置args.Disposition = CoreWetStrokeDisposition.Canceled;却未生效。

事件`WetStrokeContinuing`

当湿笔迹绘制被取消时触发。该事件需要通过var coreWetStrokeUpdateSource = CoreWetStrokeUpdateSource.Create(InkCanvas.InkPresenter)方法获取可注册事件的对象。

事件`WetStrokeStopping`

当湿笔迹绘制停止时时触发。该事件需要通过var coreWetStrokeUpdateSource = CoreWetStrokeUpdateSource.Create(InkCanvas.InkPresenter)方法获取可注册事件的对象。该事件触发早于WetStrokeCompleted。

事件`WetStrokeCompleted`

当湿笔迹绘制完成时触发。该事件需要通过var coreWetStrokeUpdateSource = CoreWetStrokeUpdateSource.Create(InkCanvas.InkPresenter)方法获取可注册事件的对象。该事件触发晚于WetStrokeStopping。

事件`InkCanvas.InkPresenter.StrokeInput.StrokeStarted`

湿笔迹已启动绘制时发生，此事件触发要晚于WetStrokeStarting。

事件`InkCanvas.InkPresenter.StrokeInput.StrokeCanceled`

湿笔迹取消绘制时发生。暂未验证！

事件`InkCanvas.InkPresenter.StrokeInput.StrokeContinued`

湿笔迹持续绘制时发生。此事件触发要晚于WetStrokeContinuing。

事件`InkCanvas.InkPresenter.StrokeInput.StrokeEnded`

湿笔迹完成绘制时发生。此事件触发要晚于WetStrokeStarting。

事件触发顺序如下：

WetStrokeStarting
StrokeStarted
WetStrokeContinuing
StrokeContinued
WetStrokeContinuing
StrokeContinued
----省略----
WetStrokeContinuing
StrokeContinued
WetStrokeStopping
StrokeEnded
WetStrokeCompleted

wetStrokeStarting
StrokeStarted
WetStrokeContinuing
StrokeContinued
----省略----
WetStrokeContinuing
StrokeContinued
WetStrokeContinuing
StrokeContinued
StrokeEnded
WetStrokeStopping
WetStrokeCompleted

WetStrokeStarting
StrokeStarted
WetStrokeContinuing
StrokeContinued
----省略----
WetStrokeContinuing
StrokeContinued
WetStrokeStopping
StrokeEnded
WetStrokeCompleted

这里值得一提的是，我们发现WetStrokeStopping和StrokeEnded事件触发顺序可能会出现不一致的情况。这是因为CoreWetStrokeUpdateSource下的事件和StrokeInput下的事件并不是在同一个线程，CoreWetStrokeUpdateSource的事件在触摸线程中触发，而StrokeInput事件是在主线程上触发。

核心的事件都了解了，我们围绕这些事件就可以扩展各种业务逻辑了。

这里以动态笔迹转静态笔迹为例：

        private InkSynchronizer _inkSynchronizer; 
        private InkStrokeContainer _inkStrokeContainer = new InkStrokeContainer();
        
        public void Init()
        {
            //开启自定义干操作
            _inkSynchronizer = InkCanvas.InkPresenter.ActivateCustomDrying();
            //设置基础参数
            var drawingAttributes = InkCanvas.InkPresenter.CopyDefaultDrawingAttributes();
            drawingAttributes.Color = Colors.Red;
            drawingAttributes.Size = new Size(3, 3);
            //设置笔尖
            drawingAttributes.PenTip = PenTipShape.Circle;
            //设置笔尖
            drawingAttributes.PenTipTransform = Matrix3x2.CreateSkew(4, 4);
            InkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
            //告诉InkCanvas处理那些设备类型的消息
            InkCanvas.InkPresenter.InputDeviceTypes = Windows.UI.Core.CoreInputDeviceTypes.Mouse | Windows.UI.Core.CoreInputDeviceTypes.Pen | Windows.UI.Core.CoreInputDeviceTypes.Touch;
            //开启多指触控，多指触控之前需要先开启完全控制
            InkCanvas.InkPresenter.SetPredefinedConfiguration(InkPresenterPredefinedConfiguration.SimpleMultiplePointer);
            //多指触摸必须要设置的选项
            InkCanvas.InkPresenter.InputProcessingConfiguration.RightDragAction = InkInputRightDragAction.LeaveUnprocessed;
            //注册湿笔迹收集的事件
            InkCanvas.InkPresenter.StrokesCollected += InkPresenter_StrokesCollected;
        }

        private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
        {
            _inkSynchronizer.BeginDry();
            //收集笔迹
            _inkStrokeContainer.AddStrokes(args.Strokes);
            //todo:添加自己的操作，需要如何处理收集到的笔迹。
            _inkSynchronizer.EndDry();
        }

其他的案例这里就不多写了，了解以上事件就可以自定义很多业务了。

UWP InkCanvas 基础用法

Fri, 15 May 2020 12:35:03 +0000

WPF中有InkCanvas，UWP中也一样存在InkCanvas，但是两者的API设计方面有所差异！UWP的InkCanvas的API设计上会比WPF版本的更难使用一些，同时功能也更强大一些！

InkCanvas通常称为墨迹或者笔迹，通常我们在写书写笔迹功能或者做一些标注，涂鸦等功能会用到它。它包含基本的笔迹书写，笔迹擦除，笔迹选择，笔迹识别，笔迹保存等功能。下面先简单介绍下UWP版本下的InkCanvas基本概念。

基本概念

在UWP版本中的笔迹，包含有两种：湿笔迹（Wet）和干笔迹(Dry)。
湿笔迹：其实就是动态笔迹，书写过程中绘制的笔迹。因动态笔迹不需要额外的交互功能，所以动态笔迹的绘制通常都是采用最高性能的方式绘制，不支持交互。笔迹变干后，湿笔迹就会消失，干笔迹就会代替湿笔迹，并支持交互。

干笔迹：干笔迹就是动态笔迹落笔后生成的笔迹，干笔迹一旦生成，湿笔迹就会被删除或者不再渲染。干笔迹支持交互，渲染上的性能要求相比湿笔迹要低。

开始书写

默认情况下，我直接将InkCanvas控件拖放到我们MainPage里面，直接运行程序，我们会发现，此时的InkCanvas并不能直接开始书写，因为我们没有给InkCanvas初始化相关参数。
具体参数设置如下：

//告诉InkCanvas，接收哪些类型的输入设备。包含此声明后，即可开始书写，默认书写（Inking）模式，颜色黑色。
InkCanvas.InkPresenter.InputDeviceTypes = Windows.UI.Core.CoreInputDeviceTypes.Mouse | Windows.UI.Core.CoreInputDeviceTypes.Pen | Windows.UI.Core.CoreInputDeviceTypes.Touch;

多指书写

InkCanvas也是支持多指书写的，只是多指书写的实现过程会复杂一些。要启用多笔书写，就必现启用自定义干的操作，即：自定义将笔迹从湿笔迹转成干笔迹。

//启用自定义干
var inkSynchronizer = InkCanvas.InkPresenter.ActivateCustomDrying();

//开启多指触摸功能
InkCanvas.InkPresenter.SetPredefinedConfiguration(InkPresenterPredefinedConfiguration.SimpleMultiplePointer);

//自定义干如何使用，下篇再讲
//……

启动擦除

InkCanvas仅提供两种模式切换：笔迹模式和擦除模式。

InkCanvas的擦除模式，只支持线相交模式擦除。

启用擦除模式方法如下：

//切换到擦除模式
InkCanvas.InkPresenter.InputProcessingConfiguration.Mode = InkInputProcessingMode.Erasing;

模式切换主要有三种：None,Inking,Erasing。使用擦除功能特别要注意，采用了自定义干模式，是不能启用擦除的，否则会报错，提示：调用的时机不正确。

基本设置

InkCanvas提供一些基础的设置方法，比如：笔迹的颜色，粗细，是否高亮，宽度，高度等。这些属性的设置都在InkDrawingAttributes对象中。可通过InkCanvas.InkPresenter.CopyDefaultDrawingAttributes();获取默认参数设置，然后根据InkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);进行修改。

值得注意的是,PenTip可用来设置笔尖显示效果，如下设置：

    //设置笔迹使用圆形
    DrawingAttributes.PenTip = PenTipShape.Circle;
    //通过矩阵变换来设置笔尖形状
    DrawingAttributes.PenTipTransform = Matrix3x2.CreateSkew(4, 4);

UWP InkCanvas的基本用法就先介绍到这儿，有了这些功能就可以完成一些基础的功能开发了，后面会再介绍一些更高级的用法。

WPF拖动功能的实现

Tue, 05 May 2020 12:35:03 +0000

WPF中实现拖动功能和WinForm中实现的功能有所差异，这里简单介绍下WPF中的拖拽的实现逻辑！

实现拖拽功能，主要包含以下几个步骤：

需要拖入到的控件中，设置 AllowDrop="True"
需要拖入到的控件中，注册Drop事件，在该事件中，将拖动到该控件中的数据进行处理。获取数据的方法：e.Data.GetData(typeof(MyClass));
在拖动的控件，注册PreviewMouseMove事件,在该事件中，启动拖拽行为：DragDrop.DoDragDrop。在设置移动的过程中，因为MouseUp事件会在Drag过程中被吞掉，所以PreviewMouseUp事件不会被触发。为了解决拖动时，鼠标移动触发拖拽情况，只需要在PreviewMouseMove事件中加上e.LeftButton == MouseButtonState.Pressed即可。
如果需要将拖动的对象，跟随鼠标移动，可以将被拖动元素以自定义Adorner的方式，添加到该元素下的AdornerLayer中。将拖动元素以VisualBrush的方式赋值给Adorner。并在GiveFeedback事件中更新坐标位置。

示例代码：

        //定义个自定义的Adorner
        DefaultAdorner adorner;

        //当鼠标拖入到控件中，并释放鼠标时发生
        private void FrameworkElement_Drop(object sender, DragEventArgs e)
        {
            var data = (MyClass)e.Data.GetData(typeof(MyClass));
           //todo:
        }

        //当鼠标按下，开始移动时开始拖拽
        private void FrameworkElement_PreviewMouseMove(object sender, MouseEventArgs e)
        {
            if (e.LeftButton == MouseButtonState.Pressed)
            {   
                //添加Adorner到AdornerLayer
                adorner = new DefaultAdorner((UIElement)Application.Current.MainWindow.Content,(UIElement)this._dragDropObject.SourceObject,this._dragDropObject.StartPosition);
                System.Windows.Media.Visual visual = Application.Current.MainWindow.Content as Visual;
                AdornerLayer.GetAdornerLayer(visual).Add(this._dragDropObject.DragAdorner);
                //开始拖动
                DragDrop.DoDragDrop(frameworkElement, data, DragDropEffects.Move);               
            }
        }

         private void DragSource_GiveFeedback(object sender, GiveFeedbackEventArgs e)
         {
            //设置移动Adorner的位置
            adorner.SetMousePosition(dragAdorner.AdornedElement.PointFromScreen(point));
         }

    //DefaultAdorner定义
    public class DefaultAdorner : Adorner
    {
        private UIElement _child;
        private Point _adornerOrigin;
        private Point _adornerOffset;

        public DefaultAdorner(UIElement adornedElement, UIElement adornerElement, Point adornerOrigin)
            : this(adornedElement, adornerElement, adornerOrigin, 0.3)
        {
        }

        //将需要拖动的元素附加到Adorner
        public DefaultAdorner(UIElement adornedElement, UIElement adornerElement, Point adornerOrigin, double opacity)
            : base(adornedElement)
        {
            Rectangle rect = new Rectangle();
            rect.Width = adornerElement.RenderSize.Width;
            rect.Height = adornerElement.RenderSize.Height;

            VisualBrush visualBrush = new VisualBrush(adornerElement);
            visualBrush.Opacity = opacity;
            visualBrush.Stretch = Stretch.None;
            rect.Fill = visualBrush;

            this._child = rect;

            this._adornerOrigin = adornerOrigin;
        }

        public void SetMousePosition(Point position) {
            this._adornerOffset.X = position.X - this._adornerOrigin.X;
            this._adornerOffset.Y = position.Y - this._adornerOrigin.Y;
            UpdatePosition();
        }

        //重绘
        private void UpdatePosition() {
            AdornerLayer adornerLayer = (AdornerLayer)this.Parent;
            if(adornerLayer != null) {
                adornerLayer.Update(this.AdornedElement);
            }
        }

        protected override int VisualChildrenCount { get { return 1; } }

        protected override Visual GetVisualChild(int index) {
            System.Diagnostics.Debug.Assert(index == 0, "Index must be 0, there's only one child");
            return this._child;
        }

        protected override Size MeasureOverride(Size finalSize) {
            this._child.Measure(finalSize);
            return this._child.DesiredSize;
        }

        protected override Size ArrangeOverride(Size finalSize) {
            this._child.Arrange(new Rect(finalSize));
            return finalSize;
        }

        //通过变换，更改移动位置
        public override GeneralTransform GetDesiredTransform(GeneralTransform transform) {
            GeneralTransformGroup newTransform = new GeneralTransformGroup();
            newTransform.Children.Add(base.GetDesiredTransform(transform));
            newTransform.Children.Add(new TranslateTransform(this._adornerOffset.X, this._adornerOffset.Y));
            return newTransform;
        }
    }

以上就是拖动功能实现的主题思路，按照以上思路可对拖动操作做一层封装，简化拖动功能实现的复杂度。

WPF附加属性绑定无效的问题

Fri, 24 Apr 2020 12:35:03 +0000

WPF有的时候我们会发现一些BUG，看似非常合理，甚至微小到怀疑Visual Studio出BUG了，然而并不是，电脑通常不会欺骗我们的！

下面举个案例： ControlTemplate样式定义部分

                    <Border x:Name="radioButtonBorder" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}">
                        <Grid Margin="2">
                            <Image Source="{Binding (local:UIHelper.ImageSource),RelativeSource={RelativeSource Mode=TemplatedParent}}" Margin="2"/>
                            <Border Visibility="{TemplateBinding IsChecked,Converter={StaticResource VisibilityConverter}}" CornerRadius="25" Background="White" Height="25" Width="25" Margin="15" HorizontalAlignment="Right" VerticalAlignment="Bottom">
                                <Image Source="{StaticResource checked}" Height="20" Width="20"/>
                            </Border>
                        </Grid>
                    </Border>

应用样式部分：

    <RadioButton helper:UIHelper.ImageSource="Background/9.jpg" Style="{StaticResource Style.RadioButton.Graphic}"/>

以上代码，是不是可以正常运行呢？是的，能正常编译通过，也能正常跑起来！

但是，图片出不来……！！ Why?

因为样式绑定的时候，ControlTemplate中使用(local:UIHelper.ImageSource)进行绑定，而在使用过程中，用helper:UIHelper.ImageSource进行绑定。但是实际上，local:UIHelper.ImageSource和helper:UIHelper.ImageSource指向的是同一个类对象。而，xaml在处理过程中，因为绑定的PropertyPath不一致，而导致绑定失败！

因为，这个错误，看似很符合逻辑，符合语法，但是它并不能正确的绑定成功，因为PropertyPath不一样。

WPF如何快速定制化样式

Tue, 21 Apr 2020 12:35:03 +0000

WPF的样式非常灵活，我们可以根据需求，定制各种各样的样式外观，让我们的界面变的更加的漂亮！当我们面对WPF自带样式时，想改成我们想要的界面外观，有的时候写一个复杂点的样式就会显得很麻烦！

那如何快速定制自己的样式呢？

其实很简单，Visual Studio本身就自带有强大的功能，可以将系统自带控件的样式自动生成出来。于是我们只需要基于自带样式的基础上进行修改就可以快速定制新的样式。

具体操作如下：

打开Xaml文件，选中需要定制样式的任意一个控件。
鼠标右键，选中【编辑模版】 -> 【编辑副本】
重命名样式名称，点击【确定】

通过以上步骤，就可以将控件的默认样式生成在xaml文件中了，我们就可以直接在xaml文件中修改了。

C# 如何判断本机网络端口是否可用

Mon, 20 Apr 2020 12:35:03 +0000

无论是TCP端口还是UDP端口，在同一台机器上只能开启一个。为了能够让我们正常启用端口，我们不得不查询本机端口是否已经占用，如果已经占用，我们就需要查询其它可用端口，并启动连接。

那如何查找空闲的网络端口呢？

请看具体演示代码：

    public class FreePort
    {
        private const string PortReleaseGuid = "8875BD8E-4D5B-11DE-B2F4-691756D89593";

        //查找TCP可用端口
        public static int FindNextAvailableTCPPort(int startPort)
        {
            int port = startPort;
            bool isAvailable = true;

            var mutex = new Mutex(false, string.Concat("Global/", PortReleaseGuid));
            mutex.WaitOne();
            try
            {
                IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
                IPEndPoint[] endPoints = ipGlobalProperties.GetActiveTcpListeners();

                do
                {
                    if (!isAvailable)
                    {
                        port++;
                        isAvailable = true;
                    }

                    foreach (IPEndPoint endPoint in endPoints)
                    {
                        if (endPoint.Port != port) continue;
                        isAvailable = false;
                        break;
                    }

                } while (!isAvailable && port < IPEndPoint.MaxPort);

                if (!isAvailable)
                    throw new ApplicationException("Not able to find a free TCP port.");

                return port;
            }
            finally
            {
                mutex.ReleaseMutex();
            }
        }

        //查找UDP可用端口
        public static int FindNextAvailableUDPPort(int startPort)
        {
            int port = startPort;
            bool isAvailable = true;

            var mutex = new Mutex(false, string.Concat("Global/", PortReleaseGuid));
            mutex.WaitOne();
            try
            {
                IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
                IPEndPoint[] endPoints = ipGlobalProperties.GetActiveUdpListeners();

                do
                {
                    if (!isAvailable)
                    {
                        port++;
                        isAvailable = true;
                    }

                    foreach (IPEndPoint endPoint in endPoints)
                    {
                        if (endPoint.Port != port)
                            continue;
                        isAvailable = false;
                        break;
                    }

                } while (!isAvailable && port < IPEndPoint.MaxPort);

                if (!isAvailable)
                    throw new ApplicationException("Not able to find a free UDP port.");

                return port;
            }
            finally
            {
                mutex.ReleaseMutex();
            }
        }
    }

C# 如何判断本机网络是否可用

Sun, 19 Apr 2020 13:35:03 +0000

判断网络连接是否正常的方法有很多，常规思路便是检查网卡状态，ping指定的网络验证网络是否通畅！以下是具体的实现方法：

示例代码如下：

    public class InternetConnetedStatusHelper
    {
        private const int INTERNET_CONNECTION_MODEM = 1;
        private const int INTERNET_CONNECTION_LAN = 2;

        [DllImport("winInet.dll")]
        private static extern bool InternetGetConnectedState(ref int dwFlag, int dwReserved);

        /// <summary>
        /// 判断网络的连接状态
        /// </summary>
        /// <returns>
        /// 网络状态(1-->未联网;2-->采用调治解调器上网;3-->采用网卡上网)
        ///</returns>
        public static int GetNetConStatus(string strNetAddress)
        {
            int iNetStatus = 0, dwFlag = 0;
            if (!InternetGetConnectedState(ref dwFlag, 0))
            {
                //没有能连上互联网
                iNetStatus = 1;
            }
            else if ((dwFlag & INTERNET_CONNECTION_MODEM) != 0)
            {
                //采用调治解调器上网,需要进一步判断能否登录具体网站
                if (PingNetAddress(strNetAddress))
                {
                    //可以ping通给定的网址,网络OK
                    iNetStatus = 2;
                }
                else
                {
                    //不可以ping通给定的网址,网络不OK
                    iNetStatus = 4;
                }
            }

            else if ((dwFlag & INTERNET_CONNECTION_LAN) != 0)
            {
                //采用网卡上网,需要进一步判断能否登录具体网站
                if (PingNetAddress(strNetAddress))
                {
                    //可以ping通给定的网址,网络OK
                    iNetStatus = 3;
                }
                else
                {
                    //不可以ping通给定的网址,网络不OK
                    iNetStatus = 5;
                }
            }

            return iNetStatus;
        }

        /// <summary>
        /// ping 具体的网址看能否ping通
        /// </summary>
        /// <param name="strNetAdd"></param>
        /// <returns></returns>
        private static bool PingNetAddress(string strNetAdd)
        {
            Ping ping = new Ping();
            bool Flage;
            try
            {
                PingReply pr = ping.Send(strNetAdd, 3000);
                if (pr.Status == IPStatus.TimedOut)
                {
                    Flage = false;
                }
                if (pr.Status == IPStatus.Success)
                {
                    Flage = true;
                }
                else
                {
                    Flage = false;
                }
            }
            catch
            {
                Flage = false;
            }
            return Flage;
        }
    }

有其它更好的方法，欢迎留言！

WPF 如何正确获取屏幕分辨率

Sun, 19 Apr 2020 12:35:03 +0000

我们知道在WinForm里面，我们可以通过类System.Windows.Forms.Screen.PrimaryScreen.Bounds来获取主屏幕的分辨率。但是在WPF里面，根本没有这个类！

那么在WPF里面怎么获取屏幕分辨率呢？

其实很简单，.net里面提供了获取屏幕各种参数的静态辅助类：SystemParameters。获取主屏幕高度：SystemParameters.PrimaryScreenHeight 获取主屏幕宽度：SystemParameters.PrimaryScreenWidth

但是实际在获取的时候会发现，获取的值和实际分辨率不一致。

以 1920 * 1080 和 125% DPI为例：

分辨率高度：1080，实际获取的高度为：864。分辨率宽度：1920，实际获取的宽度为：1536。

其实我们可以发现，SystemParameters提供的接口，其实是获取渲染过程中的实际高宽，是受系统DPI设置的影响。所以我们在获取分辨率的时候，只需要根据DPI做下处理即可。

以下是完整的实现代码：

    public class ScreenManager
    {
        /// <summary>
        /// 获取DPI百分比
        /// </summary>
        /// <param name="window"></param>
        /// <returns></returns>
        public static double GetDpiRatio(Window window)
        {
            var currentGraphics = Graphics.FromHwnd(new WindowInteropHelper(window).Handle);
            return currentGraphics.DpiX / 96;
        }

        public static double GetDpiRatio()
        {
            return GetDpiRatio(Application.Current.MainWindow);
        }

        public static double GetScreenHeight()
        {
            return SystemParameters.PrimaryScreenHeight * GetDpiRatio();
        }

        public static double GetScreenActualHeight()
        {
            return SystemParameters.PrimaryScreenHeight;
        }

        public static double GetScreenWidth()
        {
            return SystemParameters.PrimaryScreenWidth * GetDpiRatio();
        }

        public static double GetScreenActualWidth()
        {
            return SystemParameters.PrimaryScreenWidth;
        }
    }

如果要获取屏幕分辨率，直接调用 ScreenManager.GetScreenWidth和ScreenManager.GetScreenHeight方法,反之调用ScreenManager.GetScreenActualWidth和ScreenManager.GetScreenActualHeight方法。

WPF通过附加属性给控件修改样式

Sat, 18 Apr 2020 12:35:03 +0000

为了让我们WPF控件样式能够重复利用和解耦，我们可以通过附加属性来给我们的样式添加扩展。今天就带大家看看如果使用扩展属性来定制样式！

假设一种应用场景：我们需要做一个状态按钮控件，但鼠标按下去的时候，呈现一种图片，弹起来的时候呈现一种图片。所以我们给他加两个附加属性：PressedIcon,ReleasedIcon.

先定义两个附加属性：

    public class UIHelper
    {
        /// <summary>
        /// 默认图标附加属性
        /// </summary>
        public readonly static DependencyProperty PressedIconProperty = DependencyProperty.RegisterAttached("PressedIcon", typeof(ImageSource), typeof(UIHelper));

        /// <summary>
        /// 
        /// </summary>
        /// <param name="frameworkElement"></param>
        /// <returns></returns>
        public static ImageSource GetPressedIcon(FrameworkElement frameworkElement)
        {
            return (ImageSource)frameworkElement.GetValue(PressedIconProperty);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="frameworkElement"></param>
        /// <param name="value"></param>
        public static void SetPressedIcon(FrameworkElement frameworkElement, ImageSource value)
        {
            frameworkElement.SetValue(PressedIconProperty, value);
        }

        public readonly static DependencyProperty ReleasedIconProperty = DependencyProperty.RegisterAttached("ReleasedIcon", typeof(ImageSource), typeof(UIHelper));

        /// <summary>
        /// 
        /// </summary>
        /// <param name="frameworkElement"></param>
        /// <returns></returns>
        public static ImageSource GetReleasedIcon(FrameworkElement frameworkElement)
        {
            return (ImageSource)frameworkElement.GetValue(ReleasedIconProperty);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="frameworkElement"></param>
        /// <param name="value"></param>
        public static void SetReleasedIcon(FrameworkElement frameworkElement, ImageSource value)
        {
            frameworkElement.SetValue(ReleasedIconProperty, value);
        }
    ｝

附加属性定义好后，我们只需要在Xaml代码中引用他们，并给予赋值。

RadioButton示例样式：

    <Style x:Key="RadioButtonStyle" TargetType="{x:Type RadioButton}">
        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
        <Setter Property="Background" Value="Transparent"/>
        <Setter Property="BorderBrush" Value="Transparent"/>
        <Setter Property="Foreground" Value="Transparent"/>
        <Setter Property="BorderThickness" Value="0"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type RadioButton}">
                    <Grid x:Name="markGrid" Background="Transparent">
                        <Ellipse x:Name="optionMark" Fill="Transparent" Width="{Binding ActualHeight, RelativeSource={RelativeSource Mode=Self}}"/>
                        <Image x:Name="img" Margin="{Binding ActualHeight,RelativeSource={RelativeSource Mode=TemplatedParent},Converter={StaticResource EllipseMarginConverter}}" Source="{Binding Path=(helper:UIHelper.ReleasedIcon),RelativeSource={ RelativeSource Mode=TemplatedParent}}"/>
                    </Grid>
                    <ControlTemplate.Triggers>
                        <Trigger Property="IsMouseOver" Value="true">
                            <Setter Property="Fill" TargetName="optionMark" Value="{StaticResource RadioButton.MouseOver.Glyph}"/>
                        </Trigger>
                        <Trigger Property="IsPressed" Value="true">
                            <Setter Property="Fill" TargetName="optionMark" Value="{StaticResource RadioButton.Pressed.Glyph}"/>
                        </Trigger>
                        <Trigger Property="IsChecked" Value="true">
                            <Setter Property="Source" TargetName="img" Value="{Binding Path=(helper:UIHelper.PressedIcon),RelativeSource={RelativeSource Mode=TemplatedParent}}"/>
                            <Setter Property="Fill" Value="{StaticResource RadioButton.MouseOver.Glyph}" TargetName="optionMark"/>
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

在我们控件中使用他们：

<UserControl x:Class="Hilk.InkMarker.UserControl1"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:helper="clr-namespace:test.XamlUI"
             mc:Ignorable="d" 
             d:DesignHeight="450" d:DesignWidth="800">

    <!--此处省略静态资源字典的引入，包含：PressedIcon和ReleasedIcon-->

    <Grid>
        <RadioButton Style="{StaticResource  RadioButtonStyle}" helper:UIHelper.PressedIcon="{StaticResource PressedIcon}" helper:UIHelper.ReleasedIcon="{StaticResource ReleasedIcon}"/>
    </Grid>
</UserControl> 

这样就可以通过附加属性，给我们的控件定制化样式了。

如何替换ToggleButton的默认鼠标移入或者按下样式

Tue, 31 Mar 2020 12:35:03 +0000

WPF有段时间没有做界面了，温故而知新，重新复习下模版相关知识。这里只以ToggleButton的模版举例！

代码不清真不重要，本博客主要是想演示下，如何修改Button在鼠标移入或者按下时的样式。
直接看代码：

<Style x:Key="ToggleButtonStyle" TargetType="ToggleButton">
                <Style.Setters>
                    <Setter Property="Template">
                        <Setter.Value>
                            <ControlTemplate>
                                <Border Background="{TemplateBinding Property=Background }" BorderBrush="Transparent">
                                    <Image Source="{Binding RelativeSource={RelativeSource AncestorType=UserControl}, Path=CurrentIcon}"/>
                                </Border>
                            </ControlTemplate>
                        </Setter.Value>
                    </Setter>
                    <Setter Property="Background" Value="Transparent"/>
                </Style.Setters>
                <Style.Triggers>
                    <Trigger Property="IsMouseOver" Value="True">
                        <Setter Property="Background" Value="Transparent"/>
                    </Trigger>
                    <Trigger Property="IsPressed" Value="True">
                        <Setter Property="Background" Value="Transparent"/>
                    </Trigger>
                </Style.Triggers>
            </Style>           

代码其实很简单，我们给ToggleButton定义了一个Style样式，重写了Template的模版属性。

这里我们重点看下Border的Background属性中，我们是使用TemplateBinding。这样我们在后面的Style.Triggers中，才可以修改IsMouseOver和IsPressed触发器中设置的背景颜色。

控件默认的颜色设置是通过VisualStateManager来修改的，如果我们不使用TemplateBinding来绑定Background的话，我们就无法修改到原有的依赖项属性值，从而导致我们的修改无效。

WPF迁移至WPF Core 之生成操作

Thu, 19 Mar 2020 07:35:03 +0000

.net core 3.x开始，已经支持WPF了。我们可以将原有的小型项目迁移到.net core平台了。迁移过程中可能会遇到各种问题，本次我们只分享资源文件可能遇到的问题。

.net framework和.net core之间还是存在一些差异的，最明显的就是csproj文件了。在.net core里面，我们能发现csproj文件变得清爽了很多。

为什么会变得如此清爽？因为繁杂的配置都丢<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">里面了。

原理参见：https://blog.lindexi.com/post/WPF-%E8%AE%B2%E8%AE%B2-Microsoft.NET.Sdk.WindowsDesktop-%E7%9A%84%E5%8E%9F%E7%90%86.html。

包括AssemblyInfo.cs文件也变得非常简单了，因为它部分内容也放到公共部分了。（这些本次不讨论）

实际上迁移过程中，绝大部分的文件，我们都可以直接迁移过来，当我们在编译的时候，就会发现有些编译不通过，比较常见的问题就是类找不到，通常只需要寻找nuget包即可解决，vs会有提示。

我们也会遇到一些资源文件迁移后，会出现资源找不到的情况，如下图所示：

其实原因很简单，因为文件放到wpf core里面，默认生成操作是无，只需要将资源文件的生成操作改成资源即可。 改完以后切记要重新编译，不然会导致修改无效的假象

就结束了？这也太少了吧！好吧，再来回忆下生成操作！生成操作是Visual Studio针对不同的文件类型所做的处理方式。如：编译，资源，内容，嵌入的资源等等。有些操作是针对整个.net平台适用，有些是针对WPF适用，则有些是针对WF适用。

可选项：

具体说明：

如何模拟键盘按键

Sat, 14 Mar 2020 04:35:03 +0000

虚拟键盘可以模拟大多数点快捷键，使用起来非常方便实用。比如说Alt + F4 (关闭程序), LCtrl + LWin + D (新建桌面)，LCtrl +LWin + F4 (删除桌面)，LWin + D （显示桌面）等。通过快捷键，我们可以实现各种有趣点功能。

废话不多说，具体实现如下：

    /// <summary>
    /// 虚拟键盘
    /// </summary>
    public class VirtualKeyboard
    {
        /// <summary>
        /// 模拟发送键盘消息
        /// </summary>
        /// <param name="keys">虚拟键码</param>
        /// <param name="bScan">硬件扫描码，一般设置为0</param>
        /// <param name="dwFlags">函数操作的一个标志位，如果值为KEYEVENTF_EXTENDEDKEY（0）则该键被按下，如果值为KEYEVENTF_KEYUP（2）则该按键被释放</param>
        /// <param name="dwExtraInfo">定义与击键相关的附加的32位值，通常为0</param>
        [DllImport("user32.dll", EntryPoint = "keybd_event")]
        private static extern void keybd_event(byte keys, byte bScan, int dwFlags, int dwExtraInfo);

        /// <summary>
        /// 发送单一按键
        /// </summary>
        /// <param name="key"></param>
        public static void SendKey(KeyboardKeys key)
        {
            keybd_event((byte)key, 0, 0, 0);
            keybd_event((byte)key, 0, 2, 0);
        }

        /// <summary>
        /// 发送组合键
        /// </summary>
        /// <param name="keys"></param>
        public static void SendCompositeKey(params KeyboardKeys[] keys)
        {
            foreach (var key in keys)
            {
                keybd_event((byte)key, 0, 0, 0);
            }

            foreach (var key in keys)
            {
                keybd_event((byte)key, 0, 2, 0);
            }
        }
    }

    public enum KeyboardKeys
    {
        //
        // 摘要:
        //     若要从一个密钥值中提取修饰符位掩码。
        Modifiers = -65536,
        //
        // 摘要:
        //     不按任何键。
        None = 0,
        //
        // 摘要:
        //     鼠标左键。
        LButton = 1,
        //
        // 摘要:
        //     鼠标右键按钮中。
        RButton = 2,
        //
        // 摘要:
        //     CANCEL 键。
        Cancel = 3,
        //
        // 摘要:
        //     鼠标中键 （三个按钮的鼠标）。
        MButton = 4,
        //
        // 摘要:
        //     第一个 x 鼠标按钮 （五个按钮的鼠标）。
        XButton1 = 5,
        //
        // 摘要:
        //     第二个鼠标按钮 （五个按钮的鼠标） x。
        XButton2 = 6,
        //
        // 摘要:
        //     BACKSPACE 键。
        Back = 8,
        //
        // 摘要:
        //     TAB 键。
        Tab = 9,
        //
        // 摘要:
        //     LINEFEED 键。
        LineFeed = 10,
        //
        // 摘要:
        //     CLEAR 键。
        Clear = 12,
        //
        // 摘要:
        //     RETURN 键。
        Return = 13,
        //
        // 摘要:
        //     ENTER 键。
        Enter = 13,
        //
        // 摘要:
        //     SHIFT 键。
        ShiftKey = 16,
        //
        // 摘要:
        //     CTRL 键。
        ControlKey = 17,
        //
        // 摘要:
        //     ALT 键。
        Menu = 18,
        //
        // 摘要:
        //     PAUSE 键。
        Pause = 19,
        //
        // 摘要:
        //     CAPS LOCK 键。
        Capital = 20,
        //
        // 摘要:
        //     CAPS LOCK 键。
        CapsLock = 20,
        //
        // 摘要:
        //     IME Kana 模式键。
        KanaMode = 21,
        //
        // 摘要:
        //     IME Hanguel 模式键。 (保留为了兼容; 使用HangulMode)
        HanguelMode = 21,
        //
        // 摘要:
        //     IME Hangul 模式键。
        HangulMode = 21,
        //
        // 摘要:
        //     IME Junja 模式键。
        JunjaMode = 23,
        //
        // 摘要:
        //     IME 最终模式键。
        FinalMode = 24,
        //
        // 摘要:
        //     IME Hanja 模式键。
        HanjaMode = 25,
        //
        // 摘要:
        //     IME Kanji 模式键。
        KanjiMode = 25,
        //
        // 摘要:
        //     ESC 键。
        Escape = 27,
        //
        // 摘要:
        //     IME convert 键。
        IMEConvert = 28,
        //
        // 摘要:
        //     IME nonconvert 键。
        IMENonconvert = 29,
        //
        // 摘要:
        //     IME 接受密钥，替换System.Windows.Forms.Keys.IMEAceept。
        IMEAccept = 30,
        //
        // 摘要:
        //     IME 接受密钥。 已过时，请System.Windows.Forms.Keys.IMEAccept相反。
        IMEAceept = 30,
        //
        // 摘要:
        //     IME 模式更改密钥。
        IMEModeChange = 31,
        //
        // 摘要:
        //     SPACEBAR 键。
        Space = 32,
        //
        // 摘要:
        //     PAGE UP 键。
        Prior = 33,
        //
        // 摘要:
        //     PAGE UP 键。
        PageUp = 33,
        //
        // 摘要:
        //     PAGE DOWN 键。
        Next = 34,
        //
        // 摘要:
        //     PAGE DOWN 键。
        PageDown = 34,
        //
        // 摘要:
        //     END 键。
        End = 35,
        //
        // 摘要:
        //     HOME 键。
        Home = 36,
        //
        // 摘要:
        //     LEFT ARROW 键。
        Left = 37,
        //
        // 摘要:
        //     UP ARROW 键。
        Up = 38,
        //
        // 摘要:
        //     RIGHT ARROW 键。
        Right = 39,
        //
        // 摘要:
        //     DOWN ARROW 键。
        Down = 40,
        //
        // 摘要:
        //     SELECT 键。
        Select = 41,
        //
        // 摘要:
        //     PRINT 键。
        Print = 42,
        //
        // 摘要:
        //     EXECUTE 键。
        Execute = 43,
        //
        // 摘要:
        //     PRINT SCREEN 键。
        Snapshot = 44,
        //
        // 摘要:
        //     PRINT SCREEN 键。
        PrintScreen = 44,
        //
        // 摘要:
        //     INS 键。
        Insert = 45,
        //
        // 摘要:
        //     DEL 键。
        Delete = 46,
        //
        // 摘要:
        //     HELP 键。
        Help = 47,
        //
        // 摘要:
        //     0 键。
        D0 = 48,
        //
        // 摘要:
        //     1 键。
        D1 = 49,
        //
        // 摘要:
        //     2 键。
        D2 = 50,
        //
        // 摘要:
        //     3 键。
        D3 = 51,
        //
        // 摘要:
        //     4 键。
        D4 = 52,
        //
        // 摘要:
        //     5 键。
        D5 = 53,
        //
        // 摘要:
        //     6 键。
        D6 = 54,
        //
        // 摘要:
        //     7 键。
        D7 = 55,
        //
        // 摘要:
        //     8 键。
        D8 = 56,
        //
        // 摘要:
        //     9 键。
        D9 = 57,
        //
        // 摘要:
        //     A 键。
        A = 65,
        //
        // 摘要:
        //     B 键。
        B = 66,
        //
        // 摘要:
        //     C 键。
        C = 67,
        //
        // 摘要:
        //     D 键。
        D = 68,
        //
        // 摘要:
        //     E 键。
        E = 69,
        //
        // 摘要:
        //     F 键。
        F = 70,
        //
        // 摘要:
        //     G 键。
        G = 71,
        //
        // 摘要:
        //     H 键。
        H = 72,
        //
        // 摘要:
        //     I 键。
        I = 73,
        //
        // 摘要:
        //     J 键。
        J = 74,
        //
        // 摘要:
        //     K 键。
        K = 75,
        //
        // 摘要:
        //     L 键。
        L = 76,
        //
        // 摘要:
        //     M 键。
        M = 77,
        //
        // 摘要:
        //     N 键。
        N = 78,
        //
        // 摘要:
        //     O 键。
        O = 79,
        //
        // 摘要:
        //     P 键。
        P = 80,
        //
        // 摘要:
        //     Q 键。
        Q = 81,
        //
        // 摘要:
        //     R 键。
        R = 82,
        //
        // 摘要:
        //     S 键。
        S = 83,
        //
        // 摘要:
        //     T 键。
        T = 84,
        //
        // 摘要:
        //     U 键。
        U = 85,
        //
        // 摘要:
        //     V 键。
        V = 86,
        //
        // 摘要:
        //     W 键。
        W = 87,
        //
        // 摘要:
        //     X 键。
        X = 88,
        //
        // 摘要:
        //     Y 键。
        Y = 89,
        //
        // 摘要:
        //     Z 键。
        Z = 90,
        //
        // 摘要:
        //     左 Windows 徽标键 (Microsoft Natural Keyboard)。
        LWin = 91,
        //
        // 摘要:
        //     右 Windows 徽标键 (Microsoft Natural Keyboard)。
        RWin = 92,
        //
        // 摘要:
        //     应用程序密钥 (Microsoft Natural Keyboard)。
        Apps = 93,
        //
        // 摘要:
        //     计算机休眠键。
        Sleep = 95,
        //
        // 摘要:
        //     数字键盘上的 0 键。
        NumPad0 = 96,
        //
        // 摘要:
        //     数字键盘上的 1 键。
        NumPad1 = 97,
        //
        // 摘要:
        //     数字键盘上的 2 键。
        NumPad2 = 98,
        //
        // 摘要:
        //     数字键盘上的 3 键。
        NumPad3 = 99,
        //
        // 摘要:
        //     数字键盘上的 4 键。
        NumPad4 = 100,
        //
        // 摘要:
        //     数字键盘上的 5 键。
        NumPad5 = 101,
        //
        // 摘要:
        //     数字键盘上的 6 键。
        NumPad6 = 102,
        //
        // 摘要:
        //     数字键盘上的 7 键。
        NumPad7 = 103,
        //
        // 摘要:
        //     数字键盘上的 8 键。
        NumPad8 = 104,
        //
        // 摘要:
        //     数字键盘上的 9 键。
        NumPad9 = 105,
        //
        // 摘要:
        //     乘号键。
        Multiply = 106,
        //
        // 摘要:
        //     加号键。
        Add = 107,
        //
        // 摘要:
        //     分隔符键。
        Separator = 108,
        //
        // 摘要:
        //     减号键。
        Subtract = 109,
        //
        // 摘要:
        //     句点键。
        Decimal = 110,
        //
        // 摘要:
        //     除号键。
        Divide = 111,
        //
        // 摘要:
        //     F1 键。
        F1 = 112,
        //
        // 摘要:
        //     F2 键。
        F2 = 113,
        //
        // 摘要:
        //     F3 键。
        F3 = 114,
        //
        // 摘要:
        //     F4 键。
        F4 = 115,
        //
        // 摘要:
        //     F5 键。
        F5 = 116,
        //
        // 摘要:
        //     F6 键。
        F6 = 117,
        //
        // 摘要:
        //     F7 键。
        F7 = 118,
        //
        // 摘要:
        //     F8 键。
        F8 = 119,
        //
        // 摘要:
        //     F9 键。
        F9 = 120,
        //
        // 摘要:
        //     F10 键。
        F10 = 121,
        //
        // 摘要:
        //     F11 键。
        F11 = 122,
        //
        // 摘要:
        //     F12 键。
        F12 = 123,
        //
        // 摘要:
        //     F13 键。
        F13 = 124,
        //
        // 摘要:
        //     F14 键。
        F14 = 125,
        //
        // 摘要:
        //     F15 键。
        F15 = 126,
        //
        // 摘要:
        //     F16 键。
        F16 = 127,
        //
        // 摘要:
        //     F17 键。
        F17 = 128,
        //
        // 摘要:
        //     F18 键。
        F18 = 129,
        //
        // 摘要:
        //     F19 键。
        F19 = 130,
        //
        // 摘要:
        //     F20 键。
        F20 = 131,
        //
        // 摘要:
        //     F21 键。
        F21 = 132,
        //
        // 摘要:
        //     F22 键。
        F22 = 133,
        //
        // 摘要:
        //     F23 键。
        F23 = 134,
        //
        // 摘要:
        //     F24 键。
        F24 = 135,
        //
        // 摘要:
        //     NUM LOCK 键。
        NumLock = 144,
        //
        // 摘要:
        //     SCROLL LOCK 键。
        Scroll = 145,
        //
        // 摘要:
        //     左的 SHIFT 键。
        LShiftKey = 160,
        //
        // 摘要:
        //     右 SHIFT 键。
        RShiftKey = 161,
        //
        // 摘要:
        //     左 CTRL 键。
        LControlKey = 162,
        //
        // 摘要:
        //     右 CTRL 键。
        RControlKey = 163,
        //
        // 摘要:
        //     左 ALT 键。
        LMenu = 164,
        //
        // 摘要:
        //     右 ALT 键。
        RMenu = 165,
        //
        // 摘要:
        //     浏览器后退键 (Windows 2000 或更高版本)。
        BrowserBack = 166,
        //
        // 摘要:
        //     浏览器前进键 (Windows 2000 或更高版本)。
        BrowserForward = 167,
        //
        // 摘要:
        //     浏览器刷新键 (Windows 2000 或更高版本)。
        BrowserRefresh = 168,
        //
        // 摘要:
        //     浏览器停止键 (Windows 2000 或更高版本)。
        BrowserStop = 169,
        //
        // 摘要:
        //     浏览器搜索键 (Windows 2000 或更高版本)。
        BrowserSearch = 170,
        //
        // 摘要:
        //     浏览器收藏键 (Windows 2000 或更高版本)。
        BrowserFavorites = 171,
        //
        // 摘要:
        //     浏览器主页键 (Windows 2000 或更高版本)。
        BrowserHome = 172,
        //
        // 摘要:
        //     卷静音键 (Windows 2000 或更高版本)。
        VolumeMute = 173,
        //
        // 摘要:
        //     音量降低键 (Windows 2000 或更高版本)。
        VolumeDown = 174,
        //
        // 摘要:
        //     音量增大键 (Windows 2000 或更高版本)。
        VolumeUp = 175,
        //
        // 摘要:
        //     媒体下一曲目键 (Windows 2000 或更高版本)。
        MediaNextTrack = 176,
        //
        // 摘要:
        //     媒体上一曲目键 (Windows 2000 或更高版本)。
        MediaPreviousTrack = 177,
        //
        // 摘要:
        //     媒体停止键 (Windows 2000 或更高版本)。
        MediaStop = 178,
        //
        // 摘要:
        //     在媒体播放暂停键 (Windows 2000 或更高版本)。
        MediaPlayPause = 179,
        //
        // 摘要:
        //     启动邮件键 (Windows 2000 或更高版本)。
        LaunchMail = 180,
        //
        // 摘要:
        //     选择媒体键 (Windows 2000 或更高版本) 中。
        SelectMedia = 181,
        //
        // 摘要:
        //     启动应用程序一个键 (Windows 2000 或更高版本)。
        LaunchApplication1 = 182,
        //
        // 摘要:
        //     启动应用程序两个键 (Windows 2000 或更高版本)。
        LaunchApplication2 = 183,
        //
        // 摘要:
        //     美国标准键盘 (Windows 2000 或更高版本) 上的 OEM 分号键。
        OemSemicolon = 186,
        //
        // 摘要:
        //     OEM 1 键。
        Oem1 = 186,
        //
        // 摘要:
        //     OEM 加上任何国家/地区键盘 (Windows 2000 或更高版本) 上的密钥。
        Oemplus = 187,
        //
        // 摘要:
        //     任何国家/地区键盘 (Windows 2000 或更高版本) 上的 OEM 逗号键。
        Oemcomma = 188,
        //
        // 摘要:
        //     OEM 减号键 (Windows 2000 或更高版本) 任何国家/地区键盘上。
        OemMinus = 189,
        //
        // 摘要:
        //     任何国家/地区键盘 (Windows 2000 或更高版本) 上的 OEM 期间键。
        OemPeriod = 190,
        //
        // 摘要:
        //     美国标准键盘 (Windows 2000 或更高版本) 上的 OEM 问号键。
        OemQuestion = 191,
        //
        // 摘要:
        //     OEM 2 键。
        Oem2 = 191,
        //
        // 摘要:
        //     美国标准键盘 (Windows 2000 或更高版本) 上的 OEM 颚化符键。
        Oemtilde = 192,
        //
        // 摘要:
        //     OEM 3 键。
        Oem3 = 192,
        //
        // 摘要:
        //     美国标准键盘 (Windows 2000 或更高版本) 上的 OEM 左大括号键。
        OemOpenBrackets = 219,
        //
        // 摘要:
        //     OEM 4 键。
        Oem4 = 219,
        //
        // 摘要:
        //     美国标准键盘 (Windows 2000 或更高版本) 上的 OEM 管道键。
        OemPipe = 220,
        //
        // 摘要:
        //     OEM 5 键。
        Oem5 = 220,
        //
        // 摘要:
        //     美国标准键盘 (Windows 2000 或更高版本) 上的 OEM 右大括号键。
        OemCloseBrackets = 221,
        //
        // 摘要:
        //     OEM 6 键。
        Oem6 = 221,
        //
        // 摘要:
        //     OEM 意见/双精度型引号密钥美国标准键盘 (Windows 2000 或更高版本) 上。
        OemQuotes = 222,
        //
        // 摘要:
        //     OEM 7 键。
        Oem7 = 222,
        //
        // 摘要:
        //     OEM 8 键。
        Oem8 = 223,
        //
        // 摘要:
        //     OEM 尖括号或 RT 102 键键盘 (Windows 2000 或更高版本) 上的反斜杠键。
        OemBackslash = 226,
        //
        // 摘要:
        //     OEM 102 键。
        Oem102 = 226,
        //
        // 摘要:
        //     PROCESS 键键中。
        ProcessKey = 229,
        //
        // 摘要:
        //     用于传递 Unicode 字符，就像它们是击键一样。 Packet 键值是用于非键盘输入方法的 32 位虚拟密钥值的低位字。
        Packet = 231,
        //
        // 摘要:
        //     ATTN 键。
        Attn = 246,
        //
        // 摘要:
        //     CRSEL 键。
        Crsel = 247,
        //
        // 摘要:
        //     EXSEL 键。
        Exsel = 248,
        //
        // 摘要:
        //     ERASE EOF 键。
        EraseEof = 249,
        //
        // 摘要:
        //     播放键。
        Play = 250,
        //
        // 摘要:
        //     缩放键。
        Zoom = 251,
        //
        // 摘要:
        //     留待将来使用的常数。
        NoName = 252,
        //
        // 摘要:
        //     PA1 键。
        Pa1 = 253,
        //
        // 摘要:
        //     CLEAR 键。
        OemClear = 254,
        //
        // 摘要:
        //     从一个密钥值中提取键代码的位屏蔽。
        KeyCode = 65535,
        //
        // 摘要:
        //     SHIFT 修改键。
        Shift = 65536,
        //
        // 摘要:
        //     CTRL 修改键。
        Control = 131072,
        //
        // 摘要:
        //     ALT 修改键。
        Alt = 262144
    }

如何获取进程或dll的ico图标

Sat, 14 Mar 2020 03:35:03 +0000

大家有没有发现，我们任意一个软件发送到桌面快捷方式，就可以有个清晰的图标展示出来。当我们在系统桌面通过右键菜单“查看”来切换图标时，选择大图标依然可以很清晰的显示出来。这是为什么呢？我们通过C#能不能获取这些图标呢？今天就来给大家答疑解惑！

背景

当我们要实现一个功能，用来显示桌面上的应用程序，或者管理第三方应用程序。这个时候，我们需要将应用程序自带的图标在管理软件中显示出来，因为这样，我们才能让用户知道自己想要的软件在什么位置。但是这些图标从哪里来，怎么获取就是我们面临的问题了（当然，我们可以通过第三方软件把图标给扣出来）。

为什么图标调整大小后可以这么清晰，难道是因为图标本身就很大？

大家应该还记得，在VS中，我们每个应用程序都可以设置图标：打开visual studio，选中解决方案 -> 右键属性 -> 应用程序 -> 浏览选择图标。

我们会发现，我们能浏览的图标必须是ico格式。为什么不能选择PNG格式呢？

其实ico格式文件，是一组图片集合，也就是对应系统api中的：ImageList。我们可以任意找一个ico图标，我们会发现ico图标的大小会比通常的jpg,png等格式的图片更大。我们用visual studio打开查看，我们会发现，其实ico图标里面是有一组图标，可以是png、jpg、bmp等格式。分辨率包含有：16 * 16、24 * 24、32 * 32、48 * 48、64 * 64、 128 * 128,甚至是256 * 256！难怪可以这么清晰！ exe或dll资源也可用ResourceHacker工具打开，能看到更多详细信息和图标。

如何通用`csharp`获取系统图标

获取图标的方法有好几种

通过 System.Drawing.Icon.ExtractAssociatedIcon(filename) 获取
通过 windows api ExtractIconEx 获取
通过 windows api SHGetFileInfo等组合方法获取

注意：Icon格式的图标文件，可以通过ToBitmap()方法，将其转换成winform和wpf程序使用。

System.Drawing.Icon.ExtractAssociatedIcon(filename)

该方法比较简单，只需要引入dll System.Drawing.dll，调用此方法，传入文件路径即可返回Icon格式的图标文件。
该方法获取的图标大小不确定，跟图标的索引有关，针对部分图标会存在获取失败或者崩溃的现象。
该方法无法对参数做过多的设置，难以满足业务要求。

方法内部实现也是调用系统api：

Declare Function ExtractAssociatedIcon Lib "shell32.dll" Alias "ExtractAssociateIconA" (ByVal hInst As Long, ByVal lpIconPath As String, lpiIcon As Long) As Long

通过ExtractIconEx获取

ExtractIconEx方法也是通过调用系统 shell32.dll 中的 api来实现。
具体调用方式如下：

[DllImport("shell32.dll")]
public static extern int ExtractIconEx(string lpszFile, int niconIndex, IntPtr[] phiconLarge, IntPtr[] phiconSmall, int nIcons);

方法名	描述
lpszFile	表示文件路径
niconIndex	表示图标索引
phiconLarge	指向图标句柄数组的指针，它可接收从文件获取的大图标的句柄。如果该参数是NULL没有从文件抽取大图标。
phiconSmall	指向图标句柄数组的指针，它可接收从文件获取的小图标的句柄。如果该参数是NULL，没有从文件抽取小图标。
nIcons	指定要从文件中抽取图标的数目

调用示例

        private static void ExtractIconToPng(string appPath, string saveFileName)
        {
            int IconCount = Shell32.ExtractIconEx(appPath, -1, null, null, 0);

            var largeIcons = new IntPtr[IconCount];

            var smallIcons = new IntPtr[IconCount];

            Shell32.ExtractIconEx(appPath, 1, largeIcons, smallIcons, IconCount);

            for (int i = 0; i < IconCount; i++)
            {
                var icon = Icon.FromHandle(largeIcons[i]);
                var bitmap = icon.ToBitmap();

                var fs = new FileStream(saveFileName, FileMode.Create);

                var ic2 = System.Drawing.Icon.ExtractAssociatedIcon(appPath);

                ic2.ToBitmap().Save(fs, System.Drawing.Imaging.ImageFormat.Png);
                fs.Close();
            }
        }

该方法不好获取到想要得图标，尤其是256*256这么大的图标。那么继续往下看第三种方法。

通过 SHGetFileInfo 方法获取

基本调用API

        [DllImport("shell32.dll", EntryPoint = "#727")]
        public extern static int SHGetImageList(int iImageList, ref Guid riid, ref IImageList ppv);

        [DllImport("user32.dll", EntryPoint = "DestroyIcon", SetLastError = true)]
        public static extern int DestroyIcon(IntPtr hIcon);

        [DllImport("shell32.dll")]
        public static extern uint SHGetIDListFromObject([MarshalAs(UnmanagedType.IUnknown)] object iUnknown, out IntPtr ppidl);

        [DllImport("Shell32.dll")]
        public static extern IntPtr SHGetFileInfo(string pszPath, uint dwFileAttributes, ref SHFILEINFO psfi, uint cbFileInfo, uint uFlags);

        

常量的定义：

        public const int SHIL_LARGE = 0x0;
        public const int SHIL_SMALL = 0x1;
        public const int SHIL_EXTRALARGE = 0x2;
        public const int SHIL_SYSSMALL = 0x3;
        public const int SHIL_JUMBO = 0x4;
        public const int SHIL_LAST = 0x4;

        public const int ILD_TRANSPARENT = 0x00000001;
        public const int ILD_IMAGE = 0x00000020;

定义好方法所需要的结构体

 [Flags]
    public enum SHGFI : uint
    {
        /// <summary>get icon</summary>
        Icon = 0x000000100,
        /// <summary>get display name</summary>
        DisplayName = 0x000000200,
        /// <summary>get type name</summary>
        TypeName = 0x000000400,
        /// <summary>get attributes</summary>
        Attributes = 0x000000800,
        /// <summary>get icon location</summary>
        IconLocation = 0x000001000,
        /// <summary>return exe type</summary>
        ExeType = 0x000002000,
        /// <summary>get system icon index</summary>
        SysIconIndex = 0x000004000,
        /// <summary>put a link overlay on icon</summary>
        LinkOverlay = 0x000008000,
        /// <summary>show icon in selected state</summary>
        Selected = 0x000010000,
        /// <summary>get only specified attributes</summary>
        Attr_Specified = 0x000020000,
        /// <summary>get large icon</summary>
        LargeIcon = 0x000000000,
        /// <summary>get small icon</summary>
        SmallIcon = 0x000000001,
        /// <summary>get open icon</summary>
        OpenIcon = 0x000000002,
        /// <summary>get shell size icon</summary>
        ShellIconSize = 0x000000004,
        /// <summary>pszPath is a pidl</summary>
        PIDL = 0x000000008,
        /// <summary>use passed dwFileAttribute</summary>
        UseFileAttributes = 0x000000010,
        /// <summary>apply the appropriate overlays</summary>
        AddOverlays = 0x000000020,
        /// <summary>Get the index of the overlay in the upper 8 bits of the iIcon</summary>
        OverlayIndex = 0x000000040,
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct SHFILEINFO
    {
        public const int NAMESIZE = 80;
        public IntPtr hIcon;
        public int iIcon;
        public uint dwAttributes;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
        public string szDisplayName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
        public string szTypeName;
    };

    [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        public int left, top, right, bottom;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
        int x;
        int y;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct IMAGELISTDRAWPARAMS
    {
        public int cbSize;
        public IntPtr himl;
        public int i;
        public IntPtr hdcDst;
        public int x;
        public int y;
        public int cx;
        public int cy;
        public int xBitmap;    // x offest from the upperleft of bitmap
        public int yBitmap;    // y offset from the upperleft of bitmap
        public int rgbBk;
        public int rgbFg;
        public int fStyle;
        public int dwRop;
        public int fState;
        public int Frame;
        public int crEffect;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct IMAGEINFO
    {
        public IntPtr hbmImage;
        public IntPtr hbmMask;
        public int Unused1;
        public int Unused2;
        public RECT rcImage;
    }

    [ComImportAttribute()]
    [GuidAttribute("192B9D83-50FC-457B-90A0-2B82A8B5DAE1")]
    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IImageList
    {
        [PreserveSig]
        int Add(IntPtr hbmImage, IntPtr hbmMask, ref int pi);

        [PreserveSig]
        int ReplaceIcon(int i, IntPtr hicon, ref int pi);

        [PreserveSig]
        int SetOverlayImage(int iImage, int iOverlay);

        [PreserveSig]
        int Replace(int i, IntPtr hbmImage, IntPtr hbmMask);

        [PreserveSig]
        int AddMasked(IntPtr hbmImage, int crMask, ref int pi);

        [PreserveSig]
        int Draw(ref IMAGELISTDRAWPARAMS pimldp);

        [PreserveSig]
        int Remove(int i);

        [PreserveSig]
        int GetIcon(int i, int flags, ref IntPtr picon);

        [PreserveSig]
        int GetImageInfo(int i, ref IMAGEINFO pImageInfo);

        [PreserveSig]
        int Copy(int iDst, IImageList punkSrc, int iSrc, int uFlags);

        [PreserveSig]
        int Merge(int i1, IImageList punk2, int i2, int dx, int dy, ref Guid riid, ref IntPtr ppv);

        [PreserveSig]
        int Clone(ref Guid riid, ref IntPtr ppv);

        [PreserveSig]
        int GetImageRect(int i, ref RECT prc);

        [PreserveSig]
        int GetIconSize(ref int cx, ref int cy);

        [PreserveSig]
        int SetIconSize(int cx, int cy);

        [PreserveSig]
        int GetImageCount(ref int pi);

        [PreserveSig]
        int SetImageCount(int uNewCount);

        [PreserveSig]
        int SetBkColor(int clrBk, ref int pclr);

        [PreserveSig]
        int GetBkColor(ref int pclr);

        [PreserveSig]
        int BeginDrag(int iTrack, int dxHotspot, int dyHotspot);

        [PreserveSig]
        int EndDrag();

        [PreserveSig]
        int DragEnter(IntPtr hwndLock, int x, int y);

        [PreserveSig]
        int DragLeave(IntPtr hwndLock);

        [PreserveSig]
        int DragMove(int x, int y);

        [PreserveSig]
        int SetDragCursorImage(ref IImageList punk, int iDrag, int dxHotspot, int dyHotspot);

        [PreserveSig]
        int DragShowNolock(int fShow);

        [PreserveSig]
        int GetDragImage(ref POINT ppt, ref POINT pptHotspot, ref Guid riid, ref IntPtr ppv);

        [PreserveSig]
        int GetItemFlags(int i, ref int dwFlags);

        [PreserveSig]
        int GetOverlayImage(int iOverlay, ref int piIndex);
    };

调用逻辑：先根据要求获取图标的索引号，在通过图标列表方法，传入索引号来获取符合的图标。

具体调用如下：

        //ImageList Guid 固定死的，com id
        const string IID_IImageList2 = "192B9D83-50FC-457B-90A0-2B82A8B5DAE1";
        
        const string IID_IImageList = "46EB5926-582E-4017-9FDF-E8998DAA0950";

        /// <summary>
        /// 获取图标索引
        /// </summary>
        /// <param name="pszFile"></param>
        /// <returns></returns>
        private static int GetIconIndex(string pszFile)
        {
            SHFILEINFO sfi = new SHFILEINFO();
            Shell32.SHGetFileInfo(pszFile, 0, ref sfi, (uint)Marshal.SizeOf(sfi), (uint)(SHGFI.SysIconIndex | SHGFI.OpenIcon | SHGFI.UseFileAttributes));
            return sfi.iIcon;
        }

        /// <summary>
        /// 获取60*60图标
        /// </summary>
        /// <param name="iImage"></param>
        /// <returns></returns>
        private static Bitmap GetLargeIcon(int iImage)
        {
            IImageList spiml = null;
            Guid guil = new Guid(IID_IImageList);//or IID_IImageList
            Shell32.SHGetImageList(Shell32.SHIL_EXTRALARGE, ref guil, ref spiml);
            IntPtr hIcon = IntPtr.Zero;
            spiml.GetIcon(iImage, Shell32.ILD_TRANSPARENT | Shell32.ILD_IMAGE, ref hIcon);
            var fileIcon = Icon.FromHandle(hIcon).ToBitmap();
            Shell32.DestroyIcon(hIcon);
            return fileIcon;
        }

参数iImageList必须是以下值之一：

SHIL_LARGE（0x0）

图像尺寸通常为32x32像素。但是，如果从“显示属性”的“外观”选项卡的“效果”部分中选择了“使用大图标”选项，则图像为48x48像素。

SHIL_SMALL（0x1）

这些图像是Shell标准的小图标尺寸16x16，但是该尺寸可以由用户自定义。

SHIL_EXTRALARGE（0x2）

这些图像是Shell标准的超大图标尺寸。通常为48x48，但是大小可以由用户自定义。

SHIL_SYSSMALL（0x3）

这些图像是由指定的大小GetSystemMetrics的调用SM_CXSMICON和GetSystemMetrics的调用SM_CYSMICON。

SHIL_JUMBO（0x4）

Windows Vista及更高版本。图像通常为256x256像素。

SHIL_LAST

最大有效标志值，用于验证。

为什么在`GetLargeIcon`方法中，必须是固定的两个`GUID`？

我们可以发现在IImageList接口中，有个 [GuidAttribute("192B9D83-50FC-457B-90A0-2B82A8B5DAE1")]得Attribute，这两个GUID是com标识，底层固定了，因为IMAGELIST有两个，通常使用第一个。接口IImageList也可以标记两个中的任意一个。

参考文献：
https://www.pinvoke.net/default.aspx/shell32.shgetimagelist
https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shgetimagelist

获取系统图标先到这里，如果大家有其它方法，请在下方评论留言。

C++数据类型在C#中的表示方法及其使用

Wed, 22 Jan 2020 03:35:03 +0000

通过C#代码来调用外部程序代码是非常常见的行为，外部程序主要以C语言编译的程序为主。如：windows api,第三方SDK库等。目前大多数的底层些的程序都是使用C++语言开发并以C的方式导出，供外部调用。所以本次我们主要探讨下C++与C#之间的不解之缘。

在调用C++库文件之前，我们首先来了解下两种语言的数据类型对照关系。

基础类型对照表：

C++类型	C#类型	位数	取值范围
bool	bool	8位	0~255
unsigned char	byte	8位	0 ~ 255
[signed] char	sbyte	8位	-128 ~ 127
[signed] int long	int Int32	32位	-2147483648 ~ 2147483647
unsigned int	uint UInt32	32位	0 ~ 4294967295
[signed] short int	short Int16	16位	-32768 ~ 32767
unsigned short int	ushort UInt16	16位	0 ~ 65535
long int	long Int64	64位	-9223372036854775808 ~ 9223372036854775807
unsigned long int	ulong UInt64	64位	0 ~ 18446744073709551615
float	float	32位	-3.40282347E+38f ~ 3.40282347E+38f
double	double	64位	-1.7976931348623157E+308 ~ 1.7976931348623157E+308
long double	double	64位	/
long long	long Int64	64位	/
wchar_t	string	16或32位	/

备注：

int类型根据编译器不同，16位编译器int占2字节，32位和64位编译器，占4字节
C++中，signed int和int是等效的，int默认是有符号的。同样在C#中，int默认是Int32
C#中的char是占用两个字节默认是Unicode编码，C++中的char是占用一个字节。
wchar_t数据类型一般为16位或32位，但不同的C或C++库有不同的规定，如GNU Libc规定wchar_t为32位
C++中的wchar_t 是Unicode编码，char是ANSI编码。C#中的char是占用两个字节，16 位的 Unicode 字符

指针类型对照表：

C++类型	C#类型	描述
void *	IntPtr	`IntPtr可以转换成对应的object类型`
void **	out IntPtr	`表示任意类型指向的指针`
int&	ref int	`表示int类型的引用地址`
int *	ref int	`表示int类型的指针地址`
int[]	int[]	`UnmanagedType.ByValArray` `ArraySubType:UnmanagedType.I4`
int* []	IntPtr[]	`UnmanagedType.ByValArray` `ArraySubType:UnmanagedType.SysUInt`
char *	byte[] IntPtr ref byte	`UnmanagedType.LPArray`
char **	string
const char *	string (const string)
char[n]	string	`UnmanagedType.ByValTStr`

未完待续……

如何通过SQL SERVER访问C#代码

Tue, 21 Jan 2020 10:35:03 +0000

有时候操作SQL SERVER 数据库时，我们需要做一些复杂的算法或者业务逻辑。如果我们用应用程序来实现，就需要将数据查询出来后再插入，必然效率低下。好在SQL SERVER提供了强大的功能，直接调用C#托管代码。

虽然我们不推荐使用这种方法，毕竟会影响程序的移植性和可维护性，但是用来做些小工具还是非常不错的。本次以简单的safe权限以及信任列表方式为例：

具体sql如下：

-- 开启安全配置，表示启用clr的代码访问 0代表不允许，1代表运行

EXEC sp_configure 'clr enabled' , '1';

-- 更新当前运行值：需要注意有些参数的设置需要重启服务，此配置不需要重启服务
RECONFIGURE;

-- 添加到受信任列表：从SQL Server 2017 (14.x)开始，要求强制要求启用安全认证，safe权限等同于unsafe权限。SQL SERVER 2017 可以可以不写这行sql。
DECLARE @hash AS BINARY(64) = (SELECT HASHBYTES('SHA2_512', (SELECT * FROM OPENROWSET (BULK 'C:\xxx\Encrypt.dll', SINGLE_BLOB) AS [Data]))) ;
EXEC sp_add_trusted_assembly @hash;

-- 查看受信任程序，检查有没有添加进去
SELECT * FROM sys.trusted_assemblies;

-- 创建程序集：将需要引用的程序集添加到数据库，需要注意.net的编译版本。如sql server 2008，只能引用framework 3.0或3.5的版本。
CREATE ASSEMBLY EncryptDll   
FROM 'C:\xxx\Encrypt.dll' WITH PERMISSION_SET = SAFE; -- WITH PERMISSION_SET 指定其执行权限；

-- 创建加密函数：当dll引入的数据库中以后，我们需要在数据库中增加函数来对其发起调用。这里要特别注意参数类型，需要保证参数的长度合理，否则调用过程中会引发异常。
CREATE FUNCTION dbo.Encrypt
(
     @InputString as nvarchar(max)
)
RETURNS nvarchar(max)　　　　　--返回类型
AS EXTERNAL NAME EncryptDll.[MK.EncryptProvider.EncryptProvider].Encrypt ;

-- 创建解密函数
CREATE FUNCTION dbo.Decrypt
(
     @InputString as nvarchar(max)
)
RETURNS nvarchar(max)　　　　　--返回类型
AS EXTERNAL NAME EncryptDll.[MK.EncryptProvider.EncryptProvider].Decrypt ;

-- 测试加密函数，并打印输出
print dbo.Encrypt('测试字符串');

-- 如果dll有更新，那么就需要将dll的hash值重新添加到受信任列表，然后再修改程序集。这里的EncryptDll表示程序集在数据库里面的名称。
ALTER ASSEMBLY  EncryptDll   
FROM 'C:\xxx\Encrypt.dll' WITH PERMISSION_SET = unsafe;

-- 删除程序集：删除程序集需要先把依赖删除，需要先删除函数
DROP ASSEMBLY EncryptDll;

-- 如果存在函数，则删除
if exists(select * from sys.objects where name=[ schema_name. ] function_name)
drop function [ schema_name. ] function_name;

如果数据库中存在多个数据库的情况下，程序集已经创建，那么只需要对其它为创建函数的数据库增加函数即可。

参考文献：
设计程序集 - SQL Server
clr enabled 服务器配置选项 - SQL Server

对应的C#代码

编译后的dll命名为Encrypt.dll,类名为EncryptProvider,命名空间为Encrypt，创建函数时需要以命名空间.类名.方法名的方式表示

注意：数据库的类型很多，我们加密解密要保证字符串的长度不变，所以加密解密的算法也不能直接使用常规的加密解密算法，以下只是一个示例。

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="str">要加密的字符串</param>
        /// <returns>返回加密后的字符串</returns>
        /// 
        public static string Encrypt(string str)
        {
            if (string.IsNullOrEmpty(str)) return str;
            str = str.Trim();
            byte[] crypt = Encoding.Default.GetBytes(str).Select(x => (byte)((x + 10) % 256)).ToArray();
            return Encoding.Default.GetString(crypt);
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="str">要解密的字符串</param>
        /// <returns>返回解密后的字符串</returns>
        /// 
        public static string Decrypt(string str)
        {
            if (string.IsNullOrEmpty(str)) return str;
            var decrypt = Encoding.Default.GetBytes(str);
            byte[] source = decrypt.Select(x => (byte)((x - 10 + 256) % 256)).ToArray();
            return Encoding.Default.GetString(source);
        }

也可以通过对字符做处理，但是这种方法可能会改变字节长度，因为数据库的字符编码不一样。

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="str">要加密的字符串</param>
        /// <returns>返回加密后的字符串</returns>
        public static string Encrypt(string str)
        {
            var sb = new StringBuilder();
            foreach (var c in str)
            {
                sb.Append((char)(c + 8));
            }
            return sb.ToString();
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="str">要解密的字符串</param>
        /// <returns>返回解密后的字符串</returns>
        public static string Decrypt(string str)
        {
            var sb = new StringBuilder();
            foreach (var c in str)
            {
                sb.Append((char)(c - 8));
            }
            return sb.ToString();
        }

CREATE ASSEMBLY 权限设置

权限包含有：SAFE，UNSAFE，EXTERNAL_ACCESS，通过 WITH PERMISSION_SET 来指定。

各权限说明：

SAFE：使用具有 SAFE 权限的程序集运行的代码不能访问外部系统资源（例如文件、网络、环境变量或注册表）。 SAFE 代码可以从本地 SQL Server 数据库访问数据，或执行不涉及访问本地数据库以外资源的计算和业务逻辑。大多数程序集执行计算和数据管理任务，而不需要访问 SQL Server 以外的资源。因此，建议您将 SAFE 作为程序集权限集。

EXTERNAL_ACCESS：EXTERNAL_ACCESS 允许程序集访问某些外部系统资源（例如文件、网络、Web 服务、环境变量和注册表）。只有具有 EXTERNAL ACCESS 权限的 SQL Server 登录名才能创建 EXTERNAL_ACCESS 程序集。SAFE 和 EXTERNAL_ACCESS 程序集只能包含可验证为类型安全的代码。这意味着这些程序集仅可以通过对类型定义有效的具有定义完善的入口点来访问类。因此，它们不能随意访问不属于该代码所有的内存缓冲区。另外，它们不能执行可能对 SQL Server 进程的可靠性具有负面影响的操作。

UNSAFE：UNSAFE 不限制程序集访问资源，包括 SQL Server 以内和以外的资源。在 UNSAFE 程序集内运行的代码可以调用非托管代码。同时，指定 UNSAFE 将允许程序集中的代码执行 CLR 验证工具认为是非安全类型的操作。这些操作可能以非控制的方式访问 SQL Server 进程空间中的内存缓冲区。 UNSAFE 程序集也可能破坏 SQL Server 或公共语言运行时的安全系统。有经验的开发人员或管理员应仅向高度可信的程序集授予 UNSAFE 权限。只有的成员sysadmin固定的服务器角色可以创建 UNSAFE 程序集。

扩展阅读

如果是要授予 EXTERNAL ACCESS ASSEMBLY 或 UNSAFE ASSEMBLY 权限，也可以通过以下方式授予（前面添加信任列表方法也是可行的）。

方法一：

--使用master系统数据库
USE master
--创建非对称密钥
CREATE ASYMMETRIC KEY testkey FROM EXECUTABLE FILE = 'C:\xxx\Encrypt.dll'   
--创建登录名
CREATE LOGIN loginName FROM ASYMMETRIC KEY testkey 
--把权限授予给该登录名  
GRANT EXTERNAL ACCESS ASSEMBLY TO loginName; 

方法二：

-- 将数据库设置为受信任数据库，不建议使用该方式,请参考下方官方文档
ALTER DATABASE dbName SET TRUSTWORTHY ON

参考文献：
TRUSTWORTHY 数据库属性 - SQL Server

设计模式（模板方法）

Thu, 16 Jan 2020 14:35:03 +0000

设计模式是软件开发必备的技能，但是只有少部分小伙伴才会去研究这块的内容。设计模式相关的书籍也比较多，为了让我们的设计模式能在实际工作中得到实践，把工作中运用到的设计模式记录下来。以便日后精益学习。

业务场景说明

当我们在主线程上处理一些业务逻辑时，希望能把部分任务丢到一个异步线程中处理，防止卡UI。但是我们又希望任务能够按照特定的流程或要求执行，如：单任务顺序执行，仅单任务执行等。当然，我们直接在主流程中通过异步方法去实现相关的逻辑也是没有问题的，但是场景越多，情况越多，代码会显得越乱，维护性也会变得越差。于是，我们就需要对它进行一下改造了。

案例

当我们在处理人脸识别的开发过程中，我们需要从视频流中做抽帧处理。通过抽取的帧用来做人脸识别跟踪，活体检测，人脸比对等功能。但是为了避免算法的执行速度，影响视频播放流畅度，于是需要将算法放在异步线程中执行，同时为了避免不必要的运算和并行错误，我们需要将异步任务做串行处理。于是我们就有了以下方法来解决这个问题：

示例代码：单一异步任务调度器（模板类）

    /// <summary>
    /// 单一异步任务调度器
    /// </summary>
    public abstract class SingleAsyncTaskDispatcher
    {
        private CancellationTokenSource _cancellationTokenSource;

        public SingleAsyncTaskDispatcher()
        {
            Status = AsyncTaskStatus.Waiting;
        }

        /// <summary>
        /// 任务启动时执行
        /// </summary>
        protected virtual void OnStarting()
        {
            Status = AsyncTaskStatus.Starting;
        }

        /// <summary>
        /// 任务执行的主体
        /// </summary>
        protected virtual void OnRun()
        {
            Status = AsyncTaskStatus.Running;
        }

        /// <summary>
        /// 任务取消时执行
        /// </summary>
        protected virtual void OnCanceled()
        {
            Status = AsyncTaskStatus.Canceled;
        }

        /// <summary>
        /// 任务完成时执行
        /// </summary>
        protected virtual void OnCompleted()
        {
            Status = AsyncTaskStatus.Completed;
        }

        /// <summary>
        /// 当前任务状态
        /// </summary>
        public AsyncTaskStatus Status
        {
            get; private set;
        }

        /// <summary>
        /// 是否允许启动一个新任务
        /// </summary>
        bool CanStartNew
        {
            get
            {
                return Status.Equals(AsyncTaskStatus.Completed) || Status.Equals(AsyncTaskStatus.Canceled) || Status.Equals(AsyncTaskStatus.Waiting);
            }
        }

        /// <summary>
        /// 任务令牌，只有存在任务时才存在令牌
        /// </summary>
        public CancellationToken? TaskToken
        {
            get
            {
                return _cancellationTokenSource?.Token;
            }
        }

        /// <summary>
        /// 尝试运行一个新的任务，如果任务正忙，则任务不会启动
        /// </summary>
        /// <param name="action"></param>
        /// <returns></returns>
        public bool TryStartNew()
        {
            if (CanStartNew)
            {
                _cancellationTokenSource = new CancellationTokenSource();
                OnStarting();
                Task.Run(() =>
                {
                    OnRun();
                }, _cancellationTokenSource.Token)
                .ContinueWith((t) =>
                {
                    if (_cancellationTokenSource.Token.IsCancellationRequested)
                    {
                        _cancellationTokenSource = null;
                        OnCanceled();
                    }
                    else
                    {
                        _cancellationTokenSource = null;
                        OnCompleted();
                    }
                });
                return true;
            }

            return false;
        }

        /// <summary>
        /// 取消任务
        /// </summary>
        public void Cancel()
        {
            _cancellationTokenSource?.Cancel();
        }
    }

    /// <summary>
    /// 异步任务状态
    /// </summary>
    public enum AsyncTaskStatus
    {
        /// <summary>
        /// 任务空闲
        /// </summary>
        Waiting,
        /// <summary>
        /// 正在启动一个任务
        /// </summary>
        Starting,
        /// <summary>
        /// 任务正在执行
        /// </summary>
        Running,
        /// <summary>
        /// 任务已取消
        /// </summary>
        Canceled,
        /// <summary>
        /// 任务已完成
        /// </summary>
        Completed,
    }

示例代码：人脸比对任务调度器（实例类）

    /// <summary>
    /// 人脸比对任务调度器
    /// </summary>
    public class FaceMatchAsyncTaskExecutor : SingleAsyncTaskDispatcher
    {
        public FaceMatchAsyncTaskExecutor()
        {
            //参数根据实际情况设计
        }

        protected override void OnStarting()
        {
            base.OnStarting();
            //启动人脸扫描动画，此处代码省略
            Console.WriteLine("OnStarting");
        }

        protected override void OnRun()
        {
            //参数根据实际情况设计
            base.OnRun();
            Console.WriteLine("OnRun");
            //获取人脸比对图片
            while (!TaskToken.Value.IsCancellationRequested)
            {
                //检测人脸是否在指定区域内
                //开始人脸比对
                //…… 代码省略s
            }
        }

        protected override void OnCanceled()
        {
            base.OnCanceled();
            //关闭人脸扫描动画，此处代码省略
            Console.WriteLine("OnCanceled");
        }

        protected override void OnCompleted()
        {
            base.OnCompleted();
            //关闭人脸扫描动画，此处代码省略
            Console.WriteLine("OnCompleted");
        }
    }

至此，我们就可以使用这套模板，开发其他类似的业务逻辑了。

那什么时候会用到模板方法模式呢？

我们在实现一个算法，但发现其中有些部分非常易变，或者很容易随着运行环境、后续开发的不同产生很多变化，所以把它们抽象出来，供子类完成。
随着项目的展开，我们发现之前有些工作可以被独立出来形成公共的开发库。
对一系列子类进行约束，要求它们必须实现算法要求的某些方法，便于其他客户程序按照这些方法操作子类。

未完待续……

初识百度人脸识别

Sat, 04 Jan 2020 09:24:03 +0000

百度人脸识别算法包含有在线算法和本地离线算法，同时也涵盖了多种语言：有C#、C++、Android。现在就带大家来认识一下，百度人脸识别算法（C#版本）是个什么样子的。

准备工作

先注册百度帐号，并登录
SDK完整详细文档：https://ai.baidu.com/sdk
SDK在线版本文档：https://ai.baidu.com/ai-doc/FACE/Ck37c1ri0
SDK离线版本文档：https://ai.baidu.com/ai-doc/FACE/4k37c1n7e

在线版本

进入控制台，创建新的应用，获取授权 API Key , Secret Key ，地址：https://console.bce.baidu.com/ai/#/ai/face/app/list 。
安装在线依赖库。可通过页面下载或nuget安装【在NuGet中搜索 Baidu.AI，安装最新版即可】，推荐使用nuget安装。
安装好后，我们可以在C#代码中，编写以下调用代码：

    //在线调用
    private JObject MatchFace(byte[] image2)
    {
        //初始化百度人脸在线sdk
        var face = new Baidu.Aip.Face.Face("API Key", "Secret Key");
        //读取一张需要对比的本地图片
        var image1 = File.ReadAllBytes("bp.jpg");

        var faces = new JArray
            {
              new JObject
                {
                    {"image",Convert.ToBase64String(image1)},
                    {"image_type", "BASE64"},
                    {"face_type", "LIVE"},
                    {"quality_control", "LOW"},
                    {"liveness_control", "NONE"},
                },
              new JObject
                {
                    {"image", Convert.ToBase64String(image2)},
                    {"image_type", "BASE64"},
                    {"face_type", "LIVE"},
                    {"quality_control", "LOW"},
                    {"liveness_control", "NONE"},
                }
            };

        var result = face.Match(faces);
        return result;
    }

通过以上代码就可以完成最简单的人脸比对功能了。

注意：百度的算法依赖Newtonsoft.Json.dll，如果本地也存在此dll，需要注意版本冲突！

在线版本其它功能都有详细的文档介绍，此处不做过多介绍了，主要了解使用线上版本的先决步骤和注意事项。

离线版本

离线版本相比在线版本会更复杂，离线版本需要先在官网上下载相关的SDK，约580MB。
下载后解压压缩包，使用visual studio 2015以上版本打开。
函数的入口在Face.cs文件中，可根据示例代码进行自行学习。自己对代码稍微整理了下,请大家享用（其它代码，有需要请邮箱留言）：

    public class BaiduFaceApi
    {
        const string STR_BAIDU_API = "BaiduFaceApi.dll";

        /// <summary>
        /// 初始化人脸sdk
        /// </summary>
        /// <param name="id_card"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "sdk_init", CharSet = CharSet.Ansi
             , CallingConvention = CallingConvention.Cdecl)]
        public static extern int sdk_init(bool id_card);

        /// <summary>
        /// sdk销毁
        /// </summary>
        [DllImport(STR_BAIDU_API, EntryPoint = "sdk_destroy", CharSet = CharSet.Ansi
             , CallingConvention = CallingConvention.Cdecl)]
        public static extern void sdk_destroy();

        /// <summary>
        /// 是否授权
        /// </summary>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "is_auth", CharSet = CharSet.Ansi
                , CallingConvention = CallingConvention.Cdecl)]
        public static extern bool is_auth();

        /// <summary>
        /// 获取设备指纹
        /// </summary>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "get_device_id", CharSet = CharSet.Ansi
                 , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr get_device_id();

        /// <summary>
        /// 人脸跟踪
        /// </summary>
        /// <param name="oface"></param>
        /// <param name="mat"></param>
        /// <param name="max_track_num"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "track_mat", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int track_mat(IntPtr oface, IntPtr mat, ref int max_track_num);

        /// <summary>
        /// 跟踪最大人脸
        /// </summary>
        /// <param name="file_name"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "track_max_face", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr track_max_face(string file_name);

        /// <summary>
        /// 通过二进制图片跟踪人脸
        /// </summary>
        /// <param name="image"></param>
        /// <param name="size"></param>
        /// <param name="max_track_num"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "track_by_buf", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr track_by_buf(byte[] image, int size, int max_track_num);

        /// <summary>
        /// 清除人脸跟踪
        /// </summary>
        [DllImport(STR_BAIDU_API, EntryPoint = "clear_tracked_faces", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern void clear_tracked_faces();

        /// <summary>
        /// 跟踪人脸
        /// </summary>
        /// <param name="file_name"></param>
        /// <param name="max_track_num"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "track", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr track(string file_name, int max_track_num);

        /// <summary>
        /// 跟踪最大人脸
        /// </summary>
        /// <param name="image"></param>
        /// <param name="size"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "track_max_face_by_buf", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr track_max_face_by_buf(byte[] image, int size);


        /// <summary>
        /// 人脸1:1比对（传二进制图片buffer）
        /// </summary>
        /// <param name="buf1"></param>
        /// <param name="size1"></param>
        /// <param name="buf2"></param>
        /// <param name="size2"></param>
        /// <returns></returns>
        [DllImport(STR_BAIDU_API, EntryPoint = "match_by_buf", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr match_by_buf(byte[] buf1, int size1, byte[] buf2, int size2);

        /// <summary>
        /// 设置人脸最小尺寸
        /// </summary>
        /// <param name="size"></param>
        [DllImport("BaiduFaceApi.dll", EntryPoint = "set_min_face_size", CharSet = CharSet.Ansi
        , CallingConvention = CallingConvention.Cdecl)]
        public static extern void set_min_face_size(int size = 30);

        [DllImport("BaiduFaceApi.dll", EntryPoint = "rgb_ir_liveness_check_by_buf", CharSet = CharSet.Ansi
    , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr rgb_ir_liveness_check_by_buf(byte[] rgb_buf, int rgb_size,
     byte[] ir_buf, int ir_size);

        // 单目RGB静默活体检测（传入图片文件二进制buffer)
        [DllImport("BaiduFaceApi.dll", EntryPoint = "rgb_liveness_check_by_buf", CharSet = CharSet.Ansi
           , CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr rgb_liveness_check_by_buf(byte[] buf, int size);
    }

打开摄像头并用WPF显示的方法：

OpenCvSharp.Extensions.BitmapConverter 类需要反编译出来，百度算法自带的没有包含。

        private void StartCamera()
        {
            Task.Run(() =>
            {
                while (PlayState.Starting == State)
                {
                    try
                    {
                        var curCamera = Cv2.CreateFrameSource_Camera(0);
                        Mat curFrame=new Mat();
                        System.Drawing.Bitmap bitmap;
                        State = PlayState.Playing;
                        while (PlayState.Stoped != State)
                        {
                            curCamera.NextFrame(curFrame);
                            //设置摄像头的画面镜像显示，以保证人物移动方向和视频流中相同
                            //除此方法还有更强大的方法，是使用Remap.该方法功能更强大，同时也更耗性能
                            curFrame=curFrame.Flip(FlipMode.Y);

                            bitmap = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(curFrame);                            

                            Dispatcher.Invoke(() => img.Source = ImageUtil.BitmapToBitmapImage(bitmap));
                        }

                        curCamera.Dispose();
                    }
                    catch (Exception)
                    {
                        Thread.Sleep(1000);
                    }
                }
            });
        }

        public enum PlayState
        {
            Starting,
            Playing,
            Pause,
            Stoped
        }

remap的参考实现

        public static void TestRemap()
        {
            int index = 0;
            Mat src = new Mat(path, ImreadModes.AnyColor | ImreadModes.AnyDepth);
            Mat dst = new Mat(src.Size(), src.Type());
            Mat x = new Mat(src.Rows, src.Cols, MatType.CV_32FC1);
            Mat y = new Mat(src.Rows, src.Cols, MatType.CV_32FC1);
            //new OpenCvSharp.Window("Input", WindowMode.AutoSize, src);
            int key = 0;
            while (true)
            {
                key = Cv2.WaitKey(500);
                index = key % 4;
                if ((char)key == 27)
                {
                    break;
                }
                Console.WriteLine("{0}%{1}={2}", key, 4, index);
                UpdateRemap(src, x, y, 0);
                Cv2.Remap(src, dst, x, y, InterpolationFlags.Linear, BorderTypes.Constant, new Scalar(0, 0, 255));
                //new OpenCvSharp.Window("Output", WindowMode.AutoSize, dst);
            }
        }

        public static void UpdateRemap(Mat src, Mat x, Mat y, int flipMode)
        {
            for (int row = 0; row < src.Rows; row++)
            {
                for (int col = 0; col < src.Cols; col++)
                {
                    switch (flipMode)
                    {
                        case 0:
                            if (col > (src.Cols * 0.25) && col < (src.Cols * 0.75) && row > (src.Rows * 0.25) && row < (src.Rows * 0.75))
                            {
                                /*
                                 * 图像的 Cols 列 组成矩阵的宽度 对应 二维平面的x轴
                                 * 图像的 Rows 行 组成矩阵的高度 对应 二维平面的y轴
                                 * if 条件成立必定满足  
                                 *          src.Cols*0.75 <= col <= src.Cols*0.25
                                 *          src.Rows*0.75 <= row <= src.Rows*0.25
                                 * 则：
                                 *  (col - (src.Cols * 0.25)范围在 0 -- 0.5 之间
                                 *   若 (2 * (col - (src.Cols * 0.25)) 则：范围在 0 --1 之间 （原图像的大小）X轴
                                 *   (row - (src.Rows * 0.25))范围在 0 -- 0.5 之间
                                 *   若 (2 * (row - (src.Rows * 0.25)) 则：范围在 0 --1 之间 （原图像的大小）Y轴
                                 *   
                                 *   前面创建 x ,y 对象是的类型是 CV_32FC1 所以 赋值要用 float 类型
                                 */
                                float xVal = (float)(2 * (col - (src.Cols * 0.25)));
                                float yVal = (float)(2 * (row - (src.Rows * 0.25)));
                                x.Set<float>(row, col, xVal);
                                y.Set<float>(row, col, yVal);
                            }
                            else
                            {
                                x.Set<float>(row, col, 0);
                                y.Set<float>(row, col, 0);
                            }
                            break;
                        case 1:
                            x.Set<float>(row, col, (src.Cols - col - 1)); //左右映射  X 轴
                            y.Set<float>(row, col, row); //Y 轴不变
                            break;
                        case 2:
                            x.Set<float>(row, col, col); //X 轴
                            y.Set<float>(row, col, (src.Rows - row - 1)); //上下映射 Y轴
                            break;
                        case 3:
                            x.Set<float>(row, col, (src.Cols - col - 1)); //左右映射  X 轴
                            y.Set<float>(row, col, (src.Rows - row - 1));//上下映射 Y轴
                            break;
                    }
                }
            }
        }

划重点：百度SDK在使用的过程中会遇到很多问题，影响我们项目推进。为了防止大家入坑

使用百度算法之前，必须要先注册，否则SDK无法正常使用。注册方法只需要打开启动目录下的LicenseTool.exe文件，输入授权码。授权成功后，会生成两个授权文件：license.ini和license.key。授权是绑定物理机器，如果换另外一台机器，授权码将失效。授权过程中，如果遇到授权失败，则多点几次重试即可。
face-resource 资源包，一定要放在程序运行的上一级目录，否则会导致SDK初始化失败，也就是返回值为-1。
人脸识别算法在调用的过程中，我们可能会发现错误返回，抽取人脸特征数据失败，这种情况多数因为人脸识别的人脸大小过大，把人脸size设置更小就可以了(调用set_min_face_size方法进行设置)，默认值是100。具体参数需要根据实际设定。
百度算法依赖opencv相关的库，我们在打开摄像头的过程中，也需要使用opencv的相关功能。为了避免冲突，我们需要从baidu sdk目录下的common文件夹中，把里面的文件拷贝到启动目录下，否则会出现版本冲突导致的编译错误。
程序启动时，会出现无法定位程序输入点 SfmDxGetSwapChainStats 于动态链接库 xxx d3d9.dll的错误，只需要将d3d9.dll改成d3nv.dll即可
opencv相关的扩展方法，百度SDK所使用的版本过低，不包含该扩展方法，需要自行反编译出来加入使用，需要开启启用不安全代码。
人脸识别率会受装饰，头发等影响，使用过程中尽可能避免脸部遮挡，画浓妆等，推荐阈值80。
调用人脸接口，可能会出现返回的指针为空指针，那么这种情况很有可能是因为百度SDK被Dispose了

持续更新……

设计模式（智能指针）

Sat, 04 Jan 2020 08:54:03 +0000

智能指针实例

智能指针模式，是自己命名的一种模式。因为该模式中会存在一个变量，用来控制内部状态，故而叫智能指针。

在业务使用中，我们可能会遇到同一个函数被多个地方调用，而多个地方在调用的过程中，又会存在相互事件触发，从而导致某些代码陷入递归调用中，从而引发死循环，或者业务逻辑执行不对。所以我们需要通过状态来保证我们的函数是否可执行,基本逻辑：函数入口到函数结束过程中，为了避免递归调用，增加状态控制量。当然，这种思路有点像栈，先进后出，用栈也是可以实现这种效果，但是会增加没有必要的内存占用。

不过为了学习，我们还是自己来实现一个简单的例子：

        class SmartPointerOperator : IDisposable
        {
            private int _flag;

            public SmartPointerOperator BeginUpdate()
            {
                _flag++;
                return this;
            }

            public bool CanUpdate
            {
                get
                {
                    if (_flag == 0)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            public void Reset()
            {
                _flag = 0;
            }

            public void Dispose()
            {
                _flag--;
            }
        }

继承IDisposable的目的，只是为了让他能够支持using语法。

调用方法：

    //哪些地方需要添加状态控制，使用using语法包起来
    //控制逻辑
    using (_smartPointerOperator.BeginUpdate())
    {

    }


    //调用逻辑，判断当前状态是否可用
    if (_smartPointerOperator.CanUpdate)
    {
      //todo:
    }

至此，我们简易的智能指针设计模式就结束了。未来如果有遇到类似场景，就可以使用这种模式来保证状态的正确性。

java与C#处理byte类型带来的坑

Wed, 01 Jan 2020 12:27:03 +0000

在实际工作中，如果我们用的语言存在跨语言的情况，那么我们无形中可能会遇到各种各样，奇奇怪怪的坑，比如说加解密算法的使用，数据类型的转换等。今天就来给大家分享下，两种语言中的byte类型所带来的坑。

背景

因工作需要，我们需要通过PC电脑和安卓手机做网络通信。因TCP的通信过程中会存在粘包问题，所以我们在通信的过程中，需要指定传输的字节长度，这个时候我们就需要处理数据类型转换的问题了。通常我们传输数据都是使用字节数组（byte[]）来承载我们的数据，而我们传输过程中需要带上长度的信息，这个时候就需要把长度值（int类型），转成byte[]，以方便被传输。

过程

C#代码：int 转 byte[]

        /// <summary>
        /// 将int类型以数组方式添加到目标数组
        /// </summary>
        /// <param name="data"></param>
        /// <param name="offset"></param>
        /// <param name="value"></param>
        public static void IntoBytes(byte[] data, int offset, int value)
        {
            data[offset++] = (byte)(value);
            data[offset++] = (byte)(value >> 8);
            data[offset++] = (byte)(value >> 16);
            data[offset] = (byte)(value >> 24);
        }

C#代码：byte[] 转 int

        /// <summary>
        /// bytes数据长度转成int类型
        /// </summary>
        /// <param name="data"></param>
        /// <param name="offset"></param>
        /// <returns></returns>
        public static int ToInt32(byte[] data, int offset)
        {
            return (int)(data[offset++] | data[offset++] << 8 | data[offset++] << 16 | data[offset] << 24);
        }

以上代码，将一个int类型的数据转成byte[]后，也可以正常的转回来。为了投机取巧，java端并没有对这段代码做处理，直接拿去使用。而在实际使用中，java传递过来的长度并没有问题，能够正常解析。然后从C#传递给java的数据，却发现解析的长度值和发送的长度值相差非常大。比如：byte[]{178,24,0,0}，转换后的值为-78。字节长度为负数，显然是错的，而且错的很离谱。

为什么值会是负数呢？

原因

在java中，byte的取值范围是【-128 127】；而在C#中，byte的取值范围是【0 255】！

是的，正是因为byte数据类型，在两种不同的语言中，定义的存储范围存在差异。C#代码中的ToInt方法，是以正数的方式来做解析，然而java中的byte存在负数，所以结局当然也可想而知了。

科普

二进制在存储负数时，是通过最高位来做记录的。1表示负数，0表示正数。当一个数字存在负数时，先是以绝对值的方式来存储，再将字节取反后+1。如：7 的二进制表示：0 0000 111，负数的话便是：1 1111 000 + 1 = 11111001（第一个1表示负数，1111 000 表示取反的值）。

分析

知道上面的背景知识以后，我们再来分析下我们应该要怎么解析以上二进制数据。

以C#的存储方式来分析：

一个int类型是4个字节，占4*8=32位，也就是：11111111 1111111 1111111 1111111，也就是每8个位代表着一个字节,下面我们以C#中的byte[]{178,24,0,0}为例：

助算：2^1=2 2^2=4 2^3=8 2^4=16 2^5=32 2^6=64 2^7=128

十进制	二进制	类型	语言
`178`	`10110010`	`byte`	`C#`
`24`	`00100010`	`byte`	`C#`
`0`	`00000000`	`byte`	`C#`
`0`	`00000000`	`byte`	`C#`

解析
178： 2^7 + 2^5 + 2^4 + 2^1 = 178，取第8，6，5，2位为1，其余补0。最终取值为10110010。
24 ：2^4 + 2^3 = 24，取第5，4位标记为1，其余补0。最终取值为00100010。
byte[] 二进制表示为：10110010 00011000 00000000 00000000
特别注意：byte[]数组中的字节高位是在后面的，低位是在前面的,所以对应int类型二进制表示为："00000000 00000000 00011000 10110010" 即：6322。

以java的存储方式来分析：

int类型6322转成byte[]后，在java中的表示形式为：{-78,24,0,0},在这里要使用前面提到的负数的表示方法。

十进制	二进制	类型	语言
`-78`	`10110010`	`byte`	`java`
`24`	`00100010`	`byte`	`java`
`0`	`00000000`	`byte`	`java`
`0`	`00000000`	`byte`	`java`

解析
十进制-78：10110010在java中表示的为负数，所以我们需要反过来取值：10110010 减 1 => 10110001,再取反=> 01001110，即：78。

根据上面分析，各字节对齐思路没有问题，java和C#的二进制是一致的。

解决问题

问题清楚了，在java中主要是需要解决负数表示的问题，因为负数的补位和正数是不一样的。如果是左移<<，那么就是用0补位。如果是右移>>,那么就是用1补位。正因为如此，才导致了移位运算后，结果不符合预期。
所以我们需要加上0xFF与运算,用0xFF做运算的主要目的是取高位，让byte负数的表示，还原成int的正数表示。具体代码如下：

        /// <summary>
        /// bytes数据长度转成int类型
        /// </summary>
        /// <param name="data"></param>
        /// <param name="offset"></param>
        /// <returns></returns>
        public static int ToInt32(byte[] data, int offset)
        {
            return (int)((data[offset++] & 0xFF) | ((data[offset++] & 0xFF) << 8) | ((data[offset++] & 0xFF) << 16) | ((data[offset] & 0xFF) << 24));
        }

说明：&运算表示相同位部分，如果都为1则取1，否则取0

如何处理Tcp粘包半包问题

Mon, 30 Dec 2019 02:23:03 +0000

TCP是网络传输层中非常重要的传输协议，广泛应用于Http、WebSocket、FTP、Telnet、SMTP、POP3与DNS等应用协议。了解TCP的基本原理对我们分析网络问题有着举足轻重的作用。此次我们先来了解下：如何解决TCP的粘包，半包的问题。

先来简单的了解下TCP协议的基本原理

TCP是以流动的方式传输数据，传输的最小单位为一个报文段（segment）。TCP Header中有个Options标识位，常见的标识为mss(Maximum Segment Size最大消息长度)指的是，连接层每次传输的数据有个最大限制MTU(Maximum Transmission Unit)，一般是1500比特，超过这个量要分成多个报文段，mss则是这个最大限制减去TCP的header,即：

MSS = MTU - header

TCP是数据安全的，它可以确保数据在传输的过程中不会出现数据丢失，这是因为TCP在传输过程中，会对传输的数据做校验，以确保数据接收的完整性。另外也因为TCP是分段传输，需要确保数据接收的顺序正确。也正是因为有这种机制，才导致TCP的传输效率相比UDP协议会更低，于是TCP为提高性能，发送端会将需要发送的数据发送到缓冲区，等待缓冲区满了之后，再将缓冲中的数据发送到接收方。同理，接收方也有缓冲区这样的机制，来接收数据。其中数据缓冲区的大小，默认65536字节。

那什么是粘包和半包？

粘包：指的是发送端在多次发送数据的过程中，数据包在同一个数据流中传输给了接收端，此现象就称之为粘包。

半包：发送端发送的数据大于发送缓冲区，接收端一次接收的数据不是完整的数据，此现象称之为半包

粘包、拆包发生原因

原因很多种，有补充请在评论区留言

拆包：

要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。
待发送数据大于MSS（最大报文长度），TCP在传输前将进行拆包。

粘包：

要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包。
接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。

粘包常规的解决方法

传输字符串类数据，可使用特殊字符作为分隔符。字节数组也可以使用特定的字节码来作为分隔符。如：\0
使用固定字节长度作为传输协议
添加数据头，通过数据头部来解析数据包长度

其中第一种和第二种方法都比较简单，也有一定的局限性，不推荐采用。就第三种实现方法，以C# 代码作为简单的案例分享。

准备工作，数据长度与字节数组的转换

        /// <summary>
        /// 将int类型以数组方式添加到目标数组
        /// </summary>
        /// <param name="data"></param>
        /// <param name="offset"></param>
        /// <param name="value"></param>
        public static void IntoBytes(byte[] data, int offset, int value)
        {
            data[offset++] = (byte)(value);
            data[offset++] = (byte)(value >> 8);
            data[offset++] = (byte)(value >> 16);
            data[offset] = (byte)(value >> 24);
        }

        /// <summary>
        /// bytes数据长度转成int类型
        /// </summary>
        /// <param name="data"></param>
        /// <param name="offset"></param>
        /// <returns></returns>
        public static int ToInt32(byte[] data, int offset)
        {
            return (int)(data[offset++] | data[offset++] << 8 | data[offset++] << 16 | data[offset] << 24);
        }

定义消息头部

        /// <summary>
        /// Demo消息头定义
        /// </summary>
        public struct SocketHead
        {
            //起始位，表示字节的开始
            public byte StartFlag;
            //校验位，检验数据是否正确
            public byte CheckNum;
            //协议位，表示需要执行什么功能
            public byte Cmd;
            //消息体数据长度
            public int Length;
        }

构建数据包头

        public static byte[] BuildData(byte cmd, byte[] data)
        {
            byte[] buffer = new byte[7 + data.Length];

            byte startFlag = 0xF;
            //起始位
            buffer[0] = startFlag;
            //指令位
            buffer[1] = cmd;
            //校验位
            buffer[2] = (byte)(cmd + startFlag);

            IntoBytes(buffer, 3, data.Length);

            Array.Copy(data, 0, buffer, 7, data.Length);

            return buffer;
        }

解析数据包头

        public static bool ParseHead(byte[] data, out SocketHead socketHead)
        {
            if (data.Length >= 7)
            {
                socketHead = new SocketHead
                {
                    StartFlag = data[0],
                    Cmd = data[1],
                    CheckNum = data[2]
                };
                //验证数据是否正确
                if (socketHead.CheckNum == socketHead.StartFlag + socketHead.Cmd)
                {
                    socketHead.Length = ToInt32(data, 3);
                    return true;
                }
                return false;
            }
            socketHead = new SocketHead();
            return false;
        }

发送数据

        //示例代码，非完整代码
        public bool SendData(byte[] data)
        {
            //将头部增加到数据中
            var bufferData = SocketWrap.BuildData(0x9, data);
            //发送缓存数据
            var len = _tcpClient.Send(bufferData);
            if(len==bufferData.Length)
            {
                return true;
            }
            return false;
        }        

接收数据

        //示例代码，非完整代码
        public void ReviceData()
        {
            try
            {
                while (_tcpClient.Connected)
                {
                    var socketClient = _tcpClient.Client;
                    if (socketClient == null)
                    {
                        break;
                    }

                    byte[] head = new byte[7];
                    var receiveCount = socketClient.Receive(head);
                    if (receiveCount != 0)
                    {
                        if (SocketWrap.ParseHead(head, out SocketWrap.SocketHead socketHead))
                        {
                            var len = socketHead.Length;

                            byte[] data = new byte[len];

                            var count = 1;
                            if (len > 1024)
                            {
                                var ys = len % 1024;
                                var c = len / 1024;
                                if (ys > 0)
                                {
                                    count = c + 1;
                                }
                                else
                                {
                                    count = c;
                                }
                            }

                            if (count == 1)
                            {

                                byte[] buffer = new byte[len];
                                _tcpClient.Client.Receive(buffer);

                                buffer.CopyTo(data, 0);

                                //todo:可以增加数据接收完成事件
                            }
                            else
                            {
                                byte[] buffer = new byte[1024];
                                for (int i = 0; i < count - 1; i++)
                                {
                                    _tcpClient.Client.Receive(buffer);

                                    buffer.CopyTo(data, i * 1024);
                                }

                                var d = len - (count - 1) * 1024;

                                _tcpClient.Client.Receive(buffer);

                                Array.Copy(buffer, 0, data, (count - 1) * 1024, d);

                                //todo:可以增加数据接收完成事件
                            }
                        }
                    }
                    else
                    {
                        //数据接收返回为0，表示连接已经断开了，需要做重连
                        throw new SocketException(5);
                    }
                }
            }
            catch (SocketException ex)
            {
                //todo:
            }
            catch
            {
                //todo:
            }
        }

以上接收代码看似没毛病，但是在实际运行过程中，我们可能会出现发送的数据和接收的数据不一致！！！

那么为什么会出现这样的情况呢？

我们找来 SocketTool 测试工具进行了一轮测试，使用SocketTool来接收相应的消息；结果发现，SocketTool能够很好的接收完成相关数据。那基本可以排除发送端的问题，那主要在接收端查找原因。当我们把 _tcpClient.Client.Receive(buffer) 调用返回的数据全部打印出来查看时，我们发现这样的情况：

接收的数据并没有按buffer大小全部接收完成！

于是我们将以上代码重新做个修改，修改如下：

        //示例代码，非完整代码
        public void ReviceData()
        {
            try
            {
                while (_tcpClient.Connected)
                {
                    var socketClient = _tcpClient.Client;
                    if (socketClient == null)
                    {
                        break;
                    }

                    byte[] head = new byte[7];
                    var receiveCount = socketClient.Receive(head);
                    if (receiveCount != 0)
                    {
                        if (SocketWrap.ParseHead(head, out SocketWrap.SocketHead socketHead))
                        {
                            var len = socketHead.Length;
                            List<byte> data = new List<byte>();
                            int totalCount = 0;
                            int tmpSize = 0;
                            while (totalCount < len)
                            {
                                tmpSize = _tcpClient.Available;
                                if(tmpSize==0)
                                {
                                    Thread.Sleep(10);
                                    continue;
                                }

                                //保证接收到的数据是协议内的数据
                                if (totalCount + tmpSize >= len)
                                {
                                    var buffer = new byte[len - totalCount];
                                    _tcpClient.Client.Receive(buffer);
                                    data.AddRange(buffer);
                                    totalCount = len;
                                }
                                else
                                {
                                    var receiveBuffer = new byte[tmpSize];
                                    _tcpClient.Client.Receive(receiveBuffer);
                                    data.AddRange(receiveBuffer);
                                    totalCount += tmpSize;
                                }
                            }

                            DataReceived?.Invoke(this, new SocketDataArgs(data.ToArray()));                            
                        }
                    }
                    else
                    {
                        //数据接收返回为0，表示连接已经断开了，需要做重连
                        throw new SocketException(5);
                    }
                }
            }
            catch (SocketException ex)
            {
                //todo:
            }
            catch
            {
                //todo:
            }
        }

通过 _tcpClient.Available 来判断有多少字节可以读取，那么直接在缓冲区中读取相应的字节数。读取完成后，再将他们合并起来，给到业务层使用。

以上就是解决粘包，半包的基本方法，欢迎留言评论！

WPF & Winform 窗口大小设置范围限制引发的惨案

Thu, 26 Dec 2019 14:23:03 +0000

有个有趣的事情，当我们创建一个WPF窗体时，我们将窗体的大小设置为Width=90,Height=160。在设计器模式下，窗体比例看着很和谐如下图所示：

示例代码：

<Window x:Class="WpfApp1.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"
        mc:Ignorable="d"
        Title="MainWindow" Height="160" Width="90" WindowStyle="SingleBorderWindow" ResizeMode="NoResize" >
    <Grid Background="Gray">
        <Image Source="Images/test.jpg" Stretch="Fill"/>
    </Grid>
</Window>

运行以后，我们发现窗口中的图片居然变形了!

WPF的窗体高宽设置有bug么？不是所见即所得吗？
通过snoop看到窗体的ActualWidth并不是90，此时窗体的Height属性依然是90！如下图所示：

注意：在1600 * 900 的分辨率下，最小值是136,。1920 * 1080分辨率下是131。

然后我们把WindowStyle设置成None时，窗口的大小能够顺利的应用90 * 160 的分辨率。
嗯，看到这里，好像问题已经解决了，因为WindowStyle非None时，有标题栏。

但是又继续尝试，将分辨率设置成768 * 1366，同样的，在设计器模式下，图片没有变形，显示正常。

在运行模式下，图片发现又变形了！同样打开snoop，查看窗体的高宽，结果发现高度相比原有值更小了，只有1095。

难道真的是WPF的窗体在计算的时候出现了bug？

于是在窗体里面重写了以下两个方法:

        protected override Size ArrangeOverride(Size arrangeBounds)
        {
            var size = base.ArrangeOverride(arrangeBounds);
            return size;
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            var size = base.MeasureOverride(availableSize);
            return size;
        }

通过断点我们发现，arrangeBounds 和 availableSize 并不等于我们之前设定的Height和Width值。

arrangeBounds 和 availableSize传入过来的参数已经不是我们之前设定的值了，所以计算出来的结果也一定不会是我们之前设定的值，验证失败！**

那么还不行，使用DNspy做源代码调试，一步一步跟进查看问题的根源在哪里。

究其调用堆栈：发现GetWindowRect方法被调用，于是使用MoveWindow的方法尝试，结果依然。

最后考虑到窗体存在超出显示区的最大值的情况，比如说任务栏，于是通过日志跟踪法，将其窗体的大小打印出来。

            Task.Run(() =>
            {
                while (true)
                {
                    Thread.Sleep(1000);
                    Dispatcher.Invoke(()=> Console.WriteLine($"awid: {this.ActualWidth} ah:{this.ActualHeight} maxh:{ SystemParameters.MaximumWindowTrackHeight } maxwid:{ SystemParameters.MaximumWindowTrackWidth } minh:{SystemParameters.MinimumWindowTrackHeight} minwid:{SystemParameters.MinimumWindowTrackWidth}"));
                }                
            });

根据以上打印的结果发现：
窗口的高度最大值是SystemParameters.MaximumWindowTrackHeight的值；
窗口的宽度最大值是SystemParameters.MaximumWindowTrackWidth的值；
窗口的高度最小值是SystemParameters.MinimumWindowTrackHeight的值；
窗口的宽度最小值是SystemParameters.MinimumWindowTrackHeight的值。

经过多次反复验证后最终确认问题就是窗体的大小因为操作系统做了限制，并不能随意按照我们设置的高度来应用到窗体。同时，窗体还受WindowStyle的属性，标题栏，任务栏等影响。

特别注意：该窗口的最小值限制不适用于WindowStyle.None的情况。

为了确保结论正确，以上问题同样在Winform中验证过，存在相同的问题。并且在win7和win10不同的操作系统上运行过。

总结：导致窗口在设计器模式和运行模式表现不一样的原因是因为因为Windows操作系统的机制原因，限制的窗口的最大值和最小值。而设计器模式时，窗体属于VisualStudio的内部组件，不受窗体大小的限制，所以渲染出来的效果会存在以上比较诡异的差异。

gogs Windows系统上简易部署

Thu, 26 Dec 2019 00:23:03 +0000

gogs是免费开源的一款类似于gitlab的版本管理服务软件，部署起来非常的方便轻巧，习惯使用git命令的小伙伴们赶紧来尝尝鲜。今天我们就来搭建一个gogs服务器端。

步骤

下载gogs安装包

https://github.com/gogs/gogs/releases/download/v0.11.91/windows_386.zip

将下载好的压缩包解压出来，如下图所示：

在当前目录下，打开cmd命令窗口，输入：gogs web ,回车

配置完成后,下次打开显示以下界面

根据gogs控制台上的显示的URL，使用浏览器打开。默认http://localhost:3000

配置界面

注册账号

创建仓库

拉取

基础安装就完成了，可以愉快的玩耍了。更详细的步骤，有兴趣的同学可以自己研究，跟gitlab差不多。

划重点-排错

安装上去提示 git 执行失败？
使用gogs必须要安装git才行，下载地址：https://gitforwindows.org/
下载完成后，按默认向导安装完成即可。
localhost:3000可以访问，127.0.0.1却不能访问？
方法1：关闭gogs.exe，在使用cmd命令检查下3000端口是否存在。cmd命令：netstat -nao|findstr “3000”。如果还存在，那么可以换个端口重新打开gogs.exe，或者注销电脑重新登录。
方法2：在C:\Windows\System32\drivers\etc下面找到hosts文件，添加以下两行：
127.0.0.1 localhost
::1 localhost
在重试。
使用过程中，gogs卡住了，git命令也无法执行
检查确认以命令行方式打开的窗口是否有被鼠标点击过，终止了命令行的WriteLine的方法，导致程序被中断。可试图按个回车后再试
也可使用启动工具来启动gogs，将启动工具放gogs.exe相同路径下，双击即可。
工具下载地址：https://github.com/huchengv5/huchengv5.github.io/blob/master/attachment/apps/gogsrun.exe
配置文件修改可以打开 gogs\custom\conf\app.ini 文件，直接修改文件对应的配置项即可。修改完成后，重新启动下gogs。

简易介绍到此结束，只带大家入门，修行还得靠自己。

C# 通过adb与安卓设备通讯

Mon, 23 Dec 2019 10:23:03 +0000

我们都有看过手机助手软件，当手机插到电脑上时，电脑上就可以看到手机中的文件夹。还能完成文件的拷贝，安装等功能。现在我们就用C#，通过 adb + usb 实现简单的网络通讯功能。调用adb有几种方式：一种就是通过cmd命令行来调用。另外一种就是直接调用adb工具。cmd命令调用的例子较多，本例就使用直接通过adb的方式来实现。

准备工作

下载以下依赖文件：

- adb.exe
- AdbWinApi.dll
- AdbWinUsbApi.dll

核心代码

        private string RunAdbCmd(string arg)
        {
            var p = new Process(); //实例一个Process类，启动一个独立进程
            p.StartInfo.FileName = "adb.exe"; //设定程序名
            p.StartInfo.Arguments = arg;
            p.StartInfo.UseShellExecute = false; //关闭Shell的使用
            p.StartInfo.RedirectStandardInput = true; //重定向标准输入
            p.StartInfo.RedirectStandardOutput = true; //重定向标准输出
            p.StartInfo.RedirectStandardError = true; //重定向错误输出
            p.StartInfo.CreateNoWindow = true; // 设置不显示窗口
            p.StartInfo.ErrorDialog = false;
            p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            p.Start();
            return p.StandardOutput.ReadToEnd();
        }

使用方法如：

var result = RunAdbCmd("devices");
    result = RunAdbCmd($"-s {deviceId} forward tcp:11100 tcp:10089");
    result = RunAdbCmd("shel netstat");

注意：

调用adb.exe是通过命令行传参的方式调用，前面不需要输入”adb”。如果是通过cmd命令行工具输入时才需要加上“adb”。
调用adb.exe执行命令时，adb会根据命令执行不同的逻辑。有些命令执行完成后，adb会立刻退出，有些命令会一直不退出。为了防止程序得不到想要的结果，需要注意了解哪些命令是立即退出，哪些是延时退出。如：shell命令，forward命令，都是被动式退出，需要收到退出指令后才会退出。

C# log4net快速开始

Mon, 23 Dec 2019 09:23:03 +0000

log4net是非常强大的日志管理系统，在客户端桌面开发中，大多数情况下我们都是把日志输出到本地文件。为了让大家能够快速开发，特此记录。配置文件内容

  <log4net>
    <root>
      <!--控制级别，由低到高: ALL|DEBUG|INFO|WARN|ERROR|FATAL|OFF
      比如定义级别为INFO，则INFO级别向下的级别，比如DEBUG日志将不会被记录
      如果没有定义LEVEL的值，则缺省为DEBUG-->
      <level value="DEBUG"/>
      <appender-ref ref="RollingFileAppender"/>
    </root>
    <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
      <file value="Log\\log.txt"/>
      <lockingModel type="log4net.Appender.FileAppender+MinimalLock"/>
      <datePattern value="(yyyyMMdd)"/>
      <appendToFile value="true"/>
      <rollingStyle value="Date"/>
      <RollingStyle value="Size"/>
      <MaxSizeRollBackups value="10"/>
      <maximumFileSize value="2MB"/>
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%date [%t]%-5p %c - %m%n"/>
      </layout>
    </appender>
  </log4net>

在AssemblyInfo中添加如下代码，表示log4net从配置文件中读取

//log4net从配置文件中读取配置
[assembly: log4net.Config.XmlConfigurator(ConfigFileExtension = "config", Watch = true)]

通过配置以上节点到app.config中还不够，只要程序在运行过程中，需要用到配置管理器，那么很有可能会遇到“配置文件尚未初始化”的错误提示。这是因为在App.Config中，需要将log4net的节点注册进去，以让配置管理器识别。

在app.config中添加如下节点代码：

<!--configSections是在配置文件的最上方，定义节点必须要在第一行上面定义-->
 <configSections>
    <!-- log4net的定义 -->
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
  </configSections>

有了以上的配置，我们就可以在代码里面开始初始化日志管理器了。

    public class LogService
    {
        static LogService()
        {
            Instance = LogManager.GetLogger("需要记录的日志节点名称，可任意填写。填写的名称会记录在日志里面，可以表示是什么程序记录的日志");
        }

        public static ILog Instance { get; private set; }
    }

注意：客户端软件在app.config中配置，web程序在web.config中配置。祝君玩耍愉快！

C# 通过Fleck实现WebSocket监听服务

Mon, 23 Dec 2019 08:23:03 +0000

Fleck是一个websocket开源框架，通过Fleck，我们可以很轻松的实现WebSocket服务端；
GitHub地址：https://github.com/statianzo/Fleck.git。
现在我们就用它来实现WebSocket基本通讯。我们首先在nuget上面搜索Fleck，并安装到我们的工程中,然后贴上以下关键代码即可：

                var _webSocketServer = new WebSocketServer($"ws://0.0.0.0:{port}")
                {
                    RestartAfterListenError = true
                };

                _webSocketServer.Start(socket =>
                {
                    socket.OnOpen = () =>
                    {
                        //建立新的Socket请求时发生
                    };

                    socket.OnClose = () =>
                    {
                       //关闭Socket时发生
                    };

                    socket.OnMessage = data =>
                    {
                        //收到字符串数据时发生
                    };

                    socket.OnBinary = data =>
                    {
                       //收到二进制数据时发生
                    };
                });

我们通过以上方法，就可以轻松的实现WebSocket服务端了。

C# 通过WMI监听USB插拔

Mon, 23 Dec 2019 07:23:03 +0000

监控USB的插入和拔出有几种方法，如：通过监听windows消息来获取，通过WMI查询等。
通过windows消息存在弊端就是我们的程序必须要跑在带有窗口的程序上面，另外因为操作系统不一样，消息传递的参数也不一样，所以它在不同版本的操作系统上也不一定有用，实现起来也会更麻烦。
今天介绍一下通过WMI的方式，来获取USB的插拔状态。参加代码如下：

名称解释：WMI（Windows Management Instrumentation,Windows 管理规范）

 /// <summary>
    /// USB控制设备类型
    /// </summary>
    public struct USBControllerDevice
    {
        /// <summary>
        /// USB控制器设备ID
        /// </summary>
        public string Antecedent;

        /// <summary>
        /// USB即插即用设备ID
        /// </summary>
        public string Dependent;
    }

    /// <summary>
    /// 监视USB插拔
    /// </summary>
    public class UsbWatcher
    {
        /// <summary>
        /// USB插入事件监视
        /// </summary>
        private ManagementEventWatcher insertWatcher = null;

        /// <summary>
        /// USB拔出事件监视
        /// </summary>
        private ManagementEventWatcher removeWatcher = null;

        /// <summary>
        /// 添加USB事件监视器
        /// </summary>
        /// <param name="usbInsertHandler">USB插入事件处理器</param>
        /// <param name="usbRemoveHandler">USB拔出事件处理器</param>
        /// <param name="withinInterval">发送通知允许的滞后时间</param>
        public bool AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler, EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
        {
            try
            {
                ManagementScope Scope = new ManagementScope("root\\CIMV2");
                Scope.Options.EnablePrivileges = true;

                // USB插入监视
                if (usbInsertHandler != null)
                {
                    var insertQuery = GetUsbQueryParamter("__InstanceCreationEvent", withinInterval);
                    insertWatcher = new ManagementEventWatcher(Scope, insertQuery);
                    insertWatcher.EventArrived += usbInsertHandler;
                    insertWatcher.Start();
                }

                // USB拔出监视
                if (usbRemoveHandler != null)
                {
                    var removeQuery = GetUsbQueryParamter("__InstanceDeletionEvent", withinInterval);
                    removeWatcher = new ManagementEventWatcher(Scope, removeQuery);
                    removeWatcher.EventArrived += usbRemoveHandler;
                    removeWatcher.Start();
                }

                return true;
            }

            catch (Exception)
            {
                RemoveUSBEventWatcher();
                return false;
            }
        }

        private WqlEventQuery GetUsbQueryParamter(string eventClassName, TimeSpan withinInterval)
        {
            return new WqlEventQuery(eventClassName, withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
        }

        /// <summary>
        /// 移去USB事件监视器
        /// </summary>
        public void RemoveUSBEventWatcher()
        {
            if (insertWatcher != null)
            {
                insertWatcher.Stop();
                insertWatcher.Dispose();
                insertWatcher = null;
            }

            if (removeWatcher != null)
            {
                removeWatcher.Stop();
                removeWatcher.Dispose();
                removeWatcher = null;
            }
        }

        /// <summary>
        /// 定位发生插拔的USB设备
        /// </summary>
        /// <param name="e">USB插拔事件参数</param>
        /// <returns>发生插拔现象的USB控制设备ID</returns>
        public static USBControllerDevice[] WhoUSBControllerDevice(EventArrivedEventArgs e)
        {
            ManagementBaseObject mbo = e.NewEvent["TargetInstance"] as ManagementBaseObject;
            if (mbo != null && mbo.ClassPath.ClassName == "Win32_USBControllerDevice")
            {
                string Antecedent = (mbo["Antecedent"] as string).Replace("\"", string.Empty).Split(new Char[] { '=' })[1];
                string Dependent = (mbo["Dependent"] as string).Replace("\"", string.Empty).Split(new Char[] { '=' })[1];
                return new USBControllerDevice[] { new USBControllerDevice { Antecedent = Antecedent, Dependent = Dependent } };
            }

            return null;
        }
    }

通过以上代码，我们就可以通过注册事件的方式来获取USB设备的插入或者拔出。通过调用WhoUSBControllerDevice方法来获取具体设备的ID。
这里需要注意，因为其实现原理，我们监听的事件可能会触发多次的情况，为了避免这种情况的出现，我们需要将其Watcher先暂停一下，待我们处理结束后在重新启动就可以达到只触发一次的目的了。

var watcher = sender as ManagementEventWatcher;
watcher.Stop();
// 业务代码，逻辑耗时尽量不要太长，以免影响事件的监听
watcher.Start();

以上就是实现监听USB插拔的简易方法。

如何添加到开机自启动（入门篇）

Thu, 17 Jan 2019 09:23:03 +0000

大家都知道，我们有很多软件都是开机时，就会自启动，今天就初步来聊聊这个自启动。

添加应用程序自启动的方式

使用 msconfig 添加
从开始菜单中添加
通过修改注册表添加

使用msconfig添加

使用该方法比较简单，通过 win + R ,输入“msconfig”,这个时候会打开一个系统配置界面如下图所示：

只需要将需要开机启动的项勾选后，点击“全部启动”就可以完成程序自启动的添加或者关闭。

如果是在win10中，需要在任务管理器中设置

选中需要启动的进程名称，右键菜单中选择启用，启用后需要重启电脑生效。

从开始菜单中添加

在开始菜单中，所有应用中找到启动文件夹，将需要启动的程序快捷方式拖入进去就完成了开机自启动，或者将应用程序的快捷方式拖入到对应的路径下。
具体路径包含有：
当前用户专有的启动文件夹：%appdata%\Microsoft\Windows\Start Menu\Programs\StartUp
所有用户有效的启动文件夹：%ProgramData%\Microsoft\Windows\Start Menu\Programs\StartUp

通过修改注册表添加

前面有谈到通过msconfig添加自启动，聪明的人会发现，这个列表里面可能会没有找到你想设置的软件，那是因为能在这里显示的软件都是在注册表中有做定义的。具体注册表路径为：
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run 或 HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
这种添加应用程序自启动的最常用的一种方式。
以HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run为例，我们只需要在Run目录下添加一个字符串值，并将需要启动的应用程序路径添加到键值中。如下图所示：

这样就添加完成了，重启电脑就能看到效果。通过注册表添加自启动除了这个常用的注册表外，还有其他的一些方式可以用来添加自启动，添加方式是一致的。
具体参见：

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunServices
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServicesOnce
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunServicesOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Winlogon\Userinit

添加自启动示例代码

    public class AutoStartOperator
    {
        public static void AddToAutoStart(string strAppPath)
        {
            try
            {
                var registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, Environment.Is64BitOperatingSystem ? RegistryView.Registry64 : RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true);
                var strStartPath = registryKey.GetValue("Userinit").ToString();
                var strStartPathArray = strStartPath.Split(',');
                foreach (var startPath in strStartPathArray)
                {
                    if (startPath.Equals(strAppPath))
                        return;
                }
                if (strStartPath.EndsWith(","))
                {
                    strStartPath = $"{strStartPath}{strAppPath},";
                }
                else
                {
                    strStartPath = $"{strStartPath},{strAppPath},";
                }
                registryKey.SetValue("Userinit", strStartPath);
            }
            catch (Exception)
            {

            }
        }

        public static void RemoveAutoStart(string strAppPath)
        {
            try
            {
                var registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64).OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true);
                var strStartPath = registryKey.GetValue("Userinit").ToString();
                string newValue;
                if (strStartPath.EndsWith(strAppPath))
                {
                    newValue = strStartPath.Replace(strAppPath, "");
                }
                else
                {
                    newValue = strStartPath.Replace(strAppPath + ",", "");
                }
                registryKey.SetValue("Userinit", newValue);
            }
            catch (Exception)
            {

            }
        }
    }

知道以上信息，要添加到开机自启动，相信大家也有个初步的认识。针对这些开机启动的选择，我们下期再见。

Windows后台服务调试与安装

Sun, 02 Sep 2018 09:23:03 +0000

在我们日常工作中，不免需要编写windows后台服务程序。在这过程中，你是否有考虑过这几个问题呢？

服务调试很麻烦？
双击不能启动服务？
如何安装服务？
如何使用管理员权限启动？

针对以上问题，今天我们就来聊聊它们！

调试服务

在调试服务前，我们肯定需要先新建一个服务的解决方案。打开 Visual Studio ，“新建项目” -> “Windows 服务” 点击确定。如下图所示：

新建windows服务工程后，我们就可以在service1.cs文件里面添加我们的逻辑代码（跟普通写程序一样，这里就不做赘述）。我们可以尝试随便写一些逻辑代码，并准备开始调试。调试的方式有几种：

通过附加进程和断点调试

因为服务一般情况下是不能通过双击启动的，必须得先把服务安装好后才能调试
这个时候，OnStart/OnStop方法在执行的时候，我们没有办法去调试我们的代码，整个调试过程会变得很困难。这个时候，我们可能会考虑采用第二种方案（即下面的这种方案）。
通过Debugger.Launch()

在这种方案下，我们只需要将 Debugger.Launch() 这段代码插入到期望中断的代码位置，服务在启动的时候，便会把启动调试器的窗口弹出来，我们选择一个调试器就可以进去调试了。如下图所示：

随后的调试方法跟普通调试一样。不过这种方式也存在比较明显的缺点：每次调试一次都会弹出打开调试器窗口，费时费力，体检较差。
接下来看看第三种方法。

通过直接启动方式调试

在种模式下，我们首先需要了解一点，程序即时控制台，服务也不例外。在使用这种模式之前，我们首先需要将我们之前添加的服务程序设置成控制台程序。具体步骤：选择我们需要设置的项目，右键查看属性，将输出类型改成“控制台应用程序”

到这里，还没有结束，因为我们之前添加项目是以服务的方式添加，所以我们得在 Program.cs 文件里面修改主函数的输入参数。

 主函数：static void Main(string[] args)

到这里，我们的基本设置就完成了，接下来就需要它的这种模式，开启控制台启动逻辑了。我们首先需要判断当前是否是用户交互模式，即如果是鼠标双击启动，则为用户交互模式；如果是服务启动，则不是用户交互模式。

 判断当前是否是用户交互模式： Environment.UserInteractive

通过它，我们就可以针对两种不同的模式分别写我们的代码。下面是个完整的例子：

     static void Main(string[] args)
     {
         if (Environment.UserInteractive)
         {
             //以控制台模式启动                
             //服务好控制台共用的代码，初始化服务
             MainService mainService = new MainService(); 
             Console.WriteLine("正在启动服务");
             //这行代码，是服务OnStart的执行代码,自行修改。
             mainService.Start();                        
             Console.WriteLine("服务已启动,输入 exit 退出服务");
             while (Console.ReadLine() != "exit")
             {
                 //do something
             }
             //这行代码，是服务的OnStop的执行代码
             mainService.Stop();                         
         }
         else
         {
             //以服务模式启动
             ServiceBase[] ServicesToRun;
             ServicesToRun = new ServiceBase[]
             {
                 new MainService()
             };
             ServiceBase.Run(ServicesToRun);
         }
     }

使用这种方法，我们可以通过控制台的输出来监控我们的程序运行是否正常，用来做测试也非常方便，可以随便打断点，跟普通的控制台程序的使用一摸一样。

安装服务

当我们开发完服务程序后，会面临这样一样问题：我应该怎么安装我的服务呢？如果给用户更好的体验？接下来，我们针对这一问题，简单的聊一聊！服务安装的方式有多种，常见的方法有这么两种

使用cmd命令进行安装。

这种模式下，我们需要调起cmd.exe，输入命令行来完成我们的安装。例如：sc create “{服务名}” binpath =”{服务启动的程序绝对路径}”。后面也可以跟随参数，标记是否是自动启动等。也可以通过sc delete “{服务名}” 这种方式来删除服务。具体细节，这里就不做赘述，感兴趣可以自行查阅，我们主要讨论第二种方法。
使用C#代码来完成安装。

使用cmd命名的模式安装服务，难免会影响体验，也不好控制，虽然我们也可以在我们的代码里面去调用cmd来完成服务的安装，相对会显得很麻烦。所以，我们可以选择接下来讨论这种方式来安装我们的服务。双击打开我们刚才创建的服务，以上例子是 MainService.cs，我们会看到一个设计面板。

鼠标右键，选择添加安装程序，如下图所示：

创建安装程序后，这个时候会在项目中自动生成一个 ProjectInstaller.cs 文件，这个文件里面就包含了我们的安装信息。在这个文件里面，我们可以看到两个安装组件：serviceInstaller 和 serviceProcessInstall。
在serviceProcessInstall安装组件中，我们主要关注它的访问权限设置,其他的默认就好。

我们通常将访问权限设置为LocalSystem ，权限最大（注意：设置为这个权限，安装的时候需要以管理员权限运行）。具体区别可以参见：https://docs.microsoft.com/zh-cn/windows/desktop/Services/localsystem-account。

serviceProcessInstall设置完成后，我们接下来看下serviceInstaller，选中它，查看属性面板：

我们会发现他有更多的设置项，主要有：ServiceName (服务名) ，DisplayName (服务显示名)，StartType (启动类型)， DelayedAutoStart （是否延时启动），ServicesDependedOn (服务运行所依赖的其它服务列表)，Description (服务描述)。

通常我们主要前面三个就可以了，根据自己需要设置好就行了。
特别注意：服务安装程序设置好了后，它并不会自己进行安装，它需要由其它的程序来调用它，才能真正完成安装。

为了测试，我们可以新建一个测试的demo，用来安装这个服务（比如说在程序启动的时候，调用安装服务逻辑）。这里贴出关键代码。

        /// <summary>
        /// 安装服务
        /// </summary>
        /// <param name="serviceFilePath">服务程序的绝对路径</param>
        public static void Install(string serviceFilePath)
        {
            using (AssemblyInstaller installer = new AssemblyInstaller())
            {
                installer.UseNewContext = true;
                installer.Path = serviceFilePath;
                IDictionary savedState = new Hashtable();
                installer.Install(savedState);
                installer.Commit(savedState);
            }
        }

        /// <summary>
        /// 卸载服务
        /// </summary>
        /// <param name="serviceFilePath">服务程序的绝对路径</param>
        public static void Uninstall(string serviceFilePath)
        {
            using (AssemblyInstaller installer = new AssemblyInstaller())
            {
                installer.UseNewContext = true;
                installer.Path = serviceFilePath;
                installer.Uninstall(null);
            }
        }

只需要在我们的程序中调用以上代码，就可以完成对服务的安装。

提升权限

前面我们有提及到，要安装服务，需要有足够的权限才能成功。不用担心，我们有办法来给我们的程序做提权。我们找到刚才新建的demo程序，在项目的属性中，找到“安全性”选项卡，点击“启用ClickOnce安全设置”

这个时候项目中会自动生成一个 app.manifest 的配置文件，我们打开它：

我们可以看到红线部分的配置项，只需要将 level=”asInvoker” 修改成 requireAdministrator ，再保存。

设置完成后，再回到“安全性”选项卡，将“启用ClickOnce安全设置”取消选中。最后再编译后，我们看下我们的应用程序图标会发生变化，应用程序图标上多了个“盾牌”小图标，能看到这个，那么恭喜你成功了。

最后，可以运行程序愉快的玩耍了。

开始写一篇属于我们自己的博客

Sun, 02 Sep 2018 09:23:03 +0000

前面我们已经学习了如何搭建一个博客，现在的你是不是已经蠢蠢欲动，想动手开始写自己的博客了呢？别急，现在就教你，如何完成第一篇博客。

准备工作

学习使用Markdown基础语法
下载 visual studio code 编辑软件
下载UWP辅助程序-图床

准备写博客

在开始写博客之前，我们推荐使用markdown语法来写，markdown 的基础语法也比较简单，可以自行学习一下，这里就不赘述了（推荐工具：visual studio code，请自行下载安装）。

还记得我们前面讲到的几个需要注意的文件和文件夹：_posts 文件夹，_config.yml 文件，about.md。是的，我们只需要关注这几个部分。

先来看下 _config.yml 文件，我们使用 vs code 来打开它，我们可以看到这样的一些信息。

简单的说下其中的某些标签的含义：

                title : 显示在博客最上方的标题

               author : 现在作者的名称，显示在左上角位置

          post_author : 表示作者的名称，显示在author下方

                  logo: 我们的头像，显示在左上方

           description：描述，显示在post_author后方

                  mail: 邮箱地址，考虑的信息安全性，界面上不显示

     excerpt_separator: 用于将博客标题和内容分开，以便让我们博客在不点击进去的情况下，只显示标题。

     ……

about.md 文件对应博客的关于内容，可以根据自己的风格修改。

我们再来看下 _posts 文件夹。 _posts 文件夹其实就是我们博客所呈现的内容，我们只需要在这个文件夹下面创建一个 *.md 格式的文件，并在文件里面编辑我们要写的内容。

值得一说的是，在给文件命名的时候，需要注意把时间加上去，总体命名规则：年-月-日-博客标题。

如：2018-09-02-如何使用GitHub搭建简易博客。这样我们就完成了一篇最简单的博客编写了。

开始写博客

在写博客之前，我们可以先把个人信息部分先修改一下。

然后在_posts文件夹下新建一个 *.md文件，在里面编辑我们所需要些的内容。里面提到excerpt_separator,它所对应的值，就可以用来将标题和内容隔开，这样在我们的列表里面，就不会显示整个篇幅的内容了（需要点击进去看）。如下图所示：

效果预览：

另外，在我们写博客的过程中，可能经常会用到图片，但是作为博客，我们附加的图片是要能够外网访问的，那么问题来了，如果我们自己本地图片或者截图，那怎么使得我们的图片能够被外网访问呢？这个时候就需要图床这个工具来帮助我们解决这个问题了。根据上面的链接，先下载和安装图床APP（ump程序），安装完成后打开如下界面：

使用方法：我们先复制我们需要用到的图片，然后在图床的左边点击一下，图床工具就会自动生成一个预览图，并且生成适用于markdown和bbcode的描述文本，我们只需要将我们需要的文本拷贝到我们博客就可以了。

写到最后

到这里，我们已经可以完成我们的第一篇博客了，在我们写完后，将修改提交到github上。当我们提交完成后，网页上不能马上看到，需要等待小段时间（可能是几分钟）。过了几分钟后，就可以去我们的首页刷新看看效果啦。

如何使用GitHub搭建简易博客

Sun, 02 Sep 2018 09:23:03 +0000

本文告诉大家如何通过GitHub搭建简易博客

环境准备

下载并安装 Gitlab for Windows
下载博客模版（如果访问不了，请翻墙后重试）
注册 GitHub 帐号

具体搭建步骤

下载Git for Windows

在搭建博客之前，我们首先需要按照以上链接，将 Gitlab for Windows 软件先下载下来，并安装好。具体安装方法可以参考链接：Git for Windows安装和基本设置。

安装好了以后，我们就可以利用它来下载博客主题了。

下载方式有两种：

直接下载ZIP格式的压缩包，然后再解压出来,如下图所示：

使用git命令下载

在需要保存的目录下，打开git brash ，在命令窗口中输入下面代码

git clone "https://github.com/iip-easi/Theme"

下载后，包含以下文件

看到这么多文件，不要慌，其实我们需要关注的文件并不多，我们只需要关注 _config.yml 文件和 _posts 文件夹。

到这里，您已经把博客的主题下载下来了，接下来我们就需要把我们的博客跑起来了。

建立域名

在建域名之前，我们首先需要有个github帐号。如果你还没有，请点击这里注册! 在注册完成后，我们能看到以下界面

点击 New repository 进行新建仓库。

到这里，我们可以看到新建仓库的界面，这个界面也非常简单，我们只需要填写仓库的名称。 (值得注意的是，仓库的名称就是我们未来所使用的域名，填写的时候尽量填写一个比较容易记住的域名。) 并且将全新开放成public就可以了。

到了这里，我们已经创建好了域名，接下来我们需要让我们的博客跑起来。在模版里面，其实已经有了默认的主题和博客可以供预览使用。现在我们需要将我们前面下载下来的主题推送到我们的github服务器上。

我们先从github上拉取我们刚才新建的项目

命令：$ git pull

默认都是master分支。刚开始分支先并没有什么文件，我们需要将我们之前下载下来的Theme文件夹下的文件全部拷贝到这个分支的目录下。
如，放到我自己的仓库目录下：

我们再把这些文件推送到服务器上。

命令：$ git push

前面我们提到了 _config.yml 文件，这时我们打开这个文件

我们能看到这里面有一个baseurl的一个属性，我们需要把里面的URL改成我们的仓库地址。您只要将仓库地址替换成自己的仓库地址就好了。

到这里，我们的博客已经构建好了。我们可以尝试打开我们的链接，以我的博客地址为例：https://huchengv5.github.io。如果您能正常打开，那么恭喜您，您已经成功搭建了属于您自己的博客了。

关于后续，如何编写自己地第一篇博客，我们下次分享，尽请期待！

Markdown Mail

Sun, 24 Sep 2017 00:00:00 +0000

Markdown Mail

splender

Tue, 15 Aug 2017 00:00:00 +0000

splender

dotnet 职业技术学院

使用FFMpeg.AutoGen播放视频

说明：ffmpeg软解码和硬解码

环境准备

实现步骤

适用于.NET的FFMpeg.AutoGen简介

WPF如何实现“不用写转换器的Binding

具体实现思路如下：

XBinding扩展代码实现

多路绑定的转换器实现：

ICommand的实现：

共享内存的基本用法

共享内存打开与创建

共享内存数据读写

基于流式读取的完整示例

共享内存的优缺点

IMultiValueConverter的Values直接返回会怎样？

使用VisualStudio同时调试多个进程

WPF-如何实现图片按像素拉伸

WPF-缩放动画和平移动画叠加后会发生什么？

WPF如何使用外部字体

Nuget包的版本规范

版本号定义

语义说明：

版本号示例

版本范围

使用BaGet快速搭建nuget服务

环境准备

命令终端运行（自我寄宿）

以服务的方式运行

相关配置

配置Visual Studio中的Nuget配置

使用浏览器打开Nuget管理页面

如何动态加载程序集

如何使用ffmpeg进行录屏

诡异的Visual Studio编译错误

如何构建多平台nuget包

Nuget包的基础结构

Nuget包内部文件组织步骤

csproj标签的简单介绍

Window.Owner的几个注意事项

Application.Current正确获取主窗口

Path.Combine容易被忽略的细节

RichTextBox如何显示省略号？

如何显示灰色特效

说明：

渲染管线配置文件（*.fx）

应用WPF中特效类

位的基础运算

WebView2的踩坑记

一、Win7系统下，兼容性不够好

二、以管理员权限运行

三、WebView2的层级问题

EnsureCoreWebView2Async 一直处于等待状态

因为ssl证书不可用导致页面无法访问问题

一些奇怪的异常

reject is not a funtion

async await后的执行线程会是什么？

Mutex释放锁，从不同步的代码块中调用了对象同步方法？

解决思路

Xaml文件如何省去命名空间的前缀

手动升级csproj踩坑

一、类库中包含了 App.xaml

二、AssemblyAttribute 提示重复

三、生成事件批处理报错

四、命令行无法构建x64的原因

五、.NET Framework v4.5.2 基于netstandar无法编译通过

六、动态库的引用差异

手动构建nuget包

常用git命令汇总

常用参数解释

创建仓库

指定名称和邮箱

签出

拉取

查看状态

添加到提交

提交

推送

强推

一、类库中包含了 `App.xaml`

一、注册`JWT`中间件

二、生成`Token`

四、携带`Token`进行访问服务器的`API`

1、 `DependencyProperty.AddOwner`

2、 `DependencyProperty.OverrideMetadata`