在网上看了许多人问怎么样实现在WINDOWS托盘程序中，当点击最小化时将窗体隐藏在任务栏中，而点击托盘栏中的程序托盘时又会显示出窗体的正常状态的功能。许多人的思路是找到最小化时触发的事件或者是程序最小化时执行的方法，可是怎么也找不到。其实实现这种功能很简单，只不过许多人的思路一直停留在找到最小化的方法体上了，以为只要在此方法体中再加上一些语句就可以实现，可是怎么也找不到，于是就卡在这里了。其实实现这种功能很简单，可以通过以下方法实现：
 
1.加notifyicon控件notifyIcon1，为控件notifyIcon1的属性Icon添加一个icon图标。
2.添加窗体最小化事件(在这里实现隐藏任务栏图标，有两种方法)：
方法一：
// this.SizeChanged += new System.EventHandler(this.Form1_SizeChanged);
//上面一行是主窗体InitializeComponent()方法中需要添加的引用
 private void Form1_SizeChanged(object sender, EventArgs e)
  {
   if (this.WindowState==FormWindowState.Minimized)
   {
    this.Hide();或者是this.Visible = false;
    this.notifyIcon1.Visible=true;
   }
 }
方法二：
this.Resize += new System.EventHandler(this.Form1_Resize);
//上面一行是主窗体InitializeComponent()方法中需要添加的引用
 
private void Form1_Resize(object sender, EventArgs e)
        {
            if (this.WindowState == FormWindowState.Minimized)
               this.Visible = false;
         
           
        }
3.添加点击图标事件(实现点击左键显示主窗体正常状态)：
  private void notifyIcon1_Click(object sender, EventArgs e)
  {
   this.Visible = true;
   this.WindowState = FormWindowState.Normal;
  
  }
4.可以给notifyIcon添加右键菜单：
主窗体中拖入一个ContextMenu控件contextMenu1，点中控件，在上下文菜单中添加菜单，notifyIcon1的ContextMenu行为中选中contextMenu1作为上下文菜单。(可以在子菜单中添加行为)……
在这里主要谈谈在第二步中的两种方法。
     这里使用的是两种最常规，也是最常用的办法。第一种的SizeChanged（）事件，其本意是当控件上的Size属性更改时引发的事件。而第二种方法Resize（）事件，是在调整控件大小时引发的事件。可在这里为什么都可以实现同样的功能?可以做一下实验看看两个事件到底是什么时候发生的。
private void Form1_SizeChanged(object sender, EventArgs e)
        {
            MessageBox.Show("sizechange即将发生");
            if (this.WindowState == FormWindowState.Minimized)
                this.Visible = true;
           
 
        }
        private void Form1_Resize(object sender, EventArgs e)
        {
            if (this.WindowState == FormWindowState.Minimized)
               this.Visible = false;
           MessageBox.Show("resize发生了");
           
        }
 
  private void notifyIcon1_Click(object sender, EventArgs e)
  {
   this.Visible = true;
   this.WindowState = FormWindowState.Normal;
  
  }
     将这些代码都加在同一个程序中，编译执行可以看到。当我们手工的扩大或缩小我们的窗体大小时，会弹出消息框"resize发生了"，接着就会弹出消息框"sizechange即将发生"。从这个小例子可以看出这两个事件其实是大同小异的，只不过Resize先执行而SizeChanged后执行罢了。从这两个事件的MSDN解释上我们也不难看出，当我们改变控件大小，这时候必先触发Resize（）（在调整控件大小时引发的事件），而我们改变了大小也必然会导致Size属性的改变，这时又会触发SizeChanged事件。这个先后道理我想不难理解。所以说这两个事件是乎有着某种必然的联系！
     最小化（最大化）其实和我们手工改变窗体的大小是一个道理。而之所以能用两种方法得到相同的效果的道理也正是如以上所述，当然就可以达到异曲同工之妙！

