यूनिवर्सल ADO.NET इकाई रिपोजिटरी

प्रिय प्रोग्रामर!
ASP.NET MVC2 + इकाई फ्रेमवर्क के साथ मिलकर काम करने के लिए मुझे कोई दुख नहीं था , हालांकि, डेटाबेस के साथ काम करने की बुनियादी कार्यक्षमता ने मुझे बिल्कुल प्रभावित नहीं किया, क्योंकि मुझे हर बार सूची से वस्तुओं के आवश्यक संग्रह का चयन करना था। कई कक्षाओं को लिखने और केवल एक का उपयोग करने से बचें।

आवश्यकताओं

शुरू करने के लिए, हम तय करते हैं कि मैं वास्तव में बाहर निकलने के रास्ते पर क्या करना चाहता हूं।

मैं वस्तुओं के साथ आसानी से काम करना चाहूंगा:

• जोड़ें।
• हटाए गए।
• संपादित करने के लिए।
• आईडी द्वारा प्राप्त करें।
• सभी वस्तुओं की एक सूची प्राप्त करें।

फार्म के निर्माण का उपयोग:

Unit a = new Unit();
BaseRepository<Unit> unitRepository = new BaseRepository<Unit>();
...........
unitRepository.AddItem(a);
unitRepository.ChangeItem(a);
unitRepository.DeleteItem(a.ID);

* This source code was highlighted with Source Code Highlighter .

इसके अलावा, यह स्पष्ट रूप से इंगित करने के लिए नहीं कि किस विशेष सेट ( ObjectSet <...>) ObjectContext के साथ काम करना चाहिए।

प्रतिबिंब के बारे में थोड़ा सिद्धांत

चूंकि मेरा सारा कोड इस सिद्धांत पर आधारित होगा, आपको समझना चाहिए कि यह क्या है।

परावर्तन एक प्रक्रिया है जिसके दौरान कोई प्रोग्राम रनटाइम पर अपनी संरचना और व्यवहार को ट्रैक और संशोधित कर सकता है।

संक्षेप में - बेस क्लास ऑब्जेक्ट में गेटटाइप () विधि होती है जो वर्ग संरचना (इसके सभी गुण, क्षेत्र, विधियाँ) को लौटाती है। इसलिए, हम एक फ़ंक्शन को कॉल करने के लिए और रनटाइम पर गुणों के लिए मान सेट करने के लिए इसका उपयोग कर सकते हैं, यहां तक ​​कि कोड लिखने के चरण में यह जाने बिना कि ये फ़ील्ड और फ़ंक्शन क्लास में मौजूद हैं।

गेट टाइप () विधि एक प्रकार की वस्तु लौटाती है, जिसकी हमें वास्तव में आवश्यकता होती है। लिंक का पालन करके, आप अपने लिए इस ऑब्जेक्ट की विधियों और गुणों की संख्या और विविधता के बारे में देख सकते हैं। अभी के लिए, हमें GetMethod () और GetProperty () की आवश्यकता होगी।

वास्तव में कार्यान्वयन

शुरू करने के लिए, मैं ऑपरेशन के सिद्धांत का वर्णन करूंगा।

संक्षेप में:

1. स्थानांतरित वस्तु का प्रकार प्राप्त करें।
2. नाम से टाइप करें।
3. ObjectContext से निर्धारित वांछित इकाई का चयन करें।
4. वांछित विधि "खींचो" (जोड़ें, हटाएं)।

/// <summary>
/// Base repository for all sets.
/// </summary>
/// <typeparam name="T">Class from Business Model, should be EntityType</typeparam>
public class BaseRepository<T> where T : EntityObject

* This source code was highlighted with Source Code Highlighter .

कोण कोष्ठक में किसी वस्तु को स्थानांतरित करते समय, हम पहले से ही सभी आवश्यक डेटा प्राप्त कर सकते हैं (विशेष रूप से, नाम, जो महत्वपूर्ण है)। चूंकि, डिफ़ॉल्ट रूप से, ObjectContext में ऑब्जेक्ट्स को ****** सेट कहा जाता है, जहां दृश्य संपादक में ****** इकाई का नाम है। प्रतिबिंब का उपयोग करके, हमें कोड में इस नाम को इंगित किए बिना वस्तुओं के किसी भी सेट तक पहुंचने का अवसर मिलता है। इस प्रकार, सभी जोड़तोड़ किए जाते हैं।

