.NET
Che altro dire: .NET!
Non avevo mai usato un named Mutex, ma oggi ho bisogno di acquisire un Lock a livello di sistema e non solo interno al processo e ovviamente ci ho perso 1 ora per capirci qualcosa!
In poche ed imprecise parole: se nel nome di un Mutex anteponete la stringa "Global\" il Mutex avrà validità contemporanea su tutte le sessioni Terminal Services, se mettete "Local\" o non mettete niente avrà effetto solo sulla sessione corrente.
Dov'é il problema? Se voi mettete una stringa tipo "Global\MioPC\MiaRisorsa" o "Local\MioPC\MiaRisorsa" o "MioPC\MiaRisorsa" vi beccate una IOException non propriamente parlante ("La sintassi del nome del file, della...
Per tutti quelli che non seguono il blog di Brian Harry: dalla prossima versione dei Power Tools sarà disponibile una procedura di backup VERAMENTE ALLA PORTATA DI TUTTI! Soprattutto per chi ha installato la versione Basic, i piccoli team che si aspettano una procedura di backup semplificata.
Maggiori informazioni (veramente dettagliate): alla fonte.
In TFS l'unico metodo per cancellare un progetto é tramite un tool a linea di comando: TFSDeleteProject. Alcune informazioni relative al progetto poterbbero però sopravvivere anche a questa operazione, in particolare:
- Il TFSWarehouse non subirà alcuna modifica, i dati relativi al progetto rimarranno caricati. Per eliminare questi dati é necessario fare il rebuild del TFSwarehouse (vedi Setupwarehouse)
- Le cartelle dove viene fatto il drop delle build non vengono toccate
- Metadati dei workitem condivisi tra più progetti
- Shelveset che contengono file provenienti da un altro progetto
Maggiori informazioni: qui
Fonte: neno's blog
Lo so che é una cosa abbastanza inusuale avviare un processo con una stringa di comando (ampiamente) più lunga di 2000 caratteri, ma se dovesse servirvi sappiate un paio di cose:
Su windows <= windows 2000 (ok, dovrebbero essere un ricordo) il limite é sempre e comunque 260 caratteri, su windows >= windows XP il limite teorico é di 32Kb
Non usate Process.StartInfo.UseShellExecute = true (o gli overload Process.Start(string, string), ecc.)
Impostando UseShellExecute = true (valore di default) riceverete una bella: "System.ComponentModel.Win32Exception: Access Denied"
Se dovesse capitarvi, come al sottoscritto, di scervellarvi per capire perché il metodo DrawImageUnscaled della classe Graphics vi stampa un'immagine che é tutt'altro che UNscaled la spiegazione sta nel fatto che l'immagine di origine e di destinazione hanno impostato dei differenti DPI... Al di là del fatto che mi sembrava molto più logico che usasse i pixel come unità di riferimento, la soluzione é usare il metodo DrawImage. Se anche voi come il sottoscritto temete un degrado di prestazioni vi rassicuro che potete dormire sonni tranquilli: DrawImageUnscaled internamente usa DrawImage (No Comment!).
Estraendo files da un server Team Foundation la data dei files presenti sul disco viene impostata alla data in cui questi sono stati estratti. Non che ci veda niente di strano, anzi... Purtroppo però numerose persone che erano abiuate ad usare Visual Source Safe sentono questo come un problema (non chiedetemi perché, ma vi garantisco che almeno una decina di persone me l'ha segnalato).
Soluzione? Creare un programmino (console) che imposti la data dei file NON ESTRATTI in base alla data dell'ultimo checkin (scusate la lunghezza):
public static void ChangeDate(string ServerName, string workspaceName, string workspaceOwner, string pattern, bool subDirectories){ TeamFoundationServer tfs...
Se cercate di creare un oggetto TeamFoundationServer da un thread che gira con un account utente che non ha le credenziali di scrittura sul registry incapperete nell'eccezione [SecurityException: Requested registry access is not allowed.] (come già descritto qui).Grazie all'inossidabile Lorenzo ed ai suoi preziosi contatti ho trovato la soluzione.
Sostanzialmente (se ho ben capito) se specifico un server nei metodi (ed i loro rispettivi overloads):TeamFoundationServerFactory.GetServer(serverName)new TeamFoundationServer(serverName)passando come parametro il SOLO NOME del server viene effettuato dapprima un accesso in lettura alla chiave:HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\TeamFoundation\Serversper verificare se esiste un server memorizzato con il nome passato, dappoi tenta l'accesso al server specificato sulla porta standard (8080)....
E se il mio utente non ha permesso di scrivere nel registry?!Risposta:
System.ThrowHelper.ThrowSecurityException(ExceptionResource resource) +48Microsoft.Win32.RegistryKey.OpenSubKey(String name, Boolean writable) +2780921 Microsoft.TeamFoundation.Client.RegisteredServers.OpenCurrentUser(Boolean writable, Boolean shouldCreate) +50 Microsoft.TeamFoundation.Client.RegisteredServers.GetUriForServer(String serverName) +43 Microsoft.TeamFoundation.Client.TeamFoundationServer.GetUriForName(String name) +93 Microsoft.TeamFoundation.Client.TeamFoundationServer.get_Uri() +25 Microsoft.TeamFoundation.Client.CheckAuthenticationProxy..ctor(TeamFoundationServer server) +22 Microsoft.TeamFoundation.Client.TeamFoundationServer.Authenticate(Boolean useProvider, ICredentialsProvider provider) +58 Microsoft.TeamFoundation.Client.TeamFoundationServer.Authenticate() +17
E tutto questo per memorizzare l'elenco dei server conosciuti per l'utente... Direi che sono DISCRETAMENTE senza parole... alla faccia di sviluppare con zero privilegi!!! Francamente per quanto mi sforzi non riesco a trovare nessuna soluzione SPECIALMENTE perché la mia é un'applicazione ASP.NET che dovrebbe girare con impersonation!!! :-S
Faccio un po' di publicità ad una contestatissima (anche se secondo me nemmeno troppo giustamente) società di hosting italiano: su aruba é possibile registrarsi per una "demo" di ASP.NET 2.0 con SQL Server 2005 (express). 100 Mb di spazio + 50 di DB + dominio di quarto livello...Provare per credere!!!
Fonte: http://testdotnet.aruba.it/
Dovesse servirvi...Eccolo:
''' ----------------------------------------------------------------------------- ''' <summary> ''' Calcola il minimo comune multiplo ''' </summary> ''' <param name="num">Interi tra cui calcolare il mcm</param> ''' <returns></returns> ''' <remarks> ''' </remarks> ''' <history> ''' [michele] 08/02/2006 Created ''' </history> ''' ----------------------------------------------------------------------------- Public Overloads Shared Function mcm(ByVal ParamArray num() As Int32) As Int32 If num.Length = 0 Then Return 0 ElseIf num.Length = 1 Then Return num(1) End If mcm = num(0) For N As Int32 = 1 To num.GetUpperBound(0) mcm = mcm(mcm, num(N)) Next N End Function ''' ----------------------------------------------------------------------------- ''' <summary> ''' Calcola il minimo comune multiplo ''' </summary> ''' <param name="a">Primo intero</param> ''' <param name="b">Secondo intero</param> ''' <returns></returns> ''' <remarks> ''' </remarks> ''' <history> ''' [michele] 08/02/2006 Created ''' </history> ''' ----------------------------------------------------------------------------- Public Overloads Shared Function mcm(ByVal a As Int32, ByVal b As Int32) As Int32 Dim c As Long = a * b 'Dim r As Long Do mcm = a Mod b a = b b = mcm Loop While mcm <> 0 Return Convert.ToInt32(c \
a) End Function
powered by IMHO 1.3
L'applicazione Windows Forms alla quale sto
lavorando ha la possibilità di creare automaticamente un nuovo database sul
quale lavorare. Per caricare valori nei dizionari ho messo nelle risorse dei
file .sql che carico ed eseguo in un SQLCommand... E qui viene il bello: alcune
insert into non funzionavano correttamente: non venivano inseriti i caratteri
accentati... Dopo un paio di figuracce su usenet e sul forum di ugi mi sono
accorto che leggevo le risorse con l'encoding di default anziché il corretto
encoding:
System.Text.Encoding.GetEncoding(1252)
...mannaggia a me!!!
powered by IMHO 1.3
Intercettare l'aggiunta/rimozione di form MDIChild ad una form MDIParent é un'operazione che ho scoperto essere piuttosto macchinosa. L'area contenitore di form MDIChild non é altro che un controllo nascosto di tipo System.Windows.Forms.MdiClient. Questo controllo espone come tutti i controls container gli eventi di ControlAdded e ControlRemoved che corrispondo all'aggiunta o alla rimozione di una form Child.Questo é il codice di una Form MDI base con gli eventi ChildFormAdded e Removed:
Public Class MDIParentForm Inherits System.Windows.Forms.Form Protected WithEvents mdiClient As System.Windows.Forms.MdiClient#Region "Eventi" Public Event ChildFormAdded As System.Windows.Forms.ControlEventHandler Public Event ChildFormRemoved As System.Windows.Forms.ControlEventHandler ''' ----------------------------------------------------------------------------- ''' ''' Solleva l'evento ChildFormAdded ''' ''' ''' ''' ''' ''' [michele] 23/02/2005 Created ''' ''' ----------------------------------------------------------------------------- Protected Overridable Overloads Sub OnChildFormAdded(ByVal e As System.Windows.Forms.ControlEventArgs) RaiseEvent ChildFormAdded(Me, e) End Sub ''' ----------------------------------------------------------------------------- ''' ''' Solleva l'evento ChildFormRemoved ''' ''' ''' ''' ''' ''' [michele] 23/02/2005 Created ''' ''' ----------------------------------------------------------------------------- Protected Overridable Overloads Sub OnChildFormRemoved(ByVal e As System.Windows.Forms.ControlEventArgs) RaiseEvent ChildFormRemoved(Me, e) End Sub#End Region ''' ----------------------------------------------------------------------------- ''' ''' Crea una form MDIParent ''' ''' ''' ''' ''' [michele] 03/03/2006 Created ''' ''' ----------------------------------------------------------------------------- Public Sub New() Me.IsMdiContainer = True End Sub ''' ----------------------------------------------------------------------------- ''' ''' Ritorna il controllo MDIClient della form corrente ''' ''' ''' ''' ''' ''' [michele] 03/03/2006 Created ''' ''' ----------------------------------------------------------------------------- Protected Overridable Function GetMDIClientControl() As System.Windows.Forms.MdiClient For Each ctl As System.Windows.Forms.Control In Me.Controls If TypeOf ctl Is System.Windows.Forms.MdiClient Then Return DirectCast(ctl, System.Windows.Forms.MdiClient) End If Next ctl End Function ''' ----------------------------------------------------------------------------- ''' ''' Recupera il controllo MDIClient dalla control's collection ''' ''' ''' ''' ''' ''' [michele] 03/03/2006 Created ''' ''' ----------------------------------------------------------------------------- Protected Overrides Sub OnLoad(ByVal e As System.EventArgs) Me.mdiClient = Me.GetMDIClientControl MyBase.OnLoad(e) End Sub#Region "Riflessione degli eventi di MDIClient" Private Sub mdiClient_ControlAdded(ByVal sender As Object, ByVal e As System.Windows.Forms.ControlEventArgs) Handles mdiClient.ControlAdded Me.OnChildFormAdded(e) End Sub Private Sub mdiClient_ControlRemoved(ByVal sender As Object, ByVal e As System.Windows.Forms.ControlEventArgs) Handles mdiClient.ControlRemoved Me.OnChildFormRemoved(e) End Sub#End RegionEnd Class
powered by IMHO 1.3
Facendo delle prove per verificare la compatibilità dell'applicazione che stiamo scrivendo per MSDE 2000 con SQLServer Express mi sono imbattutto in un fastidiosissimo bug che inchioda puntualmente un paio di unit test:se create un diagramma di database in SQL Server 2000 con Visual Studio viene creata la tabella dtproperties che é erroneamente marcata come usertable al posto di systemtable!!! Il bug é arcinoto, ma comunque una seccatura...
Penso che chiunque abbia usato i Thread in un'applicazione si sia trovato prima o poi a testare la proprietà ThreadState. System.Threading.ThreadState é un'enumerazione di tipo Flag, infatti un Thread può trovarsi in più di uno stato contemporaneamente.Ad esempio un thread potrebbe essere in join (WaitSleepJoin) su un altro thread e contemporaneamente sospeso (Suspended) o SuspendedRequest, StopRequest, ecc. ecc.Il più naturale modo per testare lo stato di un Thread quindi sarebbe (secondo me):(myThread.ThreadState And ThreadState.StatoDesiderato) = ThreadState.StatoDesideratoGiusto, ma non vi venga mai in mente di testare in questo modo se é Running:(myThread.ThreadState And ThreadState.Running) = ThreadState.Runningperché questa riga di codice restituirà sempre...
Mi sono appena imbattutto in una stranezza: usando NUnit eseguo i test di una classe testFixture e il metodo di Teardown fallisce perché viene richiamato due volte. Come mai viene richiamato due volte?!La mia classe di test deriva una classe base nella quale é già definito un metodo di Nome Teardown decorato con l'attributo <NUnit.Framework.TearDown()>. Nella classe derivata Ridefinivo lo stesso metodo e rimettevo l'attributo. Evidentemente NUnit trovava due volte l'attributo e quindi chiamava il metodo due volte!La soluzione:
<NUnit.Framework.TearDown()> _Public Overrides Sub TearDown()
...un grattacapo in meno!
Durante i miei esperimenti di generazione e compilazione dinamica di codice mi sto imbattendo in quella che non stenterei a definire una stranezza.Genero al volo una classe che estende una classe base (definita nella libreria che genera il codice) e si riferisce ad un particolare tipo che varia di volta in volta e si trova probabilmente in un'altra libreria.Al momento della generazione imposto tutti i riferimenti e le opzioni:
Dim provider As Microsoft.VisualBasic.VBCodeProviderDim compiler As System.CodeDom.Compiler.ICodeCompilerDim results As System.CodeDom.Compiler.CompilerResultsDim cp As New System.CodeDom.Compiler.CompilerParameterscp.ReferencedAssemblies.Add("System.dll")cp.ReferencedAssemblies.Add("System.Data.dll")
Presto particolare attenzione a riferire gli assembly (ed ogni eventuale loro dipendenza) che non si trovano nella GAC specificandone il...
Alla ricerca di una soluzione per il QuizSharp di Adrian mi sono imbattutto
in una bella stranezza del Threading: a quanto posso vedere il Thread principale
di un'applicazione NON termina finché non terminano tutti i Thread "secondari"
con piorità almeno Normal.
La prova:
class Foo { static System.Threading.Thread MainThread; static void SecThread() { if (MainThread.IsAlive) MainThread.Join(); Console.WriteLine("Fine Thread Secondario"); } static void Main() { MainThread = System.Threading.Thread.CurrentThread; System.Threading.Thread ST = new System.Threading.Thread(new System.Threading.ThreadStart(SecThread)); ST.Priority = System.Threading.ThreadPriority.AboveNormal; ST.Start(); Console.WriteLine("Fine Thread Principale"); } }
Questo codice NON termina MAI, perché la Procedura SecThread che gira nel
Thread "secondario" aspetta che il Thread principale dell'applicazione termini,
ma questo NON termina!!! L'applicazione raggiunge l'ultima riga di Main, stampa
a console "Fine Thread Principale", ma in realtà il Thread principale sopravvive
alla fine del Main ed entra nello stato composito di: "Background, Stopped,
WaitSleepJoin", tant'é vero che...
Oggi mi sono trovato per
la prima volta a creare delle classi on-the-fly ereditando da una classe base ed
estendendo in base a delle informazioni passate.
Benché ci siano già
parecchi esempi in rete (che comunque ho fatto parecchia fatica a trovare) posto
anche il mio esempio che é arricchito di una piccola funzione per aggiungere i
riferimenti in maniera semplice.
Dim provider As Microsoft.VisualBasic.VBCodeProvider Dim compiler As System.CodeDom.Compiler.ICodeCompiler Dim results As System.CodeDom.Compiler.CompilerResults 'Impostazioni di compilazione Dim cp As New System.CodeDom.Compiler.CompilerParameters cp.GenerateInMemory = True 'Non mi interessa salvare su disco cp.TreatWarningsAsErrors = False cp.ReferencedAssemblies.Add("System.dll") AddReferences(cp, GetType(TipoUtilizzatoDalCodiceGenerato)) Try provider = New Microsoft.VisualBasic.VBCodeProvider compiler = provider.CreateCompiler results = compiler.CompileAssemblyFromSource(cp, CodiceGenerato) If results.Errors.Count = 0 Then Dim Ass As System.Reflection.Assembly = results.CompiledAssembly Dim GeneratedType as Type = Ass.GetType("GeneratedType") 'Creo un'istanza del tipo appena creato Dim O As Object = Activator.CreateInstance(Me.GeneratedType) 'Inserire qui il codice che usa il nuovo oggetto! Else 'Errore di compilazione! End If Catch ex As System.Exception 'Attenzione: qualcosa é andato storto: il compilatore non dovrebbe 'sollevare eccezioni normalmente, ma al massimo riportare errori di 'compilazione in: results.Errors End Try
Private Sub AddReferences(ByVal cp As System.CodeDom.Compiler.CompilerParameters, ByVal type As System.Type) For Each M As System.Reflection.Module In type.Assembly.GetModules() cp.ReferencedAssemblies.Add(M.Name) Next M 'Analisi tipo base If Not type.BaseType Is GetType(System.Object) Then AddReferences(cp, type.BaseType) End If 'Analisi interfacce For Each T As Type In type.GetInterfaces AddReferences(cp, T) Next T End Sub
Se
scrivete controlli windows forms vi sarà probabilmente capitato di volerli
proteggere da utilizzi inautorizzati e quindi immagino vi sarete creati una
libreria in cui definite un LicenseProvider ereditato da
System.ComponentModel.LicenseProvider. Per poi assegnare il custom
LicenseProvider al vostro controllo avrete usato
System.ComponentModel.LicenseProviderAttribute. Bene, tutto fila liscio finché
non vi verrà in mente di esporre il vostro controllo a dei client
COM.Purtroppo l'assembly con il vostro LicenseProvider non verrà più
caricato da System.ComponentModel.LicenseManager. Giustamente, il caricamento di
un assembly per la licenza NON é customizzabile tramite
AppDomain.AssemblyResolve (la verifica della licenza avviene in un altro
appDomain??), quindi, IMHO, non rimane altro...
Forse a chi usa C# e
viene da un background di programmatore C/C++ sembrerà normalissimo, ma per un
programmatore VB non avere errori di compilazione sulla prima di queste due
righe é piuttosto strano:
Dim B As Boolean = NothingMessageBox.Show(B.ToString)
Se avvio comparirà una messagebox che reciterà "false". Quindi Nothing
castato a Boolean é l'equivalente di false? Forse, ma, allora perché la
riga:
MessageBox.Show(DirectCast(Nothing, Boolean).ToString)
Invece genera un eccezione in esecuzione?
Decompilando con Reflector (in IL, perché in VB vengono entrambe tradotte con
le prime due linee) noto che l'inizio di queste espressioni é:
L_0000: ldc.i4.0 L_0001: stloc.0 L_0002: ldloca.s flag1
Pur non capendo niente di IL mi pare di vedere che il mio Nothing é...
Sono giorni che a tratti
ottengo dei problemi di caricamento di alcuni assembly. Per ignoti motivi non
vengono caricate le versioni giuste. Ad un certo punto una istruzione interrompe
l'esecuzione e senza alcuna plausibile motivazione esce un'eccezione di tipo
System.IO.FileLoadException che mi dice che la versione dell'assembly XXXX non
corrisponde a quella.... blablabla... Uso visual studio con una soluzione
che contiene 6 progetti. Ho provato a ricercare con la funzione "trova" di
windows tutte le occorrenze di quell'assembly nel mio file system ed eliminarle,
ma niente da fare il problema persiste a cancellazioni, riavvii e addirittura
ri-creazione dei progetti (sì, anche...
Sarà un bug dell'oggetto
System.Windows.Forms.DataObject?
Dal principio: ho una
treeview che contiene oggetti di tipo System.Windows.Forms.TreeNode ed oggetti
di tipo treeNode che ereditano, naturalmente, dal primo tipo.Quando parte un
Drag&Drop chiamo la DoDragDrop con il nodo in questione:Me.DoDragDrop(e.Item, AllowDrag)
All'evento DragOver verifico la presenza di un oggetto di tipo
System.Windows.Forms.TreeNode in e.Data:If e.Data.GetDataPresent(GetType(System.Windows.Forms.TreeNode)) ThenPurtroppo
questo metodo ritorna true SOLO nel caso che l'oggetto sia effettivamente di
tipo System.Windows.Forms.TreeNode e non se questo é un tipo da lì
ereditato!!!
Soluzioni?Nulla, quindi mi armo di Reflector ed indago:Innanzitutto
e.Data a parte l'interfaccia IDataObject é di tipo
System.Windows.Forms.DataObject il quale contiene un campo
privato che si chiama InnerData del tipo...
Mi é
recentemente capitata l'esigenza di avere una treeview (vale anche per la
listview) che permetta di avere le checkbox a tre (o più) stati.Basandomi
sull'ottimo lavoro di Brad Martinez (in VB6)http://www.mvps.org/ccrp/ho esteso il
controllo treeview per suportare nodi a tre stati.
Dal principio, un
bell'Enum e una classe TreeNode estesa:
Public Enum TreeViewCheckState NoCheck = 0 UnChecked = 1 Checked = 2 UnCheckedGrayed = 3 CheckedGrayed = 4End EnumPublic Class TreeNode Inherits System.Windows.Forms.TreeNode Private m_CheckState As TreeViewCheckState Public Overridable Property CheckState() As TreeViewCheckState Get Return m_CheckState End Get Set(ByVal Value As TreeViewCheckState) m_CheckState = Value 'Imposto il valore di checked: If Not Me.TreeView Is Nothing AndAlso TypeOf Me.TreeView Is Treeview Then DirectCast(Me.TreeView, Treeview).SetCheckIcon(Me) End If End Set End PropertyEnd Class
E a questo punto
viene il momento della treeview.Alcune note sul comportamento della
treeview:1) Integra una ImageList ChecksImageList
che continene le immagini che può assumere la "checkbox" dei singoli treenode.
L'immagine di indice zero non ha importanza perché all'indice zero corrisponde
l'assenza di checkbox.2) C'è una sottoclasse EventHashtable (il nome deriva
dal fatto che nella...
Vi é
mai capitato di dover gestire/enumerare le finestre aperte non dal vostro
programma? Se sì vi consiglio questo utile wrapper:
http://www.koders.com/csharp/fidF5C2650F8631BB4506D2DD38094D9FDF30D0C47B.aspx
Parecchie volte mi sono chiesto il perché di alcune mancanze
che mi sembrano veramente poco sensate, tipo:
perché non
posso richiedere delle funzioni statiche da un'interfaccia,perché non posso
fare l'override di funzioni statiche,perché non posso richiedere dei
costruttori da un interfaccia?
Per esempio l'interfaccia
ISerializable secondo me DOVREBBE richiedere alle classi che la
implementano un costruttore tipo:
Private Sub New(ByVal info As System.Runtime.Serialization.SerializationInfo, ByVal context As System.Runtime.Serialization.StreamingContext)
...altrimenti mi sembra tutto un po' aleatorio: potrei avere degli oggetti
che implementano ISerializable che poi a tutti gli effetti non possono essere
deserializzati!
Bello TestDriven.NET però manca una funzionalità: creare un progetto di
test per il progetto corrente...A questo proposito da un po' di tempo mi
sono fatto una bella Macro...Perché non l'ho mai
postata? Beh, é un po' empirica, funziona solo per VB.NET e crea il progetto di
test solo per il primo progetto della lista... E' da un bel po' che mi propongo
di migliorarla e farne un add-in, ma alla fine non ho mai tempo, così...
prendela per quello che é... e modificatela...
Cosa fa:Prende
il primo progetto della vostra soluzione, crea una sottocartella che si chiama
come la costante TestClassName...
Avete mai
notato che la "finestra di comando" di Visual Studio vi permette di vedere
dall'esterno (anche senza avere aperto il progetto in questione) anche
metodi/campi e proprietà che non dovrebbero essere visibili (Protected, Private,
Friend, ...). Unica pecca: non si vedono con l'intellisense.
P.S. Grazie Ele del
suggerimento
Quale di questi 3 metodi é il più efficiente?
PrivateFunction ProvaBool1()AsBoolean ReturnTrueEndFunction
PrivateFunction ProvaBool2()AsBoolean ProvaBool2 =TrueEndFunction
PrivateFunction ProvaBool3()AsBoolean Dim ResAsBoolean =True Return ResEndFunction
Da quello che credevo avrei pensato il primo, invece devo ricredermi! Ma chi ha scritto il compilatore VB?Premetto che sul mio computer é considerata una bestemmia mettere Option Strict Off...L'IL generato da ProvaBool2 é:
.method private instance bool ProvaBool2() cil managed
{
// Code Size: 5 byte(s)
.maxstack 1
.locals (
bool flag1)
...
Per me affacciarsi al mondo .NET é stato anche
affacciarsi al fantastico mondo delle regular expressions!
Così criptiche, ma così potenti!
Ovviamente non mi é passato inosservato il loro possibile utilizzo nella
pratica di tutti i giorni, così ho creato programmino MOLTO interessante
serve ad editare e salvare sequenze di Replace basati sulle Regular
Expressions.
Fin qui nulla di strano se non che mi sto rendendo conto che giorno dopo
giorno la libreria di regular expressions che mi sto costruendo é sempre più
fornita, così ho pensato che magari potrebbe fare comodo anche a
qualcun'altro.
D'ora in avanti posterò saltuariamente delle Regular Expressions di utilità...
Avete mai provato questa espressione?Public Enum Pippo As Int32Apparentemente non c'é niente di male, ma se la mettete un file .vb vi beccherete questo errore di compilazione:I valori Enum devono essere dichiarati "Byte", "Short", "Integer" o "Long"Ovvero?Ho sempre pensato (senza mai controllare, mea culpa) che Integer fosse una import di questo tipo:Imports Integer = System.Int32Probabilmente definita nel namespace Microsoft.VisualBasicSe così fosse si potrebbe trattare di un errore nel Parser del compilatore di VB.NET......Ma l'esperienza mi insegna che prima di gridare "al bug, al bug!" é meglio darsi un'occhiata in giro.Parto dal buon san google (protettore dei programmatori) ed ecco che la prima risposta utile che...
Sto scrivendo un piccolo controllo per la generazione di stringhe di connessione generiche ed ho deciso di appoggiarmi all'arcinoto oggetto (COM) Datalink della libreria MSDASC. Costruisco il wrapper e lo provo:
Dim cn As New ADODB.Connection
Dim UDL As New MSDASC.DataLinksClass
UDL.PromptEdit(cn)
Sull’ultima riga viene segnato l’errore:
Option Strict On non consente conversioni implicite da "System.Object" a "ADODB.Connection".
Cioé ADODB.Connection non eredita da Object?
…da quanto ho capito gli unici tipi che non derivano da Object sono le interfacce. Apro l’Object browser e vedo che Connection appare come una classe. Del resto New ADODB.Connection è un’operazione legale.
Apro Reflector e vedo...
In questo post Paul Vick sta facendo un indagine se preferiamo usare il costruttore di una Windows Form piuttosto che l'evento Form_Load. Mi sembra interessante. Voi cosa usate? Perché?Io uso quasi sempre l'evento Form_Load: non mi piace andare ad immischiarmi con il codice generato dalla "progettazione windows form" di Visual Studio.Faccio eccezione se:1) Ho un parametro talmente vitale in una form che lo richiedo nel costruttore (mi sembra molto più pulito definire il costruttore con un parametro piuttosto che fare lo Shadow di Form.Show)2) Sto creando una form base per altre form: Meglio vincolare il codice importante nel costruttore che...
Avete mai provato da una Windows Form MDIParent temporanemanete invisibile a fare lo Show di un MDIChild? Fin qui nessun problema, ma se vi trovaste all'interno di un altro thread e doveste fare lo Show del Child usando MDIParent.Invoke?Ottereste una bella:Eccezione non gestita di tipo "System.StackOverflowException" in mscorlib.dllCause: ...boh...Possibili soluzioni:Ereditate le vostre Form MDIChild da questa:
Public Class BaseMDIChild
Inherits System.Windows.Forms.Form
Public Shadows Sub Show()
If Not Me.MdiParent Is Nothing Then
If Me.MdiParent.Visible Then
MyBase.Show()
Else
AddHandler Me.MdiParent.VisibleChanged, DelParentVisibleChanged
End If
End If
End Sub
Private DelParentVisibleChanged As EventHandler = AddressOf ParentVisibleChanged
Private Sub...
Avete mai lavorato in VB6? Ricordate il designtime della form? Avevo letto da qualche parte che in VS.NET non é più così e ieri ne ho avuto conferma. Credo che ci sia un qualche metodo "nascosto" che avvia la form nella modalità di progettazione che ben conosciamo. Perché lo penso? Ho commesso una distrazione nell' override del metodo Dispose: al posto che richiamare il dispose della base ho creato un loop continuo chiamando Me.Dispose (this.Dispose();;-)) ed ho aperto la form nel designer. Fin qui tutto bene il problema é stato chiuderla: ogni volta che tentavo di chiuderla Visual Studio crashava......
Mi sono sempre chiesto come funzionasse l'override degli operatori in C# 1.X... CLS 1 non prevede l'override degli operatori...public static bool operator == (Classe a, Classe b) {return false;}public static bool operator != (Classe a, Classe b) {return false;}Compilo classe e reflecto... ed ecco svelato l'arcanClasse ha due belle Function:Public Shared Function op_Equality(ByVal a As Classe, ByVal b As Classe) As BooleanPublic Shared Function op_Inequality(ByVal a As Classe, ByVal b As Classe) As BooleanCreo un metodo che contiene (in C#):Console.WriteLine(a == b);dove a e b sono istanze di ClasseProvo a decompilare (*) e cosa vedo? E poi guardando il codice...