🛀🏾 🥥 👩🏾‍🌾 ストーブを離れずにORMを調理する 💀 👂🏿 🚞

この記事は、 ~~過激派の~~バイクの設計を求めるものではありません。投稿の目的はメカニズムをよく理解することです。多くの場合、最初から作成する必要があります。これは、ORMなどの不安定なトピックの場合に特に当てはまります。

なぜこれだけなのですか？

MS Entity Framework、NHibernateなどの工業製品は複雑で、優れた機能を備えており、実際にはそれ自体が別個のものです。多くの場合、このようなORMから目的の動作を取得するには、そのようなシステムの複雑な操作に精通している別の人が必要です。これはチーム開発には適していません。

投稿の主な理論的情報源は、 Martin Fowlerの著書『Patterns of Enterprise Application Architecture（P of EAA）』です。

実際にORM、DDD、TTD、 ~~交通警察~~とは何かについて多くの情報があります-私はここで止まらないようにします、私の目標は実用的です。記事の2つの部分が想定されています。最後に、gitハブの完全なソースコードへのリンクがあります。

何を取得したいですか？

すぐに用語を定義します：追跡とは、保存されたデータをさらに同期するために、単一のトランザクション内でビジネスオブジェクトの変更を追跡することを意味します

RAMおよびデータベースの内容。

ORMの主な種類は何ですか？

.NETの世界でトラッキングを使用するためのORMには、変更を追跡する場合と変更を追跡しない場合の2種類があります。
SQLクエリを生成するアプローチについて：クエリを明示的に使用し、オブジェクトモデルのクエリジェネレーターに基づきます。

たとえば、クエリを使用せず、クエリを明示的に使用する有名なORMの中で、最も顕著な例はStack OverflowのDapper ORMです。このようなORMの主な機能は、リレーショナルデータベースモデルをオブジェクトモデルにマップすることです。一方、クライアントはデータベースへのクエリの外観を明確に決定します。

オブジェクトモデルの追跡およびクエリジェネレーターの使用におけるMS Entity FrameworkおよびNHibernateの基本概念。これらのアプローチの長所と短所は考慮しません。すべてのヨーグルトは同様に有用であり、真実はアプローチを組み合わせることにあります。

顧客（つまり、私）は、追跡を使用して（オフにする機能を備えた）、オブジェクトモデルのクエリジェネレーターに基づいてORMを作成したいと考えていました。 Linq2Sql、LinqToEntitiesを使用せずに、ラムダ-C＃言語式、ゼロからSQLクエリを生成します（はい、ハードコアのみ！）。

すぐに使用できるMS Entity Frameworkには、データのバッチ更新と削除に関する厄介な問題があります。最初にデータベースからすべてのオブジェクトを取得し、次にサイクルで更新/削除してから、データベースに変更を適用する必要があります。その結果、データベースへの呼び出しが必要以上に多くなります。ここで問題を説明します。この問題は、記事の後半で解決します。

主な成分を決定する

クライアントコードが開発中のライブラリとどのようにやり取りするかを直ちに決定します。クライアントコードから利用できるORMの主要コンポーネントを強調します。

クライアントとORMとの対話の概念は、抽象リポジトリからの継承という考え方に基づいています。また、スーパークラスを定義して、ORMが動作するビジネスオブジェクトのセットを制限する必要があります。

各ビジネスオブジェクトはそのタイプ内で一意である必要があるため、相続人は自分の識別子を明示的に再定義する必要があります。

空のリポジトリとビジネスオブジェクトのスーパークラス

public abstract class Repository<T> : IRepository<T> where T : EntityBase,new() { //   }

 //   public abstract class EntityBase : IEntity { //      public abstract int Id { get; set; } public object Clone() { return MemberwiseClone(); } }

Clone（）メソッドは、追跡するときにオブジェクトをコピーするのに便利です。詳細は以下を参照してください。

ユーザーに関する情報を保存するクライアントビジネスオブジェクト、Profileクラスを作成します。

ORMでビジネスオブジェクトを使用するには、3つの手順が必要です。

属性に基づいてビジネスオブジェクトをデータベースのテーブルにバインドする

クラスクラス

