博客园_haoxiaobo

关于中文编程的段子的一个实现

2012-02-06T07:03:00Z

网上这几天正在疯传一段用C#进行中文编程的段子，说一个程序员就职后，发现公司的大哥里把C#用中文进行了包装，不光是类，还有关键字也进行了中文化，正在苦恼是不是要继续在这个公司干下去。

这位大哥这种精神是否可嘉还真不好评价。对于没有意义的事情执着追求，是可嘉呢还是不可嘉，估计还是要看评论的人是谁。不过，人家自己的执着，别人也确实无资格评价。

还有所谓“意义”，恐怕也是因人而定义的。一个东西，对于为之付出了精力的人来说是有意义的，而对于其他人来说，即然与之没有交集，也就无资格置评。对于文中的小哥来说，喜欢的就留下搞搞明白，不喜欢的就走人吧。

只是这段中文化的代码，很有意思，上午试着用C#的lamda实现了一下，就所看到的代码而言，基本算是都实现了，现在我也可以用中文编程了。

下面是中文编程的示例，基本与网上那个段子差不多。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 中文编程
{
    class Program
    {
        static void Main(string[] args)
        {
            // 逻辑判断演示....
            判断.如果是(判断.真).则(() =>
            {
                Console.WriteLine("是");
            }).否则(() =>
            {
                Console.WriteLine("否");
            });
            // 遍历器演示.....
            登陆信息[] 所有登录信息 = new 登陆信息[100];
            // ....

            遍历器.计数遍历().从(0).到(99).每隔(1).执行((当前索引行) =>
            {
                所有登录信息[当前索引行] = new 登陆信息() { 姓名 = "姓名 " + 当前索引行.ToString() };
            });

            遍历器.枚举遍历<登陆信息>(所有登录信息).从(0).到(99).每隔(3).执行((当前索引行, 登录信息项) =>
            {
                Console.WriteLine(登录信息项);
            });

            数据库连接类数据连接对象 = null;
            //异常处理........
            异常.对下列语句进行异常检测(() =>
            {
                数据连接对象 = 数据库连接类.连接到("10.1.138.35").用户名为("xxx").密码为("xxx");
                数据连接对象.打开连接();

                //...
                throw new Exception("测试异常");

            })
            .发现异常则((异常对象) =>
            {
                //...
                Console.WriteLine(异常对象);
            })
            .最终执行(() => {
                // ...
                数据连接对象.关闭连接();

            });
        }
    }

    public class 登陆信息
    {
        public string 姓名;
        public override string ToString()
        {
            return "姓名" + 姓名;
        }
    }

}

关键字的包装：-----------------------------------------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 中文编程
{
    public class 判断
    {
        public const bool 真 = true;
        public const bool 假 = false;

        bool _b;

        public static 判断如果是(bool 条件)
        {
            return new 判断(){_b = 条件};
        }

        public 判断则(Action act)
        {
            if (_b)
            {
                act();
            }
            return this;
        }

        public 判断否则(Action act)
        {
            if (!_b)
            {
                act();
            }
            return this;
        }
    }

    public class 遍历器
    {
        public static 枚举遍历器<T> 枚举遍历<T>(IEnumerable<T> 枚举集合)
        {
            return new 枚举遍历器<T>(枚举集合);
        }

        public static 计数遍历器计数遍历()
        {
            return new 计数遍历器() { };
        }
    }

    public class 枚举遍历器<T>
    {
        protected IEnumerable<T> _set;
        protected int _iStartIndex;
        protected int _iEndIndex;
        protected int _Step;

        public 枚举遍历器(IEnumerable<T> 枚举集合)
        {
            this._set = 枚举集合;
        }

        public 枚举遍历器<T> 从(int 开始元素序号)
        {
            this._iStartIndex = 开始元素序号;
            return this;
        }

        public 枚举遍历器<T> 到(int 结束元素序号)
        {
            this._iEndIndex = 结束元素序号;
            return this;
        }

        public 枚举遍历器<T> 每隔(int 每隔步长)
        {
            this._Step = 每隔步长;
            return this;
        }

        public void 执行(Action<int, T> 循环体方法)
        {
            int i = 0;
            foreach (var e in _set)
            {
                if (i >= this._iStartIndex && i <= this._iEndIndex)
                {
                    if ((i - this._iStartIndex) % this._Step == 0)
                    {
                        循环体方法(i, e);
                    }
                }
                i++;

            }
        }
    }


    public class 计数遍历器
    {
        protected int _iStartIndex;
        protected int _iEndIndex;
        protected int _Step;

        public 计数遍历器从(int 开始元素序号)
        {
            this._iStartIndex = 开始元素序号;
            return this;
        }

        public 计数遍历器到(int 结束元素序号)
        {
            this._iEndIndex = 结束元素序号;
            return this;
        }

        public 计数遍历器每隔(int 每隔步长)
        {
            this._Step = 每隔步长;
            return this;
        }

        public void 执行(Action<int> 循环体方法)
        {
            for (int i = this._iStartIndex; i <= this._iEndIndex; i += this._Step)
            {
                循环体方法(i);
            }
        }
    }

    public class 异常
    {
        Exception _ex = null;

        public static 异常对下列语句进行异常检测(Action 正常执行程序)
        {
            try
            {
                正常执行程序();
                return new 异常() { _ex = null};
            }
            catch (Exception ex)
            {
                return new 异常() { _ex = ex};
            }

        }

        public 异常发现异常则(Action<Exception> 异常处理程序)
        {
            if (this._ex != null)
            {
                异常处理程序(this._ex);
            }
            return this;
        }

        public 异常最终执行(Action 最终处理程序)
        {
            最终处理程序();
            return this;
        }
    }

}

数据库连接的包装：

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;

namespace 中文编程
{
    public class 数据库连接类
    {
        private string _sServer;
        private string _sUID;
        private string _sPassword;
        private string _sDBName;
        SqlConnection _sqlconn = null;

        public static 数据库连接类连接到(string 服务器名)
        {
            return new 数据库连接类() { _sServer = 服务器名 };
        }

        public 数据库连接类用户名为(string 用户名)
        {
            _sUID = 用户名;
            return this;
        }

        public 数据库连接类密码为(string 密码)
        {
            _sPassword = 密码;
            return this;
        }

        public 数据库连接类数据库为(string 数据库名)
        {
            _sDBName = 数据库名;
            return this;
        }

        public void 打开连接()
        {
            this._sqlconn = new SqlConnection(string.Format("Data Source={0};Initial Catalog={1};User ID={2};Password={3}", this._sServer, this._sDBName, this._sUID, this._sPassword));
            this._sqlconn.Open();
        }

        public void 关闭连接()
        {
            this._sqlconn.Close();
        }

    }
}

说实话，感觉很奇怪。

本文链接

VC非托管代码调用webservice，并支持代理服务器设置

2012-01-09T14:49:00Z

这是这几天里我同时解决的另一个问题。

我用的是VC2003，在非托菅的本机代码中调用webservice时，很有一些令人糊涂的地方，在这里记下来，以后也方便自己回忆。

方法：

1.增加webservice引用。

2.自动生成代理类。

上面简单。但当看着所生成的代理类时，多年没碰过VC代码的我哭了……VC的代理类是下面这样的：

template <typename TClient = CSoapSocketClientT<> >

class CWebService1T :

public TClient,

public CSoapRootHandler

{

。。。

}

模板套模板。。。

嘛意思？

意思是：代理类在实例化时，要指定一个网络客户端工具类。默认这个类是CSoapSocketClientT<>, 这也是一个模板类。

template <typename TSocketClass = ZEvtSyncSocket>

class CSoapSocketClientT

{ 。。。}

看，默认的默认类是ZEvtSyncSocket，这是个啥类我实在没有心情去研究，看名字是一个Sock通讯类。不要不要！

那么调用webservice方法仲么办? 要这样：

CWebService1T<CSoapWininetClient> proxy = new CWebService1T<CSoapWininetClient>;

proxy->SetUrl("http://xxx.com/Webservice1.asmx");

proxy->HelloWork();

