C# Repetitive Code vermeiden und verwenden Generisches

Question

Das Thema könnte so aussehen, dass diese Frage bereits gebucht, aber mein Code-Schnipsel und Problem ist anders. Bitte sehen Sie es sich an. Ich habe 20 bis 22 SQL-Tabellen, von denen ich meine POCO-Klasse in meiner Anwendung erstellt habe. Jede dieser Tabellen hat 4-5 gemeinsame Spalten, zu denen ich einige Datensätze in der Anwendung füllen muss, Restspalten der Tabelle sind bereits mit XML-Daten gefüllt, die von einer anderen Anwendung gesendet wurden. Die nur 4-5 gemeinsamen Spalten jeder Tabelle, die ich versuche, die Anwendung wie unten zu füllen.

In ähnlicher Weise habe ich Code für 22 Tabellen geschrieben und diese Funktionen werden aufgerufen, wenn ich mit dieser spezifischen Objektgruppe zu tun habe.

Wie kann ich eine generische Methode zu erstellen, so dass ich von 22 Funktionen loswerden kann, die sie wiederholenden Code?

ich meine Informationen Klasse bin Entsendung hier unten auch.

public class Information 
{ 
public List<Software> Software{get;set;} 
public List<Users> Users{get;set;} 
} 

So jetzt meine Software und Benutzerklasse sieht aus wie unten mit einer Schnittstelle Implementierung ICommonColumns genannt.

public interface ICommonColumns 
{ 
DateTime DCDTime{get;set;} 
DateTime LastModDTime{get;set} 
..... 
and others common fields 
} 

public class Software : ICommonColumns 
{ 
.... 
} 

public class Users : ICommonColumns 
{ 
.... 
} 

Answer 1

Beide Software und Users müssen einen Zwang haben, um sicherzustellen, dass sie etwas gemeinsam, wie eine interface oder Basisklasse haben.

public class BaseEntity 
{ 
    public DateTime DCDTime { get; set; } 
    public DateTime LastModDTime { get; set; } 
    public DateTime ScanDateTime { get; set; } 
    public int ID { get; set; } 
    public int SrNo { get; set; } 
} 

Zum Beispiel Ihre Software Klasse würde wie folgt aussehen:

public class Software : BaseEntity 
{ 
    //Some more properties 
} 

Dann Sie eine generische Methode wie folgt erstellen:

private IEnumerable<TEntity> GetEntityData<TEntity>(int requestId, IEnumerable<TEntity> requestEntities, DateTime scanDateTime) 
    where TEntity : BaseEntity, new() 
{ 
    int SrNo = 0; 

    foreach (var item in requestEntities) 
    { 
     TEntity d = new TEntity(); 
     d = item; 
     d.DCDTime = DateTime.Now; 
     d.LastModDTime = scanDateTime; 
     d.ID = requestId; 
     d.ScanDateTime = scanDateTime; 
     d.SrNo = ++SrNo; 

     yield return item; 
    } 
} 

Und es so nennen:

IEnumerable<Software> softwares = GetEntityData<Software>(request.Id, request.Software, DateTime.Now); 
IEnumerable<Users> users = GetEntityData<Users>(request.Id, request.Users, DateTime.Now); 

Answer 2

Warum haben nicht die POCO eine Schnittstelle implementieren und ein Verfahren zu schaffen, die Implementierungen dieser Schnittstelle akzeptiert?

Edit:

public interface ISomething 
{ 
    public DateTime DCDTime { get; set; } 
    public DateTime LastModDTime { get; set; } 
    public int ID { get; set; } 
    public DateTime ScanDateTime { get; set; } 
    public int SrNo { get; set; } 
} 
    private IEnumerable<T> GetSoftwareEntityData<T>(Information request, DateTime scanDateTime, Func<Information, T> someCollection) 
    where T : ISomething 
    { 
    int SrNo = 0; 

    foreach (var item in someCollection(request)) 
    { 
     item.DCDTime = DateTime.Now; 
     item.LastModDTime = scanDateTime; 
     item.ID = request.Id; 
     item.ScanDateTime = scanDateTime; 
     item.SrNo = ++SrNo; 

     yield return item; 
    } 
}