diff --git a/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs b/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
index 486ad29db961..9936f6695440 100644
--- a/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
+++ b/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
@@ -301,6 +301,9 @@ public partial struct Vector<T> : System.IEquatable<System.Numerics.Vector<T>>,
         public Vector(T value) { throw null; }
         public Vector(T[] values) { throw null; }
         public Vector(T[] values, int index) { throw null; }
+#if netcoreapp
+        public Vector(Span<T> values) { throw null; }
+#endif
         public static int Count { get { throw null; } }
         public T this[int index] { get { throw null; } }
         public static System.Numerics.Vector<T> One { get { throw null; } }
diff --git a/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.csproj b/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.csproj
index b585b3369a1e..5ac70e7e0522 100644
--- a/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.csproj
+++ b/src/System.Numerics.Vectors/ref/System.Numerics.Vectors.csproj
@@ -4,6 +4,7 @@
   <PropertyGroup>
     <ProjectGuid>{650277B5-9423-4ACE-BB54-2659995B21C7}</ProjectGuid>
     <IsPartialFacadeAssembly Condition="'$(TargetGroup)' == 'netfx' OR '$(TargetGroup)' == 'net46'">true</IsPartialFacadeAssembly>
+	<DefineConstants Condition="'$(TargetGroup)'=='netcoreapp'">$(DefineConstants);netcoreapp</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'net46-Debug|AnyCPU'" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'net46-Release|AnyCPU'" />
diff --git a/src/System.Numerics.Vectors/src/System.Numerics.Vectors.csproj b/src/System.Numerics.Vectors/src/System.Numerics.Vectors.csproj
index 47a3bf9c341a..d72e3435765d 100644
--- a/src/System.Numerics.Vectors/src/System.Numerics.Vectors.csproj
+++ b/src/System.Numerics.Vectors/src/System.Numerics.Vectors.csproj
@@ -10,6 +10,7 @@
     <IsTargetingNetCoreApp Condition="'$(TargetGroup)'=='netcoreapp' OR '$(TargetGroup)'=='uap' OR '$(TargetGroup)'=='uapaot'">true</IsTargetingNetCoreApp>
     <IsPartialFacadeAssembly Condition="'$(IsTargetingNetFx)'=='true' OR '$(IsTargetingNetCoreApp)'=='true'">true</IsPartialFacadeAssembly>
     <PackageTargetFramework Condition="'$(TargetGroup)' == 'netstandard1.0'">netstandard1.0;portable-net45+win8+wp8+wpa81</PackageTargetFramework>
+    <DefineConstants Condition="'$(IsTargetingNetCoreApp)' != 'true'">$(DefineConstants);netcoreapp</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'net46-Debug|AnyCPU'" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'net46-Release|AnyCPU'" />
diff --git a/src/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/System.Numerics.Vectors/tests/GenericVectorTests.cs
index e03022a21608..e06cb36be623 100644
--- a/src/System.Numerics.Vectors/tests/GenericVectorTests.cs
+++ b/src/System.Numerics.Vectors/tests/GenericVectorTests.cs
@@ -14,7 +14,7 @@ namespace System.Numerics.Tests
     /// <summary>
     ///  Vector{T} tests that use random number generation and a unified generic test structure
     /// </summary>
-    public class GenericVectorTests
+    public partial class GenericVectorTests
     {
         // Static constructor in top-level class\
         static System.Numerics.Vector<float> dummy;
@@ -2699,11 +2699,12 @@ private static void ValidateVector<T>(Vector<T> vector, Action<int, T> indexVali
             }
         }
 
-        internal static T[] GenerateRandomValuesForVector<T>() where T : struct
+        internal static T[] GenerateRandomValuesForVector<T>(int numValues = int.MinValue) where T : struct
         {
             int minValue = GetMinValue<T>();
             int maxValue = GetMaxValue<T>();
-            return Util.GenerateRandomValues<T>(Vector<T>.Count, minValue, maxValue);
+            numValues = numValues == int.MinValue ? Vector<T>.Count : numValues;
+            return Util.GenerateRandomValues<T>(numValues, minValue, maxValue);
         }
 
         internal static int GetMinValue<T>() where T : struct