这里我没有用VC神经乎乎地推荐的那个 CSoapSocketClientT<ZEvtSyncSocket>, 而是用了CSoapWininetClient类做为工具类（atlsoap.h)。

注意上面的代码，有一个SetUrl的方法调用，这个方法你一定在代理类中找不到，但是编译运行又都正常。奇怪不？

请您这时候再回去注意一下CWebService1T的定义，CSoapWininetClient被置换为TClient泛型参数，而TClient又被放在了类定义的冒号后面，啥意思？

就是说你代入的这个模板参数类型将是代理类的父类呀！简直把人绕晕了！

也就是说，我写CWebService1T<CSoapWininetClient> proxy 时，CSoapWininetClient将是CWebService1T<>的基类！CSoapWininetClient有SetUrl, SetProxy等方法，所以proxy 也就可以调用这些方法了。

因为 CSoapWininetClient是用了Wininet.dll库的api进行通信的，这个库的特点就是支持http，而且和ie的设置是相通的，因此，用了这个工具类，你的proxy对象就可以透过代理服务器调用webserivce了。

一切问题都解决了？没有。

我这两天遇上了几个做难死人的问题——一个客户的网络需要用代理服务器上网，而且是需要输入口令的。

本来这个问题也不是问题，只要ie能上网，在代理服务器要口令时，输入口令并选一下保存密码的复选框，这个用户凭据就会记录在系统中， CSoapWininetClient就可以自动取用, 很多客户的网络环境都是这样的，我们的客户端程序运行得很好。

但是不幸的是，这个客户的机器被设置了策略，就算是在ie里选了保存密码的复选框，密码也不能保存下来，每次打开ie时，都需要重新输入口令。

既然系统里没有用户凭据，CSoapWininetClient也就没有办法从ie得到用户名与口令。

我研究了CSoapWininetClient这个类，可恨的是这个类没有任何事件、callback、委托等扩展渠道让我在合适地地方切进去，设置那些代理啦、用户名啦口令啦什么的。在代理类调用hellowork时，就调用CSoapWininetClient的第一个方法就是SendRequest方法，在这个方法里，它打开对话，建立连接，Post数据、得到回应的流，一气呵成了！中间没有用户的机会加入代码。

我发愁了老半天，决定从 CSoapWininetClient派生一个子类来用，想试试能不能通过重载一下某些方法来介入自己的代码。这叫什么模式来着？装饰类?

结果发现这个类里很多粉重要的方法、成员都是private的，没法引用。

真没有办法了？我暴怒了！我和他拼了！我把 CSoapWininetClient类的源代码全拷贝出来，在项目里建了一个新类，叫CFuckedSoapWininetClient, 然后把CSoapWininetClient类的所有内容都复制了进去，现在，你是我的啦！哇哈哈！

再把调用Webservice的代码改一下，把参数类名改为Fuck过的新类。

CWebService1T<CFuckedSoapWininetClient> proxy = new CWebService1T<CFuckedSoapWininetClient>;

proxy->SetUrl("http://xxx.com/Webservice1.asmx");

proxy->HelloWork();

编译，通过。运行，通过！

现在，通信类是我的了，任我哪啥了！想加代理服务器支持，那是易如翻掌了。

有关代理服务器支持功能的实现，请参考另一篇文章 http://www.cnblogs.com/haoxiaobo/archive/2012/01/09/2317559.html。

本文链接

天哪，我遇上了一个windows api BUG! 并贡献一个完全支持代理服务器的http文件下载VC代码

2012-01-09T14:04:00Z

好吧，我遇上了windows api的bug...

一开始程序是采用了CInternetSession来打开一个Session，然后再用OpenUrl来打开一个CHttpFile文件. 这个程序一直工作得很好，只要ie能上网，它就能下载。如果用代理服务器，只需要在ie中设置好即可。如果代理服务器需要口令，只需要先在ie中访问页面，输入口令，并选择保存口令，这个程序就也能正常透过代理连接了。

直到有一天，它被安装在了一台ie6的windows xp机器上，它不能工作了。

因为 CInternetSession::OpenUrl方法调用了InternetOperUrl api函数，而InternetOperUrl函数，有个BUG.

InternetOperUrl在IE6的环境下，除非代理服务器的用户名与口令与当前用户的用户名与口令一致，否则他不能透过代理服务器连接http文件。

为什么我知道这是个BUG? 因为安装了ie8之后， InternetOperUrl就能正常工作了——只要在ie通过代理上网时，输入代理服务器口令时选择一下“保存我的口令”，InternetOperUrl就也能正常连接了。

在ie6下， InternetOperUrl的似乎是总是用当前登录电脑的用户名与口令向代理服务器验证。这明显是一个错误。后来他们修好了。

这个问题让我折腾了三天，安装了n台不同版本的windows和ie环境，测试了各种各样的程序，我都几乎准备要动用我的msdn技术支持时, 终于确认了问题原因。

知道了原因就好办了。只需要绕开mfc的这个问题，直接用几个底层api就可以正常工作了。下面是可以正常工作的代码，一共支持三种不同的代理服务器设置：0 用ie的设置（包括ie保存了的密码），1，坚决不用代理，一定要直连。2，用本程序指定的代理。

iProxyMode 、bProxyNeedPassword、proxyinfo、sProxyUserName、sProxyPassword等是全局变量，你可以在调用这个函数之前准备好这些变量。

BOOL GetHttpFile(LPCTSTR psUrl, LPCTSTR psLocalFile, CString &sErrMg)

