Code Blog

Web-Applikation in VisualStudio 2022 langsam

deceed — Sat, 06 Aug 2022 08:40:10 GMT

Beim Wechsel von VisualStudio 2019 auf 2022 hatte ich kürzlich den Fall, dass eine Web-Applikation sehr langsam lief. Jeder HTTP Request hatte eine Verzögerung von ca. 2 Sekunden.

Nach langem Suchen fand ich heraus, dass dies an der Eisntellung "CSS Hot Reload" lag. Sobald ich diese Einstellung deaktiviert hatte, lief alles wieder im gewohnten Tempo. Die Einstellung befindet sich unter Debug => Options... => Projects and Solutions => ASP.NET Core

INSERT wenn nicht vorhanden

deceed — Sat, 06 Aug 2022 08:31:38 GMT

Will man einen Datensatz in eine Tabelle einfügen falls er noch nicht existiert, behilft man sich normalerweise mit einem NOT EXISTS(...) Statement. Eleganter - und vor allem threadsafe mit einem atomaren Statement - geht es mit dem MERGE Befehl.

Hier ein Beispiel anhand einer Tabelle Table1 mit Primary-Key Id und den Spalten Name und Wert:

MERGE INTO
  Table1 WITH (HOLDLOCK) t 
USING
  (VALUES (1, 'test', 6)) s([Id], [Name], [Wert])
ON
  t.[Id] = s.[Id]
WHEN NOT MATCHED THEN
  INSERT ([Id], [Name], [Wert]) VALUES (s.[Id], s.[Name], s.[Wert]);

Dateien von Publish ausschliessen

deceed — Thu, 21 Apr 2022 18:38:02 GMT

Projekt in Visual Studio "entladen" damit die .csproj Datei bearbeitet werden kann. Dann eine neue ItemGroup einfügen:

<ItemGroup>
  <Content Update="appsettings*.json" CopyToPublishDirectory="Never" />
  <Content Update="wwwroot/Posts/*.*" CopyToPublishDirectory="Never" />
</ItemGroup>

"Bitte warten" Animation während der Generierung einer Datei anzeigen

deceed — Tue, 12 Apr 2022 19:25:18 GMT

Oftmals möchte man ein "Bitte warten..." mit einer Animation anzeigen, während dem eine Datei auf dem Server dynamisch generiert und dann heruntergeladen wird.

Das Problem hierbei ist, dass man nicht weiss wann der Download beginnt (Browser zeigt Download Dialog) und man die Animation wieder stoppen muss.

Einen simplen aber effektiven Trick dafür habe ich auf folgender Seite gefunden: http://gruffcode.com/2010/10/28/detecting-the-file-download-dialog-in-the-browser/

Ganz einfach zusammengefasst funktioniert es folgendermassen:

Ein Klick auf einen Download-Link zeigt eine Animation an und führt einen Postback aus
Gleichzeitig wird clientseitig ein Timer gestartet der alle 500ms prüft ob ein bestimmtes Cookie vorhanden ist
Ist das Cookie vorhanden, wird die Animation wieder ausgeblendet
Serverseitig wird die Datei die heruntergeladen werden soll dynamisch erstellt und direkt in die HTTP Response geschrieben
Zusätzlich wird auch das oben erwähnte Cookie in die Response geschrieben
Sobald der Browser die Antwort des Servers erhält, wird der Download-Dialog angezeigt und gleichzeitig das Cookie gespeichert
Der clientseitigt JavaScript Timer läuft dabei im Hintergrund weiter, erkennt das Cookie und blendet die Animation aus

Beispielimplementierung einer ASP.NET MVC View:

<div>
    @using (Html.BeginForm("Download", "Home"))
    {
        @Html.Hidden("cookieValue")
        
    }
</div>

@section scripts {
<script>
    var _tmr;
    $(function () {
        $('#btnDownload').click(function () {
            $('#cookieValue').val(Date.now().toString());
            $('#divAnimation').show();

            _tmr = window.setInterval(function () {
                var _str = 'dlc=' + $('#cookieValue').val();
                if (document.cookie.indexOf(_str) !== -1) {
                    $('#divAnimation').hide();
                }
            }, 500);
        });
    });
</script>
}

Und die Implementierung des Controllers:

[HttpPost]
public FileResult Download(string cookieValue)
{
    System.Threading.Thread.Sleep(5000);
    string content = "Das ist meine Datei.";            
    ControllerContext.HttpContext.Response.Cookies.Add(
        new HttpCookie("dlc", cookieValue));
    return File(System.Text.Encoding.ASCII.GetBytes(content),
        "text/plain", "dateiname.txt");
}

