c#异步通信代码错误问题

public void ConnectCallback(IAsyncResult ar)
{
Socket client = (Socket)ar.AsyncState;
client.EndConnect(ar);
bool connect_flag = false;
connect_flag = true;
ManualResetEvent connectDone = new ManualResetEvent(false); //连接的信号
connectDone.Set();
}
//vs的这段代码中 ,bool connect_flag的connect_flag报了一个警告错误,变量connect_flag已赋值,但是其值从未使用过。如何修改?
public static MODEL.DataSourceVersionQuery BrowseDataSource_QueryVersionData()
{
MODEL.DataSourceVersionQuery result = new MODEL.DataSourceVersionQuery();
//获取数据包
string strPacket = BrowseDataSource_PrepareVersionPacket();
//向服务端提交查询版本信息
string str = DAL.socket.GetSocketData(strPacket);
//DAL.socket.GetSocketData(strPacket) vs报了一个错误,非静态字段、方法或属性DAL.socket.GetSocketData(string)“要求对象引用。如何修改?
还有这个错误图片说明
另外我想把DAL中的socket.cs的 public byte[] bytesReceived { get; set; }这段移动到Model中而不报错要如何修改?
DAL中socket完整代码如下:
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Data;
using System.Windows.Forms;
using System.Threading;

namespace DAL
{
///
/// Socket接口
///

class socket
{
    //Socket
    public Socket clientSocket;

    /// <summary>
    /// socket连接
    /// </summary>
    /// <returns>
    /// true    成功
    /// false   失败
    /// </returns>

    public bool SocketConnect()
    {

        byte[] bytesReceived = new byte[256];
        ManualResetEvent connectDone = new ManualResetEvent(false); //连接的信号

        ManualResetEvent sendDone = new ManualResetEvent(false); //发送结束

        //从配置文件获取IP
        string SocketIP = DAL.Common.ReadConfigString("Recover", "IP");
        //从配置文件获取端口
        int SocketPort = Convert.ToInt32(DAL.Common.ReadConfigString("Recover", "Port"));
        //创建IP地址
        IPAddress IP = IPAddress.Parse(SocketIP);

        try
        {

            //创建socket实例
            clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //创建网络端点
            IPEndPoint ipEnd = new IPEndPoint(IP, SocketPort);

            //与目标终端连接
            clientSocket.BeginConnect(ipEnd,

            new AsyncCallback(ConnectCallback), clientSocket);//调用回调函数


            connectDone.WaitOne();
            if (clientSocket.Connected)
            {
                return true;
            }
            else
            {
                return false;
            }




        }
        catch (Exception e)
        {
            string strError = "";
            strError += "\r\n SocketIP = " + SocketIP.ToString();
            strError += "\r\n SocketPort = " + SocketPort.ToString();
            DAL.Common.WriteErrorLog(e, strError);
            return false;
        }
    }
    /// <summary>

    /// 异步连接的回调函数

    /// </summary>

    /// <param name="ar"></param>
    public void ConnectCallback(IAsyncResult ar)
    {
        Socket client = (Socket)ar.AsyncState;
        client.EndConnect(ar);
        bool connect_flag = false;
        connect_flag = true;
        ManualResetEvent connectDone = new ManualResetEvent(false); //连接的信号
        connectDone.Set();
    }

    /// <summary>
    /// Socket发送数据
    /// </summary>
    /// <param name="strSend">
    /// 数据的内容
    /// </param>
    public void SocketSend(string strSend)
    {
        Socket clientSocket; //发送创建套接字

        int length = strSend.Length;
        Byte[] bytesSent = new byte[length];
        clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {

            bytesSent = System.Text.Encoding.Default.GetBytes(strSend); //将字符串指定到指定Byte数组
            clientSocket.BeginSend(bytesSent, 0, bytesSent.Length, 0, new AsyncCallback(SendCallback), clientSocket); //异步发送数据
            ManualResetEvent sendDone = new ManualResetEvent(false);//发送结束
            sendDone.WaitOne();
        }
        catch (Exception e)
        {
            string strError = "";
            DAL.Common.WriteErrorLog(e, strError);
        }
    }
    public void SendCallback(IAsyncResult ar) //发送的回调函数
    {
        ManualResetEvent sendDone = new ManualResetEvent(false);    //发送结束
        Socket client = (Socket)ar.AsyncState;
        int bytesSend = client.EndSend(ar); //完成发送
        sendDone.Set();
    }
    /// <summary>
    /// Socket接收数据
    /// </summary>
    /// <returns>
    /// 收到的数据
    /// </returns>
    public string SocketReceive()
    {
        string result = "";
        try
        {
            MemoryStream stream = new MemoryStream();
            Byte[] bytesReceived = new Byte[256];
            clientSocket.BeginReceive(bytesReceived, 0, bytesReceived.Length, 0, new AsyncCallback(ReceiveCallback), clientSocket);
            ManualResetEvent sendDone = new ManualResetEvent(false); //发送结束
            sendDone.WaitOne();
        }
        catch (Exception e)
        {
            string strError = "";
            DAL.Common.WriteErrorLog(e, strError);
        }
        return result;
    }
    public void ReceiveCallback(IAsyncResult ar)
    {
        Socket client = (Socket)ar.AsyncState; //获取句柄
        int bytesread = client.EndReceive(ar);
        if (bytesread > 0)
        {
            clientSocket.BeginReceive(bytesReceived, 0, bytesReceived.Length, 0, new AsyncCallback(ReceiveCallback), client);
            string content = Encoding.ASCII.GetString(bytesReceived, 0, bytesReceived.Length);

        }
        else
        {
            ManualResetEvent readDone = new ManualResetEvent(false); //读信号
            readDone.Set();
        }
    }


    /// <summary>
    /// Socket通信
    /// </summary>
    /// <param name="strSend">
    /// 发送的信息
    /// </param>
    /// <returns>
    /// 包体的内容
    /// </returns>
    public string GetSocketData(string strSend)
    {
        string strDatas = "";
        string strResult = "";
        string strExtLength = "";
        try
        {
            //Socket连接
            SocketConnect();
            //发送信息
            SocketSend(strSend);
            //接收服务器的信息
            strResult = SocketReceive();
            //获取扩展信息的长度
            strExtLength = strResult.Substring(16, 12);
            int ExtLength = Convert.ToInt32(strExtLength);
            //扩展信息,暂不使用
            //string strExtInfo = strResult.Substring(32, ExtLength);
            //获取包体的内容
            strDatas = strResult.Substring(ExtLength + 32);

            //strDatas = decodedString;
        }
        catch (Exception e)
        {
            string strError = "";
            strError += "\r\n strResult = " + strResult;
            strError += "\r\n strExtLength = " + strExtLength;
            DAL.Common.WriteErrorLog(e, strError);
            strDatas = "";
        }
        return strDatas;
    }

    public string SocketReceiveFile(string FileName)
    {
        string result = "";
        try
        {
            MemoryStream streamPacketLength = new MemoryStream();
            Byte[] bytesPacketLength = new Byte[16];

            clientSocket.Receive(bytesPacketLength, bytesPacketLength.Length, 0);
            streamPacketLength.Write(bytesPacketLength, 0, bytesPacketLength.Length);
            result = System.Text.Encoding.Default.GetString(streamPacketLength.ToArray());
            int PacketLength = Convert.ToInt32(result);
            streamPacketLength.Close();

            MemoryStream streamExtLength = new MemoryStream();
            Byte[] bytesExtLength = new Byte[12];
            clientSocket.Receive(bytesExtLength, bytesExtLength.Length, 0);
            streamExtLength.Write(bytesExtLength, 0, bytesExtLength.Length);
            result = System.Text.Encoding.Default.GetString(streamExtLength.ToArray());
            int ExtLength = Convert.ToInt32(result);
            streamExtLength.Close();

            MemoryStream streamProtocol = new MemoryStream();
            Byte[] bytesProtocol = new Byte[4];
            clientSocket.Receive(bytesProtocol, bytesProtocol.Length, 0);
            streamProtocol.Write(bytesProtocol, 0, bytesProtocol.Length);
            result = System.Text.Encoding.Default.GetString(streamProtocol.ToArray());
            string Protocol = result;
            streamProtocol.Close();

            MemoryStream streamExtInfo = new MemoryStream();
            Byte[] bytesExtInfo = new Byte[ExtLength];
            clientSocket.Receive(bytesExtInfo, bytesExtInfo.Length, 0);
            streamExtInfo.Write(bytesExtInfo, 0, bytesExtInfo.Length);
            result = System.Text.Encoding.Default.GetString(streamExtInfo.ToArray());
            byte[] Buffer = Convert.FromBase64String(result);
            string strExtInfo = UTF8Encoding.UTF8.GetString(Buffer);
            streamExtInfo.Close();

            MODEL.FileTrackQuery ExtInfo = new MODEL.FileTrackQuery();
            ExtInfo = JsonConvert.DeserializeObject<MODEL.FileTrackQuery>(strExtInfo);

            if (ExtInfo.code == "00")
            {
                FileInfo fi = new FileInfo(FileName);
                DirectoryInfo di = fi.Directory;
                if (!di.Exists)
                {
                    di.Create();
                }

                FileStream streamPacketInfo = new FileStream(FileName, FileMode.Create);

                if (PacketLength > 0)
                {
                    Byte[] bytesPacketInfo = new Byte[PacketLength];

                    int bytes = 0;
                    do
                    {
                        bytes = clientSocket.Receive(bytesPacketInfo, bytesPacketInfo.Length, 0);
                        streamPacketInfo.Write(bytesPacketInfo, 0, bytes);
                    }
                    while (bytes > 0);
                }
                streamPacketInfo.Close();
            }
            clientSocket.Close();

            string strLogFile = System.AppDomain.CurrentDomain.BaseDirectory + "debug.txt";
            StreamWriter sw = new StreamWriter(strLogFile, true);
            sw.WriteLine("PacketLength : " + PacketLength.ToString());
            sw.WriteLine("ExtLength : " + ExtLength.ToString());
            sw.WriteLine("strExtInfo : " + strExtInfo);
            sw.WriteLine("ExtInfo.code : " + ExtInfo.code);
            sw.WriteLine("\n------------------------------------------------------------------------\n");
            sw.Flush();
            sw.Close();

        }
        catch (Exception e)
        {
            string strError = "";
            DAL.Common.WriteErrorLog(e, strError);
        }
        return result;
    }

    public string GetSocketFile(string strSend, string FileName)
    {
        string strDatas = "";
        string strResult = "";
        string strExtLength = "";
        try
        {
            //Socket连接
            SocketConnect();
            //发送信息
            SocketSend(strSend);
            //接收服务器的信息
            strResult = SocketReceiveFile(FileName);
            //获取扩展信息的长度
            //strExtLength = strResult.Substring(16, 12);
            //int ExtLength = Convert.ToInt32(strExtLength);
            //扩展信息,暂不使用
            //string strExtInfo = strResult.Substring(32, ExtLength);
            //获取包体的内容
            //strDatas = strResult.Substring(ExtLength + 32);
        }
        catch (Exception e)
        {
            string strError = "";
            strError += "\r\n strResult = " + strResult;
            strError += "\r\n strExtLength = " + strExtLength;
            DAL.Common.WriteErrorLog(e, strError);
            strDatas = "";
        }
        return strDatas;
    }




    public byte[] bytesReceived { get; set; }
}

}
MODEL完整代码如下:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MODEL
{
public enum ClientEditionEnum
{
Enterprise,//企业版
Personal,//个人版
Internal,//内部版
None,//error
}

/// <summary>
/// 授权文件内容
/// </summary>
public class AuthorizeFileInfo
{
    public string startTime { get; set; }
    public string expiryTime { get; set; }
    public string licenseID { get; set; }
    public string licensePassword { get; set; }
    public string terminalID { get; set; }
    public string customName { get; set; }
    public string customID { get; set; }
    public AuthorizeFileInfo()
    {
        startTime = "";
        expiryTime = "";
        licenseID = "";
        licensePassword = "";
        terminalID = "";
        customName = "";
        customID = "";
    }
}

/// <summary>
/// 通用返回值
/// </summary>
/// 
public class CommonResult
{
    public string code { get; set; }
    public string message { get; set; }
    public CommonResult()
    {
        code = "";
        message = "";
    }
}

public class EnterpriseConfirmAuthorizeDatas
{
    public string sessionID { get; set; }
    public EnterpriseConfirmAuthorizeDatas()
    {
        sessionID = "";
    }
}

/// <summary>
/// 企业版授权校验接口
/// </summary>
public class EnterpriseConfirmAuthorizeResult
{
    public string code { get; set; }
    public string message { get; set; }
    public EnterpriseConfirmAuthorizeDatas datas { get; set; }
    public EnterpriseConfirmAuthorizeResult()
    {
        code = "";
        message = "";
        datas = new EnterpriseConfirmAuthorizeDatas();
    }
}

public class PersonalConfirmAuthorizeDatas
{
    public string sessionID { get; set; }
    public string licenseInfo { get; set; }
    public PersonalConfirmAuthorizeDatas()
    {
        sessionID = "";
        licenseInfo = "";
    }
}

/// <summary>
/// 个人版授权校验接口
/// </summary>
public class PersonalConfirmAuthorizeResult
{
    public string code { get; set; }
    public string message { get; set; }
    public PersonalConfirmAuthorizeDatas datas { get; set; }
    public PersonalConfirmAuthorizeResult()
    {
        code = "";
        message = "";
        datas = new PersonalConfirmAuthorizeDatas();
    }
}

/// <summary>
/// 鉴权信息,每次调用安全接口时使用
/// </summary>
public class LicInfo
{
    public string licenseID { get; set; }
    public string licensePassword { get; set; }
    public string terminalID { get; set; }
    public string deviceID { get; set; }
    public string sessionID { get; set; }
    public LicInfo()
    {
        licenseID = "";
        licensePassword = "";
        terminalID = "";
        deviceID = "";
        sessionID = "";
    }
}

/// <summary>
/// java引擎的参数
/// </summary>
public class JavaEngineArg
{
    public string licenseID { get; set; }
    public string licensePassword { get; set; }
    public string terminalID { get; set; }
    public string customName { get; set; }
    public string customID { get; set; }
    public string deviceID { get; set; }
    public JavaEngineArg()
    {
        licenseID = "";
        licensePassword = "";
        terminalID = "";
        customName = "";
        customID = "";
        deviceID = "";
    }
}

/// <summary>
/// 用户登录接口(一),非安全接口
/// </summary>
/// 
public class UserInfoUnSafe
{
    public string userID { get; set; }
    public string userName { get; set; }
    public string departmentName { get; set; }
    public UserInfoUnSafe()
    {
        userID = "";
        userName = "";
        departmentName = "";
    }
}

public class UserLoginUnSafe
{
    public string code { get; set; }
    public string message { get; set; }
    public UserInfoUnSafe datas { get; set; }
    public UserLoginUnSafe()
    {
        code = "";
        message = "";
        datas = new UserInfoUnSafe();
    }
}

/// <summary>
/// 个人版用户登录接口,非安全接口
/// </summary>
/// 
public class UserInfoForPersonal
{
    public string userID { get; set; }
    public string userName { get; set; }
    public string departmentName { get; set; }
    public string licenseInfo { get; set; }
    public UserInfoForPersonal()
    {
        userID = "";
        userName = "";
        departmentName = "";
        licenseInfo = "";
    }
}

public class UserLoginForPersonal
{
    public string code { get; set; }
    public string message { get; set; }
    public UserInfoForPersonal datas { get; set; }
    public UserLoginForPersonal()
    {
        code = "";
        message = "";
        datas = new UserInfoForPersonal();
    }
}

/// <summary>
/// 用户登录接口(二),安全接口
/// </summary>
/// 
public class UserInfoSafe
{
    public string userSessionID { get; set; }
    public string userID { get; set; }
    public string userName { get; set; }
    public string departmentName { get; set; }
    public string activeTime { get; set; }
    public UserInfoSafe()
    {
        userSessionID = "";
        userID = "";
        userName = "";
        departmentName = "";
        activeTime = "";
    }
}

public class UserLoginSafe
{
    public string code { get; set; }
    public string message { get; set; }
    public UserInfoSafe datas { get; set; }
    public UserLoginSafe()
    {
        code = "";
        message = "";
        datas = new UserInfoSafe();
    }
}

/// <summary>
/// 更新检查接口
/// </summary>
/// 
public class SingleVersion
{
    public string softID { get; set; }
    public int version { get; set; }
    public SingleVersion()
    {
        softID = "";
        version = new int();
    }
}

public class Versions
{
    public List<SingleVersion> versions { get; set; }
    public Versions()
    {
        versions = new List<SingleVersion>();
    }
}

public class VersionUpdate
{
    public string softID { get; set; }
    public int version { get; set; }
    public string url { get; set; }
    public VersionUpdate()
    {
        softID = "";
        version = new int();
        url = "";
    }
}

public class VersionCheck
{
    public string code { get; set; }
    public string message { get; set; }
    public List<VersionUpdate> datas { get; set; }
    public VersionCheck()
    {
        code = "";
        message = "";
        datas = new List<VersionUpdate>();
    }
}


/// <summary>
/// 数据源信息查询接口
/// </summary>
/// 
public class OptInfoQuery
{
    public string createUserID { get; set; }
    public string createUserName { get; set; }
    public string createUserTime { get; set; }

    public OptInfoQuery()
    {
        createUserID = "";
        createUserName = "";
        createUserTime = "";
    }
}

public class Period
{
    public int cycle { get; set; }
    public int cycleUnit { get; set; }
    public string timer { get; set; }
    public Period()
    {
        cycle = 1;
        cycleUnit = 1;
        timer = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");
    }
}

public class StrategyConfig
{
    public int backType { get; set; }
    public int taskType { get; set; }
    public Period config { get; set; }
    public StrategyConfig()
    {
        backType = 0;
        taskType = 1;
        config = new Period();
    }
}
public class FilterFileSuffix
{
    public string suffix { get; set; }

    public FilterFileSuffix()
    {
        suffix = "";
    }
}

public class Scan
{
    public int scanType { get; set; }
    public string root { get; set; }
    public bool scanHideFile { get; set; }
    public string verifyCompleteName { get; set; }
    public int verifyCompleteMaxCount { get; set; }
    public int verifyCompleteTimer { get; set; }
    public string fileAttrGainer { get; set; }
    public bool recordCanNotReadFileInfo { get; set; }
    public bool recordEmptyDirectory { get; set; }
    public bool recordEmptyFile { get; set; }
    public List<FilterFileSuffix> filterFileSuffix { get; set; }
    public Scan()
    {
        scanType = 2;
        root = "";
        scanHideFile = false;
        verifyCompleteName = "";
        verifyCompleteMaxCount = 5;
        verifyCompleteTimer = 10000;
        fileAttrGainer = "null";
        recordCanNotReadFileInfo = false;
        recordEmptyDirectory = false;
        recordEmptyFile = false;
        filterFileSuffix = new List<FilterFileSuffix>();
    }
}

public class DataSourceConfigQuery
{
    public int status { get; set; }
    public int dataSourceType { get; set; }
    public string dataSourceID { get; set; }
    public string dataSourceName { get; set; }
    public string dataSourceDescription { get; set; }
    public Scan config { get; set; }
    public DataSourceConfigQuery()
    {
        status = 0;
        dataSourceType = 0;
        dataSourceID = "";
        dataSourceName = "";
        dataSourceDescription = "";
        config = new Scan();
    }
}

public class DatasQuery
{
    public OptInfoQuery optInfo { get; set; }
    public StrategyConfig strategyConfig { get; set; }
    public DataSourceConfigQuery dataSourceConfig { get; set; }
    public DatasQuery()
    {
        optInfo = new OptInfoQuery();
        strategyConfig = new StrategyConfig();
        dataSourceConfig = new DataSourceConfigQuery();
    }
}

public class DataSourceInfoQuery
{
    public string code { get; set; }
    public string message { get; set; }
    public List<DatasQuery> datas { get; set; }
    public DataSourceInfoQuery()
    {
        code = "";
        message = "";
        datas = new List<DatasQuery>();
    }
}

public class WebSite
{
    public string ExpirationTime { get; set; }
    public string WebSiteSpace { get; set; }
    public bool DataBaseEnable { get; set; }
    public string DataBaseUserName { get; set; }
    public string DataBasePassword { get; set; }
    public string DataBaseMark { get; set; }
    public string WebSiteAdmin { get; set; }
    public string WebSitePassword { get; set; }
    public WebSite()
    {
        ExpirationTime = "";
        WebSiteSpace = "";
        DataBaseEnable = false;
        DataBaseUserName = "";
        DataBasePassword = "";
        DataBaseMark = "";
        WebSiteAdmin = "";
        WebSitePassword = "";
    }
}

public class WebSiteDatasQuery
{
    public OptInfoQuery optInfo { get; set; }
    public StrategyConfig strategyConfig { get; set; }
    public DataSourceConfigQuery dataSourceConfig { get; set; }
    public WebSite webSiteConfig { get; set; }
    public WebSiteDatasQuery()
    {
        optInfo = new OptInfoQuery();
        strategyConfig = new StrategyConfig();
        dataSourceConfig = new DataSourceConfigQuery();
        webSiteConfig = new WebSite();
    }
}

public class WebSiteDataSourceInfoQuery
{
    public string code { get; set; }
    public string message { get; set; }
    public List<WebSiteDatasQuery> datas { get; set; }
    public WebSiteDataSourceInfoQuery()
    {
        code = "";
        message = "";
        datas = new List<WebSiteDatasQuery>();
    }
}

/// <summary>
/// 新增数据源接口
/// </summary>
/// 
public class OptInfoNew
{
    public bool forceFlag { get; set; }
    public OptInfoNew()
    {
        forceFlag = true;
    }
}

public class DataSourceConfigNew
{
    public int dataSourceType { get; set; }
    public string dataSourceName { get; set; }
    public string dataSourceDescription { get; set; }
    public Scan config { get; set; }
    public DataSourceConfigNew()
    {
        dataSourceType = 0;
        dataSourceName = "";
        dataSourceDescription = "";
        config = new Scan();
    }
}

public class DataSourceNew
{
    public OptInfoNew optInfo { get; set; }
    public StrategyConfig strategyConfig { get; set; }
    public DataSourceConfigNew dataSourceConfig { get; set; }
    public DataSourceNew()
    {
        optInfo = new OptInfoNew();
        strategyConfig = new StrategyConfig();
        dataSourceConfig = new DataSourceConfigNew();
    }
}

/// <summary>
/// 修改数据源接口
/// </summary>
/// 
public class DataSourceModify
{
    public StrategyConfig strategyConfig { get; set; }
    public DataSourceConfigQuery dataSourceConfig { get; set; }
    public DataSourceModify()
    {
        strategyConfig = new StrategyConfig();
        dataSourceConfig = new DataSourceConfigQuery();
    }
}

/// <summary>
/// 停用/启用数据源接口
/// </summary>
/// 
public class DataSourceStatus
{
    public string dataSourceID { get; set; }
    public int optType { get; set; }
    public DataSourceStatus()
    {
        dataSourceID = "";
        optType = new int();
    }
}

/// <summary>
/// 数据源数据,仅用于存放数据
/// </summary>
/// 
public class DataSourceData
{
    public List<DatasQuery> datas { get; set; }
    public DataSourceData()
    {
        datas = new List<DatasQuery>();
    }
}

/// <summary>
/// WebSite数据源数据,仅用于存放数据
/// </summary>
/// 
public class WebSiteDataSourceData
{
    public List<WebSiteDatasQuery> datas { get; set; }
    public WebSiteDataSourceData()
    {
        datas = new List<WebSiteDatasQuery>();
    }
}

/// <summary>
/// 文件恢复,版本查询
/// </summary>
/// 
public class DataSourceVersionArg
{
    // 通讯令牌
    public string secretKey { get; set; }//由token进过MD5->BASE64->MD5获得
    // 任务令牌
    public string token { get; set; }//客户端生成一个UUID
    // 前置机编号
    public string terminalId { get; set; }
    // 操作用户编号
    public string optUserID { get; set; }

    public DataSourceVersionArg()
    {
        secretKey = "";
        token = "";
        terminalId = "";
        optUserID = "";
    }
}

public class FileVersions
{
    public int file_count { get; set; }
    public long space_size { get; set; }
    public string task_id { get; set; }
    public string task_time { get; set; }
    public int total_count { get; set; }
    public string version { get; set; }
    public FileVersions()
    {
        file_count = new int();
        space_size = new long();
        task_id = "";
        task_time = "";
        total_count = new int();
        version = "";
    }
}

public class DataSourceVersion
{
    public Scan datasourceConfig { get; set; }
    public string datasourceId { get; set; }
    public string datasourceName { get; set; }
    public int datasourceStatus { get; set; }
    public int datasourceType { get; set; }
    public List<FileVersions> versions { get; set; }
    public DataSourceVersion()
    {
        datasourceConfig = new Scan();
        datasourceId = "";
        datasourceName = "";
        datasourceStatus = new int();
        datasourceType = new int();
        versions = new List<FileVersions>();
    }
}

/// <summary>
/// 查询数据源接口
/// </summary>
public class DataSourceVersionQuery
{
    public string code { get; set; }
    public string message { get; set; }
    public List<DataSourceVersion> datas { get; set; }
    public DataSourceVersionQuery()
    {
        code = "";
        message = "";
        datas = new List<DataSourceVersion>();
    }
}

/// <summary>
/// 数据源版本信息
/// </summary>
public class DataSourceVersionDatas
{
    public List<DataSourceVersion> datas { get; set; }
    public DataSourceVersionDatas()
    {
        datas = new List<DataSourceVersion>();
    }
}

/// <summary>
/// 文件恢复,文件信息查询
/// </summary>
/// 
public class QueryFileInfoArg
{
    // 通讯令牌
    public string secretKey { get; set; }//由token进过MD5->BASE64->MD5获得
    // 任务令牌
    public string token { get; set; }//客户端生成一个UUID
    // 数据源编号
    public string datasourceId { get; set; }
    // 操作用户编号
    public string optUserID { get; set; }
    // 目录文件编号--如果为根目录使用 DS_ROOT
    public string fileID { get; set; }
    // 查询的版本编号  如果是综合分析  这个字段设置为 ALL
    public string taskID { get; set; }

    public QueryFileInfoArg()
    {
        secretKey = "";
        token = "";
        datasourceId = "";
        optUserID = "";
        fileID = "";
        taskID = "";
    }
}

public class FileInfoCondition
{
    public string datasourceId { get; set; }
    public string parentId { get; set; }
    public string taskID { get; set; }
    public FileInfoCondition()
    {
        datasourceId = "";
        parentId = "";
        taskID = "";
    }
}

public class FileInfo
{
    // 文件唯一编号
    public string file_id { get; set; }
    // 源相对目录
    public string file_src_path { get; set; }
    // 文件名
    public string file_name { get; set; }
    // 文件后缀
    public string file_suffix { get; set; }
    // 是否为文件
    public bool is_file { get; set; }
    // 上级文件编号
    public string parent_id { get; set; }
    // 是否删除
    public bool is_del { get; set; }
    // 是否隐藏
    public bool is_hide { get; set; }
    // 文件大小
    public int size { get; set; }
    // 文件创建时间
    public string create_time { get; set; }
    // 文件创建人
    public string create_user { get; set; }
    // 文件最后修改时间
    public string lm_time { get; set; }
    // 文件最后修改人
    public string lm_user { get; set; }
    // 是否可读
    public bool can_read { get; set; }

    public FileInfo()
    {
        file_id = "";
        file_src_path = "";
        file_name = "";
        file_suffix = "";
        is_file = new bool();
        parent_id = "";
        is_del = new bool();
        is_hide = new bool();
        size = new int();
        create_time = "";
        create_user = "";
        lm_time = "";
        lm_user = "";
        can_read = new bool();
    }
}

public class FileInfoAndCondition
{
    public FileInfoCondition condition { get; set; }
    public List<FileInfo> fileInfos { get; set; }
    public FileInfoAndCondition()
    {
        condition = new FileInfoCondition();
        fileInfos = new List<FileInfo>();
    }
}

/// <summary>
/// 查询文件信息接口
/// </summary>
public class FileInfoQuery
{
    public string code { get; set; }
    public string message { get; set; }
    public FileInfoAndCondition datas { get; set; }
    public FileInfoQuery()
    {
        code = "";
        message = "";
        datas = new FileInfoAndCondition();
    }
}

/// <summary>
/// 文件信息
/// </summary>
public class FileInfoData
{
    public List<FileInfo> datas { get; set; }
    public FileInfoData()
    {
        datas = new List<FileInfo>();
    }
}

public class QueryFileTrackArg
{
    // 通讯令牌
    public string secretKey { get; set; }//由token进过MD5->BASE64->MD5获得
    // 任务令牌
    public string token { get; set; }//客户端生成一个UUID
    // 文件编号
    public string fileID { get; set; }
    // 操作用户编号
    public string optUserID { get; set; }
    // 查询的版本编号
    public string taskID { get; set; }

    public QueryFileTrackArg()
    {
        secretKey = "";
        token = "";
        fileID = "";
        optUserID = "";
        taskID = "";
    }
}

public class FileTrack
{
    // 文件操作
    public string act_cmd { get; set; }
    // 是否可读
    public bool can_read { get; set; }
    // 文件创建时间
    public string create_time { get; set; }
    // 文件创建人
    public string create_user { get; set; }
    // 是否删除
    public bool is_del { get; set; }
    // 是否隐藏
    public bool is_hide { get; set; }
    // 文件最后修改时间
    public string lm_time { get; set; }
    // 文件最后修改人
    public string lm_user { get; set; }
    // 文件大小
    public int size { get; set; }
    public string taskID { get; set; }

    public FileTrack()
    {
        act_cmd = "";
        can_read = new bool();
        create_time = "";
        create_user = "";
        is_del = new bool();
        is_hide = new bool();
        lm_time = "";
        lm_user = "";
        size = new int();
        taskID = "";
    }
}

public class FileTrackCondition
{
    public string fileID { get; set; }
    public string taskID { get; set; }
    public FileTrackCondition()
    {
        fileID = "";
        taskID = "";
    }
}

/// <summary>
/// 查询文件轨迹接口
/// </summary>
public class FileTrackQuery
{
    public string code { get; set; }
    public string message { get; set; }
    public FileTrackCondition condition { get; set; }
    public List<FileTrack> datas { get; set; }

    public FileTrackQuery()
    {
        code = "";
        message = "";
        condition = new FileTrackCondition();
        datas = new List<FileTrack>();
    }
}

/// <summary>
/// 文件轨迹
/// </summary>
public class FileTrackData
{
    public List<FileTrack> datas { get; set; }
    public FileTrackData()
    {
        datas = new List<FileTrack>();
    }
}

/// <summary>
/// 字典item
/// </summary>
public class DictionaryData
{
    public string version { get; set; }
    public string task_time { get; set; }
    public DictionaryData()
    {
        version = "";
        task_time = "";
    }
}

public class FileRecoverArg
{
    // 通讯令牌
    public string secretKey { get; set; }//由token进过MD5->BASE64->MD5获得
    // 任务令牌
    public string token { get; set; }//客户端生成一个UUID
    // 操作用户编号
    public string optUserID { get; set; }

    public string fileID { get; set; }
    public string taskID { get; set; }
    public string password { get; set; }

    public FileRecoverArg()
    {
        secretKey = "";
        token = "";
        optUserID = "";
        fileID = "";
        taskID = "";
        password = "";
    }
}

}

2个回答

你的图是另一个问题,你转到定义看不到这些函数的定义,因为找不到dll

报了一个错误,非静态字段、方法或属性DAL.socket.GetSocketData(string)“要求对象引用。如何修改
这个是因为你在静态方法中调用成员方法,要么你把那个方法也定义成static,要么你先new 一个对象,再调用

caozhy
贵阳老马马善福专业维修游泳池堵漏防水工程 回复alazhuabc304: new 你的类(构造函数参数列表)
接近 5 年之前 回复
alazhuabc304
alazhuabc304 如何new啊
接近 5 年之前 回复

代码太长了,看都要半天了,爱莫能助啊,

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
C#用Socket异步时出现错误

各位大侠: 我刚用 C# 写Socket 代码,服务器端用异步监控客户端,代码如下 //开启服务器端监控---Begin internal void MonitorClient() { IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 端口号); Socket serverSocket = new Socket(ipep.AddressFamily, SocketType.Stream, ProtocolType.Tcp); try { serverSocket.Bind(ipep); serverSocket.Listen(100); serverSocket.BeginAccept(clientAcceptCallBack, serverSocket); } catch ( } finally { } //serverSocket.Close(); serverSocket.Dispose(); }//End //异步监听客户端连接---Begin private void clientAcceptCallBack(IAsyncResult ar) { string IP = ""; try { Socket serverSocket = ar.AsyncState as Socket; Socket clientSocket = serverSocket.EndAccept(ar); //结束异步Accept并获已连接的Socket IPEndPoint ipEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint; //可能在这里或上面两行出错 IP = ipEndPoint.Address.ToString() + ":" + ipEndPoint.Port.ToString(); ThreadPool.QueueUserWorkItem(new WaitCallback(acceptClientMsg), (object)IP); //收信息,并根据收到的信息执行相关操作 serverSocket.BeginAccept(clientAcceptCallBack, serverSocket); //继续异步Accept,保持Accept一直开启! } catch (Exception ex) { } finally { } }//End 在 clientAcceptCallBack 中偶尔会出现“远程主机关闭了一个现有连接”的错误,但出现次数少,没办法跟踪。 由于出现次数少,没有规律,目前还不知道具体是什么原因,没办法跟踪和解决。 有没有哪位高手知道是什么原因,或碰到过?

C#异步线程回调问题,请大神帮忙

问大神一个关于异步线程回调的问题 程序运行后执行主线程的第一次循环,执行到代码A后,调用线程B异步执行 主线程继续执行 主线程第一次循环执行完后,执行第二次循环, 然后执行到代码A后 判断B线程的执行状态,如果B线程没有完成,则主线程等待B线程执行完成后再继续向下执行 以此反复 我这边写了B线程回调函数中将判断条件设为true,然后在B线程前面对这个条件进行了判断,发现没有用 不知道怎么回事儿 大神帮忙看下怎么做才能实现我想要的效果

c#同步通信改异步,求代码如何修改?

using Newtonsoft.Json; using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace DAL { /// <summary> /// Socket接口 /// </summary> static class socket { //Socket private static Socket clientSocket; /// <summary> /// socket连接 /// </summary> /// <returns> /// true 成功 /// false 失败 /// </returns> public static bool SocketConnect() { //从配置文件获取IP string SocketIP = DAL.Common.ReadConfigString("Recover", "IP"); //从配置文件获取端口 int SocketPort = Convert.ToInt32(DAL.Common.ReadConfigString("Recover", "Port")); try { //创建socket实例 clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //创建IP地址 IPAddress IP = IPAddress.Parse(SocketIP); //创建网络端点 IPEndPoint ipEnd = new IPEndPoint(IP, SocketPort); //clientSocket.Blocking = false; //Socket连接 clientSocket.Connect(ipEnd); if (clientSocket.Connected) { return true; } else { return false; } } catch (Exception e) { string strError = ""; strError += "\r\n SocketIP = " + SocketIP.ToString(); strError += "\r\n SocketPort = " + SocketPort.ToString(); DAL.Common.WriteErrorLog(e, strError); return false; } } /// <summary> /// Socket发送数据 /// </summary> /// <param name="strSend"> /// 数据的内容 /// </param> public static void SocketSend(string strSend) { try { Byte[] bytesSent = Encoding.UTF8.GetBytes(strSend); //按byte发送 clientSocket.Send(bytesSent, bytesSent.Length, 0); } catch (Exception e) { string strError = ""; DAL.Common.WriteErrorLog(e, strError); } } /// <summary> /// Socket接收数据 /// </summary> /// <returns> /// 收到的数据 /// </returns> public static string SocketReceive() { string result = ""; try { MemoryStream stream = new MemoryStream(); Byte[] bytesReceived = new Byte[256]; int bytes = 0; do { bytes = clientSocket.Receive(bytesReceived, bytesReceived.Length, 0); stream.Write(bytesReceived, 0, bytes); } while (bytes > 0); result = System.Text.Encoding.UTF8.GetString(stream.ToArray()); /*string strLogFile = System.AppDomain.CurrentDomain.BaseDirectory + "debug.txt"; StreamWriter sw = new StreamWriter(strLogFile, true); sw.WriteLine(result); sw.WriteLine("\n------------------------------------------------------------------------\n"); int len = stream.ToArray().Length; char[] tempchar = new char[len]; byte[] tempbyte = new byte[len]; tempbyte = stream.ToArray(); for (int i = 0; i < len; i++) { tempchar[i] = (char)tempbyte[i]; } sw.Write(tempchar); sw.WriteLine("\n------------------------------------------------------------------------\n"); sw.Flush(); sw.Close();*/ //接收完毕后断开连接 clientSocket.Close(); } catch (Exception e) { string strError = ""; DAL.Common.WriteErrorLog(e, strError); } return result; } /// <summary> /// Socket通信 /// </summary> /// <param name="strSend"> /// 发送的信息 /// </param> /// <returns> /// 包体的内容 /// </returns> public static string GetSocketData(string strSend) { string strDatas = ""; string strResult = ""; string strExtLength = ""; try { //Socket连接 SocketConnect(); //发送信息 SocketSend(strSend); //接收服务器的信息 strResult = SocketReceive(); //获取扩展信息的长度 strExtLength = strResult.Substring(16, 12); int ExtLength = Convert.ToInt32(strExtLength); //扩展信息,暂不使用 //string strExtInfo = strResult.Substring(32, ExtLength); //获取包体的内容 strDatas = strResult.Substring(ExtLength + 32); //strDatas = decodedString; } catch (Exception e) { string strError = ""; strError += "\r\n strResult = " + strResult; strError += "\r\n strExtLength = " + strExtLength; DAL.Common.WriteErrorLog(e, strError); strDatas = ""; } return strDatas; }

关于C#异步多线程编写时准确传参的问题

如题,如何做到在多个带参数线程依次执行时传参准确,我的具体情况如下: 线程执行函数中带有参数dotime,同时为保证异步顺次执行,使用了信号量,代码为 ```public class proinformation { ... public int dotime; ... public async void Threadbuild() { await slim.WaitAsync(); ... Thread.Sleep(dotime * 1000); ... slim.Release(); } }``` 以上封装在一个类中,在窗体控件Form类中,有触发函数 ```proin[x].dotime = proin[x].lesstime; pro = new Thread(proin[x].Threadbuild); pro.Start();``` 如果X=1,2,3,相当于创建了3个进程,其dotime参数假设为2,4,5,但在我实际操作过程中发现问题 即本来应该是执行2S,4S,5S的进程的实际执行情况为5S,5S,5S,即重复最后一次执行 我个人认为原因可能在于传参时覆盖了前一参数,故有上述问题,我该如何准确传参?

C# 异步下载问题

public string IPAdress = "xx.xx.xx.xx"; public string ftpUser = "xxx"; public string ftpPassWord = "xxxxxxxx"; public string LocalAdress = "D://"; public string FileName = "xx.txt"; private void Upload() { Uri uri = new Uri("ftp://" + IPAdress + "/" + FileName); //定义FtpWebRequest,并设置相关属性 FtpWebRequest uploadRequest = (FtpWebRequest)WebRequest.Create(uri); uploadRequest.Method = WebRequestMethods.Ftp.UploadFile; uploadRequest.Credentials = new NetworkCredential(ftpUser, ftpPassWord); //开始以异步方式打开请求的内容流以便写入 uploadRequest.BeginGetRequestStream(new AsyncCallback(EndGetStreamCallback), uploadRequest); } private void EndGetStreamCallback(IAsyncResult ar) { //用户定义对象,其中包含该操作的相关信息,在这里得到FtpWebRequest FtpWebRequest uploadRequest = (FtpWebRequest)ar.AsyncState; //结束由BeginGetRequestStream启动的挂起的异步操作 //必须调用EndGetRequestStream方法来完成异步操作 //通常EndGetRequestStream由callback所引用的方法调用 Stream requestStream = uploadRequest.EndGetRequestStream(ar); FileStream fileStream = File.Open(@""+LocalAdress + FileName, FileMode.Open); byte[] buffer = new byte[2048]; int bytesRead; float size; while (true) { bytesRead = fileStream.Read(buffer, 0, buffer.Length); startbye += bytesRead; if (bytesRead == 0) break; Debug.Log(startbye); size = fileStream.Length; //本地的文件流数据写到请求流 requestStream.Write(buffer, 0, bytesRead); } requestStream.Close(); fileStream.Close(); //开始以异步方式向FTP服务器发送请求并从FTP服务器接收响应 uploadRequest.BeginGetResponse(new AsyncCallback(EndGetResponseCallback), uploadRequest); } private void EndGetResponseCallback(IAsyncResult ar) { FtpWebRequest uploadRequest = (FtpWebRequest)ar.AsyncState; //结束由BeginGetResponse启动的挂起的异步操作 FtpWebResponse uploadResponse = (FtpWebResponse)uploadRequest.EndGetResponse(ar); Debug.Log(uploadResponse.StatusDescription); Debug.Log("Upload complete"); } 求教大神!!!!!如何把这段异步上传修改成异步下载!!!

C#多线程异步线程监控的问题

我现在除主线程外又写了一个异步线程A 但是我主线程往下执行时,会有一程序需要在这个异步线程完成后才能继续执行, 我现在想写一个异步线程B,来实时监控线程A的执行状态,当线程A执行完后返回true 来让主线程继续执行 请大神帮忙给组织下逻辑

C#中 没有循环的异步操作如何中止

private async Task<string> CheckServer() { SqlConnection mySqlConnection = new SqlConnection(); mySqlConnection.ConnectionString = UserInfo.Session.ConnectString1; try { await Task.Run(() => mySqlConnection.Open()); mySqlConnection.Close(); UserInfo.Session.PublicIP = await UtilConv.GetPublicIP(); } catch (Exception) { return "远程服务器连接失败,请检查远程服务器设置"; } return "1"; } public async void CheckDB() { var result= await CheckServer(); } ``` ```

C#网口通信网口的问题

C#网口程序有时候在一台电脑可以实现数据传输,但是换了电脑,程序就发不出数据,用wireshark抓不到数据,这是为什么?

关于C#异步多线程编写时插入新线程的问题

如题,C#环境下,遇到问题如下,**假设我现在执行的线程依次为pro1,2,3,这时候我通过窗体控件新建了线程pro4并且想让他在pro3后运行(插入PRO4时PRO3未结束)请问该如何处理?** 具体解释: 我的线程创建函数在timealgorithm()方法中,会依次创建线程 整体处于go按钮的点击触发方法中,如下代码: ```private void go_Click(object sender, EventArgs e) { ... while (judgeall(finish) == false) { timealgorithm(); } ... //here }``` 如果我在here处添加了字符回显于richtestbox控件,他会在线程开始之前立刻显示 (ps. **所以顺带求问如何监控多个重名线程状态是否结束**,我是在一个循环里创建线程,创建代码如下: ```Thread pro = new Thread(new ParameterizedThreadStart(proin[x].Threadbuild)); pro.Start(timet);``` ) 我个人由于基础是C语言,开始考虑使用死循环解决,用一个按钮结束循环,但是学习C#发现按钮触发方法中死循环会直接卡死框体,故求问解决方法

c#有关异步的问题: async await Task

比方说我现在有个api:a页面中有个 a1方法, a1异步调用a2方法, a2异步调用a3方法, a3中是执行数据库查询操作的,那么我的a3中数据库查询也必须要用异步数据库查询方法吗?如果是同步查询数据库,那么前面的异步起作用了吗?

c# socket同步操作代码改异步操作,客户端界面错误问题

c# socket同步操作代码改异步操作,客户端软件界面错误如下:一点击数据源配置模块,就提示数据解析错误,请重启客户端。除了首页模块是正确的以外,点击文件修复和授权信息界面信息都出不来,而且软件卡死,按右上角的关闭键也无法退出。项目采用.net三层架构,修改后的socket类的异步传输部代码如下: ![![图片说明](https://img-ask.csdn.net/upload/201509/17/1442497613_763975.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442497607_172400.png) ![![![![![![![![![![![图片说明](https://img-ask.csdn.net/upload/201509/17/1442498556_560286.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498594_534760.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498557_279873.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498469_791285.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498420_801626.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498378_653933.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498306_209580.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498276_400425.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498211_949856.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498103_147396.png)图片说明](https://img-ask.csdn.net/upload/201509/17/1442498033_216971.png)

c#的异步socket回调是多线程回调,怎么处理的

在写一个unity的项目网络层,用c#的异步socket,BeginSend,EndSend,BeginReceive,EndReceive,但是发现回调的方式是多线程回调: 下面的代码我在回调的地方打印出线程id,发现不一样: 如果是多线程回调,那么收到数据recve回调的时候想要做包解析,必须要自己把这个事件丢到消息队列中放到网络层线程中去处理,这样又好麻烦,感觉这个异步的接口应该不会这么麻烦吧,怀疑是不是用错了。有没有遇到相同问题的,求教一下怎么处理的。 /// 异步发送 public void AsynSend() { if (m_socket == null) return; //编码 try { m_socket.BeginSend(m_sendBuffer, 0, m_sendPos, SocketFlags.None, asyncResult => { //完成发送消息 int bytes = m_socket.EndSend(asyncResult); if(bytes <= 0) { Close(); return; } UnityEngine.Debug.LogWarning("send length:"+bytes); UnityEngine.Debug.LogWarning("current send thread:" + Thread.CurrentThread.ManagedThreadId); m_sendPos -= bytes; }, null); } catch (Exception ex) { Close(); UnityEngine.Debug.LogWarning("异常信息:"+ ex.Message); } } //异步接受 public void AsynRecive() { try { //开始接收数据 m_socket.BeginReceive(m_recvBuffer, m_recvPos, m_recvBuffer.Length - m_recvPos, SocketFlags.None, asyncResult => { int bytes = m_socket.EndReceive(asyncResult); UnityEngine.Debug.LogWarning("recv length:"+bytes); UnityEngine.Debug.LogWarning("current recv thread:" + Thread.CurrentThread.ManagedThreadId); AsynRecive(); if (bytes <= 0) { Close(); return; } m_recvPos += bytes; ParseProtocol(); }, null); } catch (Exception ex) { Close(); UnityEngine.Debug.LogWarning("异常信息:"+ex.Message); } }

新人求问关于C#异步编程的问题

异步编程是不是轮询时间片来执行?如果是的话,那么其实跟只有一条线程来执行有什么区别?await是不是就是实现线程中的同步?

C#同/异步委托使用和调用,请指教

public delegate void GetResultEventHandler(object sender, bool IsSucceed, string DataResults); public event GetResultEventHandler OnGetInfoCompleted; public void GetPostHtmlResults(string GetURL, int GetTimeOut) { HttpWebRequest request = HttpWebRequest.CreateHttp(GetURL); request.Method = "GET"; request.ContinueTimeout = GetTimeOut; request.BeginGetResponse(GetInfoCompleted, request); } private void GetInfoCompleted(IAsyncResult asyncResult) { try { HttpWebRequest webRequest = asyncResult.AsyncState as HttpWebRequest; HttpWebResponse webResponse = (HttpWebResponse)webRequest.EndGetResponse(asyncResult); Stream streamResult = webResponse.GetResponseStream(); StreamReader reader = new StreamReader(streamResult, Encoding.UTF8); if (OnGetInfoCompleted != null) OnGetInfoCompleted(this, true, reader.ReadToEnd()); } catch (WebException ex) { OnGetInfoCompleted(this, false, ex.Message.ToString()); } } 请问这个同/异步委托对不对,还有怎样调用它,谢谢!

C#控制台与窗体异步调用线程ID输出不一样

![图片说明](https://img-ask.csdn.net/upload/201705/08/1494226319_971909.jpg)![图片说明](https://img-ask.csdn.net/upload/201705/08/1494226305_992717.jpg) 窗体程序在调用GetStringAsync之后的方法是在主线程(线程ID:1)中运行的与前面的方法线程ID一致 而控制台程序在调用GetStringAsync之后的方法在子线程(线程ID:9)中运行,与前面方法线程ID(主线程1)不一致 这是为什么?

C# click事件 多线程 异步 耗时 操作UI

listbox做了个目录(单层),点击一条就在另一个控件加载相应的内容。这个加载过程是耗时操作。 所以考虑用异步,在click处理函数里开了子线程。因为需要操作UI,所以在子线程里调用invoke,但是无论使用invoke还是beginInvoke,那个加载内容的函数都是在UI线程上执行。这样就会造成UI线程阻塞。 想实现的效果是,一次点击之后马上能响应下一次点击同时把上一次点击的加载线程结束掉而执行当前点击的加载线程。或者在下一次点击的时候判断上一次是否加载完成,如果没完成则提示,等待完成。 哪位熟悉这个的有什么好办法?

C# 用FileStream.WriteAsync 异步读文件 调用线程还是被阻塞了。

在用FileStream WriteAsync方法(BeginWrite方法也是一样)的异步写文件时、 如下代码。实际上调用这段代码的时候,还是被阻塞了。 ``` FileStream stream = new FileStream("in.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, 1024, FileOptions.Asynchronous); byte[] byteData = new byte[80961024 * 4]; Task task = stream.WriteAsync(byteData, 0, byteData.Length); ``` 如果把这个FileStream绑定到一个StreamWriter上,用StreamWriter的WriteAsync方法倒是能异步,不会阻塞。 ``` FileStream stream = new FileStream("in.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, 1024, FileOptions.Asynchronous); char[] byteData = new char[80961024 * 4]; var sw = new StreamWriter(stream); Task task = sw.WriteAsync(byteData, 0, byteData.Length); ``` 求大神解惑

C#中串口通信发送数据问题

串口通信数据发送,除了可用字节数组byte[],还可以用其他的什么吗?

vb与c#之间通信,VB不能正常接收数据

两个程序之间用WM_COPYDATA方法传递数据,现在VB向c#发送数据,c#可以正常接收(不管VB发送的数据有多长);c#向VB发送的数据长度小于50,VB能正常接收。问题是c#向VB发送的数据长度大于50的话,VB只能接收前50个,不知道问题出现在哪,请各位高手帮忙看一下,也可qq联系我45262121,另源程序代码附上 ![http://ask.csdn.net/mentors#图片说明](https://img-ask.csdn.net/upload/201503/02/1425267701_449579.jpg)

c#客户端程序 socket异步接收终端设备传输的数据

现在要做一个客户端程序,需要接收终端设备传输过来的数据,需要做到多线程异步通讯,求大神解决

Python可以这样学(第一季:Python内功修炼)

董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

获取Linux下Ftp目录树并逐步绑定到treeview

在linux下抓取目录树,双击后获取该节点子节点(逐步生成)。另外有两个类,一个是windows下的(一次性获取目录树),一个是linux下的(足部获取目录树)

NS网络模拟和协议仿真源代码

NS网络模拟和协议仿真源代码,包含代码说明及协议分析

简单的NS3网络模拟仿真(计算机网络作业)

简单的NS3网络模拟仿真,内附有PPT演示。论文评述。以及简单的安装教程。

手把手实现Java图书管理系统(附源码)

【超实用课程内容】 本课程演示的是一套基于Java的SSM框架实现的图书管理系统,主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的java人群。详细介绍了图书管理系统的实现,包括:环境搭建、系统业务、技术实现、项目运行、功能演示、系统扩展等,以通俗易懂的方式,手把手的带你从零开始运行本套图书管理系统,该项目附带全部源码可作为毕设使用。 【课程如何观看?】 PC端:https://edu.csdn.net/course/detail/27513 移动端:CSDN 学院APP(注意不是CSDN APP哦) 本课程为录播课,课程2年有效观看时长,大家可以抓紧时间学习后一起讨论哦~ 【学员专享增值服务】 源码开放 课件、课程案例代码完全开放给你,你可以根据所学知识,自行修改、优化

三个项目玩转深度学习(附1G源码)

从事大数据与人工智能开发与实践约十年,钱老师亲自见证了大数据行业的发展与人工智能的从冷到热。事实证明,计算机技术的发展,算力突破,海量数据,机器人技术等,开启了第四次工业革命的序章。深度学习图像分类一直是人工智能的经典任务,是智慧零售、安防、无人驾驶等机器视觉应用领域的核心技术之一,掌握图像分类技术是机器视觉学习的重中之重。针对现有线上学习的特点与实际需求,我们开发了人工智能案例实战系列课程。打造:以项目案例实践为驱动的课程学习方式,覆盖了智能零售,智慧交通等常见领域,通过基础学习、项目案例实践、社群答疑,三维立体的方式,打造最好的学习效果。

150讲轻松搞定Python网络爬虫

【为什么学爬虫?】 &nbsp; &nbsp; &nbsp; &nbsp;1、爬虫入手容易,但是深入较难,如何写出高效率的爬虫,如何写出灵活性高可扩展的爬虫都是一项技术活。另外在爬虫过程中,经常容易遇到被反爬虫,比如字体反爬、IP识别、验证码等,如何层层攻克难点拿到想要的数据,这门课程,你都能学到! &nbsp; &nbsp; &nbsp; &nbsp;2、如果是作为一个其他行业的开发者,比如app开发,web开发,学习爬虫能让你加强对技术的认知,能够开发出更加安全的软件和网站 【课程设计】 一个完整的爬虫程序,无论大小,总体来说可以分成三个步骤,分别是: 网络请求:模拟浏览器的行为从网上抓取数据。 数据解析:将请求下来的数据进行过滤,提取我们想要的数据。 数据存储:将提取到的数据存储到硬盘或者内存中。比如用mysql数据库或者redis等。 那么本课程也是按照这几个步骤循序渐进的进行讲解,带领学生完整的掌握每个步骤的技术。另外,因为爬虫的多样性,在爬取的过程中可能会发生被反爬、效率低下等。因此我们又增加了两个章节用来提高爬虫程序的灵活性,分别是: 爬虫进阶:包括IP代理,多线程爬虫,图形验证码识别、JS加密解密、动态网页爬虫、字体反爬识别等。 Scrapy和分布式爬虫:Scrapy框架、Scrapy-redis组件、分布式爬虫等。 通过爬虫进阶的知识点我们能应付大量的反爬网站,而Scrapy框架作为一个专业的爬虫框架,使用他可以快速提高我们编写爬虫程序的效率和速度。另外如果一台机器不能满足你的需求,我们可以用分布式爬虫让多台机器帮助你快速爬取数据。 &nbsp; 从基础爬虫到商业化应用爬虫,本套课程满足您的所有需求! 【课程服务】 专属付费社群+每周三讨论会+1v1答疑

cuda开发cutilDLL

包括cutil32.dll、cutil32D.dll、cutil32.lib、cutil32D.lib,以及附带的glew32.lib/freeglut.lib

深度学习原理+项目实战+算法详解+主流框架(套餐)

深度学习系列课程从深度学习基础知识点开始讲解一步步进入神经网络的世界再到卷积和递归神经网络,详解各大经典网络架构。实战部分选择当下最火爆深度学习框架PyTorch与Tensorflow/Keras,全程实战演示框架核心使用与建模方法。项目实战部分选择计算机视觉与自然语言处理领域经典项目,从零开始详解算法原理,debug模式逐行代码解读。适合准备就业和转行的同学们加入学习! 建议按照下列课程顺序来进行学习 (1)掌握深度学习必备经典网络架构 (2)深度框架实战方法 (3)计算机视觉与自然语言处理项目实战。(按照课程排列顺序即可)

Tensorflow与python3.7适配版本

tensorflow与python3.7匹配的最新库,更新了python3.7以后可以自行下载,或者去国外python的扩展包下载界面自行下载。

4小时玩转微信小程序——基础入门与微信支付实战

这是一个门针对零基础学员学习微信小程序开发的视频教学课程。课程采用腾讯官方文档作为教程的唯一技术资料来源。杜绝网络上质量良莠不齐的资料给学员学习带来的障碍。 视频课程按照开发工具的下载、安装、使用、程序结构、视图层、逻辑层、微信小程序等几个部分组织课程,详细讲解整个小程序的开发过程

专为程序员设计的数学课

<p> 限时福利限时福利,<span>15000+程序员的选择!</span> </p> <p> 购课后添加学习助手(微信号:csdn590),按提示消息领取编程大礼包!并获取讲师答疑服务! </p> <p> <br> </p> <p> 套餐中一共包含5门程序员必学的数学课程(共47讲) </p> <p> 课程1:《零基础入门微积分》 </p> <p> 课程2:《数理统计与概率论》 </p> <p> 课程3:《代码学习线性代数》 </p> <p> 课程4:《数据处理的最优化》 </p> <p> 课程5:《马尔可夫随机过程》 </p> <p> <br> </p> <p> 哪些人适合学习这门课程? </p> <p> 1)大学生,平时只学习了数学理论,并未接触如何应用数学解决编程问题; </p> <p> 2)对算法、数据结构掌握程度薄弱的人,数学可以让你更好的理解算法、数据结构原理及应用; </p> <p> 3)看不懂大牛代码设计思想的人,因为所有的程序设计底层逻辑都是数学; </p> <p> 4)想学习新技术,如:人工智能、机器学习、深度学习等,这门课程是你的必修课程; </p> <p> 5)想修炼更好的编程内功,在遇到问题时可以灵活的应用数学思维解决问题。 </p> <p> <br> </p> <p> 在这门「专为程序员设计的数学课」系列课中,我们保证你能收获到这些:<br> <br> <span> </span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">①价值300元编程课程大礼包</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">②应用数学优化代码的实操方法</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">③数学理论在编程实战中的应用</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">④程序员必学的5大数学知识</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">⑤人工智能领域必修数学课</span> </p> <p> <br> 备注:此课程只讲程序员所需要的数学,即使你数学基础薄弱,也能听懂,只需要初中的数学知识就足矣。<br> <br> 如何听课? </p> <p> 1、登录CSDN学院 APP 在我的课程中进行学习; </p> <p> 2、登录CSDN学院官网。 </p> <p> <br> </p> <p> 购课后如何领取免费赠送的编程大礼包和加入答疑群? </p> <p> 购课后,添加助教微信:<span> csdn590</span>,按提示领取编程大礼包,或观看付费视频的第一节内容扫码进群答疑交流! </p> <p> <img src="https://img-bss.csdn.net/201912251155398753.jpg" alt=""> </p>

