// A normal looking string containing an invisible 0x01 character
string dirtyData = "Header" + (char)0x01 + "Details";

var item = list.GetItemById(1);
item["MyMultilineField"] = dirtyData; // BOOM. Fails here!
item.Update();
context.ExecuteQuery();

System.ArgumentException:
'
', hexadecimal value 0x01, is an invalid character.

Stacktrace:
   at System.Xml.XmlEncodedRawTextWriter.InvalidXmlChar(Int32 ch, Char* pDst, Boolean entitize)
   at System.Xml.XmlEncodedRawTextWriter.WriteElementTextBlock(Char* pSrc, Char* pSrcEnd)
   at System.Xml.XmlEncodedRawTextWriter.WriteString(String text)
   at System.Xml.XmlRawWriter.WriteValue(String value)
   at System.Xml.XmlWellFormedWriter.WriteValue(String value)
   at Microsoft.SharePoint.Client.DataConvert.WriteValue_Char(XmlWriter writer, Object objValue)
   at Microsoft.SharePoint.Client.DataConvert.WriteValueToXmlElement(XmlWriter writer, Object objValue, SerializationContext serializationContext)
   at Microsoft.SharePoint.Client.ClientActionInvokeMethod.WriteToXmlPrivate(XmlWriter writer, SerializationContext serializationContext)
   at Microsoft.SharePoint.Client.ClientActionInvokeMethod..ctor(ClientObject obj, String methodName, Object[] parameters)
   at Microsoft.SharePoint.Client.ListItem.SetFieldValue(String fieldName, Object value)
   at Microsoft.SharePoint.Client.ListItem.set_Item(String fieldName, Object value)

public class SharePointHooks
{
    // Call this once at startup (e.g., in Main)
    public static void ApplyHooks()
    {
        var harmony = new Harmony("com.example.sharepoint.hooks");
        harmony.PatchAll(Assembly.GetExecutingAssembly());
        Console.WriteLine("Hooks applied!");
    }
}

// 1. Tell Harmony which class and method to hook
[HarmonyPatch("Microsoft.SharePoint.Client.ChunkStringBuilder", "CreateXmlWriter")]
public class Patch_OverrideXmlSettings
{
    static bool Prefix(object __instance, ref XmlWriter __result)
    {
        try
        {
            // 1. Get the internal StringBuilder from the ChunkStringBuilder instance.
            // We use Harmony's AccessTools to find the private field.
            // Note: The field name is typically "m_sb" in SharePoint libraries, 
            // but we dynamically search for it just in case.

            var type = __instance.GetType();
            var sbField = AccessTools.Field(type, "m_sb");

            // Fallback: If "m_sb" isn't found, grab the first StringBuilder field we find.
            if (sbField == null)
            {
                foreach (var field in AccessTools.GetDeclaredFields(type))
                {
                    if (field.FieldType == typeof(StringBuilder))
                    {
                        sbField = field;
                        break;
                    }
                }
            }

            if (sbField == null)
                return true; // Run original method (fallback)

            // 2. Get the actual StringBuilder object instance
            StringBuilder internalSb = (StringBuilder)sbField.GetValue(__instance);

            // 3. Define your CUSTOM settings
            var settings = new XmlWriterSettings
            {
                CheckCharacters = false, // This is the fix we try (client-side)
                OmitXmlDeclaration = true,
                Indent = false,
                CloseOutput = false,
                ConformanceLevel = ConformanceLevel.Fragment
            };

            // 4. Create the new XmlWriter pointing to the internal StringBuilder
            // We wrap the StringBuilder in a StringWriter, then in the XmlWriter
            XmlWriter customWriter = XmlWriter.Create(new StringWriter(internalSb), settings);

            // 5. Set the result and skip the original method
            __result = customWriter;

            return false; // Skip the original method
        }
        catch (Exception ex)
        {
            Console.WriteLine($">> HOOK FAILED: {ex.Message}");
            return true; // On error, fall back to the original method
        }
    }
}

using System.Text;
using System.Net.Http;
using System.Net.Http.Headers;
using Newtonsoft.Json; // NuGet: Newtonsoft.Json
using System.Threading.Tasks;

public static async Task UpdateItemViaRest(string siteUrl, string accessToken, string listTitle, int itemId, object payload)
{
    using (var client = new HttpClient())
    {
        // 1. Setup the Endpoint
        string updateUrl = $"{siteUrl}/_api/web/lists/getbytitle('{listTitle}')/items({itemId})";

        // 2. Configure Headers
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        
        // IMPORTANT: These headers tell SharePoint this is an UPDATE, not a CREATE
        client.DefaultRequestHeaders.Add("IF-MATCH", "*"); // Overwrite changes. Use ETag if you care about concurrency.
        client.DefaultRequestHeaders.Add("X-HTTP-Method", "MERGE");

        // 3. Serialize the payload to JSON
        string jsonBody = JsonConvert.SerializeObject(payload);
        var content = new StringContent(jsonBody, Encoding.UTF8, "application/json");

        // 4. Send the Request
        // Note: We use PostAsync because X-HTTP-Method header handles the verb change
        var response = await client.PostAsync(updateUrl, content);

        if (!response.IsSuccessStatusCode)
        {
            string error = await response.Content.ReadAsStringAsync();
            throw new Exception($"REST Update Failed: {response.StatusCode} - {error}");
        }
    }
}