精华内容
下载资源
问答
  • Windows 窗体开发指南.pdf
  • 计时码表115 这是一个在.NET Windows窗体中使用Sockets和MySql作为数据库开发的项目
  • 内含ppt,视频,文档,示例!!!!!!!
  • 精通 C#与.NET4.0 数据库开发 实验报告 实验题目 Windows 窗体程序的开发 专 业 计算机科学与技术 学 生 姓 名 班 级 学 号 教 师 指 导 单 位 日 期 教 师 评 教师签名 年 月 日 语 成 绩 评 定 备 注 一实验目的 1...
  • Windows窗体应用开发

    2011-12-31 20:58:15
    Windows窗体应用开发
  • Windows窗体程序开发

    2013-03-10 10:37:20
    基于C#的windows窗体应用程序开发
  • Windows窗体应用开发1

    2017-03-30 15:24:00
    1.Windows窗体的基本概念  2.Windows窗体应用程序  3.Windows窗体常见界面元素  4.Windows窗体中的事件处理 1.Windows窗体的基本概念  打开一个Window的系统应用,可以拿记事本作为例子:    这个...

      1.Windows窗体的基本概念

      2.Windows窗体应用程序

      3.Windows窗体常见界面元素

      4.Windows窗体中的事件处理

    1.Windows窗体的基本概念

      打开一个Window的系统应用,可以拿记事本作为例子:

      

      这个记事本就是一个窗体,用户和程序之间的交互是通过“窗体”、“按钮”等图形化界面元素进行的。我们使用这些软件为我们实现了一些目的,如上面提到的txt文档,写一些内容然后存到电脑上,也有word套件用于办公,用户和程序进行交互,程序做出来要功能强大,效率高,才能实现我们使用这些工具的目的,就像办公时候的word套件加快办公效率,软件设计使用的时候也要想着使用时候的情形。

    2.Windows窗体应用程序

      创建我的第一个应用程序,

      

      跟学习编程语言不一样的是要有工程(Project)的思想,做什么软件,先建一个工程。然后根据模块化的思想一块一块地将整个工程搭建起来。类比成写文章,搭建房子,每个功能用一个模块来实现,最后就可以做成我们平时在用的软件。当然现在第一个工程,也像我们学习每个编程语言一样,一开始先“HelloWorld”。建立完工程之后可以看见一个窗口,这个窗口就是我们最基础的窗口,通过工具箱向窗口上添加新的控件(按钮,文本之类的东西)。

      通过这个控件的属性进行更改,比如像我将text属性改成“HelloRyner”,此时按钮上显示的文本变成了设定的字符串。要更改关于按钮的代码,点击这个按钮,进入到相关代码

     private void button1_Click(object sender, EventArgs e)
     {
    
     }

    按钮1触发某个事件,此时添加一个“HelloWorld”

    后面弹出的这个窗口就是windows的消息框,MessageBox,添加代码 MessageBox.Show("Hello World");即可实现。

     

    3.Windows窗体常见界面元素

      上面的用到的按钮(Button)就是常用的窗体界面元素中空间的一种。

    元素 说明
    窗体 窗体就在上面用到的整个作为背景的窗口
    控件

    窗体上面的元素就有按钮之类的东西可以控制一些功能,方法和事件可以定义控件的外观和行为常用的控件包括Button、TextBox、Label

    、Panel、ComboBox

    组件 组件比较少见后面用到的时候会提及
    对话框 当我们要关闭txt文档的时候会弹出一个窗口询问“是否保存”

      注:控件和组件的区别主要在于控件位于窗体上而组件不是。组件通常从System.ComponentModel.Component基类派生而来

     

    转载于:https://www.cnblogs.com/rynerlute/p/6646078.html

    展开全文
  • 1.Windows窗体应用程序的各种组件 2.windows窗体控件的主要类别和功能 3.Windows窗体应用程序处理事件的方法 4.添加并配置Windows窗体和控件 5.创建时间处理程序并监视程序 6.在程序运行时向窗体添加控件和事件...

    1.Windows窗体应用程序的各种组件

    2.windows窗体控件的主要类别和功能

    3.Windows窗体应用程序处理事件的方法

    4.添加并配置Windows窗体和控件

    5.创建时间处理程序并监视程序

    6.在程序运行时向窗体添加控件和事件处理程序

     

     

    1.创建简单Windows应用程序

      

     

      之前创建的HelloWorld的窗口可以和我们平时使用的窗口做个对比,左上角有个标题栏,右上角是几乎所有程序都有的最小化,最大化,关闭按钮。此时来看解决方案管理器(solution explorer)。对比软件自动生成的几个文件:Assemblyinfo.cs,Resources.resx,Settings.settings,Form1.cs,Program.cs等等。

    按照以前写代码的想法,一般程序都是从main开始执行的,打开Program.cs可以发现里面有个main函数,也就是说这个文件就是整个项目的入口,再打开Form1.cs文件。这个文件就是我们一开始写HelloWorld的地方,也就是说这是一个实现helloWorld的模块,在这个窗口中有个button,点击触发事件,实现一个消息弹出。此时如果我们要添加一个窗体

     

    2.windows窗体控件的主要类别和功能

    我们添加一个叫做Form2.cs的窗体,做工程的时候不要这个样命名。添加完毕会发现和一开始我们建立的Form1.cs窗体是一样的,同样的也有窗体属性,可以通过属性来确定这些窗体的各种功能,比如命名,或者窗体上的某个按钮要键盘才能点击,常见的窗体属性如下:

    (Name) 项目中窗体的名称(写代码时候用的类似android中所说的ID)通过这个id找到这个可视的窗口 默认命名就是上面偷懒时候自动命名出来的form1.cs form2.cs
    AcceptButton 设置某个按钮,当用户按Enter键时才相当于单击此按钮   
    CancelButton 当用户按ESC的时候相当于单击此按钮  
    ControlBox 控制:最大化、最小化、帮助、关闭  
    StrartPostion 窗体第一次出现时候的位置  
    FormBorderStyle 控制窗体的外观  
    MaximizeBox 是否有最大化按钮  
    MinimizeBos 最小化  
    Text 显示在标题栏上的文本  

     

    向窗体添加控件

      方法1 向窗体添加多个控件,然后调整其大小和位置:

        (1)工具箱

        (2)工具箱中双击要添加的控件

        (3)添加之后可以调整位置

      方法2 添加控件之后,立即调整其位置和大小

      方法3 拖拽控件到窗口

      方法1 2 3 主要是玩转这个工具箱的使用,鼠标点多看,以“Problem driven”的想法来看哪个顺手就用哪个。主要将工具箱玩的溜。

    控件和组件的功能分类(具体要实现的时候去查表格,不必死记硬背):

      文本编辑(编辑框,输账号密码,记账时候写数字)

        文本编辑主要有TextBox,RichTextBox,MaskedTestBox。

      文本显示(用户不能编辑,文本显示)

        Label,LinkLabel,StatusStrip

      从列表中选择

        CheckListBox 显示一个可滚动的选项列表,每个选项带有一个复选框

        ComboBox 显示下拉式列表

        DomainUpDown 显示一个文本项列表

        ..

      图形显示

        PictureBox 在框架中显示图形文件,位图和图标

      值设置

        CheckBox 复选框和文本标签

        RadioButton 可启用或禁用的按钮以及文本标签

        TrackBar 用户沿着标尺移动滑块来设置值

      内容显示

        DataGridView 用户自定义的网格中显示数行和数列数据

        WebBrower 使用户能够在窗体中浏览Web页面

        ProcessBar   在水平条中显示相应比例的矩形来指示操作进度

      日期设置

        DateTimePicker 显示一个图形日历使得用户能够选择日期或者时间

        MonthCalendar 显示一个图形日历使得用户能够选择日期范围

      菜单控件

          MenuStrip 显示按功能分组的应用程序命令和选项

          ContexMenuStrip 当用户用鼠标右键单击关联控件时,显示相应的快捷菜单

      命令

             Button 提供选项以启动、停止、中断一个过程

             NotifyIcon 在任务栏的状态通知区域显示一个图标

      容器

            Panel 将一组控件组合在一个不带标签的框架上,用户可在其中进行滚动操作

            FlowLayout 在流布局中自动排列控件

           GroupBox 将一组控件组合在一个带标签的控件上,用户可以进行滚动操作

           ...

    3.Windows窗体应用程序处理事件的方法

      事件处理:前面提到一个helloWorld的程序:点击按钮弹出消息框HelloWorld

      此时转变为程序员写这个程序的想法:一个点击此按钮触发一个事件,调用某段代码实现某个功能。

    在设计时创建事件处理程序

      (1)默认事件处理程序:双击窗体或者控件来为此对象的默认事件创建事件处理程序。前面的button控件默认的事件就是click,而窗体,窗体就是load某个事件

      (2)属性窗口:

            

        在属性中找到事件,也就是说:有哪些动作触发哪些事件。

      (3)代码编辑器窗口:直接在代码编辑器中创建事件处理程序,在C#应用程序中,通过手动方式将处理程序的代码写入窗口

    在程序运行时创建事件处理程序

      也就是添加代码:

      button1.click + = new EventHandler(button1_click);

      解读语法,对象button1调用click,点击时候是通过新的对象,在生成这个对象时实现button1_click

    更多的事件处理技巧

      (1)使用单个事件处理方法来处理多个事件。

      (2)创建重写基类方法的事件处理方法。

     

     

    关于类与对象的知识点:

      控件基类: 控件都是从System.Windows.Forms.Control类继承而来的。通常意义上的控件都是一种组件(Component),这种组件结合了图形界面的特点和预先设计好的功能。其实控件就是用来完成特定任务的可重用代码单元。所有的控件都从Control基类继承而来,因此即使是不同的控件,也会具备一些相同的属性。

      System.Object

         System.MarshallByRefObject

                System.ComponentModel.Component

                   System.Window.Forms.Control

     

    转载于:https://www.cnblogs.com/rynerlute/p/6652112.html

    展开全文
  • windows窗体 Sometimes when developing windows forms application, it becomes an important part of application design to persist the state of windows form after it is closed. 有时,在开发Win...

    windows窗体

    Sometimes when developing windows forms application, it becomes an important part of application design to persist the state of windows form after it is closed.

    有时,在开发Windows窗体应用程序时,保持Windows窗体关闭后的状态成为应用程序设计的重要组成部分。

    One such example that comes to my mind is an application called “Sticky Notes”.

    我想到的一个这样的例子是一个名为“ Sticky Notes”的应用程序。

    Here the user is expected to open a notepad which she can re-size as and when required, can write few notes on it and then close this form. The notes are to be saved in a persistent storage like Database or XML.

    期望用户在此处打开一个记事本,她可以根据需要调整大小,可以在记事本上写一些便笺,然后关闭此表单。 注释将保存在数据库或XML等持久性存储中。

    Next time when the user opens that sticky note, it should open in the same size and display the notes that were written by the user last time.

    下次用户打开该便笺时,它应以相同的大小打开并显示用户上次写的便笺。

    As far as persistence of the notes to Database and/or XML file is concerned, I know there are many ways to do it. This article however deals with the second part of the problem, i.e. persistence of the form state in the application.

    至于数据库和/或XML文件的注释的持久性,我知道有很多方法可以做到。 但是,本文讨论了问题的第二部分,即应用程序中表单状态的持久性。

    Some people might argue that if we can save note’s data in DB/XML we can also save form’s State. But, i personally feel that since form’s state is the data related to user interface, so it should be persisted somewhere in the application.

    有人可能会争辩说,如果我们可以将注释的数据保存在DB / XML中,那么我们也可以保存表单的状态。 但是,我个人认为,由于表单的状态是与用户界面相关的数据,因此应将其保存在应用程序中的某个位置。

    So let’s begin this tutorial by understanding the problem statement first:-

    因此,让我们首先了解问题陈述来开始本教程:

    The Problem Statement

    问题陈述

    During the flow of an application, a windows form is opened. The User the re-sizes the form, make some other activity with the form and closes the form. Next time when the user opens this same form again, the size of the form should be same as when the form was closed.

    在应用程序流程中,将打开一个Windows窗体。 用户重新调整表单的大小,使用该表单进行其他活动并关闭该表单。 下次用户再次打开此相同表单时,表单的大小应与表单关闭时的大小相同。

    Solution

    Looking at the problem statement, as an application developer we can make out the following requirements:-

    查看问题陈述,作为应用程序开发人员,我们可以满足以下要求:

    1。 (1. )

    We need a mechanism to save the size of the form before the form closes

    我们需要一种机制来在表单关闭之前保存表单的大小

    2。 (2. )

    We need a mechanism to reload the saved state and apply this state to the form  before the form loads on screen.

    我们需要一种机制来重新加载保存的状态,并在表单加载到屏幕上之前将此状态应用于表单。

    Serialization Comes To Rescue

    序列化得到拯救

    If I have to put it in simple language, Serialization is the mechanism to convert an object graph to an array of bytes. De-Serialization is vice-verse.

    如果必须用简单的语言来表达,序列化是一种将对象图转换为字节数组的机制。 反序列化是反之。

    Right from the time .net came to existence; I personally feel serialization has been among the top features offered by the framework. It is truly very simple to serialize an object graph to array of bytes.

    从.net诞生之日起; 我个人觉得序列化一直是该框架提供的主要功能之一。 将对象图序列化为字节数组确实非常简单。

    The following few lines is just what we need to convert an object graph to memory stream:-

    以下几行正是将对象图转换为内存流所需要的:

    Stream memStream=new MemoryStream();
    IFormatter formatter=new BinaryFormatter();
    formatter.serialize(memStream, object);
    

    Here is how to de-serialize it:-

    以下是反序列化的方法:-

    Object obj = formatter.deserialize(memStream);
    

    So, let’s focus back on our problem. Let’s build the infrastructure to hold the persistence logic.

    因此,让我们重新关注我们的问题。 让我们构建基础结构以容纳持久性逻辑。

    A form state wrapper

    表单状态包装器

    Let’s first make a type which will hold the form’s state that can be persisted later on. Let’s name the class FormState and start with holding the form’s window state and form’s size in the FormState Type.  Next since we need to save this object through serialization, we need to mark it  as Serializable.

    首先让我们创建一个将保留表单状态的类型,该类型以后可以保留。 让我们命名类FormState并从在FormState Type中保存表单的窗口状态和表单大小开始。 接下来,由于我们需要通过序列化保存该对象,因此需要将其标记为Serializable。

    So the class looks like this:-

    所以该类看起来像这样:

        [Serializable]
        internal class FormState
        {
            private readonly FormWindowState _windowState;
            private readonly Point _formSize;
    
            private FormState()
            {
            }
    
            public FormState(FormWindowState state, int width, int height)
            {
                _windowState = state;
                _formSize = new Point(width, height);
            }
    
            public FormWindowState WindowState
            {
                get { return _windowState; }
            }
    
            public Point Size
            {
                get { return _formSize; }
            }
         }
    

    Also we have created a private parameter less constructor in FormState as is required at the time of serialization.

    同样,我们在序列化时在FormState中创建了一个不带私有参数的构造函数。

    A FormState collection

    一个FormState集合

    OK, so now we have a type to store form’s state information. Next let’s make a type to hold this state object of various forms. We need a dictionary where the key would be the form’s name and value would be an instance of FormState.

    好,现在我们有了一个类型来存储表单的状态信息。 接下来,让我们创建一个类型来保存各种形式的状态对象。 我们需要一个字典,其中的键将是表单的名称,而值将是FormState的实例。

    Let’s name the type as FormStateCollection as it will hold a collection of FormState Type.

    我们将类型命名为FormStateCollection,因为它将保存FormState Type的集合。

    Again this will also be marked serializable as this is the penultimate type that we are going to serialize and de-serialize. You can also say that this type is more of a state bag that will hold state information for all the forms.

    同样,这也将被标记为可序列化,因为这是我们要序列化和反序列化的倒数第二种类型。 您也可以说这种类型更多的是状态包,它将保存所有表单的状态信息。

    Here is how the type looks like:-

    类型如下:

        [Serializable]
        class FormStateCollection
        {
            private IDictionary<string, FormState> _formPersistanceHandlers;
            public static FormStateCollection Instance { get; private set; }
    
    
            static FormStateCollection()
            {
                Instance =
                    FileHelper.ReadFromFile<FormStateCollection>
                        (string.Format(Resources.FilePath,  Directory.GetCurrentDirectory())) ??
                    new FormStateCollection();
            }
            
            #region Methods
    
            /// <summary>
            /// Adds Persistance Handler To The Dictionary(Thread Safe Way)
            /// </summary>
            /// <param name="formName"></param>
            /// <param name="handler"></param>
            [MethodImpl(MethodImplOptions.Synchronized)]
            public void Persist(string formName, FormState handler)
            {
                if(!IsInitialized()) _formPersistanceHandlers = new Dictionary<string, FormState>();
    
                if(ContainsKey(formName))
                {
                    _formPersistanceHandlers[formName] = handler;
                }
                else
                {
                    _formPersistanceHandlers.Add(formName, handler);
                }
                
            }
    
            /// <summary>
            /// Gets The Persistance Handler For Particular Form
            /// </summary>
            /// <param name="formName"></param>
            /// <returns></returns>
            public FormState ReadState(string formName)
            {
                if (!IsInitialized() || !ContainsKey(formName)) return null;
    
                return _formPersistanceHandlers[formName];
            }
    
            /// <summary>
            /// Checks Whether The Dictionary Has Been Initialized or Not
            /// </summary>
            /// <returns></returns>
            private bool IsInitialized()
            {
                return _formPersistanceHandlers != null;
            }
    
            /// <summary>
            /// If Dictionary Contains This Key
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            private bool ContainsKey(string key)
            {
                return _formPersistanceHandlers.ContainsKey(key);
            }
    
            #endregion
        }
    

    The collection implements a singleton so that for entire application we can have a single collection that can be read from and written to by any form.

    该集合实现一个单例,因此对于整个应用程序,我们可以有一个可以以任何形式读取和写入的单个集合。

    The two most important behaviors of this collection are to save the form state and read the persisted state. The two methods namely Persist and ReadState are implementing the functionality.

    此集合的两个最重要的行为是保存表单状态并读取持久状态。 Persist和ReadState这两个方法正在实现该功能。

    OK, so we had enough of infrastructure, let’s put this to work and create our concrete types that forms are going to work with in the application.

    好的,因此我们有足够的基础结构,让我们使用它来创建表单要在应用程序中使用的具体类型。

    The PersistantForm

    持久形式

    If you could remember the initial requirements list that we made, we need to read from saved state before form load and save the state at the time when the form closes.

    如果您还记得我们创建的初始需求列表,则需要在表单加载之前从保存的状态中读取信息,并在表单关闭时保存状态。

    So we need to bind to the form’s load and close events. This means we need a form that can act as the base form for all the forms that need their state to be persisted.

    因此,我们需要绑定到表单的load和close事件。 这意味着我们需要一个可以充当所有需要持久保存其状态的表单的基础表单的表单。

    Let’s make an base form namely PersistantForm and bind to its load and closing events.

    让我们创建一个基本表单,即PersistantForm并绑定到其load和close事件。

    In the form load event handler, we will read from the saved state.

    在表单加载事件处理程序中,我们将从已保存状态中读取。

    In the form closing event handler, we will save the form’s current state.

    在表单关闭事件处理程序中,我们将保存表单的当前状态。

    Let’s have a look at this base form:-

    让我们看一下这种基本形式:

    public class PersistantForm : Form
        {
            public PersistantForm()
            {
                this.Load += PersistantFormBaseLoad;
                this.FormClosing += PersistantFormBaseFormClosing;
            }
    
            /// <summary>
            /// Update Our Persistable Forms Type & Serialize It
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            void PersistantFormBaseFormClosing(object sender, FormClosingEventArgs e)
            {
                FormStateCollection.Instance.Persist(this.GetType().FullName, ReadCurrentState());
            }
    
            /// <summary>
            /// Apply Last Saved State To This Form
            /// </summary>
            /// <param name="state"></param>
            internal virtual void ApplyState(FormState state)
            {
                this.WindowState = state.WindowState;
                this.Size = new Size(state.Size);
    
                /********************************
                 * You Can Also Read any other information
                 * Persisted for this Form by calling
                 * FormState ReadCustomState method like this:-
                 * state.ReadCustomState<Rectangle>("key");
                 ********************************/
            }
    
            /// <summary>
            /// Reads The Previous Saved State of this form
            /// </summary>
            /// <returns></returns>
            private FormState ReadLastState()
            {
                return FormStateCollection.Instance.ReadState(this.GetType().FullName);
            }
    
            
    
      /// <summary>
            /// Gets The Current State Of This Form
            /// </summary>
            /// <returns></returns>
            internal virtual FormState ReadCurrentState()
            {
                var currState = new FormState(this.WindowState, this.Size.Width, this.Size.Height);
                return currState;
    
                /********************************
                 * You Can Also Persist any other information
                 * by calling FormState AddCustomState method:-
                 * currState.AddCustomState("key","value");
                 ********************************/
            }
        } //End of class
    

    What about other form states

    那其他形式的状态呢

    All looks good till now, but simply saving the form’s size and window state doesn’t help. We might need to store other information as well in our form type, so I have kept a dictionary in the FormState class to hold other state information.

    到现在为止看起来一切都不错,但是简单地保存表单的大小和窗口状态并没有帮助。 我们可能还需要在表单类型中存储其他信息,因此我在FormState类中保留了一个词典来保存其他状态信息。

    Also there are few methods to work around with this state dictionary.

    同样,很少有方法可以处理此状态字典。

    So that’s it folks, we have made an infrastructure which can be used to persist the Form’s state and then read from that state.

    就是这样,伙计们,我们已经建立了可用于持久保存Form状态并从中读取状态的基础结构。

    Go ahead and download the code attached.

    继续并下载附带的代码。

    Happy Programming.....FormPersist.zip FormPersist.zip

    翻译自: https://www.experts-exchange.com/articles/10111/How-To-Persist-Windows-Form-State.html

    windows窗体

    展开全文
  • 类型:Windows窗体应用 效果图–父窗体 主窗体 功能描述 记事本: 这些事子窗体的功能 在工具栏中添加保存 打开 加粗 倾斜四个带图片文字的按钮,两个下拉框选择字体和字号,文本输入框设置边框 滚动条 铺满整个...

    开发语言:C#
    开发工具:VS2017
    类型:Windows窗体应用
    效果图–父窗体
    在这里插入图片描述
    主窗体
    在这里插入图片描述
    功能描述
    记事本:
    这些事子窗体的功能

    1. 在工具栏中添加保存 打开 加粗 倾斜四个带图片文字的按钮,两个下拉框选择字体和字号,文本输入框设置边框 滚动条 铺满整个容器。
    2. 窗体加载时,将系统字体加载到字体控件中,点击加粗按钮加粗文本框,再次点击取消。
    3. 点击倾斜按钮,再次点击取消。(未解决问题:不能让同时设置加粗和倾斜属性,字体设置重载方法中,fontStyle.Bold
      和fontStyle.Italic不能同时存在,以后解决)。
    4. 保存文件,为空不能保存,设置用户保存的路径streamwrite。
    5. 打开文件。
      6.新建窗体
      注意事项:
      如果文件是新建的那么保存的时候应该选择路径,如果不是就直接保存。用户修改了文档如果直接关闭窗体应该提示用户保存。新建按钮。
      修改字体 字号,可以通过下拉框修改,也可以直接输入一个值修改。
      DisplaStyle:指定是否同时呈现图像和文本。
      代码区
      父窗体代码
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace TextProj
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
    
            //新建一个窗口
            private void MenuItemExitNewCre_Click(object sender, EventArgs e)
            {
                FormChild fc = new FormChild();
                fc.MdiParent = this;
                fc.Show();
            }
            
            private void MenuItemExitClose_Click(object sender, EventArgs e)
            {
                Form frm = this.ActiveMdiChild;
                frm.Close();
            }
    
            private void MenuItemExitCloseAll_Click(object sender, EventArgs e)
            {
                foreach (Form frm in this.MdiChildren)
                {
                    Form f = this.ActiveMdiChild;
                    f.Close();
                }
            }
    
            private void MenuItemExit_Click(object sender, EventArgs e)
            {
                this.Close();
            }
        }
    }
    
    

    子窗体代码

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    using System.Drawing.Text;
    using System.IO;
    using System.Collections;
    
    namespace TextProj
    {
        public partial class FormChild : Form
        {
            public FormChild()
            {
                InitializeComponent();
            }
    
            private void textBox1_TextChanged(object sender, EventArgs e)
            {
                labFlag.Text = "*";
            }
    
            //窗体加载事件
            private void FormChild_Load(object sender, EventArgs e)
            {
                //在窗体加载的时候,将字体加载到combobox中
                InstalledFontCollection ifc = new InstalledFontCollection();
                FontFamily[] ff = ifc.Families;                    //获取字体数组
                for(int i = 0; i < ff.Length; i++)
                {
                    toolStripComboFont.Items.Add(ff[i].Name);
                }
    
            }
    
            //点击按钮文本内容加粗或取消加粗
            private void toolStripBtnBold_Click(object sender, EventArgs e)
            {
                //先获取文本内容的加粗属性,只有为false的时候才加粗
                //加粗不能修改已经设置的属性,字体和字号
                //获取当前的字体
                string fontName = toolStripComboFont.Text;
                string fontSizes = toolStripComboFontSize.Text;
                float fontSize = 0;
                if (fontSizes == "字号")
                {
                    fontSize = 8;
                }
                else
                {
                    fontSize = float.Parse(fontSizes);
                }
    
                if(textBox1.Font.Bold == false)
                {
                    this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Bold);
                }
                else
                {
                    this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Regular);
                }
            }
    
            private void toolStripBtnIval_Click(object sender, EventArgs e)
            {
                string fontName = toolStripComboFont.Text;
                string fontSizes = toolStripComboFontSize.Text;
                float fontSize = 0;
                if (fontSizes == "字号")      //显示当前combobox的Text属性,字号只能是数字,不能是字符串
                {
                    fontSize = 8;
                }
                else
                {
                    fontSize = float.Parse(fontSizes);
                }
    
                if (textBox1.Font.Italic == false)
                {
                    this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Italic);
                }
                else
                {
                    this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Regular);
                }
            }
    
            private void toolStripComboFont_SelectedIndexChanged(object sender, EventArgs e)
            {
                string fontName = toolStripComboFont.Text;
                string fontSizes = toolStripComboFontSize.Text;
                float fontSize = 0;
                if (fontSizes == "字号")
                {
                    fontSize = 8;
                }
                else
                {
                    fontSize = float.Parse(fontSizes);
                }
                this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Italic);
            }
    
            private void toolStripComboFontSize_SelectedIndexChanged(object sender, EventArgs e)
            {
                string fontName = toolStripComboFont.Text;
                string fontSizes = toolStripComboFontSize.Text;
                float fontSize = 0;
                if (fontSizes == "字号")
                {
                    fontSize = 8;
                }
                else
                {
                    fontSize = float.Parse(fontSizes);
                }
                this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Italic);
            }
    
            private void toolStripComboFontSize_TextChanged(object sender, EventArgs e)
            {
                string fontName = toolStripComboFont.Text;
                string fontSizes = toolStripComboFontSize.Text;
                float fontSize = 0;
                if (fontSizes == "字号")
                {
                    fontSize = 8;
                }
                else
                {
                    if(fontSize == 0)
                    {
                        fontSize = 1;
                    }
                    fontSize = float.Parse(fontSizes);
                }
                this.textBox1.Font = new Font(fontName, fontSize, FontStyle.Italic);
            }
            //打开文件按钮
            private void toolStripBtnOpen_Click(object sender, EventArgs e)
            {
                openFileDialog1.Filter = "文本文件(*.txt)|*.txt";
                if(openFileDialog1.ShowDialog() == DialogResult.OK)
                {
                    string path = openFileDialog1.FileName;
                    //用指定的字符编码,初始化一个新实例
                    StreamReader sr = new StreamReader(path, Encoding.UTF8);
                    //读取来自流末尾前的所有字符
                    string str = sr.ReadToEnd();
                    textBox1.Text = str;
                    sr.Close();
                }
            }
    
            //保存文件按钮
            private void toolStripBtnSave_Click(object sender, EventArgs e)
            {
                //文件不为空才可以保存
                if(this.textBox1.Text.Trim() != "")
                {
                    saveFileDialog1.Filter = "文本文件(*.txt)|*.txt";
                    //用户点击OK保存文件
                    if(saveFileDialog1.ShowDialog() == DialogResult.OK)
                    {
                        //设置用户的保存目录
                        string path = saveFileDialog1.FileName;
                        StreamWriter sw = new StreamWriter(path, false);
                        sw.WriteLine(textBox1.Text);
                        sw.Flush();
                        sw.Close();
                    }
                }
                else
                {
                    MessageBox.Show("文件内容不能为空,请输入...","提示信息",MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                labFlag.Text = "";
                 
            }
    
            private void toolStripBtnNewCreate_Click(object sender, EventArgs e)
            {
                this.textBox1.Text = "";
                this.Text = "";
            }
    
            private void labFlag_TextChanged(object sender, EventArgs e)
            {
    
            }
    
            //如果用户没有保存就关闭窗口,就提醒用户保存之后再关闭
            private void FormChild_FormClosed(object sender, FormClosedEventArgs e)
            {
                //未保存
                if(labFlag.Text == "*")
                {
                    DialogResult dr = MessageBox.Show("未保存,确认退出吗?", "提示信息", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                    if(dr == DialogResult.Yes)
                    {
                        this.Dispose();         //释放所有资源
                    }
                    else
                    {
                        //e.Cancel = true;
                    }
                }
            }
        }
    }
    
    
    展开全文
  • windows窗体应用开发

    2012-02-15 23:14:50
    求一段能让窗口不能拖动的代码。。。
  • Windows窗体Windows窗体(WinForms)是用于构建Windows桌面应用程序的UI框架。 它是Windows用户界面库(例如User32和GDI +)上的.NET包装。 它还提供控件和其他功能Windows窗体Windows窗体(WinForms)是用于构建...
  • 基于.NET Framework 2.0的Windows窗体应用开发(MCP 70-526).pdf
  • C#windows窗体猜数字小游戏

    热门讨论 2011-07-05 11:52:29
    windows窗体开发的猜数字小游戏,休闲,益智。
  • FixtureTrackingUI 灯具跟踪用户界面-Windows窗体 开发了一个跟踪公司固定装置的项目
  • 从此篇开始,将一步一步讲述如何利用...2.选择“Windows窗体应用” 3.设定项目名称及其存放位置(个人建议,不要放在默认路径) 4.创建得到如下窗体 至此,窗体的初步创建已经完成,接下来就是相应功能的编写。 ...
  • C#开发Windows窗体应用程序的步骤

    千次阅读 2017-12-06 13:43:15
    使用C#开发应用程序时,一般包括创建项目、界面设计、设置属性、编写程序代码、保存项目、程序运行等6个步骤。...选择“Windows窗体应用(.NET Framework)”、输入项目的名称、选择保存路径,然后单击“确定
  • Windows窗体应用

    2013-01-04 18:32:55
    Windows窗体应用程序还体现了一种思维,即对事件的处理,详细讲解有关Windows窗体应用程序的开发以及网络应用。 重点学习以下内容: Windows窗体控件; 菜单创建; 单文档和多文档应用程序;
  • 能够使用vs工具开发Windows窗体应用程序 1. 2. 3. 4. 5.
  • 在.NET中有3种创建自定义Windows窗体控件的基本技术,分别对应于3个不同的起点。这些选择允许开发人员在简易型和灵活性之间进行适当的平衡,选择最合适的...最简单的技术是从一个已开发的完整的Windows窗体控件开...
  • 基于.NET+Framework2.0的Windows窗体应用开发(汉70-526)基于.NET+Framework2.0的Windows窗体应用开发(汉70-526)
  • Windows窗体

    2012-01-19 09:50:00
    Windows窗体 窗体 .NET Framework提供了一系列与窗体编程相关的类,用来供开发人员使用。这些类主要包含于System.Windows.Forms命名空间中。 其中与窗体和控件相关的基类见下表: .NET Framework窗体...
  • Windows 窗体编程 演练:本地化 Windows 窗体 Visual Studio 项目系统为本地化 Windows 窗体应用程序提供相当大的支持。下面是两种使用 Visual Studio 开发环境生成资源文件的方法: 使项目系统为可本地化...
  • visual studio2008 开发windows窗体应用程序
  • 演示将基于MFC的控件移动到.NET Windows窗体的不同方法
  • 1.1. Windows窗体控件的种类及介绍 Windows 窗体支持三种用户定义的控件:复合、扩展和自定义。 复合控件是通过从 UserControl 类继承创建的控件。复合控件包含与每个包含的 Windows 窗体控件相关联的所有固有...
  • 创建Windows窗体

    千次阅读 2018-06-10 19:07:23
        开发 游戏的第一步,需要建立窗体。     做出的空白窗体,并没有游戏的绘图系统,只是“建立了一个标准窗体”而已。需要探讨的是,在窗体背后,Windows 系统的工作。 Windows 窗体的构成部分   ...
  • 基于.NET Framework 2.0的Windows窗体应用开发(MCP 70-526).pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,207
精华内容 1,282
关键字:

windows窗体开发