实现简单的文件系统

实验内容: 通过对具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现,加深对文件系统内部功能和实现过程的理解。 要求: 1.在内存中开辟一个虚拟磁盘空间作为文件存储器,在其上实现一个简

机器学习初学者必会的案例精讲

通过六个实际的编码项目,带领同学入门人工智能。这些项目涉及机器学习(回归,分类,聚类),深度学习(神经网络),底层数学算法,Weka数据挖掘,利用Git开源项目实战等。

四分之一悬架模型simulink.7z

首先建立了四分之一车辆悬架系统的数学模型,应用MATLAB/Simulink软件建立该系统的仿真模型,并输入路面激励为随机激励,控制不同的悬架刚度和阻尼,选用最优的参数得到车辆悬架的振动加速度变化曲线

MFC一站式终极全套课程包

该套餐共包含从C小白到C++到MFC的全部课程,整套学下来绝对成为一名C++大牛!!!

C++语言基础视频教程

C++语言基础视频培训课程:本课与主讲者在大学开出的程序设计课程直接对接,准确把握知识点,注重教学视频与实践体系的结合,帮助初学者有效学习。本教程详细介绍C++语言中的封装、数据隐藏、继承、多态的实现等入门知识;主要包括类的声明、对象定义、构造函数和析构函数、运算符重载、继承和派生、多态性实现等。 课程需要有C语言程序设计的基础(可以利用本人开出的《C语言与程序设计》系列课学习)。学习者能够通过实践的方式,学会利用C++语言解决问题,具备进一步学习利用C++开发应用程序的基础。

