Jepp, das war der richtige Hinweis - vielen Dank!

Eigentlich sollte diese Enumeration gar kein Teil einer Relation sein, sondern der Wert händisch gesetzt werden, weshalb der Setter auch internal ist. Aber ich hatte absolut keinen Plan, dass das Framework die Eigenschaft dennoch entsprechend interpretieren und sogar ergänzen würde.

Habe jetzt einfach ein NotMapped-Attribut drüber gesetzt, und nun arbeitet der Code auch wie gewünscht.

Entität "DangerousGoods":

public class DangerousGoods : DbModel
{
    public int Position { get; set; }
    public int TransportContainerId { get; set; }
    public bool? IndicatorTank { get; set; }
    public string EmsNumbers { get; set; }
    public string ProperShippingName { get; set; }
    public string UNNumber { get; set; }
    public string Class { get; set; }
    public string PackingGroup { get; set; }
    public bool? TransportProhibited { get; set; }
    public double? DangerWeightNet { get; set; }
    public int PackingNumber { get; set; }
    public string PackingCode { get; set; }
    public double? DangerWeightNetExplosive { get; set; }
    public string LegalNorm { get; set; }

    public TransportContainer TransportContainer { get; set; }
}

Entität "TransportContainer":

public class TransportContainer : DbModel
{
    public string ContainerNumber { get; set; }
    public string OceanVoyageBookingNumber { get; set; }
    public double NetWeight { get; set; }
    public double GrossWeight { get; set; }
    public double? TaraWeight { get; set; }
    public int? OceanVoyagePortId { get; set; }
    public bool? IsForOceanVoyage { get; set; }
    public string Description { get; set; }
    public string OriginCountryCode { get; set; }
    public string DestinationCountryCode { get; set; }
    public int? CustomsId { get; set; }
    public bool IsFullContainer { get; set; }
    public bool? IsActiveReefer { get; set; }
    public string OceanVoyageShip { get; set; }
    public string Comments { get; set; }
    //public string OceanVoyage { get; set; }
    public string TransportPaperReference { get; set; }
    public double? MaxTemperature { get; set; }
    public string SealNumbers { get; set; }

    public IEnumerable<DangerousGoods> DangerousGoods { get; set; }
}

Builder:

