顺藤摸瓜——自主知识猎取的学习方法（1）

 

自主知识猎取的学习方法

北京百育炎华教育咨询公司

http://www.c1945.com

 

 

•  物流系统规划报告 项目管理系统设计 项目管理相关文档 OA 系统需求分析 OA 系统详细设计 人力资源系统设计 数据库设计报告 [CRM 词汇大全]
  [彩信业务原理] [微软内容服务器介绍] [软件项目开发技能要求] [UML 用例图设计]  [网上营销系统方案书] [电子政务方案书] [项目管理系统方案书]
  [软件投标技巧] [网上证券系统方案书]  [软件投标书规范] [技术发展与技术生涯] [E-LEARNING 方案书] [面向对象建模方法] [微软项目开发准则 MSF]
• [web 服务与应用整合] [用户界面设计原理]  [网络管理概述] [JSP 基本知识]  [电子商务] [XML 技术]  [IDC 数据中心建设方法] [大型MIS软件开发的几点体会]
• [Office 建立办公自动化环境] [网站建设10步曲]  [解决方案设计方法]

 

 

本文节选自“百育兔子”系列软件之[企业项目开发资源版]，详情到我公司网站查询。

 

第一阶段：概念和术语

无论学习什么语言，首先简单了解一下基本概念和术语，不必深入研究，但要大概知道这些概念和术语，就像学习英语首先要掌握单词一样，至于如何灵活运用，以后编码中体会。但是，如果连这些基本概念和术语都不了解，则以后学习中，遇到了也会糊涂，甚至看不到代码的深层含义。自学第一步，了解基本概念，比如：面向对象，窗体，控件，web service。

第一阶段学习方法

1、  要了解概念和术语，请阅读 MSDN 帮助文件，专门看“入门”部分，就可以看到技术的基本轮廓；比如，.net 2003 的 msdn。

 

 

2、  要了解更多专业术语，比如：SOAP 等单词，可以看 msdn 的词汇解释。比如，.net 2003 msdn 中。

 

 

3、  其他办法，就是到搜索引擎中搜索你希望了解的知识，使用关键词，如果是多个关键词，中间使用空格分开，命中率高。

 

理解各种概念和术语的时候要注意，有些概念和术语，只是作为一种原理的讲解，编程序基本用不上，知道就行了。比如，windows 中的进程，如果你要是看到相关资料，肯定是长篇累牍地说进程技术，实际上，这是操作系统的一种运行程序的原理，你编码的时候根本用不上。当你运行一个 exe或者调用 dll 的时候，在操作系统来看，它就会以进程方式运行，达到并发运行等效果。这是操作系统的事情，不用你在编程的时候考虑什么。编写的程序自然就是进程了。但如果你被这种概念搞糊涂，以为是一种编程技术，那么就麻烦了！因为根本不要，除非你自己想开发一个 windows 操作系统。

因此一定要分清楚哪些是原理知识，与编程无关；哪些是编程中要用到的概念和术语。如果编程中要用到，对应的语言语法和类库中肯定有相关的函数、类或者控件。比如：线程。实现程序的并发运行（多个代码段并发运行），以前在 vb 中只能使用 timer 控件来模拟，而在 .net 和 java 中，则提供了类的方法，就是 thread 类。如果让游戏中多个人物同时各自运动，关键是同时，使用线程技术就简单了，否则怎么办呢？这个时候，这个线程的概念就中要了。

类似的还有网络编程（qq等）的 socket，实际上就是操作网卡和使用 tcp/ip 协议。如果研究原理，那就复杂了，你只要理解这个东西能够进行网络编程，并使用好 socket 类就行了。

如同学汉语，我们没有必要研究汉语的发展史，以及汉语是怎么诞生的，那是语言学家的事情，我们只要知道每个汉字、词汇的用法，并能学出文章就 ok了。

如果你的女朋友爱上你，你不必研究为什么爱上你，甚至研究她的 DNA 中是否有可以按上你的成分，你只要懂得爱她就行了。

 

总之，这个阶段略知一二即可，不要钻牛角尖，把自己类似，并掉到概念的陷阱中无法自拔！

这就类似数学中的“公理”，大家必须认同，然后才能依据公理推出定理。没有人去研究为什么有公理，既然是公理，那就必须默认！

 

第二阶段：代码操练

当知道了一些概念和术语后，就可以进行大量代码练习，根据开发工具提供的功能的分类进行。体会编程语言技巧和各种技术知识。微软提供了大量的代码练习例子，已经发送给大家了。每个技术（vb.net/c#）都包含不同基础知识的联系程序，文件组成结构如下：

 

n         语言知识

n         窗体编程

n         Web 编程

n         数据库访问

n         Web service

 

