Navegación dinámica para un mayor rendimiento

Navegación dinámica para un mayor rendimiento


la Reducción o eliminación de código de navegación de la interfaz gráfica de usuario mediante la adición de derivados de enlaces y, al mismo tiempo, mejorar el rendimiento.

el Modelado de las estructuras de la clase se lleva a algunos a pensar, y cuando se hace el pensamiento y el dibujo, y después de que el uso del modelo, entonces pasará horrible montón de código que atraviesan los enlaces para recuperar trivial de información en una estructura de objetos. La navegación por el mismo somtimes vínculo complicado-caminos una y otra vez toma energía de la CPU, y también tarda mucho código redundante y/o expresiones de acceder a las mismas rutas de navegación y otra vez. En el Audaz arquitectura también lugar redundante suscripciones de muchos lugares diferentes para el mismo destino de la suscripción a los mismos caminos, más de una vez más.

Pero con Negrita usted puede a menudo directamente de la dirección innecesario de navegación, el redundantes de navegación, el código/ocl-expresiones y obtener la disminución de la carga de la CPU mediante la adición de derivados de asociaciones en lugar de hacer la par de los enlaces permanentes más útil e 'inteligentes'. Y, además, hacerlo directamente en su modelo de tu modelo, al mismo tiempo, reflejar, más específicamente, qué partes del modelo se utiliza realmente. Y cómo.

Un ejemplo puede mostrar una típica situación en la que la adición de muchos derivados de enlaces, extender el modelo con más información útil, el resultado será más eficiente, menos redundante y más legible el código. Si estábamos hablando tradicional artesana que, probablemente, hubiese pensado que era una broma, porque por lo general, no nos salvará de más problemas mediante la adición de más las relaciones entre los objetos...! Pero yo no estoy bromeando - usted realmente va a lograr todos los mencionados beneficios mediante la adición de un par de líneas sencillas para el modelo de uso de la Negrita.

EJEMPLO

Un camión combinación de vehículos nos pueden servir con un ejemplo. El modelo de ejemplo se componen de unidades de Vehículos, algunas Parcelas y un viaje objeto de mantener toda la información de los viajes y los cálculos. Con estas tres categorías básicas vamos a terminar escribiendo casi el 50% de código (o expresiones) en los algoritmos de navegación de la estructura básica que tiene sólo tres los enlaces permanentes... Tal codificación es trivial, se toma su tiempo y no aporta nada de valor al sistema.

en Primer lugar un 'RIL mundial de la representación' del ejemplo antes de que se represente mediante un diagrama de clases de UML ('RIL' es las iniciales de mi nombre) :

Fig 1: Este Vehículo de combinación contiene de los Paquetes, pero sólo la parte delantera de la mayoría de VehicleUnit mantiene Viaje de info acerca de las distancias, los eventos y los cálculos económicos.

1.jpg

el Desprecio de los aspectos de las artes de la ilustración. Por varias razones, no se discuten aquí, la VehicleUnits se muestra arriba siempre tiene un viaje de objetos conectados, pero sólo la parte delantera de la mayoría de viaje de un objeto es la representación de toda la combinación. El otro viaje objetos/calculadoras son 'desmovilizados' hasta que el remolque (posiblemente) se desconecta de la camioneta y, a continuación, el trailer será válido ('principal') TripHolder por su propia cuenta.

Imagínese que usted está viendo una de las unidades de Vehículos o uno de los Paquetes en una interfaz de usuario y usted probablemente desea saber más acerca de viaje relacionados con la info, tal vez las distancias recorridas, las direcciones visitadas, el pásate por fin, costos o ingresos por km, etc (todos administrados por el viaje objeto).

sólo Hay tres relaciones en este modelo, pero todavía tendría que pensar dos veces cuando se trata de navegar correctamente tratando de encontrar la 'calculadora' (de aquí en representación de un 'viaje de clase').

sería aún peor si desea implementar algunos de los genéricos de la lógica o de los cálculos de la VehicleUnits, porque siempre tiene que asegurarse de que usted vaya a la 'frente a la mayoría de los vehículos de la unidad' (vamos a llamarlo el 'transportista') y desde allí se accede directamente a la información de los viajes (la calculadora).

En la aplicación real hay tanta información incrustados en la estructura básica de que los tres enlaces se accede/navegar de nuevo y de nuevo tantas veces que muchos cientos de líneas de código (y/o expresiones OCL) se habrían de escribir 'aquí, allá y en todas partes'. Una de las cosas malas con esto es que si usted explícitamente recorrer estos enlaces cada vez que usted necesita para acceder a un objeto o atributo en el otro extremo de la estructura, deberá ejecutar esta lógica en la CPU todo el tiempo.

Otra cosa mala es que su núcleo de negocio de la lógica de 'ahogarse' en el código y las expresiones lidiar con este trivial de navegación como 'if then else, for i :=' y asignar los cheques. Aquí es donde derivan los enlaces pueden ser de gran ayuda para evitar una lógica de desastre (derivados de atributos también, por supuesto).

Fig 2: Una clase simple modelo de la ilustración de arriba podría ser algo como esto :

