.Net Web and Windows Applications, C# and VB.net

2010-04-07T13:17:00.000-07:00

Dans mon espace de LinkedIn, j'ai 3 recommandations que j'apprécie beaucoup, des collègues avec qui j'ai travaillé.
Avant de les citer, j'aimerais dire un grand merci à eux, c'étais un plaisir pour moi.

De Oussama Dinia, Expert Technique .NET
et qui a travaillé directement avec moi
“During the times I have worked with Redouane, I have always felt a certain complementarity. Redouane is very strong technically, especially when it comes to low level development, or development without UI. He's highly experience with the .NET framework, and has a very intensly positive attitude as a team member. You can rely on Redouane in just about all the "Mission Impossible" situations :). I did.” 7 avril 2010

De Jalal Mankach, Développeur Sharepoint, ONA Holding
qui a travaillé directement avec moi
“Mr Radouan Mounafia a exercé au sein de Netopia Solution les fonctions de Développeur confirmé. Je peux vous assurer que Monsieur Radouan Mounafia a toujours su montrer un grand intérêt pour son travail et qu'il ma donné entière satisfaction en s'acquittant de ses tâches avec célérité. C'est, en effet, une personne très compétente qui maîtrise parfaitement son métier et l'exerce avec professionnalisme.” 18 janvier 2010

De Tarik Fadli, Lead Solutions Architect, Microsoft Middle East & Africa (relation professionnelle)
qui était employé par une autre entreprise quand j'ai travaillé avec son équipe
“It is my pleasure to recommend Redouane. He worked as a developer in a team I worked with as an architect for a complex ticketing system. Readouane showed good work ethics and great commitment to completing his tasks and even taking on others. He established good relationships with his peers and with the end users. I look forward to working with him.” 18 janvier 2010

Modification du fichier de configuration .Net

2010-01-18T06:54:00.000-08:00

Avec la sortie du Framework 2.0, on pourrait gérer un fichier de configuration dynamiquement, chose qui n’était pas avant.
Depuis .Net 2.0, on a la possibilité de modifier, ajouter et/ou crypter des sections dans le fichier de configuration, en général on a des outils de configuration qui nous permettent de rendre nos applications flexibles et portables d’une façon aisée.
Ces outils on les trouve dans l’espace de nom System.Configuration.

Ci-après un petit exemple pour vous montrer, comment modifier une clé de la section appSettings ou une chaîne de connexion de la section connectionStrings.

< configuration>
< appSettings>
< add key="TestKey" value="Test Value" />
< /appSettings>
< connectionStrings>
< add name="ConnString" connectionString="Data Source=TestSource; DataBase=TestData; User ID=Login; Pwd=Passeword" providerName="System.Data.SqlServer" />
< /connectionStrings>

D’abord et avant de compiler le code, il faut ajouter une référence dans votre projet à System.Configuration.dll :

Imports System.Configuration
Imports System.Web.Configuration

Et le code :

Dim config As Configuration = WebConfigurationManager.OpenWebConfiguration("~")

' Vérifier la présence d'un fichier de configuration
If (config.HasFile) Then

' AppSettingsSection => Fournit une prise en charge du système de configuration pour la section de configuration appSettings
Dim AppSet As AppSettingsSection = CType(config.GetSection("appSettings"), AppSettingsSection)

' ConnectionStringsSection => Fournit l'accès par programme à la section des chaînes de connexion du fichier de configuration
Dim ConnSet As ConnectionStringsSection = CType(config.GetSection("connectionStrings"), ConnectionStringsSection)

'config.Save() => Enregistre les paramètres courant
de l’objet Configuration dans le fichier XML associé.
'config.SaveAs(filename As String) => Enregistre les paramètres courant de l’objet Configuration dans un fichier XML indiqué en paramètre.

If (Not AppSet Is Nothing) Then
AppSet.Settings("TestKey").Value = "Test Value"
config.Save()
End If

If (Not ConnSet Is Nothing) Then
ConnSet.ConnectionStrings("ConnString").ConnectionString = "La chaîne de connexion"
ConnSet.ConnectionStrings("ConnString").ProviderName = "System.Data.SqlServer"
config.Save()
End If

End If

Utilisation de code non managé sans les composants COM

2010-01-13T07:53:00.000-08:00

• Les composants COM et le code non managé
(Utilisation de code non managé sans les composants COM)

On sait presque tous comment utilisé des objets COM (Components Object Model) dans nos assemblées (la plupart du temps à l’aide de l’outil d’importation Visual Studio) et ça permet aux applications qui fonctionnent avec le Framework .Net d’interagir avec des applications non-managées.

Mais il peut arriver parfois que le composant COM qui englobe le code non managé n’existe pas, dans ce cas, nous allons utiliser d’autres outils du Framework pour importer et utiliser du code non managé.

Parmi ces outils, il y a le principal qui est : P/Invoke (ou Platform Invoke) qu’on trouve dans l’espace de nom « System.Runtime.InteropServices » et qui invoque et fourni des fonctionnalités pour accéder à des fonctions, des structures et des callbacks dans des Dlls non managées.
Essayons de comprendre bien ces fonctionnalités et comment utiliser le P/Invoke, avec un exemple :

 Nous allons nous servir de l’API Win32 qui permet à la manière des Windows Form d’afficher des fenêtres ou dessiner des formes mais avec du code non managé .NET. Parmi les Dlls fréquemment utilisées dans cet API :
User32.dll (Fonctions de gestion Windows pour les messages, les minuteries, les menus et les communications).
Pour utilise P/Invoke, nous allons utiliser conjointement un attribut et le mot clé extern (ou shared en vb.net) :

