डिज़ाइन पैटर्न: समान फ़ाइलों को पार्स करना, लेकिन टेक्स्ट फ़ाइलों में अलग-अलग स्कीमा

Question

आपकी सहायता के लिए अग्रिम धन्यवाद। मैं सोच रहा हूं कि कोई (डिज़ाइन) पैटर्न है जिसे इस समस्या पर लागू किया जा सकता है।

मैं इसी तरह के, लेकिन अलग-अलग प्रारूपों के साथ टेक्स्ट फ़ाइलों से मूल्यों को पार्स, प्रोसेस और निकालने के लिए देख रहा हूं।

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

मेरा पहला विचार केवल 1 वर्ग बनाना होगा जो प्रत्येक फ़ाइल प्रकार और पार्स/प्रक्रियाओं के अनुसार "स्कीमा" स्वीकार करता है। मुझे यकीन है कि इसके लिए एक बेहतर समाधान है।

धन्यवाद!

बोनस प्वाइंट: सी # में कोई विशिष्ट कार्यान्वयन संकेत।

Answer 1

इस रणनीति पैटर्न के लिए एक उम्मीदवार की तरह लगता है। सी # में एक उदाहरण here और दूसरा एक here पाया जा सकता है। Wikipedia पर एक संक्षिप्त विवरण उपलब्ध है।

अधिक संपूर्ण विवरण Fowler और Kerievsky द्वारा पुस्तक में उपलब्ध है।

यह गोफ बुक से भी उपलब्ध है।

Answer 2

"प्रदाता" पैटर्न वह है जिसे आप ढूंढ रहे हैं ... यह ADO.Net में उपयोग किया जाता है। प्रत्येक डेटाबेस विक्रेता के पास एक अलग डेटा "प्रदाता" होता है जो "विशिष्ट" डीबी विक्रेताओं के उत्पाद से डेटा को कैसे पढ़ा जाता है, लेकिन इसे मानक प्रारूप (इंटरफ़ेस) में डाउनस्ट्रीम सिस्टम में वितरित करता है ... आप एक छोटा "प्रदाता" लिखेंगे घटक (एकल वर्ग पर्याप्त होगा) कि अपने अलग वेबसाइट पोकर इतिहास डेटा प्रदाताओं से प्रत्येक के लिए प्रारूप "जानता", और उजागर करता है कि नदी के ऊपर प्रणाली है कि इसे पढ़ता है के लिए बिल्कुल उसी तरह डेटा ...

Answer 3

पहले, अपना "ऑनलाइन पोकर हैंड हिस्ट्री" बनाएं मॉडल। यह मॉडल डेटा का प्रतिनिधित्व करेगा और स्रोत से स्वतंत्र रूप से इस डेटा को संसाधित करने में सक्षम होगा। फिर प्रदाता प्रत्येक अलग-अलग स्रोत प्रारूपों के लिए बनाएं जो फ़ाइल की जानकारी को मॉडल में परिवर्तित करने में सक्षम होना चाहिए।

संपादित करें: उदा।

public interface IDataProvider 
{ 
    IOnlinePokerInfo ParseFileInformation(FileInfo input); 
} 

public interface IOnlinePokerInfo 
{ 
    int Hand { get; set; } 
    DateTime DateInfo { get; set; } 
    List<IPlayer> Players { get; set; } 
    void ProcessInformation(); 
} 

public interface IPlayer 
{ 
    string Name { get; set; } 
} 

public class MyOnlinePokerInfo : IOnlinePokerInfo 
{ 
    private int hand; 
    private DateTime date; 
    private List<IPlayer> players; 

    public int Hand { get { return hand; } set { hand = value; } } 
    public DateTime DateInfo { get { return date; } set { date = value; } } 
    public List<IPlayer> Players { get { return players; } set { players = value; } } 

    public MyOnlinePokerInfo(int hand, DateTime date) 
    { 
     this.hand = hand; 
     this.date = date; 
     players = new List<IPlayer>(); 
    } 

    public MyOnlinePokerInfo(int hand, DateTime date, List<IPlayer> players) 
     : this(hand, date) 
    { 
     this.players = players; 
    } 

    public void AddPlayer(IPlayer player) 
    { 
     players.Add(player); 
    } 

    public void ProcessInformation() 
    { 
     Console.WriteLine(ToString()); 
    } 

    public override string ToString() 
    { 
     StringBuilder info = new StringBuilder("Hand #: " + hand + " Date: " + date.ToLongDateString()); 
     info.Append("\nPlayers:"); 
     foreach (var s in players) 
     { 
      info.Append("\n"); 
      info.Append(s.Name); 
     } 
     return info.ToString(); 
    } 
} 

public class MySampleProvider1 : IDataProvider 
{ 
    public IOnlinePokerInfo ParseFileInformation(FileInfo input) 
    { 
     MyOnlinePokerInfo info = new MyOnlinePokerInfo(1, DateTime.Now); 
     IPlayer p = new MyPlayer("me"); 
     info.AddPlayer(p); 
     return info; 
    } 
} 

public class MySampleProvider2 : IDataProvider 
{ 
    public IOnlinePokerInfo ParseFileInformation(FileInfo input) 
    { 
     MyOnlinePokerInfo info = new MyOnlinePokerInfo(2, DateTime.Now); 
     IPlayer p = new MyPlayer("you"); 
     info.AddPlayer(p); 
     return info; 
    } 
} 

public class MyPlayer : IPlayer 
{ 
    private string name; 
    public string Name { get { return name; } set { name = value; } } 

    public MyPlayer(string name) 
    { 
     this.name = name; 
    } 
} 

public class OnlinePokerInfoManager 
{ 
    static void Main(string[] args) 
    { 
     List<IOnlinePokerInfo> infos = new List<IOnlinePokerInfo>(); 

     MySampleProvider1 prov1 = new MySampleProvider1(); 
     infos.Add(prov1.ParseFileInformation(new FileInfo(@"c:\file1.txt"))); 

     MySampleProvider2 prov2 = new MySampleProvider2(); 
     infos.Add(prov2.ParseFileInformation(new FileInfo(@"c:\file2.log"))); 

     foreach (var m in infos) 
     { 
      m.ProcessInformation(); 
     } 
    } 
} 

Answer 4

लगता है कि आपने रणनीति पैटर्न है, जो आप अलग अलग तरीकों की एक संख्या में एक एल्गोरिथ्म को लागू करने की अनुमति देता है की जरूरत है:

http://en.wikipedia.org/wiki/Strategy_pattern

Answer 5

तुम भी जहां पहुंच के लिए एक कार्य के लिए होता है Command Pattern उपयोग करने पर विचार कर सकता है फ़ाइल प्रकार का समय आपको संसाधित करने की आवश्यकता है। इस तरह आप सभी प्रारूपों के लिए लचीलापन प्राप्त कर सकते हैं और आपके प्रक्रिया की आवश्यकता वाले लगातार पैरामीटर का पालन कर सकते हैं।

एक अन्य लाभ यह है कि आप अन्य प्रारूपों के लिए कोड को दोबारा बिना किसी नए फ़ाइल प्रारूप के लिए नई क्रियाएं बना सकते हैं।