博客园_.Net 泥水佬

Smark.Net.Tcp.XmlService性能测试程序

2011-06-13T06:37:00Z

　　　Smark.Net.Tcp.XmlService是基于Smark.Net.Tcp基础进行XML封装处理的开源的tcp组件，组件提供了一对象发送和基于action绑定的处理机制，使基于socket编写网络就更应更轻松．如果你的应用在几千长连接中要处理几千请求处理．那组件完全满足你的要求，如果你想要更高的性处理就可以考虑Smark.Net.Tcp，相信他的性能可以满足你大部分应用的需要．

以下是Smark.Net.Tcp.XmlService的简单测试情况

下载: http://smark.codeplex.com/releases/view/45483#DownloadId=249210

组件网站:http://smark.codeplex.com/

http://smark.codeplex.com/

本文链接

基于Flex的http简易文件管理工具

2010-08-29T16:23:00Z

发布基于Flex表现管理的http简易文件管理工具，后台使用Smark的Web服务组件功能。
* 1.0
** 支持多文件同时上传和下载
** 支持快捷键操作
** 支持Winrar在线压缩和解压
** 支持用户配置

Flex Code SVN地址https://smark.svn.codeplex.com/svn/FlashBuilder/Smark.HttpFileServer/

C# Code SVN地址https://smark.svn.codeplex.com/svn/Smark/Smark.HttpFileServer/

http://smark.nbao.net

本文链接

性能的瓶颈到底在那呢?

2010-07-07T09:00:00Z

最近在写c# socket tcp组件碰到一个让我很烦恼事情，秒处理消息总会到一定值的情况产生瓶颈。刚开始大概秒处理2000消息以后会生成瓶颈，经过优化后秒处理消息达到5000后又来了。。。

秒处理5000前CPU站用率会在10%内，当到达秒处理消息6000后CPU会涨到60%。。。不知道c# socket tcp到底有多少处理能力。。。

那位朋友有相关测试数据和代码能否提供一下参考.

测试cpu是q8300,内存使用情况非常平稳。

本文链接

运用Smark.SocketAsyncs扩展基于XML的TCP服务

2010-06-30T09:21:00Z

XML作为业界标准所以很多语言平台都提供对XML很好的支持和处理，下面为Smark.SocketAsyncs扩展出简单XML支持。

性能测试情况
向服务端发送一个CustomMessage并获取返回结果，在3台client上分别启到750个tcpclient接入，server端查看处理情况是：有2250个TCP接入，秒处理消息在2000以上;而CPU占用率在30%,内存占用在140M

http://smark.codeplex.com/wikipage?title=%u8fd0%u7528Smark.SocketAsyncs%u6269%u5c55%u57fa%u4e8eXML%u7684TCP%u670d%u52a1

本文链接

运用Smark.SocketAsyncs方便实现数据交互服务

2010-06-23T04:27:00Z

Smark.SocketAsyncs是通过SocketAsyncEventArgs对Socket进行包装的处理程序，暂时只封装了对Tcp的支持。以下是通过Smark.SocketAsyncs封装一个简单的数据交互服务。
1)制定基础数据传输描述
实现消息转换适配器

    public class MessageAdapter:Smark.SocketAsyncs.IMessage
    {
        public object Message
        {
            get;
            set;
        }
        #region IMessage 成员
        public void SaveData(Encoding coding, Smark.SocketAsyncs.SendBuffer buffer)
        {
            buffer.Write(Smark.Core.Functions.SerializeObject(Message));
            buffer.WriteRN();
        }
        public void LoadData(Encoding coding, Smark.SocketAsyncs.ReceiveBuffer buffer)
        {
            byte[] data = buffer.ToBytes();
            Message = Smark.Core.Functions.DeserializeObject(data);
        }
        #endregion
    }

适配器主要功能是对象和byte之前的转换.

实现命令和返回类型描述

    [Serializable]
    public class Command
    {

        public CommandType Type
        {
            get;
            set;
        }
        private List<object> mParameters = new List<object>();
        public List<object> Parameters
        {
            get
            {
                return mParameters;
            }
        }
        public object this[int index]
        {
            get
            {
                return Parameters[index];
            }
        }

    }
    public enum CommandType
    {
        ListEmployee,
        LoadEmployee
    }
    [Serializable]
    public class Result
    {
        public object Data { get; set; }
        public string ErrorMessage { get; set; }
    }