不要打开代码看一眼就走，要仔细看看代码是如何编写的，并自己模仿重新编写一次，这些代码解释了很多基础知识的运用方法，非常有用！！

 

 

大体思路是：

1、  掌握语言语法知识和编程理论（只有两种：结构化和面向对象，目前 .net 和 java 都是面向对象的编程思维）。方法也是查 msdn。比如，要知道 OOP 技术，到 msdn 中搜索：

 

 

2、  掌握界面设计方法：窗体、页面和控件

任何程序都要有界面，否则没法使用，界面分为窗体和浏览器两种，窗体界面以微软的控件和 java 的 awt&swing 控件为主；浏览器界面则以 html 标记为主。基于的国际标准不同，必然界面设计方法也不同，但很类似。要知道如何设计界面，也可以通过 msdn。

n         在早期 vb6.0 的 msdn 中，详细说明了窗体开发的技术：

n         在 .net 中，只是提出了窗体编程技术的升级，方式升级，控件升级等，但方法策略不变。下图是早期 6.0 中的 msdn，要想理解微软技术知识，不妨走一次回头路，从早期资料中获得基础知识：

 

 

3、  掌握类、属性、方法函数和事件

这些内容讲解最清楚的还是 6.0 的 msdn。

 

4、  掌握数据库处理技术

微软的数据库处理技术很统一，就是 ado(.net)技术。这是开发工具操作数据库系统的接口。其实更多的数据库处理技术则在数据库系统中。开发工具大多是在调用数据库系统的对象（table 等）和程序（sql 语言程序，如：select、storeprocduer,view 等）。

要掌握更多数据库技术，应该看数据库系统的开发指南。比如 sql server 的开发指南（联机丛书）：

 

 

5、  掌握调试技术

任何编写的代码肯定要调试，主要围绕以下问题：

n         代码拼写错误？

n         使用的语法错误？

n         算法设计错误？

n         系统配置错误？

n         调用关系错误？

调试技巧在 msdn 6.0 中有明确说明，可惜，.net 中就不再提出了。似乎微软认为学习 .net 的都是高手。

 

 

6、  掌握底层开发技术（API 和图形图像处理）

许多看似神奇的程序，往往是通过底层开发实现的，因为我们常用的开发工具提供的内容并不会如此丰富。最典型的就是微软的技术，常规 mis 系统开发和一般编程都可以，但如果要操作更加复杂的内容，则需要下载安装相关的开发工具，其实是更多的类、函数和接口程序甚至是控件。装上这些 sdk，你的开发工具就多了很多控件和类库了。微软统一提供了几百兆的 sdk 软件包，可以下载，名字是：windows xxx platform sdk。典型的有：

n         三维图象，使用 directx sdk，做游戏等；

n         语音技术，使用 ms agent sdk，做语音识别；

n         系统底层，使用 相关 API，比如，各种设备驱动程序，使用 DDE SDK，就可以开发网卡、打印机、显卡驱动了，我们很少用；厂商的开发人员使用；

 

对于 java 来说，则更加惨烈一些，几乎除了 java 语言之外，所有的都需要 sdk(jdk)和api。要找全这些 api 才能开发大程序。

第三阶段：从小项目开始综合运用所学知识

这也是我们实训的起点，让大家学会综合运用各种技术。在培训中，我们采用了“倒行逆施”的方法，就是让大家先有应用技术的感觉，然后，再理解技术基础，那就容易多了。但，大家不要指望短短的学习就可以掌握全部，还需要按照老师指导的方法和本指南的方法，自学其他知识，将来一定有用，会让自己不断扩展知识面，不断丰富和提高。

 

“顺藤摸瓜”学习法

目前，互联网很发达了，我们随时可以从网上得到很多技术资料。但是，当我们面对一些源代码例子的时候，却不知道如何下手来学习。下面告诉大家一个方法，就是顺藤摸瓜。

比如，以下代码是微软提供的练习代码中的一部分。主要讲解如何编写多线程程序，如果我们希望学习多线程技术，可以看这个例子，当然，假设你已经具备了基本的 c# 编程技术：

 

 

程序演示了线程之间的互操作和协同工作方式。我们看一看其中一部分代码，字体放大的部分表示我们应该学习和研究的，从 msdn 帮助中找到这些知识：

 

using System;

using System.Threading;

using System.Drawing;

using System.Windows.Forms;

 

// This class encapsulates a two second process for non-threaded, threaded, and thread-

// pool operations.

 

public delegate void OnProcessesComplete();

 

public class ProcessGroup

{

     // Constructor

     public ProcessGroup(Label ActiveLabel,Label ThreadNumLabel,Label IsPoolThreadLabel)

     {

         lblActive = ActiveLabel;

         lblThreadNum = ThreadNumLabel;

         lblIsPoolThread = IsPoolThreadLabel;

         // Add one to the shared property numberOfProcesses.

         numberOfProcesses += 1;

     }

