DEV Community: Anil Joseph Edward

StringBuilder is (almost always) better than String Concatenation

Anil Joseph Edward — Mon, 16 Jun 2025 02:10:31 +0000

Today we're diving into a super-cool trick to make your C# code run like lightning ⚡️ when you're working with strings. It's all about choosing the right tool for the job, and that tool is called... StringBuilder! ️

Here's the scoop:

String Concatenation: The Usual Way
- You know how you normally put strings together with the + sign? Like "Hello" + " " + "World"?
- That's called string concatenation, and while it's easy to do, it can get a bit slow when you're working with lots of strings. Imagine building a huge sentence word by word—it takes time to glue everything together!

public void WithConcatenation(string[] AllStrings)
{
    string finalString = "";
    foreach (string s in AllStrings)
    {
        finalString += s;
    }
}

StringBuilder: The Performance Powerhouse
- Enter StringBuilder! It's like having a special string workshop where you can quickly assemble strings without all the fuss.
- Instead of creating new strings every time you add something (like with the + sign), StringBuilder lets you build the string in memory first. It's like having all your words ready to go before you start gluing.
- When you're done, you just ask StringBuilder for the final string, and it hands it over, perfectly crafted and ready to use!

public void WithStringBuilder(string[] AllStrings)
{
    StringBuilder sb = new StringBuilder();

    foreach (string s in AllStrings)
    {
        sb.Append(s);
    }

    var finalString = sb.ToString();
}

When to Use Which:

Just a few strings? The + sign is still your pal. It's quick and easy for small jobs.
Building a string empire? Summon the StringBuilder! It's a master of efficiency for larger string projects.
- Think of it like this: if you're making a sandwich, using a knife to spread peanut butter is fine. But if you're catering a party, you'll want a big old spatula to get the job done quickly!

Key Takeaways:

StringBuilder is almost always faster than string concatenation when you're working with more than a handful of strings.
It can make your code run up to 7000 times faster in some cases!
Remember to use the right tool for the job: StringBuilder for big string projects, + sign for smaller tasks.

Now go forth and build those strings with lightning speed! ⚡️

Original Source: Tip #1: StringBuilder is (almost always) better than String Concatenation

PowerShell script to add IP ranges in bulk

Anil Joseph Edward — Mon, 16 Jun 2025 02:09:13 +0000

We had several websites hosted on a Windows server and usually there were several attempts to hack those websites using SQL Injection.
I needed a script to add IP addresses in bulk to a Firewall rule in Windows server.

Custom 500 error page

We have configured the web.config to show a custom 500 error page instead of the default one.
And in that custom 500 page, we have a script to log those errors and send us an email when that error occurs.
We use this for debugging or fixing issues with the application that we run.

This is the code in web.config file for allowing custom error pages:

<httpErrors>
 <remove statusCode="500" subStatusCode="100" />
 <error statusCode="500" subStatusCode="100" path="/iishelp/common/500-100.asp" responseMode="ExecuteURL" />
</httpErrors>

And in our "500-100.asp" (custom error page) we had the following code:

strMessage = "HTTP Referrer : " & Request.ServerVariables("HTTP_REFERER") & vbCrLf & _
            "URL : " & Request.ServerVariables("URL")  & vbCrLf & _
            "IP Address: " & Request.ServerVariables("REMOTE_ADDR") & vbCrLf & _
            "Browser: " & Request.ServerVariables("HTTP_USER_AGENT") & vbCrLf & _
            "Category: " & objASPError.Category & vbCrLf & _
            "Filename: " & objASPError.File & vbCrLf & _
            "ASP Code: " & objASPError.ASPCode & vbCrLf & _
            "Error Number: " & objASPError.Number & vbCrLf & _
            "Source: " & objASPError.Source & vbCrLf & _
            "Line Number: " & objASPError.Line & vbCrLf & _
            "Column: " & objASPError.Column & vbCrLf & _
            "Description: " & objASPError.Description & vbCrLf & _
            "ASP Description: " & objASPError.ASPDescription & vbCrLf & _
            "All HTTP: " & Request.ServerVariables("ALL_HTTP") & vbCrLf & _
            "POST Fields: " & Request.Form & vbCrLf & _
            "GET Fields: " & Request.QueryString & vbCrLf

This message is sent as an email and also logged in Error Log Table.
Using the IP Address information from the error message, we wanted to block the IP Address range whenever we find some kind of hacking attempt on the website.