Damit das Ganze auch mehrfach hintereinander funktioniert, muss jedes Mal auf einen neuen eindeutigen Wert des Cookies geprüft werden. Dazu wird ein Timestamp generiert und in einem Hidden-Field im POST Request an den Server übermittelt. Der Server setzt dann das Cookie mit diesem Wert.

ASP.NET MVC Lokalisierung aus Datenbank

deceed — Tue, 12 Apr 2022 19:23:20 GMT

Mittels DataAnnotations auf den Model Properties lassen sich die Texte für Labels und Validierungsfehler festlegen. Hardcodierte Texte und Texte in Ressourcedateien werden durch das MVC Framework bereits unterstützt. Konkret sieht dass dann z.B. so aus:

public class LoginModel
{
    [Required(ErrorMessage = "Benutzername darf nicht leer sein.")]
    [Display(Name = "Benutzername")]
    public string UserName { get; set; }

    [Required(ErrorMessageResourceName = "PasswordRequired", 
        ErrorMessageResourceType = typeof(Properties.Resources))]
    [Display(Name = "Password",
        ResourceType = typeof(Properties.Resources))]
    public string Password { get; set; }
}

In der View werden Anzeigename, Eingabefeld und Validierung folgendermassen ausgegeben:

@Html.LabelFor(m => m.UserName):
@Html.TextBoxFor(m => m.UserName)
@Html.ValidationMessageFor(m => m.UserName)

Jetzt sollen die Texte aber aus einer Datenbank gelesen werden. In den DataAnnotations wird darum nur noch die Datenbank-ID der entsprechenden Texte angegeben:

[Required(ErrorMessage = "27")]
[Display(Name = "42")]
public string UserName { get; set; }

Um diese IDs in Texte umzuwandeln sind noch einige Zusatzklassen notwendig. Dabei funktionieren Anzeigename (Display Attribut) und Validierung (Required Attribut) komplett unterschiedlich.

Lokalisierung des Anzeigenamens

Wir erstellen uns einen Metadata-Provider:

public class MetadataProvider : AssociatedMetadataProvider
{
    protected override ModelMetadata CreateMetadata(
        IEnumerable<Attribute> attributes, Type containerType,
        Func<object> modelAccessor, Type modelType,
        string propertyName)
    {
        var metadata = new ModelMetadata(this,
            containerType, modelAccessor, modelType, propertyName);
        if (propertyName != null)
        {
            var displayAttr = attributes.
                OfType<DisplayAttribute>().FirstOrDefault();
            if (displayAttr != null)
            {
                int textId;
                if (Int32.TryParse(displayAttr.Name, out textId))
                {
                    // TODO: read text from database
                    metadata.DisplayName = ...
                }
            }
        }

        return metadata;
    }
}

Unsere Klasse muss jetzt noch in Global.asax.cs in der Application_Start() Methode registriert werden:

ModelMetadataProviders.Current = new MetadataProvider();

Lokalisierung der Validierungsfehler

Hierzu sind zwei zusätzliche Klassen notwendig. Zuerst einmal der ModelValidatorProvider:

public class LocalizableModelValidatorProvider :
    DataAnnotationsModelValidatorProvider
{
    protected override IEnumerable GetValidators(
        ModelMetadata metadata, ControllerContext context,
        IEnumerable attributes)
    {
        var validators = base.GetValidators(metadata,
          context, attributes);
        return validators.Select(validator =>
            new LocalizableModelValidator(validator, metadata,
                context)).ToList();
    }
}

Diese Klasse sorgt dafür, dass wir unsere eigene Klasse "LocalizableModelValidator" zur Validierung des Models verwenden können. Wie schon beim MetadataProvider muss auch der ModelValidatorProvider in Global.asax.cs in der Application_Start() Methode registriert werden:

var provider = ModelValidatorProviders.Providers.FirstOrDefault(p =>
    p.GetType() == typeof(DataAnnotationsModelValidatorProvider));
if (provider != null)
{
    ModelValidatorProviders.Providers.Remove(provider);
}
ModelValidatorProviders.Providers.Add(
    new LocalizableDataAnnotationsModelValidatorProvider());

Eine bereit vorhandener Provider vom Typ DataAnnotationsModelValidatorProvider wird dabei zuerst entfernt.

Und schlussendlich noch die etwas umfangreichere Implementierung des ModelValidators:

public class LocalizableModelValidator : ModelValidator
{
    private readonly ModelValidator innerValidator;

    public LocalizableModelValidator(ModelValidator innerValidator,
        ModelMetadata metadata, ControllerContext controllerContext)
        : base(metadata, controllerContext)
    {
        this.innerValidator = innerValidator;
    }

