精华内容
下载资源
问答
  • ASP.NET可交互式位图窗体设计3

    千次阅读 2005-10-28 16:11:00
    构造函数 构造函数传递三个参数:包含圆的中心坐标的点、圆的... 绘图代码 Draw 方法重载实际上非常简单:它根据我们保存在构造函数中的颜色对象创建一个笔对象,然后使用该笔,调用 Graphics.DrawEllipse 方法绘制
    构造函数 
      构造函数传递三个参数:包含圆的中心坐标的点、圆的半径以及一个
    System.Drawing.Color 结构(包含用于绘制圆轮廓的颜色)。

      然后我们根据中心和半径计算边框,并将笔颜色项设置为我们传递的颜色对象。

      绘图代码
      Draw 方法重载实际上非常简单:它根据我们保存在构造函数中的颜色对象创建一个
    笔对象,然后使用该笔,调用 Graphics.DrawEllipse 方法绘制圆,同时传递了我们早
    先创建的边框。

      图形、笔和画笔
      这里我们需要解释一下 Graphics、Pen 和 Brush 对象。(在开始填充我们的可填
    充对象时,就会看到 Brush 对象。)

      Graphics 对象代表一个与某个真实绘图空间相关联的虚拟化的绘图空间。虚拟化是
    指,通过在 Graphics 对象上绘图,我们可以使用相同的 Graphics 方法在与该对象相
    关联的任何类型的实际表面上绘图。对于那些习惯于使用 MFC 或 Microsoft
    Windows? SDK 编程的用户,Graphics 对象相当于 Windows 中称为“设备上下文”(或
    DC)的 .NET 版本。

      在此 Windows 窗体应用程序中,传递到 Draw 方法的 Graphics 对象将与屏幕上的
    一个窗口相关联 -- 这里是 PictureBox。在我们的 Microsoft ASP.NET 应用程序中使
    用这一代码时,传递给 Draw 方法的 Graphics 对象将与一个位图图像相关联。它也可
    以和打印机或其他设备相关联。

      这个方案的优点是我们可以使用相同的绘图代码在不同的表面上绘图。在我们的绘
    图代码中,我们不需要知道任何有关屏幕、位图、打印机等等之间的不同 -- .NET
    Framework(以及底层的操作系统)可以为我们处理所有细节。

      利用相同的标记,笔和画笔成为虚拟化的绘图工具。笔代表线条属性 -- 颜色、宽
    度、样式,甚至可以是用来绘制线的位图。画笔代表一个填充区域的属性 -- 颜色、样
    式,甚至可以是用来填充区域的位图。

      在使用 Using 后清除(或至少 Dispose)
      Graphics、Pen 和 Brush 对象都与相似类型的 Windows 对象相关联。这些
    Windows 对象分配在操作系统的内存中 -- 这些内存尚未被 .NET 运行时管理。长时间
    将这些对象驻留在内存中会导致性能问题,并且在 Microsoft Windows 98 下,当图形
    堆填满时会导致绘图问题。因此,我们应尽快释放这些 Windows 对象。

      当相应的 .NET Framework 对象完成操作并回收内存后,.NET 运行时会自动释放
    Windows 对象。但回收内存的时间会很长 -- 如果我们不迅速释放这些对象,所有不幸
    的事情(包括填满 Windows 堆)都可能发生。在该应用程序的 ASP.NET 版本中,由于
    很多用户在同一台服务器上访问该应用程序,所以这种现象会更加严重。

      因为这些对象与未管理的资源相关联,所以它们实现 IDisposable 接口。该接口有
    一个方法,即 Dispose,它将 .NET Framework 对象从 Windows 对象中分离出来,并释
    放 Windows 对象,从而使计算机处于良好的状态。

      这时您只需完成一项任务:确保在使用完该对象后,调用 Dispose 方法。

      Visual Basic .NET 代码中显示了这一内容的经典形式:首先创建对象,然后在一
    个 Try 块中使用该对象,最后在 Finally 块中清理该对象。Try/Finally 能够确保即
    使出现异常也会清理对象。(在本例中,我们调用的绘图方法可能不会引发异常,所以
    可能并不需要 Try/Finally 块。但掌握这些技巧很有用,因此 Dr. GUI 也希望向您演
    示这一正确方法。)

      这种形式很常见,因此 C# 为其提供了一个私有语句:using。C# 代码中的
    using 语句等同于 Visual Basic .NET 代码中的声明和 Try/Finally -- 但更为简洁、
    方便,并减少了发生错误的可能性。(Dr. GUI 不清楚为什么 Visual Basic .NET 不包
    含一些诸如 using 的语句。)

      接口
      有些(但不是全部)可绘制对象可以被填充。某些对象(如点和线)不能被填充,
    因为它们不是封闭的区域,而矩形和圆等对象可以是中空的,或者被填充。

      另一方面,就象将所有可绘制对象作为多态处理一样,我们也可以将所有可填充对
    象作为多态处理,这会很方便。例如,如同我们将所有可绘制对象放到一个集合中,通
    过遍历集合并在每个对象上调用 Draw 来绘制对象一样,我们可以将所有可填充对象放
    到一个集合中,而不考虑这些可填充对象的实际类型。因此,我们使用某种机制(如继
    承)来获得真正的多态。

      因为不是所有的可绘制对象都可以被填充,因此不能将 Fill 方法的声明放在抽象
    基类中。.NET Framework 不允许类的多重继承,所以也不能将其放在另一个抽象基类中
    。并且如果我们从不是非可填充类的其他基类中派生出可填充对象,则不能将所有可绘
    制对象作为多态处理。

      但 .NET Framework 支持接口 -- 并提供了一个可实现任意数量的接口的类。接口
    不具有任何实现 -- 没有代码,也没有任何数据。因此,实现接口的类必须提供所有内
    容。



      接口所能包含的只有声明。以下是我们在 C# 中的接口 IFillable。单击此处在新
    窗口中查看全部源文件。



      C#
    public interface IFillable {
    void Fill(Graphics g);
    Color FillBrushColor { get; set; }
    }


      以下是等同的 Visual Basic .NET 代码。单击此处在新窗口中查看全部源文件。

      Visual Basic .NET

    Public Interface IFillable
    Sub Fill(ByVal g As Graphics)
    Property FillBrushColor() As Color
    End Interface 

      我们不需要声明方法或者 virtual/Overridable 或 abstract/MustOverride 属性
    以及任何其他项,因为接口中的所有方法和属性都自动设置为公开的和
    abstract/MustOverride。

      使用一个属性:不能在接口中包含数据
      请注意,虽然我们不能在接口中声明字段,但可以声明一个属性,因为属性实际上
    是作为方法实现的。

      但这样做会给接口的实现者带来负担,下面就会看到。实现者必须实现 get 和
    set 方法,以及实现该属性所必需的任何数据。如果实现非常复杂,则可以编写一个
    helper 类以封装某些部分。在本文稍后我们将就一个略微不同的上下文环境显示如何使
    用 helper 类。

      实现接口
      我们已经定义了接口,现在可以在类中实现它了。请注意,我们必须提供所实现接
    口的完整实现:不能只从中选取一部分。

      下面我们看看 C# 中 DFilledRectangle 类的代码。


      C#
    public class DFilledCircle : DHollowCircle, IFillable
    {
    public DFilledCircle(Point center, int radius, Color penColor,
    Color brushColor) : base(center, radius, penColor) {
    this.brushColor = brushColor;
    }

    public void Fill(Graphics g) {
    using (Brush b = new SolidBrush(brushColor)) {
    g.FillEllipse(b, bounding);
    }
    }
    protected Color brushColor;
    public Color FillBrushColor {
    get {
    return brushColor;
    }
    set {
    brushColor = value;
    }
    }
    public override void Draw(Graphics g) {
    Fill(g);
    base.Draw(g);
    }
    }


      以下是 Visual Basic .NET 中 DFilledRectangle 类的代码。


      Visual Basic .NET
    Public Class DFilledRectangle
    Inherits DHollowRectangle
    Implements IFillable
    Public Sub New(ByVal rect As Rectangle, _
    ByVal penColor As Color, ByVal brushColor As Color)
    MyBase.New(rect, penColor)
    Me.brushColor = brushColor
    End Sub
    Public Sub Fill(ByVal g As Graphics) Implements IFillable.Fill
    Dim b = New SolidBrush(FillBrushColor)
    Try
    g.FillRectangle(b, bounding)
    Finally
    b.dispose()
    End Try
    End Sub
    Protected brushColor As Color
    Public Property FillBrushColor() As Color _
    Implements IFillable.FillBrushColor
    Get
    Return brushColor
    End Get
    Set(ByVal Value As Color)
    brushColor = Value
    End Set
    End Property


    Public Overrides Sub Draw(ByVal g As Graphics)
    Dim p = New Pen(penColor)
    Try
    Fill(g)
    MyBase.Draw(g)
    Finally
    p.Dispose()
    End Try
    End Sub
    End Class


      以下是有关这些类的注意事项。

      从 HollowRectangle 中派生
      我们从这个类的空心版本中派生出填充类。这个类中的多数内容都发生了改变:Dra
    w 方法和构造函数都是新的(但两者都调用基类的版本),并且为 IFillable 接口的
    Fill 方法以及 FillBrushColor 属性添加了实现。

      需要新构造函数的原因是我们在这个类中包含了需要初始化的其他数据,即填充画
    笔。(您可以回顾我们前面讨论的画笔。)请注意此构造函数是如何调用基类构造函数
    的:在 C# 中,该调用被内置到声明 (: base(center, radius, penColor)) 中;在
    Visual Basic .NET 中,我们将它明确放在 New 方法(即构造函数)的第一行
    (MyBase.New(rect, penColor))。

      因为我们已经向基类构造函数中传递了三个参数中的两个,现在只需初始化最后的
    字段即可。
    展开全文
  • ASP.NET可交互式位图窗体设计5

    千次阅读 2005-11-18 03:30:00
    使我们的对象可序列化 为在 ASP.NET 中使用可绘制对象类,我们需要对其再进行一项更改。这些类需要是可序列化的,...反序列化是从序列化数据中重新创建对象的过程。我们会在将来的专栏中深入讨论这个问题。 Dr. GUI
    使我们的对象可序列化 
      为在 ASP.NET 中使用可绘制对象类,我们需要对其再进行一项更改。这些类需要是
    可序列化的,以便能够在主要的 Web 页和生成该图像的 Web 页之间传递数据(后面将
    详述)。序列化是这样的过程:将某个类的数据以某种方式写入存储介质,以便存储和/
    或传递数据并在以后反序列化。反序列化是从序列化数据中重新创建对象的过程。我们
    会在将来的专栏中深入讨论这个问题。

      Dr. GUI 最开始作为 Windows 窗体应用程序编写此应用程序时,只使用了 .NET
    Framework 和操作系统预先分配的 Brushes 和 Pens 类中的可用常用画笔和笔。因为这
    些已经分配完毕,保持对它们的引用不会有任何妨碍,同时也无需对其进行 Dispose。

      但由于笔和画笔是非常复杂的对象,不能是可序列化的,因此 Dr. GUI 必须改变其
    策略,转而决定存储笔和画笔的颜色,然后在需要绘制和填充对象时动态创建笔和画笔


      如何使之可序列化?
      序列化是 .NET Framework 的一个重要部分,因此也使序列化对象的工作变得很简
    单。

      我们只需使用 Serializable 属性标记一个类便可使之可序列化。(这与我们以前
    用于在枚举上将其标记为一套标志的属性是同一种属性。)在 C# 和 Visual Basic
    .NET 中的语法如下所示:


    C#

    [Serializable]
    class Foo // ...
    Visual Basic

    .NET _
    Class Foo ' ...


      注意:除了将类标记为可序列化外,还必须使类中包含的所有数据可序列化,否则
    在试图序列化数据时,序列化框架会引发一个异常。

      使容器可序列化
      .NET Framework 的一大优点是可以使容器类可序列化。这意味着如果将对象存储在
    可序列化的容器中,容器可以自动序列化对象。

      因此在本例中,DShapeList 类包含了两个 ArrayList 对象。由于 ArrayList 是可
    序列化的,因此要使 DShapeList 可序列化,只需将其标记为 Serializable 属性即可
    ,如下所示:


    Visual Basic

    .NET _
    Public Class DShapeList
    Dim wholeList As New ArrayList()
    Dim filledList As New ArrayList()
    ' ...


    C#

    [Serializable]
    public class DShapeList {
    ArrayList wholeList = new ArrayList();
    ArrayList filledList = new ArrayList();


      假设我们放在 DShapeList 中的对象都是可序列化的,这时便可以使用单个语句序
    列化和反序列化整个列表!

      顺便说一下,这对于该应用程序的 Windows 窗体版本也是一个很好的改变,因为它
    使我们能够将绘图写入磁盘文件并重新加载。

      可绘制对象的三个版本;任何一个都可以在任何上下文中使用
      您可能已经注意到,我们有三种版本的可绘制对象代码:在 C# 和 Visual Basic
    .NET 中各有一个不使用我们在上面编写的 helper 方法的版本,另一个是 Visual
    Basic .NET 中使用 helper 方法的版本。

      在这里还有一点微小的差别:使用 helper 的文件中的数据类被标记为可序列化;
    其他文件中的数据类则没有标记为可序列化。

      但是,请注意下面很重要的一点:如果我们返回去并将所有文件中的数据类标记为
    可序列化,那么将能够在任何应用程序中使用任何类。我们将能够混合使用 C# 和
    Visual Basic .NET。并且能够在 ASP.NET 应用程序中使用最初为 Windows 窗体应用程
    序编写的代码。

      这种简便的代码重用意味着您编写的代码更具价值,因为代码可以在很多不同的环
    境中重复使用。
    展开全文
  • C#学习笔记: ...选择“Windows窗体应用程序(.NET Framework)”输入创建的项目名称,选择项目保存路径,然后单击“确定”按钮即可创建一个Windows窗体应用程序 步骤二:界面设计 项目创建完成后,在Vi

    C#学习笔记:

    第一小节:开发应用程序的步骤

    在使用C#开发应用程序时,一般包括创建项目,界面设计,设置属性,编写程序代码,保存项目,运行项目六个步骤。

    步骤一:创建项目
    1. 在Visual Studio 2017中依次选择“文件” -->“新建” --> “项目”,弹出“新建项目”对话框
    2. 选择“Windows窗体应用程序(.NET Framework)”输入创建的项目名称,选择项目保存路径,然后单击“确定”按钮即可创建一个Windows窗体应用程序
    步骤二:界面设计
    1. 项目创建完成后,在Visual Studio 2017中会有一个默认窗体,可以通过工具箱向其中添加各种控件来设计窗体界面

    2. 具体步骤是,选定工具箱中要添加的控件,将该控件拖放到窗体中的指定位置

    3. 比如,向窗体中添加两个Label控件,两个TextBox控件,两个Button控件

    4. 效果如下:

    在这里插入图片描述

    步骤三:设置属性
    1. 在窗体中选择指定控件,在“属性”窗口中对控件的相应属性进行设置。
    名称 属性 设置值
    label1 Text 用户名:
    label2 Text 密 码:
    button1 Text 登录
    button2 Text 退出
    1. 效果如下:

    在这里插入图片描述

    步骤四:编写程序代码
    1. 双击两个Button控件即可进入代码编辑器,并自动触发Button控件中的Click事件,在该事件中可编写代码。

    2. Button控件的默认代码为:

    private void button1_Click(object sender, EventArgs e)
    {
        
    }
    private void button2_Click(object sender, EventArgs e)
    {
    
    }
    
    步骤五:保存项目
    1. 单击Visual Studio 2017工具栏中的全部保存按钮,保存当前项目
    2. 或依次选择“文件” --> “全部保存”,保存当前项目
    步骤六:运行程序
    1. 单击Visual Studio 2017工具栏中的启动按钮,运行当前程序

    2. 或依次选择“调试” -->“开始调试”,运行当前程序

    3. 效果如下:

      在这里插入图片描述

    第二小节:Form窗体
    1. Form窗体也被称为窗口,它是向用户显示信息的可视界面,是windows窗体应用程序的基本单元。

    2. 窗体的特征可以通过编程来进行设置。

    3. 窗体也是对象,窗体类定义了生成窗体的模板,每实例化一个窗体类,就产生一个窗体。

    4. .NET框架类库的System.Windows.Forms命名空间中定义的Form类是所有窗体类的基类

    第一:添加和删除窗体

    添加窗体

    1. 在添加窗体时,首先要创建一个Windows窗体应用程序

    2. 选中项目名称并单击鼠标右键,在弹出的快捷菜单中依次选择“添加” --> “Windows窗体”,或者依次选择“添加” --> “新建项”

    3. 选择“新建项”或“Windows窗体”后,都会打开“添加新项-EMS”对话框,选择“Windows窗体”,输入窗体名称后,单击“添加”按钮即可在项目中添加一个新的窗体

    4. 说明:不要使用关键字设置窗体的名称

    在这里插入图片描述

    删除窗体

    1. 在要删除的窗体名称上单击鼠标右键,在弹出的快捷菜单中单击“删除”按钮即可将窗体删除
      在这里插入图片描述
    第二:多窗体的使用

    一个完整的Windows窗体应用程序是由多个窗体组成的,每个窗体实现不同的功能

    多窗体的建立

    1.  多窗体的建立是指在某个项目中添加多个窗体。
    
    2.  说明:在添加多个窗体时,其名称不能相同
    

    设置启动窗体

    1. 当在项目中添加了多个窗体以后,如果要调试程序,必须要设置先运行的窗体,即设置项目的启动窗体

    2. 项目的启动窗体是在Program.cs文件中设置的,在Program.cs文件中改变Run方法的参数即可实现设置启动窗体

    3. Run方法用于在当前线程上开始运行标准应用程序,并使指定窗体可见

      //Run()方法的语法如下
      public static void Run(Form mainForm)
      //mainForm:要设为启动窗体的对象
      
    4. 举例:将Form1设置为项目的启动窗体

      Application.Run(new Form1());
      

    在这里插入图片描述

    第三:窗体的属性

    窗体包含一些基本的组成要素,如图标,标题,位置和背景等。这些要素可以通过窗体的“属性”窗口进行设置,也可以通过代码进行设置。但是为了快速开发Windows窗体应用程序,通常都是通过“属性”窗口进行设置的。

    更换窗体的图标

    1. 添加完成一个新的窗体后,窗体的图标是系统默认的图标。如果需要更换窗体的图标,可以在“属性”窗口中设置窗体的Icon属性
    2. 步骤一:选中窗体并在窗体的“属性”窗口中选中Icon属性,会出现在这里插入图片描述按钮
    3. 步骤二:单击在这里插入图片描述按钮,打开选择图标文件的窗体
    4. 步骤三:选择新的窗体图标文件,单击“打开”按钮,完成窗体图标的更换

    隐藏窗体的标题栏

    1. 在某些情况下需要隐藏窗体的标题栏,例如,软件的加载窗口大多都采用无标题栏的窗体。

    2. 通过设置窗体的FormBorderStyle属性的属性值可以隐藏窗体的标题栏

    3. FormBorderStyle属性有7个属性值:

      属性值 说明
      Fixed3D 固定的三维边框
      FixedDialog 固定的对话框样式的粗边框
      FixedSingle 固定的单行边框
      FixedToolWindow 不可调整大小的工具窗口边框
      None 无边框
      Sizable 可调整大小的边框
      SizableToolWindow 可调整大小的工具窗口边框
      1. 只要将FormBorderStyle属性设置为None即可隐藏窗体的标题栏
      2. form border style 窗体边框样式,在“属性”窗口的外观中

    设置窗体的显示位置

    1. 窗体在显示器中加载时的位置可以通过窗体的StartPositong属性进行设置
    属性值 说明
    CenterParent 窗体在其父窗体中居中
    CenterScreen 窗体在当前显示窗口中居中,其尺寸在窗口大小中指定
    Manual 窗体的位置由Location属性确定
    WindowDefaultBounds 窗体在Windows默认位置,其边界也由Windows默认指定
    WindowsDefaultLocation 窗体在Windows默认位置,其尺寸在窗口大小中指定
    1. 在设置窗体的显示位置时,只需要根据不同需要选择属性值即可。

    设置窗体的大小

    1. 窗体的大小可以通过Size属性进行设置。

    2. 双击窗体的“属性”窗口的Size属性,可以看到其下拉菜单中有Width和Height两个属性,分别用于设置窗体的宽和高

    3. 说明:在设置窗体的大小时,若窗体的值是Int32(整数)类型的,不能使用单精度和双精度(小说)进行设置

    在这里插入图片描述
    设置窗体的背景图片

    为了使窗体更加美观,通常需要设置窗体的背景。

    1. 窗体的背景主要通过窗体的BackgroundImage属性进行设置

    2. 步骤一:选中窗体“属性”窗口中的BackgroundImage属性,会出现在这里插入图片描述按钮

    3. 步骤二:单击在这里插入图片描述按钮,打开“选择资源”对话框

    在这里插入图片描述

    1. 在“选择资源”对话框中,有两个单选按钮,一个是“本地资源”对话框,另一个是“项目资源文件”单选按钮。这两个单选按钮的不同之处在,选中“本地资源”单选按钮后,直接选择图片,保存的是图片的路径;而选中“项目资源文件”单选按钮后,会将选择的图片保存到项目资源文件Resources.resx中。

    2. 无论选择哪个单选按钮,都需要单击“导入”按钮选择背景图片,单击“确定”按钮完成窗体背景图片的设置。

    第四:显示与隐藏窗体

    窗体的显示

    1. 如果要在一个窗体中通过按钮打开另一个窗体,就必须通过调用Show()方法显示窗体

      public void Show()
      
    2. 举例:在Form1窗体中添加一个Button按钮,在按钮的Click事件中调用Show()方法,打开Form2窗体

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 form2 = new Form2();//创建Form2窗体的对象
            form2.Show();//调用Show()方法显示Form2窗体
        }
      

      在这里插入图片描述

    窗体的隐藏

    1. 通过调用Hide()方法可以隐藏窗体

      public void Hide()
      
    2. 举例:在Form1窗体中打开Form2窗体后,隐藏当前窗体Form1

       private void button1_Click(object sender, EventArgs e)
        {
            Form2 form2 = new Form2();//创建Form2窗体的对象
            form2.Show();//调用Show()方法显示Form2窗体
            this.Hide();//调用Hide()方法隐藏当前窗口
        }
      
      第五:窗体的事件

      Windows是事件驱动的操作系统,其对Form类的任何交互都是基于事件来实现的。Form类提供了大量事件用于响应对窗体执行的各种操作

      1. Click事件

      当单击窗体时会触发窗体的Click事件

      public event EventHandler Click
      

      举例:在窗体的Click事件中编写代码,实现当单击窗体时,弹出提示框

      private void Form1_Click(object sender, EventArgs e)
      {
          //MessageBox类,该类是一个消息提示框类,其Show()方法用来显示对话框
          MessageBox.Show("单击窗体触发Click事件");
      }
      

    在这里插入图片描述

    在这里插入图片描述

    说明:触发窗体或控件的相关事件时,只需要选中指定的窗体或控件,单击鼠标右键,在弹出的快捷菜单中选择“属性”选项,然后在弹出的“属性”对话框中单击
    在这里插入图片描述按钮,在列表中找到相应事件名称,双击即可生成该事件的代码

    2. Load事件

    窗体在加载时会触发窗体的Load事件,语法如下:

    public event  EventHandler Load
    

    举例:当窗体加载时,弹出提示框,询问是否产看窗体,单击“是”按钮查看窗体

    private void Form1_Load(object sender, EventArgs e)
    {
        if (MessageBox.Show("是否查看窗体!", " ", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == 	DialogResult.Yes)
        {
    
        }
    }
    

    在这里插入图片描述

    3. FormClosing事件

    窗体在关闭时会触发窗体的FormClosing事件,语法如下:

    public event FormClosingEventHandler FormClosing
    

    举例:在关闭窗体之前,弹出提示框,询问是否关闭当前窗体,单击“是:按钮,关闭窗体;单击”否“按钮,不关闭窗体

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        //使用if语句判断是否单击“是”按钮
        if(MessageBox.Show("是否关闭窗体","提示",MessageBoxButtons.YesNo,MessageBoxIcon.Warning) == DialogResult.Yes)
        {
            e.Cancel = false; //如果单击“是”按钮则关闭窗体
    
        }
        else  //否则
        {
            e.Cancel = true;    //否则不执行操作
        }
    
    }
    
    第三节:MDI窗体

    窗体是所有界面的基础,这就意味着为了打开多个文档,需要具有能够同时处理多个窗体的应用程序。MDI窗体(多文档界面)可以解决这种需求。

    第一:设置MDI窗体

    在MDI窗体中,具体容器作用的窗体称为父窗体;可以放在父窗体中的其他窗体称为子窗体,也称为MDI子窗体。

    MDI应用程序在启动时,首先会显示父窗体。所有的子窗体都在父窗体中打开。

    在父窗体中可以在任何时候打开多个子窗体。

    每个应用程序只能有一个父窗体,子窗体不能移出父窗体的框架区域。

    1. 设置父窗体

    如果要将某个窗体设置为父窗体,只需要在窗体的”属性“窗口中将IsMdiContainer属性设置为True即可

    2. 设置子窗体

    父窗体设置完成后,通过设置某个窗体的MdiParent属性来将其设置为子窗体

    public Form MdiParent {get;set;}
    

    属性值为MDI父窗体

    举例:

    第二:排列子窗体
    枚举成员 说明
    Cascade 所有子窗体均层叠在父窗体的工作区内
    TileHorizontal 所有子窗体均水平铺在父窗体的工作区内
    TileVertical 所有子窗体均垂直平铺在父窗体的工作区

    举例:排列父窗体中的的多个子窗体

    程序开发步骤:

    步骤一: 新建一个Windows窗体应用程序,并将其命名为Demo,默认窗体为Form1

    步骤二: 将窗体Form1的IsMdiContainer属性设置为True,以用作父窗体,然后再添加三个Windows窗体,用作子窗体

    步骤三: 在Form1窗体中,添加MenuStrip控件,用作该父窗体的菜单项

    步骤四: 通过MenuStrip控件建立4个菜单项,分别为”加载子窗体“,“水平平铺”,“垂直平铺”,“层叠排列”。运行程序,单击“加载子窗体”菜单后,可以加载所有的子窗体,对应代码如下:

    private void 加载子窗体ToolStripMenuItem_Click(object sender, EventArgs e)
    {
        Form2 form2 = new Form2();  // 创建Forma2窗体的对象
        form2.MdiParent = this;   // 创建Forma2窗体的对象
        form2.Show();     // 创建Forma2窗体的对象
    
        Form3 form3 = new Form3();  // 创建Forma2窗体的对象
        form3.MdiParent = this;  // 创建Forma2窗体的对象
        form3.Show();  // 创建Forma2窗体的对象
    
        Form4 form4 = new Form4();// 创建Forma2窗体的对象
        form4.MdiParent = this;// 创建Forma2窗体的对象
        form4.Show();  // 创建Forma2窗体的对象
    }
    

    步骤五: 加载完所有的子窗体后,单击“水平平铺”菜单,使窗体中所有的子窗体水平排列:

    private void 水平平铺ToolStripMenuItem_Click(object sender, EventArgs e)
    {
        LayoutMdi(MdiLayout.TileHorizontal);//使用MdiLayout枚举实现窗体的水平排列
    }
    

    步骤六: 单击“垂直平铺”菜单,使得窗体中的全部子窗体垂直排列

    private void 垂直平铺ToolStripMenuItem_Click(object sender, EventArgs e)
    {
        LayoutMdi(MdiLayout.TileVertical);//使用MdiLayout枚举实现窗体的垂直排列
    }
    

    步骤七: 单击“层叠排列”菜单,使得窗体中的全部子窗体层叠排列

    private void 层叠排列ToolStripMenuItem_Click(object sender, EventArgs e)
    {
    	//使用MdiLayout枚举实现窗体的层叠排列
        LayoutMdi(MdiLayout.Cascade);
    }
    

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • Windows 窗体(或简称 WinForms),多年来被用于开发具有丰富和交互式界面的基于 Windows 的强大应用程序。各类企业对这些桌面应用程序的投入量非常巨大,...
        

    Windows 窗体(或简称 WinForms),多年来被用于开发具有丰富和交互式界面的基于 Windows 的强大应用程序。


    各类企业对这些桌面应用程序的投入量非常巨大,每月有大约 240 万开发人员使用 Visual Studio 创建桌面式应用。


    利用和扩展现有WinForms代码资产的好处无疑极具吸引力,但还有其他好处。


    WinForms 拖放式设计器体验使用户能够构建功能齐全的 UI,而不需要任何特殊知识或培训。


    WinForms 应用程序易于部署和更新,可独立于 Internet 连接工作,并且可以在不向 Internet 公开配置的本地计算机上运行,提高了安全性。


    一直到最近,WinForms 应用程序都还依然只能使用完整的 .NET Framework 进行构建,但 .NET Core 3.0 预览版的发布改变了这一现状。


    .NET Core 的新功能和优点不再局限于 Web 开发。


    通过.NET Core 3.0 WinForms增加了一些功能,比如更易于部署、更高的性能、对.NET Core 特有的NuGet 包的支持、.NET Core 命令行接口 (CLI) 等等。


    本文将介绍使用这些功能的诸多好处、它们的重要性以及如何在WinForms应用程序中使用它们。


    让我们直接开始构建第一个 .NET Core 3.0 WinForms 应用程序。


    在本文中,我将构建一个应用程序,用于检索并显示托管在 GitHub 上的其中一个开源 Microsoft 存储库的开放式拉取请求。


    第一步是安装最新版本的 Visual Studio 2019 和 .NET Core 3.0 SDK,之后便可使用 .NET Core CLI 命令来创建新的 WinForms 应用程序。


    在添加 .NET Core 支持之前,WinForms 应用程序无法实现这一点。


    即将发布的是一个新的 Visual Studio 模板,用于创建针对 .NET Core 3.0 的 WinForms 项目。


    由于模板目前尚未发布,因此现在让我们通过运行以下命令生成一个名为 PullRequestHub 的新 WinForms 项目:


    dotnet new winforms -o PullRequestHub


    为了确保项目成功创建,请导航到 dotnet new 命令创建的新目录,使用 CLI 构建并运行项目,如下所示:


    cd .\PullRequestHub\


    由于可以访问 .NET Core CLI,因此也可以访问要还原、运行和构建的命令。在运行之前,请尝试还原和构建命令,如下所示:


    dotnet restoredotnet build



    这些命令的工作方式与在 .NET Core Web 应用程序的命令行中运行时的工作方式相同。请注意,在执行 dotnet run 命令时,它实际上会在执行应用之前执行还原和构建命令 (bit.ly/2UCkEaN)。现在让我们运行项目,通过在命令行输入 dotnet run 对其进行测试。


    成功!你刚刚创建了第一个 .NET Core WinForms 应用程序。


    运行时,将看到屏幕上出现一个带有“Hello .NET Core!”文本的窗体。


    在进一步向应用程序添加逻辑之前,让我们花一点时间来讨论 Visual Studio 中 WinForms 设计器视图的当前状态。


    设置 .NET Core WinForms 应用的设计器


    在 Visual Studio 中打开 CLI 生成的项目时,可能会注意到缺少某些功能。最值得注意的是,目前没有为 .NET Core WinForms 应用程序提供设计器视图。虽然有计划提供此功能,但尚未完成。


    幸运的是,有一个解决方案可让你至少在添加本机支持之前访问设计器。现在,可创建包含 UI 文件的 .NET Framework 项目。


    通过这种方式就可以使用设计器编辑 UI 文件,然后 .NET Core 项目将引用 .NET Framework 项目中的 UI 文件。这使你能够利用 UI 功能,同时仍然在 .NET Core 中构建应用程序。


    以下是我为项目执行操作的方法。


    除了所创建的 PullRequestHub 项目之外,还需要添加一个在 .NET Full-Framework 版本上运行的新 WinForms 项目。


    将此项目命名为 PullRequestHub.Designer。创建新项目后,从 .NET Core 项目中删除 Form1 文件,只保留 Program.cs 类。


    导航到 PullRequestHub.Designer 并将窗体文件重命名为 PullRequestForm。


    现在将编辑 .NET Core 项目文件,并添加以下代码,将两个项目中的文件关联起来。这还将负责处理将来创建的任何其他窗体或资源:


    <ItemGroup>  <Compile Include=”..\PullRequestHub.Designer\**\*.cs” /></ItemGroup>



    保存项目文件后,将看到 PullRequestForm 文件出现在解决方案资源管理器中,你将能够与它们进行交互。


    如果要使用 UI 编辑器,需要确保从 .NET Core 项目中关闭 PullRequestForm 文件,并从 .NET Framework 项目中打开 PullRequestForm 文件。


    更改将在两者中进行,但仅 .NET Framework 项目提供编辑器。


    构建应用程序


    让我们开始向应用程序中添加一些代码。为了从 GitHub 检索开放式拉取请求,我需要创建一个 HttpClient。


    这就是 .NET Core 3.0 的用武之地,因为它提供了对新 HttpClientFactory 的访问权限。全框架版本中的 HttpClient 存在一些问题,包括使用 using 语句创建客户端的问题。HttpClient 对象将被释放,但底层套接字在一段时间内不会被释放,默认情况下为 240 秒。如果套接字连接保持打开状态 240 秒,并且系统中的吞吐量很高,则系统可能会使所有空闲套接字达到饱和。发生这种情况时,新请求必须等待套接字释放,这可能对性能产生一些非常严重的影响。


    HttpClientFactory 有助于缓解这些问题。首先,它提供了一种在更中心位置预先配置客户端实现的更简单方法。它还为你管理 HttpClients 的生命周期,因此你不会遇到前面提到的问题。我们来了解如何在 WinForms 应用程序中执行此操作。


    使用此新功能的最佳和最简单的方法之一是通过依赖项注入。依赖项注入,或更普遍的控制反转,是一种将依赖项传递到类中的技术。它也是减少类耦合和简化单元测试的绝佳方法。例如,你将看到如何在程序启动时创建 IHttpClientFactory 的实例,以便稍后在窗体中使用该对象。在以前的 .NET 版本中,这在 WinForms 中不太容易实现,这就是使用 .NET Core 的另一个优势。


    在 Program.cs 中,将创建一个名为 ConfigureServices 的方法。在本方法中,创建新的 ServiceCollection,以便可通过依赖项注入来使用服务。


    需要先安装最新的这两个 NuGet 包:


    Microsoft.Extensions.DependencyInjectionMicrosoft.Extensions.Http



    然后添加图 1 中所示的代码。


    这将创建一个要在窗体中使用的新 IHttpClientFactory。


    结果会得到一个客户端,可以显式地使用它来处理涉及 GitHub API 的请求。


    图 1 创建新的 IHttpClientFactory


    private static void ConfigureServices(){  var services = new ServiceCollection();  services.AddHttpClient();  services.AddHttpClient(“github”, c =>  {    c.BaseAddress = new Uri(“https://api.github.com/”);    c.DefaultRequestHeaders.Add(“Accept”, “application/vnd.github.v3+json”);    c.DefaultRequestHeaders.Add(“User-Agent”, “HttpClientFactory-Sample”);    c.DefaultRequestHeaders.Add(“Accept”, “application/json”);    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;  });}



    接下来,需要将实际的窗体类 PullRequestForm 注册为单一实例。在本方法的末尾处,添加以下行:


    services.AddSingleton<PullRequestForm>();


    然后,需要创建 ServiceProvider 的实例。在 Program.cs 类的顶部,创建以下属性:


    private static IServiceProvider ServiceProvider { get; set; }


    现在有了 ServiceProvider 属性,请在 ConfigureServices 方法的末尾处添加一行来构建 ServiceProvider,如下所示:


    ServiceProvider = services.BuildServiceProvider();



    最后,完整的 ConfigureServices 方法应类似于图 2 中的代码。


    图 2 ConfigureServices 方法


    private static void ConfigureServices(){  var services = new ServiceCollection();  services.AddHttpClient();  services.AddHttpClient(“github”, c =>  {    c.BaseAddress = new Uri(“https://api.github.com/”);    c.DefaultRequestHeaders.Add(“Accept”, “application/vnd.github.v3+json”);    c.DefaultRequestHeaders.Add(“User-Agent”, “HttpClientFactory-Sample”);    c.DefaultRequestHeaders.Add(“Accept”, “application/json”);    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;  });  services.AddSingleton<PullRequestForm>();  ServiceProvider = services.BuildServiceProvider();}



    现在,需要在启动时将窗体与容器连接起来。


    应用程序运行时,这将调用 PullRequestForm 并提供可用的必要服务。


    将 Main 方法更改为以下代码:


    [STAThread]static void Main(){  Application.EnableVisualStyles();  Application.SetCompatibleTextRenderingDefault(false);  ConfigureServices();Application.Run((PullRequestForm)ServiceProvider.GetService(typeof(PullRequestForm)));}



    感觉很棒!现在已完成所有连接。在 PullRequestForm 构造函数中,注入刚连接好的 IHttpClientFactory 并将其分配给本地变量,如以下代码所示:


    private static HttpClient _httpClient;public PullRequestForm(IHttpClientFactory httpClientFactory){  InitializeComponent();  _httpClient = httpClientFactory.CreateClient(“github”);}



    现在有了 HttpClient,可使用它来调用 GitHub 以检索拉取请求、问题等。这也使得后续几个步骤略微棘手。来自 HttpClient 的调用将为异步请求,如果你一直在使用 WinForms,你就知道接下来该怎么做。接下来必须处理线程,并将调度更新发送到 UI 线程。


    为了开始检索所有拉取请求,需在视图中添加一个按钮。通过这种方式,可在将来添加更多存储库或更多存储库组进行检查。使用连接的设计器,将按钮拖到窗体上,并将文本重命名为“Microsoft”。


    在此过程中,给按钮取一个更具含义的名称,如 RetrieveData_Button。需要绑定到 RetrieveData_Button_Click 事件,但需要使用此代码将其设置为异步:


    private async void RetrieveData_Button_Click(object sender, EventArgs e){}



    在此处,需要调用检索开放式 GitHub 拉取请求的方法。但首先,由于现在正在处理异步调用,因此必须连接 SynchronizationContext。可通过添加新属性并使用以下代码更新构造函数来完成此操作:


    private static HttpClient _httpClient;private readonly SynchronizationContext synchronizationContext;public PullRequestForm(IHttpClientFactory httpClientFactory){  InitializeComponent();  synchronizationContext = SynchronizationContext.Current;  _httpClient = httpClientFactory.CreateClient(“github”);}



    接下来,创建一个模型并将其命名为 PullRequestData,以便可以轻松地反序列化请求。相关代码如下:


    public class PullRequestData{  public string Url { get; set; }  public string Title { get; set; }}



    最后,创建一个名为 GetPullRequestData 方法。在本方法中,将向 GitHub API 发出请求并检索所有开放式拉取请求。将反序列化 JSON 请求,因此请将最新版本的 Newtonsoft.Json 包添加到项目中。


    代码如下:


    private async Task<List<PullRequestData>> GetPullRequestData(){  var gitHubResponse =    await _httpClient.GetStringAsync(    $”repos/dotnet/winforms/pulls?state=open”);  var gitHubData =    JsonConvert.DeserializeObject<List<PullRequestData>>(gitHubResponse);  return gitHubData;}



    现在可使用 RetrieveData_Button_Click 方法调用此方法。获得所需的数据列表后,为每个标题创建标签列表,以便在窗体上显示。


    获得标签列表后,可在 UpdateUI 方法中将它们添加到 UI 中。


    图 3 显示了此步骤。


    图 3 从 RetrieveData_Button_Click 进行调用


    private async void RetrieveData_Button_Click(object sender, EventArgs e){  var pullRequestData = await GetPullRequestData();  await Task.Run(() =>  {    var labelsToAdd = new List<Label>();    var verticalSpaceBetweenLabels = 20;    var horizontalSpaceFromLeft = 10;    for (int i = 0; i < pullRequestData.Count; i++)    {      Label label = new Label();      label.Text = pullRequestData[i].Title;      label.Left = horizontalSpaceFromLeft;      label.Size = new Size(100, 10);      label.AutoSize = true;      label.Top = (i * verticalSpaceBetweenLabels);      labelsToAdd.Add(label);    }    UpdateUI(labelsToAdd);  });}


    然后,UpdateUI 方法将使用 synchronizationContext 更新 UI,如下所示:



    public void UpdateUI(List<Label> labels){  synchronizationContext.Post(new SendOrPostCallback(o =>  {    foreach (var label in labels)    {      Controls.Add(label);    }  }), labels);}


    如果运行应用程序并单击 Microsoft 按钮,UI 将和 GitHub 上 dotnet/winforms 存储库中的所有开放式拉取请求的窗体一起更新。


    现在轮到你了。正如本文的标题所说,为了使它成为一个真正的集中式拉取请求中心,让我们更新此示例,以便从多个 GitHub 存储库中进行读取。


    这些存储库不需要来自 Microsoft 团队,尽管观察它们的进程十分有趣。


    例如,微服务体系结构非常常见,在其中你可能拥有许多组成整个系统的存储库。鉴于一般而言,不长时间将分支和拉取请求单独存储是一个好主意,这样的工具可以提高对开放式拉取请求的见解并提高整个系统的质量。


    可设置一个 Web 应用,但又得担心部署、运行、身份验证等问题。


    使用 . NET Core 中的 WinForms 应用程序,你无需担心任何此类问题。


    现在让我们来看看使用 .NET Core 构建 WinForms 应用的最大优势之一。


    打包应用程序


    过去,部署新的或更新的 WinForms 应用程序可能会导致与主机上安装的 .NET Framework 版本相关的问题。通过 .NET Core 则可以独立部署应用并从单个文件夹运行应用,而不依赖于计算机上安装的 .NET Framework 版本。


    这意味着用户无需安装任何内容;他们可以仅运行应用程序。通过 .NET Core 还可以一次更新和部署一个应用,因为其包版本不会相互影响。


    对于本文中的示例应用,需要为其独立打包。请注意,独立应用程序会更大,因为它们包含 .NET Core 库。如果要部署到安装了 .NET Core 最新版本的计算机中,则无需独立部署应用。相反,可通过利用已安装的 .NET Core 版本来减小已部署应用的大小。当不希望应用程序依赖于它将运行的环境时,可使用独立选项。


    若要在本地打包应用程序,需要确保在设置中启用了开发人员模式。尝试运行打包项目时,Visual Studio 将进行提示并提供设置的链接,但若要直接启用它,请转到 Windows 设置,按 Windows 徽标键并搜索“设置”。在搜索框中键入“面向开发人员的设置”并选择它。将看到启用开发人员模式的选项。选择并启用此选项。


    大多数情况下,如果以前打包过 WinForms 应用程序,那么创建独立包的步骤则看起来比较熟悉。首先,创建一个新的 Windows 应用程序打包项目。将新项目命名为 PullRequestHubPackaging。当系统提示选择目标和最低平台版本时,请使用默认值并单击“确定”。右键单击应用程序并为 PullRequestHub 项目添加引用。


    添加引用后,需要将 PullRequestHub 项目设置为入口点。完成后,在下次构建时很可能会看到以下错误:“如果 SelfContained 为 true,则项目 PullRequestHub 必须在项目文件中指定 RuntimeIdentifiers。”


    若要修复此错误,请编辑 PullRequestHub.csproj 文件。在打开本项目文件时,你会注意到使用 .NET Core 的另一个优点,这是因为该项目文件现在使用的是新的轻量级格式。在基于 .NET Framework 的 WinForms 项目中,项目文件将更详细地包含显式默认值和引用,并将 NuGet 引用拆分为 packages.config 文件。新的项目文件格式会将包引用引入到项目文件中,从而可以在一个位置管理所有依赖项。


    在本文件的第一个 PropertyGroup 节点中,添加以下行:


    <RuntimeIdentifiers>win-x86</RuntimeIdentifiers>


    运行时标识符用于标识运行应用程序的目标平台,并由 .NET 包用来表示 NuGet 包中特定于平台的资产。


    添加该标识符后,构建就应该成功了,可将 PullRequestHubPackaging 项目设置为 Visual Studio 中的启动项目。


    指示项目是独立的设置是 PullRequestHubPackaging.wapproj 文件中需要注意的一点。文件中需要注意的代码部分如下:


    <ItemGroup>  <ProjectReference Include=”..\PullRequestHub\PullRequestHub.csproj”> <DesktopBridgeSelfContained>True</DesktopBridgeSelfContained>    <DesktopBridgeIdentifier>$(DesktopBridgeRuntimeIdentifier)    </DesktopBridgeIdentifier>      <Properties>SelfContained=%(DesktopBridgeSelfContained);        RuntimeIdentifier=%(DesktopBridgeIdentifier)      </Properties>    <SkipGetTargetFrameworkProperties>True    </SkipGetTargetFrameworkProperties>  </ProjectReference></ItemGroup>



    在此处,可看到 DesktopBridgeSelfContained 选项已设置为 true,这使得 WinForms 应用程序可以与 .NET Core 二进制文件一起打包。


    运行该项目时,它会将文件转储到“win-x86”的文件夹中,该文件夹的路径与此类似:


    C:\Your-Path\PullRequestHub\PullRequestHub\bin\x86\Debug\netcoreapp3.0


    在 win-x86 文件夹中你会注意到有许多 DLL,这些 DLL 包含独立应用运行所需的所有文件。


    你更有可能需要将应用部署为旁载应用程序或将其上载到 Microsoft Store。旁载将使用 appinstaller 文件进行自动更新。


    从Visual Studio 2017 Update 15.7 开始支持这些更新。


    此外,还可以创建支持提交到 Microsoft Store 进行分发的包。


    Microsoft Store 随后会处理应用的所有代码签名、分发和更新。


    除了这些选项之外,还有一些正在进行的工作可以将应用程序打包成单个可执行文件,从而无需使用 DLL 填充输出目录。


    其他优点


    通过 .NET Core 3.0,还可以利用 C# 8.0 的功能,包括可为 null 的引用类型、接口上的默认实现、使用模式切换语句的改进以及异步数据流。


    若要启用 C# 8.0,请打开 PullRequestHub.csproj 文件并将以下行添加到第一个 PropertyGroup:


    <LangVersion>8.0</LangVersion>


    使用 .NET Core 和 WinForms 的另一个优点是两个项目均为开源。


    这使得你可以访问源代码、提交 bug、共享反馈并成为贡献者。


    请查看 github.com/dotnet/winforms上的 WinForms 项目。


    .NET Core 3.0 旨在为企业和公司在 WinForms 应用程序中进行的投资注入新的活力,而 WinForms 应用程序会继续保持高效、可靠且易于部署和维护。


    开发人员可以利用新的 .NET Core 特定类(如 HttpClientFactory)、采用 C# 8.0 功能(如可为 null 的引用类型)和打包独立应用程序。


    还可以访问 .NET Core CLI 以及 .NET Core 附带的所有性能改进。

    原文地址:https://msdn.microsoft.com/zh-cn/magazine/mt833442


    .NET社区新闻,深度好文,欢迎访问公众号文章汇总 http://www.csharpkit.com 

    640?wx_fmt=jpeg

    展开全文
  • 对于一个应用程序而言,控件是用户界面的积木,他们具备交互式的特征 添加控件的方法:拖、拉、拽 添加控件的另一种方法:即通过窗体的controls类的add方法,格式如下 窗体的标志.controls.add...
  • 启动Python自带的编程和交互式环境IDLE,点击“File”→“New File”菜单项,打开一个文件编辑窗口,在此窗口中输入下面的程序,并保存为文件demo2_1Hello.py,此文件保存在随书示例Demo2_1目录下。## demo2_1Hello....
  • 使用模块化交互式工具创建应用程序时,这很有用。最初使用imshow返回句柄的语法在图形窗口中显示图像时获取句柄。 hfig = figure; himage = imshow('moon.tif') himage = Image with properties: ​ CData: ...
  • 数据库学习笔记之Access_Day05

    千次阅读 2012-08-21 11:11:15
     ①:窗体类型:窗体主要有命令选择型窗体和数据交互式窗体两种。命令选择型窗体,主要用于信息系统控制界面设计,在应用系统开发中可以根据实际要求进行相应的设计;数据交互式的窗体,主要用于显示信息和输入数据,...
  • Activity 是用户接口程序,原则上它会提供给用户一个交互式的接口功能。它是 android 应用程序的基本功能单元。Activity 本身是没有界面的。所以activity类创建了一个窗体,开发者能够通过setContentView(View)接口...
  • Access(一)学到了1 窗体概述 2 窗体创建 (二)心得体会窗体为用户提供查看和操作数据的界面,灵活的浏览,输入和修改(三)疑惑窗体太多,难以操控CoreIDRAW(一)学到了1 交互式填充及其他填充工具 2 颜色...
  • vb 运行ppt示例代码

    2014-06-25 13:01:00
    通过使用 PowerPoint 中的自动运行功能,您可以以编程方式打印、显示幻灯片及执行以交互式执行的大多数事情。按照以下步骤构建并运行一个 Visual Basic 自动运行示例: 创建一个新的标准 EXE 项目。Form1 是默认...
  • 数据可视化一

    2020-12-14 22:06:46
    Matplotlib是一个Python 2D绘图库,能够以多种硬拷贝格式和跨平台的交互式环境生成出版物质量的图形,用来绘制各种静态,动态,交互式的图表。 二、一个最简单的绘图例子 Matplotlib的图像是画在figure(如windows,...
  • C#66课的主要内容

    2016-12-09 23:57:37
    水晶报表技术简介 ...借助交互式界面更加容易地创建报表 运行时数据的自定义功能 水晶报表的主要特征和结构 案例学习:打开并查看水晶报表文件 水晶报表的执行模式 水晶报表的类型 案例学习
  • 如果您有根据用户输入 HTML 窗体上的选项对想要提供列表, 可通过使用对 MSXML 和 JavaScript 提供功能使此交互式。 针对本文, 我们将说明创建 Web 服务, 使它作为对用户可从选择列表呈现新闻复制到 <SELECT>...
  • 图表库包含100多个具有丰富功能的交互式图表,适用于在最苛刻的行业中创建应用程序:科学和研究,工程,经济和金融,贸易,医药,能源,太空和国防 XY图表 最权威的2D笛卡尔图表,具有业界最佳的渲染性能。通过我们...
  • 图表库包含100多个具有丰富功能的交互式图表,适用于在最苛刻的行业中创建应用程序:科学和研究,工程,经济和金融,贸易,医药,能源,太空和国防。 XY图表 最权威的2D笛卡尔图表,具有业界最佳的渲染性能。通过...
  • 本书配套网站www.itzcn.com提供了配套学习资源和在线互动学习平台,帮助读者实现交互式学习模式。 本书可以作为C#的基础入门学习书籍,也可以帮助中级读者提高编程技能,掌握面向实践的应用技能
  • 11.2 用按窗体查询来创建同一报表的动态分组 312 11.3 复杂的特征:创建迂回报表 316 11.3.1 查看前面的报表 318 11.3.2 "列”页面的属性 318 11.3.3 报表之后的工作 320 11.4 用动态列创建交叉表查询的...
  • ProEssentials v7破解版

    热门讨论 2012-08-08 22:15:37
     颇具特色的在线交互式Web演示更新,演示的表格采用.NET WebForm的技术创建。会注意到每一样东西后面的gradient 工具栏和 drop-shadow 效果,包括文本;可以打印,最大化和输出浏览器内的正确图片和数据;当正确...
  • 中文版Excel.2007高级VBA编程宝典 1/2

    热门讨论 2012-04-06 16:00:16
    本书将介绍如何定制Excel 用户窗体、开发新实用程序、用VBA 处理图表及数据透视表,以及创建事件处理应用程序。还将介绍如何使用VBA 子过程和函数过程、与其他应用程序轻松交互、构建用户友好的工具栏、菜单和帮助...
  • 1.2.2 从项目模板上创建项目 11 1.2.3 solution explorer窗口 13 1.2.4 项目属性 14 1.2.5 assembly information屏幕 15 1.2.6 编译设置 16 1.2.7 调试属性 20 1.2.8 引用 21 1.2.9 资源 23 ...
  • 1.2.2 从项目模板上创建项目 11 1.2.3 solution explorer窗口 13 1.2.4 项目属性 14 1.2.5 assembly information屏幕 15 1.2.6 编译设置 16 1.2.7 调试属性 20 1.2.8 引用 21 1.2.9 资源 23 1.2.10 ...
  • 一款非常好的WPF编程宝典2010 源代码

    热门讨论 2014-04-14 09:57:41
    17.3.6 声明创建视图 478 17.3.7 视图导航 480 17.4 数据提供者 483 17.4.1 ObjectDataProvider 484 17.4.2 XmlDataProvider 486 17.5 结束语 488 第18章 列表、树、工具条和菜单 489 18.1 ItemsControl...
  • 23.6.1 交互式服务 23.6.2 事件日志 23.7 电源事件 23.8 小结 第24章 互操作性 24.1 .NET和COM 24.1.1 元数据 24.1.2 释放内存 24.1.3 接口 24.1.4 方法绑定 24.1.5 数据类型 24.1.6 注册 24.1.7 线程 24.1.8 错误...
  • C#高级编程(第6版)

    2011-05-11 11:10:30
     1.7.2 创建Windows窗体  1.7.3 使用Windows Presentation Foundation(WPF)  1.7.4 Windows控件  1.7.5 Windows服务  1.7.6 Windows Communication Foundation(WCF)  1.8 C#在.NET企业体系结构中的作用  1.9 ...
  • 实例096——创建弹出菜单 实例097——实现中英文双语菜单 实例098——为系统菜单添加菜单项 实例099——在对话框中添加菜单 实例100——使用快捷键和发送消息触发菜单命令 实例101——基本工具栏按钮的创建...
  • 1.7.2 创建Windows窗体 1.7.3 使用Windows Presentation Foundation(WPF) 1.7.4 Windows控件 1.7.5 Windows服务 1.7.6 Windows Communication Foundation(WCF) 1.8 C#在.NET企业体系结构中的作用 1.9 小结 第2章 C#...
  •  1.7.2 创建Windows窗体  1.7.3 使用Windows Presentation Foundation(WPF)  1.7.4 Windows控件  1.7.5 Windows服务  1.7.6 Windows Communication Foundation(WCF)  1.8 C#在.NET企业体系结构中的作用  1.9 ...
  • 实例096——创建弹出菜单 实例097——实现中英文双语菜单 实例098——为系统菜单添加菜单项 实例099——在对话框中添加菜单 实例100——使用快捷键和发送消息触发菜单命令 实例101——基本工具栏按钮的创建...

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

创建交互式窗体