{
    BOOL b;
    BOOL bOK = TRUE;
    DWORD dwServiceType;
    CString strServer;
    CString strObject;
    INTERNET_PORT nPort;

    BOOL bParsed = AfxParseURL(psUrl, dwServiceType, strServer, strObject, nPort);
    if (!bParsed)
    {
        sErrMg = "远程文件地址格式不对！";
        return FALSE;
    }

    HINTERNET m_hInternet = InternetOpen(
        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; InfoPath.1)",
        INTERNET_OPEN_TYPE_PRECONFIG,
        NULL,
        NULL, 0);

    if (FALSE == m_hInternet)
    {
        InternetCloseHandle(m_hInternet);
        sErrMg.Format("建立网络会话 %s 失败", psUrl);
        return FALSE;
    }

    if (iProxyMode != 0)
    {
        b = InternetSetOption (NULL, INTERNET_OPTION_PROXY, (LPVOID) &proxyinfo, sizeof (proxyinfo));
    }

    HINTERNET m_hConnection = InternetConnect(
        m_hInternet,
        strServer,
        nPort,
        NULL,
        NULL,
        INTERNET_SERVICE_HTTP,
        INTERNET_FLAG_NO_UI,
        NULL);

    if (FALSE == m_hConnection)
    {
        InternetCloseHandle(m_hConnection);
        InternetCloseHandle(m_hInternet);
        sErrMg.Format("建立网络连接 %s 失败", psUrl);
        return FALSE;
    }

    if (iProxyMode == 2 && bProxyNeedPassword)
    {
        DWORD dwUserNameLen = sProxyUserName.GetLength() + 1;
        DWORD dwUserPassLen = sProxyPassword.GetLength() + 1;

        b = InternetSetOption (m_hConnection, INTERNET_OPTION_PROXY_USERNAME, (LPVOID)(LPCTSTR)sProxyUserName, dwUserNameLen);
        b = InternetSetOption (m_hConnection, INTERNET_OPTION_PROXY_PASSWORD, (LPVOID)(LPCTSTR)sProxyPassword, dwUserPassLen);
    }

    static LPCTSTR s_szAcceptTypes[] = { _T("*/*"), NULL };

    HINTERNET m_hRequest = HttpOpenRequest(
        m_hConnection, _T("GET"),
        strObject,
        _T("HTTP/1.0"), NULL,
        s_szAcceptTypes,
        INTERNET_FLAG_NO_UI | INTERNET_FLAG_KEEP_CONNECTION, // | ((m_url.GetScheme() == ATL_URL_SCHEME_HTTPS) ? INTERNET_FLAG_SECURE : 0)
        NULL);
    if (FALSE == m_hRequest)
    {
        InternetCloseHandle(m_hRequest);
        InternetCloseHandle(m_hConnection);
        InternetCloseHandle(m_hInternet);
        sErrMg.Format("打开网络连接 %s 失败", psUrl);
        return FALSE;
    }

    CString strHeaders;
    //strHeaders.Append(_T("Content-Type: text/xml; charset=utf-8\r\n"));

    b = HttpSendRequest(m_hRequest, strHeaders, (DWORD) strHeaders.GetLength(),
        NULL, 0);

    if (FALSE == b)
    {
        InternetCloseHandle(m_hRequest);
        InternetCloseHandle(m_hConnection);
        InternetCloseHandle(m_hInternet);
        sErrMg.Format("向服务器发送请求 %s 失败", psUrl);
        return FALSE;
    }

    int iStatus = GetInternetRequestStatusCode(m_hRequest);

    if(!(iStatus>= 200&& iStatus<300 ))
    {
        InternetCloseHandle(m_hRequest);
        InternetCloseHandle(m_hConnection);
        InternetCloseHandle(m_hInternet);
        sErrMg.Format("打开远程文件出错，错误码：%d", iStatus);
        return FALSE;
    }

    byte pData[65535];
    DWORD dwReadedLen;
    DWORD dwWrittenLen;

    HANDLE hfile = CreateFile(psLocalFile,GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
    if (hfile == INVALID_HANDLE_VALUE)
    {
        InternetCloseHandle(m_hRequest);
        InternetCloseHandle(m_hConnection);
        InternetCloseHandle(m_hInternet);

        sErrMg.Format("创建本地文件 %s 失败", psLocalFile);

        return FALSE;
    }

    while(1)
    {
        b =  InternetReadFile(m_hRequest, (LPVOID)pData, sizeof(pData), &dwReadedLen);
        if (b == FALSE)
        {
            CloseHandle(hfile);
            InternetCloseHandle(m_hRequest);
            InternetCloseHandle(m_hConnection);
            InternetCloseHandle(m_hInternet);

            sErrMg.Format("读取文件 %s 失败", psUrl);
            return FALSE;
        }
        if(dwReadedLen == 0)
        {
            break;
        }
        b = WriteFile(hfile, pData, dwReadedLen, &dwWrittenLen,NULL);
        if (b == FALSE)
        {
            CloseHandle(hfile);
            InternetCloseHandle(m_hRequest);
            InternetCloseHandle(m_hConnection);
            InternetCloseHandle(m_hInternet);
            sErrMg.Format("写入本地文件 %s 失败", psLocalFile);
            return FALSE;
        }

    }

    CloseHandle(hfile);
    InternetCloseHandle(m_hRequest);
    InternetCloseHandle(m_hConnection);
    InternetCloseHandle(m_hInternet);
    sErrMg.Format("下载成功");
    return TRUE;

}

本文链接

找到锁域账号的元凶

2012-01-07T07:06:00Z

域账号多次被锁，看起来是有人在狂试我的账号似的，解决办法记录一下。

在ad控制器里，安全日志里做如下查找：

事件id：644

意思是Lockout事件。

内容：输入要搜索的账户名。不必输入域名。

查到到日志之后，看看内容里的来源工作站名。

去那个工作站上，查查有没有用此账户运行的定时任务、服务啥的。如果从前有，后来你改了口令，这些任务就不能运行了，可能会一遍遍用旧口令启动，最后达到次数上限锁定你的账号。

如果没有明显的此类任务，查查是不是有一种叫Downadup的病毒。这个病毒会利用rdp的一个安全漏洞感染机器，如果你改了用户口令，这个病毒会重试你的账号直到lockout.

从symantec网站上可以找到专杀工具。

http://www.symantec.com/content/en/us/global/removal_tool/threat_writeups/D.exe

杀完病毒之后，可以按工具的提示去查看ms08-67安全公告，并下载补丁KB958644修复漏洞。

这个漏洞到从windows 2000 到 windows7 beta版和windows 2008 server为止都存在。在windows7 和windows 2008 Server r2开始不存在了。

http://technet.microsoft.com/zh-CN/security/bulletin/ms08-067

要检查系统中有没有已经安装对应的补丁，可以检查KB958644是否安装。

本文链接

求高手指点：VC中wininet的代理服务器问题，耗了两天了，没有一点办法

2012-01-07T06:45:00Z

windows xp sp3 + ie6环境

如何在CInternetSession下传文件时，设置要求用户名口令的代理服务器？
如果安装了ie8，CInternetSession会自动采用ie的设置和用户保存的凭据，程序是完全透明的，但ie6下，相同的程序行为不同了，如何显式地设置代理服务器与用户名口令呢？

下面是我目前不能工作的代码，这个代码在ie8的环境里完全不必有SetOption()的动作都能自动正常。

如何实现代理服务器的设置？

BOOL GetHttpFile(LPCTSTR psUrl, LPCTSTR psLocalFile, CString &sErrMg)
{
    //通过http获得远程的update文件。
    char buf[65536];
    CString sTemp;

    CInternetSession sess;
    char* sProxyServer = _T("http://192.168.1.9:8080");
    char* sProxyUserName = _T("bejlife\\username");
    char* sProxyPassword = _T("Password");

    INTERNET_PROXY_INFO proxyinfo;

    proxyinfo.dwAccessType = INTERNET_OPEN_TYPE_PROXY;
    proxyinfo.lpszProxy = sProxyServer;
    proxyinfo.lpszProxyBypass = NULL;

    bool b = sess.SetOption(INTERNET_OPTION_PROXY, (LPVOID)&proxyinfo, sizeof(INTERNET_PROXY_INFO), 0);

    CHttpFile* fileGet;
    try
    {

        fileGet=(CHttpFile*)sess.OpenURL(psUrl); //, 1, INTERNET_FLAG_TRANSFER_BINARY);
        if(!fileGet)
        {
            sess.Close();
            sErrMg = "不能打开远程文件！";
            return FALSE;
        }

        fileGet->SetOption(INTERNET_OPTION_PROXY_USERNAME, (LPVOID)sProxyUserName, lstrlen(sProxyUserName) + 1, 0);
        fileGet->SetOption(INTERNET_OPTION_PROXY_PASSWORD, (LPVOID)sProxyPassword, lstrlen(sProxyPassword) + 1, 0);
    }
    catch(CException* e)
    {
        fileGet = NULL;
    }

    if(!fileGet)
    {
        sess.Close();
        sErrMg = "不能找到远程文件！";
        return FALSE;
    }
    int iBuffLen;

    DWORD dwStatus;
    DWORD dwBuffLen = sizeof(dwStatus);
    BOOL bSuccess = fileGet->QueryInfo(HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwBuffLen);

    if(!( bSuccess && dwStatus>= 200&& dwStatus<300 ))
    {
        fileGet->Close();
        sess.Close();
        delete fileGet;
        sErrMg.Format("打开远程文件出错，错误码：%d", dwStatus);

        return FALSE;
    }

    CFile fileWrite;
    if( ! fileWrite.Open(psLocalFile, CFile::modeWrite|CFile::modeCreate))
    {
        fileGet->Close();
        sess.Close();
        delete fileGet;
        sErrMg.Format("本地文件打开出错.");
        return FALSE;
    }

    iBuffLen = fileGet->Read((void*)buf, sizeof(buf));

    while(iBuffLen != 0)
    {
        fileWrite.Write(buf, iBuffLen);
        iBuffLen = fileGet->Read((void*)buf, sizeof(buf));
    }
    fileWrite.Close();
    fileGet->Close();
    sess.Close();
    delete fileGet;
    sErrMg.Format("下载成功");

    return TRUE;

}

本文链接

业务系统设计要考虑的问题（三）地域化支持

2011-08-31T13:34:00Z

既然已经上线了这样的“标准流程”的核心业务系统，就必然会立即遇上各种地域化问题。前面说过，中国各地发展极不同步，在经济、文化、政治、民间风俗、人文道德水平方面全国各地千差万别，相同的业务要求不同的服务方式是不可避免的。

