WCF服务

最新推荐文章于 2024-01-31 13:07:34 发布
最新推荐文章于 2024-01-31 13:07:34 发布
阅读量777 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c# 文章标签： c# wcf 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cuiweibin5/article/details/37564493

最近写了一个小的东西，其中用到了WCF的REST服务，简单的分享一下，如果有不对的地方请海涵。

1:定义实体类

 [Serializable]
    public class ConnectService
    {

        private string NVSid;
        public string NVSID
        {
            get { return NVSid; }
            set { this.NVSid = value; }
        }

        private int port;
        public int Port
        {
            get { return port; }
            set { this.port = value; }
        }

        private int serviceType;
        public int ServiceType
        {
            get { return serviceType; }
            set { this.serviceType = value; }
        }

        private string serviceName;
        public string ServiceName
        {
            get { return serviceName; }
            set { this.serviceName = value; }
        }

        private string connectDateTime;
        public string ConnectDateTime
        {
            get { return connectDateTime; }
            set { this.connectDateTime = value; }
        }

           private int state;
        public int State
        {
            get { return state; }
            set { this.state = value; }
        }

        private string desc;
        public string Desc
        {
            get { return desc; }
            set { this.desc = value; }
        }
    }

2: 定义服务端接口，传动模式为POST的模式


      [ServiceContract]
      public interface ICommandDispatchService
      {
      
        [OperationContract]
        [WebInvoke(UriTemplate = "keepHeartJump", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
        void KeepHeartJump(ConnectService connectService);


        [OperationContract]
        [WebInvoke(UriTemplate = "registConnectService", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
        void RegistConnectService(ConnectService connectService);


        [OperationContract]
        [WebInvoke(UriTemplate = "cannelConnectService", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
        void CannelConnectService(ConnectService connectService);

      }

      [ServiceContract]
      public interface ICommandHandleMsgService
      {
          //同步设备信息
          [OperationContract]
          [WebInvoke(UriTemplate = "syncDeviceInfo", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void SyncDeviceInfo(List<Device> devices);

          //同步联动信息
          [OperationContract]
          [WebInvoke(UriTemplate = "syncAutomation", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void SyncAutomation();

          //发送文本消息
          [OperationContract]
          [WebInvoke(UriTemplate = "sendTextMsg", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void SendTextMsg(Communication communication);

          //发送图片消息
          [OperationContract]
          [WebInvoke(UriTemplate = "sendPicMsg", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void SendPicMsg(Communication communication);

          //发送报警消息（联动方案用）
          [OperationContract]
          [WebInvoke(UriTemplate = "startAlarmMsg", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void StartAlarmMsg(Communication communication);


          //发送联动报警图片消息
          [OperationContract]
          [WebInvoke(UriTemplate = "sendAlarmPic", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void SendAlarmPic(Communication communication);

          //设备是否上线，下线
          [OperationContract]
          [WebInvoke(UriTemplate = "deviceShankLine", Method = "POST", ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
          void DeviceShankLine(Device device);

      }

3：定义用于客户端通讯的接口

  public interface IHandleMsg
    {
        //同步设备信息
     
        void SyncDeviceInfo(List<Device> devices);

        //同步联动信息

        void SyncAutomation();

        //发送文本消息

        void SendTextMsg(Communication communication);

        //发送图片消息

        void SendPicMsg(Communication communication);

        //发送报警消息（联动方案用）

        void StartAlarmMsg(Communication communication);


        //发送联动报警图片消息

        void SendAlarmPic(Communication communication);

        //设备是否上线，下线

        void DeviceShankLine(Device device);

    }

  public interface IReisterService
    {
        void KeepHeartJump(ConnectService connectService);
        void RegistConnectService(ConnectService connectService);
        void CannelConnectService(ConnectService connectService);
    }

4:注册，绑定，启动等用户接口控件

  [Serializable]
    public class ReisterService : ICommandDispatchService
    {

        public void KeepHeartJump(ConnectService connectService)
        {
            CommandDispatchServiceManager.Singleton.KeepHeartJump(connectService);
        }

        public void RegistConnectService(ConnectService connectService)
        {
            CommandDispatchServiceManager.Singleton.RegistConnectService(connectService);
        }

        public void CannelConnectService(ConnectService connectService)
        {
            CommandDispatchServiceManager.Singleton.CannelConnectService(connectService);
        }
    }
    public class CommandDispatchServiceManager : IDisposable
    {
        private static CommandDispatchServiceManager commandDispatchServiceManager = new CommandDispatchServiceManager();
        private static object objectLock = new object();
        private CommandDispatchServiceManager()
        {

        }
        //private ServiceHost serviceHost = null;

        private WebServiceHost serviceHost = null;
        /// <summary>
        /// 启动一个监听服务。
        /// </summary>
        /// <param name="ucShiJianDiaoDu"></param>
        /// <returns></returns>
        public void StartService()
        {
            if (!this.started)
            {
                lock (objectLock)
                {
                    if (!this.started)
                    {
                        monitorAddress = Helper.GetMonitorAddress();
                        monitorPort = Helper.GetMonitorPoint(0);
                        Uri baseAddress = new Uri(string.Format("http://{0}:{1}/", monitorAddress, monitorPort));
                        serviceHost = new WebServiceHost(typeof(ReisterService), baseAddress);
                        WebHttpBinding binding = new WebHttpBinding(WebHttpSecurityMode.None);
                        XmlDictionaryReaderQuotas readerQuotas = new XmlDictionaryReaderQuotas();
                        readerQuotas.MaxArrayLength = 2147483647;
                        readerQuotas.MaxStringContentLength = 2147483647;
                        readerQuotas.MaxBytesPerRead = 2147483647;
                        binding.ReaderQuotas = readerQuotas;
                        binding.MaxReceivedMessageSize = 2147483647;
                        binding.MaxBufferPoolSize = 2147483647;
                        binding.MaxBufferSize = 2147483647;
                      
                        try
                        {
                            serviceHost.AddServiceEndpoint(typeof(ICommandDispatchService), binding, string.Format("http://{0}:{1}/",
                                monitorAddress, monitorPort));
                            serviceHost.Open();
                        }
                        catch (Exception exp)
                        {
                            BestelException.WriteLog("StartService", exp);
                        }
                        this.started = true;
                    }
                }
            }
        }

        public string monitorAddress = "";
        public string monitorPort = "";
        public void RegisterTriggerControl(IReisterService triggerAlarmControl)
        {
            triggerAlarmControls.Add(triggerAlarmControl);
        }
        public void CancelTriggerControl(IReisterService triggerAlarmControl)
        {
            triggerAlarmControls.Remove(triggerAlarmControl);
        }


        public void KeepHeartJumpControl(IReisterService triggerAlarmControl)
        {
            triggerAlarmControls.Add(triggerAlarmControl);

        }
        public void StopService()
        {
            try
            {
                serviceHost.Close();
                if (this.started)
                {
                    lock (objectLock)
                    {
                        if (this.started)
                        {
                            this.started = false;
                        }
                    }
                }
            }
            catch (Exception exp)
            {
                BestelException.WriteLog("停止报警服务--StopService", exp.ToString());
            }
        }
        //<summary>
        //推送WIN8绘制的数据
        //</summary>
        //<param name="pushmsg"></param>
        public void KeepHeartJump(ConnectService connectService)
        {
            BackgroundWorker backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork -= (sender, e) => { };
            backgroundWorker.DoWork += (sender, e) =>
            {
                for (int i = 0; i < triggerAlarmControls.Count; i++)
                {
                    if (triggerAlarmControls[i] != null)
                        triggerAlarmControls[i].KeepHeartJump(connectService);
                }
            };
            backgroundWorker.RunWorkerAsync();

        }
        public void RegistConnectService(ConnectService connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].RegistConnectService(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }
        public void CannelConnectService(ConnectService connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork -= (sender, e) => { };
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].CannelConnectService(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }
        private List<IReisterService> triggerAlarmControls = new List<IReisterService>();
        public static CommandDispatchServiceManager Singleton
        {
            get { return commandDispatchServiceManager; }
        }
        private bool started = false;

        public void Dispose()
        {
            if (this.triggerAlarmControls != null && this.triggerAlarmControls.Count > 0)
            {
                this.triggerAlarmControls.Clear();
            }
            if (serviceHost != null) serviceHost.Close();
        }

}

 [Serializable]
    public class HandleService :ICommandHandleMsgService
    {
        public void SyncDeviceInfo(List<Device> devices)
        {
            CommandHandleMsgerviceManager.Singleton.SyncDeviceInfo(devices);
        }

        public void SyncAutomation()
        {
            CommandHandleMsgerviceManager.Singleton.SyncAutomation();
        }

        public void SendTextMsg(Communication communication)
        {
            CommandHandleMsgerviceManager.Singleton.SendTextMsg(communication);
        }

        public void SendPicMsg(Communication communication)
        {
            CommandHandleMsgerviceManager.Singleton.SendPicMsg(communication);
        }

        public void StartAlarmMsg(Communication communication)
        {
            CommandHandleMsgerviceManager.Singleton.StartAlarmMsg(communication);
        }

        public void SendAlarmPic(Communication communication)
        {
            CommandHandleMsgerviceManager.Singleton.SendAlarmPic(communication);
        }

        public void DeviceShankLine(Device device)
        {
            CommandHandleMsgerviceManager.Singleton.DeviceShankLine(device);
        }
    }


    public class CommandHandleMsgerviceManager : IDisposable
    {
         private static CommandHandleMsgerviceManager commandDispatchServiceManager = new CommandHandleMsgerviceManager();
        private static object objectLock = new object();
        private CommandHandleMsgerviceManager()
        {

        }
        //private ServiceHost serviceHost = null;

        private WebServiceHost serviceHost = null;
        /// <summary>
        /// 启动一个监听服务。
        /// </summary>
        /// <param name="ucShiJianDiaoDu"></param>
        /// <returns></returns>
        public void StartService()
        {
            if (!this.started)
            {
                lock (objectLock)
                {
                    if (!this.started)
                    {
                        monitorAddress = Helper.GetHandleAddress();
                        monitorPort = Helper.GetHandlerPoint(0);
                        Uri baseAddress = new Uri(string.Format("http://{0}:{1}/", monitorAddress, monitorPort));
                        serviceHost = new WebServiceHost(typeof(HandleService), baseAddress);
                        WebHttpBinding binding = new WebHttpBinding(WebHttpSecurityMode.None);
                        XmlDictionaryReaderQuotas readerQuotas = new XmlDictionaryReaderQuotas();
                        readerQuotas.MaxArrayLength = 2147483647;
                        readerQuotas.MaxStringContentLength = 2147483647;
                        readerQuotas.MaxBytesPerRead = 2147483647;
                        binding.ReaderQuotas = readerQuotas;
                        binding.MaxReceivedMessageSize = 2147483647;
                        binding.MaxBufferPoolSize = 2147483647;
                        binding.MaxBufferSize = 2147483647;

                        try
                        {
                            serviceHost.AddServiceEndpoint(typeof(ICommandHandleMsgService), binding, string.Format("http://{0}:{1}/",
                                monitorAddress, monitorPort));
                            serviceHost.Open();
                        }
                        catch (Exception exp)
                        {
                            BestelException.WriteLog("StartService", exp);
                        }
                        this.started = true;
                    }
                }
            }
        }

 

        public string monitorAddress = "";
        public string monitorPort = "";
        public void RegisterTriggerControl(IHandleMsg triggerAlarmControl)
        {
            triggerAlarmControls.Add(triggerAlarmControl);
        }
        public void CancelTriggerControl(IHandleMsg triggerAlarmControl)
        {
            triggerAlarmControls.Remove(triggerAlarmControl);
        }


        public void KeepHeartJumpControl(IHandleMsg triggerAlarmControl)
        {
            triggerAlarmControls.Add(triggerAlarmControl);

        }
        public void StopService()
        {
            try
            {
                serviceHost.Close();
                if (this.started)
                {
                    lock (objectLock)
                    {
                        if (this.started)
                        {
                            this.started = false;
                        }
                    }
                }
            }
            catch (Exception exp)
            {
                BestelException.WriteLog("停止报警服务--StopService", exp.ToString());
            }
        }

        public void SyncDeviceInfo(List<Device> device)
        {
            BackgroundWorker backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork -= (sender, e) => { };
            backgroundWorker.DoWork += (sender, e) =>
            {
                for (int i = 0; i < triggerAlarmControls.Count; i++)
                {
                    if (triggerAlarmControls[i] != null)
                        triggerAlarmControls[i].SyncDeviceInfo(device);
                }
            };
            backgroundWorker.RunWorkerAsync();

        }
        public void SyncAutomation()
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].SyncAutomation();
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }
        public void SendTextMsg(Communication connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork -= (sender, e) => { };
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].SendTextMsg(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }


        public void SendPicMsg(Communication connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork -= (sender, e) => { };
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].SendPicMsg(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }

 

        public void StartAlarmMsg(Communication connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork -= (sender, e) => { };
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].StartAlarmMsg(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }


        public void SendAlarmPic(Communication connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork -= (sender, e) => { };
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].SendAlarmPic(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }


        public void DeviceShankLine(Device connectService)
        {
            using (BackgroundWorker backgroundWorker = new BackgroundWorker())
            {
                backgroundWorker.DoWork -= (sender, e) => { };
                backgroundWorker.DoWork += (sender, e) =>
                {
                    for (int i = 0; i < triggerAlarmControls.Count; i++)
                    {
                        if (triggerAlarmControls[i] != null)
                            triggerAlarmControls[i].DeviceShankLine(connectService);
                    }
                };
                backgroundWorker.RunWorkerAsync();
            }
        }


        private List<IHandleMsg> triggerAlarmControls = new List<IHandleMsg>();
        public static CommandHandleMsgerviceManager Singleton
        {
            get { return commandDispatchServiceManager; }
        }
        private bool started = false;

        public void Dispose()
        {
            if (this.triggerAlarmControls != null && this.triggerAlarmControls.Count > 0)
            {
                this.triggerAlarmControls.Clear();
            }
            if (serviceHost != null) serviceHost.Close();
        }


    }

5：客户端调用与相互通信

  public partial class Form1 : Form, IReisterService, IHandleMsg
    {

实现接口

}

6：调用服务REST服务的POST方式

 WebChannelFactory<WCFServiceClibs.ICommandDispatchService> scf = new WebChannelFactory<ICommandDispatchService>(new Uri(System.Configuration.ConfigurationSettings.AppSettings["URL"]));
                WCFServiceClibs.ICommandDispatchService svc = scf.CreateChannel();
                svc.RegistConnectService(connection);

 

WCF服务器
hzj22456的博客
04-10 267
WCF，应用程序可能会使用多种现有的.NET Framework技术 1、ASP.NET Web 服务(ASMX)。 　　这种技术用于与基于 J2EE 的现有预定应用程序，以及与 Internet上的合作伙伴应用程序进行通信。 因为目前大多数平台都支持基 本的Web 服务，所以在WCF 发布之前，这是实现跨供应商互操作性的最直接的方法。 2、.NET Framework 远程处理。 　　这种技术可用于与呼叫中心应用程序进行通信，因为二者都是建立在.NET Framework 之上的。远程处理专门为紧密耦合的
webx—CommandDispatcher分发服务
公众号：微观技术
01-09 2343
一、简介Command pattern是一套基于Spring Framework ，以Use Case为中心的框架。它糅合了几种经典的JavaEE设计模式，使应用开发者在实现Use Case时，能够更专注于商业逻辑本身。结构图：1
WCF服务配置
Qyingya的博客
06-08 1190
服务端的服务配置及客户端的引用
创建WCF服务
mrtwenty的博客
08-12 964
WindowsCommunication Foundation（WCF）是由微软发展的一组数据通信的应用程序开发接口，它是.NET框架的一部分，由.NET Framework 3.0开始引入，与Windows Presentation Foundation及 Windows Workflow Foundation并行为新一代Windows操作系统以及WinFX的三个重大应用程序开发类库。...............
WCF服务总结
qq_58563355的博客
12-21 708
WCF，全称为Windows Communication Foundation，是一种用于构建分布式应用程序的微软框架。它提供了一种统一的编程模型，用于构建服务导向的应用程序，这些应用程序可以在本地或远程计算机上运行。WCF 支持多种传输协议和编码格式，并提供了高级安全性、可靠性和事务处理。通过 WCF，开发人员可以轻松地创建基于服务的体系结构，以实现不同平台和技术之间的互操作性。
.NET丶WCF服务
weixin_44870681的博客
09-17 582
一丶什么是WCF Windows Communication Foundation(WCF)是由微软发展的一组数据通信的应用程序开发接口，可以翻译为Windows通讯接口，它是.NET框架的一部分。由.NET Framework 3.0开始引入。 WCF的最终目标是通过进程或不同的系统、通过本地网络或是通过Internet收发客户和服务之间的消息。 WCF合并了Web服务、.net Remotin...
WPF 内置WCF服务配置
最新发布
weixin_45381071的博客
01-31 850
WPF 内置WCF服务配置。
C# WCF服务
zls365365的博客
05-29 604
1：什么是WCF。WCF（Windows Communication Foundation）是由微软开发的一系列支持数据通信的应用程序框架，可以翻译为Windows 通讯开发平台。整合了...
WCF服务/客户端
gqk01的博客
07-25 661
打开service1 类文件, 集成于Iservice1 的接口并且有具体实现, 在我们测试中, 则是利用客户端进行访问进行演示, 而下面,要讲的技术一个关于终结点的概念。本地或者是异地的消息接收程序再从该队列中取出发给它的消息进行处理。它是一种异步传输模式，可以在不同的应用之间实现相互通信，相互通信的应用可以分布在同一台机器上，也可以分布于相连的网络空间中的任一位置。在我们的实际开发过程中, 需要用于数据交互的实体类, 则必须声明类及成员的数据协定, 声明的意义则表示该实体可以序列化。
JS跨域调用WCF服务实例(WCF服务宿主到控制台)
09-24
本文将详细介绍如何实现JS跨域调用WCF服务，并通过一个控制台应用作为服务宿主的实例进行讲解。 首先，我们要理解什么是跨域问题。在Web浏览器的安全策略中，同源策略限制了JavaScript只能访问与当前页面同源（协议...
wcf服务 winform宿主 客户端请求wcf 示例
04-23
WCF服务可以被各种类型的客户端访问，包括WinForms应用程序。本示例将详细讲解如何在WinForm应用中宿主WCF服务以及创建一个客户端来请求该服务。 首先，我们有`WcfServiceLibrary1`项目，这是一个WCF服务的实现。在...
C# 调用WCF服务例程
12-16
**C#调用WCF服务例程详解** 在.NET框架中，Windows Communication Foundation（WCF）是一种用于构建和部署服务的全面模型。它允许开发者创建跨平台、互操作性强的服务，能够通过各种传输协议进行通信。本文将深入...
WCFService可以通过web调用和WCF服务访问
04-21
WCF服务可以被多种客户端访问，包括基于Web的和传统的WCF客户端。在标题和描述中提到的“WCFService可以通过web调用和WCF服务访问”，这意味着该服务已经配置为允许两种不同的调用方式。 1. **Web调用**：WCF服务...
WCF服务编程
02-27
目录序1前言5第1章WCF基础13什么是WCF13服务14地址16契约19托管23绑定30终结点34元数据交换39客户端编程47编程方式配置与管理方式配置56WCF体系架构57使用通道59可靠性63第2章服务契约68操作重载68契约的继承70服务...
WPF统计（饼图，折线，柱图）控件与调用
cuiweibin5的专栏
01-26 7380
1:柱图              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"              xmlns:mc="http://schemas.openx
c#利用libvlc.dll写了一个播放器
cuiweibin5的专栏
12-14 5657
最近没有事情的时候利用libvlc.dll写了一个播放器，参考了网上的一些利用libvlc.dll写播放器的例子，你可以通过SOCKET传递不同的命令来控制播放。不过可惜的是利用libvlc.dll只能在.NET FRAMEWORK2.0模式运行，更高的库不知道网上有没有。其中用到Plugin这个文件夹里的东西，在网上的一些博客至少写了代码，但是Plugin 文件夹里的东西并没有上传。通过整理我就
c#MQ简单操作
cuiweibin5的专栏
12-25 4113
c#利用HESSIAN序列化自定义实体，并接收ACTIVEMQ的信息  这几天因为项目上的需要，需要推送一定的统计信息到WINFROM的项目上。我们利用了ACTIVEMQ进行了推送。因为要和JAVA之间进行数据的推送。里面还是有点意思的。就简单的说一下c#建立ACTIVEMQ，和JAVA之间进行数据的交换。主要有如下几步； 第一步：从网上下载到ACTIVEMQ在.NET
c#调用硬件提供的二次开发函数方法
cuiweibin5的专栏
07-23 2793
对于调用硬件提供的二次开发函数，有人认为我把c++或C语言提供的二次开发接口翻译一下，然后我就能调用产生我需要的效果。说的也对，这样确实能得到你想要得结果，但是你把整个模块写完后，你会发现，来个新的硬件你又该怎么办，把原来的推倒重新来吗。对于软件设计来说这种方法来说是不可取的。如何解决这个问题，我们必须提供可以满足一定规则的结构。在做c#程序开发的时候，我们可以参考JAVA里很多优秀的架构。从中获
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值