StructureMap Dependencies for Arguments in Constructor

Question

If I have the following, and I were to say ObjectFactory.GetInstance<Master>() is it possible to tell StructureMap to make the I_A instance to A_User the same instance as the I_A passed to Master?

public interface I_A { }
public interface I_B { }

public class A_User {
    public A_User(I_A A) { }
}

public class Master {
    public Master(I_A _, I_B __, A_User ___) { }
}

Answer 1

UPDATED: As @Joshua Flanagan points out below, this is default SM behaviour. The following unit tests show that. The first tests uses the default behaviour. The second shows how you would get a unique instance if you wanted it:

using System;
using System.Collections.Generic;
using NUnit.Framework;
using StructureMap;
using StructureMap.Pipeline;

namespace SMTest
{
    [TestFixture]
    public class TestSOQuestion
    {

        class Foo : IFoo { }
        interface IFoo { }

        private interface IBar {
            IFoo Foo { get; set; }
        }
        class Bar : IBar
        {
            public IFoo Foo { get; set; }
            public Bar(IFoo foo)
            {
                Foo = foo;
            }
        }

        class UsesFooAndBar
        {
            public IBar Bar { get; set; }
            public IFoo Foo { get; set; }
            public UsesFooAndBar(IFoo foo, IBar bar)
            {
                Foo = foo;
                Bar = bar;
            }
        }

        [Test]
        public void TestOtherAnswer()
        {
            IContainer container = new Container(x =>
                                         {
                                             x.For<IFoo>().Use<Foo>();
                                             x.For<IBar>().Use<Bar>();
                                         });
            var usesFooAndBar = container.GetInstance<UsesFooAndBar>();
            Assert.AreSame(usesFooAndBar.Foo, usesFooAndBar.Bar.Foo);            
        }

        [Test]
        public void TestNonDefaultBehaviour()
        {
            IContainer container = new Container(x =>
                                         {
                                             x.For<IFoo>().AlwaysUnique().Use<Foo>();
                                             x.For<IBar>().Use<Bar>();
                                         });
            var usesFooAndBar = container.GetInstance<UsesFooAndBar>();
            Assert.AreNotSame(usesFooAndBar.Foo, usesFooAndBar.Bar.Foo); 
        }

    }
}

Answer 2

The default behavior of StructureMap will always give you the same instance within a "build session" (effectively, a single call to GetInstance). You should not have to configure anything extra to get the behavior you want.

If it is not working as you expect, please post more details, or mention it on the StructureMap mailing list.