2.jpg

El problema de la navegación es más obvio en este modelo de clase que en el 'RIL mundo de la ilustración'.

Si me seleccionado un Paquete en una interfaz gráfica de usuario de la lista y la información necesaria desde el viaje objeto no podía estar seguro de exactamente la ruta de navegación a los 'movilizados' viaje de un objeto que es el que sostiene la validez de viaje de info. Ejemplo:

Si el paquete se carga en un remolque de la expresión 'vehicleUnit.viaje' devolvería un desmovilizados viaje de objeto, pero si el paquete se ha cargado en el transportista volvería el deseado 'movilizado' viaje de objeto. Esta complicación es razón suficiente para agregar un vínculo derivada de solucionar el problema directamente en el modelo, de manera que uno nunca más tendría que tener esto en cuenta al diseñar algoritmos o navegar por la estructura. Definitivamente, me gustaría añadir un enlace llamado 'EffectiveTrip' de la siguiente manera :

Fig 3: Un enlace llamado 'EffectiveTrip' se agregó a la modelo. (Yo siempre trato de dejar que el color azul se representan los 'persistentes' (='congelar') y naranja que representa la 'derivada' para los enlaces).

3.jpg

Como yo ya se puede prever que este enlace se accede por numerosas combinaciones de vehículos (en grids, etc) Me gustaría duro código de la derivación de la optimización de la lógica aquí para encontrar 'frente a la mayoría de vehículo' y que significa atravesar el remolque/transportista de enlace y se detiene cuando el transportista de enlace es igual a cero (=IsFrontMost). A partir de ahí podemos hacer referencia al viaje de objeto directamente. Pero también sé que la búsqueda de la frente a la mayoría de los vehículos (la combinación de la transportista) es muy típica y que va a suceder, incluso, más a menudo de lo que el acceso al viaje de objeto en sí mismo. Ya sé que el EffectiveTrip enlace como bien puede usar este tipo de derivados enlace! Permite añadir de inmediato, dándole el nombre de 'CombinationFirst'.

yo he elegido el nombre de 'CombinationFirst' porque entonces se da cuenta de inmediato de la típica en esta situación. Es una lista típico problema de la gestión. Ya se puede imaginar la utilidad de un otro derivado de un enlace que podemos llamar 'CombinationLast' e incluso un tercer enlace llamado 'CombinationUnits'!

puedo asegurar que estos vínculos se utiliza con frecuencia y por lo tanto el 'costo' de la evaluación de ellos será pagado ya la segunda vez que utilice cualquiera de ellos !

Fig 4: no se deriva también de los enlaces requieren de la CPU con el fin de ser evaluados...? usted puede pedir. La respuesta es, sí, por supuesto - pero sólo una vez - si el suscrito elementos no cambian. Y esto no es muy probable que aquí, pero la muy 'hot spot' de la estructura de aquí va a ser utilizado en muchos lugares, en la lógica de acceso a los objetos de la cruz muy a menudo y cuando se hace por lo que los enlaces ya hace referencia directamente a las instancias que desea acceder. Mira el 'lío' de abajo... ! :

4.jpg

Esto una solución de alto rendimiento utilizando el modelo como herramienta para la optimización, y al mismo tiempo los enlaces adicionales están aclarando/indica directamente en el modelo de la intención de uso de esta estructura específica !

Para aquellos de ustedes que piensan que por fin tengo mad puedo decir que yo no. En su lugar he aumentado la velocidad de los cálculos y todas las actividades relacionadas con esta estructura en las aplicaciones del mundo real con muchos de mil por ciento en comparación a definir explícitamente toda la ruta de navegación cada vez que la combinación de viaje o un Vehículo específico de la unidad (o atributo en cualquiera de ellos) fue alcanzada !

Todos los tipos de datos que se almacenan en esta estructura, y más de 30 derivada de atributos para diferentes propósitos del cálculo de los accesos de la estructura de ida y vuelta todo el tiempo, proporcionando el usuario del cliente en tiempo real con los cálculos de los ingresos/km y las distancias, la distancia de las acciones de los totales, la participación en las acciones de... etc, etc.

La cosa es dejar un vínculo derivada del uso de los otros enlaces como a menudo culo es posible, entonces, incluso la necesidad de reevaluar los enlaces cuando las cosas cambios disminuye!

La última afirmación se puede verificar muy claramente con un ejemplo aparte de mostrar lo importante que es para 'REUTILIZAR' todo lo que se derivan para cada nivel superior (en cuanto a que parte de la estructura es más probable que cambie y que parte es más 'estática'). Con la 'reutilización' me refiero a 'la CPU de trabajo ya está hecho' a la hora de derivar el enlace. Más sobre este podría ser tema para un artículo independiente.

Ahora veamos el código. Tenemos que conseguir que el viaje objeto (para algunos reson), a partir de una Parcela, pero no sabemos en que VehicleUnit estamos cargados de modo que empecemos a buscar usando el enlace 'EffectiveTrip' que 'esconde' la lógica de la determinación de que el viaje objeto es 'movilizados' (he.e 'eficaz') :