उदाहरण के लिए, सभी ObjectSets में DeleteObject पद्धति है।

अगला, हमें खुद ObjectContext की जरूरत है (जहां, वास्तव में, हम डेटा लिखेंगे और प्राप्त करेंगे):

//DataBase container
DBContainer db = new DBContainer();

* This source code was highlighted with Source Code Highlighter .

आप पहले से ही इसे प्राप्त कर सकते हैं, विज़ार्ड और ऑब्जेक्ट्स के दृश्य संपादन का उपयोग कर सकते हैं।

कोड की कुछ और लाइनें केवल पठनीयता में सुधार करती हैं:

/// <summary>
/// Reflection - get name of T.
/// </summary>
private string name
{
get { return typeof (T).Name; }
}

* This source code was highlighted with Source Code Highlighter .

यह टाइप T (ऊपर) का नाम और एक छोटा "मैक्रो" प्रकार की वस्तु प्राप्त कर रहा है:

//Simple macros
Type dbT = typeof (DBContainer);

* This source code was highlighted with Source Code Highlighter .

सामान्य तौर पर, परिचय पूरा हो गया है और आप पूरे कोड पर जा सकते हैं। अगला, मैं कोड के बहुत स्पष्ट टुकड़े के बारे में बात नहीं करूंगा।

using System;
using System.Collections. Generic ;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Data.Objects;
using System.Data.Objects.DataClasses;

namespace Chib.Lib
{
/// <summary>
/// Base repository for all sets.
/// </summary>
/// <typeparam name="T">Class from Business Model, should be EntityType</typeparam>
public class BaseRepository<T> where T : EntityObject
{
/// <summary>
/// Reflection - get name of T.
/// </summary>
private string name
{
get { return typeof (T).Name; }
}

//DataBase container
DBContainer db = new DBContainer();
//Simple macros
Type dbT = typeof (DBContainer);

/// <summary>
/// Get all items in Set as IQueryable, making easy to operate with data.
/// </summary>
/// <returns>Items in Set</returns>
public IQueryable<T> AllItems
{
get
{
return (IQueryable<T>)AllItemsAsObj;
}
}

/// <summary>
/// Get the items (ObjectSet) as Object. For internal use only.
/// </summary>
/// <returns>Object</returns>
private object AllItemsAsObj
{
get
{
PropertyInfo mi = dbT.GetProperty(name + "Set" );
object obj = mi.GetValue(db, null );
return obj;
}
}

/// <summary>
/// Add item to collection and save changes.
/// </summary>
/// <typeparam name="T">The type of item</typeparam>
/// <param name="item">Added item</param>
/// <returns>True if no errors.</returns>
public bool AddItem(T item)
{
try
{
object obj = AllItemsAsObj;
obj.GetType().GetMethod( "AddObject" ).Invoke(obj, new object [] { item });
db.SaveChanges();
return true ;
}
catch
{ return false ; }
}

/// <summary>
/// Get the single T item by it's ID
/// </summary>
/// <param name="id">Guid ID</param>
/// <returns>Null if nothing found.</returns>
public T GetItem( Guid id)
{
foreach ( var item in AllItems)
{
if ( new Guid (item.GetType().GetProperty( "ID" ).GetValue(item, null ).ToString()) == id)
return (T)item;
}
return null ;
}

/// <summary>
/// Delets an item by it's ID.
/// </summary>
/// <param name="id">ID of item</param>
/// <returns>True if no errors.</returns>
public bool DeleteItem( Guid id)
{
try
{
T item = GetItem(id);
object set = AllItemsAsObj;
set .GetType().GetMethod( "DeleteObject" ).Invoke( set , new object [] { item });
db.SaveChanges();
return true ;
}
catch
{
return false ;
}
}

public bool ChangeItem(T item)
{
try
{
var guid = new Guid (item.GetType().GetProperty( "ID" ).GetValue(item, null ).ToString());
T modyfying = AllItems.Single(x => x.GetType().GetProperty( "ID" ).GetValue( null , null ).ToString() == guid.ToString());
modyfying = item;
db.SaveChanges();
return true ;
}
catch
{
return false ;
}
}

/// <summary>
/// Force save changes to DB.
/// </summary>
/// <returns>True if no errors.</returns>
public bool SaveChanges()
{
try
{
db.SaveChanges();
return true ;
}
catch
{
return false ;
}
}
}
}

