Tag: logic

I have the C # ASP.Net Core Webapi application that performs calculations for physical models. I have this project class:

Public class Project {
public IEnumerable components;
private ValueService valueService = new ValueService ();

public project (string norm) {
components = FactoryGenerator.GetFactory (norm) .GetComponents (valueService);
}

public IEnumerable Get results () {
Returns valueService.GetResults ();
}

public void SetValues ​​(IEnumerable values) {
values.ToList (). ForEach (t => valueService.SetValue (t.Key, t.Value));
}

public bool Valid (string ComponentName) {
return components.Where (s => s.Title == componentName) .Single (). Valid ();
}
}

This creates smaller components that do calculations. Depends on standard parameter, another set of components is created (via the factory). Each component contains a list of variables that can exist (the client knows which ones) and it can perform calculations on these variables and on variables being initialized in other components (with 3 examples). implementation of GenericComponent).

public abstract class GenericComponent: IObserver <Tuple> {
read-only public IValueService valueService;
identifiable secure cancellation;
public list the variables;
public list observerVariables;

public GenericComponent (IValueService _valueService) {
valueService = _valueService;
}
public string Title {get; together; }
public void OnCompleted () {launches new NotImplementedException (); }
public void OnError (exception error) {// no implementation
}
empty public summary OnNext (Tuple value);
public abstract bool Valid ();
}

Public class LoadComponent: GenericComponent {
public LoadComponent (IValueService valueService): base (valueService) {
variables = new list() { "charge" };
variables.ForEach (s => valueService.RegisterValue (s));
cancel = valueService.Subscribe (this, variables);
}
public override bool Valid () => valueService.GetValue ("load")?. Valid ?? false;
empty public replacement OnNext (Tuple value) {
double load = (double) value.Item2;
if (Math.Abs ​​(load) <1) {
valueService.SetWarning (value.Item1, "The small load must be larger");
}
}
}


Public class ValidationComponent: GenericComponent {

public ValidationComponent (IValueService valueService): base (valueService) {
variables = new list() {"validation.load"};
variables.ForEach (s => valueService.RegisterValue (s));
observingVariables = new list() {"load", "area"};
cancel = valueService.Subscribe (this, observingVariables);
}
private double CalcMargin () {
return 0.5 * (double) valueService.GetValue ("area"). Value
- (double) valueService.GetValue ("load"). Value;
}
public override bool Valid () => CalcMargin ()> 0;
empty public replacement OnNext (Tuple value) {
if (valueService.GetValue ("load"). Value! = null &&
valueService.GetValue ("area"). Value! = null) {
double margin = CalcMargin ();
valid boolean = margin> 0;
valueService.SetValue ("validation.load", "the margin is:" + margin.ToString (),
valid);
if (margin <1) {
valueService.SetWarning ("validation.load", "very narrow margin");
}
}
}
}

Public class CrossSectionComponent: GenericComponent {
public CrossSectionComponent (IValueService valueService): base (valueService) {
variables = new list() {"area", "radius"};
variables.ForEach (s => valueService.RegisterValue (s));
cancel = valueService.Subscribe (this, variables);
}
public override bool Valid () => valueService.GetValue ("radius")?. Valid ?? false;
empty public replacement OnNext (Tuple value) {
if (value.Item1 == "radius") {
double radius = (double) value.Item2;
if (radius <0) {
valueService.SetError ("radius", "Radius must be greater than 0");
} else if (radius <1) {
valueService.SetWarning ("radius", "The radius is very small");
}
valueService.SetValid ("radius", true);
valueService.SetValue ("area", radius * radius * Math.PI, true);
}
}
}

Each component has a list of values ​​with unique keys on the entire model (here, I probably need more controls, as all keys are really unique).
At the moment I'm using a ValueService, where each component stores its values ​​with the respective keys. the ValueService can be used to obtain values ​​from other components in order to perform validation calculations or intermediate steps.

