VSTDGPProgrammersGuide ESP

Machine Translated by Google
Herramientas de Visual Studio® para Microsoft Dynamics® GP 2013

Guía del programador
Derechos de autor Copyright © 2012 Microsoft Corporation. Reservados todos los derechos.
Limitación de responsabilidad Este documento se proporciona "tal cual". Información y opiniones expresadas en este documento, incluida la URL
y otras referencias a sitios web de Internet, pueden cambiar sin previo aviso. Usted asume el riesgo de utilizarlo.
Algunos ejemplos representados en este documento se proporcionan solo como ilustración y son ficticios. No se pretende ni
debe inferirse ninguna asociación o conexión real.
Propiedad intelectual Este documento no le otorga ningún derecho legal a ninguna propiedad intelectual en ningún producto de Microsoft.
Puede copiar y utilizar este documento para sus fines internos de referencia.
Marcas registradas Microsoft, Dexterity, Microsoft Dynamics, Visual Basic, Visual Studio, Windows, Windows Server y Windows Vista son marcas comerciales
del grupo de empresas Microsoft.
El resto de marcas registradas son propiedad de sus respectivos propietarios.
Renuncia a la garantía Microsoft Corporation renuncia a cualquier garantía con respecto al código de muestra contenido en esta documentación,
incluidas las garantías de comerciabilidad e idoneidad para un propósito particular.
Acuerdo de licencia El uso de este producto está cubierto por un contrato de licencia proporcionado con el producto de software. Si tiene alguna pregunta, llame
al Departamento de asistencia al cliente de Microsoft Dynamics GP al 8004560025 (en EE. UU. o Canadá) o al
+17012816500.
Fecha de publicación julio de 2012

Contenido
Introducción................................................. .................................................... .............................................2
Contenido de este manual ............................................... .................................................... ....................................2
Requisitos previos.................................................. .................................................... ..........................................2
Símbolos y convenciones .................................................. .................................................... ..........................3 Soporte
de productos ..................... .................................................... .................................................... ...................3
Parte 1: Primeros pasos .................................................. .................................................... ....................6
Capítulo 1: Instalación del SDK................................................ .................................................... ......... 7 Procedimiento de

instalación ....................................... .................................................... ..........................................7 Registro de
plantilla..... .................................................... .................................................... ..........................8

Lo que se instaló.................................................. .................................................... ..........................................9
Actualizar a un Visual Studio más nuevo.................................................. .................................................... .............9
Capítulo 2: Conceptos básicos de integración ........................................... .................................................... ...11

Lo que proporciona Visual Studio Tools ............................................. .................................................... .......... 11
Arquitectura ................................................. .................................................... ............................................. 11
Creación de un proyecto ............................................... .................................................... ..........................................12
Capítulo 3: Actualización de una integración ........................................... .................................. 15 Actualización desde la

versión 9 ........... .................................................... .................................................... ..........15 Actualización desde la
versión 10 o posterior .................................. .................................................... ......................20
Parte 2: Desarrollo de integraciones ............................................... ..........................................24
Capítulo 4: WinForms ............................................... .................................................... ...................... 25 Adición de un

formulario de Dynamics GP a un proyecto .................. .................................................... ..........................25 Propiedades
de WinForm ............... .................................................... .................................................... ...........26 Adición de
controles.................................... .................................................... .................................................... ...27
Capítulo 5: Referencia de control ............................................. .................................................... .29

Botones................................................... .................................................... .................................................... .......29
Cajas de texto................................................. .................................................... .................................................... .31
Etiquetas................................................. .................................................... .................................................... .......32
Cuadros combinados .................................................. .................................................... .............................................32
Cuadros de lista .................................................. .................................................... .................................................... .32
Capítulo 6: Generador de ensamblado de diccionarios .................................. .................. 33 Creación de conjuntos de

aplicaciones ........................... .................................................... ............................33 Archivos de
salida .............. .................................................... .................................................... ..........................33 Uso del
generador de ensamblado de diccionarios .................. .................................................... ..............................34
Optimización del proceso de generación de ensamblajes .................. .................................................... ..........................36
Capítulo 7: Acceder a los recursos del diccionario......................................... .......... 37 Adición de

referencias ............................... .................................................... .................................................... ....37 Espacio de
nombres................................... .................................................... .................................................... ...38 Clase de
diccionario ............................................. .................................................... .............................................38
GUÍA DEL PROGRAMADOR i

CONTENIDO
Acceder a recursos adicionales .................................................. .................................................... ..........39 Variables
para recursos de diccionario ............................... .................................................... .............................39
Capítulo 8: Eventos .................................................. .................................................... ...............41 Registro de

eventos .................. .................................................... .................................................... ..................41 Responder a
eventos .................................. .................................................... .................................................... .43 Dar de baja
eventos.................................................... .................................................... ....................................44
Capítulo 9: Trabajar con tablas.................................................... ...................................................47 Tablas en Microsoft

Dinámico GP .................................................. .................................................... .............47
Búferes de mesa ................................................. .................................................... .......................................................48
Apertura y cierre de mesas .............................................. .................................................... .......................49
Teclas................................. .................................................... .................................................... ..................................50
Recuperación de una fila ............ .................................................... .................................................... ..........................50
Guardar una fila ............... .................................................... .................................................... ........................51
Actualizar una fila ...................... .................................................... .................................................... ...........52 Eliminación
de una fila .......................... .................................................... .................................................... .........53 Errores de
operación de la tabla .................................. .................................................... .......................................54
Rangos....... .................................................... .................................................... ..........................................55 Fila
bloqueo .................................................. .................................................... .............................................59 Procesamiento
multiusuario . .................................................... .................................................... .............................59
Capítulo 10: Construir e implementar ............................................... ..................................65 Configuración de la información

de montaje .......... .................................................... .................................................... ......65 Crear una
integración ............................................... .................................................... ....................................66 Desplegando una
integración ........... .................................................... .................................................... .............67
Capítulo 11: Depuración.................................................... .................................................... ...........69 Preparándose para

depurar ............................... .................................................... .................................................... ....69 Examen de la
solicitud ........................................... .................................................... .............................70 Deshabilitar
eventos .................. .................................................... .................................................... .....................70
Capítulo 12: Formas modificadas y alternativas ........................................... ....................71 Formas

modificadas........................... .................................................... .................................................... .............71
Formas alternativas ................................................ .................................................... ..........................................72
Pautas ................................................. .................................................... ..................................................73
Capítulo 13: Implementación del soporte de macros .................................. ....................75 Descripción general de la
compatibilidad con macros ............... .................................................... ..........................................75 Grabación de
macros .... .................................................... .................................................... ...............................75 Reproducción de
macros ................ .................................................... .................................................... ..........................76 Manejo de
procesos asincrónicos durante la reproducción .................. .................................................... .......78
Capítulo 14: Uso de búsquedas.................................................... .................................................... .......79 Cómo funcionan

las búsquedas.................................... .................................................... ............................................79 Búsquedas
disponibles... .................................................... .................................................... ............................80 Ejemplo de
búsqueda ............ .................................................... .................................................... ..........................80
yo ESCUADRÓN DE PROGRAMADORES
CONTENIDO
Parte 3: Referencia de recursos ............................................. .................................................... .84
Capítulo 15: Formularios .............................................. .................................................... ............................. 85 Acceder a

formularios .................. .................................................... .................................................... ....................85
Métodos de formulario ................................................. .................................................... ..........................................85
Propiedades del formulario................................................. .................................................... .......................................87

Formar eventos .................................................. .................................................... ...............................................88
Capítulo 16: Ventanas.................................................... .................................................... ..................... 89 Acceder a las

ventanas .......................... .................................................... .................................................... ......89
Métodos de ventana.................................................. .................................................... ......................................89
Propiedades de la ventana .................................................. .................................................... ....................................89

Eventos de ventana ................................................. .................................................... ..........................................90
Capítulo 17: Desplazamiento de ventanas ....................................... ............................................. 95 Acceder al desplazamiento

ventanas ............................................... .................................................... ...........95 Métodos de ventana de
desplazamiento .................. .................................................... .......................................95 Propiedades de la ventana de
desplazamiento ..... .................................................... .................................................... ............95 Eventos de ventana de
desplazamiento ........................... .................................................... ..........................................95
Capítulo 18: Campos de ventana ............................................... .................................................... ........ 99 Acceder a los campos
de la ventana .................................. .................................................... ....................................99
Métodos de campo de ventana .................................................. .................................................... ...............99
Propiedades del campo de ventana .................................................. .................................................... .........................101

Eventos de campo de ventana.................................................. .................................................... .............................102
Capítulo 19: Tablas .............................................. .................................................... ......................... 103 Acceder a las

tablas ...................... .................................................... .................................................... ..............103
Métodos de tabla.................................................. .................................................... ..........................................104
Propiedades de la tabla................................................. .................................................... ..........................................107
Capítulo 20: Campos de la tabla........................................... .................................................... ............ 109 Acceder a los campos
de la tabla .................................. .................................................... ..........................................109
Métodos de campo de tabla.................................................. .................................................... ....................................109
Propiedades del campo de la tabla.................................................. .................................................... ............................... 110
Capítulo 21: Comandos .............................................. .................................................... .............111 Tipos de

comandos ............................... .................................................... .................................................... .. 111 Acceder a los
comandos ............................................... .................................................... ............................. 111

Métodos de comando .................................................. .................................................... ............................. 111
Capítulo 22: Globales ............................................... .................................................... ...................... 113 Acceder a los

globales ......................... .................................................... .................................................... ......... 113 Propiedades
globales ....................................... .................................................... ............................................... 113
Capítulo 23: Procedimientos ............................................. .................................................... .............115 Acceder a procedimientos

globales ............................... .................................................... .......................... 115 Acceder a procedimientos a nivel de
formulario ............ .................................................... ............................................. 115

Métodos de procedimiento ................................................ .................................................... ............................. 115
Eventos de procedimiento ................................................ .................................................... ..................................... 116
Parámetros para los procedimientos .................................................. .................................................... ...................... 117
ESCUADRÓN DE PROGRAMADORES iii

CONTENIDO
Procedimientos invocables .................................................. .................................................... ............................. 118
Capítulo 24: Funciones ............................................... .................................................... ..........119 Acceder a las

funciones globales ............................... .................................................... ....................................... 119 Acceder a
funciones de nivel de formulario ..... .................................................... .................................................... ...... 119
Métodos de función ................................................ .................................................... ....................................120
Eventos de función .................................................. .................................................... ..........................................120
Parámetros para funciones.................................................... .................................................... .........................121
Funciones invocables .................................................. .................................................... .............................122
Capítulo 25: Compuestos ............................................... .................................................... ...........123 Tipos

compuestos.................................... .................................................... .................................................... 123 Acceder
a compuestos ............................................... .................................................... .............................123 Métodos de
campos compuestos .................. .................................................... .................................................... .....125
Propiedades de campos compuestos ....................................... .................................................... ..........................127
Eventos de campo compuesto .................. .................................................... .................................................... ......128
Parte 4: Ejemplos de Integración ............................................... ..........................................130
Capítulo 26: Incumplimiento de campo ........................................... .................................................... ....131 Descripción

general .............................................. .................................................... .................................................... ....131
Ejecución de la aplicación de ejemplo.................................................. .................................................... .............131

Cómo se utilizó Visual Studio Tools ............................................... .................................................... ..........132
Capítulo 27: Estimar el flete.................................................... .................................................... 133 Descripción

general.................................................. .................................................... .................................................... 133

Capítulo 28: Detalles ambientales.................................................... ....................................137 Descripción

general ............ .................................................... .................................................... ....................................137

Capítulo 29: Búsquedas .............................................. .................................................... ...................141 Descripción

general .......................... .................................................... .................................................... ...................141

Glosario................................................. .................................................... .................................................... 145
Índice................................................. .................................................... .................................................... .......... 147
IV ESCUADRÓN DE PROGRAMADORES
INTRODU
Introducción
Bienvenido a Visual Studio® Tools para Microsoft Dynamics® GP. Esta documentación explica cómo
integrar las aplicaciones que crea con Visual Studio en Microsoft Dynamics GP. Antes de comenzar a
crear una integración para Microsoft Dynamics GP, tómese un momento para revisar la información
que se presenta aquí.
¿Qué hay en este manual?
La Guía del programador de Visual Studio Tools para Microsoft Dynamics GP está diseñada para
brindarle una comprensión profunda de cómo usar estas herramientas para crear una aplicación que
se integre con Microsoft Dynamics GP. Incluso si está familiarizado con el uso de Visual Studio para
desarrollar aplicaciones, le resultará útil examinar el material que se presenta aquí.
La información se divide en las siguientes partes:
• La Parte 1, Primeros pasos, explica cómo instalar Visual Studio Tools para Microsoft
Dynamics GP y comience a crear una integración.
• La Parte 2, Desarrollo de integraciones, proporciona información detallada sobre la creación de

WinForms que coincidan con la apariencia de Microsoft Dynamics GP. Se analiza la interacción
con Microsoft Dynamics GP a través de eventos. También se abordan la creación, implementación
y depuración de integraciones.
• La Parte 3, Referencia de recursos, proporciona información detallada sobre la interacción con los
distintos tipos de recursos en Microsoft Dynamics GP.
• Parte 4, Ejemplos de integración, describe integraciones de ejemplo que usan Visual

Herramientas de estudio para Microsoft Dynamics GP.
requisitos previos
Debe utilizar Microsoft Dynamics GP 2013. Dado que trabajará con Microsoft Dynamics GP, el
conocimiento del sistema de contabilidad será útil.
Consulte los recursos de documentación de Microsoft Dynamics GP para obtener más información
sobre el producto.
También querrá instalar el SDK para Microsoft Dynamics GP. El SDK está disponible en la carpeta
Herramientas en los medios de instalación de Microsoft Dynamics GP. Contiene información útil sobre
Microsoft Dynamics GP, como listas de procedimientos y funciones de uso común.
Para usar Visual Studio Tools para Microsoft Dynamics GP, se requiere Visual Studio 2010 o posterior.
No se pueden usar versiones anteriores de Visual Studio. Se supone que está familiarizado con la
programación en un lenguaje administrado como C#. Esta documentación usa C# y Visual Basic para
demostrar cómo crear integraciones.
2 GUÍA DEL PROGRAMADOR

INTRODUCCIÓN
Símbolos y convenciones
Para ayudarlo a usar esta documentación de manera más efectiva, hemos usado los siguientes símbolos
y convenciones dentro del texto para resaltar tipos específicos de información.
Símbolo Descripción
El símbolo de la bombilla indica consejos útiles, atajos y sugerencias.
Las advertencias indican situaciones que debe tener en cuenta al

completar tareas.
Las notas al margen resumen Las notas al margen llaman la atención sobre información crítica y
la información importante. lo dirigen a otras áreas de la documentación donde se explica un
tema.
Convención Descripción
Parte 1, Primeros pasos La negrita indica el nombre de una pieza.
Capítulo 8, “Eventos” Las comillas indican el nombre de un capítulo.
Agregar controles El tipo en cursiva indica un nombre de sección.

utilizando System.IO; Esta fuente se utiliza para indicar ejemplos de guiones.
Ensamblaje de diccionario Los acrónimos se deletrean la primera vez que se utilizan.

Generador (DÍA)
TAB o ALT+M Las letras mayúsculas pequeñas indican una tecla o una secuencia de teclas.
Soporte de producto
Se puede acceder al soporte técnico para desarrolladores de Microsoft Dynamics GP en línea o por
teléfono. Vaya a www.microsoft.com/dynamics y haga clic en el vínculo CustomerSource o PartnerSource,
o llame al 8884777877 (en EE. UU. y Canadá) o al 7012810555.
GUÍA DEL PROGRAMADOR 3


PAS
PAR
PRI
1:
Parte 1: Primeros pasos

Esta parte de la documentación describe cómo comenzar a crear una integración con Visual
Studio Tools para Microsoft Dynamics GP. Se discuten los siguientes temas:
• El Capítulo 1, "Instalación del SDK", explica cómo instalar el SDK de Visual Studio Tools.
para Microsoft Dynamics GP.
• El Capítulo 2, "Conceptos básicos de integración", describe la arquitectura de una integración

de Visual Studio Tools para Microsoft Dynamics GP. También explica cómo crear un
proyecto para una nueva integración.
• El Capítulo 3, "Actualización de una integración", explica cómo actualizar una integración

existente para que funcione con la versión actual de Visual Studio Tools para Microsoft
Dynamics GP.

Capítulo 1: Instalación del SDK

El SDK de Visual Studio Tools para Microsoft Dynamics GP contiene los componentes necesarios para
crear y construir integraciones. Se discuten los siguientes temas:
• Procedimiento de instalación
• Registro de plantilla • Qué
se instaló • Actualización a
un Visual Studio más nuevo
Procedimiento de instalación
El instalador del SDK de Visual Studio Tools para Microsoft Dynamics GP requiere la instalación previa de
Visual Studio 2010 o posterior. Para probar integraciones, también querrá tener instalado Microsoft
Dynamics GP.
Si ha instalado una versión anterior del SDK de Visual Studio Tools, asegúrese de eliminarlo del sistema
antes de instalar la nueva versión.
Para instalar Visual Studio Tools para Microsoft Dynamics GP SDK, complete el siguiente procedimiento:
1. Inicie el instalador del SDK de Visual Studio Tools.

Inicie el instalador ejecutando VSToolsSDK.exe.
2. Reconocer el acuerdo de licencia.

Lea y reconozca el acuerdo de licencia. Haga clic en Siguiente para continuar.
3. Especifique las funciones que desea instalar.

Elija las funciones que se instalarán:
Característica Descripción
Plantillas de Visual Studio 2010 Las plantillas de C# y Visual Basic para proyectos y formularios.
Se requiere Visual Studio 2010 para instalar esta función.
Plantillas de Visual Studio 2012 Las plantillas de C# y Visual Basic para proyectos y formularios.
Se requiere Visual Studio 2012 para instalar esta característica.
Documentación La guía del programador de Visual Studio Tools para Microsoft
Dynamics GP.
Muestras Ejemplos de integraciones que demuestran Visual Studio Tools.
Asambleas y Asamblea El Generador de ensamblados de diccionario (Dag.exe) y los

Generador ensamblados de diccionario para los productos que se envían con
Microsoft Dynamics GP. También incluye los archivos XML de
IntelliSense que usa Visual Studio para mostrar información sobre los
recursos a los que se accede a través de los ensamblados de la
aplicación.
4. Especifique la ubicación de instalación.

Utilice la ubicación predeterminada o elija otra ubicación. Haga clic en Siguiente para continuar.
5. Comience la instalación.
Haga clic en Instalar para comenzar a instalar los componentes del SDK.
Durante la instalación, Visual Studio debe reconfigurarse para reconocer las nuevas plantillas que se
están instalando. Este proceso puede tardar unos minutos en completarse.

PARTE 1 PRIMEROS PASOS
6. Finalice la instalación.
Haga clic en Finalizar para completar la instalación.
Registro de plantilla
Si está ejecutando con privilegios de usuario limitados o con el Control de cuentas de usuario (UAC)
activo, es posible que las plantillas instaladas para Visual Studio Tools no estén registradas en Visual
Studio. Es posible que deba registrar manualmente las plantillas para que aparezcan como selecciones
cuando cree nuevos proyectos.
Utilice el siguiente comando para que Visual Studio 2010 vuelva a crear su caché de plantilla:
C:\Archivos de programa\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe/setup
Si utiliza una versión de Windows de 64 bits, los archivos de Visual Studio se ubicarán en la carpeta
Archivos de programa (x86).
En los sistemas que se ejecutan con UAC (Control de cuentas de usuario), deberá configurar las
propiedades de la aplicación devenv.exe para que se ejecute con privilegios administrativos.
En sistemas con UAC,

elija ejecutar devenv.exe
como administrador.

CAPÍTULO 1 INSTALACIÓN DEL SDK
que fue instalado
Los siguientes elementos están instalados para Visual Studio Tools para Microsoft Dynamics
Médico de cabecera en la ubicación que especificó:
Componente Descripción
VSTDGPReadme.rtf Contiene información de última hora sobre Visual
Studio Tools para Microsoft Dynamics GP.
VSTDGPProgrammersGuide.pdf Documentación para las herramientas de Visual Studio.
Muestras.zip Ejemplos de proyectos de Visual Studio que

demuestran Visual Studio Tools.
Microsoft.Dexterity.Bridge.dll Componentes principales de Microsoft Dynamics GP

Microsoft.Dexterity.Shell.dll utilizados por las integraciones de Visual Studio Tools.
Microsoft.Dynamics.Framework.UI.Navigation.dll
Microsoft.Dynamics.Framework.UI.WinForms.
controles.dll
día.exe El Generador de ensamblados de diccionarios, que se

utiliza para crear ensamblados de aplicaciones para
diccionarios de aplicaciones y diccionarios de formularios.
Bidi32.dll Archivos de soporte necesarios para Dag.exe

Ddapi.dll
Tntlib.dll
Dex.dic
Dex ini
Ensambles de aplicación Ensamblados que contienen información sobre los

recursos en cada diccionario que se envía con
Microsoft Dynamics GP. Además del inglés
estadounidense, se incluyen otras versiones locales de
ensamblajes de aplicaciones.
Archivos XML de IntelliSense Utilizado por Visual Studio para mostrar información
sobre el ensamblaje de la aplicación
correspondiente.
Si elige instalarlos, las plantillas de proyecto para C# y Visual Basic estarán en las ubicaciones
adecuadas para Visual Studio.
Actualizar a un Visual Studio más nuevo

Si ha instalado previamente Visual Studio Tools para Microsoft Dynamics GP
SDK y desea actualizar a una versión más reciente de Visual Studio, complete el siguiente
procedimiento:
1. Instale la nueva versión de Visual Studio.

Instale la nueva versión de Visual Studio a la que se muda, como Visual Studio 2010.
2. Inicie el instalador del SDK de Visual Studio Tools.

Inicie el instalador ejecutando VSToolsSDK.exe. Se instalarán los componentes
actualizados para Visual Studio Tools.
3. Cierre el instalador.
Cuando el instalador haya terminado de actualizar los componentes, haga clic en Finalizar.
4. Cambie la instalación de Visual Studio Tools.

En Programas y características, elija Visual Studio Tools para Microsoft Dynamics GP
SDK. Haga clic en Cambiar.

5. Agregue una nueva función.

Haga clic en Agregar o quitar funciones para agregar una nueva función a la instalación de Visual
Studio Tools.
6. Instale las plantillas de Visual Studio.

Marque la opción para instalar las plantillas de Visual Studio para la versión de Visual Studio que está
utilizando y luego haga clic en Siguiente. Haga clic en Instalar para comenzar el proceso de instalación.
7. Finalice la instalación.
Haga clic en Finalizar para completar la instalación.
10 ESCUADRÓN DE PROGRAMADORES
Capítulo 2: Conceptos básicos de integración

Antes de crear una integración con Visual Studio Tools para Microsoft Dynamics GP, será útil
comprender los conceptos básicos de una integración. Se discuten los siguientes temas:
• Qué proporciona Visual Studio Tools •

Arquitectura •
Creación de un proyecto
Qué proporciona Visual Studio Tools
Visual Studio Tools para Microsoft Dynamics GP proporciona tres capacidades principales para
una aplicación de integración:
WinForms personalizados Cualquier

WinForms incluido en una aplicación de integración puede usar las capacidades proporcionadas
por Visual Studio Tools para Microsoft Dynamics GP para que coincida con la apariencia de la
aplicación principal. La apariencia de la ventana, así como los diversos controles de la ventana,
se pueden personalizar. Aprenderá a crear ventanas para su integración en el Capítulo 4,
"WinForms", y el Capítulo 5, "Referencia de control".
Acceso a los recursos del diccionario Las aplicaciones

integradas tienen acceso a los numerosos recursos disponibles en los diccionarios de la
aplicación utilizados para Microsoft Dynamics GP. Una aplicación de integración puede acceder
a los formularios, ventanas, campos de ventana, tablas y campos de tabla de cada diccionario.
También pueden acceder a variables globales, comandos, procedimientos y funciones definidas
en cada diccionario. Aprenderá a acceder a los recursos del diccionario en el Capítulo 7,
“Acceder a los recursos del diccionario”.
Acceso a eventos Las

aplicaciones integradas pueden recibir notificaciones de eventos que ocurren en Microsoft
Dynamics GP, como la apertura de una ventana o el movimiento del foco a un campo. Las
aplicaciones pueden responder a los eventos, realizando acciones como verificar valores de
campo o abrir ventanas adicionales. El Capítulo 8, "Eventos", contiene información sobre cómo
registrarse y responder a los eventos.
Arquitectura
Visual Studio Tools para Microsoft Dynamics GP consta de componentes de tiempo de ejecución
y componentes de desarrollo.
Componentes de tiempo de ejecución

Los componentes de tiempo de ejecución de Visual Studio Tools se instalan con Microsoft
Dynamics GP y proporcionan la funcionalidad utilizada por las integraciones. Estos consisten
en lo siguiente:
Dexterity Shell Este ensamblaje (Microsoft.Dexterity.Shell.dll) proporciona las capacidades de

dibujo que permiten que una aplicación de integración coincida con la apariencia de Microsoft
Dynamics GP.
Dexterity Bridge Este ensamblado (Microsoft.Dexterity.Bridge.dll) proporciona el acceso a los

eventos en Microsoft Dynamics GP, así como a los recursos en los diccionarios de la aplicación.
ESCUADRÓN DE PROGRAMADORES 11
Ensambles de aplicación Cada diccionario al que accederá una integración de Visual Studio Tools para
Microsoft Dynamics GP tendrá un ensamblaje de aplicación. Cada ensamblado de aplicación
proporciona acceso a los recursos en su diccionario correspondiente. Por ejemplo, el ensamblado
Application.Dynamics.dll proporciona acceso a los recursos del diccionario Dynamics.dic.
Visual Studio Tools para Microsoft Dynamics GP incluye los ensamblados de aplicaciones para todos
los módulos que se envían con Microsoft Dynamics GP. Puede usar la herramienta Generador de
ensamblados de diccionarios (Dag.exe) para crear ensamblados de aplicaciones para otros diccionarios
de terceros para Microsoft Dynamics GP. Aprenderá más sobre esta herramienta en el Capítulo 6,
“Generador de ensamblados de diccionario”.
Carpeta AddIns Los ensamblados para las aplicaciones de integración creadas con Visual Studio Tools
para Microsoft Dynamics GP se colocan en esta carpeta. Cuando se inicia Microsoft Dynamics GP,
busca automáticamente en esta carpeta e intenta iniciar las aplicaciones de integración que encuentra
allí.
Componentes de desarrollo
Los siguientes componentes de desarrollo están instalados en la carpeta donde eligió instalar Visual
Studio Tools para Microsoft Dynamics GP:
DAG.exe Esta es la herramienta Generador de ensamblados de diccionarios, utilizada para crear

ensamblados de aplicaciones para diccionarios. Lo usará para crear ensamblajes de aplicaciones para
diccionarios de terceros que no los tienen. También lo usará para crear ensamblajes de aplicaciones
para diccionarios de formularios en los casos en que su integración deba interactuar con formularios
modificados en Microsoft Dynamics GP.
Archivos XML de IntelliSense El archivo XML de IntelliSense contiene la información sobre el

ensamblado de la aplicación que se muestra en IntelliSense dentro de Visual Studio. El nombre del
archivo XML de la aplicación coincide con el del ensamblado de la aplicación al que corresponde. Por
ejemplo, el archivo Application.Dynamics.xml contiene información sobre el ensamblado
Application.Dynamics.dll.
Los siguientes componentes se instalan en la instalación de Visual Studio:
Proyecto de Visual Basic Este es el proyecto de plantilla para un complemento basado en Visual Basic.
Proyecto de Visual C# Este es el proyecto de plantilla para un complemento basado en Visual C#.
Creando un proyecto
Utilice el siguiente procedimiento para crear un nuevo proyecto de Visual Studio para un complemento
de Microsoft Dynamics GP.
1. Inicie Visual Studio.

Si aún no se está ejecutando, inicie Visual Studio.
2. Cree un nuevo proyecto.

En el menú Archivo, seleccione Nuevo y elija Proyecto.
3. Seleccione el tipo de proyecto.

Elija un proyecto de Visual Basic o un proyecto de Visual C#. Debajo del tipo que ha seleccionado,
elija Dynamics GP.
CAPÍTULO 2 FUNDAMENTOS DE LA INTEGRACIÓN
4. Elija la plantilla de complemento de Microsoft Dynamics GP.

En la lista de plantillas disponibles, elija la plantilla de proyecto del complemento de Microsoft Dynamics
GP.
Si las plantillas de Microsoft Dynamics GP no aparecen en la lista, es posible que deba registrarlas
manualmente. Consulte Registro de plantillas en la página 8 para obtener detalles sobre cómo hacerlo.
5. Especifique el nombre y la ubicación del proyecto.

Haga clic en Aceptar para crear el proyecto.
Capítulo 3: Actualización de una integración

Si ha creado una integración con Visual Studio Tools para una versión anterior de Microsoft Dynamics
GP, use los siguientes procedimientos para actualizar su integración para que funcione con la versión
actual de Visual Studio Tools. Asegúrese de haber instalado la versión actual de Visual Studio Tools antes
de intentar actualizar sus integraciones. Se describen los siguientes procedimientos de actualización:
• Actualización desde la versión 9

• Actualización desde la versión 10 o posterior
Actualización desde la versión 9

Si su integración se creó con la versión 9 de Visual Studio Tools, use los siguientes procedimientos para
actualizar su integración para que funcione con Visual Studio Tools para Microsoft Dynamics GP 2013.
Se incluyen procedimientos separados para C# y Visual Basic.
Integración de C# Use el
siguiente procedimiento para actualizar una integración de Visual Studio Tools creada con C#.
1. Abra la solución para su integración.

Con Visual Studio, abra el archivo de solución para la integración que desea actualizar.
2. Utilice el asistente de conversión de Visual Studio.

El proyecto de Visual Studio debe convertirse para que funcione con la versión actual de Visual
Studio. Complete los pasos del Asistente de conversión de Visual Studio para convertir el proyecto.
3. Reconstruir ensamblajes de aplicaciones.

Si creó ensamblajes de aplicaciones para su integración, deberá reconstruirlos para que estén
actualizados con la última versión de Microsoft Dynamics GP. Consulte el Capítulo 6, "Generador de
ensamblados de diccionario", para obtener información sobre la generación de ensamblados de
aplicaciones.
4. Configure la versión de .NET Framework como destino.

Las integraciones de Visual Studio Tools para Microsoft Dynamics GP 2013 deben apuntar a .NET
Framework 4 para compilarse correctamente. Para especificar el marco de destino, muestre las
propiedades del proyecto. En el grupo Aplicación, establezca el campo Marco de destino en .NET
Framework 4. En el mensaje que se muestra, haga clic en Sí para indicar que desea realizar el
cambio.
Si no tiene como destino .NET Framework 4, verá numerosos errores de compilación cuando compile
su proyecto.
5. Actualice las referencias de ensamblado.

Es probable que las referencias de ensamblado para el proyecto sean incorrectas, porque no se
referirán a las nuevas versiones de los ensamblados de aplicaciones y componentes de Visual
Studio Tools.
Las referencias de ensamblaje son

incorrectas y deben
estar actualizado.
Agregue referencias a los ensamblados actualizados de Visual Studio Tools para reemplazar las
referencias rotas.
La referencia al ensamblado Microsoft.Dexterity.Shell.UI es una situación especial. Este componente

se fusionó con el ensamblado Microsoft.Dexterity.Shell. Cree una referencia al ensamblado
Microsoft.Dexterity.Shell y elimine la referencia al ensamblado Microsoft.Dexterity.Shell.UI.
6. Actualice los espacios de nombres utilizados en el código de integración.

El espacio de nombres para los componentes de shell (interfaz de usuario) de la integración de
Visual Studio Tools ha cambiado. La referencia del espacio de nombres debe cambiarse de:
Microsoft.Dexterity.Shell.UI
Al valor actualizado:
Microsoft.Dexterity.Shell
7. Actualice las referencias de espacio de nombres utilizadas para cualquier formulario.

Se debe realizar el mismo cambio de espacio de nombres para cualquier formulario que haya creado
para su integración. Cuando intente abrir un formulario en el diseñador de Visual Studio, verá un
error similar al siguiente:
dieciséis ESCUADRÓN DE PROGRAMADORES