* This source code was highlighted with Source Code Highlighter .

नुकसान

यहां मैं कुछ बिंदुओं की व्याख्या करना चाहूंगा जिनके बारे में पढ़ने में मैं बहुत आलसी था, जो तुरंत काम नहीं करता था, साथ ही साथ कोड के गैर-स्पष्ट टुकड़े भी।

निजी ऑब्जेक्ट AllItemsAsObj () फ़ंक्शन का उपयोग ऑब्जेक्ट्स (ऑब्जेक्टसेट) के सेट को प्राप्त करने के लिए किया जाता है और केवल कक्षा के अंदर ही उपलब्ध होता है। यह लगभग सभी मामलों में आवश्यक है, क्योंकि यह हमारी मूल वस्तु है, जिस पर जोड़-तोड़ किया जाएगा।

AddItem (T आइटम) फ़ंक्शन पहले लिखा गया था।
मैं GetMethod विधि का चालान विधि नहीं चाहूंगा। यह पता चला कि एक तर्क के रूप में पारित करना आवश्यक था जिस पर हम कार्रवाई करते हैं। अशक्त स्थापित करके (जैसा कि मैंने अज्ञात साइटों पर उदाहरणों में देखा था), विधि को नहीं बुलाया गया था। इस पर ध्यान दो!

/// <summary>
/// Get the single T item by it's ID
/// </summary>
/// <param name="id">Guid ID</param>
/// <returns>Null if nothing found.</returns>
public T GetItem( Guid id)
{
foreach ( var item in AllItems)
{
if ( new Guid (item.GetType().GetProperty( "ID" ).GetValue(item, null ).ToString()) == id)
return (T)item;
}
return null ;
}

* This source code was highlighted with Source Code Highlighter .

कोड का यह हिस्सा सेट से एक वस्तु को अपनी आईडी द्वारा चुनता है। मेरे प्रोजेक्ट में, हर ऑब्जेक्ट में एक प्रकार का ID फ़ील्ड होता है। यदि आपके पास यह अलग है - बस अपने नाम के साथ "आईडी" के सभी संदर्भों को बदलें।
इस फ़ंक्शन में, संग्रह के सभी तत्वों की गणना की जाती है, और जब आईडी फ़ील्ड का मान इनपुट पैरामीटर के साथ मेल खाता है, तो वांछित वस्तु वापस आ जाती है।

प्रत्येक फ़ंक्शन के अंत में एक पंक्ति है:

db.SaveChanges();

* This source code was highlighted with Source Code Highlighter .

यह डेटाबेस में किए गए सभी परिवर्तनों को बचाता है।

उदाहरण का उपयोग करें

मान लीजिए कि आपके पास दो वर्ग हैं: यूनिट और सिटी।
डेटाबेस के साथ काम करने के लिए दो रिपॉजिटरी घोषित करने के लिए, निम्नानुसार आगे बढ़ें:

BaseRepository<Unit> unitRepository = new BaseRepository<Unit>();
BaseRepository<City> cityRepository = new BaseRepository<City>();

* This source code was highlighted with Source Code Highlighter .

सब कुछ, कोई अधिक जोड़तोड़ की जरूरत है। आपके पास पहले से तैयार वस्तुएं हैं जो आपके काम में मदद करेंगी। यदि आप चाहें, तो आप अपनी कक्षा को विरासत में प्राप्त कार्यों के साथ कार्यक्षमता का विस्तार कर सकते हैं।