Введение в ObjectSpaces

В .NET Framework управление данными осуществляется на уровне объектов. Каждый объект характеризуется своим состоянием (свойства), поведением (методы), и является экземпляром какого-либо конкретного класса. В рамках приложения классы могут различаться по целевому назначению – это могут быть элементы управления, отображающие интерфейс пользователя, или сервисные классы, отвечающие за связи с базами данных и работу с сетевыми функциями, это могут быть классы “сообщений”, обеспечивающие обмен информацией между частями приложения. Все эти сущности объединяет одна общая черта – время их жизни обычно не превышает времени жизни всего приложения. Но, кроме вышеперечисленных категорий классов, можно выделить целый ряд сущностей, время жизни которых превышает срок жизни приложения. Например, в бизнес-задачах роль подобных сущностей могут играть объекты “Клиент”, “Заказчик”, “Продукт”. Таким объектам необходимо предоставить возможность сохранения своего состояния во внешнее хранилище.

В .NET Framework существуют готовые средства для работы с сохраняемыми объектами, – есть возможность сохранять состояние объектов в двоичном виде с использованием BinaryFormatter или XML-формате с использованием XmlSerializer. Все эти средства предоставляют возможности сохранения “графов” объектов, однако сохраняемая информация не оптимизирована для выполнения запросов к хранимым данным – так, поиск необходимой информации в XML-файле, содержащем несколько тысяч записей, может оказаться неприемлемо медленным. В большинстве подобных случаев в качестве хранилища информации подойдет реляционная СУБД – данные сохраняются в таблицах, для дополнительного контроля целостности между ними устанавливаются отношения, поиск информации осуществляется с использованием языка запросов SQL. Аналогичную функциональность предоставляют специальные библиотеки Object/Relational Mapping (O/R Mapping). Такая библиотека перекладывает на себя всю “черную” работу по сохранению/загрузке информации из объектной модели приложения в реляционную модель базы данных. В .NET Framework 1.2 для этих целей есть специальный набор классов из пространства имен System.ObjectSpaces.*.

ObjectSpaces

Если раньше, используя ADO.NET, нужно было самостоятельно писать SQL-запросы, то теперь это требование становится необязательным – ObjectSpaces берут на себя всю заботу об отображении классов приложения на различные источники данных. При этом мы можем создавать новые объекты, сохранять их, выполнять различные запросы - все необходимые действия по взаимодействию с источником данных будут выполняться внутри ObjectSpaces (при этом данные могут находиться как в традиционной БД, так и быть представленными в XML форме)

Для объектов приложения ObjectSpaces предоставляет следующие возможности:

Архитектура ObjectSpaces

Какая функциональность требуется от O/R Mapping-библиотеки? Кроме очевидных задач – загрузки/сохранения состояния объекта и выполнения операций поиска, есть и менее очевидные задачи – отслеживание состояния и идентификация объекта. Для чего это нужно?

Отслеживание состояния требуется для принятия решения о необходимости сохранения объекта. Совершенно очевидно, что если ни одно из полей объекта не изменялось, то повторно сохранять ту же информацию совершенно не обязательно. Информация об оригинальных значениях полей может понадобиться и для достижения “оптимистической параллельности” (optimistic concurrency) в ситуациях, когда в БД нет колонки с версией записи. Также можно оптимизировать сохранение полей объекта для ситуаций, когда один объект отображается на несколько таблиц в базе данных, просто не обновляя не изменившиеся данные.

В каких случаях нужно уметь идентифицировать объект? В случае с O/R Mapping-библиотекой мы работаем не с “сырыми” данными, а с реальными объектами. Это значит, что одному значению первичного ключа в базе данных должен соответствовать один объект в приложении. В самом деле, разумно рассчитывать, что все возможные способы получения одного и того же объекта из базы данных каждый раз должны возвращать одну и ту же ссылку. Это означает, что O/R Mapping-библиотека должна отслеживать все загружаемые объекты, и в случае повторной попытки восстановить объект с тем же значением первичного ключа возвращать ссылку на уже загруженный.

Какие есть пути для реализации подобной функциональности? Реализация функциональности идентификации объектов пересекается с реализацией отслеживания состояния объекта и не представляет особой сложности. Поэтому сосредоточимся на том, какими способами можно обеспечить отслеживание состояния.