función TParcel.CalculateTrip_Something...: Doble
var
TripObj : TTrip
begin
TripObj := vehicleUnit.effectiveTrip // eso es todo! ...

Fácil, esto es claro de código. Los detalles acerca de cómo obtuvimos el viaje correcta objeto no debe ser la mezcla de la lógica de negocio que se ocupan del acceso o cálculos en la estructura del objeto.

En nuestro mundo real de la aplicación de ambos VehicleUnits y Parcelas tienen en común un super clase (no se muestra aquí). Un vehículo puede ser instalada en otro vehículo, al igual que cualquier otra parcela por lo que el código anterior es aún más simple en mi último modelo genérico donde la derivada de enlace es 'virtual overrided' en diferentes subclases. Mi código final va como esto :


begin

TripObj := effectiveTrip // eso es todo!

El Paquete encontrará en su viaje válido el uso de este comando, independientemente de lo complicada que es la ruta de acceso puede ser. Esto se muestra en la figura 5, donde una nueva comunes clase super actualmente es el dueño de la persistente y derivados enlace a la clase de disparo y la EffectiveTrip-link es implementado primero en el TParcel y, a continuación, overrided para la VehicleUnit clase como se muestra a continuación.

Fig 5: Aquí he modificado el modelo a ser más genérico que permite a cualquier 'planable objeto de' llevar un lote de otros planable objetos - y como el modelo va más genérica de la función de los nombres de hacerlo también.


5.jpg

Viaje info se aplica directamente para una Parcela demasiado (a través de AbstractPlanPortion) porque una empresa de transporte puede planificar una parcela en la que se entregan con, por ejemplo, un avión que los totales no estamos interesados, pero todavía estamos interesados en hacer el seguimiento de cualquier viaje de los eventos involucrados en el transporte, y la documentación y las transacciones se adjunta a la parcela de la misma, etc. Pero esto también significa que cuando hay necesidad de acceder a la 'eficacia' de viaje objeto que también se necesitan para llevar a cabo muy complicado cheques de toda la estructura tratando de averiguar en qué contexto la (correcta, 'movilizados') viaje de un objeto se puede encontrar... Esto realmente va a hacer que nuestra lógica es algo complicado para una cosa tan simple como simplemente recuperar algunos datos de la estructura. Una verdadera pesadilla, de hecho,...

Esta complicación de una cosa tan simple no es muy singular. Lo que es único es la forma en que pueden ser tratados con el uso de la Negrita de la tecnología, con sus derivados de enlaces.

El Paquete puede ser el TripHolder mismo, o si el Paquete se carga en un portador que no sé si es cargado en el soporte que en realidad contiene la información de los viajes. Es realmente necesario hacer algunas navigatiion aquí. En una situación como esta se puede fácilmente imaginar cuánto de codificación y de lo complicado expresiones OCL sería acceder a la información en la estructura. Su núcleo de negocio de la lógica de 'ahogarse' en la navegación de la lógica cuando simplemente recuperar las cosas más triviales de la estructura y de la CPU pasaría mucho tiempo para encontrar Su camino(s) a los objetos de destino/de datos.

por último : Tres (3) de los enlaces permanentes celebración de la estructura de todos juntos acabaron en otro de los cinco (5) muy útil derivados de enlaces ! El resultado es que la final de la aplicación se ejecuta mucho más rápido y la lógica de negocio se mantiene más allá de trivial de navegación sin fin de atravesar las estructuras de los objetos.

Antes de listar el código más eficiente para la optimización de los codificado derivaciones de los enlaces, me gustaría concluir con estos enlaces puede, desde cualquier lugar en la estructura, ir a cualquier lugar - directamente - por la referencia a link miembros con nombres totalmente aclarar lo que se pretende acceder, y esto se hará en la forma más eficaz que usted puede venir para arriba con el uso regular Audaz arquitectura.

Con 'eficiente' que significa 'siempre acceso directo a la meta deseada instancia de objeto' (excepto para la primera evaluación que en mi caso solo pasa una vez por cientos de accesos...).

Esto es sólo una parte de los conceptos que hemos utilizado conscientemente para hacer posible lo que antes no era posible : el uso regular, pero 'diseño limpio', siguiendo el modelo estructurado y orientado a objetos clases de negocios escénicas de alto rendimiento en tiempo real (re)cálculos de muy avanzada viaje cálculos (no se discute aquí). En una sola CPU (servidor de aplicaciones) para varios clientes.

Derivación código, con comentarios

En el código de abajo te subrayó todas las referencias internas de la que se derivan los vínculos ('reutilización eficiente de los ya evaluados los resultados').

también he utilizado las variables locales y así evitar la interna 'buscar' de la Negrita miembros más de una vez (=> evita repetir la activación de los internos en negrita eventos, etc).

La eficiencia de todo el concepto discutido y la codificación detallada a continuación se verifica por medio de ProDelphi profiler (muy alta precisión ( -3%) sobre la medición del rendimiento del código).


{ TParcel }



