public static void RegisterInterfaceImplementations(this TinyIoCContainer container,
string @namespace,
RegisterOptions options = RegisterOptions.AsMultiInstance,
RegisterTypes registerTypes = RegisterTypes.AsInterfaceTypes,
Assembly[] assemblies = null)
{
if (assemblies == null)
assemblies = new[] { Assembly.GetExecutingAssembly() };
var interfaces = GetInterfacesFromNamespace(@namespace, assemblies);
foreach (var i in interfaces)
{
var implementation = GetImplementingType(i, assemblies);
if ((registerTypes & RegisterTypes.AsObjects) == RegisterTypes.AsObjects)
{
var o = container.Register(typeof(object), implementation, i.Name);
if (options == RegisterOptions.AsSingleton)
o.AsSingleton();
else
o.AsMultiInstance();
}
if ((registerTypes & RegisterTypes.AsInterfaceTypes) == RegisterTypes.AsInterfaceTypes)
{
var o = container.Register(i, implementation);
if (options == RegisterOptions.AsSingleton)
o.AsSingleton();
else
o.AsMultiInstance();
}
}
}
static void Main(string[] args)
{
var busPublisher = ConfigurationPublisher.With("config/sender.xml")
.Log4NetBuilder("config/logging.xml")
.ConfigureMessageBuilder().With(
RegisterTypes.FromAssembly(typeof(IMySimpleData))
.Pick()
.WithService.FirstInterface()
).AllInterfaceToClass()
.ConfigurePublisher()
.Create();
Console.WriteLine("Pulsa un tecla para enviar un mensaje, o X para salir.");
while (true)
{
var key = Console.ReadKey(true);
if (key.KeyChar == 'x' || key.KeyChar == 'X')
{
break;
}
var mySimpleData = busPublisher.MessageBuilder.CreateInstance <IMySimpleData>(data =>
{
data.Data = "Hello Receiver";
data.Count = 10;
});
busPublisher.Publish(mySimpleData);
}
}
/// <summary>
/// Main function.
/// </summary>
/// <param name="args">Arguments from comand line.</param>
public static void Main(string[] args)
{
if (args.Length != 1)
{
Usage();
return;
}
var builder = new ContainerBuilder();
builder.RegisterInstance(new GlassTeletype()).As <ITeletype>();
RegisterTypes.Register(builder);
try
{
var program = File.ReadAllLines(args[0]);
var container = builder.Build();
var interpreter = container.Resolve <IInterpreter>();
interpreter.Execute(program);
}
catch (Exception ex)
{
Console.WriteLine($".Net exception {ex}");
Console.ReadKey();
}
}
static void Main(string[] args)
{
LoggerManager.Create(Log4NetFactory.CreateFrom("config/logging.xml"));
var service = ConfigurationHelper.With("config/service.xml")
.Log4NetBuilder("config/logging.xml")
.ConfigureMessageBuilder()
.With(
RegisterTypes.FromAssembly(typeof(MessageBasic))
.Pick()
.WithService.FirstInterface()
).AllInterfaceToClass()
.ConfigureService()
.Create();
service.Start();
Console.WriteLine("Pulsa X para parar el servicio");
while (true)
{
var key = Console.ReadKey(true);
if (key.KeyChar == 'x' || key.KeyChar == 'X')
{
break;
}
}
service.Stop();
}
/// <summary>
/// Main program. Passes argument one to interpreter as a run file command.
/// </summary>
/// <param name="args">Arguments from the command line.</param>
public static void Main(string[] args)
{
string initialCommand = string.Empty;
if (args.Length == 1)
{
initialCommand = $"RUN \"{args[0]}\"";
}
else
{
Console.WriteLine("Welcome to Classic BASIC, let us program like it's 1979");
}
var builder = new ContainerBuilder();
builder.RegisterInstance(new GlassTeletype(initialCommand)).As <ITeletype>();
RegisterTypes.Register(builder);
try
{
var container = builder.Build();
var interpreter = container.Resolve <IInterpreter>();
interpreter.Execute();
}
catch (Exception ex)
{
Console.WriteLine($".Net exception {ex}");
Console.ReadKey();
}
}
protected NetCommon(Peer peer)
{
_Peer = peer;
_Context = new Context {
Language = ELanguage.Pi
};
RegisterTypes.Register(_Context.Registry);
}
public static void SetupSut(TestContext context)
{
var builder = new ContainerBuilder();
RegisterTypes.Register(builder);
builder.RegisterInstance(new MockTeletype()).As <ITeletype>();
var container = builder.Build();
_tokeniser = container.Resolve <ITokeniser>();
}
public static void RegisterComponents()
{
RegisterTypes.RegisterApplicationTypes();
var container = DependencyFactory.Container;
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
public static void Initialize(bool registerSystem, bool registerUnity, bool registerCustom)
{
DebugUtil.Log("Reset Domain");
ccq2itype.Clear();
type2itype.Clear();
str2itype.Clear();
DebugUtil.Log("Register Base Type");
//注册基本类型
RegisterType(new Type_String());
RegisterType(new Type_Var());
RegisterType(new Type_Bool());
RegisterType(new Type_Lambda());
RegisterType(new Type_Delegate());
str2itype["null"] = new Type_NULL();
RegisterType <double>("double");
RegisterType <float>("float");
RegisterType <long>("long");
RegisterType <ulong>("ulong");
RegisterType <int>("int");
RegisterType <uint>("uint");
RegisterType <short>("short");
RegisterType <ushort>("ushort");
RegisterType <byte>("byte");
RegisterType <sbyte>("sbyte");
RegisterType <char>("char");
RegisterType <object>("object");
RegisterType <IEnumerator>("IEnumerator");
RegisterType(typeof(List <>), "System.Collections.Generic.List"); //模板类要独立注册
RegisterType(typeof(Dictionary <,>), "System.Collections.Generic.Dictionary");
RegisterType(typeof(Stack <>), "System.Collections.Stack");
RegisterType(typeof(Queue <>), "System.Collections.Queue");
RegisterType <System.Action> ();
if (registerSystem)
{
RegisterTypes.RegisterSystemTypes();
}
if (registerUnity)
{
RegisterTypes.RegisterUnityTypes();
}
if (registerCustom)
{
RegisterTypes.RegisterCustomTypes();
}
}
public static void SetupTokeniser(TestContext context)
{
_mockTeletype = new MockTeletype();
var builder = new ContainerBuilder();
RegisterTypes.Register(builder);
builder.RegisterInstance(_mockTeletype).As <ITeletype>();
var container = builder.Build();
_tokeniser = container.Resolve <ITokeniser>();
_runEnvironment = container.Resolve <IRunEnvironment>();
_variableRepository = container.Resolve <IVariableRepository>();
}
public static void init()
{
//if (Myro.Db.FetchConnectionCmd == null)
// Myro.Db.FetchConnectionCmd = new GetNpgsqlConnect();
//IRegisterType registerType = new Myro.Npgsql.RegisterTypes();
//Myro.Helpers.IRegisterType registerType = new Myro.RegisterTypes();
IRegisterType registerType = new RegisterTypes();
//registerType.Container.RegisterApiControllers();
//registerType.Container.EnableWebApi(GlobalConfiguration.Configuration);
App.init(registerType);
//TaxMigrations taxMigrations = new TaxMigrations();
//taxMigrations.Load_Migrations()
//MakeSymlink();
}
public static void RegisterInterfaceImplementations(this TinyIoCContainer container,
string @namespace,
RegisterOptions options = RegisterOptions.AsMultiInstance,
RegisterTypes registerTypes = RegisterTypes.AsInterfaceTypes,
Assembly[] assemblies = null)
{
if (assemblies == null)
{
assemblies = new [] { Assembly.GetExecutingAssembly() }
}
;
var interfaces = GetInterfacesFromNamespace(@namespace, assemblies);
foreach (var i in interfaces)
{
var implementation = GetImplementingType(i, assemblies);
if (implementation != null)
{
if ((registerTypes & RegisterTypes.AsObjects) == RegisterTypes.AsObjects)
{
var o = container.Register(typeof(object), implementation, i.Name);
if (options == RegisterOptions.AsSingleton)
{
o.AsSingleton();
}
else
{
o.AsMultiInstance();
}
}
if ((registerTypes & RegisterTypes.AsInterfaceTypes) == RegisterTypes.AsInterfaceTypes)
{
var o = container.Register(i, implementation);
if (options == RegisterOptions.AsSingleton)
{
o.AsSingleton();
}
else
{
o.AsMultiInstance();
}
}
}
}
}
}
private Program(string[] args)
: base(args)
{
_context = new Context {
Language = ELanguage.Rho
};
RegisterTypes.Register(_context.Registry);
if (!StartPeer(args))
{
Exit(1);
}
SetupPeer();
RunInitialisationScripts();
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
RegisterTypes.ConfigureApi(GlobalConfiguration.Configuration);
}
private static byte[] GetBArray(RegisterTypes t)
{
return new byte[] { (byte)t };
}
