Visszamenőleges kompatibilitási irányelvek

A visszamenőlegesen kompatibilis kód írása nehéz és nehezen tesztelhető. Ez a cikk a visszamenőlegesen kompatibilis kód .NET-ben Orleansvaló írásának irányelveit ismerteti. Ez a cikk az és ObsoleteAttributea VersionAttribute.

Soha ne módosítsa a meglévő metódusok aláírását

Orleans A szerializáló működése miatt soha ne módosítsa a meglévő metódusok aláírását.

A következő példa helyes:

[Version(1)]
public interface IMyGrain : IGrainWithIntegerKey
{
    // First method
    Task MyMethod(int arg);
}

[Version(2)]
public interface IMyGrain : IGrainWithIntegerKey
{
    // Method inherited from V1
    Task MyMethod(int arg);

    // New method added in V2
    Task MyNewMethod(int arg, obj o);
}

Ez nem helyes:

[Version(1)]
public interface IMyGrain : IGrainWithIntegerKey
{
    // First method
    Task MyMethod(int arg);
}

[Version(2)]
public interface IMyGrain : IGrainWithIntegerKey
{
    // Method inherited from V1
    Task MyMethod(int arg, obj o);
}

Fontos

Ezt a módosítást nem szabad elvégeznie a kódban, mivel ez egy olyan rossz gyakorlat példája, amely nagyon rossz mellékhatásokhoz vezet. Ez egy példa arra, hogy mi történhet, ha egyszerűen átnevezi a paraméterneveket: tegyük fel, hogy a fürtben az alábbi két felületverzió van üzembe helyezve:

[Version(1)]
public interface IMyGrain : IGrainWithIntegerKey
{
    // return a - b
    Task<int> Subtract(int a, int b);
}

[Version(2)]
public interface IMyGrain : IGrainWithIntegerKey
{
    // return a - b
    Task<int> Subtract(int b, int a);
}

Ez a módszer azonosnak tűnik. Ha azonban az ügyfelet az 1. V-vel hívták meg, és a kérést egy V2-aktiválás kezeli:

var grain = client.GetGrain<IMyGrain>(0);
var result = await grain.Subtract(5, 4); // Will return "-1" instead of expected "1"

Ennek oka a belső Orleans szerializáló működése.

A meglévő metóduslogika módosításának elkerülése

Nyilvánvalónak tűnhet, de nagyon óvatosnak kell lennie egy meglévő módszer törzsének módosításakor. Ha nem javít egy hibát, jobb, ha csak egy új metódust ad hozzá, ha módosítania kell a kódot.

Példa:

// V1
public interface MyGrain : IMyGrain
{
    // First method
    Task MyMethod(int arg)
    {
        SomeSubRoutine(arg);
    }
}

// V2
public interface MyGrain : IMyGrain
{
    // Method inherited from V1
    // Do not change the body
    Task MyMethod(int arg)
    {
        SomeSubRoutine(arg);
    }

    // New method added in V2
    Task MyNewMethod(int arg)
    {
        SomeSubRoutine(arg);
        NewRoutineAdded(arg);
    }
}

Ne távolítsa el a metódusokat a szemcsés felületekről

Hacsak nem biztos abban, hogy már nem használják őket, ne távolítsa el a metódusokat a szemcsés felületről. Ha el szeretné távolítani a metódusokat, ezt két lépésben kell elvégeznie:

1. V2-szemcsék üzembe helyezése v1 metódussal Obsolete

   [Version(1)]
   public interface IMyGrain : IGrainWithIntegerKey
   {
       // First method
       Task MyMethod(int arg);
   }
   

   [Version(2)]
   public interface IMyGrain : IGrainWithIntegerKey
   {
       // Method inherited from V1
       [Obsolete]
       Task MyMethod(int arg);
   
       // New method added in V2
       Task MyNewMethod(int arg, obj o);
   }
   

2. Ha biztos abban, hogy nincs V1-hívás (gyakorlatilag a V1 már nincs üzembe helyezve a futó fürtben), helyezze üzembe a V3-at a V1 metódus eltávolításával

   [Version(3)]
   public interface IMyGrain : IGrainWithIntegerKey
   {
       // New method added in V2
       Task MyNewMethod(int arg, obj o);
   }