定义：

     sql语句执行的时候要先编译，然后执行。存储过程（Stored Procedure）是一组为了完成特定功能的SQL语句集，经编译后存储在数据库中。用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。

优点：

     允许模块化程序设计，只需创建一次存储过程，并将其存储在数据库中，以后可在程序中调用该过程任意次

     执行效益高

     减少网络流量

     可保证数据的安全性和完整性

分类：

     系统存储过程 以sp_开头并存放在master数据库中

     扩展存储过程 以xp_开头

     用户自定义存储过程 用户自己定义

这里重点介绍用户自定义存储过程

     自定义存储过程又分为两种：带参数的存储过程及不带参数的存储过程

     带参数的存储过程又分为：带输入参数的存储过程和带输出参数的存储过程

存储过程语法规则：

create proc[edure](关键字，中括号内为可选内容) procName(存储过程名字)

@参数 数据类型=默认值， （输入参数）

@参数 数据类型 output（输出参数必须加上output）

as

sql语句

go

 

删除存储过程

创建的存储过程位于sysobjects表中

if exists(select * from sysobjects where name='存储过程名字')

drop proc 存储过程

go

 

存储过程执行使用关键字exec

执行无参存储过程

exec 存储过程名

执行输入参数存储过程

如：

exec 存储过程 参数值

执行输出参数的存储过程要求定义变量用来接受存储过程的返回值

declare @count int (数据类型需和存储过程中输出参数类型一致)

exec 存储过程 输出参数 output (output不能少)

print 输出参数 (用于显示输出参数)

 

创建无参的存储过程

查询student表中所有记录

if exists(select * from sysobjects where name='proc_select')

drop proc proc_select

go

create proc proc_select

as

select * from student

go

执行存储过程

exec proc_select 效果类似于 select * from student

 

创建带输入参数的存储过程

比如根据用户名查询用户密码

if exists(select * from sysobjects where name='proc_username')

drop proc proc_username

go

create proc proc_username

@username varchar(50)

as

select pwd from userinfo where username=@username

 

执行存储过程：

exec proc_username admin  (或@username=admin)

 

创建带输出参数的存储过程执行时需要自定义一个变量用来接受存储过程返回的值

比如查询userinfo表中有多少条记录

if exists(select * from sysobjects where name='proc_num')

drop proc proc_num

go

create proc proc_num

@count int output  (output不能少,不能赋默认值)

as

select @count=count(*) from userinfo 

go

执行存储过程

declare @n int

exec proc_num @n output (output不能少)

go

print @n  显示表中有多少条记录

 

     注:定义参数时多个参数间用逗号隔开而不是分号最后一个参数逗号可省略

 

    阅读此文应先阅读简单工厂模式与工厂方法模式

抽象工厂模式是对象的创建模式，它是工厂方法模式的进一步推广。

假 设一个子系统需要一些产品对象，而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分开，可以引进抽象 工厂模式。这样的话，消费产品的客户不需要直接参与产品的创建工作，而只需要向一个公用的工厂接口请求所需要的产品。

采用抽象工厂模式设计出的系统类图如下。

从上图可以看到，抽象工厂模式设计到以下的角色：

抽象工厂角色：担任这个角色的是工厂方法模式的核心，它是与应用系统的商业逻辑无关的。通常使用接口或抽象类实现。

具体工厂角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用具体的类实现。

抽象产品角色：担任这个角色的类是抽象工厂方法模式所创建的对象的父类，或它们共同拥有的接口。通常使用接口或抽象类实现这一角色。

具体产品角色：抽象工厂模式所创建的任何产品对象都是某一具体产品类的实例。这是客户端最终需要的东西。通常使用具体类实现这个角色。

下面给出这个系统的原代码：

Creator:

public interface Creator

{

ProductA factoryA();

ProductB factoryB();

}

ConcreteCreator1:

public class ConcreteCreator1:Creator