比如说我们上线不久遇上的一个事情：这些年政府管控的力度越来越大，不仅管产品，管财务，还要管到各个公司的内部操作流程上，搞得大家都很难受，不知道国家是不是想要回到计划经济的路子上去。就是在这种背景下，我们分公司所在的当地政府的一些监管机关经常搞出个通知，要求在某个业务办理时，所出具的业务材料必须按官方规定的文字向客户进行书面表述什么的。

新业务系统上线之后，这种小小的需求也必须要向总公司提申请要求修改了。业务系统本来对于操作中的打印件采用了模板技术，如果需要修改内容，只需要修改模板中就可以了，但是问题是这个修改是只对我们一个分公司的，其他分公司没有这样的要求(或是其他的什么要求，都不一样)，一但这个模板修改了，全公司都会跟着我们的样式生成打印件。

这个需求提到总部IT之后，负责的家伙着实地发了一阵子愁，最后还是没有好办法，只好在崭新的系统代码里加上了那个肮脏的“if(strncmp(deptno, “BEJ”, 3) == 0)…”，在我们公司的操作员在操作这种业务时，特别地调用一个专门的模板文件。

在目前的社会环境下，这种需求一定会很多，不仅有这样特别打印件的问题，还可以设想其他可能存在的同样地域性需要：

l 在UI上某处为某个地域的操作增加某些特别提醒信息

l 必要时还要跳出个MessageBox\alter来。

l 打印外文版文档。

l 某地区在标准流程中特别插入的步骤。

l 某地区对某个业务的前置\后置检查逻辑。

l 某种特别需要的警戒线提示。

l 特别的数据展示格式。

l … …

对于这些域化的需求的解决方案，我在操作系统的设计中得到了启发。

a) 地域化静态资源扩展

操作系统常常需要开发不同的语言版本，为了简化开发，一般会将UI中所用到的字符串、图片、多媒体文件等做为一种“资源”来单独处理。操作系统中总是有一套Default的资源文件，然后为不同的文化和语言分别准备不同的特定资源。如果当前的文化设定所对应的特殊资源没有提供，那么系统就采用默认的资源，比如英文，如果存在当前文化设定对应的特殊资源，那么就采用特殊的资源。

这个思想完全可以借签到业务系统的设计中，把分支机构如同操作系统中的一个文化-语言来处理，对于系统中所需要的资源类内容，按分支机构整理。在默认的情况下，系统会加载default资源来处理，而当一个分公司有特别需要时，为其特别定义一个资源，这样系统优先使用这个特殊定义的资源，使得系统可以方便地按地域提供个性的服务。

应该说我们的系统还是考虑到了一个层面，就是可变的模板让标准内容可以方便地修改，可惜没有进一步认识到各地区差异需求必然性，现在，该为业务系统的设计者提个醒了——当你设计一个要用到全国各地的系统时，地域化支持就成了必然要考虑的问题。

b) 应该考虑客户化插件标准

还有很多地方对于功能类的扩展要求，也可以参考操作系统的“事件”思想。就是说核心业务系统可以按标准的操作过程执行，但是同时设计一种机制，可以在某些时机来callback触发预定的“额外功能插件”。

所述的“时机”可能如下的情况：

l 一个订单生成之前、之后。

l 操作员登录后、注销前。

l 某些信息安全事件。

l ……

对于这些事件，系统应该有一种标准化的“定阅”协议，使得程序员可以方便地注册定阅程序，这样在事件发生之后，系统根据定阅记录触发注册程序。这些程序可能不只一个，而且可能只是对与某个分支机构有关的事件才会触发。

这里需要注意的系统的健壮性如何不受callback程序的影响，比如从技术上限定callback程序可以做的事情或不能做的事情，甚至要求callback程序只能是异步执行等。

进一步地，可以将一些常见的插入任务制式化，比如特别的消息提示，电子邮件通知，存档，简单的表达式计算与数据检查，这些常见任务可以固定为可选用的任务模板，通过预定参数来达到不同的目的。

应该承认，在整个系统中的所有的可能的地方实现这些可定制、可插入，其成本必然是很高的，但是，应该在系统中为这些特性做好技术的准备，你应该把加载资源的函数增加个分支机构代码参数，以备在需要时可供使用。也应该规定好事件触发的技术协议，那怕是通过某个规定的数据表中的记录来传递消息，只要有标准就行。

如果你在系统设计中没有增加这些特性，那么你在发现自己在第二次在同一个地方写入“if(strncmp())…”时，总应该开始认识考虑这个问题了吧？一个if可能是个偶然的个性问题，两个if出现在同一个地方时，你应该能认识到这是一个值得重构的弹性需求点，及时在这个地方引入地域资源化、事件订阅等设计模式，以免在上线第二个月时，就把你崭新的系统代码挂上一串串的大便。

本文链接

业务系统设计要考虑的问题（二）分离业务逻辑服务层

2011-08-31T12:21:00Z

商业公司的业务同质化很高，市场如战场，谁能快一步应变，谁能给客户提供个性化，谁就得到了业务，谁就能生存。特别是象中国这样各地的经济、文化、政治极其不平均的国家，中央与地方的差异鸿沟巨大，地方特色必然需要。

但是站在总公司的管理角度上来考虑，当然是希望业务流程越规范越好，新花样总是意味着管理上的潜在危险。而对于总部信息技术部门的角度来看，个性化的新花样则是开发工作量的剧增、无止无尽的新需求。

管理与市场、领导与客户、全局与局部、总公司与分公司之间，这个思路方向性的矛盾是现实存在，而且不可避免的。

当然，最后项目还是要按上级的管理意图来实施，于是我们得到了一个全国一致的系统，一个唯一可用的UI，一本统一印发的操作手册。对于常规的业务，按着系统的要求操作就可以满足需要了。但是这个系统不再给机会进行业务、技术的创新，一切新的想法只能做为新需求向上级提出，然后由情绪恶劣的IT人员在程序里加入一个个 “if(strncmp(deptno, “BEJ”, 3) == 0)…” 这样丑陋到暴的代码来完成流程定制化。

其实要在同一个系统里同时满足总分公司双方的诉求，并不是不可能，就是把应用系统分为两层：业务逻辑与UI层，业务逻辑层是对业务逻辑的原子化，以实时服务的形式提供。在此业务逻辑服务的基础上，构建界面展现。

这里的关键点在于业务逻辑服务的提供，不仅可以是标准UI对其的进程内调用，也同时需要能够通过webserivce等协议提供进程外服务。对于标准流程，可以由总部来做“典型实现”，而对于有特别需要的分部，则可以方便在业务服务的基础构建业务系统的其他前端外延。

这样，从管理的角度上来讲，业务数据的进出都是通过标准服务来进行的，业务数据质量、业务一致性、合规性都可以通过统一的业务逻辑来得到保证，而分支机构则有机会为不同的业务开发不同的前端接口，以根据市场要求灵活创新。

这种模式特别适合于有外部合作机构的公司采用，如金融企业、电子商务企业等。如果业务系统只有一个UI的IO方式，一切数据进出都要通过操作员来进行，那么与其他合作方进行自动化的数据对接就很难实现，一但有这样的需求，只能由交由掌握了底层逻辑的总公司IT从头开发。

现在我们的系统已经上线，可惜的是，系统采用了最简单最直觉的思路开发，几乎要把业务逻辑写在界面里了。事已至此，也不可能有什么改变了，这里只是我有过的想法分享出来，作为讨论。

本文链接

业务系统设计要考虑的问题(一)分散式数据存储设计

2011-08-31T06:15:00Z

近一段时间，公司上线了一个全国性的业务系统，这个系统功能覆盖了全部业务流程，用户包括全国32个分公司，可谓是一个把所有鸡蛋放在同一个蓝子里的巨大系统，上线过程多么辛苦不说了，只说上线后的一些问题所带给我的一些关于业务系统设计启发。

一、应该考虑分散式数据存储设计

