1 亚马逊

　　2 墨西哥电信

　　3 Telefonica

　　4 鸿海精密

　　5 Telenor

　　6 苹果

　　7 AT&T

　　8 任天堂

　　9 微软

　　10 中国移动

　　11 Research In Motion

　　12 VimpelCom

　　13 英国电信

　　14 Bharti Airtel

　　15 Mobile Telesystems

　　16 Accentrue

　　17 诺基亚

　　18 Millicom Intl. Cellular

　　19 谷歌

　　20 思科

以下为《Computerworld》评出的被淘汰的10项计算机技术：

　　1. 商业通用语言(Cobol)

　　2. 非关系数据库管理系统

　　3. 非IP网络

　　4. cc:Mail（Lotus推出的电子邮件系统）

　　5. ColdFusion（Allaire推出的网络程序设计语言）

　　6. C 语言

　　7. PowerBuilder

　　8. NetWare认证工程师

　　9. PC 网络管理员

　　10. OS/2

 

/**

*20070419

*fantasy

*/

 

char *strupr(char *str)
{
    assert(str != NULL);
    char *s = str;
    while (*s != '\0')
    {
        if (*s >= 'a' && *s <= 'z')
            *s -= 0x20;
        s ++;
    }
    return str;
}

 

char *strlwr(char *str)
{
    assert(str != NULL);
    char *s = str;
    while (*s != '\0')
    {
        if (*s >= 'A' && *s <= 'Z')
            *s += 0x20;
        s ++;
    }
    return str;
}

 

void *memcpy(void *dest, const void *src, int count)
{
    assert((dest != NULL) && (src != NULL));
    void *address = dest;
    while (count --)
    {
        *(char *) dest = *(char *) src;
        dest = (char *) dest + 1;
        src = (char *) src + 1;
    }
    return address;
}

 

void *memccpy(void *dest, const void *src, int c, unsigned int count)
{
    assert((dest != NULL) && (src != NULL));
    while (count --)
    {
        *(char *) dest = *(char *) src;
        if (* (char *) src == (char) c)
            return ((char *)dest + 1);
        dest = (char *) dest + 1;
        src = (char *) src + 1;
    }
    return NULL;
}

 

void *memchr(const void *buf, int c, int count)
{
    assert(buf != NULL);
    while (count --)
    {
        if (*(char *) buf == c)
            return (void *) buf;
        buf = (char *) buf + 1;
    }
    return NULL;
}

 

int memcmp(const void *s, const void *t, int count)
{
    assert((s != NULL) && (t != NULL));
    while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count --)
    {
        s = (char *) s + 1;
        t = (char *) t + 1;
    }
    return (*(char *) s - *(char *) t);
}

 

void *memmove(void *dest, const void *src, int count)
{
    assert(dest != NULL && src != NULL);
    void *address = dest;
    while (count --)
    {
        *(char *) dest = *(char *) src;
        dest = (char *) dest + 1;
        src = (const char *)src + 1;
    }
    return address;
}

 

void *memset(void *str, int c, int count)
{
    assert(str != NULL);
    void *s = str;
    while (count --)
    {
        *(char *) s = (char) c;
        s = (char *) s + 1;
    }
    return str;
}

/**
*20070419
*fantasy
*/

 

int strspn(const char *strSrc, const char *str)
{
    assert((strSrc != NULL) && (str != NULL));
    const char *s;
    const char *t = strSrc;
    while (*t != '\0')
    {
        s = str;
        while (*s != '\0')
        {
            if (*t == *s)
                break;
            ++ s;
        }
        if (*s == '\0')
            return t - strSrc;
        ++ t;
    }
    return 0;
}

 

char *strrchr(const char *str, int c)
{
    assert(str != NULL);
    const char *s = str;
    while (*s != '\0')
        ++ s;
    for (-- s; *s != (char) c; -- s)
        if (s == str)
            return NULL;
    return (char *) s;
}

 

char* strrev(char *str)
{
    assert(str != NULL);
    char *s = str, *t = str, c;
    while (*t != '\0')
        ++ t;
    for (-- t; s < t; ++ s, -- t)
    {
        c = *s;
        *s = *t;
        *t = c;
    }
    return str;
}

 

char *strnset(char *str, int c, int count)
{
    assert(str != NULL);
    char *s = str;
    for (; *s != '\0' && s - str < count; ++ s)
        *s = (char) c;
    return str;
}

 

char *strset(char *str, int c)
{
    assert(str != NULL);
    char *s = str;
    for (; *s != '\0'; ++ s)
        *s = (char) c;
    return str;
}

 

char *strtok(char *strToken, const char *str)
{
    assert(strToken != NULL && str != NULL);
    char *s = strToken;
    const char *t = str;
    while (*s != '\0')
    {
        t = str;
        while (*t != '\0')
        {
            if (*s == *t)
            {
                *(strToken + (s - strToken)) = '\0';
                return strToken;
            }
            ++ t;
        }
        ++ s;
    }
    return NULL;
}