PowerShell Script

We were adding the IP address range manually in the Firewall rule.
For example, if the IP Address was "157.55.39.12", we will add the whole range, "157.55.39.0/24" in the blocking Firewall rule.

But this was cumbersome to do it manually.
So, we used this PowerShell script for adding the IP address range to the Firewall rule, automatically.

param (
    [Parameter(Mandatory = $true)]
    [string]
    $FirewallRuleName,

    [Parameter(Mandatory = $true)]
    [string[]]
    $NewIPs
)

$firewallRule = Get-NetFirewallRule -Name $FirewallRuleName

$existingRemoteAddresses = (Get-NetFirewallAddressFilter -AssociatedNetFirewallRule $firewallRule).RemoteAddress

# Convert the existing remote addresses and new IP addresses to arrays
$existingRemoteAddressesArray = $existingRemoteAddresses -split ","

$updatedRemoteAddresses = $existingRemoteAddressesArray + $NewIPs

# Remove any leading or trailing spaces from the IP addresses
$updatedRemoteAddresses = $updatedRemoteAddresses.Trim()

Set-NetFirewallRule -Name $FirewallRuleName -RemoteAddress $updatedRemoteAddresses -Confirm:$false

#Write-Output $updatedRemoteAddresses

It was stored in a folder, "C:\PowerShellScripts"
The code was called in PowerShell as the following:

cd C:\PowerShellScripts
.\AddFirewall.ps1 -FirewallRuleName "Block Other Server IP Addresses" -NewIPs "157.55.39.0/24", "5.255.231.0/24", "213.180.203.0/24", "207.46.13.0/24", "114.119.159.0/24", "114.119.133.0/24"

With this option we were able to add lots of IP address ranges to the Firewall rule to block offending IP Addresses.

Statistics and the Ascending Key Problem

Anil Joseph Edward — Mon, 16 Jun 2025 02:08:23 +0000

This article examines the Ascending Key Problem, which can affect query performance due to outdated statistics, and provides ways to mitigate it through SQL Server. Solutions discussed include updating statistics more regularly than the built-in thresholds, and using Traceflag 2371 to reduce the threshold for statistics updates.

Visit the link to read more clearly about it.

Summary:

This article looks at the Ascending Key Problem, which can cause problems in query performance due to outdated statistics, and provides mitigations to deal with it in SQL Server.

Key takeaways:

The Ascending Key Problem relates to the most recently inserted data in a table, which may not have been sampled and included in the statistics histograms.
The Optimizer will guess that there are zero rows if the range you are looking for falls beyond the top of the histogram captured in the statistics object.
Scans aren't always bad for performance, as they can bail out once they are satisfied.

Counter arguments:

Updating statistics more regularly than the built-in automatic thresholds may not be necessary.
Traceflag 2371 reduces the threshold for statistics updates.

How to delete large records in batches

Anil Joseph Edward — Mon, 16 Jun 2025 02:07:39 +0000

When performing long-running modifications, I'm sure many of you enjoy using batches to increase concurrency. But I want to talk about a pitfall to be aware of. If you're not careful, the method you use to implement batching can actually worsen concurrency.

Why Use Batches?

Even without an explicit transaction, all SQL statements are atomic – changes are all or nothing. So when you have long-running modifications to make, locks on data can be held for the duration of your query and that can be too long. Especially if your changes are intended for live databases.

But you can make your modifications in several smaller chunks or batches. The hope is that each individual batch executes quickly and holds locks on resources for a short period of time. But care is needed.

Example

I'm going to give an example to show what I mean.

The example uses the FactOnlineSales table in the ContosoRetailDW database (available as a download here).

The FactOnlineSales table has

one clustered index on OnlineSalesKey and no other indexes,
12 million rows,
and 46 thousand database pages

Metrics to Use
In this example, I want to know how long each query takes because this should let me know roughly how long locks are held. But instead of duration, I'm going to measure logical reads. It's a little more consistent and in the examples below, it's nicely correlated with duration.

The Straight Query

Suppose we want to remove sales data from FactOnlineSales for the "Worcester Company" whose CustomerKey = 19036. That's a simple delete statement:

DELETE FactOnlineSales WHERE CustomerKey = 19036;

This delete statement runs an unacceptably long time. It scans the clustered index and performs 46,650 logical reads and I'm worried about concurrency issues.

