ViennaNET: ਬੈਕਐਂਡ ਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਇੱਕ ਸੈੱਟ। ਭਾਗ 2

Raiffeisenbank .NET ਡਿਵੈਲਪਰ ਕਮਿਊਨਿਟੀ ViennaNET ਦੀਆਂ ਸਮੱਗਰੀਆਂ ਦੀ ਸੰਖੇਪ ਸਮੀਖਿਆ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦੀ ਹੈ। ਇਸ ਬਾਰੇ ਅਸੀਂ ਕਿਵੇਂ ਅਤੇ ਕਿਉਂ ਆਏ ਹਾਂ, ਤੁਸੀਂ ਪਹਿਲਾ ਭਾਗ ਪੜ੍ਹ ਸਕਦੇ ਹੋ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਵਿਤਰਿਤ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ, ਕਤਾਰਾਂ ਅਤੇ ਡੇਟਾਬੇਸ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਅਜੇ ਤੱਕ ਵਿਚਾਰੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚੋਂ ਲੰਘਾਂਗੇ, ਜੋ ਕਿ ਸਾਡੇ GitHub ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਲੱਭੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ (ਸਰੋਤ ਇੱਥੇ ਹਨ), ਅਤੇ Nuget ਪੈਕੇਜ ਇੱਥੇ.

ViennaNET.Sagas

ਜਦੋਂ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਡੀਡੀਡੀ ਅਤੇ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਸਵਿਚ ਕਰਦਾ ਹੈ, ਤਾਂ ਜਦੋਂ ਵਪਾਰਕ ਤਰਕ ਨੂੰ ਵੱਖ-ਵੱਖ ਸੇਵਾਵਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਵਿਤਰਿਤ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਾਲ ਸਬੰਧਤ ਇੱਕ ਸਮੱਸਿਆ ਪੈਦਾ ਹੁੰਦੀ ਹੈ, ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰੇ ਦ੍ਰਿਸ਼ ਅਕਸਰ ਇੱਕ ਵਾਰ ਵਿੱਚ ਕਈ ਡੋਮੇਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ। ਤੁਸੀਂ ਅਜਿਹੀਆਂ ਵਿਧੀਆਂ ਨਾਲ ਵਧੇਰੇ ਵਿਸਥਾਰ ਨਾਲ ਜਾਣੂ ਹੋ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਣ ਲਈ, "ਮਾਈਕਰੋ ਸਰਵਿਸਿਜ਼ ਪੈਟਰਨ" ਕਿਤਾਬ ਵਿੱਚ, ਕ੍ਰਿਸ ਰਿਚਰਡਸਨ.

ਸਾਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪਰ ਉਪਯੋਗੀ ਵਿਧੀ ਲਾਗੂ ਕੀਤੀ ਹੈ: ਇੱਕ ਗਾਥਾ, ਜਾਂ ਇੱਕ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ-ਆਧਾਰਿਤ ਗਾਥਾ। ਇਸਦਾ ਨਿਚੋੜ ਇਸ ਪ੍ਰਕਾਰ ਹੈ: ਇੱਥੇ ਇੱਕ ਖਾਸ ਕਾਰੋਬਾਰੀ ਦ੍ਰਿਸ਼ ਹੈ ਜਿਸ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਸੇਵਾਵਾਂ ਵਿੱਚ ਕ੍ਰਮਵਾਰ ਕਾਰਵਾਈਆਂ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਜੇਕਰ ਕਿਸੇ ਵੀ ਪੜਾਅ 'ਤੇ ਕੋਈ ਸਮੱਸਿਆ ਪੈਦਾ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਪਿਛਲੇ ਸਾਰੇ ਪੜਾਵਾਂ ਲਈ ਰੋਲਬੈਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਾਲ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ, ਜਿੱਥੇ ਇਹ ਹੈ. ਪ੍ਰਦਾਨ ਕੀਤਾ। ਇਸ ਤਰ੍ਹਾਂ, ਗਾਥਾ ਦੇ ਅੰਤ ਵਿੱਚ, ਸਫਲਤਾ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਅਸੀਂ ਸਾਰੇ ਡੋਮੇਨਾਂ ਵਿੱਚ ਇਕਸਾਰ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।

