Vb vs C# (implemetare un interfaccia.... )

A denti stretti .. molto molto stretti ...


Questa la non troppo diversa Interfaccia.....
Public Interface IPlugin

Property PluginName() As String
Property PluginLabel() As String
Property PluginCategory() As String

Sub Execute(ByVal params As Object())

End Interface

Questa la troppo diversa Implementazione dell' Interfaccia.....

Public Class SimpleCalculator
Implements IPlugin

Private _PluginName As String = "SimpleCalculator"
Private _PluginLabel As String = "Simple Calculator"
Private _PluginCategory As String = "Commons"

Public Property PluginName() As String Implements IPlugin.PluginName
Get
Return _PluginName
End Get
Set(ByVal value As String)
_PluginName = value
End Set
End Property

Public Property PluginLabel() As String Implements IPlugin.PluginLabel
Get
Return _PluginLabel
End Get
Set(ByVal value As String)
_PluginLabel = value
End Set
End Property

Public Property PluginCategory() As String Implements IPlugin.PluginCategory
Get
Return _PluginCategory
End Get
Set(ByVal value As String)
_PluginCategory = value
End Set
End Property


Public Sub Execute(ByVal params As Object()) _
Implements IPlugin.Execute

End Sub
End Class


Io io io io ... si ci vorrebbe una bella scarica di "io io io" non è semplice intuire come si fa cosa e perchè ....

Vi siete domandati come si ottiene una classe ASTRATTA.. o UNA STATICA... no ???
bhe la seconda vi posso dire che non esiste.. o quanto meno vi serve un modulo e dichiarare in esso la classe,

STATIC pictureManager AS New PictureManager()

La prima... vi posto l'esempio che forse fa meno male....

Public MustInherit Class FactoryCore

Public iPluginList As List(Of IPlugin)

Private Sub LoadItems()

End Sub

Public MustOverride Sub CreatePlugin()


End Class

La difficoltà sta nel comprendere che si Sottointende, e non che cosa realmente si intende...

MustInherit sottointende che si "deve necessariamente "ESTENDERE QUESTA CLASSE

E' questa è una buona grammatica....

Vb vs C#

mamma mia... che cosa mi è venuto in mente...
Credo che a molti di noi sia capitato di dover passare a vb.net dopo aver lavorato in c# e credo e (anzi) ne sono sicuro che l'esclamazione iniziale sia più che dovuta....

questo esempio si basa sulla serializzazione / deserializzazione.. di un oggetto tramite xml serializer

c#

///

/// Serializza i campi
///

private void Serialize()
{
TextWriter tw = new StreamWriter(fileName);

XmlSerializer xmls = new XmlSerializer(typeof(FieldPrototypeCollection));
xmls.Serialize(tw, fieldDefinitions);

tw.Close();
xmls = null;
}

///

/// Serializza i campi
///

private FieldPrototypeCollection Deserialize()
{
TextReader tr = new StreamReader(fileName);

FieldPrototypeCollection fc = new FieldPrototypeCollection();
XmlSerializer xmls = new XmlSerializer(typeof(FieldPrototypeCollection));
fc = (FieldPrototypeCollection)xmls.Deserialize(tr);

tr.Close();
xmls = null;

return fc;
}


vb
'''

''' Legge il file e lo deserializza
'''

'''
Private sub Serialize()
''
'' serializza le proprietà in un file.
''
Dim xmls As New XmlSerializer(GetType(FieldPrototypeCollectione))
Dim tw As New StreamWriter(fileName)

xmls.Serialize(tw, px)

End Sub