{

public ProductA factoryA()

{

return new ProductA1();

}

public ProductB factoryB()

{

return new ProductB1();

}

}

ConcreteCreator2:

public class ConcreteCreator2:Creator

{

public ProductA factoryA()

{

return new ProductA2();

}

public ProductB factoryB()

{

return new ProductB2();

}

}



ProductA:

public interface ProductA

{

}

ProductA1:

public class ProductA1:ProductA

{

public ProductA1()

{

}

}

ProductA2:

public class ProductA2:ProductA

{

public ProductA2()

{

}

}

ProductB:

public interface ProductB

{

}

ProductB1:

public class ProductB1:ProductB

{

public ProductB1()

{

}

}

ProductB2:

public class ProductB2:ProductB

{

public ProductB2()

{

}

}

     在以下情况下应该使用抽象工厂模式：

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。      作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

单例模式有以下特点：

单例类只能有一个实例。

单例类必须自己创建自己的唯一实例。

单例类必须给所有其他对象提供这一实例。

一个典型的单例类的实现如下所示：其中构造子私有表示子类不能被继承。

public class Singleton

{

private static Singleton m_instance = null;

private Singleton()

{

}

public static Singleton getInstance()

{

if(m_instance==null)

{

m_instance=new Singleton();

}

return m_instance;

}

}

     所谓多例模式，实际上就是单例模式的自然推广，单例类一般情况下只可以有一个实例，但单例类也可以推广到允许有限个实例，这种模式就是多例模式。作为对象的创建模式，多例模式有以下特点：

多例类可以有多个实例。

多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。

多例类分为有上限多例类与无上限多例类。

一个有上限的多例类已经把实例的上限当作逻辑的一部分，并建造到了多例类的内部。如下：

public class Multiton

{

private static Multiton instance1=null;

private static Multiton instance2=null;

private Multiton()

{

}

public static Multiton getInstance(int whichOne)

{

if(whichOne==1)

{

if(instance1==null)

{

instance1=new Multiton ();

}

return instance1;

}

else

{

if(instance2==null)

{

instance2=new Multiton ();

}

return instance2;

}

}

}

     多例类的实例数目不需要有上限，实例数目没有上限的多例模式就叫做无上限多例模式。由于没有上限的多例类对实例的数目是没有限制的，因此，虽然这种多例模式是单例模式的推广，但是这种多例类并不一定能够回到单例类。一般采用聚集管理所有的实例。       前 言：设计模式是软件开发领域的精髓之一。学好设计模式是目前每一个开发人员的必修课。目前关于设计模式的书很多，其中比较好的有GOF那本的中译本，但并 不很适合初学者。还有一本是《JAVA与模式》，比较适合初学者使用，在此强烈推荐。但这本书的不足之处是一些地方讲的过于繁琐，很多地方只须简单说明一 下即可，却大费笔墨，使得书籍很厚，看起来费力。而且是用JAVA描述的，这使得一些只懂C#的人无从下手。我是一个.net的拥护者，为了看这本书我特 意看了些JAVA的书，感觉JAVA在书籍的多样性方面比 .net好很多，而且不少书籍的质量很高。可能是现在JAVA已经比较成熟的原因吧。为了方便.net的爱好者学习设计模式，在此把我学习《JAVA与模 式》这本书的学习笔记发出来，并用C#语言重新描述，希望能对初学者有所帮助。
其实设计模式也并不是什么高深的理论，个人认为并不是象一些人所说的“没写过10万代码就不要谈设计模式”，只要用心学习与实践是完全能够掌握的。

简单工厂模式是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。一般涉及到三种角色（如下图）：

工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的类实现。
抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或她们共同拥有的接口。一般由接口或抽象类实现。
具体产品角色：工厂方法模式所创建的任何对
象都是这个角色的实例，由具体类实现。

简单工厂模式优缺点：
模式的核心是工厂类，这个类负责产品的创建，而客户端可以免去产品创建的责任，这实现了责任的分割。但由于工厂类集中了所有产品创建逻辑的，如果不能正常工作的话会对系统造成很大的影响。如果增加新产品必须修改工厂角色的源码。

