diff --git a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/UDPClient.cs b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/UDPClient.cs
index 7646d0ae458d3..8d628720d7e43 100644
--- a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/UDPClient.cs
+++ b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/UDPClient.cs
@@ -379,14 +379,7 @@ public byte[] EndReceive(IAsyncResult asyncResult, ref IPEndPoint? remoteEP)
 
             // Because we don't return the actual length, we need to ensure the returned buffer
             // has the appropriate length.
-            if (received < MaxUDPSize)
-            {
-                byte[] newBuffer = new byte[received];
-                Buffer.BlockCopy(_buffer, 0, newBuffer, 0, received);
-                return newBuffer;
-            }
-
-            return _buffer;
+            return _buffer.AsSpan(0, received).ToArray();
         }
 
         // Joins a multicast address group.
@@ -623,11 +616,7 @@ public Task<UdpReceiveResult> ReceiveAsync()
             async Task<UdpReceiveResult> WaitAndWrap(Task<SocketReceiveFromResult> task)
             {
                 SocketReceiveFromResult result = await task.ConfigureAwait(false);
-
-                byte[] buffer = result.ReceivedBytes < MaxUDPSize ?
-                    _buffer.AsSpan(0, result.ReceivedBytes).ToArray() :
-                    _buffer;
-
+                byte[] buffer = _buffer.AsSpan(0, result.ReceivedBytes).ToArray();
                 return new UdpReceiveResult(buffer, (IPEndPoint)result.RemoteEndPoint);
             }
         }
@@ -653,11 +642,7 @@ public ValueTask<UdpReceiveResult> ReceiveAsync(CancellationToken cancellationTo
             async ValueTask<UdpReceiveResult> WaitAndWrap(ValueTask<SocketReceiveFromResult> task)
             {
                 SocketReceiveFromResult result = await task.ConfigureAwait(false);
-
-                byte[] buffer = result.ReceivedBytes < MaxUDPSize ?
-                    _buffer.AsSpan(0, result.ReceivedBytes).ToArray() :
-                    _buffer;
-
+                byte[] buffer = _buffer.AsSpan(0, result.ReceivedBytes).ToArray();
                 return new UdpReceiveResult(buffer, (IPEndPoint)result.RemoteEndPoint);
             }
         }
@@ -845,14 +830,7 @@ public byte[] Receive([NotNull] ref IPEndPoint? remoteEP)
 
             // because we don't return the actual length, we need to ensure the returned buffer
             // has the appropriate length.
