Category Archives: C#

dapper使用

访问量不大的项目我都是用EF写数据库操作，因为EF除了速度上慢以外，但开发效率极快，省略了很多sql写法，并能很方便的调用外键、集合等信息，用EF写项目最爽的事。不过有些项目网站要考虑运行速度，这时不得不用其它的ORM框架，我常用dapper，因为它效果快，而且写sql非常灵活，接下来面写一些方法看看dapper的使用 1、连接语句 var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["SqlDiagnosticsDb"].ConnectionString); 使用dapper不需要考虑conn是否连接，在执行dapper时自行判断 open状态，如果没有打开它会自己打开。 2、insert

1 2	string query = "INSERT INTO Book(Name)VALUES(@name)"; conn.Execute(query, book);

book类中有name属性，就可以这样方便去写，当然也可以写成

1 2	string query = "INSERT INTO Book(Name)VALUES(@name)"; conn.Execute(query, new{@name=book.name});

3、update

1 2	string query = "UPDATE Book SET Name=@name WHERE id =@id"; conn.Execute(query, book);

4、 delete

string query = "DELETE FROM Book WHERE id = @id";

conn.Execute(query, book);

conn.Execute(query, new { id = id });

5、query

string query = "SELECT * FROM Book";

//无参数查询，返回列表，带参数查询和之前的参数赋值法相同。

conn.Query<Book>(query).ToList();

//返回单条信息

string query = "SELECT * FROM Book WHERE id = @id";

book = conn.Query<Book>(query, new { id = id }).SingleOrDefault();

6、传统sql in (1,2,3) 用dapper就这样写

1 2	conn.Query<Users>("SELECT * FROM Users s WHERE s.id IN (@ids) ",new { ids = new int[]{1,2,3}}) conn.Query<Users>("SELECT * FROM Users s WHERE s.id IN (@ids) ",new { ids = IDs.ToArray()})

在dapper因为安全性，不能直接用sql接接要采用参数化, 7、批量插入

1	conn.Execute(@"insert MyTable(colA, colB) values (@a, @b)", new[] { new { a=1, b=1 }, new { a=2, b=2 }, new { a=3, b=3 } })

也可以直接写入一个集合

1	conn.Execute("insert user(name) values(@name)",users)

这里users是一个user表的对象集合，可一次把集合中的所有数据插入到数据表中。 8、多表查询

//查询图书时，同时查找对应的书评，并存在List中。实现1--n的查询操作

string query = "SELECT * FROM Book b LEFT JOIN BookReview br ON br.BookId = b.Id WHERE b.id = @id";

Book lookup = null;

//Query<TFirst, TSecond, TReturn>

var b = conn.Query<Book, BookReview, Book>(query,

　　(book, bookReview) =>

　　{

　　　　//扫描第一条记录，判断非空和非重复

　　　　if (lookup == null || lookup.Id != book.Id)

　　　　　　lookup = book;

　　　　//书对应的书评非空，加入当前书的书评List中，最后把重复的书去掉。

　　　　if (bookReview != null)

　　　　　　lookup.Reviews.Add(bookReview);

　　　　return lookup;

　　}, new { id = id }).Distinct().SingleOrDefault();

return b;

多表联合查询是比较麻烦一些，到现在不是完全明白，多看几个例子

1 2	var sql = @"select * from Posts p join Users u on u.Id = p.OwnerId Order by p.Id"; var data = conn.Query<Post, User, Post>(sql, (post, user) => { post.Owner = user; return post;}，splitOn："id");

Post类和User类,它们存在外键， conn.Query返回的类型是最后一个参数Post, 其中Post中有一属性Owner是User对象，在(post, user)=>lamda中指定了Owner值，上边的代码中的splitOn是ID，运行时，会从查询结果所有字段列表的最后一个字段开始进行匹配，一直到找到Id这个字段（大小写忽略），找到的第一个ID字段匹配User类的ID属性，那么从ID到最后一个字段都属于User，ID以前的字段都被影射到Post，通过 (post, user) => {return post;},把两个类的实例解析出来。 9、三表查询，一个是关联主键表（单个对象），一个是关联外键表（集合）。

public partial class UserInfo

{

public UserInfo()

{

this.Persion = new HashSet<Persion>();

this.MyTYC = new HashSet<MyTYC>();

}

public int id { get; set; }

public string name { get; set; }

public Nullable<System.DateTime> createTime { get; set; }

public Movies Movies { get; set; }

public virtual ICollection<MyTYC> MyTYC { get; set; }

}

public class Movies

{

public int ID { get; set; }

public string Title { get; set; }

public string ReleaseDate { get; set; }

public string Genre { get; set; }

public string Price { get; set; }

public UserInfo UserInfo { get; set; }

}

public partial class MyTYC

{

public int id { get; set; }

public string name { get; set; }

}

string sql = @"select * from UserInfo u

inner join [Movies].dbo.Movies m on u.id=m.ID

inner join MyTYC t on u.id=t.id";

var data = conn.Query<UserInfo, Movies, MyTYC, UserInfo>(sql, (u, m, t) => { u.Movies = m; u.MyTYC.Add(t); return u; });

注意这里的对象和集合的获取方法：u.Movies = m; u.MyTYC.Add(t); 10、多结果查询

var sql = @"select * from Customers where CustomerId = @id;

select * from Orders where CustomerId = @id;

select * from Returns where CustomerId = @id";

using (var multi = connection.QueryMultiple(sql, new {id=selectedId}))

{

var customer = multi.Read<Customer>().Single();

var orders = multi.Read<Order>().ToList();

var returns = multi.Read<Return>().ToList();

}

再来一个

class Program

