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"...