关于Romoting又一例

关于Romoting又一例
--------------------
本文主要描述了Romoting的远程对象定义，以及工厂模式的用法,
事件的相关知识，
为了安全，可分三个组件，BLLObject.dll共用接口组件，BLLService.dll(exe)服务器组件商务逻辑实现代码
BLLClient.dll客户端引用的且只定义不实现的与服务器组件相同命名空间和类名的组件库,
废话少说，请看代码：


FaxService.cs
-------------------------------------------------
/// <summary>
    /// 功能：传真服务(即客户端向服务端发传真信息)
    /// vp:hsg
    /// create date:2011-09-29
    /// version:1.0
    /// </summary>
    public class FaxService : MarshalByRefObject,IRegisterSelf, IFaxService
    {
        private static List<string> FaxList = new List<string>();
        public  static event FaxEventHandler FaxSendedEvent=null;
        public FaxService()
        {
            init();
        }
        public override object InitializeLifetimeService()
        {
            return null;
        }
        public static void init()
        {
            FaxService.FaxSendedEvent += new FaxEventHandler(FaxService_FaxSendedEvent);
        }
        public static void Close()
        {
            FaxService.FaxSendedEvent -= new FaxEventHandler(FaxService_FaxSendedEvent);
            FaxList.Clear();
        }
        private static void FaxService_FaxSendedEvent(string fax)
        {
            FaxList.Add(fax);
            errorlog.WriteLine("ServiceIn_fax=" + fax);
        }


        #region IFaxService 成员


        public void SendFax(string fax)
        {
            if (FaxSendedEvent != null)
            {
                FaxSendedEvent(fax);
            }


        }


        #endregion
        
        #region IRegisterSelf 成员


        public void RegisterSelf()
        {
            RemotingConfiguration.RegisterWellKnownServiceType(typeof(FaxService), "FaxService", 


WellKnownObjectMode.Singleton);
        }


        #endregion
        //
    }


BroadCastService.cs文件内容如下：
----------------------------------------------------------------------------------------------
public class BroadCastService : MarshalByRefObject, IRegisterSelf, IBroadCastService
    {
        public BroadCastService()
        {
        }


        public override object InitializeLifetimeService()
        {
            return null;
        }


        #region IRegisterSelf 成员


        public void RegisterSelf()
        {
            RemotingConfiguration.RegisterWellKnownServiceType(typeof(BroadCastService), "BroadCastService", 


WellKnownObjectMode.Singleton);
        }
        #endregion


        #region IBroadCastService 成员


        public event BroadCastEventHandler BroadCastEvent=null;


        public void BroadCastingInfo(string info)
        {
            //errorlog.WriteLine("BroadCastService.cs/36="+info);
            if (BroadCastEvent != null)
            {
                //BroadCastEvent(info);
                BroadCastEventHandler tempEvent = null;
                int index = 1; //记录事件订阅者委托的索引，为方便标识，从1开始。
                foreach (Delegate del in BroadCastEvent.GetInvocationList())
                {
                    try
                    {
                        tempEvent = (BroadCastEventHandler)del;
                        if (tempEvent != null)
                        {


                            tempEvent(info);
                        }
                    }
                    catch (Exception ee)
                    {
                        //errorlog.WriteLine("执行BroadCast:BroadCastingInfo(string info):" + ee.ToString());
                        //MessageBox.Show("事件订阅者" + index.ToString() + "发生错误,系统将取消事件订阅!");
                        BroadCastEvent -= tempEvent;
                    }
                    index++;
                }
            }
            else
            {
                //errorlog.WriteLine("BroadCast事件为空!");
            }
            //
        }


        #endregion
    }


