/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:Configuration=Release
/p:DeployOnBuild=true /p:WebPublishMethod=FileSystem /p:publishUrl="$(build.artifactstagingdirectory)" /p:DeployDefaultTarget=WebPublish
Your account has no free minutes remaining.https://{{vsts_account_name}}.visualstudio.comhttps://{{vsts_account_name}}.visualstudio.com/_details/security/tokenshttps://{{vsts_account_name}}.visualstudio.com/_admin/_AgentPoolaz lab vm {{command}} --lab-name {{devtestlab}} --name {{vm-name}}
--resource-group {{resource-group}}
command : start ou stop$scope.tableParams = odataTableService.createTableParams({
endPoint: 'http://services.odata.org/V3/Northwind/Northwind.svc/Products'
});
RunOctoPack est initialisée à false et c’est elle qui déclenche ou non la génération du package.
Alors évidemment, une solution possible est de modifier cette variable à true. Néanmoins cela induit qu’un package de déploiement sera créé a chaque build du projet. Ce n’est vraisemblablement pas ce que vous souhaitez.
Je vous propose plutôt d’ouvrir une console DOS et une fois dans le répertoire du projet, tapez la commande suivante :
msbuild ContinuousBI.Sql.sqlproj /t:Build /p:RunOctoPack=true
Si tout s’est bien passé vous devriez avoir une sortie similaire a celle-ci :
Cette fois ci, si vous jetez un œil dans le sous-dossier obj/octopacked de votre projet vous y découvrirez un fichier .nupkg qui est le package de déploiement
A quoi ressemble mon package ?
Pour aller un peu plus loin nous pouvons jeter un œil à ce qui a été produit pour nous par Octopack.
Je vous propose d’utiliser nuget package explorer
Ouvrez le et glissez déposez le fichier .nupkg, vous devriez obtenir un résultat semblable à celui-ci.
C’est confirmé, le dacpac issu de la compilation à bien été reconnu ; il est embarqué dans package de déploiement.
Nous verrons dans le prochain post comment le déployer avec Octopus.
private string sentence = "Hello world";
public dynamic BuildObj()
{
dynamic myDynObj = new ExpandoObject();
myDynObj.SayHello = new Func<string>(() => sentence);
return myDynObj;
}
[Test]
public void CallDirectlyMethod()
{
dynamic myObj = BuildObj();
var ret = myObj.SayHello();
Assert.That(ret, Is.EqualTo(sentence));
}
[Test]
public void CallMethodWithReflectionFails()
{
dynamic myObj = BuildObj();
Type t = myObj.GetType();
var method = t.GetMethod("SayHello", BindingFlags.Default | BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic);
Assert.That(method, Is.Null);
}
[Test]
public void CallMethodWithCallSite()
{
dynamic myObj = BuildObj();
var callSiteBinder = Binder.InvokeMember(CSharpBinderFlags.None, "SayHello",
Enumerable.Empty<Type>(), myObj.GetType(),
new []
{
CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
});
var callSite = CallSite<Func<CallSite, object, object>>.Create(callSiteBinder);
string ret = callSite.Target(callSite, myObj);
Assert.That(ret, Is.EqualTo(sentence));
}
sudo apt-get update sudo apt-get upgrade
sudo apt-get install mono-runtime
pscp.exe "C:\ BBB\ HelloWorld\bin\Debug\HelloWorld.exe" ubuntu@192.168.10.2:/home/ubuntu
Mono HelloWorld.exe
Cet article fait partie d’une sérié dédiée à Elasticsearch, reportez vous à l’article sommaire pour accéder facilement aux autres posts.
Kibana est la brique de visualisation qui gravite autour d’Elasticsearch. Voici, quelques exemple de représentations faites avec Kibana :
L’exploration de données et la réalisation de dashboard ne nécessitent aucun code, ce qui permet de donner la main aux fonctionnels ; De plus Kibana et Elastocsearch permettent d’avoir des rapports real time, se mettant à jour à mesure que les données sont stockées.
Pour les lecteurs qui connaissent bien la stack SQL Serveur, on pourrait le comparer à un Report Builder sous stéroïdes et surtout qui tiendrait (mieux) ses promesses de simplicités et d’accessibilité pour les non-techniciens
Je me propose dans ce billet de découvrir ensemble les fonctionnalités de « data discovering » sur un dataset public recensant les accidents corporels de la circulation
Si ces données vous intéressent, je vous invite d’ailleurs à jeter un œil à la très bonne session (video, slides) de Patrice Harel sur le mining avec SSAS et qui s’appui sur le même jeu de données.
Commençons par l’installation qui comme pour les autres composants de la stack est triviale :
Tout commence évidement par le téléchargement du binaire ici, suivi de la décompression de l’archive.
Si votre instance elasticsearh ne tourne pas sur le même serveur qui hébergera Kibana ou si elle écoute sur un port non standard, il vous faudra modifier le fichier de configuration config/kibana.yml.
Dans mon cas, je ne touche à rien!
Puis à l’aide d’une fenêtre commande, il nous faudra exécuter /bin/kibana après s’être placé dans le répertoire ou a été décompressé l’archive.
Finalement pointons notre navigateur sur l’url http://localhost:5601
S’il s’agit de la première fois que vous lancez Kibana, cet écran vous sera présenté, dans lequel il vous faudra choisir un index (équivalent de base de données) ainsi qu’une colonne typée date.
Ce dernier point est extrêmement important, car Kibana part du principe qu’il est naturel pour l’esprit humain et plus facile de découvrir des données lorsqu’elles sont représentées sur une frise.
Dans notre dataset, nous ne disposons malheureusement pas de la date de l’accident, qui aurait été le candidat idéal en tant que « time field ».
Pour l’exemple, nous nous rabattrons sur le champ @timestamp représentant l’instant ou a été inséré l’événement dans notre index.
On se retrouve propulsé dans nos données via l’écran suivant :
On reconnait très vite plusieurs sections dans cette interface :
Commençons par cliquer sur les barres du graph afin d’effectuer un drilldown au niveau temps.
Instantanément cela nous permet de découvrir la répartition des data dans le temps. Notez, que les clics que nous avons fait sur le graph sont interprétés comme une clause de filtrage, diminuant les événements auxquels on s’intéresse.
Pour avoir un aperçu du contenu des champs, je vous conseille de cliquer sur le nom d'un champ dans la colonne de gauche ; comme ceci :
Les informations et actions présentées ici sont une vraie mine d’or.
En plus d'un premier comptage des données sous-jacentes, on peut par exemple se concentrer sur les événements qui ont eu lieu sur l’A31 en cliquant sur l'icone loupe+. Evidemment, la frise temporelle et les données sont mis à jour.
Maintenant, intéressons nous au champ tbl qui représente le nombre de blessés légers dans un accident.
En cliquant sur « Visualize », on obtient la répartition top 20, sous forme d’histogramme, du nombre de blessés légers sur l’ensemble des événements de la base.
Ici aussi cette visualisation, nous permet d’appréhender rapidement la teneur de nos données.
Finalement jetons un œil, au filtre qui se trouve tout en haut de l’interface de Kibana. Par défaut, vous y trouverez une *. Attention, il n’y a pas ici d’analogie avec SQL, ici l’étoile signifie sans filtre.
Nous pourrions par exemple nous intéresser à une commune en particulier, celle de Cergy par exemple (95002). Il nous suffira pour ce faire de saisir le filtre suivant :
codeinsee:=95002
ttué:>2
ttué:>2 AND codeinsee [60000 TO 69999]
Voila qui clos ce premier article sur Kibana, en espérant vous avoir donné envie d’essayer ce superbe outil.
Ce post fait office de sommaire à toute une série d’articles que j’ai bon espoir d’écrire sur cette toute fin d’année 2014 et le début 2015.
Mais pourquoi parler d’Elasticsearch, moi qui ne traite que de technos Microsoft sur ce blog?
Cela part du constat qu’a mon humble avis, la stack BI Microsoft pèche sur deux points :
C’est avec ces regrets dans l’âme, que je me retrouve lors de la conférence ncraft 2014 à assister à une superbe session d’Itamar Syn-Hershko consacrée au couple Elasticsearch et Kibana.
Je vous passe les détails de cette présentation, mais effet whaou garanti vers la fin de la session lorsque Kibana rentre en scène.
Certain doivent se dire qu’il m’a fallu presque 1 an pour commencer à sortir un article, quelle productivité !
Pour être tout à fait franc, il y a 1 an il manquait encore quelques features indispensable a mon sens pour que Kibana puisse jouer un rôle aussi important que ce pour quoi il à été conçu. L’exemple le plus probant était l’impossibilité de réaliser un « distinc count » ; un « show stopper » pour qui compte faire un peu de BI sérieusement.
Voila pour le petit historique et mes états d’âmes ; Kibana est arrivé à maturité selon moi dans ses cas d’utilisation standard et cela mérité bien qu’on s’y intéresse ainsi qu’a l’écosystème qui gravite autour.
Voici enfin l’heure du menu :
Il y’a de forte chance que ce sommaire soit agrémenté d’autres articles dans le futur ; le domaine étant extrêmement large.
Dernier point, l’ordre des premiers articles peut vous paraître étrange ; j’ai voulu partir de ce qui apportera le plus de valeur ajouté aux fonctionnels pour finir par ce qui requiers le plus de compétences techniques.
Il ne me reste qu'a vous souhaiter une bonne lecture, et n'hésitez pas a me laisser vos commentaires.
Dernièrement, je vous présentais une façon simple d'utiliser le cache dans vos applications .NET
Cependant cette solution possède plusieurs inconvénients. En voici quelque uns :
Aujourd'hui, je voudrais partager avec vous une solution qui répond à tous les manques évoqués plus haut et plus encore.
Couchbase est une base NoSQL Key/Value; la value ayant comme particularité d'être un document json.
Couchbase est issu du mariage heureux de Membase (cache mémoire avec réplication des caches, persistance et interface d’admin Web sexy) et
CouchDB (NoSQL orienté document). Ce qui nous intéresse plus particulièrement aujourd'hui sont les fonctionnalités qui en font un bon serveur de cache.
Pour l'installer, tout commence par télécharger le setup ici
Je vous passe le scénario d'installation qui a le bon gout de se faire en "Next" > "Next" > "Next"
Couchbase dispose d'un très bel écosystème qui gravite autour, et la plateforme .NET ne fait pas exception.
Je me propose d'adapter le cache manager vu dans le précédent article.
Pour rappel nous avions l'interface suivante :
public interface ICacheManager
{
T GetOrInsert<T>(string key, Func<T> callback) where T : class;
}
Passons à l'implémentation. Il va nous falloir un driver, que l'on peut aisément installer via nuget :
son utilisation est des plus simple, avec des méthodes explicites comme Get() et Store().
Voici une implémentation de cache respectant notre interface basée sur Couchbase.
public class CouchbaseCacheManager : ICacheManager
{
private readonly CouchbaseClient _client;
public CouchebaseCacheManager()
{
_client = new CouchbaseClient();
}
public T GetOrInsert<T>(string key, Func<T> callback) where T : class
{
T elmnt;
try
{
if (_client.KeyExists(key))
return _client.Get<T>(key);
elmnt = callback();
_client.Store(StoreMode.Add, key, elmnt);
}
catch (Exception)
{
elmnt = callback();
}
return elmnt;
}
}
Et vous, quel type de cache utilisez vous dans vos projets?
Depuis la version 4 du framework .NET, la gestion d'un cache est profondement encrée dans l'adn de notre framework.
Il devient alors extrêmement facile de stocker en mémoire à peu près n'importe quoi.
Je vous livre dans ce court billet, une implémentation extrêmement simple que j'utilise souvent dans mes projets.
Commençons par définir une interface, qui nous permettra d'injecter notre cache manager un peu partout :
public interface ICacheManager
{
T GetOrInsert<T>(string key, Func<T> callback) where T : class;
}
et finalement voici une implémentation extra simple de notre cache manager
public class CacheManager : ICacheManager
{
public T GetOrInsert<T>(string key, Func<T> callback) where T : class
{
ObjectCache cache = MemoryCache.Default;
if (cache.Contains(key))
return cache[key] as T;
T elmnt = callback();
cache.Add(new CacheItem(key, elmnt), new CacheItemPolicy());
return elmnt;
}
}
Voici un exemple d'utilisation.
IEnumerable<Product> products = _cache.GetOrInsert("Ma_Clef_Unique_Cache",
() => { return _productService.GetFrenchProducts(); } );
Simple non?
Nul doute, IISExpress nous a simplifié la vie au quotidien de par sa facilité d'utilisation et son intégration à Visual Studio.
Aujourd'hui, je devais travailler à rendre un site compatible avec l'ipad. Ni une ni deux, je lance safari et pointe vers l'ip de ma machine de dev.
Et boom une belle erreur, me prévient que IISExpress ne servira de pages qu'en local.
Voici comment je l'ai configuré afin de pouvoir tester sur mon Ipad.
Pour ce faire ouvrons le fichier de config de IISExpress qui se trouve sur : %userprofile%\My Documents\IISExpress\config\applicationhost.config
Recherchons la config de notre site
<site name="MonSite" id="10"> <application path="/" applicationPool="Clr4IntegratedAppPool"> <virtualDirectory path="/" physicalPath="C:\!Project\MonSite" /> </application> <bindings> <binding protocol="https" bindingInformation="*:44300:localhost" /> </bindings> </site>
remplaçons le binding afin que le site soit servi quelque soit l'ip sur laquelle arrive la requete
<site name="MonSite" id="10"> <application path="/" applicationPool="Clr4IntegratedAppPool"> <virtualDirectory path="/" physicalPath="C:\!Project\MonSite" /> </application> <bindings> <binding protocol="https" bindingInformation="*:44300:*" /> </bindings> </site>
Cela se fait via la ligne de commande suivante, a executée dans une console en mode admin.
netsh http add urlacl url=https://*:44300/ user=everyone
Note : pour ceux qui travaillent sur un windows en français il faudra alors taper
netsh http add urlacl url=https://*:44300/ user="tout le monde"
De nouveau une commande à exécuter via une console en mode admin :
netsh firewall add portopening TCP 44300 IISExpressWeb enable ALL
Voila, j'espère que cette astuce pourra vous éviter de rester coincé si vous devez exposer un site hebergé sur votre machine de dev
Ça faisait longtemps que je n'avais pas remis les mains dans ce projet, plus d'un an pour être exact. Le passage à Entity Framework 5 n'avait pas posé de soucis car aucun breaking changes dans l'API n'avait bloqué l'utilisation de la librairie. C'est surement ce qui explique le nombre "plutôt important" (7500) download sur nuget gallery.
Mais avec EF 6 c'est une autre histoire, tout un tas de nouvelles fonctionnalités très sympa, mais aussi une api qui a pas mal bougé... ainsi plusieurs utilisateurs sur codeplex, m'ont tout naturellement contacté pour me demander de mettre à jour EntityFramework.Patterns.
C'est chose faite, la version 0.8 est désormais disponible via nuget ou sous forme binaire et est compatible avec la dernière version d'EF
Ça signifie que mes chers utilisateurs vont pouvoir profiter des gains de performances apportées par EF 6; Quant au projet sur lequel je travaille actuellement, j'espère bien upgrader EF dès demain... Romain, si tu m'entends :p
Dans un avenir proche, je pense ajouter un bout d'API asynchrone aux repository d'EntityFramework.Patterns.
Bon upgrade de package !!
Il y a quelques jours je tweetais de joie, après être tombé sur la msdn concernant TPL.Dataflow
L'API propose un système de pipeline que l'on peut aisément imaginer utiliser dans un process d'ETL.
Ni une ni deux, je m'imagine délaisser SSII lors de mes prochaines alims de base de données et enfin pouvoir unit tester mon ETL.
L'accueil fait par mes collègues purement BI fut plutôt frileux... n'est ce pas David :)
Au rayon des réponses constructives, Fred Brossard, me fait revenir très vite sur terre, en demandant à voir les perfs du framework.
C'est ce que je me propose de présenter ici avec un exemple simple.
L'idée est d'importer le snapshot de septembre des posts de stackoverflow; d'abord avec notre bon vieux SSIS puis avec TPL.Dataflow.
En entrée on a donc un bon gros fichier XML de 170MO correspondant aux nouveaux posts du mois.
Commençons par SSIS, rien de sorcier, une XML source qui se déverse directement dans une SQL Destination pointant vers ma jolie table.
Ce qui nous donne env. 150K lignes intégrées en env. 20 sec
Ok, passons à la version C#. Ce que je vous livre ici est une version non optimisée et naive d'un algo d'import avec TPL.Dataflow.
Commencons par créer nos taches :
// XML datasource
var inputBlock = new BufferBlock<XDocument>();
// Split xml, one for each <row> element
var xDocumentToXmlRow = new TransformManyBlock<XDocument, XElement>(
x => x.Root.DescendantNodes().OfType<XElement>());
// Convert xml <row> element to a Post object.
var xmlRowToObjectBlock = new TransformBlock<XElement, Post>(
x => x.FromXElement<Post>(),
new ExecutionDataflowBlockOptions {MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded});
// a buffer of 10000 elements
var batch = new BatchBlock<Post>(10000);
// SQL destination, using bulk insert.
var sqlBulk = new ActionBlock<Post[]>(x =>
{
using (SqlBulkCopy sbc = new SqlBulkCopy("Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=Stackoverflow;Data Source=(local)", SqlBulkCopyOptions.TableLock))
{
sbc.DestinationTableName = "Posts";
// Number of records to be processed in one go
sbc.BatchSize = 10000;
// commit to the server
sbc.WriteToServer(x.ToList().ToDataTable());
sbc.Close();
}
},
new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded });
using (inputBlock.LinkTo(xDocumentToXmlRow))
using (xDocumentToXmlRow.LinkTo(xmlRowToObjectBlock))
using (xmlRowToObjectBlock.LinkTo(batch))
using (batch.LinkTo(sqlBulk))
{
inputBlock.Completion.ContinueWith(t => xDocumentToXmlRow.Complete());
xDocumentToXmlRow.Completion.ContinueWith(t => xmlRowToObjectBlock.Complete());
xmlRowToObjectBlock.Completion.ContinueWith(t => batch.Complete());
batch.Completion.ContinueWith(t => sqlBulk.Complete());
var inputfile = XDocument.Load(@"C:\!PoC\Stackoverflow\Sourcefiles\Posts.xml");
inputBlock.Post(inputfile);
inputBlock.Complete();
sqlBulk.Completion.Wait();
}
Je suis sur que vous êtes aussi étonnés que moi... TPL est plus rapide (de quelques 15%) par rapport à SSIS dans ce cas simple.
Pour être tout à fait franc, je ne m'y attendais pas du tout. Je pensais qu'il y aurait vraisemblablement une 20 aine de % d'écart, mais en faveur de SSIS.
Bien que cet exemple simplissime ne puisse pas permettre de généraliser, TPL.Dataflow semble apporter des performances suffisantes, si non meilleures qu'SSIS;
mais surtout, cet API va nous permettre d’écrire des tests unitaires sur nos jobs d'intégration. C'est ce que je vous présenterai dans un prochain article.
Et vous, avez vous déjà utilisé TPL.Dataflow? Pourriez-vous l'utiliser dans vos projets? A la lumière de ce post, que pensez vous de ces performances?
Malgré la version 5 d'Entity Framework sortie il y a peu de temps, beaucoup déplorent l’absence d’un mécanisme de cache implémenté dans le Framework.
Pour ceux qui ont un peu creusé le sujet, il y a bien les "Tracing and Caching Provider Wrappers for Entity Framework" parus début 2011. Cependant, ce n’est pas la solution ultime ; à l’époque Code First n’existait pas ce qui rend cette librairie incompatible avec Code First.
Pour être tout à fait franc, le code des wrappers est disponible, je pense donc qu’en bidouillant un peu, ça doit être possible d’adapter le code pour Code First.
A l’occasion de la sortie d’EntityFramework.Patterns 0.7, je vous propose de voir ensemble comme utiliser les fonctionnalités de cache fournies par cette librairie.
Soit le contexte suivant :
public class EfContext : DbContext
{
public DbSet<User> Users { get; set; }
public EfContext()
{
Database.SetInitializer(new DropCreateDatabaseIfModelChanges<EfContext>());
}
}
Et l’entité User tel que :
public class User
{
public int Id { get; set; }
public string Name { get; set; }
public virtual ICollection<UserRole> UserRoles { get; set; }
}
On peut facilement utiliser le cache en mémoire (il est possible d’en utiliser d’autre) fournit par EntityFramework.Patterns pour mettre en cache une collection de User.
// On charge tous les users et on les stocke dans le cache.
using (EfContext ctx = new EfContext())
{
IEnumerable<User> usrs = ctx.Users.ToCache();
}
// autre code...
// Cette fois ci, on récupère les users à partir du cache.
using (EfContext ctx = new EfContext())
{
IEnumerable<User> usrs = ctx.Users.FromCache();
}
Simple non ?
Pour ceux qui préfèrent éviter l’accès direct au context d’Entity Framework et qui isolent leur accès à la base dans des repository, EntityFramework.Patterns vous facilitera la tâche également.
Il vous suffit de wrapper votre Repository
using (EfContext ctx = new EfContext())
{
DbContextAdapter adpt = new DbContextAdapter(ctx);
IRepository<User> repo =
new CacheableRepository<User>(
new Repository<User>(adpt)
);
// On charge tous les utilisateurs.
// Par defaut le CacheableRepository va mettre en cache le resultset
// en provenance de la base et le réutilisera le cas échéant plus tard.
IEnumerable<User> usrs = repo.GetAll();
// autre code.
// Cette fois-ci, les users proviennent du cache. Il n'y a pas d'accès en base.
usrs = repo.GetAll();
}
Comme vous le voyez le CacheableRepository fait appel au cache pour vous ; et vous permet de ne pas avoir à gérer la suppression d’éléments dans le cache lorsque les éléments ont étés modifiés/supprimés/insérés etc…
Je reviendrais ultérieurement dans un prochain post sur les mécanismes avancés du cache proposés par EntityFramework.Patterns.
public class RoleProviderDecorator<TSurrogateRoleProvider> : RoleProvider
where TSurrogateRoleProvider : RoleProvider, new()
{
protected TSurrogateRoleProvider _surrogate;
public override void Initialize(string name, NameValueCollection config)
{
if (config == null)
throw new ArgumentNullException("config");
base.Initialize(name, config);
_surrogate = new TSurrogateRoleProvider();
InitializeInnerProvider(_surrogate, name, config);
}
protected virtual void InitializeInnerProvider(RoleProvider innerProvider, string name, NameValueCollection config)
{
innerProvider.Initialize(name, config);
}
public override bool IsUserInRole(string username, string roleName)
{
return _surrogate.IsUserInRole(username, roleName);
}
public override string[] GetRolesForUser(string username)
{
return _surrogate.GetRolesForUser(username).ToArray();
}
public override void CreateRole(string roleName)
{
_surrogate.CreateRole(roleName);
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
return _surrogate.DeleteRole(roleName, throwOnPopulatedRole);
}
public override bool RoleExists(string roleName)
{
return _surrogate.RoleExists(roleName);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
_surrogate.AddUsersToRoles(usernames, roleNames);
}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
_surrogate.RemoveUsersFromRoles(usernames, roleNames);
}
public override string[] GetUsersInRole(string roleName)
{
return _surrogate.GetUsersInRole(roleName).ToArray();
}
public override string[] GetAllRoles()
{
return _surrogate.GetAllRoles().ToArray();
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
return
_surrogate.FindUsersInRole(roleName, usernameToMatch).ToArray();
}
public override string ApplicationName
{
get { return _surrogate.ApplicationName; }
set { _surrogate.ApplicationName = value; }
}
}
public abstract class UnionRoleProvider<TPrimaryRoleProvider, TSecondaryRoleProvider> : RoleProviderDecorator<TPrimaryRoleProvider>
where TPrimaryRoleProvider : RoleProvider, new()
where TSecondaryRoleProvider : RoleProvider, new()
{
private TSecondaryRoleProvider _secondSurrogate;
public override void Initialize(string name, NameValueCollection config)
{
if (config == null)
throw new ArgumentNullException("config");
base.Initialize(name, config);
_secondSurrogate = new TSecondaryRoleProvider();
InitializeInnerProvider(_secondSurrogate, name, config);
}
public override bool IsUserInRole(string username, string roleName)
{
return _surrogate.IsUserInRole(username, roleName) || _secondSurrogate.IsUserInRole(username, roleName);
}
public override string[] GetRolesForUser(string username)
{
return _surrogate.GetRolesForUser(username).Union(_secondSurrogate.GetRolesForUser(username)).ToArray();
}
public override void CreateRole(string roleName)
{
_surrogate.CreateRole(roleName);
_secondSurrogate.CreateRole(roleName);
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
return _surrogate.DeleteRole(roleName, throwOnPopulatedRole) && _surrogate.DeleteRole(roleName, throwOnPopulatedRole);
}
public override bool RoleExists(string roleName)
{
return _surrogate.RoleExists(roleName) || _secondSurrogate.RoleExists(roleName);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
_surrogate.AddUsersToRoles(usernames, roleNames);
_secondSurrogate.AddUsersToRoles(usernames, roleNames);
}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
_surrogate.RemoveUsersFromRoles(usernames, roleNames);
_secondSurrogate.RemoveUsersFromRoles(usernames, roleNames);
}
public override string[] GetUsersInRole(string roleName)
{
return _surrogate.GetUsersInRole(roleName).Union(_secondSurrogate.GetUsersInRole(roleName)).ToArray();
}
public override string[] GetAllRoles()
{
return _surrogate.GetAllRoles().Union(_secondSurrogate.GetAllRoles()).ToArray();
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
return
_surrogate.FindUsersInRole(roleName, usernameToMatch)
.Union(_secondSurrogate.FindUsersInRole(roleName, usernameToMatch))
.ToArray();
}
}
public class ReadOnlyRoleProvider<TSurrogateRoleProvider> : RoleProviderDecorator<TSurrogateRoleProvider>
where TSurrogateRoleProvider : RoleProvider, new()
{
public override void CreateRole(string roleName){}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
return true;
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames){}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames){}
<roleManager enabled="true" defaultProvider="MyRoleProvider">
<providers>
<clear/>
<add name="MyRoleProvider " type="Providers.MyRoleProvider " connectionStringName="cnx" applicationName="MyApp" />
</providers>
</roleManager>
public class MyRoleProvider : UnionRoleProvider<SqlRoleProvider, SilentWindowsTokenRoleProvider<WindowsTokenRoleProvider>>
{
protected override void InitializeInnerProvider(RoleProvider innerProvider, string name, NameValueCollection config)
{
NameValueCollection cfg = config;
if (innerProvider is ReadOnlyRoleProvider<WindowsTokenRoleProvider>)
{
cfg = new NameValueCollection(config);
cfg.Remove("connectionStringName");
}
base.InitializeInnerProvider(innerProvider, name, cfg);
}
}
public class SilentWindowsTokenRoleProvider<TSurrogateRoleProvider> : ReadOnlyRoleProvider<TSurrogateRoleProvider>
where TSurrogateRoleProvider : RoleProvider, new()
{
public override string[] GetUsersInRole(string roleName)
{
return new string[]{};
}
public override string[] GetAllRoles()
{
return new string[]{};
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
return new string[]{};
}
}
Cela fait des mois que je repousse la publication d'un post sur l'AOP, car je ne voulais pas vous resservir le sempiternel exemple de mise en place d'une gestion de log applicatif simplifiée.
Si vous voulez vous rafraichir les idées sur le sujet je vous conseille de jeter un œil sur l'article d'Ayende Rahien sur le sujet
public interface IAuditable
{
string CreatedBy { get; set; }
DateTime Created { get; set; }
string UpdatedBy { get; set; }
DateTime? Updated { get; set; }
}
Install-Package EntityFramework Install-Package Afterthought
En attendant qu'un de mes patch soit accepté et intégré à Afterthought, il vous faudra remplacer la dll d'Afterthought par la mienne disponible ici.
public class AuditableAmender<T> : Amendment<T, T>
{
public AuditableAmender()
{
Properties.Add<string>("CreatedBy");
Properties.Add<DateTime>("Created");
Properties.Add<string>("UpdatedBy");
Properties.Add<DateTime?>("Updated");
Implement<IAuditable>();
}
}
[AttributeUsage(AttributeTargets.Class)]
public class AuditableAttribute : Attribute { }
[AttributeUsage(AttributeTargets.Assembly)]
public class AmendAttribute : Attribute, IAmendmentAttribute
{
IEnumerable<ITypeAmendment> IAmendmentAttribute.GetAmendments(Type target)
{
if (target.GetCustomAttributes(typeof(AuditableAttribute), true).Length > 0)
{
ConstructorInfo constructorInfo = typeof(AuditableAmender<>).MakeGenericType(target).GetConstructor(Type.EmptyTypes);
if (constructorInfo != null)
yield return (ITypeAmendment)constructorInfo.Invoke(new object[0]);
}
}
}
En clair, pour chaque classe qui implémente IAuditable, on va faire appel à la classe AuditableAmender (créée précédemment) pour modifier la classe.[Auditable]
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
}
public class Context : DbContext
{
public virtual DbSet<Product> Products { get; set; }
public Context()
{
Database.SetInitializer(new DropCreateDatabaseIfModelChanges<Context>());
}
}
SignalR is awesome ! Oui il va falloir vous habituer à entendre dire que cette librairie est un petit bijou.
Mais qu'est-ce qu'elle a de si bien cette librairie SignalR ?
SignalR fournit une couche d'abstraction au-dessus des WebSocket et des long polling connections pour les développeurs .NET et fonctionne sous IIS sans avoir à installer un autre service à côté.$(function () {
var stockExchangeServer = $.connection.stockExchange;
stockExchangeServer.drawShareValue = function (id, content) {
if (id != this.Id) {
return;
}
// set up the updating of the chart.
var series = chart.series[0];
var x = new Date(parseInt(content[0].Date.substr(6))).getTime(),
y = content[0].Price;
series.addPoint([x, y], true, true);
};
$.connection.hub.start(function () {
stockExchangeServer.connect();
.done(function (success) {
if (success === false) {
console.log(":(");
}
console.log("connected");
});
});
});
$.connection.hub.start(); connect; nous implémenterons cette dernière côté serveur.... oui vous avez bien lu, côté serveur.drawShareValue() qui se charge de dessiner un nouveau point dans le chart, nous ferons appel à elle dans le code serveur.public class StockExchange : Hub
{
private Timer _timer;
private double _fowlerPrice = 10.2;
private double VaryPrice()
{
Random rnd = new Random();
_fowlerPrice = _fowlerPrice + (rnd.Next(-1, 2) * rnd.NextDouble());
return _fowlerPrice;
}
public bool Connect()
{
// Set unique id for client.
Caller.Id = Context.ClientId;
_timer = new Timer { Interval = 1000 };
_timer.Elapsed += (sender, e) => Send(
new List<SharePrice>(new[]
{
new SharePrice
{
Date = DateTime.Now,
Price = VaryPrice(),
Share = new Share {Name = "Fowler-Corp"}
}
}));
_timer.Start();
return true;
}
public void Send(IEnumerable<SharePrice> sp)
{
Clients.drawShareValue(Context.ClientId, sp);
}
}
Je vous propose un très rapide post pour faciliter la prise en main des Patterns Repository
Pour simplifier le sujet, le but du pattern Repository est de donner au développeur une passerelle de requêtage unifiée, via des opérations (le plus souvent) atomiques. Unit Of Work, est la quant à lui pour valider transactionnellement un ensemble de modifications faites sur les données.
Pour la version longue vous pourrez trouver votre bonheur sur le site de Martin Fowler ici pour le Repository et ici pour Unit Of Work
Partons d'un modèle simplissime comme celui ci-dessous :
public class Context : DbContext
{
public virtual DbSet<Product> Products { get; set; }
public virtual DbSet<ProductCategory> Categories { get; set; }
public Context()
{
Database.SetInitializer(new DropCreateDatabaseAlways<Context>());
}
}
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public int? ProductCategoryId { get; set; }
public virtual ProductCategory ProductCategory { get; set; }
}
public class ProductCategory
{
public int Id { get; set; }
public string Name { get; set; }
}
Commençons par créer le Repository
using(Context ctx = new Context())
{
DbContextAdapter adapter = new DbContextAdapter(ctx);
IRepository<Product> productRepo = new Repository<Product>(adp);
...
}
Interrogeons la base pour ramener l'ensemble des produits :
IEnumerable<Product> lst = productRepo.GetAll();
Ramenons le premier élément dont le nom commence par "Bike"
Product prod = productRepo.First(p => p.Name.StartsWith("Bike"));
L'utilisation de la méthode Single a pour effet de ramener un seul élément de la base de données; mais lève une exception si plusieurs éléments répondent aux critères demandés.
productRepo.Single(p => p.Name.StartsWith("Roc"))
Find(), permet de filtrer en fonction de plusieurs critères :
IEnumerable<Product> lst = productRepo.Find(
p => p.Id < 100 && p.Name.Contains("o") && p.Name.Length < 20);
Toutes ces méthodes acceptent optionnellement un ensemble de liens de navigation inter entités
params Expression<Func<T, object>>[] includePropertiesdéfinissant les jointures à effectuer lors du requêtage. Ainsi :
productRepo.First(p => p.ProductCategoryId != null , p => p.ProductCategory);charge le produit et sa catégorie associée en une seule requete SQL; Cette façon de faire nous protège du fameux problème du Select N+1 lié au lazy loading utilisé par défaut avec Entity Framework.
Après l’interrogation de la base passons a la persistance de nos données. Pour cela nous allons faire appel au pattern UnitOfWork. L'insertion d'un nouvel élément prend cette forme :
using(...)
{
...
IUnitOfWork unitOfWork = new UnitOfWork(adp);
Product p = new Product{Name = "Skateboard"};
productRepo.Insert(p);
unitOfWork.Commit();
}
Vous l'aurez compris la mise à jour et la suppression sont aussi simple que ca :
Product p = productRepo.First(c => c.Name == "Bike");
p.Name = "New bike";
productRepo.Update(p);
Product delete = productRepo.First(p => p.Name.StartsWith("To be"));
productRepo.Delete(delete);
unitOfWork.Commit();
Dans les prochains jours je vous montrerais comment injecter Repository et Unit of work dans une couche Service par exemple avec un conteneur DI comme NInject.