/**
*20070418

*fantasy
*/

char *strdup(const char *strSrc)
{
    assert(strSrc != NULL);
    int len = 0;
    while (*strSrc ++ != '\0')
        ++ len;
    char *strDes = (char *) malloc (len + 1);
    while ((*strDes ++ = *strSrc ++) != '\0')
        NULL;
    return strDes;
}

char *strstr(const char *strSrc, const char *str)
{
    assert(strSrc != NULL && str != NULL);

    const char *s = strSrc;
    const char *t = str;

    for (; *t != '\0'; ++ strSrc)
    {
        for (s = strSrc, t = str; *t != '\0' && *s == *t; ++s, ++t)
            NULL;
        if (*t == '\0')
            return (char *) strSrc;
    }
    return NULL;
}

 

char *strncpy(char *strDes, const char *strSrc, int count)
{
    assert(strDes != NULL && strSrc != NULL);
    char *address = strDes;
    while (count -- && *strSrc != '\0')
        *strDes ++ = *strSrc ++;
    return address;
}

char *strncat(char *strDes, const char *strSrc, int count)
{
    assert((strDes != NULL) && (strSrc != NULL));
    char *address = strDes;

    while (*strDes != '\0')
        ++ strDes;
    while (count -- && *strSrc != '\0' )
        *strDes ++ = *strSrc ++;
    *strDes = '\0';
    return address;
}

 

int strncmp(const char *s, const char *t, int count)
{
    assert((s != NULL) && (t != NULL));
    while (*s && *t && *s == *t && count --)
    {
        ++ s;
        ++ t;
    }
    return (*s - *t);
}

 

char *strpbrk(const char *strSrc, const char *str)
{
    assert((strSrc != NULL) && (str != NULL));
    const char *s;
    while (*strSrc != '\0')
    {
        s = str;
        while (*s != '\0')
        {
            if (*strSrc == *s)
                return (char *) strSrc;
            ++ s;
        }
        ++ strSrc;
    }
    return NULL;
}

 

int strcspn(const char *strSrc, const char *str)
{
    assert((strSrc != NULL) && (str != NULL));
    const char *s;
    const char *t = strSrc;
    while (*t != '\0')
    {
        s = str;
        while (*s != '\0')
        {
            if (*t == *s)
                return t - strSrc;
            ++ s;
        }
        ++ t;
    }
    return 0;
}

 

/**
*20070417
*fantasy
*/

char *strcpy(char *strDes, const char *strSrc)
{
    assert((strDes != NULL) && (strSrc != NULL));
    char *address = strDes;
    while ((*strDes ++ = *strSrc ++) != '\0')
        NULL;
    return address;
}

 

char *strchr_(char *str, int c)
{
    assert(str != NULL);
    while ((*str != (char) c) && (*str != '\0'))
        str ++;
    if (*str != '\0')
        return str;
    return NULL;
}

 

char *strchr(const char *str, int c)
{
    assert(str != NULL);
    for (; *str != (char) c; ++ str)
        if (*str == '\0')
            return NULL;
    return (char *) str;
}

 

int strcmp(const char *s, const char *t)
{
    assert(s != NULL && t != NULL);
    while (*s && *t && *s == *t)
    {
        ++ s;
        ++ t;
    }
    return (*s - *t);
}

 

char *strcat(char *strDes, const char *strSrc)
{
    assert((strDes != NULL) && (strSrc != NULL));
    char *address = strDes;
    while (*strDes != '\0')
        ++ strDes;
    while ((*strDes ++ = *strSrc ++) != '\0')
        NULL;
    return address;
}

 

int strlen(const char *str)
{
    assert(str != NULL);
    int len = 0;
    while (*str ++ != '\0')
        ++ len;
    return len;
}

一、IP地址

(1)IP地址 

不同的物理网络技术有不同的编址方式；不同物理网络中的主机，有不同的物理网络地址。网间网技术是将不同物理网络技术统一起来的高层软件技术。网间网技术采用一种全局通用的地址格式，为全网的每一网络和每一主机都分配一个网间网地址，以此屏蔽物理网络地址的差异。IP协议提供一种全网间网通用的地址格式，并在统一管理下进行地址分配，保证一个地址对应一台网间网主机（包括网关），这样物理地址的差异被IP层所屏蔽。IP层所用到的地址叫做网间网地址，又叫IP地址。它由网络号和主机号两部分组成，统一网络内的所有主机使用相同的网络号，主机号是唯一的。IP地址是一个32为的二进制数，分成4个字段，每个字段8位。 

(2)三类主要的网络地址 
我们知道，从LAN到WAN，不同种类网络规模相差很大，必须区别对待。因此按网络规模大小，将网络地址分为主要的三类，如下： 

A类： 
1 网络号 主机号 
B类： 
1 0 网络号 主机号 
C类： 
1 1 0 网络号 主机号 