@@ -2774,6 +2775,16 @@ internal static T GetValueWithAllOnesSet<T>() where T : struct
             }
             throw new NotSupportedException();
         }
+
+        internal static T[] GetArrayOfDefaultValues<T>(int count)
+        {
+            T[] arr = new T[count];
+            for (int index = 0; index < count; ++index)
+            {
+                arr[index] = default(T);
+            }
+            return arr;
+        }
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/System.Numerics.Vectors/tests/GenericVectorTests.netcoreapp.cs b/src/System.Numerics.Vectors/tests/GenericVectorTests.netcoreapp.cs
new file mode 100644
index 000000000000..39e50e434af5
--- /dev/null
+++ b/src/System.Numerics.Vectors/tests/GenericVectorTests.netcoreapp.cs
@@ -0,0 +1,233 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using Xunit;
+using Xunit.Sdk;
+
+namespace System.Numerics.Tests
+{
+    /// <summary>
+    ///  Vector{T} tests that use random number generation and a unified generic test structure
+    /// </summary>
+    public partial class GenericVectorTests
+    {
+        #region Constructor Tests
+
+        #region Tests for Span based constructor
+        [Fact]
+        public void ConstructorWithSpanByte() => TestConstructorWithSpan<Byte>();
+        [Fact]
+        public void ConstructorWithSpanSByte() => TestConstructorWithSpan<SByte>();
+        [Fact]
+        public void ConstructorWithSpanUInt16() => TestConstructorWithSpan<UInt16>();
+        [Fact]
+        public void ConstructorWithSpanInt16() => TestConstructorWithSpan<Int16>();
+        [Fact]
+        public void ConstructorWithSpanUInt32() => TestConstructorWithSpan<UInt32>();
+        [Fact]
+        public void ConstructorWithSpanInt32() => TestConstructorWithSpan<Int32>();
+        [Fact]
+        public void ConstructorWithSpanUInt64() => TestConstructorWithSpan<UInt64>();
+        [Fact]
+        public void ConstructorWithSpanInt64() => TestConstructorWithSpan<Int64>();
+        [Fact]
+        public void ConstructorWithSpanSingle() => TestConstructorWithSpan<Single>();
+        [Fact]
+        public void ConstructorWithSpanDouble() => TestConstructorWithSpan<Double>();
+
+        private void TestConstructorWithSpan<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>().ToArray();
+            Span<T> valueSpan = new Span<T>(values);
+
+            var vector = new Vector<T>(valueSpan);
+            ValidateVector(vector,
+                (index, val) =>
+                {
+                    Assert.Equal(values[index], val);
+                });
+        }
+
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_Byte() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<Byte>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_SByte() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<SByte>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_UInt16() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<UInt16>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_Int16() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<Int16>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_UInt32() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<UInt32>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_Int32() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<Int32>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_UInt64() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<UInt64>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_Int64() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<Int64>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_Single() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<Single>());
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_Double() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<Double>());
+
+        private void TestSpanBasedConstructorWithLessElements<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count - 1).ToArray();
+            Span<T> valueSpan = new Span<T>(values);
+
+            Vector<T> v = new Vector<T>(valueSpan);
+        }
+
+        #endregion Tests for Span based constructor
+
+        #region Tests for Array based constructor
+
+        [Fact]
+        public void ArrayBasedConstructor_Byte() => TestArrayBasedConstructor<Byte>();
+        [Fact]
+        public void ArrayBasedConstructor_SByte() => TestArrayBasedConstructor<SByte>();
+        [Fact]
+        public void ArrayBasedConstructor_UInt16() => TestArrayBasedConstructor<UInt16>();
+        [Fact]
+        public void ArrayBasedConstructor_Int16() => TestArrayBasedConstructor<Int16>();
+        [Fact]
+        public void ArrayBasedConstructor_UInt32() => TestArrayBasedConstructor<UInt32>();
+        [Fact]
+        public void ArrayBasedConstructor_Int32() => TestArrayBasedConstructor<Int32>();
+        [Fact]
+        public void ArrayBasedConstructor_UInt64() => TestArrayBasedConstructor<UInt64>();
+        [Fact]
+        public void ArrayBasedConstructor_Int64() => TestArrayBasedConstructor<Int64>();
+        [Fact]
+        public void ArrayBasedConstructor_Single() => TestArrayBasedConstructor<Single>();
+        [Fact]
+        public void ArrayBasedConstructor_Double() => TestArrayBasedConstructor<Double>();
+
+        private void TestArrayBasedConstructor<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count).ToArray();
+            Vector<T> vector = new Vector<T>(values);
+            ValidateVector(vector,
+                (index, val) =>
+                {
+                    Assert.Equal(values[index], val);
+                });
+        }
+
+        [Fact]
+        public void ArrayIndexBasedConstructor_Byte() => TestArrayIndexBasedConstructor<Byte>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_SByte() => TestArrayIndexBasedConstructor<SByte>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_UInt16() => TestArrayIndexBasedConstructor<UInt16>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_Int16() => TestArrayIndexBasedConstructor<Int16>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_UInt32() => TestArrayIndexBasedConstructor<UInt32>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_Int32() => TestArrayIndexBasedConstructor<Int32>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_UInt64() => TestArrayIndexBasedConstructor<UInt64>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_Int64() => TestArrayIndexBasedConstructor<Int64>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_Single() => TestArrayIndexBasedConstructor<Single>();
+        [Fact]
+        public void ArrayIndexBasedConstructor_Double() => TestArrayIndexBasedConstructor<Double>();
+
+        private void TestArrayIndexBasedConstructor<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count * 2).ToArray();
+            int offset = Vector<T>.Count - 1;
+            Vector<T> vector = new Vector<T>(values, offset);
+            ValidateVector(vector,
+                (index, val) =>
+                {
+                    Assert.Equal(values[offset + index], val);
+                });
+        }
+
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_Byte() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<Byte>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_SByte() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<SByte>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_UInt16() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<UInt16>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_Int16() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<Int16>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_UInt32() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<UInt32>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_Int32() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<Int32>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_UInt64() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<UInt64>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_Int64() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<Int64>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_Single() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<Single>());
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_Double() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<Double>());
+
+        private void TestArrayBasedConstructorWithLessElements<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count - 1).ToArray();
+            Vector<T> v = new Vector<T>(values);
+        }
+
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_Byte() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<Byte>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_SByte() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<SByte>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_UInt16() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<UInt16>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_Int16() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<Int16>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_UInt32() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<UInt32>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_Int32() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<Int32>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_UInt64() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<UInt64>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_Int64() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<Int64>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_Single() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<Single>());
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_Double() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<Double>());
+
+        private void TestArrayIndexBasedConstructorLessElements<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count * 2).ToArray();
+            Vector<T> v = new Vector<T>(values, Vector<T>.Count + 1);
+        }
+
+        #endregion Tests for Array based constructor
+
+        #region Tests for constructors using unsupported types
+
+        [Fact]
+        public void ConstructorWithUnsupportedTypes_Guid() => TestConstructorWithUnsupportedTypes<Guid>();
+        [Fact]
+        public void ConstructorWithUnsupportedTypes_DateTime() => TestConstructorWithUnsupportedTypes<DateTime>();
+        [Fact]
+        public void ConstructorWithUnsupportedTypes_Char() => TestConstructorWithUnsupportedTypes<Char>();
+
+        private void TestConstructorWithUnsupportedTypes<T>() where T : struct
+        {
+            Assert.Throws<NotSupportedException>(() =>
+            {
+                T[] arr = GetArrayOfDefaultValues<T>(4);
+                Span<T> span = new Span<T>(arr);
+                Vector<T> vector = new Vector<T>(span);
+            });
+        }
+
+        #endregion Tests for constructors using unsupported types
+
+        #endregion Constructor Tests
+    }
+}
diff --git a/src/System.Numerics.Vectors/tests/GenericVectorTests.netcoreapp.tt b/src/System.Numerics.Vectors/tests/GenericVectorTests.netcoreapp.tt
new file mode 100644
index 000000000000..3ed408209cfd
--- /dev/null
+++ b/src/System.Numerics.Vectors/tests/GenericVectorTests.netcoreapp.tt
@@ -0,0 +1,181 @@
+<#@ template debug="true" hostSpecific="true" #>
+<#@ output extension=".cs" #>
+<#@ Assembly Name="System.Core.dll" #>
+<#@ Assembly Name="System.Xml.dll" #>
+<#@ import namespace="System" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Runtime.InteropServices" #>
+<#@ include file="..\..\Common\src\CoreLib\System\Numerics\GenerationConfig.ttinclude" #><# GenerateCopyrightHeader(); #>
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using Xunit;
+using Xunit.Sdk;
+
+namespace System.Numerics.Tests
+{
+    /// <summary>
+    ///  Vector{T} tests that use random number generation and a unified generic test structure
+    /// </summary>
+    public partial class GenericVectorTests
+    {
+        #region Constructor Tests
+
+        #region Tests for Span based constructor
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Fact]
+        public void ConstructorWithSpan<#=type.Name#>() => TestConstructorWithSpan<<#=type.Name#>>();
+<#
+    }
+#>
+
+        private void TestConstructorWithSpan<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>().ToArray();
+            Span<T> valueSpan = new Span<T>(values);
+
+            var vector = new Vector<T>(valueSpan);
+            ValidateVector(vector,
+                (index, val) =>
+                {
+                    Assert.Equal(values[index], val);
+                });
+        }
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Fact]
+        public void SpanBasedConstructorWithLessElements_<#=type.Name#>() => Assert.Throws<IndexOutOfRangeException>(() => TestSpanBasedConstructorWithLessElements<<#=type.Name#>>());
+<#
+    }
+#>
+
+        private void TestSpanBasedConstructorWithLessElements<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count - 1).ToArray();
+            Span<T> valueSpan = new Span<T>(values);
+
+            Vector<T> v = new Vector<T>(valueSpan);
+        }
+
+        #endregion Tests for Span based constructor
+
+        #region Tests for Array based constructor
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Fact]
+        public void ArrayBasedConstructor_<#=type.Name#>() => TestArrayBasedConstructor<<#=type.Name#>>();
+<#
+    }
+#>
+
+        private void TestArrayBasedConstructor<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count).ToArray();
+            Vector<T> vector = new Vector<T>(values);
+            ValidateVector(vector,
+                (index, val) =>
+                {
+                    Assert.Equal(values[index], val);
+                });
+        }
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Fact]
+        public void ArrayIndexBasedConstructor_<#=type.Name#>() => TestArrayIndexBasedConstructor<<#=type.Name#>>();
+<#
+    }
+#>
+
+        private void TestArrayIndexBasedConstructor<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count * 2).ToArray();
+            int offset = Vector<T>.Count - 1;
+            Vector<T> vector = new Vector<T>(values, offset);
+            ValidateVector(vector,
+                (index, val) =>
+                {
+                    Assert.Equal(values[offset + index], val);
+                });
+        }
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Fact]
+        public void ArrayBasedConstructorWithLessElements_<#=type.Name#>() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayBasedConstructorWithLessElements<<#=type.Name#>>());
+<#
+    }
+#>
+
+        private void TestArrayBasedConstructorWithLessElements<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count - 1).ToArray();
+            Vector<T> v = new Vector<T>(values);
+        }
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Fact]
+        public void ArrayIndexBasedConstructorLessElements_<#=type.Name#>() => Assert.Throws<IndexOutOfRangeException>(() => TestArrayIndexBasedConstructorLessElements<<#=type.Name#>>());
+<#
+    }
+#>
+
+        private void TestArrayIndexBasedConstructorLessElements<T>() where T : struct
+        {
+            T[] values = GenerateRandomValuesForVector<T>(Vector<T>.Count * 2).ToArray();
+            Vector<T> v = new Vector<T>(values, Vector<T>.Count + 1);
+        }
+
+        #endregion Tests for Array based constructor
+
+        #region Tests for constructors using unsupported types
+
+<#
+    Type[] unsupportedTypes = new[]
+    {
+        typeof(Guid), typeof(DateTime), typeof(char)
+    };
+
+
+    foreach (var type in unsupportedTypes)
+    {
+#>
+        [Fact]
+        public void ConstructorWithUnsupportedTypes_<#=type.Name#>() => TestConstructorWithUnsupportedTypes<<#=type.Name#>>();
+<#
+    }
+#>
+
+        private void TestConstructorWithUnsupportedTypes<T>() where T : struct
+        {
+            Assert.Throws<NotSupportedException>(() =>
+            {
+                T[] arr = GetArrayOfDefaultValues<T>(4);
+                Span<T> span = new Span<T>(arr);
+                Vector<T> vector = new Vector<T>(span);
+            });
+        }
+
+        #endregion Tests for constructors using unsupported types
+
+        #endregion Constructor Tests
+    }
+}
diff --git a/src/System.Numerics.Vectors/tests/GenericVectorTests.tt b/src/System.Numerics.Vectors/tests/GenericVectorTests.tt
index 4790b1ac50f1..67295b70b31b 100644
--- a/src/System.Numerics.Vectors/tests/GenericVectorTests.tt
+++ b/src/System.Numerics.Vectors/tests/GenericVectorTests.tt
@@ -19,7 +19,7 @@ namespace System.Numerics.Tests
     /// <summary>
     ///  Vector{T} tests that use random number generation and a unified generic test structure
     /// </summary>
