Le délégué à une méthode d'instance ne peut pas avoir null 'this'

Je développe en C# .NET 2.0 de l'application dans laquelle au moment de l'exécution de l'une des deux Dll sont chargées en fonction de l'environnement. Les deux Dll contiennent les mêmes fonctions, mais ils ne sont pas liés à la même adresse d'offset. Ma question est au sujet de la fonction des délégués dans mon code de l'application.

public class MyClass
{
    public delegate int MyFunctionDelegate(int _some, string _args);

    public MyFunctionDelegate MyFuncToCallFrmApp;

    public MyClass() : base()
    {
        this.MyFuncToCallFrmApp = new MyFunctionDelegate(this.MyFuncToCallFrmApp); //<-- Exception thrown here.
    }

    public SomeFunction()
    {
        MyFuncToCallFrmApp(int _someOther, string _argsLocal);
    }
}

Quand mon code s'exécute, je reçois un ArgumentException de "Déléguer à une méthode d'instance ne peut pas avoir la valeur null 'cette'." Ce que je fais mal?

source d'informationauteur Jim Fell

c#delegates

10

Vous devez attribuer une fonction valide (hébergé par une classe dans le chargement dynamique des dll) pour votre délégué variable. Si les fonctions sont des méthodes statiques de classes avec la même nomc'est simple:
```
public MyClass() {
    this.MyFuncToCallFrmApp = ExternalClass.Function;
}
```
Si les fonctions sont les méthodes d'instance de classes avec le même nom, il suffit de créer une instance et faire la même chose (à noter également que, tant que le délégué est dans la portée, il permettra d'éviter la ExternalClass instance de garbage collector - vous pouvez stocker l'instance en tant que membre de la variable pour le rendre plus clair):
```
public MyClass() {
    this.MyFuncToCallFrmApp = new ExternalClass().Function;
}
```
Si l'chargées dynamiquement les classes ont des noms différents, vous aurez besoin de déterminer qui de l'une à l'appel dans cet exemple, je suis à l'aide d'un booléen variable de membre de décider si ou de ne pas utiliser une valeur par défaut de l'assemblée de classe:
```
public MyClass() {
    if (this.defaultAssembly) {
        this.MyFuncToCallFrmApp = ExternalClass1.Function;
    } else {
        this.MyFuncToCallFrmApp = ExternalClass2.Function;
    }
}
```
10

Dans votre ligne:
```
this.MyFuncToCallFrmApp = new MyFunctionDelegate(this.MyFuncToCallFrmApp); 
```
Vous utilisez ".MyFuncToCallFrmApp" avant de le céder, ce qui signifie qu'il est null au moment de la cession. Faire un délégué point à lui-même n'a pas de sens. Est-ce que vous essayez de faire?

Que vous essayez de créer une nouvelle instance d'un délégué à l'aide de la non initialisée instance du délégué qui est déjà dans votre classe...ce qui n'a pas de sens.

Vous devez initialiser le délégué à l'aide d'une méthode à partir de votre classe qui correspond à un les arguments de la liste que votre délégué ou de ne pas initialiser le délégué et de permettre au consommateur de votre classe afin d'initialiser le délégué à l'aide de la méthode d'appariement à partir de leur code (qui est ce que les délégués sont normalement utilisés pour les):

public class MyClass
{
    public delegate int MyFunctionDelegate(int some, string args);
    public MyFunctionDelegate MyFuncToCallFrmApp;

    public MyClass() : base() { }
    public SomeFunction()
    {
        if(MyFuncToCallFrmApp != null)
            MyFuncToCallFrmApp(_someOther, _argsLocal);
    }
}

public class Consumer
{
    MyClass instance = new MyClass();

    public Consumer()
    {
        instance.MyFuncToCallFrmApp = new MyFunctionDelegate(MyFunc);
    }

    public void MyFunc(int some, string args)
    {
        //Do Something
    }
}

Jim, je suis en train d'apprendre les délégués en C# moi-même.

Un problème avec votre code, c'est que vous n'avez pas attribué le délégué d'une ordonnance d'un gestionnaire. La signature du délégué doit être assortie d'une ordonnance d'un gestionnaire avec la même signature de la méthode.

Dans la ligne:

this.MyFuncToCallFrmApp = new MyFunctionDelegate(this.MyFuncToCallFrmApp);

this.MyFuncToCallFrmApp est un délégué, mais il doit être une méthode valable gestionnaire de la place.

Ici est de savoir comment vous passez par un gestionnaire de méthode:

public delegate int MyFunctionDelegate(int _some, string _args);

MyFunctionDelegate MyFuncToCallFrmApp = new MyFunctionDelegate(PrintValues);

//the method I'm mapping has a valid signature for the delegate I'm mapping to:
public void PrintValues(int some, string args)
{
  Console.WriteLine(string.Format("Some = {0} & Args = {1}", some.ToString(), args));
}

J'espère que le lien ci-dessous et le code de l'échantillon sera de peu d'aide pour vous:

Les Délégués Tutoriel

Un délégué en C# est semblable à un pointeur de fonction en C ou C++. À l'aide d'un délégué permet au programmeur d'encapsuler une référence à une méthode à l'intérieur d'un délégué de l'objet. Le délégué de l'objet peut ensuite être transmis à un code qui peut appeler référencé dans la méthode, sans avoir à connaître au moment de la compilation de la méthode qui sera invoquée. Contrairement aux pointeurs de fonction en C ou C++, les délégués sont orientées objet, de type sécurisé et sécurisé. (MSDN)

public class MyClass
{
  //a delegate by definition is a collection of pointers to method handlers
  //I declare my delegate on this line
  //PLEASE NOTE THE SIGNATURE!
  public delegate void MyFunctionDelegate(int some, string args);

  public MyClass() : base()
  {
    //instantiate the delegate (AKA create the pointer)
    MyFunctionDelegate myFunctionDelegate = new MyFunctionDelegate();

    //map a valid method handler (WITH THE SAME SIGNATURE) to this delegate
    //I'm using "+=" operator because you can add more than one handler to a collection
    myFunctionDelegate += new MyFunctionDelegate(PrintValues);

    //invoke the method handler (which in this case is PrintValues() - see below)
    //NOTE THE SIGNATURE OF THIS CALL
    myFunctionDelegate(1, "Test");
  }

  //this is the handler method that I am going to map to the delegate
  //AGAIN, PLEASE NOTE THE SIGNATURE
  public void PrintValues(int some, string args)
  {
    Console.WriteLine(string.Format("Some = {0} & Args = {1}", some.ToString(), args));
  }
}

2

Vous essayez d'initialiser le délégué à l'appel lui-même. Ce que vous faites fondamentalement n'a pas de sens.

Vous devez vous connecter pour publier un commentaire.