    public override IEnumerable
        GetClientValidationRules()
    {
        var rules = innerValidator.GetClientValidationRules();
        var modelClientValidationRules = 
            rules as ModelClientValidationRule[] ?? rules.ToArray();
        foreach (var rule in modelClientValidationRules)
        {
            int textId;
            if (Int32.TryParse(rule.ErrorMessage, out textId))
            {
                // TODO: read text from database
                rule.ErrorMessage = ...
            }
        }
        return modelClientValidationRules;
    }

    public override IEnumerable
        Validate(object container)
    {
        var results = innerValidator.Validate(container);
        return results.Select(result =>
        {
            int textId;
            if (Int32.TryParse(result.Message, out textId))
            {
                // TODO: read text from database
                result.Message = ...
            }
            return new ModelValidationResult() {
                Message = result.Message };
        });
    }
}

Berechtigungen für Application-Pool

deceed — Tue, 12 Apr 2022 19:19:03 GMT

Um Berechtigungen, z.B. auf dem Dateisystem für den Application-Pool zu setzen, kann der Benutzer IIS APPPOOL\<NameDesAppPools> verwendet werden.

SQL Cursor

deceed — Tue, 12 Apr 2022 19:02:29 GMT

Als kleine Hilfe die Syntax eines T-SQL Cursors. (Ja, Cursors sind langsam und sollten wenn immer möglich nicht verwendet werden...)

DECLARE @Id INT
DECLARE cur CURSOR LOCAL FAST_FORWARD READ_ONLY FOR
    SELECT
        Id
    FROM
        ItemObjects
    WHERE
        Version_Id = @SourceVersionId


OPEN cur
FETCH NEXT FROM cur INTO @ItemObject_Id
WHILE @@FETCH_STATUS = 0
BEGIN


    FETCH NEXT FROM cur INTO @Id
END
CLOSE cur
DEALLOCATE cur

Diakritische Zeichen in SQL entfernen

deceed — Tue, 12 Apr 2022 19:01:46 GMT

Diakritische Zeichen - oder Diakritika - sind an Buchstaben angebrachte kleine Zeichen wie Punkte, Striche, Häkchen, Bögen oder Kreise. Also z.B. die Punkte auf dem ö, oder der Akzent auf dem é. In T-SQL gibt es eine einfache Methode diese Zeichen zu entfernen und durch die reinen Buchstaben zu ersetzen:

SELECT 'àéêöhello!' Collate SQL_Latin1_General_CP1253_CI_AI

Tabellenzeilen als String zurückgeben

deceed — Tue, 12 Apr 2022 19:01:00 GMT

Das FOR XML Schlüsselwort in T-SQL kann dazu missbraucht werden die Resultate eines Sub-Select zu einem String zusammenzusetzen.

Schauen wir uns mal folgendes Datenmodell an:

Wir möchten eine Liste aller Produkte ausgeben, und in derselben Liste zeigen in welchen Farben ein Produkt lieferbar ist. Mit Hilfe des FOR XML Konstrukts lässt sich das einfach in einer einzigen SQL Abfrage realisieren:

SELECT
  P.Name,
  (SELECT STUFF((
    SELECT ', ' + C.Name
    FROM 
      Color C
    INNER JOIN
      ProductColor PC ON PC.ColorId = C.ColorId
    WHERE
      PC.ProductId = P.ProductId
    FOR XML PATH('')), 1, 2, '')
  ) AS Colors
FROM
  Product P

Diese Abfrage liefert folgendes Ergebnis:

JOIN auf Tabelle A oder Tabelle B

deceed — Tue, 12 Apr 2022 18:49:13 GMT

Eine Person hat eine Rechnungsdresse und optional eine Lieferadresse. Falls eine Lieferadresse vorhanden ist, soll diese ausgegeben werden, falls nicht die Rechnungsadresse. Dies könnte man folgendermassen lösen:

SELECT
  A.AddressString
FROM
  Person P
INNER JOIN
  Address A ON A.AddressId = ISNULL(P.AddressId, P.DeliveryAddressId)

Dummerweise kann die JOIN Bedingung mit der ISNULL Funktion dazu führen, dass ein bestehender Index auf Address.Id nicht verwendet wird.

Folgende Variante gibt zwar etwas mehr zu schreiben, die Performance ist jedoch um Welten besser:

SELECT
  ISNULL(A2.AddressString, A1.AddressString) AddressString
FROM
  Person P
INNER JOIN
  Address A1 ON A.AddressId = P.AddressId
LEFT OUTER JOIN
  Address A2 ON A.AddressId = P.DeliveryAddressId