Java8零基础入门视频教程

这门课程基于主流的java8平台,由浅入深的详细讲解了java SE的开发技术,可以使java方向的入门学员,快速扎实的掌握java开发技术!

HoloLens2开发入门教程

本课程为HoloLens2开发入门教程,讲解部署开发环境,安装VS2019,Unity版本,Windows SDK,创建Unity项目,讲解如何使用MRTK,编辑器模拟手势交互,打包VS工程并编译部署应用到HoloLens上等。

C/C++学习指南全套教程

C/C++学习的全套教程,从基本语法,基本原理,到界面开发、网络开发、Linux开发、安全算法,应用尽用。由毕业于清华大学的业内人士执课,为C/C++编程爱好者的教程。

pokemmo的资源

pokemmo必须的4个rom 分别为绿宝石 火红 心金 黑白 还有汉化补丁 资源不错哦 记得下载

test_head.py

本文件主要是针对使用dlib的imglab标注工具标记的目标检测框和关键点检测而生成的xml文件, 转换为coco数据集格式.

Java面试史上最全的JAVA专业术语面试100问 (前1-50)

前言: 说在前面, 面试题是根据一些朋友去面试提供的,再就是从网上整理了一些。 先更新50道,下一波吧后面的也更出来。 求赞求关注!! 废话也不多说,现在就来看看有哪些面试题 1、面向对象的特点有哪些? 抽象、继承、封装、多态。 2、接口和抽象类有什么联系和区别? 3、重载和重写有什么区别? 4、java有哪些基本数据类型? 5、数组有没有length()方法?String有没有length()方法? 数组没有length()方法,它有length属性。 String有length()方法。 集合求长度用

