自定义异步可插入协议 (代码记录)

最新推荐文章于 2025-05-08 14:15:47 发布
转载 最新推荐文章于 2025-05-08 14:15:47 发布 · 662 阅读 · 0

本文详细介绍了HTTP协议的实现方法以及与组件聚合技术的结合应用，包括接口定义、方法实现和内部交互流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

参考：

http://www.codeguru.com/cpp/com-tech/atl/misc/article.php/c37/Asynchronous-Pluggable-Protocol-Implementation-with-ATL.htm

http://blog.youkuaiyun.com/cumtzly/article/details/40072613

    // http_protocol.cc  
      
    #include "trident/glue/protocol_impl/http_protocol.h"  
    #include "base/logging.h"  
    #include <WinInet.h>  
    #include <ExDisp.h>  
      
    namespace trident {  
      
    HttpProtocol::HttpProtocol(IUnknown* pOuterUnknown)  
        : reference_count_(0),   
          outer_unknown_(pOuterUnknown),   
          grf_BindF_(0),  
          inner_unknown_(NULL) {  
      inner_unknown_ = reinterpret_cast<IUnknown*>((INonDelegatingUnknown*)(this));    
      ZeroMemory(&bind_info_, sizeof(BINDINFO));  
      bind_info_.cbSize = sizeof(BINDINFO);  
    }  
      
    HttpProtocol::~HttpProtocol() {  
    }  
      
    // INonDelegatingUnknown  
    STDMETHODIMP HttpProtocol::NonDelegatingQueryInterface(REFIID riid, void** ppvObject) {  
      if(ppvObject == NULL){  
        return E_INVALIDARG;  
      }  
      
      HRESULT result = E_NOINTERFACE;  
      *ppvObject = NULL;  
      NonDelegatingAddRef();  
      if (riid == IID_IUnknown) {  
        *ppvObject = static_cast<INonDelegatingUnknown*>(this);  
      }else if(riid == IID_IInternetProtocolRoot) {   
        *ppvObject = static_cast<IInternetProtocolRoot*>(this);  
      } else if (riid == IID_IInternetProtocol) {  
        *ppvObject = static_cast<IInternetProtocol*>(this);  
      } else if (riid == IID_IInternetProtocolEx) {                                     
        *ppvObject = static_cast<IInternetProtocolEx*>(this);  
      } else if (riid == IID_IInternetProtocolInfo) {                                     
        *ppvObject = static_cast<IInternetProtocolInfo*>(this);  
      }  
      if(*ppvObject)  
        result = S_OK;  
      else  
        NonDelegatingRelease();  
      return result;  
    }  
      
    STDMETHODIMP_(ULONG) HttpProtocol::NonDelegatingAddRef() {  
      return (ULONG)::InterlockedIncrement(&reference_count_);  
    }  
      
    STDMETHODIMP_(ULONG) HttpProtocol::NonDelegatingRelease() {  
      ::InterlockedDecrement(&reference_count_);  
      if (reference_count_ == 0) {  
        delete this;  
      }  
      return reference_count_;  
    }  
      
    // IUnknown  
    STDMETHODIMP HttpProtocol::QueryInterface(REFIID riid, void** ppvObject) {  
      if (outer_unknown_) {  
        return outer_unknown_->QueryInterface(riid, ppvObject);  
      } else {  
        return inner_unknown_->QueryInterface(riid, ppvObject);  
      }  
    }  
      
    STDMETHODIMP_(ULONG) HttpProtocol::AddRef() {  
      if (outer_unknown_) {  
        return outer_unknown_->AddRef();  
      } else {  
        return inner_unknown_->AddRef();  
      }  
    }  
      
    STDMETHODIMP_(ULONG) HttpProtocol::Release() {  
      if (outer_unknown_) {  
        return outer_unknown_->Release();  
      } else {  
        return inner_unknown_->Release();  
      }  
    }  
      
    // IInternetProtocolRoot , XP SP2及以下版本走这个接口  
    STDMETHODIMP HttpProtocol::Start(LPCWSTR url, IInternetProtocolSink* protocol_sink, IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {  
       
      if(bind_info == NULL || protocol_sink == NULL || url == NULL)  
        return E_INVALIDARG;  
       
      bind_url_ = GURL(url);  
      
      spSink_ = protocol_sink;  
      
      spBindinfo_ = bind_info;     
      
      spSink_->QueryInterface(IID_IServiceProvider, (void**)&spServiceProvider_);  
      if(!spServiceProvider_)  
        spBindinfo_->QueryInterface(IID_IServiceProvider, (void**)&spServiceProvider_);  
      DCHECK(spServiceProvider_);                                               
      
      // BINDINFO  
      //http://msdn.microsoft.com/en-us/library/ie/aa767897(v=vs.85).aspx  
      //http://msdn.microsoft.com/en-us/library/ie/aa741006(v=vs.85).aspx#Handling_BINDINFO_St  
      HRESULT result = spBindinfo_->GetBindInfo(&grf_BindF_, &bind_info_);  
      DCHECK(result == S_OK);  
      
      if( !bind_info_.dwCodePage )  
        bind_info_.dwCodePage = ::GetACP();  
      
      /*bind_info_->ReportProgress(BINDSTATUS_FINDINGRESOURCE, strData); 
      bind_info_->ReportProgress(BINDSTATUS_CONNECTING, strData); 
      bind_info_->ReportProgress(BINDSTATUS_SENDINGREQUEST, strData); 
      bind_info_->ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, CAtlString(m_url.GetMimeType())); 
      bind_info_->ReportData(BSCF_FIRSTDATANOTIFICATION, 0, bind_url_.GetDataLength()); 
      bind_info_->ReportData(BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE, m_url.GetDataLength(), m_url.GetDataLength());*/  
      
      
      return S_OK;  
      
      return S_OK;  
    }  
      
    STDMETHODIMP HttpProtocol::Continue(PROTOCOLDATA* pProtocolData) {  
      return S_OK;  
    }  
      
    // IE6/IE8下有断言，发现调用Terminate后还会调用Abort  
    STDMETHODIMP HttpProtocol::Abort(HRESULT reason, DWORD options) {  
      return S_OK;  
    }  
      
    STDMETHODIMP HttpProtocol::Terminate(DWORD options) {  
      return S_OK;  
    }  
      
    STDMETHODIMP HttpProtocol::Suspend() {  
      return E_NOTIMPL;  
    }  
      
    STDMETHODIMP HttpProtocol::Resume() {   
      return E_NOTIMPL;  
    }  
      
    STDMETHODIMP HttpProtocol::Read(void* pv, ULONG size, ULONG* pcbRead) {  
      return S_OK;  
    }  
      
    STDMETHODIMP HttpProtocol::Seek(LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER* new_position) {    
      return S_OK;  
    }  
      
    STDMETHODIMP HttpProtocol::LockRequest(DWORD options) {  
      has_lock_request_ = true;  
      return S_OK;  
    }  
      
    STDMETHODIMP HttpProtocol::UnlockRequest() {  
      has_lock_request_ = false;  
      return S_OK;  
    }  
      
    // XP SP3及以上版本走这个接口  
    STDMETHODIMP HttpProtocol::StartEx(IUri* uri, IInternetProtocolSink* protocol_sink, IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {   
      if(uri == NULL) {  
        return E_INVALIDARG;  
      }  
      
      BSTR uri_URL = NULL;  
      std::wstring url;  
      uri->GetAbsoluteUri(&uri_URL);  
      if (uri_URL != NULL) {  
        url = uri_URL;  
        ::SysFreeString(uri_URL);  
      }  
      uri->Release();  
      
      return Start(url.c_str(), protocol_sink, bind_info, flags, reserved);  
    }  
      
    STDMETHODIMP  HttpProtocol::ParseUrl(LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult,    
      DWORD cchResult,  DWORD *pcchResult, DWORD dwReserved) {  
      return S_OK;  
    }  
      
    STDMETHODIMP  HttpProtocol::CombineUrl( LPCWSTR pwzBaseUrl,  LPCWSTR pwzRelativeUrl,  DWORD dwCombineFlags, LPWSTR pwzResult,  
      DWORD cchResult,DWORD *pcchResult,DWORD dwReserved)  {  
      return S_OK;  
    }  
      
    STDMETHODIMP  HttpProtocol::CompareUrl( LPCWSTR pwzUrl1,LPCWSTR pwzUrl2,DWORD dwCompareFlags) {  
      return S_OK;  
    }  
      
    STDMETHODIMP  HttpProtocol::QueryInfo(LPCWSTR pwzUrl,  QUERYOPTION OueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer,   
      DWORD *pcbBuf, DWORD dwReserved)  {  
       return S_OK;  
    }  
      
    std::wstring HttpProtocol::GetVerbStr() const {  
      wchar_t* pszRes = NULL;  
      switch (bind_info_.dwBindVerb)  
      {  
      case BINDVERB_GET      :  
        pszRes = L"GET";  
        break;  
      case BINDVERB_POST     :  
        pszRes = L"POST";  
        break;  
      case BINDVERB_PUT      :  
        pszRes = L"PUT";  
        break;  
      case BINDVERB_CUSTOM   :  
        pszRes = bind_info_.szCustomVerb;  
        break;  
      }  
      DCHECK(pszRes);  
      return pszRes;  
    }  
      
      
    bool HttpProtocol::GetDataToSend(char** lplpData, DWORD* pdwSize) const {  
      
      if(bind_info_.dwBindVerb == BINDVERB_GET)  
        return false;  
      
      if (bind_info_.stgmedData.tymed == TYMED_HGLOBAL) {  
        if(lplpData)  
          *lplpData = (char*)bind_info_.stgmedData.hGlobal;  
        if(pdwSize)  
          *pdwSize = bind_info_.cbstgmedData;  
        return true;  
      } else {  
        return false;  
      }  
    }  
      
    }  

    <pre name="code" class="cpp">// http_protocol.h  
      
    #ifndef TRIDENT_PROTOCOL_HTTP_PROTOCOL_H_  
    #define TRIDENT_PROTOCOL_HTTP_PROTOCOL_H_  
      
    // 实现参考 Win2K 源码  
    // private\inet\urlmon\iapp\cnet.cxx  
    // private\inet\urlmon\iapp\cnethttp.cxx  
      
    #include <atlbase.h>  
    #include <urlmon.h>  
    #include <vector>  
    #include "base/basictypes.h"  
    #include "url/gurl.h"  
      
    namespace trident {  
      
    // COM组件聚合帮助接口  
    // 参考：http://msdn.microsoft.com/en-us/library/windows/desktop/dd390339(v=vs.85).aspx  
    struct INonDelegatingUnknown {  
      STDMETHOD(NonDelegatingQueryInterface)(REFIID riid, void** ppvObject) = 0;  
      STDMETHOD_(ULONG, NonDelegatingAddRef)() = 0;  
      STDMETHOD_(ULONG, NonDelegatingRelease)() = 0;  
    };  
      
    class HttpProtocol : public INonDelegatingUnknown,  
                         public IInternetProtocolEx,   
                         public IInternetProtocolInfo{  
    public:  
      HttpProtocol(IUnknown* pOuterUnknown);  
      virtual ~HttpProtocol();  
      
    public:  
      
      // INonDelegatingUnknown  
      // 只提供Protocol接口查询，不提供Sink接口查询  
      STDMETHOD(NonDelegatingQueryInterface)(REFIID riid, void** ppvObject);  
      STDMETHOD_(ULONG, NonDelegatingAddRef)();  
      STDMETHOD_(ULONG, NonDelegatingRelease)();  
      
      // IUnknown  
      STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject);  
      STDMETHOD_(ULONG, AddRef)();  
      STDMETHOD_(ULONG, Release)();  
      
      // IInternetProtocolRoot  
      STDMETHOD(Start)(LPCWSTR url, IInternetProtocolSink* protocol_sink, IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved);  
      STDMETHOD(Continue)(PROTOCOLDATA* pProtocolData);  
      STDMETHOD(Abort)(HRESULT reason, DWORD options);  
      STDMETHOD(Terminate)(DWORD options);  
      STDMETHOD(Suspend)();  
      STDMETHOD(Resume)();  
      
      // IInternetProtocol : public IInternetProtocolRoot  
      STDMETHOD(Read)(void* pv, ULONG size, ULONG* pcbRead);  
      STDMETHOD(Seek)(LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER* new_position);  
      STDMETHOD(LockRequest)(DWORD options);  
      STDMETHOD(UnlockRequest)();  
      
      // IInternetProtocolEx : public IInternetProtocol  
      STDMETHOD(StartEx)(IUri* uri, IInternetProtocolSink* protocol_sink, IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved);  
      
      // IInternetProtocolInfo  
      STDMETHOD(ParseUrl)(LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult,  DWORD cchResult,  DWORD *pcchResult, DWORD dwReserved) ;  
      STDMETHOD(CombineUrl)( LPCWSTR pwzBaseUrl,  LPCWSTR pwzRelativeUrl,  DWORD dwCombineFlags, LPWSTR pwzResult,DWORD cchResult,DWORD *pcchResult,DWORD dwReserved) ;  
      STDMETHOD(CompareUrl)( LPCWSTR pwzUrl1,LPCWSTR pwzUrl2,DWORD dwCompareFlags) ;  
      STDMETHOD(QueryInfo)(LPCWSTR pwzUrl,  QUERYOPTION OueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD *pcbBuf, DWORD dwReserved);  
      
    private:  
      std::wstring GetVerbStr() const ;  
      bool  GetDataToSend(char** lplpData, DWORD* pdwSize) const ;  
      
    private:  
      
      volatile LONG reference_count_;  
      
      IUnknown* outer_unknown_;  
      
      IUnknown* inner_unknown_;  
      
      CComPtr<IInternetProtocolSink> spSink_;  
      
      CComPtr<IInternetBindInfo> spBindinfo_;  
      
      CComPtr<IServiceProvider> spServiceProvider_;  
      
      BINDINFO bind_info_;  
      
      DWORD grf_BindF_;  
      
      bool has_lock_request_;  
      
      GURL bind_url_;  
      
      DISALLOW_COPY_AND_ASSIGN(HttpProtocol);  
    };  
      
    }  //namespace trident  
      
    #endif  // TRIDENT_PROTOCOL_HTTP_PROTOCOL_H_  

    <pre name="code" class="cpp">// http protocol factory.cc  
      
    #include "trident/glue/protocol_impl/http_protocol_factory.h"  
    #include "base/logging.h"  
    #include "trident/glue/protocol_impl/http_protocol.h"  
      
    namespace trident {  
      
    HttpProtocolFactory::HttpProtocolFactory(bool is_https_protocol) : reference_count_(1) {  
      HRESULT result = S_OK;  
      if (is_https_protocol) {  
        result = ::CoGetClassObject(CLSID_HttpSProtocol, CLSCTX_INPROC_SERVER, NULL, IID_IClassFactory, (void**)&origin_factory_);  
      } else {  
        result = ::CoGetClassObject(CLSID_HttpProtocol, CLSCTX_INPROC_SERVER, NULL, IID_IClassFactory, (void**)&origin_factory_);  
      }  
      DCHECK(result == S_OK);  
      DCHECK(origin_factory_ != NULL);  
    }  
      
    HttpProtocolFactory::~HttpProtocolFactory() {  
    }  
      
    // IUnknown  
    STDMETHODIMP HttpProtocolFactory::QueryInterface(REFIID riid, void** ppvObject) {  
      if (!ppvObject) {  
        return E_INVALIDARG;  
      }  
      *ppvObject = NULL;  
      HRESULT result = E_NOINTERFACE;  
      if (riid == IID_IUnknown) {  
        *ppvObject = static_cast<IUnknown*>(this);  
      } else if (riid == IID_IClassFactory) {  
        *ppvObject = static_cast<IClassFactory*>(this);  
      }  
      
      if (*ppvObject) {  
        static_cast<IUnknown*>(*ppvObject)->AddRef();  
        result = S_OK;  
      }  
      
      return result;  
    }  
      
    STDMETHODIMP_(ULONG) HttpProtocolFactory::AddRef() {  
      return ::InterlockedIncrement(&reference_count_);  
    }  
      
    STDMETHODIMP_(ULONG) HttpProtocolFactory::Release() {  
      ULONG count = ::InterlockedDecrement(&reference_count_);  
      if (count == 0) {  
        delete this;  
        return 0;  
      }  
      
      return count;  
    }  
      
    // IClassFactory  
    STDMETHODIMP HttpProtocolFactory::CreateInstance(IUnknown* pUnkOuter, REFIID riid, void** ppvObject) {  
      if (pUnkOuter && riid != IID_IUnknown) {  
        return CLASS_E_NOAGGREGATION;  
      }  
      
      HttpProtocol* http_protocol = new HttpProtocol(pUnkOuter);  
      if(http_protocol->NonDelegatingQueryInterface(riid, ppvObject) != S_OK) {  
        delete http_protocol;  
        *ppvObject = NULL;  
        return E_NOINTERFACE;  
      }else {  
        return S_OK;  
      }  
    }  
      
    STDMETHODIMP HttpProtocolFactory::LockServer(BOOL fLock) {  
      if(fLock)  
        AddRef();  
      else  
        Release();  
      return S_OK;  
    }  
      
    }  

    // http protocol factroy .h  
      
    #ifndef TRIDENT_HTTP_PROTOCOL_FACTORY_H_  
    #define TRIDENT_HTTP_PROTOCOL_FACTORY_H_  
      
    #include <atlbase.h>  
    #include <Unknwn.h>  
    #include "base/basictypes.h"  
      
    namespace trident {  
      
    class HttpProtocolFactory : public IClassFactory {  
    public:  
      
      explicit HttpProtocolFactory(bool is_https_protocol);  
      
      // IUnknown  
      STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject);  
      STDMETHOD_(ULONG, AddRef)();  
      STDMETHOD_(ULONG, Release)();  
      
      // IClassFactory  
      STDMETHOD(CreateInstance)(IUnknown* pUnkOuter, REFIID riid, void** ppvObject);  
      STDMETHOD(LockServer)(BOOL fLock);  
      
    private:  
      virtual ~HttpProtocolFactory();  
      
      volatile ULONG reference_count_;  
      CComPtr<IClassFactory> origin_factory_;  
      DISALLOW_IMPLICIT_CONSTRUCTORS(HttpProtocolFactory);  
    };  
      
    }  
      
    #endif  // TRIDENT_HTTP_PROTOCOL_FACTORY_H_