企业内的生产线类系统，一开始都对性能考虑不足，在设计中基本上都采用单一数据库来支持业务，随着业务规模的扩大，对数据库性能要求提升时，企业会采购更昂贵的软硬件产品来支持更大的访问压力，当实在无法缓解时，会考虑在数据库端采用分区等方法来分散硬件压力，但是数据库本身从逻辑上还是单一的实例。

由于所有数据服务都在集中在少数的关键硬件上，就会造成几方面的问题，一是极高性能的硬件成本太高，二是所有的鸡蛋放在了同一个篮子里，服务故障造成的灾难影响面太大，三是硬件的升级总是跟不上数据量、访问量的提升速度，整个系统总是慢吞吞的。

要解决这个问题，可以采用的第一个设计思路，是按业务领域划分为若干个系统，每个系统之间再做服务、数据、流程的集成。这种思路已经广为采用，优劣各人自知，不再多说，本文想讨论的是另一个更为大胆激进的想法：分散式客户数据。

Facebook、twitter、微博这种社交网站面对的访问量远远大于企业应用，与企业应用相比而言，社交网站还要考虑如“突然大批的用户涌来怎么办？”、“某个普通用户突然火了怎么办？”这种突发性能要求的处理。

他们解决方案是在软件逻辑上就支持分散存储，即建立数量不限的数据库，数据被按一定的策略分散保存在不同的数据库硬件里，这样在访问不同的数据时，可以按策略来判断应该去哪个数据库里去寻找数据。由于数据库是独立的，只需要增加一些低端的硬件，就可以达到平滑升级性能的目的。

为了与逻辑上集中物理上分布的表分区等技术相区别，我以“分散”一词来表示这种在逻辑上的多数存储方案。

数据分散的策略有哪些？主要是三种：

一是按业务（产品）领域划分。这种方式其实与分为多个子系统没有区别，但主要业务一般也是数据量最大、访问量最大的，按这种划分的话，可能还是无法解决最主要的问题。

二是按业务时间划分。这种方法对于一些偏重近期的业务会有作用，如股票交易，但是对于依靠长期信息的业务则不实用，比如长期保险业务中，保单生效越长，反而越有可能发生理赔、给付等，而且在这些业务处理过程中，要依据业务对象的所有信息进行处理，如果数据是按时间分散保存的，软件系统逻辑上则有较大幅度的复杂度增加。

三是按主业务对象的“群落”来划分。比如把客户分群，某一个客户的所有相关业务信息（比如他的博文、有关评论等）不可分散，按群放在不同的物理数据源中。这样，当系统存取某个客户的信息时，可以按群落找到客户所在的物理数据库，之后的逻辑则与集中式数据库的处理大体类似。

如何得知客户所在群落呢？对于不存在个别突发的访问增长的系统，可以暂时采用平均式的分群方案，用某种约定算法求得客户群号，比如说按客户证件号的前几位。但是这种分类一但固定了就不容易更改，例如，一开始用证件号第一位平均分为10个数据库，但如果业务增加到10个数据库也顶不住时，要修改这个分群就很困难了。

另一个办法就是采用一个中心数据库来记录用户所在群落，这个中心数据库里只需要一张表、最少三个字段就够了——用户标识、群落号或物理数据源地址、可访问状态。当系统要开始处理一个用户的业务时，需要向这个数据库进行询问，得到群号后就可以转向所在数据源进行业务处理。

这种办法的好处很大，比如微博这种社会网络上，常常会有人突然火了，前一天还是无名小卒，一百多个粉丝，每天两篇微博，被与其他五十万同样的屁民放在某个刀片机上的mysql里默默无闻着，谁知道第二天他可能运气太好（或是运气太坏）赶上了个什么热点时件，突然有几十万人来关注他，那个机器立即就顶不住了。在这种情况下，就用数据迁移程序把这个人的有关信息全部移到另一台小型机上去跑，迁移完成之后修改中心数据库，压力立即就调整了。

这种迁移甚至可以做成自动的，发现哪个用户火了就自动启动，按策略移到预备的空闲计算资源上去。

这样的系统架构下，压力最大的地方就成了中心数据库，但是第一，这个数据库中里没有业务数据，数据结构很简单，极容易优化索引与性能，就是买好硬件，所需的投资也有限。其次，用户分群策略可以结合固定规则与特殊指定分群，中心数据库可以只保存特殊指定分群的记录，如果没有记录则是按固定规则（证件号第一位？）来分。再次，应用服务器也可以按缓存访问过的用户分群信息，只在按固定规则断言数据源后访问失败、而且没有缓存过或按缓存访问失败的情况下才访问中心数据库，得到用户的最新群落位置。

不可否认，这种模式会对全局性数据访问需求造成技术困难，例如需要统计全系统的一些数据时，就需要协调所有的数据库进行分别运算，最后再把结果汇总，这肯定需要一些全新的开发与运维架构来支持，但对于巨量数据的系统来说，统计结果的绝对精确性已经让位于系统可以正常运行的要求。

本文链接

xml, oop, 云计算、web service，敏捷开发

2011-02-14T07:31:00Z

有位老兄写了一篇《被高估的几种it技术》，大部分都没意见，只是对于其中xml, oop, 云计算、web service，敏捷开发几项，感觉应该客观地再评价一下。

xml

xml有其他数据语义标准之长，而无之短，只是语法上上有点儿冗余，但是这东西主要还是让计算机看的，捎待让人看懂已经很不错了。如果你玩过银行里那种古系统中的文本文件数据报文你就知道xml的好了。xml还有一整套配套的技术，如xmldoc, xpath等辅助使用。

我见过用字符串拼接、查找来生成xml或是解析xml的（好可怜的程序员），这种用法是在用xml的皮毛，如果你是这样的程序员之一，那快去系统学习一下吧！不然要累毙了。

oop

原作者认为oop的设计模式把程序开发搞复杂志了，实际上oop与设计模式不是一回事，oop的思想根本上是把现实世界在计算机中建立映射，这是很好很有效的降低开发复杂度的办法。设计模式是是在oop基础上的算法总结，是指导而非要求。要反对的是学院派由于《设计模式》一书的存在而“过度设计”，而非是oop本身。但是，当你系统扩展弹性要求高了之后，你会发现答案还是设计模式中的一些办法。

我没有看过《设计模式》之前，多年做oop的开发，之间为了解决问题而想出了不少设计办法。后来为了不被学院派精神虐待而看了《设计模式》这本当年的“圣经”之后，发现其中大半的设计办法我早就在之前的工作中自行发明使用过了。

web service

web service是目前最好的解决平台间数据通讯的技术了。中立的数据类型，支持对象的语法规则，中立的通讯协议，自动代理方法工具，甚至连异常都能跨平台传输，你还需要啥呢？

不过，它的确不是万用法宝，它只能解决他适合解决的问题。ibm最会炒概念，你迷信ibm是你无知, webservice仍然工作得让人安心。

最后，要是如果能解决web service的接口版本的兼容性问题就更好了，不解释了，用过的就知道我的意思。

敏捷开发

敏捷开发的一个潜台词是“高手开发”，“敏捷” 的核心就是：深刻理解业务需求 + 合适（成本、可扩展性的均衡）地实现需求+ 一有必要立即重构以增加设计弹性 + tdd（质量保证）。所有这一切都需要高手才能做到。关于双人编程，实践中发有两个巨大好处: 一、知识传承没有问题了。二、两个人一起工作，注意能高度集中几倍于单人工作时的时间，三，讨论能理清思路。

“敏捷”中文档的问题：同步程序与文档是一件很麻烦而没有效果的事情，后来人一般不会看详细设计的文档，更别提你的文笔也不一定达到让人能轻松读下去的水平。我的解决办法是：

一：设计文档就到架构设计。说明程序结构、设计思路、数据库设计，聪明人看过之后就明白你的意思了，一般不需要更详细的文档了。

一：程序就是文档，我不在乎你的变量名有多长：匈牙利命名法、动词短语方法名。后来人看你的程序要像看一篇文章那么清楚。

二：文档注释，必要的过程＼算法＼注释对接口方法进行说明。然后ndoc之类的工具就可以生成文档了，比自己搞得好得多，而且不会出错。