A类地址用于少量的（最多27个）主机数大于216的大型网，每个A类网络可容纳最多224台主机；B类地址用于主机数介于28～216之间数量不多不少的中型网，B类网络最多214个；C类地址用于每个网络只能容纳28台主机的大量小型网，C类网络最多221个。 
除了以上A、B、C三个主类地址外，还有另外两类地址，如下： 

D类： 
1 1 1 0多目地址 
E类： 
1 1 1 1 0留待后用 

其中多目地址（multicast address）是比广播地址稍弱的多点传送地址，用于支持多目传输技术。E类地址用于将来的扩展之用。 

(3)TCP/IP规定网络地址 
除了一般地标识一台主机外，还有几种具有特殊意义的特殊形式。 

*广播地址 
TCP/IP规定，主机号全为“1”的网络地址用于广播之用，叫做广播地址。所谓广播，指同时向网上所有主机发送报文。 
*有限广播 
前面提到的广播地址包含一个有效的网络号和主机号，技术上称为直接广播（directed boradcasting）地址。在网间网上的任何一点均可向其他任何网络进行直接广播，但直接广播有一个缺点，就是要知道信宿网络的网络号。有时需要在本网络内部广播，但又不知道本网络网络号。TCP/IP规定，32比特全为“1”的网间网地址用于本网广播，该地址叫做有限广播地址（limited broadcast address）。 
*“0”地址 
TCP/IP协议规定，各位全为“0”的网络号被解释成“本”网络。 
*回送地址 
A类网络地址127是一个保留地址，用于网络软件测试以及本地机进程间通信，叫做回送地址（loopback address）。无论什么程序，一旦使用回送地址发送数据，协议软件立即返回之，不进行任何网络传输。 

TCP/IP协议规
一、含网络号127的分组不能出现在任何网络上；
二、主机和网关不能为该地址广播任何寻径信息。由以上规定可以看出，主机号全“0”全“1”的地址在TCP/IP协议中有特殊含义，不能用作一台主机的有效地址。 

二、子网掩码 

(1)子网TCP/IP网间网技术产生于大型主流机环境中，它能发展到今天的规模是当初的设计者们始料未及的。网间网规模的迅速扩展对IP地址模式的威胁并不是它不能保证主机地址的唯一性，而是会带来两方面的负担：第一，巨大的网络地址管理开销；第二，网关寻径急剧膨胀。其中第二点尤为突出，寻径表的膨胀不仅会降低网关寻径效率（甚至可能使寻径表溢出，从而造成寻径故障），更重要的是将增加内外部路径刷新时的开销，从而加重网络负担。 

因此，迫切需要寻求新的技术，以应付网间网规模增长带来的问题。仔细分析发现，网间网规模的增长在内部主要表现为网络地址的增减，因此解决问题的思路集中在：如何减少网络地址。于是IP网络地址的多重复用技术应运而生。 通过复用技术，使若干物理网络共享同一IP网络地址，无疑将减少网络地址数。 

子网编址（subnet addressing）技术，又叫子网寻径（subnetrouting），英文简称subnetting，是最广泛使用的IP网络地址复用方式，目前已经标准化，并成为IP地址模式的一部分。一般的，32位的IP地址分为两部分，即网络号和主机号，我们分别把他们叫做IP地址的“网间网部分”和“本地部分”。子网编址技术将本地部分进一步划分为“物理网络”部分和“主机”部分，如图： 

网间网部分物理网络主机 
|←网间网部分→|←────本地部分─────→| 
其中“物理网络”用于标识同一IP网络地址下的不同物理网络，既是“子网”。 

(2)子网掩码IP协议标准规定：每一个使用子网的网点都选择一个32位的位模式，若位模式中的某位置1，则对应IP地址中的某位为网络地址（包括网间网部分和物理网络号）中的一位；若位模式中的某位置0，则对应IP地址中的某位为主机地址中的一位。例如位模式： 11111111 11111111 11111111 00000000中，前三个字节全1，代表对应IP地址中最高的三个字节为网络地址；后一个字节全0，代表对应IP地址中最后的一个字节为主机地址。这种位模式叫做子网模（subnet mask）或“子网掩码”。 

为了使用的方便，常常使用“点分整数表示法”来表示一个IP地址和子网掩码，例如B类地址子网掩码（11111111 11111111 11111111 00000000）为：255.255.25.0 IP协议关于子网掩码的定义提供一种有趣的灵活性，允许子网掩码中的“0”和“1”位不连续。但是，这样的子网掩码给分配主机地址和理解寻径表都带来一定困难，并且，极少的路由器支持在子网中使用低序或无序的位，因此在实际应用中通常各网点采用连续方式的子网掩码。像255.255.255.64和255.255.255.160等一类的子网掩码不推荐使用。

(3)子网掩码与IP地址子网掩码与IP地址结合使用，可以区分出一个网络地址的网络号和主机号。 
例如：有一个C类地址为： 
192.9.200.13其缺省的子网掩码为： 
255.255.255.0则它的网络号和主机号可按如下方法得到： 

