diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
index 2c7897748380f8..6e7c8c386ad2a0 100644
--- a/eng/pipelines/libraries/helix-queues-setup.yml
+++ b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -39,7 +39,7 @@ jobs:
     # Linux arm64
     - ${{ if eq(parameters.platform, 'Linux_arm64') }}:
       - ${{ if or(eq(parameters.jobParameters.isExtraPlatforms, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
-        - (Ubuntu.2110.Arm64.Open)Ubuntu.1804.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-21.10-helix-arm64v8-20211116135000-0f8d97e
+        - (Ubuntu.2204.Arm64.Open)Ubuntu.1804.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04-helix-arm64v8-20220504035342-1b9461f
       - ${{ if or(ne(parameters.jobParameters.isExtraPlatforms, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
         - (Ubuntu.1804.ArmArch.Open)Ubuntu.1804.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-20220427172132-97d8652
 
@@ -63,14 +63,14 @@ jobs:
           - RedHat.7.Amd64.Open
           - SLES.15.Amd64.Open
           - (Fedora.34.Amd64.Open)Ubuntu.1804.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:fedora-34-helix-20220523142223-4f64125
-          - (Ubuntu.2110.Amd64.Open)Ubuntu.1804.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-21.10-helix-amd64-20211116135132-0f8d97e
+          - (Ubuntu.2204.Amd64.Open)Ubuntu.1804.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04-helix-amd64-20220504035722-1b9461f
           - (Debian.10.Amd64.Open)Ubuntu.1804.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-10-helix-amd64-bfcd90a-20200121150006
         - ${{ if or(ne(parameters.jobParameters.testScope, 'outerloop'), ne(parameters.jobParameters.runtimeFlavor, 'mono')) }}:
           - ${{ if or(eq(parameters.jobParameters.isExtraPlatforms, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
             - (Centos.8.Amd64.Open)Ubuntu.1604.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:centos-8-helix-20201229003624-c1bf759
             - SLES.15.Amd64.Open
             - (Fedora.34.Amd64.Open)ubuntu.1604.amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:fedora-34-helix-20220523142223-4f64125
-            - (Ubuntu.2110.Amd64.Open)ubuntu.1604.amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-21.04-helix-amd64-20210922170909-34a2d72
+            - (Ubuntu.2204.Amd64.Open)Ubuntu.1804.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04-helix-amd64-20220504035722-1b9461f
             - (Debian.11.Amd64.Open)Ubuntu.1804.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-11-helix-amd64-20210304164428-5a7c380
             - (Mariner.1.0.Amd64.Open)ubuntu.1604.amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:cbl-mariner-1.0-helix-20210528192219-92bf620
             - (openSUSE.15.2.Amd64.Open)ubuntu.1604.amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:opensuse-15.2-helix-amd64-20211018152525-9cc02fe
diff --git a/src/coreclr/scripts/genEventPipe.py b/src/coreclr/scripts/genEventPipe.py
index 2f46735cc43e2c..fa737eaa15360a 100644
--- a/src/coreclr/scripts/genEventPipe.py
+++ b/src/coreclr/scripts/genEventPipe.py
@@ -239,6 +239,20 @@ def generateClrEventPipeWriteEventsImpl(
 
 
 def generateWriteEventBody(template, providerName, eventName, runtimeFlavor):
+    def winTypeToFixedWidthType(t):
+        return {'win:Int8': 'int8_t',
+                'win:UInt8': 'uint8_t',
+                'win:Int16': 'int16_t',
+                'win:UInt16': 'uint16_t',
+                'win:Int32': 'int32_t',
+                'win:UInt32': 'uint32_t',
+                'win:Int64': 'int64_t',
+                'win:UInt64': 'uint64_t',
+                'win:Pointer': 'uintptr_t',
+                'win:AnsiString': 'UTF8String',
+                'win:UnicodeString': 'UTF16String'
+                }[t]
+
     fnSig = template.signature
     pack_list = []
 
@@ -267,9 +281,33 @@ def generateWriteEventBody(template, providerName, eventName, runtimeFlavor):
             if template.name in specialCaseSizes and paramName in specialCaseSizes[template.name]:
                 size = "(int)(%s)" % specialCaseSizes[template.name][paramName]
             if runtimeFlavor.mono:
+                pack_list.append("#if BIGENDIAN")
+                pack_list.append("    const uint8_t *valuePtr = %s;" % paramName)
+                pack_list.append("    for (uint32_t i = 0; i < %s; ++i) {" % template.structs[paramName])
+                types = [winTypeToFixedWidthType(t) for t in template.structTypes[paramName]]
+                for t in set(types) - {"UTF8String", "UTF16String"}:
+                    pack_list.append("        %(type)s value_%(type)s;" % {'type': t})
+                if "UTF8String" in types or "UTF16String" in types:
+                    pack_list.append("        size_t value_len;")
+                for t in types:
+                    if t == "UTF8String":
+                        pack_list.append("        value_len = strlen((const char *)valuePtr);")
+                        pack_list.append("        success &= write_buffer_string_utf8_t((const ep_char8_t *)valuePtr, value_len, &buffer, &offset, &size, &fixedBuffer);")
+                        pack_list.append("        valuePtr += value_len + 1;")
+                    elif t == "UTF16String":
+                        pack_list.append("        value_len = strlen((const char *)valuePtr);")
+                        pack_list.append("        success &= write_buffer_string_utf8_to_utf16_t((const ep_char8_t *)valuePtr, value_len, &buffer, &offset, &size, &fixedBuffer);")
+                        pack_list.append("        valuePtr += value_len + 1;")
+                    else:
+                        pack_list.append("        memcpy (&value_%(type)s, valuePtr, sizeof (value_%(type)s));" % {'type': t})
+                        pack_list.append("        valuePtr += sizeof (%s);" % t)
+                        pack_list.append("        success &= write_buffer_%(type)s (value_%(type)s, &buffer, &offset, &size, &fixedBuffer);" % {'type': t})
+                pack_list.append("    }")
+                pack_list.append("#else")
                 pack_list.append(
                     "    success &= write_buffer((const uint8_t *)%s, %s, &buffer, &offset, &size, &fixedBuffer);" %
                     (paramName, size))
+                pack_list.append("#endif // BIGENDIAN")
                 emittedWriteToBuffer = True
             elif runtimeFlavor.coreclr:
                 pack_list.append(
@@ -283,9 +321,16 @@ def generateWriteEventBody(template, providerName, eventName, runtimeFlavor):
             if template.name in specialCaseSizes and paramName in specialCaseSizes[template.name]:
                 size = "(int)(%s)" % specialCaseSizes[template.name][paramName]
             if runtimeFlavor.mono:
+                t = winTypeToFixedWidthType(parameter.winType)
+                pack_list.append("#if BIGENDIAN")
+                pack_list.append("    for (uint32_t i = 0; i < %s; ++i) {" % template.arrays[paramName])
+                pack_list.append("        success &= write_buffer_%(type)s (%(name)s[i], &buffer, &offset, &size, &fixedBuffer);" % {'name': paramName, 'type': t})
+                pack_list.append("    }")
+                pack_list.append("#else")
                 pack_list.append(
                     "    success &= write_buffer((const uint8_t *)%s, %s, &buffer, &offset, &size, &fixedBuffer);" %
                     (paramName, size))
+                pack_list.append("#endif // BIGENDIAN")
                 emittedWriteToBuffer = True
             elif runtimeFlavor.coreclr:
                 pack_list.append(
@@ -304,13 +349,13 @@ def generateWriteEventBody(template, providerName, eventName, runtimeFlavor):
             emittedWriteToBuffer = True
         elif parameter.winType == "win:AnsiString" and runtimeFlavor.mono:
             pack_list.append(
-                    "    success &= write_buffer_string_utf8_t(%s, &buffer, &offset, &size, &fixedBuffer);" %
-                    (parameter.name,))
+                    "    success &= write_buffer_string_utf8_t(%s, strlen((const char *)%s), &buffer, &offset, &size, &fixedBuffer);" %
+                    (parameter.name, parameter.name))
             emittedWriteToBuffer = True
         elif parameter.winType == "win:UnicodeString" and runtimeFlavor.mono:
             pack_list.append(
-                    "    success &= write_buffer_string_utf8_to_utf16_t(%s, &buffer, &offset, &size, &fixedBuffer);" %
-                    (parameter.name,))
+                    "    success &= write_buffer_string_utf8_to_utf16_t(%s, strlen((const char *)%s), &buffer, &offset, &size, &fixedBuffer);" %
+                    (parameter.name, parameter.name))
             emittedWriteToBuffer = True
         elif parameter.winType == "win:UInt8" and runtimeFlavor.mono:
             pack_list.append(
@@ -558,6 +603,7 @@ def getMonoEventPipeHelperFileImplPrefix():
 bool
 write_buffer_string_utf8_to_utf16_t (
     const ep_char8_t *value,
+    size_t value_len,
     uint8_t **buffer,
     size_t *offset,
     size_t *size,
@@ -566,6 +612,7 @@ def getMonoEventPipeHelperFileImplPrefix():
 bool
 write_buffer_string_utf8_t (
     const ep_char8_t *value,
+    size_t value_len,
     uint8_t **buffer,
     size_t *offset,
     size_t *size,
@@ -640,6 +687,7 @@ def getMonoEventPipeHelperFileImplPrefix():
 bool
 write_buffer_string_utf8_to_utf16_t (
     const ep_char8_t *value,
+    size_t value_len,
     uint8_t **buffer,
     size_t *offset,
     size_t *size,
@@ -653,12 +701,12 @@ def getMonoEventPipeHelperFileImplPrefix():
     custom_alloc_data.buffer_size = *size - *offset;
     custom_alloc_data.req_buffer_size = 0;
 
-    if (!g_utf8_to_utf16_custom_alloc (value, -1, NULL, NULL, g_fixed_buffer_custom_allocator, &custom_alloc_data, NULL)) {
+    if (!g_utf8_to_utf16le_custom_alloc (value, (glong)value_len, NULL, NULL, g_fixed_buffer_custom_allocator, &custom_alloc_data, NULL)) {
         ep_raise_error_if_nok (resize_buffer (buffer, size, *offset, *size + custom_alloc_data.req_buffer_size, fixed_buffer));
         custom_alloc_data.buffer = *buffer + *offset;
         custom_alloc_data.buffer_size = *size - *offset;
         custom_alloc_data.req_buffer_size = 0;
-        ep_raise_error_if_nok (g_utf8_to_utf16_custom_alloc (value, -1, NULL, NULL, g_fixed_buffer_custom_allocator, &custom_alloc_data, NULL) != NULL);
+        ep_raise_error_if_nok (g_utf8_to_utf16le_custom_alloc (value, (glong)value_len, NULL, NULL, g_fixed_buffer_custom_allocator, &custom_alloc_data, NULL) != NULL);
     }
 
     *offset += custom_alloc_data.req_buffer_size;
@@ -671,6 +719,7 @@ def getMonoEventPipeHelperFileImplPrefix():
 bool
 write_buffer_string_utf8_t (
     const ep_char8_t *value,
+    size_t value_len,
     uint8_t **buffer,
     size_t *offset,
     size_t *size,
@@ -679,10 +728,6 @@ def getMonoEventPipeHelperFileImplPrefix():
     if (!value)
         return true;
 
-    size_t value_len = 0;
-    while (value [value_len])
-        value_len++;
-
     return write_buffer ((const uint8_t *)value, (value_len + 1) * sizeof(*value), buffer, offset, size, fixed_buffer);
 }
 
@@ -802,6 +847,7 @@ def getMonoEventPipeImplFilePrefix():
 bool
 write_buffer_string_utf8_t (
     const ep_char8_t *value,
+    size_t value_len,
     uint8_t **buffer,
     size_t *offset,
     size_t *size,
@@ -810,6 +856,7 @@ def getMonoEventPipeImplFilePrefix():
 bool
 write_buffer_string_utf8_to_utf16_t (
     const ep_char8_t *value,
+    size_t value_len,
     uint8_t **buffer,
     size_t *offset,
     size_t *size,
@@ -851,6 +898,7 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+    value = ep_rt_val_uint16_t (value);
     return write_buffer ((const uint8_t *)&value, sizeof (uint16_t), buffer, offset, size, fixed_buffer);
 }
 
@@ -864,6 +912,7 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+    value = ep_rt_val_uint32_t (value);
     return write_buffer ((const uint8_t *)&value, sizeof (uint32_t), buffer, offset, size, fixed_buffer);
 }
 
@@ -877,6 +926,7 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+    value = ep_rt_val_int32_t (value);
     return write_buffer ((const uint8_t *)&value, sizeof (int32_t), buffer, offset, size, fixed_buffer);
 }
 
@@ -890,6 +940,7 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+    value = ep_rt_val_uint64_t (value);
     return write_buffer ((const uint8_t *)&value, sizeof (uint64_t), buffer, offset, size, fixed_buffer);
 }
 
@@ -903,6 +954,7 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+    value = ep_rt_val_int64_t (value);
     return write_buffer ((const uint8_t *)&value, sizeof (int64_t), buffer, offset, size, fixed_buffer);
 }
 
@@ -916,6 +968,12 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+#if BIGENDIAN
+    uint64_t value_as_uint64_t;
+    memcpy (&value_as_uint64_t, &value, sizeof (uint64_t));
+    value_as_uint64_t = ep_rt_val_uint64_t (value_as_uint64_t);
+    memcpy (&value, &value_as_uint64_t, sizeof (uint64_t));
+#endif
     return write_buffer ((const uint8_t *)&value, sizeof (double), buffer, offset, size, fixed_buffer);
 }
 
@@ -942,6 +1000,7 @@ def getMonoEventPipeImplFilePrefix():
     size_t *size,
     bool *fixed_buffer)
 {
+    value = ep_rt_val_uintptr_t (value);
     return write_buffer ((const uint8_t *)&value, sizeof (uintptr_t), buffer, offset, size, fixed_buffer);
 }
 
diff --git a/src/coreclr/scripts/genEventing.py b/src/coreclr/scripts/genEventing.py
index e557a8e8aabb8a..a711373d2d4b32 100644
--- a/src/coreclr/scripts/genEventing.py
+++ b/src/coreclr/scripts/genEventing.py
@@ -188,10 +188,11 @@ class Template:
     def __repr__(self):
         return "<Template " + self.name + ">"
 
-    def __init__(self, templateName, fnPrototypes, dependencies, structSizes, arrays):
+    def __init__(self, templateName, fnPrototypes, dependencies, structSizes, structTypes, arrays):
         self.name = templateName
         self.signature = FunctionSignature()
         self.structs = structSizes
+        self.structTypes = structTypes
         self.arrays = arrays
 
         for variable in fnPrototypes.paramlist:
@@ -273,6 +274,7 @@ def parseTemplateNodes(templateNodes):
 
     for templateNode in templateNodes:
         structCounts = {}
+        structTypes  = {}
         arrays = {}
         templateName    = templateNode.getAttribute('tid')
         var_Dependencies = {}
@@ -337,11 +339,12 @@ def parseTemplateNodes(templateNodes):
             types = [x.attributes['inType'].value for x in structToBeMarshalled.getElementsByTagName("data")]
 
             structCounts[structName] = countVarName
+            structTypes[structName] = types
             var_Dependencies[structName] = [countVarName, structName]
             fnparam_pointer = FunctionParameter("win:Struct", structName, "win:count", countVarName)
             fnPrototypes.append(structName, fnparam_pointer)
 
-        allTemplates[templateName] = Template(templateName, fnPrototypes, var_Dependencies, structCounts, arrays)
+        allTemplates[templateName] = Template(templateName, fnPrototypes, var_Dependencies, structCounts, structTypes, arrays)
 
     return allTemplates
 
diff --git a/src/coreclr/vm/ClrEtwAllMeta.lst b/src/coreclr/vm/ClrEtwAllMeta.lst
index 2fae1ae9af5934..1d5c92cbce24b5 100644
--- a/src/coreclr/vm/ClrEtwAllMeta.lst
+++ b/src/coreclr/vm/ClrEtwAllMeta.lst
@@ -640,7 +640,37 @@ nomac:CLRStackStress:::CLRStackWalkStress
 # Events from the Mono profiler provider
 #################################
 noclrinstanceid:MonoProfiler:::
-nostack:MonoProfiler:::MonoProfilerExceptionClause
+nostack:MonoProfiler:::MonoProfilerContextLoaded
+nostack:MonoProfiler:::MonoProfilerContextUnloaded
+nostack:MonoProfiler:::MonoProfilerAppDomainLoading
+nostack:MonoProfiler:::MonoProfilerAppDomainLoaded
+nostack:MonoProfiler:::MonoProfilerAppDomainUnloading
+nostack:MonoProfiler:::MonoProfilerAppDomainUnloaded
+nostack:MonoProfiler:::MonoProfilerAppDomainName
+nostack:MonoProfiler:::MonoProfilerJitBegin
+nostack:MonoProfiler:::MonoProfilerJitFailed
+nostack:MonoProfiler:::MonoProfilerJitDone
+nostack:MonoProfiler:::MonoProfilerJitDone_V1
+nostack:MonoProfiler:::MonoProfilerJitChunkCreated
+nostack:MonoProfiler:::MonoProfilerJitChunkDestroyed
+nostack:MonoProfiler:::MonoProfilerJitCodeBuffer
+nostack:MonoProfiler:::MonoProfilerClassLoading
+nostack:MonoProfiler:::MonoProfilerClassFailed
+nostack:MonoProfiler:::MonoProfilerClassLoaded
+nostack:MonoProfiler:::MonoProfilerClassLoaded_V1
+nostack:MonoProfiler:::MonoProfilerVTableLoading
+nostack:MonoProfiler:::MonoProfilerVTableFailed
+nostack:MonoProfiler:::MonoProfilerVTableLoaded
+nostack:MonoProfiler:::MonoProfilerModuleLoading
+nostack:MonoProfiler:::MonoProfilerModuleFailed
+nostack:MonoProfiler:::MonoProfilerModuleLoaded
+nostack:MonoProfiler:::MonoProfilerModuleUnloading
+nostack:MonoProfiler:::MonoProfilerModuleUnloaded
+nostack:MonoProfiler:::MonoProfilerAssemblyLoading
+nostack:MonoProfiler:::MonoProfilerAssemblyFailed
+nostack:MonoProfiler:::MonoProfilerAssemblyLoaded
+nostack:MonoProfiler:::MonoProfilerAssemblyUnloading
+nostack:MonoProfiler:::MonoProfilerAssemblyUnloaded
 nostack:MonoProfiler:::MonoProfilerMethodEnter
 nostack:MonoProfiler:::MonoProfilerMethodLeave
 nostack:MonoProfiler:::MonoProfilerMethodTailCall
@@ -648,6 +678,7 @@ nostack:MonoProfiler:::MonoProfilerMethodExceptionLeave
 nostack:MonoProfiler:::MonoProfilerMethodFree
 nostack:MonoProfiler:::MonoProfilerMethodBeginInvoke
 nostack:MonoProfiler:::MonoProfilerMethodEndInvoke
+nostack:MonoProfiler:::MonoProfilerExceptionClause
 nostack:MonoProfiler:::MonoProfilerGCEvent
 nostack:MonoProfiler:::MonoProfilerGCMoves
 nostack:MonoProfiler:::MonoProfilerGCResize
@@ -666,4 +697,5 @@ nostack:MonoProfiler:::MonoProfilerThreadStopping
 nostack:MonoProfiler:::MonoProfilerThreadStopped
 nostack:MonoProfiler:::MonoProfilerThreadExited
 nostack:MonoProfiler:::MonoProfilerThreadName
+nostack:MonoProfiler:::MonoProfilerJitDoneVerbose
 nostack:MonoProfiler:::MonoProfilerGCHeapDumpVTableClassReference
\ No newline at end of file
diff --git a/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h b/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h
index c4246df418a643..9b940adc091bf6 100644
--- a/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h
+++ b/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h
@@ -1149,6 +1149,66 @@ ep_rt_runtime_version_get_utf8 (void)
 	return reinterpret_cast<const ep_char8_t*>(CLR_PRODUCT_VERSION);
 }
 
+/*
+ * Little-Endian Conversion.
+ */
+
+static
+EP_ALWAYS_INLINE
+uint16_t
+ep_rt_val_uint16_t (uint16_t value)
+{
+	return value;
+}
+
+static
+EP_ALWAYS_INLINE
+uint32_t
+ep_rt_val_uint32_t (uint32_t value)
+{
+	return value;
+}
+
+static
+EP_ALWAYS_INLINE
+uint64_t
+ep_rt_val_uint64_t (uint64_t value)
+{
+	return value;
+}
+
+static
+EP_ALWAYS_INLINE
+int16_t
+ep_rt_val_int16_t (int16_t value)
+{
+	return value;
+}
+
+static
+EP_ALWAYS_INLINE
+int32_t
+ep_rt_val_int32_t (int32_t value)
+{
+	return value;
+}
+
+static
+EP_ALWAYS_INLINE
+int64_t
+ep_rt_val_int64_t (int64_t value)
+{
+	return value;
+}
+
+static
+EP_ALWAYS_INLINE
+uintptr_t
+ep_rt_val_uintptr_t (uintptr_t value)
+{
+	return value;
+}
+
 /*
 * Atomics.
 */
@@ -2154,7 +2214,7 @@ ep_rt_file_open_write (const ep_char8_t *path)
 {
 	STATIC_CONTRACT_NOTHROW;
 
-	ep_char16_t *path_utf16 = ep_rt_utf8_to_utf16_string (path, -1);
+	ep_char16_t *path_utf16 = ep_rt_utf8_to_utf16le_string (path, -1);
 	ep_return_null_if_nok (path_utf16 != NULL);
 
 	CFileStream *file_stream = new (nothrow) CFileStream ();
@@ -2542,7 +2602,7 @@ ep_rt_utf8_string_replace (
 
 static
 ep_char16_t *
-ep_rt_utf8_to_utf16_string (
+ep_rt_utf8_to_utf16le_string (
 	const ep_char8_t *str,
 	size_t len)
 {
@@ -2643,6 +2703,16 @@ ep_rt_utf16_to_utf8_string (
 	return str_utf8;
 }
 
+static
+inline
+ep_char8_t *
+ep_rt_utf16le_to_utf8_string (
+	const ep_char16_t *str,
+	size_t len)
+{
+	return ep_rt_utf16_to_utf8_string (str, len);
+}
+
 static
 inline
 void
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
index 42e0e80e704cd3..ac2cf97e1088c0 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
@@ -472,7 +472,15 @@ private async Task ProcessIncomingFramesAsync()
                     frameHeader = await ReadFrameAsync(initialFrame: true).ConfigureAwait(false);
                     if (frameHeader.Type != FrameType.Settings || frameHeader.AckFlag)
                     {
-                        ThrowProtocolError();
+                        if (frameHeader.Type == FrameType.GoAway)
+                        {
+                            var (_, errorCode) = ReadGoAwayFrame(frameHeader);
+                            ThrowProtocolError(errorCode);
+                        }
+                        else
+                        {
+                            ThrowProtocolError();
+                        }
                     }
 
                     if (NetEventSource.Log.IsEnabled()) Trace($"Frame 0: {frameHeader}.");
@@ -999,23 +1007,7 @@ private void ProcessRstStreamFrame(FrameHeader frameHeader)
 
         private void ProcessGoAwayFrame(FrameHeader frameHeader)
         {
-            Debug.Assert(frameHeader.Type == FrameType.GoAway);
-
-            if (frameHeader.PayloadLength < FrameHeader.GoAwayMinLength)
-            {
-                ThrowProtocolError(Http2ProtocolErrorCode.FrameSizeError);
-            }
-
-            if (frameHeader.StreamId != 0)
-            {
-                ThrowProtocolError();
-            }
-
-            int lastStreamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(_incomingBuffer.ActiveSpan) & 0x7FFFFFFF);
-            Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int)));
-            if (NetEventSource.Log.IsEnabled()) Trace(frameHeader.StreamId, $"{nameof(lastStreamId)}={lastStreamId}, {nameof(errorCode)}={errorCode}");
-
-            _incomingBuffer.Discard(frameHeader.PayloadLength);
+            var (lastStreamId, errorCode) = ReadGoAwayFrame(frameHeader);
 
             Debug.Assert(lastStreamId >= 0);
             Exception resetException = HttpProtocolException.CreateHttp2ConnectionException(errorCode);
@@ -1047,6 +1039,29 @@ private void ProcessGoAwayFrame(FrameHeader frameHeader)
             }
         }
 
+        private (int lastStreamId, Http2ProtocolErrorCode errorCode) ReadGoAwayFrame(FrameHeader frameHeader)
+        {
+            Debug.Assert(frameHeader.Type == FrameType.GoAway);
+
+            if (frameHeader.PayloadLength < FrameHeader.GoAwayMinLength)
+            {
+                ThrowProtocolError(Http2ProtocolErrorCode.FrameSizeError);
+            }
+
+            if (frameHeader.StreamId != 0)
+            {
+                ThrowProtocolError();
+            }
+
+            int lastStreamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(_incomingBuffer.ActiveSpan) & 0x7FFFFFFF);
+            Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int)));
+            if (NetEventSource.Log.IsEnabled()) Trace(frameHeader.StreamId, $"{nameof(lastStreamId)}={lastStreamId}, {nameof(errorCode)}={errorCode}");
+
+            _incomingBuffer.Discard(frameHeader.PayloadLength);
+
+            return (lastStreamId, errorCode);
+        }
+
         internal Task FlushAsync(CancellationToken cancellationToken) =>
             PerformWriteAsync(0, 0, static (_, __) => true, cancellationToken);
 
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http2.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http2.cs
index 90421159618685..98537366ec43d8 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http2.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http2.cs
@@ -129,6 +129,38 @@ public async Task Http2_DataSentBeforeServerPreface_ProtocolError()
             }
         }
 
+        [ConditionalFact(nameof(SupportsAlpn))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/69870", TestPlatforms.Android)]
+        public async Task Http2_StreamResetByServerBeforePrefix_RequestFailsWithGoawayProtocolError()
+        {
+            using (Http2LoopbackServer server = Http2LoopbackServer.CreateServer())
+            using (HttpClient client = CreateHttpClient())
+            {
+                Task<HttpResponseMessage> sendTask = client.GetAsync(server.Address);
+
+                Http2LoopbackConnection connection = await server.AcceptConnectionAsync(timeout: null);
+                _ = await connection.ReadSettingsAsync();
+
+                GoAwayFrame goAwayFrame = new GoAwayFrame(lastStreamId: 0, (int)ProtocolErrors.HTTP_1_1_REQUIRED, additionalDebugData: Array.Empty<byte>(), streamId: 0);
+                await connection.WriteFrameAsync(goAwayFrame);
+
+                var ex = await Assert.ThrowsAnyAsync<Exception>(() => sendTask);
+
+                // Position of HttpProtocolException in exception hierarchy can change depending on timing.
+                var current = ex;
+                do
+                {
+                    if (current is HttpProtocolException protocolException)
+                    {
+                        Assert.Equal((long)ProtocolErrors.HTTP_1_1_REQUIRED, protocolException.ErrorCode);
+                        return;
+                    }
+                } while ((current = current.InnerException) != null);
+
+                Assert.Fail($"Couldn't find {nameof(HttpProtocolException)} with matching error code in exception: {ex}");
+            }
+        }
+
         [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/69870", TestPlatforms.Android)]
         public async Task Http2_NoResponseBody_Success()
diff --git a/src/libraries/System.Text.Json/src/System/ReflectionExtensions.cs b/src/libraries/System.Text.Json/src/System/ReflectionExtensions.cs
index 006c9c4e0e3abb..6cc6dbbf91e70c 100644
--- a/src/libraries/System.Text.Json/src/System/ReflectionExtensions.cs
+++ b/src/libraries/System.Text.Json/src/System/ReflectionExtensions.cs
@@ -43,5 +43,24 @@ public static bool IsAssignableFromInternal(this Type type, Type from)
 
         private static bool HasJsonConstructorAttribute(ConstructorInfo constructorInfo)
             => constructorInfo.GetCustomAttribute<JsonConstructorAttribute>() != null;
+
+        public static TAttribute? GetUniqueCustomAttribute<TAttribute>(this MemberInfo memberInfo, bool inherit)
+            where TAttribute : Attribute
+        {
+            object[] attributes = memberInfo.GetCustomAttributes(typeof(TAttribute), inherit);
+
+            if (attributes.Length == 0)
+            {
+                return null;
+            }
+
+            if (attributes.Length == 1)
+            {
+                return (TAttribute)attributes[0];
+            }
+
+            ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateAttribute(typeof(TAttribute), memberInfo);
+            return null;
+        }
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverter.cs
index bfff00aa3e39a4..571eb1459d8d09 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverter.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverter.cs
@@ -67,7 +67,7 @@ internal virtual void ReadElementAndSetProperty(
             throw new InvalidOperationException(SR.NodeJsonObjectCustomConverterNotAllowedOnExtensionProperty);
         }
 
-        internal abstract JsonPropertyInfo CreateJsonPropertyInfo(JsonTypeInfo parentTypeInfo);
+        internal abstract JsonPropertyInfo CreateJsonPropertyInfo(JsonTypeInfo declaringTypeInfo, Type propertyType, JsonSerializerOptions options);
 
         internal abstract JsonParameterInfo CreateJsonParameterInfo();
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs
index dcb8c950111089..0db82dbb610292 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs
@@ -32,7 +32,7 @@ protected JsonConverterFactory() { }
         /// </returns>
         public abstract JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options);
 
-        internal override JsonPropertyInfo CreateJsonPropertyInfo(JsonTypeInfo parentTypeInfo)
+        internal override JsonPropertyInfo CreateJsonPropertyInfo(JsonTypeInfo declaringTypeInfo, Type propertyType, JsonSerializerOptions options)
         {
             Debug.Fail("We should never get here.");
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
index a4dee4e3ff90a8..a6c7c5baae034d 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
@@ -69,9 +69,9 @@ public override bool CanConvert(Type typeToConvert)
 
         internal override ConverterStrategy ConverterStrategy => ConverterStrategy.Value;
 
-        internal sealed override JsonPropertyInfo CreateJsonPropertyInfo(JsonTypeInfo parentTypeInfo)
+        internal sealed override JsonPropertyInfo CreateJsonPropertyInfo(JsonTypeInfo declaringTypeInfo, Type propertyType, JsonSerializerOptions options)
         {
-            return new JsonPropertyInfo<T>(parentTypeInfo);
+            return new JsonPropertyInfo<T>(declaringTypeInfo.Type, propertyType, declaringTypeInfo, options);
         }
 
         internal sealed override JsonParameterInfo CreateJsonParameterInfo()
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Converters.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Converters.cs
index 2dd8adf20952d3..bdf26c36dfb9cd 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Converters.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Converters.cs
@@ -27,21 +27,15 @@ public sealed partial class JsonSerializerOptions
         public IList<JsonConverter> Converters => _converters;
 
         // This may return factory converter
-        internal JsonConverter? GetCustomConverterFromMember(Type? parentClassType, Type typeToConvert, MemberInfo? memberInfo)
+        internal JsonConverter? GetCustomConverterFromMember(Type typeToConvert, MemberInfo memberInfo)
         {
+            Debug.Assert(memberInfo.DeclaringType != null, "Properties and fields always have a declaring type.");
             JsonConverter? converter = null;
 
-            if (memberInfo != null)
+            JsonConverterAttribute? converterAttribute = memberInfo.GetUniqueCustomAttribute<JsonConverterAttribute>(inherit: false);
+            if (converterAttribute != null)
             {
-                Debug.Assert(parentClassType != null);
-
-                JsonConverterAttribute? converterAttribute = (JsonConverterAttribute?)
-                    GetAttributeThatCanHaveMultiple(parentClassType!, typeof(JsonConverterAttribute), memberInfo);
-
-                if (converterAttribute != null)
-                {
-                    converter = GetConverterFromAttribute(converterAttribute, typeToConvert, classTypeAttributeIsOn: parentClassType!, memberInfo);
-                }
+                converter = GetConverterFromAttribute(converterAttribute, typeToConvert, memberInfo);
             }
 
             return converter;
@@ -180,12 +174,10 @@ private JsonConverter GetConverterFromOptionsOrReflectionConverter(Type typeToCo
             // Priority 2: Attempt to get converter from [JsonConverter] on the type being converted.
             if (converter == null)
             {
-                JsonConverterAttribute? converterAttribute = (JsonConverterAttribute?)
-                    GetAttributeThatCanHaveMultiple(typeToConvert, typeof(JsonConverterAttribute));
-
+                JsonConverterAttribute? converterAttribute = typeToConvert.GetUniqueCustomAttribute<JsonConverterAttribute>(inherit: false);
                 if (converterAttribute != null)
                 {
-                    converter = GetConverterFromAttribute(converterAttribute, typeToConvert: typeToConvert, classTypeAttributeIsOn: typeToConvert, memberInfo: null);
+                    converter = GetConverterFromAttribute(converterAttribute, typeToConvert: typeToConvert, memberInfo: null);
                 }
             }
 
@@ -215,29 +207,30 @@ private JsonConverter GetConverterFromOptionsOrReflectionConverter(Type typeToCo
         // This suppression needs to be removed. https://github.com/dotnet/runtime/issues/68878
         [UnconditionalSuppressMessage("AotAnalysis", "IL3050:RequiresDynamicCode", Justification = "The factory constructors are only invoked in the context of reflection serialization code paths " +
             "and are marked RequiresDynamicCode")]
-        private JsonConverter GetConverterFromAttribute(JsonConverterAttribute converterAttribute, Type typeToConvert, Type classTypeAttributeIsOn, MemberInfo? memberInfo)
+        private JsonConverter GetConverterFromAttribute(JsonConverterAttribute converterAttribute, Type typeToConvert, MemberInfo? memberInfo)
         {
             JsonConverter? converter;
 
-            Type? type = converterAttribute.ConverterType;
-            if (type == null)
+            Type declaringType = memberInfo?.DeclaringType ?? typeToConvert;
+            Type? converterType = converterAttribute.ConverterType;
+            if (converterType == null)
             {
                 // Allow the attribute to create the converter.
                 converter = converterAttribute.CreateConverter(typeToConvert);
                 if (converter == null)
                 {
-                    ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeNotCompatible(classTypeAttributeIsOn, memberInfo, typeToConvert);
+                    ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeNotCompatible(declaringType, memberInfo, typeToConvert);
                 }
             }
             else
             {
-                ConstructorInfo? ctor = type.GetConstructor(Type.EmptyTypes);
-                if (!typeof(JsonConverter).IsAssignableFrom(type) || ctor == null || !ctor.IsPublic)
+                ConstructorInfo? ctor = converterType.GetConstructor(Type.EmptyTypes);
+                if (!typeof(JsonConverter).IsAssignableFrom(converterType) || ctor == null || !ctor.IsPublic)
                 {
-                    ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeInvalid(classTypeAttributeIsOn, memberInfo);
+                    ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeInvalid(declaringType, memberInfo);
                 }
 
-                converter = (JsonConverter)Activator.CreateInstance(type)!;
+                converter = (JsonConverter)Activator.CreateInstance(converterType)!;
             }
 
             Debug.Assert(converter != null);
@@ -255,38 +248,10 @@ private JsonConverter GetConverterFromAttribute(JsonConverterAttribute converter
                     return NullableConverterFactory.CreateValueConverter(underlyingType, converter);
                 }
 
-                ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeNotCompatible(classTypeAttributeIsOn, memberInfo, typeToConvert);
+                ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeNotCompatible(declaringType, memberInfo, typeToConvert);
             }
 
             return converter;
         }
-
-        private static Attribute? GetAttributeThatCanHaveMultiple(Type classType, Type attributeType, MemberInfo memberInfo)
-        {
-            object[] attributes = memberInfo.GetCustomAttributes(attributeType, inherit: false);
-            return GetAttributeThatCanHaveMultiple(attributeType, classType, memberInfo, attributes);
-        }
-
-        internal static Attribute? GetAttributeThatCanHaveMultiple(Type classType, Type attributeType)
-        {
-            object[] attributes = classType.GetCustomAttributes(attributeType, inherit: false);
-            return GetAttributeThatCanHaveMultiple(attributeType, classType, null, attributes);
-        }
-
-        private static Attribute? GetAttributeThatCanHaveMultiple(Type attributeType, Type classType, MemberInfo? memberInfo, object[] attributes)
-        {
-            if (attributes.Length == 0)
-            {
-                return null;
-            }
-
-            if (attributes.Length == 1)
-            {
-                return (Attribute)attributes[0];
-            }
-
-            ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateAttribute(attributeType, classType, memberInfo);
-            return default;
-        }
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/CustomJsonTypeInfoOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/CustomJsonTypeInfoOfT.cs
index 874815923eacb2..b8cc6c1661be3d 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/CustomJsonTypeInfoOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/CustomJsonTypeInfoOfT.cs
@@ -31,11 +31,7 @@ internal CustomJsonTypeInfo(JsonSerializerOptions options)
         private static JsonConverter GetConverter(JsonSerializerOptions options)
         {
             DefaultJsonTypeInfoResolver.RootDefaultInstance();
-            return GetEffectiveConverter(
-                    typeof(T),
-                    parentClassType: null, // A TypeInfo never has a "parent" class.
-                    memberInfo: null, // A TypeInfo never has a "parent" property.
-                    options);
+            return options.GetConverterForType(typeof(T));
         }
 
         internal override JsonParameterInfoValues[] GetParameterInfoValues()
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.cs
index d0baa8e2e18dc9..817a6f4feb6102 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.cs
@@ -50,7 +50,7 @@ public virtual JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions options
 
             _mutable = false;
 
-            JsonTypeInfo.ValidateType(type, null, null, options);
+            JsonTypeInfo.ValidateType(type);
             JsonTypeInfo typeInfo = CreateJsonTypeInfo(type, options);
 
             if (_modifiers != null)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.cs
index a60ec2fe2d5084..308e1841a0a59e 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.cs
@@ -48,9 +48,7 @@ public static JsonPropertyInfo CreatePropertyInfo<T>(JsonSerializerOptions optio
                 throw new InvalidOperationException(SR.Format(SR.FieldCannotBeVirtual, nameof(propertyInfo.IsProperty), nameof(propertyInfo.IsVirtual)));
             }
 
-            JsonPropertyInfo<T> jsonPropertyInfo = new JsonPropertyInfo<T>(parentTypeInfo: null);
-            jsonPropertyInfo.InitializeForSourceGen(options, propertyInfo);
-            return jsonPropertyInfo;
+            return new JsonPropertyInfo<T>(options, propertyInfo);
         }
 
         /// <summary>
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs
index c9a77e5db5a89e..00c59fe5ea4f69 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
@@ -100,24 +99,95 @@ public JsonConverter? CustomConverter
                 _shouldSerialize = value;
                 // By default we will go through faster path (not using delegate) and use IgnoreCondition
                 // If users sets it explicitly we always go through delegate
-                IgnoreCondition = null;
+                _ignoreCondition = null;
                 IsIgnored = false;
                 _shouldSerializeIsExplicitlySet = true;
             }
         }
 
-        private protected Func<object, object?, bool>? _shouldSerialize;
+        internal JsonIgnoreCondition? IgnoreCondition
+        {
+            get => _ignoreCondition;
+            set
+            {
+                Debug.Assert(!_isConfigured);
+
+                _ignoreCondition = value;
+                IsIgnored = value == JsonIgnoreCondition.Always;
+                _shouldSerialize = value != null ? GetShouldSerializeForIgnoreCondition(value.Value) : null;
+                _shouldSerializeIsExplicitlySet = false;
+            }
+        }
+
+        private Func<object, object?, bool>? _shouldSerialize;
         private bool _shouldSerializeIsExplicitlySet;
+        private JsonIgnoreCondition? _ignoreCondition;
+
+        private protected abstract Func<object, object?, bool> GetShouldSerializeForIgnoreCondition(JsonIgnoreCondition condition);
+
+        /// <summary>
+        /// Gets or sets a custom attribute provider for the current property.
+        /// </summary>
+        /// <remarks>
+        /// When resolving metadata via <see cref="DefaultJsonTypeInfoResolver"/> this
+        /// will be populated with the underlying <see cref="MemberInfo" /> of the serialized property or field.
+        ///
+        /// Setting a custom attribute provider will have no impact on the contract model,
+        /// but serves as metadata for downstream contract modifiers.
+        /// </remarks>
+        internal ICustomAttributeProvider? AttributeProvider
+        {
+            get => _attributeProvider;
+            set
+            {
+                VerifyMutable();
+
+                _attributeProvider = value;
+            }
+        }
+
+        private ICustomAttributeProvider? _attributeProvider;
+        internal string? MemberName { get; private protected set; }
+        internal MemberTypes MemberType { get; private protected set; }
+        internal bool IsVirtual { get; private set; }
+
+        /// <summary>
+        /// Specifies whether the current property is a special extension data property.
+        /// </summary>
+        /// <remarks>
+        /// Properties annotated with <see cref="JsonExtensionDataAttribute"/>
+        /// will appear here when using <see cref="DefaultJsonTypeInfoResolver"/> or <see cref="JsonSerializerContext"/>.
+        /// </remarks>
+        internal bool IsExtensionData
+        {
+            get => _isExtensionDataProperty;
+            set
+            {
+                VerifyMutable();
+
+                if (value && !JsonTypeInfo.IsValidExtensionDataProperty(this))
+                {
+                    ThrowHelper.ThrowInvalidOperationException_SerializationDataExtensionPropertyInvalid(this);
+                }
+
+                _isExtensionDataProperty = value;
+            }
+        }
+
+        private bool _isExtensionDataProperty;
 
-        internal JsonPropertyInfo(JsonTypeInfo? parentTypeInfo)
+        internal JsonPropertyInfo(Type declaringType, Type propertyType, JsonTypeInfo? parentTypeInfo, JsonSerializerOptions options)
         {
-            // null parentTypeInfo means it's not tied yet
-            ParentTypeInfo = parentTypeInfo;
+            DeclaringType = declaringType;
+            PropertyType = propertyType;
+            Options = options;
+            ParentTypeInfo = parentTypeInfo; // null parentTypeInfo means it's not tied yet
+            PropertyTypeCanBeNull = PropertyType.CanBeNull();
         }
 
         internal static JsonPropertyInfo GetPropertyPlaceholder()
         {
-            JsonPropertyInfo info = new JsonPropertyInfo<object>(parentTypeInfo: null);
+            JsonPropertyInfo info = new JsonPropertyInfo<object>(typeof(object), typeof(object), parentTypeInfo: null, options: null!);
 
             Debug.Assert(!info.IsForTypeInfo);
             Debug.Assert(!info.CanDeserialize);
@@ -131,7 +201,7 @@ internal static JsonPropertyInfo GetPropertyPlaceholder()
         /// <summary>
         /// Gets the type of the current property metadata.
         /// </summary>
-        public Type PropertyType { get; private protected set; } = null!;
+        public Type PropertyType { get; }
 
         private protected void VerifyMutable()
         {
@@ -190,54 +260,41 @@ internal virtual void Configure()
             }
         }
 
-        internal abstract void DetermineEffectiveConverter();
+        private protected abstract void DetermineEffectiveConverter();
+        private protected abstract void DetermineMemberAccessors(MemberInfo memberInfo);
 
-        internal void GetPolicies()
+        private void DeterminePoliciesFromMember(MemberInfo memberInfo)
         {
-            Debug.Assert(MemberInfo != null);
-            DeterminePropertyName();
+            JsonPropertyOrderAttribute? orderAttr = memberInfo.GetCustomAttribute<JsonPropertyOrderAttribute>(inherit: false);
+            Order = orderAttr?.Order ?? 0;
 
-            JsonPropertyOrderAttribute? orderAttr = MemberInfo.GetCustomAttribute<JsonPropertyOrderAttribute>(inherit: false);
-            if (orderAttr != null)
-            {
-                Order = orderAttr.Order;
-            }
-
-            JsonNumberHandlingAttribute? attribute = MemberInfo.GetCustomAttribute<JsonNumberHandlingAttribute>(inherit: false);
-            NumberHandling = attribute?.Handling;
+            JsonNumberHandlingAttribute? numberHandlingAttr = memberInfo.GetCustomAttribute<JsonNumberHandlingAttribute>(inherit: false);
+            NumberHandling = numberHandlingAttr?.Handling;
         }
 
-        private void DeterminePropertyName()
+        private void DeterminePropertyNameFromMember(MemberInfo memberInfo)
         {
-            Debug.Assert(MemberInfo != null);
-
-            ClrName = MemberInfo.Name;
-
-            JsonPropertyNameAttribute? nameAttribute = MemberInfo.GetCustomAttribute<JsonPropertyNameAttribute>(inherit: false);
+            JsonPropertyNameAttribute? nameAttribute = memberInfo.GetCustomAttribute<JsonPropertyNameAttribute>(inherit: false);
+            string? name;
             if (nameAttribute != null)
             {
-                string name = nameAttribute.Name;
-                if (name == null)
-                {
-                    ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameNull(DeclaringType, this);
-                }
-
-                Name = name;
+                name = nameAttribute.Name;
             }
             else if (Options.PropertyNamingPolicy != null)
             {
-                string name = Options.PropertyNamingPolicy.ConvertName(MemberInfo.Name);
-                if (name == null)
-                {
-                    ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameNull(DeclaringType, this);
-                }
-
-                Name = name;
+                name = Options.PropertyNamingPolicy.ConvertName(memberInfo.Name);
             }
             else
             {
-                Name = MemberInfo.Name;
+                name = memberInfo.Name;
             }
+
+            if (name == null)
+            {
+                ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameNull(this);
+            }
+
+            Name = name;
         }
 
         internal void CacheNameAsUtf8BytesAndEscapedNameSection()
@@ -330,7 +387,7 @@ internal void DetermineIgnoreCondition(JsonIgnoreCondition? ignoreCondition)
                     }
                     else
                     {
-                        ThrowHelper.ThrowInvalidOperationException_IgnoreConditionOnValueTypeInvalid(ClrName!, DeclaringType);
+                        ThrowHelper.ThrowInvalidOperationException_IgnoreConditionOnValueTypeInvalid(MemberName!, DeclaringType);
                     }
                 }
             }
@@ -468,17 +525,40 @@ internal string GetDebugInfo(int indent = 0)
         internal bool HasGetter => _untypedGet is not null;
         internal bool HasSetter => _untypedSet is not null;
 
-        internal abstract void Initialize(
-            Type parentClassType,
-            Type declaredPropertyType,
-            ConverterStrategy converterStrategy,
-            MemberInfo? memberInfo,
-            bool isVirtual,
-            JsonConverter converter,
-            JsonIgnoreCondition? ignoreCondition,
-            JsonSerializerOptions options,
-            JsonTypeInfo? jsonTypeInfo = null,
-            bool isUserDefinedProperty = false);
+        internal void InitializeUsingMemberReflection(MemberInfo memberInfo)
+        {
+            Debug.Assert(AttributeProvider == null);
+
+            switch (AttributeProvider = memberInfo)
+            {
+                case PropertyInfo propertyInfo:
+                    {
+                        MemberName = propertyInfo.Name;
+                        IsVirtual = propertyInfo.IsVirtual();
+                        MemberType = MemberTypes.Property;
+                        break;
+                    }
+                case FieldInfo fieldInfo:
+                    {
+                        MemberName = fieldInfo.Name;
+                        MemberType = MemberTypes.Field;
+                        break;
+                    }
+                default:
+                    Debug.Fail("Only FieldInfo and PropertyInfo members are supported.");
+                    break;
+            }
+
+            DeterminePoliciesFromMember(memberInfo);
+            DeterminePropertyNameFromMember(memberInfo);
+
+            if (!IsIgnored)
+            {
+                DetermineMemberAccessors(memberInfo);
+            }
+
+            IsExtensionData = memberInfo.GetCustomAttribute<JsonExtensionDataAttribute>(inherit: false) != null;
+        }
 
         internal bool IgnoreDefaultValuesOnRead { get; private set; }
         internal bool IgnoreDefaultValuesOnWrite { get; private set; }
@@ -532,7 +612,7 @@ public string Name
         /// <summary>
         /// Options associated with JsonPropertyInfo
         /// </summary>
-        public JsonSerializerOptions Options { get; internal set; } = null!; // initialized in Init method
+        public JsonSerializerOptions Options { get; }
 
         /// <summary>
         /// Gets or sets the serialization order for the current property.
@@ -650,9 +730,7 @@ internal void EnsureChildOf(JsonTypeInfo parent)
             }
         }
 
-        internal Type DeclaringType { get; set; } = null!;
-
-        internal MemberInfo? MemberInfo { get; set; }
+        internal Type DeclaringType { get; }
 
         [AllowNull]
         internal JsonTypeInfo JsonTypeInfo
@@ -685,22 +763,17 @@ internal JsonTypeInfo JsonTypeInfo
 
         internal abstract void SetExtensionDictionaryAsObject(object obj, object? extensionDict);
 
-        internal bool CanSerialize { get; set; }
+        internal bool CanSerialize { get; private set; }
 
-        internal bool CanDeserialize { get; set; }
+        internal bool CanDeserialize { get; private set; }
 
-        internal bool IsIgnored { get; set; }
+        internal bool IsIgnored { get; private set; }
 
         /// <summary>
         /// Relevant to source generated metadata: did the property have the <see cref="JsonIncludeAttribute"/>?
         /// </summary>
         internal bool SrcGen_HasJsonInclude { get; set; }
 
-        /// <summary>
-        /// Relevant to source generated metadata: did the property have the <see cref="JsonExtensionDataAttribute"/>?
-        /// </summary>
-        internal bool SrcGen_IsExtensionData { get; set; }
-
         /// <summary>
         /// Relevant to source generated metadata: is the property public?
         /// </summary>
@@ -732,15 +805,7 @@ public JsonNumberHandling? NumberHandling
         internal JsonNumberHandling? EffectiveNumberHandling { get; set; }
 
         //  Whether the property type can be null.
-        internal bool PropertyTypeCanBeNull { get; set; }
-
-        internal JsonIgnoreCondition? IgnoreCondition { get; set; }
-
-        internal MemberTypes MemberType { get; set; } // TODO: with some refactoring, we should be able to remove this.
-
-        internal string? ClrName { get; set; }
-
-        internal bool IsVirtual { get; set; }
+        internal bool PropertyTypeCanBeNull { get; }
 
         /// <summary>
         /// Default value used for parameterized ctor invocation.
@@ -748,6 +813,6 @@ public JsonNumberHandling? NumberHandling
         internal abstract object? DefaultValue { get; }
 
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private string DebuggerDisplay => $"MemberInfo={MemberInfo}";
+        private string DebuggerDisplay => $"MemberInfo={AttributeProvider as MemberInfo}";
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs
index 31c9ca3aa28f29..8176763ce7bd33 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs
@@ -25,13 +25,15 @@ internal sealed class JsonPropertyInfo<T> : JsonPropertyInfo
 
         // Since a converter's TypeToConvert (which is the T value in this type) can be different than
         // the property's type, we track that and whether the property type can be null.
-        private bool _propertyTypeEqualsTypeToConvert;
+        private readonly bool _propertyTypeEqualsTypeToConvert;
 
         private Func<object, T>? _typedGet;
         private Action<object, T>? _typedSet;
 
-        internal JsonPropertyInfo(JsonTypeInfo? parentTypeInfo) : base(parentTypeInfo)
+        internal JsonPropertyInfo(Type declaringType, Type propertyType, JsonTypeInfo? parentTypeInfo, JsonSerializerOptions options)
+            : base(declaringType, propertyType, parentTypeInfo, options)
         {
+            _propertyTypeEqualsTypeToConvert = propertyType == typeof(T);
         }
 
         internal new Func<object, T>? Get
@@ -98,107 +100,57 @@ private protected override void SetSetter(Delegate? setter)
 
         internal JsonConverter<T> TypedEffectiveConverter { get; private set; } = null!;
 
-        internal override void Initialize(
-            Type declaringType,
-            Type declaredPropertyType,
-            ConverterStrategy converterStrategy,
-            MemberInfo? memberInfo,
-            bool isVirtual,
-            JsonConverter converter,
-            JsonIgnoreCondition? ignoreCondition,
-            JsonSerializerOptions options,
-            JsonTypeInfo? jsonTypeInfo = null,
-            bool isUserDefinedProperty = false)
+        private protected override void DetermineMemberAccessors(MemberInfo memberInfo)
         {
-            Debug.Assert(converter != null);
+            Debug.Assert(memberInfo is FieldInfo or PropertyInfo);
 
-            PropertyType = declaredPropertyType;
-            _propertyTypeEqualsTypeToConvert = typeof(T) == declaredPropertyType;
-            PropertyTypeCanBeNull = PropertyType.CanBeNull();
-            ConverterStrategy = converterStrategy;
-            if (jsonTypeInfo != null)
+            switch (memberInfo)
             {
-                JsonTypeInfo = jsonTypeInfo;
-            }
-
-            DefaultConverterForType = converter;
-            Options = options;
-            DeclaringType = declaringType;
-            MemberInfo = memberInfo;
-            IsVirtual = isVirtual;
-            IgnoreCondition = ignoreCondition;
-            IsIgnored = ignoreCondition == JsonIgnoreCondition.Always;
-
-            if (memberInfo != null)
-            {
-                if (!IsIgnored)
-                {
-                    switch (memberInfo)
+                case PropertyInfo propertyInfo:
                     {
-                        case PropertyInfo propertyInfo:
-                            {
-                                bool useNonPublicAccessors = propertyInfo.GetCustomAttribute<JsonIncludeAttribute>(inherit: false) != null;
-
-                                MethodInfo? getMethod = propertyInfo.GetMethod;
-                                if (getMethod != null && (getMethod.IsPublic || useNonPublicAccessors))
-                                {
-                                    Get = options.MemberAccessorStrategy.CreatePropertyGetter<T>(propertyInfo);
-                                }
-
-                                MethodInfo? setMethod = propertyInfo.SetMethod;
-                                if (setMethod != null && (setMethod.IsPublic || useNonPublicAccessors))
-                                {
-                                    Set = options.MemberAccessorStrategy.CreatePropertySetter<T>(propertyInfo);
-                                }
+                        bool useNonPublicAccessors = propertyInfo.GetCustomAttribute<JsonIncludeAttribute>(inherit: false) != null;
 
-                                MemberType = MemberTypes.Property;
-
-                                break;
-                            }
+                        MethodInfo? getMethod = propertyInfo.GetMethod;
+                        if (getMethod != null && (getMethod.IsPublic || useNonPublicAccessors))
+                        {
+                            Get = Options.MemberAccessorStrategy.CreatePropertyGetter<T>(propertyInfo);
+                        }
 
-                        case FieldInfo fieldInfo:
-                            {
-                                Debug.Assert(fieldInfo.IsPublic);
+                        MethodInfo? setMethod = propertyInfo.SetMethod;
+                        if (setMethod != null && (setMethod.IsPublic || useNonPublicAccessors))
+                        {
+                            Set = Options.MemberAccessorStrategy.CreatePropertySetter<T>(propertyInfo);
+                        }
 
-                                Get = options.MemberAccessorStrategy.CreateFieldGetter<T>(fieldInfo);
+                        break;
+                    }
 
-                                if (!fieldInfo.IsInitOnly)
-                                {
-                                    Set = options.MemberAccessorStrategy.CreateFieldSetter<T>(fieldInfo);
-                                }
+                case FieldInfo fieldInfo:
+                    {
+                        Debug.Assert(fieldInfo.IsPublic);
 
-                                MemberType = MemberTypes.Field;
+                        Get = Options.MemberAccessorStrategy.CreateFieldGetter<T>(fieldInfo);
 
-                                break;
-                            }
+                        if (!fieldInfo.IsInitOnly)
+                        {
+                            Set = Options.MemberAccessorStrategy.CreateFieldSetter<T>(fieldInfo);
+                        }
 
-                        default:
-                            {
-                                Debug.Fail($"Invalid memberInfo type: {memberInfo.GetType().FullName}");
-                                break;
-                            }
+                        break;
                     }
-                }
 
-                GetPolicies();
-            }
-            else if (!isUserDefinedProperty)
-            {
-                IsForTypeInfo = true;
-            }
-
-            if (IgnoreCondition != null)
-            {
-                _shouldSerialize = GetShouldSerializeForIgnoreCondition(IgnoreCondition.Value);
+                default:
+                    {
+                        Debug.Fail($"Invalid MemberInfo type: {memberInfo.MemberType}");
+                        break;
+                    }
             }
         }
 
-        internal void InitializeForSourceGen(JsonSerializerOptions options, JsonPropertyInfoValues<T> propertyInfo)
+        internal JsonPropertyInfo(JsonSerializerOptions options, JsonPropertyInfoValues<T> propertyInfo)
+            : this(propertyInfo.DeclaringType, propertyType: typeof(T), parentTypeInfo: null, options)
         {
-            Options = options;
-            ClrName = propertyInfo.PropertyName;
-
-            string name;
+            string? name;
 
             // Property name settings.
             if (propertyInfo.JsonPropertyName != null)
@@ -207,30 +159,27 @@ internal void InitializeForSourceGen(JsonSerializerOptions options, JsonProperty
             }
             else if (options.PropertyNamingPolicy == null)
             {
-                name = ClrName;
+                name = propertyInfo.PropertyName;
             }
             else
             {
-                name = options.PropertyNamingPolicy.ConvertName(ClrName);
+                name = options.PropertyNamingPolicy.ConvertName(propertyInfo.PropertyName);
             }
 
             // Compat: We need to do validation before we assign Name so that we get InvalidOperationException rather than ArgumentNullException
             if (name == null)
             {
-                ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameNull(DeclaringType, this);
+                ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameNull(this);
             }
 
             Name = name;
-
+            MemberName = propertyInfo.PropertyName;
+            MemberType = propertyInfo.IsProperty ? MemberTypes.Property : MemberTypes.Field;
             SrcGen_IsPublic = propertyInfo.IsPublic;
             SrcGen_HasJsonInclude = propertyInfo.HasJsonInclude;
-            SrcGen_IsExtensionData = propertyInfo.IsExtensionData;
-            PropertyType = typeof(T);
-            _propertyTypeEqualsTypeToConvert = true;
-            PropertyTypeCanBeNull = PropertyType.CanBeNull();
+            IsExtensionData = propertyInfo.IsExtensionData;
 
             JsonTypeInfo? propertyTypeInfo = propertyInfo.PropertyTypeInfo;
-            Type declaringType = propertyInfo.DeclaringType;
 
             JsonConverter<T>? typedCustomConverter = propertyInfo.Converter;
             CustomConverter = typedCustomConverter;
@@ -238,23 +187,15 @@ internal void InitializeForSourceGen(JsonSerializerOptions options, JsonProperty
             JsonConverter<T>? typedNonCustomConverter = propertyTypeInfo?.Converter as JsonConverter<T>;
             DefaultConverterForType = typedNonCustomConverter;
 
-            IsIgnored = propertyInfo.IgnoreCondition == JsonIgnoreCondition.Always;
-            if (!IsIgnored)
+            IgnoreCondition = propertyInfo.IgnoreCondition;
+            if (IgnoreCondition != JsonIgnoreCondition.Always)
             {
                 Get = propertyInfo.Getter!;
                 Set = propertyInfo.Setter;
             }
 
             JsonTypeInfo = propertyTypeInfo;
-            DeclaringType = declaringType;
-            IgnoreCondition = propertyInfo.IgnoreCondition;
-            MemberType = propertyInfo.IsProperty ? MemberTypes.Property : MemberTypes.Field;
             NumberHandling = propertyInfo.NumberHandling;
-
-            if (IgnoreCondition != null)
-            {
-                _shouldSerialize = GetShouldSerializeForIgnoreCondition(IgnoreCondition.Value);
-            }
         }
 
         internal override void Configure()
@@ -267,7 +208,7 @@ internal override void Configure()
             }
         }
 
