# TPVPC: Integración C

La integración de Get Central en un entorno .NET se realiza mediante **Platform Invocation Services (P/Invoke)**, lo que permite que el código C# administrado invoque la biblioteca nativa de Get Central. Esta guía explica cómo configurar tu proyecto, declarar las funciones nativas y ejecutar una operación básica de pago utilizando la DLL de Get Central.

Esta guía se aplica a **TpvpcImplantado**.

Este modelo de integración se aplica a **TpvpcImplantado**.

## Requisitos

Antes de empezar, asegúrate de disponer de:

* **dllTpvpcLatente.dll** disponible en tiempo de ejecución
* Todas las dependencias nativas necesarias presentes en el mismo directorio
* **Visual Studio** u otro IDE compatible con .NET

## Proceso de integración C-Sharp

El proceso de integración consiste en mapear las funciones de la biblioteca nativa e invocarlas desde código administrado. No se envía ningún XML como solicitud; los parámetros se pasan por posición y el XML se devuelve como respuesta.

### Paso 1: Declarar funciones nativas

Las funciones nativas se declaran usando el atributo `DllImport`. La biblioteca expone un conjunto fijo de puntos de entrada que deben mapearse exactamente.

**Inicialización de la Biblioteca**

Las siguientes funciones se utilizan para inicializar la biblioteca:

| Parámetro     | Tipo   | Descripción                                                    |
| ------------- | ------ | -------------------------------------------------------------- |
| `cComercio`   | string | Identificador del comercio asignado por la entidad. |
| `cTerminal`   | string | Identificador del terminal asociado al PIN pad.                |
| `cClaveFirma` | string | Clave de firma asignada al comercio y al terminal.             |
| `cConfPuerto` | string | Puerto de comunicación opcional.                               |
| `cVersion`    | string | Versión de protocolo opcional.                                 |

```csharp
[DllImport("dllTpvpcLatente.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi)]
public static extern int fnDllIniTpvpcLatente(
    string cComercio,
    string cTerminal,
    string cClaveFirma,
    string cConfPuerto,
    string cVersion
);
```

**Ejecución de Pago**

Las siguientes funciones se utilizan para ejecutar una operación de pago:

| Parámetro     | Tipo          | Descripción                                          |
| ------------- | ------------- | ---------------------------------------------------- |
| `cImporte`    | string        | Importe de la transacción en formato `XXXXXXXXX.XX`. |
| `cFactura`    | string        | Referencia del comercio para la transacción.         |
| `cTipoOper`   | string        | Tipo de operación. Para pagos estándar, usa `PAGO`.  |
| `cXMLResp`    | StringBuilder | Buffer que recibe la respuesta XML.                   |
| `iTamMaxResp` | int           | Tamaño máximo del buffer de respuesta.                |

```csharp
[DllImport("dllTpvpcLatente.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi)]
public static extern int fnDllOperPinPad(
    string cImporte,
    string cFactura,
    string cTipoOper,
    StringBuilder cXMLResp,
    int iTamMaxResp
);
```

**Finalización de la Biblioteca**

Las siguientes funciones se utilizan para finalizar la biblioteca:

| Parámetro | Tipo | Descripción                        |
| --------- | ---- | ---------------------------------- |
| —         | —    | Esta función no recibe parámetros. |

```csharp
[DllImport("dllTpvpcLatente.dll", CallingConvention = CallingConvention.StdCall)]
public static extern int fnDllParaTpvpcLatente();
```

### Paso 2: Inicializar la biblioteca

Antes de ejecutar cualquier transacción, la biblioteca debe inicializarse una vez por ciclo de vida de la aplicación.

```csharp
int result = fnDllIniTpvpcLatente(
    "99999999",
    "00000001",
    "CLAVE123456",
    "",
    ""
);

if (result != 0)
{
    // Initialization failed. Do not proceed.
}
```

Un valor de retorno de `0` indica que la inicialización se ha realizado correctamente.

En **TpvpcImplantado**, `cConfPuerto` y `cVersion` pueden proporcionarse cuando la implantación lo requiera. Si se especifica uno, también debe especificarse el otro.

### Paso 3: Ejecutar una operación de pago

Una vez inicializada, puede ejecutarse una operación de pago estándar con tarjeta presente usando `cTipoOper = "PAGO"`.

```csharp
StringBuilder xmlResponse = new StringBuilder(8192);

int result = fnDllOperPinPad(
    "1.00",
    "TEST0001",
    "PAGO",
    xmlResponse,
    xmlResponse.Capacity
);
```

Cuando la función devuelve el control, el buffer de respuesta XML se rellena con el resultado de la transacción.

En **TpvpcImplantado**, los mensajes dirigidos al comercio pueden ser gestionados por la aplicación POS en implantaciones transparentes.

### Paso 4: Procesar la respuesta

El valor entero devuelto indica únicamente el estado técnico de la ejecución. El resultado financiero debe determinarse analizando la respuesta XML.

Una transacción se autoriza únicamente si la respuesta contiene:

```xml
<estado>F</estado>
<resultado>Autorizada</resultado>
```

Cualquier otra combinación debe tratarse como una transacción DENEGADA.

### Paso 5: Finalizar la biblioteca

Cuando la aplicación ya no necesite ejecutar operaciones, la biblioteca debe finalizarse para liberar recursos del sistema.

```csharp
fnDllParaTpvpcLatente();
```

## Próximos pasos

Después de completar la integración en C#, puedes continuar con implementaciones adicionales:

* Para procesar pagos estándar, consulta la guía [Procesar un Pago en un Solo Paso](/es/get-central/tpvpc-payment-guides/process-a-single-step-payment).
* Para obtener detalles sobre la creación e impresión de recibos de transacción, consulta la documentación [Generar e Imprimir Recibos](/es/get-central/tpvpc-payment-guides/generate-and-print-receipts).
* Para implement