CAPÍTULO 3 ACTUALIZACIÓN DE UNA INTEGRACIÓN
Esto significa que el código usado para el formulario usa el espacio de nombres anterior, en lugar
del nuevo espacio de nombres Microsoft.Dexterity.Shell. Debe ver el código del formulario y
cambiar todas las referencias del espacio de nombres para eliminar la parte de la "IU". Esto será
requerido en varios lugares. Un ejemplo de código que se corregirá se muestra resaltado en la
siguiente ilustración.
Es posible que deba expandir algunas secciones ocultas del código para encontrar todas las referencias.
Después de realizar estos cambios en el código del formulario, guarde el archivo actualizado.
Cierre el diseñador de formularios si aún está abierto y luego vuelva a abrir el formulario. El
formulario ahora debería abrirse y tener la apariencia actualizada de Microsoft Dynamics GP.
8. Cree la solución.
Elija compilar la solución actualizada en Visual Studio. Puede encontrar errores de compilación si
su integración hace referencia a recursos en Microsoft Dynamics GP que se eliminaron, movieron
o cambiaron de nombre. Deberá solucionar estos problemas y reconstruir la integración.
Integración de Visual Basic Use el siguiente

procedimiento para actualizar una integración de Visual Studio Tools creada con Visual Basic.

2. Utilice el asistente de conversión de Visual Studio.

El proyecto de Visual Studio debe convertirse para que funcione con la versión actual de Visual
Studio. Complete los pasos del Asistente de conversión de Visual Studio para convertir el proyecto.

actualizados con la última versión de Microsoft Dynamics GP. Consulte el Capítulo 6, "Generador
de ensamblados de diccionario", para obtener información sobre la generación de ensamblados de
aplicaciones.

Framework 4 para compilarse correctamente. Para especificar el marco de destino, muestre las
propiedades del proyecto. En el grupo Compilar, haga clic en Opciones avanzadas de compilación.
Establezca el campo Marco de destino (todas las configuraciones) en .NET Framework 4 y luego
haga clic en Aceptar. En el mensaje que se muestra, haga clic en Sí para indicar que desea realizar
el cambio.
Si no tiene como destino .NET Framework 4, verá numerosos errores de compilación cuando
compile su proyecto.
5. Actualice las referencias de ensamblado.

Las referencias de ensamblado para el proyecto serán incorrectas, porque no harán referencia
a las nuevas versiones de los ensamblados de aplicaciones y componentes de Visual Studio
Tools.
Las referencias de ensamblaje son

incorrectas y deben
estar actualizado.
Agregue referencias a los ensamblados actualizados de Visual Studio Tools para reemplazar
las referencias rotas.
La referencia al ensamblado Microsoft.Dexterity.Shell.UI es una situación especial. Este

componente se fusionó con el ensamblado Microsoft.Dexterity.Shell. Cree una referencia al
ensamblado Microsoft.Dexterity.Shell y elimine la referencia al ensamblado
Microsoft.Dexterity.Shell.UI.
6. Actualice los espacios de nombres utilizados en el código de integración.

El espacio de nombres para los componentes de shell (interfaz de usuario) de la integración
de Visual Studio Tools ha cambiado. Cualquier referencia de espacio de nombres debe
cambiarse de:
Microsoft.Dexterity.Shell.UI
Al valor actualizado:
7. Actualice las referencias de espacio de nombres utilizadas para cualquier formulario.

Se debe realizar el mismo cambio de espacio de nombres para cualquier formulario que haya creado
para su integración. Cuando intente abrir un formulario en el diseñador de Visual Studio, verá un
error que impide que se muestre el formulario. Ver el código del formulario:
Corrija las referencias del

espacio de nombres para el formulario.
8. Actualice el código del diseñador de formularios.

Abra el archivo de origen "Diseñador" del formulario para corregir las referencias para que usen el
nuevo espacio de nombres Microsoft.Dexterity.Shell. Cambie todas las referencias del espacio de
nombres para eliminar la parte de la "IU". Esto será requerido en varios lugares.
En la siguiente ilustración se muestra un ejemplo de código que se corregirá.
Corrija todas las referencias para

usar el nuevo espacio
de nombres Microsoft.Dexterity.Shell.
Después de realizar estos cambios en el código del formulario, guarde el archivo actualizado. Vuelva
a abrir el formulario. El formulario debe aparecer en el diseñador de formularios y tener la apariencia
actualizada de Microsoft Dynamics GP.
Elija compilar la solución actualizada en Visual Studio. Puede encontrar errores de compilación si su
integración hace referencia a recursos en Microsoft Dynamics GP que se eliminaron, movieron o
cambiaron de nombre. Deberá solucionar estos problemas y reconstruir la integración.
Actualización desde la versión 10 o posterior

Si su integración se creó con la versión 10 o posterior de Visual Studio Tools, use los siguientes
procedimientos para actualizar su integración para que funcione con Visual Studio Tools para Microsoft
Dynamics GP 2013. El procedimiento de actualización es relativamente simple.
El mismo procedimiento se puede utilizar tanto para C# como para Visual Basic.

2. Utilice el asistente de conversión de Visual Studio (si es necesario).

Si el proyecto de Visual Studio se debe convertir para que funcione con la versión actual de Visual
Studio, se mostrará el asistente de conversión de Visual Studio.
Complete los pasos del asistente para convertir el proyecto.

actualizados con la última versión de Microsoft Dynamics GP. Consulte el Capítulo 6, "Generador de
ensamblados de diccionario", para obtener información sobre la generación de ensamblados de
aplicaciones.

Framework 4 para compilarse correctamente. Para especificar el marco de destino, haga lo siguiente:
• Para un proyecto de C#, muestre las propiedades del proyecto. En el grupo Aplicación, establezca
el campo Marco de destino en .NET Framework 4. En el mensaje que se muestra, haga clic en
Sí para indicar que desea realizar el cambio.
• Para un proyecto de Visual Basic, muestre las propiedades del proyecto. En el grupo Compilar, haga
clic en Opciones avanzadas de compilación. Establezca el campo Marco de destino (todas las
configuraciones) en .NET Framework 4 y luego haga clic en Aceptar. En el mensaje que se
muestra, haga clic en Sí para indicar que desea realizar el cambio.
Si no tiene como destino .NET Framework 4, verá numerosos errores de compilación cuando compile
su proyecto.
5. Actualice las referencias de ensamblado si es necesario.

Las referencias de ensamblado para el proyecto pueden ser incorrectas, porque es posible que no
hagan referencia a las nuevas versiones de los ensamblados de aplicaciones y componentes de Visual
Studio Tools.
Si alguna de las referencias no es válida, elimine y vuelva a agregar referencias a los

ensamblados actualizados de Visual Studio Tools para reemplazar las referencias incorrectas.
Elija compilar la solución actualizada en Visual Studio. Puede encontrar errores de compilación
si su integración hace referencia a recursos en Microsoft Dynamics GP que se eliminaron,
movieron o cambiaron de nombre. Deberá solucionar estos problemas y reconstruir la
integración.
DE
PA
IN
2:
Parte 2: Desarrollo de integraciones

Esta parte de la documentación describe las diversas técnicas que usará a medida que desarrolla
integraciones con Visual Studio Tools para Microsoft Dynamics GP.
Se discuten los siguientes temas:
• El Capítulo 4, “WinForms”, describe cómo crear WinForms que tengan la apariencia de ventanas en
Microsoft Dynamics GP.
• El Capítulo 5, "Referencia de control", proporciona detalles de los diversos controles que son modificados
por Visual Studio Tools para Microsoft Dynamics GP.
• El Capítulo 6, “Generador de ensamblados de diccionario”, describe la herramienta utilizada para crear

ensamblados .NET que brindan acceso a los recursos del diccionario.
• El Capítulo 7, “Acceso a los recursos del diccionario”, explica cómo acceder a los recursos de los
diccionarios desde su aplicación de integración.
• El Capítulo 8, “Eventos”, describe cómo registrarse y responder a eventos para Microsoft Dynamics GP.
• El Capítulo 9, "Trabajar con tablas", describe cómo acceder directamente a Microsoft

Tablas de Dynamics GP de una integración.
• El Capítulo 10, "Creación e implementación", explica cómo crear e implementar una

integración que ha creado.
• El Capítulo 11, "Depuración", explica cómo depurar una integración creada con
Herramientas de Visual Studio para Microsoft Dynamics GP.
• El Capítulo 12, “Formularios modificados y alternativos”, describe cómo acceder a los recursos en
formularios modificados y alternativos en Microsoft Dynamics GP.
• El Capítulo 13, "Implementación de compatibilidad con macros", explica cómo hacer que los formularios
creados con Visual Studio Tools sean accesibles por el sistema de macros en Microsoft Dynamics
GP.
• El Capítulo 14, "Uso de búsquedas", describe cómo usar las búsquedas existentes de Microsoft
Dynamics GP en su integración con Visual Studio Tools.
Capítulo 4: WinForms
Los WinForms estándar son la base de la interfaz de usuario para los complementos creados con Visual Studio Tools
para Microsoft Dynamics GP. Estos WinForms y los controles colocados en ellos se modifican especialmente para
que coincidan con la apariencia de Microsoft Dynamics GP. La información sobre WinForms se divide en las siguientes
secciones:
• Agregar un formulario de Dynamics GP a un proyecto •

Propiedades de WinForm •
Agregar controles
Agregar un formulario de Dynamics GP a un proyecto

Para agregar un nuevo formulario de Dynamics GP a un proyecto de complemento, complete el siguiente procedimiento:
1. Agregue un nuevo componente.

En Visual Studio, elija Agregar componente en el menú Proyecto.
2. Seleccione un formulario de Microsoft Dynamics GP.

En la lista de plantillas, elija un formulario de Microsoft Dynamics GP.
Elija un formulario de
3. Asigne un nombre al nuevo formulario.
Asigne al formulario un nombre que sea apropiado para la forma en que se utilizará.
4. Agregue el nuevo formulario.

Haga clic en Agregar para agregar el nuevo WinForm al proyecto.
5. Especifique las propiedades del formulario.

Establezca las propiedades necesarias para el nuevo formulario.
PARTE 2 DESARROLLANDO INTEGRACIONES
Propiedades de WinForm
Los WinForms que se agregan a un proyecto de Visual Studio Tools para Microsoft Dynamics
GP tienen varias propiedades adicionales que controlan su apariencia. Establecer estas
propiedades correctamente ayuda a que coincida con la apariencia de Microsoft Dynamics GP.
Estas propiedades son:
• AutoSetDexColors • Área
de control • Área de
estado
Estas propiedades de WinForm se encuentran en el grupo "Destreza" en el panel Propiedades

de Visual Studio.
AutoSetDexColors La propiedad
AutoSetDexColors controla si los colores utilizados para WinForm coincidirán automáticamente
con el esquema de color seleccionado en las preferencias del usuario dentro de Microsoft
Dynamics GP. Establezca esta propiedad en True para que coincida con la apariencia de
ControlArea La
propiedad ControlArea especifica si la banda llamada área de control se dibuja en la parte
superior de WinForm. En las ventanas estándar de Microsoft Dynamics GP, los controles como
los botones Guardar, Borrar y Eliminar se colocan en el área de control. Establezca esta
propiedad en True para mostrar el área de control de un WinForm.
Esta es el área de control.
StatusArea La
propiedad StatusArea especifica si la banda denominada área de estado se dibuja en la parte
inferior de WinForm. Se dibuja una línea divisoria en la parte inferior de WinForm para indicar el
área de estado. En las ventanas estándar de Microsoft Dynamics GP, los controles como los
botones de exploración, los botones de notas y los botones de ayuda se colocan en el área de
estado. Establezca esta propiedad en True para mostrar el área de estado de un WinForm.
Esta es el área de estado.
CAPÍTULO 4 WINFORMS
Agregar controles
Puede agregar controles a los formularios para su integración de Microsoft Dynamics GP de la misma
manera que los agrega a los formularios estándar de Windows. Simplemente seleccione el control
en la caja de herramientas y arrástrelo al formulario.
Para agregar un control,

simplemente selecciónelo en la
caja de herramientas y arrástrelo al formulario.
Cuando agregue los controles, habrá propiedades adicionales disponibles para que algunos de ellos
coincidan con la apariencia de Microsoft Dynamics GP. Por ejemplo, los botones pulsadores tendrán
propiedades adicionales. Consulte el Capítulo 5, "Referencia de control", para obtener más
información acerca de los controles individuales.
Capítulo 5: Referencia de control

Puede usar cualquiera de los controles disponibles en WinForms para su integración con Microsoft
Dynamics GP. Algunos de los controles estándar se han personalizado para que coincidan mejor
con la apariencia de Microsoft Dynamics GP. Esta parte de la documentación describe los controles
que tienen propiedades adicionales o características actualizadas cuando se usan en un WinForm
en un proyecto de Visual Studio Tools para Microsoft Dynamics GP. Se discuten los siguientes
controles:
• Botones •
Cuadros de texto
• Etiquetas •
Cuadros combinados
• Cuadros de lista
Botones
Los controles de botón se usan para cada uno de los tipos de botón en un formulario de Microsoft
Dynamics GP. Los controles de botón en un WinForm para un proyecto de Microsoft Dynamics GP
obtienen sus características adicionales del dexButtonProvider que ve en el diseño de WinForm. La
propiedad ButtonType es una propiedad adicional disponible para cada botón. Especifica cómo se
muestra el control de botón y qué características tendrá. Puede establecer la propiedad
AutoSetDexColors en True para que los colores de los botones coincidan con los colores en Microsoft
Dynamics GP.
La siguiente es una lista de la configuración de la propiedad ButtonType y una descripción de cómo

se usa cada tipo de botón.
Estándar Los
botones estándar no modifican su apariencia cuando se colocan en un WinForm para un proyecto
de Dynamics GP. La siguiente ilustración muestra un botón estándar.
Este es un botón estándar.
Los botones
de la barra de herramientas con el Tipo de botón establecido en Barra de herramientas normalmente
se colocan en el área de control de un formulario de Microsoft Dynamics GP. Estos botones tienen
una apariencia plana, con un color especial resaltado cuando se coloca el puntero sobre ellos.
También es común que estos botones tengan imágenes. La siguiente ilustración muestra un botón
de la barra de herramientas.
Un botón de la barra de herramientas es
normalmente se coloca en el
área de control.
ToolbarWithSeparator Los botones

con el tipo ToolbarWithSeparator se colocan normalmente en el área de control,
como los botones con el tipo Toolbar. Sin embargo, tienen una línea de separación
adicional dibujada en el lado derecho del botón para separarlo de los otros controles
en el área de control. La siguiente ilustración muestra dos botones que tienen el
tipo ToolbarWithSeparator. Observe la línea de separación dibujada a la derecha
de cada botón.
Estos son botones de la barra de
herramientas con separadores.
StatusArea Los
botones ubicados en el área de estado en la parte inferior de una ventana deben tener el tipo
StatusArea. Estos botones deben mostrar solo gráficos y tendrán un borde 3D especial dibujado
alrededor de ellos cuando el puntero se coloque sobre ellos. Estos botones deben tener
establecida la propiedad Información sobre herramientas para que muestren una descripción de
la acción que realiza el botón. En la siguiente ilustración se muestra un botón de área de estado.
Muestra una información sobre herramientas que describe el propósito del botón.
Botones en el área de estado

por lo general solo tienen imágenes.
Los
botones de campo que muestran solo imágenes y se colocan junto a otros controles en el
formulario deben tener la propiedad ButtonType establecida en Field. Estos botones se utilizan
para cosas como búsquedas o expansiones. Varios botones con este tipo se muestran junto a
un control de texto en la siguiente ilustración.
Estos son botones

de campo.
Imágenes para botones Cada

proyecto de Visual Studio para Microsoft Dynamics GP incluye varias imágenes
estándar que se usan para botones en Microsoft Dynamics GP. Estas imágenes
(en formato PNG) deben usarse con los botones que cree para sus integraciones.
La siguiente tabla enumera las imágenes y describe cómo se utilizan.
Nombre de la imágen Descripción

Campo_Eliminar.png Se utiliza para eliminar botones en el área de la ventana ubicada junto a
los campos.
Campo_Editar.png Se utiliza para los botones de edición en el área de la ventana situada junto a
los campos.
Expansión_de_campo.png Se utiliza para los botones de expansión en el área de la ventana

situada junto a los campos.
Búsqueda_de_campo.png Se utiliza para los botones de búsqueda en el área de la ventana situada

junto a los campos.
Campo_MapaPunto.png Se utiliza para los botones de MapPoint en el área de la ventana situada junto
a los campos.
CAPÍTULO 5 REFERENCIA DE CONTROL
Nombre de la imágen Descripción

Field_NoteAbsent.png Se utiliza para los botones de nota en el área de la ventana situada junto a
los campos.
Field_NotePresent.png Se utiliza para los botones de nota en el área de la ventana situada junto a
los campos.
ImagenAyuda.png Se utiliza para el botón de Ayuda situado en el área de estado de la

ventana.
Barra de herramientas_Cancelar.png Se usa para el botón Cancelar ubicado en el área de control de la

ventana.
Barra de herramientas_Borrar.png Se usa para el botón Borrar ubicado en el área de control de la

ventana.
Barra_herramienta_Copiar.png Se usa para el botón Copiar ubicado en el área de control de la

ventana.
Barra_herramienta_Eliminar.png Se usa para el botón Eliminar ubicado en el área de control de la

ventana.
Toolbar_DeleteAll.png Se usa para el botón Eliminar todo ubicado en el área de control de la

ventana.
Barra de herramientas_Nueva.png Usado para el botón Nuevo colocado en el control de la ventana

área.
Barra de herramientas_Abrir.png Se utiliza para el botón Abrir situado en el área de control de la

ventana.
Barra de herramientas_Publicar.png Se utiliza para el botón Publicar colocado en el control de la ventana.

área.
Barra de herramientas_Imprimir.png Se usa para el botón Imprimir ubicado en el control de la ventana

área.
Barra de herramientas_Redisplay.png Se usa para el botón Volver a mostrar ubicado en el área de control de
la ventana.
Barra de herramientas_Guardar.png Se usa para el botón Guardar ubicado en el área de control de la

ventana.
Toolbar_Void.png Se utiliza para el botón Void colocado en el control de la ventana.

área.
VCR_primero.png Se utiliza para el primer control de navegación en el estado de la ventana

área.
VCR_Last.png Se utiliza para el último control de navegación en el estado de la ventana

área.
VCR_Siguiente.png Se utiliza para el control de exploración Siguiente en la ventana

área de estado.
VCR_Anterior.png Se utiliza para el control de navegación anterior en la ventana

área de estado.
Window_NoteAbsent.png Se utiliza para el botón de nota en el área de estado de la ventana.
Window_NotePresent.png Se utiliza para el botón de nota en el área de estado de la ventana.
Cajas de texto
Los controles TextBox se utilizan para los controles de cadena, entero, moneda, fecha y hora en un
formulario de Microsoft Dynamics GP. Los cuadros de texto tienen la propiedad AutoSetDexColors que
se puede establecer en True para que los colores de control coincidan con los colores de Microsoft
Dynamics GP.
Un control TextBox se usa para

campos estándar como
valores de moneda.
A diferencia de los controles estándar en Microsoft Dynamics GP, los controles de cuadro de texto no tienen compatibilidad
integrada para formatear datos como valores de moneda. Deberá agregar código adicional a su integración para que
coincida con el comportamiento de los controles en Microsoft Dynamics GP. Por ejemplo, el siguiente código C# establece
el valor del cuadro de texto en la ilustración anterior. Utiliza el método Format para que el objeto String dé formato al valor
de la moneda.
// Mostrar el valor, formateándolo como una cantidad de moneda

textBoxEstimatedFreight.Text = String.Format("{0:C}",EstimatedFreight);
Etiquetas
Los controles de etiquetas se utilizan para las etiquetas de texto que aparecen junto a los controles en el formulario de
Microsoft Dynamics GP. Corresponden a los elementos de texto estático que aparecen en las ventanas estándar de
Un control de etiqueta
muestra la etiqueta de texto
que aparece junto a otro control.
Los controles de etiqueta tienen la propiedad LinkField que debe establecerse cuando se etiqueta un campo específico.
Esta propiedad se establece en el nombre del control al que se aplica la etiqueta. Cuando se especifica en las Preferencias
del usuario de Microsoft Dynamics GP, la etiqueta se dibujará con el subrayado único que es estándar para las solicitudes.
Para que la etiqueta subrayada se dibuje correctamente, asegúrese de que la propiedad AutoSize de la etiqueta esté
establecida en False.
ComboBoxes
Use el control ComboBox en los casos en que usaría una lista desplegable o un cuadro combinado en Microsoft Dynamics
GP. Los controles ComboBox tienen la propiedad AutoSetDexColors que se puede establecer en True para que los colores
del control coincidan con los colores en Microsoft Dynamics GP.
La siguiente ilustración muestra un control ComboBox que se usa como una lista desplegable en un formulario de Microsoft
Dynamics GP.
cuadros de lista
Use el control ListBox en los casos en que usaría un cuadro de lista o un cuadro de lista de selección múltiple en Microsoft
Dynamics GP.
Capítulo 6: Generador de ensamblado de diccionarios

Dictionary Assembly Generator (DAG.exe) es una utilidad incluida con Visual Studio Tools para Microsoft
Dynamics GP que crea un ensamblado de código administrado que brinda acceso a los recursos en un
diccionario de aplicación. La información sobre esta herramienta se divide en las siguientes secciones:
• Creación de ensamblajes de aplicaciones

• Archivos de salida
• Uso del generador de ensamblajes de diccionario •
Optimización del proceso de generación de ensamblajes
Creación de ensamblajes de aplicaciones
Se incluyen varios ensamblajes de aplicaciones con Visual Studio Tools para Microsoft Dynamics GP. Estos
son los ensamblados para la aplicación principal (Dynamics.dic) y las demás aplicaciones que se entregan
con Microsoft Dynamics GP.
Cuando desarrolle integraciones que utilicen recursos de estos diccionarios, utilice siempre los ensamblados
de aplicaciones que se incluyen con la instalación de Visual Studio Tools. Estos ensamblajes están firmados
digitalmente, lo que indica que fueron producidos por Microsoft. No genere sus propias versiones de
ensamblajes de aplicaciones para diccionarios enviados con el producto Microsoft Dynamics GP.
Creará ensamblajes de aplicación para los siguientes casos:
• Existe un diccionario de formularios para un producto y desea que su integración de Microsoft Dynamics
GP acceda a los recursos modificados en el diccionario de formularios.
• Ha instalado un diccionario de terceros para el que no existe ningún ensamblado de aplicación y desea
acceder a los recursos de este diccionario desde su integración de Microsoft Dynamics GP. El
diccionario de terceros podría contener nuevos formularios y otros recursos. Podría contener formas
alternativas del diccionario Dynamics.dic.
Archivos de salida
El Generador de ensamblados de diccionario produce dos archivos de salida que se utilizan en su

integración: un ensamblado de aplicaciones y un archivo de datos de IntelliSense.
Montaje de la aplicación El resultado más

importante es el montaje de la aplicación. Este es el ensamblado de código administrado que proporciona
acceso a los recursos de un diccionario. Cada diccionario puede tener un ensamblado de aplicación
correspondiente.
La siguiente convención de nomenclatura se utiliza para los diccionarios de aplicaciones:
Application.ProductName.dll
La siguiente convención de nomenclatura se utiliza para los diccionarios de formularios:
Application.ProductName.ModifiedForms.dll
ProductName se deriva automáticamente del nombre del producto en el archivo de inicio. Se eliminan los
espacios o caracteres especiales del nombre del producto.
Por ejemplo, el ensamblado de la aplicación que proporciona acceso a los recursos del diccionario de la
aplicación SRVCADV.dic se denomina Application.FieldService.dll. El ensamblado de la aplicación que
proporciona acceso a los recursos del diccionario de formularios (FRMS949.dic) se denomina
Application.FieldService.ModifiedForms.dll.
Archivo de datos de IntelliSense El segundo

tipo de salida del Generador de ensamblaje de diccionario es el archivo de datos de IntelliSense que
utilizará Visual Studio. Este archivo tiene el mismo nombre que su ensamblaje de aplicación correspondiente,
pero tiene la extensión .xml. A medida que escribe código, Visual Studio usará la información de este
archivo para mostrar detalles sobre los recursos a los que se puede acceder a través del ensamblado de
la aplicación. En la siguiente ilustración se muestra un ejemplo de IntelliSense para un recurso de
diccionario.
La información del
archivo XML del
ensamblado de la aplicación
se muestra en IntelliSense.
Uso del generador de ensamblado de diccionarios

El Generador de ensamblajes de diccionarios (DAG.exe) está instalado en la ubicación donde instaló
Visual Studio Tools. Por lo general, esta será la siguiente ubicación:
C:\Archivos de programa\Microsoft Dynamics\GP2013 VS Tools SDK
Si está utilizando una versión de Windows de 64 bits, los archivos se ubicarán en la carpeta Archivos de
programa (x86).
Dictionary Assembly Generator es una herramienta de línea de comandos y debe ejecutarse desde un
símbolo del sistema. Abra un símbolo del sistema y establezca la ubicación actual en la carpeta donde se
encuentra DAG.exe.
Para ver la sintaxis del comando, use el siguiente comando en el símbolo del sistema:
día.exe /?
El Generador de ensamblados de diccionarios utiliza el ID del producto para identificar el diccionario para
el que desea crear el ensamblado de la aplicación. Busque en el archivo de inicio (normalmente
Dynamics.set) una lista de los productos instalados.
CAPÍTULO 6 GENERADOR DE MONTAJE DE DICCIONARIO
Opcionalmente, puede especificar el archivo de inicio en el que buscará el Generador de ensamblajes de

diccionarios para encontrar la lista de productos instalados y las ubicaciones de diccionarios correspondientes.
Si no proporciona el nombre del archivo de inicio, DAG.exe buscará el archivo de inicio denominado
Dynamics.set en la ubicación actual.
Dado que está ejecutando DAG.exe desde una ubicación diferente a donde está instalado Microsoft
Dynamics GP, deberá proporcionar la ruta completa al archivo de inicio.
El Generador de ensamblados de diccionarios debe poder escribir en la ubicación desde la que se ejecuta.
Esto significa que el usuario que ejecuta DAG.exe debe ser parte del grupo Administradores o del grupo
Usuarios avanzados. En un sistema que se ejecuta con Control de cuentas de usuario (UAC), significa
iniciar DAG.exe con privilegios administrativos.
Creación de un ensamblado de aplicación El Generador de ensamblados

de diccionario creará un ensamblado de aplicación para el diccionario principal de una aplicación o para el
diccionario de formularios de una aplicación. Al generar un ensamblado para un diccionario de aplicación,
use el parámetro /M. Por ejemplo, el siguiente comando genera el ensamblado de la aplicación para el
diccionario principal de la aplicación de integración de muestra. Esta aplicación tiene el valor de ID de
producto 3333. Se proporciona la ruta al archivo de inicio (Dynamics.set).
dag.exe 3333 "C:\Archivos de programa\Microsoft Dynamics\GP\Dynamics.set" /M
Este comando produce dos archivos:
• Aplicación.SampleIntegratingApp.dll •
Aplicación.SampleIntegratingApp.xml
Para generar un ensamblado para un diccionario de formularios, use el parámetro /F. Por ejemplo, el
siguiente comando genera el ensamblado de la aplicación para el diccionario de formularios del producto
Field Service (con ID de diccionario 949).
dag.exe 949 "C:\Archivos de programa\Microsoft Dynamics\GP\Dynamics.set" /F
Este comando produce dos archivos:
• Aplicación.FieldService.ModifiedForms.dll •
Aplicación.FieldService.ModifiedForms.xml
Consulte Formularios modificados en la página 71 para obtener detalles sobre cómo crear un ensamblado de aplicación
para el diccionario de formularios (Forms.dic) utilizado por Microsoft Dynamics GP.
Firmar un ensamblado de aplicación Es posible que desee firmar los

ensamblados de aplicación que cree. Esta es una buena práctica, porque ayuda a garantizar que solo se
use la versión oficial de un ensamblado de aplicación. El Generador de ensamblados de diccionario puede
firmar los ensamblados que crea. Puede firmar completamente las asambleas o retrasarlas. Puede usar la
utilidad SN.exe (incluida con .NET Framework) para crear un archivo de clave de nombre seguro (.snk) que
se usa para firmar el ensamblado.
Después de crear y usar un archivo de clave de nombre seguro, guárdelo en un lugar seguro. Tendrá que
usarlo cada vez que compile o reconstruya ensamblajes de aplicaciones.
El siguiente ejemplo muestra cómo el ensamblado de la aplicación para la aplicación de integración de

muestra está totalmente firmado con la clave de nombre seguro Sample.snk. El archivo Sample.snk se
generó con la utilidad SN.exe.

/S:Ejemplo.snk
Anulación del nombre del ensamblado de la aplicación Al crear un ensamblado

de la aplicación para un diccionario, el Generador de ensamblados del diccionario utilizará
el nombre del producto del archivo de inicio. Es posible que este no sea el nombre que
desea usar para el ensamblado de la aplicación. Puede usar el parámetro /N para especificar
un nombre diferente para el ensamblado de la aplicación que se está generando.
Por ejemplo, el siguiente comando creará un ensamblado de aplicación para la aplicación de integración de
muestra, pero usará el nombre "Desarrollar" en lugar del nombre del producto en el archivo de inicio.

/N:Desarrollar
El ensamblado de la aplicación generada tendrá el nombre Application.Develop.dll.
Anulación del nombre del diccionario principal al que se hace referencia Al generar
ensamblados de aplicaciones para diccionarios que se integran con Microsoft Dynamics GP,
el Generador de ensamblados de diccionarios debe poder hacer referencia al ensamblado
de aplicaciones para el diccionario principal (normalmente Application.Dynamics.dll). Si al
ensamblado de la aplicación para el diccionario principal se le ha dado un nombre diferente,
puede usar el parámetro /NM para especificar el nuevo nombre para que se pueda encontrar
el ensamblado de la aplicación.
Por ejemplo, si el ensamblado de la aplicación para el diccionario principal se llamara

Application.DynamicsGP.dll, usaría el siguiente comando para crear un ensamblado de la aplicación para la
aplicación de integración de muestra. Tenga en cuenta que el parámetro /NM se usa para especificar el
nombre del ensamblado de la aplicación principal al que se hace referencia.

/NM:DynamicsGP
Optimización del proceso de generación de ensamblajes
Producir un ensamblado de aplicación para diccionarios grandes es un proceso que consume muchos
recursos. El Generador de ensamblados de diccionario utilizará una gran cantidad de memoria (a menudo
más de 1 gigabyte) y un tiempo de procesador considerable al producir un ensamblado de aplicaciones.
Para optimizar el proceso, haga lo siguiente:
• Utilice el mejor hardware que tenga disponible para generar el ensamblaje de la aplicación.
• Cierre todas las demás aplicaciones antes de iniciar el proceso.
• Desactive temporalmente las tareas de procesamiento en segundo plano, como el análisis de virus.
Capítulo 7: Acceder a los recursos del diccionario

Para crear una integración para Microsoft Dynamics GP o las aplicaciones adicionales que se
instalan con él, su código debe acceder a los recursos en los distintos diccionarios de la aplicación.
Esta parte de la documentación describe cómo hacer esto para su proyecto. Se discuten los
siguientes temas:
• Adición de referencias
• Espacio de
nombres • Clase de
diccionario • Acceso a recursos
adicionales • Variables para recursos de diccionario
Agregar referencias
Para acceder a los recursos de un diccionario específico, un proyecto debe contener una referencia
al ensamblado de la aplicación para ese diccionario. Cuando crea un nuevo proyecto de Visual
Studio Tools para Microsoft Dynamics GP, automáticamente contendrá una referencia al ensamblado
de la aplicación Application.Dynamics.dll. Esto proporciona acceso a los recursos del diccionario
Dynamics.dic. Para acceder a recursos en otros diccionarios, agregue referencias a los ensamblados
de aplicación para ellos.
Si un diccionario no tiene un ensamblado de aplicación correspondiente, consulte el Capítulo 6,

