Question 1

What is the C# equivalent of SQL Server datetime2?

Accepted Answer

DateTime. Both datetime and datetime2 are read as DateTime, and EF Core creates datetime2 columns for DateTime properties. datetime2 keeps 100 ns precision and dates from year 1; datetime rounds to 1/300 of a second and starts in 1753.

Question 2

Which C# type should I use for SQL Server decimal and money?

Accepted Answer

decimal. Set the precision explicitly: EF Core maps an unconfigured decimal property to decimal(18,2) and only logs a warning, so extra decimals are rounded away.

Question 3

What is the C# type for uniqueidentifier?

Accepted Answer

Guid (SqlDbType.UniqueIdentifier). SQL Server sorts uniqueidentifier values by their last six bytes first, so its ORDER BY differs from Guid.CompareTo.

Question 4

Can I map SQL Server date and time to DateOnly and TimeOnly?

Accepted Answer

Yes. EF Core scaffolds date as DateOnly and time as TimeOnly, and SqlDataReader.GetFieldValue and GetFieldValue work with Microsoft.Data.SqlClient 6. GetFieldType still reports DateTime and TimeSpan.

Question 5

Should I use nvarchar or varchar?

Accepted Answer

nvarchar for text people type: it stores any Unicode character. varchar stores one code page and silently turns other characters into question marks, unless the column has a UTF-8 collation (SQL Server 2019 and later).

Question 6

What is rowversion in C#?

Accepted Answer

A byte[] of 8 bytes. With [Timestamp] or IsRowVersion() EF Core uses it as a concurrency token and throws DbUpdateConcurrencyException when the row changed since it was read.