{

//创建连接对象

protected static SqlConnection GetConnection()

{

var connection = new SqlConnection("Data Source=.;Initial Catalog=TestDB;Integrated Security=True");

connection.Open();

return connection;

}

static void Main(string[] args)

{

//测试输出多个结果集

var sql = @"INSERT INTO [dbo].[Student] ([Name]) VALUES ('A1'); select @@IDENTITY as A;

INSERT INTO [dbo].[Student] ([Name]) VALUES ('B1'); select @@IDENTITY as A;

INSERT INTO [dbo].[Student] ([Name]) VALUES ('C1'); select @@IDENTITY as A";

//初始化数据库连接

using (SqlConnection connection = GetConnection())

{

List<int> ilist = new List<int>();

//执行查询，获取结果集集合

var multi = connection.QueryMultiple(sql);

//遍历结果集

while(!multi.IsConsumed)

{

//读取当前结果集

var result = multi.Read().ToList()[0].A;

if (result != null)

{

ilist.Add(Convert.ToInt32(result));

}

//for(int i = 0;i<3;i++)

//{

// var result = multi.Read().ToList()[0].A;

// if (result != null)

// {

// ilist.Add(Convert.ToInt32(result));

// }

//}

foreach (var item in ilist)

{

Console.WriteLine(item.ToString());

}

Console.ReadLine();

}

11、如果某一代码中多次操作数据库，可以把conn设置为打开，最后时再close, 比如：

conn.open()

conn.Query(.....

.....

for....

.....

conn.close()

from:https://www.cnblogs.com/lunawzh/p/6607116.html

龙生 27 Mar 2018

View Details

ABP入门教程

ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称。 ASP.NET Boilerplate是一个用最佳实践和流行技术开发现代WEB应用程序的新起点，它旨在成为一个通用的WEB应用程序框架和项目模板。 ABP的官方网站： http://www.aspnetboilerplate.com ABP在Github上的开源项目：https://github.com/aspnetboilerplate ABP 的由来 “DRY——避免重复代码”是一个优秀的开发者在开发软件时所具备的最重要的思想之一。我们在开发企业WEB应用程序时都有一些类似的需求，例如：都需要登录页面、用户/角色管理、权限验证、数据有效性验证、多语言/本地化等等。一个高品质的大型软件都会运用一些最佳实践，例如分层体系结构、领域驱动设计、依赖注入等。我们也可能会采用ORM、数据库迁移（Database Migrations）、日志记录（Logging）等工具。从零开始创建一个企业应用程序是一件繁琐的事，因为需要重复做很多常见的基础工作。许多公司都在开发自己的应用程序框架来重用于不同的项目，然后在框架的基础上开发一些新的功能。但并不是每个公司都有这样的实力。假如我们可以分享的更多，也许可以避免每个公司或每个项目的重复编写类似的代码。作者之所以把项目命名为“ASP.NET Boilerplate”，就是希望它能成为开发一般企业WEB应用的新起点，直接把ABP作为项目模板。 ABP是什么？ ABP是为新的现代Web应用程序使用最佳实践和使用最流行工具的一个起点。可作为一般用途的应用程序的基础框架或项目模板。它的功能包括：服务器端：基于最新的.NET技术（目前是ASP.NET MVC 5、Web API 2、C# 5.0，在ASP.NET 5正式发布后会升级）实现领域驱动设计（实体、仓储、领域服务、领域事件、应用服务、数据传输对象，工作单元等等）实现分层体系结构（领域层，应用层，展现层和基础设施层）提供了一个基础架构来开发可重用可配置的模块集成一些最流行的开源框架/库，也许有些是你正在使用的。提供了一个基础架构让我们很方便地使用依赖注入（使用Castle Windsor作为依赖注入的容器）提供Repository仓储模式支持不同的ORM（已实现Entity Framework 、NHibernate、MangoDb和内存数据库）支持并实现数据库迁移（EF 的 Code first）模块化开发（每个模块有独立的EF DbContext，可单独指定数据库）包括一个简单的和灵活的多语言/本地化系统包括一个 EventBus来实现服务器端全局的领域事件统一的异常处理（应用层几乎不需要处理自己写异常处理代码）数据有效性验证（Asp.NET MVC只能做到Action方法的参数验证，ABP实现了Application层方法的参数有效性验证）通过Application Services自动创建Web Api层（不需要写ApiController层了）提供基类和帮助类让我们方便地实现一些常见的任务使用“约定优于配置原则” 客户端： Bootstrap、Less、AngularJs、jQuery、Modernizr和其他JS库: jQuery.validate、jQuery.form、jQuery.blockUI、json2等为单页面应用程序（AngularJs、Durandaljs）和多页面应用程序（Bootstrap+Jquery）提供了项目模板。自动创建Javascript 的代理层来更方便使用Web Api 封装一些Javascript 函数，更方便地使用ajax、消息框、通知组件、忙状态的遮罩层等等除ABP框架项目以外，还开发了名叫“Zero”的模块，实现了以下功能：身份验证与授权管理（通过ASP.NET Identity实现的）用户&角色管理系统设置存取管理（系统级、租户级、用户级，作用范围自动管理）审计日志（自动记录每一次接口的调用者和参数） ABP不是什么？ ABP 提供了一个应用程序开发模型用于最佳实践。它拥有基础类、接口和工具使我们容易建立起可维护的大规模的应用程序。然而：它不是RAD工具之一，RAD工具的目的是无需编码创建应用程序。相反，ABP提供了一种编码的最佳实践。它不是一个代码生成工具。在运行时虽然它有一些特性构建动态代码，但它不能生成代码。它不是一个一体化的框架。相反，它使用流行的工具/库来完成特定的任务（例如用EF做ORM，用Log4Net做日志记录，使得Castle Windsor作为赖注入容器， AngularJs 用于SPA 框架）。就我使用了ABP几个月的经验来看，虽然ABP不是RAD，但是用它开发项目绝对比传统三层架构要快很多。虽然ABP不是代码生成工具，但因为有了它，使我们项目的代码更简洁规范，这有利于使用代码生成工具。我自己使用VS2013的Scaffolder+T4开发的代码生成器，可根据领域对象的UML类图自动生成全部前后端代码和数据库，简单的CURD模块几乎不需要编写代码，有复杂业务逻辑的模块主要补充领域层代码即可。这样就能把时间多花在领域模型的设计上，减少写代码的时间。下面通过原作者的“简单任务系统”例子，演示如何运用ABP开发项目从模板创建空的web应用程序 ABP提供了一个启动模板用于新建的项目（尽管你能手动地创建项目并且从nuget获得ABP包，模板的方式更容易）。转到www.aspnetboilerplate.com/Templates从模板创建你的应用程序。你可以选择SPA（AngularJs或DurandalJs）或者选择MPA（经典的多页面应用程序）项目。可以选择Entity Framework或NHibernate作为ORM框架。这里我们选择AngularJs和Entity Framework，填入项目名称“SimpleTaskSystem”，点击“CREATE […]

龙生 25 Mar 2018

View Details

聊聊ASP.NET Core默认提供的这个跨平台的服务器——KestrelServer

跨平台是ASP.NET Core一个显著的特性，而KestrelServer是目前微软推出了唯一一个能够真正跨平台的Server。KestrelServer利用一个名为KestrelEngine的网络引擎实现对请求的监听、接收和响应。KetrelServer之所以具有跨平台的特质，源于KestrelEngine是在一个名为libuv的跨平台网络库上开发的。目录一、libuv 二、KestrelServer 三、KestrelServerOptions 四、ApplicationLifetime 五、设置监听地址一、libuv 说起libuv，就不得不谈谈libev，后者是Unix系统上一个事件循环和事件模型的网络库。libev因其具有的高性能成为了继lievent和Event perl module之后一套最受欢迎的网络库。由于Libev不支持Windows，有人在libev之上创建了一个抽象层以屏蔽平台之间的差异，这个抽象层就是libuv。libuv在Windows平台上是采用IOCP的形式实现的，右图揭示了libuv针对Unix和Windows的跨平台实现原理。到目前为止，libuv支持的平台已经不限于Unix和Windows了，包括Linux（2.6）、MacOS和Solaris （121以及之后的版本）在内的平台在libuv支持范围之内。二、KestrelServer 如下所示的代码片段体现了KestrelServer这个类型的定义。除了实现接口IServer定义的Features属性之外，KestrelServer还具有一个类型为KestrelServerOptions的只读属性Options。这个属性表示对KestrelServer所作的相关设置，我们在调用构造函数时通过输入参数options所代表的IOptions<KestrelServerOptions>对象对这个属性进行初始化。构造函数还具有另两个额外的参数，它们的类型分别是IApplicationLifetime和ILoggerFactory，后者用于创建记录日志的Logger，前者与应用的生命周期管理有关。

1: public class KestrelServer : IServer

2: {

3: public IFeatureCollection Features { get; }

4: public KestrelServerOptions Options { get; }

6: public KestrelServer(IOptions<KestrelServerOptions> options,IApplicationLifetime applicationLifetime, ILoggerFactory loggerFactory);

7: public void Dispose();

8: public void Start<TContext>(IHttpApplication<TContext> application);

9: }

我们一般通过调用WebHostBuilder的扩展方法UseKestrel方法来完成对KestrelServer的注册。如下面的代码片段所示，UseKestrel方法具有两个重载，其中一个具有同一个类型为Action<KestrelServerOptions>的参数，我们可以利用这个参数直接完成对KestrelServerOptions的设置。

1: public static class WebHostBuilderKestrelExtensions

2: {

3: public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder);

4: public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder, Action<KestrelServerOptions> options);

5: }

三、KestrelServerOptions 由于Server负责请求的监听、接收和响应，所以Server是影响整个Web应用响应能力和吞吐量最大的因素之一，为了更加有效地使用Server，我们往往针对具体的网络负载状况对其作针对性的设置。对于KestrelServer来说，在构造函数中作为参数指定的KestrelServerOptions对象代表针对它所做的设置。我们针对KestrelServer所做的设置主要体现在KestrelServerOptions类型的如下5个属性上。

1: public class KestrelServerOptions

2: {

3: //省略其他成员

4: public int MaxPooledHeaders { get; set; }

5: public int MaxPooledStreams { get; set; }

6: public bool NoDelay { get; set; }

7: public TimeSpan ShutdownTimeout { get; set; }

8: public int ThreadCount { get; set; }

9: }

KestrelServerOptions注册的KetrelServer在管道中会以依赖注入的方式被创建，并采用构造器注入的方式提供其构造函数的参数options，由于这个参数类型为IOptions<KestrelServerOptions>，所以我们利用Options模型以配置的方式来指定KestrelServerOptions对象承载的设置。比如我们可以将KestrelServer的相关配置定义在如下一个JSON文件中。

1: {

2: "noDelay" : false,

3: "shutdownTimeout" : "00:00:10",

4: "threadCount" : 10

5: }

为了让应用加载这么一个配置文件（文件名假设为“KestrelServerOptions.json”），我们只需要在启动类型（Startup）类的ConfigureServces方法中按照如下的方式利用ConfigurationBuilder加载这个配置文件并生成相应的Configuration对象，最后按照Options模型的编程方式完成KestrelServerOptions类型和该对象的映射即可。

1: public class Startup

2: {

3: //其他成员

4: public void ConfigureServices(IServiceCollection services)

5: {

6: IConfiguration configuration = new ConfigurationBuilder()

7: .AddJsonFile("KestrelServerOptions.json")

8: .Build();

9: services.Configure<KestrelServerOptions>(configuration);

10: }

11: }

四、ApplicationLifetime 我们将所有实现了IApplicationLifetime接口的所有类型及其对应对象统称为ApplicationLifetime。从命名的角度来看，ApplicationLifetime貌似是对当前应用生命周期的描述，而实际上它存在的目的仅仅是在应用启动和关闭（只要是关闭）时对相关组件发送通知而已。如下面的代码片段所示，IApplicationLifetime接口具有三个CancellationToken类型的属性（ApplicationStarted、ApplicationStopping和ApplicationStopped），我们可以利用它们是否已经被取消（Cancel）确定当前应用的状态（已经开启、正在关闭和已经关闭）。如果试图关闭应用，StopApplication方法应该被调用以发出应用正在被关闭的通知。对于KestrelServer来说，如果请求处理线程中发生未被处理异常，它会调用这个方法。

1: public interface IApplicationLifetime

2: {

3: CancellationToken ApplicationStarted { get; }

4: CancellationToken ApplicationStopping { get; }

5: CancellationToken ApplicationStopped { get; }

7: void StopApplication();

8: }

ASP.NET Core默认使用的ApplicationLifetime是具有如下定义的一个同名类型。可以看出它实现的三个属性返回的CancellationToken对象是通过三个对应的CancellationTokenSource生成。除了实现IApplicationLifetime接口的StopApplication方法用于发送“正在关闭”通知之外，这个类型还定义了额外两个方法（NotifyStarted和NotifyStopped）用于发送“已经开启/关闭”的通知。

1: public class ApplicationLifetime : IApplicationLifetime

2: {

3: private readonly CancellationTokenSource _startedSource = new CancellationTokenSource();

4: private readonly CancellationTokenSource _stoppedSource = new CancellationTokenSource();

5: private readonly CancellationTokenSource _stoppingSource = new CancellationTokenSource();

7: public CancellationToken ApplicationStarted

8: {

9: get { return this._startedSource.Token; }

10: }

11: public CancellationToken ApplicationStopped

12: {

13: get { return this._stoppedSource.Token; }

14: }

15: public CancellationToken ApplicationStopping

16: {

17: get { return this._stoppingSource.Token; }

18: }

19:

20: public void NotifyStarted()

21: {

22: this._startedSource.Cancel(false);

23: }

24: public void NotifyStopped()

25: {

26: this._stoppedSource.Cancel(false);

27: }

28: public void StopApplication()

29: {

30: this._stoppingSource.Cancel(false);

31: }

32: }

一个ASP.NET Core应用利用管道处理请求，所以管道的生命周期等同于应用自身的生命周期。当我们调用Run方法开启WebHost时，请求处理管道被构建出来。如果管道在处理请求时发生未被处理的异常，管道的Sever会调用ApplicationLifeTime对象的StopApplication方法向WebHost发送关闭应用的通知以便后者执行一些回收释放工作。五、设置监听地址在演示的实例中，我们实际上并不曾为注册的KestrelServer指定一个监听地址，从运行的效果我们不难看出，WebHost在这种情况下会指定“http://localhost:5000”为默认的监听地址，Server的监听地址自然可以显式指定。在介绍如何通过编程的方式为Server指定监听地址之前，我们有先来认识一个名为ServerAddressesFeature的特性。我们知道表示Server的接口IServer中定义了一个类型为IFeatureCollection 的只读属性Features，它表示用于描述当前Server的特性集合，ServerAddressesFeature作为一个重要的特性，就包含在这个集合之中。我们所说的ServerAddressesFeature对象是对所有实现了IServerAddressesFeature接口的所有类型及其对应对象的统称，该接口具有一个唯一的只读属性返回Server的监听地址列表。ASP.NET Core默认使用的ServerAddressesFeature是具有如下定义的同名类型。

1: public interface IServerAddressesFeature

2: {

3: ICollection<string> Addresses { get; }

4: }

6: public class ServerAddressesFeature : IServerAddressesFeature

7: {

8: public ICollection<string> Addresses { get; }

9: }

对于WebHost在通过依赖注入的方式创建的Server，由它的Features属性表示的特性集合中会默认包含这么一个ServerAddressesFeature对象。如果没有一个合法的监听地址被添加到这个 ServerAddressesFeature对象的地址列表中，WebHost会将显式指定的地址（一个或者多个）添加到该列表中。我们显式指定的监听地址实际上是作为WebHost的配置保存在一个Configuration对象上，配置项对应的Key为“server.urls”，WebHostDefaults的静态只读属性ServerUrlsKey返回的就是这么一个Key。

1: new WebHostBuilder()

2: .UseSetting(WebHostDefaults.ServerUrlsKey, "http://localhost:3721/")

3: .UseMyKestrel()

4: .UseStartup<Startup>()

5: .Build()

6: .Run();

WebHost的配置最初来源于创建它的WebHostBuilder，后者提供了一个UseSettings方法来设置某个配置项的值，所以我们可以采用如下的方式来指定监听地址（“http://localhost:3721/”）。不过，针对监听地址的显式设置，最直接的编程方式还是调用WebHostBuilder的扩展方法UseUrls，如下面的代码片段所示，该方法的实现逻辑与上面完全一致。

1: public static class WebHostBuilderExtensions

2: {

3: public static IWebHostBuilder UseUrls(this IWebHostBuilder hostBuilder, params string[] urls)

4: =>hostBuilder.UseSetting(WebHostDefaults.ServerUrlsKey, string.Join(ServerUrlsSeparator, urls)) ;

5: }

from:https://www.cnblogs.com/artech/p/KestrelServer.html

龙生 25 Mar 2018

View Details

ASP.NET Core的Kestrel服务器

原文地址—-Kestrel server for ASP.NET Core By Tom Dykstra, Chris Ross, and Stephen Halter Kestrel是一个基于libuv的跨平台ASP.NET Core web服务器，libuv是一个跨平台的异步I/O库。ASP.NET Core模板项目使用Kestrel作为默认的web服务器。 Kestrel支持以下功能： HTTPS 用于启用不透明升级的WebSockets 位于Nginx之后的高性能Unix sockets Kestrel 被.NET Core支持的所有平台和版本所支持查看或下载示例代码何时使用Kestrel和反向代理服务器如果你的应用只接收来自内部网络的请求，你可以只使用Kestrel本身。如果你将你的应用部署在公共网络上，我们建议你使用IIS，Nginx或者Apache作为反向代理服务器。一个反向代理服务器接收来自网络的HTTP请求并且在经过一些初步处理后将请求传递到Kestrel服务器。出于安全性的理由，反向代理常常被edge deployments所采用。因为Kestrel相对较新，对抵御安全攻击至今还没有一个完整的功能补充。安全性处理包括但不限于适当的超时，大小的限制，以及并发连接限制等问题。另一个需要反向代理的场景是，你有多个需要在单独的服务器上运行并分享同一端口的应用。因为Kestrel不支持在多进程间分享同一端口，所以应用并不能直接和Kestrel合作。当你在某个端口上配置Kestrel运行侦听时，不算主机头如何标识，Kestrel会为该端口处理所有的流量。反向代理可以为多个应用共享唯一端口并将流量发送给Kestrel。即使不需要反向代理服务器，使用它也可以简化负载均衡和SSL设置 — 只要你的反向代理服务器需要SSL证书，并且该服务器可以和你的应用在内部网中通过普通HTTP进行通信。如何在ASP.NET Core应用中使用Kestrel 安装 Microsoft.AspNetCore.Server.Kestrel Nuget包。在应用的Main方法中调用WebHostBuilder的UseKestrel 扩展方法，指定你需要的Kestrel选项，如以下示例所示：

public static int Main(string[] args)

{

Console.WriteLine("Running demo with Kestrel.");

var config = new ConfigurationBuilder()

.AddCommandLine(args)

.Build();

var builder = new WebHostBuilder()

.UseContentRoot(Directory.GetCurrentDirectory())

.UseConfiguration(config)

.UseStartup<Startup>()

.UseKestrel(options =>

{

if (config["threadCount"] != null)

{

options.ThreadCount = int.Parse(config["threadCount"]);

}

})

.UseUrls("http://localhost:5000");

var host = builder.Build();

host.Run();

return 0;

}

URL 前缀默认情况下，ASP.NET Core项目绑定了http://localhost:5000。通过使用UseUrls扩展方法——编辑urls命令行参数，或者是通过ASP.NET Core配置系统，你可以为Ketrel配置URL前缀和端口号以用来侦听请求。关于这些方法更多的信息，请参考Hosting。有关于当你使用IIS作为反向代理时，URL绑定是如何工作的信息，请参考ASP.NET Core 模块。 Kestrel URL前缀可以是以下格式中的任一种。 IPv4 地址和端口号

1 2	http://65.55.39.10:80/ https://65.55.39.10:443/

IPv6 地址和端口号

1 2	http://[0:0:0:0:0:ffff:4137:270a]:80/ https://[0:0:0:0:0:ffff:4137:270a]:443/

IPv6中的 [::] 等价于 IPv4 0.0.0.0。主机名和端口号

http://contoso.com:80/

http://*:80/

https://contoso.com:443/

https://*:443/

主机名称，*，以及+，都不是特殊的。任何没有公认的IP 或是“localhost”的地址将绑定到所有的IPv4和IPv6的IP上。如果你需要为不同的ASP.NET Core应用在同一端口上绑定不同的主机名，请使用WebListener或者诸如IIS，Nginx或Apache这样的反向代理服务器。 *　"Localhost" 名称和端口号或回送IP地址和端口号

http://localhost:5000/

http://127.0.0.1:5000/

http://[::1]:5000/

当localhost被指定时，Kestrel会尝试去绑定到IPv4和IPv6的环回接口。如果被请求的端口号正在任一环回接口上被其他服务所使用，Kestrel将会启动失败。如果任一环回接口出于各种原因而不可用（最通常的情况是因为IPv6暂不被支持），Kestrel将记录下一个警告信息。 Unix socket

1	http://unix:/run/dan-live.sock

如果你指定了端口号0，Kestrel将动态地绑定到合适的端口号。除了localhost名称，绑定到0端口号被其他任何主机名称或IP地址所允许。当你指定了端口号0，你可以使用IServerAddressesFeature接口去决定运行时Kestrel实际绑定到哪个端口。下列示例用于获取绑定端口并且在console上显示出来。

public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)

{

loggerFactory.AddConsole();

var serverAddressesFeature = app.ServerFeatures.Get<IServerAddressesFeature>();

app.UseStaticFiles();

app.Run(async (context) =>

{

context.Response.ContentType = "text/html";

await context.Response

.WriteAsync("Hosted by Kestrel");

if (serverAddressesFeature != null)

{

await context.Response

.WriteAsync("Listening on the following addresses: " +

string.Join(", ", serverAddressesFeature.Addresses) +

"");

}

await context.Response.WriteAsync($"Request URL: {context.Request.GetDisplayUrl()}");

});

}

SSL的URL前缀如果你调用UseSSL扩展方法，请确保在https:中包含URL前缀，如下所示：

var host = new WebHostBuilder()

.UseKestrel(options =>

{

options.UseHttps("testCert.pfx", "testPassword");

})

.UseUrls("http://localhost:5000", "https://localhost:5001")

.UseContentRoot(Directory.GetCurrentDirectory())

.UseStartup<Startup>()

.Build();

Note HTTPS和HTTP不能在同一端口上被托管。下一步更多的信息，请参考以下资源： Sample app for this […]

龙生 25 Mar 2018

View Details

C# Unity的使用

控制反转：我们向IOC容器发出获取一个对象实例的一个请求，IOC容器便把这个对象实例“注入”到我们的手中，在这个过程中你不是一个控制者而是一个请求者，依赖于容器提供给你的资源，控制权落到了容器身上。这个过程就是控制反转。依赖注入：我们向容器发出请求以后，获得这个对象实例的过程就叫依赖注入。 IoC模式其实是工厂设计模式的升华，在微软较早的PetShop项目通过反射技术做了很多工厂。我认为可能是IoC的原型。关于Ioc的框架有很多，比如Castle Windsor、Unity、Spring.NET、StructureMap，我们这边使用微软提供的Unity做示例，你可以使用 Nuget 添加 Unity ，也可以引用Microsoft.Practices.Unity.dll和Microsoft.Practices.Unity.Configuration.dll，下面我们就一步一步的学习下 Unity依赖注入的详细使用。 Unity是微软推出的IOC框架，使用这个框架，可以实现AOP面向切面编程，便于代码的后期维护，此外，这套框架还自带单例模式，可以提高程序的运行效率。下面是我自己的案例，以供日后参考：使用VS2015的Nuget管理器下载Unity。程序员接口类：

namespace UnityDemo

{

public interface IProgrammer

{

void Working();

}

程序员类：

using System;

namespace UnityDemo

{

public class CSharp : IProgrammer

{

public void Working()

{

Console.WriteLine("programming C# ...");

}

public class VB : IProgrammer

{

public void Working()

{

Console.WriteLine("programming VB ...");

}

public class Java : IProgrammer

{

public void Working()

{

Console.WriteLine("programming Java ...");

}

App.config配置文件：

<?xml version="1.0" encoding="utf-8"?>

<!--<startup>

</startup>-->

</configSections>

<unity>

</container>

</containers>

</unity>

</configuration>

主程序代码：

using Microsoft.Practices.Unity;

using Microsoft.Practices.Unity.Configuration;

using System;

using System.Configuration;

namespace UnityDemo

{

class Program

{

private static IUnityContainer container = null;

static void Main(string[] args)

{

RegisterContainer();

var programmer = container.Resolve<IProgrammer>("CSharp");

//var programmer = container.Resolve<IProgrammer>("VB");

programmer.Working();

Console.ReadKey();

}

private static void RegisterContainer()

{

container = new UnityContainer();

UnityConfigurationSection config =(UnityConfigurationSection) ConfigurationManager.GetSection(UnityConfigurationSection.SectionName);

config.Configure(container, "Programmer");

}

运行结果：这个Demo的思想：定义一个程序员接口IProgrammer，有3个实现这个接口的程序员类，分别是CSharp、VB、Java，然后配置App.config文件，里面首先定义一个配置节点（configSection），名称为Unity，引用的命名空间是微软的Unity，接着下面定义一个unity节点，里面的容器集合（containers），集合里面可以有多个容器，这个Demo里的只有一个容器，里面包含了3个注册节点（register），分别是CSharp，VB、Java，注意，里节点中的name属性用于在程序调用时选择类的。在主程序的代码中， 1、有一个Unity的容器container； 2、注册容器的方法RegisterContainer，作用是到App.config中读取容器的信息，把接口和3个类的映射关系注册到容器中； 3、主程序运行前，先注册容器，然后通过容器的Resolve方法，实例化一个programmer类，原理大概是，我们把类名传入到容器中，容器会根据类名，找到App.config中对应的register映射关系，容器就会通过反射得到相应的程序员类，返回这个类。 4、此时programmer类就实例化完成，可以使用了。使用了Unity，以后如果需要追加新的类，只需要实现IProgrammer接口，在配置文件追加映射关系，执行代码中修改name的值就能使用新的类了。这样，我们不需要删除旧的代码，就能追加新的功能，便于维护代码。本人的Demo下载转自： https://www.cnblogs.com/chenyucong/p/6272600.html

龙生 25 Mar 2018

View Details

官网生成带Zero的Abp出现Default language is not defined!的错误

官网生成的ABP + module zero出现Default language is not defined!的错误，原因是数据库没有language数据，而不是缺少language.xml资源文件，所以先创建数据库就好了。解决方法： 1.选择Web项目作为起始项目。 2.打开程序包管理控制台，选择“EntityFramework”项目作为默认项目，然后运行EF的’Update-Database’命令。该命令会创建数据库。 3.运行该应用，默认的用户名是’admin’，密码是’123qwe’。在执行第2步时遇到了如下错误： Update-Database : 无法将“Update-Database”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括路径，请确保路径正确，然后重试。原因可能是EntityFramework没有安装，Install-Package EntityFramework就好了。什么？还是不行？全部重新生成再重新打开vs试试吧！ https://blog.csdn.net/klo220/article/details/51138582

龙生 25 Mar 2018

View Details

集合已修改;可能无法执行枚举操作

摘要我相信很多人对这个再熟悉不过了。对已经修改的集合进行操作就会出现这个错。解决办法比如有下面的一段代码，我们创建一个集合，并向集合中添加10个数，然后，我们循环再将这些数移除了。

static void Main(string[] args)

{

List<int> lst = new List<int>();

for (int i = 0; i < 10; i++)

{

lst.Add(i);

}

foreach (var item in lst)

{

lst.Remove(item);

}

Console.Read();

}

出现了….. 是不是被泛型集合提供的方法坑了？我记得很久之前我也被坑过。很疑惑吧，其实也很简单，因为你如果移除了一项，集合的元素个数是变化的。这个时候元素会重排，第二个元素的索引由1变为0，后面的依次往前移动。

static void Main(string[] args)

{

List<int> lst = new List<int>();

for (int i = 0; i < 10; i++)

{

lst.Add(i);

}

var result = lst;

Console.WriteLine("lst的count" + lst.Count);

lst.Remove(0);

Console.WriteLine("lst的count" + lst.Count);

for (int i = 0; i < lst.Count; i++)

{

Console.WriteLine("索引:{0},值：{1}", i, lst[i]);

}

Console.Read();

}

上面的代码为集合添加10个元素。然后输出当前集合的count，接着将索引为0的元素移除。这个时候集合中应该没有元素0了。然后输出集合的元素个数。输出此时的集合中索引和对应的值。如图所示可以看到，本来索引为1的1，往前移动了，此时他的索引变为了0.所以在使用foreach移除的时候，集合是变化的，是不允许的。难道就没办法操作了吗？当然有，它不是移除一个集合就少一个吗》此时，我们可以通过for循环，从集合的队尾移除，这个时候移除队尾的元素，虽然集合的count变了，但他们的索引没有变化。

static void Main(string[] args)

{

List<int> lst = new List<int>();

for (int i = 0; i < 10; i++)

{

lst.Add(i);

}

var result = lst;

Console.WriteLine("lst的count" + lst.Count);

lst.Remove(0);

Console.WriteLine("lst的count" + lst.Count);

for (int i = lst.Count - 1; i >= 0; i--)

{

Console.WriteLine("索引:{0},值：{1}", i, lst[i]);

Console.WriteLine("移除了元素：{0}", lst[i]);

lst.RemoveAt(i);

}

Console.Read();

}

那么我们只移除满足条件的是否也可以通过for循环呢？当然可以，foreach你不是不让吗？又不是只有你一个可以循环。

static void Main(string[] args)

{

List<int> lst = new List<int>();

for (int i = 0; i < 10; i++)

{

lst.Add(i);

}

var result = lst;

Console.WriteLine("lst的count" + lst.Count);

lst.Remove(0);

Console.WriteLine("lst的count" + lst.Count);

for (int i = 0; i < lst.Count; i++)

{

Console.WriteLine("索引:{0},值：{1}", i, lst[i]);

if (lst[i] % 2 == 0)

{

Console.WriteLine("移除了元素：{0}", lst[i]);

lst.RemoveAt(i);

}

Console.Read();

}

总结前不久刚有人遇到，这里还是记录一下吧。 from:https://www.cnblogs.com/wolf-sun/p/5721457.html

龙生 08 Jan 2018

View Details

浅谈命令查询职责分离(CQRS)模式

在常用的三层架构中，通常都是通过数据访问层来修改或者查询数据，一般修改和查询使用的是相同的实体。在一些业务逻辑简单的系统中可能没有什么问题，但是随着系统逻辑变得复杂，用户增多，这种设计就会出现一些性能问题。虽然在DB上可以做一些读写分离的设计，但在业务上如果在读写方面混合在一起的话，仍然会出现一些问题。本文介绍了命令查询职责分离模式(Command Query Responsibility Segregation，CQRS)，该模式从业务上分离修改 (Command，增，删，改，会对系统状态进行修改)和查询（Query，查，不会对系统状态进行修改)的行为。从而使得逻辑更加清晰，便于对不同部分进行针对性的优化。文章首先简要介绍了传统的CRUD方式存在的问题，接着介绍了CQRS模式，最后以一个简单的在线日记系统演示了如何实现CQRS模式。要谈到读写操作，首先我们来看传统的CRUD的问题。一 CRUD方式的问题在以前的管理系统中，命令(Command，通常用来更新数据，操作DB)和查询(Query)通常使用的是在数据访问层中Repository中的实体对象(这些对象是对DB中表的映射)，这些实体有可能是SQLServer中的一行数据或者多个表。通常对DB执行的增，删，改，查（CRUD）都是针对的系统的实体对象。如通过数据访问层获取数据，然后通过数据传输对象DTO传给表现层。或者，用户需要更新数据，通过DTO对象将数据传给Model，然后通过数据访问层写回数据库，系统中的所有交互都是和数据查询和存储有关，可以认为是数据驱动（Data-Driven）的，如下图：对于一些比较简单的系统，使用这种CRUD的设计方式能够满足要求。特别是通过一些代码生成工具及ORM等能够非常方便快速的实现功能。但是传统的CRUD方法有一些问题：使用同一个对象实体来进行数据库读写可能会太粗糙，大多数情况下，比如编辑的时候可能只需要更新个别字段，但是却需要将整个对象都穿进去，有些字段其实是不需要更新的。在查询的时候在表现层可能只需要个别字段，但是需要查询和返回整个实体对象。使用同一实体对象对同一数据进行读写操作的时候，可能会遇到资源竞争的情况，经常要处理的锁的问题，在写入数据的时候，需要加锁。读取数据的时候需要判断是否允许脏读。这样使得系统的逻辑性和复杂性增加，并且会对系统吞吐量的增长会产生影响。同步的，直接与数据库进行交互在大数据量同时访问的情况下可能会影响性能和响应性，并且可能会产生性能瓶颈。由于同一实体对象都会在读写操作中用到，所以对于安全和权限的管理会变得比较复杂。这里面很重要的一个问题是，系统中的读写频率比，是偏向读，还是偏向写，就如同一般的数据结构在查找和修改上时间复杂度不一样，在设计系统的结构时也需要考虑这样的问题。解决方法就是我们经常用到的对数据库进行读写分离。让主数据库处理事务性的增，删，改操作(Insert,Update,Delete)操作，让从数据库处理查询操作(Select操作)，数据库复制被用来将事务性操作导致的变更同步到集群中的从数据库。这只是从DB角度处理了读写分离，但是从业务或者系统上面读和写仍然是存放在一起的。他们都是用的同一个实体对象。要从业务上将读和写分离，就是接下来要介绍的命令查询职责分离模式。二什么是CQRS CQRS最早来自于Betrand Meyer（Eiffel语言之父，开-闭原则OCP提出者）在 Object-Oriented Software Construction 这本书中提到的一种命令查询分离 (Command Query Separation,CQS) 的概念。其基本思想在于，任何一个对象的方法可以分为两大类：命令(Command):不返回任何结果(void)，但会改变对象的状态。查询(Query):返回结果，但是不会改变对象的状态，对系统没有副作用。根据CQS的思想，任何一个方法都可以拆分为命令和查询两部分，比如：

1	private int i = 0;

private int Increase(int value)

{

i += value;

return i;

}

这个方法，我们执行了一个命令即对变量i进行相加，同时又执行了一个Query，即查询返回了i的值，如果按照CQS的思想，该方法可以拆成Command和Query两个方法，如下：

private void IncreaseCommand(int value)

{

i += value;

}

private int QueryValue()

{

return i;

}

操作和查询分离使得我们能够更好的把握对象的细节，能够更好的理解哪些操作会改变系统的状态。当然CQS也有一些缺点，比如代码需要处理多线程的情况。 CQRS是对CQS模式的进一步改进成的一种简单模式。它由Greg Young在CQRS, Task Based UIs, Event Sourcing agh! 这篇文章中提出。“CQRS只是简单的将之前只需要创建一个对象拆分成了两个对象，这种分离是基于方法是执行命令还是执行查询这一原则来定的(这个和CQS的定义一致)”。 CQRS使用分离的接口将数据查询操作(Queries)和数据修改操作(Commands)分离开来，这也意味着在查询和更新过程中使用的数据模型也是不一样的。这样读和写逻辑就隔离开来了。使用CQRS分离了读写职责之后，可以对数据进行读写分离操作来改进性能，可扩展性和安全。如下图：主数据库处理CUD，从库处理R，从库的的结构可以和主库的结构完全一样，也可以不一样，从库主要用来进行只读的查询操作。在数量上从库的个数也可以根据查询的规模进行扩展，在业务逻辑上，也可以根据专题从主库中划分出不同的从库。从库也可以实现成ReportingDatabase，根据查询的业务需求，从主库中抽取一些必要的数据生成一系列查询报表来存储。使用ReportingDatabase的一些优点通常可以使得查询变得更加简单高效： ReportingDatabase的结构和数据表会针对常用的查询请求进行设计。 ReportingDatabase数据库通常会去正规化，存储一些冗余而减少必要的Join等联合查询操作，使得查询简化和高效，一些在主数据库中用不到的数据信息，在ReportingDatabase可以不用存储。可以对ReportingDatabase重构优化，而不用去改变操作数据库。对ReportingDatabase数据库的查询不会给操作数据库带来任何压力。可以针对不同的查询请求建立不同的ReportingDatabase库。当然这也有一些缺点，比如从库数据的更新。如果使用SQLServer，本身也提供了一些如故障转移和复制机制来方便部署。三什么时候可以考虑CQRS CQRS模式有一些优点：分工明确，可以负责不同的部分将业务上的命令和查询的职责分离能够提高系统的性能、可扩展性和安全性。并且在系统的演化中能够保持高度的灵活性，能够防止出现CRUD模式中，对查询或者修改中的某一方进行改动，导致另一方出现问题的情况。逻辑清晰，能够看到系统中的那些行为或者操作导致了系统的状态变化。可以从数据驱动(Data-Driven) 转到任务驱动(Task-Driven)以及事件驱动(Event-Driven). 在下场景中，可以考虑使用CQRS模式：当在业务逻辑层有很多操作需要相同的实体或者对象进行操作的时候。CQRS使得我们可以对读和写定义不同的实体和方法，从而可以减少或者避免对某一方面的更改造成冲突对于一些基于任务的用户交互系统，通常这类系统会引导用户通过一系列复杂的步骤和操作，通常会需要一些复杂的领域模型，并且整个团队已经熟悉领域驱动设计技术。写模型有很多和业务逻辑相关的命令操作的堆，输入验证，业务逻辑验证来保证数据的一致性。读模型没有业务逻辑以及验证堆，仅仅是返回DTO对象为视图模型提供数据。读模型最终和写模型相一致。适用于一些需要对查询性能和写入性能分开进行优化的系统，尤其是读/写比非常高的系统，横向扩展是必须的。比如，在很多系统中读操作的请求时远大于写操作。为适应这种场景，可以考虑将写模型抽离出来单独扩展，而将写模型运行在一个或者少数几个实例上。少量的写模型实例能够减少合并冲突发生的情况适用于一些团队中，一些有经验的开发者可以关注复杂的领域模型，这些用到写操作，而另一些经验较少的开发者可以关注用户界面上的读模型。对于系统在将来会随着时间不段演化，有可能会包含不同版本的模型，或者业务规则经常变化的系统需要和其他系统整合，特别是需要和事件溯源Event Sourcing进行整合的系统，这样子系统的临时异常不会影响整个系统的其他部分。但是在以下场景中，可能不适宜使用CQRS：领域模型或者业务逻辑比较简单，这种情况下使用CQRS会把系统搞复杂。对于简单的，CRUD模式的用户界面以及与之相关的数据访问操作已经足够的话，没必要使用CQRS，这些都是一个简单的对数据进行增删改查。不适合在整个系统中到处使用该模式。在整个数据管理场景中的特定模块中CQRS可能比较有用。但是在有些地方使用CQRS会增加系统不必要的复杂性。四 CQRS与Event Sourcing的关系在CQRS中，查询方面，直接通过方法查询数据库，然后通过DTO将数据返回。在操作(Command)方面，是通过发送Command实现，由CommandBus处理特定的Command，然后由Command将特定的Event发布到EventBus上，然后EventBus使用特定的Handler来处理事件，执行一些诸如，修改，删除，更新等操作。这里，所有与Command相关的操作都通过Event实现。这样我们可以通过记录Event来记录系统的运行历史记录，并且能够方便的回滚到某一历史状态。Event Sourcing就是用来进行存储和管理事件的。这里不展开介绍。五 CQRS的简单实现 CQRS模式在思想上比较简单，但是实现上还是有些复杂。它涉及到DDD，以及Event Sourcing，这里使用codeproject上的 Introduction to CQRS 这篇文章的例子来说明CQRS模式。这个例子是一个简单的在线记日志(Diary)系统，实现了日志的增删改查功能。整体结构如下：上图很清晰的说明了CQRS在读写方面的分离，在读方面，通过QueryFacade到数据库里去读取数据，这个库有可能是ReportingDB。在写方面，比较复杂，操作通过Command发送到CommandBus上，然后特定的CommandHandler处理请求，产生对应的Event，将Eevnt持久化后，通过EventBus特定的EevntHandler对数据库进行修改等操作。例子代码可以到codeproject上下载，整体结构如下： […]

龙生 03 Jan 2018

View Details

WPF实现窗口最小化到托盘，并且实现右击菜单

原版是从网上找了一位大神的，自己只是用了一点适合自己的。具体实现 1.首先已经确认WPF中没有实现最小化托盘的类与方法，用到了winform中的程序集 using Drawing = System.Drawing; using Forms = System.Windows.Forms; 2.XAML的后代相应事件的Demo，只是为了看起来方便~！其中也包含了在任务栏中不现实图标，只在托盘中显示。双击实现窗口的还原。没用到大神写的，自己琢磨了个，令人想不到的蛋疼的后果还没出现，也就暂时这样了。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

namespace 最小化到托盘

{

/// <summary>

/// MainWindow.xaml 的交互逻辑

/// </summary>

public partial class MainWindow : Window

{

public MainWindow()

{

//妈蛋找了你一天，，启动后不现实任务栏图标！！！！！！！！！！！！！！！！！！！！

this.ShowInTaskbar = false;

InitializeComponent();

}

/// <summary>

/// 托盘右击菜单--上线按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_OnlineClick(object sender, EventArgs e)

{

MessageBox.Show("提示上线！");

}

/// <summary>

/// 托盘右击菜单--离开按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_LeaveClick(object sender, EventArgs e)

{

MessageBox.Show("提示暂时离开！");

}

/// <summary>

/// 托盘右击菜单--在忙按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_BusyClick(object sender, EventArgs e)

{

MessageBox.Show("提示在忙！");

}

/// <summary>

/// 托盘右击菜单--请勿打扰按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_NoBotherClick(object sender, EventArgs e)

{

MessageBox.Show("提示请勿打扰！");

}

/// <summary>

/// 托盘右击菜单--隐身按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_HideClick(object sender, EventArgs e)

{

MessageBox.Show("提示隐身！");

}

/// <summary>

/// 托盘右击菜单--离线按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_OffLineClick(object sender, EventArgs e)

{

MessageBox.Show("提示离线！");

}

/// <summary>

/// 托盘右击菜单--关于我们按钮

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MenuItem_AboutUsClick(object sender, EventArgs e)

{

MessageBox.Show("提示关于我们！");

}

/// <summary>

/// 托盘小图标的双击事件--最小化的状态下双击还原

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void NotificationAreaIcon_MouseDoubleClick_1(object sender, MouseButtonEventArgs e)

{

//if (e.ChangedButton==MouseButton.Left)

//{

if (this.WindowState == WindowState.Minimized)

{

WindowState = WindowState.Normal;

}

// }

}

private void MenuItem_ExitClick(object sender, EventArgs e)

{

this.Close();

}

private void Window_MouseMove_1(object sender, MouseEventArgs e)

{

}

//以下代码想实现即时聊天的记住密码功能，度娘说要存入配置文件，没搞成功，希望看到的人帮我这个忙~

private void Button_Click_1(object sender, RoutedEventArgs e)

{

//点击按钮往配置文件存入信息

Configuration cfa = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

cfa.AppSettings.Settings["LogName"].Value = "123";

cfa.Save();

MessageBox.Show(ConfigurationManager.AppSettings["LogName"]);

}

3.最主要的是大神写的这个类，学习编程五个月，能看懂的不是太多，稍微明白点意思，但是说不上来，直接贴代码吧。以后在研究！

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Windows;

using System.Windows.Input;

using System.Windows.Markup;

using System.Windows.Media;

using System.Windows.Threading;

using Drawing = System.Drawing;

using Forms = System.Windows.Forms;

namespace 最小化到托盘

{

/// <summary>

/// Represents a thin wrapper for <see cref="Forms.NotifyIcon"/>

/// </summary>

[ContentProperty("Text")]

[DefaultEvent("MouseDoubleClick")]

public class NotificationAreaIcon : FrameworkElement

{

Forms.NotifyIcon notifyIcon;

public static readonly RoutedEvent MouseClickEvent = EventManager.RegisterRoutedEvent(

"MouseClick", RoutingStrategy.Bubble, typeof(MouseButtonEventHandler), typeof(NotificationAreaIcon));

public static readonly RoutedEvent MouseDoubleClickEvent = EventManager.RegisterRoutedEvent(

"MouseDoubleClick", RoutingStrategy.Bubble, typeof(MouseButtonEventHandler), typeof(NotificationAreaIcon));

public static readonly DependencyProperty IconProperty =

DependencyProperty.Register("Icon", typeof(ImageSource), typeof(NotificationAreaIcon));

public static readonly DependencyProperty TextProperty =

DependencyProperty.Register("Text", typeof(string), typeof(NotificationAreaIcon));

public static readonly DependencyProperty FormsContextMenuProperty =

DependencyProperty.Register("MenuItems", typeof(List<Forms.MenuItem>), typeof(NotificationAreaIcon), new PropertyMetadata(new List<Forms.MenuItem>()));

protected override void OnInitialized(EventArgs e)

{

base.OnInitialized(e);

// Create and initialize the window forms notify icon based

notifyIcon = new Forms.NotifyIcon();

notifyIcon.Text = Text;

if (!DesignerProperties.GetIsInDesignMode(this))

{

notifyIcon.Icon = FromImageSource(Icon);

}

notifyIcon.Visible = FromVisibility(Visibility);

if (this.MenuItems != null && this.MenuItems.Count > 0)

{

notifyIcon.ContextMenu = new System.Windows.Forms.ContextMenu(this.MenuItems.ToArray());

}

notifyIcon.MouseDown += OnMouseDown;

notifyIcon.MouseUp += OnMouseUp;

notifyIcon.MouseClick += OnMouseClick;

notifyIcon.MouseDoubleClick += OnMouseDoubleClick;

Dispatcher.ShutdownStarted += OnDispatcherShutdownStarted;

}

private void OnDispatcherShutdownStarted(object sender, EventArgs e)

{

notifyIcon.Dispose();

}

private void OnMouseDown(object sender, Forms.MouseEventArgs e)

{

OnRaiseEvent(MouseDownEvent, new MouseButtonEventArgs(

InputManager.Current.PrimaryMouseDevice, 0, ToMouseButton(e.Button)));

}

private void OnMouseUp(object sender, Forms.MouseEventArgs e)

{

OnRaiseEvent(MouseUpEvent, new MouseButtonEventArgs(

InputManager.Current.PrimaryMouseDevice, 0, ToMouseButton(e.Button)));

}

private void OnMouseDoubleClick(object sender, Forms.MouseEventArgs e)

{

OnRaiseEvent(MouseDoubleClickEvent, new MouseButtonEventArgs(

InputManager.Current.PrimaryMouseDevice, 0, ToMouseButton(e.Button)));

}

private void OnMouseClick(object sender, Forms.MouseEventArgs e)

{

OnRaiseEvent(MouseClickEvent, new MouseButtonEventArgs(

InputManager.Current.PrimaryMouseDevice, 0, ToMouseButton(e.Button)));

}

private void OnRaiseEvent(RoutedEvent handler, MouseButtonEventArgs e)

{

e.RoutedEvent = handler;

RaiseEvent(e);

}

public List<Forms.MenuItem> MenuItems

{

get { return (List<Forms.MenuItem>)GetValue(FormsContextMenuProperty); }

set { SetValue(FormsContextMenuProperty, value); }

}

public ImageSource Icon

{

get { return (ImageSource)GetValue(IconProperty); }

set { SetValue(IconProperty, value); }

}

public string Text

{

get { return (string)GetValue(TextProperty); }

set { SetValue(TextProperty, value); }

}

public event MouseButtonEventHandler MouseClick

{

add { AddHandler(MouseClickEvent, value); }

remove { RemoveHandler(MouseClickEvent, value); }

}

public event MouseButtonEventHandler MouseDoubleClick

{

add { AddHandler(MouseDoubleClickEvent, value); }

remove { RemoveHandler(MouseDoubleClickEvent, value); }

}

#region Conversion members

private static Drawing.Icon FromImageSource(ImageSource icon)

{

if (icon == null)

{

return null;

}

Uri iconUri = new Uri(icon.ToString());

return new Drawing.Icon(Application.GetResourceStream(iconUri).Stream);

}

private static bool FromVisibility(Visibility visibility)

{

return visibility == Visibility.Visible;

}

private MouseButton ToMouseButton(Forms.MouseButtons button)

{

switch (button)

{

case Forms.MouseButtons.Left:

return MouseButton.Left;

case Forms.MouseButtons.Right:

return MouseButton.Right;

case Forms.MouseButtons.Middle:

return MouseButton.Middle;

case Forms.MouseButtons.XButton1:

return MouseButton.XButton1;

case Forms.MouseButtons.XButton2:

return MouseButton.XButton2;

}

throw new InvalidOperationException();

}

#endregion Conversion members

}

from:https://www.cnblogs.com/gchlcc/p/4987042.html

龙生 28 Dec 2017

View Details

WPF窗体最小化到任务栏

WPF程序也可以很轻松的实现类似QQ那样最小化到任务栏的功能。

WindowState ws;

WindowState wsl;

NotifyIcon notifyIcon;

#region Constructions

public MainWindow()();//显示托盘。

icon();

//保证窗体显示在上方。

wsl = WindowState;

}

#endregion

private void icon()

{

this.notifyIcon = new NotifyIcon();

this.notifyIcon.BalloonTipText = "Hello, 文件监视器"; //设置程序启动时显示的文本

this.notifyIcon.Text = "文件监视器";//最小化到托盘时，鼠标点击时显示的文本

this.notifyIcon.Icon = new System.Drawing.Icon("Downloads.ico");//程序图标

this.notifyIcon.Visible = true;

notifyIcon.MouseDoubleClick += OnNotifyIconDoubleClick;

this.notifyIcon.ShowBalloonTip(1000);

}

private void OnNotifyIconDoubleClick(object sender, EventArgs e)

{

this.Show();

WindowState = wsl;

}

private void Window_StateChanged(object sender, EventArgs e)

{

ws = WindowState;

if (ws == WindowState.Minimized)

{

this.Hide();

}

from:https://www.cnblogs.com/Gyoung/archive/2012/12/06/2805932.html

龙生 28 Dec 2017

View Details

« Previous 1 … 15 16 17 … 43 Next »