  //       EntityBase [TableName("profile")] public class Profile : EntityBase { //        [FieldName("profile_id")] public override int Id { get; } [FieldName("userinfo_id")] public int? UserInfoId { get; set; } [FieldName("role_id")] public int RoleId { get; set; } public string Info { get; set; } }

各ビジネスオブジェクトのリポジトリを定義する

プロファイルリポジトリは次のようになります

  public class ProfileRepository : Repository<Profile> { //         public ProfileRepository() : base("PhotoGallery") { //  CRUD  } }

データベースへの接続文字列を形成する

接続文字列は次のようになります

 <connectionStrings> <add name="PhotoGallery" providerName="System.Data.SqlClient" connectionString="server=PC\SQLEXPRESS; database=db_PhotoGallery"/> </connectionStrings>

変更を追跡するには、UnitOfWorkパターンを使用するのが慣例です。 UnitOfWorkの本質は、ドメインオブジェクトで実行されるアクションを追跡して、メインメモリに格納されているデータをデータベースの内容とさらに同期させることです。この場合、変更は一度にすべて記録されます。

UnitOfWorkフロントエンド

  public interface IUnitOfWork : IDisposable { void Commit(); }

それがすべてのようです。ただし、考慮すべきことが2つあります。

変更の追跡は、現在のビジネストランザクション全体に役立ち、すべてのビジネスオブジェクトにアクセスできる必要があります。
ビジネストランザクションは単一のスレッド内で実行する必要があるため、ローカルスレッドストアを使用して、作業単位を現在実行中のスレッドに関連付ける必要があります。

UnitOfWorkオブジェクトが既にビジネストランザクションフローに関連付けられている場合は、このオブジェクトに配置する必要があります。さらに、論理的な観点から見ると、作業ユニットはこのセッションに属します。

静的クラスSessionを使用します

  public static class Session { //   private static readonly ThreadLocal<IUnitOfWork> CurrentThreadData = new ThreadLocal<IUnitOfWork>(true); public static IUnitOfWork Current { get { return CurrentThreadData.Value; } private set { CurrentThreadData.Value = value; } } public static IUnitOfWork Create(IUnitOfWork uow) { return Current ?? (Current = uow); } }

追跡せずに行う必要がある場合、Session.Createを呼び出すように、UnitOfWorkクラスのインスタンスを作成する必要はありません。

したがって、ORMとやり取りするために必要なすべての要素を決定した後、ORMで作業する例を示します。

ORMの使用例