对于大型的系统，我的实践经验是：在架构设计层面（系统设计、程序结构设计、数据库设计等），高手进行“敏捷式设计”，而具体的实现可由普通开发人员完成，一则提供优秀的系统设计、为未来始终留下扩展余地，二来也不会过度设计导致实现成本过高，三来普通的开发人员的工作也好干。

题外话：与高手一起工作的惬意无与伦比。

云计算

其实这是一个基础运行体系的解决方案，在专业it运行领域，虚拟化、基于冗余思想的高可用硬件是多年以来企业级厂商努力的方向。

虚拟化有两个方向，一个是把一个高性能的硬件分为多个虚拟机运行，如ibm的高端机型，另一个方向是把多个物理机整合为一个虚拟的单一机器，任务分散、分布执行，从而得到高性能计算能力。

云的意思是两者的结合——多个物理机整合为一个虚拟机，这个一个虚拟机上再分为多个独立的逻辑单位，用于隔离不同的应用程序运行空间。这样，即得到了应用程序管理的便利，又得到了冗余硬件的可靠性，以及高弹性的性能管理。只要你做过基础运维你就会理解这个东西的宝贵。

一个IT经理高声呼喊，快点到来吧，云计算！我需要一个私有云来解放我！

本文链接

用C#开发TUXEDO客户端

2010-12-31T01:04:00Z

0 概述

Tuxedo是类似于Message query server的一种东西，它以消息服务器的方式提供一个服务器框架，客户端向服务器发送请求报文，服务器处理之后返回应答报文。当然，服务器有对消息队列的各种管理能力。

我猜这个东西最初提供给客户的动机是为了保留客户用C开发的业务逻辑，又能方便地把自己的系统改造为面向服务的交易系统, 毕竟客户们的系统已经正常运行多年，该卖给他们一些新东西了。

因为要与C兼容，还有客户们现存应用的多样性问题，Tuxedo决定在设计上不提供消息语法与语义的支持，只是透明地转发数据块——也就是说，C语言里的char*，struct*, 甚至是void*.

于是，很多公司当时都上了当，把自己的系统改为了Tuxedo的架构，但是几乎马上的，更好的东西就出来了：jri, web service...新的服务协议都不仅提供通信层的支持，还有语法支持，有些甚至还有语义支持。杯具呀！

现在，用新技术开发的应用程序很可能会遇上需要与旧的tuxedo服务交互的要求，幸运的是，BEA提供了几种主流语言调用Tuxedo服务的技术，不幸的是，有一些很讨厌的问题存在，主要是C语言的ANSI字符集与现代语言的unicode内码的兼容问题，更别提还有utf-8这种东西……你分得清UTF8和Unicode吗？

本文说明了以C#调用Tuxedo服务的基本过程，会帮助你完成第一次Tuxedo调用。在后记中，又讨论了字符集可能会引起的问题, 希望能减少你在这条路的摸索时间。

1 安装

1.1 安装版本的选择

从BEA网站可以下载到所有版本的tuxedo服务器与客户端的安装包。我下载了V10.0 专for xp版，装在Windows Vista Professional上。

从9.1以后的客户端版本，就开始支持.net的托管代码的访问。在安装完了v10.0之后，察看了一下%TUXDIR\%bin\libscdnet.dll文件，他的版本其实还是9.1，可能在V10.0上这个托管库并没有升级。

在BEA的网站上下载完安装包之后，别忘记了在下载页面里下载许可证文件。

1.2 安装后的一些调整

1.2.1 TUXDIR环境变量的修改

我安装完成之后，客户端程序被安装在了C:\Program Files\BEA Systems\TUXEDO\tuxedo10.0_VS2005路径下，但是TUXDIR变量的设置值不知道什么原因没有指到正确的路径,而是指到了C:\Program Files\BEA Systems\TUXEDO，导致运行程序时出错，经检查C:\Program Files\BEA Systems\TUXEDO下的ULOG日志文件，报告找不到locale文件夹。我试着修改了一下TUXDIR环境变量，但没有作用。

于是把C:\Program Files\BEA Systems\TUXEDO\tuxedo10.0_VS2005\下的所有文件复制了一份到上一层的C:\Program Files\BEA Systems\TUXEDO，这个问题就解决了。

1.2.2 PATH环境变量的修改

在PATH里增加对C:\Program Files\BEA Systems\TUXEDO\tuxedo10.0_VS2005\bin目录的指向。

1.2.3 许可证文件

把下载到的许可证文件改名为lic.txt，复制到udataobj目录下。由于我们复制了安装目录，就造成了有两个这个文件夹的情况。都复制进去好了。

2 用C#写tuxedo客户端程序的基础知识

2.1 托管类的引用

%TUXDIR%/bin/libwscdnet.dll是.net2.0的托管代码类库，可以通过对这个库的引用来对tuxedo函数进行调用。当建立了一个C#客户端项目后，必须新建一个引用，选择%TUXDIR%/bin/libwscdnet.dll。其命名空间是Bea.Tuxedo;

2.2 服务器地址等环境变量的设置

根据网上的说法，有三种方法设置服务器地址：

一．用环境变量来设置：

在系统的环境变量中设置WSNADDR=//<ip address>:<port>

这样做的好处是不必在程序里配置。坏处是只支持一个服务器的连接。

二．用tuxreadenv函数

用tuxreadenv函数来从一个配置文件中读取指定的节，作为当前环境变量的设置。

如：tuxenv.ini.内容格式如下：

[TUXCOMM]

TUXDIR=c:\tuxedo

PATH=%PATH%;c:\tuxedo\bin

WSADDR=//192.168.0.1:6000

在程序中使用: tuxreadenv("tuxenv.ini","TUXCOMM");语句来调用。

在C#中，tuxreadenv函数被warp到Utils.tuxreadenv()了。

三．用tuxputenv函数inline地指定环境变量

tuxputenv函数可以在程序中直接指定环境变量。如：

tuxputenv("WSNADDR=//10.1.128.227:9401");

如果有多个环境变量要设置，可以多次调用这个函数来分别执行设置。

在C#中，tuxputenv函数被warp到Utils. tuxputenv ()了。

2.3 高版本客户端调用低于7.1版的服务器的问题

由于服务器是V6.5，而我装的客户端是10.0，因此存在一个协议兼容性的问题，在运行时报错：protocol error. 经查看ULOG文件，发现在调用7.1以下的服务器时，要设置一个环境变量WSINTOPPRE71的值为“yes”。

增加对这个环境变量设置的方法，见上节三种方法中的任何一种。

2.4 调用的一般形式

客户端调用服务的一般过程为:

设定环境变量à初始化应用上下文à调用服务à得到结果à关闭应用上下文

下面是一个最简单的C#客户端：

//设定环境变量

Utils.tuxputenv("WSNADDR=//10.1.128.227:9401");

Utils.tuxputenv("WSINTOPPRE71=yes");

//初始化应用上下文

AppContext ac = AppContext.tpinit(null);

//同步调用服务。

// 同步调用时，服务器不返回结果或是出错之前，

// tpcall方法不会返回，程序将等在这里。

TypedString sndstr = new TypedString(1000);

sndstr.PutString(0, “hello world!”);

TypedString rcvstr = new TypedString(1000);

ac.tpcall("TOUPPER", sndstr, ref rcvstr, 0);

// 得到结果

string rcvstr_str = rcvstr.GetString(0, 1000);

//关闭应用上下文

ac.tpterm();

2.5 异步调用服务

TUXEDO支持异步调用模式。在异步调用方式下，用 tpacall方式调用服务。当异步调用一个服务后，客户端程序不等服务器完成工作就立即继续执行其他工作，只保留一个句柄。等到客户端程序有空的时，再回来用tpgetrply方汉等待已经调过的服务。如下面的程序

//异步调用服务。得到异步调用描述符 acd.

AsyncCallDescriptor acd = ac.tpacall("TOUPPER", sndstr, 0);

// …. 做些其他的事情。

// 继续刚刚的服务调用，等待结果。这个方法是一个同步函数。

ac.tpgetrply(ref acd, ref rcvstr, 0);

string rcvstr_str = rcvstr.GetString();

