public void InterceptClientSideOverrideFaultedCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var request1 = main.Bar();
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsFalse(request1.IsCompleted);
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
Assert.IsNotNull(cc.Exception);
cc.ReturnCanceled = false;
cc.Exception = null;
cc.ReturnToAlice();
Assert.ThrowsException <InvalidOperationException>(() => cc.ReturnToAlice());
Assert.IsTrue(request1.IsCompleted);
Assert.IsFalse(request1.IsFaulted);
}
}
}
public void UninterceptInCaps()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestMoreStuffImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestMoreStuff>()))
{
var counters2 = new Counters();
var cap = policy.Attach <ITestInterface>(new TestInterfaceImpl(counters2));
var foof = main.CallFoo(cap);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
cc.UninterceptInCaps();
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc.ReturnToAlice();
Assert.IsTrue(foof.Wait(MediumNonDbgTimeout));
}
}
}
public void InterceptClientSideCancelReturn()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var request1 = main.Foo(321, false, default);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsFalse(request1.IsCompleted);
Assert.IsFalse(cc.CancelFromAlice.IsCancellationRequested);
cc.ReturnCanceled = true;
cc.ReturnToAlice();
Assert.IsTrue(request1.IsCompleted);
Assert.IsTrue(request1.IsCanceled);
}
}
}
public void InterceptClientSideOverrideCanceledCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestMoreStuffImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestMoreStuff>()))
{
var request1 = main.NeverReturn(new TestInterfaceImpl(new Counters()), new CancellationToken(true));
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsFalse(request1.IsCompleted);
Assert.IsTrue(cc.CancelFromAlice.IsCancellationRequested);
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout), "must return");
Assert.IsTrue(cc.ReturnCanceled, "must be canceled");
cc.ReturnCanceled = false;
cc.Exception = "Cancelled";
cc.ReturnToAlice();
Assert.IsTrue(request1.IsCompleted);
Assert.IsTrue(request1.IsFaulted);
}
}
}
public void InterceptClientSideShortCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var request1 = main.Foo(321, false, default);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsFalse(request1.IsCompleted);
var rw = SerializerState.CreateForRpc <Capnproto_test.Capnp.Test.TestInterface.Result_Foo.WRITER>();
rw.X = "bar";
cc.OutArgs = rw;
cc.ReturnToAlice();
Assert.IsTrue(request1.IsCompleted);
Assert.AreEqual("bar", request1.Result);
}
}
}
public void InterceptClientSideRejectCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var request1 = main.Foo(321, false, default);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsFalse(request1.IsCompleted);
cc.Exception = "rejected";
cc.ReturnToAlice();
Assert.IsTrue(request1.IsCompleted);
Assert.IsTrue(request1.IsFaulted);
Assert.AreEqual("rejected", request1.Exception.InnerException.Message);
}
}
}
public void TailCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestTailCallerImpl(counters);
using (var main = client.GetMain <ITestTailCaller>())
{
var calleeCallCount = new Counters();
var callee = policy.Attach <ITestTailCallee>(new TestTailCalleeImpl(calleeCallCount));
var promise = main.Foo(456, callee, default);
var ccf = policy.Calls.ReceiveAsync();
Assert.IsTrue(ccf.Wait(MediumNonDbgTimeout));
var cc = ccf.Result;
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc.ReturnToAlice();
Assert.IsTrue(promise.Wait(MediumNonDbgTimeout));
Assert.AreEqual("from TestTailCaller", promise.Result.T);
}
}
}
public void InterceptClientSideRedirectCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var request1 = main.Foo(123, true, default);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsFalse(request1.IsCompleted);
var counters2 = new Counters();
var impl2 = new TestInterfaceImpl(counters2);
cc.Bob = impl2;
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc.ReturnToAlice();
Assert.IsTrue(request1.IsCompleted);
Assert.AreEqual("foo", request1.Result);
Assert.AreEqual(0, counters.CallCount);
Assert.AreEqual(1, counters2.CallCount);
}
}
}
public void InterceptOutCaps()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = policy.Attach <ITestMoreStuff>(new TestMoreStuffImpl(counters));
using (var main = client.GetMain <ITestMoreStuff>())
{
var counters2 = new Counters();
var cap = new TestInterfaceImpl(counters2);
main.Hold(cap);
{
var ccf = policy.Calls.ReceiveAsync();
Assert.IsTrue(ccf.Wait(MediumNonDbgTimeout));
ccf.Result.ForwardToBob();
var ccfr = policy.Returns.ReceiveAsync();
Assert.IsTrue(ccfr.Wait(MediumNonDbgTimeout));
ccf.Result.ReturnToAlice();
}
var ghf = main.GetHeld();
{
var ccf = policy.Calls.ReceiveAsync();
Assert.IsTrue(ccf.Wait(MediumNonDbgTimeout));
ccf.Result.ForwardToBob();
var ccfr = policy.Returns.ReceiveAsync();
Assert.IsTrue(ccfr.Wait(MediumNonDbgTimeout));
ccf.Result.InterceptOutCaps();
ccf.Result.ReturnToAlice();
}
Assert.IsTrue(ghf.Wait(MediumNonDbgTimeout));
var held = ghf.Result;
var foof = held.Foo(123, true);
{
var ccf = policy.Calls.ReceiveAsync();
Assert.IsTrue(ccf.Wait(MediumNonDbgTimeout));
ccf.Result.ForwardToBob();
var ccfr = policy.Returns.ReceiveAsync();
Assert.IsTrue(ccfr.Wait(MediumNonDbgTimeout));
ccf.Result.ReturnToAlice();
}
Assert.IsTrue(foof.Wait(MediumNonDbgTimeout));
}
}
}
public void InterceptClientSideModifyCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var request1 = main.Foo(321, false, default);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.AreEqual(InterceptionState.RequestedFromAlice, cc.State);
var pr = new Capnproto_test.Capnp.Test.TestInterface.Params_Foo.READER(cc.InArgs);
Assert.AreEqual(321u, pr.I);
Assert.AreEqual(false, pr.J);
var pw = cc.InArgs.Rewrap <Capnproto_test.Capnp.Test.TestInterface.Params_Foo.WRITER>();
pw.I = 123u;
pw.J = true;
cc.ForwardToBob();
var rx = policy.Returns.ReceiveAsync();
// Racing against Bob's answer
Assert.IsTrue(cc.State == InterceptionState.ForwardedToBob || cc.State == InterceptionState.ReturnedFromBob);
Assert.IsTrue(rx.Wait(MediumNonDbgTimeout));
var rr = new Capnproto_test.Capnp.Test.TestInterface.Result_Foo.READER(cc.OutArgs);
Assert.AreEqual("foo", rr.X);
Assert.IsFalse(request1.IsCompleted);
var rw = ((DynamicSerializerState)cc.OutArgs).Rewrap <Capnproto_test.Capnp.Test.TestInterface.Result_Foo.WRITER>();
rw.X = "bar";
cc.OutArgs = rw;
Assert.AreEqual(InterceptionState.ReturnedFromBob, cc.State);
cc.ReturnToAlice();
Assert.AreEqual(InterceptionState.ReturnedToAlice, cc.State);
Assert.IsTrue(request1.IsCompleted);
Assert.AreEqual("bar", request1.Result);
}
}
}
public void AttachDetach()
{
ConsumedCapability GetCap(object obj) => ((Proxy)obj).ConsumedCap;
var a = new MyPolicy("a");
var b = new MyPolicy("b");
var c = new MyPolicy("c");
var proxy = Proxy.Share <ITestInterface>(new TestInterfaceImpl2());
var attached = a.Attach(b.Attach(c.Attach(proxy)));
Assert.AreEqual(GetCap(attached), GetCap(b.Attach(attached)));
var detached = c.Detach(a.Detach(b.Detach(attached)));
Assert.AreEqual(GetCap(proxy), GetCap(detached));
}
public void MultiAttachAndDetach()
{
var a = new MyPolicy("a");
var b = new MyPolicy("b");
var c = new MyPolicy("c");
var counters = new Counters();
var impl = new TestInterfaceImpl(counters);
var implA = a.Attach <ITestInterface>(impl);
var implAbc = b.Attach(a.Attach(b.Attach(c.Attach(implA))));
var implAc = b.Detach(implAbc);
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
server.Main = implAc;
using (var main = client.GetMain <ITestInterface>())
{
var foof = main.Foo(123, true);
var ccf1 = c.Calls.ReceiveAsync();
Assert.IsTrue(ccf1.Wait(MediumNonDbgTimeout));
var cc1 = ccf1.Result;
cc1.ForwardToBob();
var ccf2 = a.Calls.ReceiveAsync();
Assert.IsTrue(ccf2.Wait(MediumNonDbgTimeout));
var cc2 = ccf2.Result;
cc2.ForwardToBob();
Assert.IsTrue(a.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc2.ReturnToAlice();
Assert.IsTrue(c.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc1.ReturnToAlice();
Assert.IsTrue(foof.Wait(MediumNonDbgTimeout));
}
}
}
public void InterceptServerSideRedirectCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = policy.Attach <ITestInterface>(new TestInterfaceImpl(counters));
var redirTarget = new TestInterfaceImpl2();
using (var main = client.GetMain <ITestInterface>())
using (redirTarget)
{
var request1 = main.Foo(123, true, default);
var fcc = policy.Calls.ReceiveAsync();
Assert.IsTrue(fcc.Wait(MediumNonDbgTimeout));
var cc = fcc.Result;
Assert.ThrowsException <ArgumentNullException>(() => cc.Bob = null);
cc.Bob = redirTarget;
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc.ReturnToAlice();
Assert.IsTrue(request1.Wait(MediumNonDbgTimeout));
Assert.AreEqual("bar", request1.Result);
}
Assert.IsTrue(redirTarget.IsDisposed);
Assert.AreEqual(0, counters.CallCount);
}
}
public void InterceptInCaps()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestMoreStuffImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestMoreStuff>()))
{
var counters2 = new Counters();
var cap = new TestInterfaceImpl(counters2);
var promise = main.CallFoo(cap);
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
cc.InterceptInCaps();
cc.ForwardToBob();
var cc2f = policy.Calls.ReceiveAsync();
Assert.IsTrue(cc2f.Wait(MediumNonDbgTimeout));
var cc2 = cc2f.Result;
cc2.ForwardToBob();
var cc2fr = policy.Returns.ReceiveAsync();
Assert.IsTrue(cc2fr.Wait(MediumNonDbgTimeout));
Assert.AreSame(cc2, cc2fr.Result);
Assert.AreEqual(1, counters2.CallCount);
cc2.ReturnToAlice();
var ccfr = policy.Returns.ReceiveAsync();
Assert.IsTrue(ccfr.Wait(MediumNonDbgTimeout));
Assert.AreSame(cc, ccfr.Result);
cc.ReturnToAlice();
Assert.IsTrue(promise.Wait(MediumNonDbgTimeout));
}
}
}
public void InterfaceAndMethodId()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = policy.Attach(client.GetMain <ITestInterface>()))
{
var baz = main.Baz(new TestAllTypes());
Assert.IsTrue(policy.Calls.TryReceive(out var cc));
Assert.IsTrue(cc.MethodId == 2);
Assert.AreEqual(new TestInterface_Skeleton().InterfaceId, cc.InterfaceId);
}
}
}
public void InterceptServerSideObserveCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
client.WhenConnected.Wait();
var counters = new Counters();
server.Main = policy.Attach <ITestInterface>(new TestInterfaceImpl(counters));
using (var main = client.GetMain <ITestInterface>())
{
var request1 = main.Foo(123, true, default);
var fcc = policy.Calls.ReceiveAsync();
Assert.IsTrue(fcc.Wait(MediumNonDbgTimeout));
var cc = fcc.Result;
var pr = new Capnproto_test.Capnp.Test.TestInterface.Params_foo.READER(cc.InArgs);
Assert.AreEqual(123u, pr.I);
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
var rr = new Capnproto_test.Capnp.Test.TestInterface.Result_foo.READER(cc.OutArgs);
Assert.AreEqual("foo", rr.X);
cc.ReturnToAlice();
Assert.IsTrue(request1.Wait(MediumNonDbgTimeout));
Assert.AreEqual("foo", request1.Result);
}
}
}
public void InterceptClientSideModifyPipelinedCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair(TcpRpcTestOptions.ClientTracer);
using (server)
using (client)
{
var counters = new Counters();
var impl = new TestMoreStuffImpl(counters);
server.Main = impl;
using (var main = policy.Attach(client.GetMain <ITestMoreStuff>()))
{
var req = main.GetNull().Eager().GetCallSequence(0);
Assert.IsTrue(policy.Calls.TryReceive(out var ccGetNull));
Assert.IsTrue(policy.Calls.TryReceive(out var ccGetCallSequence));
ccGetNull.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
ccGetNull.ReturnToAlice();
ccGetCallSequence.Bob = Proxy.Share <ITestMoreStuff>(impl);
ccGetCallSequence.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
ccGetCallSequence.ReturnToAlice();
Assert.IsTrue(req.IsCompleted && !req.IsFaulted && !req.IsCanceled);
Assert.AreEqual(0u, req.Result);
}
}
}
public static void Run()
{
string exploration_type = "greedy";
if (exploration_type == "greedy")
{
// Initialize Epsilon-Greedy explore algorithm using built-in StringRecorder and SimpleContext types
// Creates a recorder of built-in StringRecorder type for string serialization
StringRecorder <SimpleContext> recorder = new StringRecorder <SimpleContext>();
// Creates an MwtExplorer instance using the recorder above
MwtExplorer <SimpleContext> mwtt = new MwtExplorer <SimpleContext>("mwt", recorder);
// Creates a policy that interacts with SimpleContext type
StringPolicy policy = new StringPolicy();
uint numActions = 10;
float epsilon = 0.2f;
// Creates an Epsilon-Greedy explorer using the specified settings
EpsilonGreedyExplorer <SimpleContext> explorer = new EpsilonGreedyExplorer <SimpleContext>(policy, epsilon, numActions);
// Creates a context of built-in SimpleContext type
SimpleContext context = new SimpleContext(new Feature[] {
new Feature()
{
Id = 1, Value = 0.5f
},
new Feature()
{
Id = 4, Value = 1.3f
},
new Feature()
{
Id = 9, Value = -0.5f
},
});
// Performs exploration by passing an instance of the Epsilon-Greedy exploration algorithm into MwtExplorer
// using a sample string to uniquely identify this event
string uniqueKey = "eventid";
uint action = mwtt.ChooseAction(explorer, uniqueKey, context);
Console.WriteLine(recorder.GetRecording());
return;
}
else if (exploration_type == "tau-first")
{
// Initialize Tau-First explore algorithm using custom Recorder, Policy & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
uint tau = 0;
MyPolicy policy = new MyPolicy();
uint action = mwtt.ChooseAction(new TauFirstExplorer <MyContext>(policy, tau, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetAllInteractions().Select(it => it.Action)));
return;
}
else if (exploration_type == "bootstrap")
{
// Initialize Bootstrap explore algorithm using custom Recorder, Policy & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
uint numbags = 2;
MyPolicy[] policies = new MyPolicy[numbags];
for (int i = 0; i < numbags; i++)
{
policies[i] = new MyPolicy(i * 2);
}
uint action = mwtt.ChooseAction(new BootstrapExplorer <MyContext>(policies, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetAllInteractions().Select(it => it.Action)));
return;
}
else if (exploration_type == "softmax")
{
// Initialize Softmax explore algorithm using custom Recorder, Scorer & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
float lambda = 0.5f;
MyScorer scorer = new MyScorer(numActions);
uint action = mwtt.ChooseAction(new SoftmaxExplorer <MyContext>(scorer, lambda, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetAllInteractions().Select(it => it.Action)));
return;
}
else if (exploration_type == "generic")
{
// Initialize Generic explore algorithm using custom Recorder, Scorer & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
MyScorer scorer = new MyScorer(numActions);
uint action = mwtt.ChooseAction(new GenericExplorer <MyContext>(scorer, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetAllInteractions().Select(it => it.Action)));
return;
}
else
{ //add error here
}
}
public static MyPolicy getHashPolitica(string PolicyUriSource, string PolicyIdentifier = "2.16.76.1.7.1.2.2.3", string PolicyDigestAlgorithm = "SHA-256", string FileName = "LPA_CAdES.der")
{
MyPolicy Retorno = new MyPolicy();
Retorno.PolicyIdentifier = PolicyIdentifier;
Retorno.PolicyDigestAlgorithm = PolicyDigestAlgorithm;
Retorno.URLPolicy = PolicyUriSource;
Stream St;
try
{
St = Helper.FileHelper.MSReadFileURL(PolicyUriSource);
}
catch (Exception ex)
{
//FileStream File = Helper.FileHelper.FSReadFile(System.AppDomain.CurrentDomain.BaseDirectory + FileName);
//St = File;
St = new MemoryStream(Properties.Resources.LPA_CAdES);
}
DerSequence privKeyObj = (DerSequence)Asn1Object.FromStream(St);
var objCollection = privKeyObj.GetEnumerator();
objCollection.MoveNext();
Org.BouncyCastle.Asn1.Asn1Sequence objPrincipal = (Org.BouncyCastle.Asn1.Asn1Sequence)objCollection.Current;
var Politicas = objPrincipal.GetObjects();
while (Politicas.MoveNext())
{
Org.BouncyCastle.Asn1.Asn1Sequence Politica = (Org.BouncyCastle.Asn1.Asn1Sequence)Politicas.Current;
var Itens = Politica.GetObjects();
Itens.MoveNext();
string item1 = Itens.Current.ToString();
Itens.MoveNext();
string item2 = Itens.Current.ToString();
if (item2.Contains(PolicyIdentifier))
{
Itens.MoveNext();
string item3 = Itens.Current.ToString();
Retorno.SubURLPolicy = item3.Replace("[", "").Replace("]", "");
Itens.MoveNext();
Org.BouncyCastle.Asn1.Asn1Sequence item4 = (Org.BouncyCastle.Asn1.Asn1Sequence)Itens.Current;
var Item4d = item4.GetObjects();
Item4d.MoveNext();
Retorno.SubPolicyIdentifier = Item4d.Current.ToString().Replace("[", "").Replace("]", "");
Item4d.MoveNext();
Retorno.Hash = Item4d.Current.ToString();
}
}
St.Close();
return(Retorno);
}
public static void Run()
{
string exploration_type = "greedy";
if (exploration_type == "greedy")
{
// Initialize Epsilon-Greedy explore algorithm using built-in StringRecorder and SimpleContext types
StringRecorder <SimpleContext> recorder = new StringRecorder <SimpleContext>();
MwtExplorer <SimpleContext> mwtt = new MwtExplorer <SimpleContext>("mwt", recorder);
uint numActions = 10;
float epsilon = 0.2f;
StringPolicy policy = new StringPolicy();
SimpleContext context = new SimpleContext(new Feature[] {
new Feature()
{
Id = 1, Value = 0.5f
},
new Feature()
{
Id = 4, Value = 1.3f
},
new Feature()
{
Id = 9, Value = -0.5f
},
});
uint action = mwtt.ChooseAction(new EpsilonGreedyExplorer <SimpleContext>(policy, epsilon, numActions), "key", context);
Console.WriteLine(recorder.GetRecording());
return;
}
else if (exploration_type == "tau-first")
{
// Initialize Tau-First explore algorithm using custom Recorder, Policy & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
uint tau = 0;
MyPolicy policy = new MyPolicy();
uint action = mwtt.ChooseAction(new TauFirstExplorer <MyContext>(policy, tau, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetData()));
return;
}
else if (exploration_type == "bagging")
{
// Initialize Bagging explore algorithm using custom Recorder, Policy & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
uint numbags = 2;
MyPolicy[] policies = new MyPolicy[numbags];
for (int i = 0; i < numbags; i++)
{
policies[i] = new MyPolicy(i * 2);
}
uint action = mwtt.ChooseAction(new BaggingExplorer <MyContext>(policies, numbags, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetData()));
return;
}
else if (exploration_type == "softmax")
{
// Initialize Softmax explore algorithm using custom Recorder, Scorer & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
float lambda = 0.5f;
MyScorer scorer = new MyScorer(numActions);
uint action = mwtt.ChooseAction(new SoftmaxExplorer <MyContext>(scorer, lambda, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetData()));
return;
}
else if (exploration_type == "generic")
{
// Initialize Generic explore algorithm using custom Recorder, Scorer & Context types
MyRecorder recorder = new MyRecorder();
MwtExplorer <MyContext> mwtt = new MwtExplorer <MyContext>("mwt", recorder);
uint numActions = 10;
MyScorer scorer = new MyScorer(numActions);
uint action = mwtt.ChooseAction(new GenericExplorer <MyContext>(scorer, numActions), "key", new MyContext());
Console.WriteLine(String.Join(",", recorder.GetData()));
return;
}
else
{ //add error here
}
}
