mcs/class/referencesource/System.Data.Entity/System/Data/Objects/ObjectStateEntryDbDataRecord.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="ObjectStateEntryDbDataRecord.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner       Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 using System;
  11 using System.Data;
  12 using System.Data.Common;
  13 using System.ComponentModel;
  14 using System.Data.Metadata.Edm;
  15 using System.Diagnostics;
  16
  17 namespace System.Data.Objects
  18 {
  19
  20     internal sealed class ObjectStateEntryDbDataRecord : DbDataRecord, IExtendedDataRecord
  21     {
  22         private readonly StateManagerTypeMetadata _metadata;
  23         private readonly ObjectStateEntry _cacheEntry;
  24         private readonly object _userObject;
  25         private DataRecordInfo _recordInfo;
  26
  27         internal ObjectStateEntryDbDataRecord(EntityEntry cacheEntry, StateManagerTypeMetadata metadata, object userObject)
  28         {
  29             EntityUtil.CheckArgumentNull(cacheEntry, "cacheEntry");
  30             EntityUtil.CheckArgumentNull(userObject, "userObject");
  31             EntityUtil.CheckArgumentNull(metadata, "metadata");
  32             Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbDataRecord for a key entry");
  33             switch (cacheEntry.State)
  34             {
  35                 case EntityState.Unchanged:
  36                 case EntityState.Modified:
  37                 case EntityState.Deleted:
  38                     _cacheEntry = cacheEntry;
  39                     _userObject = userObject;
  40                     _metadata = metadata;
  41                     break;
  42                 default:
  43                     Debug.Assert(false, "A DbDataRecord cannot be created for an entity object that is in an added or detached state.");
  44                     break;
  45             }
  46         }
  47         internal ObjectStateEntryDbDataRecord(RelationshipEntry cacheEntry)
  48         {
  49             EntityUtil.CheckArgumentNull(cacheEntry, "cacheEntry");
  50             Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbDataRecord for a key entry");
  51             switch (cacheEntry.State)
  52             {
  53                 case EntityState.Unchanged:
  54                 case EntityState.Modified:
  55                 case EntityState.Deleted:
  56                     _cacheEntry = cacheEntry;
  57                     break;
  58                 default:
  59                     Debug.Assert(false, "A DbDataRecord cannot be created for an entity object that is in an added or detached state.");
  60                     break;
  61             }
  62         }
  63         override public int FieldCount
  64         {
  65             get
  66             {
  67                 Debug.Assert(_cacheEntry != null, "CacheEntry is required.");
  68                 return _cacheEntry.GetFieldCount(_metadata);
  69             }
  70         }
  71         override public object this[int ordinal]
  72         {
  73             get
  74             {
  75                 return GetValue(ordinal);
  76             }
  77         }
  78         override public object this[string name]
  79         {
  80             get
  81             {
  82                 return GetValue(GetOrdinal(name));
  83             }
  84         }
  85         override public bool GetBoolean(int ordinal)
  86         {
  87             return (bool)GetValue(ordinal);
  88         }
  89         override public byte GetByte(int ordinal)
  90         {
  91             return (byte)GetValue(ordinal);
  92         }
  93         override public long GetBytes(int ordinal, long dataIndex, byte[] buffer, int bufferIndex, int length)
  94         {
  95             byte[] tempBuffer;
  96             tempBuffer = (byte[])GetValue(ordinal);
  97
  98             if (buffer == null)
  99             {
 100                 return tempBuffer.Length;
 101             }
 102             int srcIndex = (int)dataIndex;
 103             int byteCount = Math.Min(tempBuffer.Length - srcIndex, length);
 104             if (srcIndex < 0)
 105             {
 106                 throw EntityUtil.InvalidSourceBufferIndex(tempBuffer.Length, srcIndex, "dataIndex");
 107             }
 108             else if ((bufferIndex < 0) || (bufferIndex > 0 && bufferIndex >= buffer.Length))
 109             {
 110                 throw EntityUtil.InvalidDestinationBufferIndex(buffer.Length, bufferIndex, "bufferIndex");
 111             }
 112
 113             if (0 < byteCount)
 114             {
 115                 Array.Copy(tempBuffer, dataIndex, buffer, bufferIndex, byteCount);
 116             }
 117             else if (length < 0)
 118             {
 119                 throw EntityUtil.InvalidDataLength(length);
 120             }
 121             else
 122             {
 123                 byteCount = 0;
 124             }
 125             return byteCount;
 126         }
 127         override public char GetChar(int ordinal)
 128         {
 129             return (char)GetValue(ordinal);
 130         }
 131         override public long GetChars(int ordinal, long dataIndex, char[] buffer, int bufferIndex, int length)
 132         {
 133             char[] tempBuffer;
 134             tempBuffer = (char[])GetValue(ordinal);
 135
 136             if (buffer == null)
 137             {
 138                 return tempBuffer.Length;
 139             }
 140
 141             int srcIndex = (int)dataIndex;
 142             int charCount = Math.Min(tempBuffer.Length - srcIndex, length);
 143             if (srcIndex < 0)
 144             {
 145                 throw EntityUtil.InvalidSourceBufferIndex(buffer.Length, bufferIndex, "bufferIndex");
 146             }
 147             else if ((bufferIndex < 0) || (bufferIndex > 0 && bufferIndex >= buffer.Length))
 148             {
 149                 throw EntityUtil.InvalidDestinationBufferIndex(buffer.Length, bufferIndex, "bufferIndex");
 150             }
 151
 152             if (0 < charCount)
 153             {
 154                 Array.Copy(tempBuffer, dataIndex, buffer, bufferIndex, charCount);
 155             }
 156             else if (length < 0)
 157             {
 158                 throw EntityUtil.InvalidDataLength(length);
 159             }
 160             else
 161             {
 162                 charCount = 0;
 163             }
 164             return charCount;
 165         }
 166         override protected DbDataReader GetDbDataReader(int ordinal)
 167         {
 168             throw EntityUtil.NotSupported();
 169         }
 170         override public string GetDataTypeName(int ordinal)
 171         {
 172             return (GetFieldType(ordinal)).Name;
 173         }
 174         override public DateTime GetDateTime(int ordinal)
 175         {
 176             return (DateTime)GetValue(ordinal);
 177         }
 178         override public Decimal GetDecimal(int ordinal)
 179         {
 180             return (Decimal)GetValue(ordinal);
 181         }
 182         override public double GetDouble(int ordinal)
 183         {
 184             return (Double)GetValue(ordinal);
 185         }
 186         public override Type GetFieldType(int ordinal)
 187         {
 188             return _cacheEntry.GetFieldType(ordinal, _metadata);
 189         }
 190         override public float GetFloat(int ordinal)
 191         {
 192             return (float)GetValue(ordinal);
 193         }
 194         override public Guid GetGuid(int ordinal)
 195         {
 196             return (Guid)GetValue(ordinal);
 197         }
 198         override public Int16 GetInt16(int ordinal)
 199         {
 200             return (Int16)GetValue(ordinal);
 201         }
 202         override public Int32 GetInt32(int ordinal)
 203         {
 204             return (Int32)GetValue(ordinal);
 205         }
 206         override public Int64 GetInt64(int ordinal)
 207         {
 208             return (Int64)GetValue(ordinal);
 209         }
 210         override public string GetName(int ordinal)
 211         {
 212             return _cacheEntry.GetCLayerName(ordinal, _metadata);
 213         }
 214         override public int GetOrdinal(string name)
 215         {
 216             int ordinal = _cacheEntry.GetOrdinalforCLayerName(name, _metadata);
 217             if (ordinal == -1)
 218             {
 219                 throw EntityUtil.ArgumentOutOfRange("name");
 220             }
 221             return  ordinal;
 222         }
 223         override public string GetString(int ordinal)
 224         {
 225             return (string)GetValue(ordinal);
 226         }
 227         override public object GetValue(int ordinal)
 228         {
 229             if (_cacheEntry.IsRelationship)
 230             {
 231                 return (_cacheEntry as RelationshipEntry).GetOriginalRelationValue(ordinal);
 232             }
 233             else
 234             {
 235                 return (_cacheEntry as EntityEntry).GetOriginalEntityValue(_metadata, ordinal, _userObject, ObjectStateValueRecord.OriginalReadonly);
 236             }
 237         }
 238         override public int GetValues(object[] values)
 239         {
 240             if (values == null)
 241             {
 242                 throw EntityUtil.ArgumentNull("values");
 243             }
 244             int minValue = Math.Min(values.Length, FieldCount);
 245             for (int i = 0; i < minValue; i++)
 246             {
 247                 values[i] = GetValue(i);
 248             }
 249             return minValue;
 250         }
 251         override public bool IsDBNull(int ordinal)
 252         {
 253             return (GetValue(ordinal) == DBNull.Value);
 254         }
 255
 256         public DataRecordInfo DataRecordInfo
 257         {
 258             get
 259             {
 260                 if (null == _recordInfo)
 261                 {
 262                     Debug.Assert(_cacheEntry != null, "CacheEntry is required.");
 263                     _recordInfo = _cacheEntry.GetDataRecordInfo(_metadata, _userObject);
 264                 }
 265                 return _recordInfo;
 266             }
 267         }
 268         public DbDataRecord GetDataRecord(int ordinal)
 269         {
 270             return (DbDataRecord)GetValue(ordinal);
 271         }
 272         public DbDataReader GetDataReader(int i)
 273         {
 274             return this.GetDbDataReader(i);
 275         }
 276     }
 277 }