SQL Server	C# type	SqlDbType	SqlDataReader	EF Core scaffolds	Notes
Exact numbers
`bigint`	`long`	`SqlDbType.BigInt`	`GetInt64` `SqlInt64`	`long`	8 bytes, -2^63 to 2^63-1.
`int`	`int`	`SqlDbType.Int`	`GetInt32` `SqlInt32`	`int`	4 bytes. The usual key type.
`smallint`	`short`	`SqlDbType.SmallInt`	`GetInt16` `SqlInt16`	`short`	2 bytes, -32,768 to 32,767.
`tinyint`	`byte`	`SqlDbType.TinyInt`	`GetByte` `SqlByte`	`byte`	0 to 255, unsigned: C# byte, not sbyte.
`bit`	`bool`	`SqlDbType.Bit`	`GetBoolean` `SqlBoolean`	`bool`	0 or 1 (NULL if nullable). Strings "true" and "false" convert.
`decimal(p,s)`	`decimal`	`SqlDbType.Decimal`	`GetDecimal` `SqlDecimal`	`decimal`	Up to 38 digits; C# decimal holds about 28 to 29, so a larger value throws OverflowException on read. EF Core's default for decimal is decimal(18,2).
`numeric(p,s)`	`decimal`	`SqlDbType.Decimal`	`GetDecimal` `SqlDecimal`	`decimal`	The same type as decimal; SQL Server reports it as decimal.
`money`	`decimal`	`SqlDbType.Money`	`GetDecimal` `SqlMoney`	`decimal`	8 bytes, 4 decimal places, rounds on conversion. Prefer decimal(19,4) for control over precision.
`smallmoney`	`decimal`	`SqlDbType.SmallMoney`	`GetDecimal` `SqlMoney`	`decimal`	4 bytes, about ±214,748.3647.
Approximate numbers
`float`	`double`	`SqlDbType.Float`	`GetDouble` `SqlDouble`	`double`	float(53): C# double, 8 bytes. Not for money.
`real`	`float`	`SqlDbType.Real`	`GetFloat` `SqlSingle`	`float`	float(24): C# float (Single). The reader method is GetFloat.
Dates and times
`date`	`DateTime`	`SqlDbType.Date`	`GetDateTime`	`DateOnly`	SqlDataReader.GetFieldType says DateTime, but GetFieldValue<DateOnly> works and EF Core maps it to DateOnly.
`time`	`TimeSpan`	`SqlDbType.Time`	`GetTimeSpan`	`TimeOnly`	TimeSpan from the reader; EF Core scaffolds TimeOnly. Range 00:00:00 to 23:59:59.9999999.
`datetime2`	`DateTime`	`SqlDbType.DateTime2`	`GetDateTime`	`DateTime`	0001 to 9999, 100 ns precision. EF Core's default for DateTime; use it instead of datetime.
`datetime`	`DateTime`	`SqlDbType.DateTime`	`GetDateTime` `SqlDateTime`	`DateTime`	Legacy: 1753 to 9999, rounded to 1/300 of a second (.000, .003, .007).
`smalldatetime`	`DateTime`	`SqlDbType.SmallDateTime`	`GetDateTime` `SqlDateTime`	`DateTime`	1900 to 2079-06-06, rounded to the minute.
`datetimeoffset`	`DateTimeOffset`	`SqlDbType.DateTimeOffset`	`GetDateTimeOffset`	`DateTimeOffset`	datetime2 plus the UTC offset. Keeps the offset, not the time zone.
Strings
`nvarchar(n)`	`string`	`SqlDbType.NVarChar`	`GetString` `SqlString`	`string`	Unicode (UTF-16), up to 4,000 characters. EF Core's default for string is nvarchar(max), nvarchar(450) for keys and indexed columns.
`nvarchar(max)`	`string`	`SqlDbType.NVarChar`	`GetString` `SqlString`	`string`	Up to 2 GB. Cannot be an index key.
`nchar(n)`	`string`	`SqlDbType.NChar`	`GetString` `SqlString`	`string`	Fixed length, padded with spaces on the right.
`varchar(n)`	`string`	`SqlDbType.VarChar`	`GetString` `SqlString`	`string`	Single-byte code page of the collation (UTF-8 with a _UTF8 collation on SQL Server 2019+). Characters outside it become "?".
`varchar(max)`	`string`	`SqlDbType.VarChar`	`GetString` `SqlString`	`string`	Up to 2 GB, non-Unicode. EF Core uses it for IsUnicode(false) strings.
`char(n)`	`string`	`SqlDbType.Char`	`GetString` `SqlString`	`string`	Fixed length, padded with spaces.
`ntext`	`string`	`SqlDbType.NText`	`GetString` `SqlString`	`string`	Deprecated: use nvarchar(max).
`text`	`string`	`SqlDbType.Text`	`GetString` `SqlString`	`string`	Deprecated: use varchar(max) or nvarchar(max).
`xml`	`string`	`SqlDbType.Xml`	`GetString` `SqlXml`	`string`	Read as string, or GetSqlXml for an XmlReader.
Binary
`varbinary(n)`	`byte[]`	`SqlDbType.VarBinary`	`GetFieldValue<byte[]>` `SqlBinary`	`byte[]`	Up to 8,000 bytes. Read with GetFieldValue<byte[]>, or GetStream for large values.
`varbinary(max)`	`byte[]`	`SqlDbType.VarBinary`	`GetFieldValue<byte[]>` `SqlBinary`	`byte[]`	Up to 2 GB. EF Core's default for byte[].
`binary(n)`	`byte[]`	`SqlDbType.Binary`	`GetFieldValue<byte[]>` `SqlBinary`	`byte[]`	Fixed length, padded with zero bytes.
`image`	`byte[]`	`SqlDbType.Image`	`GetFieldValue<byte[]>` `SqlBinary`	`byte[]`	Deprecated: use varbinary(max).
Other types
`uniqueidentifier`	`Guid`	`SqlDbType.UniqueIdentifier`	`GetGuid` `SqlGuid`	`Guid`	A GUID. SQL Server sorts it by the last 6 bytes first, so random GUIDs fragment clustered indexes.
`rowversion (timestamp)`	`byte[]`	`SqlDbType.Timestamp`	`GetFieldValue<byte[]>` `SqlBinary`	`byte[]`	8 bytes that change on every update; for optimistic concurrency ([Timestamp] in EF Core). Not a date.
`sql_variant`	`object`	`SqlDbType.Variant`	`GetProviderSpecificValue`	`object`	Holds a value of another type; read with GetValue.
`hierarchyid`	none built in	`SqlDbType.Udt`	GetValue with the type's assembly	not mapped	A CLR type: needs Microsoft.SqlServer.Types, or the EF Core HierarchyId package.
`geography`	none built in	`SqlDbType.Udt`	GetValue with the type's assembly	not mapped	Needs Microsoft.SqlServer.Types, or NetTopologySuite with EF Core (UseNetTopologySuite).
`geometry`	none built in	`SqlDbType.Udt`	GetValue with the type's assembly	not mapped	As geography, for flat coordinates.