ਸਾਡਾ ਲਾਗੂਕਰਨ ਅਜੇ ਵੀ ਇਸਦੇ ਮੂਲ ਰੂਪ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਹੋਰ ਸੇਵਾਵਾਂ ਦੇ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਦੇ ਕਿਸੇ ਵੀ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਨਾਲ ਜੁੜਿਆ ਨਹੀਂ ਹੈ। ਇਸਦੀ ਵਰਤੋਂ ਕਰਨਾ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ: ਬਸ ਬੇਸ ਐਬਸਟਰੈਕਟ ਕਲਾਸ SagaBase<T> ਦਾ ਇੱਕ ਉੱਤਰਾਧਿਕਾਰੀ ਬਣਾਓ, ਜਿੱਥੇ T ਤੁਹਾਡੀ ਸੰਦਰਭ ਸ਼੍ਰੇਣੀ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਸਾਗਾ ਦੇ ਕੰਮ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਸ਼ੁਰੂਆਤੀ ਡੇਟਾ, ਅਤੇ ਨਾਲ ਹੀ ਕੁਝ ਵਿਚਕਾਰਲੇ ਨਤੀਜੇ ਵੀ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ। ਸੰਦਰਭ ਉਦਾਹਰਨ ਨੂੰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਸਾਰੇ ਪੜਾਵਾਂ 'ਤੇ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਾਗਾ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਰਾਜ ਰਹਿਤ ਸ਼੍ਰੇਣੀ ਹੈ, ਇਸਲਈ ਲੋੜੀਂਦੀ ਨਿਰਭਰਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਉਦਾਹਰਨ ਨੂੰ ਸਿੰਗਲਟਨ ਵਜੋਂ DI ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਉਦਾਹਰਨ ਵਿਗਿਆਪਨ:

public class ExampleSaga : SagaBase<ExampleContext>
{
  public ExampleSaga()
  {
    Step("Step 1")
      .WithAction(c => ...)
      .WithCompensation(c => ...);
	
    AsyncStep("Step 2")
      .WithAction(async c => ...);
  }
}

ਉਦਾਹਰਨ ਕਾਲ:

var saga = new ExampleSaga();
var context = new ExampleContext();
await saga.Execute(context);

ਵੱਖ-ਵੱਖ ਲਾਗੂ ਕਰਨ ਦੀਆਂ ਪੂਰੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇਖੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ ਇੱਥੇ ਅਤੇ ਨਾਲ ਅਸੈਂਬਲੀ ਵਿੱਚ ਟੈਸਟ.

ViennaNET.Orm।*

Nhibernate ਦੁਆਰਾ ਵੱਖ-ਵੱਖ ਡਾਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਇੱਕ ਸੈੱਟ। ਅਸੀਂ Liquibase ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ DB-ਪਹਿਲੀ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਇਸਲਈ ਇੱਕ ਰੈਡੀਮੇਡ ਡੇਟਾਬੇਸ ਵਿੱਚ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਿਰਫ ਕਾਰਜਸ਼ੀਲਤਾ ਹੈ।

ViennaNET.Orm.Seedwork и ViennaNET.Orm - ਕ੍ਰਮਵਾਰ ਬੁਨਿਆਦੀ ਇੰਟਰਫੇਸ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲੀਆਂ ਮੁੱਖ ਅਸੈਂਬਲੀਆਂ। ਆਉ ਉਹਨਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ.

ਇੰਟਰਫੇਸ IEntityFactoryService ਅਤੇ ਇਸ ਦੇ ਲਾਗੂ ਕਰਨ EntityFactoryService ਡੇਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਮੁੱਖ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਹਨ, ਕਿਉਂਕਿ ਕੰਮ ਦੀ ਇਕਾਈ, ਖਾਸ ਇਕਾਈਆਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਰਿਪੋਜ਼ਟਰੀਆਂ, ਨਾਲ ਹੀ ਕਮਾਂਡਾਂ ਦੇ ਐਗਜ਼ੀਕਿਊਟਰ ਅਤੇ ਸਿੱਧੇ SQL ਸਵਾਲ ਇੱਥੇ ਬਣਾਏ ਗਏ ਹਨ। ਕਈ ਵਾਰ ਡੇਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕਲਾਸ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਸੀਮਿਤ ਕਰਨਾ ਸੁਵਿਧਾਜਨਕ ਹੁੰਦਾ ਹੈ, ਉਦਾਹਰਣ ਲਈ, ਸਿਰਫ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਨਾ। ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਲਈ IEntityFactoryService ਇੱਕ ਪੂਰਵਜ - ਇੰਟਰਫੇਸ ਹੈ IEntityRepositoryFactory, ਜੋ ਕਿ ਸਿਰਫ ਰਿਪੋਜ਼ਟਰੀਆਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਢੰਗ ਦਾ ਐਲਾਨ ਕਰਦਾ ਹੈ।