  var uow = new UnitOfWork(); using (Session.Create(uow)) { var profileRepo = new ProfileRepository(); //   uow.Commit(); }

料理を始める

前に説明したことはすべて、公開部分に関するものでした。次に、内部の部分を検討します。さらに開発するには、追跡するオブジェクトの構造を決定する必要があります。

ビジネスオブジェクトと追跡オブジェクトを混同しないでください。

ビジネスオブジェクトには独自のタイプがありますが、トラッキングオブジェクトは多くのビジネスオブジェクトの大量操作に適している必要があります。つまり、特定のタイプに依存するべきではありません。
追跡オブジェクトは、特定のビジネストランザクション内に存在するエンティティです。多くのビジネスオブジェクトの中で、その一意性はこのトランザクションのフレームワーク内で決定する必要があります

そのようなオブジェクトには、プロパティが必要であることになります。

タイプ内で一意
変わらない

本質的に、追跡用のオブジェクトは、ビジネスオブジェクトを格納するためのコンテナです。前述したように、すべてのクライアントビジネスオブジェクトはEntityBaseスーパークラスの祖先である必要があり、それらのオブジェクト識別子を再定義する必要があります。識別子は、型、つまりデータベース内のテーブル内で一意性を提供します。

追跡用のオブジェクトコンテナーの実装

  internal struct EntityStruct { //  internal Type Key { get; private set; } internal EntityBase Value { get; private set; } internal EntityStruct(Type key, EntityBase value) : this() { Key = key; Value = value; } public override bool Equals(object obj) { if (!(obj is EntityStruct)) { throw new TypeAccessException("EntityStruct"); } return Equals((EntityStruct)obj); } public bool Equals(EntityStruct obj) { if (Value.Id != obj.Value.Id) { return false; } return Key == obj.Key; } public override int GetHashCode() { //   ,        // return (unchecked(25 * Key.GetHashCode()) ^ Value.Id.GetHashCode()) & 0x7FFFFFFF; } }

ビジネスオブジェクトの追跡

追跡用のオブジェクトの登録は、リポジトリからこれらのオブジェクトを受信する段階で行われます。

データベースからビジネスオブジェクトを受け取ったら、追跡用のオブジェクトとして登録する必要があります。

このようなオブジェクトには、データベースからの受信直後と、変更をコミットする前の2つの状態があります。

最初のオブジェクトは「クリーン」、2番目のオブジェクトは「ダーティ」オブジェクトと呼ばれます。

例

  var uow = new UnitOfWork(); using (Session.Create(uow)) { var profileRepo = new ProfileRepository(); // ""      , //  "" var profiles = profileRepo.Get(x=>x.Info = " "); // ""  foreach (var profile in profiles) { profile.Info = " "; } //  uow.Commit(); }

重要な点は、「クリーンな」オブジェクトを保持するには、コピー操作が必要であり、パフォーマンスに悪影響を及ぼす可能性があることです。

一般に、追跡オブジェクトは操作の種類ごとに登録する必要があるため、更新、削除、挿入の操作用のオブジェクトが必要です。

値による比較操作が必要な、実際に変更されたオブジェクトのみを登録する必要があることを考慮する必要があります（オーバーライドされたEqualsメソッドを使用したEntityStruct構造の実装は上記で提供されています）。最終的に、比較操作はハッシュの比較に限定されます。

追跡オブジェクトの登録のイベントは、CRUDメソッドのリポジトリの抽象クラスの機能から発生します。

追跡オブジェクト登録機能の実装

  internal interface IObjectTracker { //            ICollection<EntityStruct> NewObjects { get; } ICollection<EntityStruct> ChangeObjects { get; } //  void RegInsertedNewObjects(object sender, AddObjInfoEventArgs e); void RegCleanObjects(object sender, DirtyObjsInfoEventArgs e); } internal class DefaultObjectTracker : IObjectTracker { //  - "" ,  - ""  private readonly Dictionary<EntityStruct, EntityStruct> _dirtyCreanPairs; public ICollection<EntityStruct> NewObjects { get; private set; } public ICollection<EntityStruct> ChangeObjects { get { //    return _dirtyCreanPairs.GetChangesObjects(); } } internal DefaultObjectTracker() { NewObjects = new Collection<EntityStruct>(); //   boxing/unboxing    EqualityComparer _dirtyCreanPairs = new Dictionary<EntityStruct, EntityStruct>(new IdentityMapEqualityComparer()); } public void RegInsertedNewObjects(object sender, AddObjInfoEventArgs e) { NewObjects.Add(e.InsertedObj); } public void RegCleanObjects(object sender, DirtyObjsInfoEventArgs e) { var objs = e.DirtyObjs; foreach (var obj in objs) { if (!_dirtyCreanPairs.ContainsKey(obj)) { // ""       MemberwiseClone() var cloneObj = new EntityStruct(obj.Key, (EntityBase)obj.Value.Clone()); _dirtyCreanPairs.Add(obj, cloneObj); } } } }

クライアントによって変更されたオブジェクトを識別する機能

  public static ICollection<EntityStruct> GetChangesObjects ( this Dictionary<EntityStruct, EntityStruct> dirtyCleanPairs ) { var result = new List<EntityStruct>(); foreach (var cleanObj in dirtyCleanPairs.Keys) { if (!(cleanObj.Key == dirtyCleanPairs[cleanObj].Key)) { throw new Exception("incorrect types"); } if (ChangeDirtyObjs(cleanObj.Value, dirtyCleanPairs[cleanObj].Value, cleanObj.Key)) { result.Add(cleanObj); } } return result; } public static bool ChangeDirtyObjs(EntityBase cleanObj, EntityBase dirtyObj, Type type) { var props = type.GetProperties(); //     foreach (var prop in props) { var cleanValue = prop.GetValue(cleanObj, null); var dirtyValue = prop.GetValue(dirtyObj, null); //    ,      if (!cleanValue.Equals(dirtyValue)) { return true; } } return false; }

1つのトランザクションのビジネスオブジェクトは異なるデータベースからのものである可能性があることに注意してください。各データベースに対して、追跡の独自のインスタンス（IObjectTrackerを実装するクラス、たとえばDefaultObjectTracker）を定義する必要があると想定するのは論理的です。

現在のトランザクションは、データベースが追跡される元の「既知」である必要があります。 UnitOfWorkのインスタンスを作成する段階で、構成ファイルで指定されたデータベース接続を使用して、追跡オブジェクトのインスタンス（DefaultObjectTrackerクラスのインスタンス）を初期化する必要があります。

UnitOfWorkのクラスを変更しましょう

  internal interface IDetector { //  -    ,  -   Dictionary<string, IObjectTracker> ObjectDetector { get; } } public sealed class UnitOfWork : IUnitOfWork, IDetector { private readonly Dictionary<string, IObjectTracker> _objectDetector; Dictionary<string, IObjectTracker> IDetector.ObjectDetector { get { return _objectDetector; } } public UnitOfWork() { _objectDetector = new Dictionary<string, IObjectTracker>(); foreach (ConnectionStringSettings conName in ConfigurationManager.ConnectionStrings) { //        _objectDetector.Add(conName.Name, new DefaultObjectTracker()); } } }

トランザクション内のすべてのリポジトリインスタンスで使用できるデータベースに対応する追跡インスタンスに関する情報。静的Sessionクラスに単一のアクセスポイントを作成すると便利です。

セッションクラスの形式

  public static class Session { private static readonly ThreadLocal<IUnitOfWork> CurrentThreadData = new ThreadLocal<IUnitOfWork>(true); public static IUnitOfWork Current { get { return CurrentThreadData.Value; } private set { CurrentThreadData.Value = value; } } public static IUnitOfWork Create(IUnitOfWork uow) { return Current ?? (Current = uow); } //        //     internal static IObjectTracker GetObjectTracker(string connectionName) { var uow = Current; if (uow == null) { throw new ApplicationException(" Create unit of work context and using Session."); } var detector = uow as IDetector; if (detector == null) { throw new ApplicationException("Create unit of work context and using Session."); } return detector.ObjectDetector[connectionName]; } } }

データアクセス

データアクセス機能は、データベースアクセスメソッドを直接呼び出します。この機能は、CRUDメソッドの抽象リポジトリクラスによって使用されます。単純な場合、データアクセスクラスには、データを操作するためのCRUDメソッドが含まれます。

DbProviderクラスの実装

  internal interface IDataSourceProvider : IDisposable { State State { get; } //     ,      void Commit(ICollection<EntityStruct> updObjs); ICollection<T> GetByFields<T>(BinaryExpression exp) where T : EntityBase, new(); } internal class DbProvider : IDataSourceProvider { private IDbConnection _connection; internal DbProvider(IDbConnection connection) { _connection = connection; State = State.Open; } public State State { get; private set; } public ICollection<T> GetByFields<T>(BinaryExpression exp) where T : EntityBase, new() { //    select-   exp Func<IDbCommand, BinaryExpression, string> cmdBuilder = SelectCommandBulder.Create<T>; ICollection<T> result; using (var conn = _connection) { using (var command = conn.CreateCommand()) { command.CommandText = cmdBuilder.Invoke(command, exp); command.CommandType = CommandType.Text; conn.Open(); result = command.ExecuteListReader<T>(); } } State = State.Close; return result; } public void Commit(ICollection<EntityStruct> updObjs) { if (updObjs.Count == 0) { return; } //  -    update-   exp // -   var cmdBuilder = new Dictionary<Func<IDbCommand, ICollection<EntityStruct>, string>, ICollection<EntityStruct>>(); cmdBuilder.Add(UpdateCommandBuilder.Create, updObjs); ExecuteNonQuery(cmdBuilder, packUpdDict, packDeleteDict); } private void ExecuteNonQuery(Dictionary<Func<IDbCommand, ICollection<EntityStruct>, string>, ICollection<EntityStruct>> cmdBuilder) { using (var conn = _connection) { using (var command = conn.CreateCommand()) { var cmdTxtBuilder = new StringBuilder(); foreach (var builder in cmdBuilder) { cmdTxtBuilder.Append(builder.Key.Invoke(command, builder.Value)); } command.CommandText = cmdTxtBuilder.ToString(); command.CommandType = CommandType.Text; conn.Open(); if (command.ExecuteNonQuery() < 1) throw new ExecuteQueryException(command); } } State = State.Close; } private ICollection<T> ExecuteListReader<T>(EntityStruct objs) where T : EntityBase, IEntity, new() { Func<IDbCommand, EntityStruct, string> cmdBuilder = SelectCommandBulder.Create; ICollection<T> result; using (var conn = _connection) { using (var command = conn.CreateCommand()) { command.CommandText = cmdBuilder.Invoke(command, objs); command.CommandType = CommandType.Text; conn.Open(); result = command.ExecuteListReader<T>(); } } State = State.Close; return result; } private void Dispose() { if (State == State.Open) { _connection.Close(); State = State.Close; } _connection = null; GC.SuppressFinalize(this); } void IDisposable.Dispose() { Dispose(); } ~DbProvider() { Dispose(); } }

DbProviderクラスには、データベースへの既存の接続が必要です。ファクトリメソッドに基づいて、接続と追加のインフラストラクチャの作成を別のクラスに委任します。したがって、ファクトリの補助クラスを介してのみDbProviderクラスのインスタンスを作成する必要があります。

DbProvider Factoryメソッド

  class DataSourceProviderFactory { static DbConnection CreateDbConnection(string connectionString, string providerName) { if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentException("connectionString is null or whitespace"); } DbConnection connection; DbProviderFactory factory; try { factory = DbProviderFactories.GetFactory(providerName); connection = factory.CreateConnection(); if (connection != null) connection.ConnectionString = connectionString; } catch (ArgumentException) { try { factory = DbProviderFactories.GetFactory("System.Data.SqlClient"); connection = factory.CreateConnection(); if (connection != null) { connection.ConnectionString = connectionString; } } catch (Exception) { throw new Exception("DB connection has been failed."); } } return connection; } public static IDataSourceProvider Create(string connectionString) { var settings = ConfigurationManager.ConnectionStrings[connectionString]; var dbConn = CreateDbConnection(settings.ConnectionString, settings.ProviderName); return new DbProvider(dbConn); } public static IDataSourceProvider CreateByDefaultDataProvider(string connectionString) { var dbConn = CreateDbConnection(connectionString, string.Empty); return new DbProvider(dbConn); } }

追跡オブジェクトの登録は、リポジトリのCRUDメソッドで行われる必要があり、CRUDメソッドは機能をデータアクセスレイヤーに委任します。したがって、トラッキングを考慮すると、IDataSourceProviderインターフェイスの実装が必要です。このクラスで興奮するイベントのメカニズムに基づいてオブジェクトを登録します。 IDataSourceProviderインターフェイスの想定される新しい実装は、追跡のために登録イベントを開始し、データベースにアクセスできる必要があります。この場合、DbProviderクラスを装飾すると便利です。

TrackerProviderクラスの実装

  internal class TrackerProvider : IDataSourceProvider { private event EventHandler<DirtyObjsInfoEventArgs> DirtyObjEvent; private event EventHandler<UpdateObjsInfoEventArgs> UpdateObjEvent; private readonly IDataSourceProvider _dataSourceProvider; private readonly string _connectionName; private readonly object _syncObj = new object(); private IObjectTracker ObjectTracker { get { lock (_syncObj) { //     return Session.GetObjectTracker(_connectionName); } } } public TrackerProvider(string connectionName) { _connectionName = connectionName; _dataSourceProvider = DataSourceProviderFactory.Create(_connectionName); //    RegisterEvents(); } public State State { get { return _dataSourceProvider.State; } } private void RegisterEvents() { //       if (Session.Current == null) { throw new ApplicationException("Session has should be used. Create a session."); }; //    DirtyObjEvent += ObjectTracker.RegCleanObjects; UpdateObjEvent += ObjectTracker.RegUpdatedObjects; } public ICollection<T> GetByFields<T>(BinaryExpression exp) where T : EntityBase, IEntity, new() { //        DbProvider var result = _dataSourceProvider.GetByFields<T>(exp); var registratedObjs = result.Select(r => new EntityStruct(typeof(T), r)).ToList(); //   ""  var handler = DirtyObjEvent; if (handler == null) return result; handler(this, new DirtyObjsInfoEventArgs(registratedObjs)); return result; } public void Commit(ICollection<EntityStruct> updObjs) { //     DbProvider _dataSourceProvider.Commit(updObjs, delObjs, addObjs, packUpdObjs, deleteUpdObjs); } public void Dispose() { _dataSourceProvider.Dispose(); } }

小計

パブリッククラスがどのように見えるかを見てみましょう。

上記のように、リポジトリクラスはその機能をIDataSourceProviderインターフェイス実装に委任する必要があります。コンストラクターに渡された接続文字列に基づいてリポジトリクラスを初期化するとき、トラッキングの使用に応じて、IDataSourceProviderの必要な実装を作成する必要があります。また、データアクセスクラスがデータベースへの接続をいつでも「失う」可能性があることを考慮する必要があります。このため、プロパティを使用してこの接続を監視します。

前述のように、UnitOfWorkクラスは、そのコンストラクターで、データベース接続文字列で使用可能なすべてに従って、DefaultObjectTrackerクラスのオブジェクトのリストを作成する必要があります。変更の修正もすべてのデータベースで発生する必要があることは論理的です。追跡インスタンスごとに、変更を修正するメソッドが呼び出されます。

Public-クラスは次の形式を取ります

 public abstract class Repository<T> : IRepository<T> where T : EntityBase, IEntity, new() { private readonly object _syncObj = new object(); private IDataSourceProvider _dataSourceProvider; //c   ""    private IDataSourceProvider DataSourceProvider { get { lock (_syncObj) { if (_dataSourceProvider.State == State.Close) { _dataSourceProvider = GetDataSourceProvider(); } return _dataSourceProvider; } } } private readonly string _connectionName; protected Repository(string connectionName) { if (string.IsNullOrWhiteSpace(connectionName)) { throw new ArgumentNullException("connectionName"); } _connectionName = connectionName; var dataSourceProvider = GetDataSourceProvider(); if (dataSourceProvider == null) { throw new ArgumentNullException("dataSourceProvider"); } _dataSourceProvider = dataSourceProvider; } private IDataSourceProvider GetDataSourceProvider() { //      DbProvider' //    ////  - TrackerProvider return Session.Current == null ? DataSourceProviderFactory.Create(_connectionName) : new TrackerProvider(_connectionName); } public ICollection<T> Get(Expression<Func<T, bool>> exp) { return DataSourceProvider.GetByFields<T>(exp.Body as BinaryExpression); } } public sealed class UnitOfWork : IUnitOfWork, IDetector { private readonly Dictionary<string, IObjectTracker> _objectDetector; Dictionary<string, IObjectTracker> IDetector.ObjectDetector { get { return _objectDetector; } } public UnitOfWork() { _objectDetector = new Dictionary<string, IObjectTracker>(); foreach (ConnectionStringSettings conName in ConfigurationManager.ConnectionStrings) { _objectDetector.Add(conName.Name, new DefaultObjectTracker()); } } public void Commit() { SaveChanges(); } private void SaveChanges() { foreach (var objectDetector in _objectDetector) { //         var provider = new TrackerProvider(objectDetector.Key); provider.Commit( objectDetector.Value.ChangeObjects, objectDetector.Value.DeletedObjects, objectDetector.Value.NewObjects, objectDetector.Value.UpdatedObjects, objectDetector.Value.DeletedWhereExp); } } }

記事の続きでは、関連するエンティティの操作、式ツリーに基づくSQLクエリの生成、データの一括削除/変更方法（UpdateWhere、RemoveWhereなど）を検討します。

単純化せずに、プロジェクトのソースコード全体がここにあります。

ストーブを離れずにORMを調理する