protected override void OnModelCreating(ModelBuilder builder)
{
    builder.Entity<GoodsItemCustomsNumber>()
        .HasOne<GoodsItem>(gicn => gicn.GoodsItem)
        .WithMany(gi => gi.GoodsItemCustomsNumbers)
        .HasForeignKey(gicn => gicn.GoodsItemId);
    builder.Entity<DangerousGoods>()
        .HasOne<TransportContainer>(dg => dg.TransportContainer)
        .WithMany(tc => tc.DangerousGoods)
        .HasForeignKey(dg => dg.TransportContainerId);
    ...

Tabellen und Relationen s. Anhang.

Es gibt zwei weitere Tabellen, die eine Fremdschlüsselbeziehung haben. Dort gibt es auch die Spalte "GoodsItemId":

public class GoodsItem : DbModel
{
    public int TransportContainerId { get; set; }
    public int Position { get; set; }
    public string Contents { get; set; }
    public double? MonetaryValueEUR { get; set; }
    public string PackagingCode { get; set; }
    public double PackagingGrossWeight { get; set; }
    public int PackagingNumberUnits { get; set; }
    public string CustomsTariffNumber { get; set; }

    public IEnumerable<GoodsItemCustomsNumber> GoodsItemCustomsNumbers { get; set; }
    public IEnumerable<DangerousGoods> DangerousGoods {  get; internal set; }
}

public class GoodsItemCustomsNumber : DbModel
{
    public int GoodsItemId { get; set; }
    public string RegistrationNumber { get; set; }

    public GoodsItem GoodsItem { get; set; }
}

Und so wird die Relation abgebildet:

protected override void OnModelCreating(ModelBuilder builder)
{
    builder.Entity<GoodsItemCustomsNumber>()
        .HasOne<GoodsItem>(gicn => gicn.GoodsItem)
        .WithMany(gi => gi.GoodsItemCustomsNumbers)
        .HasForeignKey(gicn => gicn.GoodsItemId);
    ...

Diese Tabellen frage ich in der Methode im oberen Beitrag auch problemlos ab. Die Exception kommt erst bei der Abfrage von "DangerousGoods", und dort gibt es diese Spalte eben nicht und auch keine Fremdschlüsselbeziehung zu "GoodsItems". Die Relation von "DangerousGoods" zeigt auf eine andere Tabelle, die aber ebenfalls keine Spalte "GoodsItemId" enthält.

@Abt: Nein, es gibt keinen Zeitzonen-Bug. Hier läuft alles nach MEZ, und auch die Server stehen in Deutschland. Datenbank und frühere Software stammen allerdings auch nicht von mir. Ich hätte alles per UTC + Zeitzone gemacht.

Edit: Screenshot Tabelle hinzugefügt.

Verwendetes Datenbanksystem: SQL Server Express, NET v7

Moin-moin,

ich habe hier ein Problem mit einem ungültigen Spaltennamen, auf das ich mir absolut keinen Reim machen kann.

Und zwar erscheint der Fehler beim Binding in ein Listenobjekt nach einer simplen Tabellenabfrage. Nur dass die besagte Spalte gar keine Eigenschaft meines Models ist, und in der Db-Tabelle existiert sie natürlich auch nicht.

So sieht mein Modell aus:

public class DangerousGoods : DbModel
{
    public int Position { get; set; }
    public int TransportContainerId { get; set; }
    public bool? IndicatorTank { get; set; }
    public string EmsNumbers { get; set; }
    public string ProperShippingName { get; set; }
    public string UNNumber { get; set; }
    public string Class { get; set; }
    public string PackingGroup { get; set; }
    public bool? TransportProhibited { get; set; }
    public double? DangerWeightNet { get; set; }
    public int PackingNumber { get; set; }
    public string PackingCode { get; set; }
    public double? DangerWeightNetExplosive { get; set; }
    public string LegalNorm { get; set; }
}

Von dieser Klasse erbt es:

public abstract class DbModel
{
    bool Modified;

    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    public int Version { get; set; }
    public string ModifiedBy { get; set; }
    public DateTime? ModifiedOn { get; set; }

    protected DbModel()
    {
    }

    public virtual void Update(string modifier = null, DateTime? date = null)
    {
        if (!this.Modified)
            this.Version++;
        this.ModifiedBy = modifier ?? ApiUser.UserName;
        this.ModifiedOn = date ?? DateTime.Now;

        this.Modified = true;
    }
}

Hier wird der Aufruf ausgeführt:

public IEnumerable<GoodsItem> GetFullGoodsDescription(ContainerTransportOrder order)
{
    if (order != null)
    {
        var id = order.TransportContainerId;
        var goodsItems = this.GoodsItems
            .Include(gi => gi.GoodsItemCustomsNumbers)
            .AsSingleQuery()
            .Where(gi => gi.TransportContainerId == id).ToList();

        if (order.ContainsDangerousGoods == true)
        {
            var dangerousGoods = this.DangerousGoods.Where(dg => dg.TransportContainerId == id).ToList(); // hier erscheint die Exception

            foreach (var item in goodsItems)
                item.DangerousGoods = dangerousGoods.Where(dg => dg.Position == item.Position).ToList();
        }

        return goodsItems;
    }

    return null;
}

Die Exception lautet:

Ungültiger Spaltenname "GoodsItemId".

Es ist mir schleierhaft, warum NET hier diesen Spaltennamen mokiert. Auf der Basisklasse "DbModel" basieren Dutzende weitere Klassen zu Tabellen, wo es noch nie vergleichbare Probleme gab.

Hat hier irgendwer eine Idee? Ich bin völlig ratlos und habe schon alles mögliche ausprobiert, inkl. Umbenennungen und Neuanlage der beteiligten Klassen u. Tabellen.

Die Lösung war jetzt folgende:

Als AppPools u. Websites eingerichtet wurden, war der Server noch auf en-US konfiguriert, und diese Einstellungen haben die AppPools übernommen, so dass die jeweilige Culture aus den AppPool-Settings kam. Offenbar haben die Vorrang vor globalen Einstellungen in der web.config.

Es wurden nun einfach neue AppPools angelegt, die de-DE verwenden, und damit stimmen auch die Datumsformate wieder.

Trotzdem vielen Dank für die Ratschläge!

Ich verstehe. Allerdings wollen wir ja gerade den Code nicht ändern, weil das Ausgabeformat auf dem alten Server korrekt war, und wir jetzt davon ausgehen, dass irgendeine Windows-seitige Andersartigkeit für das falsche Datumsformat verantwortlich ist, die man eigentlich abstellen können müsste. Zeitzone, Systemzeit u. Standardsprache wurden inzwischen per Powershell auf UTC+2 u. Deutsch festgelegt. Festlegen der Culture per web.config hat auch nichts gebracht.

Ich meine, wenn ein und derselbe Code zuvor wie beabsichtigt ausgegeben wurde und auf dem neuen System nicht, dann muss das Problem doch auf Server-Ebene behebbar sein und nicht (nur) per Code-Anpassung.

Das hilft mir leider nicht weiter, denn es geht nicht um den Offset, sondern um das Datums/Zeitformat, das eben nicht in Englisch (05/26/2022 02:55 PM), sondern in Deutsch (26.05.2022 14:55) ausgegeben werden soll. Und da die Ausgabe auf dem alten Server wie beabsichtigt funktionierte, muss es sich hier um eine globale, systemabhängige Einstellung handeln, die wir gerne ändern wollen, wenn wir denn wüssten, was zu tun ist.

Moin-moin!

Wir haben gestern einen Serverumzug vorgenommen. Das neue System (Win Server 2022) lag dabei in Englisch vor und hatte zunächst auch eine falsche Zeitzone (UTC-7, Pacific Time), obwohl der Server in Frankfurt stehen soll.

Auf dem System wurde u.a. das NETv7.0.5 Hosting Bundle installiert, und alle migrierten Apps liefen auch einwandfrei. Allerdings wird bei mehreren Anwendungen jetzt das Englische Datumsformat ausgegegeben, wenn dieses per DateTime.ToString erzeugt wurde.

Wir haben verschiedene Dinge ausprobiert, um dieses Verhalten abzustellen, z.B. Deutsch auf Systemebene als Sprache eingerichtet, NET-Framework neu installiert... aber das Datumsformat bleibt Englisch.

Jetzt in allen Anwendungen den Code oder die Culture anzupassen kann die Lösung IMO nicht sein. Weiß hier zufällig jemand Rat, was zu tun ist, um ASP.NET die Englische Schreibweise auszutreiben?

Bin über jede Anregung dankbar

Grüße

Okay, ich sehe gerade, mein Problem liegt ganz woanders.

Sorry wegen der aufgewendeten Zeit!

Nein, nicht ICH deserialisiere das JSON, sondern ASP.NET macht das vor der Übergabe an die Action. Und ASP.NET deserialisiert Strings aus dem JSON in einen Mix aus Latin u. Unicode, und zwar auch dann, wenn ich obige Aufrufe verwende. Genaugenommen scheinen sie gar keinen Einfluss auf das Deserialisierungsverhalten von ASP.NET zu haben.

Ich habe bespielsweise folgendes JSON:

{
    "foo": "Holzmühle 1",
    "bar": "Württemberg"
}

Das geht in folgendes Objekt:

public class MyObj
{
    public string Foo { get; set; }
    public string Bar { get; set; }
}

Die String-Literale, die ich erhalte, lauten aber:

MyObj.Foo -> "Holzm\u00FChle 1"
MyObj.Bar -> "W\u00FCrttemberg"

Ist es jetzt verständlich?

EDIT: Für den Aufruf der Drittanbieter-API habe ich mir eine Klasse gebaut, die im Kern HttpClient u. JsonSerializer verwendet. Die hat auch schon in Dutzenden anderen Fällen funktioniert, und ich sehe das Problem auch nicht dort, sondern an der Stelle, an der ich den GET-URL aus u.a. obigen Literalen zusammenbaue.