public static void ClientHandler(TcpClient client) {
var d = new Dictionary<string, ProcessCommand>() {
{ "cat", CatFile },
{ "clx", CalcClx },
{ "erf", CalcErf },
{ "sz", FileSize },
{ "info", GetInfo }
};
while (client.Connected) {
using (var streamReader = new StreamReader(client.GetStream()))
using (var streamWriter = new StreamWriter(client.GetStream())) {
var cmd = streamReader.ReadLine().Split(" ".ToCharArray(), 2);
try {
d[cmd[0]](cmd[1], streamWriter);
}
catch {
streamWriter.WriteLine("Error :(");
}
streamWriter.Flush();
}
}
client.Close();
}
private static void CheckUpdateCurrentLogStream()
{
DateTime nowTimestamp = DateTime.Now;
nowTimestamp = new DateTime(year: nowTimestamp.Year, month: nowTimestamp.Month, day: nowTimestamp.Day, hour: nowTimestamp.Hour, minute: 0, second: 0);
string nowStamp = nowTimestamp.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture);
if (!nowStamp.Equals(openLogStreamStamp))
{
lock (eventLogsWriter)
lock (snmpDataWriter)
try
{
eventLogsWriter?.Flush();
eventLogsWriter?.Close();
snmpDataWriter?.Flush();
snmpDataWriter?.Close();
}
catch
{
}
finally
{
openLogStreamStamp = nowStamp;
eventLogsWriter = new StreamWriter(path: Path.Combine(EVT_LOGS_DIR, $"{nowStamp}.txt"), append: false);
snmpDataWriter = new StreamWriter(path: Path.Combine(SNMP_DATA_DIR, $"{nowStamp}.csv"), append: false);
snmpDataWriter.WriteLine($"Time, IPAddress, LreLinkStatusA, LreLinkStatusB, LrePortAdminStateA, LrePortAdminStateB, LreCntTxA, LreCntTxB , LreCntTxC, LreCntRxA, LreCntRxB, LreCntRxC, LreCntErrorsA, LreCntErrorsB, LreCntErrorsC, LreCntOwnRxA, LreCntOwnRxB{Environment.NewLine}");
}
}
}
private static void MakeFileToRead(String file,Boolean option)
{
using (StreamWriter write = new StreamWriter(file))
{
if (!option)
{
for (int i = 0; i < 20; i++)
{
for (int j = 0; j < 20; j++)
{
write.Write(j);
}
write.WriteLine(i);
write.Flush();
}
}
else
{
for (int i = 0; i < final.Length; i++)
{
if (final[i] == '\n') { write.WriteLine(); }
else write.Write(final[i]);
write.Flush();
}
}
}
}
private static void MakeFileToRead(String file, Boolean optional, String dest)
{
using (StreamWriter write = new StreamWriter(file))
{
if (!optional)
{
for (int i = 97; i < 123; i++)
{
write.WriteLine((char)(i));
write.Flush();
}
}
else
{
using (StreamReader reader = new StreamReader(dest))
{
string line;
int br = 1;
while ((line = reader.ReadLine()) != null)
{
write.WriteLine(br + ". " + line);
write.Flush();
br++;
}
}
}
}
}
private void CurrentDomain_FirstChanceException(object sender, System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e)
{
_streamWriter?.WriteLine("EXCEPTION BEGIN");
_streamWriter?.WriteLine(e.Exception.ToString());
_streamWriter?.WriteLine("EXCEPTION END");
_streamWriter?.Flush();
}
} // func close
/// <summary></summary>
public virtual void flush()
{
lock (syncLock)
{
tw?.Flush();
tr?.DiscardBufferedData();
}
} // proc flush
/// <summary>
/// Writes the specifed text to the log file.
/// WARNING: Not thread safe!
/// </summary>
public static void WriteLine(string text, bool gameLog = true)
{
writer?.WriteLine($"{DateTime.UtcNow:O} {text}");
if (gameLog)
{
MyLog.Default.WriteLine($"[PluginLoader] {text}");
}
writer?.Flush();
}
public void Write(string text)
{
if (_isDisposed)
{
return;
}
_stdoutWriter?.Write(text);
_stdoutWriter?.Flush();
}
static void Main(string[] args)
{
String n="", horariosOut="";
IPAddress ip = IPAddress.Parse("127.0.0.1");
TcpListener tcpListener = new TcpListener(ip, 5050);
tcpListener.Start();
Socket serverSock = tcpListener.AcceptSocket();
if (serverSock.Connected)
{
NetworkStream con = new NetworkStream(serverSock);
//Archivo local en servidor, el cual se activará para mandar un correo
StreamWriter crearArchivoLocal = new StreamWriter("C:/Users/Dell/Documents/datoAdjunto.txt");
StreamWriter enviarDatos = new StreamWriter(con);
StreamReader recibirDatos = new StreamReader(con);
if(recibirDatos.ReadLine()!=""){
horariosOut = "Horarios disponibles: 1) 9:00 am 2) 12:00 pm 3) 3:00pm 4) 5:00 pm 5) 12:00 am. Seleccione alguna opción indicando con un numero";
enviarDatos.WriteLine(horariosOut);
enviarDatos.Flush();
}
if(recibirDatos.ReadLine().Equals("2")){
n = (recibirDatos.ReadLine() );
crearArchivoLocal.WriteLine(n);
}
if(recibirDatos.ReadLine().Equals("3")){
EnviarEmail enviarCorreo = new EnviarEmail();
bool exito = enviarCorreo.EnviarMail(recibirDatos.ReadLine(), "Datos de reservación", n, "AerolinasMisael", "*****@*****.**", "josueupbc");
if (exito == true)
{
enviarDatos.WriteLine(n + " El correo fue enviado exitosamente");
Console.WriteLine("El correo ha sido enviado exitosamente");
}
else
Console.Error.WriteLine("No fue posible enviar el correo");
enviarDatos.Flush();
}
recibirDatos.Close();
crearArchivoLocal.Close();
enviarDatos.Close();
con.Close();
serverSock.Close();
}
else
Console.WriteLine("Fallo en la conexion");
Console.ReadKey();
}
static void Main(string[] args)
{
NetworkStream stream;
TcpClient irc;
string inputLine;
StreamReader reader;
string nickname;
try
{
irc=new TcpClient(SERVER,PORT);
stream=irc.GetStream();
reader=new StreamReader(stream);
writer=new StreamWriter(stream);
PingSender ping=new PingSender();
ping.Start();
writer.WriteLine(USER);
writer.Flush();
writer.WriteLine("NICK"+NICK);
writer.Flush();
writer.WriteLine("JOIN"+CHANNEL);
writer.Flush();
while(true)
{
while((inputLine=reader.ReadLine())!=null)
{
if(inputLine.EndsWith("JOIN:"+CHANNEL))
{
nickname=inputLine.Substring(1,inputLine.IndexOf("!")-1);
writer.WriteLine("NOTICE"+nickname+":Hi"+nickname+" and welcome to "+CHANNEL+" channel! ");
writer.Flush();
Thread.Sleep(2000);
}
}
writer.Close();
reader.Close();
irc.Close();
}
}
catch(Exception e)
{
Console.WriteLine(e.ToString());
Thread.Sleep(5000);
string[] argv={};
Main(argv);
}
}
public void Close()
{
if (isDisposed)
{
throw new ObjectDisposedException(nameof(ProjectLogger));
}
streamWriter?.Flush();
streamWriter?.Close();
streamWriter = null;
}
static void Main(string[] args)
{
TcpClient socketForServer ;
bool status = true ;
try
{
socketForServer = new TcpClient("localhost",8100) ;
Console.WriteLine("Connected to Server") ;
}
catch
{
Console.WriteLine("Failed to Connect to server{0}:8100","localhost") ;
return ;
}
NetworkStream networkStream = socketForServer.GetStream() ;
StreamReader streamreader = new StreamReader(networkStream) ;
StreamWriter streamwriter = new StreamWriter(networkStream) ;
try
{
string clientmessage="" ;
string servermessage="" ;
while(status)
{
Console.Write("Client:") ;
clientmessage = Console.ReadLine() ;
if((clientmessage=="bye") || (clientmessage=="BYE"))
{
status = false ;
streamwriter.WriteLine("bye") ;
streamwriter.Flush() ;
}
if((clientmessage!="bye") && (clientmessage!="BYE"))
{
streamwriter.WriteLine(clientmessage) ;
streamwriter.Flush() ;
servermessage = streamreader.ReadLine() ;
Console.WriteLine("Server:"+servermessage) ;
}
}
}
catch
{
Console.WriteLine("Exception reading from the server") ;
}
streamreader.Close() ;
networkStream.Close() ;
streamwriter.Close() ;
}
public static void Run()
{
TcpListener server = new TcpListener(IPAddress.Loopback, 8181);
server.Start();
using (TcpClient client = server.AcceptTcpClient())
using (NetworkStream clientStream = client.GetStream())
using (StreamReader sr = new StreamReader(clientStream))
using (StreamWriter sw = new StreamWriter(clientStream))
{
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
sw.WriteLine("HTTP/1.1 101 Web Socket Protocol Handshake");
sw.WriteLine("Upgrade: WebSocket");
sw.WriteLine("Connection: Upgrade");
sw.WriteLine("WebSocket-Origin: http://localhost:8080");
sw.WriteLine("WebSocket-Location: ws://localhost:8181/websession");
sw.WriteLine("");
sw.Flush();
// Accept send
while (true)
{
// read type byte
byte type = (byte)clientStream.ReadByte();
if (type != 0x00) { Console.Error.WriteLine("Erro no protocolo: The type byte was not 0x00"); break; }
byte[] sendData = new byte[1024];
byte sendDataByte; int sendDataIdx = 0;
while ((sendDataByte = (byte)clientStream.ReadByte()) != 0xFF)
{
sendData[sendDataIdx++] = sendDataByte;
}
String text = System.Text.ASCIIEncoding.Default.GetString(sendData, 0, sendDataIdx);
Console.WriteLine("LINE: " + text);
// Write down message ECHO
clientStream.WriteByte(0x00);
sw.Write(text.ToUpper());
sw.Flush();
clientStream.WriteByte(0xFF);
}
}
server.Stop();
}
public static void Main(String[] args)
{
EchoClient conversant=null;
StreamWriter swriter=null;
StreamReader sreader=null;
try {
//Host name comes from command line
//If no host specified, local machine is host
String host=args.Length==1?args[0]:"127.0.0.1";
//Connect to Echo server
conversant=new EchoClient(host);
//Get the stream between server and client
NetworkStream ns=conversant.GetStream();
//Create a user-friendly StreamWriter
swriter=new StreamWriter(ns);
//Create a user-friendly StreamReader
sreader=new StreamReader(ns);
//Prompt user for message to send to server
//Period "exit" tells server to end session
String input;
Console.Write("Enter screen name: ");
while ((input=Console.ReadLine())!="exit") {
//Send message to server
swriter.WriteLine(input);
swriter.Flush();
//Get the Echo from the server
String returndata=sreader.ReadLine();
Console.WriteLine("Reply from "+host+": "+returndata);
Console.Write("Enter text: \"exit\" to stop: ");
}
//Send final message and scram
swriter.WriteLine(".");
swriter.Flush();
} catch (Exception e) {
Console.WriteLine(e+" "+e.StackTrace);
} finally {
//Close the connection whether exception thrown or not
if (swriter!=null) swriter.Close();
if (sreader!=null) sreader.Close();
if (conversant!=null) conversant.Close();
}
}
private static void log(String prefix, String level, String msg)
{
var line = $"{DateTime.Now.formatTime()}/{level} {prefix} {msg}";
lock (lockObject) {
Debug.WriteLine(line);
try {
writer?.WriteLine(line);
writer?.Flush();
} catch (Exception) {
writer = null;
}
}
}
public static string DESEncrypt(string input)
{
byte[] bytes = Encoding.ASCII.GetBytes((string)ConfigurationSettings.AppSettings["CipherKeyProd"]);
DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
MemoryStream memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memoryStream,
cryptoProvider.CreateEncryptor(bytes, bytes), CryptoStreamMode.Write);
StreamWriter writer = new StreamWriter(cryptoStream);
writer.Write(input);
writer.Flush();
cryptoStream.FlushFinalBlock();
writer.Flush();
return Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
}
/// <summary>
/// Activate/Deasctivate file logging
/// </summary>
public static void SwitchDump()
{
_dumpOn = !_dumpOn;
_dumpStream?.Flush();
if (_dumpOn && _dumpStream == null)
{
CommandLogger.Write("Can not activate dump as no file was specified. Use DUMP filename...");
}
else
{
CommandLogger.Write(_dumpOn ? "DUMP is now activated" : "DUMP is now deactivated");
}
}
private static LNode CompileTimeMacro(string macroName, LNode node, IMacroContext context, bool alsoRuntime, bool wantPreprocess = true)
{
if (node.ArgCount != 1 || !node[0].Calls(S.Braces))
{
context.Error(node.Target, "{0} should have a single argument: a braced block.", macroName);
return(null);
}
LNodeList code = node[0].Args;
if (wantPreprocess)
{
if (context.Ancestors.Take(context.Ancestors.Count - 1).Any(
n => n.Name.IsOneOf(S.Class, S.Struct, S.Enum, S.Namespace) ||
n.Name.IsOneOf(S.Constructor, S.Fn, S.Property, S.Var)))
{
context.Error(node.Target, "{0} is designed for use only at the top level of the file. It will be executed as though it is at the top level: any outer scopes will be ignored.", macroName);
}
code = context.PreProcess(code);
}
WriteHeaderCommentInSessionLog(node, context.Sink);
// Remove namespace blocks (not supported by Roslyn scripting)
LNode namespaceBlock = null;
var codeSansNamespaces = code.RecursiveReplace(RemoveNamespaces);
LNodeList?RemoveNamespaces(LNode n)
{
if (EcsValidators.SpaceDefinitionKind(n, out _, out _, out LNode body) == S.Namespace)
{
namespaceBlock = n;
return(body.Args.RecursiveReplace(RemoveNamespaces));
}
return(null);
}
if (namespaceBlock != null && wantPreprocess)
{
context.Warning(namespaceBlock, "The C# scripting engine does not support namespaces. They will be ignored when running at compile time.");
}
RunCSharpCodeWithRoslyn(node, codeSansNamespaces, context);
_roslynSessionLog?.Flush();
return(alsoRuntime ? F.Splice(code) : F.Splice());
}
public void Conversation()
{
try {
Console.WriteLine("Connection accepted.");
//Make a user-friendly StreamReader from the stream
sr=new StreamReader(client.GetStream());
//Make a user-friendly StreamWriter from the stream
sw=new StreamWriter(client.GetStream());
String incoming=sr.ReadLine();
while (incoming!=".") {
Console.WriteLine("Message received: "+incoming);
sw.WriteLine(incoming);
sw.Flush();
Console.WriteLine("Message Sent back: " + incoming);
incoming=sr.ReadLine();
}
Console.WriteLine("Client sent '.': closing connection.");
sr.Close();
sw.Close();
client.Close();
} catch (Exception e) {
Console.WriteLine(e+" "+e.StackTrace);
} finally {
if (sr!=null) sr.Close();
if (sw!=null) sw.Close();
if (client!=null) client.Close();
}
}
public virtual void StopOrCancelGeneratingDataset()
{
StopAllCoroutines();
commonWriter?.Flush();
commonWriter?.Close();
datasetPanel.UpdateCurrentSampleCnt(0);
}
static void Main()
{
StreamReader reader = new StreamReader("..\\..\\ProgramText.txt");
string text = reader.ReadLine();
StreamWriter write = new StreamWriter("..\\..\\Output.txt");
var names = new List<string>();
using (reader)
{
while (text != null)
{
names.Add(text);
text = reader.ReadLine();
}
}
names.Sort();
using (write)
{
foreach (var n in names)
{
write.WriteLine(n);
write.Flush();
}
}
StreamReader readerOutput = new StreamReader("..\\..\\Output.txt");
using (readerOutput)
{
Console.WriteLine("Result:\n");
Console.WriteLine(readerOutput.ReadToEnd());
}
}
private void GenerateMetadata()
{
Stream outputStream = null;
TextWriter outputWriter = null;
try
{
outputStream = options.MetadataFile?.GetStream();
if (outputStream == null)
{
return;
}
outputWriter = new StreamWriter(outputStream, new UTF8Encoding(false));
ScriptMetadataGenerator scriptGenerator = new ScriptMetadataGenerator(outputWriter, options, symbols);
scriptGenerator.GenerateScriptMetadata(symbols);
}
catch (Exception e)
{
throw;
}
finally
{
outputWriter?.Flush();
if (outputStream != null)
{
options.MetadataFile.CloseStream(outputStream);
}
}
}
/// <inheritdoc />
public void Flush()
{
lock (_syncObject)
{
_textWriter?.Flush();
}
}
public object String2Object(string s)
{
if (string.IsNullOrEmpty(s)) return null;
MemoryStream ms = new MemoryStream();
StreamWriter sw = new StreamWriter(ms);
sw.Write(s);
sw.Flush();
ms.Position = 0;
byte[] data = sf.Deserialize(ms) as byte[];
ms.Close();
MemoryStream stream = new MemoryStream(data);
stream.Position = 0;
object o = bf.Deserialize(stream);
sw.Close();
stream.Close();
return o;
}
/// <summary>
/// Callback from the Timer to flush the StreamWriter.
/// </summary>
/// <param name="_">Unused.</param>
private void FlushTimerCallback(object _)
{
lock (StreamWriterLock)
{
StreamWriter?.Flush();
}
}
public static void Log(object message)
{
if (message == null)
{
return;
}
if (writer == null)
{
try
{
writer = new StreamWriter(@"D:\log.html");
writer.WriteLine("<meta http-equiv=\"refresh\" content=\"1;url=file:///D:/log.html\" />");
}
catch
{
writer?.WriteLine("Logger already exists.");
}
}
var time = DateTime.Now;
writer?.WriteLine($"[{time:HH:mm:ss}] {HttpUtility.HtmlEncode(message)}<br/>");
writer?.Flush();
}
private void Flush()
{
lock (_lockObject)
{
_logWriter?.Flush();
}
}
public static void AddToText(Point3D point)
{
StreamWriter writer = new StreamWriter("Points.txt");
writer.WriteLine(point);
writer.Flush();
Console.WriteLine("File written!");
}
public void Dispose()
{
try
{
_flushTimer?.Dispose();
_flushTimer = null;
_sWriter?.WriteLine(".-");
_sWriter?.Flush();
_sWriter?.Dispose();
_sWriter = null;
}
catch
{
// ignored
}
if (!LogStreams.TryRemove(_currentFileName, out var oldWriter))
{
return;
}
try
{
oldWriter?.Dispose();
}
catch
{
// ignored
}
}
public override object GetEntity(Uri absoluteUri, String role, Type ofObjectToReturn)
{
if (Message != null)
{
Console.WriteLine(Message + absoluteUri + " (role=" + role + ")");
}
if (absoluteUri.ToString().EndsWith(".txt"))
{
MemoryStream ms = new MemoryStream();
StreamWriter tw = new StreamWriter(ms);
tw.Write("<uri>");
tw.Write(absoluteUri);
tw.Write("</uri>");
tw.Flush();
return new MemoryStream(ms.GetBuffer(), 0, (int)ms.Length);
}
if (absoluteUri.ToString().EndsWith("empty.xslt"))
{
String ss = "<transform xmlns='http://www.w3.org/1999/XSL/Transform' version='2.0'/>";
MemoryStream ms = new MemoryStream();
StreamWriter tw = new StreamWriter(ms);
tw.Write(ss);
tw.Flush();
return new MemoryStream(ms.GetBuffer(), 0, (int)ms.Length);
}
else
{
return null;
}
}
/// <summary>
/// Log any exception
/// </summary>
/// <param name="level">Level of the event</param>
/// <param name="eventTime">Time of the event</param>
/// <param name="message">Error message to log</param>
public void Log(TraceLevel level, DateTime eventTime, string message)
{
if (!_disposed && MinLogThreshold != TraceLevel.Off && level <= MinLogThreshold)
{
string text = $"[{level.ToString().Substring(0, 1)}][{eventTime.ToString(DateTimeHelper.FORMAT_TIME_TICKS)}]{message}";
lock (_syncRoot)
{
if (!_disposed)
{
OpenFileToWrite(eventTime.Date);
_writer?.WriteLine(text);
_writer?.Flush();
}
}
}
}
public void CloseStreams()
{
CsvWriter?.Flush();
StreamWriter?.Flush();
CsvWriter?.Dispose();
StreamWriter?.Close();
}
public void ErrorLog(string sPathName, string sErrMsg)
{
StreamWriter sw = new StreamWriter(sPathName + sErrorTime, true);
sw.WriteLine(sLogFormat + sErrMsg);
sw.Flush();
sw.Close();
}
static void Main()
{
string path = @"../../DeleteLines.txt";
string pathWrite = @"../../copyFile.txt";
StreamReader reader = new StreamReader(path);
StreamWriter writer = new StreamWriter(pathWrite);
using (reader)
{
using (writer)
{
string str = reader.ReadLine();
int counter = 1;
while (str != null)
{
if (counter % 2 == 0)
{
writer.WriteLine(str);
counter++;
}
else
{
counter++;
}
str = reader.ReadLine();
}
writer.Flush();
}
}
File.Delete(path);
File.Move(pathWrite, path);
}
void Log(LogItem li)
{
var threadId = li.ThreadId == default(int) ? "" : $"TID={li.ThreadId}";
var stackTrace = string.IsNullOrEmpty(li.StackTrace) ? "" : $"\nStackTrace={li.StackTrace}";
var s = $"{li.LogLevel} {li.Time} {li.Tag} | {threadId} {li.Message} {stackTrace}";
//if (li.Tag == "Env.TaskPool" || li.Tag == "Http")
//{
// System.Diagnostics.Debug.WriteLine(s);
//}
System.Diagnostics.Debug.WriteLine(s);
//TODO 如果这里发生异常，那很奇怪，需要检查一下，为什么会发生异常。因为正常写日志的操作应该是在Log关闭之前发生的。
sw?.WriteLine(s);
sw?.Flush();
}
public void Complete()
{
stream?.Flush();
stream?.Close();
_write = false;
foreach (var line in File.ReadLines(_fileName))
{
var parts = line.Split(' ');
switch (parts[0])
{
case "update":
File.Delete(parts[2]);
break;
case "add":
break;
case "delete":
File.Delete(parts[2]);
break;
}
}
File.Delete(_fileName);
}
protected virtual void Dispose(bool isDisposing)
{
if (isDisposing)
{
_streamWriter?.Flush();
_streamErrorWriter?.Flush();
_streamWriter?.Dispose();
_streamErrorWriter?.Dispose();
_stream?.Dispose();
_streamError?.Dispose();
try
{
foreach (var process in _processes)
{
process?.Process.Dispose();
}
_processes.Clear();
}
catch (Exception)
{
// exceptions are ok
}
_jobTracker?.Dispose();
}
}
public void Dispose()
{
try
{
_flushTimer?.Dispose();
_flushTimer = null;
_sWriter?.Write(PreFormat, "End", "↥ END ↥");
_sWriter?.Flush();
_sWriter?.Dispose();
_sWriter = null;
}
catch
{
// ignored
}
if (!LogStreams.TryRemove(_currentFileName, out var oldWriter))
{
return;
}
try
{
oldWriter?.Dispose();
}
catch
{
// ignored
}
}
public void WriteFile(string ruta)
{
StreamWriter sw = new StreamWriter(ruta,true);
sw.WriteLine(cad);
sw.Flush();
sw.Close();
}
public void OverwriteTrue()
{
string testFileSource = GetTestFilePath();
string testFileDest = GetTestFilePath();
char[] sourceData = { 'a', 'A', 'b' };
char[] destData = { 'x', 'X', 'y' };
// Write and copy file
using (StreamWriter sourceStream = new StreamWriter(File.Create(testFileSource)))
using (StreamWriter destStream = new StreamWriter(File.Create(testFileDest)))
{
sourceStream.Write(sourceData, 0, sourceData.Length);
sourceStream.Flush();
destStream.Write(destData, 0, destData.Length);
destStream.Flush();
}
Copy(testFileSource, testFileDest, true);
// Ensure copy transferred written data
using (StreamReader stream = new StreamReader(File.OpenRead(testFileDest)))
{
char[] readData = new char[sourceData.Length];
stream.Read(readData, 0, sourceData.Length);
Assert.Equal(sourceData, readData);
}
}
public void OverwriteFalse()
{
string testFileSource = GetTestFilePath();
string testFileDest = GetTestFilePath();
char[] sourceData = { 'a', 'A', 'b' };
char[] destData = { 'x', 'X', 'y' };
// Write and copy file
using (StreamWriter sourceStream = new StreamWriter(File.Create(testFileSource)))
using (StreamWriter destStream = new StreamWriter(File.Create(testFileDest)))
{
sourceStream.Write(sourceData, 0, sourceData.Length);
sourceStream.Flush();
destStream.Write(destData, 0, destData.Length);
destStream.Flush();
}
Assert.Throws<IOException>(() => Copy(testFileSource, testFileDest, false));
// Ensure copy didn't overwrite existing data
using (StreamReader stream = new StreamReader(File.OpenRead(testFileDest)))
{
char[] readData = new char[sourceData.Length];
stream.Read(readData, 0, sourceData.Length);
Assert.Equal(destData, readData);
}
}
private void Application_Exit(object sender, ExitEventArgs e)
{
streamWriter?.Flush();
streamWriter?.Close();
flushTimer?.Close();
writeTimer?.Close();
}
/// <summary>
/// Writes the analysis data.
/// </summary>
/// <param name='pathToMusicFile'>
/// Path to music file.
/// </param>
/// <param name='peaks'>
/// Array of Peaks.
/// </param>
/// <param name='loudParts'>
/// Array of Loud parts.
/// </param>
public static void writeAnalysisData(string pathToMusicFile, int[][] peaks, int[] loudParts, float variationFactor)
{
// Open
StreamWriter sw = new StreamWriter (convertToCacheFileName (pathToMusicFile));
// Write peaks to file
for (int i = 0; i < peaks.Length; i++) {
sw.Write ("c" + i + ":");
for (int j = 0; j < peaks[i].Length; j++) {
sw.Write (peaks [i] [j]);
sw.Write (';');
}
sw.WriteLine ();
}
// Write loudness levels to file
sw.Write ("lp:");
foreach (int lP in loudParts)
sw.Write (lP + ";");
sw.WriteLine();
// Write variation factor to file
sw.Write("vf:");
sw.Write(variationFactor);
// Close
sw.Flush ();
sw.Close ();
}
public static bool logException(Exception exception)
{
bool status = false;
string logFilePathName = GetDefaultPath();
if (!File.Exists(logFilePathName))
{
if (CheckForDirectory(logFilePathName))
{
FileStream fileStream = new FileStream(logFilePathName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
fileStream.Close();
}
}
try
{
StreamWriter streamWriter = new StreamWriter(logFilePathName, true);
streamWriter.WriteLine("Date : " + DateTime.Now.ToLongTimeString());
streamWriter.WriteLine("Time : " + DateTime.Now.ToShortDateString());
streamWriter.WriteLine("Error : " + exception.Message.ToString().Trim());
streamWriter.WriteLine("Type : " + exception.GetType().ToString());
streamWriter.WriteLine("********************************************************");
streamWriter.Flush();
streamWriter.Close();
status = true;
}
catch (Exception ex)
{
//There was an error return null.
Console.WriteLine(ex.ToString());
}
return status;
}
public static bool writeFile(string events,string exceptionStr)
{
string ip = HttpContext.Current.Request.ServerVariables["REMOTE_HOST"].ToString();
string ServerPath = HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"];
string errorMessage="事件源:"+ip+"\n事件缘由:"+events+"\n事件异常信息:"+exceptionStr+"\n事件发生时间:"+DateTime.Now.ToString();
StreamWriter sw = null;
string path = ServerPath.ToString() + "error\\";
Encoding encod = Encoding.GetEncoding("gb2312");//设置编码
string y= DateTime.Now.ToString("yyyy");
string M = DateTime.Now.ToString("MM");
string d = DateTime.Now.ToString("dd");
string h = DateTime.Now.ToString("HH");
string m = DateTime.Now.ToString("mm");
string s = DateTime.Now.ToString("ss");
string fullFileName =path+ y+"年"+M+"月"+d+"日"+h+"时"+m+"分"+s+"秒"+ ".txt";
try //写文件
{
sw = new StreamWriter(fullFileName, false, encod);
sw.Write(errorMessage);
sw.Flush();
return true;
}
catch (Exception ex)
{
HttpContext.Current.Response.Write(ex.Message);
HttpContext.Current.Response.End();
return false;
}
finally
{
sw.Close();
}
}
public static void Main(String[] args)
{
TcpListener server = new TcpListener(int.Parse(args[0]));
server.Start();
TcpClient client = server.AcceptTcpClient();
NetworkStream stream = client.GetStream();
StreamReader reader = new StreamReader(stream);
String s = reader.ReadLine();
String[] strings = s.Split();
StreamWriter writer;
if (strings[0] != "GET") {
writer = new StreamWriter(stream);
writer.WriteLine
("HTTP/1.0 501 Not Implemented");
writer.WriteLine();
} else {
String filename = strings[1];
while(reader.ReadLine() != "");
writer = new StreamWriter(stream);
writer.WriteLine("HTTP/1.0 200 OK");
writer.WriteLine("Content-type: text/plain");
writer.WriteLine();
StreamReader file = new StreamReader(filename);
String z = file.ReadToEnd();
writer.WriteLine(z);
writer.Flush();
writer.Close();
file.Close();
}
client.Close();
stream.Close();
reader.Close();
writer.Close();
server.Stop();
}
static void Main()
{
StreamReader reader = new StreamReader(@"../../restart.txt");
using (reader)
{
string content = reader.ReadToEnd();
StringBuilder text = new StringBuilder(content);
Console.WriteLine("This is the read file:");
Console.WriteLine(text);
Console.WriteLine();
Console.WriteLine();
text.Replace("start", "finish");
Console.WriteLine("This is the repalced file:");
Console.WriteLine(text);
Console.WriteLine();
//write in a new file
StreamWriter writer = new StreamWriter(@"../../refinish.txt", false, Encoding.GetEncoding("utf-8"));
using (writer)
{
writer.Write(text);
writer.Flush();
}
Console.WriteLine("Check the new file in solution folder");
}
}
/// <summary>
/// internal debug method about echo
/// </summary>
/// <param name="s"></param>
/// <param name="lineBreak"></param>
/// <param name="callerMemberName"></param>
/// <param name="callerLineNumber"></param>
internal virtual void EchoDebug(
string s,
bool lineBreak = false,
[CallerMemberName] string callerMemberName = "",
[CallerLineNumber] int callerLineNumber = -1)
{
if (IsMute)
{
return;
}
if (!FileEchoDebugEnabled)
{
return;
}
if (FileEchoDebugDumpDebugInfo)
{
_debugEchoStreamWriter?.Write($"l={s.Length},br={lineBreak} [{callerMemberName}:{callerLineNumber}] :");
}
_debugEchoStreamWriter?.Write(s);
if (lineBreak | FileEchoDebugAutoLineBreak)
{
_debugEchoStreamWriter?.WriteLine(string.Empty);
}
if (FileEchoDebugAutoFlush)
{
_debugEchoStreamWriter?.Flush();
}
}
// 释放资源
internal override void Close()
{
bool getLock = false;
try
{
// _timer.Change(Timeout.Infinite, Timeout.Infinite);
WriteLock.Enter(ref getLock);
bool canWrite = LogWriter?.BaseStream.CanWrite ?? false;
if (null != LogWriter)
{
if (LogWriter.BaseStream.CanWrite)
{
LogWriter?.Flush();
}
LogStream.Close();
LogWriter = null;
}
LogStream = null;
_timer?.Dispose();
}
finally
{
if (getLock)
{
WriteLock.Exit();
}
}
}
static void ReadWrite(string readFrom, string writeTo)
{
try
{
StreamReader reader = new StreamReader(readFrom);
using (reader)
{
StreamWriter writer = new StreamWriter(writeTo);
string line = reader.ReadLine();
using (writer)
{
int lineNum = 1;
while (line != null)
{
writer.WriteLine("Line {0}: {1}", lineNum, line);
writer.Flush();
lineNum++;
line = reader.ReadLine();
}
}
}
}
catch (ArgumentException ae)
{
Console.WriteLine(ae.Message);
}
catch (FileNotFoundException fe)
{
Console.WriteLine(fe.Message);
}
}
public bool ListExecute(bool busyWait = true)
{
if (this.CtlGetStatus(RtcStatus.Aborted))
{
return(false);
}
this.busy = true;
stream?.Flush();
stream?.Dispose();
stream = null;
/// busy during 1 secs by forcily
var timer = Stopwatch.StartNew();
do
{
if (this.CtlGetStatus(RtcStatus.Aborted))
{
break;
}
System.Threading.Thread.Sleep(10);
} while (timer.ElapsedMilliseconds < 1000);
this.busy = false;
return(!this.CtlGetStatus(RtcStatus.Aborted));
}
static void WriteFile(List<string> strings, string filename)
{
try
{
StreamWriter writer = new StreamWriter(filename);
using (writer)
{
foreach (var str in strings)
{
writer.WriteLine(str);
writer.Flush();
}
}
}
catch (FileNotFoundException fe)
{
Console.WriteLine(fe.Message);
}
catch (ArgumentException ae)
{
Console.WriteLine(ae.Message);
}
catch (OutOfMemoryException ofm)
{
Console.WriteLine(ofm.Message);
}
}
public static void WriteTextFile(string sFilePathAndName, string sTextContents)
{
StreamWriter sw = new StreamWriter(sFilePathAndName);
sw.WriteLine(sTextContents);
sw.Flush();
sw.Close();
}
public static void Log(ApiLogMessage message)
{
if (message.Level >= displayLogLevel)
{
switch (message.Level)
{
case ApiLogLevel.Error:
case ApiLogLevel.Critical:
Console.ForegroundColor = ConsoleColor.Red;
break;
case ApiLogLevel.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case ApiLogLevel.Debug:
case ApiLogLevel.Info:
Console.ForegroundColor = ConsoleColor.White;
break;
}
Console.WriteLine($"{Enum.GetName(typeof(ApiLogLevel), message.Level).ToUpper()}: {message.Message}");
if (logStream != null)
{
logWriter?.WriteLine($"{Enum.GetName(typeof(ApiLogLevel), message.Level).ToUpper()}: {message.Message}");
logWriter?.Flush();
}
Console.ForegroundColor = ConsoleColor.White;
}
}
private static void XMLSequences(XmlWriter xmlWriter, Debug_battleDat _BattleDat, StreamWriter csvFile, string prefix)
{
xmlWriter.WriteStartElement("sequences");
string count = $"{_BattleDat.Sequences?.Count ?? 0}";
xmlWriter.WriteAttributeString("count", count);
if (_BattleDat.Sequences != null)
{
foreach (Debug_battleDat.AnimationSequence s in _BattleDat.Sequences)
{
xmlWriter.WriteStartElement("sequence");
string id = s.id.ToString();
string offset = s.offset.ToString("X");
string bytes = s.data.Length.ToString();
xmlWriter.WriteAttributeString("id", id);
xmlWriter.WriteAttributeString("offset", offset);
xmlWriter.WriteAttributeString("bytes", bytes);
csvFile?.Write($"{prefix ?? ""}{ls}{count}{ls}{id}{ls}{s.offset}{ls}{bytes}");
foreach (byte b in s.data)
{
xmlWriter.WriteString($"{b.ToString("X2")} ");
csvFile?.Write($"{ls}{b}");
}
csvFile?.Write(Environment.NewLine);
xmlWriter.WriteEndElement();
}
}
csvFile?.Flush();
xmlWriter.WriteEndElement();
}
public void ProcessClientThread(object o)
{
try
{
NamedPipeServerStream pipeStream = (NamedPipeServerStream)o;
var streamReader = new StreamReader(pipeStream);
var streamWriter = new StreamWriter(pipeStream);
String requestString = streamReader.ReadLine();
Console.WriteLine(
"PipeStream Instance#" + pipeStream.GetHashCode() +
" recieved message: " + requestString);
Thread.Sleep(3000);
streamWriter.WriteLine(requestString.Length);
streamWriter.Flush();
pipeStream.WaitForPipeDrain();
pipeStream.Close();
pipeStream.Dispose();
}
catch (System.IO.IOException e)
{
Console.WriteLine("error while processing client" + e);
}
}
public void Write(string logfilename, string log, LogType lt)
{
#if UNITY_IPHONE || UNITY_ANDROID
return;
#endif
string filePathName = WriteFile(logfilename);
FileStream fs = new FileStream(filePathName, FileMode.Append);
StreamWriter sw = new StreamWriter(fs);
//开始写入
sw.WriteLine("");
//
string str = "[";
str += System.DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");//默认当天时间。
str += "]";
str += "\t";
str += lt.ToString();
str += "\t";
str += log;
sw.Write(str);
//清空缓冲区
sw.Flush();
//关闭流
sw.Close();
fs.Close();
}
static void Main()
{
Console.Write("n = ");
int n = int.Parse(Console.ReadLine());
Console.Write("Enter path to the file: ");
StreamReader lines = new StreamReader(Console.ReadLine());
int[,] matrix = new int[n, n];
for (int i = 0; i < n; i++)
{
string line = lines.ReadLine();
Console.WriteLine(line);
var nums = line.Split(' ');
for (int j = 0; j < n; j++)
{
matrix[i, j] = int.Parse(nums[j]);
}
}
int max = matrix[0, 0] + matrix[0, 1] + matrix[1, 0] + matrix[1, 1];
for (int i = 0; i < n-1; i++)
{
for (int j = 0; j < n-1; j++)
{
int sum = matrix[i, j] + matrix[i, j + 1] + matrix[i + 1, j] + matrix[i + 1, j + 1];
if(sum > max)
{
max = sum;
}
}
}
Console.Write("Enter path to the new fille: ");
StreamWriter writer = new StreamWriter(Console.ReadLine());
writer.Write(max);
writer.Flush();
Console.WriteLine("File is written!");
}
protected override void OnStart(string[] args)
{
try
{
Listener.Config = Config.ParseConfig(out logStream, out logWriter);
}
catch
{
Listener.Config = Config.DefaultConfig;
}
try
{
MetadataStore.LoadMetadata();
}
catch (Exception e)
{
if (logStream != null)
{
logWriter?.WriteLine(
$"{Enum.GetName(typeof(ApiLogLevel), ApiLogLevel.Critical)?.ToUpper()}: Failed to load metadata. Exception: {e.Message}{Environment.NewLine}{e.StackTrace}");
logWriter?.Flush();
}
Environment.Exit(1);
}
Listener.AttachLogger(m =>
{
if (m.Level >= displayLogLevel)
{
if (logStream != null)
{
logWriter?.WriteLine($"{Enum.GetName(typeof(ApiLogLevel), m.Level)?.ToUpper()}: {m.Message}");
logWriter?.Flush();
}
}
});
watcher = new FileSystemWatcher(Environment.CurrentDirectory, "MusicCatConfig.json")
{
NotifyFilter = NotifyFilters.LastWrite
};
watcher.Changed += OnConfigChange;
watcher.EnableRaisingEvents = true;
Listener.Start();
}
/// <summary>
/// Close the file flushing pending changes to the underlying stream and writing EOF record
/// </summary>
public void Close()
{
if (!disposedValue)
{
streamWriter?.WriteLine(":00000001FF");
streamWriter?.Flush();
}
}
