public static DateTime ReadDateTime(Stream stream) { //long v = ReadInt64(stream); //return DateTime.FromBinary(v); int b = stream.ReadByte(); if (b == -1) { throw new EndOfStreamException(); } DateTimeKind kind = (DateTimeKind)b; switch (kind) { case DateTimeKind.Utc: return(new DateTime(ReadInt64(stream), kind)); //break; case DateTimeKind.Local: return(new DateTime(ReadInt64(stream), DateTimeKind.Utc).ToLocalTime()); //break; case DateTimeKind.Unspecified: return(new DateTime(ReadInt64(stream), DateTimeKind.Unspecified)); //break; default: throw NotSupportedValueException.New(kind); } }
/// <summary> /// Rolls back all changes made since the beginning or the last call to Commit() /// </summary> /// <exception cref="InvalidUowChangeStateException"> /// Cannot rollback during commit. /// or /// Rollback is already running. /// </exception> public virtual void Rollback() { // ha nincs semmi változás if (this.ChangeState == UowChangeStateEnum.NoChanges) { return; } if (!this.IsDisposing) { ThrowIfDisposingOrDisposed(); if (!this.IsDisposing && !this.SupportsMultiThread) { this.EnsureOwnerThread(); } } lock (_commitOrRollbackLockObj) { // lekérjük, miután megszereztük a lock-ot var currentChangeState = this.ChangeState; switch (currentChangeState) { case UowChangeStateEnum.HasChanges: var sw = Stopwatch.StartNew(); try { this.ChangeState = UowChangeStateEnum.RollingBack; this.Logger.LogUowRollingBack(LogLevel.Debug, this.UowId); DoRollback(); sw.Stop(); this.Logger.LogUowRollbackSuccess(LogLevel.Debug, this.UowId, sw.Elapsed); } catch (Exception ex) { sw.Stop(); this.Logger.LogUowRollbackFailed(LogLevel.Error, this.UowId, sw.Elapsed, ex); this.ChangeState = UowChangeStateEnum.HasChanges; throw; } this.ChangeState = UowChangeStateEnum.NoChanges; break; case UowChangeStateEnum.NoChanges: return; case UowChangeStateEnum.Commiting: throw new InvalidUowChangeStateException(currentChangeState, "Cannot rollback during commit."); case UowChangeStateEnum.RollingBack: throw new InvalidUowChangeStateException(currentChangeState, "Rollback is already running."); //break; default: //throw new NotSupportedException(string.Format(System.Globalization.CultureInfo.InvariantCulture, // "'{0}' is a not supported '{1}' value.", currentChangeState, typeof(UowChangeStateEnum).Name)); throw NotSupportedValueException.New <UowChangeStateEnum>(currentChangeState); } } }
/// <summary> /// Commits all changes made since the beginning or the last call to Commit() /// </summary> /// <exception cref="InvalidUowChangeStateException"> /// Commit is already running. /// or /// Cannot commit during rollback. /// </exception> public virtual void Commit() { // ha nincs semmi változás if (this.ChangeState == UowChangeStateEnum.NoChanges) { return; } ThrowIfDisposingOrDisposed(); if (!this.SupportsMultiThread) { this.EnsureOwnerThread(); } lock (_commitOrRollbackLockObj) { // lekérjük, miután megszereztük a lock-ot var currentChangeState = this.ChangeState; switch (currentChangeState) { case UowChangeStateEnum.HasChanges: var sw = Stopwatch.StartNew(); try { this.ChangeState = UowChangeStateEnum.Commiting; this.Logger.LogUowCommiting(LogLevel.Debug, this.UowId); DoCommit(); sw.Stop(); this.Logger.LogUowCommitSuccess(LogLevel.Debug, this.UowId, sw.Elapsed); } catch (Exception ex) { sw.Stop(); this.Logger.LogUowCommitFailed(LogLevel.Error, this.UowId, sw.Elapsed, ex); this.ChangeState = UowChangeStateEnum.HasChanges; throw; } this.ChangeState = UowChangeStateEnum.NoChanges; break; case UowChangeStateEnum.NoChanges: return; case UowChangeStateEnum.Commiting: throw new InvalidUowChangeStateException(currentChangeState, "Commit is already running."); case UowChangeStateEnum.RollingBack: throw new InvalidUowChangeStateException(currentChangeState, "Cannot commit during rollback."); default: throw NotSupportedValueException.New <UowChangeStateEnum>(currentChangeState); } } }
public static DateTime?ReadNullableDateTime(Stream stream) { //if (ReadBoolean(stream)) // return ReadDateTime(stream); //else // return null; var b = stream.ReadByte(); if (b == -1) { throw new EndOfStreamException(); } if (b == 0) { return(null); } else { DateTimeKind kind = (DateTimeKind)((byte)(b - 1)); switch (kind) { case DateTimeKind.Utc: return(new DateTime(ReadInt64(stream), kind)); //break; case DateTimeKind.Local: return(new DateTime(ReadInt64(stream), DateTimeKind.Utc).ToLocalTime()); //break; case DateTimeKind.Unspecified: return(new DateTime(ReadInt64(stream), DateTimeKind.Unspecified)); //break; default: throw NotSupportedValueException.New(kind); } } }
//#endif #region DateTime public static void Write(Stream stream, DateTime value) { //long v = value.ToBinary(); //Write(stream, v); Write(stream, (byte)value.Kind); switch (value.Kind) { case DateTimeKind.Utc: Write(stream, value.Ticks); break; case DateTimeKind.Local: Write(stream, value.ToUniversalTime().Ticks); break; case DateTimeKind.Unspecified: Write(stream, value.Ticks); break; default: throw NotSupportedValueException.New(value.Kind); } }
/// <summary> /// Sets the change state to has changes. /// </summary> /// <exception cref="System.InvalidOperationException"> /// Thrown if <see cref="ChangeState"/> equals <see cref="UowChangeStateEnum.RollingBack"/> or <seealso cref="UowChangeStateEnum.Commiting"/>. /// </exception> /// <exception cref="NotSupportedValueException"> /// Thrown if <see cref="ChangeState"/> is not supported. /// </exception> protected void SetChangeStateToHasChanges() { var cs = this.ChangeState; switch (cs) { case UowChangeStateEnum.NoChanges: this.ChangeState = UowChangeStateEnum.HasChanges; break; case UowChangeStateEnum.HasChanges: break; case UowChangeStateEnum.RollingBack: throw new InvalidOperationException("Cannot make changes during rollback!"); case UowChangeStateEnum.Commiting: throw new InvalidOperationException("Cannot make changes during commit!"); default: throw NotSupportedValueException.New <UowChangeStateEnum>(cs); } }
public static void Write(Stream stream, DateTime?value) { //if (value == null) // Write(stream, false); //else //{ // Write(stream, true); // Write(stream, value.Value); //} if (value == null) { Write(stream, (byte)0); } else { Write(stream, (byte)((byte)value.Value.Kind + (byte)1)); switch (value.Value.Kind) { case DateTimeKind.Utc: Write(stream, value.Value.Ticks); break; case DateTimeKind.Local: Write(stream, value.Value.ToUniversalTime().Ticks); break; case DateTimeKind.Unspecified: Write(stream, value.Value.Ticks); break; default: throw NotSupportedValueException.New(value.Value.Kind); } } }