“Generador de ensamblados de diccionario”, para aprender a crear uno.
Por ejemplo, para acceder a los recursos de la aplicación "Aplicación de integración de muestra"
instalada con Microsoft Dynamics GP, el proyecto debe contener una referencia al ensamblado de
la aplicación Application.SampleIntegratingApp.dll. La siguiente ilustración muestra esta referencia
para un proyecto de C#.
Esta referencia
proporciona acceso a los
recursos del
diccionario correspondiente.
espacio de nombres
Se accede a los recursos de un diccionario a través del siguiente espacio de nombres:
Microsoft.Dexterity.Aplicaciones
Para facilitar el acceso a los recursos, este espacio de nombres se incluye en la plantilla del
proyecto de C# con la declaración de uso . En la plantilla de proyecto de Visual Basic, se incluye
mediante la instrucción Imports . Hacer referencia al espacio de nombres le evita tener que
calificar completamente las referencias a los recursos del diccionario.
Clase de diccionario
Se accede a los recursos de un diccionario a través de una sola clase que está disponible después
de agregar la referencia al ensamblado de la aplicación del diccionario. La clase tiene el mismo
nombre que aparece en el ensamblado de la aplicación. Por ejemplo, la clase para acceder a los
recursos del diccionario de Dynamics se llama Dynamics. De manera similar, la clase utilizada
para acceder a los recursos de la aplicación de integración de ejemplo se denomina
SampleIntegratingApp. Este es el mismo nombre que aparece en el ensamblado de la aplicación,
Application.SampleIntegratingApp.dll.
Se accede a los cinco tipos de recursos primarios en un diccionario a través de las propiedades
de la clase. Estos tipos de recursos son:
• Formularios
• Globales •
Procedimientos •
Funciones •
Tablas
Para acceder a un recurso de un tipo específico, comience escribiendo el nombre de la clase del
diccionario y luego la propiedad del tipo de recurso. IntelliSense en Visual Studio presentará una
lista del tipo específico de recursos disponibles en el diccionario. Por ejemplo, la siguiente
ilustración muestra los recursos de formularios en la aplicación principal de Dynamics.
Escriba el nombre de la clase del

diccionario y la propiedad
del tipo de recurso. IntelliSense
muestra una lista de recursos.
Cuando haya seleccionado un recurso del tipo específico, verá una lista de las propiedades,
métodos y eventos disponibles para ese recurso. La siguiente ilustración muestra algunas de las
propiedades, métodos y eventos del formulario AboutBox en el diccionario de Dynamics.
CAPÍTULO 7 ACCESO A LOS RECURSOS DEL DICCIONARIO
Acceso a recursos adicionales

Se accede a varios tipos de recursos adicionales a través de la propiedad Formularios de una clase de
diccionario. Éstas incluyen:
• Ventanas •
Comandos •
Procedimientos a nivel de
formulario • Funciones a nivel
de formulario • Búferes de tabla a nivel de formulario
Como ejemplo, la siguiente declaración de C# abre la ventana Mantenimiento del cliente. Observe cómo
se accede a la ventana a través del objeto de formulario.
Dynamics.Forms.RmCustomerMaintenance.RmCustomerMaintenance.Open();
Windows proporciona más acceso a dos tipos de recursos adicionales:
• Campos •
Ventanas de desplazamiento
Por ejemplo, la siguiente declaración de C# establece el valor del campo Comentario 1 en la ventana
Mantenimiento de proveedores.
Dynamics.Forms.PmVendorMaintenance.PmVendorMaintenance.Comment1.Value
= "Un vendedor preferido";
Aprenderá más sobre los detalles sobre el uso de cada tipo de recurso en la Parte 3, Referencia de
recursos.
Variables para recursos de diccionario

Dentro de su código, puede ser útil crear variables para recursos específicos en un diccionario de
aplicación. Las definiciones de los diversos recursos del diccionario se encuentran en un espacio de
nombres adicional disponible en el ensamblado de la aplicación. Este espacio de nombres tiene el mismo
nombre que aparece en el ensamblado de la aplicación, pero tiene un "Diccionario" adjunto. Por ejemplo,
para hacer referencia a las definiciones de recursos en el diccionario principal de Dynamics, usaría este
espacio de nombres:
Microsoft.Dexterity.Applications.DynamicsDictionary
Para hacer referencia a recursos para la aplicación de integración de muestra, usaría este espacio de
nombres:
Microsoft.Dexterity.Applications.SampleIntegratingAppDictionary;
Después de crear la variable, puede asignar su valor y luego usarlo en su código. Por ejemplo, el siguiente
código C# crea una variable para el formulario Mantenimiento de proveedores en Microsoft Dynamics GP.
Asigna el formulario a la variable y luego lo usa para abrir el formulario.
PmVendorMaintenanceForm VendorMaintenanceForm;
VendorMaintenanceForm = Dynamics.Forms.PmVendorMaintenance;
ProveedorMantenimientoForm.Open();
El uso de una variable puede simplificar su código, especialmente al acceder a recursos de

diccionario que tienen nombres largos. Por ejemplo, el siguiente código C# crea una variable
para la ventana Mantenimiento del cliente en Microsoft Dynamics GP. Luego establece los
valores de dos campos en la ventana. Observe que se necesita menos código para establecer
el campo cuando se usa la variable para la ventana.
// Crea la variable y establece su valor

RmCustomerMaintenanceForm.RmCustomerMaintenanceWindow CustMaintWindow;
CustMaintWindow = Dynamics.Forms.RmCustomerMaintenance.RmCustomerMaintenance;
// Acceder a los campos de la ventana requiere menos código cuando se usa la variable
CustMaintWindow.Comment1.Value = "Comentario 1";
Dynamics.Forms.RmCustomerMaintenance.RmCustomerMaintenance.Comment2.Value =
"Comentario 2";
Capítulo 8: Eventos
Las aplicaciones que se integran con Microsoft Dynamics GP a menudo necesitan recibir notificaciones
cuando ocurren eventos específicos en el sistema. Esta parte de la documentación describe cómo
registrarse para recibir notificaciones cuando ocurran eventos en el sistema. También describe cómo
escribir controladores de eventos que puedan responder a los eventos. La información se divide en las
siguientes secciones:
• Registro de eventos •
Respuesta a eventos •
Cancelación del registro de eventos
Registro de eventos
Su aplicación integradora debe registrar todos los eventos de los que debe ser notificado en el sistema.
Los registros de eventos se agregan al método Initialize() , ubicado en el código de la plantilla que se
agrega automáticamente cuando creó su proyecto de Visual Studio Tools para Microsoft Dynamics GP.
Los recursos para los que puede registrar eventos, como formularios, ventanas o campos, cada uno
enumera los eventos que ponen a disposición. Por ejemplo, un formulario tiene los siguientes eventos
disponibles:
• Abrir antes del original •

Abrir después del original •
Cerrar antes del original •
Cerrar después del original
Consulte cada tipo de recurso descrito en la Parte 3, Referencia de recursos, para ver la lista de
eventos que están disponibles para ese recurso.
Para registrar un evento, busque el recurso para el que desea registrar el evento. Elija el evento que
desee y luego especifique el método del controlador de eventos. El controlador de eventos es el método
que contiene el código que se ejecuta en respuesta al evento.
C#
Visual Studio lo ayudará cuando registre un evento en código C#. Comience por hacer referencia al
recurso para el que desea registrar un evento. Agregue el operador += y Visual Studio mostrará
IntelliSense para indicar que completará el controlador de eventos. Simplemente presione la tecla TAB
para agregar el registro del controlador de eventos.
Después de agregar el registro del controlador de eventos, Visual Studio ofrecerá agregar el método
del controlador de eventos para el nuevo evento. Vuelva a presionar la tecla TAB para agregar el
método del controlador de eventos. Cuando haya terminado, el evento completado tendrá un aspecto
similar al siguiente:
vacío público Inicializar ()

{
Dynamics.Forms.RmCustomerMaintenance.OpenAfterOriginal += nuevo
Controlador de eventos (RmCustomerMaintenance_OpenAfterOriginal);
}
void RmCustomerMaintenance_OpenAfterOriginal (remitente del objeto, EventArgs e)

{
throw new Exception("El método u operación no está implementado.");

}
Visual Basic Registrar

un evento en un proyecto de Visual Basic requiere dos pasos. Primero, en el método Initialize() del
proyecto, la instrucción AddHandler registra el evento.
La instrucción AddHandler toma dos parámetros. El primero especifica el recurso y el evento, mientras
que el segundo especifica el método del controlador de eventos que se ejecutará. El siguiente ejemplo
registra el evento AfterOpen para el formulario de mantenimiento del cliente en Microsoft Dynamics
GP.
Sub Initialize() implementa IDexterityAddIn.Initialize
AddHandler Dynamics.Forms.RmCustomerMaintenance.OpenAfterOriginal, _
Dirección de RMCustMaintAfterOpen
Finalizar sub
En el segundo paso, se agrega el método del controlador de eventos. Los parámetros de este método
deben coincidir con los requeridos por el evento. IntelliSense para el evento muestra los parámetros
que debe tener el controlador de eventos.
Los parámetros necesarios

para el controlador de eventos.
se muestra el método.
El siguiente ejemplo muestra el método del controlador de eventos agregado para el evento creado en
el ejemplo anterior.
Public Sub RMCustMaintAfterOpen(ByVal remitente As Object, ByVal e _

como System.EventArgs)
MsgBox("No implementado")
Finalizar sub
CAPÍTULO 8 EVENTOS
Respondiendo a eventos
El método del controlador de eventos contiene el código que se ejecuta en respuesta al evento.
Este código puede realizar cualquier acción necesaria para su aplicación de integración. Por
ejemplo, el siguiente código C# es el controlador de eventos que se ejecuta en respuesta al cambio
del valor del campo Número de documento de ventas en la ventana Entrada de transacción de
ventas. Si el formulario de Estimación de flete está abierto, se establecen los controles en el formulario.
void SopNumber_Change (remitente del objeto, EventArgs e)

{
// Si el formulario Estimar flete está abierto, actualice el número de documento

// y borre los otros controles para que se pueda realizar el nuevo cálculo.
if (EstimateFreightForm.Created == verdadero)
{
CalcularFreightForm.textBoxDocumentNumber.Text =
SOEntryWindow.SopNumber.Value;
EstimarFreightForm.textBoxFreightEstimado.Clear();
EstimarFormaCarga.textBoxTotalWeight.Clear();
}
}
Argumentos de evento Los

argumentos de evento para algunos eventos proporcionan información adicional sobre el evento.
Los argumentos de evento para eventos de procedimiento y eventos de función permiten el acceso
a los parámetros para la llamada de procedimiento o función. Por ejemplo, el siguiente ejemplo de
C# es el controlador de eventos para el evento InvokeAfterOriginal para la función GetAutoComplete
en Microsoft Dynamics GP. Los argumentos del evento contienen los parámetros que se pasaron a
la función. El controlador de eventos examina el valor del primer parámetro para verificar que su
valor sea "DYNSA". Si es así, el código establece el resultado de la función en falso.
void GetAutoComplete_InvokeAfterOriginal(objeto remitente,

SyUserDefaultsForm.GetAutoCompleteFunction.InvokeEventArgs e)
{
// Establecer el valor de retorno para desactivar siempre el autocompletado para el usuario de DYNSA
if ( p . inParam1 == " DYNSA " )
{
e.resultado = falso;
}
}
Los argumentos de evento para eventos de diálogo modal permiten el acceso a los botones y
mensajes que se muestran en el diálogo modal. Por ejemplo, el siguiente código de Visual Basic es
el controlador de eventos para el evento BeforeModalDialog de la ventana Entrada de transacción
de ventas. Muestra cómo se utilizan los argumentos de evento para examinar el texto del mensaje
que muestra el cuadro de diálogo modal y cómo se utilizan para responder al cuadro de diálogo.
Sub privado SopEntryWindow_BeforeModalDialog(ByVal remitente As Object, ByVal e

Como AntesModalDialogEventArgs)
' Examine el cuadro de diálogo para determinar si es el que debe responder.

Si e.DialogType = DialogType.Ask Entonces
Si e.Message.Contains("quiero agregar un cliente") Entonces
'Haga clic en el botón Cliente en el cuadro de diálogo modal
e.Respuesta = DialogResponse.Button1
Terminara si
Terminara si
Finalizar sub
Cancelación de eventos Algunos

eventos se pueden cancelar a través del controlador de eventos. Por lo general, estos son eventos
que ocurren antes del evento en la aplicación principal, como el evento OpenBeforeOriginal para
un formulario. El parámetro de argumento de evento que se pasa al controlador de eventos para
estos eventos tiene un tipo especial que permite cancelar el evento.
Por ejemplo, el siguiente ejemplo de Visual Basic es el controlador de eventos para el evento
BeforeOpen del formulario Mantenimiento del cliente. El método del controlador de eventos
examina al usuario actual que inició sesión en el sistema. Si es el usuario “sa”, se muestra un
mensaje y no se abre la ventana. Observe cómo se utilizan los argumentos del evento para
cancelar el evento.
Public Sub RMCustMaintBeforeOpen(ByVal remitente As Object, ByVal e _

como System.ComponentModel.CancelEventArgs)
Si Dynamics.Globals.UserId.Value = "sa" Entonces
'Mostrar el mensaje
MsgBox("No acceda a esta ventana como administrador")
'Evitar que se abra el formulario

Dynamics.Forms.RmCustomerMaintenance.Close()
'Cancelar eventos pendientes

e.Cancelar = Verdadero
Terminara si
Finalizar sub
Dar de baja eventos

En algún momento después de haber registrado un evento, es posible que ya no sea necesario.
Para anular el registro de un evento, use la sintaxis estándar para C# o Visual Basic. Puede
cancelar el registro de los siguientes tipos de eventos:
• Eventos de
procedimiento • Eventos
de función • Eventos de diálogo modal
Los otros tipos de eventos no se pueden dar de baja. Si intenta anular su registro, se lanzará una
excepción.
C#
El siguiente ejemplo de C# muestra cómo cancelaría el registro de un evento
AfterModalDialog. El método denominado IvItemMaintenance_AfterModalDialog se había
registrado como controlador de eventos para el evento de diálogo modal.
ItemMaintenanceForm.IvItemMaintenance.AfterModalDialog = nuevo
EventHandler<AfterModalDialogEventArgs>(IvItemMaintenance_AfterModalDialog);
CAPÍTULO 8 EVENTOS
Visual Basic El
siguiente ejemplo de Visual Basic muestra cómo cancelaría el registro del evento
InvokeAfterOriginal para el procedimiento AddSuccessfulLoginRecord. El método
denominado AddSuccessfulLogin se había registrado como controlador de eventos
para el evento de procedimiento.
RemoveHandler Dynamics.Procedures.AddSuccessfulLoginRecord.InvokeAfterOriginal, _
Dirección de AddSuccessfulLogin
Capítulo 9: Trabajar con tablas

Una integración de Visual Studio Tools puede interactuar directamente con las tablas
definidas en Microsoft Dynamics GP. Usar la capacidad de integración de tablas es mucho
más simple que crear y administrar conexiones externas a la base de datos de Microsoft
Dynamics GP. La información sobre cómo trabajar con tablas se divide en las siguientes
secciones:
• Tablas en Microsoft Dynamics GP •

Búferes de
tablas • Abrir y cerrar tablas •
Claves •
Recuperar una fila •
Guardar una fila
• Actualizar una fila
• Eliminar una fila •
Errores de operación de
tablas •
Rangos •
Bloqueo de filas • Procesamiento multiusuario
Tablas en Microsoft Dynamics GP

Para obtener información sobre las tablas en Microsoft Dynamics GP, deberá acceder a la
información de las siguientes fuentes.
Herramienta Descripciones de recursos La

herramienta Descripciones de recursos disponible en Microsoft Dynamics GP proporciona
detalles esenciales sobre cada tabla en la aplicación. Aquí se puede encontrar información
como los campos de la tabla y las claves definidas para la tabla.
Los detalles importantes, como las

claves definidas para la tabla,
se pueden encontrar en la
ventana Descripciones de tabla.
SDK de Microsoft Dynamics GP El SDK de Microsoft

Dynamics GP contiene diagramas detallados y descripciones de las tablas en Microsoft
Dynamics GP. Puede usar estos diagramas para obtener información sobre la tabla en un
módulo específico y cómo las tablas funcionan juntas. La información sobre cómo fluyen
las transacciones a través de las distintas tablas también está disponible en el SDK de
IntelliSense El
IntelliSense disponible en Visual Studio será útil al enumerar qué tablas están disponibles,
así como qué campos están disponibles en esas tablas.
IntelliSense enumera qué

las mesas están disponibles. A
También se proporciona una
descripción de cada tabla.
Búferes de tabla
Un búfer de tabla proporciona acceso a una fila de una tabla específica. La información en el
búfer de la tabla proviene de la tabla o de un script que se haya ejecutado. Su código interactuará
con el búfer de la tabla cuando realice operaciones en la tabla. Hay dos tipos de búferes de
tablas: globales y de nivel de formulario.
Se crea un búfer de tabla global cuando se accede directamente a una tabla a través de la lista
global de tablas. Se accede a los búferes de tablas globales a través de la clase de diccionario.
Esta clase tiene una propiedad Tables que brinda acceso a la colección de tablas definidas en el
diccionario. Un búfer de tabla global no está asociado con ningún formulario específico. Esto
hace que los búferes de tablas globales sean útiles en situaciones en las que una integración de
Visual Studio Tools debe leer o escribir en una tabla de Dynamics GP, pero no interactúa con la
interfaz de usuario.
Global Herramientas de estudio visual

Dinámica GP
Mesa Búfer de tabla Código de aplicación
De forma predeterminada, un búfer de tabla global para una tabla se comparte con todos los
demás complementos de Visual Studio Tools que acceden a esa misma tabla. Si desea que su
integración cree un búfer de tabla global que no se comparte, use el método Clone() al crear la
instancia del búfer de tabla global.
Se crea un búfer de tabla a nivel de formulario cuando se adjunta una tabla a un formulario en
Microsoft Dynamics GP. Hay un búfer de tabla para cada tabla adjunta al formulario.
Cada búfer de tabla a nivel de formulario es compartido por el código que forma parte del
formulario, así como por cualquier código fuera del formulario que acceda a la tabla a través de
ese formulario. La propiedad Tablas del formulario permite el acceso a los búferes de las tablas
adjuntas al formulario. Debido a que son compartidos, las integraciones de Visual Studio Tools
no suelen usar los búferes de tablas de nivel de formulario para leer o escribir directamente en
las tablas. En su lugar, se examinan los búferes de la tabla a nivel de formulario para encontrar
qué datos ha leído o está escribiendo la ventana de Dynamics GP en la tabla específica.
CAPÍTULO 9 TRABAJO CON TABLAS
Forma
Dinámica GP
Ventana
Herramientas de estudio visual Nivel de formulario
Código de aplicación Búferes de tabla
Tablas de Dynamics GP
Apertura y cierre de mesas.

No existe una operación "abrir" explícita para una tabla en Visual Studio Tools. La primera vez que se
accede a un búfer de tabla, la tabla se abre automáticamente. El búfer de la tabla permanece abierto hasta
que se cierra.
Cuando el código de su aplicación de integración haya terminado de trabajar con un búfer de tabla global,
debe cerrarse usando el método Close() para la tabla. Si no se cierra un búfer de tabla global, se producirá
el error "Se está ejecutando un proceso en segundo plano: se canceló la salida" cuando el usuario intente
salir de Microsoft Dynamics GP.
El usuario verá este error cuando

los búferes de tablas globales se
dejen abiertos en una integración
de Visual Studio Tools.
Para los búferes de tabla a nivel de formulario, el búfer de tabla se cerrará cuando se cierre el formulario.
Rara vez es necesario cerrar explícitamente un búfer de tabla a nivel de formulario con el método Close() .
El siguiente ejemplo de C# muestra cómo se accede a una tabla a través de un búfer de tabla global. Se
recupera la primera fila de la tabla (la tabla Maestro de clientes de RM) y se muestra el número de cliente.
Observe cómo se cierra el búfer de la tabla al final del ejemplo.
RmCustomerMstrTable CustomerMasterTable;
CustomerMasterTable = Dynamics.Tables.RmCustomerMstr;
// Lee la primera fila de la tabla

TablaMaestraCliente.GetFirst();
// Mostrar el nombre de la fila recuperada

MessageBox.Show(CustomerMasterTable.CustomerName.Value);
// Cierra el búfer de la tabla

TablaMaestraCliente.Cerrar();
Llaves
Una clave es un campo o combinación de campos en una tabla que se usa para ordenar y ubicar
filas específicas en la tabla. Por lo general, el valor del campo o campos clave es único para cada
fila de una tabla, por lo que se puede ubicar una fila específica. Las claves que no identifican de
forma única una fila específica se usan para hacer referencia a un rango de filas en la tabla.
Las claves para una tabla se identifican por número, comenzando con el valor 1. Cuando especifique
la clave que desea usar para una tabla, proporcionará el número entero correspondiente. La ventana
Descripciones de tablas en Microsoft Dynamics GP enumera las claves para cada tabla y los
segmentos clave (campos) que contiene cada clave.
Las claves de la tabla se

enumeran en orden numérico.
Los campos de cada clave se

enumeran aquí.
Utilizará las claves para una tabla cuando recupere una fila específica de la tabla.
Esto se describe en la siguiente sección, Recuperación de una fila. También utilizará claves cuando
desee realizar operaciones en un rango de filas en la tabla. Aprenderá más sobre esto en Rangos
en la página 55.
Recuperando una fila

Recuperar una fila de una tabla es un proceso de varios pasos. Primero, debe decidir qué clave
desea usar para recuperar la fila. Utilice la ventana Descripciones de tablas en Microsoft Dynamics
GP para ver las claves y los componentes de cada clave. Especifique la clave a usar y luego
establezca los valores de los campos clave. Finalmente, use el método Get() o Change() para que
la tabla recupere el registro. El que utilice depende de si desea bloquear el registro. Aprenderá más
sobre el bloqueo en Bloqueo de filas en la página 59.
El siguiente ejemplo de C# recupera la fila del cliente American Electrical Contractor de la tabla
RM_Customer_MSTR. Se utiliza la segunda clave de la tabla RM_Customer_MSTR. Esta clave
contiene un componente, el nombre del cliente. La persona de contacto del cliente recuperado se
muestra en un cuadro de diálogo.
// Variable para cualquier error de operación de tabla

TableError error;
// Crear una referencia a la tabla

// Establecer la clave que se usará para la tabla // Clave

2: contiene el nombre del cliente CustomerMasterTable.Key
= 2;
// Establecer el valor para las columnas clave

CustomerMasterTable.CustomerName.Value = "Contratista eléctrico estadounidense";
// Recuperar la fila
err = CustomerMasterTable.Get();
si (err == TableError.NoError)
{
MessageBox.Show(CustomerMasterTable.ContactPerson.Value);
}
demás
// Mostrar el error que ocurrió

MessageBox.Show(err.ToString());
}
//Cerrar la tabla
guardando una fila
Para guardar una nueva fila en una tabla, configure los campos de la tabla con los valores que
desea guardar. Luego use el método Save() para guardar la nueva fila en la tabla. El siguiente
ejemplo de C# agrega una nueva fila a la tabla GL_Account_Category_MSTR. Establece los
valores para los campos de la tabla y luego guarda la nueva fila.

TableError error;
GlAccountCategoryMstrTable CategoryMasterTable;
CategoryMasterTable = Dynamics.Tables.GlAccountCategoryMstr;
// Establecer los campos en la tabla
CategoryMasterTable.AccountCategoryNumber.Value = (corto)49;
CategoryMasterTable.AccountCategoryDescription.Value = "Participación en los beneficios";
// Guarda la nueva fila
err = CategoryMasterTable.Save();
si (err == TableError.Duplicate)
{
MessageBox.Show("La categoría de cuenta ya existe");

}
//Cerrar la tabla
CategoryMasterTable.Close();
Actualizar una fila

Para actualizar una fila en una tabla, primero lea la fila con el método Change() . Esto
recupera la fila y la bloquea, lo que le permite realizar cambios. Establezca los valores
de los campos que desea cambiar para la fila. Finalmente, use el método Save() para
guardar la fila modificada en la tabla.
El siguiente ejemplo de C# lee la fila de Adam Park Resort. La persona de contacto de

esta fila se cambia a "Steve K". Luego, la fila se vuelve a guardar en la tabla
RM_Customer_MSTR.

TableError error;

// Establecer la clave a usar para la tabla

// Clave 1 Contiene el Número de Cliente
TablaMaestraCliente.Clave = 1;
// Establecer el campo clave en la tabla

CustomerMasterTable.CustomerNumber.Value = "ADAMPARK0001";
// Intentar leer la fila. El método Change() bloqueará la fila.

err = CustomerMasterTable.Change();
{
// La fila se leyó con éxito, actualice el valor

CustomerMasterTable.ContactPerson.Value = "Steve K.";
// Guarda la fila actualizada

err = CustomerMasterTable.Save();
si (err != TableError.NoError)
{
" +
MessageBox.Show("Ocurrió un error al actualizar la fila:
err.ToString());
}
}
demás
MessageBox.Show("Se produjo un error al recuperar la fila para actualizar: " +

err.ToString());
}
//Cerrar la tabla
Eliminando una fila

Para eliminar una fila de una tabla, primero lea la fila con el método Change() .
Esto recupera la fila y la bloquea. Luego use la instrucción Remove() para eliminar
la fila de la tabla.
El siguiente ejemplo de C# lee y bloquea la fila del artículo de inventario "WIRE100"

en la tabla IV_Item_MSTR. Si el elemento se lee con éxito, se elimina de la tabla.

TableError error;

IvItemMstrTable ItemMasterTable;
ItemMasterTable = Dynamics.Tables.IvItemMstr;

// Clave 1: contiene el número de artículo
ItemMasterTable.Clave = 1;
// Establecer el campo clave en la tabla

ItemMasterTable.ItemNumber.Value = "WIRE100";
// Intentar leer la fila. El método Change() bloqueará la fila.

err = ItemMasterTable.Change();
{
// Intento de eliminar la fila

err = ItemMasterTable.Remove();
{
" +
MessageBox.Show("Se produjo un error al eliminar la fila:
err.ToString());
}
}
//Cerrar la tabla
ItemMasterTable.Close();
Errores de operación de la tabla
Se devuelve un código de error de cada una de las operaciones de tabla que se pueden realizar.
Los posibles códigos de error están contenidos en la enumeración TableError . Muchos de los errores
incluidos en la enumeración no se producirán en las versiones publicadas de Microsoft Dynamics GP. La
siguiente tabla describe los valores de error que probablemente encuentre su integración de Visual
Studio Tools:
Constante Descripción
Cambió La fila que se está guardando fue modificada por otro usuario.
Base de datosPermisoViolación El usuario actual no tiene privilegios de seguridad para acceder a la tabla.
Doble bloqueo Una fila ya estaba bloqueada en el búfer de la tabla.
Duplicar La fila que se está guardando ya existe en la tabla.
FinDeLaTabla No se puede recuperar la fila porque se ha llegado al principio o al final de la tabla.
Número de clave no válido La tabla no tiene una clave con el número especificado.
No hay error No se produjo ningún error.
sin bloqueo Se realizó una operación como Remove() , pero no se bloqueó ninguna fila.
Extraviado La fila no se encontró en la tabla.
No soportado La operación de tabla no es compatible con la tabla. Por ejemplo, intentar

bloquear activamente una fila en una tabla que no lo permite.
Intercambio La fila está bloqueada activamente por otro usuario.
Demasiadas tablas abiertas Hay demasiadas mesas abiertas en la aplicación.
Desconocido Un error desconocido ocurrió.
Por lo general, su código realizará una de las siguientes acciones, o ambas, después de cada operación de tabla:
• Verifique el valor NoError, lo que indica que la operación de la tabla fue exitosa. Si la operación fue
exitosa, el siguiente paso de procesamiento puede continuar.
• Buscar un error específico, como NotFound. El código debe responder

apropiadamente, como mostrar un mensaje para el usuario.
Si ocurre un error inesperado después de realizar una operación de tabla, siempre es una buena idea
mostrar los detalles del error al usuario. Incluya información como la tabla, la operación que se está
realizando y el error que se produjo.
Cuando ocurre un error de operación de tabla, su código no seguirá la ruta de código típica. Asegúrese
de que su código cierre todas las tablas a las que haya accedido. De lo contrario, el usuario no podrá
salir de Microsoft Dynamics GP.
Rangos
Cuando se trabaja con tablas, suele ser eficaz limitar la cantidad de información a la
que se accede. Puede hacer esto configurando un rango para la tabla. Un rango se
basa en una clave para la tabla y le permite acceder a una parte específica de las filas
de la tabla. El rango seleccionado se tratará como una tabla completa. Por ejemplo,
llamar al método GetFirst() devuelve la primera fila del rango. Llamar al método
GetLast() devuelve la última fila del rango, y así sucesivamente.
Utiliza los métodos RangeStart() y RangeEnd() para especificar el rango de una tabla.
Puede especificar un rango por tabla y el rango está asociado con una clave específica.
El rango se usará solo cuando se acceda a la tabla usando la tecla con la que está
asociado el rango. Para borrar el rango especificado para una tabla, use el método
RangeClear() .
Ejemplo 1: rango con clave simple En el siguiente ejemplo

de C#, se usa un rango para limitar las filas a las que se accede solo a aquellos clientes
cuyos nombres comienzan con "A". Observe que la segunda clave de la tabla,
compuesta por el campo Nombre del cliente, se utiliza para los métodos RangeStart() y
RangeEnd() . Se muestran la primera y la última fila del rango.

TableError error;


// Clave 2 Contiene el nombre del cliente
// Especificar el inicio del rango

TablaMaestraCliente.Clear();
CustomerMasterTable.CustomerName.Value = "A";
TablaMaestraCliente.RangeStart();
// Especificar el final del rango

TablaMaestraCliente.Clear();
CustomerMasterTable.CustomerName.Value = "B";
CustomerMasterTable.RangeEnd();
// Mostrar el primer elemento del rango

