public static void SetOutput(WriteHandler writeHandler, WriteLineHandler writeLineHandler)
{
Write = null;
WriteLine = null;
Write += writeHandler;
WriteLine += writeLineHandler;
}
internal static bool Write(string filename, WriteHandler handler)
{
try
{
using (SafeWriteStream stream = new SafeWriteStream(filename))
using (SerializationWriter writer = new SerializationWriter(stream))
{
try
{
handler(writer);
return(true);
}
catch
{
stream.Abort();
throw;
}
}
}
catch (Exception e)
{
ErrorSubmission.Submit(new OsuError(e)
{
Feedback = "database-entry"
});
return(false);
}
}
internal void Write(PexWriteMeta write)
{
write.WriteString(Name);
write.WriteString(TypeName);
write.WriteString(DocString);
write.Writer.Write(RawUserFlags);
var flags = (byte)Flags;
write.Writer.Write(flags);
if ((flags & 4) != 0)
{
write.WriteString(AutoVarName);
}
if ((flags & 5) == 1)
{
ReadHandler?.Write(write);
}
if ((flags & 6) == 2)
{
WriteHandler?.Write(write);
}
}
public void DelegatePerformanceTest()
{
int runs = 5000000;
StopWatch sw;
sw = new StopWatch();
using(sw.Start("Time:{0}"))
{
for (int i = 0; i < runs; i++)
{
PerformanceTestTarget(1, null, null);
}
}
// Trace.WriteLine( string.Format("Time:{0}", sw.Elapsed.TotalSeconds) );
WriteHandler writeHandler = new WriteHandler(PerformanceTestTarget);
using(sw.Start("Time:{0}"))
{
for (int i = 0; i < runs; i++)
{
writeHandler(1, null, null);
}
}
// Trace.WriteLine(string.Format("Time:{0}", sw.Elapsed.TotalSeconds));
IWriteHandler writeHandler2 = this;
using(sw.Start("Time:{0}"))
{
for (int i = 0; i < runs; i++)
{
writeHandler2.PerformanceTestTarget(1, null, null);
}
}
// Trace.WriteLine(string.Format("Time:{0}", sw.Elapsed.TotalSeconds));
}
static DataStreamIO()
{
if (Reader != null && Writer != null)
{
return;
}
Tuple <Delegate, Delegate> pair;
if (RWTable.TryGetValue(typeof(TE), out pair))
{
Reader = (ReadHandler <TE>)pair.Item1;
Writer = (WriteHandler <TE>)pair.Item2;
}
else
{
if (typeof(IDataSerializer).IsAssignableFrom(typeof(TE)))
{
Reader = new ReadHandler <TE>((delegate(DataStream ds, out TE value)
{
value = Helpers.FastConstructor <TE> .Create();
var dataSerializer = (IDataSerializer)value;
return(ds.TryRead(dataSerializer));
}));
Writer = new WriteHandler <TE>((delegate(DataStream ds, TE value)
{
var dataSerializer = (IDataSerializer)value;
ds.Write(dataSerializer);
}));
}
else
{
throw new Exception("Unknown type");
}
}
}
public static void writeLyrics(string songName, List <Lyrics> lyricsList)
{
Debug.Log("writing lyrics...");
try
{
XDocument doc = new XDocument(new XElement("root"));
XElement root = doc.Root;
root.RemoveAll();
foreach (Lyrics lyrics in lyricsList)
{
string start = lyrics.start;
string end = lyrics.end;
string sentence = lyrics.sentence;
int voice = lyrics.voice;
XElement xEle = new XElement("lyrics", sentence);
xEle.Add(new XAttribute("start", start));
xEle.Add(new XAttribute("end", end));
xEle.Add(new XAttribute("voice", voice));
root.Add(xEle);
}
doc.Save(PATH.LYRICS + songName + ".xml");
}
catch (System.Exception e)
{
Debug.Log(e.ToString());
WriteHandler.writeDefault();
}
}
private void doWrite(String tag, Object o, WriteHandler w, bool cache)
{
if (cache)
{
if (shouldSkipCache(o))
{
doWrite(tag, o, w, false);
}
else
{
int index = getPriorityCache().oldIndex(o);
if (index == -1)
{
writeCode(Codes.PUT_PRIORITY_CACHE);
doWrite(tag, o, w, false);
}
else
{
if (index < Ranges.PRIORITY_CACHE_PACKED_END)
{
writeCode((int)Codes.PRIORITY_CACHE_PACKED_START + index);
}
else
{
writeCode(Codes.GET_PRIORITY_CACHE);
writeInt(index);
}
}
}
}
else
{
w.write(this, o);
}
}
private void FormMain_Load(object sender, EventArgs e)
{
OpenFileDialog fd = new OpenFileDialog();
fd.Filter = "Текстовые файлы (.txt)|*.txt|Все файлы (*.*)|*.*";
fd.FilterIndex = 0;
fd.CheckFileExists = false;
MemoryFileHandler fileHandler = null;
if (MemoryFileHandler.CheckFileExistInMemory())
{
fileHandler = MemoryFileHandler.CreateInstance(fromMemory: true);
}
else
{
if (fd.ShowDialog() == DialogResult.OK)
{
fileHandler = MemoryFileHandler.CreateInstance(fd.FileName);
}
else
{
Close();
}
}
username = UsernameGenerator.CreateName();
writeHandler = new WriteHandler(username, fileHandler);
readHandler = new ReadHandler(fileHandler);
readHandler.NewMessages += ReadHandler_NewMessage;
readHandler.StartChecking();
labelUsername.Text = "Имя: " + username;
textBoxMessageText.MaxLength = Encoding.Unicode.GetMaxCharCount(MessageModel.COUNT_TEXT);
}
public static Song[] readSongs(string cateID)
{
Song[] songList = new Song[9];
//gameObject.GetComponent<ManageHandler>().changeToSongTab();
//songContainer.name = cateID;
try
{
List <XElement> xEleList = XDocument.Load(PATH.SONG + cateID + ".xml").Root.Elements("song").ToList();
for (int i = 0; i < 9; i++)
{
XElement xEle = xEleList[i];
string name = xEle.Value.Trim();
string file = xEle.Attribute("file").Value.Trim();
bool enabled = bool.Parse(xEle.Attribute("enabled").Value.Trim());
songList[i] = new Song(name, file, enabled);
}
}
catch (System.Exception e)
{
Debug.Log(e.ToString());
WriteHandler.writeDefault();
}
return(songList);
}
/// <summary>
/// Creates a new logger instance using <see cref="WriteInternal"/> for
/// writing log events to the underlying log system.
/// </summary>
/// <seealso cref="GetWriteHandler"/>
protected AbstractLogger()
{
Write = GetWriteHandler();
if (Write == null)
{
Write = new WriteHandler(WriteInternal);
}
}
/// <summary>
/// Initializes the logger, with alternate output handlers.
/// </summary>
/// <owner>t-jeffv, sumedhk</owner>
/// <param name="verbosity"></param>
/// <param name="write"></param>
/// <param name="colorSet"></param>
/// <param name="colorReset"></param>
public SerialConsoleLogger
(
LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset
)
{
InitializeConsoleMethods(verbosity, write, colorSet, colorReset);
}
public void writeSongs()
{
Song[] songList = new Song[9];
for (int i = 0; i < 9; i++)
{
SongManager songMng = songContainer.transform.GetChild(i).GetComponent <SongManager>();
songList[i] = new Song(songMng.getName(), songMng.getFileName(), songMng.getActive());
}
WriteHandler.writeSongs(songContainer.name, songList);
}
public void writeCates()
{
Cate[] cateList = new Cate[9];
for (int i = 0; i < 9; i++)
{
CategoryManager cateMng = categoryContainer.transform.GetChild(i).GetComponent <CategoryManager>();
cateList[i] = new Cate(cateMng.getID(), cateMng.getName(), cateMng.getActive());
}
WriteHandler.writeCategories(cateList);
}
public WriteHandler requireWriteHandler(String tag, Object o)
{
WriteHandler handler = getWriteHandler(tag, o);
if (handler == null)
{
throw new ArgumentOutOfRangeException("Cannot write " + o + " as tag " + tag);
}
return(handler);
}
/// <summary>
/// Initializes the logger, with alternate output handlers.
/// </summary>
/// <owner>t-jeffv, sumedhk</owner>
/// <param name="verbosity"></param>
/// <param name="write"></param>
/// <param name="colorSet"></param>
/// <param name="colorReset"></param>
public SerialConsoleLogger
(
LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset
)
{
InitializeConsoleMethods(verbosity, write, colorSet, colorReset);
}
public static void LogError(string text)
{
if (ErrorHandler != null)
{
ErrorHandler.Invoke(text);
}
else
{
WriteHandler?.Invoke($"Error: {text}");
}
}
private bool Build_Project()
{
ConsoleMessages = "";
BuildPath = System.IO.Path.GetDirectoryName(ProjectPath) + "\\build";
if (Directory.Exists(BuildPath))
{
Directory.Delete(BuildPath, true);
}
ErrorMessages.Clear();
var props = new Dictionary <string, string>
{
{ "OutputPath", BuildPath }
};
var pc = new ProjectInstance(ProjectPath, props, "4.0");
StringBuilder sb = new StringBuilder();
WriteHandler handler = (x) =>
{
sb.AppendLine(x);
var divided = x.Split(new char[] { ' ', ':' }, 4, StringSplitOptions.RemoveEmptyEntries);
var couldBeError = divided.Length > 1 ? true : false;
if (couldBeError && divided[1] == "error")
{
ErrorMessages.Add(new ErrorMessage(divided[0], "error " + divided[2], divided[3]));
}
};
var logger = new ConsoleLogger(LoggerVerbosity.Normal, handler, null, null);
var buildParams = new BuildParameters()
{
DetailedSummary = false,
Loggers = new List <ILogger> {
logger
},
DefaultToolsVersion = "14.0"
};
var targets = new List <string> {
"Build"
};
var reqData = new BuildRequestData(pc, targets.ToArray());
var res = BuildManager.DefaultBuildManager.Build(buildParams, reqData);
ConsoleMessages = sb.ToString();
errorListBox.Items.Refresh();
if (res.OverallResult == BuildResultCode.Failure)
{
return(false);
}
return(true);
}
public void AsyncQuery()
{
WriteHandler handler = new WriteHandler(this);
for (int i = 1; i <= size; i++)
{
Key key = new Key(args.ns, args.set, keyPrefix + i);
Bin bin = new Bin(binName, i);
client.Put(null, handler, key, bin);
}
WaitTillComplete();
}
public Writer writeAs(String tag, Object o, bool cache)
{
if (o is CachedObject)
{
o = CachedObject.unwrap(o);
cache = true;
}
WriteHandler w = writeHandlerLookup.requireWriteHandler(tag, o);
doWrite(tag, o, w, cache);
return(this);
}
public void AsyncQuery()
{
WriteHandler handler = new WriteHandler(this);
for (int i = 1; i <= size; i++)
{
Key key = new Key(args.ns, args.set, keyPrefix + i);
Bin bin = new Bin(binName, i);
client.Put(null, handler, key, bin);
}
WaitTillComplete();
}
private void RunQueryExample(AsyncClient client, Arguments args, string keyPrefix, string binName, int size)
{
console.Info("Write " + size + " records.");
WriteHandler handler = new WriteHandler(this, client, args, binName, size);
for (int i = 1; i <= size; i++)
{
Key key = new Key(args.ns, args.set, keyPrefix + i);
Bin bin = new Bin(binName, i);
client.Put(args.writePolicy, handler, key, bin);
}
}
public ConsoleLogger (LoggerVerbosity verbosity, WriteHandler write, ColorSetter colorSet, ColorResetter colorReset)
{
if (write == null)
throw new ArgumentNullException ("write");
if (colorSet == null)
throw new ArgumentNullException ("colorSet");
if (colorReset == null)
throw new ArgumentNullException ("colorReset");
Verbosity = verbosity;
this.write = write;
set_color = colorSet;
reset_color = colorReset;
}
public void writeLyrics()
{
List <Lyrics> lyricsList = new List <Lyrics>();
foreach (Transform gObj in lyricsContainer.transform)
{
Lyrics lyr = gObj.GetComponent <LyricsManager>().getLyrics();
lyricsList.Add(lyr);
}
string songName = lyricsContainer.name;
WriteHandler.writeLyrics(songName, lyricsList);
}
/// <summary>
/// Initializes the logger, with alternate output handlers.
/// </summary>
/// <param name="verbosity"></param>
/// <param name="write"></param>
/// <param name="colorSet"></param>
/// <param name="colorReset"></param>
public ConsoleLogger
(
LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset
)
{
_verbosity = verbosity;
_write = write;
_colorSet = colorSet;
_colorReset = colorReset;
}
private WriteHandler WriteHandlerWrapper <T>(WriteHandler <T> handler)
{
return((object obj, SerializationContext context) =>
{
if (obj is T tObj)
{
handler(tObj, context);
}
else
{
handler((T)Convert.ChangeType(obj, typeof(T)), context);
}
});
}
ILogger CreateLogger(StringBuilder builder)
{
var writer = new StringWriter(builder);
WriteHandler handler = (x) => writer.WriteLine(x);
var consoleLogger = new ConsoleLogger(
m_verbosity,
write: handler,
colorSet: null,
colorReset: null
);
return(consoleLogger);
}
/// <summary>
/// Initializes the logger, with alternate output handlers.
/// </summary>
/// <param name="verbosity"></param>
/// <param name="write"></param>
/// <param name="colorSet"></param>
/// <param name="colorReset"></param>
public ConsoleLogger
(
LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset
)
{
ErrorUtilities.VerifyThrowArgumentNull(write, "write");
_verbosity = verbosity;
_write = write;
_colorSet = colorSet;
_colorReset = colorReset;
}
/// <summary>
/// Initializes the logger, with alternate output handlers.
/// </summary>
/// <param name="verbosity"></param>
/// <param name="write"></param>
/// <param name="colorSet"></param>
/// <param name="colorReset"></param>
public ConsoleLogger
(
LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset
)
{
ErrorUtilities.VerifyThrowArgumentNull(write, nameof(write));
this.verbosity = verbosity;
this.write = write;
this.colorSet = colorSet;
this.colorReset = colorReset;
}
/// <summary>
/// Write records individually.
/// </summary>
private void WriteRecords()
{
WriteHandler handler = new WriteHandler(this, BatchSize);
for (int i = 1; i <= BatchSize; i++)
{
Key key = sendKeys[i - 1];
Bin bin = new Bin(binName, ValuePrefix + i);
console.Info("Put: namespace={0} set={1} key={2} bin={3} value={4}",
key.ns, key.setName, key.userKey, bin.name, bin.value);
client.Put(args.writePolicy, handler, key, bin);
}
}
public void ServerCloseWithoutClientReadIsDetected()
{
const int ExpectedBytes = 100;
var serverHandler = new WriteHandler(ExpectedBytes);
ServerBootstrap sb = new ServerBootstrap()
.Group(this.group)
.Channel <TcpServerChannel>()
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(serverHandler);
}));
var address = new IPEndPoint(IPAddress.IPv6Loopback, 0);
// start server
// start server
Task <IChannel> task = sb.BindAsync(address);
Assert.True(task.Wait(DefaultTimeout), "Server bind timed out");
this.serverChannel = task.Result;
Assert.NotNull(this.serverChannel.LocalAddress);
var endPoint = (IPEndPoint)this.serverChannel.LocalAddress;
// connect to server
var clientHandler = new TestHandler(ExpectedBytes);
Bootstrap cb = new Bootstrap()
.Group(this.group)
.Channel <TcpChannel>()
.Option(ChannelOption.AutoRead, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(clientHandler);
}));
task = cb.ConnectAsync(endPoint);
Assert.True(task.Wait(DefaultTimeout), "Connect to server timed out");
this.clientChannel = task.Result;
Assert.NotNull(this.clientChannel.LocalAddress);
// Wait until server inactive to read on client
Assert.True(serverHandler.Inactive.Wait(DefaultTimeout));
this.clientChannel.Read();
Task <int> completion = clientHandler.Completion;
Assert.True(completion.Wait(DefaultTimeout));
Assert.Equal(ExpectedBytes, completion.Result);
}
public bool CallMsBuild(string projectFilePath, out string consoleOutput)
{
var projectCollection = new ProjectCollection { /*DefaultToolsVersion = "16.0" */
};
var project = projectCollection.LoadProject(projectFilePath);
var builder = new StringBuilder();
var writer = new StringWriter(builder);
WriteHandler handler = (x) => writer.WriteLine(x);
var logger = new ConsoleLogger(LoggerVerbosity.Normal, handler, null, null);
projectCollection.RegisterLogger(logger);
bool result = project.Build();
projectCollection.UnregisterAllLoggers();
consoleOutput = builder.ToString();
return(result);
}
public ConsoleLogger(LoggerVerbosity verbosity, WriteHandler write, ColorSetter colorSet, ColorResetter colorReset)
{
if (write == null)
{
throw new ArgumentNullException("write");
}
if (colorSet == null)
{
throw new ArgumentNullException("colorSet");
}
if (colorReset == null)
{
throw new ArgumentNullException("colorReset");
}
Verbosity = verbosity;
this.write = write;
set_color = colorSet;
reset_color = colorReset;
}
public static void WriteRecords(TestContext testContext)
{
sendKeys = new Key[size];
for (int i = 0; i < size; i++)
{
sendKeys[i] = new Key(args.ns, args.set, keyPrefix + (i + 1));
}
AsyncMonitor monitor = new AsyncMonitor();
WriteHandler handler = new WriteHandler(monitor, size);
for (int i = 1; i <= size; i++)
{
Key key = sendKeys[i - 1];
Bin bin = new Bin(binName, valuePrefix + i);
client.Put(null, handler, key, bin);
}
monitor.WaitTillComplete();
}
public void confirmNameChange()
{
Debug.Log("confirm name change!");
if (isFileNameEditing)
{
setFileName(nameInput.text);
}
else
{
if (WriteHandler.changeSongName(getName(), nameInput.text))
{
setName(nameInput.text);
}
else
{
Debug.Log("EXISTS!");
}
}
toggleEditMode(false);
writeSongs();
}
internal void InitializeConsoleMethods(LoggerVerbosity logverbosity, WriteHandler logwriter, ColorSetter colorSet, ColorResetter colorReset)
{
this.verbosity = logverbosity;
this.write = logwriter;
IsRunningWithCharacterFileType();
// This is a workaround, because the Console class provides no way to check that a color
// can actually be set or not. Color cannot be set if the console has been redirected
// in certain ways (e.g. how BUILD.EXE does it)
bool canSetColor = true;
try
{
ConsoleColor c = Console.BackgroundColor;
}
catch (IOException)
{
// If the attempt to set a color fails with an IO exception then it is
// likely that the console has been redirected in a way that cannot
// cope with color (e.g. BUILD.EXE) so don't try to do color again.
canSetColor = false;
}
if ((colorSet != null) && canSetColor)
{
this.setColor = colorSet;
}
else
{
this.setColor = new ColorSetter(DontSetColor);
}
if ((colorReset != null) && canSetColor)
{
this.resetColor = colorReset;
}
else
{
this.resetColor = new ColorResetter(DontResetColor);
}
}
public static void WriteRecords(TestContext testContext)
{
sendKeys = new Key[size];
for (int i = 0; i < size; i++)
{
sendKeys[i] = new Key(args.ns, args.set, keyPrefix + (i + 1));
}
AsyncMonitor monitor = new AsyncMonitor();
WriteHandler handler = new WriteHandler(monitor, size);
WritePolicy policy = new WritePolicy();
policy.expiration = 2592000;
for (int i = 1; i <= size; i++)
{
Key key = sendKeys[i - 1];
Bin bin = new Bin(binName, valuePrefix + i);
client.Put(policy, handler, key, bin);
}
monitor.WaitTillComplete();
}
/// <summary>
/// Write records individually.
/// </summary>
private void WriteRecords()
{
WriteHandler handler = new WriteHandler(this, BatchSize);
for (int i = 1; i <= BatchSize; i++)
{
Key key = sendKeys[i - 1];
Bin bin = new Bin(binName, ValuePrefix + i);
console.Info("Put: namespace={0} set={1} key={2} bin={3} value={4}",
key.ns, key.setName, key.userKey, bin.name, bin.value);
client.Put(args.writePolicy, handler, key, bin);
}
}
public ConsoleLogger(Microsoft.Build.Framework.LoggerVerbosity verbosity, WriteHandler write, ColorSetter colorSet, ColorResetter colorReset) {}
public ConsoleLogger (LoggerVerbosity verbosity, WriteHandler write, ColorSetter colorSet, ColorResetter colorReset)
{
throw new NotImplementedException ();
}
public QBLogger(LoggerVerbosity verbosity, WriteHandler write, ColorSetter colorSet, ColorResetter colorReset)
: base(verbosity, write, colorSet, colorReset)
{
}
public ConsoleLogger (LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset)
{
this.verbosity = verbosity;
this.indent = 0;
this.errorCount = 0;
this.warningCount = 0;
if (write == null)
this.writeHandler += new WriteHandler (WriteHandlerFunction);
else
this.writeHandler += write;
this.performanceSummary = false;
this.showSummary = true;
this.skipProjectStartedText = false;
errors = new List<string> ();
warnings = new List<string> ();
this.colorSet = colorSet;
this.colorReset = colorReset;
events = new List<BuildStatusEventArgs> ();
errorsTable = new Dictionary<string, List<string>> ();
warningsTable = new Dictionary<string, List<string>> ();
//defaults
errorColor = ConsoleColor.DarkRed;
warningColor = ConsoleColor.DarkYellow;
eventColor = ConsoleColor.DarkCyan;
messageColor = ConsoleColor.DarkGray;
highMessageColor = ConsoleColor.White;
// if message color is not set via the env var,
// then don't use any color for it.
no_message_color = true;
use_colors = false;
if (colorSet == null || colorReset == null)
return;
// color support
string config = Environment.GetEnvironmentVariable ("XBUILD_COLORS");
if (config == null) {
use_colors = true;
return;
}
if (config == "disable")
return;
use_colors = true;
string [] pairs = config.Split (new char[] {','}, StringSplitOptions.RemoveEmptyEntries);
foreach (string pair in pairs) {
string [] parts = pair.Split (new char[] {'='}, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
continue;
if (parts [0] == "errors")
TryParseConsoleColor (parts [1], ref errorColor);
else if (parts [0] == "warnings")
TryParseConsoleColor (parts [1], ref warningColor);
else if (parts [0] == "events")
TryParseConsoleColor (parts [1], ref eventColor);
else if (parts [0] == "messages") {
if (TryParseConsoleColor (parts [1], ref messageColor)) {
highMessageColor = GetBrightColorFor (messageColor);
no_message_color = false;
}
}
}
}
internal void InitializeConsoleMethods(LoggerVerbosity logverbosity, WriteHandler logwriter, ColorSetter colorSet, ColorResetter colorReset)
{
this.verbosity = logverbosity;
this.write = logwriter;
IsRunningWithCharacterFileType();
// This is a workaround, because the Console class provides no way to check that a color
// can actually be set or not. Color cannot be set if the console has been redirected
// in certain ways (e.g. how BUILD.EXE does it)
bool canSetColor = true;
try
{
ConsoleColor c = Console.BackgroundColor;
}
catch (IOException)
{
// If the attempt to set a color fails with an IO exception then it is
// likely that the console has been redirected in a way that cannot
// cope with color (e.g. BUILD.EXE) so don't try to do color again.
canSetColor = false;
}
if ((colorSet != null) && canSetColor)
{
this.setColor = colorSet;
}
else
{
this.setColor = new ColorSetter(DontSetColor);
}
if ((colorReset != null) && canSetColor)
{
this.resetColor = colorReset;
}
else
{
this.resetColor = new ColorResetter(DontResetColor);
}
}
/// <summary>
/// Initializes the logger, with alternate output handlers.
/// </summary>
/// <param name="verbosity"></param>
/// <param name="write"></param>
/// <param name="colorSet"></param>
/// <param name="colorReset"></param>
public ConsoleLogger
(
LoggerVerbosity verbosity,
WriteHandler write,
ColorSetter colorSet,
ColorResetter colorReset
)
{
ErrorUtilities.VerifyThrowArgumentNull(write, "write");
_verbosity = verbosity;
_write = write;
_colorSet = colorSet;
_colorReset = colorReset;
}
private void RunQueryExample(AsyncClient client, Arguments args, string keyPrefix, string binName, int size)
{
console.Info("Write " + size + " records.");
WriteHandler handler = new WriteHandler(this, client, args, binName, size);
for (int i = 1; i <= size; i++)
{
Key key = new Key(args.ns, args.set, keyPrefix + i);
Bin bin = new Bin(binName, i);
client.Put(args.writePolicy, handler, key, bin);
}
}