procedimiento TParcel._EffectiveTrip_DeriveAndSubscribe(...)
// Si se cargan los portadores (en efectivo) viaje se devuelve,
// otra cosa que el viaje local (si existe).
var
CarrierObj: TVehicleUnit
ResultValue : TTrip
begin
M_batchHolder.DefaultSubscribe(Suscriptor, breResubscribe)
CarrierObj := batchHolder
si se ha Asignado(CarrierObj), a continuación,
begin
CarrierObj.M_EffectiveTrip.DefaultSubscribe(Suscriptor, breResubscribe)
ResultValue := CarrierObj.EffectiveTrip
fin
else
begin
M_trip.DefaultSubscribe(Suscriptor, breResubscribe)
ResultValue := viaje
fin
M_EffectiveTrip.BoldObject := ResultValue
fin



{ TVehicleUnit }



procedimiento TVehicleUnit._EffectiveTrip_DeriveAndSubscribe(...)
var
HaulerObj: TVehicleUnit
ResultValue,
TripObj: TTrip
begin
ResultValue := nil
M_CombinationFirst.DefaultSubscribe(Suscriptor, breResubscribe)
HaulerObj := CombinationFirst
// la que atraviesa ya está hecho aquí
si se ha Asignado(HaulerObj), a continuación,
begin
HaulerObj.M_Trip.DefaultSubscribe(Suscriptor, breResubscribe)
TripObj := HaulerObj.viaje
si se ha Asignado(TripObj), a continuación,
begin
TripObj.M_IsMobilized.DefaultSubscribe(Suscriptor)
si TripObj.IsMobilized, a continuación,
ResultValue := TripObj
fin
fin
M_EffectiveTrip.BoldObject := ResultValue
fin



procedimiento TVehicleUnit._CombinationFirst_DeriveAndSubscribe(...)
// Este enlace será el rápido 'atajo' que se utiliza por muchos
// funciones en este ámbito y otros enlaces y atributos, así
// significado de optimización, no 'extras' o 'candy' en el modelo.
var
LoopObj: TVehicleUnit
begin
LoopObj := Self // Travesía por delante
LoopObj.M_hauler.DefaultSubscribe(Suscriptor, breResubscribe)
mientras Asignados(LoopObj.Transportista)
begin
LoopObj := LoopObj.Compañia de transporte
LoopObj.M_hauler.DefaultSubscribe(Suscriptor, breResubscribe)
fin
M_CombinationFirst.BoldObject := LoopObj
fin




procedimiento TVehicleUnit._CombinationLast_DeriveAndSubscribe(DerivedObject: TObject Suscriptor: TBoldSubscriber)
var
LoopObj: TVehicleUnit
begin
LoopObj := Self
LoopObj.M_trailer.DefaultSubscribe(Suscriptor, breResubscribe)
mientras Asignados(LoopObj.remolque) no
begin
LoopObj := LoopObj.remolque
LoopObj.M_trailer.DefaultSubscribe(Suscriptor, breResubscribe)
fin
M_CombinationLast.BoldObject := LoopObj
fin




procedimiento TVehicleUnit.CombinationUnits_DeriveAndSubscribe(...)
var
LoopObj: TVehicleUnit
ResultList: TBoldObjectList
begin
M_CombinationUnits.Claro
ResultList := TBoldObjectList.Crear
prueba
M_CombinationFirst.DefaultSubscribe(Suscriptor, breResubscribe)
LoopObj := CombinationFirst
repetir
ResultList.Agregar(LoopObj)
LoopObj.M_trailer.DefaultSubscribe(Suscriptor, breResubscribe)
LoopObj := LoopObj.remolque
hasta LoopObj = nil
finalmente
M_CombinationUnits.AddList(ResultList)
FreeAndNil(ResultList)
fin
fin




procedimiento TVehicleUnit._CombinationLoadItems_DeriveAndSubscribe(DerivedObject: TObject Suscriptor: TBoldSubscriber)
// Una lista de recoger todos (lote)los objetos cargados en cualquier unidad en el
// combinación de vehículos. Implementado para la comodidad y el
// clearification.
var
UnitCnt, i: Integer
UnitObj: TVehicleUnit
begin
M_CombinationLoadItems.Claro
CombinationUnits.DefaultSubscribe(Suscriptor, breResubscribe)
UnitCnt := CombinationUnits.Cuenta
si UnitCnt > 0, entonces
begin
for i := 0 a UnitCnt-1 hacer
begin
UnitObj := CombinationUnits[i]
UnitObj.loadedItems.EnsureObjects
UnitObj.loadedItems.DefaultSubscribe(Suscriptor)
// Recoger todo si UnitObj.loadedItems.Count > 0 then
M_CombinationLoadItems.AddList(UnitObj.loadedItems)
fin
fin
fin

// Rolf Lampa

(Actual dirección de correo: rolf-dot-lampa-en-rilnet-punto-com)

& nbsp







Navegacion dinamica para un mayor rendimiento


Navegacion dinamica para un mayor rendimiento : Multi-millones de consejos para hacer su vida mas facil.


la Reduccion o eliminacion de codigo de navegacion de la interfaz grafica de usuario mediante la adicion de derivados de enlaces y, al mismo tiempo, mejorar el rendimiento.

