FlowLayoutPanel C#

Avete mai provato a usare questo splendido controllo ?? Io mi sto divertendo proprio ora ad usare uno strumento javesco in c#...
Non so effettivamente chi abbia fatto il primo passo con questo tortuoso strumento .. tuttavia lo trovo discretamente pratico, nel caso si debba ricorrere ad array di controlli... e gestirne il riposizionamento dopo la rimozione di uno o più elementi.

Nel mio caso sto cercando di realizzare un Tab control un po più ricercato e customizzabile di quello proposto nel VS 2008 che devo dire fa pure il suo porco mestiere... ma lascia poco spazio alla fantasia.

Ora imbattendomi in questo controllo speravo di trovare fra le properties qualcosa di utile.. stile grip / grid size.. ma nulla.

Scopro e mi pare carino condividere che "non esiste nulla di cio'" tuttavia lo spazio fra un controllo e l'altro all'interno del FlowLayoutPanel è demandato alla proprietà margin dei controlli che sta usando... o impilando.

Bene quindi ricordate che se usate :
Button myButton = new Button();
myButton.Text = "My Button";
flpMain.control.Add(myButton);
di aggiungere
myButton.Margin= new Padding(0, 0, 0, 0);

Attenzione MARGIN è una struct e non è del tutto accessibile..

ConfigurationManager Add Key & Value...

Sempre a me...?? ma perchè quando voglio fare qualcosa io .. becco sempre qualche sfiga strana..

System.Configuration.Configuration config =
ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

config.AppSettings.Settings.Remove(settingName);

config.AppSettings.Settings.Add(settingName, settingValue);

config.Save(ConfigurationSaveMode.Modified);

ConfigurationManager.RefreshSection("appSettings");

Questo effettivamente più che un add.. è un Edit, ma non è questo il vero problema... anzi...
In questo breve brano di codice sono emerse ben 2 cose...

A) in debug mode... non funzionerà e potrete tentarci quanto vorrete... ma non andrà... questo
perche ????
- Semplice in debug non accedete al vero app config... ma all' [Applicativo].vshost.exe.config...

Sembra facile ma non è difficile.. c'e' un motivo più che semplice, non modificare nulla, nel caso
l'exe originale ( ma perchè ??? ) fosse nella stessa cartella... ( qualcuno in m.s. si droga ).

B) a runtime va...

C) Lo sapevate che ...
In proprietà del vostro applicativo c'e' una voce chiamata... AssemblyName...
scrivete li dentro il nome del vostro "exe"...ehm...
poi Andate su assembly information (sempre da proprietà ) e modificate la voce
product.. in modo che sia diverso del vostro nome "exe"...
ED ECCO CHE APPARE UN ALTRO [nome prodotto].vshost.exe.config... !!
Vuoto naturalmente...

Ora... Ora... e ancora ora ... mi pare lecito avere tante possibilità .. ma dai un cotrollino sui nomi,
lo si poteva anche mettere no ???

Array di bottoni ?? eccolo...

Osservando le statistiche mi sono accorto che molti arrivano sul mio sito cercando "ARRAY di Bottoni"...

Ora posto che questo ricerca sia molto vicina a come creare un array di controlli, mi sembra carino pubblicare il seguente brano di codice che da qualche lume sull'argomento.

Anche se onestamente sconsiglio questa pratica.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