-    public class GenericVectorTests
+    public partial class GenericVectorTests
     {
         // Static constructor in top-level class\
         static System.Numerics.Vector<float> dummy;
@@ -116,7 +116,7 @@ namespace System.Numerics.Tests
                 });
         }
 
-<# 
+<#
     foreach (var type in supportedTypes)
     {
 #>
@@ -1869,4 +1869,4 @@ namespace System.Numerics.Tests
         }
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/System.Numerics.Vectors/tests/Performance/Constructor/GenericVectorConstructorTests.cs b/src/System.Numerics.Vectors/tests/Performance/Constructor/GenericVectorConstructorTests.cs
new file mode 100644
index 000000000000..90a2b793cdef
--- /dev/null
+++ b/src/System.Numerics.Vectors/tests/Performance/Constructor/GenericVectorConstructorTests.cs
@@ -0,0 +1,353 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Xunit;
+using Xunit.Sdk;
+using Microsoft.Xunit.Performance;
+
+namespace System.Numerics.Tests
+{
+    public static class Constructor
+    {
+        private static Random s_random = new Random();
+
+        public const int DefaultInnerIterationsCount = 100000000;
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_Byte()
+        {
+            Byte[] arrValues = GenerateRandomValuesForVector<Byte>();
+            var spanValues = new Span<Byte>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<Byte>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_SByte()
+        {
+            SByte[] arrValues = GenerateRandomValuesForVector<SByte>();
+            var spanValues = new Span<SByte>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<SByte>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_UInt16()
+        {
+            UInt16[] arrValues = GenerateRandomValuesForVector<UInt16>();
+            var spanValues = new Span<UInt16>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<UInt16>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_Int16()
+        {
+            Int16[] arrValues = GenerateRandomValuesForVector<Int16>();
+            var spanValues = new Span<Int16>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<Int16>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_UInt32()
+        {
+            UInt32[] arrValues = GenerateRandomValuesForVector<UInt32>();
+            var spanValues = new Span<UInt32>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<UInt32>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_Int32()
+        {
+            Int32[] arrValues = GenerateRandomValuesForVector<Int32>();
+            var spanValues = new Span<Int32>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<Int32>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_UInt64()
+        {
+            UInt64[] arrValues = GenerateRandomValuesForVector<UInt64>();
+            var spanValues = new Span<UInt64>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<UInt64>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_Int64()
+        {
+            Int64[] arrValues = GenerateRandomValuesForVector<Int64>();
+            var spanValues = new Span<Int64>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<Int64>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_Single()
+        {
+            Single[] arrValues = GenerateRandomValuesForVector<Single>();
+            var spanValues = new Span<Single>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<Single>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_Double()
+        {
+            Double[] arrValues = GenerateRandomValuesForVector<Double>();
+            var spanValues = new Span<Double>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<Double>(spanValues);
+                }
+            }
+        }
+
+
+        public static void Construct<T>(Span<T> values) where T : struct
+        {
+            for (var iteration = 0; iteration < Benchmark.InnerIterationCount; iteration++)
+            {
+                Vector<T> vect = new Vector<T>(values);
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_Byte()
+        {
+            Byte[] arrValues = GenerateRandomValuesForVector<Byte>();
+            var spanValues = new ReadOnlySpan<Byte>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<Byte>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_SByte()
+        {
+            SByte[] arrValues = GenerateRandomValuesForVector<SByte>();
+            var spanValues = new ReadOnlySpan<SByte>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<SByte>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_UInt16()
+        {
+            UInt16[] arrValues = GenerateRandomValuesForVector<UInt16>();
+            var spanValues = new ReadOnlySpan<UInt16>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<UInt16>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_Int16()
+        {
+            Int16[] arrValues = GenerateRandomValuesForVector<Int16>();
+            var spanValues = new ReadOnlySpan<Int16>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<Int16>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_UInt32()
+        {
+            UInt32[] arrValues = GenerateRandomValuesForVector<UInt32>();
+            var spanValues = new ReadOnlySpan<UInt32>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<UInt32>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_Int32()
+        {
+            Int32[] arrValues = GenerateRandomValuesForVector<Int32>();
+            var spanValues = new ReadOnlySpan<Int32>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<Int32>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_UInt64()
+        {
+            UInt64[] arrValues = GenerateRandomValuesForVector<UInt64>();
+            var spanValues = new ReadOnlySpan<UInt64>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<UInt64>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_Int64()
+        {
+            Int64[] arrValues = GenerateRandomValuesForVector<Int64>();
+            var spanValues = new ReadOnlySpan<Int64>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<Int64>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_Single()
+        {
+            Single[] arrValues = GenerateRandomValuesForVector<Single>();
+            var spanValues = new ReadOnlySpan<Single>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<Single>(spanValues);
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_Double()
+        {
+            Double[] arrValues = GenerateRandomValuesForVector<Double>();
+            var spanValues = new ReadOnlySpan<Double>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<Double>(spanValues);
+                }
+            }
+        }
+
+
+        public static void SpanCast<T>(ReadOnlySpan<T> values) where T : struct
+        {
+            for (var iteration = 0; iteration < Benchmark.InnerIterationCount; iteration++)
+            {
+                ReadOnlySpan<Vector<T>> vectors = MemoryMarshal.Cast<T, Vector<T>>(values);
+                Vector<T> vector = vectors[0];
+            }
+        }
+
+        internal static T[] GenerateRandomValuesForVector<T>() where T : struct
+        {
+            int minValue = GetMinValue<T>();
+            int maxValue = GetMaxValue<T>();
+            return Util.GenerateRandomValues<T>(Vector<T>.Count, minValue, maxValue);
+        }
+
+        internal static int GetMinValue<T>() where T : struct
+        {
+            if (typeof(T) == typeof(Int64) || typeof(T) == typeof(Single) || typeof(T) == typeof(Double) || typeof(T) == typeof(UInt32) || typeof(T) == typeof(UInt64))
+            {
+                return int.MinValue;
+            }
+            var typeInfo = typeof(T).GetTypeInfo();
+            var field = typeInfo.GetDeclaredField("MinValue");
+            var value = field.GetValue(null);
+            return (int)(dynamic)value;
+        }
+
+        internal static int GetMaxValue<T>() where T : struct
+        {
+            if (typeof(T) == typeof(Int64) || typeof(T) == typeof(Single) || typeof(T) == typeof(Double) || typeof(T) == typeof(UInt32) || typeof(T) == typeof(UInt64))
+            {
+                return int.MaxValue;
+            }
+            var typeInfo = typeof(T).GetTypeInfo();
+            var field = typeInfo.GetDeclaredField("MaxValue");
+            var value = field.GetValue(null);
+            return (int)(dynamic)value;
+        }
+
+    }
+}
diff --git a/src/System.Numerics.Vectors/tests/Performance/Constructor/GenericVectorConstructorTests.tt b/src/System.Numerics.Vectors/tests/Performance/Constructor/GenericVectorConstructorTests.tt
new file mode 100644
index 000000000000..0a2df77bea3f
--- /dev/null
+++ b/src/System.Numerics.Vectors/tests/Performance/Constructor/GenericVectorConstructorTests.tt
@@ -0,0 +1,120 @@
+<#@ template debug="true" hostSpecific="true" #>
+<#@ output extension=".cs" #>
+<#@ Assembly Name="System.Core.dll" #>
+<#@ Assembly Name="System.Xml.dll" #>
+<#@ import namespace="System" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Runtime.InteropServices" #>
+<#@ include file="..\..\..\..\Common\src\CoreLib\System\Numerics\GenerationConfig.ttinclude" #><# GenerateCopyrightHeader(); #>
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Xunit;
+using Xunit.Sdk;
+using Microsoft.Xunit.Performance;
+
+namespace System.Numerics.Tests
+{
+    public static class Constructor
+    {
+        private static Random s_random = new Random();
+
+        public const int DefaultInnerIterationsCount = 100000000;
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void ConstructorBenchmark_<#=type.Name#>()
+        {
+            <#=type.Name#>[] arrValues = GenerateRandomValuesForVector<<#=type.Name#>>();
+            var spanValues = new Span<<#=type.Name#>>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    Construct<<#=type.Name#>>(spanValues);
+                }
+            }
+        }
+
+<#
+    }
+#>
+
+        public static void Construct<T>(Span<T> values) where T : struct
+        {
+            for (var iteration = 0; iteration < Benchmark.InnerIterationCount; iteration++)
+            {
+                Vector<T> vect = new Vector<T>(values);
+            }
+        }
+
+<# 
+    foreach (var type in supportedTypes)
+    {
+#>
+        [Benchmark(InnerIterationCount = DefaultInnerIterationsCount)]
+        public static void SpanCastBenchmark_<#=type.Name#>()
+        {
+            <#=type.Name#>[] arrValues = GenerateRandomValuesForVector<<#=type.Name#>>();
+            var spanValues = new ReadOnlySpan<<#=type.Name#>>(arrValues);
+            foreach (var iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    SpanCast<<#=type.Name#>>(spanValues);
+                }
+            }
+        }
+
+<#
+    }
+#>
+
+        public static void SpanCast<T>(ReadOnlySpan<T> values) where T : struct
+        {
+            for (var iteration = 0; iteration < Benchmark.InnerIterationCount; iteration++)
+            {
+                ReadOnlySpan<Vector<T>> vectors = MemoryMarshal.Cast<T, Vector<T>>(values);
+                Vector<T> vector = vectors[0];
+            }
+        }
+
+        internal static T[] GenerateRandomValuesForVector<T>() where T : struct
+        {
+            int minValue = GetMinValue<T>();
+            int maxValue = GetMaxValue<T>();
+            return Util.GenerateRandomValues<T>(Vector<T>.Count, minValue, maxValue);
+        }
+
+        internal static int GetMinValue<T>() where T : struct
+        {
+            if (typeof(T) == typeof(Int64) || typeof(T) == typeof(Single) || typeof(T) == typeof(Double) || typeof(T) == typeof(UInt32) || typeof(T) == typeof(UInt64))
+            {
+                return int.MinValue;
+            }
+            var typeInfo = typeof(T).GetTypeInfo();
+            var field = typeInfo.GetDeclaredField("MinValue");
+            var value = field.GetValue(null);
+            return (int)(dynamic)value;
+        }
+
+        internal static int GetMaxValue<T>() where T : struct
+        {
+            if (typeof(T) == typeof(Int64) || typeof(T) == typeof(Single) || typeof(T) == typeof(Double) || typeof(T) == typeof(UInt32) || typeof(T) == typeof(UInt64))
+            {
+                return int.MaxValue;
+            }
+            var typeInfo = typeof(T).GetTypeInfo();
+            var field = typeInfo.GetDeclaredField("MaxValue");
+            var value = field.GetValue(null);
+            return (int)(dynamic)value;
+        }
+
+    }
+}
diff --git a/src/System.Numerics.Vectors/tests/Performance/System.Numerics.Vectors.Performance.Tests.csproj b/src/System.Numerics.Vectors/tests/Performance/System.Numerics.Vectors.Performance.Tests.csproj
index 842a2b5a1cd5..318d8f0e627a 100644
--- a/src/System.Numerics.Vectors/tests/Performance/System.Numerics.Vectors.Performance.Tests.csproj
+++ b/src/System.Numerics.Vectors/tests/Performance/System.Numerics.Vectors.Performance.Tests.csproj
@@ -63,7 +63,29 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <Content Include="Constructor\GenericVectorConstructorTests.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>GenericVectorConstructorTests.cs</LastGenOutput>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\Util.cs">
+      <Link>Util.cs</Link>
+    </Compile>
+    <Compile Include="Constructor\GenericVectorConstructorTests.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>GenericVectorConstructorTests.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\..\Common\src\CoreLib\System\Numerics\GenerationConfig.ttinclude">
+      <Link>GenerationConfig.ttinclude</Link>
+    </None>
+  </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
 </Project>
\ No newline at end of file
diff --git a/src/System.Numerics.Vectors/tests/System.Numerics.Vectors.Tests.csproj b/src/System.Numerics.Vectors/tests/System.Numerics.Vectors.Tests.csproj
index fc5d885a9281..42cbe76a3c8a 100644
--- a/src/System.Numerics.Vectors/tests/System.Numerics.Vectors.Tests.csproj
+++ b/src/System.Numerics.Vectors/tests/System.Numerics.Vectors.Tests.csproj
@@ -35,6 +35,13 @@
       <Link>System\MathF.netstandard.cs</Link>
     </Compile>
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetGroup)' == 'netcoreapp'">
+    <Compile Include="GenericVectorTests.netcoreapp.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>GenericVectorTests.netcoreapp.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
   <ItemGroup>
     <None Include="$(CommonPath)\CoreLib\System\Numerics\ConstantHelper.tt">
       <Link>ConstantHelper.tt</Link>
@@ -50,7 +57,14 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetGroup)' == 'netcoreapp'">
+    <Content Include="GenericVectorTests.netcoreapp.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>GenericVectorTests.netcoreapp.cs</LastGenOutput>
+    </Content>
+  </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
 </Project>
\ No newline at end of file