err = CustomerMasterTable.GetFirst();
{
" +
MessageBox.Show("Primer cliente:
CustomerMasterTable.CustomerName.Value);
}
demás
{
" +
MessageBox.Show("Se produjo un error al recuperar la fila:
err.ToString());
}
// Mostrar el último elemento del rango
err = CustomerMasterTable.GetLast();
{
" +
MessageBox.Show("Último cliente:
CustomerMasterTable.CustomerName.Value);
demás
{
" +
err.ToString());
//Cerrar la tabla
Ejemplo 2 Rango con clave multisegmento Si una clave se compone de varios

segmentos, puede crear rangos basados en varios segmentos de clave. Es importante que se
establezcan todos los segmentos de la clave al especificar el inicio y el final del rango. Los
métodos Clear() y Fill() se utilizan a menudo cuando se crea un rango basado en una clave de
varios segmentos. Se utilizan para establecer todos los campos en el búfer de la tabla en el
valor vacío o el valor lleno. Esto garantiza que todos los segmentos clave se hayan especificado
antes de llamar a los métodos RangeStart() o RangeEnd() .
Por ejemplo, el siguiente código de C# crea un rango para la tabla IV_Item_MSTR que incluye
solo elementos de la clase COMPONENTS. El rango se crea utilizando la clave 3 para la tabla
Maestro de artículos. Esta clave tiene dos segmentos: Código de clase de artículo y Número
de artículo.
Para establecer el comienzo del rango, se utiliza el método Clear() para establecer los campos
en el búfer de la tabla IV_Item_MSTR al valor mínimo. El campo Código de clase de artículo en
el búfer de la tabla se establece en "COMPONENTES". El método RangeStart() especificó que
este es el comienzo del rango.
Para establecer el final del rango, se usa el método Fill() para establecer los campos en el búfer
de la tabla IV_Item_MSTR al valor máximo. El campo Código de clase de artículo en el búfer
de la tabla se establece en "COMPONENTES". El método RangeEnd() especifica que este es
el final del rango.
Los valores clave para el rango se muestran en la siguiente ilustración. El rango incluirá filas
donde el valor del Código de clase de artículo es "COMPONENTE" y el Número de artículo
puede ser cualquier valor.
Código de clase de artículo Número de artículo
Rango de inicio "COMPONENTE" (Borrado)
Fin de rango "COMPONENTE" (Completado)

TableError error;

IvItemMstrTable ItemMasterTable;
ItemMasterTable = Dynamics.Tables.IvItemMstr;

// Clave 3: contiene el código de clase de artículo y el número de artículo
ItemMasterTable.Clave = 3;

ItemMasterTable.Clear();
ItemMasterTable.ItemClassCode.Value = "COMPONENTES";
ItemMasterTable.RangeStart();

ItemMasterTable.Fill();
ItemMasterTable.ItemClassCode.Value = "COMPONENTES";
ItemMasterTable.RangeEnd();
// Lee los elementos en el rango

StringBuilder itemList = new StringBuilder();
err = ItemMasterTable.GetFirst();
while(err == TableError.NoError)
{
// Agregar el elemento a la lista
" " +
itemList.AppendLine(ItemMasterTable.ItemNumber +
ItemMasterTable.ItemDescription);
// Obtener el siguiente elemento en el rango

err = ItemMasterTable.GetNext();
}
// Mostrar la lista de elementos

MessageBox.Show(itemList.ToString());
//Cerrar la tabla
ItemMasterTable.Close();
Ejemplo 3: eliminar filas de un rango Una vez que se crea

un rango para una tabla, puede usar el método RangeRemove() para eliminar
todas las filas de ese rango de la tabla. En muchos casos, esto será más
rápido que eliminar filas individuales con el método Remove() .
El siguiente ejemplo de C# elimina toda la información de los clientes del

Hospital St. Patrick. Se debe eliminar una sola fila de las tablas
RM_Customer_MSTR y RM_Customer_MSTR_SUM. Se deben eliminar
varias filas de la tabla RM_Customer_MSTR_ADDR. Se utiliza un rango para
eliminar las filas de esta tabla.

TableError error;
// Crear referencias a las tablas

RmCustomerMstrSumTable CustomerMasterSummaryTable;
CustomerMasterSummaryTable = Dynamics.Tables.RmCustomerMstrSum;
RmCustomerMstrAddrTable CustomerMasterAddressTable;
CustomerMasterAddressTable = Dynamics.Tables.RmCustomerMstrAddr;
// Eliminar la fila de la tabla Resumen del maestro de clientes

CustomerMasterSummaryTable.Clave = 1;
CustomerMasterSummaryTable.CustomerNumber.Value = "STPATRIC0001";
err = CustomerMasterSummaryTable.Change();
{
err = CustomerMasterSummaryTable.Remove();
}
//Cerrar la tabla
CustomerMasterSummaryTable.Close();
// Eliminar la fila de la tabla del Maestro de clientes
CustomerMasterTable.CustomerNumber.Value = "STPATRIC0001";
err = CustomerMasterTable.Change();
{
err = CustomerMasterTable.Remove();
}
//Cerrar la tabla
// Eliminar las filas de la tabla de direcciones maestras de clientes
// La Clave 1 tiene dos segmentos (Número de Cliente y Código de Dirección)

CustomerMasterAddressTable.Clave = 1;

CustomerMasterAddressTable.Clear();
CustomerMasterAddressTable.CustomerNumber.Value = "STPATRIC0001";
CustomerMasterAddressTable.RangeStart();

CustomerMasterAddressTable.Fill();
CustomerMasterAddressTable.CustomerNumber.Value = "STPATRIC0001";
CustomerMasterAddressTable.RangeEnd();
// Elimina las filas del rango

CustomerMasterAddressTable.RangeRemove();
//Cerrar la tabla
CustomerMasterAddressTable.Close();
Bloqueo de filas
Una fila debe estar bloqueada para eliminarla o guardar los cambios realizados en ella. Se aplica un bloqueo
cuando se lee una fila de una tabla. Se pueden utilizar dos tipos de bloqueo: pasivo y activo.
Bloqueo pasivo Un bloqueo pasivo

permite que otros usuarios accedan a la fila. Pueden eliminar la fila o realizar cambios en ella. El bloqueo
pasivo garantiza que otros usuarios que accedan a la fila puedan saber que la fila se ha eliminado o que el
contenido de la fila ha cambiado. Se aplica un bloqueo pasivo cada vez que se lee una fila mediante el método
Change() .
El método Get() se usa solo para leer una fila. Nunca bloquea la fila.
Bloqueo activo Un bloqueo

activo permite a otros usuarios leer la fila, pero no realizar cambios ni eliminar la fila. El bloqueo activo garantiza
que el usuario que tiene el bloqueo activo es el único usuario que puede realizar cambios o eliminar la fila. Si
otros usuarios intentan eliminar o cambiar la fila, recibirán un error de uso compartido. Se aplica un bloqueo
activo cada vez que se lee una fila con el método Change() y se establece el parámetro activeLock para el
método.
a la verdad
No todas las tablas de Microsoft Dynamics GP permiten el bloqueo activo. Si intenta bloquear activamente una
fila en una tabla que no la admite, se devolverá un error NotSupported.
Liberación de bloqueos
Cualquiera de las siguientes acciones libera un bloqueo de fila:
• Utilizando el método Release() .
• Usando el método Save() o el método Remove() , sin importar si el método fue exitoso.
Si una fila está actualmente bloqueada en un búfer de tabla e intenta bloquear otra fila, recibirá un error de
DoubleLock que indica que una fila ya estaba bloqueada.
Procesamiento multiusuario
Microsoft Dynamics GP admite que varios usuarios accedan a la misma tabla al mismo tiempo. Esto se logra
mediante Optimistic Concurrency Control (OCC), una forma de bloqueo de registros que permite que varios
usuarios trabajen en las mismas tablas y accedan a las mismas filas con restricciones mínimas, mientras ayuda
a garantizar la integridad de los datos.
Para permitir que varios usuarios utilicen correctamente Microsoft Dynamics GP mientras las integraciones de
Visual Studio Tools acceden a los datos, debe elegir el tipo de bloqueo utilizado. También debe manejar
cualquier condición de error que ocurra como resultado de que varios usuarios trabajen con la misma fila en
una tabla.
La siguiente tabla enumera los diversos escenarios de bloqueo que pueden ocurrir. Los eventos enumerados
suceden en orden de izquierda a derecha. Por ejemplo, en la primera fila, el usuario A bloquea pasivamente una
fila, luego el usuario B bloquea pasivamente la misma fila. El usuario A elimina la fila, luego el usuario B cambia el
contenido de la fila y la guarda. Se guardarán los cambios realizados por el usuario B.
Usuario A Usuario B Usuario A Usuario B Resultado
1 Bloquea pasivamente un Bloquea Elimina la fila. Cambia el Se guardarán los cambios realizados por el
fila. pasivamente la misma fila. contenido de la fila y usuario B.
guarda los
cambios.
2 Bloquea pasivamente un Bloquea Cambia el Elimina la fila. La fila será eliminada.

fila. pasivamente la misma fila.contenido de la fila y
guarda la fila.
3 Bloquea pasivamente un Bloquea Cambia un campo Cambia un Ambos cambios se guardarán.

fila. pasivamente la misma fila.y guarda la fila. campo diferente y
guarda la fila.
4 Bloquea pasivamente un Bloquea Cambia un campo Cambia el mismo campo El usuario B obtendrá un error que indica
fila. pasivamente la misma fila.y guarda la fila. e intenta guardar la fila. que la fila cambió. Los cambios del usuario B
no se guardarán.
5 Bloquea pasivamente un Bloquea Elimina la fila. Intenta eliminar la fila. El usuario B obtendrá un error que indica
fila. pasivamente la misma fila. que falta la fila.
6 Bloquea activamente un Bloquea Mantiene el bloqueo Intenta eliminar la fila o El usuario B obtendrá un error de fila bloqueada.
fila. pasivamente la misma fila.activo. cambiar un campo y La fila no se eliminará o los cambios no
guardar el se guardarán.
fila.
7 Bloquea activamente un Bloquea Elimina la fila. Cambia la fila y la Si el usuario B cambió la fila y guardó,
fila. pasivamente la misma fila.
El bloqueo activo se guarda o elimina la los cambios se guardarán.
libera. fila. Si el Usuario B intenta eliminar la fila, el
Usuario B obtendrá un error que indica que
falta la fila.
8 Bloquea activamente un Bloquea Realiza cambios y Cambia la fila y la Si el Usuario B cambió el mismo campo que
fila. pasivamente la misma fila.guarda la fila. guarda o elimina la el Usuario A, el Usuario B recibirá un
El bloqueo activo se fila. error que indica que la fila cambió. Los
libera. cambios del usuario B no se guardarán.
Si el usuario B cambió diferentes campos,
los cambios se guardarán.
Si el usuario B eliminó la fila, la fila se
eliminará.
9 Bloquea pasivamente un Bloquea activamente el Intenta eliminar la fila o Mantiene el bloqueo El usuario A obtendrá un error de fila bloqueada,
fila. misma fila. cambiar un campo y activo. aunque el bloqueo activo del usuario B llegó
guardar el más tarde que el bloqueo del usuario A.
fila.
10 Bloquea activamente un Los intentos de El usuario B obtendrá un error de fila bloqueada.

fila. bloquear activamente el
misma fila.
Los escenarios 1 a 3 no producen ningún error. Para ser compatible con múltiples usuarios, su aplicación debe
poder manejar los escenarios 4 a 10, alertando a los usuarios de que ocurrió un error y permitiéndoles responder
adecuadamente.
Utilice el valor de error devuelto por las distintas operaciones de la tabla, como Guardar() o Eliminar(), para atrapar
los errores, de modo que su código pueda tratar los errores que se produzcan. Los siguientes ejemplos muestran
cómo detectar errores multiusuario al leer, guardar y eliminar registros.
No debe buscar condiciones de error multiusuario en tablas que contienen campos de texto. Los campos de texto
son aquellos que almacenan texto de hasta 32.000 caracteres. Los códigos de error multiusuario no se devuelven
correctamente para las tablas que contienen campos de texto.
Ejemplo 1 El
siguiente ejemplo de C# lee y bloquea activamente la primera fila de la tabla RM_Sales_WORK.
Utiliza el valor devuelto por el método ChangeFirst() para manejar el error de uso compartido
resultante de que la fila está bloqueada activamente por otro
usuario.

TableError error;
// Crear referencias a las tablas

RmTablaDeTrabajoVentasTablaDeTrabajoVentas;
SalesWorkTable = Dynamics.Tables.RmSalesWork;
// Liberar cualquier bloqueo existente

MesaDeTrabajoVentas.Release();
// Recuperar la primera fila y bloquearla activamente

err = SalesWorkTable.ChangeFirst(true);
si (err == TableError.Sharing)
{
// La fila está bloqueada activamente por otro usuario

MessageBox.Show("Esta fila está actualmente bloqueada por otro usuario.");
}
//Cerrar la tabla
TablaTrabajoVentas.Close();
Ejemplo 2 El
siguiente ejemplo de C# lee la primera fila de la tabla RM_Customer_MSTR, cambia la ID
del vendedor e intenta guardar la fila modificada. El valor de retorno del método Save() se
usa para manejar un error que resulta de que otro usuario cambió o bloqueó activamente la
fila.

TableError error;
// Crear referencia a la tabla

// Liberar cualquier bloqueo existente

CustomerMasterTable.Release();
// Lee la primera fila de la tabla
err = CustomerMasterTable.ChangeFirst();
// Cambiar la identificación del vendedor

CustomerMasterTable.SalespersonId.Value = "STEVE K.";
// Guardar la fila modificada

// Manejar cualquier error

si (err == TableError.Changed)
{
// La fila fue cambiada por otro usuario.

MessageBox.Show("Esta fila ha sido modificada por otro usuario. Sus cambios
será anulado.");
// Vuelva a leer la fila actual para bloquearla
TablaMaestraCliente.Change();
// Reescribe el valor
CustomerMasterTable.SalespersonId.Value = "STEVE K.";
// Intentar guardar de nuevo

MessageBox.Show("No se pudo actualizar el cliente.");

}
}
más si (err == TableError.Sharing)

{
MessageBox.Show("Esta fila está bloqueada activamente por otro usuario. Los cambios se
no ser salvo.");
}
si no (err != TableError.NoError)
{
// Ocurrió algún otro error en la tabla
" +
MessageBox.Show("Ocurrió un error al actualizar el cliente:
err.ToString());
}
//Cerrar la tabla
Ejemplo 3 La
siguiente secuencia de comandos lee la última fila de la tabla
GL_Account_Category_MSTR e intenta eliminarla. El valor de error devuelto por
el método Remove() se usa para manejar un error que resulta de que la fila está
bloqueada activamente o ya la eliminó otro usuario.

TableError error;
// Crear referencia a la tabla
GlAccountCategoryMstrTable AccountCategoryMasterTable;
AccountCategoryMasterTable = Dynamics.Tables.GlAccountCategoryMstr;
// Liberar cualquier bloqueo en la fila
AccountCategoryMasterTable.Release();
// Recuperar la última fila
err = AccountCategoryMasterTable.ChangeLast();
{
// La fila fue leída y puede ser eliminada
err = AccountCategoryMasterTable.Remove();
si (err == TableError.Sharing)
{
// La fila está bloqueada activamente
MessageBox.Show("Esta fila está bloqueada activamente por otro usuario.

No se puede eliminar.");
}
si no (err == TableError.NotFound)
// La fila fue eliminada por otro usuario
MessageBox.Show("Esta fila fue eliminada por otro usuario.");

}
si no (err != TableError.NoError)
{
" +
MessageBox.Show("Se produjo un error al eliminar la fila:
err.ToString());
}
}
demás
{
" +
err.ToString());
}
//Cerrar la tabla
AccountCategoryMasterTable.Close();
Capítulo 10: Construcción e implementación

Esta parte de la documentación describe cómo crear e implementar una integración creada con Visual Studio Tools
para Microsoft Dynamics GP. La información se divide en las siguientes secciones:
• Configuración de información de
ensamblado • Creación de una
integración • Implementación de una integración
Configuración de la información de ensamblaje
Es importante configurar la información del ensamblado para que el ensamblado que cree para la integración de
Visual Studio Tools para Microsoft Dynamics GP esté correctamente identificado y versionado. Asegúrese de
configurar los siguientes elementos:
• Título •
Descripción •
Compañía • Mayor,
menor y números de compilación
Aplicación C# Para las

integraciones escritas en C#, la información del ensamblado se establece en el archivo de origen AssemblyInfo.cs
para el proyecto. La siguiente parte de este archivo muestra los distintos valores de nombre que deben configurarse.
// La información general sobre un ensamblaje se controla a través de lo siguiente

// conjunto de atributos. Cambie estos valores de atributo para modificar la información.
// asociado con un ensamblado.
[ensamblaje: AssemblyTitle("Estimación de flete")]
[ensamblado: AssemblyDescription("Estimación de la integración de muestra de flete")]
[ensamblaje: Configuración de ensamblaje("")]
[ensamblado: Compañía de ensamblaje ("Microsoft")]
[ensamblado: ProductoEnsamblado("EstimaciónFlete")]
[ensamblado: AssemblyCopyright("Copyright © Microsoft 2012")]
[ensamblado: ensambladoMarca registrada("")]
[ensamblado: cultura de ensamblaje("")]
La siguiente parte de este archivo muestra los números de versión, compilación y revisión que deben configurarse.
// La información de versión de un ensamblado consta de los siguientes cuatro valores:

//
// Versión principal
// Versión menor
// Número de compilación
// Revisión
//
// Puede especificar todos los valores o predeterminar los números de revisión y compilación
// usando el '*' Como se muestra abajo:
[ensamblaje: versión de ensamblaje ("1.0.0.0")]

[ensamblado: AssemblyFileVersion("1.0.0.0")]
ESCUADRÓN DE PROGRAMADORES sesenta y cinco

Aplicación de Visual Basic Para las

integraciones escritas en Visual Basic, la información del ensamblaje se establece en la
ventana Información del ensamblaje. Accede a esta ventana. Para ver esta ventana, elija
mostrar las propiedades del proyecto de Visual Basic. Haga clic en la pestaña Aplicación y,
a continuación, haga clic en el botón Información del ensamblaje.
Construyendo una integración
Para construir la integración, complete el siguiente procedimiento:
1. Establecer la configuración de la solución.

Si está creando una versión de prueba de la integración, establezca la configuración de la solución
en "Depurar". Si está creando una versión final de la integración, establezca la configuración de
la solución en "Lanzamiento".
Establezca la
configuración de la
solución en Depurar o Liberar.
Elija Generar solución en el menú Generar.
3. Verifique que no haya advertencias de compilación.

Si hubo advertencias de compilación, corríjalas y vuelva a compilar.
4. Copie el ensamblaje en la carpeta AddIns.

Copie el ensamblaje para su integración desde la carpeta "Depuración" o "Versión" de su proyecto
a la carpeta Complementos en la instalación de Microsoft Dynamics GP.
5. Copie los ensamblados de aplicaciones necesarios.

Si creó ensamblajes de aplicaciones para su integración, asegúrese de copiarlos en la carpeta de
6. Inicie Microsoft Dynamics GP.

Su aplicación de integración debe cargarse cuando se inicia Microsoft Dynamics GP. Verifique
que su integración esté funcionando correctamente.
CAPÍTULO 10 CONSTRUCCIÓN Y DESPLIEGUE
Implementación de una integración
Al implementar su integración creada con Visual Studio Tools para Microsoft

Dynamics GP, asegúrese de incluir lo siguiente:
• El montaje para su integración.
• Cualquier ensamblaje de aplicación adicional que haya generado y que sea específico para su
integración.
• Instrucciones que explican cómo instalar su integración.
Capítulo 11: Depuración

Al desarrollar una aplicación de integración, puede que necesite examinar el código con el
depurador de Visual Studio. La información sobre cómo depurar su integración de Microsoft
Dynamics GP se divide en las siguientes secciones:
• Preparación para la
depuración • Examen de la
aplicación • Deshabilitación de eventos
Preparándose para depurar
Para preparar su aplicación de integración para la depuración, complete el siguiente

procedimiento.
1. Cree e implemente la integración.

Asegúrese de haber creado la versión de depuración de su proyecto.

Microsoft Dynamics GP debe estar ejecutándose para que se cargue su aplicación de
integración.
3. Establezca puntos de interrupción en su código.

Dentro de Visual Studio, establezca puntos de interrupción en su código para indicar dónde desea que
espere el procesamiento.
4. Elija adjuntar a un proceso.

Dado que su aplicación de integración se ejecuta dentro del proceso Dynamics.exe, debe
adjuntar el depurador de Visual Studio a este proceso. Desde Visual Studio, elija Adjuntar
al proceso en el menú Depurar.
5. Seleccione el proceso Dynamics.exe.

En la ventana Adjuntar al proceso, localice el proceso Dynamics.exe y selecciónelo en la
lista.
Localice el proceso
Dynamics.exe y
selecciónelo en la lista.
Haga clic en Adjuntar para adjuntar al proceso. El control volverá a Visual Studio.
Examinando la aplicación
Una vez que su aplicación de integración se haya detenido en un punto de interrupción, puede usar las
herramientas de Visual Studio para examinar su código. Haz lo siguiente:
1. Cambie a Microsoft Dynamics GP.
2. Realiza las acciones para ejercitar tu código.

Dentro de Microsoft Dynamics GP, realice las acciones que ejecutarán el código que
desea examinar.
3. Examine su código.
Cuando Visual Studio encuentra un punto de interrupción, se convertirá en la aplicación
activa. Utilice las herramientas de Visual Studio para examinar su código.
Examine su código mientras se

detiene en los
puntos de interrupción que estableció.
4. Finalice la depuración.
Cuando haya terminado de depurar su aplicación de integración, elija Detener depuración
en el menú Depurar en Visual Studio.
Deshabilitar eventos
En algunos casos, es posible que desee deshabilitar los eventos de los complementos de
Visual Studio Tools para confirmar si están provocando algún comportamiento específico en la
aplicación de Microsoft Dynamics GP. Para deshabilitar eventos, use la ventana Estado de
personalización en Microsoft Dynamics GP. Para abrir esta ventana, apunte a Personalizar en
el menú Herramientas y luego elija Estado de personalización. Seleccione el producto Microsoft
Dynamics GP y luego haga clic en Deshabilitar. Asegúrese de habilitar los eventos después de
haber completado sus pruebas.
Capítulo 12: Formas modificadas y alternativas

Para acceder a formularios modificados o alternativos desde Visual Studio Tools para Microsoft
Dynamics GP, se utiliza un proceso especial. Esta parte de la documentación describe los pasos
necesarios. La información se divide en las siguientes secciones:
• Formas modificadas
• Formas alternativas
• Directrices
formularios modificados
Los formularios modificados contienen modificaciones que se han realizado con el modificador. Para
acceder a estas modificaciones desde su proyecto Visual Studio Tools para Microsoft Dynamics GP,
complete el siguiente procedimiento:
1. Cree un ensamblado de aplicación para el diccionario de formularios.

Si el diccionario de formularios para la aplicación que se ha modificado no tiene un ensamblado
de aplicación, cree uno utilizando el proceso descrito en el Capítulo 6, "Generador de
ensamblado de diccionario". Por ejemplo, el siguiente comando crea el ensamblado de la
aplicación para el diccionario de formularios del producto principal de Dynamics GP:
dag.exe 0 "C:\Archivos de programa\Microsoft Dynamics\GP\Dynamics.set" /F /N:Dynamics
La opción /N es necesaria porque el ensamblado de la aplicación usa el nombre "Dynamics",

mientras que el nombre del producto en el archivo de inicio es "Microsoft Dynamics GP".
2. Agregue la referencia al ensamblado de la aplicación para su proyecto.

En Visual Studio, agregue la referencia al ensamblado de la aplicación. La siguiente ilustración
muestra la referencia agregada para el ensamblado de la aplicación que brinda acceso a
formularios modificados para el diccionario principal de Dynamics GP.
Esta referencia al
ensamblado de la aplicación
proporciona acceso a los
formularios modificados para la aplicación.
3. Acceder a los formularios modificados.

Se accede a los formularios modificados a través de una clase de diccionario adicional que tiene
el mismo nombre que la clase de diccionario de la aplicación, pero con la frase adicional
"Modificado". Por ejemplo, la clase de diccionario utilizada para acceder a formularios
modificados para la aplicación principal de Dynamics es:
DinámicaModificado
El siguiente código C# establece el valor de un nuevo campo en la ventana Límite de crédito del
formulario Mantenimiento del cliente. El nuevo campo es un campo local, se agrega con el
modificador y se denomina "Prueba".
DynamicsModified.Forms.RmCustomerMaintenance.RmCreditLimit.LocalTest.Value =
"Campo Modificado";
Al acceder a los recursos que están definidos en el diccionario principal de una aplicación, acceda
a ellos a través de la clase del diccionario principal, en lugar de a través de la clase "Modificada" de
la aplicación.
Formas alternativas
Los formularios alternativos son formularios del diccionario principal de Dynamics que un
desarrollador externo ha modificado y se almacenan en un diccionario de terceros. Se accede a los
recursos nuevos y modificados para el formulario alternativo a través del ensamblado de la
aplicación de la aplicación de terceros. Para acceder a formularios alternativos desde su proyecto
Visual Studio Tools para Microsoft Dynamics GP, complete el siguiente procedimiento:
1. Cree un ensamblado de aplicación para el diccionario de terceros.

Si el diccionario de terceros aún no tiene un ensamblado de aplicaciones, cree uno mediante
el proceso descrito en el Capítulo 6, "Generador de ensamblados de diccionarios". Por ejemplo,
el siguiente comando crea el ensamblaje de la aplicación para la aplicación de integración de
muestra, a la que se agregó un formulario alternativo (Mantenimiento de proveedor de PM)
para este ejemplo:
2. Agregue la referencia al ensamblado de la aplicación para su proyecto.

En Visual Studio, agregue la referencia al ensamblado de la aplicación. La siguiente ilustración
muestra la referencia agregada para el ensamblado de la aplicación que brinda acceso a los
formularios alternativos en la aplicación de la aplicación de integración de muestra.
Esta referencia a la
El ensamblaje de la aplicación proporciona
acceso a los formularios alternativos.
para la aplicación
3. Acceda a los formularios alternativos.

Se accede a formas alternativas a través de la clase de diccionario para el ensamblado que
las contiene. Por ejemplo, se accedería a las formas alternativas en la aplicación de aplicación
de integración de muestra a través de su clase de diccionario:
SampleIntegratingApp
CAPÍTULO 12 FORMAS MODIFICADAS Y ALTERNATIVAS
El siguiente código de C# establece el valor de un nuevo campo en la ventana Mantenimiento de

proveedores de la versión alternativa del formulario Mantenimiento de proveedores, que forma parte del
diccionario de la aplicación de integración de muestra. El nuevo campo es un campo local llamado "Prueba".
SampleIntegratingApp.Forms.PmVendorMaintenance.PmVendorMaintenance.
LocalTest.Value = "Campo alternativo";
Pautas
Si planea usar Visual Studio Tools para Microsoft Dynamics GP para desarrollar una integración para
distribución general, le recomendamos que limite las referencias a recursos en formas modificadas o
alternativas. Debido a la configuración de seguridad, es posible que un usuario específico no tenga
acceso a la versión modificada o alternativa de un formulario, lo que posiblemente provoque errores en
su integración. Si distribuye una integración que accede a formas modificadas o alternativas, asegúrese
de que su código maneje adecuadamente los casos en los que estos recursos no estén disponibles.
Por ejemplo, cuando establece o recupera el valor de un campo, use un bloque try...catch para encerrar
las declaraciones. Esto permite que su código detecte cualquier excepción que se genere porque no se
puede acceder al campo. El siguiente ejemplo de C# muestra cómo se puede configurar un campo en
la ventana para una versión alternativa del formulario de mantenimiento de proveedores dentro de un
bloque try...catch .
// Establecer el campo local Estado en la forma alternativa
intentar
SampleIntegratingApp.Forms.PmVendorMaintenance.PmVendorMaintenance.
LocalStatus.Value = "Preferido";
}
captura (excepción ex)

{
// El campo no era accesible. En este ejemplo, muestre un mensaje.

MessageBox.Show(ex.Mensaje);
}
Capítulo 13: Implementación del soporte de macros

Puede agregar compatibilidad con macros para los formularios que cree con Visual Studio Tools.
La información sobre cómo hacer esto se encuentra en las siguientes secciones:
• Descripción general de la compatibilidad

con macros • Grabación de
macros • Reproducción
de macros • Manejo de procesos asincrónicos durante la reproducción
Descripción general del soporte de macros
En Visual Studio Tools, los formularios que crea que heredan de DexUIForm se pueden integrar en
el sistema de macros en Microsoft Dynamics GP. El soporte para el sistema de macros no es
automático. Para admitir el sistema de macros, hará lo siguiente:
• Debe agregar llamadas al método RecordMacroItem() en los lugares apropiados en su

complemento Visual Studio Tools para registrar comandos de macro para su formulario.
• Debe anular el método PlayMacroItem() en la clase base DexUIForm y agregar código para admitir
la reproducción de sus comandos de macro.
• Si su formulario de Visual Studio Tools realiza llamadas asincrónicas a otros procesos que el
sistema de macros deberá esperar, deberá anular el método IsAsynchEventPending() .
Grabación de macros
En su formulario de Visual Studio Tools, identifique los lugares en los que el usuario puede realizar
acciones. Las acciones incluyen cosas como hacer clic en botones, agregar texto a campos de texto
o mover el foco. En los eventos que se ejecutan debido a estas acciones del usuario, agregará
código que llame al método RecordMacroItem() para registrar una cadena de texto y un comentario
opcional que identifique y describa la acción. Por ejemplo, el siguiente código C# registra un
comando de macro para la casilla de verificación Energy Star:
RecordMacroItem("ClickHit EnergyStar", "Alternar la casilla de verificación Energy Star");
Las cadenas de texto que se pasan al método RecordMacroItem() se escriben en la macro como
instrucciones de macro ShellCommand .
ShellCommand 'ClickHit EnergyStar' # Alternar la casilla de verificación Energy Star
El método RecordMacroItem() registra valores solo cuando se está grabando una macro.
Sintaxis de la macro La
cadena de texto y el comentario opcional grabados en la macro son la única información disponible
para el complemento de Visual Studio Tools cuando se reproduce la macro. Estas cadenas de texto
deben contener suficiente información para que su código determine la acción que se debe realizar.
No hay una sintaxis predefinida para las cadenas de texto registradas. Debe definir las cadenas de
texto para que su complemento pueda analizarlas y, luego, el complemento pueda realizar las
acciones indicadas. La compatibilidad con macros en el ejemplo de Environmental Details Visual
Studio Tools es un buen punto de partida. La sintaxis de sus declaraciones de macro es similar al
lenguaje de macros estándar de Microsoft Dynamics GP.
Ubicación El lugar
donde coloca las llamadas RecordMacroItem() en su código puede afectar la forma en que se
escriben los datos en la macro. Es posible que se requiera algo de experimentación para encontrar
qué evento de un control es más apropiado para registrar una acción de macro. Por ejemplo, al
grabar el texto ingresado en un control de cuadro de texto, el evento Validating es el lugar más
apropiado para la llamada RecordMacroItem() . El siguiente ejemplo de C# muestra el evento
Validating para el cuadro de texto YearlyEnergyCost en el ejemplo Environmental Details.
privado void textBoxYearlyEnergyCost_Validating(objeto remitente,

Cancelar argumentos de eventos e)
// Establezca el indicador de cambio para la ventana de mantenimiento de artículos

GPAddIn.ItemMaintenanceWindow.IsChanged = verdadero;
// Si se está grabando una macro, registre el valor.

RecordMacroItem("TypeToAnualEnergyCost \"" +
textBoxYearlyEnergyCost.Text + "\"", String.Empty);
}
La siguiente tabla enumera el evento en el que se debe colocar el código de grabación de macro
para los controles comunes.
Control Evento
Caja de texto Validando
Presionar el botón Hacer clic
casilla de verificación Validando
Reproducción de macros
Cuando se reproduce una instrucción de macro ShellCommand y su formulario de Visual Studio

Tools está activo, se llamará al método PlayMacroItem() . Debe anular este método en el código del
complemento de Visual Studio Tools y procesar las declaraciones de macro para su formulario. El
siguiente ejemplo de C# muestra cómo invalida el método base.
invalidación pública void PlayMacroItem (MacroPlaybackEventArgs e)

{
Argumentos de evento
Los siguientes argumentos de evento se pasan al método PlayMacroItem() :
Manejado Este es un parámetro booleano que indica si se ha realizado la acción para la declaración
de macro. Debe verificar el valor de este parámetro al comienzo de su método PlayMacroItem() . Si
su valor es verdadero, la declaración de macro ya se ha manejado, por lo que su código no debería
realizar ninguna acción. Si determina que su código debe realizar la acción para la declaración de
macro, establezca el parámetro Handled en verdadero cuando se complete la acción. Esto le dice a
otro código que la instrucción macro ya ha sido procesada.
MacroText Este parámetro de cadena contiene la cadena de macro que fue escrita por el método
RecordMacroItem() cuando se grabó la macro. Necesitará analizar esta cadena para determinar si
su complemento debe realizar la acción de macro.
CAPÍTULO 13 IMPLEMENTACIÓN DEL SOPORTE DE MACRO
MacroComment Este parámetro de cadena contiene el comentario escrito por el

método RecordMacroItem() cuando se grabó la macro.
Procesamiento de instrucciones de macro El

código recuperará el parámetro MacroText de los argumentos del evento y luego
analizará el texto para determinar si su complemento debe realizar esta instrucción
de macro. Puede usar cualquier enfoque que desee al analizar la declaración de
macro. El ejemplo de detalles ambientales utiliza expresiones regulares para analizar
la declaración de macro. El siguiente ejemplo de C# muestra el método PlayMacroItem()
completo para la muestra. Tenga en cuenta que si el código realiza la acción de
macro, establece el parámetro Handled en verdadero. Si no realiza la acción, permite
que la clase base lo haga.
invalidación pública void PlayMacroItem (MacroPlaybackEventArgs e)
Partido m;
si (e. Manejado == falso)
// Procesar el cuadro de texto Costo anual de energía
m = Regex.Match(e.MacroText, "TypeTo YearlyEnergyCost \"(.+)\"");
si (m.Éxito)
si (m.Grupos.Cuenta >= 2)
textBoxYearlyEnergyCost.Focus();
textBoxYearlyEnergyCost.Text = m.Groups[1].Value;
e.Manejado = verdadero;
// cuadro de texto Notas del proceso
m = Regex.Match(e.MacroText, "TypeTo EnvNotes \"(.+)\"");
si (m.Éxito)
NotasCuadroTexto.Focus();
textBoxNotes.Text = m.Grupos[1].Valor;
// Procesar los pulsadores y casillas de verificación
m = Regex.Match(e.MacroText, "ClickHit (\\w+)");
si (m.Éxito)
// Casilla de verificación Energy Star
if (m.Grupos[1].Valor == "EnergyStar")
checkBoxEnergyStar.Focus();
checkBoxEnergyStar.Checked = !checkBoxEnergyStar.Checked;
// Casilla de verificación Reciclable

if (m.Grupos[1].Valor == "Reciclable")
{
checkBoxReciclable.Focus();
checkBoxRecyclable.Checked = !checkBoxReciclable.Checked;
}
// boton cerrar
if (m.Grupos[1].Valor == "BotónCerrar")
{
botónCerrar.Focus();
botónCerrar.PerformClick();
}
}
}
}
// El comando macro no era nuestro, así que deja que la clase base lo procese.
base.PlayMacroItem(e);
}
Manejo de procesos asincrónicos durante la reproducción

