diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae6e17f..29d17fb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+
+- [L10NSharp] Enabled nullable reference types on the core project, with full CS86xx warning cleanup across all layers. `ILocalizationManager.GetLocalizedString` now declares its `defaultText` parameter nullable; the internal `ILocalizedStringCache`/`ILocalizationManagerInternal` interfaces gained nullable annotations and a `where T : class` constraint.
+
 ## [11.0.0] - 2026-09-08
 
 ### Added
diff --git a/Directory.Build.props b/Directory.Build.props
index 0602157..4f46428 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -25,7 +25,7 @@ See full changelog at https://github.com/sillsdev/l10nsharp/blob/master/CHANGELO
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <GenerateResourceUsePreserializedResources>true</GenerateResourceUsePreserializedResources>
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>9.0</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <!-- Without this line some projects fail to build on TC with "error : SourceRoot items
diff --git a/src/L10NSharp.Tests/LocalizationManagerTestsBase.cs b/src/L10NSharp.Tests/LocalizationManagerTestsBase.cs
index 14ae8b2..5c6ffa7 100644
--- a/src/L10NSharp.Tests/LocalizationManagerTestsBase.cs
+++ b/src/L10NSharp.Tests/LocalizationManagerTestsBase.cs
@@ -11,7 +11,7 @@
 
 namespace L10NSharp.Tests
 {
-	public abstract class LocalizationManagerTestsBase<T> where T : IDocument
+	public abstract class LocalizationManagerTestsBase<T> where T : class, IDocument
 	{
 		protected const string AppId = "test";
 		protected const string AppName = "unit test";
diff --git a/src/L10NSharp.Tests/XLiffLocalizationManagerTests.cs b/src/L10NSharp.Tests/XLiffLocalizationManagerTests.cs
index f439045..038f275 100644
--- a/src/L10NSharp.Tests/XLiffLocalizationManagerTests.cs
+++ b/src/L10NSharp.Tests/XLiffLocalizationManagerTests.cs
@@ -280,6 +280,21 @@ public void AddTransUnit_NullSourceNullTarget_DoesNotThrow()
 			Assert.DoesNotThrow(() => body.AddTransUnit(tu));
 		}
 
+		[Test]
+		public void AddTransUnit_NoId_GeneratesIdAndIndexesTranslation()
+		{
+			var body = new XLiffBody();
+			var tu = new XLiffTransUnit {
+				Source = new XLiffTransUnitVariant { Lang = "en", Value = "Text." }
+			};
+
+			Assert.That(body.AddTransUnit(tu), Is.True);
+
+			// AddTransUnit relies on the Id generated for an Id-less unit.
+			Assert.That(tu.Id, Is.Not.Null.And.Not.Empty);
+			Assert.That(body.TranslationsById[tu.Id], Is.EqualTo("Text."));
+		}
+
 		[Test]
 		public void MergeXliffDocuments_BaselineUnitHasNullSource_DoesNotThrow()
 		{
diff --git a/src/L10NSharp.Windows.Forms/ILocalizationManagerInternalWinforms.cs b/src/L10NSharp.Windows.Forms/ILocalizationManagerInternalWinforms.cs
index dbb0320..751ce3d 100644
--- a/src/L10NSharp.Windows.Forms/ILocalizationManagerInternalWinforms.cs
+++ b/src/L10NSharp.Windows.Forms/ILocalizationManagerInternalWinforms.cs
@@ -20,7 +20,7 @@ void RegisterComponentForLocalizing(LocalizingInfoWinforms info,
 			Action<ILocalizationManagerInternalWinforms, LocalizingInfoWinforms> successAction);
 	}
 
-	internal interface ILocalizationManagerInternalWinforms<T> : ILocalizationManagerInternalWinforms, ILocalizationManagerInternal<T>
+	internal interface ILocalizationManagerInternalWinforms<T> : ILocalizationManagerInternalWinforms, ILocalizationManagerInternal<T> where T : class
 	{
 		new ILocalizedStringCacheWinforms<T> StringCache { get; }
 	}
diff --git a/src/L10NSharp.Windows.Forms/ILocalizedStringCacheWinforms.cs b/src/L10NSharp.Windows.Forms/ILocalizedStringCacheWinforms.cs
index 9c90ce2..11f9dff 100644
--- a/src/L10NSharp.Windows.Forms/ILocalizedStringCacheWinforms.cs
+++ b/src/L10NSharp.Windows.Forms/ILocalizedStringCacheWinforms.cs
@@ -4,7 +4,7 @@
 
 namespace L10NSharp.Windows.Forms
 {
-	internal interface ILocalizedStringCacheWinforms<T> : L10NSharp.ILocalizedStringCache<T>
+	internal interface ILocalizedStringCacheWinforms<T> : L10NSharp.ILocalizedStringCache<T> where T : class
 	{
 		List<LocTreeNode<T>> LeafNodeList { get; }
 		Keys GetShortcutKeys(string langId, string id);
diff --git a/src/L10NSharp.Windows.Forms/LocalizationManagerInternalWinforms.cs b/src/L10NSharp.Windows.Forms/LocalizationManagerInternalWinforms.cs
index 9a1abd5..303016d 100644
--- a/src/L10NSharp.Windows.Forms/LocalizationManagerInternalWinforms.cs
+++ b/src/L10NSharp.Windows.Forms/LocalizationManagerInternalWinforms.cs
@@ -13,7 +13,7 @@
 
 namespace L10NSharp.Windows.Forms
 {
-	internal class LocalizationManagerInternalWinforms<T> : LocalizationManagerInternal<T>
+	internal class LocalizationManagerInternalWinforms<T> : LocalizationManagerInternal<T> where T : class
 	{
 
 		/// <summary>
diff --git a/src/L10NSharp.Windows.Forms/UIComponents/FallbackLanguagesDlg.cs b/src/L10NSharp.Windows.Forms/UIComponents/FallbackLanguagesDlg.cs
index 3cb4562..55adabb 100644
--- a/src/L10NSharp.Windows.Forms/UIComponents/FallbackLanguagesDlg.cs
+++ b/src/L10NSharp.Windows.Forms/UIComponents/FallbackLanguagesDlg.cs
@@ -3,7 +3,7 @@
 
 namespace L10NSharp.Windows.Forms.UIComponents
 {
-	public class FallbackLanguagesDlg<T> : FallbackLanguagesDlgBase
+	public class FallbackLanguagesDlg<T> : FallbackLanguagesDlgBase where T : class
 	{
 		public FallbackLanguagesDlg()
 		{
diff --git a/src/L10NSharp.Windows.Forms/UIComponents/LocTreeNode.cs b/src/L10NSharp.Windows.Forms/UIComponents/LocTreeNode.cs
index 1795de3..4c78fea 100644
--- a/src/L10NSharp.Windows.Forms/UIComponents/LocTreeNode.cs
+++ b/src/L10NSharp.Windows.Forms/UIComponents/LocTreeNode.cs
@@ -5,7 +5,7 @@
 namespace L10NSharp.Windows.Forms.UIComponents
 {
 	/// ----------------------------------------------------------------------------------------
-	internal class LocTreeNode<T> : TreeNode
+	internal class LocTreeNode<T> : TreeNode where T : class
 	{
 		internal string Group { get; set; }
 		internal string Id { get; private set; }
diff --git a/src/L10NSharp.Windows.Forms/UIComponents/NodeComparer.cs b/src/L10NSharp.Windows.Forms/UIComponents/NodeComparer.cs
index 74df141..1c9956f 100644
--- a/src/L10NSharp.Windows.Forms/UIComponents/NodeComparer.cs
+++ b/src/L10NSharp.Windows.Forms/UIComponents/NodeComparer.cs
@@ -5,7 +5,7 @@
 namespace L10NSharp.Windows.Forms.UIComponents
 {
 	/// ----------------------------------------------------------------------------------------
-	internal class NodeComparer<T> : IComparer<LocTreeNode<T>>
+	internal class NodeComparer<T> : IComparer<LocTreeNode<T>> where T : class
 	{
 		internal enum SortField
 		{
diff --git a/src/L10NSharp/CodeReader/ILReader.cs b/src/L10NSharp/CodeReader/ILReader.cs
index 6b6e1e1..8934a41 100644
--- a/src/L10NSharp/CodeReader/ILReader.cs
+++ b/src/L10NSharp/CodeReader/ILReader.cs
@@ -10,10 +10,10 @@ namespace L10NSharp.CodeReader
 	internal class ILInstruction
 	{
 		public readonly OpCode opCode;
-		public readonly object operand;
+		public readonly object? operand;
 
 		/// ------------------------------------------------------------------------------------
-		public ILInstruction(OpCode opCode, object operand)
+		public ILInstruction(OpCode opCode, object? operand)
 		{
 			this.opCode = opCode;
 			this.operand = operand;
@@ -94,7 +94,7 @@ ILInstruction Next()
 				opCode = s_TwoByteOpCodes[code];
 			}
 
-			object operand = null;
+			object? operand = null;
 
 			switch (opCode.OperandType)
 			{
diff --git a/src/L10NSharp/CodeReader/StringExtractor.cs b/src/L10NSharp/CodeReader/StringExtractor.cs
index 8c0ab72..b22cfea 100644
--- a/src/L10NSharp/CodeReader/StringExtractor.cs
+++ b/src/L10NSharp/CodeReader/StringExtractor.cs
@@ -15,10 +15,10 @@ namespace L10NSharp.CodeReader
 	/// ------------------------------------------------------------------------------------
 	public class StringExtractor<T>
 	{
-		private MethodInfo[] _getStringMethodOverloads;
-		private List<LocalizingInfo> _getStringCallsInfo;
-		private Dictionary<string, LocalizingInfo> _extenderInfo;
-		private List<ILInstruction> _instructions;
+		private MethodInfo[] _getStringMethodOverloads = Array.Empty<MethodInfo>();
+		private List<LocalizingInfo> _getStringCallsInfo = new List<LocalizingInfo>();
+		private Dictionary<string, LocalizingInfo> _extenderInfo = new Dictionary<string, LocalizingInfo>();
+		private List<ILInstruction> _instructions = new List<ILInstruction>();
 		private readonly HashSet<string> _scannedTypes = new HashSet<string>();
 
 		public List<string> ExtractionExceptions = new List<string>();
@@ -34,8 +34,8 @@ public IReadOnlyList<LocalizingInfo> DoExtractingWork(
 
 		/// ------------------------------------------------------------------------------------
 		public IReadOnlyList<LocalizingInfo> DoExtractingWork(
-			IEnumerable<MethodInfo> additionalLocalizationMethods,
-			string[] namespaceBeginnings, BackgroundWorker worker)
+			IEnumerable<MethodInfo>? additionalLocalizationMethods,
+			string[] namespaceBeginnings, BackgroundWorker? worker)
 		{
 			_getStringMethodOverloads = typeof(LocalizationManager)
 				.GetMethods(BindingFlags.Static | BindingFlags.Public)
@@ -43,7 +43,7 @@ public IReadOnlyList<LocalizingInfo> DoExtractingWork(
 				.Union(typeof(L10NStringExtensions)
 				.GetMethods(BindingFlags.Static | BindingFlags.Public)
 				.Where(m => m.Name == "Localize"))
-				.Union(additionalLocalizationMethods ?? new MethodInfo[0])
+				.Union(additionalLocalizationMethods ?? Array.Empty<MethodInfo>())
 				.ToArray();
 
 			_getStringCallsInfo = new List<LocalizingInfo>();
@@ -193,7 +193,7 @@ private IEnumerable<Type> GetTypesToScan(ICollection<string> namespaceBeginnings
 
 				foreach (var type in typesInAssembly
 					.Where(t => t != null && !typesToScan.Contains(t))
-					.Where(type => namespaceBeginnings.Count == 0 || namespaceBeginnings.Any(nsb => type.FullName.StartsWith(nsb))))
+					.Where(type => namespaceBeginnings.Count == 0 || namespaceBeginnings.Any(nsb => type.FullName?.StartsWith(nsb) ?? false)))
 				{
 					typesToScan.Add(type);
 				}
@@ -208,13 +208,13 @@ private class LocInfoDistinctComparer : IEqualityComparer<LocalizingInfo>
 			/// ------------------------------------------------------------------------------------
 			public bool Equals(LocalizingInfo x, LocalizingInfo y)
 			{
-				return x.Id.Equals(y.Id, StringComparison.Ordinal);
+				return string.Equals(x.Id, y.Id, StringComparison.Ordinal);
 			}
 
 			/// ------------------------------------------------------------------------------------
 			public int GetHashCode(LocalizingInfo obj)
 			{
-				return obj.Id.GetHashCode();
+				return obj.Id?.GetHashCode() ?? 0;
 			}
 		}
 
@@ -224,7 +224,7 @@ public int GetHashCode(LocalizingInfo obj)
 		/// If this is set, no other loaded assemblies are scanned.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public Assembly[] ExternalAssembliesToScan;
+		public Assembly[]? ExternalAssembliesToScan;
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -300,7 +300,6 @@ private void FindLocalizedStringsInType(Type type)
 #endif
 				try
 				{
-					_instructions = new List<ILInstruction>(new ILReader<T>(method));
 
 					var methodCallsInMethod = GetMethodCalls(method);
 					foreach (var getStringOverload in _getStringMethodOverloads)
@@ -328,6 +327,7 @@ e is FileLoadException || // Installed version is different from the one referen
 		/// ------------------------------------------------------------------------------------
 		private List<Tuple<int, MethodBase>> GetMethodCalls(MethodBase caller)
 		{
+			_instructions = new List<ILInstruction>(new ILReader<T>(caller));
 			var methodCalls = new List<Tuple<int, MethodBase>>();
 			var module = caller.Module;
 
@@ -336,8 +336,8 @@ private List<Tuple<int, MethodBase>> GetMethodCalls(MethodBase caller)
 				if (_instructions[i].opCode != OpCodes.Call)
 					continue;
 
-				Type[] genericMethodArguments = null;
-				var genericTypeArguments = caller.DeclaringType.GetGenericArguments();
+				Type[]? genericMethodArguments = null;
+				var genericTypeArguments = caller.DeclaringType!.GetGenericArguments();
 
 				if (!caller.IsConstructor && !caller.Name.Equals(".cctor"))
 					genericMethodArguments = caller.GetGenericArguments();
@@ -345,7 +345,7 @@ private List<Tuple<int, MethodBase>> GetMethodCalls(MethodBase caller)
 				try
 				{
 					methodCalls.Add(new Tuple<int, MethodBase>(i,
-						module.ResolveMethod((int)_instructions[i].operand,
+						module.ResolveMethod((int)_instructions[i].operand!,
 						genericTypeArguments, genericMethodArguments)));
 				}
 				catch (FileNotFoundException e1)
@@ -388,7 +388,7 @@ private void FindGetStringCalls(MethodBase caller,
 		/// This is special because, as an extension method the 1st parameter in "hello".Localize("myapp.greeting") will be the string ("hello") itself,
 		/// which is backwards from the convention used in the GetString(id, theString, etc.)
 		/// </summary>
-		private LocalizingInfo GetInfoForCallToLocalizeExtension(Module module, int instrIndex, int paramsInMethodCall)
+		private LocalizingInfo? GetInfoForCallToLocalizeExtension(Module module, int instrIndex, int paramsInMethodCall)
 		{
 			var parameters = GetParameters(module, instrIndex, paramsInMethodCall);
 
@@ -399,7 +399,7 @@ private LocalizingInfo GetInfoForCallToLocalizeExtension(Module module, int inst
 
 			var id = String.IsNullOrEmpty(parameters[1]) ? parameters[0] : parameters[1];
 
-			var locInfo = new LocalizingInfo(id) { Text = parameters[0] };
+			var locInfo = new LocalizingInfo(id!) { Text = parameters[0] };
 
 			//end part that differs from GetInfoForCallToLocalizationMethod
 
@@ -417,14 +417,14 @@ private LocalizingInfo GetInfoForCallToLocalizeExtension(Module module, int inst
 			return locInfo;
 		}
 
-		private string[] GetParameters(Module module, int instrIndex, int paramsInMethodCall)
+		private string?[] GetParameters(Module module, int instrIndex, int paramsInMethodCall)
 		{
 			int parameterIndex = paramsInMethodCall - 1;
-			var parameters = new string[paramsInMethodCall];
+			var parameters = new string?[paramsInMethodCall];
 			for (int i = 1; ; i++)
 			{
 				if (_instructions[instrIndex - i].opCode == OpCodes.Ldstr)
-					parameters[parameterIndex--] = module.ResolveString((int) _instructions[instrIndex - i].operand);
+					parameters[parameterIndex--] = module.ResolveString((int)_instructions[instrIndex - i].operand!);
 				else if (_instructions[instrIndex - i].opCode != OpCodes.Call)
 				{
 					parameterIndex--;
@@ -439,7 +439,7 @@ private string[] GetParameters(Module module, int instrIndex, int paramsInMethod
 		}
 
 		/// ------------------------------------------------------------------------------------
-		private LocalizingInfo GetInfoForCallToGetStringMethod(Module module,
+		private LocalizingInfo? GetInfoForCallToGetStringMethod(Module module,
 			int instrIndex, int paramsInMethodCall)
 		{
 			var parameters = GetParameters(module, instrIndex, paramsInMethodCall);
@@ -447,7 +447,7 @@ private LocalizingInfo GetInfoForCallToGetStringMethod(Module module,
 			if (parameters[0] == null || parameters[1] == null)
 				return null;
 
-			var locInfo = new LocalizingInfo(parameters[0]) { Text = parameters[1] };
+			var locInfo = new LocalizingInfo(parameters[0]!) { Text = parameters[1]! };
 
 			if (paramsInMethodCall >= 3 && parameters[2] != null)
 				locInfo.Comment = parameters[2];
@@ -470,11 +470,11 @@ private void FindExtenderCalls(MethodBase caller)
 
 			for (int i = 1; i < _instructions.Count; i++)
 			{
-				string text = null;
+				string? text;
 
 				if (_instructions[i].opCode == OpCodes.Ldstr)
 				{
-					text = module.ResolveString((int)_instructions[i].operand);
+					text = module.ResolveString((int)_instructions[i].operand!);
 					if (text.StartsWith(LocalizationManager.kL10NPrefix))
 					{
 						var locInfo = GetLocInfoForField(caller.ReflectedType.Name, text);
@@ -494,18 +494,18 @@ private void FindExtenderCalls(MethodBase caller)
 				if (_instructions[i - 1].opCode == OpCodes.Ldnull)
 					continue;
 
-				Type[] genericMethodArguments = null;
-				var genericTypeArguments = caller.DeclaringType.GetGenericArguments();
+				Type[]? genericMethodArguments = null;
+				var genericTypeArguments = caller.DeclaringType!.GetGenericArguments();
 
 				if (!caller.IsConstructor && !caller.Name.Equals(".cctor"))
 					genericMethodArguments = caller.GetGenericArguments();
 
-				string fldName = null;
+				string? fldName;
 
-				MethodBase mi = null;
+				MethodBase? mi;
 				try
 				{
-					mi = module.ResolveMethod((int)_instructions[i].operand,
+					mi = module.ResolveMethod((int)_instructions[i].operand!,
 						genericTypeArguments, genericMethodArguments);
 
 				}
@@ -516,6 +516,9 @@ private void FindExtenderCalls(MethodBase caller)
 					continue;
 				}
 
+				if (mi == null)
+					continue;
+
 				if (mi.Name.Equals("SetLocalizationPriority", StringComparison.Ordinal))
 				{
 					var priority = (LocalizationPriority)(_instructions[i - 1].opCode.Value - 22);
@@ -525,7 +528,7 @@ private void FindExtenderCalls(MethodBase caller)
 				}
 
 				text = (i > 1 && _instructions[i - 1].opCode == OpCodes.Ldstr ?
-					module.ResolveString((int)_instructions[i - 1].operand) : null);
+					module.ResolveString((int)_instructions[i - 1].operand!) : null);
 
 				if (text == null)
 					continue;
@@ -557,7 +560,7 @@ private void FindExtenderCalls(MethodBase caller)
 		private string GetFieldName(Module module, ILInstruction instruction)
 		{
 			if (instruction.opCode == OpCodes.Ldfld)
-				return module.ResolveField((int)instruction.operand).Name;
+				return module.ResolveField((int)instruction.operand!).Name;
 
 			return (instruction.opCode == OpCodes.Ldarg_0 ? "Form" : "throwaway");
 		}
diff --git a/src/L10NSharp/ILocalizationManager.cs b/src/L10NSharp/ILocalizationManager.cs
index 0591f0f..16f524e 100644
--- a/src/L10NSharp/ILocalizationManager.cs
+++ b/src/L10NSharp/ILocalizationManager.cs
@@ -92,6 +92,6 @@ string GetLocalizedString(IComponent component, string id, string defaultText,
 		/// Gets the localized text for the specified id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		string GetLocalizedString(string id, string defaultText);
+		string GetLocalizedString(string id, string? defaultText);
 	}
 }
diff --git a/src/L10NSharp/ILocalizationManagerInternal.cs b/src/L10NSharp/ILocalizationManagerInternal.cs
index fae77a5..e0c5aeb 100644
--- a/src/L10NSharp/ILocalizationManagerInternal.cs
+++ b/src/L10NSharp/ILocalizationManagerInternal.cs
@@ -8,14 +8,14 @@ internal interface ILocalizationManagerInternal: ILocalizationManager
 	{
 		Dictionary<IComponent, string> ComponentCache { get; }
 
-		string GetStringFromStringCache(string uiLangId, string id);
+		string? GetStringFromStringCache(string uiLangId, string id);
 
-		void SaveIfDirty(ICollection<string> langIdsToForceCreate);
-		string GetPathForLanguage(string langId, bool getCustomPathEvenIfNonexistent);
+		void SaveIfDirty(ICollection<string>? langIdsToForceCreate);
+		string? GetPathForLanguage(string langId, bool getCustomPathEvenIfNonexistent);
 		void HandleUiLanguageChange();
 	}
 
-	internal interface ILocalizationManagerInternal<T>: ILocalizationManagerInternal
+	internal interface ILocalizationManagerInternal<T> : ILocalizationManagerInternal where T : class
 	{
 		ILocalizedStringCache<T> StringCache { get; }
 		/// <summary>
diff --git a/src/L10NSharp/ILocalizedStringCache.cs b/src/L10NSharp/ILocalizedStringCache.cs
index 8c82b4a..c98a72a 100644
--- a/src/L10NSharp/ILocalizedStringCache.cs
+++ b/src/L10NSharp/ILocalizedStringCache.cs
@@ -1,18 +1,19 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace L10NSharp
 {
-	internal interface ILocalizedStringCache<T>
+	internal interface ILocalizedStringCache<T> where T : class
 	{
-		bool TryGetDocument(string langId, out T doc);
+		bool TryGetDocument(string langId, [NotNullWhen(true)] out T? doc);
 		IEnumerable<string> AvailableLangKeys { get; }
-		string GetString(string langId, string id);
-		string GetString(string langId, string id, bool formatForDisplay);
-		string GetToolTipText(string langId, string id);
-		string GetToolTipText(string langId, string id, bool formatForDisplay);
-		string GetShortcutKeysText(string langId, string id);
-		string GetComment(string id);
-		string GetValueForExactLangAndId(string langId, string id, bool formatForDisplay);
+		string? GetString(string langId, string id);
+		string? GetString(string langId, string id, bool formatForDisplay);
+		string? GetToolTipText(string langId, string id);
+		string? GetToolTipText(string langId, string id, bool formatForDisplay);
+		string? GetShortcutKeysText(string langId, string id);
+		string? GetComment(string id);
+		string? GetValueForExactLangAndId(string langId, string id, bool formatForDisplay);
 
 		void UpdateLocalizedInfo(LocalizingInfo locInfo);
 
diff --git a/src/L10NSharp/L10NCultureInfo.cs b/src/L10NSharp/L10NCultureInfo.cs
index 66294ad..955baa9 100644
--- a/src/L10NSharp/L10NCultureInfo.cs
+++ b/src/L10NSharp/L10NCultureInfo.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using static System.StringComparison;
@@ -93,7 +94,7 @@ public L10NCultureInfo(string name)
 			}
 			else
 			{
-				InitializeFromRawCultureInfo();
+				InitializeFromRawCultureInfo(RawCultureInfo);
 				// The Windows .Net runtime returns 'Azərbaycan dili (Azərbaycan)' for az-Latn, and
 				// something totally different for az.
 				// The Mono runtime returns "azərbaycan" for both az and az-Latn.
@@ -126,26 +127,27 @@ public L10NCultureInfo(string name)
 		private L10NCultureInfo(CultureInfo ci)
 		{
 			RawCultureInfo = ci;
-			InitializeFromRawCultureInfo();
+			InitializeFromRawCultureInfo(ci);
 		}
 
-		private void InitializeFromRawCultureInfo()
+		[MemberNotNull(nameof(EnglishName), nameof(DisplayName), nameof(NativeName), nameof(IsNeutralCulture), nameof(NumberFormat), nameof(Name), nameof(TwoLetterISOLanguageName), nameof(ThreeLetterISOLanguageName), nameof(IetfLanguageTag))]
+		private void InitializeFromRawCultureInfo(CultureInfo rawCultureInfo)
 		{
-			EnglishName = RawCultureInfo.EnglishName;
-			DisplayName = RawCultureInfo.DisplayName;
-			NativeName = RawCultureInfo.NativeName;
-			IsNeutralCulture = RawCultureInfo.IsNeutralCulture;
-			NumberFormat = RawCultureInfo.NumberFormat;
-			Name = RawCultureInfo.Name;
-			TwoLetterISOLanguageName = RawCultureInfo.TwoLetterISOLanguageName;
-			ThreeLetterISOLanguageName = RawCultureInfo.ThreeLetterISOLanguageName;
-			IetfLanguageTag = RawCultureInfo.IetfLanguageTag;
+			EnglishName = rawCultureInfo.EnglishName;
+			DisplayName = rawCultureInfo.DisplayName;
+			NativeName = rawCultureInfo.NativeName;
+			IsNeutralCulture = rawCultureInfo.IsNeutralCulture;
+			NumberFormat = rawCultureInfo.NumberFormat;
+			Name = rawCultureInfo.Name;
+			TwoLetterISOLanguageName = rawCultureInfo.TwoLetterISOLanguageName;
+			ThreeLetterISOLanguageName = rawCultureInfo.ThreeLetterISOLanguageName;
+			IetfLanguageTag = rawCultureInfo.IetfLanguageTag;
 		}
 
 		/// <summary>
 		/// Provide access to the underlying CultureInfo object if it exists.
 		/// </summary>
-		public CultureInfo RawCultureInfo { get; }
+		public CultureInfo? RawCultureInfo { get; }
 
 		// The following properties mimic those provided by CultureInfo.
 
@@ -167,7 +169,7 @@ private void InitializeFromRawCultureInfo()
 
 		public NumberFormatInfo NumberFormat { get; set; }
 
-		private static L10NCultureInfo _currentInfo;
+		private static L10NCultureInfo? _currentInfo;
 		public static L10NCultureInfo CurrentCulture
 		{
 			get
@@ -238,7 +240,7 @@ public override string ToString()
 			return $"[L10NCultureInfo: Name={Name}, EnglishName={EnglishName}]";
 		}
 
-		public static bool operator ==(L10NCultureInfo ci1, L10NCultureInfo ci2)
+		public static bool operator ==(L10NCultureInfo? ci1, L10NCultureInfo? ci2)
 		{
 			if (ReferenceEquals(ci1, ci2))
 				return true;
@@ -250,7 +252,7 @@ public override string ToString()
 		}
 
 		// this is second one '!='
-		public static bool operator !=(L10NCultureInfo ci1, L10NCultureInfo ci2)
+		public static bool operator !=(L10NCultureInfo? ci1, L10NCultureInfo? ci2)
 		{
 			return !(ci1 == ci2);
 		}
diff --git a/src/L10NSharp/L10NSharp.csproj b/src/L10NSharp/L10NSharp.csproj
index f72e5c3..43d6551 100644
--- a/src/L10NSharp/L10NSharp.csproj
+++ b/src/L10NSharp/L10NSharp.csproj
@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
+    <Nullable>enable</Nullable>
     <TargetFrameworks>$(TargetFrameworks);netstandard2.0</TargetFrameworks>
     <RootNamespace>L10NSharp</RootNamespace>
     <Description>L10NSharp is a .NET localization library. It collects strings which need localization when your application first runs and saves them in a XLIFF file.</Description>
@@ -13,6 +14,10 @@
       <PrivateAssets>All</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="all" />
+    <PackageReference Include="PolySharp" Version="1.16.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
     <PackageReference Include="SIL.ReleaseTasks" Version="3.3.0" PrivateAssets="all" />
     <PackageReference Include="System.Resources.Extensions" Version="10.0.11" />
   </ItemGroup>
diff --git a/src/L10NSharp/LocalizationManager.cs b/src/L10NSharp/LocalizationManager.cs
index 5c1a4e0..67921df 100644
--- a/src/L10NSharp/LocalizationManager.cs
+++ b/src/L10NSharp/LocalizationManager.cs
@@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.Reflection;
@@ -26,7 +27,7 @@ public static class LocalizationManager
 		internal const string kL10NPrefix = "_L10N_:";
 		internal const string kAppVersionPropTag = "x-appversion";
 
-		private static string s_uiLangId;
+		private static string? s_uiLangId;
 		internal static TranslationMemory TranslationMemoryKind { get; set; }
 
 		/// <summary>
@@ -64,7 +65,8 @@ public static class LocalizationManager
 		/// around L10NSharp.
 		/// </summary>
 		[PublicAPI]
-		public static string PseudoLocalize(string english) => PseudoLocalization.Transform(english);
+		[return: NotNullIfNotNull("english")]
+		public static string? PseudoLocalize(string? english) => PseudoLocalization.Transform(english);
 
 		internal static bool IsPseudoLanguageId(string langId) =>
 			string.Equals(langId, PseudoLocalizationLanguageId, StringComparison.OrdinalIgnoreCase);
@@ -110,7 +112,7 @@ public static ILocalizationManager Create(string desiredUiLangId,
 			string appId, string appName, string appVersion, string directoryOfInstalledFiles,
 			string relativeSettingPathForLocalizationFolder,
 			string[] namespaceBeginnings,
-			IEnumerable<MethodInfo> additionalLocalizationMethods = null)
+			IEnumerable<MethodInfo>? additionalLocalizationMethods = null)
 		{
 			TranslationMemoryKind = TranslationMemory.XLiff;
 			return LocalizationManagerInternal<XLiffDocument>.CreateXliff(desiredUiLangId,
@@ -477,8 +479,8 @@ public static string GetString(string stringId, string englishText, string comme
 		/// policy for this library.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetString(string stringId, string englishText, string comment,
-			IEnumerable<string> preferredLanguageIds, out string languageIdUsed)
+		public static string GetString(string stringId, string englishText, string? comment,
+			IEnumerable<string> preferredLanguageIds, out string? languageIdUsed)
 		{
 			switch (TranslationMemoryKind)
 			{
@@ -631,7 +633,8 @@ public static bool GetIsStringAvailableForLangId(string id, string langId)
 			}
 		}
 
-		public static string StripOffLocalizationInfoFromText(string text)
+		[return: NotNullIfNotNull("text")]
+		public static string? StripOffLocalizationInfoFromText(string? text)
 		{
 			if (text == null || !text.StartsWith(kL10NPrefix))
 				return text;
diff --git a/src/L10NSharp/LocalizationManagerInternal.cs b/src/L10NSharp/LocalizationManagerInternal.cs
index 666941b..c3e6ce0 100644
--- a/src/L10NSharp/LocalizationManagerInternal.cs
+++ b/src/L10NSharp/LocalizationManagerInternal.cs
@@ -1,7 +1,8 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -12,10 +13,10 @@
 
 namespace L10NSharp
 {
-	internal class LocalizationManagerInternal<T>
+	internal class LocalizationManagerInternal<T> where T : class
 	{
 		protected static List<string> s_fallbackLanguageIds =
-			new List<string>(new[] { LocalizationManager.kDefaultLang });
+			new List<string> { LocalizationManager.kDefaultLang };
 
 		/// <summary>
 		/// Map from the given language code to a variant we actually have.  (It can map from a
@@ -140,7 +141,7 @@ protected static bool IsDesiredUiCultureAvailable(string desiredUiLangId)
 		public static ILocalizationManager CreateXliff(string desiredUiLangId, string appId,
 			string appName, string appVersion, string directoryOfInstalledXliffFiles,
 			string relativeSettingPathForLocalizationFolder,
-			IEnumerable<MethodInfo> additionalLocalizationMethods,
+			IEnumerable<MethodInfo>? additionalLocalizationMethods,
 			params string[] namespaceBeginnings)
 		{
 			if (string.IsNullOrWhiteSpace(appId))
@@ -175,14 +176,14 @@ internal static void RemoveManager(string id)
 		}
 
 		/// ------------------------------------------------------------------------------------
-		internal static ILocalizationManagerInternal<T> GetLocalizationManagerForComponent(
+		internal static ILocalizationManagerInternal<T>? GetLocalizationManagerForComponent(
 			IComponent component)
 		{
 			return LoadedManagers.Values.FirstOrDefault(lm => lm.ComponentCache.ContainsKey(component));
 		}
 
 		/// ------------------------------------------------------------------------------------
-		internal static ILocalizationManagerInternal<T> GetLocalizationManagerForString(string id)
+		internal static ILocalizationManagerInternal<T>? GetLocalizationManagerForString(string id)
 		{
 			return LoadedManagers.Values.FirstOrDefault(
 				lm => lm.StringCache.GetString(LocalizationManager.UILanguageId, id) != null);
@@ -335,7 +336,7 @@ public static IEnumerable<L10NCultureInfo> GetUILanguages(bool returnOnlyLanguag
 					// (short of at least a major change of API).
 					return null; // to the Select; filtered out below
 				}
-			}).Where(ci => ci != null));
+			}).OfType<L10NCultureInfo>());
 
 			if (!returnOnlyLanguagesHavingLocalizations)
 				return from ci in allLangs
@@ -442,7 +443,7 @@ public static int StringCount(string lang)
 		/// for the specified object cannot be found for the current UI language.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetStringForObject(IComponent component, string englishText)
+		public static string GetStringForObject(IComponent component, string? englishText)
 		{
 			var lm = GetLocalizationManagerForComponent(component);
 
@@ -453,7 +454,7 @@ public static string GetStringForObject(IComponent component, string englishText
 			}
 
 			return LocalizationManager.StripOffLocalizationInfoFromText(
-				englishText ?? Utils.GetProperty(component, "Text") as string);
+				englishText ?? Utils.GetProperty(component, "Text") as string) ?? string.Empty;
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -477,7 +478,7 @@ public static string GetDynamicString(string appId, string id, string englishTex
 		/// language.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetDynamicString(string appId, string id, string englishText, string comment)
+		public static string GetDynamicString(string appId, string id, string englishText, string? comment)
 		{
 			return GetDynamicStringOrEnglish(appId, id, englishText, comment, LocalizationManager.UILanguageId);
 		}
@@ -486,13 +487,13 @@ public static string GetDynamicString(string appId, string id, string englishTex
 		/// For the paths where no string cache is available: the caller-supplied englishText
 		/// (pseudolocalized if langId is the pseudo-locale), or fallback when there is none.
 		/// </summary>
-		private static string EnglishTextOrFallback(string englishText, string langId, string fallback)
+		private static string EnglishTextOrFallback(string? englishText, string langId, string fallback)
 		{
 			if (string.IsNullOrEmpty(englishText))
 				return fallback;
 			return LocalizationManager.IsPseudoLanguageId(langId)
-				? PseudoLocalization.Transform(englishText)
-				: englishText;
+				? PseudoLocalization.Transform(englishText!)
+				: englishText!;
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -507,11 +508,11 @@ private static string EnglishTextOrFallback(string englishText, string langId, s
 		/// langId = 'en', irrespective of what is in l10n file.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetDynamicStringOrEnglish(string appId, string id, string englishText,
-			string comment, string langId)
+		public static string GetDynamicStringOrEnglish(string appId, string id, string? englishText,
+			string? comment, string langId)
 		{
 			if (string.IsNullOrWhiteSpace(id))
-				return string.IsNullOrEmpty(englishText) ? string.Empty : englishText;
+				return string.IsNullOrEmpty(englishText) ? string.Empty : englishText!;
 			// This happens in unit test environments or apps that have imported a library that
 			// is localized, but the app itself isn't initializing L10N yet.
 			if (LoadedManagers.Count == 0)
@@ -554,7 +555,8 @@ public static string GetDynamicStringOrEnglish(string appId, string id, string e
 			if (LocalizationManager.IsPseudoLanguageId(langId))
 			{
 				return PseudoLocalization.Transform(englishText ??
-					lm.GetStringFromStringCache(LocalizationManager.kDefaultLang, id));
+					lm.GetStringFromStringCache(LocalizationManager.kDefaultLang, id) ??
+					string.Empty);
 			}
 
 			// If they asked for English, we are going to use the supplied englishText, regardless
@@ -570,7 +572,7 @@ public static string GetDynamicStringOrEnglish(string appId, string id, string e
 			}
 
 			if (!lm.CollectUpNewStringsDiscoveredDynamically)
-				return englishText;
+				return englishText ?? string.Empty;
 
 			var locInfo = new LocalizingInfo(id)
 			{
@@ -588,7 +590,7 @@ public static string GetDynamicStringOrEnglish(string appId, string id, string e
 
 			lm.StringCache.UpdateLocalizedInfo(locInfo);
 			lm.SaveIfDirty(null);// this will be common for GetDynamic string on users restricted from writing to ProgramData
-			return englishText;
+			return englishText ?? string.Empty;
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -603,10 +605,11 @@ public static string GetDynamicStringOrEnglish(string appId, string id, string e
 		/// <remarks>
 		/// <see cref="XliffLocalizedStringCache.LoadXliffAndUpdateExistingLanguageMap"/> must load "es-ES" before "es" will map to "es-ES".
 		/// </remarks>
-		internal static string MapToExistingLanguageIfPossible(string langId)
+		[return: NotNullIfNotNull("langId")]
+		internal static string? MapToExistingLanguageIfPossible(string? langId)
 		{
-			if (string.IsNullOrEmpty(langId))
-				return null;
+			if (langId is null || langId.Length == 0)
+				return langId;
 			// The pseudo-locale never maps to or from a real language, and no localization
 			// files exist for it, so don't try to load any.
 			if (LocalizationManager.IsPseudoLanguageId(langId))
@@ -667,7 +670,7 @@ public static bool GetIsStringAvailableForLangId(string id, string langId)
 		}
 
 		/// ------------------------------------------------------------------------------------
-		internal static string GetStringFromAnyLocalizationManager(string stringId)
+		internal static string? GetStringFromAnyLocalizationManager(string stringId)
 		{
 			if (LocalizationManager.StrictInitializationMode)
 			{
@@ -690,8 +693,8 @@ internal static string GetStringFromAnyLocalizationManager(string stringId)
 		}
 
 		/// ------------------------------------------------------------------------------------
-		internal static string GetStringFromAnyLocalizationManager(string stringId,
-			IEnumerable<string> preferredLanguageIds, out string languageIdUsed)
+		internal static string? GetStringFromAnyLocalizationManager(string stringId,
+			IEnumerable<string> preferredLanguageIds, out string? languageIdUsed)
 		{
 			foreach (var langId in preferredLanguageIds)
 			{
@@ -703,7 +706,7 @@ internal static string GetStringFromAnyLocalizationManager(string stringId,
 			return null;
 		}
 
-		protected static string MapToExistingLanguageOrAddMapping(string stringId, string langId,
+		protected static string? MapToExistingLanguageOrAddMapping(string stringId, string langId,
 			out string languageIdUsed)
 		{
 			var realLangId = MapToExistingLanguageIfPossible(langId);
@@ -732,7 +735,7 @@ public static string GetString(string stringId, string englishText)
 		/// a string cannot be found for the specified id and the current UI language.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetString(string stringId, string englishText, string comment)
+		public static string GetString(string stringId, string englishText, string? comment)
 		{
 			return GetString(stringId, englishText, comment, null, null, null);
 		}
@@ -743,7 +746,7 @@ public static string GetString(string stringId, string englishText, string comme
 		/// a string cannot be found for the specified id and the current UI language.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetString(string stringId, string englishText, string comment, IComponent component)
+		public static string GetString(string stringId, string englishText, string? comment, IComponent? component)
 		{
 			return GetString(stringId, englishText, comment, null, null, component);
 		}
@@ -754,8 +757,8 @@ public static string GetString(string stringId, string englishText, string comme
 		/// a string cannot be found for the specified id and the current UI language.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetString(string stringId, string englishText, string comment, string englishToolTipText,
-			string englishShortcutKey, IComponent component)
+		public static string GetString(string stringId, string englishText, string? comment, string? englishToolTipText,
+			string? englishShortcutKey, IComponent? component)
 		{
 			if (string.IsNullOrWhiteSpace(stringId))
 				return LocalizationManager.StripOffLocalizationInfoFromText(englishText);
@@ -765,7 +768,7 @@ public static string GetString(string stringId, string englishText, string comme
 			{
 				return PseudoLocalization.Transform(
 					LocalizationManager.StripOffLocalizationInfoFromText(englishText) ??
-					MapToExistingLanguageOrAddMapping(stringId, LocalizationManager.kDefaultLang, out _));
+					MapToExistingLanguageOrAddMapping(stringId, LocalizationManager.kDefaultLang, out _))!;
 			}
 			return GetStringFromAnyLocalizationManager(stringId) ??
 				LocalizationManager.StripOffLocalizationInfoFromText(englishText);
@@ -779,8 +782,8 @@ public static string GetString(string stringId, string englishText, string comme
 		/// policy for this library.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string GetString(string stringId, string englishText, string comment,
-			IEnumerable<string> preferredLanguageIds, out string languageIdUsed)
+		public static string GetString(string stringId, string englishText, string? comment,
+			IEnumerable<string> preferredLanguageIds, out string? languageIdUsed)
 		{
 			if (string.IsNullOrWhiteSpace(stringId))
 			{
@@ -827,7 +830,7 @@ public static string GetString(string stringId, string englishText, string comme
 				return LocalizationManager.StripOffLocalizationInfoFromText(englishText);
 			}
 
-			return stringFromAnyLocalizationManager;
+			return stringFromAnyLocalizationManager!;
 		}
 
 		/// <summary>
diff --git a/src/L10NSharp/LocalizingInfo.cs b/src/L10NSharp/LocalizingInfo.cs
index 9972eb6..07f84ea 100644
--- a/src/L10NSharp/LocalizingInfo.cs
+++ b/src/L10NSharp/LocalizingInfo.cs
@@ -99,11 +99,11 @@ internal enum UpdateFields
 	/// ----------------------------------------------------------------------------------------
 	public class LocalizingInfo
 	{
-		protected IComponent _component;
-		protected string _id;
-		protected string _text;
-		protected string _shortcutKeys;
-		protected string _comment;
+		protected IComponent? _component;
+		protected string? _id;
+		protected string? _text;
+		protected string? _shortcutKeys;
+		protected string? _comment;
 		protected LocalizationCategory _category = LocalizationCategory.Unspecified;
 
 		#region Constructors
@@ -134,7 +134,7 @@ public LocalizingInfo(IComponent component, string id) : this(component, true)
 		/// Initializes a new instance of the <see cref="LocalizingInfo"/> class.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public LocalizingInfo(string id)
+		public LocalizingInfo(string? id)
 		{
 			Id = id;
 			Priority = LocalizationPriority.MediumHigh;
@@ -177,7 +177,7 @@ public bool IsEmpty
 		/// Gets or sets the id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string Id
+		public string? Id
 		{
 			get
 			{
@@ -195,7 +195,7 @@ public string Id
 				}
 				else
 				{
-					_id = _id.Trim().Replace("..", ".");//it happens...
+					_id = _id!.Trim().Replace("..", ".");//it happens...
 				}
 			}
 		}
@@ -205,7 +205,7 @@ public string Id
 		/// Gets the component.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		internal IComponent Component
+		internal IComponent? Component
 		{
 			get { return _component; }
 			set
@@ -219,7 +219,7 @@ internal IComponent Component
 		/// Gets or sets the language id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string LangId { get; set; }
+		public string? LangId { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -233,7 +233,7 @@ internal IComponent Component
 		/// Gets or sets the comment.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string Comment
+		public string? Comment
 		{
 			get { return _comment; }
 			set { _comment = (value == "null" ? null : value); }
@@ -273,28 +273,28 @@ public LocalizationCategory Category
 		/// Gets or sets the group.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string Group { get; set; }
+		public string? Group { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
 		/// Gets or sets the tooltip.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string ToolTipText { get; set; }
+		public string? ToolTipText { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
 		/// Gets or sets the shortcutKeys.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string ShortcutKeys;
+		public string? ShortcutKeys;
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
 		/// Gets the text of the object.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string Text
+		public string? Text
 		{
 			get
 			{
diff --git a/src/L10NSharp/Pseudo/PseudoLocalization.cs b/src/L10NSharp/Pseudo/PseudoLocalization.cs
index 1572701..bd44795 100644
--- a/src/L10NSharp/Pseudo/PseudoLocalization.cs
+++ b/src/L10NSharp/Pseudo/PseudoLocalization.cs
@@ -1,3 +1,5 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace L10NSharp.Pseudo
 {
 	/// <summary>
@@ -9,11 +11,12 @@ namespace L10NSharp.Pseudo
 	/// </summary>
 	internal static class PseudoLocalization
 	{
-		public static string Transform(string english)
+		[return: NotNullIfNotNull("english")]
+		public static string? Transform(string? english)
 		{
 			if (string.IsNullOrEmpty(english))
 				return english;
-			return "[" + VowelStretch.Transform(english) + "]";
+			return "[" + VowelStretch.Transform(english!) + "]";
 		}
 	}
 }
diff --git a/src/L10NSharp/Translators/MicrosoftTranslator.cs b/src/L10NSharp/Translators/MicrosoftTranslator.cs
index 1c4ad03..3420425 100644
--- a/src/L10NSharp/Translators/MicrosoftTranslator.cs
+++ b/src/L10NSharp/Translators/MicrosoftTranslator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -32,7 +32,7 @@ public class MicrosoftTranslator : TranslatorBase
 		/// L10NSHARP_TRANSLATOR_KEY environment variable.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string SubscriptionKey { get; set; }
+		public static string? SubscriptionKey { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -41,7 +41,7 @@ public class MicrosoftTranslator : TranslatorBase
 		/// L10NSHARP_TRANSLATOR_REGION environment variable.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string Region { get; set; }
+		public static string? Region { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -49,7 +49,7 @@ public class MicrosoftTranslator : TranslatorBase
 		/// or the L10NSHARP_TRANSLATOR_KEY environment variable.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string EffectiveSubscriptionKey =>
+		public static string? EffectiveSubscriptionKey =>
 			string.IsNullOrEmpty(SubscriptionKey) ? Environment.GetEnvironmentVariable(kSubscriptionKeyEnvVar) : SubscriptionKey;
 
 		/// ------------------------------------------------------------------------------------
@@ -58,7 +58,7 @@ public class MicrosoftTranslator : TranslatorBase
 		/// L10NSHARP_TRANSLATOR_REGION environment variable.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string EffectiveRegion =>
+		public static string? EffectiveRegion =>
 			string.IsNullOrEmpty(Region) ? Environment.GetEnvironmentVariable(kRegionEnvVar) : Region;
 
 		/// ------------------------------------------------------------------------------------
@@ -129,7 +129,7 @@ internal class TranslateRequestItem
 	{
 		/// ------------------------------------------------------------------------------------
 		[DataMember(Name = "Text")]
-		public string Text { get; set; }
+		public string? Text { get; set; }
 	}
 
 	/// ----------------------------------------------------------------------------------------
@@ -138,7 +138,7 @@ internal class TranslateResponseItem
 	{
 		/// ------------------------------------------------------------------------------------
 		[DataMember(Name = "translations")]
-		public List<TranslationItem> Translations { get; set; }
+		public List<TranslationItem>? Translations { get; set; }
 	}
 
 	/// ----------------------------------------------------------------------------------------
@@ -147,10 +147,10 @@ internal class TranslationItem
 	{
 		/// ------------------------------------------------------------------------------------
 		[DataMember(Name = "text")]
-		public string Text { get; set; }
+		public string? Text { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		[DataMember(Name = "to")]
-		public string To { get; set; }
+		public string? To { get; set; }
 	}
 }
diff --git a/src/L10NSharp/Translators/MyMemoryTranslator.cs b/src/L10NSharp/Translators/MyMemoryTranslator.cs
index 4d62207..f31c2dd 100644
--- a/src/L10NSharp/Translators/MyMemoryTranslator.cs
+++ b/src/L10NSharp/Translators/MyMemoryTranslator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Net.Http;
 using System.Runtime.Serialization.Json;
@@ -86,9 +86,9 @@ protected override string InternalTranslate(string srcText)
 	internal class JSONResponse
 	{
 		/// ------------------------------------------------------------------------------------
-		public TranslationResponseData responseData = new TranslationResponseData();
+		public TranslationResponseData? responseData = new TranslationResponseData();
 		/// ------------------------------------------------------------------------------------
-		public string responseDetails;
+		public string? responseDetails;
 		/// ------------------------------------------------------------------------------------
 		public int responseStatus;
 		/// ------------------------------------------------------------------------------------
@@ -100,6 +100,6 @@ internal class JSONResponse
 	internal class TranslationResponseData
 	{
 		/// ------------------------------------------------------------------------------------
-		public string translatedText;
+		public string? translatedText;
 	}
 }
diff --git a/src/L10NSharp/Translators/TranslatorBase.cs b/src/L10NSharp/Translators/TranslatorBase.cs
index 12fe031..6af9731 100644
--- a/src/L10NSharp/Translators/TranslatorBase.cs
+++ b/src/L10NSharp/Translators/TranslatorBase.cs
@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Diagnostics.CodeAnalysis;
 using L10NSharp.Utility;
 
 namespace L10NSharp.Translators
@@ -7,16 +8,16 @@ namespace L10NSharp.Translators
 	public abstract class TranslatorBase
 	{
 		/// ------------------------------------------------------------------------------------
-		protected string m_srcCultureId;
+		protected string? m_srcCultureId;
 		/// ------------------------------------------------------------------------------------
-		protected string m_tgtCultureId;
+		protected string? m_tgtCultureId;
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
 		/// Translate the specified text.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public virtual string TranslateText(string srcText)
+		public virtual string? TranslateText(string srcText)
 		{
 			if (string.IsNullOrEmpty(srcText))
 				return null;
@@ -24,7 +25,7 @@ public virtual string TranslateText(string srcText)
 			try
 			{
 				int paramCount = PreTranslateProcess(ref srcText);
-				string result = InternalTranslate(srcText);
+				string? result = InternalTranslate(srcText);
 				return (result == null ? null : PostTranslateProcess(paramCount, result));
 			}
 			catch
@@ -38,7 +39,7 @@ public virtual string TranslateText(string srcText)
 		/// Internal method for translating the specified text.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		protected virtual string InternalTranslate(string srcText)
+		protected virtual string? InternalTranslate(string srcText)
 		{
 			throw new NotImplementedException();
 		}
@@ -74,7 +75,7 @@ protected virtual int PreTranslateProcess(ref string text)
 		/// string.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		protected virtual string PostTranslateProcess(int paramCount, string text)
+		protected virtual string? PostTranslateProcess(int paramCount, string? text)
 		{
 			if (text == null)
 				return null;
@@ -100,7 +101,8 @@ protected virtual string PostTranslateProcess(int paramCount, string text)
 		/// Removes accelerator ampersands from the specified text.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static string RemoveAcceleratorAmpersands(string text)
+		[return: NotNullIfNotNull("text")]
+		public static string? RemoveAcceleratorAmpersands(string? text)
 		{
 			if (text == null)
 				return null;
diff --git a/src/L10NSharp/Utility/HttpEncoderFromMono.cs b/src/L10NSharp/Utility/HttpEncoderFromMono.cs
index 4af461f..6398384 100644
--- a/src/L10NSharp/Utility/HttpEncoderFromMono.cs
+++ b/src/L10NSharp/Utility/HttpEncoderFromMono.cs
@@ -33,6 +33,7 @@
 //
 
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.Text;
@@ -50,7 +51,7 @@ class HttpEncoderFromMono
 	{
 		static char[] hexChars = "0123456789abcdef".ToCharArray();
 		static object entitiesLock = new object();
-		static SortedDictionary<string, char> entities;
+		static SortedDictionary<string, char>? entities;
 #if NET_4_0
 		static Lazy <HttpEncoder> defaultEncoder;
 		static Lazy <HttpEncoder> currentEncoderLazy;
@@ -136,7 +137,7 @@ void HeaderNameValueEncode(string headerName, string headerValue, out string enc
 				encodedHeaderValue = EncodeHeaderString(headerValue);
 		}
 
-		static void StringBuilderAppend(string s, ref StringBuilder sb)
+		static void StringBuilderAppend(string s, ref StringBuilder? sb)
 		{
 			if (sb == null)
 				sb = new StringBuilder(s);
@@ -146,7 +147,7 @@ static void StringBuilderAppend(string s, ref StringBuilder sb)
 
 		static string EncodeHeaderString(string input)
 		{
-			StringBuilder sb = null;
+			StringBuilder? sb = null;
 			char ch;
 
 			for (int i = 0; i < input.Length; i++)
@@ -257,7 +258,8 @@ internal static byte[] UrlEncodeToBytes(byte[] bytes, int offset, int count)
 			return result.ToArray();
 		}
 
-		internal static string HtmlEncode(string s)
+		[return: NotNullIfNotNull("s")]
+		internal static string? HtmlEncode(string? s)
 		{
 			if (s == null)
 				return null;
@@ -333,7 +335,8 @@ internal static string HtmlEncode(string s)
 			return output.ToString();
 		}
 
-		internal static string HtmlAttributeEncode(string s)
+		[return: NotNullIfNotNull("s")]
+		internal static string? HtmlAttributeEncode(string? s)
 		{
 #if NET_4_0
 			if (String.IsNullOrEmpty (s))
@@ -390,7 +393,8 @@ internal static string HtmlAttributeEncode(string s)
 			return output.ToString();
 		}
 
-		internal static string HtmlDecode(string s)
+        [return: NotNullIfNotNull("s")]
+		internal static string? HtmlDecode(string? s)
 		{
 			if (s == null)
 				return null;
@@ -657,6 +661,7 @@ internal static void UrlPathEncodeChar(char c, Stream result)
 				result.WriteByte((byte)c);
 		}
 
+        [MemberNotNull(nameof(entities))]
 		static void InitEntities()
 		{
 			// Build the hash table of HTML entity references.  This list comes
diff --git a/src/L10NSharp/Utility/HttpUtilityFromMono.cs b/src/L10NSharp/Utility/HttpUtilityFromMono.cs
index 9ff2966..50b9acb 100644
--- a/src/L10NSharp/Utility/HttpUtilityFromMono.cs
+++ b/src/L10NSharp/Utility/HttpUtilityFromMono.cs
@@ -37,6 +37,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text;
 using System.Web.Util;
@@ -98,7 +99,8 @@ public static void HtmlAttributeEncode (string s, TextWriter output)
 #endif
 		}
 
-		public static string HtmlAttributeEncode (string s)
+        [return: NotNullIfNotNull("s")]
+		public static string? HtmlAttributeEncode (string? s)
 		{
 #if NET_4_0
 			if (s == null)
@@ -113,7 +115,8 @@ public static string HtmlAttributeEncode (string s)
 #endif
 		}
 
-		public static string UrlDecode (string str)
+        [return: NotNullIfNotNull("str")]
+		public static string? UrlDecode (string? str)
 		{
 			return UrlDecode(str, Encoding.UTF8);
 		}
@@ -132,7 +135,8 @@ static void WriteCharBytes (IList buf, char ch, Encoding e)
 				buf.Add ((byte)ch);
 		}
 
-		public static string UrlDecode (string s, Encoding e)
+        [return: NotNullIfNotNull("s")]
+		public static string? UrlDecode (string? s, Encoding? e)
 		{
 			if (null == s)
 				return null;
@@ -180,7 +184,8 @@ public static string UrlDecode (string s, Encoding e)
 
 		}
 
-		public static string UrlDecode (byte [] bytes, Encoding e)
+        [return: NotNullIfNotNull("bytes")]
+		public static string? UrlDecode (byte []? bytes, Encoding e)
 		{
 			if (bytes == null)
 				return null;
@@ -235,7 +240,8 @@ static int GetChar (string str, int offset, int length)
 			return val;
 		}
 
-		public static string UrlDecode (byte [] bytes, int offset, int count, Encoding e)
+        [return: NotNullIfNotNull("bytes")]
+		public static string? UrlDecode (byte []? bytes, int offset, int count, Encoding e)
 		{
 			if (bytes == null)
 				return null;
@@ -292,11 +298,12 @@ public static string UrlDecode (byte [] bytes, int offset, int count, Encoding e
 				output.Append (GetChars (acc, e));
 			}
 
-			acc = null;
+			acc = null!;
 			return output.ToString ();
 		}
 
-		public static byte [] UrlDecodeToBytes (byte [] bytes)
+        [return: NotNullIfNotNull("bytes")]
+		public static byte[]? UrlDecodeToBytes (byte []? bytes)
 		{
 			if (bytes == null)
 				return null;
@@ -304,12 +311,14 @@ public static byte [] UrlDecodeToBytes (byte [] bytes)
 			return UrlDecodeToBytes (bytes, 0, bytes.Length);
 		}
 
-		public static byte [] UrlDecodeToBytes (string str)
+        [return: NotNullIfNotNull("str")]
+		public static byte[]? UrlDecodeToBytes (string? str)
 		{
 			return UrlDecodeToBytes (str, Encoding.UTF8);
 		}
 
-		public static byte [] UrlDecodeToBytes (string str, Encoding e)
+        [return: NotNullIfNotNull("str")]
+		public static byte[]? UrlDecodeToBytes (string? str, Encoding e)
 		{
 			if (str == null)
 				return null;
@@ -320,7 +329,8 @@ public static byte [] UrlDecodeToBytes (string str, Encoding e)
 			return UrlDecodeToBytes (e.GetBytes (str));
 		}
 
-		public static byte [] UrlDecodeToBytes (byte [] bytes, int offset, int count)
+        [return: NotNullIfNotNull("bytes")]
+		public static byte[]? UrlDecodeToBytes (byte []? bytes, int offset, int count)
 		{
 			if (bytes == null)
 				return null;
@@ -353,12 +363,14 @@ public static byte [] UrlDecodeToBytes (byte [] bytes, int offset, int count)
 			return result.ToArray ();
 		}
 
-		public static string UrlEncode(string str)
+        [return: NotNullIfNotNull("str")]
+		public static string? UrlEncode(string? str)
 		{
 			return UrlEncode(str, Encoding.UTF8);
 		}
 
-		public static string UrlEncode (string s, Encoding Enc)
+        [return: NotNullIfNotNull("s")]
+		public static string? UrlEncode (string? s, Encoding Enc)
 		{
 			if (s == null)
 				return null;
@@ -388,7 +400,8 @@ public static string UrlEncode (string s, Encoding Enc)
 			return Encoding.ASCII.GetString (UrlEncodeToBytes (bytes, 0, realLen));
 		}
 
-		public static string UrlEncode (byte [] bytes)
+        [return: NotNullIfNotNull("bytes")]
+		public static string? UrlEncode (byte []? bytes)
 		{
 			if (bytes == null)
 				return null;
@@ -399,7 +412,8 @@ public static string UrlEncode (byte [] bytes)
 			return Encoding.ASCII.GetString (UrlEncodeToBytes (bytes, 0, bytes.Length));
 		}
 
-		public static string UrlEncode (byte [] bytes, int offset, int count)
+        [return: NotNullIfNotNull("bytes")]
+		public static string? UrlEncode (byte []? bytes, int offset, int count)
 		{
 			if (bytes == null)
 				return null;
@@ -410,12 +424,14 @@ public static string UrlEncode (byte [] bytes, int offset, int count)
 			return Encoding.ASCII.GetString (UrlEncodeToBytes (bytes, offset, count));
 		}
 
-		public static byte [] UrlEncodeToBytes (string str)
+        [return: NotNullIfNotNull("str")]
+		public static byte[]? UrlEncodeToBytes (string? str)
 		{
 			return UrlEncodeToBytes (str, Encoding.UTF8);
 		}
 
-		public static byte [] UrlEncodeToBytes (string str, Encoding e)
+		[return: NotNullIfNotNull("str")]
+		public static byte[]? UrlEncodeToBytes (string? str, Encoding e)
 		{
 			if (str == null)
 				return null;
@@ -427,7 +443,8 @@ public static byte [] UrlEncodeToBytes (string str, Encoding e)
 			return UrlEncodeToBytes (bytes, 0, bytes.Length);
 		}
 
-		public static byte [] UrlEncodeToBytes (byte [] bytes)
+		[return: NotNullIfNotNull("bytes")]
+		public static byte[]? UrlEncodeToBytes (byte []? bytes)
 		{
 			if (bytes == null)
 				return null;
@@ -438,7 +455,8 @@ public static byte [] UrlEncodeToBytes (byte [] bytes)
 			return UrlEncodeToBytes (bytes, 0, bytes.Length);
 		}
 
-		public static byte [] UrlEncodeToBytes (byte [] bytes, int offset, int count)
+		[return: NotNullIfNotNull("bytes")]
+		public static byte[]? UrlEncodeToBytes (byte []? bytes, int offset, int count)
 		{
 			if (bytes == null)
 				return null;
@@ -449,7 +467,8 @@ public static byte [] UrlEncodeToBytes (byte [] bytes, int offset, int count)
 #endif
 		}
 
-		public static string UrlEncodeUnicode (string str)
+		[return: NotNullIfNotNull("str")]
+		public static string? UrlEncodeUnicode (string? str)
 		{
 			if (str == null)
 				return null;
@@ -457,7 +476,8 @@ public static string UrlEncodeUnicode (string str)
 			return Encoding.ASCII.GetString (UrlEncodeUnicodeToBytes (str));
 		}
 
-		public static byte [] UrlEncodeUnicodeToBytes (string str)
+		[return: NotNullIfNotNull("str")]
+		public static byte[]? UrlEncodeUnicodeToBytes (string? str)
 		{
 			if (str == null)
 				return null;
@@ -477,7 +497,8 @@ public static byte [] UrlEncodeUnicodeToBytes (string str)
 		/// </summary>
 		/// <param name="s">The HTML string to decode. </param>
 		/// <returns>The decoded text.</returns>
-		public static string HtmlDecode (string s)
+		[return: NotNullIfNotNull("s")]
+		public static string? HtmlDecode (string? s)
 		{
 #if NET_4_0
 			if (s == null)
@@ -516,7 +537,8 @@ public static void HtmlDecode(string s, TextWriter output)
 			}
 		}
 
-		public static string HtmlEncode (string s)
+		[return: NotNullIfNotNull("s")]
+		public static string? HtmlEncode (string? s)
 		{
 #if NET_4_0
 			if (s == null)
@@ -697,7 +719,7 @@ internal static void ParseQueryString (string query, Encoding encoding, NameValu
 						namePos++;
 				}
 
-				string name, value;
+				string? name, value;
 				if (valuePos == -1) {
 					name = null;
 					valuePos = namePos;
diff --git a/src/L10NSharp/Utils.cs b/src/L10NSharp/Utils.cs
index b0e69e5..ff894b7 100644
--- a/src/L10NSharp/Utils.cs
+++ b/src/L10NSharp/Utils.cs
@@ -48,7 +48,7 @@ public static bool HasProperty(object binding, string propertyName)
 		/// the method exists you should check first with HasProperty.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static object GetProperty(object binding, string propertyName)
+		public static object? GetProperty(object binding, string propertyName)
 		{
 			// It's not clear why this is needed. There is some indication (http://stackoverflow.com/questions/3546580/why-is-it-not-possible-to-catch-missingmethodexception)
 			// that MissingMethodException cannot be caught. In one situation in Bloom, with a ToolStripButton (which does not implement ShortcutKeys),
diff --git a/src/L10NSharp/XLiffUtils/XLiffBaseWithNotesAndProps.cs b/src/L10NSharp/XLiffUtils/XLiffBaseWithNotesAndProps.cs
index 62c0eaa..ce0d6b1 100644
--- a/src/L10NSharp/XLiffUtils/XLiffBaseWithNotesAndProps.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffBaseWithNotesAndProps.cs
@@ -45,7 +45,7 @@ public bool AddNote(string text)
 		/// Adds a note to the notes list.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public bool AddNote(string lang, string text)
+		public bool AddNote(string? lang, string text)
 		{
 			return XLiffNote.AddNote(lang, text, _notes);
 		}
@@ -120,7 +120,7 @@ public void SetPropValue(string type, string value)
 		/// specified type doesn't exist, then null is returned.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetPropValue(string type)
+		public string? GetPropValue(string type)
 		{
 			return _props.Where(p => p.Type == type).Select(p => p.Value).FirstOrDefault();
 		}
@@ -130,7 +130,7 @@ public string GetPropValue(string type)
 		/// Check whether the give comment already exists as a note.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public bool NotesContain(string comment)
+		public bool NotesContain(string? comment)
 		{
 			return _notes.Any(n => n.Text == comment);
 		}
@@ -142,9 +142,9 @@ public bool NotesContain(string comment)
 		/// "comment" if it exists.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetComment()
+		public string? GetComment()
 		{
-			var commentNote = _notes.FirstOrDefault(n => !string.IsNullOrEmpty(n.Text) && !n.Text.StartsWith("ID: "));
+			var commentNote = _notes.FirstOrDefault(n => !string.IsNullOrEmpty(n.Text) && !n.Text!.StartsWith("ID: "));
 			return commentNote?.Text;
 		}
 	}
diff --git a/src/L10NSharp/XLiffUtils/XLiffBody.cs b/src/L10NSharp/XLiffUtils/XLiffBody.cs
index 9391a0b..99e031b 100644
--- a/src/L10NSharp/XLiffUtils/XLiffBody.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffBody.cs
@@ -91,16 +91,19 @@ public ListWrapper TransUnitsForXml
 		/// Gets the translation unit for the specified id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		internal XLiffTransUnit GetTransUnitForId(string id)
+		internal XLiffTransUnit? GetTransUnitForId(string? id)
 		{
-			_transUnitDict.TryGetValue(id, out XLiffTransUnit result);
+			if (id == null)
+				return null;
+
+			_transUnitDict.TryGetValue(id, out XLiffTransUnit? result);
 			return result;
 		}
 
 		/// <summary>
 		/// When all but the last part of the id changed, this can help reunite things
 		/// </summary>
-		internal XLiffTransUnit GetTransUnitForOrphan(XLiffTransUnit orphan, XLiffBody source)
+		internal XLiffTransUnit? GetTransUnitForOrphan(XLiffTransUnit orphan, XLiffBody? source)
 		{
 			var terminalIdToMatch = XliffLocalizedStringCache.GetTerminalIdPart(orphan.Id);
 			var defaultTextToMatch = GetDefaultVariantValue(orphan);
@@ -111,7 +114,7 @@ internal XLiffTransUnit GetTransUnitForOrphan(XLiffTransUnit orphan, XLiffBody s
 				&& source?.GetTransUnitForId(tu.Id) == null); // and translation does not already have an element for this
 		}
 
-		string GetDefaultVariantValue(XLiffTransUnit tu)
+		string? GetDefaultVariantValue(XLiffTransUnit tu)
 		{
 			var variant = tu.GetVariantForLang(LocalizationManager.kDefaultLang);
 			return variant?.Value;
@@ -122,15 +125,16 @@ string GetDefaultVariantValue(XLiffTransUnit tu)
 		/// Adds the specified translation unit.
 		/// </summary>
 		/// <param name="tu">The translation unit.</param>
-		/// <returns>true if the translation unit was successfully added. Otherwise, false.</returns>
+		/// <returns>The id under which the translation unit was added, or null if it was not
+		/// added.</returns>
 		/// ------------------------------------------------------------------------------------
-		internal bool AddTransUnitRaw(XLiffTransUnit tu)
+		internal string? AddTransUnitRaw(XLiffTransUnit? tu)
 		{
 			if (tu == null || tu.IsEmpty)
-				return false;
+				return null;
 
-			bool lockTaken = false;
 			string key;
+			bool lockTaken = false;
 			try
 			{
 				_transUnitIdLock.Enter(ref lockTaken);
@@ -139,18 +143,18 @@ internal bool AddTransUnitRaw(XLiffTransUnit tu)
 				// it into the dictionary. This assumes nothing else modifies IDs once they
 				// are in this system: once our locked code has given the TU an ID, any other
 				// thread will see that it is non-empty.
-				key = tu.Id;
-				if (string.IsNullOrEmpty(key))
+				key = tu.Id ?? "";
+				if (key.Length == 0)
 				{
-					tu.Id = (++_transUnitId).ToString();
-					key = tu.Id;
+					key = (++_transUnitId).ToString();
+					tu.Id = key;
 				}
 
 				// If a translation unit with the specified id already exists, then quit here.
 				// This check and the dictionary write must both happen inside the lock to avoid
 				// a TOCTOU race where two threads with the same ID both pass the check.
 				if (GetTransUnitForId(key) != null)
-					return false;
+					return null;
 				_transUnitDict[key] = tu;
 			}
 			finally
@@ -158,19 +162,21 @@ internal bool AddTransUnitRaw(XLiffTransUnit tu)
 				if (lockTaken) _transUnitIdLock.Exit(false);
 			}
 
-			return true;
+			return key;
 		}
 		public bool AddTransUnit(XLiffTransUnit tu)
 		{
-			if (!AddTransUnitRaw(tu))
+			// Use inserted key (not tu.Id), so TranslationsById and _transUnitDict can't drift.
+			var id = AddTransUnitRaw(tu);
+			if (id == null)
 				return false;
 
 			// If the target exists, store its value in the dictionary lookup.  Otherwise, store
 			// the source value there.
 			if (tu.Target?.Value != null)
-				TranslationsById[tu.Id] = tu.Target.Value;
+				TranslationsById[id] = tu.Target.Value;
 			else if (tu.Source?.Value != null)
-				TranslationsById[tu.Id] = tu.Source.Value;
+				TranslationsById[id] = tu.Source.Value;
 			return true;
 		}
 
@@ -185,10 +191,12 @@ internal void AddTransUnitOrVariantFromExisting(XLiffTransUnit tu, string langId
 		{
 			var variantToAdd = tu.GetVariantForLang(langId);
 
-			if (variantToAdd == null || AddTransUnit(tu))
+			if (variantToAdd == null || AddTransUnit(tu) || tu.Id == null)
 				return;
 
 			var existingTu = GetTransUnitForId(tu.Id);
+			if (existingTu == null)
+				return;
 
 			//notice, we don't care if there is already a string in there for this language
 			//(that was the cause of a previous bug), because the XLiff of language X should
@@ -237,12 +245,12 @@ internal int NumberTranslated
 							if (string.IsNullOrWhiteSpace(tu.Target?.Value))
 								continue;
 							if (tu.TranslationStatus == TranslationStatus.Approved ||
-							    tu.Target.TargetState == XLiffTransUnitVariant.TranslationState.Translated)
+							    tu.Target!.TargetState == XLiffTransUnitVariant.TranslationState.Translated)
 							{
 								++_translatedCount;
 							}
 							else if (!string.IsNullOrWhiteSpace(tu.Source?.Value) &&
-							         tu.Target.Value != tu.Source.Value &&
+							         tu.Target.Value != tu.Source?.Value &&
 							         tu.Target.TargetState == XLiffTransUnitVariant.TranslationState.Undefined)
 							{
 								++_translatedCount;
diff --git a/src/L10NSharp/XLiffUtils/XLiffDocument.cs b/src/L10NSharp/XLiffUtils/XLiffDocument.cs
index 2ae56d7..a24d1d6 100644
--- a/src/L10NSharp/XLiffUtils/XLiffDocument.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffDocument.cs
@@ -59,7 +59,7 @@ public XLiffDocument()
 		/// Gets the translation unit for the specified id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public XLiffTransUnit GetTransUnitForId(string id)
+		public XLiffTransUnit? GetTransUnitForId(string id)
 		{
 			return File.Body.GetTransUnitForId(id);
 		}
@@ -82,7 +82,9 @@ public IEnumerable<XLiffTransUnit> GetTransUnitsForTextInLang(string langId, str
 		/// ------------------------------------------------------------------------------------
 		public bool AddTransUnit(ITransUnit tu)
 		{
-			return File.Body.AddTransUnit(tu as XLiffTransUnit);
+			if (tu is not XLiffTransUnit xliffTu)
+				return false;
+			return File.Body.AddTransUnit(xliffTu);
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -90,9 +92,10 @@ public bool AddTransUnit(ITransUnit tu)
 		/// Remove the specified translation unit.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public void RemoveTransUnit(ITransUnit tu)
+		public void RemoveTransUnit(ITransUnit? tu)
 		{
-			File.Body.RemoveTransUnit(tu as XLiffTransUnit);
+			if (tu is XLiffTransUnit xliffTu)
+				File.Body.RemoveTransUnit(xliffTu);
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -136,12 +139,14 @@ public static XLiffDocument Read(string xLiffFile)
 			if (!System.IO.File.Exists(xLiffFile))
 				throw new FileNotFoundException("XLiff file not found.", xLiffFile);
 
-			Exception e;
+			Exception? e;
 			var xLiffDoc =
 				XliffXmlSerializationHelper.DeserializeFromFile<XLiffDocument>(xLiffFile, out e);
 
 			if (e != null)
 				throw e;
+			if (xLiffDoc == null)
+				throw new InvalidOperationException("XLiff file could not be deserialized.", e);
 
 			// Fill in the fast lookup dictionary.
 			var langId = xLiffDoc.File.TargetLang;
@@ -149,7 +154,7 @@ public static XLiffDocument Read(string xLiffFile)
 				langId = xLiffDoc.File.SourceLang;
 			foreach (var tu in xLiffDoc.File.Body.TransUnitsUnordered)
 			{
-				if (xLiffDoc.File.Body.TranslationsById.ContainsKey(tu.Id))
+				if (xLiffDoc.File.Body.TranslationsById.ContainsKey(tu.Id!))
 				{
 					Console.WriteLine("WARNING: string ID \"{0}\" already found in \"{1}\".",
 						tu.Id, xLiffFile);
@@ -159,9 +164,9 @@ public static XLiffDocument Read(string xLiffFile)
 						!LocalizationManager.ReturnOnlyApprovedStrings ||
 						(tu.TranslationStatus == TranslationStatus.Approved))
 				{
-					var target = tu.GetVariantForLang(langId);
+					var target = tu.GetVariantForLang(langId!);
 					if (target != null && !string.IsNullOrEmpty(target.Value))
-						xLiffDoc.File.Body.TranslationsById[tu.Id] = target.Value;
+						xLiffDoc.File.Body.TranslationsById[tu.Id!] = target.Value;
 				}
 			}
 
@@ -178,7 +183,7 @@ public static XLiffDocument Read(string xLiffFile)
 		/// has an ID matching something in that. (This argument should always be supplied, but
 		/// for backwards compatibility we allow it to be omitted.)
 		/// </summary>
-		public XLiffTransUnit GetTransUnitForOrphan(XLiffTransUnit orphan, XLiffBody source = null)
+		public XLiffTransUnit? GetTransUnitForOrphan(XLiffTransUnit orphan, XLiffBody? source = null)
 		{
 			return File.Body.GetTransUnitForOrphan(orphan, source);
 		}
diff --git a/src/L10NSharp/XLiffUtils/XLiffFile.cs b/src/L10NSharp/XLiffUtils/XLiffFile.cs
index 1d6c09e..b416648 100644
--- a/src/L10NSharp/XLiffUtils/XLiffFile.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffFile.cs
@@ -21,7 +21,7 @@ public XLiffFile()
 			DataType = "plaintext";
 		}
 
-		protected XLiffHeader _header /* = new XLiffHeader()*/;
+		protected XLiffHeader? _header /* = new XLiffHeader()*/;
 		protected XLiffBody   _body = new XLiffBody();
 
 		#region Properties
@@ -32,7 +32,7 @@ public XLiffFile()
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlElement("header")]
-		public XLiffHeader Header
+		public XLiffHeader? Header
 		{
 			get => _header;
 			set => _header = value;
@@ -65,7 +65,7 @@ public XLiffBody Body
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("target-language")]
-		public string TargetLang { get; set; }
+		public string? TargetLang { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -81,7 +81,7 @@ public XLiffBody Body
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("original")]
-		public string Original { get; set; }
+		public string? Original { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -101,7 +101,7 @@ public XLiffBody Body
 		[XmlAttribute("hard-linebreak-replacement", Namespace =
 			XliffXmlSerializationHelper.kSilNamespace),
 		DefaultValue(LocalizedStringCache.kDefaultNewlineReplacement)]
-		public string HardLineBreakReplacement { get; set; }
+		public string? HardLineBreakReplacement { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -113,7 +113,7 @@ public XLiffBody Body
 		[XmlAttribute("ampersand-replacement", Namespace =
 			XliffXmlSerializationHelper.kSilNamespace),
 		DefaultValue(LocalizedStringCache.kDefaultAmpersandReplacement)]
-		public string AmpersandReplacement { get; set; }
+		public string? AmpersandReplacement { get; set; }
 
 		#endregion
 	}
diff --git a/src/L10NSharp/XLiffUtils/XLiffNote.cs b/src/L10NSharp/XLiffUtils/XLiffNote.cs
index 4efde28..b2bf0e1 100644
--- a/src/L10NSharp/XLiffUtils/XLiffNote.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffNote.cs
@@ -17,7 +17,7 @@ public class XLiffNote : XLiffBaseWithNotesAndProps
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("xml:lang")]
-		public string NoteLang { get; set; }
+		public string? NoteLang { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -25,7 +25,7 @@ public class XLiffNote : XLiffBaseWithNotesAndProps
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("from")]
-		public string From { get; set; }
+		public string? From { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -41,7 +41,7 @@ public class XLiffNote : XLiffBaseWithNotesAndProps
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("annotates")]
-		public string Annotates { get; set; }
+		public string? Annotates { get; set; }
 
 
 
@@ -51,7 +51,7 @@ public class XLiffNote : XLiffBaseWithNotesAndProps
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlText]
-		public string Text { get; set; }
+		public string? Text { get; set; }
 
 		#endregion
 
@@ -104,7 +104,7 @@ public static bool AddNote(string text, List<XLiffNote> noteList)
 		/// Adds the note.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public static bool AddNote(string lang, string text, List<XLiffNote> noteList)
+		public static bool AddNote(string? lang, string text, List<XLiffNote> noteList)
 		{
 			var note = new XLiffNote();
 			note.Text = text;
diff --git a/src/L10NSharp/XLiffUtils/XLiffProp.cs b/src/L10NSharp/XLiffUtils/XLiffProp.cs
index 3f702db..6d3ca46 100644
--- a/src/L10NSharp/XLiffUtils/XLiffProp.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffProp.cs
@@ -21,7 +21,7 @@ public class XLiffProp
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("type")]
-		public string Type { get; set; }
+		public string? Type { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -29,7 +29,7 @@ public class XLiffProp
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("xml:lang")]
-		public string Lang { get; set; }
+		public string? Lang { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -37,7 +37,7 @@ public class XLiffProp
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlText]
-		public string Value { get; set; }
+		public string? Value { get; set; }
 
 		#endregion
 
@@ -82,7 +82,7 @@ internal static bool AddProp(string type, string value, List<XLiffProp> propList
 		/// Adds a property.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		internal static bool AddProp(string lang, string type, string value, List<XLiffProp> propList)
+		internal static bool AddProp(string? lang, string type, string value, List<XLiffProp> propList)
 		{
 			var prop = new XLiffProp();
 			prop.Lang = lang;
diff --git a/src/L10NSharp/XLiffUtils/XLiffTargetVariant.cs b/src/L10NSharp/XLiffUtils/XLiffTargetVariant.cs
index a023d81..e4217f5 100644
--- a/src/L10NSharp/XLiffUtils/XLiffTargetVariant.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffTargetVariant.cs
@@ -16,7 +16,7 @@ public class XLiffTargetVariant : XLiffBaseWithNotesAndProps
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("xml:lang")]
-		public string Lang { get; set; }
+		public string? Lang { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -24,7 +24,7 @@ public class XLiffTargetVariant : XLiffBaseWithNotesAndProps
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlText]
-		public string Value { get; set; }
+		public string? Value { get; set; }
 
 		#endregion
 	}
diff --git a/src/L10NSharp/XLiffUtils/XLiffTransUnit.cs b/src/L10NSharp/XLiffUtils/XLiffTransUnit.cs
index ed5d7dd..57b8087 100644
--- a/src/L10NSharp/XLiffUtils/XLiffTransUnit.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffTransUnit.cs
@@ -24,7 +24,7 @@ public XLiffTransUnit()
 
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("id")]
-		public string Id { get; set; }
+		public string? Id { get; set; }
 
 		//  approved="yes"
 
@@ -59,7 +59,7 @@ public XLiffTransUnit()
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlElement("target")]
-		public XLiffTransUnitVariant Target { get; set; }
+		public XLiffTransUnitVariant? Target { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -83,7 +83,7 @@ public List<XLiffNote> Notes
 		/// <remarks>This appears to not be used in the Bloom files.</remarks>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("priority", Namespace = XliffXmlSerializationHelper.kSilNamespace)]
-		public string Priority { get; set; }
+		public string? Priority { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -93,7 +93,7 @@ public List<XLiffNote> Notes
 		/// <remarks>This appears to not be used in the Bloom files.</remarks>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("group", Namespace = XliffXmlSerializationHelper.kSilNamespace)]
-		public string Group { get; set; }
+		public string? Group { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -105,7 +105,7 @@ public List<XLiffNote> Notes
 		/// <remarks>This appears to not be used in the Bloom files.</remarks>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("category", Namespace = XliffXmlSerializationHelper.kSilNamespace)]
-		public string Category { get; set; }
+		public string? Category { get; set; }
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -143,7 +143,7 @@ public bool AddOrReplaceVariant(string langId, string value)
 		/// <param name="tuv">The variant.</param>
 		/// <returns>true if the variant was successfully added. Otherwise, false.</returns>
 		/// ------------------------------------------------------------------------------------
-		public bool AddOrReplaceVariant(XLiffTransUnitVariant tuv)
+		public bool AddOrReplaceVariant(XLiffTransUnitVariant? tuv)
 		{
 			if (tuv == null)
 				return false;
@@ -173,9 +173,9 @@ public void RemoveVariant(XLiffTransUnitVariant tuv)
 		/// Removes the variant for the specified language.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public void RemoveVariant(string langId)
+		public void RemoveVariant(string? langId)
 		{
-			XLiffTransUnitVariant tuv = GetVariantForLang(langId);
+			XLiffTransUnitVariant? tuv = GetVariantForLang(langId);
 			if (tuv != null)
 			{
 				if (langId == kDefaultLangId)
@@ -190,7 +190,7 @@ public void RemoveVariant(string langId)
 		/// Gets the translation unit variant for the specified language id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public XLiffTransUnitVariant GetVariantForLang(string langId)
+		public XLiffTransUnitVariant? GetVariantForLang(string? langId)
 		{
 			if (langId == kDefaultLangId)
 				return Source;
@@ -204,7 +204,7 @@ public XLiffTransUnitVariant GetVariantForLang(string langId)
 		/// ------------------------------------------------------------------------------------
 		public override string ToString()
 		{
-			return IsEmpty ? "Empty" : Id;
+			return IsNullOrEmpty(Id) ? "Empty" : Id!;
 		}
 
 		#endregion
diff --git a/src/L10NSharp/XLiffUtils/XLiffTransUnitVariant.cs b/src/L10NSharp/XLiffUtils/XLiffTransUnitVariant.cs
index 6ebf655..8d82c6a 100644
--- a/src/L10NSharp/XLiffUtils/XLiffTransUnitVariant.cs
+++ b/src/L10NSharp/XLiffUtils/XLiffTransUnitVariant.cs
@@ -21,7 +21,7 @@ public XLiffTransUnitVariant()
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
 		[XmlAttribute("xml:lang")]
-		public string Lang { get; set; }
+		public string? Lang { get; set; }
 
 		// Crowdin uses only "needs-translated" and "translated" as far as I can tell.  It appears to remove
 		// this attribute ("undefined") and use the "approved" attribute on the trans-unit element to
@@ -81,7 +81,7 @@ public enum TranslationState
 		[XmlAttribute("state"), System.ComponentModel.DefaultValue(TranslationState.Undefined)]
 		public TranslationState TargetState;
 
-		private string _value;
+		private string? _value;
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -110,7 +110,7 @@ public string Value
 					_deserializedFromElement = null;
 				}
 
-				return _value;
+				return _value ?? string.Empty;
 			}
 			set => _value = value;
 		}
@@ -119,7 +119,7 @@ public string Value
 		/// This is a temp value that allows complex input strings (with xliff-style html markup)
 		/// to be deserialized properly.
 		/// </summary>
-		private string _deserializedFromElement;
+		private string? _deserializedFromElement;
 
 		/// <summary>
 		/// Save the value deserialized from an element (and anything preceding it), and clear
diff --git a/src/L10NSharp/XLiffUtils/XliffLocalizationManager.cs b/src/L10NSharp/XLiffUtils/XliffLocalizationManager.cs
index 89b61ea..acbe56d 100644
--- a/src/L10NSharp/XLiffUtils/XliffLocalizationManager.cs
+++ b/src/L10NSharp/XLiffUtils/XliffLocalizationManager.cs
@@ -14,17 +14,18 @@ namespace L10NSharp.XLiffUtils
 	/// ----------------------------------------------------------------------------------------
 	internal class XliffLocalizationManager : ILocalizationManagerInternal<XLiffDocument>
 	{
-		public event EventHandler UiLanguageChanged;
+		public event EventHandler? UiLanguageChanged;
 
 		/// ------------------------------------------------------------------------------------
 		public const string FileExtension = ".xlf";
-		private readonly string _installedXliffFileFolder;
-		private readonly string _generatedDefaultXliffFileFolder;
-		private readonly string _customXliffFileFolder;
-		private readonly string _origExeExtension;
+		private readonly string? _installedXliffFileFolder;
+		private readonly string? _generatedDefaultXliffFileFolder;
+		private readonly string? _customXliffFileFolder;
+		private readonly string? _origExeExtension;
 		private readonly Version _appVersion;
+		private readonly ILocalizedStringCache<XLiffDocument>? _stringCache;
 
-		public Dictionary<IComponent, string> ComponentCache { get; }
+		public Dictionary<IComponent, string> ComponentCache { get; } = new Dictionary<IComponent, string>();
 
 		#region Static methods
 		/// ------------------------------------------------------------------------------------
@@ -83,7 +84,7 @@ public static void DeleteOldXliffFiles(string appId, string directoryOfWritableX
 		internal XliffLocalizationManager(string appId, string origExtension, string appName,
 			string appVersion, string directoryOfInstalledXliffFiles,
 			string directoryForGeneratedDefaultXliffFile, string directoryOfUserModifiedXliffFiles,
-			IEnumerable<MethodInfo> additionalLocalizationMethods,
+			IEnumerable<MethodInfo>? additionalLocalizationMethods,
 			params string[] namespaceBeginnings) : this(appId, appName ?? appId, appVersion)
 		{
 			// Test for a pathological case of bad install
@@ -95,7 +96,7 @@ internal XliffLocalizationManager(string appId, string origExtension, string app
 			_installedXliffFileFolder = directoryOfInstalledXliffFiles;
 			_generatedDefaultXliffFileFolder = directoryForGeneratedDefaultXliffFile;
 			DefaultStringFilePath = GetPathForLanguage(LocalizationManager.kDefaultLang,
-				false);
+				false) ?? throw new InvalidOperationException($"Default file path is null for language {LocalizationManager.kDefaultLang}");
 
 			CollectUpNewStringsDiscoveredDynamically = true;
 
@@ -105,8 +106,7 @@ internal XliffLocalizationManager(string appId, string origExtension, string app
 			if (string.IsNullOrEmpty(_customXliffFileFolder))
 				_customXliffFileFolder = null;
 
-			ComponentCache = new Dictionary<IComponent, string>();
-			StringCache = new XliffLocalizedStringCache(this);
+			_stringCache = new XliffLocalizedStringCache(this);
 		}
 
 		/// <summary>
@@ -145,7 +145,7 @@ internal XliffLocalizationManager(string appId, string appName, string appVersio
 
 		/// ------------------------------------------------------------------------------------
 		private void CreateOrUpdateDefaultXliffFileIfNecessary(
-			IEnumerable<MethodInfo> additionalLocalizationMethods,
+			IEnumerable<MethodInfo>? additionalLocalizationMethods,
 			params string[] namespaceBeginnings)
 		{
 			// Make sure the folder exists.
@@ -153,7 +153,7 @@ private void CreateOrUpdateDefaultXliffFileIfNecessary(
 			if (dir != null && !Directory.Exists(dir))
 				Directory.CreateDirectory(dir);
 
-			var defaultStringFileInstalledPath = Path.Combine(_installedXliffFileFolder,
+			var defaultStringFileInstalledPath = Path.Combine(_installedXliffFileFolder ?? throw new InvalidOperationException($"Installed file path is null"),
 				GetXliffFileNameForLanguage(LocalizationManager.kDefaultLang));
 
 			if (ScanningForCurrentStrings && DefaultStringFileExistsAndHasContents())
@@ -164,7 +164,7 @@ private void CreateOrUpdateDefaultXliffFileIfNecessary(
 
 			if (DefaultStringFileExistsAndHasContents())
 			{
-				XAttribute verAttribute = null;
+				XAttribute? verAttribute = null;
 				try
 				{
 					var xmlDoc = XElement.Load(DefaultStringFilePath);
@@ -183,8 +183,8 @@ private void CreateOrUpdateDefaultXliffFileIfNecessary(
 					Console.WriteLine("WARNING - L10NSharp Update deleted corrupted {0}", DefaultStringFilePath);
 				}
 				if (verAttribute != null &&
-				    Version.TryParse(verAttribute.Value, out var existingVer) &&
-				    existingVer >= _appVersion)
+					Version.TryParse(verAttribute.Value, out var existingVer) &&
+					existingVer >= _appVersion)
 				{
 					return;
 				}
@@ -206,10 +206,10 @@ private void CreateOrUpdateDefaultXliffFileIfNecessary(
 				else
 				{
 					stringCache.UpdateLocalizedInfo(new LocalizingInfo("_dummyEntryToGetValidFile")
-						{
-							LangId = "en",
-							Text = "No strings were collected. This entry prevents an invalid, zero-length file. Delete this file to try regenerating it."
-						}
+					{
+						LangId = "en",
+						Text = "No strings were collected. This entry prevents an invalid, zero-length file. Delete this file to try regenerating it."
+					}
 					);
 				}
 			}
@@ -218,8 +218,8 @@ private void CreateOrUpdateDefaultXliffFileIfNecessary(
 
 		public static List<string> ExtractionExceptions = new List<string>();
 
-		public static IReadOnlyList<LocalizingInfo> ExtractStringsFromCode(string name,
-			IEnumerable<MethodInfo> additionalLocalizationMethods, string[] namespaceBeginnings)
+		public static IReadOnlyList<LocalizingInfo>? ExtractStringsFromCode(string name,
+			IEnumerable<MethodInfo>? additionalLocalizationMethods, string[] namespaceBeginnings)
 		{
 			try
 			{
@@ -276,7 +276,7 @@ public void Dispose()
 		/// set of localized strings.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string OriginalExecutableFile => Id + _origExeExtension;
+		public string OriginalExecutableFile => Id + (_origExeExtension ?? string.Empty);
 
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
@@ -300,16 +300,21 @@ public void Dispose()
 		/// <summary>
 		/// Full file name and path to the default string file (i.e. English strings).
 		/// </summary>
+		/// <remarks>Empty for instances created by the minimal constructor.</remarks>
 		/// ------------------------------------------------------------------------------------
-		internal string DefaultStringFilePath { get; }
+		internal string DefaultStringFilePath { get; } = string.Empty;
 
 		internal string DefaultInstalledStringFilePath =>
-			Path.Combine(_installedXliffFileFolder,
+			Path.Combine(
+				_installedXliffFileFolder ?? throw new InvalidOperationException(
+					$"{nameof(DefaultInstalledStringFilePath)} is not available on a localization manager created without a folder of installed XLIFF files."),
 				LocalizationManager.GetTranslationFileNameForLanguage(Id,
 					LocalizationManager.kDefaultLang));
 
 		/// ------------------------------------------------------------------------------------
-		public ILocalizedStringCache<XLiffDocument> StringCache { get; }
+		public ILocalizedStringCache<XLiffDocument> StringCache =>
+			_stringCache ?? throw new InvalidOperationException(
+				"There is no string cache on a localization manager created by the minimal constructor.");
 
 
 		/// ------------------------------------------------------------------------------------
@@ -328,7 +333,7 @@ public IEnumerable<string> FilenamesToAddToCache
 			get
 			{
 				HashSet<string> langIdsOfCustomizedLocales = new HashSet<string>();
-				string langId;
+				string? langId;
 				if (_customXliffFileFolder != null && Directory.Exists(_customXliffFileFolder))
 				{
 					if (LocalizationManager.UseLanguageCodeFolders)
@@ -340,7 +345,7 @@ public IEnumerable<string> FilenamesToAddToCache
 							if (string.IsNullOrEmpty(langId) || langId == LocalizationManager.kDefaultLang)
 								continue;
 
-							langIdsOfCustomizedLocales.Add(langId);
+							langIdsOfCustomizedLocales.Add(langId!);
 							yield return xliffFile;
 						}
 					}
@@ -350,10 +355,10 @@ public IEnumerable<string> FilenamesToAddToCache
 							$"{Id}.*{FileExtension}"))
 						{
 							langId = GetLangIdFromXliffFileName(xliffFile);
-							if (langId == LocalizationManager.kDefaultLang)
+							if (string.IsNullOrEmpty(langId) || langId == LocalizationManager.kDefaultLang)
 								continue;
 
-							langIdsOfCustomizedLocales.Add(langId);
+							langIdsOfCustomizedLocales.Add(langId!);
 							yield return xliffFile;
 						}
 					}
@@ -369,9 +374,9 @@ public IEnumerable<string> FilenamesToAddToCache
 							if (string.IsNullOrEmpty(langId) || langId == LocalizationManager.kDefaultLang)
 								continue;
 
-							if (!langIdsOfCustomizedLocales.Contains(langId))
+							if (!langIdsOfCustomizedLocales.Contains(langId!))
 							{
-								langIdsOfCustomizedLocales.Add(langId);
+								langIdsOfCustomizedLocales.Add(langId!);
 								yield return xliffFile;
 							}
 						}
@@ -382,9 +387,14 @@ public IEnumerable<string> FilenamesToAddToCache
 							$"{Id}.*{FileExtension}"))
 						{
 							langId = GetLangIdFromXliffFileName(xliffFile);
-							if (langId != LocalizationManager.kDefaultLang &&    //Don't return the english Xliff here because we separately process it first.
-								!langIdsOfCustomizedLocales.Contains(langId))
+							if (string.IsNullOrEmpty(langId) || langId == LocalizationManager.kDefaultLang)
+								continue;
+
+							if (!langIdsOfCustomizedLocales.Contains(langId!))
+							{
+								langIdsOfCustomizedLocales.Add(langId!);
 								yield return xliffFile;
+							}
 						}
 					}
 				}
@@ -394,7 +404,7 @@ public IEnumerable<string> FilenamesToAddToCache
 
 		#region Methods for caching and localizing objects.
 		/// ------------------------------------------------------------------------------------
-		public void SaveIfDirty(ICollection<string> langIdsToForceCreate)
+		public void SaveIfDirty(ICollection<string>? langIdsToForceCreate)
 		{
 			try
 			{
@@ -408,7 +418,7 @@ public void SaveIfDirty(ICollection<string> langIdsToForceCreate)
 		}
 
 		/// ------------------------------------------------------------------------------------
-		internal static string GetLangIdFromXliffFileName(string fileName)
+		internal static string? GetLangIdFromXliffFileName(string fileName)
 		{
 			if (LocalizationManager.UseLanguageCodeFolders)
 			{
@@ -427,11 +437,11 @@ private string GetXliffFileNameForLanguage(string langId)
 		}
 
 		/// ------------------------------------------------------------------------------------
-		public string GetPathForLanguage(string langId, bool getCustomPathEvenIfNonexistent)
+		public string? GetPathForLanguage(string langId, bool getCustomPathEvenIfNonexistent)
 		{
 			var filename = GetXliffFileNameForLanguage(langId);
 			if (langId == LocalizationManager.kDefaultLang)
-				return Path.Combine(_generatedDefaultXliffFileFolder, filename);
+				return Path.Combine(_generatedDefaultXliffFileFolder ?? throw new InvalidOperationException($"Generated default file path is null for language {langId}"), filename);
 			if (_customXliffFileFolder != null)
 			{
 				var customXliffFile = Path.Combine(_customXliffFileFolder, filename);
@@ -488,7 +498,7 @@ public string GetLocalizedString(IComponent component, string id, string default
 		/// Gets the localized text for the specified id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetLocalizedString(string id, string defaultText)
+		public string GetLocalizedString(string id, string? defaultText)
 		{
 			// For the pseudo-locale, pseudolocalize the English text (the code-supplied default
 			// wins over the cache, as for English).
@@ -496,16 +506,17 @@ public string GetLocalizedString(string id, string defaultText)
 			{
 				return PseudoLocalization.Transform(
 					LocalizationManager.StripOffLocalizationInfoFromText(defaultText) ??
-					GetStringFromStringCache(LocalizationManager.kDefaultLang, id));
+					GetStringFromStringCache(LocalizationManager.kDefaultLang, id) ??
+					string.Empty);
 			}
 
 			var text = (UILanguageId != LocalizationManager.kDefaultLang ? GetStringFromStringCache(UILanguageId, id) : null);
 
-			return text ?? LocalizationManager.StripOffLocalizationInfoFromText(defaultText);
+			return text ?? LocalizationManager.StripOffLocalizationInfoFromText(defaultText) ?? string.Empty;
 		}
 
 		/// ------------------------------------------------------------------------------------
-		public string GetStringFromStringCache(string uiLangId, string id)
+		public string? GetStringFromStringCache(string uiLangId, string id)
 		{
 			// There is no cache for the pseudo-locale (no files exist for it), so derive it from
 			// the English entry. Doing it here rather than only in GetLocalizedString matters
@@ -522,7 +533,7 @@ public string GetStringFromStringCache(string uiLangId, string id)
 		}
 
 		/// ------------------------------------------------------------------------------------
-		protected string GetTooltipFromStringCache(string uiLangId, string id)
+		protected string? GetTooltipFromStringCache(string uiLangId, string id)
 		{
 			// See GetStringFromStringCache: same story for the tooltips of designer-created
 			// controls.
@@ -622,22 +633,27 @@ internal static XLiffDocument MergeXliffDocuments(XLiffDocument xliffNew, XLiffD
 			foreach (var tu in xliffNew.File.Body.TransUnitsUnordered)
 			{
 				xliffOutput.File.Body.AddTransUnit(tu);
+				var id = tu.Id;
+				// AddTransUnit assigns an Id unless the unit is entirely empty.
+				if (id == null)
+					continue;
+
 				if (tu.Dynamic)
 					++newDynamicCount;
 				if (xliffOld != null)
 				{
-					var tuOld = xliffOld.File.Body.GetTransUnitForId(tu.Id);
+					var tuOld = xliffOld.File.Body.GetTransUnitForId(id);
 					if (tuOld == null)
 					{
 						++newStringCount;
-						newStringIds.Add(tu.Id);
+						newStringIds.Add(id);
 					}
 					else
 					{
 						foreach (var note in tuOld.Notes)
 						{
 							// Skip "Not found[...]" notes — the string IS found in this run.
-							if (note.Text.StartsWith("Not found"))
+							if (note.Text != null && note.Text.StartsWith("Not found"))
 								continue;
 							bool haveAlready = false;
 							foreach (var newNote in tu.Notes)
@@ -650,23 +666,23 @@ internal static XLiffDocument MergeXliffDocuments(XLiffDocument xliffNew, XLiffD
 							}
 							if (!haveAlready)
 							{
-								if (note.Text.StartsWith("[OLD NOTE]") || note.Text.StartsWith("OLD TEXT"))
+								if (note.Text != null && (note.Text.StartsWith("[OLD NOTE]") || note.Text.StartsWith("OLD TEXT")))
 									tu.AddNote(note.NoteLang, note.Text);
-								else
+								else if (note.Text != null)
 									tu.AddNote(note.NoteLang, "[OLD NOTE] " + note.Text);
 							}
 						}
 						if (tu.Source?.Value != tuOld.Source?.Value)
 						{
 							++changedStringCount;
-							changedStringIds.Add(tu.Id);
+							changedStringIds.Add(id);
 							if (!string.IsNullOrWhiteSpace(tuOld.Source?.Value))
-								tu.AddNote("en", $"OLD TEXT (before {xliffNew.File.ProductVersion}): {tuOld.Source.Value}");
+								tu.AddNote("en", $"OLD TEXT (before {xliffNew.File.ProductVersion}): {tuOld.Source!.Value}");
 						}
 						if (tuOld.Dynamic && !tu.Dynamic)
 						{
 							++wrongDynamicFlagCount;
-							wrongDynamicStringIds.Add(tu.Id);
+							wrongDynamicStringIds.Add(id);
 							tu.AddNote("en", $"Not dynamic: found in static scan of compiled code (version {xliffNew.File.ProductVersion})");
 						}
 					}
@@ -683,21 +699,26 @@ internal static XLiffDocument MergeXliffDocuments(XLiffDocument xliffNew, XLiffD
 					if (tuNew == null)
 					{
 						xliffOutput.File.Body.AddTransUnit(tu);
+						var id = tu.Id;
+						// AddTransUnit assigns an Id unless the unit is entirely empty.
+						if (id == null)
+							continue;
+
 						if (tu.Dynamic)
 						{
 							++missingDynamicStringCount;
-							missingDynamicStringIds.Add(tu.Id);
+							missingDynamicStringIds.Add(id);
 							if (newDynamicCount > 0) // note only if attempt made to collect dynamic strings
 							{
-								tu.Notes.RemoveAll(n => n.Text.StartsWith("Not found"));
+								tu.Notes.RemoveAll(n => n.Text != null && n.Text.StartsWith("Not found"));
 								tu.AddNote("en", $"Not found when running compiled program (version {xliffNew.File.ProductVersion})");
 							}
 						}
 						else
 						{
 							++missingStringCount;
-							missingStringIds.Add(tu.Id);
-							tu.Notes.RemoveAll(n => n.Text.StartsWith("Not found"));
+							missingStringIds.Add(id);
+							tu.Notes.RemoveAll(n => n.Text != null && n.Text.StartsWith("Not found"));
 							tu.AddNote("en", $"Not found in static scan of compiled code (version {xliffNew.File.ProductVersion})");
 						}
 					}
@@ -772,7 +793,7 @@ public IEnumerable<string> GetAvailableUILanguageTags()
 		/// If the given file exists, return its parent folder name as a language tag if it
 		/// appears to be valid (2 or 3 letters long or "zh-CN"). Otherwise, return <c>null</c>.
 		/// </summary>
-		private static string GetLanguageTagFromFilePath(string xliffFile)
+		private static string? GetLanguageTagFromFilePath(string xliffFile)
 		{
 			Debug.Assert(LocalizationManager.UseLanguageCodeFolders);
 			if (!File.Exists(xliffFile))
diff --git a/src/L10NSharp/XLiffUtils/XliffLocalizedStringCache.cs b/src/L10NSharp/XLiffUtils/XliffLocalizedStringCache.cs
index 93f6766..d02a18e 100644
--- a/src/L10NSharp/XLiffUtils/XliffLocalizedStringCache.cs
+++ b/src/L10NSharp/XLiffUtils/XliffLocalizedStringCache.cs
@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Security;
@@ -51,6 +52,8 @@ internal XliffLocalizedStringCache(ILocalizationManager owningManager, bool load
 					Console.WriteLine("Error occurred reading localization file:");
 					Console.WriteLine(e.Message);
 					LocalizationManager.SetUILanguage(LocalizationManager.kDefaultLang);
+					if (DefaultXliffDocument is null)
+						throw new InvalidOperationException("DefaultXliffDocument could not be loaded", e);
 				}
 			}
 			else
@@ -72,13 +75,13 @@ internal XliffLocalizedStringCache(ILocalizationManager owningManager, bool load
 			IsDirty = false;
 		}
 
-		internal XLiffDocument GetDocument(string langId)
+		internal XLiffDocument? GetDocument(string langId)
 		{
-			TryGetDocument(langId, out XLiffDocument doc);
+			TryGetDocument(langId, out XLiffDocument? doc);
 			return doc;
 		}
 
-		public bool TryGetDocument(string langId, out XLiffDocument doc)
+		public bool TryGetDocument(string langId, [NotNullWhen(true)] out XLiffDocument? doc)
 		{
 			// It's tempting to try to do this with the ConcurrentDictionary method GetOrAdd.
 			// But it's not guaranteed that the doc which LoadXLiff loads will be put in
@@ -121,6 +124,7 @@ internal void AddDocument(string langId, XLiffDocument doc)
 		/// <summary>
 		/// May only be called from constructor. Not thread-safe.
 		/// </summary>
+		[MemberNotNull(nameof(DefaultXliffDocument))]
 		private void MergeXliffFilesIntoCache(IEnumerable<string> xliffFiles)
 		{
 			DefaultXliffDocument = XLiffDocument.Read(OwningManager.DefaultStringFilePath); // read the generated file
@@ -149,7 +153,7 @@ private void MergeXliffFilesIntoCache(IEnumerable<string> xliffFiles)
 				var langId = XliffLocalizationManager.GetLangIdFromXliffFileName(file);
 				Debug.Assert(!string.IsNullOrEmpty(langId));
 				Debug.Assert(langId != LocalizationManager.kDefaultLang);
-				_unloadedXliffDocuments[langId] = file;
+				_unloadedXliffDocuments[langId!] = file;
 			}
 		}
 
@@ -192,6 +196,8 @@ private void LoadXliffAndUpdateExistingLanguageMap(string langId)
 
 			// This might be different, typically more specific, than the name we deduced from the file path.
 			var targetLang = xliffDoc.File.TargetLang;
+            if (targetLang is null)
+                throw new InvalidOperationException($"Target language not found in {file}");
 
 			// Now we have some maintenance to do on MapToExistingLanguage, which does not yet contain data
 			// about this file. It is definitely the one to use for targetLanguage.
@@ -227,6 +233,8 @@ private void LoadXliffAndUpdateExistingLanguageMap(string langId)
 			var defunctUnits = new List<XLiffTransUnit>();
 			foreach (var tu in xliffDoc.File.Body.TransUnitsUnordered.ToList()) // need a list here because we may modify it while enumerating
 			{
+                if (tu.Id is null)
+                    throw new InvalidOperationException($"Translation unit ID is null in {file}");
 				// This block attempts to find 'orphans', that is, localizations that have been done using an obsolete ID.
 				// We assume the default language Xliff has only current IDs, and therefore don't look for orphans in that case.
 				// This guards against cases such as recently occurred in Bloom, where a dynamic ID EditTab.AddPageDialog.Title
@@ -251,7 +259,7 @@ private void LoadXliffAndUpdateExistingLanguageMap(string langId)
 						if (xliffDoc.File.Body.TranslationsById.ContainsKey(tu.Id))
 						{
 							// adjust the document's internal cache
-							xliffDoc.File.Body.TranslationsById[movedUnit.Id] =
+							xliffDoc.File.Body.TranslationsById[movedUnit.Id!] =
 								xliffDoc.File.Body.TranslationsById[tu.Id];
 							xliffDoc.File.Body.TranslationsById.TryRemove(tu.Id, out _);
 						}
@@ -326,12 +334,12 @@ internal void SaveIfDirty()
 		/// Otherwise, false is returned.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		internal void SaveIfDirty(ICollection<string> langIdsToForceCreate)
+		internal void SaveIfDirty(ICollection<string>? langIdsToForceCreate)
 		{
 			if (!IsDirty)
 				return;
 
-			StringBuilder errorMsg = null;
+			StringBuilder? errorMsg = null;
 			foreach (var langId in XliffDocuments.Keys)
 			{
 				try
@@ -381,8 +389,8 @@ private void SaveFileForLangId(string langId, bool forceCreation, XLiffDocument
 
 			foreach (var tu in DefaultXliffDocument.File.Body.TransUnitsUnordered)
 			{
-				var tuTarget = xliffOriginal.File.Body.GetTransUnitForId(tu.Id);
-				XLiffTransUnitVariant tuv = null;
+				var tuTarget = xliffOriginal.File.Body.GetTransUnitForId(tu.Id!);
+				XLiffTransUnitVariant? tuv = null;
 				if (tuTarget != null)
 					tuv = tuTarget.GetVariantForLang(langId);
 				// REVIEW: should we write units with no translation (target)?
@@ -393,7 +401,10 @@ private void SaveFileForLangId(string langId, bool forceCreation, XLiffDocument
 				newTu.Notes = tu.CopyNotes();
 				xliffOutput.AddTransUnit(newTu);
 			}
-			xliffOutput.Save(OwningManager.GetPathForLanguage(langId, true));
+			var outputPath = OwningManager.GetPathForLanguage(langId, true);
+			if (outputPath == null)
+                throw new InvalidOperationException($"Output path is null for language {langId}");
+			xliffOutput.Save(outputPath);
 		}
 		#endregion
 
@@ -402,7 +413,7 @@ private void SaveFileForLangId(string langId, bool forceCreation, XLiffDocument
 		/// Compares two translation units for equality.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		internal static int TuComparer(XLiffTransUnit tu1, XLiffTransUnit tu2)
+		internal static int TuComparer(XLiffTransUnit? tu1, XLiffTransUnit? tu2)
 		{
 			if (tu1 == null && tu2 == null)
 				return 0;
@@ -413,11 +424,11 @@ internal static int TuComparer(XLiffTransUnit tu1, XLiffTransUnit tu2)
 			if (tu2 == null)
 				return 1;
 
-			string x = tu1.Group;
-			string y = tu2.Group;
+			string? x = tu1.Group;
+			string? y = tu2.Group;
 
 			if (x == y)
-				return string.CompareOrdinal(tu1.Id, tu2.Id);
+				return string.CompareOrdinal(tu1.Id ?? string.Empty, tu2.Id ?? string.Empty);
 
 			if (x == null)
 				return -1;
@@ -450,7 +461,7 @@ public bool DoTranslationsExist(string langId, string id)
 		/// Gets the localized text for the specified id and suffix.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetString(string langId, string id)
+		public string? GetString(string langId, string id)
 		{
 			return GetValueForLangAndIdWithFallback(langId, id);
 		}
@@ -462,7 +473,7 @@ public string GetString(string langId, string id)
 		/// is displayed nicely at runtime.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetString(string langId, string id, bool formatForDisplay)
+		public string? GetString(string langId, string id, bool formatForDisplay)
 		{
 			return GetValueForExactLangAndId(langId, id, formatForDisplay);
 		}
@@ -472,7 +483,7 @@ public string GetString(string langId, string id, bool formatForDisplay)
 		/// Gets the localized tooltip text for the specified id and suffix.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetToolTipText(string langId, string id)
+		public string? GetToolTipText(string langId, string id)
 		{
 			return GetValueForLangAndIdWithFallback(langId, id + kToolTipSuffix);
 		}
@@ -484,7 +495,7 @@ public string GetToolTipText(string langId, string id)
 		/// converted so the text is displayed nicely at runtime.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetToolTipText(string langId, string id, bool formatForDisplay)
+		public string? GetToolTipText(string langId, string id, bool formatForDisplay)
 		{
 			return GetValueForExactLangAndId(langId, id + kToolTipSuffix, formatForDisplay);
 		}
@@ -494,7 +505,7 @@ public string GetToolTipText(string langId, string id, bool formatForDisplay)
 		/// Gets the localized tooltip text for the specified id and suffix.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetShortcutKeysText(string langId, string id)
+		public string? GetShortcutKeysText(string langId, string id)
 		{
 			return GetValueForExactLangAndId(langId, id + kShortcutSuffix, false);
 		}
@@ -506,7 +517,7 @@ public string GetShortcutKeysText(string langId, string id)
 		/// fails, then the default (i.e. "en") is used.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		protected string GetValueForLangAndIdWithFallback(string langId, string id)
+		protected string? GetValueForLangAndIdWithFallback(string langId, string id)
 		{
 			var value = GetValueForExactLangAndId(langId, id, true);
 			if (value != null)
@@ -529,7 +540,7 @@ protected string GetValueForLangAndIdWithFallback(string langId, string id)
 		/// nicely at runtime.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		public string GetValueForExactLangAndId(string langId, string id, bool formatForDisplay)
+		public string? GetValueForExactLangAndId(string langId, string id, bool formatForDisplay)
 		{
 			if (string.IsNullOrEmpty(langId) || string.IsNullOrEmpty(id))
 				return null;
@@ -578,10 +589,9 @@ public string GetValueForExactLangAndId(string langId, string id, bool formatFor
 		/// considered the "comment" if it exists.
 		/// </remarks>
 		/// ------------------------------------------------------------------------------------
-		public string GetComment(string id)
+		public string? GetComment(string id)
 		{
-			XLiffTransUnit tu = DefaultXliffDocument.GetTransUnitForId(id);
-			return (tu == null ? null : tu.GetComment());
+			return DefaultXliffDocument.GetTransUnitForId(id)?.GetComment();
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -589,10 +599,9 @@ public string GetComment(string id)
 		/// Gets the group for the specified id.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		internal string GetGroup(string id)
+		internal string? GetGroup(string id)
 		{
-			XLiffTransUnit tu = DefaultXliffDocument.GetTransUnitForId(id);
-			return (tu == null ? null : tu.Group);
+			return DefaultXliffDocument.GetTransUnitForId(id)?.Group;
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -602,7 +611,7 @@ internal string GetGroup(string id)
 		/// ------------------------------------------------------------------------------------
 		internal LocalizationPriority GetPriority(string id)
 		{
-			XLiffTransUnit tu = DefaultXliffDocument.GetTransUnitForId(id);
+			XLiffTransUnit? tu = DefaultXliffDocument.GetTransUnitForId(id);
 			if (tu != null)
 			{
 				if (string.IsNullOrEmpty(tu.Priority))
@@ -610,7 +619,7 @@ internal LocalizationPriority GetPriority(string id)
 
 				try
 				{
-					return (LocalizationPriority)Enum.Parse(typeof(LocalizationPriority), tu.Priority);
+					return (LocalizationPriority)Enum.Parse(typeof(LocalizationPriority), tu.Priority!);
 				}
 				catch { }
 			}
@@ -624,10 +633,10 @@ internal LocalizationPriority GetPriority(string id)
 		/// ------------------------------------------------------------------------------------
 		internal LocalizationCategory GetCategory(string id)
 		{
-			XLiffTransUnit tu = DefaultXliffDocument.GetTransUnitForId(id);
+			XLiffTransUnit? tu = DefaultXliffDocument.GetTransUnitForId(id);
 			if (tu != null)
 			{
-				string category = tu.Category;
+				string? category = tu.Category;
 				if (string.IsNullOrEmpty(category))
 					return LocalizationCategory.DontCare;
 
@@ -681,6 +690,8 @@ protected IEnumerable<XLiffTransUnit> GetTranslationUnitsForTree()
 		{
 			foreach (var tu in DefaultXliffDocument.File.Body.TransUnitsUnordered)
 			{
+                if (tu.Id is null)
+					throw new InvalidOperationException("Translation unit ID is null in DefaultXliffDocument");
 				// If the translation unit is not for a tooltip or shortcutkey, then return it.
 				if (!tu.Id.EndsWith(kToolTipSuffix) && !tu.Id.EndsWith(kShortcutSuffix))
 					yield return tu;
@@ -732,9 +743,11 @@ protected static List<string> ParseGroupAndId(string group, string id)
 			return allPieces;
 		}
 
-		public static string GetTerminalIdPart(string id)
+		public static string GetTerminalIdPart(string? id)
 		{
-			var pieces = id.Split('.');
+			if (string.IsNullOrEmpty(id))
+				return "";
+			var pieces = id!.Split('.');
 			if (pieces.Length == 0)
 				return "";
 			return pieces.Last();
@@ -752,7 +765,7 @@ internal static bool CheckForValidSubstitutionMarkers(int markersCount, string t
 		{
 			try
 			{
-				string s = null;
+				string? s = null;
 				switch (markersCount)
 				{
 					case 0:
diff --git a/src/L10NSharp/XLiffUtils/XliffTransUnitUpdater.cs b/src/L10NSharp/XLiffUtils/XliffTransUnitUpdater.cs
index ca96816..371a7a0 100644
--- a/src/L10NSharp/XLiffUtils/XliffTransUnitUpdater.cs
+++ b/src/L10NSharp/XLiffUtils/XliffTransUnitUpdater.cs
@@ -27,7 +27,7 @@ internal XliffTransUnitUpdater(XliffLocalizedStringCache cache)
 		{
 			_stringCache = cache;
 			_defaultLang = LocalizationManager.kDefaultLang;
-			var replacement = _stringCache.GetDocument(_defaultLang).File
+			var replacement = _stringCache.GetDocument(_defaultLang)?.File
 				.HardLineBreakReplacement;
 			if (replacement != null)
 				_literalNewline = replacement;
@@ -49,10 +49,10 @@ internal bool Update(LocalizingInfo locInfo)
 			if (string.IsNullOrWhiteSpace(locInfo.Id))
 				return _updated;
 
-			var xliffSource = _stringCache.GetDocument(_defaultLang);
-			Debug.Assert(xliffSource != null);
+			if (!_stringCache.TryGetDocument(_defaultLang, out var xliffSource))
+                throw new InvalidOperationException($"Source document for default language {_defaultLang} not found");
 
-			if (!_stringCache.TryGetDocument(locInfo.LangId, out var xliffTarget))
+			if (!_stringCache.TryGetDocument(locInfo.LangId!, out var xliffTarget))
 			{
 				xliffTarget = new XLiffDocument();
 				xliffTarget.File.AmpersandReplacement = xliffSource.File.AmpersandReplacement;
@@ -65,10 +65,10 @@ internal bool Update(LocalizingInfo locInfo)
 				xliffTarget.File.TargetLang = locInfo.LangId;
 				xliffTarget.IsDirty = true;
 				_updated = true;
-				_stringCache.AddDocument(locInfo.LangId, xliffTarget);
+				_stringCache.AddDocument(locInfo.LangId!, xliffTarget);
 			}
 
-			var tuSourceText = xliffSource.GetTransUnitForId(locInfo.Id);
+			var tuSourceText = xliffSource.GetTransUnitForId(locInfo.Id!);
 			var tuSourceToolTip = xliffSource.GetTransUnitForId(locInfo.Id + kToolTipSuffix);
 			var tuSourceShortcutKeys =
 				xliffSource.GetTransUnitForId(locInfo.Id + kShortcutSuffix);
@@ -116,7 +116,7 @@ internal bool Update(LocalizingInfo locInfo)
 				text = text.Replace(_literalNewline, "@#$");
 				text = text.Replace(kOSRealNewline, _literalNewline);
 				text = text.Replace("@#$", _literalNewline);
-				UpdateValueAndComment(xliffTarget, tuSourceText, text, locInfo, locInfo.Id);
+				UpdateValueAndComment(xliffTarget, tuSourceText, text, locInfo, locInfo.Id!);
 			}
 
 			if (_updated)
@@ -124,15 +124,15 @@ internal bool Update(LocalizingInfo locInfo)
 			return _updated;
 		}
 
-		void UpdateValueAndComment(XLiffDocument xliffTarget, XLiffTransUnit tuSource,
-			string                               newText,     LocalizingInfo locInfo, string tuId)
+		void UpdateValueAndComment(XLiffDocument xliffTarget, XLiffTransUnit? tuSource,
+			string?                               newText,     LocalizingInfo locInfo, string tuId)
 		{
 			var tuTarget = UpdateValue(xliffTarget, tuSource, newText, locInfo, tuId);
 			UpdateTransUnitComment(xliffTarget, tuSource, locInfo);
 			UpdateTransUnitComment(xliffTarget, tuTarget, locInfo);
 		}
 
-		private void UpdateTransUnitComment(XLiffDocument xliffTarget, XLiffTransUnit tu,
+		private void UpdateTransUnitComment(XLiffDocument xliffTarget, XLiffTransUnit? tu,
 			LocalizingInfo                                locInfo)
 		{
 			if (tu == null)
@@ -155,7 +155,7 @@ private void UpdateTransUnitComment(XLiffDocument xliffTarget, XLiffTransUnit tu
 			tu.Notes.Clear();
 			tu.AddNote("ID: " + tu.Id);
 			if (!string.IsNullOrEmpty(locInfo.Comment))
-				tu.AddNote(locInfo.Comment);
+				tu.AddNote(locInfo.Comment!);
 		}
 
 		/// ------------------------------------------------------------------------------------
@@ -163,8 +163,8 @@ private void UpdateTransUnitComment(XLiffDocument xliffTarget, XLiffTransUnit tu
 		/// Updates the value for the specified translation unit with the specified new value.
 		/// </summary>
 		/// ------------------------------------------------------------------------------------
-		private XLiffTransUnit UpdateValue(XLiffDocument xliffTarget, XLiffTransUnit tuSource,
-			string                                       newValue,    LocalizingInfo locInfo,
+		private XLiffTransUnit? UpdateValue(XLiffDocument xliffTarget, XLiffTransUnit? tuSource,
+			string?                                       newValue,    LocalizingInfo locInfo,
 			string                                       tuId)
 		{
 			// One would think there would be a source XLiffTransUnit, but that isn't necessarily true
@@ -226,8 +226,8 @@ private XLiffTransUnit UpdateValue(XLiffDocument xliffTarget, XLiffTransUnit tuS
 				tuTarget.AddNote("ID: " + tuId);
 			}
 
-			tuTarget.AddOrReplaceVariant(locInfo.LangId, newValue);
-			xliffTarget.File.Body.TranslationsById[tuId] = newValue;
+			tuTarget.AddOrReplaceVariant(locInfo.LangId!, newValue!);
+			xliffTarget.File.Body.TranslationsById[tuId] = newValue!;
 			_updated = true;
 			return tuTarget;
 		}
diff --git a/src/L10NSharp/XLiffUtils/XliffXmlSerializationHelper.cs b/src/L10NSharp/XLiffUtils/XliffXmlSerializationHelper.cs
index 781b526..696fd4c 100644
--- a/src/L10NSharp/XLiffUtils/XliffXmlSerializationHelper.cs
+++ b/src/L10NSharp/XLiffUtils/XliffXmlSerializationHelper.cs
@@ -126,7 +126,7 @@ public static bool SerializeToFile<T>(string filename, T data)
 		/// <param name="filename">The filename from which to load</param>
 		/// <param name="e">The exception generated during the deserialization.</param>
 		/// ------------------------------------------------------------------------------------
-		public static T DeserializeFromFile<T>(string filename, out Exception e) where T : class
+		public static T? DeserializeFromFile<T>(string filename, out Exception? e) where T : class
 		{
 			return DeserializeFromFile<T>(filename, false, out e);
 		}
@@ -142,10 +142,10 @@ public static T DeserializeFromFile<T>(string filename, out Exception e) where T
 		/// these elements will be ignored during a deserialization.</param>
 		/// <param name="e">The exception generated during the deserialization.</param>
 		/// ------------------------------------------------------------------------------------
-		public static T DeserializeFromFile<T>(string filename, bool fKeepWhitespaceInElements,
-			out Exception                             e) where T : class
+		public static T? DeserializeFromFile<T>(string filename, bool fKeepWhitespaceInElements,
+			out Exception?                             e) where T : class
 		{
-			T data = null;
+			T? data = null;
 			e = null;
 
 			try