2)服务端代码实现
建立一个控制台程序，定义相关监听对象和启用服务

            Functions.LogOutputToConsole = LogType.Track;
            string dbstring = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=";
            dbstring += Smark.Core.Functions.GetPath(typeof(Program).Assembly);
            dbstring += "Northwind.mdb";
            DBContext.SetConnectionString(ConnectionType.Context1, dbstring);
            TcpServer<TcpClient<EofAtEnter>> server = new TcpServer<TcpClient<EofAtEnter>>();
            server.ClientConnected += (o, e) => {
                Functions.WriteLog(LogType.Track, typeof(Program), "{0} On Connected \t {1}", e.Client.Name,DateTime.Now);
            };
            server.ClientDisposed += (o, e) => {
                Functions.WriteLog(LogType.Track, typeof(Program), "{0} On Disposed \t {1}", e.Client.Name,DateTime.Now);
            };
            server.ClientError += (o, e) => {
                Functions.WriteLog(LogType.Track, typeof(Program), "{0} On Error:{1} \t {2}", e.Client.Name,e.Exception.Message, DateTime.Now);
            };
            server.ClientReceive += (o, e) => {
                try
                {

                    Modules.Command cmd = (Modules.Command)Functions.DeserializeObject(e.Buffer.Data, e.Buffer.Count - 2);
                    Execute(cmd,e.Client);
                }
                catch (Exception e_)
                {
                    Functions.WriteLog(LogType.Track, typeof(Program), "{0} Data Error:{1} \t {2}", e.Client.Name, e_.Message, DateTime.Now);
                    e.Client.Dispose();
                }
            };
            server.Open(Functions.AppSettingValue("ip"),Functions.AppSettingValue<int>("port"),100);
            Functions.WriteLog(LogType.Track, typeof(Program), "SocketAsyncsForNorthwind.ServerApp Start \t {0}",DateTime.Now);
            Console.Read();

以上是构建一个Tcp服务，并以/r/n作为结束分析协议。

命令分发和处理代码

        static void Execute(Modules.Command cmd,ITcpClient client)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("Execute Command:" + cmd.Type);
            foreach(object item in cmd.Parameters)
            {
                sb.AppendFormat("Parameter:{0}\r\n", item);

            }

            Functions.WriteLog(LogType.Track, typeof(Program), sb.ToString());
            switch (cmd.Type)
            {
                case SocketAsyncsForNorthwind.Modules.CommandType.LoadEmployee:
                    LoadEmployee(cmd,client);
                    break;
                case SocketAsyncsForNorthwind.Modules.CommandType.ListEmployee:
                    ListEmployee(cmd, client);
                    break;

            }
        }
        static void ListEmployee(Modules.Command cmd, ITcpClient client)
        {
            Modules.Result resul = new SocketAsyncsForNorthwind.Modules.Result();
            try
            {
                Expression exp = new Expression();
                if (cmd.Parameters[0] != null)
                    exp &= Modules.Employees.firstName.Match(cmd[0]);
                if (cmd[1] != null)
                    exp &= Modules.Employees.lastName.Match(cmd[0]);
                if (cmd[2] != null)
                    exp &= Modules.Employees.region.Match(cmd[0]);
                resul.Data = exp.List<Modules.Employees>();
            }
            catch (Exception e_)
            {
                resul.ErrorMessage = e_.Message;
            }
            SendData(resul, client);
        }

        static void LoadEmployee(Modules.Command cmd,ITcpClient client)
        {
            Modules.Result resul = new SocketAsyncsForNorthwind.Modules.Result();
            try
            {
                Modules.Employees employee = DBContext.Load<Modules.Employees>(cmd.Parameters[0]);
                resul.Data = employee;
            }
            catch (Exception e_)
            {
                resul.ErrorMessage = e_.Message;
            }
            SendData(resul, client);


        }
        static void SendData(object data, ITcpClient client)
        {
            Modules.MessageAdapter ma = new SocketAsyncsForNorthwind.Modules.MessageAdapter();
            ma.Message = data;
            client.Send(ma);
        }

3)客户端实调用处理
客户端逻辑包装类
由于Smark.SocketAsyncs是基于异步处理的，所以为了方便调用封装一个基本同步发送和接放的包装类。

public class NorthWindClient:IDisposable
    {

        private System.Threading.EventWaitHandle mHandler = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset);
        private TcpClient<EofAtEnter> mClient;
        public NorthWindClient(string ip, int port)
        {
            Init(ip, port);
        }
        private void Init(string ip,int port)
        {
            mClient = TcpServer<TcpClient<EofAtEnter>>.CreateClient(ip, port);
            mClient.Receive();
            mClient.Error += (o, e) => {
                Result = new Result();
                Result.ErrorMessage = e.Exception.Message;
                mHandler.Set();
            };
            mClient.DataReceive += (o, e) => {
                byte[] data = e.Buffer.ToBytes(0, e.Buffer.Count - 2);
                Result = (Modules.Result)Functions.DeserializeObject(data);
                mHandler.Set();
            };
        }
        public Result Result
        {
            get;
            set;
        }
        public IList<Employees> ListEmployees(string firstname, string lastname, string region)
        {
            Result = null;
            Modules.Command cmd = new Command();
            cmd.Type = CommandType.ListEmployee;
            cmd.Parameters.Add(firstname);
            cmd.Parameters.Add(lastname);
            cmd.Parameters.Add(region);
            return (IList<Employees>)SendData(cmd);
        }
        public Employees LoadEmployee(int id)
        {
            Result = null;
            Modules.Command cmd = new Command();
            cmd.Type = CommandType.LoadEmployee;
            cmd.Parameters.Add(id);
           return (Employees) SendData(cmd);



        }
        protected object SendData(object data)
        {
            return SendData(data, 2000);
        }
        protected object SendData(object data,int timeout)
        {
            Modules.MessageAdapter ma = new MessageAdapter();
            ma.Message = data;
            mClient.Send(ma);
            mHandler.Reset();
            mHandler.WaitOne(timeout);
            if (Result == null)
            {
                throw new Exception("超时!");
            }
            else if (Result.ErrorMessage != null)
            {
                throw new Exception(Result.ErrorMessage);
            }
            return Result.Data;
        }
        #region IDisposable 成员

        public void Dispose()
        {
            if (mClient != null)
                mClient.Dispose();
        }

        #endregion
    }

