C# 将方法传递给另一个方法以启动线程

我目前正在创建一个类，该类具有通用方法，专门用于类调用的方法。其中一个通用方法需要获取一个方法作为参数，以使用它启动新线程

我的问题是必须如何处理此参数（因此，我必须用什么替换，或者我需要总共更改什么才能使其按预期工作）：

classmytest
{
public void myPublicStarter（）
{
起动器（“试验”，这是道具）；
}
公共无效DoWork（对象myIDString）
{
}
私有void启动器（字符串myIDString，paramethod）
{
Thread myThread=新线程（paramethod）；
myThread.Start（myIDString）；
}
}

创建新的

线程

对象时，必须向其传递委托，即引用方法的对象。如果输入方法没有参数，则该委托的类型必须为

ThreadStart

；如果输入方法有参数，则该委托的类型必须为

ParameterizedThreadStart

。在本例中，您的

DoWork

方法有一个参数，因此委托类型必须是后者。因为

paramethod

参数被声明为该类型，所以当调用

Starter

时，编译器知道将

this.DoWork

转换为该类型。如果方法签名与委托的签名不匹配，则会发生编译错误

public void myPublicStarter()
{
    Starter("Test", this.DoWork);
}

public void DoWork(object myIDString)
{

}

private void Starter(string myIDString, ParameterizedThreadStart paramethod)
{
     Thread myThread = new Thread(paramethod);
     myThread.Start(myIDString);
}

---

创建新的

线程

对象时，必须向其传递委托，即引用方法的对象。如果输入方法没有参数，则该委托的类型必须为

ThreadStart

；如果输入方法有参数，则该委托的类型必须为

ParameterizedThreadStart

。在本例中，您的

DoWork

方法有一个参数，因此委托类型必须是后者。因为

paramethod

参数被声明为该类型，所以当调用

Starter

时，编译器知道将

this.DoWork

转换为该类型。如果方法签名与委托的签名不匹配，则会发生编译错误

public void myPublicStarter()
{
    Starter("Test", this.DoWork);
}

public void DoWork(object myIDString)
{

}

private void Starter(string myIDString, ParameterizedThreadStart paramethod)
{
     Thread myThread = new Thread(paramethod);
     myThread.Start(myIDString);
}

---

创建新的

线程

对象时，必须向其传递委托，即引用方法的对象。如果输入方法没有参数，则该委托的类型必须为

ThreadStart

；如果输入方法有参数，则该委托的类型必须为

ParameterizedThreadStart

。在本例中，您的

DoWork

方法有一个参数，因此委托类型必须是后者。因为

paramethod

参数被声明为该类型，所以当调用

Starter

时，编译器知道将

this.DoWork

转换为该类型。如果方法签名与委托的签名不匹配，则会发生编译错误

public void myPublicStarter()
{
    Starter("Test", this.DoWork);
}

public void DoWork(object myIDString)
{

}

private void Starter(string myIDString, ParameterizedThreadStart paramethod)
{
     Thread myThread = new Thread(paramethod);
     myThread.Start(myIDString);
}

---

创建新的

线程

对象时，必须向其传递委托，即引用方法的对象。如果输入方法没有参数，则该委托的类型必须为

ThreadStart

；如果输入方法有参数，则该委托的类型必须为

ParameterizedThreadStart

。在本例中，您的

DoWork

方法有一个参数，因此委托类型必须是后者。因为

paramethod

参数被声明为该类型，所以当调用

Starter

时，编译器知道将

this.DoWork

转换为该类型。如果方法签名与委托的签名不匹配，则会发生编译错误

public void myPublicStarter()
{
    Starter("Test", this.DoWork);
}

public void DoWork(object myIDString)
{

}

private void Starter(string myIDString, ParameterizedThreadStart paramethod)
{
     Thread myThread = new Thread(paramethod);
     myThread.Start(myIDString);
}

---

在.NET中，你有委托的概念，你有实际上只是委托的动作和函数