以园丁种植水果为例讨论该模式的具体实现：
Fruit 水果接口，规定水果具有的一些共同特性
Apple 苹果类 派生自Fruit接口
Strawberry 草莓类 派生自Fruit接口
FruitGardener 园丁类 负责草莓与苹果的创建工作。
当Client要创建水果（苹果或草莓对象）的时候调用园丁类的factory方法创建：ＵＭＬ图如下：

代码如下：
Fruit.cs
namespace Simple_Factory
{
public interface Fruit
{
//生长
void grow();
//收获
void harvest();
//种植
void plant();
}
}
Apple.cs
namespace Simple_Factory
{
public class Apple:Fruit
{
public Apple()
{
}
#region Fruit 成员
public void grow()
{
Console.WriteLine ("Apple is growing.......");
}
public void harvest()
{
Console.WriteLine ("Apple is harvesting.......");
}
public void plant()
{
Console.WriteLine ("Apple is planting.......");
}
#endregion
}
}
Strawberry.cs
namespace Simple_Factory
{
public class Strawberry:Fruit
{
public Strawberry()
{
}
#region Fruit 成员
public void grow()
{
Console.WriteLine ("Strawberry is growing.......");
}
public void harvest()
{
Console.WriteLine ("Strawberry is harvesting.......");
}
public void plant()
{
Console.WriteLine ("Strawberry is planting.......");
}
#endregion
}
}
FruitGardener.cs
namespace Simple_Factory
{
public class FruitGardener
{
//静态工厂方法
public static Fruit factory(string which)
{
if(which.Equals ("Apple"))
{
return new Apple();
}
else if(which.Equals ("Strawberry"))
{
return new Strawberry ();
}
else
{
return null;
}
}
}
}
Client.cs
using System;
namespace Simple_Factory
{
class Client
{
[STAThread]
static void Main(string[] args)
{
Fruit aFruit=FruitGardener.factory ("Apple");//creat apple
aFruit.grow ();
aFruit.harvest ();
aFruit.plant();
aFruit=FruitGardener.factory ("Strawberry");//creat strawberry
aFruit.grow ();
aFruit.harvest ();
aFruit.plant();
}
}
}
输出如下：
Apple is growing.......
Apple is harvesting.......
Apple is planting.......
Strawberry is growing.......
Strawberry is harvesting.......
Strawberry is planting.......
所在命名空间：using System.Windows.Forms;
语法：    MESSAGEBOX(提示信息[,对话框的标题,对话框上的按钮，对话框上的图标，对话框上的默认按钮])
参数描述：
          
    提示信息：对话框中所用到的提示文字。
    对话框标题：就是对话框上的标题
    对话框上的按钮：MessageBoxButtons.OKCancel等，通过输入MessageBoxButtons就会有相应的提示，也就不写了
    对话框上的图标：MessageBoxIcon.Question同上
    对话框默认按钮：MessageBoxDefaultButton.Button2

获取返回的值：
    messagebox1.show()=DialogResult.OK其他类似
设置对话框的返回之：   
   this.DialogResult = DialogResult.OK;

      if (comexample.ShowDialog() == DialogResult.OK)
            {                              
            }  

这样就可以显示comexample窗体，并获得其返回值 准备工作：

    新建一个Windows应用程序然后在窗体上画一个textBox和一个Button及一个webBrowser。

    双击Button在Button的单击事件中编写代码

 

      呵呵！DataSet和DataGridView及xml大家都熟悉吧！这里就不做介绍了。咱们直奔主题！这里给出关键部分代码！仅供参考

     既然xml文件能读取到DataGridView中,哪么能否在DataGridView中修改xml文件的数据了？答案是肯定的！其实代码也很简单！

    只有注册用户登录后才能阅读该文。阅读全文