डेटाबेस तर्क विभाग (प्रयास क्रमांक 2)

पहला प्रयास थोड़ा गड़बड़ था, इसलिए मैंने लगातार लिखने का फैसला किया।

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

लेकिन यह डेटाबेस निर्माताओं द्वारा पेश किए जाने वाले इंटरफ़ेस से बाधित हो सकता है। हम MongoDB के आधार पर अभ्यास करेंगे।

यहाँ मैं काम के निम्नलिखित तर्क के कार्यान्वयन का प्रस्ताव करूंगा:

एक आधार वर्ग होना चाहिए जिससे डेटाबेस में संग्रहीत सभी वर्ग विरासत में मिले, उसे DBData होना चाहिए। फिर उसके पास 3 तरीके होंगे: लोड, सेव, डिलीट। डेटाबेस के लिए एक कॉल पहले से ही एक DBData चक्कर होगा।

इस तरह की अवधारणा के लाभ स्पष्ट होना चाहिए - वस्तुओं का उपयोगकर्ता डेटाबेस के कार्यान्वयन और बारीकियों के बारे में सोचने के बिना बस अपनी वस्तुओं को बचा सकता है और पुनर्स्थापित कर सकता है। लेकिन इस रास्ते पर कई मुश्किलें हैं। उन पर विचार करें।

अपडेट मेरे हिस्से की चर्चा समाप्त हो गई है। ध्यान देने के लिए आप सभी का धन्यवाद, लेकिन सत्य ने चर्चा के लिए बहुत समय लिया।



चलो हमारे सॉफ्टवेयर में हमारे प्रबंधन वर्ग के साथ शुरू करते हैं। यह हमेशा एक या दूसरे रूप में होना चाहिए। उनकी जिम्मेदारी काफी व्यापक है - वह हमारे सॉफ्टवेयर में सभी सिस्टम कक्षाओं को चमकाने में लगे हुए हैं, हमारे मामले में भी डेटाबेस का प्रबंधन करते हैं।

सार्वजनिक वर्ग टास्कमैनर
{
/// लिंक कार्य प्रबंधक
निजी स्थैतिक कार्य प्रबंधक
/// हमारे एडॉप्टर को MongoDB से लिंक करें
निजी डेटाबेस currentDatabase ;
सार्वजनिक कार्य प्रबंधक ( )
{
इनस्टांस = यह ;
currentDatabase = नया डेटाबेस ( ) ;
currentDatabase। RunServer ( ) ;
}
/// कार्य प्रबंधक को एक सूचक प्राप्त करें
सार्वजनिक स्थैतिक कार्य प्रबंधक GetInstance ( )
{
यह वापसी ;
}
/// डेटाबेस के लिए एक सूचक प्राप्त करें
सार्वजनिक डेटाबेस GetDatabase ( )
{
currentDatabase पर वापस लौटें ;
}
सार्वजनिक शून्य CloseDBServer ( )
{
अगर ( currentDatabase ! = null )
{ currentDatabase क्लोज़रवर ( ) ; }
}
}

अब MongoDB के लिए वास्तविक एडाप्टर। जैसा कि हम यहां देखते हैं, सामान्यीकृत तरीकों के लिए मानचित्रण का उपयोग करना आवश्यक हो सकता है, और विभिन्न रूपों में।