ਡੇਟਾਬੇਸ ਤੱਕ ਸਿੱਧੇ ਪਹੁੰਚ ਕਰਨ ਲਈ, ਪ੍ਰਦਾਤਾ ਵਿਧੀ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਹਰੇਕ DBMS ਜੋ ਅਸੀਂ ਆਪਣੀਆਂ ਟੀਮਾਂ ਵਿੱਚ ਵਰਤਦੇ ਹਾਂ ਇਸਦਾ ਆਪਣਾ ਲਾਗੂਕਰਨ ਹੈ: ViennaNET.Orm.MSSQL, ViennaNET.Orm.Oracle, ViennaNET.Orm.SQLite, ViennaNET.Orm.PostgreSql.

ਉਸੇ ਸਮੇਂ, ਕਈ ਪ੍ਰਦਾਤਾਵਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਰਜਿਸਟਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਸੇਵਾ ਦੇ ਢਾਂਚੇ ਦੇ ਅੰਦਰ, ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਸੋਧਣ ਲਈ ਬਿਨਾਂ ਕਿਸੇ ਖਰਚੇ ਦੇ, ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇੱਕ DBMS ਦੂਜੇ ਨੂੰ. ਲੋੜੀਂਦੇ ਕਨੈਕਸ਼ਨ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਵਿਧੀ ਅਤੇ, ਇਸਲਈ, ਇੱਕ ਖਾਸ ਇਕਾਈ ਕਲਾਸ ਲਈ ਪ੍ਰਦਾਤਾ (ਜਿਸ ਲਈ ਡੇਟਾਬੇਸ ਟੇਬਲ ਵਿੱਚ ਮੈਪਿੰਗ ਲਿਖੀ ਜਾਂਦੀ ਹੈ) ਨੂੰ BoundedContext ਕਲਾਸ (ਡੋਮੇਨ ਇਕਾਈਆਂ ਨੂੰ ਰਜਿਸਟਰ ਕਰਨ ਲਈ ਇੱਕ ਵਿਧੀ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ) ਜਾਂ ਇਸਦੇ ਉੱਤਰਾਧਿਕਾਰੀ ਵਿੱਚ ਇਕਾਈ ਨੂੰ ਰਜਿਸਟਰ ਕਰਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ApplicationContext (ਐਪਲੀਕੇਸ਼ਨ ਇਕਾਈਆਂ, ਸਿੱਧੀਆਂ ਬੇਨਤੀਆਂ ਅਤੇ ਕਮਾਂਡਾਂ ਨੂੰ ਰਜਿਸਟਰ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਹਨ), ਜਿੱਥੇ ਸੰਰਚਨਾ ਤੋਂ ਕਨੈਕਸ਼ਨ ਪਛਾਣਕਰਤਾ ਨੂੰ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਸਵੀਕਾਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

"db": [
  {
    "nick": "mssql_connection",
    "dbServerType": "MSSQL",
    "ConnectionString": "...",
    "useCallContext": true
  },
  {
    "nick": "oracle_connection",
    "dbServerType": "Oracle",
    "ConnectionString": "..."
  }
],

ਉਦਾਹਰਨ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਸੰਗ:

internal sealed class DbContext : ApplicationContext
{
  public DbContext()
  {
    AddEntity<SomeEntity>("mssql_connection");
    AddEntity<MigratedSomeEntity>("oracle_connection");
    AddEntity<AnotherEntity>("oracle_connection");
  }
}

ਜੇਕਰ ਕਨੈਕਸ਼ਨ ਆਈਡੀ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ, ਤਾਂ "ਡਿਫਾਲਟ" ਨਾਮਕ ਕੁਨੈਕਸ਼ਨ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਡਾਟਾਬੇਸ ਟੇਬਲ 'ਤੇ ਇਕਾਈਆਂ ਦੀ ਸਿੱਧੀ ਮੈਪਿੰਗ ਮਿਆਰੀ NHibernate ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਤੁਸੀਂ xml ਫਾਈਲਾਂ ਅਤੇ ਕਲਾਸਾਂ ਰਾਹੀਂ ਵਰਣਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਯੂਨਿਟ ਟੈਸਟਾਂ ਵਿੱਚ ਸਟੱਬ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਸੁਵਿਧਾਜਨਕ ਲਿਖਤ ਲਈ, ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ViennaNET.TestUtils.Orm.

ViennaNET.Orm.* ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਪੂਰੀ ਉਦਾਹਰਨਾਂ ਮਿਲ ਸਕਦੀਆਂ ਹਨ ਇੱਥੇ.

ViennaNET.ਮੈਸੇਜਿੰਗ।*

ਕਤਾਰਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਇੱਕ ਸੈੱਟ।

ਕਤਾਰਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਵੱਖ-ਵੱਖ DBMSs ਦੇ ਨਾਲ ਉਹੀ ਪਹੁੰਚ ਚੁਣੀ ਗਈ ਸੀ, ਅਰਥਾਤ, ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਭਾਵਿਤ ਏਕੀਕ੍ਰਿਤ ਪਹੁੰਚ, ਭਾਵੇਂ ਕਤਾਰ ਪ੍ਰਬੰਧਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੋਵੇ। ਲਾਇਬ੍ਰੇਰੀ ViennaNET.Messaging ਇਸ ਏਕੀਕਰਨ ਲਈ ਬਿਲਕੁਲ ਜ਼ਿੰਮੇਵਾਰ ਹੈ, ਅਤੇ ViennaNET.Messaging.MQSeriesQueue, ViennaNET.Messaging.RabbitMQQueue и ViennaNET.Messaging.KafkaQueue ਕ੍ਰਮਵਾਰ IBM MQ, RabbitMQ ਅਤੇ Kafka ਲਈ ਅਡਾਪਟਰ ਲਾਗੂਕਰਨ ਸ਼ਾਮਲ ਹਨ।

ਕਤਾਰਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਦੋ ਪ੍ਰਕਿਰਿਆਵਾਂ ਹੁੰਦੀਆਂ ਹਨ: ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਭੇਜਣਾ।

ਪ੍ਰਾਪਤ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਇੱਥੇ 2 ਵਿਕਲਪ ਹਨ: ਲਗਾਤਾਰ ਸੁਣਨ ਲਈ ਅਤੇ ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ। ਕਤਾਰ ਨੂੰ ਲਗਾਤਾਰ ਸੁਣਨ ਲਈ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਪ੍ਰੋਸੈਸਰ ਕਲਾਸ ਦਾ ਵਰਣਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ IMessageProcessor, ਜੋ ਆਉਣ ਵਾਲੇ ਸੁਨੇਹੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋਵੇਗਾ। ਅੱਗੇ, ਇਹ ਇੱਕ ਖਾਸ ਕਤਾਰ ਨਾਲ "ਲਿੰਕ" ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ; ਇਹ ਰਜਿਸਟਰੇਸ਼ਨ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ IQueueReactorFactory ਸੰਰਚਨਾ ਤੋਂ ਕਤਾਰ ਪਛਾਣਕਰਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

"messaging": {
    "ApplicationName": "MyApplication"
},
"rabbitmq": {
    "queues": [
      {
        "id": "myQueue",
        "queuename": "lalala",
        ...
      }
    ]
},

ਸੁਣਨਾ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਉਦਾਹਰਨ:

_queueReactorFactory.Register<MyMessageProcessor>("myQueue");
var queueReactor = queueReactorFactory.CreateQueueReactor("myQueue");
queueReactor.StartProcessing();

ਫਿਰ, ਜਦੋਂ ਸੇਵਾ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਵਿਧੀ ਨੂੰ ਸੁਣਨਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਨਿਰਧਾਰਤ ਕਤਾਰ ਤੋਂ ਸਾਰੇ ਸੁਨੇਹੇ ਸੰਬੰਧਿਤ ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਜਾਣਗੇ।

ਇੱਕ ਫੈਕਟਰੀ ਇੰਟਰਫੇਸ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ IMessagingComponentFactory ਇੱਕ ਢੰਗ ਹੈ CreateMessageReceiverਜੋ ਕਿ ਇੱਕ ਪ੍ਰਾਪਤਕਰਤਾ ਨੂੰ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਤਾਰ ਤੋਂ ਇੱਕ ਸੰਦੇਸ਼ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਣਾਏਗਾ:

using (var receiver = _messagingComponentFactory.CreateMessageReceiver<TestMessage>("myQueue"))
{
    var message = receiver.Receive();
}

ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਣ ਲਈ ਤੁਹਾਨੂੰ ਉਹੀ ਵਰਤਣ ਦੀ ਲੋੜ ਹੈ IMessagingComponentFactory ਅਤੇ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਣ ਵਾਲਾ ਬਣਾਓ:

using (var sender = _messagingComponentFactory.CreateMessageSender<MyMessage>("myQueue"))
{
    sender.SendMessage(new MyMessage { Value = ...});
}