将IP地址192.9.200.13转换为二进制11000000 00001001 11001000 00001101 
将子网掩码255.255.255.0转换为二进制11111111 11111111 11111111 00000000 
将两个二进制数逻辑与（AND）运算后得出的结果即为网络部分11000000 00001001 11001000 00001101 AND 11111111 11111111 11111111 00000000 11000000 00001001 11001000 00000000结果为192.9.200.0，即网络号为 192.9.200.0。 
将子网掩码取反再与IP地址逻辑与（AND）后得到的结果即为主机部分11000000 00001001 11001000 00001101 AND 00000000 00000000 00000000 11111111 00000000 00000000 00000000 00001101结果为0.0.0.13，即主机号为13。 
(4)子网掩码与IP地址子网掩码与IP地址结合使用，可以区分出一个网络地址的网络号和主机号。 
例如：有一个C类地址为： 
192.9.200.13 其缺省的子网掩码为： 
255.255.255.0 则它的网络号和主机号可按如下方法得到： 

将IP地址192.9.200.13转换为二进制11000000 00001001 11001000 00001101 
将子网掩码255.255.255.0转换为二进制11111111 11111111 11111111 00000000 
将两个二进制数逻辑与（AND）运算后得出的结果即为网络部分11000000 00001001 11001000 00001101 AND 11111111 11111111 11111111 00000000 11000000 00001001 11001000 00000000结果为192.9.200.0， 即网络号为192.9.200.0。 
将子网掩码取反再与IP地址逻辑与（AND）后得到的结果即为主机部分11000000 00001001 11001000 00001101 AND 00000000 00000000 00000000 11111111 00000000 00000000 00000000 00001101 结果为0.0.0.13，即主机号为13。 

三、子网划分与实例根据以上分析，建议按以下步骤和实例定义子网掩码。 

将要划分的子网数目转换为2的m次方。如要分8个子网，8=23。 
取上述要划分子网数的2的m次方的幂。如23，即m=3。 
将上一步确定的幂m按高序占用主机地址m位后转换为十进制。如m为3 则是11100000，转换为十进制为224，即为最终确定的子网掩码。如果是C类网，则子网掩码为255.255.255.224；如果是B类网，则子网掩码为255.255.224.0；如果是C类网，则子网掩码为255.224.0.0。 在这里，子网个数与占用主机地址位数有如下等式成立：2m=n。其中，m表示 占用主机地址的位数；n表示划分的子网个数。根据这些原则，将一个C类网络分成4个子网。若我们用的网络号为192.9.200，则该C类网内的主机IP地址就是 192.9.200.1～192.9.200.254（因为全“0”和全“1”的主机地址有特殊含义， 不作为有效的IP地址），现将网络划分为4个部分，按照以上步骤： 4=22，取22的幂，即2，则二进制为11，占用主机地址的高序位即为11000000 ，转换为十进制为192。这样就可确定该子网掩码为：192.9.200.192，4个子网的 IP地址范围分别为： 
二进制十进制 

① 11000000 00001001 11001000 00000001 11000000 00001001 11001000 00111110 
192.9.200.1 
192.9.200.62 
② 11000000 00001001 11001000 01000001 11000000 00001001 11001000 01111110 
192.9.200.65 
192.9.200.126 
③ 11000000 00001001 11001000 10000001 11000000 00001001 11001000 10111110 
192.9.200.129 
192.9.200.190 
④ 11000000 00001001 11001000 11000001 11000000 00001001 11001000 
11111110 192.9.200.193 
192.9.200.254 
　　在此列出A、B、C三类网络子网数目与子网掩码的转换表，以供参考。 
A类： 

子网数目 占用位数　　　　子网掩码　　　　子网中主机数 
　2　　　　　1　　　　255.128.0.0　　　　8,388,606 
　4　　　　　2　　　　255.192.0.0　　　　4,194,302 
　8　　　　　3　　　　255.224.0.0　　　　2,097,150 
　16　　　　 4　　　　255.240.0.0　　　　1,048,574 
　32　　　　 5　　　　255.248.0.0　　　　524,286 
　64　　　　 6　　　　255.252.0.0　　　　262,142 
　128　　　　7　　　　255.254.0.0　　　　131,070 
　128　　　　8　　　　255.255.0.0　　　　65,534 

B类： 

子网数目 占用位数　　　　子网掩码　　　　子网中主机数 
　2　　　　　1　　　　255.255.128.0　　　32,766 
　4　　　　　2　　　　255.255.192.0　　　16,382 
　8　　　　　3　　　　255.255.224.0　　　8,190 
　16　　　　 4　　　　255.255.240.0　　　4,094 
　32　　　　 5　　　　255.255.248.0　　　2,046 
　64　　　　 6　　　　255.255.252.0　　　1,022 
　128　　　　7　　　　255.255.254.0　　　510 
　256　　　　8　　　　255.255.255.0　　　254 

C类： 

