Ich habe ein Problem mit C# MVC, ich muss ein JSON Parsen der nicht immer gleich ist.

1. Zustand "[[\"Bezeichnung\",\"=\",\"2K-Gelcoat-PUR-Steodur-3kg\"]]"
2. Zustand "[[[\"Bezeichnung\",\"=\",\"2K-Gelcoat-PUR-Steodur-3kg\"]],\"and\",[[\"charge\",\"=\",\"11\"]]]"

WIe kann ich das machen für Zustand 1 habe ich volgenden Code

markieren

Code:

JavaScriptSerializer serializer = new JavaScriptSerializer();
            List<string[]> filterItems = serializer.Deserialize<List<string[]>>(filter);

            string buffer = "";

            foreach (string[] filterItem in filterItems)
            {
               buffer = buffer + filterItem[0] + " " + filterItem[1] + " " + filterItem[2];
               //list = FilterItems<YourItemType>(list, filterItem[0], filterItem[2]);
            }

Sei doch so lieb und zeige uns den puren JSON-Code (eingebettet in die CODE-Tags). Bei diesem String aus dem Debugger mit den Escape-Zeichen sieht man ja den Wald vor lauter Bäumen nicht.

Ich wette, dann wird dich auch schon die Lösung anspringen

Sorry habs einfach aus dem Debug rasukopiert


1. [["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]
2. [[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]

1. Variante
   
   markieren

   Code:

   [
      [
         "Bezeichnung",
         "=",
         "Angussstutzen-Rev/B-PPTV30"
      ]
   ]
2. Variante
   
   markieren

   Code:

   [
      [
         [
            "Bezeichnung",
            "=",
            "Angussstutzen-Rev/B-PPTV30"
         ]
      ],
      "and",
      [
         [
            "charge",
            "=",
            "11"
         ]
      ]
   ]

Schauen wir uns an, was wir da haben (wir fangen von aussen an):

• Hat das äußere Array einen Eintrag, dann haben wir die Variante 1 vor uns
• Hat das äußere Array drei Einträge, dann haben wir die Variante 2 vor uns, wobei das Item 0 und Item 2 wie die Variante 1 behandelt werden kann

Es ist eigentlich immer nur eine Variante. (im aktuellen Beispiel)
[WertA, Operator, WertB]

markieren

Code:

Auswertgung:
[
   "Bezeichnung",       Spalte
   "=",                 Vergleichsoperator
   "Angussstutzen..."   Wert
]

Verknüpfung
[
   [ VergleichA ],      GruppeA
   "and",               Operator
   [ VergleichB ]       GruppeB
]

interessant wären jetzt mehrere Verknüpfungen ... eventuell so, oder immer nur in 2er-Gruppen
[
   [ VergleichA ],      GruppeA
   "and",               Operator
   [ VergleichB ]       GruppeB
   "and",               Operator
   [ VergleichC ]       GruppeC
]

[
   [ VergleichA ],      GruppeA
   "and",               Operator
   [
      [ VergleichB ]    GruppeB.A
      "and",            Operator
      [ VergleichC ]    GruppeB.B
   ]
]

Wenn ich die eckigen Klammern zähle, dann sehe ich das etwas anders

Lege zwei "Auswertgung" in ein "Verknüpfung" rein und schon kommt das doch mit den Klammern doch hin?

Zitat von himitsu:

Lege zwei "Auswertgung" in ein "Verknüpfung" rein und schon kommt das doch mit den Klammern doch hin?

Es gibt aber auch den Fall, wo es nur einen Vergleich gibt. Diesen Fall muss man speziell behandeln, alle anderen (mehrere Vergleiche verknüpft mit einem Operator) folgen durchaus dem, was du gezeigt hast.

Die Frage dreht sich hier aber ganz speziell um die Erkennung dieser beiden Fälle

Mal eben so heruntergetippt ...

zusammenfalten · markieren

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.Json,
  System.SysUtils;

function IsEven( const Value: Integer ): Boolean;
begin
  Result := Value mod 2 = 0;
end;

function ParseSingleExpression( AJsonArray: TJsonArray ): string;
var
  lInner : TJsonArray;
  lFieldName: string;
  lOperator : string;
  lValue : string;
begin
  if AJsonArray.Count <> 1
  then
    raise EArgumentException.Create( 'single item in array expected' );

  if not( AJsonArray.Items[ 0 ] is TJsonArray )
  then
    raise EArgumentException.Create( 'array expected' );

  lInner := AJsonArray.Items[ 0 ] as TJsonArray;

  if lInner.Count <> 3
  then
    raise EArgumentException.Create( 'three items expected' );

  if not( lInner.Items[ 0 ] is TJSONString )
  then
    raise EArgumentException.Create( 'string expected' );
  lFieldName := lInner.Items[ 0 ].Value;

  if not( lInner.Items[ 1 ] is TJSONString )
  then
    raise EArgumentException.Create( 'string expected' );
  lOperator := lInner.Items[ 1 ].Value;

  if lInner.Items[ 2 ] is TJSONString
  then
    lValue := QuotedStr( lInner.Items[ 2 ].Value )
  else
    lValue := lInner.Items[ 2 ].Value;

  Result := string.Format( '(%s %s %s)', [ lFieldName, lOperator, lValue ] );
end;

function ParseJsonExpression( AJsonArray: TJsonArray ): string;
overload
var
  I: Integer;
begin
  if IsEven( AJsonArray.Count )
  then
    raise EArgumentException.Create( 'odd items in array expected' );

  if AJsonArray.Count = 1
  then
    Result := ParseSingleExpression( AJsonArray )
  else
    begin
      Result := '( ';
      for I := 0 to AJsonArray.Count - 1 do
        begin
          if I mod 2 = 0
          then
            if AJsonArray.Items[ I ] is TJsonArray
            then
              Result := Result + ParseJsonExpression( AJsonArray.Items[ I ] as TJsonArray )
            else
              raise EArgumentException.Create( 'Array expected' )
          else
            Result := Result + ' ' + AJsonArray.Items[ I ].Value + ' ';
        end;
      Result := Result + ' )';
    end;
end;

function ParseJsonExpression( AJsonStr: string ): string; overload;
var
  lValue: TJSONValue;
begin
  lValue := TJSONObject.ParseJSONValue( AJsonStr );
  try
    if lValue is TJsonArray
    then
      Result := ParseJsonExpression( lValue as TJsonArray )
    else
      raise EArgumentException.Create( 'Fehlermeldung' );
  finally
    lValue.Free;
  end;
end;

const
  Data1 = '[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]';
  Data2 = '[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]';
  Data3 = '[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]],"and",[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]]';

procedure Main;
begin
  WriteLn( Data1 );
  WriteLn( ParseJsonExpression( Data1 ) );
  WriteLn;
  WriteLn( Data2 );
  WriteLn( ParseJsonExpression( Data2 ) );
  WriteLn;
  WriteLn( Data3 );
  WriteLn( ParseJsonExpression( Data3 ) );
end;

begin
  try
    Main( );
  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

und liefert

markieren

Code:

[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]
(Bezeichnung = 'Angussstutzen-Rev/B-PPTV30')

[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]
( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') )

[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]],"and",[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]]
( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') and ( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') ) )

Sorry4OT: So viel zum Thema "JSON ist sooo einfach" XML hat halt etwas mehr overhead, aber einfacher als JSON ist es allemal.

Sherlock