     private Label lblActive;

     private Label lblIsPoolThread;

     private Label lblThreadNum;

 

     // static members

     private static bool highIntensity ;

     private static int numberOfProcesses  = 0;

     private static int processesCompleted;

     private static int ticksElapsed;

 

     public static int GetTicksElapsed

     {

         get

         {

              return ticksElapsed;

         }

     }

 

     public static bool SetHighIntensity

     {

         set

         {

              highIntensity = value;

         }

     }

    

     public event OnProcessesComplete Completed;

    

     // Initialize static members for another run

     public static void PrepareToRun()

     {

         processesCompleted = 0;

         ticksElapsed = Environment.TickCount;

     }

 

     // This procedure runs a two second process, updating the appropriate labels,

     // forcing refresh in case Main thread is starved.

      public void Run()

     {

         // Show that we are active in green.

         lblActive.Text = "Active";

         lblActive.ForeColor = Color.Green;

         lblActive.Refresh();

         // Update ThreadNum label with current thread number.  GetHashCode will contain

         // a unique value for each thread.

         lblThreadNum.Text = Thread.CurrentThread.GetHashCode().ToString();

         lblThreadNum.Refresh();

         // Update the IsThreadPooled label with Yes/No depending on whether the current

         // thread is a pool thread.

 

         if (Thread.CurrentThread.IsThreadPoolThread)

         {

              lblIsPoolThread.Text = "Yes";

         }

         else

         {

              lblIsPoolThread.Text = "No";

         }

         lblIsPoolThread.Refresh();

         // if highIntensity is selected loop based on TickCount for two seconds to max

         // out the CPU, otherwise let this thread sleep for 2 seconds.

 

         if (highIntensity)

         {

              int ticks  = Environment.TickCount;

              while (Environment.TickCount - ticks < 2000)

              {

              }

         }

         else

         {

              System.Threading.Thread.Sleep(2000);

         }

 

         // Process is finished, display inactive in red

         lblActive.Text = "Inactive";

         lblActive.ForeColor = Color.Red;

         lblActive.Refresh();

         // Add to the shared property ProcessCompleted.  if all processes are done,

         // raise a completed event.  This is necessary for the threaded processes,

         // to allow the user interface to know when to enable buttons, and update

         // time elapsed, since they return immediately.

         processesCompleted += 1;

 

         if (processesCompleted == numberOfProcesses)

         {

              ticksElapsed = Environment.TickCount - ticksElapsed;

              Completed();

         }

     }

 

     // This subroutine is callback for Threadpool.QueueWorkItem.  This is the necessary

     // subroutine signiture for QueueWorkItem, and run is proper for creating a Thread

     // so the two subroutines can! be combined, so instead just call Run from here.

 

     private void RunPooledThread(object state)

     {

         Run();

     }

 

     // Add a queue request to Threadpool with a callback to RunPooledThread (which calls

     // Run()

     public void StartPooledThread()

     {

         // Create a callback to subroutine RunPooledThread

         WaitCallback callback = new WaitCallback(RunPooledThread);

         // && put in a request to ThreadPool to run the process.

         ThreadPool.QueueUserWorkItem(callback, null);

     }

 

     // Start a new thread, running subroutine Run.

     public void StartThread()

     {

         Thread newThread;

         newThread = new Thread(new ThreadStart(Run));

     newThread.Start();

 

     }

}

 

其中，放大的部分基本是你搞不懂的部分，那就需要学习了。然后可以通过这个完整的程序，体会线程编程的作用和能够解决的实际问题。

“顺藤摸瓜”的具体步骤是：

1、  找到完整并能够运行的程序代码；

2、  运行程序，先看看这个程序有什么效果，解决了什么问题；

3、  逐个打开每个代码文件，按照上面的方法，快速浏览代码，将遇到的自己含糊或者不懂的部分记录下来；

4、  逐个查找帮助资料，逐个理解，不要试图一次都明白；

5、  然后自己重新建立一套程序，把自己明白的代码部分粘贴到自己的程序中；

6、  把自己刚刚理解的部分，亲自编写一遍，不要看原来提供的代码，靠自己的理解来编写；

7、  如此循环，直到把所有代码重新编写了一遍；

8、  运行你自己的程序，会发现问题，调试程序，从调试程序中会得到更多体会；

 

.NET 程序的总体结构

任何 .NET 程序，就是一个程序文件。虽然 .net 可以在一个文件中定义多个类，但通常象java 一样，都是一个类使用一个文件比较好。但每个文件都具备以下的总体框架结构，只是有些程序少了其中一部分，因为程序简单，这个框架也是我们编码和学习的基本思路：