public class ButtonArrayController
{
Button[] _buttons = new Button[4];

public void CreateControlList()
{
_buttons = new Button[4];

_buttons[0] = new Button(); // create a new item
_buttons[0].Text = "New";
_buttons[0].Click += new EventHandler(ButtonArrayController_Click);

_buttons[1] = new Button(); // edit element (select to edit)
_buttons[1].Text = "Edit";
_buttons[1].Click += new EventHandler(ButtonArrayController_Click);

_buttons[2] = new Button(); // delete element (select to delete)
_buttons[2].Text = "Delete";
_buttons[2].Click += new EventHandler(ButtonArrayController_Click);

_buttons[3] = new Button(); // commit from new and edit
_buttons[3].Text = "Save";
_buttons[3].Click += new EventHandler(ButtonArrayController_Click);
}

public void SetStatus(int status)
{
for (int i = 0; i < 4; i++) { _buttons[0].Enabled = false; }

switch (status)
{
case 0: { _buttons[0].Enabled = true; break; } // init
case 1: { _buttons[1].Enabled = true; _buttons[2].Enabled = true; break; } // from grid click
case 2: { _buttons[3].Enabled = true; break; } // after case 0 or 1
}
}


public void ButtonArrayController_Click(object sender, EventArgs e)
{
// do action here..
}
}


Ad ogni modo un array di controlli in c# è un array e non quella strana situazione che creava VB6, tanto comoda quanto rischiosa.

ERROR [NA000] [Microsoft][ODBC driver for Oracle][Oracle]ORA-06413: Connessione non aperta. Risolto

Quando si verifica?
Nella maggior parte dei casi si verifica quando da un web service pubblicato su un II7.# si tenta di accedere ad un driver odbc realizzato a 32 bit.
Ci sono Workaround Noti?
Facendo parecchie ricerche emergono "estenuanti affermazioni inutili" come
-Associare a utenze diritti vari...
-Spostare programmi in cartelle varie...
-Utilizzare prodotti di terze parti...

Ma nessuno di questi funzioni o è la suoluzione effettiva, perchè il problema non è li...

Risoluzione per windows 7
A) assicurarsi di aver realizzato un odbc a 32 bit
-Accedere a c:/windows/siswow64/odbcad32.exe
-Creare un odbc per Oracle Microsoft ODBC for Oracle

B) assicurarsi di aver compilato la propria soluzione (progetto per progetto) con:
-Framework 2.0
-cpu X86

C) aprire "Gestione Internet Information Server"
-Scegliere: Pool di applicazioni
Aggiungere quindi un nuovo pool con le specifiche come da immagine:


Accertarsi che la voce "ATTIVA APPLICAZIONI A 32 bit " sia a TRUE

D) pubblicare la propria soluzione



E) Tornare su IIS e configurare la soluzione per l'appPool appena creato
-Selezionare il gruppo di appPool
-Verificare fra le proprietà degli appPool le applicazioni associate
(Dovrebbe trovarsi sotto DEFAULT APPPOOL)
-Selezionare default apppool
-Selezionare il link dal blocco di destra Visualizza Applicazioni
-Doppio Click sull'applicazione



-Tornare alla soluzionee verificare che eventuali referenze al web service realizzato, puntino
al web service pubblicato.

Esito
In questo modo si ha la certezza che il Web Service sia Eseguito in modalità 32 bit, dall' IIS,
va da se che deve essere compilato a 32 bit.

Se al termine di questo processo si ottiene ancora lo stesso errore possono essersi verificati due
problemi .
a) IIS non ha visto le modifiche (conviene riavviare tutto - macchina compresa)
b) non tutte le web reference sono state aggiornate.

Note conclusive
Questo problema esiste da quando esiste IIS a 64 bit, tuttavia non sono documentati i processi per ottimizzare il sistema a lavorare in piena compatibilità con le applicazioni a 32 bit.

-Potrebbe essere necessario aver installato il client di Oracle in program files (x86).
-Alcuni set up di Oracle client potrebbero non accettare spazie e parentesi nei nomi.

Foreach (xmlNode in xmlDocument.childNodes) non va...

Sembra strano .. ma c'e' una possbilità di Bug....

Fate questa prova createvi un xml che abbia quest'aspetto:
Coordinate
coordinata
x = 1
y= 1

coordinata
x = 2
y= 2

coordinata
x = 3
y= 3

coordinata
x = 4
y= 4