2.6 多线程调用

多线程调用时，需要在应用程序上下文初始化时，加入多线程标志。如下：

TypedTPINIT tpinfo = new TypedTPINIT();

tpinfo.flags = TypedTPINIT.TPMULTICONTEXTS;

AppContext ac = AppContext.tpinit(tpinfo);

2.7 结构数据传递问题

Tuxedo windows客户端的原始API是面向C语言的，因此在很多的服务器程序的编写时，会采用struct结构来会传递数据的方案。对于C结构体数据，在tuxedo中对应的消息类型应该是CArray, 在用C#制作客户端时，可以采用TypedCArray这个类型来传递数据，其中，需要特别注意的问题是.net中interop操作时的一些技术细节。

下面是一个具体的例子：

[StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)]

public struct MYMSGBODY

{

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x20)]

public string usrname; // char usrname[20]

[MarshalAs(UnmanagedType.U4, SizeConst=4)]

public uint lLogNo; // unsigned long int lLogNo;

[MarshalAs(UnmanagedType.I4)]

public int iRecNum; // int iRecNum;

}

在MSDN上有详细的结构体interop类型对应表可以查阅。这里要解释其中几个重要的地方：

l StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)

n Pack=4表示以最大4字节边界对齐成员。

n CharSet = CharSet.Ansi表示字串是ansi字串。之后再详述。

l MarshalAs(UnmanagedType.U4, SizeConst=4)
此属性标记为此string成员是以值传递的，也就是是一个数组，而不是指针。并指定了长度。这个长度是指C串里包括了结尾0的总长度。

l Long类型：这个类型在C与.net里的有重要不同，在C中， int的大小根据平台不同有16位长，32位长，（在windows和现代的unix中，一般都是32位）, long的长度在windows和unix中一般是32位的，而在.net中，long类型的长度是64位，并且interop很多操作不支持对long型数据的转换，如对结构体取size时，如果有long型字段，就会出现异常，这里要注意。

l 内存分配的对齐问题

这个问题是最难以讲清楚的问题。在C语句的编译器中，都会有一些关于结构体成员如何对齐地址的编译指令或是伪指令，如VC的#pragma pack, __declspec( align() )指令等。这些指令指示编译器如何在内存中排布结构体的成员。

其中，pack=n的意思是：结构体中下一个成员的起始地址，要用 “成员类型的长度和n之中的比较小的那个”来对齐。比如说下面的结构体成员：

#program pack(8)

Struct ST_E1{

char s1[2]; // 从0偏移开始, 占到1位置，共2字节

int i; // min(sizeof int= 4，pack=8)=4, 因此，i的起始地址应该按4对齐

// 也就是空两个字节，到偏移4处开始，到偏移7，共4字节

char s2[3]; // min(sizeof char=1, pack=8) = 1, 因此s2的起始地址按1对齐，

// 也就是从偏移8开始，到10，共3字节。

Char s3 // 同理，s3占偏移量11，一个字节

}

结构体总长度为12个字节长。

Off	0	1	2	3	4	5	6	7	8	9	10	11
V	S1	S1	空	空	i	i	i	i	S2	S2	S2	S3

如果pack指为1呢？那么分配的方式如下：

Off	0	1	2	3	4	5	6	7	8	9
V	S1	S1	i	i	i	i	S2	S2	S2	S3

共10个字节长。

可以看出，如果两边的pack值不一样，那么这个结构体在送到目的地之后就会出现成员偏移乱掉的问题（开始想念web services了吧？但是我们不总是能选择所处的条件的）。因此，一定要检查服务器与客户端的这个编译选项是不是一样的。一般情况下，pack=4是比较常见的情况。

有关更多的内存对齐方式的讨论，可以参见本人另一博客文章及其评论内容。

http://www.cnblogs.com/haoxiaobo/archive/2005/09/05/230204.html

l 字符集问题

字符集是另一个需要注意的兼容性问题。例如上面的成员定义：

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x20)]

public string usrname; // char usrname[20]

在大多数面向C语言的API中，基本上是没有char与byte的区别的，但是.net中对于char与byte则有本质的不同，char是指一个与文化相关的符号，而byte指一个8位二进制数的物理存储单位。一个char需要几个byte来保存，要视字符集编码方式而定，在.net和java里，内部的char都是unicode，一个字符两个字节，而在C中，基本上都是ansi（除了windows nt之后新增的那些 _T类型）。

由于这个原因，一定要认真考虑服务器系统的字符集编码，否则会导致字符串在interop转换时，产生非常令人生气的结果。

在结构体的定义时，charset = charset.ansi即通知了interop程序，字符串在向结构体转换时，要用ansi方式进行转换。

更多有关字符集的讨论，请参见本人另一篇博客文章：

http://xiaobohao.spaces.live.com/blog/cns!D1C72860197EBF38!1250.entry

完整的用结构体内存块数据做消息体，调用tuxedo服务的代码如下：

Bea.Tuxedo.ATMI.Utils.tuxputenv("WSNADDR=//10.1.128.227:9401");

Bea.Tuxedo.ATMI.Utils.tuxputenv("WSINTOPPRE71=yes");

AppContext ac = AppContext.tpinit(null);

RecivedStruct rec; // 这个RecivedSTRUCT即是tuxedo服务所规定的返回消息结构体在C#里的对应定义，请参阅本节之前的说明，对C风格的结构进行C#定义。

SendStruct app = new SendStruct (); // 这个SENDSTRUCT即是tuxedo服务所规定的调用消息结构体在C#里的对应定义，请参阅本节之前的说明，对C风格的结构进行C#定义。

app.sOperCode = “…”; // 几个示意成员

app.sDeptCode = “…”;

//…

// 开始把C#结构体的内容复制为byte[]。

// 取得长度

int iAppLen = Marshal.SizeOf(app);

int iRecLen = Marshal.SizeOf(typeof(RecivedStruct));

TypedCArray tbSend = new TypedCArray(iAppLen);

TypedBuffer tbRecive = new TypedCArray(iRecLen);

byte[] arAppData = new byte[iAppLen];

// 分配一个系统堆内存, 并用于一个指针来指向之

IntPtr pApp = Marshal.AllocHGlobal(iAppLen);

IntPtr pRec = Marshal.AllocHGlobal(iRecLen);

// 将托管结构复制到此地址指向的内存块中。

Marshal.StructureToPtr(app, pApp, false);

// 再将此地址块复制到字节数组中。

Marshal.Copy(pApp, arAppData, 0, iLen);

//把此字节数组绑定到要发送数据中。

tbSend.PutBytes(arAppData);

try

{

// 调用服务，返回一个typedbuffer.

ac.tpcall(sServiceName, tbSend, ref tbRecive, 0);

// 开始从这个返回的内容里取出数据。

// 初始化一个与返回值相同大小的数组。

byte[] arRecived = new byte[tbRecive.Size];

// 从返回值对象中取出字节数组。

((TypedCArray)tbRecive).GetBytes(arRecived, arRecived.Length);

// 用相反的步子把数据从字节流中复制到C#结构中。

Marsal.Copy(arRecived, 0, pRec, iRecLen);

Rec = Marsal.PtrToStructure(pRec, typeof(RecivedStruct));

}

catch (TPException tpex)

{

Trace.TraceError(tpex.ToString());

}

finally

{

ac.tpterm();

Marshal.FreeHGlobal(pApp);

Marshal.FreeHGlobal(pRec);

}

3 常用Tuxedo类与方法：

3.1 tpchkauth检查是否需要认证和认证的级别

int tpchkauth();

在调用tpinit()之前检查是否需要认证和认证的级别。

返回值：

TPNOAUTH：不需要认证；

TPSYSAUTH：系统认证，需要密码；

TPAPPAUTH：应用认证，需要密码和特殊应用数据；

当返回值为TPSYSAUTH和TPAPPAUTH时，我们必须使用tpalloc()分配一个TPINIT结构，在该结构中填入认证数据，然后用该结构作为参数调用tpinit()。

失败原因主要有：

协议错；

操作系统错；

tuxedo底层错。

3.2 tpinit初始化