子网数目 占用位数　　　　子网掩码　　　　子网中主机数 
　2　　　　　1　　　　255.255.255.128　　　126 
　4　　　　　2　　　　255.255.255.192　　　62 
　8　　　　　3　　　　255.255.255.224　　　30 
　16　　　　 4　　　　255.255.255.240　　　14 
　32　　　　 5　　　　255.255.255.248　　　6 
　64　　　　 6　　　　255.255.255.252　　　2

四、快速计算子网掩码的方法
     最后介绍三种快速计算机子网掩码的方法。
     1. 利用子网数来计算
     在求子网掩码之前必须先搞清楚要划分的子网数目，以及每个子网内的所需主机数目。然后按以下基本步骤进行计算：
     第1步，将子网数目转化为二进制来表示；
     第2步，取得子网数二进制的位数（n）；
     第3步，取得该IP地址类的子网掩码，然后将其主机地址部分的的前n位置“1”，即得出该IP地址划分子网的子网掩码。
     为了便于理解，现举例说明如下：现假如要将一B类IP地址168.195.0.0划分成27个子网，则它的子网掩码的计算机方法如下（对应以上各基本步骤）：
     第1步，首先要划分成27个子网，“27”的二进制为“11011”；
     第2步，该子网数二进制为五位数，即n = 5；
     第3步，将该B类地址的子网掩码255.255.0.0的主机号前5位全部置“1”，即可得到 255.255.248.0，这就是划分成 27个子网的B类IP地址 168.195.0.0的子网掩码。
     2. 利用主机数来计算
     利用主机数来计算子网掩码的方法与上类似，基本步骤如下：
     第1步，将子网中需容纳的主机数转化为二进制；
     第2步，如果主机数小于或等于254（因为要去掉保留的两个IP地址），则取得该主机的二进制位数，为n，这里肯定 n<8。如果大于254，则 n>8，这就是说主机地址将占据不止8位。
     第3步，将255.255.255.255的主机地址位数全部置1，然后从后向前的将n位全部置为 0，即为子网掩码值。
     举例如下。如要将一B类IP地址为168.195.0.0的网络划分成若干子网，要求每个子网内有主机数为700台，则该子网掩码的计算方法如下（也是对应以上各基本步骤）：
     第1步，首先将子网中要求容纳的主机数“700”转换成二进制，得到1010111100。
     第2步，计算出该二进制的位数为10位，即n = 10
     第3步，将255.255.255.255从后向前的10位全部置“0”,得到的二进制数为“11111111.11111111.11111100.00000000”，转换成十进制后即为255.255.252.0，这就是该要划分成主机数为700的B类IP地址 168.195.0.0的子网掩码。
     3. 子网ID增量计算法
     其基本计算步骤如下：
     第1步，将所需的子网数转换为二进制，如所需划分的子网数为“4”，则转换成成二进制为00000100； 
     第2步，取子网数的二进制中有效位数，即为向缺省子网掩码中加入的位数（既向主机ID中借用的位数）。如前面的00000100，有效位为“100”，为3位；
     第3步，决定子网掩码。如IP地址为B类1129.20.0.0网络，则缺省子网掩码为：255.255.0.0，借用主机ID的3位以后变为：255.255.224（11100000）0，即将所借的位全表示为1，用作子网掩码。 
     第4步，将所借位的主机ID的起始位段最右边的“1”转换为十进制，即为每个子网ID之间的增量，如前面的借位的主机ID起始位段为“11100000”，最右边的“1”，转换成十进制后为25=32。 
     第5步，产生的子网ID数为：2m-2 （m为向缺省子网掩码中加入的位数），如本例向子网掩码中添加的位数为3，则可用子网ID数为：23-2=6个； 
     第6步，将上面产生的子网ID增量附在原网络ID之后的第一个位段，便形成第一个子网网络ID 129.20.32.0； 
     第7步，重复上步操作，在原子网ID基础上加上一个子网ID增量，依次类推，直到子网ID中的最后位段为缺省子网掩码位用主机ID位之后的最后一个位段值，这样就可得到所有的子网网络ID。如缺省子网掩码位用主机ID位之后的子网ID为255.255.224.0，其中的“224”为借用主机ID后子网ID的最后一位段值，所以当子网ID通过以上增加增量的方法得到129.20.224.0时便终止，不要再添加了

清华大学出版社出版的《window2000 server 网络系统与服务》提供以下的操作步骤:
在一个B类的网络中，其网络ID为140.116,而我们需要将其分割成6个子网络.步骤如下:
1.先把6换算成二进制的数字.6的二进制为110,再加以排列组合.所以我们有000、001、100、011、101、110、111.IP地址不可以全部为0或者全部为1，所以只剩下001、010、011、100、101、110；
2.把上步骤所得的二制数字转换成十进制：
00100000=32
01000000=64
01100000=96
10000000=128
10100000=160
11000000=192
3.上步骤所得的号码就是我们分割子网络的范围，一共有6个区段：
140.116.32.0
140.116.64.0
140.116.96.0
140.116.128.0
140.116.160.0
140.116.192.0
4.而该子网掩码就是11100000=224，这是因为有6个子网络，所以把6转换成二进制并且全部把数字变成1后再补上0至8位数，所以就是11100000了.所以分成6个子网张时，子网掩码就变成255.255.224.0.
而每一段的范围如下表：
140.116.32.0 140.116.32.1~140.116.63.254
140.116.64.0 140.116.64.1~140.116.95.254
140.116.96.0 140.116.96.1~140.116.127.254
140.116.128.0 140.116.128.1~140.116.159.254
140.116.160.0 140.116.160.1~140.116.191.254
140.116.192.0 140.116.192.1~140.116.223.254

 

 

 