-        internal override void DetermineEffectiveConverter()
+        private protected override void DetermineEffectiveConverter()
         {
             JsonConverter? customConverter = CustomConverter;
             if (customConverter != null)
@@ -544,7 +485,7 @@ internal override void SetExtensionDictionaryAsObject(object obj, object? extens
             Set!(obj, typedValue);
         }
 
-        private Func<object, object?, bool> GetShouldSerializeForIgnoreCondition(JsonIgnoreCondition ignoreCondition)
+        private protected override Func<object, object?, bool> GetShouldSerializeForIgnoreCondition(JsonIgnoreCondition ignoreCondition)
         {
             switch (ignoreCondition)
             {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs
index 3d99324b5e0aee..32703dc5c8f3c6 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs
@@ -51,35 +51,12 @@ public abstract partial class JsonTypeInfo
 
         internal Func<JsonParameterInfoValues[]>? CtorParamInitFunc;
 
-        internal JsonPropertyInfo CreateProperty(
-            Type declaredPropertyType,
-            MemberInfo? memberInfo,
-            Type parentClassType,
-            bool isVirtual,
-            JsonConverter converter,
-            JsonSerializerOptions options,
-            JsonIgnoreCondition? ignoreCondition = null,
-            JsonTypeInfo? jsonTypeInfo = null,
-            JsonConverter? customConverter = null,
-            bool isUserDefinedProperty = false)
+        internal JsonPropertyInfo CreateProperty(Type propertyType, JsonConverter converter)
         {
             // Create the JsonPropertyInfo instance.
-            JsonPropertyInfo jsonPropertyInfo = converter.CreateJsonPropertyInfo(parentTypeInfo: this);
-
-            jsonPropertyInfo.Initialize(
-                parentClassType,
-                declaredPropertyType,
-                converterStrategy: converter.ConverterStrategy,
-                memberInfo,
-                isVirtual,
-                converter,
-                ignoreCondition,
-                options,
-                jsonTypeInfo,
-                isUserDefinedProperty: isUserDefinedProperty);
-
-            jsonPropertyInfo.CustomConverter = customConverter;
-
+            JsonPropertyInfo jsonPropertyInfo = converter.CreateJsonPropertyInfo(declaringTypeInfo: this, propertyType, Options);
+            jsonPropertyInfo.DefaultConverterForType = converter;
+            jsonPropertyInfo.ConverterStrategy = converter.ConverterStrategy;
             return jsonPropertyInfo;
         }
 
@@ -87,23 +64,11 @@ internal JsonPropertyInfo CreateProperty(
         /// Create a <see cref="JsonPropertyInfo"/> for a given Type.
         /// See <seealso cref="PropertyInfoForTypeInfo"/>.
         /// </summary>
-        private JsonPropertyInfo CreatePropertyInfoForTypeInfo(
-            Type declaredPropertyType,
-            JsonConverter converter,
-            JsonSerializerOptions options,
-            JsonTypeInfo? jsonTypeInfo = null)
+        private JsonPropertyInfo CreatePropertyInfoForTypeInfo(JsonTypeInfo jsonTypeInfo, JsonConverter converter)
         {
-            JsonPropertyInfo jsonPropertyInfo = CreateProperty(
-                declaredPropertyType: declaredPropertyType,
-                memberInfo: null, // Not a real property so this is null.
-                parentClassType: ObjectType, // a dummy value (not used)
-                isVirtual: false,
-                converter: converter,
-                options: options,
-                jsonTypeInfo: jsonTypeInfo);
-
-            Debug.Assert(jsonPropertyInfo.IsForTypeInfo);
-
+            JsonPropertyInfo jsonPropertyInfo = CreateProperty(jsonTypeInfo.Type, converter: converter);
+            jsonPropertyInfo.JsonTypeInfo = jsonTypeInfo;
+            jsonPropertyInfo.IsForTypeInfo = true;
             return jsonPropertyInfo;
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
index db5982be7c15f3..5defed1620aafa 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
@@ -194,30 +194,7 @@ public JsonPolymorphismOptions? PolymorphismOptions
         // Add method delegate for non-generic Stack and Queue; and types that derive from them.
         internal object? AddMethodDelegate { get; set; }
 
-        /// <summary>
-        /// Gets or sets an extension data property for the current type.
-        /// </summary>
-        /// <remarks>
-        /// Properties annotated with <see cref="JsonExtensionDataAttribute"/>
-        /// will appears here when using <see cref="DefaultJsonTypeInfoResolver"/> or <see cref="JsonSerializerContext"/>.
-        /// </remarks>
-        internal JsonPropertyInfo? ExtensionDataProperty
-        {
-            get => _extensionDataProperty;
-            set
-            {
-                VerifyMutable();
-
-                if (value != null && !IsValidDataExtensionProperty(value))
-                {
-                    ThrowHelper.ThrowInvalidOperationException_SerializationDataExtensionPropertyInvalid(Type, value);
-                }
-
-                _extensionDataProperty = value;
-            }
-        }
-
-        private JsonPropertyInfo? _extensionDataProperty;
+        internal JsonPropertyInfo? ExtensionDataProperty { get; private set; }
 
         internal PolymorphicTypeResolver? PolymorphicTypeResolver { get; private set; }
 
@@ -225,11 +202,11 @@ internal JsonPropertyInfo? ExtensionDataProperty
         private JsonTypeInfo? _elementTypeInfo;
 
         // Avoids having to perform an expensive cast to JsonTypeInfo<T> to check if there is a Serialize method.
-        internal bool HasSerialize { get; set; }
+        internal bool HasSerialize { get; private protected set; }
 
         // Configure would normally have thrown why initializing properties for source gen but type had SerializeHandler
         // so it is allowed to be used for serialization but it will throw if used for deserialization
-        internal bool ThrowOnDeserialize { get; set; }
+        internal bool ThrowOnDeserialize { get; private protected set; }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ValidateCanBeUsedForDeserialization()
@@ -275,7 +252,7 @@ internal JsonTypeInfo? ElementTypeInfo
             }
         }
 
-        internal Type? ElementType { get; set; }
+        internal Type? ElementType { get; }
 
         // If dictionary, the JsonTypeInfo for the key type.
         private JsonTypeInfo? _keyTypeInfo;
@@ -317,17 +294,17 @@ internal JsonTypeInfo? KeyTypeInfo
             }
         }
 
-        internal Type? KeyType { get; set; }
+        internal Type? KeyType { get; }
 
         /// <summary>
         /// Gets the <see cref="JsonSerializerOptions"/> instance associated with <see cref="JsonTypeInfo" />.
         /// </summary>
-        public JsonSerializerOptions Options { get; private set; }
+        public JsonSerializerOptions Options { get; }
 
         /// <summary>
         /// Type associated with JsonTypeInfo
         /// </summary>
-        public Type Type { get; private set; }
+        public Type Type { get; }
 
         /// <summary>
         /// Converter associated with the type for the given options instance
@@ -390,7 +367,7 @@ internal JsonTypeInfo(Type type, JsonConverter converter, JsonSerializerOptions
         {
             Type = type;
             Options = options;
-            PropertyInfoForTypeInfo = CreatePropertyInfoForTypeInfo(Type, converter, Options, this);
+            PropertyInfoForTypeInfo = CreatePropertyInfoForTypeInfo(this, converter);
             ElementType = converter.ElementType;
 
             switch (PropertyInfoForTypeInfo.ConverterStrategy)
@@ -494,7 +471,7 @@ internal virtual void Configure()
             {
                 PropertyCache ??= CreatePropertyCache(capacity: 0);
 
-                foreach (var jsonPropertyInfoKv in PropertyCache.List)
+                foreach (KeyValuePair<string, JsonPropertyInfo> jsonPropertyInfoKv in PropertyCache.List)
                 {
                     JsonPropertyInfo jsonPropertyInfo = jsonPropertyInfoKv.Value;
 
@@ -629,21 +606,8 @@ public JsonPropertyInfo CreateJsonPropertyInfo(Type propertyType, string name)
                 ThrowHelper.ThrowArgumentException_CannotSerializeInvalidType(nameof(propertyType), propertyType, Type, name);
             }
 
-            JsonConverter converter = GetConverter(propertyType,
-                parentClassType: null,
-                memberInfo: null,
-                options: Options,
-                out _);
-
-            JsonPropertyInfo propertyInfo = CreateProperty(
-                declaredPropertyType: propertyType,
-                memberInfo: null,
-                parentClassType: Type,
-                isVirtual: false,
-                converter: converter,
-                options: Options,
-                isUserDefinedProperty: true);
-
+            JsonConverter converter = Options.GetConverterForType(propertyType);
+            JsonPropertyInfo propertyInfo = CreateProperty(propertyType, converter);
             propertyInfo.Name = name;
 
             return propertyInfo;
@@ -651,13 +615,24 @@ public JsonPropertyInfo CreateJsonPropertyInfo(Type propertyType, string name)
 
         internal abstract JsonParameterInfoValues[] GetParameterInfoValues();
 
-        internal void CacheMember(JsonPropertyInfo jsonPropertyInfo, JsonPropertyDictionary<JsonPropertyInfo>? propertyCache, ref Dictionary<string, JsonPropertyInfo>? ignoredMembers)
+        internal void CacheMember(JsonPropertyInfo jsonPropertyInfo, JsonPropertyDictionary<JsonPropertyInfo> propertyCache, ref Dictionary<string, JsonPropertyInfo>? ignoredMembers)
         {
-            Debug.Assert(jsonPropertyInfo.ClrName != null, "ClrName can be null in custom JsonPropertyInfo instances and should never be passed in this method");
-            string memberName = jsonPropertyInfo.ClrName;
+            Debug.Assert(jsonPropertyInfo.MemberName != null, "MemberName can be null in custom JsonPropertyInfo instances and should never be passed in this method");
+            string memberName = jsonPropertyInfo.MemberName;
+
+            if (jsonPropertyInfo.IsExtensionData)
+            {
+                if (ExtensionDataProperty != null)
+                {
+                    ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateTypeAttribute(Type, typeof(JsonExtensionDataAttribute));
+                }
+
+                ExtensionDataProperty = jsonPropertyInfo;
+                return;
+            }
 
             // The JsonPropertyNameAttribute or naming policy resulted in a collision.
-            if (!propertyCache!.TryAdd(jsonPropertyInfo.Name, jsonPropertyInfo))
+            if (!propertyCache.TryAdd(jsonPropertyInfo.Name, jsonPropertyInfo))
             {
                 JsonPropertyInfo other = propertyCache[jsonPropertyInfo.Name]!;
 
@@ -671,7 +646,7 @@ internal void CacheMember(JsonPropertyInfo jsonPropertyInfo, JsonPropertyDiction
                     !jsonPropertyInfo.IsIgnored &&
                     // Is the current property hidden by the previously cached property
                     // (with `new` keyword, or by overriding)?
-                    other.ClrName != memberName &&
+                    other.MemberName != memberName &&
                     // Was a property with the same CLR name was ignored? That property hid the current property,
                     // thus, if it was ignored, the current property should be ignored too.
                     ignoredMembers?.ContainsKey(memberName) != true)
@@ -738,7 +713,7 @@ internal void InitializeConstructorParameters(JsonParameterInfoValues[] jsonPara
             foreach (KeyValuePair<string, JsonPropertyInfo> kvp in PropertyCache.List)
             {
                 JsonPropertyInfo jsonProperty = kvp.Value;
-                string propertyName = jsonProperty.ClrName ?? jsonProperty.Name;
+                string propertyName = jsonProperty.MemberName ?? jsonProperty.Name;
 
                 ParameterLookupKey key = new(propertyName, jsonProperty.PropertyType);
                 ParameterLookupValue value = new(jsonProperty);
@@ -777,8 +752,8 @@ internal void InitializeConstructorParameters(JsonParameterInfoValues[] jsonPara
                 else if (ExtensionDataProperty != null &&
                     StringComparer.OrdinalIgnoreCase.Equals(paramToCheck.Name, ExtensionDataProperty.Name))
                 {
-                    Debug.Assert(ExtensionDataProperty.ClrName != null, "Custom property info cannot be data extension property");
-                    ThrowHelper.ThrowInvalidOperationException_ExtensionDataCannotBindToCtorParam(ExtensionDataProperty.ClrName, ExtensionDataProperty);
+                    Debug.Assert(ExtensionDataProperty.MemberName != null, "Custom property info cannot be data extension property");
+                    ThrowHelper.ThrowInvalidOperationException_ExtensionDataCannotBindToCtorParam(ExtensionDataProperty.MemberName, ExtensionDataProperty);
                 }
             }
 
@@ -786,11 +761,11 @@ internal void InitializeConstructorParameters(JsonParameterInfoValues[] jsonPara
             Volatile.Write(ref ParameterCache, parameterCache);
         }
 
-        internal static void ValidateType(Type type, Type? parentClassType, MemberInfo? memberInfo, JsonSerializerOptions options)
+        internal static void ValidateType(Type type)
         {
             if (IsInvalidForSerialization(type))
             {
-                ThrowHelper.ThrowInvalidOperationException_CannotSerializeInvalidType(type, parentClassType, memberInfo);
+                ThrowHelper.ThrowInvalidOperationException_CannotSerializeInvalidType(type, declaringType: null, memberInfo: null);
             }
         }
 
@@ -823,16 +798,16 @@ private static bool IsByRefLike(Type type)
 #endif
         }
 
-        internal bool IsValidDataExtensionProperty(JsonPropertyInfo jsonPropertyInfo)
+        internal static bool IsValidExtensionDataProperty(JsonPropertyInfo jsonPropertyInfo)
         {
             Type memberType = jsonPropertyInfo.PropertyType;
 
             bool typeIsValid = typeof(IDictionary<string, object>).IsAssignableFrom(memberType) ||
                 typeof(IDictionary<string, JsonElement>).IsAssignableFrom(memberType) ||
                 // Avoid a reference to typeof(JsonNode) to support trimming.
-                (memberType.FullName == JsonObjectTypeName && ReferenceEquals(memberType.Assembly, GetType().Assembly));
+                (memberType.FullName == JsonObjectTypeName && ReferenceEquals(memberType.Assembly, typeof(JsonTypeInfo).Assembly));
 
-            return typeIsValid && Options.GetConverterFromTypeInfo(memberType) != null;
+            return typeIsValid && jsonPropertyInfo.Options.GetConverterFromTypeInfo(memberType) != null;
         }
 
         internal JsonPropertyDictionary<JsonPropertyInfo> CreatePropertyCache(int capacity)
@@ -845,30 +820,16 @@ internal JsonPropertyDictionary<JsonPropertyInfo> CreatePropertyCache(int capaci
         // - class type,
         // - element type (if the type is a collection),
         // - the converter (either native or custom), if one exists.
-        internal static JsonConverter GetConverter(
-            Type type,
-            Type? parentClassType,
-            MemberInfo? memberInfo,
+        private protected static JsonConverter GetConverterFromMember(
+            Type typeToConvert,
+            MemberInfo memberInfo,
             JsonSerializerOptions options,
             out JsonConverter? customConverter)
         {
-            Debug.Assert(type != null);
-            Debug.Assert(!IsInvalidForSerialization(type), $"Type `{type.FullName}` should already be validated.");
-            customConverter = parentClassType != null ? options.GetCustomConverterFromMember(parentClassType, type, memberInfo) : null;
-            return options.GetConverterForType(type);
-        }
-
-        internal static JsonConverter GetEffectiveConverter(
-            Type type,
-            Type? parentClassType,
-            MemberInfo? memberInfo,
-            JsonSerializerOptions options)
-        {
-            JsonConverter converter = GetConverter(type, parentClassType, memberInfo, options, out JsonConverter? customConverter);
-
-            customConverter = options.ExpandFactoryConverter(customConverter, type);
-
-            return customConverter ?? converter;
+            Debug.Assert(typeToConvert != null);
+            Debug.Assert(!IsInvalidForSerialization(typeToConvert), $"Type `{typeToConvert.FullName}` should already be validated.");
+            customConverter = options.GetCustomConverterFromMember(typeToConvert, memberInfo);
+            return options.GetConverterForType(typeToConvert);
         }
 
         private static JsonParameterInfo CreateConstructorParameter(
@@ -908,6 +869,6 @@ private static JsonTypeInfoKind GetTypeInfoKind(Type type, ConverterStrategy con
         }
 
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private string DebuggerDisplay => $"ConverterStrategy.{PropertyInfoForTypeInfo.ConverterStrategy}, {Type.Name}";
+        private string DebuggerDisplay => $"Type:{Type.Name}, TypeInfoKind:{Kind}";
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/ReflectionJsonTypeInfoOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/ReflectionJsonTypeInfoOfT.cs
index 2a0d33f6bfea25..22f322478ec604 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/ReflectionJsonTypeInfoOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/ReflectionJsonTypeInfoOfT.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
@@ -18,13 +17,7 @@ internal sealed class ReflectionJsonTypeInfo<T> : JsonTypeInfo<T>
         [RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
         [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
         internal ReflectionJsonTypeInfo(JsonSerializerOptions options)
-            : this(
-                  GetEffectiveConverter(
-                    typeof(T),
-                    parentClassType: null, // A TypeInfo never has a "parent" class.
-                    memberInfo: null, // A TypeInfo never has a "parent" property.
-                    options),
-                  options)
+            : this(options.GetConverterForType(typeof(T)), options)
         {
         }
 
@@ -67,34 +60,32 @@ private void AddPropertiesAndParametersUsingReflection()
         {
             Debug.Assert(PropertyInfoForTypeInfo.ConverterStrategy == ConverterStrategy.Object);
 
-            const BindingFlags bindingFlags =
+            const BindingFlags BindingFlags =
                 BindingFlags.Instance |
                 BindingFlags.Public |
                 BindingFlags.NonPublic |
                 BindingFlags.DeclaredOnly;
 
             Dictionary<string, JsonPropertyInfo>? ignoredMembers = null;
-            PropertyInfo[] properties = Type.GetProperties(bindingFlags);
             bool propertyOrderSpecified = false;
 
-            // PropertyCache is not accessed by other threads until the current JsonTypeInfo instance
-            //  is finished initializing and added to the cache on JsonSerializerOptions.
-            // Default 'capacity' to the common non-polymorphic + property case.
-            PropertyCache = CreatePropertyCache(capacity: properties.Length);
+            // Walk through the inheritance hierarchy, starting from the most derived type upward.
+            for (Type? currentType = Type; currentType != null; currentType = currentType.BaseType)
+            {
+                PropertyInfo[] properties = currentType.GetProperties(BindingFlags);
 
-            // We start from the most derived type.
-            Type? currentType = Type;
+                // PropertyCache is not accessed by other threads until the current JsonTypeInfo instance
+                // is finished initializing and added to the cache in JsonSerializerOptions.
+                // Default 'capacity' to the common non-polymorphic + property case.
+                PropertyCache ??= CreatePropertyCache(capacity: properties.Length);
 
-            while (true)
-            {
                 foreach (PropertyInfo propertyInfo in properties)
                 {
-                    bool isVirtual = propertyInfo.IsVirtual();
                     string propertyName = propertyInfo.Name;
 
                     // Ignore indexers and virtual properties that have overrides that were [JsonIgnore]d.
                     if (propertyInfo.GetIndexParameters().Length > 0 ||
-                        PropertyIsOverridenAndIgnored(propertyName, propertyInfo.PropertyType, isVirtual, ignoredMembers))
+                        PropertyIsOverridenAndIgnored(propertyName, propertyInfo.PropertyType, propertyInfo.IsVirtual(), ignoredMembers))
                     {
                         continue;
                     }
@@ -104,11 +95,8 @@ private void AddPropertiesAndParametersUsingReflection()
                         propertyInfo.SetMethod?.IsPublic == true)
                     {
                         CacheMember(
-                            currentType,
-                            propertyInfo.PropertyType,
-                            propertyInfo,
-                            isVirtual,
-                            NumberHandling,
+                            typeToConvert: propertyInfo.PropertyType,
+                            memberInfo: propertyInfo,
                             ref propertyOrderSpecified,
                             ref ignoredMembers);
                     }
@@ -123,7 +111,7 @@ private void AddPropertiesAndParametersUsingReflection()
                     }
                 }
 
-                foreach (FieldInfo fieldInfo in currentType.GetFields(bindingFlags))
+                foreach (FieldInfo fieldInfo in currentType.GetFields(BindingFlags))
                 {
                     string fieldName = fieldInfo.Name;
 
@@ -139,11 +127,8 @@ private void AddPropertiesAndParametersUsingReflection()
                         if (hasJsonInclude || Options.IncludeFields)
                         {
                             CacheMember(
-                                currentType,
-                                fieldInfo.FieldType,
-                                fieldInfo,
-                                isVirtual: false,
-                                NumberHandling,
+                                typeToConvert: fieldInfo.FieldType,
+                                memberInfo: fieldInfo,
                                 ref propertyOrderSpecified,
                                 ref ignoredMembers);
                         }
@@ -158,15 +143,9 @@ private void AddPropertiesAndParametersUsingReflection()
                         // Non-public fields should not be included for (de)serialization.
                     }
                 }
+            }
 
-                currentType = currentType.BaseType;
-                if (currentType == null)
-                {
-                    break;
-                }
-
-                properties = currentType.GetProperties(bindingFlags);
-            };
+            Debug.Assert(PropertyCache != null);
 
             if (propertyOrderSpecified)
             {
@@ -175,21 +154,12 @@ private void AddPropertiesAndParametersUsingReflection()
         }
 
         private void CacheMember(
-            Type declaringType,
-            Type memberType,
+            Type typeToConvert,
             MemberInfo memberInfo,
-            bool isVirtual,
-            JsonNumberHandling? typeNumberHandling,
             ref bool propertyOrderSpecified,
             ref Dictionary<string, JsonPropertyInfo>? ignoredMembers)
         {
-            bool hasExtensionAttribute = memberInfo.GetCustomAttribute<JsonExtensionDataAttribute>(inherit: false) != null;
-            if (hasExtensionAttribute && ExtensionDataProperty != null)
-            {
-                ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateTypeAttribute(Type, typeof(JsonExtensionDataAttribute));
-            }
-
-            JsonPropertyInfo? jsonPropertyInfo = AddProperty(memberInfo, memberType, declaringType, isVirtual, Options);
+            JsonPropertyInfo? jsonPropertyInfo = AddProperty(typeToConvert, memberInfo, Options);
             if (jsonPropertyInfo == null)
             {
                 // ignored invalid property
@@ -197,34 +167,24 @@ private void CacheMember(
             }
 
             Debug.Assert(jsonPropertyInfo.Name != null);
-
-            if (hasExtensionAttribute)
-            {
-                Debug.Assert(ExtensionDataProperty == null);
-                ExtensionDataProperty = jsonPropertyInfo;
-            }
-            else
-            {
-                CacheMember(jsonPropertyInfo, PropertyCache, ref ignoredMembers);
-                propertyOrderSpecified |= jsonPropertyInfo.Order != 0;
-            }
+            Debug.Assert(PropertyCache != null);
+            CacheMember(jsonPropertyInfo, PropertyCache, ref ignoredMembers);
+            propertyOrderSpecified |= jsonPropertyInfo.Order != 0;
         }
 
         private JsonPropertyInfo? AddProperty(
+            Type typeToConvert,
             MemberInfo memberInfo,
-            Type memberType,
-            Type parentClassType,
-            bool isVirtual,
             JsonSerializerOptions options)
         {
             JsonIgnoreCondition? ignoreCondition = memberInfo.GetCustomAttribute<JsonIgnoreAttribute>(inherit: false)?.Condition;
 
-            if (IsInvalidForSerialization(memberType))
+            if (IsInvalidForSerialization(typeToConvert))
             {
                 if (ignoreCondition == JsonIgnoreCondition.Always)
                     return null;
 
-                ThrowHelper.ThrowInvalidOperationException_CannotSerializeInvalidType(memberType, parentClassType, memberInfo);
+                ThrowHelper.ThrowInvalidOperationException_CannotSerializeInvalidType(typeToConvert, memberInfo.DeclaringType, memberInfo);
             }
 
             JsonConverter? customConverter;
@@ -232,34 +192,27 @@ private void CacheMember(
 
             try
             {
-                converter = GetConverter(
-                memberType,
-                parentClassType,
-                memberInfo,
-                options,
-                out customConverter);
+                converter = GetConverterFromMember(
+                    typeToConvert,
+                    memberInfo,
+                    options,
+                    out customConverter);
             }
             catch (InvalidOperationException) when (ignoreCondition == JsonIgnoreCondition.Always)
             {
                 return null;
             }
 
-            return CreateProperty(
-                declaredPropertyType: memberType,
-                memberInfo,
-                parentClassType,
-                isVirtual,
-                converter,
-                options,
-                ignoreCondition,
-                customConverter: customConverter);
+            JsonPropertyInfo jsonPropertyInfo = CreateProperty(typeToConvert, converter);
+            jsonPropertyInfo.IgnoreCondition = ignoreCondition;
+            jsonPropertyInfo.CustomConverter = customConverter;
+            jsonPropertyInfo.InitializeUsingMemberReflection(memberInfo);
+            return jsonPropertyInfo;
         }
 
         private static JsonNumberHandling? GetNumberHandlingForType(Type type)
         {
-            var numberHandlingAttribute =
-                (JsonNumberHandlingAttribute?)JsonSerializerOptions.GetAttributeThatCanHaveMultiple(type, typeof(JsonNumberHandlingAttribute));
-
+            JsonNumberHandlingAttribute? numberHandlingAttribute = type.GetUniqueCustomAttribute<JsonNumberHandlingAttribute>(inherit: false);
             return numberHandlingAttribute?.Handling;
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/SourceGenJsonTypeInfoOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/SourceGenJsonTypeInfoOfT.cs
index f50063c670318b..c981e0bc8e2d08 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/SourceGenJsonTypeInfoOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/SourceGenJsonTypeInfoOfT.cs
@@ -151,8 +151,8 @@ internal void AddPropertiesUsingSourceGenInfo()
                 {
                     if (hasJsonInclude)
                     {
-                        Debug.Assert(jsonPropertyInfo.ClrName != null, "ClrName is not set by source gen");
-                        ThrowHelper.ThrowInvalidOperationException_JsonIncludeOnNonPublicInvalid(jsonPropertyInfo.ClrName, jsonPropertyInfo.DeclaringType);
+                        Debug.Assert(jsonPropertyInfo.MemberName != null, "MemberName is not set by source gen");
+                        ThrowHelper.ThrowInvalidOperationException_JsonIncludeOnNonPublicInvalid(jsonPropertyInfo.MemberName, jsonPropertyInfo.DeclaringType);
                     }
 
                     continue;
@@ -163,17 +163,6 @@ internal void AddPropertiesUsingSourceGenInfo()
                     continue;
                 }
 
-                if (jsonPropertyInfo.SrcGen_IsExtensionData)
-                {
-                    if (ExtensionDataProperty != null)
-                    {
-                        ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateTypeAttribute(Type, typeof(JsonExtensionDataAttribute));
-                    }
-
-                    ExtensionDataProperty = jsonPropertyInfo;
-                    continue;
-                }
-
                 CacheMember(jsonPropertyInfo, propertyCache, ref ignoredMembers);
             }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs
index 1366bda342f97b..b6f448100d07b6 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs
@@ -407,7 +407,7 @@ public string PropertyPath()
             static void AppendStackFrame(StringBuilder sb, ref WriteStackFrame frame)
             {
                 // Append the property name.
-                string? propertyName = frame.JsonPropertyInfo?.ClrName;
+                string? propertyName = frame.JsonPropertyInfo?.MemberName;
                 if (propertyName == null)
                 {
                     // Attempt to get the JSON property name from the property name specified in re-entry.
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
index 025605f098e15c..b65ab991d88979 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
@@ -86,29 +86,29 @@ public static void ThrowJsonException(string? message = null)
         }
 
         [DoesNotReturn]
-        public static void ThrowArgumentException_CannotSerializeInvalidType(string paramName, Type type, Type? parentClassType, string? propertyName)
+        public static void ThrowArgumentException_CannotSerializeInvalidType(string paramName, Type typeToConvert, Type? declaringType, string? propertyName)
         {
-            if (parentClassType == null)
+            if (declaringType == null)
             {
                 Debug.Assert(propertyName == null);
-                throw new ArgumentException(SR.Format(SR.CannotSerializeInvalidType, type), paramName);
+                throw new ArgumentException(SR.Format(SR.CannotSerializeInvalidType, typeToConvert), paramName);
             }
 
             Debug.Assert(propertyName != null);
-            throw new ArgumentException(SR.Format(SR.CannotSerializeInvalidMember, type, propertyName, parentClassType), paramName);
+            throw new ArgumentException(SR.Format(SR.CannotSerializeInvalidMember, typeToConvert, propertyName, declaringType), paramName);
         }
 
         [DoesNotReturn]
-        public static void ThrowInvalidOperationException_CannotSerializeInvalidType(Type type, Type? parentClassType, MemberInfo? memberInfo)
+        public static void ThrowInvalidOperationException_CannotSerializeInvalidType(Type typeToConvert, Type? declaringType, MemberInfo? memberInfo)
         {
-            if (parentClassType == null)
+            if (declaringType == null)
             {
                 Debug.Assert(memberInfo == null);
-                throw new InvalidOperationException(SR.Format(SR.CannotSerializeInvalidType, type));
+                throw new InvalidOperationException(SR.Format(SR.CannotSerializeInvalidType, typeToConvert));
             }
 
             Debug.Assert(memberInfo != null);
-            throw new InvalidOperationException(SR.Format(SR.CannotSerializeInvalidMember, type, memberInfo.Name, parentClassType));
+            throw new InvalidOperationException(SR.Format(SR.CannotSerializeInvalidMember, typeToConvert, memberInfo.Name, declaringType));
         }
 
         [DoesNotReturn]
@@ -201,9 +201,9 @@ public static void ThrowInvalidOperationException_SerializerPropertyNameConflict
         }
 
         [DoesNotReturn]
-        public static void ThrowInvalidOperationException_SerializerPropertyNameNull(Type parentType, JsonPropertyInfo jsonPropertyInfo)
+        public static void ThrowInvalidOperationException_SerializerPropertyNameNull(JsonPropertyInfo jsonPropertyInfo)
         {
-            throw new InvalidOperationException(SR.Format(SR.SerializerPropertyNameNull, parentType, jsonPropertyInfo.MemberInfo?.Name));
+            throw new InvalidOperationException(SR.Format(SR.SerializerPropertyNameNull, jsonPropertyInfo.DeclaringType, jsonPropertyInfo.MemberName));
         }
 
         [DoesNotReturn]
@@ -267,11 +267,8 @@ public static void ThrowInvalidOperationException_IgnoreConditionOnValueTypeInva
         [DoesNotReturn]
         public static void ThrowInvalidOperationException_NumberHandlingOnPropertyInvalid(JsonPropertyInfo jsonPropertyInfo)
         {
-            MemberInfo? memberInfo = jsonPropertyInfo.MemberInfo;
-            Debug.Assert(memberInfo != null);
             Debug.Assert(!jsonPropertyInfo.IsForTypeInfo);
-
-            throw new InvalidOperationException(SR.Format(SR.NumberHandlingOnPropertyInvalid, memberInfo.Name, memberInfo.DeclaringType));
+            throw new InvalidOperationException(SR.Format(SR.NumberHandlingOnPropertyInvalid, jsonPropertyInfo.MemberName, jsonPropertyInfo.DeclaringType));
         }
 
         [DoesNotReturn]
@@ -401,14 +398,9 @@ public static void AddJsonExceptionInformation(ref WriteStack state, JsonExcepti
         }
 
         [DoesNotReturn]
-        public static void ThrowInvalidOperationException_SerializationDuplicateAttribute(Type attribute, Type classType, MemberInfo? memberInfo)
+        public static void ThrowInvalidOperationException_SerializationDuplicateAttribute(Type attribute, MemberInfo memberInfo)
         {
-            string location = classType.ToString();
-            if (memberInfo != null)
-            {
-                location += $".{memberInfo.Name}";
-            }
-
+            string location = memberInfo is Type type ? type.ToString() : $"{memberInfo.DeclaringType}.{memberInfo.Name}";
             throw new InvalidOperationException(SR.Format(SR.SerializationDuplicateAttribute, attribute, location));
         }
 
@@ -425,9 +417,9 @@ public static void ThrowInvalidOperationException_SerializationDuplicateTypeAttr
         }
 
         [DoesNotReturn]
-        public static void ThrowInvalidOperationException_SerializationDataExtensionPropertyInvalid(Type type, JsonPropertyInfo jsonPropertyInfo)
+        public static void ThrowInvalidOperationException_SerializationDataExtensionPropertyInvalid(JsonPropertyInfo jsonPropertyInfo)
         {
-            throw new InvalidOperationException(SR.Format(SR.SerializationDataExtensionPropertyInvalid, type, jsonPropertyInfo.MemberInfo?.Name));
+            throw new InvalidOperationException(SR.Format(SR.SerializationDataExtensionPropertyInvalid, jsonPropertyInfo.PropertyType, jsonPropertyInfo.MemberName));
         }
 
         [DoesNotReturn]
diff --git a/src/mono/mono/eglib/giconv.c b/src/mono/mono/eglib/giconv.c
index f7ca5c3e3b8d29..fff2b1dccf4a54 100644
--- a/src/mono/mono/eglib/giconv.c
+++ b/src/mono/mono/eglib/giconv.c
@@ -476,28 +476,35 @@ g_unichar_to_utf8 (gunichar c, gchar *outbuf)
 }
 
 static FORCE_INLINE (int)
-g_unichar_to_utf16 (gunichar c, gunichar2 *outbuf)
+g_unichar_to_utf16_endian (gunichar c, gunichar2 *outbuf, unsigned endian)
 {
 	gunichar c2;
 
 	if (c < 0xd800) {
 		if (outbuf)
-			*outbuf = (gunichar2) c;
+			*outbuf = (gunichar2) (endian == G_BIG_ENDIAN ? GUINT16_TO_BE(c) : GUINT16_TO_LE(c));
 
 		return 1;
 	} else if (c < 0xe000) {
 		return -1;
 	} else if (c < 0x10000) {
 		if (outbuf)
-			*outbuf = (gunichar2) c;
+			*outbuf = (gunichar2) (endian == G_BIG_ENDIAN ? GUINT16_TO_BE(c) : GUINT16_TO_LE(c));
 
 		return 1;
 	} else if (c < 0x110000) {
 		if (outbuf) {
 			c2 = c - 0x10000;
 
-			outbuf[0] = (gunichar2) ((c2 >> 10) + 0xd800);
-			outbuf[1] = (gunichar2) ((c2 & 0x3ff) + 0xdc00);
+			gunichar2 part1 = (c2 >> 10) + 0xd800;
+			gunichar2 part2 = (c2 & 0x3ff) + 0xdc00;
+			if (endian == G_BIG_ENDIAN) {
+				outbuf[0] = (gunichar2) GUINT16_TO_BE(part1);
+				outbuf[1] = (gunichar2) GUINT16_TO_BE(part2);
+			} else {
+				outbuf[0] = (gunichar2) GUINT16_TO_LE(part1);
+				outbuf[1] = (gunichar2) GUINT16_TO_LE(part2);
+			}
 		}
 
 		return 2;
@@ -506,6 +513,24 @@ g_unichar_to_utf16 (gunichar c, gunichar2 *outbuf)
 	}
 }
 
+static FORCE_INLINE (int)
+g_unichar_to_utf16 (gunichar c, gunichar2 *outbuf)
+{
+	return g_unichar_to_utf16_endian (c, outbuf, G_BYTE_ORDER);
+}
+
+static FORCE_INLINE (int)
+g_unichar_to_utf16be (gunichar c, gunichar2 *outbuf)
+{
+	return g_unichar_to_utf16_endian (c, outbuf, G_BIG_ENDIAN);
+}
+
+static FORCE_INLINE (int)
+g_unichar_to_utf16le (gunichar c, gunichar2 *outbuf)
+{
+	return g_unichar_to_utf16_endian (c, outbuf, G_LITTLE_ENDIAN);
+}
+
 gunichar *
 g_utf8_to_ucs4_fast (const gchar *str, glong len, glong *items_written)
 {
@@ -534,7 +559,7 @@ g_utf8_to_ucs4_fast (const gchar *str, glong len, glong *items_written)
 }
 
 static gunichar2 *
-eg_utf8_to_utf16_general (const gchar *str, glong len, glong *items_read, glong *items_written, gboolean include_nuls, gboolean replace_invalid_codepoints, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err)
+eg_utf8_to_utf16_general (const gchar *str, glong len, glong *items_read, glong *items_written, gboolean include_nuls, gboolean replace_invalid_codepoints, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err, unsigned endian)
 {
 	gunichar2 *outbuf, *outptr;
 	size_t outlen = 0;
@@ -564,7 +589,7 @@ eg_utf8_to_utf16_general (const gchar *str, glong len, glong *items_read, glong
 		if (c == 0 && !include_nuls)
 			break;
 
-		if ((u = g_unichar_to_utf16 (c, NULL)) < 0) {
+		if ((u = g_unichar_to_utf16_endian (c, NULL, endian)) < 0) {
 			if (replace_invalid_codepoints) {
 				u = 2;
 			} else {
@@ -604,7 +629,7 @@ eg_utf8_to_utf16_general (const gchar *str, glong len, glong *items_read, glong
 		if (c == 0 && !include_nuls)
 			break;
 
-		u = g_unichar_to_utf16 (c, outptr);
+		u = g_unichar_to_utf16_endian (c, outptr, endian);
 		if ((u < 0) && replace_invalid_codepoints) {
 			outptr[0] = 0xFFFD;
 			outptr[1] = 0xFFFD;
@@ -646,25 +671,49 @@ eg_utf8_to_utf16_general (const gchar *str, glong len, glong *items_read, glong
 gunichar2 *
 g_utf8_to_utf16 (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err)
 {
-	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, NULL, NULL, err);
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, NULL, NULL, err, G_BYTE_ORDER);
+}
+
+gunichar2 *
+g_utf8_to_utf16be (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err)
+{
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, NULL, NULL, err, G_BIG_ENDIAN);
+}
+
+gunichar2 *
+g_utf8_to_utf16le (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err)
+{
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, NULL, NULL, err, G_LITTLE_ENDIAN);
 }
 
 gunichar2 *
 g_utf8_to_utf16_custom_alloc (const gchar *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err)
 {
-	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, custom_alloc_func, custom_alloc_data, err);
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, custom_alloc_func, custom_alloc_data, err, G_BYTE_ORDER);
+}
+
+gunichar2 *
+g_utf8_to_utf16be_custom_alloc (const gchar *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err)
+{
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, custom_alloc_func, custom_alloc_data, err, G_BIG_ENDIAN);
+}
+
+gunichar2 *
+g_utf8_to_utf16le_custom_alloc (const gchar *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err)
+{
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, FALSE, FALSE, custom_alloc_func, custom_alloc_data, err, G_LITTLE_ENDIAN);
 }
 
 gunichar2 *
 eg_utf8_to_utf16_with_nuls (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err)
 {
-	return eg_utf8_to_utf16_general (str, len, items_read, items_written, TRUE, FALSE, NULL, NULL, err);
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, TRUE, FALSE, NULL, NULL, err, G_BYTE_ORDER);
 }
 
 gunichar2 *
 eg_wtf8_to_utf16 (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err)
 {
-	return eg_utf8_to_utf16_general (str, len, items_read, items_written, TRUE, TRUE, NULL, NULL, err);
+	return eg_utf8_to_utf16_general (str, len, items_read, items_written, TRUE, TRUE, NULL, NULL, err, G_BYTE_ORDER);
 }
 
 gunichar *
@@ -741,7 +790,7 @@ g_utf8_to_ucs4 (const gchar *str, glong len, glong *items_read, glong *items_wri
 
 static
 gchar *
-eg_utf16_to_utf8_general (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err)
+eg_utf16_to_utf8_general (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err, unsigned endian)
 {
 	char *inptr, *outbuf, *outptr;
 	size_t outlen = 0;
@@ -761,7 +810,7 @@ eg_utf16_to_utf8_general (const gunichar2 *str, glong len, glong *items_read, gl
 	inleft = len * 2;
 
 	while (inleft > 0) {
-		if ((n = decode_utf16 (inptr, inleft, &c)) < 0) {
+		if ((n = decode_utf16_endian (inptr, inleft, &c, endian)) < 0) {
 			if (n == -2 && inleft > 2) {
 				/* This means that the first UTF-16 char was read, but second failed */
 				inleft -= 2;
@@ -816,7 +865,7 @@ eg_utf16_to_utf8_general (const gunichar2 *str, glong len, glong *items_read, gl
 	inleft = len * 2;
 
 	while (inleft > 0) {
-		if ((n = decode_utf16 (inptr, inleft, &c)) < 0)
+		if ((n = decode_utf16_endian (inptr, inleft, &c, endian)) < 0)
 			break;
 		else if (c == 0)
 			break;
@@ -834,13 +883,25 @@ eg_utf16_to_utf8_general (const gunichar2 *str, glong len, glong *items_read, gl
 gchar *
 g_utf16_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err)
 {
-	return eg_utf16_to_utf8_general (str, len, items_read, items_written, NULL, NULL, err);
+	return eg_utf16_to_utf8_general (str, len, items_read, items_written, NULL, NULL, err, G_BYTE_ORDER);
+}
+
+gchar *
+g_utf16le_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err)
+{
+	return eg_utf16_to_utf8_general (str, len, items_read, items_written, NULL, NULL, err, G_LITTLE_ENDIAN);
+}
+
+gchar *
+g_utf16be_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err)
+{
+	return eg_utf16_to_utf8_general (str, len, items_read, items_written, NULL, NULL, err, G_BIG_ENDIAN);
 }
 
 gchar *
 g_utf16_to_utf8_custom_alloc (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err)
 {
-	return eg_utf16_to_utf8_general (str, len, items_read, items_written, custom_alloc_func, custom_alloc_data, err);
+	return eg_utf16_to_utf8_general (str, len, items_read, items_written, custom_alloc_func, custom_alloc_data, err, G_BYTE_ORDER);
 }
 
 gunichar *
diff --git a/src/mono/mono/eglib/glib.h b/src/mono/mono/eglib/glib.h
index 0276020f17fa20..671e08b2426be4 100644
--- a/src/mono/mono/eglib/glib.h
+++ b/src/mono/mono/eglib/glib.h
@@ -882,10 +882,14 @@ gunichar  *g_utf8_to_ucs4_fast (const gchar *str, glong len, glong *items_writte
 gunichar  *g_utf8_to_ucs4 (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err);
 G_EXTERN_C // Used by libtest, at least.
 gunichar2 *g_utf8_to_utf16 (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err);
+gunichar2 *g_utf8_to_utf16be (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err);
+gunichar2 *g_utf8_to_utf16le (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err);
 gunichar2 *eg_utf8_to_utf16_with_nuls (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err);
 gunichar2 *eg_wtf8_to_utf16 (const gchar *str, glong len, glong *items_read, glong *items_written, GError **err);
 G_EXTERN_C // Used by libtest, at least.
 gchar     *g_utf16_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err);
+gchar     *g_utf16le_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err);
+gchar     *g_utf16be_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err);
 gunichar  *g_utf16_to_ucs4 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **err);
 gchar     *g_ucs4_to_utf8  (const gunichar *str, glong len, glong *items_read, glong *items_written, GError **err);
 gunichar2 *g_ucs4_to_utf16 (const gunichar *str, glong len, glong *items_read, glong *items_written, GError **err);
@@ -911,6 +915,8 @@ gpointer
 g_fixed_buffer_custom_allocator (gsize req_size, gpointer custom_alloc_data);
 
 gunichar2 *g_utf8_to_utf16_custom_alloc (const gchar *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err);
+gunichar2 *g_utf8_to_utf16be_custom_alloc (const gchar *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err);
+gunichar2 *g_utf8_to_utf16le_custom_alloc (const gchar *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err);
 gchar *g_utf16_to_utf8_custom_alloc (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GCustomAllocator custom_alloc_func, gpointer custom_alloc_data, GError **err);
 
 /*
diff --git a/src/mono/mono/eventpipe/CMakeLists.txt b/src/mono/mono/eventpipe/CMakeLists.txt
index 30d3139e5879ad..e1e9b20a90af22 100644
--- a/src/mono/mono/eventpipe/CMakeLists.txt
+++ b/src/mono/mono/eventpipe/CMakeLists.txt
@@ -22,6 +22,10 @@ if(ENABLE_PERFTRACING)
         add_definitions(-DDISABLE_PERFTRACING_CONNECT_PORTS)
     endif (FEATURE_PERFTRACING_DISABLE_CONNECT_PORTS)
 
+    if (TARGET_S390X)
+        add_definitions(-DBIGENDIAN)
+    endif (TARGET_S390X)
+
     include (${SHARED_EVENTPIPE_SOURCE_PATH}CMakeLists.txt)
 
     set(MONO_EVENTPIPE_SHIM_SOURCES "")
diff --git a/src/mono/mono/eventpipe/ds-rt-mono.h b/src/mono/mono/eventpipe/ds-rt-mono.h
index f674dfa2e2b0dd..e951ca13825f84 100644
--- a/src/mono/mono/eventpipe/ds-rt-mono.h
+++ b/src/mono/mono/eventpipe/ds-rt-mono.h
@@ -258,8 +258,8 @@ static
 uint32_t
 ds_rt_set_environment_variable (const ep_char16_t *name, const ep_char16_t *value)
 {
-	gchar *nameNarrow = ep_rt_utf16_to_utf8_string (name, ep_rt_utf16_string_len (name));
-	gchar *valueNarrow = ep_rt_utf16_to_utf8_string (value, ep_rt_utf16_string_len (value));
+	gchar *nameNarrow = ep_rt_utf16le_to_utf8_string (name, ep_rt_utf16_string_len (name));
+	gchar *valueNarrow = ep_rt_utf16le_to_utf8_string (value, ep_rt_utf16_string_len (value));
 
 	gboolean success = g_setenv(nameNarrow, valueNarrow, true);
 
diff --git a/src/mono/mono/eventpipe/ep-rt-mono.c b/src/mono/mono/eventpipe/ep-rt-mono.c
index 9e9cd70dece9d3..36ee962b8c5813 100644
--- a/src/mono/mono/eventpipe/ep-rt-mono.c
+++ b/src/mono/mono/eventpipe/ep-rt-mono.c
@@ -38,6 +38,7 @@ gboolean _ep_rt_mono_initialized;
 
 // EventPipe TLS key.
 MonoNativeTlsKey _ep_rt_mono_thread_holder_tls_id;
+MonoNativeTlsKey _ep_rt_mono_thread_data_tls_id;
 
 // Random byte provider.
 gpointer _ep_rt_mono_rand_provider;
@@ -53,6 +54,11 @@ char *_ep_rt_mono_os_cmd_line = NULL;
 mono_lazy_init_t _ep_rt_mono_managed_cmd_line_init = MONO_LAZY_INIT_STATUS_NOT_INITIALIZED;
 char *_ep_rt_mono_managed_cmd_line = NULL;
 
+// Custom Mono EventPipe thread data.
+typedef struct _EventPipeThreadData EventPipeThreadData;
+struct _EventPipeThreadData {
+	bool prevent_profiler_event_recursion;
+};
 
 // Sample profiler.
 static GArray * _ep_rt_mono_sampled_thread_callstacks = NULL;
@@ -295,6 +301,14 @@ static ep_rt_spin_lock_handle_t _ep_rt_mono_profiler_gc_state_lock = {0};
  * Forward declares of all static functions.
  */
 
+static
+EventPipeThreadData *
+eventpipe_thread_data_get_or_create (void);
+
+static
+void
+eventpipe_thread_data_free (EventPipeThreadData *thread_data);
+
 static
 bool
 fire_method_rundown_events_func (
@@ -1221,6 +1235,26 @@ clr_instance_get_id (void)
 	return 9;
 }
 
+static
+EventPipeThreadData *
+eventpipe_thread_data_get_or_create (void)
+{
+	EventPipeThreadData *thread_data = (EventPipeThreadData *)mono_native_tls_get_value (_ep_rt_mono_thread_data_tls_id);
+	if (!thread_data) {
+		thread_data = ep_rt_object_alloc (EventPipeThreadData);
+		mono_native_tls_set_value (_ep_rt_mono_thread_data_tls_id, thread_data);
+	}
+	return thread_data;
+}
+
+static
+void
+eventpipe_thread_data_free (EventPipeThreadData *thread_data)
+{
+	ep_return_void_if_nok (thread_data != NULL);
+	ep_rt_object_free (thread_data);
+}
+
 static
 bool
 fire_method_rundown_events_func (
@@ -1845,7 +1879,8 @@ profiler_eventpipe_thread_exited (
 	ep_rt_mono_thread_exited ();
 }
 
-static bool
+static
+bool
 parse_mono_profiler_options (const ep_char8_t *option)
 {
 	do {
@@ -1931,6 +1966,7 @@ void
 ep_rt_mono_init (void)
 {
 	mono_native_tls_alloc (&_ep_rt_mono_thread_holder_tls_id, NULL);
+	mono_native_tls_alloc (&_ep_rt_mono_thread_data_tls_id, NULL);
 
 	mono_100ns_ticks ();
 	mono_rand_open ();
@@ -2115,7 +2151,7 @@ ep_rt_mono_file_open_write (const ep_char8_t *path)
 	if (!path)
 		return INVALID_HANDLE_VALUE;
 
-	ep_char16_t *path_utf16 = ep_rt_utf8_to_utf16_string (path, -1);
+	ep_char16_t *path_utf16 = ep_rt_utf8_to_utf16le_string (path, -1);
 
 	if (!path_utf16)
 		return INVALID_HANDLE_VALUE;
@@ -2335,6 +2371,11 @@ ep_rt_mono_thread_exited (void)
 		if (thread_holder)
 			thread_holder_free_func (thread_holder);
 		mono_native_tls_set_value (_ep_rt_mono_thread_holder_tls_id, NULL);
+
+		EventPipeThreadData *thread_data = (EventPipeThreadData *)mono_native_tls_get_value (_ep_rt_mono_thread_data_tls_id);
+		if (thread_data)
+			eventpipe_thread_data_free (thread_data);
+		mono_native_tls_set_value (_ep_rt_mono_thread_data_tls_id, NULL);
 	}
 }
 
@@ -2595,7 +2636,7 @@ ep_rt_mono_os_environment_get_utf16 (ep_rt_env_array_utf16_t *env_array)
 #else
 	gchar **next = NULL;
 	for (next = environ; *next != NULL; ++next)
-		ep_rt_env_array_utf16_append (env_array, ep_rt_utf8_to_utf16_string (*next, -1));
+		ep_rt_env_array_utf16_append (env_array, ep_rt_utf8_to_utf16le_string (*next, -1));
 #endif
 }
 
@@ -2646,11 +2687,32 @@ ep_rt_mono_walk_managed_stack_for_thread (
 	stack_walk_data.safe_point_frame = false;
 	stack_walk_data.runtime_invoke_frame = false;
 
+	bool restore_async_context = FALSE;
+	bool prevent_profiler_event_recursion = FALSE;
+	EventPipeThreadData *thread_data = eventpipe_thread_data_get_or_create ();
+	if (thread_data) {
+		prevent_profiler_event_recursion = thread_data->prevent_profiler_event_recursion;
+		if (prevent_profiler_event_recursion && !mono_thread_info_is_async_context ()) {
+			// Running stackwalk in async context mode is currently the only way to prevent
+			// unwinder to NOT load additional classes during stackwalk, making it signal unsafe and
+			// potential triggering uncontrolled recursion in profiler class loading event.
+			mono_thread_info_set_is_async_context (TRUE);
+			restore_async_context = TRUE;
+		}
+		thread_data->prevent_profiler_event_recursion = TRUE;
+	}
+
 	if (thread == ep_rt_thread_get_handle () && mono_get_eh_callbacks ()->mono_walk_stack_with_ctx)
 		mono_get_eh_callbacks ()->mono_walk_stack_with_ctx (eventpipe_walk_managed_stack_for_thread_func, NULL, MONO_UNWIND_SIGNAL_SAFE, &stack_walk_data);
 	else if (mono_get_eh_callbacks ()->mono_walk_stack_with_state)
 		mono_get_eh_callbacks ()->mono_walk_stack_with_state (eventpipe_walk_managed_stack_for_thread_func, mono_thread_info_get_suspend_state (thread), MONO_UNWIND_SIGNAL_SAFE, &stack_walk_data);
 
+	if (thread_data) {
+		if (restore_async_context)
+			mono_thread_info_set_is_async_context (FALSE);
+		thread_data->prevent_profiler_event_recursion = prevent_profiler_event_recursion;
+	}
+
 	return true;
 }
 
@@ -2715,8 +2777,11 @@ ep_rt_mono_sample_profiler_write_sampling_event_for_threads (
 
 	mono_stop_world (MONO_THREAD_INFO_FLAGS_NO_GC);
 
-	gboolean async_context = mono_thread_info_is_async_context ();
-	mono_thread_info_set_is_async_context (TRUE);
+	bool restore_async_context = FALSE;
+	if (!mono_thread_info_is_async_context ()) {
+		mono_thread_info_set_is_async_context (TRUE);
+		restore_async_context = TRUE;
+	}
 
 	// Record all info needed in sample events while runtime is suspended, must be async safe.
 	FOREACH_THREAD_SAFE_EXCLUDE (thread_info, MONO_THREAD_INFO_FLAGS_NO_GC | MONO_THREAD_INFO_FLAGS_NO_SAMPLE) {
@@ -2758,7 +2823,9 @@ ep_rt_mono_sample_profiler_write_sampling_event_for_threads (
 		filtered_thread_count++;
 	} FOREACH_THREAD_SAFE_END
 
-	mono_thread_info_set_is_async_context (async_context);
+	if (restore_async_context)
+		mono_thread_info_set_is_async_context (FALSE);
+
 	mono_restart_world (MONO_THREAD_INFO_FLAGS_NO_GC);
 
 	// Fire sample event for threads. Must be done after runtime is resumed since it's not async safe.
@@ -2776,7 +2843,8 @@ ep_rt_mono_sample_profiler_write_sampling_event_for_threads (
 					mono_jit_info_table_find_internal ((gpointer)data->stack_contents.stack_frames [frame_count], TRUE, FALSE);
 			}
 			mono_thread_info_set_tid (&adapter, ep_rt_uint64_t_to_thread_id_t (data->thread_id));
-			ep_write_sample_profile_event (sampling_thread, sampling_event, &adapter, &data->stack_contents, (uint8_t *)&data->payload_data, sizeof (data->payload_data));
+			uint32_t payload_data = ep_rt_val_uint32_t (data->payload_data);
+			ep_write_sample_profile_event (sampling_thread, sampling_event, &adapter, &data->stack_contents, (uint8_t *)&payload_data, sizeof (payload_data));
 		}
 	}
 
@@ -4504,7 +4572,19 @@ runtime_profiler_class_loading (
 	MonoProfiler *prof,
 	MonoClass *klass)
 {
+	bool prevent_profiler_event_recursion = FALSE;
+	EventPipeThreadData *thread_data = eventpipe_thread_data_get_or_create ();
+	if (thread_data) {
+		// Prevent additional class loading to happen recursively as part of fire TypeLoadStart event.
+		// Additional class loading can happen as part of capturing callstack for TypeLoadStart event.
+		prevent_profiler_event_recursion = thread_data->prevent_profiler_event_recursion;
+		thread_data->prevent_profiler_event_recursion = TRUE;
+	}
+
 	ep_rt_mono_write_event_type_load_start (m_class_get_byval_arg (klass));
+
+	if (thread_data)
+		thread_data->prevent_profiler_event_recursion = prevent_profiler_event_recursion;
 }
 
 static
@@ -5794,12 +5874,10 @@ mono_profiler_get_generic_types (
 			*generic_type_count = generic_instance->type_argc;
 			for (uint32_t i = 0; i < generic_instance->type_argc; ++i) {
 				uint8_t type = generic_instance->type_argv [i]->type;
-				memcpy (buffer, &type, sizeof (type));
-				buffer += sizeof (type);
+				ep_write_buffer_uint8_t (&buffer, type);
 
 				uint64_t class_id = (uint64_t)mono_class_from_mono_type_internal (generic_instance->type_argv [i]);
-				memcpy (buffer, &class_id, sizeof (class_id));
-				buffer += sizeof (class_id);
+				ep_write_buffer_uint64_t (&buffer, class_id);
 			}
 		}
 	}
diff --git a/src/mono/mono/eventpipe/ep-rt-mono.h b/src/mono/mono/eventpipe/ep-rt-mono.h
index ebe81a05d8ac34..095266b20d1f18 100644
--- a/src/mono/mono/eventpipe/ep-rt-mono.h
+++ b/src/mono/mono/eventpipe/ep-rt-mono.h
@@ -539,6 +539,70 @@ ep_rt_mono_thread_teardown (void)
 	ep_rt_mono_thread_detach ();
 }
 
+/*
+ * Little-Endian Conversion.
+ */
+
+static
+EP_ALWAYS_INLINE
+uint16_t
+ep_rt_val_uint16_t (uint16_t value)
+{
+	return GUINT16_TO_LE (value);
+}
+
+static
+EP_ALWAYS_INLINE
+uint32_t
+ep_rt_val_uint32_t (uint32_t value)
+{
+	return GUINT32_TO_LE (value);
+}
+
+static
+EP_ALWAYS_INLINE
+uint64_t
+ep_rt_val_uint64_t (uint64_t value)
+{
+	return GUINT64_TO_LE (value);
+}
+
+static
+EP_ALWAYS_INLINE
+int16_t
+ep_rt_val_int16_t (int16_t value)
+{
+	return (int16_t)GUINT16_TO_LE ((uint16_t)value);
+}
+
+static
+EP_ALWAYS_INLINE
+int32_t
+ep_rt_val_int32_t (int32_t value)
+{
+	return (int32_t)GUINT32_TO_LE ((uint32_t)value);
+}
+
+static
+EP_ALWAYS_INLINE
+int64_t
+ep_rt_val_int64_t (int64_t value)
+{
+	return (int64_t)GUINT64_TO_LE ((uint64_t)value);
+}
+
+static
+EP_ALWAYS_INLINE
+uintptr_t
+ep_rt_val_uintptr_t (uintptr_t value)
+{
+#if SIZEOF_VOID_P == 4
+	return (uintptr_t)GUINT32_TO_LE ((uint32_t)value);
+#else
+	return (uintptr_t)GUINT64_TO_LE ((uint64_t)value);
+#endif
+}
+
 /*
 * Atomics.
 */
@@ -1755,11 +1819,11 @@ ep_rt_utf8_string_replace (
 static
 inline
 ep_char16_t *
-ep_rt_utf8_to_utf16_string (
+ep_rt_utf8_to_utf16le_string (
 	const ep_char8_t *str,
 	size_t len)
 {
-	return (ep_char16_t *)(g_utf8_to_utf16 ((const gchar *)str, (glong)len, NULL, NULL, NULL));
+	return (ep_char16_t *)(g_utf8_to_utf16le ((const gchar *)str, (glong)len, NULL, NULL, NULL));
 }
 
 static
@@ -1800,6 +1864,16 @@ ep_rt_utf16_to_utf8_string (
 	return g_utf16_to_utf8 ((const gunichar2 *)str, (glong)len, NULL, NULL, NULL);
 }
 
+static
+inline
+ep_char8_t *
+ep_rt_utf16le_to_utf8_string (
+	const ep_char16_t *str,
+	size_t len)
+{
+	return g_utf16le_to_utf8 ((const gunichar2 *)str, (glong)len, NULL, NULL, NULL);
+}
+
 static
 inline
 void
diff --git a/src/native/eventpipe/ds-dump-protocol.c b/src/native/eventpipe/ds-dump-protocol.c
index 42ee6a217d60f0..869d96019105f5 100644
--- a/src/native/eventpipe/ds-dump-protocol.c
+++ b/src/native/eventpipe/ds-dump-protocol.c
@@ -106,7 +106,7 @@ dump_protocol_generate_core_dump_response_init(
 
 	payload->error = error;
 	// If this conversion failures it will set error_message to NULL which will send an empty message
-	payload->error_message = ep_rt_utf8_to_utf16_string (errorText, -1);
+	payload->error_message = ep_rt_utf8_to_utf16le_string (errorText, -1);
 }
 
 static
diff --git a/src/native/eventpipe/ds-eventpipe-protocol.c b/src/native/eventpipe/ds-eventpipe-protocol.c
index f5082bf9949552..2f7ccd504a9d2e 100644
--- a/src/native/eventpipe/ds-eventpipe-protocol.c
+++ b/src/native/eventpipe/ds-eventpipe-protocol.c
@@ -182,7 +182,7 @@ eventpipe_collect_tracing_command_try_parse_config (
 		uint32_t provider_name_byte_array_len = 0;
 		ep_raise_error_if_nok (ds_ipc_message_try_parse_string_utf16_t_byte_array_alloc (buffer, buffer_len, &provider_name_byte_array, &provider_name_byte_array_len));
 
-		provider_name_utf8 = ep_rt_utf16_to_utf8_string ((const ep_char16_t *)provider_name_byte_array, -1);
+		provider_name_utf8 = ep_rt_utf16le_to_utf8_string ((const ep_char16_t *)provider_name_byte_array, -1);
 		ep_raise_error_if_nok (provider_name_utf8 != NULL);
 
 		ep_raise_error_if_nok (!ep_rt_utf8_string_is_null_or_empty (provider_name_utf8));
@@ -195,7 +195,7 @@ eventpipe_collect_tracing_command_try_parse_config (
 
 		// This parameter is optional.
 		if (filter_data_byte_array) {
-			filter_data_utf8 = ep_rt_utf16_to_utf8_string ((const ep_char16_t *)filter_data_byte_array, -1);
+			filter_data_utf8 = ep_rt_utf16le_to_utf8_string ((const ep_char16_t *)filter_data_byte_array, -1);
 			ep_raise_error_if_nok (filter_data_utf8 != NULL);
 
 			ep_rt_byte_array_free (filter_data_byte_array);
diff --git a/src/native/eventpipe/ds-process-protocol.c b/src/native/eventpipe/ds-process-protocol.c
index 6f97ac29078cfa..52c210af2f8a7e 100644
--- a/src/native/eventpipe/ds-process-protocol.c
+++ b/src/native/eventpipe/ds-process-protocol.c
@@ -428,6 +428,7 @@ env_info_stream_env_block (
 
 	// Array<Array<WCHAR>>
 	uint32_t env_len = (uint32_t)ep_rt_env_array_utf16_size (&env_info->env_array);
+	env_len = ep_rt_val_uint32_t (env_len);
 	success &= ds_ipc_stream_write (stream, (const uint8_t *)&env_len, sizeof (env_len), &bytes_written, EP_INFINITE_WAIT);
 
 	ep_rt_env_array_utf16_iterator_t iterator = ep_rt_env_array_utf16_iterator_begin (&env_info->env_array);
@@ -485,13 +486,13 @@ process_protocol_helper_get_process_info (
 	DiagnosticsProcessInfoPayload payload;
 	DiagnosticsProcessInfoPayload *process_info_payload = NULL;
 
-	command_line = ep_rt_utf8_to_utf16_string (ep_rt_diagnostics_command_line_get (), -1);
+	command_line = ep_rt_utf8_to_utf16le_string (ep_rt_diagnostics_command_line_get (), -1);
 	ep_raise_error_if_nok (command_line != NULL);
 
-	os_info = ep_rt_utf8_to_utf16_string (ep_event_source_get_os_info (), -1);
+	os_info = ep_rt_utf8_to_utf16le_string (ep_event_source_get_os_info (), -1);
 	ep_raise_error_if_nok (os_info != NULL);
 
-	arch_info = ep_rt_utf8_to_utf16_string (ep_event_source_get_arch_info (), -1);
+	arch_info = ep_rt_utf8_to_utf16le_string (ep_event_source_get_arch_info (), -1);
 	ep_raise_error_if_nok (arch_info != NULL);
 
 	process_info_payload = ds_process_info_payload_init (
@@ -547,19 +548,19 @@ process_protocol_helper_get_process_info_2 (
 	DiagnosticsProcessInfo2Payload payload;
 	DiagnosticsProcessInfo2Payload *process_info_2_payload = NULL;
 
-	command_line = ep_rt_utf8_to_utf16_string (ep_rt_diagnostics_command_line_get (), -1);
+	command_line = ep_rt_utf8_to_utf16le_string (ep_rt_diagnostics_command_line_get (), -1);
 	ep_raise_error_if_nok (command_line != NULL);
 
-	os_info = ep_rt_utf8_to_utf16_string (ep_event_source_get_os_info (), -1);
+	os_info = ep_rt_utf8_to_utf16le_string (ep_event_source_get_os_info (), -1);
 	ep_raise_error_if_nok (os_info != NULL);
 
-	arch_info = ep_rt_utf8_to_utf16_string (ep_event_source_get_arch_info (), -1);
+	arch_info = ep_rt_utf8_to_utf16le_string (ep_event_source_get_arch_info (), -1);
 	ep_raise_error_if_nok (arch_info != NULL);
 
-	managed_entrypoint_assembly_name = ep_rt_utf8_to_utf16_string (ep_rt_entrypoint_assembly_name_get_utf8 (), -1);
+	managed_entrypoint_assembly_name = ep_rt_utf8_to_utf16le_string (ep_rt_entrypoint_assembly_name_get_utf8 (), -1);
 	ep_raise_error_if_nok (managed_entrypoint_assembly_name != NULL);
 
-	clr_product_version = ep_rt_utf8_to_utf16_string (ep_rt_runtime_version_get_utf8 (), -1);
+	clr_product_version = ep_rt_utf8_to_utf16le_string (ep_rt_runtime_version_get_utf8 (), -1);
 	ep_raise_error_if_nok (clr_product_version != NULL);
 
 	process_info_2_payload = ds_process_info_2_payload_init (
diff --git a/src/native/eventpipe/ds-protocol.c b/src/native/eventpipe/ds-protocol.c
index 2ad6e7cca2130b..228a574068f547 100644
--- a/src/native/eventpipe/ds-protocol.c
+++ b/src/native/eventpipe/ds-protocol.c
@@ -102,7 +102,7 @@ ds_icp_advertise_v1_send (DiagnosticsIpcStream *stream)
 {
 	uint8_t advertise_buffer [DOTNET_IPC_V1_ADVERTISE_SIZE];
 	uint8_t *cookie = ds_ipc_advertise_cookie_v1_get ();
-	uint64_t pid = DS_VAL64 (ep_rt_current_process_get_id ());
+	uint64_t pid = ep_rt_val_uint64_t (ep_rt_current_process_get_id ());
 	uint64_t *buffer = (uint64_t *)advertise_buffer;
 	bool result = false;
 
@@ -152,6 +152,7 @@ ipc_message_try_send_string_utf16_t (
 	uint32_t total_written = 0;
 	uint32_t written = 0;
 
+	string_len = ep_rt_val_uint32_t (string_len);
 	bool result = ds_ipc_stream_write (stream, (const uint8_t *)&string_len, (uint32_t)sizeof (string_len), &written, EP_INFINITE_WAIT);
 	total_written += written;
 
@@ -188,7 +189,7 @@ ipc_message_flatten_blitable_type (
 	ep_raise_error_if_nok (buffer != NULL);
 
 	buffer_cursor = buffer;
-	message->header.size = message->size;
+	message->header.size = ep_rt_val_uint16_t (message->size);
 
 	memcpy (buffer_cursor, &message->header, sizeof (message->header));
 	buffer_cursor += sizeof (message->header);
@@ -230,14 +231,14 @@ ipc_message_try_parse (
 	if (!result || (bytes_read < sizeof (message->header)))
 		ep_raise_error ();
 
-	if (message->header.size < sizeof (message->header))
-		ep_raise_error ();
+	message->size = ep_rt_val_uint16_t (message->header.size);
 
-	message->size = message->header.size;
+	if (message->size < sizeof (message->header))
+		ep_raise_error ();
 
 	// Then read out payload to buffer.
 	uint16_t payload_len;
-	payload_len = message->header.size - sizeof (message->header);
+	payload_len = message->size - sizeof (message->header);
 	if (payload_len != 0) {
 		buffer = ep_rt_byte_array_alloc (payload_len);
 		ep_raise_error_if_nok (buffer != NULL);
@@ -288,7 +289,7 @@ ipc_message_flatten (
 
 	uint8_t * buffer_cursor;
 	buffer_cursor = buffer;
-	message->header.size = message->size;
+	message->header.size = ep_rt_val_uint16_t (message->size);
 
 	memcpy (buffer_cursor, &message->header, sizeof (DiagnosticsIpcHeader));
 	buffer_cursor += sizeof (DiagnosticsIpcHeader);
@@ -415,7 +416,7 @@ ds_ipc_message_try_parse_uint64_t (
 
 	bool result = ds_ipc_message_try_parse_value (buffer, buffer_len, (uint8_t *)value, (uint32_t)sizeof (uint64_t));
 	if (result)
-		*value = DS_VAL64 (*value);
+		*value = ep_rt_val_uint64_t (*value);
 	return result;
 }
 
@@ -431,7 +432,7 @@ ds_ipc_message_try_parse_uint32_t (
 
 	bool result = ds_ipc_message_try_parse_value (buffer, buffer_len, (uint8_t*)value, (uint32_t)sizeof (uint32_t));
 	if (result)
-		*value = DS_VAL32 (*value);
+		*value = ep_rt_val_uint32_t (*value);
 	return result;
 }
 
@@ -499,6 +500,7 @@ ds_ipc_message_initialize_header_uint32_t_payload (
 	EP_ASSERT (header);
 
 	message->header = *header;
+	payload = ep_rt_val_uint32_t (payload);
 	return ipc_message_flatten_blitable_type (message, (uint8_t *)&payload, sizeof (payload));
 }
 
@@ -512,6 +514,7 @@ ds_ipc_message_initialize_header_uint64_t_payload (
 	EP_ASSERT (header);
 
 	message->header = *header;
+	payload = ep_rt_val_uint64_t (payload);
 	return ipc_message_flatten_blitable_type (message, (uint8_t *)&payload, sizeof (payload));
 }
 
@@ -560,6 +563,7 @@ ds_ipc_message_try_write_string_utf16_t (
 
 	bool result = true;
 	uint32_t string_len = (uint32_t)(ep_rt_utf16_string_len (value) + 1);
+	uint32_t string_len_le = ep_rt_val_uint32_t (string_len);
 	size_t total_bytes = (string_len * sizeof (ep_char16_t)) + sizeof(uint32_t);
 
 	EP_ASSERT (total_bytes <= UINT16_MAX);
@@ -567,8 +571,8 @@ ds_ipc_message_try_write_string_utf16_t (
 	if (*buffer_len < (uint16_t)total_bytes || total_bytes > UINT16_MAX)
 		ep_raise_error ();
 
-	memcpy (*buffer, &string_len, sizeof (string_len));
-	*buffer += sizeof (string_len);
+	memcpy (*buffer, &string_len_le, sizeof (string_len_le));
+	*buffer += sizeof (string_len_le);
 
 	memcpy (*buffer, value, string_len * sizeof (ep_char16_t));
 	*buffer += (string_len * sizeof (ep_char16_t));
@@ -594,11 +598,12 @@ ds_ipc_message_try_write_string_utf16_t_to_stream (
 	bool result = true;
 	uint32_t bytes_written = 0;
 	uint32_t string_len = (uint32_t)(ep_rt_utf16_string_len (value) + 1);
+	uint32_t string_len_le = ep_rt_val_uint32_t (string_len);
 	size_t total_bytes = (string_len * sizeof (ep_char16_t)) + sizeof(uint32_t);
 
 	EP_ASSERT (total_bytes <= UINT16_MAX);
 
-	result &= ds_ipc_stream_write (stream, (const uint8_t *)&string_len, sizeof (string_len), &bytes_written, EP_INFINITE_WAIT);
+	result &= ds_ipc_stream_write (stream, (const uint8_t *)&string_len_le, sizeof (string_len_le), &bytes_written, EP_INFINITE_WAIT);
 	total_bytes -= bytes_written;
 	if (result) {
 		result &= ds_ipc_stream_write (stream, (const uint8_t *)value, string_len * sizeof (ep_char16_t), &bytes_written, EP_INFINITE_WAIT);
diff --git a/src/native/eventpipe/ds-types.h b/src/native/eventpipe/ds-types.h
index 29baf2259b3bba..0787f2032053e1 100644
--- a/src/native/eventpipe/ds-types.h
+++ b/src/native/eventpipe/ds-types.h
@@ -114,16 +114,6 @@ typedef enum {
 #define DOTNET_IPC_V1_ADVERTISE_MAGIC "ADVR_V1"
 #define DOTNET_IPC_V1_ADVERTISE_SIZE 34
 
-#if BIGENDIAN
-#define DS_VAL16(x)    (((x) >> 8) | ((x) << 8))
-#define DS_VAL32(y)    (((y) >> 24) | (((y) >> 8) & 0x0000FF00L) | (((y) & 0x0000FF00L) << 8) | ((y) << 24))
-#define DS_VAL64(z)    (((uint64_t)DS_VAL32(z) << 32) | DS_VAL32((z) >> 32))
-#else
-#define DS_VAL16(x) x
-#define DS_VAL32(x) x
-#define DS_VAL64(x) x
-#endif // BIGENDIAN
-
 typedef int32_t ds_ipc_result_t;
 
 #define DS_IPC_S_OK ((ds_ipc_result_t)(0L))
diff --git a/src/native/eventpipe/ep-block.c b/src/native/eventpipe/ep-block.c
index 4561ee2274dec1..c40d76897d2be2 100644
--- a/src/native/eventpipe/ep-block.c
+++ b/src/native/eventpipe/ep-block.c
@@ -327,7 +327,7 @@ ep_block_fast_serialize (
 
 	uint32_t header_size =  ep_block_get_header_size_vcall (block);
 	uint32_t total_size = data_size + header_size;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&total_size, sizeof (total_size));
+	ep_fast_serializer_write_uint32_t (fast_serializer, total_size);
 
 	uint32_t required_padding = ep_fast_serializer_get_required_padding (fast_serializer);
 	if (required_padding != 0) {
@@ -495,16 +495,16 @@ ep_event_block_base_serialize_header (
 	ep_return_void_if_nok (((EventPipeBlock *)event_block_base)->format != EP_SERIALIZATION_FORMAT_NETPERF_V3);
 
 	const uint16_t header_size = (uint16_t)ep_block_get_header_size_vcall ((EventPipeBlock *)event_block_base);
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&header_size, sizeof (header_size));
+	ep_fast_serializer_write_uint16_t (fast_serializer, header_size);
 
 	const uint16_t flags = event_block_base->use_header_compression ? 1 : 0;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&flags, sizeof (flags));
+	ep_fast_serializer_write_uint16_t (fast_serializer, flags);
 
 	ep_timestamp_t min_timestamp = event_block_base->min_timestamp;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&min_timestamp, sizeof (min_timestamp));
+	ep_fast_serializer_write_int64_t (fast_serializer, min_timestamp);
 
 	ep_timestamp_t max_timestamp = event_block_base->max_timestamp;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&max_timestamp, sizeof (max_timestamp));
+	ep_fast_serializer_write_int64_t (fast_serializer, max_timestamp);
 }
 
 bool
@@ -536,41 +536,32 @@ ep_event_block_base_write_event (
 
 		aligned_end = write_pointer + total_size + sizeof (total_size);
 
-		memcpy (write_pointer, &total_size, sizeof (total_size));
-		write_pointer += sizeof (total_size);
+		ep_write_buffer_uint32_t (&write_pointer, total_size);
 
 		uint32_t metadata_id = ep_event_instance_get_metadata_id (event_instance);
 		EP_ASSERT ((metadata_id & (1 << 31)) == 0);
 
 		metadata_id |= (!is_sorted_event ? 1 << 31 : 0);
-		memcpy (write_pointer, &metadata_id, sizeof (metadata_id));
-		write_pointer += sizeof (metadata_id);
+		ep_write_buffer_uint32_t (&write_pointer, metadata_id);
 
 		if (block->format == EP_SERIALIZATION_FORMAT_NETPERF_V3) {
 			uint32_t thread_id = (uint32_t)ep_event_instance_get_thread_id (event_instance);
-			memcpy (write_pointer, &thread_id, sizeof (thread_id));
-			write_pointer += sizeof (thread_id);
+			ep_write_buffer_uint32_t (&write_pointer, thread_id);
 		} else if (block->format == EP_SERIALIZATION_FORMAT_NETTRACE_V4) {
-			memcpy (write_pointer, &sequence_number, sizeof (sequence_number));
-			write_pointer += sizeof (sequence_number);
+			ep_write_buffer_uint32_t (&write_pointer, sequence_number);
 
 			uint64_t thread_id = ep_event_instance_get_thread_id (event_instance);
-			memcpy (write_pointer, &thread_id, sizeof (thread_id));
-			write_pointer += sizeof (thread_id);
+			ep_write_buffer_uint64_t (&write_pointer, thread_id);
 
-			memcpy (write_pointer, &capture_thread_id, sizeof (capture_thread_id));
-			write_pointer += sizeof (capture_thread_id);
+			ep_write_buffer_uint64_t (&write_pointer, capture_thread_id);
 
-			memcpy (write_pointer, &capture_proc_number, sizeof (capture_proc_number));
-			write_pointer += sizeof (capture_proc_number);
+			ep_write_buffer_uint32_t (&write_pointer, capture_proc_number);
 
-			memcpy (write_pointer, &stack_id, sizeof (stack_id));
-			write_pointer += sizeof (stack_id);
+			ep_write_buffer_uint32_t (&write_pointer, stack_id);
 		}
 
 		ep_timestamp_t timestamp = ep_event_instance_get_timestamp (event_instance);
-		memcpy (write_pointer, &timestamp, sizeof (timestamp));
-		write_pointer += sizeof (timestamp);
+		ep_write_buffer_int64_t (&write_pointer, timestamp);
 
 		const uint8_t *activity_id = ep_event_instance_get_activity_id_cref (event_instance);
 		memcpy (write_pointer, activity_id, EP_ACTIVITY_ID_SIZE);
@@ -581,8 +572,7 @@ ep_event_block_base_write_event (
 		write_pointer += EP_ACTIVITY_ID_SIZE;
 
 		data_len = ep_event_instance_get_data_len (event_instance);
-		memcpy (write_pointer, &data_len, sizeof (data_len));
-		write_pointer += sizeof (data_len);
+		ep_write_buffer_uint32_t (&write_pointer, data_len);
 	} else { // using header compression
 		uint8_t flags = 0;
 		uint8_t *header_write_pointer = &event_block_base->compressed_header[0];
@@ -672,8 +662,7 @@ ep_event_block_base_write_event (
 
 	if (block->format == EP_SERIALIZATION_FORMAT_NETPERF_V3) {
 		uint32_t stack_size = ep_stack_contents_instance_get_size (ep_event_instance_get_stack_contents_instance_ref (event_instance));
-		memcpy (write_pointer, &stack_size, sizeof (stack_size));
-		write_pointer += sizeof (stack_size);
+		ep_write_buffer_uint32_t (&write_pointer, stack_size);
 
 		if (stack_size > 0) {
 			memcpy (write_pointer, ep_stack_contents_instance_get_pointer (ep_event_instance_get_stack_contents_instance_ref (event_instance)), stack_size);
@@ -909,12 +898,10 @@ ep_sequence_point_block_init (
 		EP_SERIALIZATION_FORMAT_NETTRACE_V4) != NULL);
 
 	const ep_timestamp_t timestamp = ep_sequence_point_get_timestamp (sequence_point);
-	memcpy (sequence_point_block->block.write_pointer, &timestamp, sizeof (timestamp));
-	sequence_point_block->block.write_pointer += sizeof (timestamp);
+	ep_write_buffer_timestamp (&sequence_point_block->block.write_pointer, timestamp);
 
 	const uint32_t thread_count = ep_rt_thread_sequence_number_map_count (ep_sequence_point_get_thread_sequence_numbers_cref (sequence_point));
-	memcpy (sequence_point_block->block.write_pointer, &thread_count, sizeof (thread_count));
-	sequence_point_block->block.write_pointer += sizeof (thread_count);
+	ep_write_buffer_uint32_t (&sequence_point_block->block.write_pointer, thread_count);
 
 	for (ep_rt_thread_sequence_number_hash_map_iterator_t iterator = ep_rt_thread_sequence_number_map_iterator_begin (ep_sequence_point_get_thread_sequence_numbers_cref (sequence_point));
 		!ep_rt_thread_sequence_number_map_iterator_end (ep_sequence_point_get_thread_sequence_numbers_cref (sequence_point), &iterator);
@@ -923,12 +910,10 @@ ep_sequence_point_block_init (
 		const EventPipeThreadSessionState *key = ep_rt_thread_sequence_number_map_iterator_key (&iterator);
 
 		const uint64_t thread_id = ep_thread_get_os_thread_id (ep_thread_session_state_get_thread (key));
-		memcpy (sequence_point_block->block.write_pointer, &thread_id, sizeof (thread_id));
-		sequence_point_block->block.write_pointer += sizeof (thread_id);
+		ep_write_buffer_uint64_t (&sequence_point_block->block.write_pointer, thread_id);
 
 		const uint32_t sequence_number = ep_rt_thread_sequence_number_map_iterator_value (&iterator);
-		memcpy (sequence_point_block->block.write_pointer, &sequence_number, sizeof (sequence_number));
-		sequence_point_block->block.write_pointer += sizeof (sequence_number);
+		ep_write_buffer_uint32_t (&sequence_point_block->block.write_pointer, sequence_number);
 	}
 
 	return sequence_point_block;
@@ -1003,8 +988,8 @@ stack_block_serialize_header_func (
 	EP_ASSERT (fast_serializer != NULL);
 
 	EventPipeStackBlock *stack_block = (EventPipeStackBlock *)object;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&stack_block->initial_index, sizeof (stack_block->initial_index));
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&stack_block->count, sizeof (stack_block->count));
+	ep_fast_serializer_write_uint32_t (fast_serializer, stack_block->initial_index);
+	ep_fast_serializer_write_uint32_t (fast_serializer, stack_block->count);
 }
 
 static EventPipeBlockVtable stack_block_vtable = {
@@ -1072,8 +1057,7 @@ ep_stack_block_write_stack (
 
 	stack_block->count++;
 
-	memcpy (write_pointer, &stack_size, sizeof (stack_size));
-	write_pointer += sizeof (stack_size);
+	ep_write_buffer_uint32_t (&write_pointer, stack_size);
 
 	if (stack_size > 0) {
 		memcpy (write_pointer, ep_stack_contents_instance_get_pointer (stack), stack_size);
diff --git a/src/native/eventpipe/ep-config.c b/src/native/eventpipe/ep-config.c
index f2b24b215dadc1..626e07b5ffcaf2 100644
--- a/src/native/eventpipe/ep-config.c
+++ b/src/native/eventpipe/ep-config.c
@@ -367,11 +367,9 @@ ep_config_build_event_metadata_event (
 	uint8_t *current;
 	current = instance_payload;
 
-	memcpy(current, &metadata_id, sizeof(metadata_id));
-	current += sizeof(metadata_id);
+	ep_write_buffer_uint32_t (&current, metadata_id);
 
-	memcpy(current, provider_name_utf16, provider_name_len);
-	current += provider_name_len;
+	ep_write_buffer_string_utf16_t (&current, provider_name_utf16, provider_name_len);
 
 	// Write the incoming payload data.
 	memcpy(current, payload_data, payload_data_len);
diff --git a/src/native/eventpipe/ep-event-source.c b/src/native/eventpipe/ep-event-source.c
index 5fd07ab77ebd0a..497de0ea8f1259 100644
--- a/src/native/eventpipe/ep-event-source.c
+++ b/src/native/eventpipe/ep-event-source.c
@@ -108,19 +108,19 @@ ep_event_source_init (EventPipeEventSource *event_source)
 	uint32_t params_len;
 	params_len = (uint32_t)ARRAY_SIZE (params);
 
-	command_line_arg_utf16 = ep_rt_utf8_to_utf16_string ("CommandLine", -1);
+	command_line_arg_utf16 = ep_rt_utf8_to_utf16le_string ("CommandLine", -1);
 	ep_raise_error_if_nok (command_line_arg_utf16 != NULL);
 	ep_parameter_desc_init (&params[0], EP_PARAMETER_TYPE_STRING, command_line_arg_utf16);
 
-	os_info_arg_utf16 = ep_rt_utf8_to_utf16_string ("OSInformation", -1);
+	os_info_arg_utf16 = ep_rt_utf8_to_utf16le_string ("OSInformation", -1);
 	ep_raise_error_if_nok (os_info_arg_utf16 != NULL);
 	ep_parameter_desc_init (&params[1], EP_PARAMETER_TYPE_STRING, os_info_arg_utf16);
 
-	arch_info_arg_utf16 = ep_rt_utf8_to_utf16_string ("ArchInformation", -1);
+	arch_info_arg_utf16 = ep_rt_utf8_to_utf16le_string ("ArchInformation", -1);
 	ep_raise_error_if_nok (arch_info_arg_utf16 != NULL);
 	ep_parameter_desc_init (&params[2], EP_PARAMETER_TYPE_STRING, arch_info_arg_utf16);
 
-	event_name_utf16 = ep_rt_utf8_to_utf16_string ("ProcessInfo", -1);
+	event_name_utf16 = ep_rt_utf8_to_utf16le_string ("ProcessInfo", -1);
 	ep_raise_error_if_nok (event_name_utf16 != NULL);
 
 	size_t metadata_len;
@@ -215,9 +215,9 @@ ep_event_source_send_process_info (
 	ep_char16_t *os_info_utf16 = NULL;
 	ep_char16_t *arch_info_utf16 = NULL;
 
-	command_line_utf16 = ep_rt_utf8_to_utf16_string (command_line, -1);
-	os_info_utf16 = ep_rt_utf8_to_utf16_string (ep_event_source_get_os_info (), -1);
-	arch_info_utf16 = ep_rt_utf8_to_utf16_string (ep_event_source_get_arch_info (), -1);
+	command_line_utf16 = ep_rt_utf8_to_utf16le_string (command_line, -1);
+	os_info_utf16 = ep_rt_utf8_to_utf16le_string (ep_event_source_get_os_info (), -1);
+	arch_info_utf16 = ep_rt_utf8_to_utf16le_string (ep_event_source_get_arch_info (), -1);
 
 	EventData data [3] = { { 0 } };
 	if (command_line_utf16)
diff --git a/src/native/eventpipe/ep-file.c b/src/native/eventpipe/ep-file.c
index c587365ebe88fa..04291bee5a85cf 100644
--- a/src/native/eventpipe/ep-file.c
+++ b/src/native/eventpipe/ep-file.c
@@ -93,15 +93,15 @@ file_fast_serialize_func (void *object, FastSerializer *fast_serializer)
 	EP_ASSERT (fast_serializer != NULL);
 
 	EventPipeFile *file = (EventPipeFile *)object;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->file_open_system_time, sizeof (file->file_open_system_time));
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->file_open_timestamp, sizeof (file->file_open_timestamp));
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->timestamp_frequency, sizeof (file->timestamp_frequency));
+	ep_fast_serializer_write_system_time (fast_serializer, &file->file_open_system_time);
+	ep_fast_serializer_write_timestamp (fast_serializer, file->file_open_timestamp);
+	ep_fast_serializer_write_int64_t (fast_serializer, file->timestamp_frequency);
 
 	// the beginning of V3
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->pointer_size, sizeof (file->pointer_size));
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->current_process_id, sizeof (file->current_process_id));
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->number_of_processors, sizeof (file->number_of_processors));
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&file->sampling_rate_in_ns, sizeof (file->sampling_rate_in_ns));
+	ep_fast_serializer_write_uint32_t (fast_serializer, file->pointer_size);
+	ep_fast_serializer_write_uint32_t (fast_serializer, file->current_process_id);
+	ep_fast_serializer_write_uint32_t (fast_serializer, file->number_of_processors);
+	ep_fast_serializer_write_uint32_t (fast_serializer, file->sampling_rate_in_ns);
 }
 
 static
diff --git a/src/native/eventpipe/ep-metadata-generator.c b/src/native/eventpipe/ep-metadata-generator.c
index 25a8b647a291e4..4a8e669c82f306 100644
--- a/src/native/eventpipe/ep-metadata-generator.c
+++ b/src/native/eventpipe/ep-metadata-generator.c
@@ -176,6 +176,7 @@ metadata_generator_write_uint32_to_buffer (
 	uint32_t value)
 {
 	EP_ASSERT ((*offset + sizeof (value)) <= buffer_len);
+	value = ep_rt_val_uint32_t (value);
 	memcpy (buffer + *offset, &value, sizeof (value));
 	*offset += sizeof (value);
 }
@@ -189,6 +190,7 @@ metadata_generator_write_int64_to_buffer (
 	int64_t value)
 {
 	EP_ASSERT ((*offset + sizeof (value)) <= buffer_len);
+	value = ep_rt_val_int64_t (value);
 	memcpy (buffer + *offset, &value, sizeof (value));
 	*offset += sizeof (value);
 }
diff --git a/src/native/eventpipe/ep-provider.c b/src/native/eventpipe/ep-provider.c
index 566b09270d3af8..c8640433478fb4 100644
--- a/src/native/eventpipe/ep-provider.c
+++ b/src/native/eventpipe/ep-provider.c
@@ -178,7 +178,7 @@ ep_provider_alloc (
 	instance->provider_name = ep_rt_utf8_string_dup (provider_name);
 	ep_raise_error_if_nok (instance->provider_name != NULL);
 
-	instance->provider_name_utf16 = ep_rt_utf8_to_utf16_string (provider_name, -1);
+	instance->provider_name_utf16 = ep_rt_utf8_to_utf16le_string (provider_name, -1);
 	ep_raise_error_if_nok (instance->provider_name_utf16 != NULL);
 
 	ep_rt_event_list_alloc (&instance->event_list);
diff --git a/src/native/eventpipe/ep-rt.h b/src/native/eventpipe/ep-rt.h
index 8684e155a5d983..efd681fdeec108 100644
--- a/src/native/eventpipe/ep-rt.h
+++ b/src/native/eventpipe/ep-rt.h
@@ -150,6 +150,45 @@ prefix_name ## _rt_ ## type_name ## _ ## func_name
 
 #define EP_RT_DEFINE_HASH_MAP_ITERATOR ep_rt_redefine
 
+/*
+ * Little-Endian Conversion.
+ */
+
+static
+inline
+uint16_t
+ep_rt_val_uint16_t (uint16_t value);
+
+static
+inline
+uint32_t
+ep_rt_val_uint32_t (uint32_t value);
+
+static
+inline
+uint64_t
+ep_rt_val_uint64_t (uint64_t value);
+
+static
+inline
+int16_t
+ep_rt_val_int16_t (int16_t value);
+
+static
+inline
+int32_t
+ep_rt_val_int32_t (int32_t value);
+
+static
+inline
+int64_t
+ep_rt_val_int64_t (int64_t value);
+
+static
+inline
+uintptr_t
+ep_rt_val_uintptr_t (uintptr_t value);
+
 /*
 * Atomics.
 */
@@ -725,7 +764,7 @@ ep_rt_utf8_string_replace (
 
 static
 ep_char16_t *
-ep_rt_utf8_to_utf16_string (
+ep_rt_utf8_to_utf16le_string (
 	const ep_char8_t *str,
 	size_t len);
 
@@ -747,6 +786,12 @@ ep_rt_utf16_to_utf8_string (
 	const ep_char16_t *str,
 	size_t len);
 
+static
+ep_char8_t *
+ep_rt_utf16le_to_utf8_string (
+	const ep_char16_t *str,
+	size_t len);
+
 static
 void
 ep_rt_utf16_string_free (ep_char16_t *str);
diff --git a/src/native/eventpipe/ep-stack-contents.h b/src/native/eventpipe/ep-stack-contents.h
index bf82c023c458e6..b006bae0cc4fff 100644
--- a/src/native/eventpipe/ep-stack-contents.h
+++ b/src/native/eventpipe/ep-stack-contents.h
@@ -4,6 +4,7 @@
 #include "ep-rt-config.h"
 
 #ifdef ENABLE_PERFTRACING
+#include "ep-rt.h"
 #include "ep-types.h"
 
 #undef EP_IMPL_GETTER_SETTER
@@ -109,7 +110,7 @@ ep_stack_contents_append (
 	EP_ASSERT (stack_contents != NULL);
 	uint32_t next_frame = ep_stack_contents_get_next_available_frame (stack_contents);
 	if (next_frame < EP_MAX_STACK_DEPTH) {
-		ep_stack_contents_get_stack_frames_ref (stack_contents)[next_frame] = control_pc;
+		ep_stack_contents_get_stack_frames_ref (stack_contents)[next_frame] = ep_rt_val_uintptr_t (control_pc);
 #ifdef EP_CHECKED_BUILD
 		ep_stack_contents_get_methods_ref (stack_contents)[next_frame] = method;
 #endif
diff --git a/src/native/eventpipe/ep-stream.c b/src/native/eventpipe/ep-stream.c
index 3f3551674dd444..cad5516adbcff7 100644
--- a/src/native/eventpipe/ep-stream.c
+++ b/src/native/eventpipe/ep-stream.c
@@ -136,24 +136,22 @@ static
 void
 fast_serializer_write_serialization_type (
 	FastSerializer *fast_serializer,
-	FastSerializableObject *fast_serializable_ojbect)
+	FastSerializableObject *fast_serializable_object)
 {
-	EP_ASSERT (fast_serializable_ojbect != NULL);
+	EP_ASSERT (fast_serializable_object != NULL);
 
 	// Write the BeginObject tag.
-	ep_fast_serializer_write_tag (fast_serializer, fast_serializable_ojbect->is_private ? FAST_SERIALIZER_TAGS_BEGIN_PRIVATE_OBJECT : FAST_SERIALIZER_TAGS_BEGIN_OBJECT, NULL, 0);
+	ep_fast_serializer_write_tag (fast_serializer, fast_serializable_object->is_private ? FAST_SERIALIZER_TAGS_BEGIN_PRIVATE_OBJECT : FAST_SERIALIZER_TAGS_BEGIN_OBJECT, NULL, 0);
 
 	// Write a NullReferenceTag, which implies that the following fields belong to SerializationType.
 	ep_fast_serializer_write_tag (fast_serializer, FAST_SERIALIZER_TAGS_NULL_REFERENCE, NULL, 0);
 
 	// Write the SerializationType version fields.
-	int32_t serialization_type [2];
-	serialization_type [0] = fast_serializable_ojbect->object_version;
-	serialization_type [1] = fast_serializable_ojbect->min_reader_version;
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)serialization_type, sizeof (serialization_type));
+	ep_fast_serializer_write_int32_t (fast_serializer, fast_serializable_object->object_version);
+	ep_fast_serializer_write_int32_t (fast_serializer, fast_serializable_object->min_reader_version);
 
 	// Write the SerializationType TypeName field.
-	const ep_char8_t *type_name = ep_fast_serializable_object_get_type_name_vcall (fast_serializable_ojbect);
+	const ep_char8_t *type_name = ep_fast_serializable_object_get_type_name_vcall (fast_serializable_object);
 	if (type_name)
 		ep_fast_serializer_write_string (fast_serializer, type_name, (uint32_t)strlen (type_name));
 
@@ -224,6 +222,28 @@ ep_fast_serializer_write_buffer (
 	fast_serializer->write_error_encountered = ((buffer_len != bytes_written) || !result);
 }
 
+void
+ep_fast_serializer_write_system_time (
+	FastSerializer *fast_serializer,
+	const EventPipeSystemTime *system_time)
+{
+	EP_ASSERT (fast_serializer != NULL);
+	EP_ASSERT (system_time != NULL);
+
+#if BIGENDIAN
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->year);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->month);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->day_of_week);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->day);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->hour);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->minute);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->second);
+	ep_fast_serializer_write_uint16_t (fast_serializer, system_time->milliseconds);
+#else
+	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)system_time, sizeof (*system_time));
+#endif
+}
+
 void
 ep_fast_serializer_write_object (
 	FastSerializer *fast_serializer,
@@ -249,7 +269,7 @@ ep_fast_serializer_write_string (
 	uint32_t contents_len)
 {
 	// Write the string length.
-	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)&contents_len, sizeof (contents_len));
+	ep_fast_serializer_write_uint32_t (fast_serializer, contents_len);
 
 	//Wirte the string contents.
 	ep_fast_serializer_write_buffer (fast_serializer, (const uint8_t *)contents, contents_len);
diff --git a/src/native/eventpipe/ep-stream.h b/src/native/eventpipe/ep-stream.h
index 4e4215e5ffe10f..52c1023c5f3e88 100644
--- a/src/native/eventpipe/ep-stream.h
+++ b/src/native/eventpipe/ep-stream.h
@@ -186,6 +186,42 @@ ep_fast_serializer_write_buffer (
 	const uint8_t *buffer,
 	uint32_t buffer_len);
 
+#define EP_FAST_SERIALIZER_WRITE_INT(BITS, SIGNEDNESS) \
+static \
+inline \
+void \
+ep_fast_serializer_write_##SIGNEDNESS##int##BITS##_t ( \
+	FastSerializer *fast_serializer, \
+	SIGNEDNESS##int##BITS##_t value) \
+{ \
+	value = ep_rt_val_##SIGNEDNESS##int##BITS##_t (value); \
+	ep_fast_serializer_write_buffer (fast_serializer, (uint8_t *)&value, sizeof (value)); \
+}
+
+EP_FAST_SERIALIZER_WRITE_INT (16, )
+EP_FAST_SERIALIZER_WRITE_INT (16, u)
+EP_FAST_SERIALIZER_WRITE_INT (32, )
+EP_FAST_SERIALIZER_WRITE_INT (32, u)
+EP_FAST_SERIALIZER_WRITE_INT (64, )
+EP_FAST_SERIALIZER_WRITE_INT (64, u)
+
+#undef EP_FAST_SERIALIZER_WRITE_INT
+
+static
+inline
+void
+ep_fast_serializer_write_timestamp (
+	FastSerializer *fast_serializer,
+	ep_timestamp_t value)
+{
+	ep_fast_serializer_write_int64_t (fast_serializer, value);
+}
+
+void
+ep_fast_serializer_write_system_time (
+	FastSerializer *fast_serializer,
+	const EventPipeSystemTime *system_time);
+
 void
 ep_fast_serializer_write_object (
 	FastSerializer *fast_serializer,
diff --git a/src/native/eventpipe/ep.h b/src/native/eventpipe/ep.h
index daeaa8d9b7b5fb..29176c5f9bb45c 100644
--- a/src/native/eventpipe/ep.h
+++ b/src/native/eventpipe/ep.h
@@ -288,6 +288,56 @@ ep_system_time_get (EventPipeSystemTime *system_time)
 void
 ep_ipc_stream_factory_callback_set (EventPipeIpcStreamFactorySuspendedPortsCallback suspended_ports_callback);
 
+/*
+ * EventPipeWriteBuffer.
+ */
+
+static
+inline
+void
+ep_write_buffer_uint8_t (uint8_t **buffer, uint8_t value)
+{
+	memcpy (*buffer, &value, sizeof (value));
+	*buffer += sizeof (value);
+}
+
+#define EP_WRITE_BUFFER_INT(BITS, SIGNEDNESS) \
+static \
+inline \
+void \
+ep_write_buffer_##SIGNEDNESS##int##BITS##_t (uint8_t **buffer, SIGNEDNESS##int##BITS##_t value) \
+{ \
+	value = ep_rt_val_##SIGNEDNESS##int##BITS##_t (value); \
+	memcpy (*buffer, &value, sizeof (value)); \
+	*buffer += sizeof (value); \
+}
+
+EP_WRITE_BUFFER_INT (16, )
+EP_WRITE_BUFFER_INT (16, u)
+EP_WRITE_BUFFER_INT (32, )
+EP_WRITE_BUFFER_INT (32, u)
+EP_WRITE_BUFFER_INT (64, )
+EP_WRITE_BUFFER_INT (64, u)
+
+#undef EP_WRITE_BUFFER_INT
+
+static
+inline
+void
+ep_write_buffer_string_utf16_t (uint8_t **buf, const ep_char16_t *str, size_t len)
+{
+	memcpy (*buf, str, len);
+	*buf += len;
+}
+
+static
+inline
+void
+ep_write_buffer_timestamp (uint8_t **buffer, ep_timestamp_t value)
+{
+	ep_write_buffer_int64_t (buffer, value);
+}
+
 #else /* ENABLE_PERFTRACING */
 
 static