GUID que se puede anular

Question

En mi base de datos, en una de las tablas tengo una columna GUID con nulos permitidos. Tengo un método con un Guid? parámetro que inserta una nueva fila de datos en la tabla. Sin embargo, cuando digo myNewRow.myGuidColumn = myGuid, aparece el siguiente error: "¿No se puede convertir implícitamente el tipo 'System.Guid?' a 'System.Guid' ".

Answer 1

La API de ADO.NET tiene algunos problemas cuando se trata de manejar tipos de valores que aceptan nulos (es decir, simplemente no funciona correctamente). No hemos tenido problemas al respecto, por lo que hemos llegado a la conclusión de que lo mejor es establecer manualmente el valor en nulo, p.

myNewRow.myGuidColumn = myGuid == null ? (object)DBNull.Value : myGuid.Value 

Es un trabajo extra dolorosa que ADO.NET debe manipular, pero no parece hacerlo de forma fiable (incluso en 3.5 SP1). Esto al menos funciona correctamente.

También hemos visto problemas con el paso de tipos de valores anulables a SqlParameters donde el SQL generado incluye la palabra clave DEFAULT en lugar de NULL para el valor, así que recomendaría el mismo enfoque al construir parámetros.

Answer 2

OK; ¿Cómo se define myGuidColumn y cómo se define myGuid?

Si myGuid es Guid? y myGuidColumn es Guid, entonces el error es correcto: usted tendrá que usar myGuid.Value o (Guid)myGuid para obtener el valor (que tirar si es nulo), o tal vez myGuid.GetValueOrDefault() para devolver el GUID cero si nulo

Si myGuid es Guid y myGuidColumn es Guid?, entonces debería funcionar.

Si myGuidColumn es object, probablemente necesite DBNull.Value en lugar del nulo normal.

Por supuesto, si la columna es anulable verdad, es posible que simplemente quieren asegurarse de que es Guid? en el código C# ;-P

Answer 3

Se puede utilizar un método de ayuda:

public static class Ado { 
    public static void SetParameterValue<T>(IDataParameter parameter, T? value) where T : struct { 
     if (null == value) { parameter.Value = DBNull.Value; } 
     else { parameter.Value = value.Value; } 
    } 
    public static void SetParameterValue(IDataParameter parameter, string value) { 
     if (null == value) { parameter.Value = DBNull.Value; } 
     else { parameter.Value = value; } 
    } 
} 

Answer 4

o :

internal static T CastTo<T>(object value) 
    { 
     return value != DBNull.Value ? (T)value : default(T); 
    } 

Answer 5

Si se quiere evitar trabajar con GUID anulables en su código C# (personalmente, a menudo resulta engorroso trabajar con tipos anulables) que pudiera en algún culo temprana ign Guid.Empty a los datos .NET que es nulo en el db. De esta forma, no tiene que preocuparse por todas las cosas de .HasValue y simplemente verifique si myGuid != Guid.Empty.

Answer 6

mismo que la respuesta de Greg Haya

myNewRow.myGuidColumn = (object)myGuid ?? DBNull.Value 

Answer 7

Try System.Guid.Empty donde quiera que sea nula

Answer 8

Si usted está en los métodos de extensión ...

/// <summary> 
/// Returns nullable Guid (Guid?) value if not null or Guid.Empty, otherwise returns DBNull.Value 
/// </summary> 
public static object GetValueOrDBNull(this Guid? aGuid) 
{ 
    return (!aGuid.IsNullOrEmpty()) ? (object)aGuid : DBNull.Value; 
} 

/// <summary> 
/// Determines if a nullable Guid (Guid?) is null or Guid.Empty 
/// </summary> 
public static bool IsNullOrEmpty(this Guid? aGuid) 
{ 
    return (!aGuid.HasValue || aGuid.Value == Guid.Empty); 
} 

Entonces usted podría decir: myNewRow.myGuidColumn = myGuid.GetValueOrDBNull();

NOTA: Esto inserte nulo cuando myGuid == Guid.Empty, puede modificar fácilmente el método si desea permitir las guías vacías en su columna.

Answer 9

tienen que desechar null a un nullable Guid, así como se trabajó para mí:

myRecord.myGuidCol = (myGuid == null) ? (Guid?)null : myGuid.Value 

Answer 10

Guid? _field = null; 
if (myValue!="")//test if myValue has value 
{ 
_field = Guid.Parse(myValue) 
}