--------------------------------------------------------------------------------
 
1. A Beginners Hello World   初学者
public class HelloWorld
{
  public static void Main()
  {
    System.Console.WriteLine("HELLO WORLD");
  }
}

2. Slightly improved version   略有提高
using System;  （就这？会用命名空间？）

public class HelloWorld
{
  public static void Main()
  {
    Console.WriteLine("HELLO WORLD");
  }
}

3. Command Line Arguments
using System;

public class HelloWorld
{
  public static void Main(string[] args)   //会传参数了
  {
    Console.WriteLine(args[0]);
  }
}

4. From Constructor
using System;
public class HelloWorld
{
  public HelloWorld()
  {
    Console.WriteLine("HELLO WORLD");
  }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();  //会用类了？构造？
  }
}

5. More OO
using System;
public class HelloWorld
{
  public void helloWorld()
  {
    Console.WriteLine("HELLO WORLD");
  }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();
    hw.HelloWorld();   //更进一步的面向对象？会用方法了？
  }
}

6. From another class
using System;
public class HelloWorld
{
  public static void Main()
  {
    HelloWorldHelperClass hwh = new HelloWorldHelperClass();   //类里调用其它类？
    hwh.writeHelloWorld();
  }
}

public class HelloWorldHelperClass
{
  public void writeHelloWorld()
  {
    Console.WriteLine("Hello World");
  }
}

7. Inheritance
abstract class HelloWorldBase  //抽象类
{
  public abstract void writeHelloWorld();
}
class HelloWorld : HelloWorldBase  //继承----不得不严肃起来了，能抽象的已经可以做系统架构设计了！
{
  public override void writeHelloWorld()
  {
    Console.WriteLine("Hello World");
  }
}
class HelloWorldImp
{
  static void Main() {
    HelloWorldBase hwb = HelloWorld;
    HelloWorldBase.writeHelloWorld();
  }
}

8. Static Constructor
using System;
public class HelloWorld
{
  private static string strHelloWorld;

  static HelloWorld()    //静态构造
  {
    strHelloWorld = "Hello World";
  }
  void writeHelloWorld()
  {
    Console.WriteLine(strHelloWorld);    }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();   //需要吗？
    hw.writeHelloWorld();   //居然写得这么啰嗦

  }
}


9. Exception Handling
using System;

public class HelloWorld
{
  public static void Main(string[] args)
  {
    try
    {
      Console.WriteLine(args[0]);
    }
    catch(IndexOutOfRangeException e)   //会用异常处理了,但如何更好回收资源呢？异常接下来应该是资源回收啊？
    {
      Console.WriteLine(e.ToString());
    }
  }
}

10. Creating a DLL and using it in an application   //做组件吗？
using System;

namespace HelloLibrary
{
  public class HelloMessage
  {
    public string Message
    {
      get
      {
        return "Hello, World!!!";
      }
    }
  }
}

//------

using System;
using HelloLibrary;

namespace HelloApplication
{
  class HelloApp
  {

    public static void Main(string[] args)
    {
      HelloMessage m = new HelloMessage();

    }
  }
}

11. Using Property  
using System;
public class HelloWorld
{
  public string strHelloWorld
  {
    get   //会用属性了
    {
      return "Hello World";
    }
  }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();
    Console.WriteLine(cs.strHelloWorld);
  }
}

12. Using Delegates    //委托！
using System;
class HelloWorld
{
  static void writeHelloWorld() {
    Console.WriteLine("HelloWorld");
  }
  static void Main() {
    SimpleDelegate d = new SimpleDelegate(writeHelloWorld);  //委托？！？！
    d();   //语法的确这么写，但含义无法理解;因为实在体会不出好处来
  }
}

13. Using Attributes    //啥子东西
#define DEBUGGING

using System;
using System.Diagnostics;

public class HelloWorld : Attribute
{
  [Conditional("DEBUGGING")]

  public void writeHelloWorld()
  {
    Console.WriteLine("Hello World");
  }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();

    hw.writeHelloWorld();
  }
}

14. Using Interfaces   //会用接口了
using System;

interface IHelloWorld
{
  void writeHelloWorld();
}

public class HelloWorld : IHelloWorld
{
  public void writeHelloWorld()
  {
    Console.WriteLine("Hello World");
  }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();

    hw.writeHelloWorld();
  }
}