2019 AI开发者大会

2019 AI开发者大会(AI ProCon 2019)是由中国IT社区CSDN主办的AI技术与产业年度盛会。多年经验淬炼,如今蓄势待发:2019年9月6-7日,大会将有近百位中美顶尖AI专家、知名企业代表以及千余名AI开发者齐聚北京,进行技术解读和产业论证。我们不空谈口号,只谈技术,诚挚邀请AI业内人士一起共铸人工智能新篇章!

linux“开发工具三剑客”速成攻略

工欲善其事,必先利其器。Vim+Git+Makefile是Linux环境下嵌入式开发常用的工具。本专题主要面向初次接触Linux的新手,熟练掌握工作中常用的工具,在以后的学习和工作中提高效率。

DirectX修复工具V4.0增强版

DirectX修复工具(DirectX Repair)是一款系统级工具软件,简便易用。本程序为绿色版,无需安装,可直接运行。 本程序的主要功能是检测当前系统的DirectX状态,如果发现异常则进行修复

20行代码教你用python给证件照换底色

20行代码教你用python给证件照换底色

2019 Python开发者日-培训

本次活动将秉承“只讲技术,拒绝空谈”的理念,邀请十余位身处一线的Python技术专家,重点围绕Web开发、自动化运维、数据分析、人工智能等技术模块,分享真实生产环境中使用Python应对IT挑战的真知灼见。此外,针对不同层次的开发者,大会还安排了深度培训实操环节,为开发者们带来更多深度实战的机会。

我以为我对Mysql事务很熟,直到我遇到了阿里面试官

太惨了,面试又被吊打

相关热词 c#中如何设置提交按钮 c#帮助怎么用 c# 读取合并单元格的值 c#带阻程序 c# 替换span内容 c# rpc c#控制台点阵字输出 c#do while循环 c#调用dll多线程 c#找出两个集合不同的
立即提问