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];
  }
}