Welcome to MCT Trainer MS for Aghilas


Cool :) I am now Microsoft Trainer team, and I can animate MC training with my clients, future sessions at IBS Consulting, whom I thank, Many thanks to Philip, Michael, Nadège and Raef.

November 17, 2015

Dear Technical team leader Philippe Kajmar:

Thank you for taking the time to complete the Microsoft Certified Trainer (MCT) reference form for yakoub aghilas. We have received your response and the instructional skills requirement for this candidate has been approved .

Sincerely,

MCT Program Team

Microsoft respects your privacy. Review our online Privacy Statement.

Microsoft Corporation
One Microsoft Way
Redmond, WA, USA 98052

MCT.png

Application Status

Thank you for submitting your MCT application on November 10, 2015.

Your MCT application status is listed as: Approved.

Your instructional skills validation status is listed as: Approved by both Reference and Regional Service Center.

Please note that it can take up to 10 business days for the Regional Service Center to validate your instructional skills upon receipt.

If we have not received payment and instructional skills validation within 90 days of application submission, your application will be cancelled.

Renewal Information
Your renewal anniversary date is November 18, 2016. You can renew your membership 90 days prior to your renewal anniversary date.

Welcome to AEA for Aghilas (Togaf )


Cool I am now part of the AEA committee;)

Dear Aghilas,

Welcome to the Association of Enterprise Architects (AEA). As a new member, you have joined forces with EA professionals worldwide who are working together to advance the profession of Enterprise Architecture and promote professional excellence.

Your username for the AEA is aghilas.yakoub and your Membership Number is ………

To sign into the AEA website please go to: https://www.globalaea.org

After logging in you will be able to manage your Profile by editing your bio,managing preferences and email subscriptions to blogs and forums.

You will also be able to access content and features, such as blogs, photo gallery, networks, and our AEA community via messaging, connections, groups,chapters, Work Groups, and Forums. You will be able to connect with fellow members, share ideas and expertise.

We hope you enjoy our online community and look forward to your participation!

Association of Enterprise Architects (AEA)

Togaf

Tips


Below a post aimed to alert you if a volume is exceeded on your SQL Server, for example, the basic transaction data may exceed certain thresholds for that access your agent SQL SERVER, configure it in such a way as to send mails.

Mail Alert