Есть два варианта отслеживания состояния объекта. В первом варианте инициатором сохранения состояния выступает сам объект. По второму варианту объект играет пассивную роль, а вся необходимая функциональность реализуется в библиотеке O/R Mapper. Разберем каждую из двух реализаций более подробно.

Инициатором сохранения выступает объект. В данной ситуации O/R Mapper предоставляет механизм хранения оригинальных и текущих значений, а “сохраняемый” объект выступает лишь интерфейсом для работы c этим хранилищем. Здесь можно выделить два возможных направления:

“Сохраняемый” класс описывается на некотором метаязыке. Что это за метаязык, и какие средства работы с ним используются, в общем случае не столь важно. Отличительной особенностью данной реализации является то, что весь необходимый код отслеживания состояния генерируется на этапе разработки (компиляции). В качестве примера подобного подхода можно взять реализацию Borland Enterprise Core Objects (ECO).

Все свойства, для которых необходимо предоставить возможности “сохранения” объявляются как абстрактные, сам такой класс также становится абстрактным (MustInherit в VisualBasic). На O/R Mapping-библиотеку в такой ситуации ложится ответственность за создание наследника “сохраняемого” (например, через Reflection.Emit) класса с неизбежной реализацией всех сохраняемых свойств, и предоставление фабрики класса для его создания. Найти реализацию подобной функциональности можно в ранней preview-версии ObjectSpaces и в EntityBroker (http://www.thona-consulting.com).

У каждого из этих направлений есть свои достоинства и недостатки. Плюсом первого направления является более быстрый запуск, т.к. весь необходимый код сгенерирован еще на этапе компиляции. Между тем, этот плюс может стать и минусом – если по какой-то причине реализация “отслеживания” состояния изменится, придется повторить операцию генерации кода сохраняемого класса и перекомпилировать его. В случае использования второго направления будет достаточно заменить реализацию O/R Mapper.

Объект играет пассивную роль, вся реализация – в O/R Mapper. В этой ситуации к “сохраняемому” классу не предъявляется никаких дополнительных требований. Основной плюс данного подхода состоит в том, что для добавления “сохраняемости” к существующему классу его не надо никак модифицировать (максимальная прозрачность в использовании O/R Mapper), а минус состоит в том, что для сохранения закрытых полей класса приходится использовать механизмы рефлексии, что может отрицательно сказаться на производительности.

В ObjectSpaces выбран второй вариант. В основе реализации ObjectSpaces (Рисунок 1) лежат три основных класса: ObjectEngine, ObjectContext и ObjectSpace.

Схемы данных

Для большинства приложений описать однозначное (“один к одному”) отображение объектной модели данных на реляционную модель нельзя, иногда нужно специально описывать то, как объекты должны отображаться на источник данных. В ObjectSpaces эту задачу выполняет класс MappingSchema (пространство имен System.Data.Mapping). Данный класс предназначен для описания:

ObjectSpaces дает возможность самостоятельно формировать состояние класса MappingSchema или загружать его состояние из XML-файла. Рассмотрим использование MappingSchema на основе базы данных Northwind из состава SQL Server. На первом этапе нужно описать структуру этой базы данных в RSD-схеме:

<rsd:Database Name="Northwind" Owner="sa"
  xmlns:rsd="http://schemas.microsoft.com/data/2002/09/28/rsd">
  <rsd:Schema Name="dbo">
    <rsd:Tables>
      <rsd:Table Name="Orders">
        <rsd:Columns>
          <rsd:Column AutoIncrement="true" Name="OrderID" SqlType="int"
                      IncrementStep="1" IncrementSeed="1"/>
          <rsd:Column AllowDbNull="true" Name="CustomerID" SqlType="nchar"
                      Precision="5"/>
          <rsd:Column AllowDbNull="true" Name="EmployeeID" SqlType="int"/>
          <rsd:Column AllowDbNull="true" Name="OrderDate" SqlType="datetime"/>
          <rsd:Column AllowDbNull="true" Name="RequiredDate" SqlType="datetime"/>
          <rsd:Column AllowDbNull="true" Name="ShippedDate" SqlType="datetime"/>
          <rsd:Column AllowDbNull="true" Name="Freight" SqlType="money">
            <rsd:Default>0</rsd:Default>
          </rsd:Column>
        </rsd:Columns>
        <rsd:Constraints>
          <rsd:PrimaryKey Name="PK_Orders">
            <rsd:ColumnRef Name="OrderID"/>
          </rsd:PrimaryKey>
          <rsd:ForeignKey ForeignTable="Customers" Name="FK_Orders_Customers">
            <rsd:ColumnMatch ForeignName="CustomerID" Name="CustomerID"/>
          </rsd:ForeignKey>
        </rsd:Constraints>
      </rsd:Table>
      <rsd:Table Name="Customers">
        <rsd:Columns>
          <rsd:Column Name="CustomerID" SqlType="nchar" Precision="5"/>
          <rsd:Column Name="CompanyName" SqlType="nvarchar" Precision="40"/>
          <rsd:Column AllowDbNull="true" Name="ContactName" 
                      SqlType="nvarchar" Precision="30"/>
          <rsd:Column AllowDbNull="true" Name="Phone" SqlType="nvarchar"
                      Precision="24"/>
        </rsd:Columns>
        <rsd:Constraints>
          <rsd:PrimaryKey Name="PK_Customers">
            <rsd:ColumnRef Name="CustomerID"/>
          </rsd:PrimaryKey>
        </rsd:Constraints>
      </rsd:Table>
    </rsd:Tables>
  </rsd:Schema>
</rsd:Database>

Эта схема описывает две таблицы из базы данных Northwind (рисунок 2). Для таблиц Customers и Orders описываются исходные поля в БД, первичные ключи, а также связи между таблицами.

Кроме этого, понадобится описать OSD-схему, которая будет описывать объекты C#-кода.

<osd:ExtendedObjectSchema Name="DataTypesOSD"
  xmlns:osd="http://schemas.microsoft.com/data/2002/09/20/persistenceschema">
  <osd:Classes>
    <osd:Class Name="Rsdn.Samples.Northwind.Customer">
      <osd:Member Name="CustomerID" Key="true" />
      <osd:Member Name="Company" />
      <osd:Member Name="Name" />
      <osd:Member Name="Phone" />
      <osd:Member Name="Orders" />
    </osd:Class>
    <osd:Class Name="Rsdn.Samples.Northwind.Order">
      <osd:Member Name="_orderID" KeyType="AutoIncrement" 
                  Hidden="false" Key="true" Alias="OrderID" />
      <osd:Member Name="OrderDate" />
      <osd:Member Name="RequiredDate" />
      <osd:Member Name="ShippedDate" />
      <osd:Member Name="EmployeeID" />
      <osd:Member Name="Freight" />
      <osd:Member Name="Customer" />
    </osd:Class>
  </osd:Classes>
  <osd:ObjectRelationships>
    <osd:ObjectRelationship Name="Customers_Orders" 
         Type="OneToMany" ParentClass="Rsdn.Samples.Northwind.Customer"
         ParentMember="Orders" ChildClass="Rsdn.Samples.Northwind.Order" 
         ChildMember="Customer" />
  </osd:ObjectRelationships>
</osd:ExtendedObjectSchema>

После объявления RSD- и OSD-схем (рисунок 3), нужно создать Mapping-схему, которая определит отображение одной схемы на другую:

<m:MappingSchema xmlns:m="http://schemas.microsoft.com/data/2002/09/28/mapping">
  <m:DataSources>
    <m:DataSource Name="NorthwindRSD" Type="SQL Server" Direction="Source">
      <m:Schema Location="RSD.XML" />
      <m:Variable Name="Customers" Select="Customers" />
      <m:Variable Name="Orders" Select="Orders" />
      <m:Relationship Name="Customers_Orders" 
                      FromVariable="Customers" ToVariable="Orders">
        <m:FieldJoin From="CustomerID" To="CustomerID" />
      </m:Relationship>
    </m:DataSource>
    <m:DataSource Name="DataTypesOSD" Type="Object" Direction="Target">
      <m:Schema Location="OSD.XML" />
    </m:DataSource>
  </m:DataSources>
  <m:Mappings>
    <m:Map SourceVariable="Customers" 
           TargetSelect="Rsdn.Samples.Northwind.Customer">
      <m:FieldMap SourceField="CustomerID" TargetField="CustomerID" />
      <m:FieldMap SourceField="CompanyName" TargetField="Company" />
      <m:FieldMap SourceField="ContactName" TargetField="Name" />
      <m:FieldMap SourceField="Phone" TargetField="Phone" />
    </m:Map>
    <m:Map SourceVariable="Orders" 
           TargetSelect="Rsdn.Samples.Northwind.Order">
      <m:FieldMap SourceField="OrderID" TargetField="_orderID" />
      <m:FieldMap SourceField="OrderDate" TargetField="OrderDate" />
      <m:FieldMap SourceField="RequiredDate" TargetField="RequiredDate" />
      <m:FieldMap SourceField="ShippedDate" TargetField="ShippedDate" />
      <m:FieldMap SourceField="EmployeeID" 
                  TargetField="EmployeeID" NullValue="-1" />
      <m:FieldMap SourceField="Freight" TargetField="Freight" />
    </m:Map>
    <m:RelationshipMap Source="Customers_Orders" Target="Customers_Orders" />
  </m:Mappings>
</m:MappingSchema>

OPath

Одна из основных задач при работе с информацией – это создание запросов для выборки необходимых данных. Так, в случае РСУБД можно использовать язык запросов SQL, для выборки информации из XML-источников у нас есть XPath. Но как SQL, так и XPath – это языки запросов, которые слишком сильно привязаны к модели хранения данных и, как результат, для O/R Mapper приходится применять специальный язык запросов, который позволит создавать запросы к данным в терминах объектной модели приложения и легко транслировать их в язык, понимаемый хранилищем данных (для ObjectSpaces и MS SQL Server это SQL).

Для обращения к источнику данных в ObjectSpaces используется специальный язык запросов – OPath. Синтаксис этого языка (отдаленно он напоминает XPath) позволяет выполнять запросы к источнику данных, основываясь на иерархии классов, используемых в приложении. В настоящее время OPath поддерживает следующий набор операторов (для операторов может использоваться синтаксис как C#, так и VB.NET):

Оператор в C# стиле	Оператор в VB стиле	Описание
. []	. ()	Операторы группировки используются для разделения свойств и группировки выражений. Например:Customer[CustomerID=’alfki’].Orders.ShipDate>#11/12/2003#
!	not	Логическое отрицание. not (Customer[CustomerID=’alfki’])
* / %	* / MOD	Умножение, деление, получение модуля
+ -	+ -	Сложение, вычитание
< > <= >=	< > <= >=	Сравнение двух значенийCustomer.CreateDate > #12/09/2002#
= != ==	= <> ==	Равенство двух значений
&& \|\|	and or	Customer.Region = ‘ru’ \|\| Customer.Region = ‘en’
^	^	Символ ^ используется для обозначений родитель/потомок. В случае использования оператора ^ следующие два выражения эквивалентны:Orders.OrderDetail[^.OrderDate > #1/1/2003#]Orders.[OrderDate > #1/1/2003#]

ObjectSpace

При работе с сохраняемыми объектами нам нужны следующие возможности – загрузка сохраненных объектов, отслеживание состояния и возврат изменений обратно, в базу данных. Класс ObjectSpace объединяет в себе все эти возможности. Рассмотрим отдельные моменты работы с этим классом.

Создание экземпляра ObjectSpace

Для создания экземпляра ObjectSpace нужно иметь три схемы – RSD, OSD и MSD (при желании их можно скомбинировать в одном XML-файле), а также экземпляр SqlConnection для взаимодействия с источником данных.

          //  Создание экземпляра класса ObjectSpaces
          using (SqlConnection conn = new SqlConnection(
  "Data Source=tim; Integrated Security=SSPI; Database=northwind"))
{
  ObjectSpace os = new ObjectSpace("map.xml", conn);

  //  Работаем с os. Явно открывать подключение SqlConnection не обязательно.//  Это происходит автоматически.
}

Запрос к источнику данных

После инициализации экземпляра ObjectSpace можно обратиться к источнику данных. Для этого у класса ObjectSpace есть три метода GetObject, GetObjectReader, GetObjectSet которые позволяют получать данные в виде трех различных форм – одиночный объект, курсор или список.

          //  Определим “сохраняемые” объекты, которые будем использовать в дальнейшем
          public
          class Customer
  {
    publicstring CustomerID;
    publicstring Name;
    publicstring Company;
    publicstring Phone;
    publicstring Fax;
    public ArrayList Orders = new ArrayList();
  }

  publicclass Order
  {
    privateint _orderID = 0;

    publicint OrderID
    {
      get { return _orderID; }
    }

    public DateTime OrderDate;
    public DateTime RequiredDate;
    public DateTime ShippedDate;
    public Decimal Freight;
    publicint EmployeeID;
    public Customer Customer;
}

// Извлекаем объект Customer (включая подчиненное свойство Orders)// на основе OPath-запроса (City='Berlin' && Orders.OrderDate < #1998.10.10#).// Для каждого экземпляра класса Customer загружается свойство “Orders”.
Customer cust = (Customer)os.GetObject(typeof(Customer), 
     "City='Berlin' && Orders.OrderDate < #1998.10.10#", “Orders”);

Во что выливается вызов приведенного выше метода os.GetObject? Используя Profiler из MS SQL Server, можно увидеть, что в БД будет выполнен следующий SQL-запрос (отформатирован для приведения в более “читаемый” вид):

          exec sp_executesql 
N'select Customers.[CustomerID], 
      Customers.[CompanyName], 
      Customers.[ContactName], 
      Customers.[City], 
      Customers.[Phone] 
    from [Northwind].[dbo].[Customers] as  Customers 
    where  ((Customers.[City]) = (@p0)) 
       AND (EXISTS(
             select Orders.[OrderID], Orders.[CustomerID] 
               from [Northwind].[dbo].[Orders] as Orders 
               where ((Customers.[CustomerID]) = (Orders.[CustomerID]))
                 AND ((Orders.[OrderDate]) > (@p1)))) 
  order by 1;

select Customers.[CustomerID], 
    Orders.[OrderID], 
    Orders.[CustomerID], 
    Orders.[RequiredDate], 
    Orders.[ShippedDate], 
    Orders.[OrderDate] 
  from [Northwind].[dbo].[Customers] as Customers, 
       [Northwind].[dbo].[Orders] as Orders 
  where (((Customers.[City]) = (@p0)) 
    AND (EXISTS(
      select Orders.[OrderID], Orders.[CustomerID]
        from [Northwind].[dbo].[Orders] as Orders 
        where ((Customers.[CustomerID]) = (Orders.[CustomerID]))
          AND ((Orders.[OrderDate])>(@p1)) )))
          AND ((Customers.[CustomerID])=(Orders.[CustomerID])) 
  order by 1, 2, 3 ;', 

N'@p0 nvarchar(6),@p1 datetime', @p0 = N'Berlin', 
  @p1 = 'Oct 10 1998 12:00:00:000AM'

Создание записей в базе данных

Одно из больших преимуществ в использовании ObjectSpaces состоит в том, что для добавления объекту свойств “сохраняемости” его не надо специальным образом модифицировать (наследовать от специального базового класса, специальным образом размечать свойства или поля). Подобная прозрачность реализации ObjectSpaces дает преимущества в использовании.

          //  Работа с объектами Customer и Orders не зависит 
          //  от того, используется ObjectSpaces или нет
Customer cust = new Customer();
Order ord = new Order();

cust.Id = "ALFQI";
cust.Name = "MyName";
cust.Company = "MyCompany";
cust.Phone = "MyPhone";
cust.Fax = "MyFax";

ord.Customer = cust;
ord.OrderDate = DateTime.Now;
ord.ShippedDate = DateTime.Now;
ord.RequiredDate = DateTime.Now;
cust.Orders.Add(ord);

//  Перед сохранением объектов необходимо поместить их в контекст //  ObjectSpaces. Флаг InitialState.Inserted показывает, что мы добавляем новую //  запись в базу данных
os.StartTracking(ord, InitialState.Inserted);
os.StartTracking(cust, InitialState.Inserted);

//  Сохраняем экземпляр класса Customer. //  Параметр PersistenceOptions(Depth.ObjectGraph) сообщает, //  что будет сохранен весь граф объектов.
os.PersistChanges(cust, new PersistenceOptions(Depth.ObjectGraph));

Удаление записей с использованием ObjectSpaces

Существующая версия ObjectSpaces поддерживает удаление объектов только в том случае, если они ранее были добавлены в контекст ObjectSpaces.

Customer cust = new Customer();
cust.Id = "ALFQI";

//  Перед операцией над объектом необходимо поместить его в контекст //  ObjectSpaces. Флаг InitialState.Unchanged показывает, что объект ранее//  был сохранен в базе данных
os.StartTracking(cust, InitialState.Unchanged);

//  Помечаем экземпляр класса Customer как удаляемый. 
os.MarkForDeletion(cust);

//  Сохраняем изменения в базе данных
os.PersistChanges(cust);

Отложенная загрузка данных

Отложенная загрузка данных – это очень полезная возможность, реализованная в ObjectSpaces. Правда, использование этой функциональности омрачается ее недостаточной “прозрачностью”. Это значит, что в случае, когда необходимо подгружать зависимые классы по требованию, придется модифицировать исходный код. К счастью, модификации незначительны.

          public
          class Customer
{
  publicstring CustomerID;
  publicstring Name;
  publicstring Company;
  publicstring Phone;
  publicstring Fax;

  // Для отложенной загрузки списка заказов необходимо перейти // от использования ArrayList к использованию специального класса из // ObjectSpaces – ObjectList.public ObjectList Orders = new ObjectList();
}

publicclass Order
{
  privateint _orderID = 0;

  publicint OrderID
  {
    get {return _orderID;}
  }

  public DateTime OrderDate;
  public DateTime RequiredDate;
  public DateTime ShippedDate;
  public Decimal Freight;
  publicint EmployeeID;

  // Для отложенной загрузки класса Customer, мы меняем тип поля с Customer // на ObjectHolder. Именно ObjectHolder будет отвечать за подгрузку нужных // данных.private ObjectHolder _customer = new ObjectHolder();

  public Customer Customer
  {
    get {return (Customer) _customer.InnerObject;}
    set {_customer.InnerObject = value;}
  }
}

Кроме изменения кода приложения, отложенную загрузку свойств следует объявить в OSD-схеме. Для этого нужно добавить в описание полей специальный атрибут LazyLoad=”true”.

          <!-- Фрагмент OSD схемы  -->
<osd:Class Name="Rsdn.Samples.Northwind.Customer">
  <osd:Member Name="CustomerID" Key="true" />
  <osd:Member Name="Company" />
  <osd:Member Name="Name" />
  <osd:Member Name="Phone" />
  <osd:Member Name="Orders"LazyLoad=”true” />
</osd:Class>
<osd:Class Name="Rsdn.Samples.Northwind.Order">
  <osd:Member Name="_orderID" KeyType="AutoIncrement" 
              Hidden="false" Key="true" Alias="OrderID" />
  <osd:Member Name="OrderDate" />
  <osd:Member Name="RequiredDate" />
  <osd:Member Name="ShippedDate" />
  <osd:Member Name="EmployeeID" />
  <osd:Member Name="Freight" />
  <osd:Member Name="_customer" Alias=”Customer”LazyLoad=”true” />
</osd:Class>

После этого можно работать с восстановленным объектом как обычно:

          using (SqlConnection conn = new SqlConnection(
  "Data Source=tim; Integrated Security=SSPI; Database=northwind"))
{
  ObjectSpace os = new ObjectSpace("map.xml", conn);

  Customer cust = (Customer)os.GetObject(typeof(Customer), 
    "CustomerID=’alfki’");

  //  Список заказов загрузится при первом обращенииforeach (Order order in cust.Orders)
  {
    Console.WriteLine(“Customer: {0}, OrderDate: {1}”, 
      order.Customer.Name, order.OrderDate);
  }
}

Метод	Описание
BeginTransaction, Commit, Rollback	Управление транзакциями. Стоит обратить внимание, что метод Rollback не откатывает изменения в сохраняемых объектах, поэтому возможны ситуации, когда информация в БД и информация в сохраняемых объектах окажутся несогласоваными. Поэтому, во избежание конфликтов, рекомендуется после Rollback создавать новый экземпляр ObjectSpaces.
GetObject	Получить одиночный объект заданного типа из базы данных. В параметрах метода можно передать как OPath-запрос, так и список дочерних объектов, которые должны быть загружены одновременно с запрашиваемым объектом.
GetObjectReader	Получить из базы данных объекты через курсор, используя семантику, аналогичную используемой при работе с IDataReader.
GetObjectSet	Получить объекты из БД в виде единого массива. В отличии от ArrayList, класс ObjectSet предоставляет дополнительные возможности отслеживания оригинальных значений, передачи изменений через Remoting и некоторые другие.
PersistChanges	Сохранить измененный объект в БД.
MarkForDeletion	Пометить объект для удаления. Реальное удаление происходит при вызове PersistChanges.
Resync	Синхронизировать состочние объекта с информацией из БД.
StartTracking	“Пометить” объект как сохраняемый. Кроме текущих значений, в контексте сохраняется и состояние объекта (новый/измененный/удаленный/без изменений)

Дополнительные возможности ObjectSpaces

Чтение данных с использованием DbObjectReader

В отдельных случаях использование класса ObjectSpace может оказаться избыточным или неудобным. Например, если для доступа к базе данных необходимо использовать хранимые процедуры, большая часть функциональности ObjectSpaces окажется ненужной. Но и для подобных ситуаций в ObjectSpaces есть свое решение. Если требуется извлекать из произвольного источника данных информацию в виде объектов приложения, можно использовать класс DbObjectReader. Выступая как тонкая прослойка между ADO.NET-курсором (IDataReader) и классами приложения, DbObjectReader позволяет загружать сохраняемые объекты из источников данных, которые не поддерживаются ObjectSpaces напрямую.

        public
        static
        void Main()
{
  DataTable table = new DataTable();

  table.Columns.Add("CustomerID", typeof(int));
  table.Columns.Add("CompanyName", typeof(string));
  table.Columns.Add("ContactName", typeof(string));
  table.Columns.Add("Phone", typeof(string));
  table.Rows.Add(newobject[] { 1, "MyCompany", "MyCustomer", "222 33 22" });

  using (IDataReader reader = table.GetDataReader())
  {
    DbObjectReader objectReader = new DbObjectReader(reader,
      typeof(Customer), new MappingSchema("map.xml"));
    while (objectReader.Read())
    {
      Customer cust = (Customer)objectReader.Current;
      Console.WriteLine(cust.Name);
    }
  }
}

ObjectEngine

Класс ObjectEngine лежит в основе ObjectSpaces и реализует механизмы взаимодействия с источником данных. В большинстве случаев ObjectEngine напрямую не используется, но в ситуациях, когда необходимо выполнить OPath-запрос или сохранить объект в БД в обход основной функциональности ObjectSpaces и с минимальными издержками – использование ObjectEngine может пригодиться.

        // Небольшой пример использования функциональности ObjectEngine
        public
        static
        void Main()
{
  using (SqlConnection conn = new SqlConnection(
    "Data Source=tim; Integrated Security=SSPI; Database=northwind"))
  {
    conn.Open();

    // Учитывая, что ObjectEngine – это “низкоуровневый” класс, некоторую часть // подготовительной работы приходится выполнять самостоятельно.
    ObjectContext context = 
      new CommonObjectContext(new ObjectSchema("osd.xml"));
    MappingSchema msd = new MappingSchema("map.xml");
    ObjectSchema osd = new ObjectSchema("osd.xml");
    ObjectSources sources = new ObjectSources();

    sources.Add("NorthwindRSD", conn);

    // Создаем OPath запрос и читаем данные из БД
    ObjectExpression expr = OPath.Parse(
        new ObjectQuery(typeof(Customer), "", ""), osd);

    // Еще одна издержка ObjectEngine – перед использованием OPath // запрос надо “компилировать”.
    CompiledQuery query = expr.Compile(msd);
    Customer cust = null;

    //  Выполняем OPath-запрос, используя “объектный” курсор.using (ObjectReader reader = 
      ObjectEngine.GetObjectReader(sources, context, query, newobject[] { }))
    {
      while (reader.Read())
      {
        cust = (Customer)reader.Current;

        Console.WriteLine(cust.Name);
      }
    }

    //  Cоздаем объект и сохраняем его в источнике данных
    cust = new Customer();
    cust.CustomerID = "alfq";
    cust.Name = "MyName";
    cust.Phone = "MyPhone";
    cust.Company = "MyComp";
    context.Add(cust, ObjectState.Inserted);

    ObjectEngine.PersistChanges(msd, sources, context, 
      newobject[] { cust }, PersistenceOptions.Default);
  }
}

Расширения ObjectSpaces

Использование нескольких XML-схем для описания структуры классов приложения, реляционной структуры БД, а кроме того еще и Mapping-схемы, не может не удручать. Конечно, в финальной версии .NET Framework 1.2 возможности визуального проектирования этих схем должны обязательно появиться, но пока их нет, можно воспользоваться сторонними средствами. Одно из таких средств входит в пример ObjectSpacesPDCSamples.zip (файл можно найти на http://www.gotdotnet.com).

В состав этого примера входит специальная утилита для создания всех необходимых XML-схем (рисунок 4).

Кроме этого, в данный пример входит реализация класса ObjectPersistence. Этот класс обладает одной характерной особенностью – он скрывает в себе не только создание XML-описаний, но и создание необходимой базы данных. Рассмотрим простейший пример использования ObjectPersistence.

        using System;
using Microsoft.ObjectSpaces.ObjectPersistence;

class ObjectPersistenceDemo
{
  //  Исходный код класса ObjectPersistence также доступен в рамках примераstatic ObjectPersistence op = new 
    ObjectPersistence("Data Source=local; Integrated Security=true;", 
    "Persistence");

  staticvoid Main(string[] args)
  {
    Customer c = new Customer();

    //  Ищем заказчика в базе данных 
    c = (Customer)op.LoadObject(typeof(Customer), "CustomerID = 'alfki'");
    if (c == null)
    {
      c = new Customer("alfki");
      c.Comments = "New Customer";
    }
    else
    {
      c.Comments = "Old Customer";
    }
    
    //  Сохраняем изменения. // Если база данных/таблица еще не созданы, то это произойдет сейчас
    op.Persist(c);
  }
}

Класс ObjectPersistence спроектирован таким образом, что для его использования не обязательно предварительно создавать базу данных, настраивать XML-схемы данных – все это делается внутри реализации ObjectPersistence. Так, в приведенном выше примере на SQL Server будет создана база данных Persistence, и в нее будет добавлена таблица с именем Customer. Конечно, не в каждом проекте можно допустить подобные вольности со стороны библиотеки доступа к данным, но для простейших реализаций – это замечательная возможность скрыть ненужные детали.

Итог

Технологии доступа к данным в .NET Framework 1.2 содержат множество полезных нововведений, но если для ADO.NET это скорее эволюционные изменения, связанные с простым расширением библиотеки, то ObjectSpaces является совершенно новым продуктом, который может кардинальным образом изменить подход к работе с данными. Конечно, в настоящий момент работа над библиотекой еще далека от завершения. К моменту выхода VisualStudio «Whidbey» мы сможем увидеть в ней массу изменений, начиная с использования generics и расширения возможностей OPath, и заканчивая DML-операторами для удаления объектов без предварительного их извлечения.

Введение в ObjectSpaces

Автор: Тимофей Казаков (TK)
The RSDN Group
Источник: RSDN Magazine #6-2003

Опубликовано: 14.08.2004
Исправлено: 10.12.2016
Версия текста: 1.0

Сохраняемые объекты

ObjectSpaces

Архитектура ObjectSpaces

Схемы данных

OPath

ObjectSpace

Создание экземпляра ObjectSpace

Запрос к источнику данных

Создание записей в базе данных

Удаление записей с использованием ObjectSpaces

Отложенная загрузка данных

Дополнительные возможности ObjectSpaces

Чтение данных с использованием DbObjectReader

ObjectEngine

Расширения ObjectSpaces

Итог

Введение в ObjectSpaces

Автор: Тимофей Казаков (TK)The RSDN GroupИсточник: RSDN Magazine #6-2003

Опубликовано: 14.08.2004Исправлено: 10.12.2016Версия текста: 1.0

Сохраняемые объекты

ObjectSpaces

Архитектура ObjectSpaces

Схемы данных

OPath

ObjectSpace

Создание экземпляра ObjectSpace

Запрос к источнику данных

Создание записей в базе данных

Удаление записей с использованием ObjectSpaces

Отложенная загрузка данных

Дополнительные возможности ObjectSpaces

Чтение данных с использованием DbObjectReader

ObjectEngine

Расширения ObjectSpaces

Итог

Автор: Тимофей Казаков (TK)
The RSDN Group
Источник: RSDN Magazine #6-2003

Опубликовано: 14.08.2004
Исправлено: 10.12.2016
Версия текста: 1.0