BFFactory.cs类的定义
-----------------------------------------------------------
/// <summary>
    /// 功能：BF 工厂类
    /// vp:hsg
    /// create date:2011-09-29
    /// version:1.0
    /// </summary>
    public class BFFactory : MarshalByRefObject, IRegisterSelf, IBFFactory,IDisposable 
    {
        public BFFactory()
        {
        }


        //生命周期为无限
        public override object InitializeLifetimeService()
        {
            //return base.InitializeLifetimeService();
            return null;
        }


        #region IRegisterSelf 成员


        public void RegisterSelf()
        {
            RemotingConfiguration.RegisterWellKnownServiceType(typeof(BFFactory), "BFFactory", 


WellKnownObjectMode.Singleton);
        }


        #endregion


        #region IDisposable 成员


        public void Dispose()
        {
            if (m_IBaseService != null)
            {
                m_IBaseService = null;
            }
            if (m_IDatabaseService != null)
            {
                m_IDatabaseService.Dispose();
                m_IDatabaseService = null;
            }
            if (m_FaxService != null)
            {
                FaxService.FaxSendedEvent -= new FaxEventHandler(FaxService_FaxSendedEvent);
                FaxService.Close();
                m_FaxService = null;
            }
            if (m_BroadCastService != null)
            {
                RemotingServices.Disconnect(m_BroadCastService as MarshalByRefObject);
                m_BroadCastService = null;
            }
        }


        #endregion


        #region IBFFactory 成员
        private IBaseService m_IBaseService = null;
        public IBaseService GetBaseService()
        {
            if (m_IBaseService == null)
            {
                m_IBaseService = new BaseService();
                (m_IBaseService as IRegisterSelf).RegisterSelf();
            }
            return m_IBaseService;
        }
        private IDatabaseService m_IDatabaseService = null;
        public IDatabaseService GetDatabaseService()
        {
            if (m_IDatabaseService == null)
            {
                m_IDatabaseService = new DatabaseService();
                (m_IDatabaseService as IRegisterSelf).RegisterSelf();
            }
            return m_IDatabaseService;
        }


        private IFaxService m_FaxService = null;
        public IFaxService GetFaxService()
        {
            if (m_FaxService == null)
            {
               m_FaxService= new FaxService();
               (m_FaxService as IRegisterSelf).RegisterSelf();
               FaxService.FaxSendedEvent -= new FaxEventHandler(FaxService_FaxSendedEvent);
               FaxService.FaxSendedEvent += new FaxEventHandler(FaxService_FaxSendedEvent);
            }
            return m_FaxService;
        }


        private void FaxService_FaxSendedEvent(string fax)
        {
            //errorlog.WriteLine("ServiceFactory_fax=" + fax);
            //接收到传真后,从服务器端发广播
            IBroadCastService bcs = GetBroadCastService();            
            bcs.BroadCastingInfo(fax);
        }


        private BroadCastService m_BroadCastService = null;
        private ObjRef m_bcsRef = null;
        public IBroadCastService GetBroadCastService()
        {
            //errorlog.WriteLine("BC_1");
            if (m_BroadCastService == null)
            {
                //errorlog.WriteLine("BC_2");
                m_BroadCastService = new BroadCastService();
                //(m_BroadCastService as IRegisterSelf).RegisterSelf();
                m_bcsRef = RemotingServices.Marshal(m_BroadCastService, "BroadCastService");
            }
            //errorlog.WriteLine("BC_3");
            return m_BroadCastService;
        }




        #endregion
                
        //
    }


//服务器端初始化方法
---------------------------------------------------------
app.config
<configuration>
  <appSettings>
    <add key="tcpport" value="9999"/>
    <add key="httpport" value="8888"/>
  </appSettings>  
</configuration>
------------------------------------------------------
public void init()
        {
            try
            {
                //default=9999
                string tcpport_str = ConfigurationManager.AppSettings["tcpport"];
                int tcpport = int.Parse(tcpport_str);


                //default=8888
                string httpport_str = ConfigurationManager.AppSettings["httpport"];
                int httpport = int.Parse(httpport_str);


                远程对象并自注册
                //baseService = new BaseService();
                //baseService.RegisterSelf();


                //dbService = new DatabaseService();
                //dbService.RegisterSelf();


                //远程对象并自注册
                BFFact = new BFFactory();
                BFFact.RegisterSelf();


                //
                //initOneTcpChannel(tcpport);
                initMuliChanel(tcpport, httpport);
                
            }
            catch (Exception ee)
            {
                errorlog.WriteLine(ee.ToString());
            }
        }


        //关闭服务功能
        public void CloseService()
        {
            try
            {
                //if (baseService != null)
                //{
                //    baseService = null;
                //}
                //if (dbService != null)
                //{
                //    dbService.Dispose();
                //    dbService = null;
                //}
                if (BFFact != null)
                {
                    BFFact.Dispose();
                    BFFact = null;
                }
                if (tcpchannel != null)
                {
                    ChannelServices.UnregisterChannel(tcpchannel);
                    tcpchannel = null;
                }
                if (httpchannel != null)
                {
                    ChannelServices.UnregisterChannel(httpchannel);
                    httpchannel = null;
                }
            }
            catch (Exception ee)
            {
                errorlog.WriteLine(ee.ToString());
            }
        }


        //注册一个Tcp通道方法
        public void initOneTcpChannel(int port)
        {            
            //注册Tcp通道
            tcpchannel = new TcpChannel(port);
            ChannelServices.RegisterChannel(tcpchannel, false);
        }


        //注册多通道方法
        public void initMuliChanel(int tcpPort,int httpPort)
        {
            //注册Tcp通道  9999
            IDictionary tcpProp = new Hashtable();
            tcpProp["name"] = "tcp" + tcpPort;
            tcpProp["port"] = tcpPort;
            IClientChannelSinkProvider ccsp=new BinaryClientFormatterSinkProvider();
            BinaryServerFormatterSinkProvider scsp = new BinaryServerFormatterSinkProvider();
            scsp.TypeFilterLevel = TypeFilterLevel.Full;
            tcpchannel = new TcpChannel(tcpProp, ccsp, scsp);
            ChannelServices.RegisterChannel(tcpchannel,false);


            //注册Http通道  8888
            IDictionary httpProp = new Hashtable();
            httpProp["name"] = "http" + httpPort;
            httpProp["port"] = httpPort;
            IClientChannelSinkProvider ccsp_soap=new SoapClientFormatterSinkProvider();
            SoapServerFormatterSinkProvider scsp_soap = new SoapServerFormatterSinkProvider();
            scsp_soap.TypeFilterLevel = TypeFilterLevel.Full;
            httpchannel = new HttpChannel(httpProp, ccsp_soap, scsp_soap);
            ChannelServices.RegisterChannel(httpchannel,false);
        }