el Modelado de las estructuras de la clase se lleva a algunos a pensar, y cuando se hace el pensamiento y el dibujo, y despues de que el uso del modelo, entonces pasara horrible monton de codigo que atraviesan los enlaces para recuperar trivial de informacion en una estructura de objetos. La navegacion por el mismo somtimes vinculo complicado-caminos una y otra vez toma energia de la CPU, y tambien tarda mucho codigo redundante y/o expresiones de acceder a las mismas rutas de navegacion y otra vez. En el Audaz arquitectura tambien lugar redundante suscripciones de muchos lugares diferentes para el mismo destino de la suscripcion a los mismos caminos, mas de una vez mas.

Pero con Negrita usted puede a menudo directamente de la direccion innecesario de navegacion, el redundantes de navegacion, el codigo/ocl-expresiones y obtener la disminucion de la carga de la CPU mediante la adicion de derivados de asociaciones en lugar de hacer la par de los enlaces permanentes mas util e 'inteligentes'. Y, ademas, hacerlo directamente en su modelo de tu modelo, al mismo tiempo, reflejar, mas especificamente, que partes del modelo se utiliza realmente. Y como.

Un ejemplo puede mostrar una tipica situacion en la que la adicion de muchos derivados de enlaces, extender el modelo con mas informacion util, el resultado sera mas eficiente, menos redundante y mas legible el codigo. Si estabamos hablando tradicional artesana que, probablemente, hubiese pensado que era una broma, porque por lo general, no nos salvara de mas problemas mediante la adicion de mas las relaciones entre los objetos...! Pero yo no estoy bromeando - usted realmente va a lograr todos los mencionados beneficios mediante la adicion de un par de lineas sencillas para el modelo de uso de la Negrita.

EJEMPLO

Un camion combinacion de vehiculos nos pueden servir con un ejemplo. El modelo de ejemplo se componen de unidades de Vehiculos, algunas Parcelas y un viaje objeto de mantener toda la informacion de los viajes y los calculos. Con estas tres categorias basicas vamos a terminar escribiendo casi el 50% de codigo (o expresiones) en los algoritmos de navegacion de la estructura basica que tiene solo tres los enlaces permanentes... Tal codificacion es trivial, se toma su tiempo y no aporta nada de valor al sistema.

en Primer lugar un 'RIL mundial de la representacion' del ejemplo antes de que se represente mediante un diagrama de clases de UML ('RIL' es las iniciales de mi nombre) :

Fig 1: Este Vehiculo de combinacion contiene de los Paquetes, pero solo la parte delantera de la mayoria de VehicleUnit mantiene Viaje de info acerca de las distancias, los eventos y los calculos economicos.

1.jpg

el Desprecio de los aspectos de las artes de la ilustracion. Por varias razones, no se discuten aqui, la VehicleUnits se muestra arriba siempre tiene un viaje de objetos conectados, pero solo la parte delantera de la mayoria de viaje de un objeto es la representacion de toda la combinacion. El otro viaje objetos/calculadoras son 'desmovilizados' hasta que el remolque (posiblemente) se desconecta de la camioneta y, a continuacion, el trailer sera valido ('principal') TripHolder por su propia cuenta.

Imaginese que usted esta viendo una de las unidades de Vehiculos o uno de los Paquetes en una interfaz de usuario y usted probablemente desea saber mas acerca de viaje relacionados con la info, tal vez las distancias recorridas, las direcciones visitadas, el pasate por fin, costos o ingresos por km, etc (todos administrados por el viaje objeto).

solo Hay tres relaciones en este modelo, pero todavia tendria que pensar dos veces cuando se trata de navegar correctamente tratando de encontrar la 'calculadora' (de aqui en representacion de un 'viaje de clase').

seria aun peor si desea implementar algunos de los genericos de la logica o de los calculos de la VehicleUnits, porque siempre tiene que asegurarse de que usted vaya a la 'frente a la mayoria de los vehiculos de la unidad' (vamos a llamarlo el 'transportista') y desde alli se accede directamente a la informacion de los viajes (la calculadora).

En la aplicacion real hay tanta informacion incrustados en la estructura basica de que los tres enlaces se accede/navegar de nuevo y de nuevo tantas veces que muchos cientos de lineas de codigo (y/o expresiones OCL) se habrian de escribir 'aqui, alla y en todas partes'. Una de las cosas malas con esto es que si usted explicitamente recorrer estos enlaces cada vez que usted necesita para acceder a un objeto o atributo en el otro extremo de la estructura, debera ejecutar esta logica en la CPU todo el tiempo.

Otra cosa mala es que su nucleo de negocio de la logica de 'ahogarse' en el codigo y las expresiones lidiar con este trivial de navegacion como 'if then else, for i :=' y asignar los cheques. Aqui es donde derivan los enlaces pueden ser de gran ayuda para evitar una logica de desastre (derivados de atributos tambien, por supuesto).

Fig 2: Una clase simple modelo de la ilustracion de arriba podria ser algo como esto :

2.jpg

El problema de la navegacion es mas obvio en este modelo de clase que en el 'RIL mundo de la ilustracion'.