函数表示接受一些输入参数并具有返回值的函数。 动作表示一个方法，该方法接受一些输入参数，但不返回任何值

所以这取决于你想要达到什么

下面是一个演示示例：

static void Main(string[] args)
{
    myPublicStarter();
}

public static void myPublicStarter()
{
    Starter("Test", () => DoWork("My Id String Passed here"));
}

public static void DoWork(object myIDString)
{
    Console.WriteLine(myIDString);
}

private static void Starter(string myIDString, Action paramethod)
{
    paramethod.Invoke();
}

}

注意：在将类转换为控制台应用程序时，我将这些类设置为静态的

现在，要使代码适应线程，可以使用以下命令：

static void Main(string[] args)
{
    myPublicStarter();
}

public static void myPublicStarter()
{
    Starter("Test", x => DoWork("My Id String Passed here"));
}

public static void DoWork(object myIDString)
{
    Console.WriteLine(myIDString);
}

private static void Starter(string myIDString, Action<object> paramethod)
{
    Thread myThread = new Thread(x => paramethod(x));
    myThread.Start(myIDString);
}

static void Main（字符串[]args）
{
myPublicStarter（）；
}
公共静态void myPublicStarter（）
{
Starter（“Test”，x=>DoWork（“我的Id字符串在这里传递”）；
}
公共静态无效DoWork（对象myIDString）
{
Console.WriteLine（myIDString）；
}
私有静态void启动器（字符串myIDString，操作参数方法）
{
线程myThread=新线程（x=>paramethod（x））；
myThread.Start（myIDString）；
}

---

这将生成与上面列出的完全相同的输出。

好吧，在.NET中，您有委托的概念，您有实际上只是委托的操作和函数

函数表示接受一些输入参数并具有返回值的函数。 动作表示一个方法，该方法接受一些输入参数，但不返回任何值

所以这取决于你想要达到什么

下面是一个演示示例：

static void Main(string[] args)
{
    myPublicStarter();
}

public static void myPublicStarter()
{
    Starter("Test", () => DoWork("My Id String Passed here"));
}

public static void DoWork(object myIDString)
{
    Console.WriteLine(myIDString);
}

private static void Starter(string myIDString, Action paramethod)
{
    paramethod.Invoke();
}

}

注意：在将类转换为控制台应用程序时，我将这些类设置为静态的

现在，要使代码适应线程，可以使用以下命令：

static void Main(string[] args)
{
    myPublicStarter();
}

public static void myPublicStarter()
{
    Starter("Test", x => DoWork("My Id String Passed here"));
}

public static void DoWork(object myIDString)
{
    Console.WriteLine(myIDString);
}

private static void Starter(string myIDString, Action<object> paramethod)
{
    Thread myThread = new Thread(x => paramethod(x));
    myThread.Start(myIDString);
}

static void Main（字符串[]args）
{
myPublicStarter（）；
}
公共静态void myPublicStarter（）
{
Starter（“Test”，x=>DoWork（“我的Id字符串在这里传递”）；
}
公共静态无效DoWork（对象myIDString）
{
Console.WriteLine（myIDString）；
}
私有静态void启动器（字符串myIDString，操作参数方法）
{
线程myThread=新线程（x=>paramethod（x））；
myThread.Start（myIDString）；
}

---

这将生成与上面列出的完全相同的输出。

好吧，在.NET中，您有委托的概念，您有实际上只是委托的操作和函数

函数表示接受一些输入参数并具有返回值的函数。 动作表示一个方法，该方法接受一些输入参数，但不返回任何值

所以这取决于你想要达到什么

下面是一个演示示例：

static void Main(string[] args)
{
    myPublicStarter();
}

public static void myPublicStarter()
{
    Starter("Test", () => DoWork("My Id String Passed here"));
}

public static void DoWork(object myIDString)
{
    Console.WriteLine(myIDString);
}

private static void Starter(string myIDString, Action paramethod)
{
    paramethod.Invoke();
}

}

注意：在将类转换为控制台应用程序时，我将这些类设置为静态的

现在，到adap