在使用tuxedo其他服务之前，必须调用tpinit加入到应用中。

int tpinit(TPINIT *tpinfo);

参数说明：

tpinfo：指向TPINIT类型的指针。

TPINIT类型在atmi.h中有定义，如以下几个域：

char usrname [32]; (32 characters significant)

char cltname [32]; (32 characters significant)

char passwd [32]; (8 characters significant)

char grpname [32]; (32 characters significant)

long flags;

long datalen;

long data;

usrname：用户名或login名；

cltname：应用定义；

passwd：应用密码；

grpname：在事务中使用，必须在配置文件定义的组列表中；

flags：定义请求/通知类型和系统存取方法，其中TPU_SIG、TPU_DIP和TPU_IGN不能同时指定；TPSA_FASTPATH和TPSA_PROTECTED不能同时指定。有如下的值：

TPU_SIG：选择信号通知；

TPU_DIP：选择dip-in通知；

TPU_IGN：忽略通知；

TPSA_FASTPATH：选择fastpath方式系统存取；

TPSA_PROTECTED：选择protected方式系统存取；

datalen：应用特殊数据的长度；

data：应用特殊数据；

域flags的值覆盖系统的缺省定义，前提是在配置文件中没有指定NO_OVERRIDE。

如果参数使用(TPINIT*)NULL，则client使用系统缺省的通知设置和系统存取设置，若需要认证，则出错返回TPEPERM。

tpinit()调用失败返回-1，失败原因有：

参数错；

没有空间在BB；

没有权限；

协议错；

操作系统错；

tuxedo底层错。

示例：

TPINIT *tpinfo;

char password[9];

/* prompt user for password */

if ((tpinfo = (TPINIT *)tpalloc(“TPINIT”, NULL,

TPINITNEED(0))) == NULL) {

(void)userlog(“unable to allocate TPINIT buffer”);

exit(1);

}

(void)strcpy(tpinfo->passwd, password);

(void)strcpy(tpinfo->usrname, “Smith”);

(void)strcpy(tpinfo->cltname, “Teller”);

tpinfo->flags = (TPU_DIP|TPSA_PROTECTED);

if (tpinit(tpinfo) == -1) {

(void)userlog(“failed to join application”);

tpfree((char*)tpinfo);

exit(1);

}

3.3 tperm离开应用

使用tuxedo服务完毕，调用tpterm()离开应用。

int tpterm();

函数出错返回-1。

错误原因有：

协议错；

操作系统错；

tuxedo底层错。

3.4 tpacall发送异步请求

发送异步请求。

int tpacall(char *service, char *bufptr, long length,

long flags);

参数说明：

service：请求的service名(最大15个字符，以null结尾)；

bufptr：请求发送的数据；

length：发送数据长度(只有CARRAY类型用，其他设为0)；

flags：发送模式，有如下的值：

TPNOTRAN：该次调用不能在一个事务里；

TPNOREPLY：不需要回应(reply)；

TPNOBLOCK：非阻塞；

TPNOTIME：不超时，一直等待；

TPSIGRSTRT：被信号中断的系统调用重启。

成功返回一个非负的描述符，该描述符可用于后续的tpgetrply调用，出错返回-1。

错误原因有：

参数错；

当前太多的tpacall处理存在，上限是50；

事务错；

超时(time-out)；

3.5 tpgetrply接收异步回应数据

接收异步回应数据。

int tpgetrply(int *handle, char **bufpp, long *length,

long flags)；

参数说明：

handle：tpacall返回的描述符；

bufpp：接收buffer的地址的地址，原buffer会自动调整；

length：接收的buffer的长度的地址；

flags：接收选项。有如下值：

TPNOBLOCK：非阻塞；

TPNOTIME：不超时，一直等待；

TPSIGRSTRT：被信号中断的系统调用重启；

TPGETANY：接收任何回应；

TPNOCHANGE：要求接收的回应与发送数据相同。

成功返回0，失败返回-1。

出错原因：

参数错；

错误的接收buffer类型；

超时；

其他错误；

3.6 tpcancel取消由tpacall发送的请求的响应

取消由tpacall发送的请求的响应，在没有事务未完时。不能取消一个已经处理的请求。

int tpcancel(int handle);

参数说明：

handle：tpacall返回的描述符；

出错返回-1。错误原因有：

错误的描述符；

当前在事务模式；

其他错误；

3.7 tpcall同步发送请求并接收回应数据

同步发送请求并接收回应数据。

int tpcall(char *service, char *sbufp, long slength, \

char **rbufpp, long *rlength, long flags);

参数说明：

service：请求的service名；

bufp：发送buffer的地址；

slength：发送数据长度(只CARRAY使用，其他为0)；

rbufpp：响应buffer的地址的地址，可以与发送buffer为同一块区域；

rlength：响应buffer的长度的地址(不能为NULL)；

flags：标志。有如下值(含义见tpacall和tpgetrply)：

TPNOTRAN：该次调用不能在一个事务里；

TPNOREPLY：不需要回应(reply)；

TPNOBLOCK：非阻塞；

TPNOTIME：不超时，一直等待；

TPSIGRSTRT：被信号中断的系统调用重启。

返回-1表示出错，其他返回值都表示成功。

错误原因与tpacall和tpgetrply相同，除了描述符错。

3.8 tpgprio获得上一次请求或接收的消息的优先级

获得上一次请求或接收的消息的优先级。

int tpgprio();

成功返回的范围是1-100，值越大优先级越高。失败返回-1。

使用举例：

struct {

int hdl; /* handle*/

int pr; /* priority*/

} pa[SIZE];

for (i=0; i < requests; i++) {

/* Determine service and data for request */

pa [i].hdl = tpacall(Svc, buf, len, flags);

/* Save priority used to send request */

pa[i].pr = tpgprio();

}

/* Use qsort(3) routine to sort handles in priority order */

qsort((char*) pa, requests, sizeof(pa[0]), cmpfcn);

for (i=0; i< requests; i++) {

tpgetrply(&pa[i].hdl, &rbufp, &rlen, rflags);

}

3.9 tpsprio设置下一个要发送的消息的优先级

设置下一个要发送的消息的优先级。

int tpsprio (int prio, long flags);

参数说明：

prio：要设置的优先级；

flags：标志。有如下值：

0：使用相对优先级，值改为(default+prio)；

TPABSOLUTE：绝对优先级，值改为prio；

优先级的范围是1-100，超过次限制的值被改为相应的最大(小)值。

失败返回-1。错误原因有TPEINVAL、TPEPROTO、TPESYSTEM、和TPEOS。

-------------------------------------------------------------------

后记： 再谈字符集问题

在tuxedo返回消息的格式定义中，如果采用定长字串组合的方式（表笑，我们的业务系统就是这么干的），会造成一些意外的困难。

如下：如果返回值格式的定义是：

%4s%2s // 一个4字节的串，一个2字节的串

有一个返回值是：

Aaaabb

在C语言中以sscanf()来结析这个串很容易：

char s1[5],s2[3];

Sscanf(“AAAABB”, “%4s%2s”, s1,s2)

但是在C#, java中，由于没有sscanf这个函数，就不得不手工写截字串的函数，这样的数据还可以应付。但继续考虑以下的情况：

char s1[5],s2[3];

Sscanf(“中国红”, “%4s%2s”, s1,s2)

在有汉字的情况下，使用ANSI字符集的程序在sscanf之后，结果是s1=”中国”, s2=”红”.

而在C#等用unicode字符集的程序中，截取4个字符的结果将会出错，因为整个字串才只有3个字符。

因此，在unicode程序中对这个字串解析，就必须先把字串从unicode串以GB18030编码转换为字节组，然后再对字节流进行截取，截取的结果，又必须转换为unicode以在程序中处理。

---------------------------------------------

再后记：这篇文章是从前的文章，原来在xiaobohao.live.spaces.com中，后来微软放弃了live spaces, 只好用MS提供的迁移功能迁到了wordpress, 然后，悲杯了，你懂的。

好不容易从墙外找回了这篇文章，加了一点点修改，放到博客园里来。

本文链接