NorthWindClient功能在初始化的时候接入的服务器，每个逻辑在请求时挂起2秒等待处理，处理错误或超时返回异常。当接收到服务端处理完后取消挂起返回处理值。

客户端UI处理代码

    public partial class Form1 : Form
    {
        private Modules.NorthWindClient Client;
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                Smark.SocketAsyncs.Utils.AsyncEventArgsPool_MAX = 10;
                Client = new SocketAsyncsForNorthwind.Modules.NorthWindClient(Functions.AppSettingValue("ip"), Functions.AppSettingValue<int>("port"));
                dataGridView1.DataSource = Client.ListEmployees(null, null, null);
            }
            catch (Exception e_)
            {
                MessageBox.Show(e_.Message);
            }
        }

        private void dataGridView1_SelectionChanged(object sender, EventArgs e)
        {
            if (dataGridView1.SelectedRows.Count>0)
            {
                Modules.Employees emp = (Modules.Employees)dataGridView1.SelectedRows[0].DataBoundItem;
                propertyGrid1.SelectedObject = Client.LoadEmployee(emp.EmployeeID);
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
            dataGridView1.DataSource = Client.ListEmployees(textBox1.Text, textBox2.Text, textBox3.Text);
            }
            catch (Exception e_)
            {
                MessageBox.Show(e_.Message);
            }
        }
    }

相关程序代码:[url:https://smark.svn.codeplex.com/svn/Samples/SocketAsyncsForNorthwind/]

4)简单负载测试

测试用例获取所有Employee数据

本文链接

实现分布式对象锁

2010-06-08T05:18:00Z

在数据操作中经常需要锁一个对象来达到数据同步的目的;在一个应用程序中锁对象比较方便,因为c#提供了线程锁对象功能，但如果是不同服务器的数据操作需要锁对象就必须做一个对象锁服务了。
制定功能方法:

Enter(string owner,string id, int milliseconds)
获取对象锁，直到获取拥用权再往下走
owner:锁的拥有者
id:锁的标识
milliseconds:锁对象的时间，超过这个时间即使程序没有释放标识，组件自动释放
Exit(string owner,string id)
owner:锁的拥有者
TryEnter(string owner, string id, int milliseconds, int timeout)
获取对象锁，在指定时间内没有获取相关标识的锁就放弃往下执行
owner:锁的拥有者
id:锁的标识
milliseconds:锁对象的时间，超过这个时间即使程序没有释放标识，组件自动释放
timeout：超时时间
TryEnter(string id, int milliseconds, int timeout, Smark.Core.AsyncDelegate<string> lockhandler)
获取对象锁，根据情况调用相关回委托
owner:锁的拥有者
id:锁的标识
milliseconds:锁对象的时间，超过这个时间即使程序没有释放标识，组件自动释放
timeout：超时时间
lockhandler:委托