सार्वजनिक वर्ग डेटाबेस
{
/// MongoDB सर्वर प्रक्रिया
निजी प्रक्रिया MongoDBProcess ;
/// MongoDB सर्वर से कनेक्ट करें
मोंगो मोंगो = नया मोंगो ( ) ;
/// वर्तमान डेटाबेस
IMongoDatabase db ;

/// सर्वर शुरू करें
सार्वजनिक शून्य RunServer ( )
{{ }
/// सर्वर को डिस्कनेक्ट करें
सार्वजनिक शून्य क्लोज़रवर ( )
{{ }

/// ऑब्जेक्ट को ID से लोड करें
सार्वजनिक DBData लोड ( DBData argObject )
{
MethodInfo locMethodGetCollection = GetCollection ( argObject ) ;
var locCollection = locMethodGetCollection। आह्वान ( db, null ) ;
MethodInfo locMethodLoad = GetMethod ( locCollection, "FindOne" , 1 , "ऑब्जेक्ट ऑब्जेक्ट" ) ;
ऑब्जेक्ट [ ] locArgs = { new { ID = argObject। आईडी } } ;
वापसी ( DBData ) locMethodLoad। आह्वान ( locCollection, locArgs ) ;
}
/// ऑब्जेक्ट को सेव करें
सार्वजनिक शून्य सहेजें ( DBData argObject )
{
MethodInfo locMethodGetCollection = GetCollection ( argObject ) ;
var locCollection = locMethodGetCollection। आह्वान ( db, null ) ;
MethodInfo locMethodSave = GetMethod ( लोकोलक्शन, "सहेजें" , 1 , "ऑब्जेक्ट" ) ;
ऑब्जेक्ट [ ] locArgs = { argObject } ;
locMethodSave। आह्वान ( locCollection, locArgs ) ;
}
/// ऑब्जेक्ट हटाएं
सार्वजनिक शून्य हटाएं ( DBData argObject )
{
MethodInfo locMethodGetCollection = GetCollection ( argObject ) ;
var locCollection = locMethodGetCollection। आह्वान ( db, null ) ;
MethodInfo locMethodDelete = GetMethod ( लोकोलिलेशन, "हटाएं" , 1 , "ऑब्जेक्ट" ) ;
ऑब्जेक्ट [ ] locArgs = { new { ID = argObject। आईडी } } ;
locMethodDelete। आह्वान ( locCollection, locArgs ) ;
}

/// वस्तुओं की संख्या प्राप्त करें
सार्वजनिक लंबी गणना ( DBData argObject )
{
MethodInfo locMethodGetCollection = GetCollection ( argObject ) ;
var locCollection = locMethodGetCollection। आह्वान ( db, null ) ;
MethodInfo locMethodCount = GetMethod ( लोकोलक्शन, "काउंट" ) ;
वापसी ( लंबे ) locMethodCount। आह्वान ( लोकोलिलेशन, अशक्त ) ;
}

/// सभी वस्तुओं की पहचान डाउनलोड करें
सार्वजनिक एरेलेस्ट लोडअलाइड ( DBData argObject )
{
MethodInfo locMethodGeneric = InstantiationLoadAllID ( argObject ) ;
ऑब्जेक्ट [ ] locArgs = { argObject } ;
वापसी ( ArrayList ) locMethodGeneric। आह्वान ( यह , locArgs ) ;
}

/// सभी वस्तुओं की पहचान डाउनलोड करें
निजी ArrayList LoadAllID < T > ( DBData argObject ) जहां T : DBData है
{
ArrayList retArray = नया ArrayList ( ) ;
MethodInfo locMethodGetCollection = GetCollection ( argObject ) ;
var locCollection = locMethodGetCollection। आह्वान ( db, null ) ;

MethodInfo locMethodFindAll = GetMethod ( locCollection, "FindAll" ) ;
ICursor < T > locCursor = locMethodFindAll। ICursor < T > के रूप में आह्वान करें ( लोकोलिलेशन, नल ) ;

foreach ( DBData d in locCursor। दस्तावेज़ )
{ रिटायर। जोड़ें ( डी। आईडी ) ; }
वापसी वापसी ;
}

निजी MethodInfo GetCollection ( ऑब्जेक्ट argObject )
{
MethodInfo locMethodGetCollectionGeneric = null ;

प्रकार टाइप करें = टाइपो ( IMongoDatabase ) ;
MethodInfo [ ] myMethod = locType। गेटमेथोड्स ( ) ;
foreach ( मेथेमेट में MethodInfo m )
{
अगर ( m। name == "GetCollection" )
{
ParameterInfo [ ] पी = एम। GetParameters ( ) ;
यदि ( m। ReturnType । IsGenericType && pi। लंबाई == 0 )
{
locMethodGetCollectionGeneric = m ;
तोड़ना ;
}
}
}
प्रकार locObjectType = argObject। GetType ( ) ;
टाइप [ ] locTypeArgs = { locObjectType } ;
locMethodGetCollectionGeneric लौटें। MakeGenericMethod ( locTypeArgs ) ;
}

निजी MethodInfo InstantiationLoadAllID ( ऑब्जेक्ट argObject )
{
MethodInfo locMethodGeneric = अशक्त ;
टाइप टाइप = टाइपोफ़ ( डेटाबेस ) ;
MethodInfo [ ] locMethod = locType। GetMethods ( BindingFlags। NonPublic | BindingFlags। इंस्टेंस )
foreach ( मेथेमेटो में मेथइनफो मी )
{
अगर ( एम। नाम == "लोडएलाइड" )
{
ParameterInfo [ ] पी = एम। GetParameters ( ) ;
यदि ( m। इस्गेनेरिकमेथोड && pi। लंबाई == 1 )
{
locMethodGeneric = m ;
तोड़ना ;
}
}
}
प्रकार locObjectType = argObject। GetType ( ) ;
टाइप [ ] locTypeArgs = { locObjectType } ;
locMethodGeneric लौटें। MakeGenericMethod ( locTypeArgs ) ;
}

निजी MethodInfo GetMethod ( ऑब्जेक्ट argObject, स्ट्रिंग argMethodName )
{
वापसी GetMethod ( argObject, argMethodName, 0 , null ) ;
}

निजी MethodInfo GetMethod ( ऑब्जेक्ट argObject, string argMethodName, int argParamCount, string artTypeP1 )
{
MethodInfo locMethod = अशक्त ;

प्रकार टाइप करें = argObject। GetType ( ) ;
MethodInfo [ ] locMethods = locType। गेटमेथोड्स ( ) ;
foreach ( MethodInfo m in locMethods )
{
अगर ( एम। नाम == argMethodName )
{
ParameterInfo [ ] पी = एम। GetParameters ( ) ;
अगर ( पी। लंबाई == argParamCount )
{
अगर ( पी। लंबाई == 1 )
{
अगर ( pi [ 0 ] । ParameterType । Name ! = artTypeP1 )
{ जारी ; }
}
locMethod = m ;
तोड़ना ;
}
}
}
लोकेमथोड लौटें ;
}
}

लेकिन लब्बोलुआब यह है कि कोई भी एडेप्टर तक नहीं पहुंच रहा है। हमारे पास एक मूल वर्ग है जिसके वंशजों को डेटाबेस से बचाया और पुनर्स्थापित किया जा सकता है। यहाँ मूल वर्ग है:

पब्लिक क्लास DBData
{
सार्वजनिक इंट आईडी ;
सार्वजनिक DBData ( )
{ }

सार्वजनिक DBData ( int argID )
{ ID = argID ; }

निजी डेटाबेस GetDB ( )
{
टास्कमैनजर को लौटाएं । GetInstance ( ) । गेटडाबेस ( ) ;
}

सार्वजनिक int गणना ( )
{
वापसी ( int ) गेटबीडी ( ) । गिनती ( यह ) ;
}
सार्वजनिक शून्य सहेजें ( )
{
GetDB ( ) । बचाओ ( यह ) ;
}
सार्वजनिक शून्य हटाएं ( )
{
GetDB ( ) । हटाएं ( यह ) ;
}
सार्वजनिक वस्तु लोड ( )
{
रिटर्न गेटबीडी ( ) । लोड ( यह ) ;
}
सार्वजनिक ArrayList LoadAllID ( )
{
रिटर्न गेटबीडी ( ) । लोडएलाइड ( यह ) ;
}
}

अगला, वारिस बनाएं:

सार्वजनिक वर्ग रणनीतियाँ : DBData
{
सार्वजनिक स्ट्रिंग नाम ;

सार्वजनिक रणनीतियाँडेटा ( ) : आधार ( )
{ }

सार्वजनिक रणनीतियाँडेटा ( int argID ) : आधार ( argID )
{ }

सार्वजनिक रणनीतियाँडता ( int argID, स्ट्रिंग argName )
{
ID = argID ;
नाम = argName ;
}
}

और फिर हम इसके साथ प्राथमिक रूप से काम करते हैं:

रणनीतियाँडेटा एसडी = नई रणनीतियाँडाटा ( 1 , "टेस्ट 1 " ) ;
एसडी। बचाओ ( ) ;

और पसंद है। क्या आसान और अधिक सुखद हो सकता है :)

युपीडी। यहां मैं उस कोड को फेंक दूंगा जो कई अलग-अलग डेटाबेसों में बदल जाएगा (हम देखते हैं कि यहां के इंटरफेस पूरी तरह से शानदार हैं और आवश्यक नहीं हैं)

सार्वजनिक सार वर्ग डेटाबेस
{

सार्वजनिक सार DBData लोड ( DBData argObject )
{ }
सार्वजनिक सार शून्य सहेजें ( DBData argObject )
{ }
सार्वजनिक सार शून्य हटाएं ( DBData argObject )
{ }
}
सार्वजनिक वर्ग MongoDb : डेटाबेस
{
सार्वजनिक DBData लोड ( DBData argObject )
{ }
सार्वजनिक शून्य सहेजें ( DBData argObject )
{ }
सार्वजनिक शून्य हटाएं ( DBData argObject )
{ }
}
सार्वजनिक वर्ग AnyDb : डेटाबेस
{
सार्वजनिक DBData लोड ( DBData argObject )
{ }
सार्वजनिक शून्य सहेजें ( DBData argObject )
{ }
सार्वजनिक शून्य हटाएं ( DBData argObject )
{ }
}
सार्वजनिक वर्ग टास्कमैनर
{
निजी डेटाबेस currentDatabase ;
/// डेटाबेस के लिए एक सूचक प्राप्त करें
सार्वजनिक डेटाबेस GetDatabase ( )
{
currentDatabase पर वापस लौटें ;
}
सार्वजनिक शून्य ChangeDB ( )
{
यदि ( मानगो के अनुसार )
{
currentDatabase = नया MongoDb ( )
}
अगर ( स्थितियां जब कोई अन्य )
{
currentDatabase = नया AnyDb ( )
}
}
}