PROCEDURE assertNoDuplicatesInTableRow(tblControl is Control,  cbColName is Control, vOldValue is Variant, sDialogText is string )

nFoundIndex					is int
nRetValDialog, nRetValInput	are int
vSearchValue, vNewValue		is string
vSearchValue	= cbColName

nFoundIndex		= TableSearch(cbColName, vSearchValue)

WHILE ((nFoundIndex > 0) AND  (nFoundIndex <> tblControl))
	nRetValDialog =  Dialog(sDialogText, ["Change", "Cancel"], 1, 2)
	IF (nRetValDialog = 1) THEN
		nRetValInput = Input("New value", vNewValue)
		IF nRetValInput = 2 THEN
			MySelf = vOldValue
			BREAK
		ELSE
			nFoundIndex = TableSearch(cbColName, vNewValue)
			IF nFoundIndex = tblControl THEN
				MySelf = vNewValue				
				BREAK
			END
		END
	ELSE
		MySelf = vOldValue
		BREAK
	END		
END

Asked ChatGPT to refactor ist:
Answer: Get rid of the loop and recall recursivly.

IF nFoundIndex > 0 AND nFoundIndex <> tblControl THEN Dialog(„Duplicate value found. Please enter a different value.“, [„OK“], 1, 1) assertNoDuplicatesInTableRow(tblControl, cbColName, vOldValue, sDialogText) ELSE MySelf = vNewValue END

That of course not WLanguage bu thte idea is decent:
One can write it this way:

PROCEDURE assertNoDuplicatesInTableRow(tblControl is Control,  cbColName is Control, vOldValue is Variant, sDialogText is string )

nFoundIndex					is int
nRetValDialog, nRetValInput	are int
vSearchValue, vNewValue		is Variant
vSearchValue	= cbColName

nFoundIndex		= TableSearch(cbColName, cbColName)

IF ((nFoundIndex > 0) AND  (nFoundIndex <> tblControl)) THEN
	nRetValDialog = Dialog(sDialogText, ["Change", "Cancel"], 1, 2)
	IF nRetValDialog = 2 THEN
			MySelf = vOldValue
	ELSE
		nRetValInput = Input("New value", vNewValue)
		IF nRetValInput = 2 THEN
			MySelf = vOldValue
			// BREAK
		ELSE
			cbColName.Value = vNewValue
			assertNoDuplicatesInTableRow(tblControl,cbColName, vOldValue, sDialogText)			
		END
	END
		
END

//WHILE ((nFoundIndex > 0) and  (nFoundIndex <> tblControl))
//	nRetValDialog =  Dialog(sDialogText, ["Change", "Cancel"], 1, 2)
//	IF (nRetValDialog = 1) THEN
//		nRetValInput = Input("New value", vNewValue)
//		IF nRetValInput = 2 THEN
//			MySelf = vOldValue
//			BREAK
//		ELSE
//			nFoundIndex = TableSearch(cbColName, vNewValue)
//			IF nFoundIndex = tblControl THEN
//				MySelf = vNewValue				
//				break
//			END
//		END
//	ELSE
//		MySelf = vOldValue
//		BREAK
//	END		
//END
//
//

Is it better? Well, it avoid a loop with different places where one has to break it
It avoids a double call to TableSearch, but replaces it with a recursive call

Other really good suggestions:

function to avoid a double in a two dimensional array

You can use a loop to iterate over the elements in the two-dimensional array and check if a given value already exists. Here’s an example implementation in C#:

csharpCopy codepublic bool CheckIfValueExistsInArray(int[,] array, int value)
{
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            if (array[i, j] == value)
            {
                return true;
            }
        }
    }
    return false;
}

In this example, the CheckIfValueExistsInArray method takes in a two-dimensional integer array and a value to check for. It then iterates over each element in the array using two nested loops, comparing each element to the given value. If a match is found, the method returns true. If the loop completes without finding a match, the method returns false.

You can call this method to check if a value already exists in a two-dimensional array before inserting a new value. You can then decide whether or not to insert the new value based on the return value of the method.

And:

How can I avoid the double loop in the suggested code?

If you want to avoid using nested loops, you can use the Array.IndexOf method to search for the value in a flattened version of the two-dimensional array. Here’s an example implementation:

csharpCopy codepublic bool CheckIfValueExistsInArray(int[,] array, int value)
{
    int[] flattenedArray = new int[array.GetLength(0) * array.GetLength(1)];
    Buffer.BlockCopy(array, 0, flattenedArray, 0, flattenedArray.Length * sizeof(int));
    return Array.IndexOf(flattenedArray, value) != -1;
}

In this example, the CheckIfValueExistsInArray method takes in a two-dimensional integer array and a value to check for. It creates a new one-dimensional integer array with the same number of elements as the two-dimensional array by using Buffer.BlockCopy to copy the elements from the two-dimensional array to the new array. It then uses the Array.IndexOf method to search for the value in the flattened array. If the value is found, the method returns true. If the value is not found, the method returns false.

Note that this approach has some overhead because of the need to create a new flattened array, so it may not be faster than using nested loops for very small arrays. However, it can be more concise and easier to read for larger arrays.

Was genau kann jemanden dazu bewegen, die Groß/Kleinschreibung von
Prozeduren/Methoden vorzugeben, was ist daran gut jedes Verb in Großbuchstaben zu schreiben? Und dann noch in Englisch.

Hier normaler englischer Text:
„

A grasshopper spent the summer hopping about in the sun and singing to his heart’s content. One day, an ant went hurrying by, looking very hot and weary.

„Why are you working on such a lovely day?“ said the grasshopper.

„I’m collecting food for the winter,“ said the ant, „and I suggest you do the same.“ And off she went, helping the other ants to carry food to their store. The grasshopper carried on hopping and singing. When winter came the ground was covered with snow. The grasshopper had no food and was hungry. So he went to the ants and asked for food.

„What did you do all summer when we were working to collect our food?“ said one of the ants.“

Wieso verlangt man in C#, daß Methoden groß geschrieben werden sollen:
Console.WriteLn(“ ..

Was für eine Aussehen, da bekommt man doch das Grausen und bei Go ist es „obligatorisch“
In Go, a name is exported if it begins with a capital letter. For example, Pizza is an exported name, as is Pi, which is exported from the math package.‘

WT …?

Es gibt sicherlich gute und schlechte Ideen und das ist in meinen Augen schlecht.