常用处理 - Githubissues

rainit2006 commented 6 years ago

在TaskScheduler里创建一个Task

C++

This C++ example shows how to create a task that is scheduled to execute Notepad on a daily basis. https://msdn.microsoft.com/en-us/library/aa446861(VS.85).aspx
在Phila客户端项目里，自己封装了一个TaskScheduler类，用于程序调用。

C#

C# タスクスケジューラにタスクを登録する http://cammy.co.jp/technical/2017/05/31/c-%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%B9%E3%82%B1%E3%82%B8%E3%83%A5%E3%83%BC%E3%83%A9%E3%81%AB%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%92%E7%99%BB%E9%8C%B2%E3%81%99%E3%82%8B/

rainit2006 commented 6 years ago

从URL里下载文件 C++ ■关键函数:

InternetOpen関数 : Initializes an application's use of the WinINet functions.
InternetConnect関数 :　Opens an File Transfer Protocol (FTP) or HTTP session for a given site.
HttpOpenRequest関数：Creates an HTTP request handle.
HttpSendRequest関数：Sends the specified request to the HTTP server, allowing callers to send extra data beyond what is normally passed to HttpSendRequestEx.
HttpQueryInfo関数：Retrieves header information associated with an HTTP request.
InternetReadFile関数：Reads data from a handle opened by the InternetOpenUrl, FtpOpenFile, or HttpOpenRequest function.

参照サイト：

HTTP通信のリクエスト送信とレスポンス確認（WinInet API使用） http://www.hiramine.com/programming/windows/httprequest.html

■项目代码

    InternetError_Enum enResult = STATUS_OK;
    HINTERNET hInternet = NULL;
    HINTERNET hHttp = NULL;
    HINTERNET hReq = NULL;

    DWORD dwTotalRead = 0UL;
    DWORD dwContentLength = 0UL;
    BYTE aucBuff[BUFFBLOCK];
    BYTE *pucReadContent = NULL;
    CString csETag;

    SecureZeroMemory(aucBuff, BUFFBLOCK);

    do
    {
        hInternet  = ::InternetOpen(
            USER_AGENT,
            PRE_CONFIG_INTERNET_ACCESS,
            //INTERNET_OPEN_TYPE_DIRECT,
            NULL,
            NULL,
            0);
        if ( NULL == hInternet )
        {
            enResult = FAILED_TO_SEND;
            break;
        }

        InternetSetOption(hInternet, INTERNET_OPTION_IGNORE_OFFLINE, NULL, 0);

        hHttp = ::InternetConnect(
            hInternet,
            m_strServerURL,
            m_wPort, 
            NULL, 
            NULL, 
            INTERNET_SERVICE_HTTP,
            0,
            NULL);
        if ( NULL == hHttp )
        {
            enResult = FAILED_TO_SEND;
            break;
        }

        LPCTSTR AcceptTypes[2] = {_T("*/*"), NULL}; 
        if ( m_bIsSecure )
        {
            hReq = ::HttpOpenRequest(
                hHttp,
                INTERNET_GET,
                m_strFilePath,
                _T("HTTP/1.1"),
                NULL,
                AcceptTypes,
                INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_SECURE |
                INTERNET_FLAG_IGNORE_CERT_CN_INVALID | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID,
                0) ;
        }
        else
        {
            hReq = ::HttpOpenRequest(
                hHttp,
                INTERNET_GET,
                m_strFilePath,
                _T("HTTP/1.1"),
                NULL,
                AcceptTypes,
                INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE,
                0) ;
        }
        if ( NULL == hReq )
        {
            enResult = FAILED_TO_SEND;
            break;
        }
        AddHeader(hReq, HTTP_HEADER_HOST, m_strServerURL);
        AddHeader(hReq, HTTP_HEADER_ACCEPT, HTTP_ACCEPT_VALUE);
        AddHeader(hReq, HTTP_HEADER_USERAGENT, USER_AGENT);
        if ( !m_strETag.IsEmpty() )
        {
            AddHeader(hReq, HTTP_HEADER_IFNONEMATCH, m_strETag);
        }

        if ( !::HttpSendRequest (hReq, NULL, 0, NULL, 0) )
        {
            DWORD d = GetLastError();
            if ( ERROR_INTERNET_INVALID_CA == d )
            {
                DWORD dwFlags = 0;
                DWORD dwBuffLen = sizeof(dwFlags);

                InternetQueryOption (hReq, INTERNET_OPTION_SECURITY_FLAGS,
                    (LPVOID)&dwFlags, &dwBuffLen);

                dwFlags |= SECURITY_FLAG_IGNORE_UNKNOWN_CA;
                InternetSetOption (hReq, INTERNET_OPTION_SECURITY_FLAGS,
                    &dwFlags, sizeof (dwFlags) );

                if ( !::HttpSendRequest(hReq, NULL, 0, NULL, 0) )
                {
                    enResult = FAILED_TO_SEND;
                    break;
                }
            }
            else
            {
                enResult = FAILED_TO_SEND;
                break;
            }
        }

        TCHAR awcStatusCode[33];
        DWORD dwInfoSize = 64;
        SecureZeroMemory(awcStatusCode, sizeof(awcStatusCode));
        if ( !HttpQueryInfo (hReq,
            HTTP_QUERY_STATUS_CODE, 
            awcStatusCode, 
            &dwInfoSize, 
            NULL) )
        {
            enResult = REQUEST_ERROR;
            break;
        }
        awcStatusCode[dwInfoSize / sizeof(TCHAR)] = 0;
        long lStatusCode = _ttol(awcStatusCode);

        if ( HTTP_STATUS_OK == lStatusCode )
        {
            enResult = STATUS_OK;
        }
        else if ( HTTP_STATUS_NOT_FOUND == lStatusCode )
        {
            enResult = NOT_FOUND;
            dwTotalRead = 0;
            break;
        }
        else if ( HTTP_STATUS_NOT_MODIFIED == lStatusCode )
        {
            enResult = STATUS_NOT_MODIFY;
            csETag = m_strETag;
            dwTotalRead = 0;
            break;
        }
        else
        {
            enResult = REQUEST_ERROR;
            break;
        }
        dwInfoSize = 64;
        SecureZeroMemory(awcStatusCode, sizeof(awcStatusCode));
        if ( !HttpQueryInfo (hReq,
            HTTP_QUERY_ETAG, 
            awcStatusCode, 
            &dwInfoSize, 
            NULL))
        {
            csETag = _T("");
        }
        else
        {
            awcStatusCode[dwInfoSize / sizeof(TCHAR)] = 0;
            csETag = awcStatusCode;
        }
        dwInfoSize = 64;
        SecureZeroMemory(awcStatusCode, sizeof(awcStatusCode));
        if ( !HttpQueryInfo (hReq,
            HTTP_QUERY_CONTENT_LENGTH, 
            awcStatusCode, 
            &dwInfoSize, 
            NULL))
        {
            enResult = BAD_PACKET;
            break;
        }
        awcStatusCode[dwInfoSize / sizeof(TCHAR)] = 0;
        dwContentLength = _ttol(awcStatusCode);
        pucReadContent = new BYTE[dwContentLength];
        if ( !pucReadContent )
        {
            enResult = MEMERORY_ERROR;
            break;
        }
        SecureZeroMemory(pucReadContent, dwContentLength);
        DWORD dwRead = 0;
        while ( ::InternetReadFile(hReq, aucBuff, sizeof(aucBuff), &dwRead) )
        {
            if ( (0 ==dwRead) || m_bQuitGet || ((dwContentLength - dwTotalRead) < 0))
            {
                break;
            }
            memcpy_s(pucReadContent + dwTotalRead, dwContentLength - dwTotalRead, aucBuff, dwRead); 
            dwTotalRead += dwRead;
        }
        if ( dwContentLength != dwTotalRead)
        {
            enResult = BAD_PACKET;
            break;
        }
    }while( false );
    if ( hReq )
    {
        InternetCloseHandle(hReq);
        hReq = NULL;
    }
    if ( hHttp )
    {
        InternetCloseHandle(hHttp);
        hHttp = NULL;
    }
    if ( hInternet )
    {
        ::InternetCloseHandle(hInternet);
        hInternet = NULL;
    }