-
-            if (received < MaxUDPSize)
-            {
-                byte[] newBuffer = new byte[received];
-                Buffer.BlockCopy(_buffer, 0, newBuffer, 0, received);
-                return newBuffer;
-            }
-            return _buffer;
+            return _buffer.AsSpan(0, received).ToArray();
         }
 
 
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/UdpClientTest.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/UdpClientTest.cs
index 1b90ef0d688d4..4b8db5e71d6d2 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/UdpClientTest.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/UdpClientTest.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -517,11 +518,12 @@ public void Send_Receive_Success(bool ipv4)
             using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
             using (var sender = new UdpClient(new IPEndPoint(address, 0)))
             {
-                sender.Send(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
-                AssertReceive(receiver);
+                byte[] data = [1, 2, 3];
+                sender.Send(data, 2, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
+                AssertReceive(receiver, [1, 2]);
 
-                sender.Send(new ReadOnlySpan<byte>(new byte[1]), new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
-                AssertReceive(receiver);
+                sender.Send(new ReadOnlySpan<byte>(data), new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
+                AssertReceive(receiver, data);
             }
         }
 
@@ -536,11 +538,12 @@ public void Send_Receive_With_HostName_Success(bool ipv4)
             using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
             using (var sender = new UdpClient(new IPEndPoint(address, 0)))
             {
-                sender.Send(new byte[1], 1, "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
-                AssertReceive(receiver);
+                byte[] data = [1, 2, 3];
+                sender.Send(data, 2, "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
+                AssertReceive(receiver, [1, 2]);
 
-                sender.Send(new ReadOnlySpan<byte>(new byte[1]), "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
-                AssertReceive(receiver);
+                sender.Send(new ReadOnlySpan<byte>(data), "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
+                AssertReceive(receiver, data);
             }
         }
 
@@ -551,20 +554,22 @@ public void Send_Receive_Connected_Success()
             using (var receiver = new UdpClient("localhost", 0))
             using (var sender = new UdpClient("localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port))
             {
-                sender.Send(new byte[1], 1);
-                AssertReceive(receiver);
+                byte[] data = [1, 2, 3];
+
+                sender.Send(data, 2);
+                AssertReceive(receiver, [1, 2]);
 
-                sender.Send(new ReadOnlySpan<byte>(new byte[1]));
-                AssertReceive(receiver);
+                sender.Send(new ReadOnlySpan<byte>(data));
+                AssertReceive(receiver, data);
             }
         }
 
-        private static void AssertReceive(UdpClient receiver)
+        private static void AssertReceive(UdpClient receiver, byte[] sentData)
         {
             IPEndPoint remoteEP = null;
             byte[] data = receiver.Receive(ref remoteEP);
             Assert.NotNull(remoteEP);
-            Assert.InRange(data.Length, 1, int.MaxValue);
+            Assert.True(Enumerable.SequenceEqual(sentData, data));
         }
 
         [Theory]
@@ -589,16 +594,17 @@ public void Send_Available_Success(bool ipv4)
         public void BeginEndSend_BeginEndReceive_Success(bool ipv4)
         {
             IPAddress address = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
+            byte[] data = [1, 2, 3];
 
             using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
             using (var sender = new UdpClient(new IPEndPoint(address, 0)))
             {
-                sender.EndSend(sender.BeginSend(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port), null, null));
+                sender.EndSend(sender.BeginSend(data, 2, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port), null, null));
 
                 IPEndPoint remoteEP = null;
-                byte[] data = receiver.EndReceive(receiver.BeginReceive(null, null), ref remoteEP);
+                byte[] receivedData = receiver.EndReceive(receiver.BeginReceive(null, null), ref remoteEP);
                 Assert.NotNull(remoteEP);
-                Assert.InRange(data.Length, 1, int.MaxValue);
+                Assert.True(Enumerable.SequenceEqual(receivedData, new byte[] {1, 2}));
             }
         }
 
@@ -606,15 +612,17 @@ public void BeginEndSend_BeginEndReceive_Success(bool ipv4)
         [PlatformSpecific(TestPlatforms.Windows)] // "localhost" resolves to IPv4 & IPV6 on Windows, but may resolve to only one of those on Unix
         public void BeginEndSend_BeginEndReceive_Connected_Success()
         {
+            byte[] data = [1, 2, 3];
+
             using (var receiver = new UdpClient("localhost", 0))
             using (var sender = new UdpClient("localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port))
             {
-                sender.EndSend(sender.BeginSend(new byte[1], 1, null, null));
+                sender.EndSend(sender.BeginSend(data, 2, null, null));
 
                 IPEndPoint remoteEP = null;
-                byte[] data = receiver.EndReceive(receiver.BeginReceive(null, null), ref remoteEP);
+                byte[] receivedData = receiver.EndReceive(receiver.BeginReceive(null, null), ref remoteEP);
                 Assert.NotNull(remoteEP);
-                Assert.InRange(data.Length, 1, int.MaxValue);
+                Assert.True(Enumerable.SequenceEqual(receivedData, new byte[] {1, 2}));
             }
         }
 
@@ -624,15 +632,16 @@ public void BeginEndSend_BeginEndReceive_Connected_Success()
         public async Task SendAsync_ReceiveAsync_Success(bool ipv4)
         {
             IPAddress address = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
+            byte[] data = [1, 2, 3];
 
             using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
             using (var sender = new UdpClient(new IPEndPoint(address, 0)))
             {
-                await sender.SendAsync(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(data, 2, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
+                await AssertReceiveAsync(receiver, [1, 2]);
 
-                await sender.SendAsync(new ReadOnlyMemory<byte>(new byte[1]), new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(new ReadOnlyMemory<byte>(data), new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
+                await AssertReceiveAsync(receiver, data);
             }
         }
 
@@ -643,15 +652,16 @@ public async Task SendAsync_ReceiveAsync_Success(bool ipv4)
         public async Task SendAsync_ReceiveAsync_With_HostName_Success(bool ipv4)
         {
             IPAddress address = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
+            byte[] data = [1, 2, 3];
 
             using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
             using (var sender = new UdpClient(new IPEndPoint(address, 0)))
             {
-                await sender.SendAsync(new byte[1], "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(data, "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
+                await AssertReceiveAsync(receiver, data);
 
-                await sender.SendAsync(new ReadOnlyMemory<byte>(new byte[1]), "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(new ReadOnlyMemory<byte>(data), "localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port);
+                await AssertReceiveAsync(receiver, data);
             }
         }
 
@@ -675,29 +685,30 @@ public async Task ReceiveAsync_Cancel_Throw(bool ipv4)
         [PlatformSpecific(TestPlatforms.Windows)] // "localhost" resolves to IPv4 & IPV6 on Windows, but may resolve to only one of those on Unix
         public async Task SendAsync_ReceiveAsync_Connected_Success()
         {
+            byte[] data = [1, 2, 3];
+
             using (var receiver = new UdpClient("localhost", 0))
             using (var sender = new UdpClient("localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port))
             {
-                await sender.SendAsync(new byte[1], 1);
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(data, 2);
+                await AssertReceiveAsync(receiver, [1, 2]);
 
-                await sender.SendAsync(new ReadOnlyMemory<byte>(new byte[1]));
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(new ReadOnlyMemory<byte>(data));
+                await AssertReceiveAsync(receiver, data);
 
-                await sender.SendAsync(new ReadOnlyMemory<byte>(new byte[1]), null);
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(new ReadOnlyMemory<byte>(data), null);
+                await AssertReceiveAsync(receiver, data);
 
-                await sender.SendAsync(new ReadOnlyMemory<byte>(new byte[1]), null, 0);
-                await AssertReceiveAsync(receiver);
+                await sender.SendAsync(new ReadOnlyMemory<byte>(data), null, 0);
+                await AssertReceiveAsync(receiver, data);
             }
         }
 
-        private static async Task AssertReceiveAsync(UdpClient receiver)
+        private static async Task AssertReceiveAsync(UdpClient receiver, byte[] sentData)
         {
             UdpReceiveResult result = await receiver.ReceiveAsync();
             Assert.NotNull(result.RemoteEndPoint);
-            Assert.NotNull(result.Buffer);
-            Assert.InRange(result.Buffer.Length, 1, int.MaxValue);
+            Assert.True(Enumerable.SequenceEqual(sentData, result.Buffer));
         }
 
         [Fact]