C# property	EF Core column	AddWithValue sends
`bool`	`bit` NOT NULL	`SqlDbType.Bit`
`byte`	`tinyint` NOT NULL	`SqlDbType.TinyInt`
`short`	`smallint` NOT NULL	`SqlDbType.SmallInt`
`int`	`int` NOT NULL	`SqlDbType.Int`
`long`	`bigint` NOT NULL	`SqlDbType.BigInt`
`decimal`	`decimal(18,2)` NOT NULL	`SqlDbType.Decimal`
`decimal with [Precision(19, 4)]`	`decimal(19,4)` NOT NULL
`float`	`real` NOT NULL	`SqlDbType.Real`
`double`	`float` NOT NULL	`SqlDbType.Float`
`string`	`nvarchar(max)` NOT NULL	`SqlDbType.NVarChar`
`string?`	`nvarchar(max)` NULL
`string with [MaxLength(100)]`	`nvarchar(100)` NOT NULL
`string in a key or index`	`nvarchar(450)` NOT NULL
`string with IsUnicode(false)`	`varchar(max)` NOT NULL
`char`	`nvarchar(1)` NOT NULL	`SqlDbType.NVarChar`
`DateTime`	`datetime2` NOT NULL	`SqlDbType.DateTime`
`DateTime?`	`datetime2` NULL
`DateTimeOffset`	`datetimeoffset` NOT NULL	`SqlDbType.DateTimeOffset`
`DateOnly`	`date` NOT NULL	`SqlDbType.Date`
`TimeOnly`	`time` NOT NULL	`SqlDbType.Time`
`TimeSpan`	`time` NOT NULL	`SqlDbType.Time`
`Guid`	`uniqueidentifier` NOT NULL	`SqlDbType.UniqueIdentifier`
`byte[]`	`varbinary(max)` NOT NULL	`SqlDbType.VarBinary`
`byte[] with [Timestamp]`	`rowversion` NOT NULL
`sbyte`	`smallint` NOT NULL
`ushort`	`int` NOT NULL
`uint`	`bigint` NOT NULL
`ulong`	`decimal(20,0)` NOT NULL
`int?`	`int` NULL

Expression	Result
`SELECT CAST(1.005 AS decimal(18,2))`	`1.01`
`SELECT CAST(2.675 AS decimal(18,2))`	`2.68`
`SELECT CAST(12345678901234567.0 AS decimal(18,2))`	Error 8115 Arithmetic overflow error converting numeric to data type numeric.

Expression	Result
`SELECT CAST('2026-01-01T12:00:00.001' AS datetime)`	`2026-01-01 12:00:00.0000000`
`SELECT CAST('2026-01-01T12:00:00.005' AS datetime)`	`2026-01-01 12:00:00.0070000`
`SELECT CAST('2026-01-01T23:59:59.999' AS datetime)`	`2026-01-02 00:00:00.0000000`
`SELECT CAST('2026-01-01T23:59:59.9999999' AS datetime2)`	`2026-01-01 23:59:59.9999999`
`SELECT CAST('1752-12-31' AS datetime)`	Error 242 The conversion of a varchar data type to a datetime data type resulted in an out-of-range value.
`DateTime.MinValue sent as SqlDbType.DateTime`	SqlTypeException SqlDateTime overflow. Must be between 1/1/1753 12:00:00 AM and 12/31/9999 11:59:59 PM.
`DateTime.MinValue sent as SqlDbType.DateTime2`	`0001-01-01 00:00:00.0000000`

C#	Result
`AddWithValue("@p", /* DateTime */ value)`	`SqlDbType.DateTime`
`AddWithValue("@p", /* string */ value)`	`SqlDbType.NVarChar`
`AddWithValue("@p", /* decimal */ value)`	`SqlDbType.Decimal`
`AddWithValue("@p", /* DateOnly */ value)`	`SqlDbType.Date`
`AddWithValue("@p", /* TimeSpan */ value)`	`SqlDbType.Time`
`AddWithValue("@p", /* double */ value)`	`SqlDbType.Float`
`AddWithValue("@p", /* float */ value)`	`SqlDbType.Real`

SQL Server Data Types in C# and EF Core

SQL Server type to C# type

C# type to SQL Server column (EF Core code first)

The traps, with real results

decimal(18,2) is EF Core's silent default

datetime rounds; datetime2 does not

AddWithValue guesses the SQL type from the C# value

varchar loses characters outside its code page

Values .NET cannot hold

NULL, DBNull and nullable types

rowversion for optimistic concurrency

FAQ

Related

Expression	Result
`SELECT CAST(N'Ђорђе' AS varchar(10))`	`?????`
`SELECT CAST(N'café' AS varchar(10))`	`café`
`SELECT LEN(CAST(N'😀' AS nvarchar(10)))`	`2`
`SELECT DATALENGTH(CAST(N'abc' AS nvarchar(10)))`	`6`
`SELECT DATALENGTH(CAST('abc' AS char(10)))`	`10`

Expression	Result
`reader.GetSqlDecimal(0)`	`99999999999999999999999999999999999999`
`reader.GetDecimal(0)`	OverflowException Conversion overflows.