public class ObjectEnter:IDisposable
    {
        private string mOwnerID;
        static ObjectEnter()
        {
            Core.Functions.Action(CheckExpires);
        }
        public ObjectEnter(string id)
        {
            mOwnerID = Guid.NewGuid().ToString("N");
            mID = id;
            Enter(mOwnerID, id, 60000);
        }
        public ObjectEnter(string id, int milliseconds)
        {
            mOwnerID = Guid.NewGuid().ToString("N");
            mID = id;
            Enter(mOwnerID, id, milliseconds);
        }
        private string mID = null;
        private static Dictionary<string, LockItem> mObjectTable = new Dictionary<string, LockItem>(100);
        public static void TryEnter(string id, Smark.Core.AsyncDelegate<string,bool> lockhandler)
        {
            TryEnter(id, 60000, 30000, lockhandler);
        }
        public static void TryEnter(string id, int milliseconds, int timeout, Smark.Core.AsyncDelegate<string,bool> lockhandler)
        {
            string owner = Guid.NewGuid().ToString("N");
            if(lockhandler!=null)
                lockhandler(owner,TryEnter(owner, id, milliseconds, timeout));

        }
        public static bool TryEnter(string owner, string id, int milliseconds, int timeout)
        {
            QueueState state = new QueueState();
            state.EntrerMilliseconds = milliseconds;
            state.TimeOut = timeout;
            if (!GetLockItem(id).Enter(owner, milliseconds, state))
            {
                state.Handler.Reset();
                state.Handler.WaitOne(state.TimeOut);
                return GetLockItem(id).Enter(owner, milliseconds, null);
            }
            else
            {
                return true;
            }

        }
        public static void Enter(string owner,string id, int milliseconds)
        {
            QueueState state = new QueueState();
            state.EntrerMilliseconds = milliseconds;
            if (!GetLockItem(id).Enter(owner, milliseconds, state))
            {
                state.Handler.Reset();
                state.Handler.WaitOne();
            }

        }
        public static void Exit(string owner,string id)
        {
            if (mObjectTable.ContainsKey(id))
                 mObjectTable[id].Exit(owner);

        }
        private static LockItem GetLockItem(string id)
        {
            lock (mObjectTable)
            {
                LockItem item = null;
                if (!mObjectTable.ContainsKey(id))
                {
                    item = new LockItem();
                    item.ID = id;
                    mObjectTable.Add(id, item);
                }
                else
                {
                    item = mObjectTable[id];
                }
                return item;
            }

        }
        private static void CheckExpires()
        {
            while (true)
            {
                lock (mObjectTable)
                {
                    foreach (System.Collections.Generic.KeyValuePair<string, LockItem> item in mObjectTable)
                    {
                        item.Value.Expires();
                    }
                }
                System.Threading.Thread.Sleep(5000);
            }
        }
        class LockItem
        {
            const string SYSTEM_ID = "SYSTEM_4EB49CA1-7470-44af-94DE-B2128B9B5BA9";
            public LockItem()
            {

            }
            public bool Enter(string owner, int milliseconds, QueueState handler)
            {
                lock (this)
                {
                    if (Count>0 && owner != Owner)
                    {

                        if (handler != null)
                            EnterWait(handler);
                        return false;
                    }
                    Count++;
                    EntrerMilliseconds = milliseconds;
                    EnterTime = DateTime.Now;
                    return true;
                }
            }

            private void EnterWait(QueueState handler)
            {
                lock (mWaitHandle)
                {
                    mWaitHandle.Enqueue(handler);

                }

            }
            private Queue<QueueState> mWaitHandle = new Queue<QueueState>();

            public void Exit(string owner)
            {
                lock (this)
                {
                    if (owner == SYSTEM_ID)
                    {
                        Owner = null;
                        Count = 0;

                    }
                    else
                    {
                        if (owner == Owner)
                        {
                            Count--;
                        }
                    }
                    if (Count == 0)
                    {
                        lock (mWaitHandle)
                        {
                            if (mWaitHandle.Count > 0)
                            {
                                QueueState state = mWaitHandle.Dequeue();
                                state.Handler.Set();
                            }
                        }
                    }


                }
            }
            public int EntrerMilliseconds
            {
                get;
                set;
            }
            public DateTime EnterTime
            {
                get;
                set;
            }
            public string ID
            {
                get;
                set;
            }
            public string Owner
            {
                get;
                set;
            }
            public int Count
            {
                get;
                set;
            }
            public void Expires()
            {
                lock (this)
                {
                    TimeSpan ts = DateTime.Now - EnterTime;
                    if (ts.TotalMilliseconds > EntrerMilliseconds)
                        Exit(SYSTEM_ID);
                }
            }
        }

        #region IDisposable 成员
        private bool mDisposed = false;
        public void Dispose()
        {
            lock (this)
            {
                if (!mDisposed)
                {
                    Exit(mID,mOwnerID);
                    mDisposed = true;
                }
            }

        }

        #endregion
    }
    class QueueState
    {
        public QueueState()
        {
            EntrerMilliseconds = 60000;
        }
        public bool Idle
        {
            get;
            set;
        }
        public int EntrerMilliseconds
        {
            get;
            set;
        }
        public int TimeOut
        {
            get;
            set;
        }
        private System.Threading.EventWaitHandle mHandler = new EventWaitHandle(false, EventResetMode.ManualReset);
        public System.Threading.EventWaitHandle Handler
        {
            get
            {
                return mHandler;
            }

        }
    }

实现相关锁的ＷＥＢ服务

    /// <summary>
    /// 对象锁服务
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    public class ObjectEnterService : System.Web.Services.WebService
    {

        [WebMethod]
        public string TryEnter(string id, int seconds, int timeout)
        {
            string owner = null;
            Core.ObjectEnter.TryEnter(id, seconds * 1000, timeout * 1000, (o, Success) =>
            {
                if(Success)
                    owner = o;
            });
            return owner;
        }
        [WebMethod]
        public void Exit(string owner, string id)
        {
            Core.ObjectEnter.Exit(owner, id);
        }
    }

服务比较简单如果能锁住对象就返回一个拥有者的ID,释放的时候需要转入这个拥有者的ID和锁标识.

本文链接

发布一个C#实现的Asterisk的管理系统

