Verifica dello stato di frammentazione degli indici del database

Per verificare lo stato della frammentazione degli indici di tutte le tabelle è sufficiente utilizzare questo script:


SELECT dbschemas.[name] as 'Schema',
dbtables.[name] as 'Table',
dbindexes.[name] as 'Index',
indexstats.alloc_unit_type_desc,
indexstats.avg_fragmentation_in_percent,
indexstats.page_count
FROM sys.dm_db_index_physical_stats (DB_ID(), NULL, NULL, NULL, NULL) AS indexstats
INNER JOIN sys.tables dbtables on dbtables.[object_id] = indexstats.[object_id]
INNER JOIN sys.schemas dbschemas on dbtables.[schema_id] = dbschemas.[schema_id]
INNER JOIN sys.indexes AS dbindexes ON dbindexes.[object_id] = indexstats.[object_id]
AND indexstats.index_id = dbindexes.index_id
WHERE indexstats.database_id = DB_ID()
ORDER BY indexstats.avg_fragmentation_in_percent desc

Chiusura immediata di tutte le connessioni ad un database

USE [master];

DECLARE @kill varchar(8000) = '';
SELECT @kill = @kill + 'kill ' + CONVERT(varchar(5), session_id) + ';'
FROM sys.dm_exec_sessions
WHERE database_id  = db_id('KnoS_GestioneStudio')

EXEC(@kill);

Conteggio del numero di connessioni aperte su SQL server

Un uso "sbagliato" delle risorse porta qualche volta a dimenticarsi le connessioni aperte sul server.

Ci sono tecniche per garantire che le connessioni siano usate correttamente, ma se c'è il dubbio di aver lasciato connessioni aperte è importante controllare come il loro numero vari durante l'esecuzione del software.

Per controllare "lato SQL" quante connessioni sono aperte è sufficiente usare la query:

SELECT 
    DB_NAME(dbid) as DBName, 
    COUNT(dbid) as NumberOfConnections,
    loginame as LoginName
FROM
    sys.sysprocesses
WHERE 
    dbid > 0
GROUP BY dbid, loginame 

Analisi degli attributi di una proprietà a runtime

Per iindividuare e valutare se un attributo è stato definito su una proprietà è possibile utilizzare il seguente codice

// verifica se l'attributo è definito o meno
if (Attribute.IsDefined(propertyDef, typeof(DataMemberAttribute)))
{
        //estrazione dell'istanza di attributo di quella proprietà, tipizzato
   var a = Attribute.GetCustomAttribute(propertyDef, typeof(DataMemberAttribute)) as DataMemberAttribute;
   if (a != null)
   {
       bool emitDefaultValue = a.EmitDefaultValue;
   }
}

i 12 passi per scrivere ottimo codice...

qualche giorno fa è appara sulla mia scrivania un bellissimo link, che consiglio  tutti i developer leggere..
http://www.joelonsoftware.com/articles/fog0000000043.html

si parla di dodici passi che devi fare per poter garantire la scrittura di codice quantomeno accettabile. Dopo aver apprezzato l'articolo ho provato a raccoglier le risposte peggiori che si posson fornire ad ogni domanda posta, scoprendo amaramente che sono più comuni di quanto vorrei...

Q1 usi un software di controllo sorgente?
re- "no, i miei dev sviluppano da soli e si scambiano il codice  via mail, uniamo poi il tutto appena possibile"

Q2 puoi compilare con una procedura semplice e nota?
re- "ho scelto appositamente un linguaggio interpretato e senza compilazione cosí da evitare questi problemi"

Q3 fai compilazioni notturne?
re- "non compilo, non ne ho bisogno"

Q4 hai un database delle anomalie?
re- "il cliente manda mail e telefona se ha un problema, inseguo sempre il cliente più incazzato"

Q5 correggi i bug prima di scrivere altri pezzi nuovi?
re. "no, se non li sollecita nessuno signfica che non sono gravi e posson stare li."

Q9 usi il miglior software che il denaro possa comprare?
re. "ho deciso di usare solo prodotti open source cosí da non dover investire in licenze"

Q10 hai dei tester ?
re "i clienti possono tranquillamente sopportare un poca di instabilità e sono una base di test più che sufficiente"

Q11 fai scrivere codice durante i colloqui di assunzione?
re. "no, i criteri di valutazione sono solo legati a costo (poco) e tette grosse..."



Q12 fai test di usabilità del softwaew?
re . "ho scritto un manuale di 6890 pagine,i clienti possono leggersele"

Confrontare due resx...

Su un progetto pluriennale e multilingua, diventa importante manutenere i file contenenti le traduzioni statiche.

In c# dei comodi file di risorse, resx, rimangono alla base dell'apparato tecnico. Quello che diventa più impegnativo di solito è mantener allineate tutte le lingue possibili.

Quando poi le chiavi diventano migliaia, individuare le "nuove chiavi non tradotte" diventa una fatica inenarrabile. Per questo mi sono scritto un piccolo programmino di supporto

Ho creato una semplice console application, inserito dentro il progetto due resx (ItalianoMaster.resx ed EnglishTranslate.resx)

E il semplice codice

static void Main(string[] args)
{
// carico tutte le traduzioni  di default (per me italiano)
Dictionary italiano = new Dictionary();
ResourceSet resourceSetùMaster = ItalianoMaster.ResourceManager.GetResourceSet(CultureInfo.CurrentUICulture, true, true);
foreach (DictionaryEntry entry in resourceSetùMaster)
{
    string resourceKey = entry.Key as string;
    object resource = entry.Value;
    italiano.Add(resourceKey, resource.ToString());
}

// carico tutte le traduzioni in inglese
Dictionary inglese = new Dictionary();
ResourceSet resourceSet = EnglishTranslate.ResourceManager.GetResourceSet(CultureInfo.CurrentUICulture, true, true);
foreach (DictionaryEntry entry in resourceSet)
{
    string resourceKey = entry.Key as string;
    object resource = entry.Value;
    inglese.Add(resourceKey, resource.ToString());
}



foreach (string k in italiano.Keys)
{
    if (inglese.ContainsKey(k))
    {
        inglese.Remove(k);
    }else
    {
        System.IO.File.AppendAllText(@"c:\temp\daaggiungere.txt", String.Format("{0}ç{1}{2}", k, italiano[k], Environment.NewLine) );
    }
}

Informazioni sul metodo chiamante

http://msdn.microsoft.com/en-us/library/hh534540.aspx

Gli attributi descritti ritornano solitamente utili per effettuare operazioni di trace e log. Qualche tempo fa mi sonotrovato nella situazione di dover effettuare il redirect di un metodo verso un altro oggetto che rispondesse alla stessa interfaccia ma su una istanza diversa.

Nella prima implementazione mi son messo a scrivere tutte le chiamate, accorgendomi poi che il lavoro era smplice ma noiosissimo. Così ho cercato una tecnica più complessa ma che mi consentisse di scrivere zero codice per specifica e nuova implementazione. Ecco, usando questi attributi, un poca di reflection e molta fantasia ho ottenuto un router manager!!!!