'''

''' Legge il file e lo deserializza
'''

'''
'''
Private Function Deserialize() as FieldPrototypeCollection
''
'' deserializza l'oggetto nelle proprietà
''
Dim xmls As New XmlSerializer(GetType(FieldPrototypeCollection))
Dim tr As New StreamReader(fileName)

dim fc = CType(xmls.Deserialize(tr), FieldPrototypeCollection)

Deserialize = fc
End Function



un po maiuscolo .. un po minuscolo... sarà anche il fatto che poi è tutto disseminato di DIM AS
Non è cosa.. non è proprio cosa...

Rispetto al buon vecchio Vb questo è proprio un cesso di linguaggio .. credo che tutte le nonne di questo mondo
direbbero ...

SE USI QUESTO LINGUAGGIO TI LAVO LA BOCCA CON L'ACQUA BORICA...

Ma se proprio era necessario trasformarlo ad oggetti non si poteva fare qualcosa di utile anche per la sintassi ???

Va bhe sono di parte e questo è chiaro fin dal nome del blog.. però, però quando è troppo è troppo...

Query che passione...

Capita che qualcuno vi chieda di risolvere difficili situazioni... a volte queste portano a scrivere query davvero scriteriate.
C'e' da dire che una stored procedure possa a volte salvarci ma a volte questo non è possibile... soprattutto se il db è Mysql.

Vi porto questo esempio

SELECT
Event_Date,
id_a as l_ida,
(SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_A') as ValueA
(SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_B') as ValueB,
Entity_value,
if(
(SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_C'
AND entity_value_b = Entity_value) IS NULL, 'Id_b',
(SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_C'
AND entity_value_b = Entity_value)) as ValueC
FROM
dwh_entities_logs
WHERE
direction = 'O'
AND
status = 0
AND
event_date IN (
SELECT Max(event_date) FROM dwh_entities_logs WHERE direction = 'O' AND status = 0 GROUP BY id_a)

Bhe sembra un vera e propria pazzia.. per altro difficilemente leggibile e per una qualche ragione ho pure modificato i nomi
dei campi... ma non di molto

L'attenzione è su questa porzione.. che sembra difficile da comprendere perchè annidare un if con 2 select potrebbe sembrare
sia lenta che caotica ( che critica.. ) ma che ci crediate o no .. è un missile..

if(
(SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_C'
AND entity_value_b = Entity_value) IS NULL, 'Id_b',
(SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_C'
AND entity_value_b = Entity_value)) as ValueC

Mysql consente una notazione molto semplice ed efficace, l'associazione diretta di una query annidata ad una variabile.

questo ci consente di modificare un filo una scrittura complessa come la precedente... in

@xData := (SELECT entity_value_a FROM dwh_entities WHERE id_a = l_ida AND entity_type = 'value_C'
AND entity_value_b = Entity_value),
if(
(@xData) IS NULL, 'Id_b',
(@xData)
) as ValueC

Il vantaggio e che si esegue la query una volta sola.. velocizzando l'estrazione..

Chiaramente .. salvare il mondo da Godzilla con una calamita... rimane sempre complesso ma non impossibile.

Messagio d'errore del tutto particolare...

sto cercando di convertire questo numero... 000044110004554330000006 da chiamiamolo string a int64...

bhe credo qualche cosa possa aver creato qualche intoppo, mi aspettavo un errore, quanto meno intelligente,
eppure ottengo un qualcosa di davvero forviante.

Giusto per la chiamata è questa..
Int64 idNewSeed = Convert.ToInt64(lblSeed.Text.Replace("H",""));

lblSeed.Text contiene "H000044110004554330000006"

Ancora una volta qualche ho dubbio su come ragiona sto chiodo !!

Eventi, delegati e intefaccie...

E' stato realizzato un nuovo post più accurato con approfondimenti sull'argomento:
How To: Use Event and Delegate C#

Può succedere, per carità lo comprendo bene che prima o poi vi venga in mente di dichiarare un evento in un interfaccia...
certo la qual cosa può far anche arricciare il naso, ma non è una situazione imbroba.

E quasi palese che per prima cosa scirverte..

public interface IMyInterface
{
event MyEvent;
}
e vi suonerà il solito campanello da allarme... vi evito vari altri tentativi .. inutili e dispendiosi.

public interface IMyInterface
{
event EventHandler MyEvent;
}

ma questo tecnicamente vi costringe ad usare un Event Handler "SUO" e non vostro ...
e quando tornerete alla vostra bella classe scoprirete che quanto avrete scritto a poco vi serve.

Supponiamo che quanto vi è necessario sia un Messaggio d'errore ..

public delegate void IOnError(string Error);

public interface IMyInterface
{
event IOnError OnError();
}

public class MyClass:IMyInterface
{
public event IOnError OnError;
}

ed in questo modo ottieniamo un evento comodo comodo da ridelegare ad altri ... non male ??

Mysql Data provider...

Non proprio.

Tuttavia potrebbe sempre servire trovarsi un po di pappa pronta...

public class MySqlDataProvider
{
private string _connection;
private MySqlConnection msc = null;

public MySqlDataProvider(MySqlConnectorsDataItem mscDi)
{
msc = new MySqlConnection();
_connection = mscDi.ToString();
msc.ConnectionString = _connection;
}

public MySqlDataProvider(string connectionString)
{
msc = new MySqlConnection();
_connection = connectionString;
msc.ConnectionString = _connection;
}

public void ExecuteNonQuery(MySqlCommand myQuery)
{
myQuery.Connection = msc;
myQuery.ExecuteNonQuery();
}

public DataTable ExecuteReader(MySqlCommand myQuery)
{
DataTable dtx = new DataTable();
myQuery.Connection = msc;
MySqlDataAdapter myda = new MySqlDataAdapter(myQuery);

myda.Fill(dtx);
myda = null;

return dtx;
}
}

How To: implement an Interface (part 2)

Mi è stato chiesto in un commento la differenza fra la dichiarazione esplicita e la dichiarazione implicita di un interfaccia.

A tal proposito mi sembra corretto proporre questo semplice esempio.

Due interfaccie che espongono gli stessi metodi, se le avessi implementate in modo
implicito avrei avuto il problema di comprendere l'appartenenza del metodo.

In questo modo "non solo il codice è più leggibile" ma mi consente "come" o "per chi"
sto lavorando !

public interface IRemoteClient
{
  void DoSend(byte[] bs);
  byte[] DoRecieve();
}

public interface ILocalClient
{
  void DoSend(byte[] bs);
  byte[] DoRecieve();
}


public class Fork : IRemoteClient, ILocalClient
{

  void IRemoteClient.DoSend(byte[] bs)
  {
      // send as Remote host
  }

  byte[] IRemoteClient.DoRecieve()
  {
      // recieve as Remote host
      return new byte[100];
  }

  void ILocalClient.DoSend(byte[] bs)
  {
            
  }

  byte[] ILocalClient.DoRecieve()
  {
      // recieve as Client 
      return new byte[100];
  }
}

How To: Abstrac class c#

In questo esempio, una classe astratta che viene estesa da due classi concrete.

L'esempio è sugli animali, e forse può sembrare sciocco, ma ogni tanto può far bene fare un sorriso anche mentre si lavora, che male non fa.

public abstract class animal
{
    public abstract void DoPlay();
    public abstract void DoSleep();
    public abstract void DoRun();
    public abstract void DoPee();
    public abstract void DoPoo();
}

public class dog : animal
{
    public override void DoPlay() { Console.WriteLine("arf arf"); }
    public override void DoSleep() { Console.WriteLine("ronf ronf"); }
    public override void DoRun() { Console.WriteLine("...."); }
    public override void DoPee() { Console.WriteLine("peeee.."); }
    public override void DoPoo() { Console.WriteLine("pof pof"); }        
}

public class cat : animal
{
    public override void DoPlay() { Console.WriteLine("meeehoww "); }
    public override void DoSleep() { Console.WriteLine("ronf ronf"); }
    public override void DoRun() { Console.WriteLine("...."); }
    public override void DoPee() { Console.WriteLine("peeee..sgrut sgrut"); }
    public override void DoPoo() { Console.WriteLine("pof pof"); }
}

public class myPet
{
    public myPet()
    { 
        animal mDog = new dog();
        animal mCat = new cat();
    }

How To: inherit tow classes

In questo esempio sono presentate due classi che fanno da base, ed una terza che le eredita.

Dato che in c# non è possibile ereditare due classi contemporaneamente, è necessario che la seconda erditi la prima in cascata.

La terza quindi altro non fa che implementare i metodi.

public class testBaseA
{
    public virtual void MethodBaseA() { }
}

public class testBaseB : testBaseA
{
    public virtual void MethodBaseB() { }
}


public class testAll : testBaseB
{
    public void TestAll()
    { 
        MethodBaseA();
        MethodBaseB();
    }

    public override void MethodBaseA()
    {
        int a = 0;
        a++;
        Console.WriteLine(a);
    }

    public override void MethodBaseB()
    {
        int b = 2;
        b++;
        Console.WriteLine(b);
    }
}

How To: implement multi Interface

In questo esempio decisamente interesante sono riportate 2 interfaccie e una classe che le implementa entrambe.

Nel caso d'uso prima di eseguire un metodo, ci si accerta che la classe implementi realmente l'interfaccia, tramite il tipo.

public interface interface1
{
    void methodInterface1(string p1);
}

public interface interface2
{
    void methodInterface2(string p1);
}


public class InterfacesTest : interface1, interface2
{

    public void methodInterface1(string p1)
    {
        Console.WriteLine(p1);
    }

    public void methodInterface2(string p1)
    {
        Console.WriteLine(p1);
    }
}

public class testUse
{
    private InterfacesTest test = new InterfacesTest();


    public void DoTest()
    {
        if (test.GetType().GetInterface("interface1") != null)
        {
            test.methodInterface1("A");
        }

        if (test.GetType().GetInterface("interface2") != null)
        {
            test.methodInterface2("B");
        }

    }        
}

How To: create an Enum

Ecco due esempi di come creare degli enumerativi.

Lo scopo di questo "prototipo" è di realizzare un elenco di elementi predefinito
per cui optare per una scelta.

public enum enumListType
{
    Combo =0,
    Bullet =1,
    List = 2
}

public enum enumListType
{
    Combo,
    Bullet,
    List
}

How To: Abstract Method C#

In questo esempio, sono rappresentate due classi una nominata Test e l'altra TestAbstract.

La prima è una semplice classe astratta con un metodo astratto (e quindi senza corpo) e un metodo virtuale con corpo ed ereditabile.

la seconda estende la prima.

public abstract class Test
{
   public abstract void testAbstract();

   public virtual void testVirtual()
   {
       Console.WriteLine("Test:step 1");
              
   }
}

public class TestAbstract : Test
{
   public override void testAbstract()
   {
       Console.WriteLine("TestAbstract:step 1");
   }

   public override void testVirtual()
   {
       base.testVirtual();
       Console.WriteLine("TestVirtual:step 2");
   }
}

public class useAbstract
{
   public void DoTest()
   {
       Test tA = new TestAbstract();

       tA.testAbstract(); //TestAbstract:step 1

       tA.testVirtual(); //Test:step 1 | TestAbstract:step 1
   }       
}

Mentre la terza classe è il caso d'uso, nel commento è riportato il flusso dell'output.

How To: implement an Interface

In questi esempi, due differenti modalità di implementare un interfaccia.

Test_A implementa ITest in modo classico.
Test_B implementa ITest Esplicitandola.

public interface ITest
{
   string TestProperty {get; set;}
   void TestMethod(string s);
}


public class Test_A : ITest
{

   string _s;

   //
   // Implementazione "classica"
   // 
   public string TestProperty
   {
       get{ return _s;}
       set { _s = value;}
   }

   public void TestMethod(string s)
   {
       Console.Write(s);
   }
}

public class Test_B : ITest
{

   string _s;

   //
   // Implementazione "esplicita"
   // 
   string ITest.TestProperty
   {
       get { return _s; }
       set { _s = value; }
   }

   void ITest.TestMethod(string s)
   {
       Console.Write(s);
   }
}

How To: Crate a Static Method

Questo esempio mostra come creare un metodo Statico in una classe non statica.

public class Test
{
   public static string staticMehotod(string value)
   {
       return "Parameter is :" + value;
   }
}

public class useTest
{
   public void UseStaticMethod()
   {
       string value = "Test";

       Console.WriteLine(Test.staticMehotod(value));
   }
}

How To: Write Binary File C#

Questo esempio, mostra come scrivere un file Binario utilizzando C#

FileStream fs = new FileStream("c:/testBin.txt",FileMode.OpenOrCreate);
BinaryWriter bw = new BinaryWriter(fs);

bw.Write(12345);
bw.Write(12.345);
bw.Write("simple text");

bw.Close();
fs.Close()

Decisamente semplice, ed è curioso il risultato...

How To: Write File C#

Come si fa a scrivere in un file in C# ?

string text = "testo da scrivere nel file.";
TextWriter tw = new StreamWriter ("c:/test.txt");
tw.WriteLine(text);
tw.Close();
tw = null;

E come si fa a scrivere un file in Append ?

string newText = "Testo in append";
TextWriter twAppend = new StreamWriter("c:/test.txt",true);
twAppend.WriteLine(newText);
twAppend.Close();
twAppend = null;

How To: Open File C#

Come si apre un file in lettura in C# ?

TextReader tr = new StreamReader("c:/test.txt");
string allFile = tr.ReadToEnd();
tr = null; 

Come si apre un file in lettura in C# ottenendo un arry di righe ?

TextReader tr = new StreamReader("c:/test.txt");
string[] allLine = tr.ReadToEnd().Replace("\r","").Split(new char[] { '\n' });
tr = null; 

Nel secondo caso rimpiazziamo "\r" in modo da dover Splittare solo per un carattere.

Contare le righe di un file aperto in lettura ?

TextReader tr = new StreamReader("c:/test.txt");
int lineCount = tr.ReadToEnd().Replace("\r","").Split(new char[] { '\n' }).Length;
tr = null;

Se davvero volete un numero Random....

E' possibile che vi torni utile questo....




Già perchè dopo un lungo Test mi sono accorto che le cose non sono sempre belle come vengono dipinte.. anzi

5000 è il numero più accettabile di iterazioni .. vi dico solo che sono partito da 100... e fino a 200 niente risulati...

Ma si tratta davvero di random ?

Nel framework esiste la comoda classe Random... che a volte va a volte no.
Se fate qualche prova vi renderete conto che non sempre funziona a dovere, questo perchè "ptrebbe essere troppo veloce" o "troppo breve la latenza" fra una generazione e l'altra.

Osservate questo codice che cosa genera.



Qualcosa non convince...


Gli elementi evidenziati sono uguali e questo appare discretamente rischioso.

Mi sono accorto di questo problema utilizzando xna, nella creazione di uno screen saver mi sono accorto che tutti gli elementi generati a caso avevano le stesse coordinate.

I più saccenti potrebbero suggerire lo spostamento di Random r = new Random() all'interno del for e utilizare come seed, o l'indice del for o qualche altro strano valore...

Ma se osservate bene il codice... quelli generati per la terza colonna provengono da un nuova variabile "b"...
E' questo quello che secondo me è grave..


Perchè è questo che si verifica se le metto nel for...

Quindi Random .. random .. proprio no direi !!

Server.MapPath()... Dove come quando...

Si potrebbe suppore che in un applicazione Web torni decisamente utile sapere sia dove ci si trova, fisicamente sia logicamente.
E' pur vero che si possa utilizzare una variabile di sessione o un parametro di configurazione a cui accedere liberamente, ma non sempre è così.

In asp.Net possiamo trovare due comodi operatori Server.MapPath() e "~", che sono indispensabili o quasi in tutte le applicazioni web.

Supponiamo di avere un applicazione con larga scala di distribuzione, questa deve essere :
Semplice
Facilmente Configurabile
Decisamente MOLTO fruibile.

Questi pochi termini implicano che il "mazzo" che si deve fare lo sviluppatore è davvero enorme.
Con semplice Si intende che qualsiasi tipo di utente deve potere essere nella condizione di installare e agire sul prodotto.
Non con i classici Wizard di Start up che una volta usati scompaiono... e chi si è visto si è visto...
Questo implica che Facilmente Configurabile è la possibilità di intervenire sul prodotto Tempestivamente per modficarne la configurazione e non "disinstalla tutto fai 300 backup... e spera".
Con decisamente molto fruibile intendo che l'applicazione ovunque essa sia possa essere modificata in toto o quasi.

A tal proposito è di fondamentale importanza partire con una struttura di configurazione ben strutturata.
E' possibile usare una classe che mantenga viva la configurazione del sito sempre... o fino a quando non scade la sessione.

Dal mio canto mi trovo comodo a rimmapare qualcosa come
string SiteVirtualRootPath = "~";
string SiteRealRootPath = Server.MapPath("~");

in questo modo posso richiedere al mio Configuration Provider come e quando voglio il dove e come sono.

Non andiamo molto bene....

Come sempre mi trovo ad affrontare cose mai viste.... ma questa le batte davvero tutte.

Sembrerebbe che si verifichi un eccezione in SYSTEM.XML.DLL, e va bene ma dato che sfrutto la libreria, invocando la chiamata all'interno di un try catch mi aspetto che sia il mio codice a gestirlo... ma qualcosa non va.

Quando si verifica questa schifezza...
Semplice quanto state cercando di serializzare un file xml che non contiene elementi.. più o meno qualcosa di simile a
questo:

Che cosa si può fare per evitare un problema simile ???
utilizzando un piccolo "trucco" verificando che la lunghezza del file sia consona con almeno un elemento...

cmq... non andiamo bene. Se un applicativo non riesce a rilasciare la gestione di un eccezione .. e perchè già al suo interno
non è gestita..

ahi ahi ahi !!

Web Control .. no Span

Perchè arrabbiarsi quando non è il caso di farlo ?

Il web control, se usato bene, è uno strumento potente e affidabile, ma ha i suo oscuri limiti. Il primo fra tutti e che annida tutto quello che avete implementato in uno span.

Chiaramente c'e' qualcosa che non va. Ma per tutto c'e' una spiegazione, efficente o meno.

Lo span <>testo non è altro che il tag individuato come base. Appare evidente che un tag di questo tipo non ha grande scopo ne tanto meno possa esprimere vere potenzialità.

Per implementare un web control che ne meriti di diritto il valore bisogna tuttavia partire da un controllo più concreto che un semplice span.

se da così ...
public class LoginPanel : WebControl

si passa a così ...
public class LoginPanel : Panel

Si ottiene un output sicuramente differente, il tag span scompare...

Per ogni soluzione è necessario individuare le grandezze che ne sono coinvolte, implementare un Web Control, ha i suoi benefici è può sicuramente essere riutilizzato, ma potrebbe anche essere eccessivo.

Optional Attribute C#

Come posso implementare un Attributo Opzionale in una firma di un metodo ?

In C# è concettualmente difficile pensare ad una forma opzionale, ma chi arriva da VB, qualche domanda se la pone, probabilmente perchè può ancora ritenere che un parametro sia e rimanga un entità FLUTTUANTE.

Supponiamo di trovarci nella situazione di dover implementare noi un parametro opzionale.

Firma
private void Foo(string param1, string param2)
{
if ( param1 == null) {param1 ="";}
if ( param2 == null) {param2 ="";}

// resto del codice...
}

Chiamata
Foo("A","b")

Oppure
Foo("A",null)

Tecnicamente funziona, e non ci fa perdere troppo tempo.

Possiamo però trovarci nella spiacevole situazione di dover effettuare una chiamata ad un metodo già esistente non implementato da noi ...

SampleFoo sf = new SampleFoo();

sf.DoFooFoo(param1, param2);

Possiamo .. e per fortuna estendere SampleFoo e trasformare il nostro metodo sperando che tutto vada... perchè
del codice altri non v'e' certezza...

public class MyFooFoo :SampleFoo();

public void new DoFooFoo(string param1, string param2)
{
if ( param1 == null) {param1 ="";}
if ( param2 == null) {param2 ="";}
base.DoFooFoo ( param1, param2 );
}

Ed ecco fatto ..

Come sempre va data la giusta considerazione se stiamo creando una funzione per cui un parametro ci sembra o ci può sembrare opzionale.. probabilmente non stiamo considerando il fatto che si possano creare degli override... il che
sarebbe anche meglio.

Foo(string param1)

Foo(string param1, string param2)

Foo(string[] params)

Cmq.. anche questa è andata.

Add per la IDE 2005....

Siamo sicuri che funziona tutto ma proprio tutto ??

Provate a fare questo Esperimento.

Create un AddIn (fra i progetti dell'IDE o Extensibility)
Datagli come nome My.Addin
Selezionate le opzioni per:

• Aggiungere l'addin al menu Tools
• Aggiungere l'addin all'avvio

Ora lanciate il vostro spelndido programma e sorpresa non carica nulla.

Due appunti di viaggio ...
Il primo vi viene recapitata un' eccezione, ma molto forviante
ARGUMENT EXCEPTION e la prima cosa a cui si può pensare e che per un motivo o per l'altro non sia avvenuto il
caricamento del nuovo "comando"

La seconda e che spulciando fra glie elementi nella firma si scopre che
_addInInstance ... ha generato un eccezione ( differente dalla precedente... )

Nel dubbio dopo "parecchie parole offensive nei confronti dell'ide" scopro che ... l'addin c'e' è caricandolo non va lo stesso !!

Il problema è il "." ossia aggiungendo il punto il compilatore va a cercare una libreria che per lui non esiste..

Ci sarà un sistema per risolvere questo "possibile" baco ??

si semplice siate disordinati .. mettete pure dei nomi a caso .. e probabilmente il vostro add in andrà !

Campi di una tabella .. tipo ... e chiave primaria.

Come posso ottenere tutti i campi di una tabella con l'evidenza del campo chiave?

A molti di noi sarà capitato in più di un occasione la necessità di individuare tutti i campi di una tabella, un po per creare uno statement in automatico, un po' per analisi di Db che non abbiamo disegnato noi.

Nel mio caso sto realizzando un piccolo prodotto che crea soluzioni a pacchetto partendo da un db è va tutto bene fino a che non si impatta con le Query.. e non tanto con le SELECT .. ma con le UPDATE o con le DELETE.

Mi sono quindi domandato fino a che punto spingermi nell'implementazione... arrivando alla soluzione, che
"IO PREMO UN TASTO... LUI FA' IL 90% DEL COMPITO".

Quindi torniamo a bomba sulla query , ci servono:

1. INFORMATION_SCHEMA.COLUMNS
2. INFORMATION_SCHEMA.TABLE_CONSTRAINTS
3. INFORMATION_SCHEMA.KEY_COLUMN_USAGE

La prima contiene i nomi delle colonne..
la seconda contiene i nomi delle constraint..
la terza (a me sembra una estensione della seconda)

Dalla prima recuperiamo le colonne contenenti Nome e Tipo
Dalla seconda e dalla terza recuperiamo se è un identity
Ma chiaramente mettendole in Join .. ci perdiamo tutti i campi che non lo sono ..
Quindi ci basta fare una piccola Union con gli SCARTATI...

ed ecco che cosa ne viene fuori ..

select
m.column_name,
m.data_type,
x.CONSTRAINT_TYPE
from
INFORMATION_SCHEMA.COLUMNS m,
(select
CONSTRAINT_TYPE,column_name
from
INFORMATION_SCHEMA.TABLE_CONSTRAINTS a,
INFORMATION_SCHEMA.KEY_COLUMN_USAGE b
where
a.table_name = '[tbName]'
and
b.CONSTRAINT_NAME = a.CONSTRAINT_NAME) AS x
where
m.table_name = '[tbName]'
and
x.column_name = m.column_name
UNION
select
m.column_name,
m.data_type,
' '
from
INFORMATION_SCHEMA.COLUMNS m,
(select
CONSTRAINT_TYPE,column_name
from
INFORMATION_SCHEMA.TABLE_CONSTRAINTS a,
INFORMATION_SCHEMA.KEY_COLUMN_USAGE b
where
a.table_name = '[tbName]'
and
b.CONSTRAINT_NAME = a.CONSTRAINT_NAME) AS x
where
m.table_name = '[tbName]'
and
x.column_name <> m.column_name


Provare per credere...


Questà può essere eseguita come sqlCommand da un qualsiasi dataAdapter ed il contenuto può agevolmente essere messo
in una dataTable..

Bhe buon divertimento

Thema e Custom Web Control.

Vi sarà captitato di affrontare il traumatico discroso di associare un tema ad un castom web control... si tratta di un qualcosa di assurdo e decisamente complesso soprattutto dal punto di vista della comprensione.

Poniamo l'esempio:

public class bPanel : Panel
{
public ovveride SkinID
{get{return base.SkinId;} set {base.SkinId = value;}}

public ovveride CssClass
{get{return base.CssClass;} set {base.CssClass = value;}}

protected override void Render(HtmlTextWriter writer)
{
base.Render(writer);
}
}


Non c'e' che dire non si tratta di una gran classe, ma questo è quanto basta
implementare per il nostro esempio.

Nella vostra pagina.. serve

<%@ Register Assembly="Miei.UI.WebControls" Namespace="Miei.UI.WebControls" TagPrefix="cc1" %>

e naturalmente

< id="bPanel1" runat="server" skinid="bPanel1">


Ora spostiamoci nel file del tema ...

MioTema.skin
e ri registriamo il controllo

<%@ Register Assembly="Miei.UI.WebControls" Namespace="Miei.UI.WebControls" TagPrefix="cc1" %>



< id="bPanel1" runat="server" skinid="bPanel1">



ed ora skinniamo come più ci piace..


< skinid="bPanel1" cssclass="laClasse" runat="server" backimageurl="img/MioSfondo.jpg" height="21px" width="100%">



sul web non c'e' scritto molto a riguardo, spero quindi che possa essere utile