Naive Batching

So I try to delete 1,000 rows at a time. This implementation seems reasonable on the surface:

DECLARE 
  @RC INT = 1;

WHILE (@RC > 0)
BEGIN

  DELETE TOP (1000) FactOnlineSales
  WHERE CustomerKey = 19036;

  SET @RC = @@ROWCOUNT

END

Unfortunately, this method does poorly.
It scans the clustered index in order to find 1,000 rows to delete. The first few batches complete quickly, but later batches gradually get slower as it takes longer and longer to scan the index to find rows to delete.

By the time the script gets to the last batch, SQL Server has to delete rows near the very end of the clustered index and to find them, SQL Server has to scan the entire table. In fact, this last batch performs 46,521 logical reads (just 100 fewer reads than the straight delete).

And the entire script performed 1,486,285 logical reads in total. If concurrency is what I’m after, this script is actually worse than the simple DELETE statement.

Careful Batching

But I know something about the indexes on this table. I can make use of this knowledge by keeping track of my progress through the clustered index so that I can continue where I left off:

DECLARE
  @LargestKeyProcessed INT = -1,
  @NextBatchMax INT,
  @RC INT = 1;

WHILE (@RC > 0)
BEGIN

  SELECT TOP (1000) @NextBatchMax = OnlineSalesKey
  FROM FactOnlineSales
  WHERE OnlineSalesKey > @LargestKeyProcessed
    AND CustomerKey = 19036
  ORDER BY OnlineSalesKey ASC;

  DELETE FactOnlineSales
  WHERE CustomerKey = 19036
    AND OnlineSalesKey > @LargestKeyProcessed
    AND OnlineSalesKey <= @NextBatchMax;

  SET @RC = @@ROWCOUNT;
  SET @LargestKeyProcessed = @NextBatchMax;

END

The delete statements in this script performed 46,796 logical reads in total but no individual delete statement performed more than 6,363. Graphically that looks like:

Logical Reads Per Delete

The careful batching method runs in roughly the same time as the straight delete statement but ensures that locks are not held for long.

The naive batching method runs with an order of n² complexity (compared to the expected complexity of n) and can hold locks just as long as the straight delete statement. This underlines the importance of testing for performance.

Original Source: http://michaeljswart.com/2014/09/take-care-when-scripting-batches/

WordPress plugin updates shows -1

Anil Joseph Edward — Mon, 16 Jun 2025 02:03:40 +0000

Problem

We had an issue with a WordPress website, which wouldn't allow us to update or install any plugins.
When we try updating a plugin, the page would show just "-1".

Even adding a new plugin would show a "-1" error.
There wouldn't be any error messages or clue on what went wrong.
Even enabling debugging the WordPress site did not provide any clue on what caused this issue.

If you check the developer console of the browser, it would show that the "wp-admin/admin-ajax.php" throws a "403 error".

And the problem is that WordPress would create a ".maintenance" file when you update the plugin. Now the site would go to Maintenance mode and will not be available, unless you manually delete the ".maintenance" file via FTP.

Details

The WordPress website had many plugins. And it had the following plugins installed in it:

Autoptimize
Elementor
Page Builder by SiteOrigin
Really Simple SSL
Starter Templates (from Astra)
Sucuri Security - Auditing, Malware Scanner and Hardening
Super Page Cache for Cloudflare
Wordfence Security

And the domain was using Cloudflare to make the site load faster and use the security feature provided by it.

The site was hosted in Ionos Web hosting package.

Steps that did NOT work

Tried to find out the issue by bypassing Cloudflare. It did not work.
Tried to stop the caching on the site and Cloudflare. It did not solve the problem.
Tried deactivating the security plugins. It did not solve the problem.
Tried removing "Really Simple SSL" plugin security options. Still the problem persisted.

Solution

We were on the verge of moving the site to another hosting provider, as we could not find the source of this issue. And the hosting support could not find anything wrong with their servers or system.

And then finally, I came upon this solution on WordPress support forum.
https://wordpress.org/support/topic/plugin-updates-shows-1/

It stated that the issue is with Starter Templates (from Astra).
I just deactivated that plugin and the updates of other plugins worked smoothly.
And later on, I updated the Starter Templates plugin to the latest version.
If you face this kind of issue in the future, please check if you have installed Starter Templates. Just deactivate it and work on the other updates.