Warning:  this list is  far  too detailed.   There's won't be many question on the exam from this chapter.   I think the sample questions will give you a pretty good idea of what you need to know.  

The  (parenthesized references)  in this list are explained  here.  

Cultures

• "Culture" refers only to matters of data format and display.   It does not refer to business rules,  such as currency conversion.   (Kalani,  page 611,  box)
• The differences between the two uses for the culture specification:
  • CurrentUICulture  controls what you set on the Form using the IDE,  (without going to the code behind this Form),  such as menus,  form layouts,  input fields,  and shortcut keys.   (It might be simpler for you to think of the name as  CurrentGUICulture  because it applies only to GUI objects.   But I warn you that it is very easy to mistake the two.)
  • CurrentCulture  covers everythings else,  specifically,  display formats for dates & times,  money,  numbers,  calendars,  and alphabetical order.
• The namespace:  System.Globalization 
• The composition of a culture code, such as "en-US": 
  • neutral culture code,  such as "en",  in lower case, and
  • a subculture code,  such as "US",  in upper case or mixed.   (There may be more than one subculture code,  though it's rare.)
• Sample Code:   (Kalani, page 607)
  • To enumerate all the cultures:

            CultureInfo.GetCultures(CultureTypes.SpecificCultures)

  • To get a culture object for a specific culture:

            CultureInfo ci = new CultureInfo(string s);

    Then you have things like

            ci.DisplayName
            ci.EnglishName
            ci.DateTimeFormat.DayNames

    For calendar information, you have

            ci.Calendar.GetYear(DateTime.Today)

    There is more information on calendars in the exercises at the end of the chapter.   (Kalani,  page 630-631)   For instance, 

            DateTimeFormatInfo dtfi = ci.DateTimeFormat;
            Calendar ci = ci.Calendar;
            DateTime dt = DateTime.Today;
            cal.GetType().ToString();  //type of calendar
            cal.GetDayOFMonth(dt));    //today, in local format
            cal.GetMonth(dt));
            cal.GetYear(dt));
            cal.GetDayOfWeek(dt));
            cal.GetMonthsInYear(cal.GetYear(dt));

    And there are a lot of methods for handling time in the local format,  such as

            AddDays()
            AddHours() ....
            GetDaysInMonth()
            GetEra()
            IsLeapDay()
            IsLeapMonth() ....
            ToFourDigitYear()

    And there are subclasses of  Calendar,  such as  GregorianCalendar.

    For currency,

            ci.NumberFormat.CurrencySymbol

    Also at the end of the chapter is how to retrieve information on Region:   (Kalani,  pages 631-632)

            RegionInfo rgi = new RegionInfo(someRegion);
            rgi.Name;
            rgi.DisplayName;
            rgi.EnglishName;
            rgi.CurrencySymbol;

    For the name of the current local region,   (Kalani,  pages 633,  box)

            Thread.CurrentThread.CurrentRegion

• Setting a culture:
  • You set a culture for a Thread,  which is in the  System.Threading  namespace
  • Code to do this:   (Kalani, page 610)

            Thread.CurrentThread.CurrentCulture = 
              new CultureInfo(string selectedCulture);

  • Note that you set the current culture equal to a CultureInfo object;  you don't set it to a string.   If all you have is a string,  you create the CultureInfo object first,  then set the CurrentCulture to that object.
• The invariant culture:
  • You use this when there's no user interaction,  such as for communication with Windows system services
  • You can set it with

            CultureInfo ciInv = new CultureInfo("");

  • Or with

            CultureInfo ciInv = CultureInfo.InvariantCulture;

• System culture defaults:
  • Windows 2000 or XP can have a Multiple User Interface,  in which the .NET Framework defaults to that of the user
  • Other versions will default to that of the operating system
  • In some situations,  you may want to have the user select a culture