ਇੱਕ ਸੰਦੇਸ਼ ਨੂੰ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਨ ਅਤੇ ਡੀਸੀਰੀਅਲਾਈਜ਼ ਕਰਨ ਲਈ ਤਿੰਨ ਤਿਆਰ ਵਿਕਲਪ ਹਨ: ਸਿਰਫ਼ ਟੈਕਸਟ, XML ਅਤੇ JSON, ਪਰ ਜੇ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਆਪਣੇ ਖੁਦ ਦੇ ਇੰਟਰਫੇਸ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ। IMessageSerializer и IMessageDeserializer.

ਅਸੀਂ ਹਰੇਕ ਕਤਾਰ ਪ੍ਰਬੰਧਕ ਦੀਆਂ ਵਿਲੱਖਣ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ, ਜਿਵੇਂ ਕਿ ViennaNET.Messaging.MQSeriesQueue ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਟੈਕਸਟ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਬਾਈਟ ਸੁਨੇਹੇ ਵੀ ਭੇਜਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਅਤੇ ViennaNET.Messaging.RabbitMQQueue ਰੂਟਿੰਗ ਅਤੇ ਆਨ-ਦੀ-ਫਲਾਈ ਕਤਾਰ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। RabbitMQ ਲਈ ਸਾਡਾ ਅਡਾਪਟਰ ਰੈਪਰ ਵੀ RPC ਦੇ ਕੁਝ ਸਮਾਨ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ: ਅਸੀਂ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਅਸਥਾਈ ਕਤਾਰ ਤੋਂ ਜਵਾਬ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹਾਂ, ਜੋ ਸਿਰਫ਼ ਇੱਕ ਜਵਾਬ ਸੰਦੇਸ਼ ਲਈ ਬਣਾਈ ਗਈ ਹੈ।

ਇੱਥੇ ਬੁਨਿਆਦੀ ਕੁਨੈਕਸ਼ਨ ਸੂਖਮਤਾ ਨਾਲ ਕਤਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ.

ViennaNET.CallContext

ਅਸੀਂ ਕਤਾਰਾਂ ਦੀ ਵਰਤੋਂ ਨਾ ਸਿਰਫ਼ ਵੱਖ-ਵੱਖ ਪ੍ਰਣਾਲੀਆਂ ਵਿਚਕਾਰ ਏਕੀਕਰਣ ਲਈ ਕਰਦੇ ਹਾਂ, ਸਗੋਂ ਇੱਕੋ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਵਿਚਕਾਰ ਸੰਚਾਰ ਲਈ ਵੀ ਕਰਦੇ ਹਾਂ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਗਾਥਾ ਦੇ ਅੰਦਰ। ਇਸ ਨਾਲ ਸੁਨੇਹੇ ਦੇ ਨਾਲ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਦੀ ਲੋੜ ਪੈਦਾ ਹੋਈ ਜਿਵੇਂ ਕਿ ਉਪਭੋਗਤਾ ਲੌਗਇਨ, ਅੰਤ-ਤੋਂ-ਅੰਤ ਲੌਗਿੰਗ ਲਈ ਬੇਨਤੀ ਪਛਾਣਕਰਤਾ, ਸਰੋਤ IP ਪਤਾ ਅਤੇ ਪ੍ਰਮਾਣੀਕਰਨ ਡੇਟਾ। ਇਸ ਡੇਟਾ ਦੇ ਫਾਰਵਰਡਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵਿਕਸਿਤ ਕੀਤੀ ਹੈ ViennaNET.CallContext, ਜੋ ਤੁਹਾਨੂੰ ਸੇਵਾ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਵਾਲੀ ਬੇਨਤੀ ਤੋਂ ਡਾਟਾ ਸਟੋਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ, ਬੇਨਤੀ ਕਿਵੇਂ ਕੀਤੀ ਗਈ ਸੀ, ਇੱਕ ਕਤਾਰ ਰਾਹੀਂ ਜਾਂ Http ਦੁਆਰਾ, ਕੋਈ ਫ਼ਰਕ ਨਹੀਂ ਪੈਂਦਾ। ਫਿਰ, ਆਊਟਗੋਇੰਗ ਬੇਨਤੀ ਜਾਂ ਸੰਦੇਸ਼ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ, ਡੇਟਾ ਨੂੰ ਸੰਦਰਭ ਤੋਂ ਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਿਰਲੇਖਾਂ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਅਗਲੀ ਸੇਵਾ ਸਹਾਇਕ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਦੀ ਹੈ।

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ, ਅਸੀਂ ਤੁਹਾਡੀਆਂ ਟਿੱਪਣੀਆਂ ਅਤੇ ਪੁੱਲ ਬੇਨਤੀਆਂ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹਾਂ!

ਸਰੋਤ: www.habr.com