Si me seleccionado un Paquete en una interfaz grafica de usuario de la lista y la informacion necesaria desde el viaje objeto no podia estar seguro de exactamente la ruta de navegacion a los 'movilizados' viaje de un objeto que es el que sostiene la validez de viaje de info. Ejemplo:

Si el paquete se carga en un remolque de la expresion 'vehicleUnit.viaje' devolveria un desmovilizados viaje de objeto, pero si el paquete se ha cargado en el transportista volveria el deseado 'movilizado' viaje de objeto. Esta complicacion es razon suficiente para agregar un vinculo derivada de solucionar el problema directamente en el modelo, de manera que uno nunca mas tendria que tener esto en cuenta al diseñar algoritmos o navegar por la estructura. Definitivamente, me gustaria añadir un enlace llamado 'EffectiveTrip' de la siguiente manera :

Fig 3: Un enlace llamado 'EffectiveTrip' se agrego a la modelo. (Yo siempre trato de dejar que el color azul se representan los 'persistentes' (='congelar') y naranja que representa la 'derivada' para los enlaces).

3.jpg

Como yo ya se puede prever que este enlace se accede por numerosas combinaciones de vehiculos (en grids, etc) Me gustaria duro codigo de la derivacion de la optimizacion de la logica aqui para encontrar 'frente a la mayoria de vehiculo' y que significa atravesar el remolque/transportista de enlace y se detiene cuando el transportista de enlace es igual a cero (=IsFrontMost). A partir de ahi podemos hacer referencia al viaje de objeto directamente. Pero tambien se que la busqueda de la frente a la mayoria de los vehiculos (la combinacion de la transportista) es muy tipica y que va a suceder, incluso, mas a menudo de lo que el acceso al viaje de objeto en si mismo. Ya se que el EffectiveTrip enlace como bien puede usar este tipo de derivados enlace! Permite añadir de inmediato, dandole el nombre de 'CombinationFirst'.

yo he elegido el nombre de 'CombinationFirst' porque entonces se da cuenta de inmediato de la tipica en esta situacion. Es una lista tipico problema de la gestion. Ya se puede imaginar la utilidad de un otro derivado de un enlace que podemos llamar 'CombinationLast' e incluso un tercer enlace llamado 'CombinationUnits'!

puedo asegurar que estos vinculos se utiliza con frecuencia y por lo tanto el 'costo' de la evaluacion de ellos sera pagado ya la segunda vez que utilice cualquiera de ellos !

Fig 4: no se deriva tambien de los enlaces requieren de la CPU con el fin de ser evaluados...? usted puede pedir. La respuesta es, si, por supuesto - pero solo una vez - si el suscrito elementos no cambian. Y esto no es muy probable que aqui, pero la muy 'hot spot' de la estructura de aqui va a ser utilizado en muchos lugares, en la logica de acceso a los objetos de la cruz muy a menudo y cuando se hace por lo que los enlaces ya hace referencia directamente a las instancias que desea acceder. Mira el 'lio' de abajo... ! :

4.jpg

Esto una solucion de alto rendimiento utilizando el modelo como herramienta para la optimizacion, y al mismo tiempo los enlaces adicionales estan aclarando/indica directamente en el modelo de la intencion de uso de esta estructura especifica !

Para aquellos de ustedes que piensan que por fin tengo mad puedo decir que yo no. En su lugar he aumentado la velocidad de los calculos y todas las actividades relacionadas con esta estructura en las aplicaciones del mundo real con muchos de mil por ciento en comparacion a definir explicitamente toda la ruta de navegacion cada vez que la combinacion de viaje o un Vehiculo especifico de la unidad (o atributo en cualquiera de ellos) fue alcanzada !

Todos los tipos de datos que se almacenan en esta estructura, y mas de 30 derivada de atributos para diferentes propositos del calculo de los accesos de la estructura de ida y vuelta todo el tiempo, proporcionando el usuario del cliente en tiempo real con los calculos de los ingresos/km y las distancias, la distancia de las acciones de los totales, la participacion en las acciones de... etc, etc.

La cosa es dejar un vinculo derivada del uso de los otros enlaces como a menudo culo es posible, entonces, incluso la necesidad de reevaluar los enlaces cuando las cosas cambios disminuye!

La ultima afirmacion se puede verificar muy claramente con un ejemplo aparte de mostrar lo importante que es para 'REUTILIZAR' todo lo que se derivan para cada nivel superior (en cuanto a que parte de la estructura es mas probable que cambie y que parte es mas 'estatica'). Con la 'reutilizacion' me refiero a 'la CPU de trabajo ya esta hecho' a la hora de derivar el enlace. Mas sobre este podria ser tema para un articulo independiente.

Ahora veamos el codigo. Tenemos que conseguir que el viaje objeto (para algunos reson), a partir de una Parcela, pero no sabemos en que VehicleUnit estamos cargados de modo que empecemos a buscar usando el enlace 'EffectiveTrip' que 'esconde' la logica de la determinacion de que el viaje objeto es 'movilizados' (he.e 'eficaz') :


