Question

I’m sending signed XML via WebClient to a gateway. Now I have to ensure, that the node values only contain german letters. I have 2 Testwords. The first gets very well converted by using:

string foreignString = "Łůj꣥ü";
Encoding utf8 = Encoding.UTF8;
Encoding iso = Encoding.GetEncoding("ISO-8859-1");
byte[] utfBytes = Encoding.Convert(iso, utf8, iso.GetBytes(foreignString));
string result = utf8.GetString(utfBytes);

But in the second string is a character which is also included in the UTF-8 Encoding. Its the

ç (Latin small letter c with cedilla)

After testing a little bit with other Encoding I always got the same result: the character was always there. What makes sense, because it is part of the UTF-8 table 🙂

So my question is: is there a way to mask out all the french, portuguese and spanish characters without dropping the german umlauts ?

Thanks in advance!

Answer 1

You can create your own Encoding class based on the ISO-8859-1 encoding with your additional special rules:

class GermanEncoding : Encoding {

  static readonly Encoding iso88791Encoding = Encoding.GetEncoding("ISO-8859-1");

  static readonly Dictionary<Char, Char> charMappingTable = new Dictionary<Char, Char> {
    { 'À', 'A' },
    { 'Á', 'A' },
    { 'Â', 'A' },
    { 'ç', 'c' },
    // Add more mappings
  };

  static readonly Dictionary<Byte, Byte> byteMappingTable = charMappingTable
    .ToDictionary(kvp => MapCharToByte(kvp.Key), kvp => MapCharToByte(kvp.Value));

  public override Int32 GetByteCount(Char[] chars, Int32 index, Int32 count) {
    return iso88791Encoding.GetByteCount(chars, index, count);
  }

  public override Int32 GetBytes(Char[] chars, Int32 charIndex, Int32 charCount, Byte[] bytes, Int32 byteIndex) {
    var count = iso88791Encoding.GetBytes(chars, charIndex, charCount, bytes, byteIndex);
    for (var i = byteIndex; i < byteIndex + count; ++i)
      if (byteMappingTable.ContainsKey(bytes[i]))
        bytes[i] = byteMappingTable[bytes[i]];
    return count;
  }

  public override Int32 GetCharCount(Byte[] bytes, Int32 index, Int32 count) {
    return iso88791Encoding.GetCharCount(bytes, index, count);
  }

  public override Int32 GetChars(Byte[] bytes, Int32 byteIndex, Int32 byteCount, Char[] chars, Int32 charIndex) {
    return iso88791Encoding.GetChars(bytes, byteIndex, byteCount, chars, charIndex);
  }

  public override Int32 GetMaxByteCount(Int32 charCount) {
    return iso88791Encoding.GetMaxByteCount(charCount);
  }

  public override Int32 GetMaxCharCount(Int32 byteCount) {
    return iso88791Encoding.GetMaxCharCount(byteCount);
  }

  static Byte MapCharToByte(Char c) {
    // NOTE: Assumes that each character encodes as a single byte.
    return iso88791Encoding.GetBytes(new[] { c })[0];
  }

}

This encoding is based on the fact that you want to use the ISO-8859-1 encoding with some additional restrictions where you want to map “non-german” characters to their ASCII equivalent. The built-in ISO-8859-1 encoding knows how to map Ł to L and because ISO-8859-1 is a single byte character set you can do additional mapping on the bytes because each byte corresponds to a character. This is done in the GetBytes method.

You can “clean” a string using this code:

var encoding = new GermanEncoding();
string foreignString = "Łůj꣥üç";
var bytes = encoding.GetBytes(foreignString);
var result = encoding.GetString(bytes);

The resulting string is LujeLAüc.

Note that the implementation is quite simplistic and it uses a dictionary to perform the additional mapping step of the bytes. This might not be efficient but in that case you can consider alternatives like using a 256 byte mapping array. Also, you need to expand the charMappingTable to contain all the additional mappings you want to perform.