0

我正在制作一个库，它将执行读取进程内存并从所述进程获取信息的操作。

我遇到的问题是，要调用函数，我每次都必须传递很多变量，即使它们的值没有改变。

例如，ReadProcessMemory要求我通过：

  • 进程句柄
  • 内存地址
  • 主模块基地址
  • 要读取的字节数

每次读取唯一会改变的是内存地址，所以我真的不需要每次调用函数时都传递其余的变量（我实际上有 3 个可以通过这种方式减少的函数，并且可能很快就会有更多）。

谁能给我一个简短的解释，我应该如何去做？变量会在运行时存在，所以我可以直接从 DLL 文件中调用函数并使用它们吗？

4

4 回答 4

2

调用带有可选参数的方法时，可以使用命名参数。

public void MyMethod(string s = null, int i = 0, MyType t = null)
{ 
    /* body */ 
}

像这样称呼它：

MyMethod(i: 10, t: new MyType());
MyMethod("abc");
MyMethod("abc", t: new MyType());

或者，您可以使用重载：

public void MyMethod(string s)
{
    MyMethod(s, 0, null);
}
public void MyMethod(int i)
{
    MyMethod(null, i, null);
}
public void MyMethod(MyType t)
{
    MyMethod(null, 0, t);
}
public void MyMethod(string s = null, int i = 0, MyType t = null)
{ 
    /* body */ 
}

另一种选择是使用像这样的参数类：

public class MyParametersClass
{
    public string s { get; set; }
    public int i { get; set; }
    public MyType t { get;set; }

    public MyParametersClass()
    {
        // set defaults
        s = null;
        i = 0;
        MyType = null;
    }
}

public void MyMethod(MyParametersClass c)
{ 
    /* body */ 
}

像这样调用：

MyMethod(new MyParametersClass 
{
    i = 25,
    t = new MyType()
});

使用参数类可能是您的首选方法。参数类可以在您处理您正在处理的任何内容时随身携带。:) 对其所做的任何更改都不会丢失...

var parameters = new MyParametersClass();
MyMethod(parameters);
parameters.i = 26;
MyMethod(parameters);
于 2013-01-18T23:17:06.743 回答
1

一种方法是将方法调用转换为对象并将参数缓存在此类对象中。称为重构为“方法对象”。

近似样本（Tx - 是一些类型）：

 int My.ReadProcessMemory(T1 a1, T2 a2, T3 variable)
 {...}


 class ReadProcessMemory
 {
      T1 a1;
      T2 a2;
      public ReadProcessMemory(T1 a1, T2 a2)
      {
         this.a1 = a1;
         this.a2 = a2;
      }
      public int Run(T3 variable)
      {
         return My.ReadProcessMemory(a1, a2, variable);
      }
 }
于 2013-01-18T23:19:13.017 回答
1

为此编写一个包装类...将变量设置为“新事物（...）”的属性或参数，然后后续调用是thing.Read（MemoryAddress）

于 2013-01-18T23:21:00.043 回答
1

除了使用命名参数之外，您还需要以某种方式将不会更改的值存储在库中。

如果这些只是运行时变量，那么您可以只使用类变量（如果您的库是类）或静态变量（如果不是）。但是，这确实意味着您的库正在存储系统的状态，并且必须验证该状态在每次调用时仍然有效。

要求在每次调用中传递值实际上是一个更简洁的接口，并强制库的用户以一致的方式工作。

于 2013-01-18T23:21:31.863 回答