2010-05-17T19:07:00Z

协议:Apache License Version 2.0

svn:https://smark.svn.codeplex.com/svn/Smark/Smark.Asterisk.Services

l        主要功能

       通过AMI和AGI来接管Asterisk的拔打控制,实现多台asterisk网内拔打可配置、对接电信移动可配置、回拔和预约回拔、拔打记录和费用结算等功能。
进行程序测试的asterisk版本是:1.6.2

       AMI的主要实现是监控用户登陆所在的服务器并登记处理和向asterisk发起回拔功能。

AGI的主要实现是接管用户拔打规则，根据配置来处理用户当拔打的号码是网内拔打还是对接到电信或移动的落地接口服务器、登记用户拔打信息和费用计算等功能。

l 配置AMI服务

AMI服务主要是连接Asterisk后接读取Asterisk的处理信息或执行对Asterisk的管理操作。程序会根据AMINet表的记录来连接相关服务器。

IPAddress

Asterisk IP地址

Port

服务端口

UserName

登陆用户

UserPWD

登陆密码

Asterisk的管理服务配置在:/etc/asterisk/manager.conf

l 配置AGI服务

AGI是程序本地监听的服务，主要是接管Asterisk的拔号处理。程序根据AGINet表的记录来启动AGI服务。

IPAddress

监听的IP地址

Port

监听的端口

l 拔号规则流程

当AGI直接收用户拔号后先查询号码是否本网号码，根据号码登陆的IP来查找对接的AsteriskIP地址，当找不到的情况下就去查找号码对应描述的电信或移动对接服务器，如果以上都不能找到的情况返回本网内对接。

配置/etc/asterisk/extensions.conf把特定的号码规则转发到AGI来处理。

l 配置asterisk网内对接描述

用于存在多台Asterisk的时候描述相关对接的用户，可以在AsteriskTRUNK中添加相关信息。

IPAddress

AsteriskIP地址

TRUNK

转接用户

Format

号码格式化描述;如:0-1就是把开头0用1代替后再对接过去

DialTimeOut

对接等待超时时间

DialMusic

对接等待时所播放的彩铃

注意：asterisk必须存在对应TRUNK用户

l 配置电信或移动对接描述

配置和外网对接的用户信息，可以在PhoneTRUNK中添加相关信息。

Prefix

号码前缀

Enabled

是否有效

Format

号码格式化

TRUNK

转接用户

DialTimeOut

对接等待超时时间

DialMusic

对接等待时所播放的彩铃

注意：asterisk必须存在对应TRUNK用户

l 用户信息

用户费用信息表Accounts，只是实现简单的费用所以表结构非常简单。

AccountID

帐号名

Amount

金额

可以根据自己需要添加一些字段；如果用户无效，当用户使用该帐号拔的时候根据有效性来提示用户。

l 费用

Fee是用来描述拔打费用单价的。

Prefix

计费前缀

Price

单价

Second

单位时间（秒为单位）

l 发起回拔

只需要向表CallBack添加相关记录，系统就自动发起回拔。

ID

Account

计费帐号

Callerid

FromPhone

主叫号

ToPhone

被叫号

Context

拔号规则类别

Priority

拔号规则类别的第X的规则

Codes

编码：ulaw,alaw,g729等，具体情况

State

记录状态

CreateTime

创建时间

l 语音回拔服务的IVR

由asterisk发起回拔给主叫用户，主叫用户接听后进行语音提示用户输出需要拔打的号码，输入#后进行转呼。

[smark]

exten => 99999999,1,Goto(CallBack,s,1)