• ' VB
• < DllImport("USER32.DLL")>
• Public Shared Function FindWindow(ByVal lpClassName As String, _
• ByVal lpWindowName As String) As IntPtr

• // C#
• [DllImport("USER32.DLL")]
• public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

L’attribut va se charger d’importer un membre de la Dll (User32.dll), nous devons le placer devant la méthode ou un paramètre.
Le mot clef extern/Shared lui permet de définir que nous allons utiliser une méthode externe à l’assembly et que celle‐ci se situe dans la dll importée. Nous devons impérativement respecter la signature de la méthode, nous devons donc connaître la signature de la méthode dans la dll importé.
NB : La méthode FindWindow a deux paramètres (Class et Window Caption) qu’on trouve dans les propriétés de la fenêtre active à l’aide de l’outil Microsoft Spy++.

Dans l’exemple ci-après (Référence msdn Microsoft : How to: Simulate Mouse and Keyboard Events in Code), nous allons activer la fenêtre de l’application (calculatrice Windows) qui recevra une séquence de touches à l’aide de l’appel de la méthode Send ou SendWait (Méthodes Windows natives pour forcer le focus sur d’autres applications) :

// Get a handle to an application window.
[DllImport("USER32.DLL")]
public static extern IntPtr FindWindow(string lpClassName,
string lpWindowName);

// Activate an application window.
[DllImport("USER32.DLL")]
public static extern bool SetForegroundWindow(IntPtr hWnd);

// Send a series of key presses to the Calculator application.
private void button1_Click(object sender, EventArgs e)
{
// Get a handle to the Calculator application. The window class
// and window name were obtained using the Spy++ tool.
IntPtr calculatorHandle = FindWindow("SciCalc", "Calculator");

// Verify that Calculator is a running process.
if (calculatorHandle == IntPtr.Zero)
{
MessageBox.Show("Calculator is not running.");
return;
}

// Make Calculator the foreground application and send it
// a set of calculations.
SetForegroundWindow(calculatorHandle);
SendKeys.SendWait("111");
SendKeys.SendWait("*");
SendKeys.SendWait("11");
SendKeys.SendWait("=");
}

Nous avons dans notre exemple encapsulé le code importé dans une méthode afin de simplifier la réutilisation du code non managé. C’est une bonne pratique car elle va nous permettre d’importer du code non managé sans perturber les autres développeurs qui pourront utiliser seulement du code managé et ne devront pas apprendre toutes les ficelles de P/Invoke.

Référence : - msdn Microsoft
- http://www.dotnet-france.com/

How to Load images in Crystal Reports dynamically Using Visual Studio 2005

2008-11-08T13:38:00.000-08:00

If you have imagepath that store in your database, Crystal Report .NET in Visual Studio 2003/2005 cannot display image file dynamically unless you use dynamic image location feature in Crystal Report XI.

I searched in the Web, I found how to display it with some work around for this :

* Sure we must have a field (imagepath) in our database. We need to create a new Dataset/XML Schema (xsd) (Typed DataSet) to use as resource data in creating report and add an additional field that is not in the table and which is of type base64Binary :

Or add it in xml :
< name="”image_stream”" type="”xs:base64Binary”" minoccurs="”0″">

* When designing a report drag and drop the “image_stream” field in the region where you want it to appear.

* Add CrystalReportViewer to your page aspx.

* In Code Behind of your page Add the following method, to load the image:

private void LoadImage(DataRow objDataRow, string strImageField, string FilePath)
{
try
{
FileStream fs = new FileStream(FilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read);

byte[] Image = new byte[fs.Length];
fs.Read(Image, 0, Convert.ToInt32(fs.Length));
fs.Close();
objDataRow[strImageField] = Image;
}
catch (Exception ex)
{
Response.Write("" + ex.Message + "");
}
}

* We need to fill the Typed DataSet, and before assigning this dataset to the “SetDataSource” of our report, we need to add some lines of code:

TypedDataSet ds = new TypedDataSet();

SqlConnection cn = new SqlConnection("Data Source=ServerName;Initial Catalog=DataBaseName;User ID=UserName;Password=UserPassword");
SqlCommand Cmd = new SqlCommand();
SqlDataAdapter myAdapter = new SqlDataAdapter();

Cmd.CommandText = " Select * From TableName";
Cmd.Connection = cn;
myAdapter.SelectCommand = Cmd;

try
{
cn.Open();
myAdapter.Fill(ds.Tables[0]);
cn.Close();
}
catch (Exception ex)
{
throw;
}

for (int index = 0; index < ds.Tables[0].Rows.Count; index++)
{
if (ds.Tables[0].Rows[index]["image_path"].ToString() != "")
{
string s = this.Server.MapPath(ds.Tables[0].Rows[index]["image_path"].ToString());
if (File.Exists(s))
{
LoadImage(ds.Tables[0].Rows[index], "image_stream", s);
}
else
{
LoadImage(ds.Tables[0].Rows[index], "image_stream", @"C:\ImagePath\DefaultPicture.jpg");
}
}
else
{
LoadImage(ds.Tables[0].Rows[index], "image_stream", @"C:\ImagePath\DefaultPicture.jpg");
}
}

try
{
ReportDocument crDoc = new ReportDocument();
crDoc.Load(Server.MapPath("CrystalReport.rpt"));
crDoc.SetDataSource(ds.Tables[0]);
CrystalReportViewer1.ReportSource = crDoc;
}
catch (Exception ex)
{
throw;
}