private void Test01()
{
IUnityContainer container = new UnityContainer();
container.RegisterType <IPhone, AndroidPhone>(); //接口
container.RegisterType <AbstractPad, ApplePad>(); //抽象类
//container.RegisterType<ApplePad, ApplePadChild>();//子父类 会覆盖<AbstractPad, ApplePad>
container.RegisterType <AbstractPad, ApplePad>("child"); //1对多
container.RegisterType <AbstractPad, ApplePadChild>("grandchild"); //1对多
container.RegisterInstance <ITV>(new AppleTV()); //注册实例 但不常用
IPhone phone = container.Resolve <IPhone>();
AbstractPad abstractPad = container.Resolve <AbstractPad>();
AbstractPad childApplePad = container.Resolve <AbstractPad>("child");
AbstractPad grandchild = container.Resolve <AbstractPad>("grandchild");
}
//[ElevenInjectionConstructor]
public AndroidPhone(AbstractPad pad)
{
Console.WriteLine("{0}构造函数", this.GetType().Name);
}
public static void Show()
{
{
Console.WriteLine("=====Basic Usage of Unity=========");
IUnityContainer container = new UnityContainer(); //1. Declare a container
container.RegisterType <IPhone, AndriodPhone>(); //2. Initiate the container, register the type
// This is an interface
IPhone phone = container.Resolve <IPhone>(); //3. Create an object by reflection
phone.Call();
container.RegisterType <AbstractPad, ApplePad>(); // This is an abstract class
AbstractPad pad = container.Resolve <AbstractPad>();
pad.Show();
container.RegisterType <ApplePad, ApplePadChild>(); //This is an example of parent and child
ApplePad applePad = container.Resolve <ApplePad>();
applePad.Show();
//One to many
container.RegisterType <AbstractPad, ApplePad>("childPad"); //One to many, use alias
container.RegisterType <AbstractPad, ApplePadChild>("grandChildPad");
var childPad = container.Resolve <AbstractPad>("childPad");
var grandChildPad = container.Resolve <AbstractPad>("grandChildPad");
childPad.Show();
grandChildPad.Show();
//Register an instance
container.RegisterInstance <ITV>(new AppleTV(123));
var tv = container.Resolve <ITV>();
tv.Show();
Console.WriteLine("====End of basic utility===");
}
{
Console.WriteLine("====Dependency injection, implementing multi layer structure ====");
IUnityContainer container = new UnityContainer();
container.RegisterType <IPhone, ApplePhone>();
container.RegisterType <IMicrophone, Microphone>();
container.RegisterType <IPower, Power>();
container.RegisterType <IHeadphone, Headphone>();
container.RegisterType <IBaseDAL, BaseDAL>();
IPhone phone = container.Resolve <IPhone>();
phone.Call();
Console.WriteLine("====End of dependency injection====");
}
{
Console.WriteLine("====Life circly management====");
IUnityContainer container = new UnityContainer();
container.RegisterType <IPhone, AndriodPhone>(); //Default is transient lifecycle
container.RegisterType <IPhone, AndriodPhone>(new TransientLifetimeManager());
container.RegisterType <IPhone, AndriodPhone>(new ContainerControlledLifetimeManager()); //container implement sigleton method
var phone1 = container.Resolve <IPhone>();
var phone2 = container.Resolve <IPhone>();
Console.WriteLine(object.ReferenceEquals(phone1, phone2)); // in transient mode, return false; in container controll mode, return true.
{
Console.WriteLine("====Singleton mode in a thread"); // The instances in same thread is same one.
container.RegisterType <IPhone, AndriodPhone>(new PerThreadLifetimeManager());
IPhone iphone1 = null;
Action act1 = new Action(() =>
{
iphone1 = container.Resolve <IPhone>();
Console.WriteLine($"iphone1 is created by thread: {Thread.CurrentThread.ManagedThreadId}");
});
var result1 = act1.BeginInvoke(null, null);
IPhone iphone2 = null;
Action act2 = new Action(() =>
{
iphone2 = container.Resolve <IPhone>();
Console.WriteLine($"iphone2 is created by thread: {Thread.CurrentThread.ManagedThreadId}");
});
IPhone iphone3 = null;
var result2 = act2.BeginInvoke(t =>
{
iphone3 = container.Resolve <IPhone>();
Console.WriteLine($"iphone1 is created by thread: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine($"object.ReferenceEquals(iphone2, iphone3)={object.ReferenceEquals(iphone2, iphone3)}");
}, null);
act1.EndInvoke(result1);
act2.EndInvoke(result2);
//iphone1 and iphone2 are created by same thread, so they are equal
Console.WriteLine($"iphone1 is equals to iphone2 is {object.ReferenceEquals(iphone1, iphone2)}");
}
{
Console.WriteLine("===Each layer container's singleton model=====");
container.RegisterType <IPhone, AndriodPhone>(new HierarchicalLifetimeManager());
IUnityContainer childContainer = container.CreateChildContainer();
}
{
Console.WriteLine("====Releaseable singleton from outside====");
container.RegisterType <IPhone, AndriodPhone>(new ExternallyControlledLifetimeManager());
}
{
Console.WriteLine("====Recycle referenced container====");
container.RegisterType <IPhone, AndriodPhone>(new PerResolveLifetimeManager());
}
{
Console.WriteLine("====Create container from configuration file====");
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
fileMap.ExeConfigFilename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory + "CfgFiles\\Unity.Config");
Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
UnityConfigurationSection section = (UnityConfigurationSection)configuration.GetSection(UnityConfigurationSection.SectionName);
//IUnityContainer containerF = new UnityContainer();
//section.Configure(containerF, "testContainer");
//IPhone phone = containerF.Resolve<IPhone>();
//phone.Call();
Console.WriteLine("====Extend class Android phone====");
//IUnityContainer containerE = new UnityContainer();
//section.Configure(containerE, "testContainerE");
//IPhone phoneE = containerF.Resolve<IPhone>();
//phoneE.Call();
Console.WriteLine("====IOC + AOP from config file====");
IUnityContainer containerAOP = new UnityContainer();
section.Configure(containerAOP, "testContainerAOP");
IPhone phoneAOP = containerAOP.Resolve <IPhone>();
phoneAOP.Call();
//IPhone android = containerF.Resolve<IPhone>("Android");
//android.Call();
}
{
}
}
}
public void Test()
{
{
IUnityContainer container = new UnityContainer();
////container.RegisterType<IPhone,AndroidPhone>();//接口注册
////container.RegisterType<AbstractPad, ApplePad>();//抽象类注册
////container.RegisterType<ApplePad, ApplePadChild>();//普通继承类注册
////IPhone iphone = container.Resolve<IPhone>();
////AbstractPad abstractPad = container.Resolve<AbstractPad>();
////ApplePad applePad = container.Resolve<ApplePad>();
#region 依赖注入
//全局单例生命周期
//container.RegisterType<AbstractPad, ApplePad>(new SingletonLifetimeManager());
#region 线程单例
/*其中pad1是一个子线程
* pad3是pad2的回调，所以处于一个线程中
*/
container.RegisterType <AbstractPad, ApplePad>(new PerThreadLifetimeManager());
AbstractPad pad1 = null;
AbstractPad pad2 = null;
AbstractPad pad3 = null;
Action act1 = new Action(() =>
{
pad1 = container.Resolve <AbstractPad>();
});
act1.BeginInvoke(null, null);
Action act2 = new Action(() =>
{
pad2 = container.Resolve <AbstractPad>();
});
act2.BeginInvoke(t =>
{
pad3 = container.Resolve <AbstractPad>();
}, null);
object.ReferenceEquals(pad1, pad2); //false，不同的线程对象
object.ReferenceEquals(pad2, pad3); //true，线程对象
#endregion
container.RegisterType <IPhone, ApplePhone>();
container.RegisterType <IPhone, ApplePhone>();
container.RegisterType <IHeadPhone, AppleHeadPhone>();
container.RegisterType <IMicrophone, Mircophone>();
container.RegisterType <IPower, Power>();
//默认是瞬时生命周期
IPhone iphone = container.Resolve <IPhone>();
IPhone iphone2 = container.Resolve <IPhone>();
bool compareResult = object.ReferenceEquals(iphone, iphone2);//false，不同的对象
IPower power = container.Resolve <IPower>();
iphone.Init(power);
#endregion
}
{
//IDavidCustomContainer container = new DavidCustomContainer();
//container.RegisterType<IPhone, AndroidPhone>();
//container.RegisterType<AbstractPad, ApplePad>();
//container.RegisterType<IHeadPhone, AppleHeadPhone>();
//container.RegisterType<IPower, Power>();
//IPhone phone = container.Resolve<IPhone>();
}
}
