#StructureMap

[mindfiresolutions-blog]

MEDICAL RECORDS MANAGEMENT

Executive Summary

The client for this project got us to build a system which allows individuals to store their medical records in a safe and secure manner. The system offers flexibility to its users to access their records anytime and from anywhere – provided they have access to internet. Besides having the provision to update records, the users have the prerogative to allow permission to people of their choice (i.e. physicians, providers, family members etc.) to access either full or parts of their records on a need basis.There are 3 subscription plans available and users are charged based on the features that they choose to use.

The system stands out for its ease of access and the high level of security. The importance of this system grows even more in times of emergency. It can potentially act as a life saver as there is scope for medical staff to be given access to a member’s medical records in such situations; thereby increasing the chances of providing accurate medical care.

About our Client

Client: Confidential

Location: Kansas, USA

Industry: Healthcare IT

Technologies

Asp.net MVC 4.0, C#, Entity Framework, Razor, HTML5, JQuery, Bootstrap, CSS3, Repository pattern, StructureMap, WinSCP, WPF, WCF, SqlServer2008R2, Window Service. Third-Party API: PayPal, Authorize.Net, RSOAPI.

Download Full Case Study

[cliveciappara]

The correct way to implement StructureMap in .NET Core WebApi when having multiple projects

The correct way to implement #StructureMap in .NET Core #WebApi when having multiple projects #devs #devtips

StructureMap is an IoC/DI container for .Net which has been a long time around. I’ve been using it for these past few years, and after all this time, I found out the correct way to implement it.

This is how I used it before and I’m sure the majority of you are currently using the same methods. In the Registry, I would register each interface and it’s inherited class by calling a “config.for” for…

[erossiniuk]

Xamarin Forms Dependency Injection

Calling native platform code in your portable class library (PCL) is achievable via Dependency Injection. It’s a common question for people starting out, who are using a PCL or .NET Standard Library for developing their Xamarin apps. Dependency Injection involves creating an interface that can be commonly applied across all native platforms, then coding the actual implementation, or the native platform code, on each platform. This interface and instance is then given to a container. The PCL or .NET Standard Library, then goes to the container with only the interface known, to retrieve the instance. It doesn’t know where the instance came from, just that it has a specific interface.

Xamarin Dependency Injection

Interface

The first thing we must do to enable dependency injection is define an interface. For this example, lets say we have to get a unique identifier for the mobile phone. There are specific calls you can make on a each platform to get this, but its not available in our PCL. Hence we would define this interface to return a string of unique identifier.

public interface IDeviceInfo { string GetUniqueIdentifier(); }

This interface would be placed in your PCL and hence accessible from your PCL and each platform project.

Implementation

Next we need to actually define the implementation of this interface in each platform.

iOS

public class DeviceInfo : IDeviceInfo { public string GetUniqueIdentifier() { return UIDevice.CurrentDevice.IdentifierForVendor.AsString(); } }

Android

public class DeviceInfo : IDeviceInfo { public string GetUniqueIdentifier() { return Android.Provider.Settings.Secure.GetString(Xamarin.Forms.Forms.Context.ContentResolver, Android.Provider.Settings.Secure.AndroidId); } }

UWP

public class DeviceInfo: IDeviceInfo { public string GetUniqueIdentifier() { var token = HardwareIdentification.GetPackageSpecificToken(null); var hardwareId = token.Id; var dataReader = Windows.Storage.Streams.DataReader.FromBuffer(hardwareId); byte[] bytes = new byte[hardwareId.Length]; dataReader.ReadBytes(bytes); return BitConverter.ToString(bytes); } }

Dependency Injection Container Registration

Next we want to register this implementation with the Dependency Injection Framework. For this example, I will just use Xamarin Forms inbuilt dependency injection container. Place the following above each implementation of the DeviceInfo, above the namespace declaration.