客户端实始化代码
-------------------------------------------------------------------------------------------------
<configuration>
  <appSettings>
    <add key ="BFFactoryUrl" value ="tcp://192.168.1.249:9999/BFFactory"/>
    <!--
      <add key ="BFFactoryUrl" value ="http://192.168.1.249:8888/BFFactory"/>
    -->
  </appSettings>  
</configuration>
------------------------------------------------------------------
//RemoteService方法
        private IBFFactory m_BFFactory = null;
        public IBFFactory BFFactory
        {
            get
            {
                if (m_BFFactory == null)
                {
                    string BFFactoryUrl = ConfigurationManager.AppSettings["BFFactoryUrl"];
                    m_BFFactory = (IBFFactory)Activator.GetObject(typeof(IBFFactory), BFFactoryUrl);
                }
                return m_BFFactory;
            }
        }


        private IBaseService m_BaseService = null;
        public IBaseService BaseService
        {
            get
            {
                if (m_BaseService == null)
                {
                    m_BaseService = BFFactory.GetBaseService();
                }
                return m_BaseService;
            }
        }
        private IDatabaseService m_DatabaseService = null;
        public IDatabaseService DatabaseService
        {
            get
            {
                if (m_DatabaseService == null)
                {
                    m_DatabaseService = BFFactory.GetDatabaseService();
                }
                return m_DatabaseService;
            }
        }


        private IBroadCastService m_BroadCastService = null;
        public IBroadCastService BroadCastService
        {
            get
            {
                if (m_BroadCastService == null)
                {
                    m_BroadCastService = BFFactory.GetBroadCastService();                    
                }
                return m_BroadCastService;
            }
        }
        private EventWrapper wrapper = null;
        public void initBroadCastService()
        {   //初始化广播服务
            BinaryServerFormatterSinkProvider serverProvider = new  BinaryServerFormatterSinkProvider();
            BinaryClientFormatterSinkProvider clientProvider = new  BinaryClientFormatterSinkProvider();
            serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
            IDictionary props = new Hashtable();
            props["name"] = "tcp0";
            props["port"] = 0;
            HttpChannel channel = new HttpChannel(props, clientProvider, serverProvider);
            ChannelServices.RegisterChannel(channel,false);


            wrapper = new EventWrapper();
            wrapper.RegisterSelf();
            wrapper.LocalBroadCastEvent += new BroadCastEventHandler(BroadCastService_BroadCastEvent);
            BroadCastService.BroadCastEvent += new BroadCastEventHandler(wrapper.BroadCasting);
            //
        }
        public void CloseBroadCastService()
        {
            if (wrapper != null)
            {
                wrapper.LocalBroadCastEvent -= new BroadCastEventHandler(BroadCastService_BroadCastEvent);
                BroadCastService.BroadCastEvent -= new BroadCastEventHandler(wrapper.BroadCasting);
            }
        }


        private void BroadCastService_BroadCastEvent(string info)
        {
            try
            {
                MessageBox.Show(info, "提示");                
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message, "提示");
            }
        }
-----------------------
--the end----

转载于:https://www.cnblogs.com/sqlite3/archive/2011/09/30/2566815.html