15. Dynamic Hello World  //啥子东西
using System;
using System.Reflection;

namespace HelloWorldNS
{

  public class HelloWorld
  {
    public string writeHelloWorld()
    {
      return "HelloWorld";
    }

    public static void Main(string[] args)
    {
      Type hw = Type.GetType(args[0]);

      // Instantiating a class dynamically

      object[] nctorParams = new object[] {};
      object nobj = Activator.CreateInstance(hw,
               nctorParams);

      // Invoking a method

      object[] nmthdParams = new object[] {};
      string strHelloWorld = (string) hw.InvokeMember(
              "writeHelloWorld", BindingFlags.Default |
              BindingFlags.InvokeMethod, null,
              nobj, nmthdParams);

      Console.WriteLine(strHelloWorld);
    }
  }
}

16. Unsafe Hello World   //不是很理解怎么Unsafe!
using System;

public class HelloWorld
{
  unsafe public void writeHelloWorld(char[] chrArray)
  {
    fixed(char *parr = chrArray)
    {
      char *pch = parr;
      for(int i=0; i<chrArray.Length; i++)
        Console.Write(*(pch+i));
    }
  }

  public static void Main()
  {
    HelloWorld hw = new HelloWorld();
    char[] chrHelloWorld = new char[]
        {'H','e','l','l','o', ' ', 'W','o','r','l','d'};
    hw.writeHelloWorld(chrHelloWorld);
  }
}

17. Using InteropServices
using System;
using System.Runtime.InteropServices;

class Class1
{  //COM ,  API接口  

  [DllImport("kernel32")]
  private static extern int Beep(int dwFreq, int dwDuration);

  static void Main(string[] args)
  {
    Console.WriteLine("Hello World");
    Beep(1000, 2000);
  }
}

文件状态： [√] 草稿 [  ] 正式发布 [  ] 正在修改	文件标识：
	当前版本：	1.0
	作    者：	FANTASY
	完成日期：	2007-3-12

版本/状态	作者	参与者	起止日期	备注
1.0/草稿	FANTASY		2007-3-12
1.1/草稿	FANTASY		2007-3-15	增加第二台机器的配置内容

 

 

1 环境准备
1.1 安装jdk-1_5_0_11-linux-i586-rpm.bin
以下操作以root帐号执行
1）首先确保有执行该文件的权限
chmod 755 jdk-1_5_0_11-linux-i586-rpm.bin

2）./jdk-1_5_0_04-linux-i586-rpm.bin
   会出现协议书类的一直回车直到显示
   Do you agree to the above license terms? [yes or no]
   输入y,会自动安装在/usr/java/j2sdk1.5.0_11目录下
1.2 安装apache-ant-1.7.0-bin.tar.gz
以下命令以root帐号执行
1） 将该文件拷到/usr/local并更改目录到/usr/local
cp apache-ant-1.7.0-bin.tar.gz /usr/local
cd /usr/local
2） 安装，解压到/usr/local下
tar -xzvf apache-ant-1.7.0-bin.tar.gz
1.3 统一设置环境变量
vi /etc/profile
在最后添加下面的内容
export ANT_HOME=/usr/local/apache-ant-1.7.0
export JAVA_HOME=/usr/java/j2sdk1.5.0_11
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=.:$PATH:$JAVA_HOME/bin:$ANT_HOME/bin
export GLOBUS_LOCATION=/usr/local/globus-4.0.4
export LD_LIBRARY_PATH=$GLOBUS_LOCATION/lib
输入:wq保存退出后执行