[assembly: Xamarin.Forms.Dependency(typeof(DeviceInfo))] namespace Mobile.Platform { ...

You can also register it via a line of code, and this is actually need for UWP, as the assembly registration has issues with UWP under Native Compilation.

Xamarin.Forms.DependencyService.Register<DeviceInfo>();

Retrieve Dependency

Lets now retrieve that dependency in code. All we need to do is call this line, referencing the interface we want the implementation of.

DependencyService.Get<IDeviceInfo>().GetUniqueIdentifier();

Now we can call the GetUniqueIdentifier and it will return a string. The PCL or .NET Standard Library doesn’t know anything about the platform, and just interact with the instance via the interface definition.

AutoFac

The Xamarin Forms Dependency Service is a nice simple dependency injection framework, but it lacks many features, including the ability to do constructor injection. Using something more advanced such as AutoFac offers you many more features. There are many other Dependency Injection Frameworks out there, and they all provide very similar functionality.

To create the container, implement the following code.

ContainerBuilder _builder = new ContainerBuilder();

Now you can add dependencies as needed.

_builder.RegisterInstance<IDeviceInfo>(new DeviceInfo()).SingleInstance();

Finally you need to call the Build function to finish the building of the container.

_builder.Build();

The Container should be accessible in the PCL and native platforms, as is the interface. Similar to Xamarin Forms implementation, you can also get the

Constructor Injection

The benefits of using a Dependency Injection Framework such as AutoFac, is you can inject dependencies into a constructor. For example.

public class MyViewModel { private readonly IDeviceInfo _deviceInfo; public MyViewModel(IDeviceInfo deviceInfo) { _deviceInfo = deviceInfo; } }

If you had registered your ViewModel and DeviceInfo, in AutoFac, when AutoFac creates an instance of your ViewModel, it will automatically detect constructors with parameters and try to fill them in as needed. This has immense benefits for readability and unit testing. No longer is a dependency in your class, hidden via a line of code, its clearly apparent, as you can only create the class, if you inject the dependency into it.

Other Frameworks

You might be wondering what other frameworks are out there. First they are some MVVM frameworks that come with one included such as FreshMVVM and MVVMLight. If you prefer to keep your MVVM frameworks and Dependency Injection Framework separate, you can also use Ninject, TinyIoc, Unity, Castle Project, StructureMap and Spring.NET, just to name a few. You can do some research to find the one that best meets your needs. Personally, I prefer AutoFac, as its recent speed improvements, along with powerful interface, features and maturity make it great to work with.

The post Xamarin Forms Dependency Injection appeared first on PureSourceCode.

from WordPress https://www.puresourcecode.com/dotnet/xamarin/xamarin-forms-dependency-injection/

[windwardsouth-blog]

For just $799.00 Free C-MAP MAX-N+ Wide Coastal or C-MAP MAX-N+ Wide Coastal Chart ($299) w/Qualifying Purchases UNTIL 10/31/2018 VIEW Elite-7 Ti Bundle w/Med/High Skimmer Ducer, StructureScan-HD Ducer & Y-Cable 7" Fishfinder/Chartplotter with high-bright, LED-backlit display with CHIRP, DownScan™ and StructureScan™ technology, built-in Features: Single-touch 7" Widescreen Built-in CHIRP/Broadband Sounder Built-in StructureScan™ (with TotalScan transducer) Built-in 10Hz GPS/GLONASS antenna Built-in Wireless connectivity Built-in Bluetooth connectivity Xi5 Trolling Motor control via Lowrance SmartSteer™ Best-in class screen brightness Single micro SD card slot NMEA 2000® connectivity Wide selection of cartography options Uses Quick Release Bracket Selling Points: Lowrance SmartSteer™ Technology for Xi5 Trolling Motor control Stand alone Fishfinder/Chartplotter Built in Detailed Basemap cartography (Americas models) and Navionics Basemap (Americas and ROW) Add on cartography available from Insight HD™, Navionics, Jeppesen C-MAP and other 3rd Party Toolkit Partners Share waypoint data via NMEA 2000® with other displays Fully customizable split-screen options StructureMap included with built-in StructureScan (requires optional TotalScan transducer) Specifications: Display Size: 7in (178mm) Diag. Display Type: WVGA color TFT LCD Resolution: 800H x 480W Backlight: Pure White LED Display Brightness: 1200 Nits Height6.332in (160.83mm) Width: 8.641" (219.48mm) Depth: 2.507" (63.68mm) Weight: 3.04lb (1.38kg) Operating Temperature: 5°F to 131°F (-15°C to 55°C ) Waterproof: IPX7 with card door closed DOC: Part 15.103 FCC rules & CE RTTE directive 1999/5/EC Current Draw: 0.9A @ 13VDC with backlight on full Operating Voltage: 12VDC Supply Voltage: 10.8-17VDC Interface: Single-touch touchscreen and Limited Keypad; ZOOM +/-,WPT,LIGHT/POWER Display Modes: North up, Course up (COG), Heading up (heading with external heading sensor or COG) Built-in Cartography: Detailed Base...

[bashcorp]

Code Extensibility

Another little snippet on code standards to help make code better!

Coding or Extensibility of one of the goals of the SOLID development pillars:

Single Responsibility Principle

Open-Closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Injection Principle

These principles are designed to lead to code that is easily extendable, easily tested and localises changes to one place in the code-base.

What is code extensibility?

Simply, the ability to take an existing piece of logic and use it to solve a problem without copy-pasting (and creating duplicate code, with its associated maintenance overhead) and without breaking things the code already does.

Consider a function that adds up two numbers. We may want to extend it so it can cope with adding negative numbers also, but we don't want to break it so it no longer adds positive numbers and we don't want to write another 'Add' function.

Single Responsibility Principle

To keep code extensible, testable and readable (lean) we should consider the Single Responsibility Principle. A piece of code should do one thing and do that one thing well.

A function that adds up should do adding, it shouldn't also do multiplication. A class that reads customers from a database shouldn't also write out HTTP cookies. A namespace for Validation shouldn't also handle CRM/Sitecore integration.

SRP keeps code lean, focused and more easily understandable.

Open-Closed Principle

Code should be open for extension and closed for modification. This is a principle focused on adding new features without breaking what's there.

If a new use-case appears that involves changes to code, eg maybe business customers get a different discount process than home customers, then we should leave the existing logic alone.

This will prevent our breaking things for existing customers and processes.

We can then extend the existing logic using normal Object-Oriented inheritance, functional-style Composition or amendments to our IoC container to build this new logic.

For example, if we have a PurchaseDiscount class we might inherit from it to create BusinessPurchaseDiscount and HomePurchaseDiscount. That way, anywhere in the code still using PurchaseDiscount will be unaffected and the system will not break. It keeps regression errors to a minimum.

We can then, at our leisure, update the code to use the new extended code to implement the new behaviour.

Liskov Substitution Principle

This rule states that wherever a parent class is used, an inheriting class should be able to be substituted without breaking the system.

Supposing I have a class that calculates BasketTotal. It takes an array of items and calculates their prices. Suppose then that we inherit from it to create BusinessBasketTotal that calculates prices and applies a business discount.

Anywhere I use BasketTotal, I should in theory be able to substitute BusinessBasketTotal. However, if BasketTotal has a property float total and BusinessBasketTotal implements its own BusinessTotal and overrides the total property from its parent and always returns -1 instead of the total, then this would break the Liskov Substitution principle.

public class BasketTotal {  public float Total { get; private set; }

 public virtual void Sum(BasketItem[] items)  {    Total = 0f;    foreach(var item in items)    {      Total += item.Price;    }  } }

public class BusinessBasketTotal : BasketTotal {  // Don't need this because it's a business basket?  public override float Total => -1f;  // Return a business basket total instead  public float BusinessTotal {get; private set; }

 public virtual void Sum(BasketItem[] items)  {    BusinessTotal = 0f;    foreach(var item in items)    {      BusinessTotal += item.BusinessPrice;    }  } }

It would not be possible to use BusinessBasketTotal in place of BasketTotal because the former breaks the design of the latter by returning a -1 for price.

This is a bad idea because it's likely to lead to weird behaviour in the system: .Net will happily allow BusinessBasketTotal in place of BasketTotal, but that will break our logic. What should be done instead is to have BusinessBasketTotal respect the interface set out in BasketTotal and set the Total property correctly.

Interface Segregation Principle

An important part of being able to compose objects together to solve bigger problems is being able to refer to them by interface. Interfaces offer advantages to the traditional inheritance model of OO software, behaving more like interchangeable Lego bricks.

If you want a class to do something different in place of another, write a new class that implements the same interface and use it instead.

This leaves an important design consideration when planning interfaces: keep them focused and not too big. It closely relates to the Single Responsibility Principle.

Let's say I have a ICustomerSaver, an interface that has the sole purpose of persisting a customer object to storage somewhere. If I write a class to implement that interface, I'd expect to write methods like Save.

Supposing I implement that interface in my class, and I am asked to write methods for Serialize, GetFromDB or CheckOrders. What has happened is that this interface does not follow the good design principle of Interface Segregation.

I implemented the ICustomerSaver interface because I wanted a class that could save Customer objects in a new way- I should not be implementing serialisation, database access or order management methods. They should be separate interfaces (eg ISerializable, IDbAccess and IOrderManager) that I choose to implement if I need them.

Dependency Injection Principle

The final step for extensible, readable and testable code is the Dependency Injection Principle. This means that if I have one class that depends on another for its logic, then that dependency should be passed in (ie injected).

public class CustomerManager {  public void Save(Customer customer)  {    var database = new CustomerDatabase();    database.Persist(customer);  } }

Consider the class above if we make changes to the CustomerDatabase object. Perhaps we add some constructor parameters, or want to replace it with a different class. We've now made a lot of work for ourselves if we want to make such changes because we'll need to change every place we use CustomerDatabase.

Suppose, instead, we injected it as a dependency:

public class CustomerManager {  public void Save(Customer customer, CustomerDatabase database)  {    database.Persist(customer);  } }

That's better: now it is the responsibility of whatever uses CustomerManager to supply the CustomerDatabase object as an argument. Presumably that will be down much farther up the stack, so there will be fewer places to change it if CustomerDatabase changes.

However, we can do better. CustomerManager is likely to have several methods, for example Save and Load. We could then pass CustomerDatabase as a constructor argument rather than as a method argument:

public class CustomerManager {  private CustomerDatabase database;

 public CustomerManager(CustomerDatabase database)  {    this.database = database;  }

 public void Save(Customer customer)  {    database.Persist(customer);  }

 public Customer Load(Guid customerId)  {    return database.Find(customerId);  } }

So we have now reduced duplication and followed better Single Responsibility: the constructor gathers dependencies and then individual methods use them to solve specific problems.

However, we still have the issue of changes to CustomerDatabase: supposing we follow the Open for Extension Principle and create a new database layer that we now want to use here? We must manually find and replace all CustomerDatabase instances with our new PersonDatabase object.

We can solve this by using Interfaces for our dependency injection. Consider:

public interface ICustomerPersistence {  Customer Find(Guid customerId);  void Save(Customer customer); }

public class CustomerManager {  private ICustomerPersistence database;

 public CustomerManager(ICustomerPersistence database)  {    this.database = database;  }

 public void Save(Customer customer)  {    database.Persist(customer);  }

 public Customer Load(Guid customerId)  {    return database.Find(customerId);  } }

Now CustomerManager will accept, without any changes whatsoever, any ICustomerPersistence implementer we choose to pass to it.

Using an IoC container (such as Unity, StructureMap, Ninject, AutoFaq or many others) we can even automate this in code, eg:

container.Register<ICustomerPersistence, PersonDatabase>(); container.Register<CustomerManager, CustomerManager>(); // ... var customerManager = container.Get<CustomerManager>(); // This will now work with everything done for us: customerManager.Load(customerId);

The IoC container will create a CustomerManager and, as long as it knows what to use for a ICustomerPersistence it will handle running the constructor for us. Swapping out to a different database is now a simple matter of writing a new class that implements ICustomerPersistence and changing that one line in the container registry!

[nisadmeras-blog]

f zillow 7407558786 black rash on lower leg online marketing academy timisoara stiri kristinehamns kommun telefon nummer finden celulas quiescentes o establesidas huawei u 80600 structuremap dbcontext dispose of tv florida computer engineering jobs baulift ingolstadt cold war cartoon...

http://numismatics.review/online-marketing-academy-timisoara-stiri/

[jobisite11]

Technical Lead

Austin, TX, United States Headspring

Headspring is a leading custom software, systems integration and mobile application development company. As a Technical Lead, you will deliver awesome software systems on the Microsoft Platform using Headspring?s proven consultative and collaborative processes. You will work in a supportive team environment ensuring our clients receive the best solutions to their toughest technology challenges. 

What will I do?

Define overall technical solutions that govern the development effort of any project

Develop project architecture, prototypes, and proofs of concepts

Own responsibility for first feature reference implementations, software configuration management decisions, and application of appropriate libraries and tools

Conduct code reviews, define internal application architecture and solve unique and unanticipated technology problems ahead of the rest of the development team

Develop customized business software on the .NET platform for a wide range of client projects across many industries

Analyze, design, code, test and deploy software on a variety of projects

What?s required to be able to succeed in this Technical Lead role?

Extensive experience defining technical solutions through the creation of successful application architecture

At least 6+ years hands-on development experience with .NET technologies that could include: C#, HTML5, CSS, jQuery, ASP.NET, MVC, WPF, NServiceBus, NHibernate or any other ORM, StructureMap, AutoMapper, Log4Net, psake, RoundHouse, Octopus, Nuget, ReSharper, TeamCity

Solid understanding and/or hands-on experience with database technologies that include SQL Server

Proven ability to quickly investigate, learn and deliver technical solutions

Proven ability to master new development tools and passion for learning

Exceptional communication, documentation and presentation skills

Why Headspring? Our fully loaded kitchen will keep you fueled throughout the day while you work side by side with some of the smartest and most passionate technical talent!  Weekly lunch & learns where your teammates will present cool and cutting-edge tech demonstrations. Quarterly off-sites will find you on city-wide scavenger hunts or racing go-karts or cave diving.  We?ve also got an awesome and very comprehensive benefits package. And we walk the walk with our Core Values.  And we win a lot of awards for being one of the best places to work! For a more inside scoop, please visit our Glassdoor page!  

TechnicalLead from Job Portal http://www.jobisite.com/extrJobView.htm?id=63027

[jobisitejobs]

Technical Lead

Austin, TX, United States Headspring

Headspring is a leading custom software, systems integration and mobile application development company. As a Technical Lead, you will deliver awesome software systems on the Microsoft Platform using Headspring?s proven consultative and collaborative processes. You will work in a supportive team environment ensuring our clients receive the best solutions to their toughest technology challenges. 

What will I do?

Define overall technical solutions that govern the development effort of any project

Develop project architecture, prototypes, and proofs of concepts

Own responsibility for first feature reference implementations, software configuration management decisions, and application of appropriate libraries and tools

Conduct code reviews, define internal application architecture and solve unique and unanticipated technology problems ahead of the rest of the development team

Develop customized business software on the .NET platform for a wide range of client projects across many industries

Analyze, design, code, test and deploy software on a variety of projects

What?s required to be able to succeed in this Technical Lead role?

Extensive experience defining technical solutions through the creation of successful application architecture

At least 6+ years hands-on development experience with .NET technologies that could include: C#, HTML5, CSS, jQuery, ASP.NET, MVC, WPF, NServiceBus, NHibernate or any other ORM, StructureMap, AutoMapper, Log4Net, psake, RoundHouse, Octopus, Nuget, ReSharper, TeamCity

Solid understanding and/or hands-on experience with database technologies that include SQL Server

Proven ability to quickly investigate, learn and deliver technical solutions

Proven ability to master new development tools and passion for learning

Exceptional communication, documentation and presentation skills

Why Headspring? Our fully loaded kitchen will keep you fueled throughout the day while you work side by side with some of the smartest and most passionate technical talent!  Weekly lunch & learns where your teammates will present cool and cutting-edge tech demonstrations. Quarterly off-sites will find you on city-wide scavenger hunts or racing go-karts or cave diving.  We?ve also got an awesome and very comprehensive benefits package. And we walk the walk with our Core Values.  And we win a lot of awards for being one of the best places to work! For a more inside scoop, please visit our Glassdoor page!  

TechnicalLead from Job Portal http://www.jobisite.com/extrJobView.htm?id=63027

[usajobsite]

Technical Lead

Austin, TX, United States Headspring

Headspring is a leading custom software, systems integration and mobile application development company. As a Technical Lead, you will deliver awesome software systems on the Microsoft Platform using Headspring?s proven consultative and collaborative processes. You will work in a supportive team environment ensuring our clients receive the best solutions to their toughest technology challenges. 

What will I do?

Define overall technical solutions that govern the development effort of any project

Develop project architecture, prototypes, and proofs of concepts

Own responsibility for first feature reference implementations, software configuration management decisions, and application of appropriate libraries and tools

Conduct code reviews, define internal application architecture and solve unique and unanticipated technology problems ahead of the rest of the development team

Develop customized business software on the .NET platform for a wide range of client projects across many industries

Analyze, design, code, test and deploy software on a variety of projects

What?s required to be able to succeed in this Technical Lead role?

Extensive experience defining technical solutions through the creation of successful application architecture

At least 6+ years hands-on development experience with .NET technologies that could include: C#, HTML5, CSS, jQuery, ASP.NET, MVC, WPF, NServiceBus, NHibernate or any other ORM, StructureMap, AutoMapper, Log4Net, psake, RoundHouse, Octopus, Nuget, ReSharper, TeamCity

Solid understanding and/or hands-on experience with database technologies that include SQL Server

Proven ability to quickly investigate, learn and deliver technical solutions

Proven ability to master new development tools and passion for learning

Exceptional communication, documentation and presentation skills

Why Headspring? Our fully loaded kitchen will keep you fueled throughout the day while you work side by side with some of the smartest and most passionate technical talent!  Weekly lunch & learns where your teammates will present cool and cutting-edge tech demonstrations. Quarterly off-sites will find you on city-wide scavenger hunts or racing go-karts or cave diving.  We?ve also got an awesome and very comprehensive benefits package. And we walk the walk with our Core Values.  And we win a lot of awards for being one of the best places to work! For a more inside scoop, please visit our Glassdoor page!  

TechnicalLead from Job Portal http://www.jobisite.com/extrJobView.htm?id=63027

[mcminton-blog-blog]

First Look: StructureMap

You did what to your IOC?

If you are unsure what an IOC container is or why you would use one you may want to skip this post. If you don't know what it is but have heard the term and wish to learn more, well this still isn't the post for you. This post is covering StructureMap, a popular IOC container and how to use it. This post is not an introduction to dependency injection. If you're looking for a quick primer check Wikipedia:

In object-oriented programming, the dependency inversion principle refers to a specific form of decoupling where conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are inverted (i.e. reversed) for the purpose of rendering high-level modules independent of the low-level module implementation details. via Wikipedia

StructureMap is

According to it's website:

StructureMap is a Dependency Injection / Inversion of Control tool for .Net that can be used to improve the architectural qualities of an object oriented system by reducing the mechanical costs of good design techniques. StructureMap can enable looser coupling between classes and their dependencies, improve the testability of a class structure, and provide generic flexibility mechanisms.

Perhaps a better definition is a magic container that can provide access to resource while avoiding a hard coupling between them.

Obtaining StructureMap

With Microsoft finally getting onboard with package managers, obtaining StructureMap is easier now than ever before. Just open your project in Visual Studio (with NuGet installed) and search the NuGet packages for StructureMap. Click the Install button and viola!

Initial Setup

Like all containers you have to configure StructureMap. This all happens at launch in a process called bootstrapping. If you've ever used an IoC container this part will be very straightforward. The foundation of StructureMap is the ObjectFactory. During the bootstrapping process you will call Initialize on ObjectFactory. It's at this point that you're basically using StructureMap as a fancy ServiceLocator for your special-need cases. Once these are define you can depend on StructureMap to "auto-wire" dependencies for you.

Uber Simple Example

public interface IComDevice { void SendMessage(string message); } public class MyComDevice : IComDevice { public void SendMessage(string message) { //Do stuff } } public class iPhone : MyComDevice { //iMessage stuff } public class Bootstrapper { ObjectFactory.Initialize(x => x.ForRequestedType() .TheDefaultIsConcreteType(); } public class SomeConcreteThingy() { var comDevice = ObjectFactory.GetInstance(); }

Coming from mostly using Castle I find StructureMap to be a little more modern and generally easier to configure. Of course there are many other options out there I just happen to be involved in a project that was using StructureMap. This led me to investigate it further and see how it compares. For an excellent and more detailed writeup check out Andrey Shchekin's series of posts Comparing .NET DI (IoC) Frameworks.

[hammerproject]

Reading Dependency Injection in .NET

So I sat down on the couch this morning with my new book Dependency Injection in .NET by Mark Seemann. I'm realy looking forward to this.

The reason for this post is more of a personal experiment. I'm interested in seeing how my expectations of the book will compare to my findings.

I certainly wouldn't call myself an expert on DI/IoC or great interface design in general. It was only recently that I learnt how bad Service Locator was. Yeh, it's ok, you can laugh. I do have what I think is a reasonable understanding of DI frameworks (I've been using StructureMap for a couple of years and more recently Autofac) but as I'm learning, that does not mean that I understand DI.

What I'm really hoping to get from this book is better design. It seems reasonable to me that DI and interface design is core to building maintainable applications; and it seems logical to infer that an application whose codebase is maintainable is designed well. Yes, I'm eager to learn more about IoC/DI but I'm much more excited to harness the underlying value or becoming a better designer [of code] rather than simply a consumer of best practises. 

I plan to follow up with some "lessons learned" -style posts as I progress through this book. Readify, my employer, has kindly allowed me PD days to do this so I want to "give back" something to the wider community in the hope that some of the nuggets of wisdom I acquire will be valuable to others.

[vu3lo]

Implementing IPriceService with default IPriceService as its dependency

In EPiServer Commerce prices are loaded via the IPriceService and IPriceDetailService. I needed to customise the IPriceService logic but just to tweak the price filtering and still intend to call the default IPriceService internally to reuse the base functionality.

This is where confusion ensues, how does one configure the dependency resolver (StructureMap) to return my custom price service implementation which itself has a dependency on the same IPriceService interface? Turns out StructureMap has a method called EnrichWith to achieve this.

So I have my implementation called “CustomPriceService” and the default EPiServer implmentation is “PriceServiceDatabase“. My CustomPriceService constructor looks like this:

public CustomPriceService(IPriceService defaultPriceService) { this._defaultPriceService = defaultPriceService; }

Now I have the local field _defaultPriceService that I can call for default functionality throughout my custom implementation and it still retains the injected abstraction for unit testing purposes.

To configure StructureMap all that is needed is:

container.For<IPriceService>().Use<PriceServiceDatabase>().EnrichWith((context, systemPriceService) => new CustomPriceService(systemPriceService));

When an IPriceService dependency is resolved StructureMap will get the default EPiServer Commerce “PriceServiceDatabase” and then create my “CustomPriceService” passing the PriceServiceDatabase into the constructor.

If your constructor needs other dependencies you can use the “IContext” that EnrichWith provides, for example:

container.For<IPriceService>().Use<PriceServiceDatabase>().EnrichWith((context, systemPriceService) => new CustomPriceService(systemPriceService, context.GetInstance<ICurrentMarket>()));

Hopefully this will help anyone trying to figure out how to get StructureMap to configure a dependency for a given type to itself have a dependency on the same type.

[daveschinkel]

In this episode we take a look at how to setup and configure StructureMap for dependency injection.

We will review how to configure your dependencies 2 different ways. First we will review how to use StructureMaps configuration Files and then we will review how to use the built in DSL syntax for wiring.

[windwardsouth-blog]

For just $2699.00 Free C-MAP MAX-N+ Wide Coastal or C-MAP MAX-N+ Wide Coastal Chart ($299) w/Qualifying Purchases UNTIL 10/31/2018 VIEWHDS-12 Carbon Chartplotter/fishfinder MFD with C-Map Insight Charts and TotalScan Transom Mount TransducerThe Lowrance® HDS-12 Carbon features a new 12-inch ultra-clear SolarMAX™ HD multi-touch display using high-bright LED backlighting and advanced anti-reflective coatings to create wider viewing angles in any lighting condition. Only in HDS Carbon will you find superior color accuracy and a boosted high-resolution viewing panels specifically designed to truly maximize today's leading sonar. Loaded with dual core high performance processor, HDS Carbon delivers faster redraw speeds and quicker response times for dual-channel CHIRP sonar, dual network sounder views, StructureScan 3D® and StructureMap™ plus split-screen views showing all this and mapping at the same time; it has enough reserve brute strength to drive future high powered fishfinding upgrades. HDS Carbon brings modern "smartphone-like" comfort with integrated wireless and Bluetooth® connectivity that supports the most advanced marine technology including a Network Analyzer that notifies user when a new software is available, a system Service Assistant that allows user to transmit a detailed report of their electronics network direct to technical advisors for custom hands-on assistance. HDS Carbon is the most versatile combo available today, it can view and control Mercuryr VesselView® Link, be paired with Power-Poler shallow-water anchors, and control SmartSteer™ trolling motor/outboard motors. An expansive list of safety and entertainment plug-ins are available to complete your network. You can navigate easily with HDS Carbon behind proven Lowrance expertise, a 10 Hz internal GPS antenna, built-in C-MAP, and a multitude of mapping options accessible from the unit's dual microSD card slots or via wireless download from GoFree® Shop.EASY TO SEE12-inch, LED-back...

[excodecowboy]

StackOverflow Excavations

StackOverflow Excavations

It’s fun to dig around StackOverflow to find interesting questions that haven’t been answered. This was one about StructureMap.

[windwardsouth-blog]

For just $2449.00 Free C-MAP MAX-N+ Wide Coastal or C-MAP MAX-N+ Wide Coastal Chart ($299) w/Qualifying Purchases UNTIL 10/31/2018 VIEWHDS-12 Carbon Chartplotter/fishfinder MFD with C-Map Insight Charts and No TransducerThe Lowrance® HDS-12 Carbon features a new 12-inch ultra-clear SolarMAX™ HD multi-touch display using high-bright LED backlighting and advanced anti-reflective coatings to create wider viewing angles in any lighting condition. Only in HDS Carbon will you find superior color accuracy and a boosted high-resolution viewing panels specifically designed to truly maximize today's leading sonar. Loaded with dual core high performance processor, HDS Carbon delivers faster redraw speeds and quicker response times for dual-channel CHIRP sonar, dual network sounder views, StructureScan 3D® and StructureMap™ plus split-screen views showing all this and mapping at the same time; it has enough reserve brute strength to drive future high powered fishfinding upgrades. HDS Carbon brings modern "smartphone-like" comfort with integrated wireless and Bluetooth® connectivity that supports the most advanced marine technology including a Network Analyzer that notifies user when a new software is available, a system Service Assistant that allows user to transmit a detailed report of their electronics network direct to technical advisors for custom hands-on assistance. HDS Carbon is the most versatile combo available today, it can view and control Mercuryr VesselView® Link, be paired with Power-Poler shallow-water anchors, and control SmartSteer™ trolling motor/outboard motors. An expansive list of safety and entertainment plug-ins are available to complete your network. You can navigate easily with HDS Carbon behind proven Lowrance expertise, a 10 Hz internal GPS antenna, built-in C-MAP, and a multitude of mapping options accessible from the unit's dual microSD card slots or via wireless download from GoFree® Shop.EASY TO SEE12-inch, LED-backlit, multi-touch, Sol...