funcion TParcel.CalculateTrip_Something...: Doble
var
TripObj : TTrip
begin
TripObj := vehicleUnit.effectiveTrip // eso es todo! ...

Facil, esto es claro de codigo. Los detalles acerca de como obtuvimos el viaje correcta objeto no debe ser la mezcla de la logica de negocio que se ocupan del acceso o calculos en la estructura del objeto.

En nuestro mundo real de la aplicacion de ambos VehicleUnits y Parcelas tienen en comun un super clase (no se muestra aqui). Un vehiculo puede ser instalada en otro vehiculo, al igual que cualquier otra parcela por lo que el codigo anterior es aun mas simple en mi ultimo modelo generico donde la derivada de enlace es 'virtual overrided' en diferentes subclases. Mi codigo final va como esto :


begin

TripObj := effectiveTrip // eso es todo!

El Paquete encontrara en su viaje valido el uso de este comando, independientemente de lo complicada que es la ruta de acceso puede ser. Esto se muestra en la figura 5, donde una nueva comunes clase super actualmente es el dueño de la persistente y derivados enlace a la clase de disparo y la EffectiveTrip-link es implementado primero en el TParcel y, a continuacion, overrided para la VehicleUnit clase como se muestra a continuacion.

Fig 5: Aqui he modificado el modelo a ser mas generico que permite a cualquier 'planable objeto de' llevar un lote de otros planable objetos - y como el modelo va mas generica de la funcion de los nombres de hacerlo tambien.


5.jpg

Viaje info se aplica directamente para una Parcela demasiado (a traves de AbstractPlanPortion) porque una empresa de transporte puede planificar una parcela en la que se entregan con, por ejemplo, un avion que los totales no estamos interesados, pero todavia estamos interesados en hacer el seguimiento de cualquier viaje de los eventos involucrados en el transporte, y la documentacion y las transacciones se adjunta a la parcela de la misma, etc. Pero esto tambien significa que cuando hay necesidad de acceder a la 'eficacia' de viaje objeto que tambien se necesitan para llevar a cabo muy complicado cheques de toda la estructura tratando de averiguar en que contexto la (correcta, 'movilizados') viaje de un objeto se puede encontrar... Esto realmente va a hacer que nuestra logica es algo complicado para una cosa tan simple como simplemente recuperar algunos datos de la estructura. Una verdadera pesadilla, de hecho,...

Esta complicacion de una cosa tan simple no es muy singular. Lo que es unico es la forma en que pueden ser tratados con el uso de la Negrita de la tecnologia, con sus derivados de enlaces.

El Paquete puede ser el TripHolder mismo, o si el Paquete se carga en un portador que no se si es cargado en el soporte que en realidad contiene la informacion de los viajes. Es realmente necesario hacer algunas navigatiion aqui. En una situacion como esta se puede facilmente imaginar cuanto de codificacion y de lo complicado expresiones OCL seria acceder a la informacion en la estructura. Su nucleo de negocio de la logica de 'ahogarse' en la navegacion de la logica cuando simplemente recuperar las cosas mas triviales de la estructura y de la CPU pasaria mucho tiempo para encontrar Su camino(s) a los objetos de destino/de datos.

por ultimo : Tres (3) de los enlaces permanentes celebracion de la estructura de todos juntos acabaron en otro de los cinco (5) muy util derivados de enlaces ! El resultado es que la final de la aplicacion se ejecuta mucho mas rapido y la logica de negocio se mantiene mas alla de trivial de navegacion sin fin de atravesar las estructuras de los objetos.

Antes de listar el codigo mas eficiente para la optimizacion de los codificado derivaciones de los enlaces, me gustaria concluir con estos enlaces puede, desde cualquier lugar en la estructura, ir a cualquier lugar - directamente - por la referencia a link miembros con nombres totalmente aclarar lo que se pretende acceder, y esto se hara en la forma mas eficaz que usted puede venir para arriba con el uso regular Audaz arquitectura.

Con 'eficiente' que significa 'siempre acceso directo a la meta deseada instancia de objeto' (excepto para la primera evaluacion que en mi caso solo pasa una vez por cientos de accesos...).

Esto es solo una parte de los conceptos que hemos utilizado conscientemente para hacer posible lo que antes no era posible : el uso regular, pero 'diseño limpio', siguiendo el modelo estructurado y orientado a objetos clases de negocios escenicas de alto rendimiento en tiempo real (re)calculos de muy avanzada viaje calculos (no se discute aqui). En una sola CPU (servidor de aplicaciones) para varios clientes.

Derivacion codigo, con comentarios

En el codigo de abajo te subrayo todas las referencias internas de la que se derivan los vinculos ('reutilizacion eficiente de los ya evaluados los resultados').

tambien he utilizado las variables locales y asi evitar la interna 'buscar' de la Negrita miembros mas de una vez (=> evita repetir la activacion de los internos en negrita eventos, etc).

La eficiencia de todo el concepto discutido y la codificacion detallada a continuacion se verifica por medio de ProDelphi profiler (muy alta precision ( -3%) sobre la medicion del rendimiento del codigo).


{ TParcel }