Si su formulario de Visual Studio Tools realiza llamadas asincrónicas a otros procesos que el
sistema de macros deberá esperar, es posible que deba anular el método IsAsynchEventPending()
de la clase base DexUIForm. Este método se llama periódicamente cuando se reproduce una
macro. Si el método devuelve verdadero, el sistema de macros esperará a que finalice el evento
asíncrono antes de que se procesen instrucciones de macro adicionales.
Invalide el método IsAsynchEventPending() solo si su complemento de Visual Studio Tools tiene

procesos asincrónicos que el sistema de macros debe esperar.
El siguiente ejemplo de C# muestra cómo invalida el método de la clase base.

Por lo general, creará su propia marca que rastrea si su complemento está ejecutando un
proceso asíncrono. En el método IsAsynchEventPending() , devolverá el valor de este indicador.
Cuando comience el proceso asíncrono, establecerá el indicador en verdadero. Esto hace que
el sistema de macros espere el evento asíncrono. Cuando finalice el proceso asincrónico,
establecerá el indicador en falso. Esto permitirá que el sistema de macros reanude el
procesamiento.
anulación pública bool IsAsyncEventPending

{
conseguir
// Devuelve el valor de la bandera que indica si un

// se está procesando un evento asíncrono.
devuelve InAsyncEventFlag;
}
}
Capítulo 14: Uso de búsquedas

Las búsquedas son ventanas con fines especiales que se utilizan para recuperar valores de ID existentes para
objetos en Microsoft Dynamics GP, como clientes, proveedores y documentos de ventas. Es posible que deba
recuperar los valores de ID para su integración con Visual Studio Tools. En muchos casos, puede usar las búsquedas
definidas en Microsoft Dynamics GP para recuperar valores de ID para campos en su formulario de Visual Studio
Tools. La información sobre el uso de búsquedas se divide en las siguientes secciones:
• Cómo funcionan las

búsquedas • Búsquedas
disponibles • Ejemplo de búsqueda
Cómo funcionan las búsquedas
Las ventanas de búsqueda en Microsoft Dynamics GP son formularios separados. El diccionario principal de
Dynamics contiene búsquedas con funciones de búsqueda básicas. Las ventanas de búsqueda que ve el usuario
en Microsoft Dynamics GP son en realidad versiones alternativas de los formularios y están definidas en el
diccionario SmartList. Esto significa que su código de Visual Studio Tools hará referencia a las búsquedas del
diccionario SmartList.
Los siguientes pasos describen el funcionamiento básico de una búsqueda de Visual Studio
Integración de herramientas:
1. Agregue código para rastrear que su integración ha abierto la búsqueda.

La aplicación principal de Microsoft Dynamics GP y otros productos de integración pueden abrir formularios de
búsqueda. Su integración de Visual Studio Tools debe realizar un seguimiento de que ha abierto la búsqueda,
por lo que sabrá recuperar el valor que seleccionó el usuario.
Normalmente, cada búsqueda utilizada por una integración de Visual Studio Tools se rastrea mediante una
variable estática definida en la clase GPAddIn. La variable debe establecerse cuando se abre la búsqueda y
borrarse cuando la búsqueda devuelve un valor.
2. Agregue código para abrir el formulario de búsqueda.

Normalmente, el usuario hace clic en un botón de búsqueda que abre el formulario de búsqueda. En su
formulario de Visual Studio Tools, agregará código al botón de búsqueda que abrirá el formulario de búsqueda.
3. Registre el evento ClickBeforeOriginal para el botón Seleccionar.

Se devuelve un valor de la búsqueda cuando el usuario hace clic en el botón Seleccionar en el formulario de
búsqueda. Registrará el evento ClickBeforeOriginal en el botón Seleccionar para recibir una notificación
cuando se haga clic en el botón.
4. Devuelve el ID del artículo seleccionado.
Cuando el usuario hace clic en el botón Seleccionar en la búsqueda, el controlador de eventos devuelve el
identificador del elemento seleccionado para el evento ClickBeforeOriginal. Este controlador de eventos
también borra la variable estática que rastrea que la integración de Visual Studio Tools abrió la búsqueda.
Búsquedas disponibles
Se han utilizado varios patrones diferentes para codificar los formularios de búsqueda en Microsoft Dynamics
GP. Cada patrón requiere una técnica específica para usar la búsqueda. Para saber qué búsquedas están
disponibles y cómo llamarlas, consulte el documento titulado "Llamada de formularios de búsqueda desde
Dexterity" en el SDK de Microsoft Dynamics GP. El vínculo de este documento se encuentra en el grupo
Fundamentos de la sección Procedimientos y funciones del archivo de ayuda del SDK de Microsoft Dynamics
GP.
El ejemplo de búsquedas, descrito en el Capítulo 29, "Búsquedas", demuestra cómo usar varios formularios
de búsqueda comunes en una integración de Visual Studio Tools.
En algunos casos, Visual Studio Tools no puede acceder a todos los recursos necesarios para usar el
formulario de búsqueda. Por ejemplo, algunos formularios de búsqueda se abren llamando a procedimientos
que tienen parámetros de referencia. Dado que Visual Studio Tools no puede llamar a procedimientos con
parámetros de referencia, estos formularios de búsqueda no se pueden usar con integraciones de Visual
Studio Tools.
ejemplo de búsqueda
El siguiente ejemplo muestra cómo usar el formulario de búsqueda Clientes y prospectos en Microsoft
Dynamics GP para recuperar números de clientes para una integración de Visual Studio Tools.
1. Agregue una referencia al ensamblado de la aplicación SmartList.

La búsqueda de Clientes y posibles clientes es una de las búsquedas mejoradas para Microsoft
Dynamics GP que se encuentran en el diccionario SmartList.
2. Agregue un botón de búsqueda al formulario de herramientas de Visual Studio.

Consulte Agregar controles en la página 27 para obtener detalles sobre cómo agregar un control a un
formulario de Visual Studio Tools.
3. Agregue el indicador para rastrear que se abrió una búsqueda.

En la clase GPAddIn, agregue una variable estática para rastrear que se abrió una búsqueda.
El siguiente ejemplo de C# muestra código que hace esto.
// Marca para rastrear que se abrió una búsqueda

ReturnToLookup booleano estático público = falso;
4. Agregue código para abrir el formulario de búsqueda.

En el evento Click para el botón Buscar, agregue el código que abre la búsqueda. Las acciones que
debe realizar este código dependerán de la búsqueda que esté utilizando. Consulte el documento
"Llamar formularios de búsqueda de Dexterity" en el SDK de Microsoft Dynamics GP para obtener
información sobre las búsquedas disponibles. Para la búsqueda de Clientes y Prospectos se deben
realizar las siguientes acciones:
• Se establece el indicador que indica que la integración de Visual Studio Tools abrió la búsqueda.
• El formulario CustomerLookup debe estar abierto.
• Se debe llamar al procedimiento Initialize en el formulario CustomerLookup. Esto configura cómo se

muestran los datos en la búsqueda.
CAPÍTULO 14 USO DE BUSQUEDAS
El siguiente ejemplo de C# muestra cómo se abre la búsqueda de Clientes.
privado vacío CustomerLookup_Click (remitente del objeto, EventArgs e)

{
// Crear una referencia al formulario CustomerLookup

Microsoft.Dexterity.Applications.SmartListDictionary.
CustomerLookupForm customerLookup = SmartList.Forms.CustomerLookup;
// Establecer la bandera que indica que abrimos la búsqueda

GPAddIn.ReturnToLookup = verdadero;
// Abre el formulario de búsqueda de clientes

búsquedacliente.Open();
// Llame al procedimiento de inicialización para configurar la búsqueda de clientes

customerLookup.Procedures.Initialize.Invoke(1, 0,
NúmeroCliente.Texto, "", "", "", "", "");
}
5. Registre el evento ClickBeforeOriginal para el botón Seleccionar.

En el método Initialize de la clase GPAddIn, registre el evento ClickBeforeOriginal del
botón Seleccionar en la ventana CustomerLookup. El siguiente ejemplo de C#
muestra este registro.
// Botón Seleccionar en la ventana de búsqueda de Clientes

Microsoft.Dexterity.Applications.SmartListDictionary.CustomerLookupForm
CustomerLookupForm = SmartList.Forms.CustomerLookup;
formulario de búsqueda de cliente. Búsqueda de cliente. Botón de selección. Haga clic antes del original +=
nuevo System.ComponentModel.CancelEventHandler(
SelectButton_ClickBeforeOriginal);
6. Devuelve el ID del artículo seleccionado.

En el controlador de eventos para el evento ClickBeforeOriginal del botón Seleccionar,
marque la marca que indica si el complemento Visual Studio Tools abrió la búsqueda.
Si lo hizo, devuelva el número de cliente para el cliente seleccionado en la ventana
de desplazamiento de la búsqueda de Clientes y prospectos. El siguiente ejemplo de
C# muestra el controlador de eventos que realiza estas acciones.
void SelectButton_ClickBeforeOriginal(objeto remitente,

System.ComponentModel.CancelEventArgs e)
{
// Ejecute este código solo si el complemento abrió la búsqueda.

si (GPAddIn.ReturnToLookup == verdadero)
{
// Recuperar el número de cliente de la fila seleccionada en el
// ventana de desplazamiento de la búsqueda de Clientes.

Microsoft.Dexterity.Applications.SmartListDictionary.
Formulario de búsqueda de clientes Formulario de búsqueda de clientes =
SmartList.Forms.CustomerLookup;
string númeroCliente = Formulario de Búsqueda de Cliente. Búsqueda de Cliente.
CustomerLookupScroll.CustomerNumber.Value;
// Mostrar el valor recuperado

LookupsWindow.CustomerNumber.Text = customerNumber;
// Borra la bandera que indica que se va a recuperar un valor

// la búsqueda.
GPAddIn.ReturnToLookup = falso;
}
}
RE
DE
RE
PA
3:
Parte 3: Referencia de recursos

Esta parte de la documentación proporciona información detallada sobre cada tipo de recurso al que puede acceder
con Visual Studio Tools para Microsoft Dynamics GP. Cada recurso tiene lo siguiente:
• Información sobre el acceso al recurso • Una lista de métodos

• Una lista de propiedades •
Una lista de eventos
Se discuten los siguientes recursos:
• El Capítulo 15, “Formularios”, describe los recursos de formulario.
• El Capítulo 16, “Windows”, describe los recursos de las ventanas.
• El Capítulo 17, “Desplazamiento de ventanas”, describe los recursos de las ventanas de desplazamiento.
• El Capítulo 18, “Campos de ventana”, describe los recursos de campo de ventana.
• El Capítulo 19, “Tablas”, describe los recursos de las tablas.
• El Capítulo 20, “Campos de tabla”, describe los recursos de campo de tabla.
• El Capítulo 21, “Comandos”, describe los recursos de comando.
• El Capítulo 22, “Globales”, describe los recursos variables globales.
• El Capítulo 23, “Procedimientos”, describe los recursos de los procedimientos.
• El Capítulo 24, “Funciones”, describe los recursos de funciones.
• El Capítulo 25, “Compuestos”, describe los recursos compuestos.
Capítulo 15: Formularios

Los formularios son el recurso básico de la aplicación Microsoft Dynamics GP. Proporcionan la organización
de la interfaz presentada al usuario. Se discuten los siguientes elementos para los formularios:
• Acceder a formularios •
Métodos de formulario •
Propiedades de formulario
• Eventos de formulario
Acceso a formularios
Se accede a los formularios de un diccionario de aplicación a través de la clase de diccionario. Esta clase
tiene una propiedad Forms que brinda acceso a la colección de formularios en el diccionario. La clase de
diccionario para el diccionario de la aplicación se encuentra en el siguiente espacio de nombres:
Por ejemplo, para acceder a la colección de formularios en el diccionario de Dynamics, use la siguiente
sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Forms
Para acceder a un formulario específico, como el formulario de Entrada de transacción de ventas

(SopEntry), use la siguiente sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Forms.SopEntry
Métodos de formulario
Los formularios proporcionan los siguientes métodos:
• AddMenuHandler() • Cerrar()
• Dispose() •
Abrir()
AñadirManejadorDeMenú()
El método AddMenuHandler() agrega un elemento de menú al menú "Adicional" que aparece en las
ventanas de Microsoft Dynamics GP. El elemento del menú estará disponible cuando el formulario esté
abierto. Este método toma tres parámetros:
EventHandler : la función que se ejecutará cuando se elija el elemento del menú en Microsoft Dynamics
GP.
MenuItemName : una cadena que contiene el texto que se mostrará para el elemento del menú.
AcceleratorKey : una cadena que contiene un solo carácter que se utilizará como tecla aceleradora para el
elemento del menú. Asegúrese de que esta tecla aceleradora no entre en conflicto con ninguna tecla
aceleradora existente. Si no desea una tecla aceleradora, use la cadena vacía.
PARTE 3 REFERENCIA DE RECURSOS
El siguiente ejemplo de C# muestra cómo se agrega un controlador de menú para el elemento de menú "Estimar
flete" al formulario SopEntry en Microsoft Dynamics GP:
Dynamics.Forms.SOPEntry.AddMenuHandler(OpenEstimateFreight,
"Estimar Flete", "F");
Este código es el controlador de eventos para el elemento del menú. Tenga en cuenta que toma dos argumentos
como controladores de eventos estándar.
static void OpenEstimateFreight (remitente del objeto, EventArgs e)

{
if (EstimateFreightForm == nulo)
{
CalcularFreightForm = new CalcularFreight();

}
demás
if (EstimateFreightForm.Created == false)
{
CalcularFreightForm = new CalcularFreight();

}
}
// Mostrar y activar siempre el WinForm

