Fix nullability warnings

mattjohnsonpint · mattjohnsonpint · commit ca003a4b3320 · 2022-10-31T11:23:33.000-07:00
diff --git a/src/TimeZoneNames.DataBuilder/DataExtractor.cs b/src/TimeZoneNames.DataBuilder/DataExtractor.cs
@@ -39,8 +39,8 @@ public void SaveData(string outputFilePath)
         JsonSerializer.Serialize(compressedStream, _data);
     }
 
-    private TzdbDateTimeZoneSource _tzdbSource;
-    private IDateTimeZoneProvider _tzdbProvider;
+    private TzdbDateTimeZoneSource _tzdbSource = null!;
+    private IDateTimeZoneProvider _tzdbProvider = null!;
 
     private void LoadData()
     {
@@ -154,7 +154,7 @@ private void LoadSelectionZones()
         var precedence = File.ReadAllLines(Path.Combine("data", "zone-precedence.txt"));
 
         var splitPoints = GetAllZoneSplitPoints();
-        IList<string> last = null;
+        IList<string>? last = null;
         var useConsole = TryHideConsoleCursor();
         for (var i = splitPoints.Count - 1; i >= 0; i--)
         {
@@ -227,7 +227,7 @@ private IList<string> GetSelectionZones(Instant fromInstant, string[] precedence
                 Location = _tzdbSource.ZoneLocations!.FirstOrDefault(l => l.ZoneId == x)
             })
             .Where(x => x.Location != null)
-            .GroupBy(x => new { x.Location.CountryCode, Hash = GetIntervalsHash(x.Intervals) })
+            .GroupBy(x => new { x.Location?.CountryCode, Hash = GetIntervalsHash(x.Intervals) })
             .Select(g =>
             {
                 var ids = g.Select(z => z.Id).ToArray();
@@ -345,7 +345,7 @@ private void LoadMetaZonesFromFile(string path)
     private void LoadLanguages()
     {
         var languages = Directory.GetFiles(Path.Combine(_cldrPath, "common", "main"))
-            .Select(Path.GetFileName)
+            .Select(s => Path.GetFileName(s)!)
             .Select(x => x.Substring(0, x.Length - 4));
 
         Parallel.ForEach(languages, LoadLanguage);
@@ -521,9 +521,9 @@ private void LoadDisplayNames()
 
         foreach (var item in languages.AsArray())
         {
-            var locale = item["Locale"]!.GetValue<string>().Replace("-", "_");
+            var locale = item!["Locale"]!.GetValue<string>().Replace("-", "_");
             var list = item["TimeZones"]!.AsObject()
-                .Select(o => new KeyValuePair<string, string>(o.Key, (string) o.Value))
+                .Select(o => new KeyValuePair<string, string>(o.Key, (string) o.Value!))
                 .ToList();
             
             // Base offset change for Jordan, reflected in Windows, not yet in tzinfo.json
diff --git a/src/TimeZoneNames/OrderedDictionary.cs b/src/TimeZoneNames/OrderedDictionary.cs
@@ -1,22 +1,24 @@
 using System.Collections;
 using System.Collections.Specialized;
+using System.Diagnostics.CodeAnalysis;
 
 namespace TimeZoneNames;
 
 internal class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+    where TKey : notnull
 {
     // TODO: Find a better implementation.
     // We might only need an IReadOnlyDictionary<TKey, TValue> but we want to preserve insertion order.
     private readonly OrderedDictionary _dictionary;
 
-    public OrderedDictionary(int capacity = 0, IEqualityComparer<TKey> equalityComparer = default)
+    public OrderedDictionary(int capacity = 0, IEqualityComparer<TKey>? equalityComparer = default)
     {
-        _dictionary = new OrderedDictionary(capacity, (IEqualityComparer) equalityComparer);
+        _dictionary = new OrderedDictionary(capacity, (IEqualityComparer?) equalityComparer);
     }
 
     public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _dictionary
         .Cast<DictionaryEntry>()
-        .Select(x => new KeyValuePair<TKey, TValue>((TKey) x.Key, (TValue) x.Value))
+        .Select(x => new KeyValuePair<TKey, TValue>((TKey) x.Key, (TValue) x.Value!))
         .GetEnumerator();
 
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
@@ -34,9 +36,9 @@ public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
         {
             if (i >= arrayIndex && i < array.Length)
             {
-                array[i] = new KeyValuePair<TKey, TValue>((TKey) entry.Key, (TValue) entry.Value);
+                array[i] = new KeyValuePair<TKey, TValue>((TKey) entry.Key, (TValue) entry.Value!);
             }
-            
+
             i++;
         }
     }
@@ -62,22 +64,24 @@ public bool Remove(TKey key)
         return found;
     }
 
-    public bool TryGetValue(TKey key, out TValue value)
+#pragma warning disable CS8767
+    public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
+#pragma warning restore CS8767
     {
         var obj = _dictionary[key];
         if (obj == null)
         {
             value = default;
             return false;
         }
-        
+
         value = (TValue) obj;
         return true;
     }
 
     public TValue this[TKey key]
     {
-        get => (TValue) _dictionary[key];
+        get => _dictionary[key] is { } value ? (TValue) value : throw new KeyNotFoundException();
         set => _dictionary[key] = value;
     }
 
@@ -90,21 +94,24 @@ internal static class OrderedDictionaryExtensions
 {
     public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TKey, TValue>(
         this ICollection<KeyValuePair<TKey, TValue>> items,
-        IEqualityComparer<TKey> comparer = default)
+        IEqualityComparer<TKey>? comparer = default)
+        where TKey : notnull
     {
         var result = new OrderedDictionary<TKey, TValue>(items.Count, comparer);
         foreach (var item in items)
         {
             result.Add(item);
         }
+
         return result;
     }
 
     public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TSource, TKey, TValue>(
         this ICollection<TSource> items,
         Func<TSource, TKey> keySelector,
         Func<TSource, TValue> valueSelector,
-        IEqualityComparer<TKey> comparer = default)
+        IEqualityComparer<TKey>? comparer = default)
+        where TKey : notnull
     {
         var result = new OrderedDictionary<TKey, TValue>(items.Count, comparer);
         foreach (var item in items)
@@ -113,18 +120,21 @@ public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TSource, TKey,
             var value = valueSelector(item);
             result.Add(key, value);
         }
+
         return result;
     }
-    
+
     public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TKey, TValue>(
         this IEnumerable<KeyValuePair<TKey, TValue>> items,
-        IEqualityComparer<TKey> comparer = default) =>
-        items.ToList().ToOrderedDictionary(comparer);
+        IEqualityComparer<TKey>? comparer = default)
+        where TKey : notnull
+        => items.ToList().ToOrderedDictionary(comparer);
 
     public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TSource, TKey, TValue>(
         this IEnumerable<TSource> items,
         Func<TSource, TKey> keySelector,
         Func<TSource, TValue> valueSelector,
-        IEqualityComparer<TKey> comparer = default) =>
-        items.ToList().ToOrderedDictionary(keySelector, valueSelector, comparer);
+        IEqualityComparer<TKey>? comparer = default)
+        where TKey : notnull
+        => items.ToList().ToOrderedDictionary(keySelector, valueSelector, comparer);
 }
