GraphQL Parte III: DI GraphQL Parte II: middleware

En los principios de diseño sólido, D representa la dependencia Inversión Principio

• Los componentes de alto nivel no deben depender de los componentes subyacentes, las dos partes deben estar basadas en abstracto
• El resumen no debe depender de la aplicación, la aplicación debe depender de abstracciones

Operador new para crear una instancia de objeto puede causar apretado acoplamiento entre los diferentes componentes. Con el fin de mantener bajo acoplamiento entre ellos, hay que seguir la Dependencia Inversión Principio. Dicho módulo no dependerá de la aplicación específica, sino que dependerá de abstracciones, tales como una interfaz.

Abstracta puede ser útil para una variedad de implementaciones diferentes, por lo que, cuando se enfrentan con el resumen, debe proporcionar una implementación específica de alguna manera. Llamamos a este tipo de problemas responsables de las clases de gestión para el contenedor de inyección de dependencias, debe ser capaz de ser configurado de alguna manera.

ASP.NET núcleo proporciona incorporado en recipientes de inyección de dependencia. Es simple pero la demanda de nuestra ya lo suficientemente bueno. No sólo se puede configurar para lograr el resumen correspondiente, sino que también puede ser controlada para crear un ciclo de vida del objeto.

Actualmente, para la aplicación en el mundo nuestro simple Hola,, que no se preocupan por el ciclo de vida, por lo que sólo vamos a utilizar todas las instancias patrón Singleton.

Ya DocumentWriter instantiate y DocumentExecutor no, no podemos utilizarlos en el IDocumentWriter interfaz abstracta y IDocumentExecutor. Por lo tanto, podemos usar la incorporada en el contenedor de inyección de dependencias de la siguiente manera:

públicos  vacíos ConfigureServices (servicios IServiceCollection)   
{ 
    services.AddSingleton <IDocumentWriter, DocumentWriter> (); 
    services.AddSingleton <IDocumentExecuter, DocumentExecuter> (); 
}

 

Para HelloWordQuery, no definimos la interfaz, también podemos usar esto para alcanzar directamente.

services.AddSingleton <HelloWordQuery> ();  

 

El esquema contiene la consulta, en el futuro vamos a aumentar la mutación, y otros campos. Por lo tanto, queremos crear una clase separada para su gestión. Tal extendida tipo de esquema, se realizó mediante la inyección de dependencia constructor.

público  de clase HelloWorldSchema: Esquema 
{ 
    público HelloWorldSchema (HelloWorldQuery consulta) 
    { 
        consultas = consulta; 
    } 
}

 

Por último, hemos configurado HelloWorldSchema en el método ConfigureServices.

services.AddSingleton <ISchema, HelloWorldSchema> ();  

 

Nota: ISchema de la biblioteca GraphQL.

Ahora, podemos código intermedio separado en su propia clase. Nombramos el siguiente código GraphQLMiddleware.

público  de clase GraphQLMiddleware 
{ 
    privado  de sólo lectura _next RequestDelegate;
    privada  de sólo lectura _writer IDocumentWriter;
    privada  de sólo lectura _executor IDocumentExecuter;
    privada  de sólo lectura _schema ISchema; 

    pública GraphQLMiddleware (RequestDelegate siguiente, IDocumentWriter escritor, IDocumentExecuter ejecutor, ISchema esquema) 
    { 
        _next = próxima; 
        _writer = escritor; 
        _executor = ejecutor; 
        _schema = esquema; 
    }

    pública  asíncrono de tareas invokeAsync (HttpContext HttpContext) 
    { 
        si (httpContext.Request.Path.StartsWithSegments ( " / api / graphql " ) && cadena .equals (httpContext.Request.Method, " POSTAL " , StringComparison.OrdinalIgnoreCase)) 
        { 
            string cuerpo;
            usando ( var StreamReader = nuevo StreamReader (httpContext.Request.Body)) 
            { 
                cuerpo = esperan streamReader.ReadToEndAsync (); 

                varrequest = JsonConvert.DeserializeObject <GraphQLRequest> (cuerpo); 

                var resultado = await _executor.ExecuteAsync (doc => 
                { 
                    doc.Schema = _schema; 
                    doc.Query = request.Query; 
                }) ConfigureAwait (. falsa ); 

                var json = _writer.Write (resultado);
                await httpContext.Response.WriteAsync (JSON); 
            } 
        } 
        Demás 
        { 
            esperan ser _next (HttpContext); 
        } 
    } 
}

 

Tenga en cuenta que vamos a sustituir todas las instancias de tipo de tipo abstracto, por lo que nuestro código se acopla sin apretar. Cada servicio puede ser inyectado a través del constructor de inyección.

Por último, pero no el último paso, que debe estar conectado a una tubería de procesamiento de aplicaciones de middleware. extensión IApplicationBuilder tiene un método llamado UseMiddleware, para la conexión de middleware, por lo que los métodos Configurar finales son como sigue:

pública  vacío Configurar (IApplicationBuilder aplicación, IHostingEnvironment env) 
{ 
    app.UseMiddleware <GraphQLMiddleware> (); 
}

 

 

Anterior: GraphQL Parte II: Middleware