es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Cómo evitar una dependencia circular pero pasar información desde un proyecto padre?

26 Jul, 2023 Programación

Contexto: Estoy trabajando en una solución grande que contiene varios proyectos. El objetivo es pasar una entrada de usuario simple (dos matrices de enteros de longitud 3 y un booleano) que se recupera en el proyecto A, al proyecto B donde es utilizado por alguna función. El proyecto B es un ViewModel. Sin embargo, el proyecto A hace referencia al proyecto B (es decir, nombra al proyecto B como referencia), por lo que para evitar una dependencia circular no puedo hacer referencia a A desde B.

Como será obvio, soy principiante, pero esto es en un entorno profesional, por lo que solo puedo “reorganizar” hasta cierto punto. Estoy trabajando en Visual Studio.

Pensamientos: La solución que se me ocurre es, en el proyecto B, generar en tiempo de compilación alguna memoria de esos enteros y booleano. Luego, en tiempo de ejecución, esta información se llena en el proyecto A y luego se recupera por el proyecto B más adelante.

En este momento, lo que tengo no hace esto en absoluto, pero publicaré lo que actualmente tengo. En el proyecto B, tengo, en un archivo adecuado:

namespace NameSpaceB
{
  public struct Inputs
  {
    public int[] array1;
    public int[] array2;
    public bool t;
  }
}

Ahora dirigiéndose al proyecto A, sería algo como:

using NameSpaceB;

/* lo que sigue es una estructura ya presente en la solución, no es mi trabajo */
namespace NameSpaceA 
{
  ... 
  internal public class MyClass
  {
    public static void MyFunction()
    {
      ...
      int[] inputs1 = { 1, 2, 3 }; // supongamos que estos son los inputs de un ViewModel durante el tiempo de ejecución
      int[] inputs2 = { 4, 5, 6 };
      bool T = true;

      /* aquí es donde me gustaría algo así */
      Inputs inputInfo;
      inputInfo = default;

      Array.Copy(inputs1, inputInfo.array1, 3);
      Array.Copy(inputs2, inputInfo.array2, 3);
      inputInfo.t = T;
      ...
    }
  }
}

Ahora idealmente, me gustaría recuperar el contenido inputInfo en el proyecto B una vez que se haya ejecutado MyFunction(). Habrá entradas predeterminadas en mi proyecto de vista (que aparece en la interfaz de usuario), así que espero que siempre haya algo “ahí” para encontrar en mis matrices.

Creo que la forma de hacer esto es en el proyecto B, asignar memoria en tiempo de compilación para esa estructura, de manera que sea accesible para ambos proyectos en tiempo de ejecución. He estado buscando en Google pero me está costando ver la mejor manera de hacer esto, o incluso si mi idea es buena.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Como experto en TI especializado en c#, struct y gestión de memoria, hay varias formas en las que podrías abordar este problema. Una forma de resolver el problema de las dependencias circulares es utilizar una interfaz para el objeto de entrada, la cual podría implementarse en el proyecto A y pasarse como parámetro a la función en el proyecto B. Esto permitiría una flexibilidad entre los dos proyectos sin hacer referencia directa entre sí.

    Otra opción es utilizar una biblioteca externa o un paquete de NuGet para almacenar el objeto de entrada compartido. Esto permitiría que ambos proyectos hicieran referencia al mismo código sin la necesidad de dependencias circulares.

    En cuanto a tu enfoque actual, un problema es que la estructura Inputs no tiene una instancia estática, por lo que no puedes acceder a sus propiedades directamente. En cambio, podrías crear una clase estática en el proyecto B para almacenar los datos de entrada y llenarla desde el proyecto A. Por ejemplo:

    namespace NameSpaceB
{
  public static class InputData
  {
    public static int[] Array1 { get; set; }
    public static int[] Array2 { get; set; }
    public static bool T { get; set; }
  }
}

    Luego, en el proyecto A, podrías llenar InputData de la siguiente manera:

    using NameSpaceB;

/* lo que sigue es alguna estructura ya presente en la solución, no es mi trabajo */
namespace NameSpaceA 
{
  ... 
  internal public class MyClass
  {
    public static void MyFunction()
    {
      ...
      int[] inputs1 = { 1, 2, 3 }; /* supongamos que estos son los datos introducidos desde un modelo de vista durante la ejecución */
      int[] inputs2 = { 4, 5, 6 };
      bool T = true;

      /* llenar los datos de entrada estáticos en el proyecto B */
      InputData.Array1 = inputs1;
      InputData.Array2 = inputs2;
      InputData.T = T;
      ...
    }
  }
}

    Y finalmente, en el proyecto B, podrías obtener los datos de entrada de la siguiente manera:

    using NameSpaceB;

namespace NameSpaceB
{
  internal public class MyViewModel
  {
    public static void MyViewModelFunction()
    {
      /* obtener los datos de entrada */
      int[] inputs1 = InputData.Array1;
      int[] inputs2 = InputData.Array2;
      bool T = InputData.T;

      /* utilizar los datos de entrada */
      ...
    }
  }
}

    En general, hay múltiples maneras de resolver el problema de las dependencias circulares y pasar datos de entrada entre proyectos. El enfoque que elijas dependerá de los requisitos específicos de tu solución y las limitaciones de tu entorno.

Comments are closed.