स्वयं को संदर्भित इकाई की रूपरेखा

Question

साथ कोड मेरी समस्या का छोटे पैमाने पर प्रतिनिधित्व करते हैं।

मैं गुणों को अर्थपूर्ण रूप से अलग करने के लिए कैसे कह सकता हूं, और सभी बच्चों की श्रेणियों (बच्चे के रिश्ते के बच्चे (रिकर्सिव टॉप-डाउन)) के साथ SQL सर्वर में दो अलग-अलग संबंध उत्पन्न कर सकता हूं, और दूसरा सभी मूल श्रेणियां प्राप्त करने के लिए (माता-पिता के माता-पिता (रिकर्सिव तल-अप))? कुछ इस तरह:

public virtual ICollection<Category> childCategories { get; set;} 
public virtual ICollection<Category> parentCategories { get; set;} 

मैं modelBuilder साथ यह कोशिश की, लेकिन वहां से मैं केवल विस्तार का एक स्तर प्राप्त कर सकते हैं।

Answer 1

मुझे अपने मॉडल में एक कर्मचारी तालिका पर क्लासिक पर्यवेक्षक/कर्मचारी स्वयं-संदर्भ संबंध के रूप में मेरी परियोजनाओं में से एक में आने के लिए सभी बच्चों के नोड्स को पुनः प्राप्त करने की समस्या हुई है। चूंकि स्लामा और मिल्राकल ने बताया, ईएफ आपको निर्दिष्ट नोड्स के तहत एन की गहराई तक सभी नोड्स को पुनर्प्राप्त करने में मदद नहीं करेगा। हालांकि, मैं अपने भंडार में Breadth-first search algorithm का उपयोग करके इस समस्या को हल करने में सक्षम था। कृपया ध्यान दें, कि मेरा लक्ष्य न केवल सभी बच्चे नोड्स को पुनर्प्राप्त करने के लिए था, बल्कि इतनी जल्दी करने के लिए, क्योंकि रिकर्सिव LINQ प्रश्नों का उपयोग प्रबंधन के शीर्ष स्तर के लिए दो मिनट से अधिक समय ले रहा था। इस विधि का उपयोग करके, यह अब दो सेकंड से भी कम समय में निष्पादित करता है।

public IEnumerable<string> GetAllSubordinateEmployeeIdsByUserId(string userId) 
{ 
    // Retrieve only the fields that create the self-referencing relationship from all nodes 
    var employees = (from e in GetAllEmployees() 
        select new { e.Id, e.SupervisorId }); 
    // Dictionary with optimal size for searching 
    Dictionary<string, string> dicEmployees = new Dictionary<string, string>(employees.Count() * 4); 
    // This queue holds any subordinate employees we find so that we may eventually identify their subordinates as well 
    Queue<string> subordinates = new Queue<string>(); 
    // This list holds the child nodes we're searching for 
    List<string> subordinateIds = new List<string>(); 

    // Load the dictionary with all nodes 
    foreach (var e in employees) 
    { 
     dicEmployees.Add(e.Id, e.SupervisorId); 
    } 

    // Get the key (employee's ID) for each value (employee's supervisor's ID) that matches the value we passed in 
    var directReports = (from d in dicEmployees 
         where d.Value == userId 
         select d.Key); 

    // Add the child nodes to the queue 
    foreach (var d in directReports) 
    { 
     subordinates.Enqueue(d); 
    } 

    // While the queue has a node in it... 
    while (subordinates.Count > 0) 
    { 
     // Retrieve the children of the next node in the queue 
     var node = subordinates.Dequeue(); 
     var childNodes = (from e in dicEmployees 
          where e.Value == node 
          select e.Key); 
     if (childNodes.Count() != 0) 
     { 
      // Add the child nodes to the queue 
      foreach (var c in childNodes) 
      { 
       subordinates.Enqueue(c); 
      } 
     } 
     // Add the node from the queue to the list of child nodes 
     subordinateIds.Add(node); 
    } 

    return subordinateIds.AsEnumerable(); 
} 

इसके अलावा, एक फुटनोट के रूप में, मैं इस Dictionary optimization लेख की मदद से शब्दकोश में लुक-अप की क्षमता बढ़ाने में सक्षम था।