• Localizing Forms using the IDE:   (Kalani, pages 612-614)
  You do this if you want to redo the Form for each culture.  
  • Set Form's  Localizable  property to  true
  • Set the Form's  Language  property and enter GUI labels in that language.
  • Reset the  Language  property and enter GUI labels in that language.   (The system automatically gives you another copy of your Form when you specify a new language,  and it will return to an earlier Form if you specify the language for that Form.)
  • The result will be "Satellite assemblies",  which include  (in this case)  five cultures:
    • neutral
    • neutral language 1 culture
    • specific language 1 culture
    • neutral language 2 culture
    • specific language 2 culture   (Kalani,  page 614,  box)
    For each one of these cultures,  you get several things.   (You might refer to Kalani's chapter 4 if you want an explanation.)
    • a Form in that language
    • an .resx  file for that language.   You can get such files to show by pressing the  "Show all files"  button atop the Solution Explorer window.
    • a subdirectory under Debug or Release, named  myProject.resources.dll.   (The names of the DLLs don't vary;  just the directory they're in.)
  • But you won't get a useful Form if you don't specify the language for it.
    • What will appear for the Default culture—that is,  the Form that appears if you haven't specified a Form for the language you just chose—will be the last version of the Form that you created before you used the IDE to specify a language.   That may very well be a temporary Form,  one which you don't want displayed.
    • You do not get a Form for a neutral culture just because you have set up a Form for a corresponding specific culture.   If you create a Form for "en-US",  you will not get that Form if you specify "en-GB".   Nor will you get a Form for just "en",  although there seems to be a small .resx  file for it.   You will get the Default Form.   If you want a default English form,  you must choose  (using the IDE)  the language  "English",  not  "English -- United States"  and complete that Form.
  • A curiosity:  the way you choose between different versions of Forms for different cultures is by setting the  Localizable  property of the Form to true and then specifying a Language for the Form.   But a Form has no  Language  property.   I don't know how to get the Form to tell you which language it was developed for.
  • Warning:  resetting the culture will not change the values displayed on the Form current displayed.   "Satellite assemblies are used only when a form is first opened."   (Kalani, page 638, answer 6)   You have to re-load the Form to get new values to appear.   The way you handle this,  of course,  is to choose the culture before you open the localized Form.
  • Remember that the value that controls which Form is opened is  CurrentUICulture,  not  CurrentCulture.   It is very easy to make this mistake.
  • You really ought to play around with this stuff if you want to see how it works.
• Localizing using Resource Files   (Kalani, page 615)
  You do this to handle strings,  say,  that don't appear on the Form on your IDE—for instance,  messages in MessageBoxes.
  • You need these namespaces:
    • System.Globalization  for for the various cultures
    • System.Resources  for the Resource Manager
    • System.Threading  so you can set a culture for a Thread
  • You use   Add New Item / Assembly Resource File template
  • Name the files  ---.resx
  • Enter names for all  the text strings on your Form
  • Copy this file for culture  en-US
  • Do another file for,  say,  fr-FR,  with strings in French
  • In your program,  read the strings after loading the resource file:

            ResourceManager rem = new ResourceManager(
              "mySolution.myResourceFile",
              Type,GetType("myProject.mySolution").Assembly);
            lblSomething.Text = rm.GetString("Something");

    etc., etc., etc., etc.
  • Incidentally,  you do remember Resource Files,  don't you?   From chapter 4?  page 338?
• The system searches for culture resources in this order:   (Kalani, page 617)
  • a specific culture,  e.g.,  resFile.fr-FR.resx
  • a neutral culture, e.g.,  resFile.fr.resx
  • an invariant culture,  e.g.,  resFile.resx

Encodings

• Namespace:  System.Text.   (You have to add a  using  declaration for this namespace,  as it's not one of the standard ones included with each Windows app.)
• Internally,  the .NET Framework uses 16-bit Unicode,  UTF-16,  giving it some  65,000  characters.
• Encoding classes:   (Kalani, pages 623-4)
  Kalani's presentation is not quite clear about this.   Each class is named for the code type that it translates data into.   I have copied information from the on-line help,  which can be found under the name of the class.   (I'm really sorry about the length of this—I got in and I couldn't get out.   I now see why Kalani limited his discussion of these things to one line each.)
  • Encoding.   The abstract class from which these others inherit.   Contains general pupose methods.   Its static  GetEncoding  method can get all the encodings,  including those not mentioned here.  

    "Use the  GetEncoding  method with a code page or name parameter to obtain other encodings."   (Help: "Encoding class")

    • Code page:  "An ordered set of characters of a given script in which a numeric index  (code-point value)  is associated with each character.... This term is generally used in the context of code pages defined by Windows and can also be called a  'character set'  or  'charset'."   (Dr. International,  8)    Each code page has an arbitrary number assigned to it,  which you use to access it.   There are two whole sets of code pages,  those for Microsoft Windows and those for Microsoft MS-DOS,  this latter set also called "Original Equipment Manufacturer (OEM)" code pages.   (Dr. International, 727)

  The  Encoding  class has some important methods which are shared by its inheriting classes:   (Help: "Encoding class")
  • "Through an encoding,  the  GetBytes  method is used to convert arrays of Unicode characters to arrays of bytes,  and the  GetChars  method is used to convert arrays of bytes to arrays of Unicode characters.   The  GetBytes  and  GetChars  methods maintain no state between conversions."
  • (I'll repeat that:  SomeEncoding.GetChars  goes into Unicode;  SomeEncoding.GetBytes  goes into the "some" encoding.)
  • ASCIIEncoding.   "Encodes Unicode characters as single 7-bit ASCII characters.   This encoding only supports character values between U+0000 and U+007F.   This limitation makes ASCII largely inadequate for internationalized applications.   Consider using UTF8Encoding or UnicodeEncoding instead."   (Help: "ASCIIEncoding")
  • UnicodeEncoding.   "Encodes Unicode characters in Unicode Transformation Format,  16-bit encoding form (UTF-16);  that is,  the character is encoded in a 16-bit field consisting of two consecutive bytes.   An extension mechanism,  using pairs of fields called surrogates,  enables another 2**20 characters to be encoded.

    "The two bytes of an encoded character are stored in either little-endian or big-endian byte order depending on the computer architecture.   In big-endian architectures the most significant byte is written and read first,  while in little-endian architectures the least significant byte is written and read first.

    "A UTF-16 encoding can be prefixed by a byte order mark (U+FEFF) to indicate the byte order used."   (Help: "UnicodeEncoding")

  • UTF7Encoding.   Encodes Unicode characters using UCS  [uh, Universal Character Set] Transformation Format,  7-bit form (UTF-7).   This encoding supports all Unicode character values.   Surrogate pairs are encoded as two separate surrogate code points.

    UTF-7 encoding was originally invented to efficiently transmit Unicode characters through e-mail systems optimized for US-ASCII text messages.

    [I suspect that UTF-7 is now rather rare,  if not obsolete.   Dr. International  doesn't even mention it.]

  • UTF8Encoding.   "This class encodes Unicode characters using UCS Transformation Format, 8-bit form  (UTF-8).   This encoding supports all Unicode character values and surrogates.   For more information regarding surrogate pairs,  see  UnicodeCategory.

    "This class contains the  GetCharCount  method that reports the number of Unicode characters that result from decoding an array of bytes,  and the  GetChars  method that actually decodes an array of bytes.   The GetByteCount  method reports the number of bytes that result from encoding strings or arrays of Unicode characters,  and the GetBytes  method actually encodes characters into an array of bytes....

    "The  GetPreamble  method can obtain a Unicode byte order mark,  which when prefixed to a series of bytes,  indicates how those bytes are encoded.

    "UTF-8 encodes Unicode characters with a variable number of bytes per character.   This encoding is optimized for the lower 127 ASCII characters,  yielding an efficient mechanism to encode English in an international way.   The UTF-8 identifier is the Unicode byte order mark,  hexadecimal 0xFEFF,  which is represented in UTF-8 as hexadecimal 0xEF 0xBB 0xBF.   The byte order mark is used to distinguish UTF-8 text from other encodings.

    "This class offers an error detection feature that can be turned on when you create an instance of the class...."   (Help: "UTF8Encoding")

    "The starting byte of a chain of bytes in a UTF-8 encoded character tells how many bytes are used to encode that character."   (Dr. International, 61)

    This is still a common encoding,  as shown by something you've already seen,  from the XML section of our web page on Kalani's chapter 6,  part 2:   the declaration at the top of an XML file:

            <?xml version="1.0" encoding="UTF-8"?>

Mirroring

• The  RightToLeft  property on a Form reverses some things,  but not all—
  • Text strings are not reversed
  • System menu and close and minimize buttons don't switch positions,  although the Form's caption is positioned at the right end of the bar
  • The statement in code that effects the change in a Form is

            this.RightToLeft = System.Windows.Forms.RightToLeft.Yes;

• Now,  Kalani says that for complete mirroring,  you need an API call:   SetProcessDefaultLayout.   (Kalani, page 625, box)

  Unfortunately,  Kalani is just flat wrong.   I tried quite a while to get this to work,  and it doesn't want to.

  The way you get a Form to come up mirrored is to add the following code to its class.   You don't even have to call anything.   It just works.   (Help: "Creating Mirrored Windows Forms and Controls")

      const int WS_EX_LAYOUTRTL = 0x400000;
      const int WS_EX_NOINHERITLAYOUT = 0x100000;
      protected override CreateParams CreateParams
      {
        get
        {
          CreateParams CP = base.CreateParams;
          if (! base.DesignMode)
            CP.ExStyle = CP.ExStyle | WS_EX_LAYOUTRTL | WS_EX_NOINHERITLAYOUT;
          return CP;
        }
      }

  This reverses the Form itself,  it even seems to reverse text boxes and buttons,  even though their  "Right to Left"  property isn't set either to  RightToLeft.Yes  or to  RightToLeft.Inherit.   And there are odd results.   The text strings are not reversed,  though they are right-adjusted,  and punctuation appears where you don't expect it.   There is a list of the effects of the  "RightToLeft"  setting on each control in Dr. International.   (Dr. International, pp. 299-306)

Non-Latin User Input  and  Some Non-English Text Handling

• A  "surrogate pair"  is a set of two 16-bit codes for a single character from the extended 32-bit Unicode set.
• A  "combining character sequence"  is a set of 16-bit codes for a single character.
• The Class for this:   System.Globalization.StringInfo
• Sample use:   (Kalani, page 627)

          TextElementEnumerator iter = 
            StringInfo.GetTextElementEnumerator(myStringWithLongChars);
          iter.MoveNext();
          do
          {
            // now can use  iter.ElementIndex 
            // and          iter.Current
          }
          while (iter.MoveNext());

• Comparing and sorting data.   Kalani's summary  (page 628)  is so compressed that I don't understand it,  but it turns out he had his reasons:  getting below the surface of this subject results in much more detail than is reasonable.

  The more I look at this,  the more I think that trying to memorize it is not a good use of your time.

  Much of what follows is from the on-line help:

  • String.Compare().   "By default,  the  String.Compare  method performs culture-sensitive and case-sensitive comparisons.   However,  an overload of the  String.Compare  method is provided that allows you to specify the culture to use by supplying a culture parameter.   Application code should clearly demonstrate whether a string comparison is intended to be culture-sensitive or culture-insensitive.   For culture-sensitive operations,  specify the  CultureInfo.CurrentCulture  property as the culture parameter.   For culture-insensitive operations,  specify the  CultureInfo.InvariantCulture  property as the culture parameter."   An example:

            int compareResult = 
              String.Compare(string1, string2, false, CultureInfo.CurrentCulture);

    (Help: "String.Compare")
  • The  CultureInfo  class is very large.   (We have been looking at examples of it earlier in this chapter.)   It knows about the current culture.   It has a property,  CompareInfo,  which returns an instance of the  CompareInfo  class in  System.Globalization.   This class  "Implements a set of methods for culture-sensitive string comparisons."   Its members include  Compare  and GetSortKey.   (Help: "CompareInfo Class")
  • Kalani says that the  Array.Sort()  method uses the current culture  (page 628).   But the on-line help makes this hard to find.   It appears to me that you have to specify the  IComparer  interface,  as in

            public static void Sort(Array, IComparer);

    because it is only in the description of  IComparer  that I can find something like  "Comparison procedures use the  Thread.CurrentCulture  of the current thread unless otherwise specified.   String comparisons might have different results depending on the culture."   (Help: "IComparer Interface";  "Array.Sort method")
  • The  SortKey  class is a member of System.Globalization.   (It is not a member of another class.)   It "Represents the result of mapping a string to its sort key."   (Help: "SortKey Class")   It has at least one important member:
    • SortKey.Compare()  Kalani says this  "compares strings according to the current culture."   But the on-line help says,  of  SortKey.Compare,  "Compares two sort keys."   Example:

                  // Creates a SortKey using the en-US culture.
                  CompareInfo myComp_enUS = 
                    new CultureInfo("en-US",false).CompareInfo;
                  SortKey mySK1 = myComp_enUS.GetSortKey( "llama" );

      For more about sorting llamas  (oh,  sometimes they're equal,  and sometimes they're not equal),  see the on-line Help.   (Help: "SortKey.Compare method")

    Test 1:  questions  38  (page 374;  answer:  page 396).

    Test 2:  none.

(The "short Kalani" text is listed  here.)