博客园_.Net 泥水佬

基于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.0svn:https://smark.svn.codeplex.com/svn/Smark/Smark.Asterisk.Servicesl 主要功能通过AMI和AGI来接管Asterisk的拔打控制,实现多台asterisk网内拔打可配置、对接电信移动可配置、回拔和预约回拔、拔打记录和费用结算等功能。进行程序测试的asterisk版本是:...

asterisk使用SIP相互对接

2010-05-11T04:04:00Z

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

开源一个基于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/Fl...

FlashBuilder4试用

2010-03-27T02:35:00Z

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

这样的重构是否有必要呢？

2010-01-19T05:16:00Z

在写数据查询的业务逻辑里，经常需要对查询条件进行合并；对于条件的构造是否有必要构造一个新的类把条件构造分离出来提供其条件的重用性呢？首先看下代码: public IList BalancesList( [Bind(Convert = typeof(ToEnum))]BalanceState? state, DateTime? ...