For your security management of your database, choose the concept of Role personalized, permission on a schema, add users to your role (Just as it would have been done with the Principal, Identity, Permission, Claims in C # ). Associating the scheme now to the role and not to different users.

Custom Role

Sql Server Normes Code & Some Tips


It is interesting how implement code standards for stored procedures in Sql Server, stored procedures system are prefixed with « sp_ », for our user stored procedures, let the prefix of « usp_ », this is done with Policy Management (see SSMS – the object explorer, root).

Right-click on Policy Management and select NewCondition, Enter a name and condition as well as the body of your condition, we have decided to select the Name filter with the LIKE expression (‘usp_%’).

PM0

The next step is to create a policy associated with this codition, right-click Policy Management and select New Policy, select the Check Condition list, the condition created previously, the evaluation mode must be set to « On change: prevent prevention « , the default mode is » On Demand « and policies can not be enabled in this mode for the Target, make sure you select all the databases and all stored procedures.

PM

C# 6.0


Below is a set of new features dedicated to the arrival here of C # 6.0, most of the new features have as main goal to reduce the number of lines of code, reducing artifacts of a class, such as builders primary, initializers automatic properties, automatic read-only properties, their purpose leads to the removal of members etc.

Facilitate the development of avoiding constraints validation, inclusion or otherwise.

Important: The examples below were developed under the Framewok

4.0.

This is now possible with a constructor.

public class Sample(int id, int code) 
{     
public int Id { get; } = id;     
public int Code { get; } = code; 
}

This is now possible with a property initializer

public int Flow { get; set; } = 2210;

Added to that using the static on a class that corresponds to import all the static members.

using System.Math;
…
// On invoque la méthode Round sans préfixer de la classe Math
double input = 123.45;
double target = Round(input, 1, MidpointRounding.AwayFromZero); // Rounds "up"

For asynchronous development it is now possible to include the keyword await.

private async Task NowIsPossible () 
{     
try     
{         
   // your treatment     
}     
catch (Exception ex)           
{         
    var exceptionMsg = new MessageDialog("Exception occured");         
    await exceptionMsg.ShowAsync();    
} 
}

The exception filters complement the exceptional treatments as below.
This becomes possible by adding an exception filters

Try
{
using (StreamReader sr = new StreamReader("TestFile.txt"))        
{                 
    string line;                
    // Read and display lines from the file until the end of                
    // the file is reached.                 
    while ((line = sr.ReadLine()) != null)                 
    {                     
      Console.WriteLine(line);                 
    }        
}
}
catch(IOException ex) if (ex.HResult == 0x80070020) 
{    
     // My resource is used by another process      
}

Treatment of nullability without raising NullReferenceException.
This becomes possible by interpreting the right name in the scenario or geek object is not null.

string name = geek?.Name;  

Avant :

 string name = geek!= null ? geek.Name : null;

See more detail http://msdn.microsoft.com/fr-fr/magazine/dn683793.aspx

GC.Collect

Multithreading Favorite patterns


Multithreading has a set of fins on why it is important to consider, study and propose solutions to circumvent among the encountered problems that we face are inter blocking and a forgotten synchronization, incorrect granularity and too broad , a reversal of priorities generating blocking an important thread and execution of a thread not significant, the immutability or absence of purity etc.

To cope with these problems it is necessary to establish a set of good development practices, below is a listing of the qualities I particularly aue.

Promote the use of TPL
Promote the use of Async Pattern Result
Promote the use of Background Work Pattern
Below a more detailed description of the three principles in place that are: the Boss Worker pattern, the Pipeline patern and Producer / Consumer (A demonstration will be performed using such notions and Task BlockingCollection).

Boss/Workers pattern :

Each request submitted to Boss class becomes a task to run on a thread defined by the boss class, the threads are managed at the boss class, the spots are encapsulated in Worker classes, it has the advantage of simplicity reading and a defined insulation.

Boss : 
foreach {					
	//get a request
	switch(request)
	{
   case X: new Thread(taskX);
     	   case Y: new Thread(taskY);
                 …
              }}

Worker :
taskX();

To weaken the coupling one could imagine the existence of classes implementing a IRequest query interface and the same for the Worker classes.
Often this pattern is associated with the use of the ThreadPool class.

Pipeline pattern:
The principle is to be executed by a thread a portion of a spot and pass the result to the next thread.
Below an example of pipeline code

class Pipeline
{
Main()	
{	
 createThread( ... stage1 )	
 createThread ( ... stage2 )	
 ...
 wait for all pipeline threads to finish	
 do any clean up	

}	

Stage1()	
{	
  foreach {	
         get next input for the program	
         do stage 1 processing of the input	
         pass result to next thread in pipeline	
  }	
}	
Stage2()	
{	
  foreach {	
         get input from previous thread in pipeline	
         do stage 2 processing of the input	
         pass result to next thread in pipeline	
  }	
}	
..
StageN()	
{	
  foreach {	
         get input from previous thread in pipeline	
         do stage N processing to the input	
         pass result to program output	
  }	
}
}

Below is a link describing in more detail the appearance http://msdn.microsoft.com/en-us/library/ff963548.aspx implementation

Producer / Consumer pattern:

The principle is to use a data stream to communicate a producer and a consumer thread thread.
The following is an implementation carried out using such classes and Task BlockingCollection representing the buffer structure.

// Declarer la structure tampon
var blockingCollection = new BlockingCollection();
// Lancer le premier consomateur qui attend que la données soit disponible sur le tampon
var consumer1 = Task.Factory.StartNew(() =>
{
	foreach (int data in blockingCollection.GetConsumingEnumerable())
   	{
	Console.Write(string.Concat("consumer1= ", data, ","));
	}
});

// Lancer le second consomateur qui attend que la données soit disponible sur le tampon
var consumer2 = Task.Factory.StartNew(() =>
{
	foreach (int data in blockingCollection.GetConsumingEnumerable())
	{
	Console.Write(string.Concat("consumer2= ", data, ","));
	}
});

// Le thread producteur produit les données sur la structure tampon
var producer = Task.Factory.StartNew(() =>
{
	for (int i = 0; i < 100; i++)
	{
	blockingCollection.Add(i);
	}
	blockingCollection.CompleteAdding();
});
producer.Wait();
// Attendre que tous les consomateurs finissent de consommer et relance le traitement
Task.WaitAll(consumer1, consumer2);
Console.WriteLine();

You have additional principles, such as the up-calls, which is to communicate the layers in an upward direction using a ThreadPool within each layer etc.

GC.Collect

TPL is nice


One of the most elegant ways to make asynchronous programming is the use of TPL (Task Parallel Library: http://msdn.microsoft.com/en-us/library/dd460717.aspx) using rudimentary notions such DataFlow.

The first step is to realize first of all to recover the associated Nuget library.

NugetTPL

Enter Data Flow in the search engine extensions and select TPL Dataflow.

ExtensionTPL

You will notice the reference is added to your project

ReferenceTPL

During the year two main classes that are used ActionBlock and TransformBlock.
The ActionBlock class lets you definer asynchronous functionality.

ActionBlock action = new ActionBlock(
 	(p) => {
	        for(int indexThread = 0 ; indexThread < 5; indexThread++)
	        {
		Thread.Sleep(1000);
		Console.WriteLine(p);
	        }});
action.Post("Nice");
while(true)
{
 Thread.Sleep(300);
 Console.WriteLine("Good");
}

Notice that the Data Flow runs along the loop made.

TPLTP

We will use in this second step TransformBlock the class, which is particular to apply a transformation to an input stream and an output stream.

Below is a desciption blocks auters:

  • BatchBlock: Aggregate flow into an output stream acting as a buffer.
  • BroadCastBlock: transfer a stream to a set of parallel processing blocks this flow entant
  • BufferBlock: To provide a set of output blocks of a same stream.
 
TransformBlock transformBlock = new TransformBlock(
(p) =>
   {
      return string.Concat("We transform this flow", p);
   });

GC.Collect

Microsoft – .Net C#

Suivre

Recevez les nouvelles publications par mail.