diff --git a/src/TimeZoneNames/TZNames.cs b/src/TimeZoneNames/TZNames.cs
@@ -84,7 +84,8 @@ public static IDictionary<string, string> GetTimeZonesForCountry(string countryC
                     Id = x,
                     Name = GetNames(x, langKey, false).Generic
                 })
-            .ToDictionary(x => x.Id, x => x.Name, StringComparer.OrdinalIgnoreCase);
+            .Where(x => x.Name != null)
+            .ToDictionary(x => x.Id, x => x.Name!, StringComparer.OrdinalIgnoreCase);
 
         // Append city names only when needed to differentiate zones with the same name
         foreach (var group in results.GroupBy(x => x.Value).Where(x => x.Count() > 1).ToArray())
@@ -169,7 +170,7 @@ private static IDictionary<string, string> GetFixedTimeZoneNames(string language
 
         foreach (var zone in zones)
         {
-            var name = GetNames(zone, langKey, abbreviations).Generic;
+            var name = GetNames(zone, langKey, abbreviations).Generic!;
             results.Add(zone, name);
         }
 
@@ -250,7 +251,7 @@ public static IDictionary<string, string> GetCountryNames(string languageCode)
     /// <param name="timeZoneId">An IANA or Windows time zone identifier.</param>
     /// <param name="languageCode">The IETF language tag (culture code) to use when localizing the display names.</param>
     /// <returns>A display name associated with this time zone.</returns>
-    public static string GetDisplayNameForTimeZone(string timeZoneId, string languageCode)
+    public static string? GetDisplayNameForTimeZone(string timeZoneId, string languageCode)
     {
         var langKey = GetLanguageKey(languageCode, true);
         if (langKey == null)
@@ -265,8 +266,8 @@ public static string GetDisplayNameForTimeZone(string timeZoneId, string languag
             return displayName;
         }
 
-        if (TZConvert.TryIanaToWindows(timeZoneId, out timeZoneId) &&
-            displayNames.TryGetValue(timeZoneId, out displayName))
+        if (TZConvert.TryIanaToWindows(timeZoneId, out var windowsTimeZoneId) &&
+            displayNames.TryGetValue(windowsTimeZoneId, out displayName))
         {
             return displayName;
         }
@@ -287,7 +288,7 @@ public static IDictionary<string, string> GetDisplayNames(string languageCode, b
         {
             throw new ArgumentException("Invalid Language Code", nameof(languageCode));
         }
-
+        
         var displayNames = Data.DisplayNames[langKey]
             .Where(x => !TimeZoneData.ObsoleteWindowsZones.Contains(x.Key))
             .ToList();
@@ -374,7 +375,7 @@ private static string GetLanguageKey(string languageCode, bool forDisplayNames =
         }
     }
 
-    private static string GetLanguageSubkey(string languageKey)
+    private static string? GetLanguageSubkey(string languageKey)
     {
         var keyParts = languageKey.Split('_');
         if (keyParts.Length == 1)
@@ -387,10 +388,11 @@ private static string GetLanguageSubkey(string languageKey)
 
     private static void SearchLanguages(string languageKey, TimeZoneValues values, Action<string> action)
     {
-        while (languageKey != null && (values.Generic == null || values.Standard == null || values.Daylight == null))
+        var langKey = languageKey;
+        while (langKey != null && (values.Generic == null || values.Standard == null || values.Daylight == null))
         {
-            action(languageKey);
-            languageKey = GetLanguageSubkey(languageKey);
+            action(langKey);
+            langKey = GetLanguageSubkey(langKey);
         }
     }
 
@@ -401,15 +403,16 @@ private static string GetCldrCanonicalId(string timeZoneId)
 
     private static string GetCityName(string timeZoneId, string languageKey)
     {
-        while (languageKey != null)
+        var langKey = languageKey;
+        while (langKey != null)
         {
-            var data = Data.CldrLanguageData[languageKey];
+            var data = Data.CldrLanguageData[langKey];
             if (data.CityNames.TryGetValue(timeZoneId, out var cityName))
             {
                 return cityName;
             }
 
-            languageKey = GetLanguageSubkey(languageKey);
+            langKey = GetLanguageSubkey(langKey);
         }
 
         return timeZoneId.Split('/').Last().Replace("_", " ");
@@ -526,7 +529,7 @@ private static TimeZoneValues GetNames(string timeZoneId, string languageKey, bo
             }
         }
 
-        string regionName = null;
+        string? regionName = null;
         if (country != null)
         {
             SearchLanguages(languageKey, values, key =>
@@ -620,12 +623,12 @@ private static TimeZoneValues GetNames(string timeZoneId, string languageKey, bo
         return values;
     }
 
-    private static string GetMetazone(string timeZoneId)
+    private static string? GetMetazone(string timeZoneId)
     {
         return Data.CldrMetazones.TryGetValue(timeZoneId, out var metaZone) ? metaZone : null;
     }
 
-    private static bool PopulateDirectValues(string langKey, TimeZoneValues values, string timeZoneId, string metaZone,
+    private static bool PopulateDirectValues(string langKey, TimeZoneValues values, string timeZoneId, string? metaZone,
         bool abbreviations)
     {
         if (!Data.CldrLanguageData.ContainsKey(langKey))
diff --git a/src/TimeZoneNames/TimeZoneData.cs b/src/TimeZoneNames/TimeZoneData.cs
@@ -56,9 +56,9 @@ public static TimeZoneData Load()
 
 internal class CldrLanguageData
 {
-    public TimeZoneValues Formats { get; set; }
+    public TimeZoneValues? Formats { get; set; }
 
-    public string FallbackFormat { get; set; }
+    public string? FallbackFormat { get; set; }
 
     public Dictionary<string, TimeZoneValues> ShortNames { get; set; } = new(StringComparer.OrdinalIgnoreCase);
 
@@ -81,7 +81,7 @@ internal class CldrLanguageData
 
 internal class TimeZoneSelectionData
 {
-    public string Id { get; set; }
+    public string Id { get; set; } = null!;
 
     public DateTime ThresholdUtc { get; set; }
 }
diff --git a/src/TimeZoneNames/TimeZoneValues.cs b/src/TimeZoneNames/TimeZoneValues.cs
@@ -11,17 +11,17 @@ public class TimeZoneValues
     /// The time zone name that generically applies.
     /// </summary>
     [JsonInclude]
-    public string Generic { get; internal set; }
+    public string? Generic { get; internal set; }
 
     /// <summary>
     /// The time zone name that applies during standard time.
     /// </summary>
     [JsonInclude]
-    public string Standard { get; internal set; }
+    public string? Standard { get; internal set; }
 
     /// <summary>
     /// The time zone name that applies during daylight saving time.
     /// </summary>
     [JsonInclude]
-    public string Daylight { get; internal set; }
+    public string? Daylight { get; internal set; }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,24 @@`
`1`	`1`	`using System.Collections;`
`2`	`2`	`using System.Collections.Specialized;`
	`3`	`+using System.Diagnostics.CodeAnalysis;`
`3`	`4`
`4`	`5`	`namespace TimeZoneNames;`
`5`	`6`
`6`	`7`	`internal class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>`
	`8`	`+ where TKey : notnull`
`7`	`9`	`{`
`8`	`10`	`// TODO: Find a better implementation.`
`9`	`11`	`// We might only need an IReadOnlyDictionary<TKey, TValue> but we want to preserve insertion order.`
`10`	`12`	`private readonly OrderedDictionary _dictionary;`
`11`	`13`
`12`		`- public OrderedDictionary(int capacity = 0, IEqualityComparer<TKey> equalityComparer = default)`
	`14`	`+ public OrderedDictionary(int capacity = 0, IEqualityComparer<TKey>? equalityComparer = default)`
`13`	`15`	`{`
`14`		`- _dictionary = new OrderedDictionary(capacity, (IEqualityComparer) equalityComparer);`
	`16`	`+ _dictionary = new OrderedDictionary(capacity, (IEqualityComparer?) equalityComparer);`
`15`	`17`	`}`
`16`	`18`
`17`	`19`	`public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _dictionary`
`18`	`20`	`.Cast<DictionaryEntry>()`
`19`		`- .Select(x => new KeyValuePair<TKey, TValue>((TKey) x.Key, (TValue) x.Value))`
	`21`	`+ .Select(x => new KeyValuePair<TKey, TValue>((TKey) x.Key, (TValue) x.Value!))`
`20`	`22`	`.GetEnumerator();`
`21`	`23`
`22`	`24`	`IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();`
`@@ -34,9 +36,9 @@ public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)`
`34`	`36`	`{`
`35`	`37`	`if (i >= arrayIndex && i < array.Length)`
`36`	`38`	`{`
`37`		`- array[i] = new KeyValuePair<TKey, TValue>((TKey) entry.Key, (TValue) entry.Value);`
	`39`	`+ array[i] = new KeyValuePair<TKey, TValue>((TKey) entry.Key, (TValue) entry.Value!);`
`38`	`40`	`}`
`39`		`-`
	`41`	`+`
`40`	`42`	`i++;`
`41`	`43`	`}`
`42`	`44`	`}`
`@@ -62,22 +64,24 @@ public bool Remove(TKey key)`
`62`	`64`	`return found;`
`63`	`65`	`}`
`64`	`66`
`65`		`- public bool TryGetValue(TKey key, out TValue value)`
	`67`	`+#pragma warning disable CS8767`
	`68`	`+ public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)`
	`69`	`+#pragma warning restore CS8767`
`66`	`70`	`{`
`67`	`71`	`var obj = _dictionary[key];`
`68`	`72`	`if (obj == null)`
`69`	`73`	`{`
`70`	`74`	`value = default;`
`71`	`75`	`return false;`
`72`	`76`	`}`
`73`		`-`
	`77`	`+`
`74`	`78`	`value = (TValue) obj;`
`75`	`79`	`return true;`
`76`	`80`	`}`
`77`	`81`
`78`	`82`	`public TValue this[TKey key]`
`79`	`83`	`{`
`80`		`- get => (TValue) _dictionary[key];`
	`84`	`+ get => _dictionary[key] is { } value ? (TValue) value : throw new KeyNotFoundException();`
`81`	`85`	`set => _dictionary[key] = value;`
`82`	`86`	`}`
`83`	`87`
`@@ -90,21 +94,24 @@ internal static class OrderedDictionaryExtensions`
`90`	`94`	`{`
`91`	`95`	`public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TKey, TValue>(`
`92`	`96`	`this ICollection<KeyValuePair<TKey, TValue>> items,`
`93`		`- IEqualityComparer<TKey> comparer = default)`
	`97`	`+ IEqualityComparer<TKey>? comparer = default)`
	`98`	`+ where TKey : notnull`
`94`	`99`	`{`
`95`	`100`	`var result = new OrderedDictionary<TKey, TValue>(items.Count, comparer);`
`96`	`101`	`foreach (var item in items)`
`97`	`102`	`{`
`98`	`103`	`result.Add(item);`
`99`	`104`	`}`
	`105`	`+`
`100`	`106`	`return result;`
`101`	`107`	`}`
`102`	`108`
`103`	`109`	`public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TSource, TKey, TValue>(`
`104`	`110`	`this ICollection<TSource> items,`
`105`	`111`	`Func<TSource, TKey> keySelector,`
`106`	`112`	`Func<TSource, TValue> valueSelector,`
`107`		`- IEqualityComparer<TKey> comparer = default)`
	`113`	`+ IEqualityComparer<TKey>? comparer = default)`
	`114`	`+ where TKey : notnull`
`108`	`115`	`{`
`109`	`116`	`var result = new OrderedDictionary<TKey, TValue>(items.Count, comparer);`
`110`	`117`	`foreach (var item in items)`
`@@ -113,18 +120,21 @@ public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TSource, TKey,`
`113`	`120`	`var value = valueSelector(item);`
`114`	`121`	`result.Add(key, value);`
`115`	`122`	`}`
	`123`	`+`
`116`	`124`	`return result;`
`117`	`125`	`}`
`118`		`-`
	`126`	`+`
`119`	`127`	`public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TKey, TValue>(`
`120`	`128`	`this IEnumerable<KeyValuePair<TKey, TValue>> items,`
`121`		`- IEqualityComparer<TKey> comparer = default) =>`
`122`		`- items.ToList().ToOrderedDictionary(comparer);`
	`129`	`+ IEqualityComparer<TKey>? comparer = default)`
	`130`	`+ where TKey : notnull`
	`131`	`+ => items.ToList().ToOrderedDictionary(comparer);`
`123`	`132`
`124`	`133`	`public static OrderedDictionary<TKey, TValue> ToOrderedDictionary<TSource, TKey, TValue>(`
`125`	`134`	`this IEnumerable<TSource> items,`
`126`	`135`	`Func<TSource, TKey> keySelector,`
`127`	`136`	`Func<TSource, TValue> valueSelector,`
`128`		`- IEqualityComparer<TKey> comparer = default) =>`
`129`		`- items.ToList().ToOrderedDictionary(keySelector, valueSelector, comparer);`
	`137`	`+ IEqualityComparer<TKey>? comparer = default)`
	`138`	`+ where TKey : notnull`
	`139`	`+ => items.ToList().ToOrderedDictionary(keySelector, valueSelector, comparer);`
`130`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,8 @@ public static IDictionary<string, string> GetTimeZonesForCountry(string countryC`
`84`	`84`	`Id = x,`
`85`	`85`	`Name = GetNames(x, langKey, false).Generic`
`86`	`86`	`})`
`87`		`- .ToDictionary(x => x.Id, x => x.Name, StringComparer.OrdinalIgnoreCase);`
	`87`	`+ .Where(x => x.Name != null)`
	`88`	`+ .ToDictionary(x => x.Id, x => x.Name!, StringComparer.OrdinalIgnoreCase);`
`88`	`89`
`89`	`90`	`// Append city names only when needed to differentiate zones with the same name`
`90`	`91`	`foreach (var group in results.GroupBy(x => x.Value).Where(x => x.Count() > 1).ToArray())`
`@@ -169,7 +170,7 @@ private static IDictionary<string, string> GetFixedTimeZoneNames(string language`
`169`	`170`
`170`	`171`	`foreach (var zone in zones)`
`171`	`172`	`{`
`172`		`- var name = GetNames(zone, langKey, abbreviations).Generic;`
	`173`	`+ var name = GetNames(zone, langKey, abbreviations).Generic!;`
`173`	`174`	`results.Add(zone, name);`
`174`	`175`	`}`
`175`	`176`
`@@ -250,7 +251,7 @@ public static IDictionary<string, string> GetCountryNames(string languageCode)`
`250`	`251`	`/// <param name="timeZoneId">An IANA or Windows time zone identifier.</param>`
`251`	`252`	`/// <param name="languageCode">The IETF language tag (culture code) to use when localizing the display names.</param>`
`252`	`253`	`/// <returns>A display name associated with this time zone.</returns>`
`253`		`- public static string GetDisplayNameForTimeZone(string timeZoneId, string languageCode)`
	`254`	`+ public static string? GetDisplayNameForTimeZone(string timeZoneId, string languageCode)`
`254`	`255`	`{`
`255`	`256`	`var langKey = GetLanguageKey(languageCode, true);`
`256`	`257`	`if (langKey == null)`
`@@ -265,8 +266,8 @@ public static string GetDisplayNameForTimeZone(string timeZoneId, string languag`
`265`	`266`	`return displayName;`
`266`	`267`	`}`
`267`	`268`
`268`		`- if (TZConvert.TryIanaToWindows(timeZoneId, out timeZoneId) &&`
`269`		`- displayNames.TryGetValue(timeZoneId, out displayName))`
	`269`	`+ if (TZConvert.TryIanaToWindows(timeZoneId, out var windowsTimeZoneId) &&`
	`270`	`+ displayNames.TryGetValue(windowsTimeZoneId, out displayName))`
`270`	`271`	`{`
`271`	`272`	`return displayName;`
`272`	`273`	`}`
`@@ -287,7 +288,7 @@ public static IDictionary<string, string> GetDisplayNames(string languageCode, b`
`287`	`288`	`{`
`288`	`289`	`throw new ArgumentException("Invalid Language Code", nameof(languageCode));`
`289`	`290`	`}`
`290`		`-`
	`291`	`+`
`291`	`292`	`var displayNames = Data.DisplayNames[langKey]`
`292`	`293`	`.Where(x => !TimeZoneData.ObsoleteWindowsZones.Contains(x.Key))`
`293`	`294`	`.ToList();`
`@@ -374,7 +375,7 @@ private static string GetLanguageKey(string languageCode, bool forDisplayNames =`
`374`	`375`	`}`
`375`	`376`	`}`
`376`	`377`
`377`		`- private static string GetLanguageSubkey(string languageKey)`
	`378`	`+ private static string? GetLanguageSubkey(string languageKey)`
`378`	`379`	`{`
`379`	`380`	`var keyParts = languageKey.Split('_');`
`380`	`381`	`if (keyParts.Length == 1)`
`@@ -387,10 +388,11 @@ private static string GetLanguageSubkey(string languageKey)`
`387`	`388`
`388`	`389`	`private static void SearchLanguages(string languageKey, TimeZoneValues values, Action<string> action)`
`389`	`390`	`{`
`390`		`- while (languageKey != null && (values.Generic == null \|\| values.Standard == null \|\| values.Daylight == null))`
	`391`	`+ var langKey = languageKey;`
	`392`	`+ while (langKey != null && (values.Generic == null \|\| values.Standard == null \|\| values.Daylight == null))`
`391`	`393`	`{`
`392`		`- action(languageKey);`
`393`		`- languageKey = GetLanguageSubkey(languageKey);`
	`394`	`+ action(langKey);`
	`395`	`+ langKey = GetLanguageSubkey(langKey);`
`394`	`396`	`}`
`395`	`397`	`}`
`396`	`398`
`@@ -401,15 +403,16 @@ private static string GetCldrCanonicalId(string timeZoneId)`
`401`	`403`
`402`	`404`	`private static string GetCityName(string timeZoneId, string languageKey)`
`403`	`405`	`{`
`404`		`- while (languageKey != null)`
	`406`	`+ var langKey = languageKey;`
	`407`	`+ while (langKey != null)`
`405`	`408`	`{`
`406`		`- var data = Data.CldrLanguageData[languageKey];`
	`409`	`+ var data = Data.CldrLanguageData[langKey];`
`407`	`410`	`if (data.CityNames.TryGetValue(timeZoneId, out var cityName))`
`408`	`411`	`{`
`409`	`412`	`return cityName;`
`410`	`413`	`}`
`411`	`414`
`412`		`- languageKey = GetLanguageSubkey(languageKey);`
	`415`	`+ langKey = GetLanguageSubkey(langKey);`
`413`	`416`	`}`
`414`	`417`
`415`	`418`	`return timeZoneId.Split('/').Last().Replace("_", " ");`
`@@ -526,7 +529,7 @@ private static TimeZoneValues GetNames(string timeZoneId, string languageKey, bo`
`526`	`529`	`}`
`527`	`530`	`}`
`528`	`531`
`529`		`- string regionName = null;`
	`532`	`+ string? regionName = null;`
`530`	`533`	`if (country != null)`
`531`	`534`	`{`
`532`	`535`	`SearchLanguages(languageKey, values, key =>`
`@@ -620,12 +623,12 @@ private static TimeZoneValues GetNames(string timeZoneId, string languageKey, bo`
`620`	`623`	`return values;`
`621`	`624`	`}`
`622`	`625`
`623`		`- private static string GetMetazone(string timeZoneId)`
	`626`	`+ private static string? GetMetazone(string timeZoneId)`
`624`	`627`	`{`
`625`	`628`	`return Data.CldrMetazones.TryGetValue(timeZoneId, out var metaZone) ? metaZone : null;`
`626`	`629`	`}`
`627`	`630`
`628`		`- private static bool PopulateDirectValues(string langKey, TimeZoneValues values, string timeZoneId, string metaZone,`
	`631`	`+ private static bool PopulateDirectValues(string langKey, TimeZoneValues values, string timeZoneId, string? metaZone,`
`629`	`632`	`bool abbreviations)`
`630`	`633`	`{`
`631`	`634`	`if (!Data.CldrLanguageData.ContainsKey(langKey))`
Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,9 @@ public static TimeZoneData Load()`
`56`	`56`
`57`	`57`	`internal class CldrLanguageData`
`58`	`58`	`{`
`59`		`- public TimeZoneValues Formats { get; set; }`
	`59`	`+ public TimeZoneValues? Formats { get; set; }`
`60`	`60`
`61`		`- public string FallbackFormat { get; set; }`
	`61`	`+ public string? FallbackFormat { get; set; }`
`62`	`62`
`63`	`63`	`public Dictionary<string, TimeZoneValues> ShortNames { get; set; } = new(StringComparer.OrdinalIgnoreCase);`
`64`	`64`
`@@ -81,7 +81,7 @@ internal class CldrLanguageData`
`81`	`81`
`82`	`82`	`internal class TimeZoneSelectionData`
`83`	`83`	`{`
`84`		`- public string Id { get; set; }`
	`84`	`+ public string Id { get; set; } = null!;`
`85`	`85`
`86`	`86`	`public DateTime ThresholdUtc { get; set; }`
`87`	`87`	`}`