集成excel工具：自定义导入回调监听器、自定义类型转换器、web中的读、捕获文件格式转换错误ExcelDataConvertException
专注于计算机研发知识和资讯分享
07-13 809
*** excel 导出* @param data 数据源* @param fileName 文件名* @param tClass 对应Class*/try {// 这里URLEncoder.encode可以防止中文乱码// 这里注意 有同学反应使用swagger 会导致各种问题，请直接用浏览器或者用postmanEasyExcel.write(response.getOutputStream(), tClass).sheet("模板").doWrite(data);
自定义IE浏览器协议
Fogan的专栏
02-21 7981
转贴保存，如何实现IE自定义协议 浏览QQ空间的时候发现，只要在IE地址中输入象一下这种形式的地址，tencent://Message/?Uin=251464630&websiteName=qzone.qq.com&Menu=yes就会弹出给 2514646
[翻译]关于“异步可插协议”（About Asynchronous Pluggable Protocols(APPs)）
weixin_33906657的博客
03-28 147
原文链接：http://msdn2.microsoft.com/en-us/library/aa767916(VS.85).aspx 异步可插协议允许开发者创建可插协议处理器，MIME过滤器，以及命名空间处理器工作在微软IE4.0浏览器以及更高版本或者URL moniker中。这篇文章涵盖了Urlmon.dll动态链接库所公开（输出）的可插协议诸多功能。关于Urlmon.dll针对其他APIs所公...
IE异步可插入协议扩展（摘自哈巴狗的小窝）
dtren的专栏
11-09 1644
IE异步可插入协议扩展作者 陈省介绍对于每天都要使用的IE浏览器的人来说，输入www.google.com 等网址进行网上冲浪就象呼吸一样自然。大多数情况时，我们可能根本想不起来要在网址前面加上http:// 来声明要访问的是一个基于http协议的Web网站。所谓网络协议，其实无非就是一组描述如何获取不同资源并进行通讯的行为规则。IE浏览器除了内置了对 http协议外，还持ftp和go
IE异步可插入协议扩展
08-28 149
介绍 对于每天都要使用的IE浏览器的人来说，输入www.google.com 等网址进行网上冲浪就象呼吸一样自然。大多数情况时，我们可能根本想不起来要在网址前面加上http:// 来声明要访问的是一个基于http协议的Web网站。所谓网络协议，其实无非就是一组描述如何获取不同资源并进行通讯的行为规则。IE浏览器除了内置了对http协议外，还持ftp和gopher等协议。 从IE4开始...
浏览器扩展系列————异步可插入协议（pluggable protocol）的实现
weixin_34217773的博客
03-28 134
IE中有很多我们比较熟悉的协议，如http,https,mailto,ftp等。当然你也可以实现自己定义的协议，稍微谈一下这里所说的协议，从我的理解来说这里的协议只有当你的网页引用某个资源时才会调用，而不是随便在某个属性的值前面加上某个协议的名称就可以了。常见的协议调用如img的src属性中，很多元素style中的background-image属性中，还有a标签的href属性中。 ...
[翻译]关于“异步可插协议”（About Asynchronous Pluggable Protocols(APPs)）
volnet的专栏
03-28 591
原文链接：http://msdn2.microsoft.com/en-us/library/aa767916(VS.85).aspx 异步可插协议允许开发者创建可插协议处理器，MIME过滤器，以及命名空间处理器工作在微软IE4.0浏览器以及更高版本或者URL moniker中。这篇文章涵盖了Urlmon.dll动态链接库所公开（输出）的可插协议诸多功能。关于Urlmon.dll针对其他AP
Redis协议与异步方式（二）
最新发布
Z2460986913的博客
05-08 1424
事务是一个不可分割的工作单位，事务中的操作要么全部成功，要么全部失败；即使事务队列中的某个命令在执行期间出现了错误，整个事务也会继续执行下去，直 到将事务队列中的所有命令都执行完毕为止。hiredis 异步客户端接入自定义的 reactor 事件驱动系统的适配器，核心作用是桥接Redis的异步事件自定义事件循环机制，实现了一套hiredis的IO多路复用抽象接口。事务：用户定义一系列数据库操作，这些操作视为一个完整的逻辑处理工作单元，要么全部执行， 要么全部不执行，是不可分割的工作单元。
Python Web开发：消息队列与异步任务
switch616的博客
09-19 1404
Kafka 中的消息是按主题（Topic）进行分类存储，并且它的消费者可以根据需要进行消息的顺序消费和重复读取，极大地增强了灵活性。它支持复杂的路由机制，能够在不同的队列之间灵活的分发消息。它能帮助开发者轻松实现任务的异步执行，特别是在处理需要耗费大量时间的任务时（如视频处理、邮件发送等），Celery 的异步机制能有效减少用户的等待时间，提升系统的响应速度。Celery 提供了丰富的任务状态监控功能，开发人员可以通过这些功能查看任务的执行状态、任务的完成情况、任务失败的次数等。装饰器将它转换为异步任务。
自定义协议与功能扩展：LwIP协议栈扩展指南
本文介绍了LwIP协议栈的基础知识、自定义协议的设计原理和功能扩展实践操作。通过深入分析LwIP核心组件以及内存和任务管理机制，探讨了自定义协议在扩展性和兼容性方面的需求。接着，本文详细阐述了状态机模型在...
【代码实战】：手把手教你构建自定义HTTP服务，不可错过的Python教程
[【代码实战】：手把手教你构建自定义HTTP服务，不可错过的Python教程](https://img-blog.csdnimg.cn/4eac4f0588334db2bfd8d056df8c263a.png) # 1. HTTP服务的基础知识 ## 1.1 HTTP概述 HTTP（HyperText Transfer ...
【设计C#自定义通信协议】：策略与实现
本文旨在为开发者提供一个全面的自定义通信协议设计和实现的指南，以提高软件系统的性能、安全性和可扩展性。 # 关键字 自定义通信协议；设计原则；C#；网络编程；数据序列化；加密机制；性能优化；物联网；量子...
浏览器协议插件Asynchronous Pluggable Protocols
ajaxtop
08-16 820
浏览器调用客户端可执行程序Asynchronous Pluggable Protocols,异步可插入协议,允许开发者创建可插协议处理，MIME过滤器以及命名空间处理器，工作在微软IE4.0浏览器以及更高版本或者URL moniker中。这涉及到Urlmon.dll动态链接库所公开（输出）的可插协议诸多功能。应用场景 tencent协议：打开tencent://message/?uin=要链接的QQ
IE异步可插入协议扩展(转)不会vb...未测试
weixin_30772261的博客
06-02 96
IE异步可插入协议扩展作者 陈省 介绍 对于每天都要使用的IE浏览器的人来说，输入http://www.google.com/ 等网址进行网上冲浪就象呼吸一样自然。大多数情况时，我们可能根本想不起来要在网址前面加上http:// 来声明要访问的是一个基于http协议的Web网站。所谓网络协议，其实无非就是一组描述如何获取不同资源并进行通讯的行为规则。IE浏览器除了内置了对 http协议...
FPGA 802.3 自定义协议发送，接收，判断丢帧
02-25
嗯，我现在要解决的问题是关于FPGA上实现802.3自定义协议的发送、接收以及判断丢帧的情况。首先，我需要理清楚整个流程和各个模块...通过上述步骤，可在FPGA上实现高效的自定义协议处理，精准检测丢帧并优化网络性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值