EstimarFormularioFrente.Mostrar();
CalcularFormularioFreight.Activate();
}
}
El siguiente ejemplo de Visual Basic muestra cómo se agrega el mismo controlador de menú para el elemento de
menú "Estimar flete" al formulario SopEntry en Microsoft Dynamics GP.
Dim estimar FreightHandler como System.EventHandler
EstimarFreightHandler = New System.EventHandler(AddressOf

OpenEstimateFreight)
Dynamics.Forms.SOPEntry.AddMenuHandler(EstimateFreightHandler, "Estimate
Flete", "F")
Este código es el controlador de eventos para el elemento de menú. Tenga en cuenta que también toma dos
argumentos como controladores de eventos estándar.
Shared Sub OpenEstimateFreight (ByVal remitente como objeto, ByVal y como EventArgs)
Si el formulario de flete estimado no es nada, entonces
Intentar
CalcularFreightForm = Nuevo CalcularFreightForm()

Captura ex como excepción
MessageBox.Show (por ejemplo, Mensaje)
Finalizar intento
Demás
Si CalcularFreightForm.Created = False Entonces

CalcularFreightForm = Nuevo CalcularFreightForm()
Terminara si
Terminara si
CAPÍTULO 15 FORMAS
' Mostrar y activar siempre el WinForm

CalcularFormularioFrente.Mostrar()
EstimarFormularioFrente.Activar()
Finalizar sub
Cerca()
El método Close() cierra el formulario.
Disponer()
El método Dispose() libera la memoria utilizada para el formulario cuando ya no se necesita.
Abierto()
El método Open() intenta abrir el formulario.
Propiedades de formulario
Los formularios proporcionan las siguientes propiedades:
• Comandos •
Funciones •
IsOpen •
IsChanged •
Procedimientos
Comandos La propiedad
Comandos proporciona acceso a la lista de comandos definidos por el formulario. Consulte el Capítulo 21,
"Comandos", para obtener más información sobre el uso de comandos en su aplicación.
Funciones La
propiedad Funciones proporciona acceso a la lista de funciones de nivel de formulario definidas por el
formulario. Consulte el Capítulo 24, “Funciones”, para obtener más información acerca de las funciones.
IsChanged La
propiedad IsChanged tiene el valor verdadero si el indicador de cambio para el formulario está establecido
y falso si no lo está. El indicador de cambio se establece automáticamente en verdadero cuando cambia
cualquier valor de campo del formulario.
IsOpen La
propiedad IsOpen tiene el valor verdadero si el formulario está abierto y falso si no lo está.
Procedimientos La
propiedad Procedimientos proporciona acceso a la lista de procedimientos de nivel de formulario definidos
por el formulario. Consulte el Capítulo 23, "Procedimientos", para obtener más información sobre el uso de
procedimientos.
Tablas La
propiedad Tablas proporciona acceso a la lista de tablas que se adjuntan al formulario. Consulte el Capítulo
9, "Trabajar con tablas", y el Capítulo 19, "Tablas", para obtener más información sobre el uso de las tablas
adjuntas a los formularios.
Eventos de formulario
Los formularios proporcionan los siguientes eventos:
• Abrir antes del original • Abrir

después del original • Cerrar antes
del original • Cerrar después del
original
OpenBeforeOriginal Este evento

ocurre cuando se abre el formulario, pero antes de que se ejecute el evento de apertura del formulario.
Este evento puede ser cancelado.
OpenAfterOriginal Este evento ocurre

cuando se abre el formulario, pero después de que se ejecuta el evento de apertura del formulario.
CerrarAntesOriginal
Este evento ocurre cuando se cierra el formulario, antes de que se ejecute el evento de cierre del formulario. Este evento
puede ser cancelado.
CerrarDespuésOriginal
Este evento ocurre cuando se cierra el formulario, después de ejecutar el evento de cierre del formulario.
Capítulo 16: Ventanas

Windows es una parte del formulario en Microsoft Dynamics GP. Muestran la interfaz de usuario de la
aplicación. Se discuten los siguientes elementos:
• Acceso a ventanas •
Métodos de ventana •
Propiedades de ventana •
Eventos de ventana
Acceso a ventanas
Se accede a las ventanas de un diccionario de aplicación como propiedades del formulario en el que
están contenidas. Por ejemplo, la ventana Entrada de transacción de ventas (SopEntry) es parte del
formulario SopEntry. Para acceder a él, usaría la siguiente sintaxis:
Dinámica.Formas.SopEntry.SopEntry
IntelliSense en Visual Studio le indicará a qué formulario y ventana de Microsoft Dynamics GP hace
referencia la expresión.
Métodos de ventana
Windows proporciona los siguientes métodos:
• Cerrar() •
Abrir() •
PullFocus()
Cerca()
El método Close() cierra la ventana.
Abierto()
El método Open() intenta abrir la ventana.
Foco de extracción ()
El método PullFocus() eliminará el foco de la ventana actual. No se enfocará ningún elemento en la
ventana. Se ejecutarán todos los eventos de "validación" o "salida" pendientes para el campo actualmente
enfocado. Utilice este método en situaciones en las que desea que se ejecuten todas las acciones
pendientes antes de que su aplicación de integración realice su procesamiento.
Propiedades de la ventana
Windows proporciona las siguientes propiedades:
• EstáCambiado •
EstáAbierto
IsChanged La
propiedad IsChanged tiene el valor verdadero si el indicador de cambio para el formulario está establecido
y falso si no lo está. El indicador de cambio se establece automáticamente en verdadero cuando cambia
cualquier valor de campo de la ventana.
IsOpen La
propiedad IsOpen tiene el valor verdadero si la ventana está abierta y falso si no lo está.
Eventos de ventana
Windows proporciona los siguientes eventos:
• Abrir antes del original • Abrir

después del original • Activar
antes del original • Activar después
del original • Cerrar antes del
original • Cerrar después del
original • Imprimir antes del
original • Imprimir después del
original • BeforeModalDialog
• AfterModalDialog
OpenBeforeOriginal Este evento

ocurre cuando se abre la ventana, pero antes de que se ejecute el evento de apertura de la
ventana. Este evento puede ser cancelado.
AbrirDespuésOriginal
Este evento ocurre cuando se abre la ventana, pero después de que el evento de apertura de la ventana es
correr.
Activar antes del original

Este evento ocurre cada vez que la ventana se activa, antes de que se ejecute el evento de activación de
la ventana. El evento de activación ocurre cada vez que el usuario abre o trae la ventana al frente. Ocurre
después del evento Open.
El evento Activar debe usarse con precaución. No debería realizar ninguna acción que pueda hacer que
aparezcan cuadros de diálogo porque la aplicación puede suspenderse en un bucle sin fin.
ActivarDespuésOriginal
Este evento ocurre cada vez que la ventana se activa, después de que se ejecuta el evento de activación
de la ventana.
CerrarAntesOriginal
Este evento ocurre cuando se cierra la ventana, pero antes de que se ejecute el evento de cierre de la
ventana. Este evento puede ser cancelado.
CerrarDespuésOriginal
Este evento ocurre cuando la ventana está cerrada, pero después de que se cierra el evento de la ventana.
correr.
PrintBeforeOriginal Este evento

ocurre cuando se elige la acción de impresión para la ventana, pero antes de que se ejecute el
evento de impresión de la ventana. La acción de imprimir para una ventana ocurre cuando el
usuario elige el elemento del menú Imprimir en el menú Archivo o hace clic en el botón Imprimir
en la ventana. Este evento puede ser cancelado.
PrintAfterOriginal Este evento

ocurre cuando se elige la acción de impresión para la ventana, pero después de ejecutar el
evento de impresión de la ventana.
CAPÍTULO 16 VENTANAS
BeforeModalDialog Este evento

ocurre cuando una ventana muestra un cuadro de diálogo modal, pero antes de que el
cuadro de diálogo se muestre realmente al usuario. Los argumentos del evento permiten
acceder a las propiedades del diálogo modal:
DialogType Indica el tipo de diálogo modal que se muestra. La enumeración DialogType define
los siguientes tipos disponibles:
Tipo Descripción
Preguntar Un cuadro de diálogo modal generado por los comandos de script de error,
advertencia o ask() .
ObtenerCadena Un diálogo modal generado por el comando getstring() .
Mensaje Contiene el texto que se muestra en el cuadro de diálogo modal. Establecer el valor
de esta propiedad en el evento BeforeModalDialog le permite cambiar el texto que se muestra
en el cuadro de diálogo modal. Normalmente, el valor de este parámetro se examina para
averiguar qué mensaje se mostrará al usuario.
Button1Text Contiene el texto que se muestra en el botón 1 del cuadro de diálogo modal.
Establecer el valor de esta propiedad en el evento BeforeModalDialog le permite cambiar el
texto que se muestra en el botón.
texto que se muestra en el botón.
Para los cuadros de diálogo getstring() , esta es la cadena editable en el cuadro de diálogo.
texto que se muestra en el botón o el campo editable.
Respuesta Indica la respuesta al diálogo modal. La enumeración DialogResponse define las

respuestas disponibles:
Tipo de respuesta Descripción

Botón 1 Se hace clic en el botón 1 en el cuadro de diálogo modal.
Botón2 Se hace clic en el botón 2 en el cuadro de diálogo modal.
Botón3 Se hace clic en el botón 3 en el cuadro de diálogo modal.
De acuerdo
Se hace clic en el botón Aceptar del cuadro de diálogo modal getstring() .
Cancelar Se hace clic en el botón Cancelar del cuadro de diálogo modal getstring() .
Ninguno No hubo respuesta.
Establecer esta propiedad en el evento BeforeModalDialog permite que su código responda al

cuadro de diálogo y evita que el cuadro de diálogo se muestre al usuario. Establecer la
respuesta en Ninguno permitirá que se muestre el cuadro de diálogo.
El siguiente ejemplo de Visual Basic crea referencias al formulario y la ventana Entrada de

transacciones de ventas y luego registra un evento BeforeModalDialog para la ventana Entrada
de transacciones de ventas.
' Crear una referencia al formulario de Entrada de Transición de Ventas

SOPEntryForm compartido como SopEntryForm = Dynamics.Forms.SopEntry
' Crear una referencia a la ventana Entrada de transacciones de ventas

SOPEntryWindow compartida como SopEntryForm.SopEntryWindow = SOPEntryForm.SopEntry
Sub Initialize() implementa IDexterityAddin.Initialize
AddHandler SOEntryWindow.BeforeModalDialog, DirecciónDe _

SopEntryWindow_BeforeModalDialog
Finalizar sub
El siguiente ejemplo es el controlador de eventos BeforeModalDialog para el evento registrado

en el ejemplo anterior. Cuando se va a mostrar un cuadro de diálogo modal, el código
examina el texto del mensaje para determinar si es el mensaje que le pregunta al usuario si
desea agregar un nuevo cliente o un nuevo prospecto. Si es así, el parámetro Respuesta de
los argumentos del evento se establece en Botón1, lo que indica que se debe crear un nuevo
cliente. Esto evita que se muestre el cuadro de diálogo modal.
Sub privado SopEntryWindow_BeforeModalDialog(ByVal remitente As Object, ByVal e

Como AntesModalDialogEventArgs)
' Examine el cuadro de diálogo para determinar si es el que debe responder.

Si e.DialogType = DialogType.Ask Entonces
Si e.Message.Contains("quiero agregar un cliente") Entonces
'Haga clic en el botón Cliente en el cuadro de diálogo modal
e.Respuesta = DialogResponse.Button1
Terminara si
Terminara si
Finalizar sub
AfterModalDialog Este evento

ocurre cuando el usuario ha actuado en un diálogo modal mostrado por una ventana. Este
evento le permite recuperar la elección que el usuario hizo en el cuadro de diálogo modal.
Por lo general, examinará las propiedades DialogType y Message en los argumentos del
evento para averiguar qué diálogo se muestra. Luego puede examinar la propiedad Respuesta
en los argumentos del evento para saber cómo respondió el usuario al cuadro de diálogo.
El siguiente ejemplo de C# crea referencias al formulario Mantenimiento de artículos y la

ventana Mantenimiento de artículos, y luego se registra para el evento AfterModalDialog para
la ventana Mantenimiento de artículos.
// Crear una referencia al formulario de Mantenimiento de artículos
public static IvItemMaintenanceForm ItemMaintenanceForm =

Dynamics.Forms.IvItemMaintenance;
// Crear una referencia a la ventana de Mantenimiento de Artículos
public static IvItemMaintenanceForm.IvItemMaintenanceWindow

ItemMaintenanceWindow = ItemMaintenanceForm.IvItemMaintenance;

{
ItemMaintenanceForm.IvItemMaintenance.AfterModalDialog +=
nuevo controlador de eventos<AfterModalDialogEventArgs>
(IvItemMaintenance_AfterModalDialog);
}
CAPÍTULO 16 VENTANAS
El siguiente ejemplo de C# es el controlador de eventos AfterModalDialog para el evento

registrado en el ejemplo anterior. Cuando se va a mostrar un cuadro de diálogo modal, el
código examina el texto del mensaje para determinar si es el mensaje que pregunta al
usuario si desea eliminar el elemento actual. Se examina la propiedad Respuesta de los
argumentos del evento para averiguar si el usuario hizo clic en Eliminar en el cuadro de
diálogo modal. Si el usuario lo hizo, también se elimina la información adicional
almacenada para el elemento.
void IvItemMaintenance_AfterModalDialog(remitente del objeto,

AfterModalDialogEventArgs e)
{
// ¿Es un diálogo de 'preguntar'?

si (e.DialogType == DialogType.Ask)
{
// ¿Está verificando una acción de eliminación?

if (e.Message.Contains("quiero borrar"))
{
// ¿El usuario hizo clic en Eliminar (botón 1)?
if (e.Response == DialogResponse.Button1)
{
// Eliminar los detalles ambientales del elemento actual.
DataAccessHelper.DeleteEnvironmentalDetails();
}
}
}
}
Capítulo 17: Desplazamiento de ventanas

Las ventanas de desplazamiento son un tipo especial de ventana en Microsoft Dynamics GP que se utilizan para mostrar
o acceder a datos directamente desde una tabla de base de datos. Se discuten los siguientes elementos:
• Acceso a ventanas de desplazamiento •

Métodos de ventana de desplazamiento •
Propiedades de ventana de desplazamiento
• Eventos de ventana de desplazamiento
Acceder a las ventanas de desplazamiento
Se accede a las ventanas de desplazamiento de un diccionario de aplicación como propiedades de la ventana en la que
están contenidas. Por ejemplo, se accede a la ventana de desplazamiento de desplazamiento de línea en la ventana
Entrada de transacción de ventas de Microsoft Dynamics GP mediante la siguiente sintaxis:
Dynamics.Forms.SopEntry.SopEntry.LineScroll
IntelliSense en Visual Studio le dirá a qué ventana de desplazamiento en Microsoft Dynamics GP se refiere la expresión.
Métodos de ventana de desplazamiento
No hay métodos adicionales para desplazarse por las ventanas.
Propiedades de la ventana de desplazamiento
No hay propiedades adicionales para las ventanas de desplazamiento.
Eventos de ventana de desplazamiento
Las ventanas de desplazamiento proporcionan los siguientes eventos:
• Llenar línea antes del original • Llenar

línea después del original • Introducir
línea antes del original • Introducir línea
después del original • Cambiar línea
antes del original • Cambiar línea después del
original • Salir línea antes del original • Salir
línea después del original • Insertar línea
antes del original • Insertar línea después
del original • Eliminar línea antes del
original • Eliminar línea después del
original
LineFillBeforeOriginal Este evento ocurre antes del

evento de relleno de línea para la ventana de desplazamiento. El evento de relleno de línea ocurre cada vez que se
agrega una nueva línea a la ventana de desplazamiento desde la tabla vinculada, como cuando el usuario se desplaza
a una nueva línea. Cuando la ventana de desplazamiento se llena por primera vez, el evento de llenado de línea ocurre
repetidamente hasta que la ventana de desplazamiento está llena. El evento de relleno de línea también ocurre cada
vez que el usuario mueve el foco a una línea existente en la ventana de desplazamiento. El evento de relleno de línea
ocurre antes que el evento de ingreso de línea.
Para averiguar qué datos se agregarán a la fila actual de la ventana de desplazamiento, examine la fila
actual del búfer de tabla de nivel de formulario para la tabla vinculada a la ventana de desplazamiento.
Al usar este evento, no puede examinar los campos de la ventana de desplazamiento para determinar
qué fila se está agregando. Los valores de los campos de la ventana aún no se habrán establecido.
El evento LineFillBeforeOriginal se puede cancelar. Si se cancela el evento, la fila actual de la tabla

vinculada a la ventana de desplazamiento no se agregará a la ventana de desplazamiento.
Por ejemplo, el siguiente código C# registra el evento LineFillBeforeOriginal para la ventana de

desplazamiento en la ventana Clientes y clientes potenciales en Microsoft Dynamics GP.

{
Dynamics.Forms.CustomerLookup.CustomerLookup.CustomerLookupScroll.
LineFillBeforeOriginal += nuevo System.ComponentModel.CancelEventHandler
(CustomerLookupScroll_LineFillBeforeOriginal);
}
El siguiente es el código C# que se ejecuta en respuesta a este evento. Permite visualizar únicamente
los clientes del territorio de venta “TERRITORIO 2”. La tabla RmCustomerMstr está vinculada a la
ventana de desplazamiento, por lo que los valores de la ventana de desplazamiento provienen de esta
tabla. Observe cómo el código accede a la fila actual del búfer de tabla de nivel de formulario para la
tabla RmCustomerMstr para averiguar qué fila se agrega a la ventana de desplazamiento. Se examina el
campo SalesTerritory en la fila actual de la tabla. Si no es “TERRITORIO 2”, el evento se cancela. Esto
evita que la fila se muestre en la ventana de desplazamiento.
void CustomerLookupScroll_LineFillBeforeOriginal(objeto remitente,

System.ComponentModel.CancelEventArgs e)
{
if(Dynamics.Forms.CustomerLookup.Tables.RmCustomerMstr.SalesTerritory.
Valor != "TERRITORIO 2")
{
// No en TERRITORIO 2, así que no muestres la línea

e.Cancelar = verdadero;
}
}
LineFillAfterOriginal Este evento ocurre

después del evento de relleno de línea para la ventana de desplazamiento.
LineEnterBeforeOriginal Este evento ocurre

cuando el foco se mueve a una línea en la ventana de desplazamiento, pero antes de que se ejecute el
evento de entrada de línea de la ventana de desplazamiento. Este evento puede ser cancelado.
LineEnterAfterOriginal Este evento ocurre

cuando el foco se mueve a una línea en la ventana de desplazamiento, pero después de que se ejecuta
el evento de entrada de línea de la ventana de desplazamiento.
CAPÍTULO 17 VENTANAS DESPLAZABLES
LineChangeBeforeOriginal Este evento ocurre cuando

el enfoque deja una línea en la ventana de desplazamiento y se ha modificado el contenido de la línea. El
evento se ejecuta antes de que se ejecute el evento de cambio de línea de la ventana de desplazamiento.
Este evento puede ser cancelado.
LineChangeAfterOriginal Este evento ocurre cuando

el enfoque deja una línea en la ventana de desplazamiento y se ha modificado el contenido de la línea. El
evento se ejecuta después de que se ejecuta el evento de cambio de línea de la ventana de desplazamiento.
LineLeaveBeforeOriginal Este evento ocurre cuando

el enfoque deja una línea en la ventana de desplazamiento, pero antes de que se ejecute el evento de
salida de línea de la ventana de desplazamiento. Este evento puede ser cancelado.
LineLeaveAfterOriginal Este evento ocurre

cuando el enfoque deja una línea en la ventana de desplazamiento, pero después de que se ejecuta el
evento de salida de línea de la ventana de desplazamiento.
LineInsertBeforeOriginal Este evento ocurre cuando

se agrega una nueva línea a la ventana de desplazamiento, pero antes de que se ejecute el evento de
inserción de línea de la ventana de desplazamiento. Este evento puede ser cancelado.
LineInsertAfterOriginal Este evento ocurre

cuando se agrega una nueva línea a la ventana de desplazamiento, pero después de que se ejecuta el
evento de inserción de línea de la ventana de desplazamiento.
LineDeleteBeforeOriginal Este evento ocurre cuando

se elimina una línea de la ventana de desplazamiento, pero antes de que se ejecute el evento de
eliminación de línea de la ventana de desplazamiento. Este evento puede ser cancelado.
LineDeleteAfterOriginal Este evento ocurre cuando

se elimina una línea de la ventana de desplazamiento, pero después de que se ejecuta el evento de
eliminación de línea de la ventana de desplazamiento.
Capítulo 18: Campos de ventana

Los campos de ventana muestran elementos de datos individuales en una ventana. Se discuten los siguientes
elementos:
• Acceso a campos de ventana •

Métodos de campo de ventana •
Propiedades de campo de ventana
• Eventos de campo de ventana
Acceder a los campos de la ventana
Se accede a los campos de Windows para un diccionario de aplicación como propiedades de la ventana o de
la ventana de desplazamiento en la que están contenidos. Por ejemplo, el campo Número SOP (SopNumber)
está disponible en la ventana Entrada de transacciones de ventas (SopEntry). Para acceder a él, usaría la
siguiente sintaxis:
Dynamics.Forms.SopEntry.SopEntry.SopNumber
Como otro ejemplo, el campo QTY To Backorder (QtyToBackOrder) está disponible en la ventana de
desplazamiento Line Scroll (LineScroll) de la ventana Sales Transaction Entry (SopEntry). Para acceder a
este campo, usaría la siguiente sintaxis:
Dynamics.Forms.SopEntry.SopEntry.LineScroll.QtyToBackOrder
IntelliSense en Visual Studio le dirá a qué campo de Microsoft Dynamics GP se refiere la expresión.
Algunos campos en las ventanas se denominan campos locales porque se usan solo dentro de un formulario
específico. Por ejemplo, la ventana Entrada de transacción de ventas (SopEntry) contiene un campo local
denominado (L) BillTo Dirección 1. La (L) en el nombre es la forma estándar en que se identifican los campos
locales en Microsoft Dynamics GP. En un proyecto de Visual Studio Tools para Microsoft Dynamics GP, los
nombres de estos campos tienen el prefijo "Local" para indicar que son campos locales. Por ejemplo, para
acceder al campo local BillTo Address 1, usaría la siguiente sintaxis:
Dinámica.Formas.SopEntry.SopEntry.LocalBillToAddress1
Métodos de campo de ventana
Los campos de ventana proporcionan los siguientes métodos:
• Limpiar() •
Deshabilitar() •
Habilitar()
•
Rellenar() •
Foco() • ForceValidate() •
Ocultar() •
Bloquear() •
EjecutarValidar() •
Mostrar() •
Desbloquear()
Claro()
El método Clear() establece el campo en su valor borrado. La siguiente tabla enumera el valor borrado
para los tipos de datos estándar:
Tipo de datos valor borrado

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0
Cadena Cuerda vacía

Tiempo 000000 que corresponde a las 00:00:00
Desactivar()
El método Disable() hace que el campo aparezca en un estado deshabilitado y evita que el usuario realice
cambios en el campo.
Permitir()
El método Enable() permite que un campo previamente deshabilitado reciba la entrada del usuario.
Llenar()
El método Fill() establece el campo en su valor de relleno. La siguiente tabla enumera el valor completo
Tipo de datos valor lleno

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647
Cadena El byte de longitud (primer byte) de la cadena se establece en el

tamaño de almacenamiento de la cadena menos 1. Cada
uno de los bytes restantes se establece en el equivalente de cadena de ASCII 255.
Tiempo 23:59:59
Enfocar()
El método Focus() mueve el foco al campo.
Forzar Validación ()
El método ForceValidate() controla si el evento de validación ocurrirá cuando el enfoque abandone el
campo. Si ocurre el evento de validación, se ejecutará cualquier código de validación para el campo. Este
método toma un parámetro booleano. Proporcionar el valor verdadero obliga a que ocurra el evento de
validación. Al proporcionar el valor falso, se borra cualquier llamada anterior para forzar que ocurra el
evento de validación.
Esconder()
El método Hide() hace que el campo se vuelva invisible e inaccesible para el usuario.
Cerrar con llave()
El método Lock() hace que un campo se vuelva inaccesible para el usuario. La apariencia del campo no
cambiará.
EQUIPO DE 100 PROGRAMADORES

CAPÍTULO 18 CAMPOS DE VENTANA
EjecutarValidar()
El método RunValidate() hace que cualquier código de validación para el campo de la ventana sea
correr.
Espectáculo()
El método Show() hace que un campo previamente oculto se vuelva visible y accesible para el usuario.
Desbloquear()
El método Unlock() hace que un campo previamente bloqueado sea accesible para el
usuario.
Propiedades de campo de ventana
Los campos de ventana tienen las siguientes propiedades:
• EstáVacío •
EstáLleno •
Valor
IsEmpty La
propiedad IsEmpty devuelve el valor verdadero cuando el valor del campo está vacío para el tipo de campo
específico. La siguiente tabla enumera el valor vacío para los tipos de datos estándar:
Tipo de datos Valor vacío

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0

IsFilled La
propiedad IsFilled devuelve el valor verdadero cuando el valor del campo se establece en el valor máximo
para el tipo de campo específico. La siguiente tabla enumera el valor completo para los tipos de datos
estándar:

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

Tiempo 23:59:59
Valor La
propiedad Valor se utiliza para establecer o recuperar el valor del campo. IntelliSense en Visual Studio le
dirá qué tipo de valor se usa para el campo.

Eventos de campo de ventana
Los campos de ventana proporcionan los siguientes eventos:
• Cambiar •
Introducir antes del original •
Introducir después del original •
Dejar antes del original • Dejar
después del original • Validar
antes del original • Validar después
del original
Cambiar Este
evento ocurre cuando cambia el valor del campo, por ejemplo, cuando lo establece el
usuario o lo cambia otro código en Microsoft Dynamics GP.
ClickAfterOriginal
Este evento ocurre cuando el usuario hace clic en un botón, pero después de que el evento de clic del botón es
correr.
ClickBeforeOriginal
Este evento ocurre cuando el usuario hace clic en un botón, pero antes de que se ejecute el evento de clic del
botón. Este evento puede ser cancelado.
IngresarAntesOriginal
Este evento ocurre cuando el foco se mueve al campo, pero antes de que se ejecute el evento de entrada del
campo. Este evento puede ser cancelado.
EnterAfterOriginal
Este evento ocurre cuando el foco se mueve al campo, pero después de que se ejecuta el evento de entrada del
campo.
DejarAntesOriginal
Este evento ocurre cuando el foco se mueve del campo, pero antes de que se ejecute el evento de abandono del
campo. Este evento puede ser cancelado.
LeaveAfterOriginal
Este evento ocurre cuando el foco se mueve del campo, pero después de que se ejecuta el evento de abandono
del campo.
ValidateBeforeOriginal
Este evento ocurre cuando el foco se va a mover del campo y el campo se ha configurado para ser validado. Un
campo se validará cuando se haya cambiado su valor o se haya forzado la validación, como con el método
ForceValidate() . Este evento ocurre antes del evento de validación del campo. Se puede cancelar.
ValidateAfterOriginal
Este evento ocurre cuando el foco se va a mover del campo y el campo se ha configurado para ser validado. Este
evento ocurre después del evento de validación del campo.
102 PROGRAMADOR 'SQUAD

Capítulo 19: Tablas

Las tablas son el recurso básico de la aplicación Microsoft Dynamics GP que proporciona
acceso a la base de datos. Los métodos proporcionados para cada tabla permiten crear,
recuperar, actualizar o eliminar filas de la tabla en la base de datos. Se discuten los siguientes
elementos para las tablas:
• Acceder a tablas •
Métodos de tabla •
Propiedades de tabla
Accediendo a las tablas

Un búfer de tabla proporciona acceso a una fila de una tabla específica. Su código interactuará
con el búfer de la tabla cuando realice operaciones en la tabla. Hay dos tipos de búferes de
tablas: globales y de nivel de formulario.
Búferes de tablas globales Se crea un

búfer de tablas globales cuando se accede directamente a una tabla a través de la lista global
de tablas. Se accede a los búferes de tablas globales a través de la clase de diccionario. Esta
clase tiene una propiedad Tables que brinda acceso a la colección de tablas definidas en el
diccionario. La clase de diccionario para el diccionario de la aplicación se encuentra en el
siguiente espacio de nombres:
Por ejemplo, para acceder a la colección de tablas en el diccionario de Dynamics, use la

siguiente sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Tables
Para acceder a una tabla específica, como la tabla RM_Customer_MSTR (RmCustomerMstr),

utilice la sintaxis que se muestra a continuación. (Este ejemplo asume que se ha hecho
referencia al espacio de nombres mencionado anteriormente).
Dynamics.Tables.RmCustomerMstr
IntelliSense en Visual Studio le dirá a qué tabla de Microsoft Dynamics GP hace referencia la
expresión.
De forma predeterminada, un búfer de tabla global para una tabla se comparte con todos los
demás complementos de Visual Studio Tools que acceden a esa misma tabla. Si desea que su
integración cree un búfer de tabla global que no se comparte, use el método Clone() al crear la
instancia del búfer de tabla global.
Búferes de tabla a nivel de formulario Se crea

un búfer de tabla a nivel de formulario cuando se adjunta una tabla a un formulario en Microsoft
Dynamics GP. Hay un búfer de tabla para cada tabla adjunta al formulario.
Cada búfer de tabla a nivel de formulario es compartido por el código que forma parte del
formulario, así como por cualquier código fuera del formulario que acceda a la tabla a través de
ese formulario. La propiedad Tablas del formulario permite el acceso a los búferes de las tablas
adjuntas al formulario. Por ejemplo, para acceder a los procedimientos de nivel de formulario
para el formulario de entrada de transacciones de ventas (SopEntryForm) en Microsoft Dynamics
GP, usaría la siguiente sintaxis:

Dynamics.Forms.SopEntry.Tables
IntelliSense en Visual Studio le dirá a qué tabla de nivel de formulario en Microsoft Dynamics GP se
refiere la expresión.
Métodos de tabla
Las tablas proporcionan los siguientes métodos:
• Cambiar() •
CambiarPrimero() •
CambiarÚltimo() •
CambiarAnterior() • Borrar()
• Clonar() •
Cerrar()
•
Rellenar()
• Obtener() •
ObtenerPrimero
() • ObtenerÚltimo()
• ObtenerSiguiente() •
ObtenerAnterior() •
BorrarRango () •
FinalizarRango ( ) •
EliminarRango() •
IniciarRango() •
Liberar() •
Eliminar ( ) • Guardar( )
Cambiar()
El método Change() recupera una fila de la tabla y bloquea la fila de forma pasiva o activa, lo que permite
realizar cambios en ella. La fila recuperada está determinada por la clave especificada para la tabla y
los valores que se especificaron para los segmentos clave.
El método Change() tiene un parámetro:
ActiveLock : un booleano opcional. El valor verdadero especifica que se aplicará un bloqueo activo a la
fila. El valor falso (el valor predeterminado) especifica que se aplicará un bloqueo pasivo.
CambiarPrimero()
El método ChangeFirst() recupera la primera fila de la tabla y bloquea la fila de forma pasiva o activa, lo
que permite realizar cambios en ella. La fila recuperada está determinada por la clave especificada para
la tabla. El método ChangeFirst() tiene un parámetro:
ActiveLock : un booleano opcional. El valor verdadero especifica que se aplicará un bloqueo activo a la
fila. El valor falso (el valor predeterminado) especifica que se aplicará un bloqueo pasivo.

CAPÍTULO 19 TABLAS
CambiarÚltimo()
El método ChangeLast() recupera la última fila de la tabla y bloquea la fila de forma pasiva o activa,
lo que permite realizar cambios en ella. La fila recuperada está determinada por la clave especificada
para la tabla. El método ChangeLast() tiene un parámetro:
ActiveLock : un booleano opcional. El valor verdadero especifica que se aplicará un bloqueo activo a
la fila. El valor falso (el valor predeterminado) especifica que se aplicará un bloqueo pasivo.
CambiarSiguiente()
El método ChangeNext() recupera la siguiente fila de la tabla y bloquea la fila de forma pasiva o
activa, lo que permite realizar cambios en ella. La fila recuperada está determinada por la clave
especificada para la tabla y los valores de los campos clave para la fila actualmente en el búfer de la
tabla. El método ChangeNext() tiene un parámetro:
CambiarAnterior()
El método ChangePrevious() recupera la fila anterior de la tabla y bloquea la fila de forma pasiva o
activa, lo que permite realizar cambios en ella. La fila recuperada está determinada por la clave
especificada para la tabla y los valores de los campos clave para la fila actualmente en el búfer de la
tabla. El método ChangePrevious() tiene un parámetro:
Claro()
El método Clear() establece todos los campos en el búfer de la tabla a sus valores borrados.
La siguiente tabla enumera el valor borrado para los tipos de datos estándar:

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0

Clon()
El método Clone() crea una nueva instancia de un búfer de tabla global para una tabla. Esta nueva
instancia de búfer de tabla no se comparte, por lo que otros complementos de Visual Studio Tools no
pueden acceder a ella. El método Clone() no tiene efecto cuando se utilizan búferes de tabla a nivel
de formulario.
Cerca()
El método Close() cierra el búfer de la tabla.

Llenar()
El método Fill() establece todos los campos en el búfer de la tabla a sus valores máximos.
La siguiente tabla enumera el valor completo para los tipos de datos estándar:

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

tamaño de almacenamiento de la cadena menos 1. Cada uno de
los bytes restantes se establece en el equivalente de cadena
de ASCII 255.
Tiempo 23:59:59
Conseguir()
El método Get() recupera una fila de la tabla. No se aplica ningún bloqueo a la fila. La fila recuperada
está determinada por la clave especificada para la tabla y los valores que se especificaron para los
segmentos clave.
ObtenerPrimero()
El método GetFirst() recupera la primera fila de la tabla. No se aplica ningún bloqueo a la fila. La fila
recuperada está determinada por la clave especificada para la tabla.
Obtener ultimo()
El método GetLast() recupera la última fila de la tabla. No se aplica ningún bloqueo a la fila. La fila
recuperada está determinada por la clave especificada para la tabla.
ObtenerSiguiente()
El método GetNext() recupera la siguiente fila de la tabla. No se aplica ningún bloqueo a la fila. La fila
recuperada está determinada por la clave especificada para la tabla y los valores de los campos clave
para la fila actualmente en el búfer de la tabla.
ObtenerAnterior()
El método GetPrevious() recupera la fila anterior de la tabla. No se aplica ningún bloqueo a la fila. La
fila recuperada está determinada por la clave especificada para la tabla y los valores de los campos
clave para la fila actualmente en el búfer de la tabla.
RangoBorrar()
El método RangeClear() elimina el rango que se especificó para la tabla.
FinRango()
El método RangeEnd() especifica los valores actuales de los segmentos clave en el búfer de la tabla
como el final del rango de filas en la tabla. La propiedad Key especifica qué clave se usará para el
rango.
RangoEliminar()
El método RangeRemove() intenta eliminar todas las filas del rango actual de la tabla.
RangoInicio()
El método RangeStart() especifica los valores actuales de los segmentos clave en el búfer de la tabla
como el comienzo del rango de filas en la tabla. La propiedad Key especifica qué clave se usará para
el rango.

CAPÍTULO 19 TABLAS
Liberar()
El método Release() libera cualquier bloqueo pasivo o activo para una fila en el búfer de la
tabla. Los valores de fila permanecen en el búfer de la tabla.
Eliminar()
El método Remove() elimina la fila actual en el búfer de la tabla de la tabla. La fila debe estar
bloqueada de forma pasiva o activa antes de que se pueda eliminar.
Ahorrar()
El método Save() guarda los valores actualmente en el búfer de la tabla en la tabla. Si la fila
está bloqueada en el búfer de la tabla, se actualizará. Si ninguna fila de la tabla está bloqueada,
se agregará una nueva fila.
Propiedades de la tabla
Las tablas tienen la siguiente propiedad:
• Clave
Clave
La propiedad Clave se utiliza para establecer o recuperar la clave que el búfer de la tabla está
utilizando actualmente para acceder a la tabla. Las claves para una tabla se identifican por
número, comenzando con el valor 1. Cuando especifique la clave que desea usar para una
tabla, proporcionará el número entero correspondiente. La ventana Descripciones de tablas en
Microsoft Dynamics GP enumera las claves para cada tabla y los segmentos clave (campos)
que contiene cada clave.

108 ESCUADRÓN DEL PROGRAMADOR

Capítulo 20: Campos de tabla

Los campos de tabla representan elementos de datos individuales en una fila de una tabla. Se discuten los siguientes
elementos:
• Acceder a campos de tabla •

Métodos de campo de tabla
• Propiedades de campo de tabla
Acceder a los campos de la tabla
Se accede a los campos de tabla para un diccionario de aplicación como propiedades de la tabla en la que están
contenidos. Por ejemplo, el campo Número de artículo (ItemNumber) está disponible en la tabla Maestro de artículos
de inventario (IvItemMstr). Para acceder a él, usaría la siguiente sintaxis:
Dynamics.Tables.IvItemMstr.ItemNumber
IntelliSense en Visual Studio le dirá a qué campo de Microsoft Dynamics GP se refiere la expresión.
Métodos de campo de tabla
Los campos de tabla proporcionan los siguientes métodos:
• Limpiar()
• Llenar()
Claro()
El método Clear() establece el campo en su valor borrado. La siguiente tabla enumera el valor borrado para los
tipos de datos estándar:

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0

Llenar()
El método Fill() establece el campo en su valor de relleno. La siguiente tabla enumera el valor completo para los

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

Tiempo 23:59:59

Propiedades de campo de tabla
Los campos de tabla tienen las siguientes propiedades:
• EstáVacío •
EstáLleno •
Valor
IsEmpty La
propiedad IsEmpty devuelve el valor verdadero cuando el valor del campo está vacío para el tipo de campo
específico. La siguiente tabla enumera el valor vacío para los tipos de datos estándar:

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0

IsFilled La
propiedad IsFilled devuelve el valor verdadero cuando el valor del campo se establece en el valor máximo
para el tipo de campo específico. La siguiente tabla enumera el valor completo para los tipos de datos estándar:

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

Tiempo 23:59:59
Valor La
propiedad Valor se utiliza para establecer o recuperar el valor del campo. IntelliSense en Visual Studio le dirá
qué tipo de valor se usa para el campo.

Capítulo 21: Comandos

En Microsoft Dynamics GP, los comandos se utilizan para encapsular una pequeña parte de la funcionalidad de
la aplicación. Normalmente se utilizan para la navegación. Los comandos pueden aparecer en los menús y
también en las barras de herramientas de Microsoft Dynamics GP. Se discuten los siguientes elementos:
• Tipos de comandos •
Comandos de acceso • Métodos
de comandos
Tipos de comandos
Un comando puede ser de uno de los siguientes tipos:
Formulario Un comando de formulario abre el formulario especificado.
Script Un comando de script ejecuta el código de script que se define para él.
Lista de comandos Un comando de lista de comandos es un contenedor para otros comandos. Una lista de
comandos se puede utilizar como menú, submenú o barra de herramientas.
Acceder a los comandos

Se accede a los comandos para un diccionario de aplicación utilizando la propiedad Comandos del formulario en
el que están contenidos. La mayoría de los comandos en Microsoft Dynamics GP están contenidos en formularios
que se usan específicamente para los comandos. Los nombres de estos formularios comienzan con "Comando"
e incluyen el módulo para el que se utilizan los comandos. Por ejemplo, para acceder al comando usado para
abrir la ventana SmartList en Microsoft Dynamics GP, usaría la siguiente sintaxis:
Dynamics.Forms.CommandSystem.Commands.SmartList
IntelliSense en Visual Studio le dirá a qué comando en Microsoft Dynamics GP se refiere la expresión.
Métodos de comando
Los comandos proporcionan los siguientes métodos:
• Marcar() •
Deshabilitar() •
Habilitar ( ) •
Ocultar() •
Ejecutar() •
Mostrar() •
Desmarcar()
Controlar()
El método Check() hace que el comando aparezca marcado si se muestra en un menú o en una barra de
herramientas.
Desactivar()
El método Disable() hace que el comando aparezca deshabilitado si se muestra en un menú o en una barra de
herramientas. Una vez deshabilitado, el comando no se puede ejecutar.

Permitir()
El método Enable() hace que un comando previamente deshabilitado se habilite. Aparecerá
habilitado si se muestra en un menú o en una barra de herramientas.
Esconder()
El método Hide() hace que un comando se oculte en cualquier menú o barra de herramientas en el
que aparezca. El comando todavía se puede ejecutar.
Correr()
El método Run() realiza la acción del comando. Para los comandos de formulario, abre el formulario
correspondiente. Para los comandos de secuencia de comandos, ejecuta el código de secuencia
de comandos adjunto al comando.
Espectáculo()
El método Show() hace que un comando previamente oculto se muestre en cualquier menú o barra
de herramientas en el que aparezca.
Desmarcar()
El método Uncheck() hace que el comando aparezca sin marcar si se muestra en un menú o en
una barra de herramientas.

Capítulo 22: Globales

Los valores globales se utilizan para mantener los valores accesibles para toda la aplicación de
Microsoft Dynamics GP. Se discuten los siguientes elementos:
• Acceder a globales •
Propiedades globales
Acceso a globales
Se accede a los valores globales para un diccionario de aplicación a través de la clase de diccionario.
Esta clase tiene una propiedad Globals que brinda acceso a la colección de globales en el diccionario.
La clase de diccionario para el diccionario de la aplicación se encuentra en el siguiente espacio de
nombres:
Por ejemplo, para acceder a la colección de globales en el diccionario de Dynamics, use la siguiente
sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Globals
Para acceder a un valor global específico, como el ID del usuario actual (UserId), utilice la siguiente
sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Globals.UserId
Propiedades globales
Los globales tienen las siguientes propiedades disponibles:
• EstáVacío •
EstáLleno •
Valor
IsEmpty La
propiedad IsEmpty devuelve el valor verdadero cuando el valor del campo está vacío para el tipo de
campo específico. La siguiente tabla enumera el valor vacío para los tipos de datos estándar:

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0


IsFilled La
propiedad IsFilled devuelve el valor verdadero cuando el valor del campo se establece en el
valor máximo para el tipo de campo específico. La siguiente tabla enumera el valor completo

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

Tiempo 23:59:59
Valor La
propiedad Valor se utiliza para recuperar el valor del global. IntelliSense en Visual Studio le
dirá qué tipo de valor se usa para el campo. Los valores globales no se pueden establecer
desde un proyecto de Visual Studio Tools para Microsoft Dynamics GP.

Capítulo 23: Procedimientos

Hay dos tipos de procedimientos en un diccionario de aplicaciones de Dynamics GP. Los procedimientos
globales son bloques de código a los que se accede desde varios lugares de la aplicación. Los parámetros
se utilizan para enviar valores a un procedimiento y también para devolver valores de él. Los procedimientos
a nivel de formulario son como los procedimientos globales, con la excepción de que se definen como
parte de un formulario específico. Por lo general, realizan alguna acción específica del formulario para el
que están definidos. Se discuten los siguientes elementos:
• Acceder a procedimientos globales •

Acceder a procedimientos a nivel de
formulario • Métodos de
procedimiento • Eventos
de procedimiento • Parámetros para
procedimientos • Procedimientos invocables
Acceso a procedimientos globales

Se accede a los procedimientos globales para un diccionario de aplicación a través de la clase de
diccionario. Esta clase tiene una propiedad Procedimientos que brinda acceso a la colección de
procedimientos globales en el diccionario. La clase de diccionario para el diccionario de la aplicación se
encuentra en el siguiente espacio de nombres:
Por ejemplo, para acceder a la colección de procedimientos globales en el diccionario de Dynamics, use
la siguiente sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Procedures
Para acceder a un procedimiento global específico, como el procedimiento Get_Next_Form_Note_To_Open

(GetNextFormNoteToOpen), utilice la sintaxis que se muestra a continuación. (Este ejemplo asume que
se ha hecho referencia al espacio de nombres mencionado anteriormente).
Dynamics.Procedures.GetNextFormNoteToOpen
IntelliSense en Visual Studio le dirá a qué procedimiento global en Microsoft Dynamics GP se refiere la
expresión.
Acceso a procedimientos a nivel de formulario

Se accede a los procedimientos de nivel de formulario para un diccionario de aplicación a través del
formulario en el que están contenidos. La propiedad Procedimientos del formulario permite el acceso a los
procedimientos de nivel de formulario. Por ejemplo, para acceder a los procedimientos de nivel de
formulario para el formulario de entrada de transacciones de ventas (SopEntryForm) en Microsoft Dynamics
GP, usaría la siguiente sintaxis:
Dynamics.Forms.SopEntry.Procedures
IntelliSense en Visual Studio le dirá a qué procedimiento de nivel de formulario en Microsoft Dynamics GP
se refiere la expresión.
Métodos de procedimiento
Los procedimientos proporcionan el siguiente método:
• Invocar()

Invocar()
El método Invoke() se utiliza para ejecutar el procedimiento especificado. Los parámetros para este método
dependerán del procedimiento que se esté ejecutando. La siguiente tabla enumera los tipos de parámetros para
los procedimientos:
Tipo Descripción
en Los parámetros de tipo "in" se usan solo para pasar valores al procedimiento.
afuera Los parámetros de tipo "out" se usan solo para pasar valores fuera del procedimiento.
En fuera Los parámetros de tipo "inout" se utilizan para pasar valores al procedimiento y para pasar
valores fuera del procedimiento.
IntelliSense en Visual Studio le indicará el tipo de cada parámetro para un procedimiento. También le dirá el tipo
de datos de cada parámetro, como decimal o cadena.
Por ejemplo, el siguiente código de C# llama al procedimiento global CheckNoteIdString.

Este procedimiento tiene un parámetro de "entrada" y dos parámetros de "salida". Tenga en cuenta que la palabra
clave out es necesaria para los parámetros a los que se devuelven valores.
Dynamics.Procedures.CheckNoteIdString.Invoke("Estimar flete", fuera

isPresent, out formNumber);
Puede consultar el SDK de Microsoft Dynamics GP para obtener detalles sobre los procedimientos disponibles
para invocar. Algunos procedimientos en Microsoft Dynamics GP tienen definidos parámetros opcionales. Visual
Studio Tools no admite parámetros opcionales. Debe proporcionar todos los parámetros para un procedimiento
cuando lo invoca desde Visual Studio Tools.
Eventos de procedimiento
Los procedimientos proporcionan los siguientes eventos:
• Invocar antes del original • Invocar

después del original
InvokeBeforeOriginal Este evento ocurre cuando

se invoca el procedimiento, pero antes de que se ejecute el procedimiento original. Los argumentos del evento
permiten acceder a los parámetros del procedimiento. Consulte Parámetros para procedimientos en la página 117
para obtener más información sobre cómo trabajar con parámetros en eventos de procedimiento.
InvokeAfterOriginal Este evento ocurre

cuando se invoca el procedimiento, pero después de que se ejecuta el procedimiento original. Los argumentos del
evento permiten acceder a los parámetros del procedimiento. Consulte Parámetros para procedimientos en la
página 117 para obtener más información sobre cómo trabajar con parámetros en eventos de procedimiento.
El siguiente ejemplo de C# registra el evento InvokeAfterOriginal para el procedimiento AddSuccessfulLoginRecord

en Microsoft Dynamics GP.
Dynamics.Procedures.AddSuccessfulLoginRecord.InvokeAfterOriginal +=
nuevo AddSuccessfulLoginRecordProcedure.InvokeEventHandler(
AddSuccessfulLoginRecord_InvokeAfterOriginal);

CAPÍTULO 23 PROCEDIMIENTOS
El siguiente ejemplo de C# es el controlador de eventos para el evento registrado en el ejemplo anterior. El

controlador de eventos para el procedimiento AddSuccessfulLoginRecord se usa normalmente para realizar
operaciones de configuración, porque el usuario ha iniciado sesión correctamente en una empresa.
void AddSuccessfulLoginRecord_InvokeAfterOriginal(objeto remitente,

AddSuccessfulLoginRecordProcedure.InvokeEventArgs e)
{
// El código de configuración se coloca aquí

}
Parámetros para procedimientos

Cuando invoque un procedimiento o use eventos de procedimiento, deberá trabajar con los parámetros del
procedimiento.
Aprender sobre los parámetros

Hay varias formas de obtener información sobre los parámetros de un procedimiento:
• Al invocar un procedimiento, IntelliSense enumera los parámetros y sus datos

tipos
• Los argumentos de evento pasados al controlador de eventos para los eventos de procedimiento se enumerarán
los parámetros disponibles y sus tipos de datos.
• La sección Parámetros para Microsoft Dynamics GP del SDK de Microsoft Dynamics GP contiene una lista
completa de los parámetros para los procedimientos en Microsoft Dynamics GP y varios diccionarios de
integración. Los documentos de parámetros en esta sección del SDK también enumeran los nombres
de los parámetros, lo que puede ser útil para determinar cómo se usan los parámetros.
Acceder a los valores de los parámetros En los controladores

de eventos InvokeBeforeOriginal e InvokeAfterOriginal, puede usar los argumentos del evento para acceder
a los valores de los parámetros que se pasaron al procedimiento. Tenga en cuenta que otras aplicaciones
que se integran con Microsoft Dynamics GP pueden haber cambiado los valores de los parámetros.
Cambiar los valores de los parámetros En los controladores

de eventos InvokeBeforeOriginal e InvokeAfterOriginal, puede cambiar los valores de los parámetros "out" y
"inout". Los valores de los parámetros "in" no se pueden cambiar.
Le recomendamos que evite cambiar los valores de los parámetros en los procedimientos de Microsoft
Dynamics GP. Cambiar los valores de los parámetros puede alterar significativamente el funcionamiento de
Si un procedimiento se procesa en la cola de fondo en Microsoft Dynamics GP, el controlador de eventos

recibirá una copia de los parámetros originales del procedimiento. Esto significa que se ignorarán todos los
cambios que realice en los parámetros.

Procedimientos invocables
Con esta versión de Visual Studio Tools para Microsoft Dynamics GP, no se pueden invocar todos los
procedimientos. No podrán invocarse procedimientos con las siguientes características:
• El procedimiento utiliza parámetros “anónimos”. Estos tipos de parámetros no son

conocido en el momento en que se compila la aplicación.
• El procedimiento utiliza parámetros de “referencia”. Estos tipos de parámetros contienen un

enlace a un recurso específico en el diccionario de la aplicación.
• Si un campo compuesto utilizado como parámetro de procedimiento contiene un valor de

referencia, ese procedimiento no se puede invocar.
Si esta versión de Visual Studio Tools no puede ejecutar un procedimiento, no se incluirá en las listas
de procedimientos que muestra IntelliSense en Visual Studio.

Capítulo 24: Funciones

Hay dos tipos de funciones en un diccionario de aplicaciones de Dynamics GP. Las funciones
globales son bloques de código a los que se accede desde varios lugares de la aplicación. Los
parámetros se utilizan para enviar valores a una función y también para devolver valores de ella.
Además, las funciones siempre devuelven un valor. Las funciones a nivel de formulario son como
funciones globales, con la excepción de que se definen como parte de un formulario específico. Por
lo general, realizan alguna acción específica del formulario para el que están definidos.
Se discuten los siguientes elementos:
• Acceso a funciones globales •

Acceso a funciones a nivel de
formulario • Métodos de
función • Eventos de
función • Parámetros para
funciones • Funciones invocables
Acceso a funciones globales

Se accede a las funciones globales para un diccionario de aplicación a través de la clase de
diccionario. Esta clase tiene una propiedad Functions que brinda acceso a la colección de funciones
globales en el diccionario. La clase de diccionario para el diccionario de la aplicación se encuentra
en el siguiente espacio de nombres:
Por ejemplo, para acceder a la colección de funciones globales en el diccionario de Dynamics, use
la siguiente sintaxis:
Microsoft.Dexterity.Applications.Dynamics.Functions
Para acceder a una función global específica, como la función GetCurrentDirectory

(GetCurrentDirectory), utilice la siguiente sintaxis que se muestra a continuación. (Este ejemplo
asume que se ha hecho referencia al espacio de nombres mencionado anteriormente).
Dynamics.Functions.GetCurrentDirectory
IntelliSense en Visual Studio le dirá a qué función global en Microsoft Dynamics GP se refiere la
expresión.
Acceso a funciones a nivel de formulario

Se accede a las funciones de nivel de formulario para un diccionario de aplicación a través del
formulario en el que están contenidas. La propiedad Functions para el formulario permite el acceso
a las funciones de nivel de formulario. Por ejemplo, para acceder a las funciones de nivel de
formulario para el formulario de entrada de transacciones de ventas (SopEntryForm) en Microsoft
Dynamics GP, usaría la siguiente sintaxis:
Dynamics.Forms.SopEntry.Functions
IntelliSense en Visual Studio le dirá a qué función de nivel de formulario en Microsoft Dynamics GP
se refiere la expresión.

métodos de función
Las funciones proporcionan el siguiente método:
• Invocar()
Invocar()
El método Invoke() se utiliza para ejecutar la función especificada. Los parámetros para este método
dependerán del procedimiento que se esté ejecutando. La siguiente tabla enumera los tipos de parámetros
para las funciones:
Tipo Descripción
en Los parámetros de tipo "in" se usan solo para pasar valores a la función.
afuera Los parámetros de tipo "out" se usan solo para pasar valores fuera de la función.
En fuera Los parámetros de tipo "inout" se utilizan para pasar valores a la función y para pasar
valores fuera de la función.
El método Invoke() tendrá un valor de retorno al que se devolverá el valor de retorno de la función.
IntelliSense en Visual Studio le indicará el tipo de cada parámetro y el valor de retorno de una función.
También le dirá el tipo de datos de cada parámetro y el valor devuelto, como decimal o cadena.
Por ejemplo, el siguiente código de C# llama a la función global GetCurrentDirectory.

Este procedimiento no tiene parámetros y devuelve un valor de cadena.
cadena directorioActual;
directorioActual = Dynamics.Functions.GetCurrentDirectory.Invoke();
Puede consultar el SDK de Microsoft Dynamics GP para obtener detalles sobre las funciones disponibles
para invocar. Algunas funciones en Microsoft Dynamics GP tienen parámetros opcionales definidos. Visual
Studio Tools no admite parámetros opcionales. Debe proporcionar todos los parámetros para una función
cuando la invoca desde Visual Studio Tools.
Eventos de función
Las funciones proporcionan los siguientes eventos:
• Invocar antes del original •

Invocar después del original
InvokeBeforeOriginal Este evento ocurre

cuando se invoca la función, pero antes de que se ejecute la función original. Los argumentos del evento
permiten acceder a los parámetros y devolver el valor de la función. Consulte Parámetros para funciones
en la página 121 para obtener más información sobre cómo trabajar con parámetros y valores devueltos
en eventos de funciones.
InvokeAfterOriginal Este evento ocurre

cuando se invoca la función, pero después de que se ejecuta la función original. Los argumentos del evento
permiten acceder a los parámetros y devolver el valor de la función. Consulte Parámetros para funciones
en la página 121 para obtener más información sobre cómo trabajar con parámetros y valores devueltos
en eventos de funciones.
PLANTILLA DE 120 PROGRAMADORES

CAPÍTULO 24 FUNCIONES
El siguiente ejemplo de C# registra el evento InvokeAfterOriginal para la función GetAutoComplete

de UserDefaultsForm en Microsoft Dynamics GP.
UserDefaultsForm.Functions.GetAutoComplete.InvokeAfterOriginal +=
nuevo SyUserDefaultsForm.GetAutoCompleteFunction.InvokeEventHandler(
GetAutoComplete_InvokeAfterOriginal);
El siguiente ejemplo de C# es el controlador de eventos para el evento registrado en el ejemplo

anterior. El controlador de eventos usa los argumentos del evento para examinar el primer
parámetro pasado a la función. Si el valor del parámetro es "DYNSA", el valor de retorno de la
función se establece en falso. Esto desactivará la funcionalidad de autocompletar para el usuario
de DYNSA.
void GetAutoComplete_InvokeAfterOriginal(objeto remitente,

SyUserDefaultsForm.GetAutoCompleteFunction.InvokeEventArgs e)
{
// Establecer el valor de retorno para desactivar siempre el autocompletado para el usuario de DYNSA
if ( p . inParam1 == " DYNSA " )
{
e.resultado = falso;
}
}
Parámetros para funciones
Cuando invoque una función o use eventos de función, deberá trabajar con los parámetros y
devolver el valor de la función.
Aprender sobre los parámetros y el valor de retorno

Hay varias formas de obtener información sobre los parámetros y el valor de retorno de una función:
• Al invocar una función, IntelliSense enumera los parámetros y el valor devuelto, junto con sus
tipos de datos.
• Los argumentos de eventos que se pasan al controlador de eventos para eventos de función
enumerarán los parámetros disponibles y el valor devuelto, junto con sus tipos de datos.
• La sección Parámetros para Microsoft Dynamics GP del SDK de Microsoft Dynamics GP contiene
una lista completa de los parámetros y valores devueltos para las funciones en Microsoft
Dynamics GP y varios diccionarios de integración. Los documentos de parámetros en esta
sección del SDK también enumeran los nombres de los parámetros y valores devueltos, lo
que puede ser útil para determinar cómo se usan los parámetros y el valor devuelto.
Acceder a parámetros y valores devueltos En los controladores de eventos

InvokeBeforeOriginal e InvokeAfterOriginal, puede usar los argumentos de eventos para acceder a
los valores de los parámetros que se pasaron a la función. También puede acceder al valor devuelto
por la función. Tenga en cuenta que otras aplicaciones que se integran con Microsoft Dynamics GP
pueden haber cambiado los valores de los parámetros o el valor de retorno.

Cambio de parámetros y valores devueltos En los

controladores de eventos InvokeBeforeOriginal e InvokeAfterOriginal, puede
cambiar los valores de los parámetros "out" e "inout". Los valores de los
parámetros "in" no se pueden cambiar. También puede cambiar el valor devuelto por la func
Le recomendamos que evite cambiar los parámetros y los valores devueltos en las funciones de
Microsoft Dynamics GP. Cambiar el parámetro y los valores devueltos puede alterar significativamente
el funcionamiento de Microsoft Dynamics GP.
Funciones invocables
Con esta versión de Visual Studio Tools para Microsoft Dynamics GP, no se pueden invocar todas las
funciones. No se pueden invocar funciones con las siguientes características:
• La función utiliza parámetros “anónimos”. Estos tipos de parámetros no son

conocido en el momento en que se compila la aplicación.
• La función utiliza parámetros de “referencia”. Estos tipos de parámetros contienen un enlace a un

recurso específico en el diccionario de la aplicación.
• Si un campo compuesto utilizado como parámetro de función contiene un valor de referencia, esa
función no se puede invocar.
Si una función no se puede ejecutar con esta versión de Visual Studio Tools, no se incluirá en las listas
de funciones que muestra IntelliSense en Visual Studio.

Capítulo 25: Compuestos

En Microsoft Dynamics GP, un compuesto es un grupo de campos y sus tipos de datos asociados que forman
un solo tipo de datos. Cada parte del compuesto se llama componente. En Microsoft Dynamics GP, los
compuestos se utilizan para almacenar datos que constan de varias partes, como el número de cuenta. Los
compuestos también se utilizan para agrupar los parámetros que se pasan a procedimientos y funciones. Se
discuten los siguientes elementos:
• Tipos de compuestos
• Acceso a compuestos •
Métodos de campos compuestos
• Propiedades de campos
compuestos • Eventos de campos compuestos
Tipos compuestos
Cuando accede a recursos compuestos desde un diccionario, cada compuesto tendrá varios tipos definidos
para él. Cada tipo se usa en situaciones específicas en Microsoft Dynamics GP. La siguiente tabla describe
los tipos compuestos.
Tipo Ejemplo Descripción

Base Número de cuentaCompuesto La implementación base del tipo compuesto.
Datos Número de cuenta Datos compuestos La implementación base del tipo

compuesto, pero con propiedades
que brindan acceso a los componentes del
compuesto.
Solo lectura AccountNumberCompositeReadOnly Una versión de solo lectura del

compuesto. Se utiliza en casos como
pasar el valor compuesto como un
parámetro para un procedimiento
o función.
con eventos NúmeroDeCuentaCompuestoConEventos El compuesto con los eventos de campo
de ventana estándar.
Con eventos completos AccountNumberCompositeWithFullEvents El compuesto con el estándar

eventos de campo de ventana y los
mismos eventos de campo para
cada componente del compuesto.
En la mayoría de los casos, IntelliSense le dirá qué tipo de compuesto se requiere para una situación
específica.
Acceso a compuestos
Los compuestos se pueden mostrar como campos en las ventanas y se accede a ellos como propiedades de
la ventana o de la ventana de desplazamiento en la que están contenidos. Los compuestos también se
pueden usar para crear variables que se pasan como parámetros para procedimientos y funciones.
Campos de ventana Se accede

a los campos compuestos como propiedades de la ventana o de la ventana de desplazamiento en la que
están contenidos. Por ejemplo, para acceder al campo Número de cuenta CS en la ventana Mantenimiento
de cuenta de Microsoft Dynamics GP, usaría la siguiente sintaxis:
Dynamics.Forms.GlAccountMaintenance.GlAccountMaintenance.AccountNumberCs

Variables En
algunos casos, es posible que desee recuperar el valor de un compuesto y usarlo como
una variable en su integración con Visual Studio Tools. Puede crear una instancia del
compuesto y luego establecer el valor de la variable compuesta.
Por ejemplo, el siguiente código C# crea una instancia del compuesto

AccountNumberCs, que aparece en la ventana Mantenimiento de la cuenta en
Microsoft Dynamics GP. Se recupera el valor de este campo de ventana. El valor
de cada componente se combina en una cadena y se muestra en un mensaje.
// Crear una instancia del compuesto AccountNumberCs

Microsoft.Dexterity.Applications.DynamicsDictionary.AccountNumberCsComposite
Número de cuenta de datos = new Número de cuentaCsCompositeData();
// Hacer referencia al formulario de mantenimiento de cuenta

Microsoft.Dexterity.Applications.DynamicsDictionary.GlAccountMaintenanceForm
Mantenimiento de cuenta = Dynamics.Forms.GlAccountMaintenance;
// Recuperar el valor del número de cuenta

numeroCuenta = MantenimientoCuenta.GlMantenimientoCuenta.NumeroCuentaCs;
string cuentaNumberString = "";
// Recuperar los componentes individuales

for (int i = 0; i <númeroCuenta.Longitud; i++)
{
CadenaNúmeroCuenta = CadenaNúmeroCuenta + NúmeroCuenta[i] + " ";

}
// Mostrar el número de cuenta

System.Windows.Forms.MessageBox.Show("Número de cuenta: " +
cadena de número de cuenta);
Parámetros Puede
crear variables compuestas y pasarlas como parámetros para procedimientos y
funciones. Se debe utilizar como parámetro una variable basada en el tipo compuesto
de "solo lectura". Para crear una variable compuesta de "solo lectura", primero debe
crear una variable basada en el tipo compuesto de "datos".
Por ejemplo, el siguiente código C# crea una variable del tipo

AccountNumberCompositeData y establece los valores de sus componentes. Se
crea una variable del tipo AccountNumberCompositeReadOnly. Su constructor
utiliza la variable compuesta de "datos" para proporcionar el valor del compuesto.
La versión de "solo lectura" del valor compuesto se pasa como parámetro a la
función ConvertAcctToAliasStr.
Microsoft.Dexterity.Applications.DynamicsDictionary.AccountNumberComposite
Datos accountNumberData = new AccountNumberCompositeData();
NúmeroDeCuentaDatos[0] = "000";
numeroDeCuentaDatos[3] = "";
// Crear el compuesto de solo lectura que se usa para la llamada de función

Microsoft.Dexterity.Applications.DynamicsDictionary.AccountNumberComposite
ReadOnly accountNumber = nuevo AccountNumberCompositeReadOnly
(datosNúmeroCuenta);

CAPÍTULO 25 COMPUESTOS
// Convierte el número de cuenta a su alias de cuenta
alias de cadena = Dynamics.Forms.GlAcctBase.Functions.ConvertAcctToAliasStr.

Invocar (número de cuenta);
// Mostrar el alias de la cuenta

System.Windows.Forms.MessageBox.Show("Alias de cuenta: " + alias);
Componentes Para
acceder a los componentes individuales de la mayoría de los compuestos, puede
utilizar las propiedades del compuesto. El compuesto tendrá una propiedad para
cada componente del compuesto.
Microsoft Dynamics GP define dinámicamente algunos compuestos, como AccountNumberComposite.

Estos compuestos no tienen las propiedades nombradas para acceder a los componentes individuales del
compuesto. Para acceder a los componentes de estos compuestos, debe utilizar el índice del componente.
Por ejemplo, el siguiente código C# crea una instancia del compuesto AccountNumber y establece el valor
de cada componente.
AccountNumberCompositeData accountNumberData = nuevo

NúmeroDeCuentaDatosCompuestos();
numeroDeCuentaDatos[3] = "";
Métodos de campo compuesto

Los campos compuestos proporcionan los siguientes métodos:
• Limpiar() •
Deshabilitar() •
Habilitar()
•
Rellenar() •
Foco() • ForceValidate()
• Ocultar() •
Bloquear() •
EjecutarValidar() •
Mostrar() •
Desbloquear()
Claro()
El método Clear() establece cada componente del compuesto en su valor borrado. La siguiente tabla
enumera el valor borrado para los tipos de datos estándar:

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0

Desactivar()
El método Disable() hace que el campo compuesto aparezca en un estado deshabilitado y evita que el
usuario realice cambios en el campo.
Permitir()
El método Enable() permite que un campo compuesto previamente deshabilitado reciba la entrada del
usuario.
Llenar()
El método Fill() establece cada componente del compuesto en su valor de relleno. La siguiente tabla
enumera el valor completo para los tipos de datos estándar:

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

Tiempo 23:59:59
Enfocar()
El método Focus() mueve el foco al campo compuesto.
Forzar Validación ()
El método ForceValidate() controla si el evento de validación ocurrirá cuando el enfoque abandone el
campo compuesto. Si ocurre el evento de validación, se ejecutará cualquier código de validación para el
campo compuesto. Este método toma un parámetro booleano.
Proporcionar el valor verdadero obliga a que ocurra el evento de validación. Al proporcionar el valor falso,
se borra cualquier llamada anterior para forzar que ocurra el evento de validación.
Esconder()
El método Hide() hace que el campo compuesto se vuelva invisible e inaccesible para el usuario.
Cerrar con llave()
El método Lock() hace que un campo compuesto se vuelva inaccesible para el usuario. La apariencia del
campo no cambiará.
EjecutarValidar()
El método RunValidate() hace que cualquier código de validación para el campo compuesto sea
correr.
Espectáculo()
El método Show() hace que un campo compuesto previamente oculto se vuelva visible y accesible para el
usuario.
Desbloquear()
El método Unlock() hace que un campo compuesto previamente bloqueado se vuelva accesible para el
usuario.

CAPÍTULO 25 COMPUESTOS
Propiedades de campo compuesto
Los campos compuestos tienen las siguientes propiedades:
• EstáVacío •
EstáLleno •
Longitud •
Valor
IsEmpty La
propiedad IsEmpty devuelve el valor verdadero cuando el valor del campo compuesto está vacío para el
tipo de campo específico. La siguiente tabla enumera el valor vacío para los tipos de datos estándar:

Fecha 0/0/0
Divisa 0
Entero 0
Largo 0

IsFilled La
propiedad IsFilled devuelve el valor verdadero cuando el valor del campo compuesto se establece en el
valor máximo para el tipo de campo específico. La siguiente tabla enumera el valor completo para los

Fecha 31/12/9999
Divisa 99999999999999.99999
Entero 32,767
Largo 2.147.483.647

Tiempo 23:59:59
Longitud La
propiedad Longitud se utiliza para recuperar el número de componentes en el campo
compuesto.
Valor La
propiedad Valor se utiliza para establecer o recuperar el valor del campo compuesto. IntelliSense en
Visual Studio le dirá qué tipo de valor se usa para el campo.

Eventos de campo compuesto
Los campos compuestos proporcionan los siguientes eventos:
• Cambiar •
Introducir antes del original •
Introducir después del original
• Dejar antes del original • Dejar
después del original • Validar
antes del original • Validar después
del original
Los compuestos del tipo "con eventos" proporcionan estos eventos para el compuesto como un solo campo.
Los compuestos del tipo “con eventos completos” suministran estos eventos para el compuesto como un solo
campo, y también para cada uno de los componentes del compuesto.
Cambio Este
evento ocurre cuando cambia el valor del compuesto o componente, como cuando lo establece
el usuario o lo cambia otro código en Microsoft Dynamics GP.
EnterBeforeOriginal Este evento

ocurre cuando el foco se mueve al campo o componente compuesto, pero antes de que se
ejecute el evento enter del campo o componente. Este evento puede ser cancelado.
EnterAfterOriginal Este evento

ocurre cuando el foco se mueve al campo o componente compuesto, pero después de que se
ejecuta el evento enter de campo o componente.
LeaveBeforeOriginal Este evento

ocurre cuando el foco se mueve desde el componente o campo compuesto, pero antes de que
se ejecute el evento de abandono del campo. Este evento puede ser cancelado.
LeaveAfterOriginal Este evento

ocurre cuando el foco se mueve del campo o componente compuesto, pero después de que
se ejecuta el evento de abandono del campo.
ValidateBeforeOriginal Este evento ocurre cuando

el enfoque se va a mover del campo o componente compuesto, y el campo o componente compuesto se ha
configurado para ser validado. Un campo o componente se validará cuando se haya cambiado su valor o se
haya forzado la validación, como con el método ForceValidate() . Este evento ocurre antes del evento de
validación del componente o del campo compuesto. Se puede cancelar.
ValidateAfterOriginal Este evento ocurre

cuando el enfoque se va a mover del campo o componente compuesto, y el campo o
componente compuesto se ha configurado para ser validado. Este evento ocurre después del
evento de validación del componente o del campo compuesto.

PAR
EJE
INT
DE
4:
Parte 4: Ejemplos de integración

Esta parte de la documentación describe ejemplos de integración que muestran cómo usar Visual Studio
Tools para Microsoft Dynamics GP. Se comentan los siguientes ejemplos:
• El Capítulo 26, “Valor predeterminado de campo”, describe un ejemplo que usa eventos para valores de
campo predeterminados en Microsoft Dynamics GP.
• El Capítulo 27, "Estimación del flete", describe un ejemplo que estima el flete
importes para documentos de ventas en Microsoft Dynamics GP.
• El Capítulo 28, "Detalles ambientales ", describe un ejemplo que almacena información detallada ambiental
adicional para elementos en Microsoft Dynamics GP.
• El Capítulo 29, "Búsquedas", describe un ejemplo que muestra cómo se implementan seis búsquedas
comunes para una integración de Visual Studio Tools.
La siguiente tabla indica qué funciones de Visual Studio Tools para Microsoft Dynamics GP se implementan
en cada muestra.
Campo Estimar Ambiental búsquedas

Moroso Transporte Detalles
Formulario de herramientas de Visual Studio X X X
Acceso a campos de Dynamics GP X X X
Eventos de campo X X X X
Eventos de formulario X X
Eventos de diálogo modales X
Acceso a procedimientos/funciones X
Acceso a la mesa X X
Integración DUOS X
Integración de notas X
búsquedas X
Ayuda en linea X
Compatibilidad con macros X

Capítulo 26: Incumplimiento de campo

Esta aplicación de muestra demuestra cómo los eventos en Microsoft Dynamics GP se pueden usar para
valores de campo predeterminados. El ejemplo establece los campos Ciudad y Estado de manera
predeterminada cuando un usuario ingresa un valor para el campo Código postal en la ventana Mantenimiento del clien
Se discuten los siguientes temas:
• Información
general • Ejecución de la aplicación de
ejemplo • Cómo se utilizó Visual Studio Tools
Descripción general
Esta aplicación de muestra se integra con la ventana de mantenimiento del cliente en Microsoft
Dynamics GP. Automáticamente establece valores predeterminados para los campos Ciudad y
Estado cuando el usuario proporciona un código postal conocido.
Los campos Ciudad y Estado se

establecen en función del código postal
Valor del código ingresado.
Esta muestra utiliza un conjunto fijo de códigos postales y los valores de ciudad y estado
correspondientes. Una aplicación real usaría un conjunto más extenso.
Ejecución de la aplicación de muestra
Para ejecutar esta aplicación de muestra, realice los siguientes pasos:
1. Extraiga el archivo .zip que contiene las muestras.

En la carpeta donde se instaló Visual Studio Tools, busque el archivo Samples.zip. Este archivo
contiene las versiones C# y Visual Basic de los ejemplos. Extraiga este archivo a una ubicación
a la que tenga permisos de acceso.
2. Abra la solución de muestra Field Defaulter.

Con Visual Studio, abra el archivo de solución FieldDefaulter.sln para la versión C# o Visual
Basic del ejemplo.
3. Verifique las referencias para la solución de muestra.

Utilice Visual Studio para ver las referencias del proyecto. El ejemplo de Estimar flete debe incluir
referencias a los siguientes ensamblajes:
• Aplicación.Dinámica •
Microsoft.Dexterity.Bridge
Si alguna de estas referencias para el proyecto no es válida, vuelva a agregarla al proyecto.
4. Establezca la configuración de la solución.

Establezca la Configuración de la solución en Versión para compilar la versión de lanzamiento
de la aplicación.

PARTE 4 EJEMPLOS DE INTEGRACIÓN
5. Genere la aplicación.
En el menú Generar, elija Generar solución. Si no hay errores de compilación, se compilará el
ensamblado para la aplicación Field Defaulter.
6. Instale el ensamblaje de Field Defaulter.

Copie FieldDefaulter.dll de la carpeta Release del proyecto a la carpeta AddIns en la instalación
de Microsoft Dynamics GP.

Se cargará la aplicación de muestra Field Defaulter.
8. Abra la ventana Mantenimiento del cliente.

En Microsoft Dynamics GP, abra la ventana Mantenimiento del cliente.
9. Ingrese un código postal.

Para fines de demostración, esta aplicación de muestra reconoce solo una pequeña cantidad
de códigos postales. Puede ingresar cualquiera de los siguientes códigos postales y completar
la ciudad y el estado correspondientes:
02109 58104
53151 58474
55111 60605
56560 85012
58078 95014
58102 98052
58103
Cuando haya terminado, cierre Microsoft Dynamics GP.
Cómo se usaron las herramientas de Visual Studio
Esta aplicación de ejemplo utiliza las funciones de acceso a recursos y eventos de Visual Studio
Tools para Microsoft Dynamics GP.
Recursos accedidos
El ejemplo de Field Defaulter utiliza los siguientes recursos en el diccionario de Dynamics:
Formularios
• RmCustomerMantenimiento
ventanas
• RmCustomerMantenimiento
Eventos
El ejemplo Field Defaulter registra el siguiente evento en Microsoft Dynamics GP:
• Un evento de cambio para el campo Código postal en la ventana Mantenimiento del cliente, que
se usa para buscar el valor ingresado. Si se puede encontrar la ciudad y el estado para el valor
del código postal ingresado, su valor se establece automáticamente en la ventana.

Capítulo 27: Estimar el flete

Esta aplicación de ejemplo demuestra varias técnicas útiles al crear integraciones de Microsoft
Dynamics GP. La muestra se integra con la ventana Entrada de transacción de ventas. Se discuten
los siguientes temas:
• Información
Esta aplicación de muestra se integra con la ventana Entrada de transacciones de ventas en Microsoft
Dynamics GP. Recupera información sobre el peso de envío de los artículos en el documento de
ventas actual, calcula un peso de envío estimado para todos los artículos y luego estima el costo del
flete. El valor estimado del flete se coloca en el campo Flete de la ventana Entrada de transacción de
ventas.
La ventana Estimar
flete estima el flete para el
documento de ventas
actual.
Este ejemplo utiliza un conjunto fijo de métodos de envío y tarifas de envío. Una aplicación real usaría
una tabla de tarifas más extensa y posiblemente un servicio web para acceder a las tarifas de flete.
El ejemplo de Estimar flete usa las capacidades de acceso a tablas de Visual Studio Tools para
acceder a datos en Microsoft Dynamics GP.

2. Abra la solución de ejemplo Calcular flete.

Con Visual Studio, abra el archivo de solución QuoteFreight.sln para la versión C# o Visual Basic
del ejemplo.

Utilice Visual Studio para ver las referencias del proyecto. El ejemplo de Estimar flete debe incluir
referencias a los siguientes ensamblajes:
Microsoft.Dexterity.Bridge •


de la aplicación.
ensamblado para la aplicación de estimación de flete.
6. Instale el ensamblaje de estimación de flete.

Copie el archivo BudgetFreight.dll de la carpeta Release del proyecto a la carpeta AddIns en la
instalación de Microsoft Dynamics GP.
7. Instale el archivo de ayuda de Estimar flete.

Copie el archivo de ayuda de BudgetFreight.chm de la carpeta de BudgetFreight a la carpeta de
instalación de Dynamics GP. El archivo de ayuda debe colocarse en la misma carpeta que el
archivo de ayuda GreatPlains.chm.

Se cargará la aplicación de ejemplo de Estimar flete.
9. Abra la ventana Entrada de transacciones de ventas.

En Microsoft Dynamics GP, abra la ventana Entrada de transacciones de ventas.
10. Muestre un documento de ventas.

Puede visualizar un documento de ventas existente o crear un nuevo documento de ventas.
11. Agregue artículos al documento de ventas.

Asegúrese de que el documento de ventas tenga artículos de inventario para los cuales se haya
especificado el peso de envío estimado.
12. Muestre la ventana Estimar flete.

En el menú Adicional, elija Estimar flete. Aparecerá la ventana Estimar flete.
13. Elija un método de envío y calcule el flete.

Elija Aéreo o Terrestre como método de envío y luego haga clic en Calcular para calcular el flete
estimado.
14. Devuelva el importe del flete al documento de ventas.

Haga clic en Guardar para devolver el importe estimado del flete al campo Flete del documento
de ventas.
Esta aplicación de ejemplo usa varias funciones de Visual Studio Tools para Microsoft Dynamics GP
para implementar esta integración.
Interfaz de usuario El
WinForm especial disponible para los complementos de Dynamics GP se usó al crear la ventana
Estimar flete. También se utilizaron los botones e imágenes personalizados.
El ejemplo ilustra la técnica que se puede utilizar para implementar notas a nivel de ventana y el
enlace de ayuda en línea.

CAPÍTULO 27 FLETE ESTIMADO
Recursos accedidos
El ejemplo de Estimar flete usa muchos recursos en el diccionario de Dynamics:
Formularios
• SOPEntry •
FormNote1 •
FormNote2 •
FormNote3 •
FormNote4 •
FormNote5
Windows •
SOPEntrada
Procedimientos globales
• CheckForNote •
CheckNoteIdString •
ObtenerNextFormNoteToOpen
Mesas
Se accede a los datos de las siguientes tablas para calcular el flete estimado para el documento de ventas actual:
• IvItemMstr (maestro de artículos de inventario) •

SopLineWork (trabajo de línea SOP)
Eventos
El ejemplo de Estimar flete registra los siguientes eventos en Microsoft Dynamics
médico de cabecera:
• Un evento de controlador de menú para el formulario Entrada de transacción de ventas, que se utiliza para abrir el
Ventana Estimar flete.
• Un evento de cierre de formulario en el formulario Entrada de transacción de ventas, que se usa para indicar cuándo
la ventana Entrada de transacciones de ventas se ha cerrado.
• Un evento de observación para el campo Número SOP en la ventana Entrada de transacción de ventas, que se
utiliza para mantener actualizada la ventana Estimar flete con el documento de ventas actual.
• Un evento de entrada para el campo Flete en la ventana Entrada de transacción de ventas, que se usa para
preguntar al usuario si desea estimar el monto del flete si no se ha proporcionado un valor.
• Varios eventos de cierre de formulario para los diversos formularios de "Nota" en Microsoft Dynamics GP,
utilizados para mantener actualizado el botón Nota en la ventana Estimar flete.


Capítulo 28: Detalles ambientales

Esta aplicación de ejemplo demuestra varias técnicas útiles al crear integraciones de Microsoft
Dynamics GP. La muestra se integra con la ventana Mantenimiento de artículos. Se discuten los
siguientes temas:
• Información
Esta aplicación de muestra se integra con la ventana Mantenimiento de artículos en Microsoft

Dynamics GP. Almacena información ambiental sobre el artículo. Los datos adicionales se almacenan
en la tabla DUOS (Dynamics User Object Store) para la empresa actual.
La ventana Detalles
ambientales rastrea la
información ambiental para
el artículo de inventario actual.
Esta muestra también implementa la compatibilidad con el sistema de macros, lo que permite grabar
y reproducir macros para esta ventana.

2. Abra la solución de muestra Detalles ambientales.

Con Visual Studio, abra el archivo de solución EnvironmentalDetails.sln para la versión C# o
Visual Basic del ejemplo.

Utilice Visual Studio para ver las referencias del proyecto. El ejemplo de detalles ambientales
debe incluir referencias a los siguientes ensamblajes:

de la aplicación.

En el menú Generar, elija Generar solución. Si no hay errores de compilación, se compilará
el ensamblado para la aplicación Detalles ambientales.
6. Instale el ensamblaje de detalles ambientales.

Copie EnvironmentalDetails.dll de la carpeta Release del proyecto a la carpeta AddIns en la
instalación de Microsoft Dynamics GP.

Se cargará la aplicación de ejemplo de Estimar flete.
8. Abra la ventana Mantenimiento de artículos.

En Microsoft Dynamics GP, abra la ventana Mantenimiento de artículos.
9. Muestre un elemento.
Puede mostrar un elemento existente o crear uno nuevo.
10. Muestre la ventana Detalles ambientales.

En el menú Adicional, elija Detalles ambientales. Aparecerá la ventana Detalles ambientales.
11. Proporcione los detalles ambientales del artículo.

Ingrese los siguientes detalles ambientales:
• Costo de energía anual

• Notas •
Reciclable •
Calificación Energy Star
12. Guarde los cambios en el elemento.

Haga clic en Guardar en la ventana Mantenimiento de artículos para guardar los cambios del artículo.
Esta aplicación de ejemplo usa varias funciones de Visual Studio Tools para Microsoft Dynamics
GP para implementar esta integración.
WinForm especial disponible para los complementos de Dynamics GP se usó al crear la ventana
Detalles ambientales.
Recursos accedidos
El ejemplo de Estimar flete usa muchos recursos en el diccionario de Dynamics:
Formularios
• IvItemMaintenanceForm
ventanas
• IvVentana de mantenimiento de elementos
Mesas
Los datos para la integración se almacenan en la siguiente tabla:
• SyUserObjectStoreTable (DUOS)

CAPÍTULO 28 DETALLES AMBIENTALES
Esta es la misma tabla utilizada por VBA para almacenar datos. La clase DUOSHelper del ejemplo de detalles
ambientales contiene métodos que se utilizan para escribir, recuperar y eliminar filas de la tabla DUOS.
Eventos
El ejemplo de detalles ambientales registra los siguientes eventos en Microsoft
Dinámica GP:
• Un evento de controlador de menú para el formulario Mantenimiento de artículos, que se utiliza para mostrar el
Formulario de detalles ambientales.
• Un evento de apertura de formulario en el formulario Mantenimiento de artículos, utilizado para crear una
instancia del formulario Detalles ambientales.
• Un evento de cierre de formulario en el formulario Mantenimiento de artículos, que se utiliza para indicar
cuándo se ha cerrado la ventana Mantenimiento de artículos. Este evento cierra el formulario Detalles
ambientales y lo elimina de la memoria.
• Un evento de cambio para el campo Número de artículo en la ventana Mantenimiento de artículos, que se usa
para mantener actualizada la ventana Detalles ambientales con el artículo actual que se muestra.
• Un evento de cambio para el campo Descripción del elemento en la ventana Mantenimiento del elemento, que
se utiliza para mantener actualizada la ventana Detalles ambientales con el elemento actual que se muestra.
• Un evento de cambio para el campo Guardar registro en la ventana Mantenimiento de elementos, que se
utiliza para guardar los detalles ambientales cuando el usuario guarda el elemento.
• Un evento de diálogo modal posterior para la ventana Mantenimiento de elementos, que se utiliza para
recuperar la respuesta cuando el usuario confirma si eliminará el elemento actual. Si el usuario elige
eliminar el elemento actual, también se elimina la información de detalles ambientales correspondiente.
Compatibilidad con macros Se

han agregado llamadas al método RecordMacroItem() a los controles en el formulario Detalles ambientales para
admitir la grabación de sentencias de macros. El método PlayMacroItem() de la clase base DexUIForm se anuló
para admitir la reproducción de las declaraciones de macro que se grabaron.


Capítulo 29: Búsquedas

Esta aplicación de ejemplo demuestra cómo usar varios formularios de búsqueda comunes en
Microsoft Dynamics GP. Se discuten los siguientes temas:
• Información
Esta aplicación de ejemplo demuestra cómo implementar formularios de búsqueda comunes en una
integración de Visual Studio Tools. Consulte el Capítulo 14, "Uso de búsquedas", para obtener
detalles sobre cómo implementar búsquedas.
Este ejemplo implementa las siguientes búsquedas:
• Número de cliente • ID de
proveedor •
Número de artículo •
Número de cuenta del LM •
Número de documento SOP •
Número de documento POP
.

2. Abra la solución de ejemplo de búsquedas.

Con Visual Studio, abra el archivo de solución Lookups.sln para la versión C# o Visual Basic del
ejemplo.

Utilice Visual Studio para ver las referencias del proyecto. El ejemplo de búsquedas debe incluir
referencias a los siguientes ensamblados:
Aplicación.SmartList •


de la aplicación.
ensamblado para la aplicación Lookups.
6. Instale el ensamblaje de búsquedas.

Copie Lookups.dll de la carpeta Release del proyecto a la carpeta AddIns en la instalación de

Se cargará la aplicación de ejemplo Lookups.
8. Abra la ventana Acerca de Box.

En Microsoft Dynamics GP, abra la ventana Acerca de Box. Se accede desde el menú Ayuda en
la ventana principal de Microsoft Dynamics GP.
9. Muestre la ventana Búsquedas.

En el menú Adicional, elija Búsquedas. Aparecerá la ventana de búsquedas.
10. Utilice las búsquedas de muestra.

Utilice las búsquedas de muestra, tal como lo haría con cualquier otra búsqueda en Microsoft
Dynamics GP.
Esta aplicación de ejemplo utiliza las funciones básicas de Visual Studio Tools para Microsoft
Dynamics GP.
WinForm especial disponible para los complementos de Dynamics GP se utilizó al crear la ventana
de búsquedas.
Recursos accedidos
El ejemplo de búsquedas utiliza los siguientes recursos en los diccionarios Dynamics y SmartList:
Formularios
• AboutBox •
Formulario de búsqueda de cliente •

Formulario de búsqueda de
proveedor • Formulario de búsqueda de número
de artículo Iv • Formulario de
búsqueda de cuenta • Formulario de búsqueda
de documento Sop • Formulario de búsqueda de documento emergente
Compuestos •
AccountNumberCompositeData
Funciones a nivel de formulario

• ConvertAcctToStr del formulario GlAcct

CAPÍTULO 29 BÚSQUEDAS
Eventos
El ejemplo de búsquedas registra los siguientes eventos en Microsoft Dynamics GP:
• Un evento de controlador de menú para el formulario AboutBox, que se utiliza para abrir las búsquedas
ventana.
• Un evento de clic para el campo SelectButton en cada una de las ventanas de búsqueda, para notificar
a la muestra de búsquedas que el usuario hizo clic en el botón Seleccionar.
• Un evento de validación para el campo PopPoLookup en la ventana PopDocumentLookup, para evitar

que se ejecute la validación cuando se abre la búsqueda de número POP desde una integración de
Visual Studio Tools. Esta es una solución para un problema que hace que la búsqueda de números
POP se cierre inmediatamente después de abrirse.


Glosario Variables globales

Una variable disponible todo el tiempo que la aplicación
de Microsoft Dynamics GP está abierta.
Bloqueo activo El código de Visual Studio Tools puede leer el valor de las
Un método de bloqueo que garantiza que solo un usuario variables globales.
pueda cambiar o eliminar el contenido de una fila a la vez.
Otro usuario no puede cambiar ni eliminar los datos de la Clave
Un campo o combinación de campos dentro de una
fila bloqueada hasta que se libere el bloqueo.
fila que se utiliza como base para almacenar,
recuperar y ordenar la fila en una tabla.
Formas alternativas
Iniciar archivo
Formularios del diccionario principal de Dynamics que han
sido modificados por un desarrollador externo y están Un archivo que se utiliza para iniciar una aplicación con el
almacenados en un diccionario de terceros. motor de tiempo de ejecución de Dynamics GP. Este

archivo almacena la ubicación del diccionario principal de
la aplicación, el nombre y la ubicación de los diccionarios
Ensamblado de aplicación Un de formularios e informes, y el nombre y la ubicación de
ensamblado .NET usado por Visual Studio Tools los diccionarios integrados.
para brindar acceso a los recursos en el diccionario
Campos locales
de Microsoft Dynamics GP. Cada diccionario de
Campos especiales que se definen y usan solo dentro de
aplicación puede tener un ensamblado de aplicación
un formulario específico en Microsoft Dynamics GP.
correspondiente.
Búfer Un
formularios modificados
área de almacenamiento temporal en la memoria de
Formularios en la aplicación de Microsoft Dynamics GP
una computadora. El tiempo de ejecución de
que contienen modificaciones realizadas con el Modificador.
Microsoft Dynamics GP utiliza varios tipos de búfer,
como búfer de tabla y búfer de ventana.
Área de control bloqueo pasivo
Una banda dibujada en la parte superior de una ventana Un método de bloqueo que permite a otros usuarios
de Microsoft Dynamics GP. Los controles como los botones acceder y realizar cambios en la fila.
Guardar, Borrar y Eliminar se colocan en el área de control. ID de producto

ID de número entero que se utiliza para identificar
Generador de ensamblado de diccionario de forma exclusiva un diccionario de aplicación. El
La herramienta (DAG.exe) utilizada para crear ensamblajes Generador de ensamblaje de diccionarios se refiere
de aplicaciones para diccionarios. a los diccionarios en función de su ID de producto.
Ensamblaje Dexterity Bridge El ensamblaje Segmentos Un
Microsoft.Dexterity.Bridge.dll que proporciona acceso campo del grupo de campos que componen una
a eventos en Microsoft Dynamics GP, así como a clave para una tabla.
los recursos en los diccionarios de la aplicación. Área de estado
Un área en la parte inferior de una ventana de Microsoft
Clase de diccionario Dynamics GP creada por una línea divisoria dibujada a lo

Una clase utilizada para hacer referencia a los recursos largo de la ventana. Los controles como los botones de
en un diccionario de aplicación. La clase está disponible navegación, los botones de notas y los botones de ayuda
después de agregar una referencia al ensamblado de la se colocan en el área de estado.
aplicación para un diccionario al proyecto de Visual Studio. Búfer de tabla

Un búfer que actúa como un área de almacenamiento
intermedia para contener una fila de una tabla.
Ensamblaje de Dexterity Shell El
ensamblaje Microsoft.Dexterity.Shell.
UI.dll que proporciona las capacidades de dibujo que
permiten que una aplicación de integración coincida con
la apariencia de Microsoft Dynamics GP
Diccionario de formas
El diccionario en una instalación de Microsoft Dynamics
GP que contiene los formularios modificados para una
aplicación. Cada diccionario de aplicación puede tener un
diccionario de formularios.
Campos globales
Un tipo de campo que se puede usar en cualquier
formulario o tabla en Microsoft Dynamics GP.


Índice C compuestos (continuación)

C# accediendo a través del código 123
registro de eventos 41 como parámetros de procedimiento y

A configuración de información de ensamblado función 124
Acceder a los recursos del diccionario, capítulo como variables 124
65 anulación del registro de
3740 como campos de ventana 123
eventos 44 actualización de
ActivateAfterOriginal, evento de ventana 90 integraciones 15 cancelación de eventos 44 capítulo 123128
ActivateBeforeOriginal, evento de ventana 90 bloqueos definido 123
Cambiar
activos referencia de recurso 123
evento de campo compuesto 128
definido 145 evento de campo de ventana 102 recuperando número de componentes 127 tipos de
descrito 59 123 área de
Change(), método de tabla 104
liberando 59 control
ChangeFirst(), método de tabla 104
carpeta AddIns, descrito 12 Menú definido 145
ChangeLast(), método de tabla 105
adicional, agregando elementos a 85 descrito 26
ChangeNext(), método de tabla 105
AddMenuHandler(), método de formulario 85 Referencia de control, capítulo 2932
ChangePrevious(), método de tabla 105
AfterModalDialog, evento de ventana 92 formularios Comprobar (), método de comando 111 ControlArea, propiedad de WinForms 26 controles
alternativos accediendo que se
Clear()
con código 72 creando método de campo compuesto 125 agregan a formularios 27
ensamblado de aplicación para 72 definido 145 método de campo de tabla 109 botones 29
pautas para método de tabla 105 cuadros combinados
acceder 73 usando try. ..atrapar con método de campo de ventana 100 32 referencia de control 29
73 ensamblados de aplicaciones etiquetas 32

ClickAfterOriginal, evento de campo de ventana
creando 33 definido 145 descrito 102 cuadros de lista
12 instalando 7 32 cuadros de
ClickBeforeOriginal, evento de campo de ventana
convención de 102 texto 31 convenciones, en la documentación 3
nomenclatura 33 Ventana Estado de personalización 70
Clonar(), método de tabla 105
reemplazando Close()
D
el nombre 36 referencias a 37 método de formulario
haciendo referencia al 87 método de tabla 105 DAG.exe, consulte Dictionary Assembly Generator
ensamblado principal Depuración,
método de ventana 89
de la aplicación 36 enviado con Visual configuración de la solución 66 depuración
Evento de formulario
Studio Tools 12 CloseAfterOriginal adjunta a un
firmando 35 qué usar 33 arquitectura, para Visual 88 evento de ventana 90 proceso 69 capítulo 6970 examen
Studio Tools de la aplicación 70

CloseBeforeOriginal formulario
11 información de evento 88 ventana integraciones 69 preparativos para
ensamblado , para integraciones 65 procesos evento 90 controles de 69 eliminación, filas
asíncronos, manejo para de tablas 53 implementación

cuadro combinado, descritos 32 línea de
de integraciones 67 Desarrollo de
comando, para ensamblaje de diccionario
reproducción de macros 78 Generador 34 integraciones, parte 2473 devenv.
Propiedad de control exe, usando para registrar plantillas 8 Dexterity
Comandos, propiedad de formulario 87
AutoSetDexColors 29 comandos que Bridge ensamblado definido 145 descrito 11
Propiedad WinForms 26 acceden a través del código 111

capítulo 111112
B comandos de lista de comandos 111
error de proceso en segundo plano, al comandos de formulario 111 Ensamblaje de Dexterity Shell
definido 145
no cerrar tablas 49 métodos para 111
BeforeModalDialog, evento de ventana 91 búferes, descrito 11
referencia de recursos 111
definido 145 Generador de ensamblajes de diccionario
comandos de script 111 tipos
construcción e implementación, capítulo 6567 ensamblaje de aplicaciones 33
de 111
construcción de integraciones 66 capítulo 3336
componentes, instalados con Visual Studio
botones comandos para 34 crear
campo 30 ensamblajes de aplicaciones 33 definido 145
Herramientas 9 componentes de composites
imágenes para 30 descrito 12, 33
accediendo a través del código 125
estándar 29 área
definido 123
de estado 30 barra archivo de datos de IntelliSense
recuperando número de componentes 127 campos
de herramientas 34 archivo de inicio usado
compuestos eventos
29 barra de herramientas con para 128 métodos 35 optimización del procesamiento
separador 30 tipos de 29 para 125 propiedades 36 salida de 33 uso
Propiedad ButtonType, para controles de botón 34 cuándo
para 127 compuestos
29 usar 33 dónde está
accediendo a
instalado 34
componentes 125

ÍNDICE
clase de diccionario eventos (continuación) funciones (continuación)

definida 145 cancelación del registro capítulo 119122
ejemplos 38 para 44 cancelación del registro con código C# procedimientos invocables 122
formas alternativas 72 para 44 cancelación del registro con código Visual Basic parámetros de aprendizaje 121
formas modificadas 71 tipos 45 valor de retorno de aprendizaje 121
de recursos para acceder 38 usando ejemplo de métodos para 120
para acceder a los recursos del diccionario excepciones 73 parámetros opcionales 120 tipos
38 manejo de formas modificadas y alternativas 73 de parámetros 120
recursos de diccionario parámetros para 121
accediendo 37 referencia de recursos 119
accediendo a través de clase de diccionario 38 valor de retorno 120

recursos adicionales 39 lista de Campo F , botones 30
84 listas en Descripción general GRAMO
IntelliSense 38 espacio de de Field Defaulter Get(), método de tabla 106
nombres para acceder 38, 39 variable para 131 ejemplo de integración 131 GetFirst(), método de tabla 106
39 trabajar con 84 uso de Visual Studio Tools 132 campos GetLast(), método de tabla 106
globales GetNext(), método de tabla 106
Deshabilitar 145 locales GetPrevious(), método de tabla 106

() método de comando 111 145 campos Getting Started, parte 613 campos
de tabla 109 campos globales, definido 145 funciones
método de campo compuesto 126
método de campo de ventana 100 de ventana 99 globales accediendo
archivos, ver tablas a través del código 119 descrito 119
deshabilitar eventos 70
procedimientos
Dispose(), documentación del método
de formulario 87, símbolos y convenciones Rellenar () método de campo compuesto 126 globales accediendo a
3 método de campo de tabla 109 través del código 115 descrito 115
método de tabla 106 búferes de tablas
Dynamics.exe, proceso de aplicación al depurar 69
método de campo de ventana 100 globales accediendo 103
enfocar, eliminar de la ventana actual 89 descrito 48, 103
Y Focus() acceso compartido 48,
Método de método de campo compuesto 126 103 globales accediendo a
comando Enable() 112 método método de campo de ventana 100 través del
de campo compuesto 126 método de ForceValidate() código 113 capítulo 113 114
campo de ventana 100 método de campo compuesto 126 propiedades 145
Evento de campo método de campo de ventana 100 definidas para
compuesto EnterAfterOriginal 128 funciones de nivel de 113 referencia de recurso

evento de campo de ventana 102 formulario que acceden a través del 113
Evento de campo compuesto código 119
EnterBeforeOriginal 128 evento de descritos 119 procedimientos H

campo de ventana 102 de nivel de formulario que acceden a Método
Descripción general de los través del código de comando Hide() 112 método
detalles ambientales 115 descritos 115 búferes de de campo compuesto 126 método de
campo de ventana 100
137 ejecución tablas de nivel de
137 integración de muestra 137 formulario que acceden
uso de Visual Studio Tools 138 a 103 I
Implementación del soporte de macros, capítulo
errores, para operaciones de tabla 54 descritos 48, 103 formularios que
7578
Descripción general de acceden a través
Estimar flete 133 del código 85 Método Initialize(), para registrar eventos
41
ejecución 133 capítulo 85 88
instalación
integración de muestra 133 uso eventos para 88
de Visual Studio Tools 134 métodos para 85 propiedades capítulo 710
SDK de herramientas de Visual Studio 7
argumentos de eventos, al reproducir macros 76 eventos para 87 referencia de
Conceptos básicos de integración, capítulo 1113
recursos 85 formularios diccionarios
Ejemplos de integración, partes 130143
cancelar eventos 44 capítulo ensamblados de aplicaciones para 33
ensamblados integraciones
4145 deshabilitar
construyendo
70 argumentos de aplicaciones para 71 definidos 145 ensamblados de aplicaciones de generación para
35 66 depurando 69
de eventos 43 descripción
general 41 función, eventos para 120 implementando
67 configurando información de ensamblado 65
registrarse 41 Funciones, propiedad de formulario 87
funciones IntelliSense, tabla de información en 48
registrarse con código C# 41
Archivos XML de IntelliSense
registrarse con código Visual Basic 42 responder a cambiar valores de parámetros 122 cambiar
descritos 12
43 valores de retorno 122
generando 34

ÍNDICE
Archivos XML de IntelliSense (continuación) LineInsertAfterOriginal, desplazamiento formularios modificados (continuación)

instalación 7 evento de ventana 97 creación de ensamblado de aplicaciones para 71
convención de nomenclatura 34 LineInsertBeforeOriginal, desplazamiento directrices
Método de evento de ventana 97 definidas 145 para acceder 73
función Invoke() 120 método LineLeaveAfterOriginal, desplazamiento usando try...catch with 73
de procedimiento 116 evento de ventana 97 usando Visual Studio Tools 71 procesamiento
Método IsAsynchEventPending() 78 LineLeaveBeforeOriginal, desplazamiento multiusuario descrito 59
IsChanged, propiedad de ventana 89 evento de ventana 97 lectura de filas
IsEmpty Propiedad LinkField, para controles de etiqueta 32 61 eliminación de

propiedad de campo compuesto 127 controles de cuadro de lista, describió filas 62 actualización de
propiedad global 113 32 campos filas 61
propiedad de campo de tabla locales que
acceden 99 N
110 propiedad de campo de ventana 101
IsFilled definió 145 nombres, anulando el nombre del ensamblado de la
aplicación
propiedad de campo compuesto 127 describió 99 convención de nomenclatura para 99
propiedad global 114 Lock() 36 espacio de nombres, para acceder a los
propiedad de campo de tabla método de campo compuesto 126 recursos del diccionario 38, 39
110 propiedad de campo de ventana 101 método de campo de ventana 100
propiedad bloqueo
O
Open()
de formulario IsOpen bloqueo activo 59
método de formulario
87 propiedad de ventana 89 escenarios multiusuario 59
87 método de ventana 89
bloqueo pasivo 59
k liberación de bloqueos
Evento de formulario
OpenAfterOriginal
Clave, propiedad de tabla 107 59 filas 59
88 evento de ventana 90
claves búsquedas
definidas 145 disponibles para usar en Visual Studio OpenBeforeOriginal
para tablas 50 formulario evento
88 ventana evento 90
segmentos para 50 Herramientas
control de concurrencia optimista, descrito
80 ejemplo 80
L 59
operación de 79 utilizando ventanas de búsqueda existentes 79
controles de optimización, generación de ensamblado de
Integración de muestra
etiquetas aplicaciones 36
de búsquedas 141
descritos 32 campo
descripción
vinculado 32
general 141
archivo de inicio Parámetros P
ejecución 141 uso de Visual Studio Tools 142
para funciones 121
definido 145 utilizado por Dictionary Assembly
Generador 35 M para procedimientos 117
Evento de campo parámetros opcionales 116, 120
macro admite
compuesto LeaveAfterOriginal 128 bloqueos pasivos
procesos asincrónicos 78 para
evento de campo de ventana 102 definidos 145
formularios de Visual Studio Tools 75
descritos 59
LeaveBeforeOriginal evento sintaxis de macros 75
de campo compuesto 128 evento descripción liberación 59
de campo de ventana 102 Método PlayMacroItem(), anulando 76 requisitos
general 75 reproducción
Longitud, propiedad de campo compuesto 127 previos, para usar Visual Studio Tools para
de macros 76 grabación de
símbolo de bombilla 3 Microsoft Dynamics GP 2 PrintAfterOriginal,
macros 75 diccionario
LineChangeAfterOriginal, desplazamiento evento de ventana 90 PrintBeforeOriginal, evento
principal generación de ensamblado de aplicaciones para
evento de ventana 97 35 de ventana 90 Procedimientos, propiedad de
LineChangeBeforeOriginal, evento de ventana de formulario 87 procedimientos que
reemplazando el nombre del ensamblado
desplazamiento 97 de la cambian
LineDeleteAfterOriginal, desplazamiento valores de parámetros 117 capítulo
aplicación 36 notas
evento de ventana 97 115118 eventos
al margen 3 menús, agregando al menú Adicional 85
para 116
LineDeleteBeforeOriginal, desplazamiento Eventos de Microsoft Dynamics
evento de ventana 97 GP en 41 tablas procedimientos invocables 118
LineEnterAfterOriginal, evento de ventana de 47 parámetros de aprendizaje 117
desplazamiento 96 métodos para 115
Microsoft Dynamics GP SDK instalando
LineEnterBeforeOriginal, desplazamiento parámetros opcionales 116 tipos
información de
evento de ventana 96 2 tablas en 48 de parámetros 116
LineFillAfterOriginal, evento de ventana de parámetros para 117
Formas modificadas y alternativas, capítulo
desplazamiento 96 referencia de recursos 115
7173
LineFillBeforeOriginal, evento de ventana de formularios proceso, adjunto a Dynamics.exe para depuración
desplazamiento 95 69 ID de producto ,
modificados accediendo con el código 71
definido 145

ÍNDICE
soporte de productos, para proyectos de Visual Studio integraciones de muestra (continuación) tablas (continuación)
Tools para Microsoft Dynamics GP 3 Estimar flete 133 Field en Microsoft Dynamics GP 47 claves
agregando Defaulter 131 instalar 7 para 50
un formulario de Dynamics GP a 25 creando Búsquedas 141 aprender sobre 47
para Visual Studio Tools 12 Save(), método métodos para 104
PullFocus(), método de ventana 89 de tabla 107 guardar, filas en procesamiento multiusuario 59

tablas 51 desplazar ventanas abrir 49
R accediendo a la fila actual propiedades para 107
RangeClear(), método de tabla 106 96 accediendo a través del código rangos 55
RangeEnd(), método de tabla 106 95 capítulo 9597 describió 95 eliminar filas 53 referencia
RangeRemove(), método de tabla 106 ejemplo eventos para 95 de recursos 103 recuperar filas
de rangos impidiendo que 50 guardar filas 51
55, 56, 57 para acceso a las filas se actualizar filas 52
la tabla 55 clave
muestren 96 referencia de recursos 95 SDK, para trabajar con 47 soporte
multisegmento 56 eliminación Microsoft Dynamics GP 2, 80 técnico, para
de filas en un rango 57 clave simple 55 segmentos definidos 145 para claves 50 compartiendo Herramientas de Visual Studio para Microsoft Dynamics
búferes de GP 3 plantillas para Visual Studio 2010
RangeStart(), método de tabla 106 tablas globales 7 para Visual
grabación de macros 75 48 Método de Studio 2012 7 registro manual 8
Método RecordMacroItem(), describió 75 referencias, a comando Show() 112 método de campo controles de cuadro de texto 31
ensamblajes de aplicaciones 37, compuesto aplicaciones de terceros,
71, 72 126 método de campo de ensamblajes de aplicaciones
registro de eventos 41 ventana 101 firma, ensamblados de para 33 barra de herramientas, tipo de botón 29
registro de plantillas de Visual Studio 8 expresiones aplicación 35 SN.exe, descrito 35 barra de herramientas
regulares, para analizar instrucciones macro 77 configuración de solución, para una Proyecto con separador, tipo de botón
de Visual Studio 66 botones 30 probar.. .catch, usando con modificado y
Lanzamiento, configuración de la solución 66 estándar 29
Release(), método de tabla 107 formas alternativas 73
liberando bloqueos en las filas de la tabla 59
Remove(), método de tabla 107 área de estado EN
eliminación de filas botones 30 Desmarcar(), método de comando 112
de tablas 53 definido 145 Desbloquear
consideraciones multiusuario 62 descrito 26 () método de campo compuesto 126
Herramienta Descripciones de recursos, descrita 47 método de campo de ventana 101
StatusArea, WinForms propiedad 26 archivo de
Referencia de recursos, partes 84122 clave de nombre seguro, describió 35 nombres anular el registro de eventos 44
recursos, consulte recursos de diccionario seguros, para ensamblajes de aplicaciones actualizar filas en
respuesta a eventos 43 35 tablas 52
recuperación de filas consideraciones multiusuario 61

soporte, para Visual Studio Tools para
de tablas 50 Actualización de una integración, capítulo 1521
Símbolos de Microsoft Dynamics
consideraciones multiusuario 61 actualización de integraciones
GP 3 en la documentación 3
bloqueo de fila Integraciones de C# 15
bloqueo activo 59 descritas 15 de
descripción 59 Búferes de tabla la versión 10 o posterior 20 de la
bloqueo pasivo 59 T definidos 145 versión 9 15
liberación de bloqueos 59 descritos 48, 103 nivel Integraciones de Visual Basic 17

filas de formulario 48 Interfaz de usuario, para proyectos de Visual Studio
bloquear 59 global 48 Tools 25
eliminar de tablas 53 recuperar de compartir acceso 48 Uso de búsquedas, capítulo 7982
tablas 50 guardar en tablas 51 campos de
actualizar en tablas 52 tabla accediendo a través de código

EN
109 capítulo 109110 Evento de campo compuesto
Run (), método de comando 112 métodos para 109 ValidateAfterOriginal 128 evento de
campo de ventana 102
componentes de tiempo de ejecución, para Visual Studio propiedades para 110
Herramientas 11 referencia de recursos 109 ValidateBeforeOriginal evento
RunValidate() rangos de tabla, ejemplo 55, 56, 57 de campo compuesto 128 evento
de campo de ventana 102
método de campo compuesto 126 Tablas, propiedad de formulario
método de campo de ventana 101 87
tablas accediendo a través de código 48, 103 propiedad de campo compuesto de valor 127
capítulo 103107 propiedad global 114

Integraciones de muestra S cierre 49 propiedad de campo de tabla
Detalles Ambientales 137 110 propiedad de campo de ventana 101
errores de operaciones de tabla 54
PLANTILLA DE 150 PROGRAMADORES

ÍNDICE
variables, para recursos de diccionario 39

Registro de
eventos de Visual Basic 42

configuración de información de ensamblado
66 anulación del registro de
eventos 45 actualización de integraciones 17
Se requiere la
actualización de Visual Studio a la versión 2010

9 de Visual Studio para Visual Studio
Herramientas 2
Visual Studio Tools acceso
a formularios modificados 71
arquitectura 11
capacidades 11
componentes instalados 9
creación de interfaz de usuario 25
componentes de desarrollo 12 requisitos
previos 2 proyectos,
creación de 12 componentes
de tiempo de ejecución 11
Instalación SDK 7 soporte
técnico 3
símbolo de advertencia
3 campos de
ventana accediendo a través del

código 99 capítulo
99102 eventos
para 102 métodos
para 99 propiedades
para 101 referencia de
recurso 99
ventanas accediendo a través del

código 89 capítulo
8993 eventos
para 90 campos
locales 99 métodos
para 89 propiedades
para 89 referencia de recurso 89
WinForms
agregando controles a 27
agregando a un proyecto 25
capítulo 2527
propiedades para 26
Trabajar con tablas, capítulo 4763
X
Archivos XML, para IntelliSense 12

VSTDGPProgrammersGuide ESP

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

VSTDGPProgrammersGuide ESP

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

Herramientas de Visual Studio® para Microsoft Dynamics® GP 2013

El resto de marcas registradas son propiedad de sus respectivos propietarios.

Fecha de publicación julio de 2012

Contenido de este manual ............................................... .................................................... ....................................2

Requisitos previos.................................................. .................................................... ..........................................2

Símbolos y convenciones .................................................. .................................................... ..........................3 Soporte

de productos ..................... .................................................... .................................................... ...................3

Parte 1: Primeros pasos .................................................. .................................................... ....................6

Capítulo 1: Instalación del SDK................................................ .................................................... ......... 7 Procedimiento de

plantilla..... .................................................... .................................................... ..........................8

Actualizar a un Visual Studio más nuevo.................................................. .................................................... .............9

Capítulo 2: Conceptos básicos de integración ........................................... .................................................... ...11

Creación de un proyecto ............................................... .................................................... ..........................................12

Capítulo 3: Actualización de una integración ........................................... .................................. 15 Actualización desde la

versión 10 o posterior .................................. .................................................... ......................20

Parte 2: Desarrollo de integraciones ............................................... ..........................................24

Capítulo 4: WinForms ............................................... .................................................... ...................... 25 Adición de un

de WinForm ............... .................................................... .................................................... ...........26 Adición de

controles.................................... .................................................... .................................................... ...27

Capítulo 5: Referencia de control ............................................. .................................................... .29

Cajas de texto................................................. .................................................... .................................................... .31

Etiquetas................................................. .................................................... .................................................... .......32

Cuadros combinados .................................................. .................................................... .............................................32

Cuadros de lista .................................................. .................................................... .................................................... .32

Capítulo 6: Generador de ensamblado de diccionarios .................................. .................. 33 Creación de conjuntos de

salida .............. .................................................... .................................................... ..........................33 Uso del

generador de ensamblado de diccionarios .................. .................................................... ..............................34

Optimización del proceso de generación de ensamblajes .................. .................................................... ..........................36

Capítulo 7: Acceder a los recursos del diccionario......................................... .......... 37 Adición de

nombres................................... .................................................... .................................................... ...38 Clase de

diccionario ............................................. .................................................... .............................................38

GUÍA DEL PROGRAMADOR i

Acceder a recursos adicionales .................................................. .................................................... ..........39 Variables

para recursos de diccionario ............................... .................................................... .............................39

Capítulo 8: Eventos .................................................. .................................................... ...............41 Registro de

eventos .................................. .................................................... .................................................... .43 Dar de baja

eventos.................................................... .................................................... ....................................44

Capítulo 9: Trabajar con tablas.................................................... ...................................................47 Tablas en Microsoft

Apertura y cierre de mesas .............................................. .................................................... .......................49

Teclas................................. .................................................... .................................................... ..................................50

Recuperación de una fila ............ .................................................... .................................................... ..........................50

Guardar una fila ............... .................................................... .................................................... ........................51

Actualizar una fila ...................... .................................................... .................................................... ...........52 Eliminación

de una fila .......................... .................................................... .................................................... .........53 Errores de

operación de la tabla .................................. .................................................... .......................................54

Rangos....... .................................................... .................................................... ..........................................55 Fila

bloqueo .................................................. .................................................... .............................................59 Procesamiento

multiusuario . .................................................... .................................................... .............................59

Capítulo 10: Construir e implementar ............................................... ..................................65 Configuración de la información

integración ............................................... .................................................... ....................................66 Desplegando una

integración ........... .................................................... .................................................... .............67

Capítulo 11: Depuración.................................................... .................................................... ...........69 Preparándose para

solicitud ........................................... .................................................... .............................70 Deshabilitar

eventos .................. .................................................... .................................................... .....................70

Capítulo 12: Formas modificadas y alternativas ........................................... ....................71 Formas

Formas alternativas ................................................ .................................................... ..........................................72

Pautas ................................................. .................................................... ..................................................73

macros .... .................................................... .................................................... ...............................75 Reproducción de

macros ................ .................................................... .................................................... ..........................76 Manejo de

procesos asincrónicos durante la reproducción .................. .................................................... .......78

Capítulo 14: Uso de búsquedas.................................................... .................................................... .......79 Cómo funcionan

disponibles... .................................................... .................................................... ............................80 Ejemplo de

búsqueda ............ .................................................... .................................................... ..........................80