Poi provate a scrivere un banalissimo :
xmlDocument xd = new xmlDocument()
xd.Load([l'xml che avete ralizzato])

foreach (xmlNode xN in xd.childNodes)
{
console.writeline ( xN.InnerText);
}

che cosa succede ??

Potrebbe essere che anche a voi capiti di vedere sempre il primo nodo ??
si credo che possa succedere... ora fate questa prova ...

for (int i = 0; i < xd.childNodes.count; i++)
{
xmlNode xN = xd.childNodes[i];
console.writeline ( xN.InnerText);
}

acc.. succede ancora la stessa cosa ??

for (int i = 0; i < xd.childNodes.count; i++)
{
xmlNode xN = xd.childNodes[i].clone();
console.writeline ( xN.InnerText);
}

Tho' va che bello così funziona ??

Le supposizioni che si possono fare sono tante .. tuttavia solo con il clone il cursore sugli elementi si sposta.. caso contrario no...

Che sia un bug ??

Ecco un bel esempio di come togliersi dai guai.

Quante volte ci è capitato di dover accedere ad un componente esterno (realizzato da altri) che non ha un interfaccia condivisa ho condivisibile... e quindi non poterlo sfruttare al meglio ??

A me capita spesso.... ma questo caso mi sono fatto più furbo che tecnico...

using System;
using System.Collections.Generic;

namespace Test
{
// interfaccia
public interface IWsDerived
{
string DerivedMethod(string text);
}

// costruttore
public class WsConcrete
{
// modello primario
public IWsDerived GetDeploy(int model)
{
if (model == 1) { return new coModelA(); }
if (model == 2) { return new coModelB(); }
}

// modello non in uso
public IWsDerived GetTest()
{

}
}

// componente "a" che non implementa l'interfaccia
public class ModelA
{
public string DoMoreAboutIt(string message)
{
return message + "| Done";
}
}

// componente "b" che non implementa l'interfaccia
public class ModelB
{
public string DoMoreText(string message)
{
return message + "| Text Done";
}
}

// wrapper (+ o -) per modello A
public class coModelA : IWsDerived
{
public string DerivedMethod(string Message)
{
ModelA a = new ModelA();

return a.DoMoreAboutIt(Message);
}
}

// wrapper (+ o -) per modello B
public class coModelB : IWsDerived
{
public string DerivedMethod(string Message)
{
ModelB b = new ModelB();

return b.DoMoreText(Message);
}
}
}


Model A e Model B immaginateli come blocchi esterni...
All'interno del mio processo diventano accessibili tramite l'interfaccia...

Scritto e compilato !!

ToOdbcDataType

Bene .. bene bene... dato che non credo di essere l'unico a litigare con Odbc nel realizzare un breve data provider mi sono visto costretto a realizzare anche questo simpatico oggettino....

Diciamo che è la base o il punto di partenza per la conversione fra un generico DBType e un OdbcDataType...

partendo da questo link "http://msdn.microsoft.com/en-us/library/bbw6zyha%28VS.71%29.aspx" che mamma microsoft ha ben pensato di pubblicare...
ho realizzato questo "mini" data converter..

private OdbcType ToOdbcDataType(DbType Type)
{
switch (Type.ToString())
{
case "AnsiString": return OdbcType.VarChar;
case "Boolean": return OdbcType.Bit;
case "Byte": return OdbcType.TinyInt;
case "Binary": return OdbcType.VarBinary;
case "Date": return OdbcType.Date;
case "DateTime": return OdbcType.DateTime;
case "Decimal": return OdbcType.Numeric;
case "Double": return OdbcType.Double;
case "Single": return OdbcType.Real;
case "Guid": return OdbcType.UniqueIdentifier;
case "Int16": return OdbcType.SmallInt;
case "Int32": return OdbcType.Int;
case "Int64": return OdbcType.BigInt;
case "String": return OdbcType.VarChar;
case "Time": return OdbcType.Time;

}
return OdbcType.VarChar;
}

Ipoteticamente il Valore di ritorno di default andrebbe gestito meglio .. ma l'occasione fa l'uomo "furbo"...