Public class ValueService: IValueService {

Private IDictionary values ​​= new dictionary();
private IDictionary <string, List <IObserver <Tuple>>> observers =
new Dictionary <string, List <IObserver <Tuple>>> ();

public void RegisterValue (string key) {
if (! values.ContainsKey (key)) {
values.Add (key, new value ValueViewModel () {
Key = key,
Value = null
});
observers.Add (key, new list <IObserver <Tuple>> ());
}
}

public IEnumerable Get results () {
return values.Where (s => s.Value.Value! = null) .Select (s => s.Value);
}

public void SetValue (string key, object value) {
if (values.ContainsKey (key)) {
values[key].Value = value;
observers[key].For each (t => {
t.OnNext (new Tuple(key value));
});
}
}

public void SetValue (string key, object value, status bool) {
SetValue (key, value);
SetValid (key, status);
}

public void SetValid (string key, status bool) {
if (values.ContainsKey (key)) {
values[key].Valid = status;
}
}

public ValueViewModel GetValue (string key) {
if (values.ContainsKey (key))
return values[key];
return null;
}

public IDisposable Subscribe (IObserver <Tuple> observer) {
returns new unsubscriber (observers.Values.ToList (). SelectMany (s => s) .ToList (), observer);
}

public IDisposable Subscribe (IObserver <Tuple> observer, IEnumerable keys)
keys.ToList (). ForEach (key => {
if (! observers.ContainsKey (key))
observers.Add (key, new list <IObserver <Tuple>> ());
if (! observers[key]Contains (observer)
observers[key].Add (observer);
});
returns new unsubscriber (observers.Values.ToList (). SelectMany (s => s) .ToList (), observer);
}

public void SetWarning (string key, string warning) {
if (values.ContainsKey (key)) {
values[key].Warning = warning;
values[key].Valid = true;
}
}

public void SetError (string key, string error) {
if (values.ContainsKey (key)) {
values[key].Error = error;
values[key].Valid = false;
}
}

}

The ValueViewModel is used to communicate with the front-end

Public class ValueViewModel
{
public channel Key {get; together; }
public object Value {get; together; }
public bool Valid {get; together; }
public channel Warning {get; together; }
public string Error {get; together; }
}

This is part of a stateless API, that is for each HTTP request (for the moment), a new Project object is generated and used to perform validations (via an array of ValueViewModels).

My API controller looks like this:

                public IActionResult postData ([FromRoute] string standard, [FromRoute] chain component, [FromBody] ValueViewModel[] The data)
{
Project project = new project (standard);
project.SetValues ​​(data);
returns Ok (project.Valid (component));
}

In order to do local testing, I created the following console application

class program {
static void Main (string[] args) {
Console.WriteLine ("Hello world");
Project project = new project ("Eurocode_CH");
listing values ​​= new list {
new ValueViewModel () {
Key = "radius",
Value = 12.0
}
};
project.SetValues ​​(values);
Console.WriteLine (Newtonsoft.Json.JsonConvert.SerializeObject (project.GetResults ()));
values[0]Value = -0.4;
project.SetValues ​​(values);
Console.WriteLine (Newtonsoft.Json.JsonConvert.SerializeObject (project.GetResults ()));
values[0]Value = 0.4;
project.SetValues ​​(values);
Console.WriteLine (Newtonsoft.Json.JsonConvert.SerializeObject (project.GetResults ()));
values.Add (new ValueViewModel () {
Key = "load",
Value = 1.2
});
project.SetValues ​​(values);
Console.WriteLine (Newtonsoft.Json.JsonConvert.SerializeObject (project.GetResults ()));
}
}

This is the exit

[{“Key”:”area”,”Value”:452.38934211693021,”Valid”:true,”Warning”:null,”Error”:null},{“Key”:”radius”,”Value”:12.0,”Valid”:true,”Warning”:null,”Error”:null}]

[{“Key”:”area”,”Value”:0.50265482457436694,”Valid”:true,”Warning”:null,”Error”:null},{“Key”:”radius”,”Value”:-0.4,”Valid”:true,”Warning”:null,”Error”:”Radius
is must be larger than 0″}]

[{“Key”:”area”,”Value”:0.50265482457436694,”Valid”:true,”Warning”:null,”Error”:null},{“Key”:”radius”,”Value”:0.4,”Valid”:true,”Warning”:”Radius
is very small”,”Error”:”Radius is must be larger than 0″}]

[{“Key”:”area”,”Value”:0.50265482457436694,”Valid”:true,”Warning”:null,”Error”:null},{“Key”:”radius”,”Value”:0.4,”Valid”:true,”Warning”:”Radius
is very small”,”Error”:”Radius is must be larger than
0″},{“Key”:”load”,”Value”:1.2,”Valid”:false,”Warning”:null,”Error”:null}]

My concerns are

• As the project continues, the number of components will become quite large. I am afraid that the performance problem will arise if, for each request, all the components must be generated -> should I use LazyLoading?
• Is the ValueService good approach to share data between components? Is there a better solution?
• I still need to implement a specific value generator, for example. a user requests the ValueViewModel for a specific key; the components must generate an error or a warning if all the values ​​have not been defined.
• I think "AbstractComponent" is a better name than "GenericComponent", on a side note.