procedimiento TParcel._EffectiveTrip_DeriveAndSubscribe(...)
// Si se cargan los portadores (en efectivo) viaje se devuelve,
// otra cosa que el viaje local (si existe).
var
CarrierObj: TVehicleUnit
ResultValue : TTrip
begin
M_batchHolder.DefaultSubscribe(Suscriptor, breResubscribe)
CarrierObj := batchHolder
si se ha Asignado(CarrierObj), a continuacion,
begin
CarrierObj.M_EffectiveTrip.DefaultSubscribe(Suscriptor, breResubscribe)
ResultValue := CarrierObj.EffectiveTrip
fin
else
begin
M_trip.DefaultSubscribe(Suscriptor, breResubscribe)
ResultValue := viaje
fin
M_EffectiveTrip.BoldObject := ResultValue
fin



{ TVehicleUnit }



procedimiento TVehicleUnit._EffectiveTrip_DeriveAndSubscribe(...)
var
HaulerObj: TVehicleUnit
ResultValue,
TripObj: TTrip
begin
ResultValue := nil
M_CombinationFirst.DefaultSubscribe(Suscriptor, breResubscribe)
HaulerObj := CombinationFirst
// la que atraviesa ya esta hecho aqui
si se ha Asignado(HaulerObj), a continuacion,
begin
HaulerObj.M_Trip.DefaultSubscribe(Suscriptor, breResubscribe)
TripObj := HaulerObj.viaje
si se ha Asignado(TripObj), a continuacion,
begin
TripObj.M_IsMobilized.DefaultSubscribe(Suscriptor)
si TripObj.IsMobilized, a continuacion,
ResultValue := TripObj
fin
fin
M_EffectiveTrip.BoldObject := ResultValue
fin



procedimiento TVehicleUnit._CombinationFirst_DeriveAndSubscribe(...)
// Este enlace sera el rapido 'atajo' que se utiliza por muchos
// funciones en este ambito y otros enlaces y atributos, asi
// significado de optimizacion, no 'extras' o 'candy' en el modelo.
var
LoopObj: TVehicleUnit
begin
LoopObj := Self // Travesia por delante
LoopObj.M_hauler.DefaultSubscribe(Suscriptor, breResubscribe)
mientras Asignados(LoopObj.Transportista)
begin
LoopObj := LoopObj.Compañia de transporte
LoopObj.M_hauler.DefaultSubscribe(Suscriptor, breResubscribe)
fin
M_CombinationFirst.BoldObject := LoopObj
fin




procedimiento TVehicleUnit._CombinationLast_DeriveAndSubscribe(DerivedObject: TObject Suscriptor: TBoldSubscriber)
var
LoopObj: TVehicleUnit
begin
LoopObj := Self
LoopObj.M_trailer.DefaultSubscribe(Suscriptor, breResubscribe)
mientras Asignados(LoopObj.remolque) no
begin
LoopObj := LoopObj.remolque
LoopObj.M_trailer.DefaultSubscribe(Suscriptor, breResubscribe)
fin
M_CombinationLast.BoldObject := LoopObj
fin




procedimiento TVehicleUnit.CombinationUnits_DeriveAndSubscribe(...)
var
LoopObj: TVehicleUnit
ResultList: TBoldObjectList
begin
M_CombinationUnits.Claro
ResultList := TBoldObjectList.Crear
prueba
M_CombinationFirst.DefaultSubscribe(Suscriptor, breResubscribe)
LoopObj := CombinationFirst
repetir
ResultList.Agregar(LoopObj)
LoopObj.M_trailer.DefaultSubscribe(Suscriptor, breResubscribe)
LoopObj := LoopObj.remolque
hasta LoopObj = nil
finalmente
M_CombinationUnits.AddList(ResultList)
FreeAndNil(ResultList)
fin
fin




procedimiento TVehicleUnit._CombinationLoadItems_DeriveAndSubscribe(DerivedObject: TObject Suscriptor: TBoldSubscriber)
// Una lista de recoger todos (lote)los objetos cargados en cualquier unidad en el
// combinacion de vehiculos. Implementado para la comodidad y el
// clearification.
var
UnitCnt, i: Integer
UnitObj: TVehicleUnit
begin
M_CombinationLoadItems.Claro
CombinationUnits.DefaultSubscribe(Suscriptor, breResubscribe)
UnitCnt := CombinationUnits.Cuenta
si UnitCnt > 0, entonces
begin
for i := 0 a UnitCnt-1 hacer
begin
UnitObj := CombinationUnits[i]
UnitObj.loadedItems.EnsureObjects
UnitObj.loadedItems.DefaultSubscribe(Suscriptor)
// Recoger todo si UnitObj.loadedItems.Count > 0 then
M_CombinationLoadItems.AddList(UnitObj.loadedItems)
fin
fin
fin

// Rolf Lampa

(Actual direccion de correo: rolf-dot-lampa-en-rilnet-punto-com)

& nbsp

Navegación dinámica para un mayor rendimiento

Navegación dinámica para un mayor rendimiento : Multi-millones de consejos para hacer su vida más fácil.
Recommander aux amis
  • gplus
  • pinterest

Comentario

Dejar un comentario

Clasificación