2 安装及配置GridFtp
2.1 安装GridFtp
# mkdir /usr/local/globus-4.0.4
# chown globus:globus /usr/local/globus-4.0.4
# cd gt4.0.4-x86_rhas_3-installer
# su globus
globus$ export ANT_HOME=/usr/local/apache-ant-1.6.5
globus$ export JAVA_HOME=/usr/java/j2sdk1.5.0_11/
globus$ export GLOBUS_LOCATION=/usr/local/globus-4.0.4
globus$ ./configure --prefix=$GLOBUS_LOCATION
globus$ make gridftp
globus$ make gridftp 2>&1 | tee build.log
globus$ make gridftp install
2.2安装simpleCA和使用
2.2.1初始化globus的使用环境
globus$ export GLOBUS_LOCATION=/usr/local/globus-4.0.4
globus$ source $GLOBUS_LOCATION/etc/globus-user-env.sh
2.2.2安装simgleCA
globus$ $GLOBUS_LOCATION/setup/globus/setup-simple-ca
globus$ ls ~/.globus/
simpleCA
globus$ ls ~/.globus/simpleCA/
cacert.pem  globus_simple_ca_ebb88ce5_setup-0.18.tar.gz  newcerts
certs       grid-ca-ssl.conf                             private
crl         index.txt                                    serial
2.2.3安装GSI
root# export GLOBUS_LOCATION=/usr/local/globus-4.0.4
root# $GLOBUS_LOCATION/setup/globus_simple_ca_ebb88ce5_setup/setup-gsi –default
root# ls /etc/grid-security/
certificates  globus-host-ssl.conf  globus-user-ssl.conf  grid-security.conf
root# ls /etc/grid-security/certificates/
ebb88ce5.0                     globus-user-ssl.conf.ebb88ce5
ebb88ce5.signing_policy        grid-security.conf.ebb88ce5
globus-host-ssl.conf.ebb88ce5
2.2.4主机证书的生成和签发
root# source $GLOBUS_LOCATION/etc/globus-user-env.sh
root# grid-cert-request -host `hostname`
globus$ grid-ca-sign -in /etc/grid-security/hostcert_request.pem -out hostsigned.pem
To sign the request
please enter the password for the CA key:******
The new signed certificate is at: /home/globus/.globus/simpleCA//newcerts/01.pem
root# cp ~globus/hostsigned.pem /etc/grid-security/hostcert.pem
2.2.5用户证书的生成和签发
用户证书生成和签发用户证书的生成和签发过程与主机证书类似. 只是生成的时候用相应的用户运行 grid-cert-request 命令, 不加-host 选项.
fantasy$ export GLOBUS_LOCATION=/usr/local/globus-4.0.4/
fantasy$ export PATH=$GLOBUS_LOCATION/bin:$PATH
fantasy$ grid-cert-request
globus$ grid-ca-sign -in usercert_request.pem  -out usersigned.pem
fantasy$ grid-proxy-init -debug -verify
2.2.6 配置grid-mapfile文件
root# vim /etc/grid-security/grid-mapfile
root# cat /etc/grid-security/grid-mapfile
"/O=Grid/OU=GlobusTest/OU=simpleCA-director/CN=host/director" root
2.2.7 配置 /etc/xinetd.d/gridftp
root# vim /etc/xinetd.d/gridftp
root# cat /etc/xinetd.d/gridftp
service gsiftp
{
instances              = 100
socket_type    = stream
wait      = no
user      = root
 protocol     = tcp
env                  += GLOBUS_LOCATION=/usr/local/globus-4.0.4
env                  += LD_LIBRARY_PATH=/usr/local/globus-4.0.4/lib
server     = /usr/local/globus-4.0.4/sbin/globus-gridftp-server
server_args    = -p 2811
disable                 = no
}
2.2.8 配置 /etc/services
root # vim /etc/services
root # tail /etc/services
vboxd           20012/udp
binkp           24554/tcp                       # binkp fidonet protocol
asp             27374/tcp                       # Address Search Protocol
asp             27374/udp
dircproxy       57000/tcp                       # Detachable IRC Proxy
tfido           60177/tcp                       # fidonet EMSI over telnet
fido            60179/tcp                       # fidonet EMSI over TCP

# Local services
gsiftp          2811/tcp

root# /etc/init.d/xinetd reload
Reloading internet superserver configuration: xinetd.

另外可能出现在使用globus-url-copy的实话, 找不到对应的动态链接库的问题. 解决:编辑/etc/ld.so.conf, 然后更新缓存
root# vi /etc/ld.so.conf
root# cat /etc/ld.so.conf
/usr/kerberos/lib
/usr/X11R6/lib
/usr/lib/sane
/usr/lib/qt-3.1/lib
/usr/local/globus-4.0.1/lib #这个是后来加入的.
[root@CGSP45 root]# ldconfig -v -v –v
2.3启动gridftp-server
root# globus-gridftp-server -S -p 2811

root# /etc/grid-security# netstat -npl | grep 2811
tcp       0      0 0.0.0.0:2811     0.0.0.0:*  LISTEN    4982/globus-gridftp 

root# globus-url-copy -vb -dbg gsiftp://director/etc/hosts file:///usr/host-copy
将/etc/hosts 拷贝为 /usr/host-copy文件

3 安装配置第二台机
首先需要明确的是，安装GT时，就已经安装Simple CA软件了。
linux环境下，建立共用一个CA的多机环境步骤：

1）在每台机器都安装GT

2） 在CA中心机器运行$GLOBUS_LOCATION/setup/globus/setup-simple-ca命令建立CA中心，并创建分发包:
globus_simple_ca_Hashcode_setup-0.17.tar.gz。
以root运行#GLOBUS_LOCATION/setup/globus_simple_ca_Hashcode_setup/setup-gsi -default；

3） 其他机器以globus用户安装分发包：
$gpt-build globus_simple_ca_Hashcode_setup-0.17.tar.gz
$gpt-postinstall
以root申请主机证书，以普通用户申请用户证书；
将hostcert_request.pem，usercert_request.pem 两个文件拷到CA中心机器
以CA中心机器上的globus用户为证书签名；在/etc/grid-security/grid-mapfile中加入授权用户。

4） 多机环境中grid-mapfile的设置：
例：HostA上的user1用户调用HostB上的服务，授权方式采用HostAuthorization，需要在HostB的grid-mapfile中加入HostA user1的授权信息。

 

 

          
编译内核