rainit2006 commented 6 years ago

C#でnullチェックを簡潔に行うには？

// ……何らかの処理……

    // if (description == null) {
    //   description = title;
    // }
    // と↓は同じ

    description = description ?? title; // 「??」はnull合体演算子

问号（1）、C#语法中一个个问号(?)的运算符是指：值类型后面加问号表示可为空null(Nullable 结构) MSDN上面的解释：在处理数据库和其他包含不可赋值的元素的数据类型时，将 null 赋值给数值类型或布尔型以及日期类型的功能特别有用。例如，数据库中的布尔型字段可以存储值 true 或 false，或者，该字段也可以未定义。

（2）、C#语法中两个问号(??)的运算符是指null 合并运算符，合并运算符为类型转换定义了一个预设值，以防可空类型的值为Null。

MSDN上面的解释： ?? 运算符称为 null 合并运算符，用于定义可以为 null 值的类型和引用类型的默认值。如果此运算符的左操作数不为 null，则此运算符将返回左操作数（左边表达式）；否则当左操作数为 null，返回右操作数（右边表达式）。

int? num = null;   //正确
int num = null;    //错误

int? x = null;//定义可空类型变量
int? y = x ?? 1000;//使用合并运算符，当变量x为null时，预设赋值1000

Nullable 结构支持将值类型扩展为可以为null，但不支持在引用类型(string, class, object都是引用类型) 上使用，因为引用类型本身就是可空的。

设置值的写法 Arg = value;
获取值的写法 Arg.Value;
判断非空的写法 Arg.HasValue

null 条件演算子 null をチェックしていなければ、メソッドは NullReferenceException をスローすることになります。これは単純ですが、文字列パラメーターが null かどうかを確認しなければならないのはやや面倒です。多くの場合、比較の頻度を考えれば無駄な処理です。C# 6.0 では、このようなチェックをより簡潔に記述できる null 条件演算子が新しく導入されました。

string result = value;
  if (value != null) // Skip empty string check for elucidation
  {
    result = value.Substring(0, Math.Min(value.Length, length));
  }
return result;

変更：

return value?.Substring(0, Math.Min(value.Length, length));

注意，null运算符返回的是nullable型（比如int? ，而不是int。否则报错） int length = text?.Length; // Compile Error: Cannot implicitly convert type 'int?' to 'int'

rainit2006 / My_Windows

常用处理 #22