exten => _.,1,AGI(agi://192.168.1.128:9001,${EXTEN},"HENRY")

[CallBack]

exten => s,1,Answer()

exten => s,2,Set(TRY=0)

exten => s,3,set(CALLPHONE=)

exten => s,4,Background(InputCalled)

exten => s,5,Set(TRY=$[${TRY}+1])

exten => s,6,GotoIf($[${TRY}<3]?8)

exten => s,7,Goto(smark,cberror,1)

exten => s,8,Noop()

exten => s,9,WaitExten(10)

exten => s,10,Goto(3)

exten => #,1,Goto(smark,${CALLPHONE},1)

exten => *,1,Goto(s,3)

exten => i,1,Set(CALLPHONE=${CALLPHONE}${INVALID_EXTEN})

exten => i,2,NoOp(${CALLPHONE})

exten => i,3,Goto(s,8)

exten => h,1,Goto(smark,cberror,1)

本文链接

asterisk使用SIP相互对接

2010-05-11T04:04:00Z

当用户数量上去,单凭一台asterisk是很能支持庞大的用户群体,所以要根据用户量来部署多台asterisk来应付实际情况的需求.但部署多台asterisk所带来的一个问题就是A服务器的用户如果Call B服务器的用户呢?其实asterisk的设计者早已帮我们解决问题,以下是通过SIP把两台asterisk对接起来(不过官方推荐asterisk的对接用AIX).

分别在192.168.1.21 和192.168.1.22两台服务器上装上asterisk,然后配置各自的用户，TRUNK和转发规则。

配置192.168.1.21

   打开/etc/asterisk/sip.conf

   在[general]组下添加注册到22的命令

    register=>AST22:123456@192.168.1.22

   然后在文件尾添加相关组信息

    [AST21]

type=friend

secret=123456

host=dynamic

username=AST21

disallow=all

allow=ulaw;alaw

context=FROMSIP

[22TRUNK]

type=friend

username=AST22

secret=123456

host=192.168.1.22

dtmfmode=rfc2833

context=FROMSIP

fromuser=AST22

insecure=very

    打开/etc/asterisk/extensions.conf 添加下面内容

    [FROMSIP]

    Exten => _90.,1,dila(sip/91${exten:2}@22TRUNK,40,m(default))

     拔打90开头的号码，把91代替90后转发192.168.1.22,拔打等待40秒，等待的时候播放default这个采铃。

     Exten => _91.,1,dial(sip/${exten:2},40,m(default))

     当接收到91开头的号码，把91后面的号码进行内部呼叫。

配置192.168.1.22

打开/etc/asterisk/sip.conf

    在[general]组下添加注册到22的命令

    register=>AST21:123456@192.168.1.21

    然后在文件尾添加相关组信息

[AST22]

type=friend

secret=123456

host=dynamic

username=AST22

disallow=all

allow=ulaw;alaw

context=FROMSIP

[21TRUNK]

type=friend

username=AST21

secret=bsmofeng

host=192.168.1.21

fromuser=AST21

dtmfmode=rfc2833

context=FROMSIP

insecure=very

    打开/etc/asterisk/extensions.conf 添加下面内容

    [FROMSIP]

     Exten => _90.,1,dila(sip/91${exten:2}@21TRUNK,40,m(default))

     拔打90开头的号码，把91代替90后转发192.168.1.21,拔打等待40秒，等待的时候播放default这个采铃。

     Exten => _91.,1,dial(sip/${exten:2},40,m(default))

     当接收到91开头的号码，把91后面的号码进行内部呼叫。

这样就配置好了两台asterisk的sip对接，不过当用户数量庞大和分布在不同地区显然2台asterisk不足以应付的。在N台asterisk下通过手动配置conf文件来实现对接是不可能的，因为用户会根据不同情况可能登陆不同的asterisk里，在这情况exten是无法固下来；这个时候就可能采asterisk的AMI和AGI来动态处理，通过AMI来获取号码登陆的asterisk服务器地址,AGI在根据号码所在asterisk做一个动态的TRUNK拔打就行。

作为一个语音较交换服务器asterisk的确算是一个好的产品，他除了开源外，还提供AMI，AGI等接口；使其他语言平台通过这些接口来扩展自己的业务需求。

本文链接

开源一个基于Flex4+C#的个人信息管理程序

2010-04-28T08:53:00Z

其实项目一开始就放到了codeplex，本来打算完成后成发布的，不过现有些事忙估计要完成的时间比较久，所以提前发布出来。项目采用Apache License，有兴趣的朋友可以参考或拿下来完善。

SVN地址: https://smark.svn.codeplex.com/svn/FlashBuilder

最终可以部署的WEB项目:https://smark.svn.codeplex.com/svn/FlashBuilder/PIM/C%23/PIM/PIM.WebApp/

关联项目SVN: https://smark.svn.codeplex.com/svn

本文链接

FlashBuilder4试用

2010-03-27T02:35:00Z

很早之前就听说Flex Builder3的新版本FlashBuilder4的事情,由于没有出正式版所以一直没有下载来试用下,昨天听同说已经出了正式版所以下载拿用了一下.总体使用感觉还可以,IDE的速度明显比Flex builder3有所提高,不过提供的控件发生了变化,所以对应MXML名称空间也发生了改变有点不太适应.有些旧的控件已经在IDE的工具栏里找不到了，不过可以手动编写MXML里得到提示。代码的布局说实话没有Flex Builder3好，行距太紧凑看到眼累…不多说了下面用FlashBuilder4做个简单的应用。

需要完成的功能：

一个简单的客户查询，当选择客户里查看他相关的订单和订单明细。所涉及的业务逻辑有三个。

定义相关业务逻辑方法:

public class Services

{

public IList<Entities.Customers> CustomerList(string companyname)

{

Expression exp = new Expression();

if (!string.IsNullOrEmpty(companyname))

exp &= Entities.Customers.companyName.Match(companyname);

return exp.List<Entities.Customers>();

}

public IList<Entities.Orders> OrderList(string customerid)

{

return (Entities.Orders.customerID == customerid).List<Entities.Orders>();

}

public IList<Entities.OrderDetails> DetailList(int orderid)

{

return (Entities.OrderDetails.orderID == orderid).List<Entities.OrderDetails>();

}

下面定义对应AS的调用类：

import Core.Utility;

import Core.ActionBase;

/**

* Action Script调用方法生成工具1.2 生成时间:2010-3-26 17:42:59

public dynamic class Services_CustomerList extends ActionBase

{

public var companyname:Object;

}

import Core.Utility;

import Core.ActionBase;

/**

* Action Script调用方法生成工具1.2 生成时间:2010-3-26 18:44:06

public dynamic class Services_OrderList extends ActionBase

{

public var customerid:Object;

}

import Core.Utility;

import Core.ActionBase;

/**

* Action Script调用方法生成工具1.2 生成时间:2010-3-27 9:04:26

public dynamic class Services_DetailList extends ActionBase

{

public var orderid:Object;

}

逻辑代码准备好后，就开始写界面了。对于FlashBuilder4编写UI提供什么快速度的方式我没有研究，还是使用最原始的方式直接手动编写MXML的方式(感觉熟悉后这样比鼠标拖来拖去要快)…..

先实现左边的客户信息查询：

        <s:Panel width="379" height="100%" title="客户">
            <s:layout>
                <s:VerticalLayout/>
            </s:layout>
            <s:BorderContainer width="100%" height="50" backgroundColor="#F4F4F4">
                <s:TextInput x="8" y="12" text="@{mCustomerList.companyname}" width="199"/>
                <s:Button x="213" y="12" label="查询">
                    <s:click>
                        <![CDATA[
                        mCustomerList.Execute();
                        ]]>
                    </s:click>
                </s:Button>
            </s:BorderContainer>
            <mx:List id="lstcustomer" dataProvider="{mCustomerList.Result.Data.Customers}" borderVisible="false" width="100%" height="100%">
                <mx:itemRenderer>
                    <fx:Component>
                        <mx:VBox horizontalScrollPolicy="off" verticalScrollPolicy="off">


                        <mx:Form verticalGap="1">
                            <mx:FormItem label="ID:">
                                <s:Label text="{data.CustomerID}"/>
                            </mx:FormItem>
                            <mx:FormItem label="Company:">
                                <s:Label text="{data.CompanyName}"/>
                            </mx:FormItem>
                            <mx:FormItem label="Phone:">
                                <s:Label text="{data.Phone}"/>
                            </mx:FormItem>
                            <mx:FormItem label="City">
                                <s:Label text="{data.Country}({data.Region})-{data.City}"/>
                            </mx:FormItem>
                            <mx:FormItem label="Address:">
                                <s:Label text="{data.Address}"/>
                            </mx:FormItem>

                        </mx:Form>
                            <mx:HRule height="1" width="100%"/>
                        </mx:VBox>
                    </fx:Component>
                </mx:itemRenderer>
                <mx:change>
                    <![CDATA[
                        mOrderList.customerid = lstcustomer.selectedItem.CustomerID;
                        mOrderList.Execute();
                    ]]>
                </mx:change>
            </mx:List>
        </s:Panel>

在FlashBuilder 4里提供一个不错的功能就是控件值修改同步到对象成员中的功能，绑定的定义也很简单在原来的基础上加个@标识就是了："@{mCustomerList.companyname}。在FlashBuilder 4提供的List控件对提供数据有要求必须是IList，XMLList对象无法绑定，只有用Flex3所提供的List控件了。在List的change事件中调用了OrderList查询来获取订单信息。

接下来看订单查询的UI输出描述:

<mx:List dataProvider="{mOrderList.Result.Data.Orders}" width="100%" height="100%" borderStyle="none">
                <mx:itemRenderer>
                    <fx:Component>
                        <mx:VBox verticalScrollPolicy="off" horizontalScrollPolicy="off">
                            <mx:Grid verticalGap="20" borderStyle="outset" borderColor="#D5D5D5" width="100%" paddingLeft="5" paddingTop="5" paddingRight="5" paddingBottom="5" verticalAlign="top">
                                <mx:GridRow verticalAlign="middle">
                                    <mx:GridItem verticalAlign="bottom">
                                        <s:Label text="Employee:" fontWeight="bold" fontStyle="italic"/>

                                    </mx:GridItem>
                                    <mx:GridItem verticalAlign="bottom">
                                        <s:Label text="{data.EmployeeName}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <mx:PopUpButton label="Details" click="event.target.open()">
                                            <mx:popUp>
                                                <mx:DataGrid dataProvider="{mDetailList.Result.Data.OrderDetails}" dropShadowVisible="true" borderVisible="true" borderColor="#969696" borderStyle="outset" height="100%">
                                                    <mx:columns>
                                                        <mx:DataGridColumn dataField="ProductName"/>
                                                        <mx:DataGridColumn dataField="UnitPrice"/>
                                                        <mx:DataGridColumn dataField="Quantity"/>
                                                        <mx:DataGridColumn dataField="Discount"/>
                                                    </mx:columns>
                                                </mx:DataGrid>
                                            </mx:popUp>
                                        </mx:PopUpButton>
                                    </mx:GridItem>
                                </mx:GridRow>
                                <mx:GridRow  verticalAlign="middle">
                                    <mx:GridItem>
                                        <s:Label text="OrderDate:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label  text="{data.OrderDate}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="RequiredDate:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.RequiredDate}"/>
                                    </mx:GridItem>
                                </mx:GridRow>

                                <mx:GridRow  verticalAlign="middle">
                                    <mx:GridItem>
                                        <s:Label text="ShippedDate:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label  text="{data.ShippedDate}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="ShipVia:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.ShipVia}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="Freight:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.Freight}"/>
                                    </mx:GridItem>
                                </mx:GridRow>

                                <mx:GridRow  verticalAlign="middle">
                                    <mx:GridItem>
                                        <s:Label text="ShipName:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label  text="{data.ShipName}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="ShipCountry:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.ShipCountry}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="ShipRegion:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.ShipRegion}"/>
                                    </mx:GridItem>
                                </mx:GridRow>

                                <mx:GridRow  verticalAlign="middle">
                                    <mx:GridItem>
                                        <s:Label text="ShipCity:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label  text="{data.ShipCity}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="ShipPostalCode:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.ShipPostalCode}"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="ShipAddress:" fontWeight="bold" fontStyle="italic"/>
                                    </mx:GridItem>
                                    <mx:GridItem>
                                        <s:Label text="{data.ShipAddress}"/>
                                    </mx:GridItem>
                                </mx:GridRow>

                            </mx:Grid>
                            <mx:creationComplete>
                                <![CDATA[
                                    if(data !=null)
                                    {
                                        mDetailList.orderid = data.OrderID;
                                        mDetailList.Execute();
                                    }
                                ]]>
                            </mx:creationComplete>


                            <fx:Script>
                                <![CDATA[
                                    import Api.Services_DetailList;
                                    private var mDetailList:Services_DetailList = new Services_DetailList();
                                ]]>
                            </fx:Script>
                        </mx:VBox>

                    </fx:Component>
                </mx:itemRenderer>
            </mx:List>

总的来说FlashBuilder4在编写应用的时候和Flex3没有多的差异，如果本身对Flex3熟悉的朋友那马上转用FlashBuilder4应该不存在问题。

下载完整代码

本文链接

IPAddress	Asterisk IP地址
Port	服务端口
UserName	登陆用户
UserPWD	登陆密码

IPAddress	AsteriskIP地址
TRUNK	转接用户
Format	号码格式化描述;如:0-1就是把开头0用1代替后再对接过去
DialTimeOut	对接等待超时时间
DialMusic	对接等待时所播放的彩铃

Prefix	号码前缀
Enabled	是否有效
Format	号码格式化
TRUNK	转接用户
DialTimeOut	对接等待超时时间
DialMusic	对接等待时所播放的彩铃

Prefix	计费前缀
Price	单价
Second	单位时间（秒为单位）

ID
Account	计费帐号
Callerid
FromPhone	主叫号
ToPhone	被叫号
Context	拔号规则类别
Priority	拔号规则类别的第X的规则
Codes	编码：ulaw,alaw,g729等，具体情况
State	记录状态
CreateTime	创建时间

博客园_.Net 泥水佬

Smark.Net.Tcp.XmlService性能测试程序

基于Flex的http简易文件管理工具

性能的瓶颈到底在那呢?

运用Smark.SocketAsyncs扩展基于XML的TCP服务

运用Smark.SocketAsyncs方便实现数据交互服务

实现分布式对象锁

发布一个C#实现的Asterisk的管理系统

协议:Apache License Version 2.0

svn:https://smark.svn.codeplex.com/svn/Smark/Smark.Asterisk.Services

l 配置AGI服务 AGI是程序本地监听的服务，主要是接管Asterisk的拔号处理。程序根据AGINet表的记录来启动AGI服务。 IPAddress 监听的IP地址 Port 监听的端口

l 用户信息 用户费用信息表Accounts，只是实现简单的费用所以表结构非常简单。 AccountID 帐号名 Amount 金额 可以根据自己需要添加一些字段；如果用户无效，当用户使用该帐号拔的时候根据有效性来提示用户。

l 费用 Fee是用来描述拔打费用单价的。 Prefix 计费前缀 Price 单价 Second 单位时间（秒为单位）

asterisk使用SIP相互对接

开源一个基于Flex4+C#的个人信息管理程序

FlashBuilder4试用

l 配置AGI服务

AGI是程序本地监听的服务，主要是接管Asterisk的拔号处理。程序根据AGINet表的记录来启动AGI服务。

IPAddress

监听的IP地址

Port

监听的端口

l 用户信息

用户费用信息表Accounts，只是实现简单的费用所以表结构非常简单。

AccountID

帐号名

Amount

金额

可以根据自己需要添加一些字段；如果用户无效，当用户使用该帐号拔的时候根据有效性来提示用户。

l 费用

Fee是用来描述拔打费用单价的。

Prefix

计费前缀

Price

单价

Second

单位时间（秒为单位）