Ho difficoltà a trovare una progettazione di codice efficiente (thread-safe) per il seguente problema. Ci sono già da un po 'di tempo e apprezzerei davvero alcuni consigli e suggerimenti sul modo migliore per avvicinarsi a questo.
Sto fondamentalmente cercando vari pattern all'interno di un set di dati. Mi piacerebbe avere una classe "master". Io chiamo i modelli di questa classe. Sto pensando di fare di questa classe un modello singleton o una classe statica. Vorrei avere una sola istanza di questa master class. Sto codificando questa classe come un modello singleton (schema di Jon Skeet) in questo momento.
public sealed class Patterns
{
private Patterns()
{}
public static Patterns Instance { get { return Nested.instance; } }
private class Nested
{
// Explicit static constructor to tell C# compiler
// not to mark type as beforefieldinit
static Nested()
{
// ... create a list to hold data for internal use
List<Point> Data = new List<Point>();
}
internal static readonly Patterns instance = new Patterns();
}
}
Ho scelto uno schema singleton perché:
- Voglio che il singleton abbia classi annidate; una classe per ogni modello.
- Voglio che queste classi nidificate siano classi di istanze (cioè non statiche)
- Vorrei che il singleton istanziasse le classi nidificate, magari usando un pattern factory, se necessario.
Non sono sicuro che il mio ragionamento sia corretto, quindi qualsiasi consiglio sarebbe molto apprezzato.
Ora ho intenzione di aggiungere le varie classi di pattern come classi nidificate perché i pattern non hanno senso al di fuori della classe Master pattern. Inoltre, IPattern è un'interfaccia per i pattern.
public sealed class Patterns
{
private Patterns()
{}
public static Patterns Instance { get { return Nested.instance; } }
private class Nested
{
// Explicit static constructor to tell C# compiler
// not to mark type as beforefieldinit
static Nested()
{
// ... create a list to hold data for internal use
static List<Point> Data = new List<Point>();
// ... indices to track occurences of each pattern
static int AIndex = 0;
static int BIndex = 0;
static int CIndex = 0;
}
internal static readonly Patterns instance = new Patterns();
}
// ... Methods
public bool SearchForPattern(Point dataPoint)
{
// ... add data to list
Data.Add(dataPoint);
}
// ... nested pattern classes
class PatternA : IPattern
{
static int = some integer
static double[] arr = new double[];
// ... do some work
}
class PatternB : IPattern
{
// ... do some work
}
class PatternC : IPattern
{
// ... do some work
}
}
I dati dell'elenco sono statici perché voglio che i dati vengano conservati per tutta la durata dell'applicazione. Lo stesso vale per i campi statici nelle classi annidate.
Questo è il punto in cui ora comincio a perdersi davvero. Nel metodo SearchForPattern (Point dataPoint) vorrei fare quanto segue:
public bool SearchForPattern(Point dataPoint)
{
// ... add data to list
Data.Add(dataPoint);
bool haveA = PatternA.SearchForA();
if (haveA)
{
PatternA a1 = new PatternA(); // the number after a will change as other A patterns are found; as per AIndex value
AIndex++;
}
... and so on for other patterns
}
Quindi ecco le mie domande. Nota che sono abbastanza nuovo in C # e sto cercando di imparare.
-
È questo l'approccio migliore (ossia la più efficiente dal punto di vista del calcolo) da adottare con questo problema? In caso contrario, puoi suggerire un approccio alternativo?
-
Non so come incorporare il modello factory per l'istanziazione delle classi pattern nidificate. Questo dovrebbe essere fatto? Se sì, puoi suggerire come?
-
Mi manca qualcosa qui che devo prendere in considerazione ma che non ho considerato finora?