private void SetMessageType(MESSAGE_TYPE m_type)
{
Span <byte> type = new Span <byte>(m_Buffer, PACKET_TYPE_START,
PACKET_TYPE_LENGTH);
type[0] = (byte)m_type;
}
//
//関数:
// 説明:
// messageを設定する
//
/// <summary>
/// messageを設定する
/// </summary>
/// <param name="text"></param>
/// <param name="type"></param>
/// <param name="mode"></param>
/// <param name="messageParam"></param>
/// <returns></returns>
public int Set(string text, MESSAGE_TYPE type, MESSAGE_MODE mode, Param messageParam)
{
int i;
ParamPrivate paramPrivate;
paramPrivate = new ParamPrivate();
paramPrivate.activated = true;
paramPrivate.isPlaying = false;
paramPrivate.messageState = MESSAGE_STATE.READY;
paramPrivate.text = text;
paramPrivate.messageStartTime = 0.0f;
paramPrivate.messageMode = mode;
paramPrivate.messageType = type;
paramPrivate.transparency = 0.0f;
if (messageList.Count == 0)
{
return(CreateMessageElement(0, paramPrivate, (Param)messageParam.Clone()));
}
for (i = 0; i < messageList.Count; i++)
{
if (!messageList[i].paramPrivate.activated)
{
break;
}
}
return(CreateMessageElement(i, paramPrivate, (Param)messageParam.Clone()));
}
// these methods translate PRSMessage <--> byte[]
// based on the expected format of a message
// NOTE: there is a challenge with the port field...
// port is an unsigned short, but
// NetworkToHostOrder() and HostToNetworkOrder() only operate on SIGNED short, so
// casting between short and ushort is required in the following methods
private PRSMessage(byte[] bytes)
{
this.msg_type = (MESSAGE_TYPE)bytes[0];
this.service_name = ASCIIEncoding.UTF8.GetString(bytes, 1, 50).TrimEnd('\0');
this.port = (ushort)IPAddress.NetworkToHostOrder(((short)BitConverter.ToInt16(bytes, 51)));
this.status = (STATUS)bytes[53];
}
public async Task CreateNewMessageForUser(string userToId, string userFromId, string content, TEAM team = null, string messageTypeName = null)
{
USER userFrom = null;
MESSAGE_TYPE messageType = null;
USER userTo = await _userRepository.GetUserById(userToId);
if (userFromId != null)
{
userFrom = await _userRepository.GetUserById(userFromId);
}
if (messageTypeName != null)
{
messageType = _messageRepository.GetMessageTypeByName(messageTypeName);
}
MESSAGE message = new MESSAGE();
if (userTo != null)
{
message.USER_TO = userTo;
message.TEXT = content;
message.MESSAGE_TYPE = messageType ?? _messageRepository.GetMessageTypeByName(MessageTypeNames.INFO);
message.USER_FROM = userFrom;
message.SEND_DATE = DateTime.Now;
message.TEAM = team;
_messageRepository.AddMessage(message);
}
}
public PRSMessage(MESSAGE_TYPE msg_type, string service_name, ushort port, STATUS status)
{
this.msg_type = msg_type;
this.service_name = service_name;
this.port = port;
this.status = status;
}
private void SendRequestMessage(MESSAGE_TYPE messageType, List <string> value = null)
{
// value is a parameters separated by $
CommunicationType cmd = new CommunicationType(messageType, "", value);
switch (messageType)
{
case MESSAGE_TYPE.GET_MENU_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_ACTIVE_ORDERS_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_COMPLETED_ORDERS_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_ACTIVE_DELIVERIES_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_COMPLETED_DELIVERIES_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_ALL_CLIENTS_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_ORDER_BYID_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.GET_DELIVERY_BYID_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.CREATE_CLIENT_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.CREATE_DISH_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.CREATE_ORDER_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.COMPLETE_ORDER_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
case MESSAGE_TYPE.COMPLETE_DELIVERY_REQ:
socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd));
break;
}
}
private MESSAGE_TYPE GetMessageTypeFromOperation()
{
MESSAGE_TYPE message_type = MESSAGE_TYPE.MSG_OPEINS;
switch (_opeType)
{
case OPE_TYPE.OPEINS:
{
message_type = MESSAGE_TYPE.MSG_OPEINS;
break;
}
case OPE_TYPE.RECINS:
{
message_type = MESSAGE_TYPE.MSG_RECINS;
break;
}
case OPE_TYPE.TARSAL:
{
message_type = MESSAGE_TYPE.MSG_TARSAL;
break;
}
}
return(message_type);
}
/// <summary>
/// This loop waits for incoming data
/// </summary>
public void AwaitData()
{
try
{
int i;
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
//Incoming data is stored in buffer
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
//Username, message_type, and message being parsed from the data
string name = data.Substring(0, data.IndexOf(':'));
MESSAGE_TYPE messageType = (MESSAGE_TYPE)Enum.Parse(typeof(MESSAGE_TYPE), data.Substring(data.IndexOf("//") + 2));
string message = data.Substring(data.IndexOf(':') + 1, data.IndexOf("//") - data.IndexOf(':') - 1);
//Calls an event to write to the console
chatEventHandler?.Invoke(this, new MessageRecievedEventArgs(name, messageType, message));
}
}
catch (System.IO.IOException)
{
ServerHandler.DisconnectClient(this);
}
catch (Exception)
{
Console.WriteLine("Error Occurred");
ServerHandler.DisconnectClient(this);
}
}
private void SendRequestMessage(MESSAGE_TYPE messageType)
{
switch (messageType)
{
case MESSAGE_TYPE.GET_MENU_REQ:
socketConnection.SendAsync("GET_MENU_REQ");
break;
case MESSAGE_TYPE.GET_ACTIVE_ORDERS_REQ:
socketConnection.SendAsync("GET_ACTIVE_ORDERS_REQ");
break;
case MESSAGE_TYPE.GET_COMPLETED_ORDERS_REQ:
socketConnection.SendAsync("GET_COMPLETED_ORDERS_REQ");
break;
case MESSAGE_TYPE.GET_ACTIVE_DELIVERIES_REQ:
socketConnection.SendAsync("GET_ACTIVE_DELIVERIES_REQ");
break;
case MESSAGE_TYPE.GET_COMPLETED_DELIVERIES_REQ:
socketConnection.SendAsync("GET_COMPLETED_DELIVERIES_REQ");
break;
}
}
public virtual void ADD_MESSAGE_LOG(
String _Message_Text
, MESSAGE_TYPE _Messaage_Type
, MESSAGE_RESULT_TYPE _Message_Result_Type = MESSAGE_RESULT_TYPE.Succeed)
{
//System.Console.WriteLine(String.Format("[{0}][{1}]:[{2}]", _Messaage_Type.ToString(), _Message_Result_Type.ToString(), _Message_Text));
}
public CustomException(Exception ex, MESSAGE_TYPE type)
: base(ex.Message)
{
if (ex.InnerException != null)
{
this.AdditionalMessage = ex.InnerException.Message;
}
}
////////////////////////////////////////////////////////////////////
///
public override void execute()
{
if (!_inited)
{
_inited = true;
dbStart();
return;
}
if (_requestUpdateDb == null)
{
return;
}
MESSAGE_TYPE type = (MESSAGE_TYPE)_requestUpdateDb.Type;
switch (type)
{
case MESSAGE_TYPE.CACHE_UPDATE_ADD:
case MESSAGE_TYPE.CACHE_UPDATE_DELETE:
case MESSAGE_TYPE.CACHE_UPDATE_EDIT:
//using (var client = new HttpClient())
//{
// string url = "api/cusid";
// client.BaseAddress = new Uri(ConfigurationManager.AppSettings["webapi_uri_root"]);
// client.DefaultRequestHeaders.Accept.Clear();
// client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
// var jsonRequest = JsonConvert.SerializeObject(_request);
// var content = new StringContent(jsonRequest, Encoding.UTF8, "text/json");
// var response = client.PostAsync(url, content).Result;
// if (response.IsSuccessStatusCode)
// {
// //string responseString = response.Content.ReadAsStringAsync().Result;
// }
//}
break;
case MESSAGE_TYPE.CACHE_SETUP:
break;
case MESSAGE_TYPE.CACHE_WEBAPI_REGISTER:
break;
default:
break;
}
//SqlCommand cmd = new SqlCommand();
//foreach (var kv in this._request..Pairs)
// cmd.Parameters.AddWithValue("@" + kv.Key, kv.Value);
//cmd.Connection = _connect;
//cmd.CommandText = _request.Message;
//cmd.CommandType = CommandType.StoredProcedure;
//cmd.ExecuteNonQuery();
}
public void RemoveListener(MESSAGE_TYPE msgType, MessageHandleDelegate handle)
{
List <MessageHandleDelegate> handleList = null;
if (m_DelegateLists.TryGetValue(msgType, out handleList))
{
handleList.Remove(handle);
}
}
public void SendMessage(Message msg)
{
MESSAGE_TYPE type = msg.GetMsgType();
List <MessageHandleDelegate> handleList = null;
if (m_DelegateLists.TryGetValue(type, out handleList))
{
ExecuteDelegate(handleList, msg);
}
}
/// <summary>
/// Vlozenie a zabalenie spravy podla zadaneho typu
/// do urcenej struktury
/// </summary>
/// <param name="type"> typ requestu</param>
/// <param name="data"> data requestu</param>
/// <return>Message</return>
public Message Wrap(MESSAGE_TYPE m, SERVICE_TYPE type, string data)
{
string message_content = "";
if (m == MESSAGE_TYPE.REQUEST)
{
message_content = new Request(type, data, DataSet.Instance().loged_user).ToString();
}
return(new Message(m, message_content));
}
public static void SendMessage(MESSAGE_TYPE msgType)
{
CommonNotify message = (CommonNotify)MessageManager.Instance.GetMsg(typeof(CommonNotify));
if (message == null)
{
message = new CommonNotify();
MessageManager.Instance.AddMsg(typeof(CommonNotify), message);
}
message.SetData(msgType);
MessageManager.Instance.SendMessage(message);
}
public static void SendMessage <T, U>(MESSAGE_TYPE msgType, T dataT, U dataU)
{
CommonNotify <T, U> message = (CommonNotify <T, U>)MessageManager.Instance.GetMsg(typeof(CommonNotify <T, U>));
if (message == null)
{
message = new CommonNotify <T, U>();
MessageManager.Instance.AddMsg(typeof(CommonNotify <T, U>), message);
}
message.SetData(msgType, dataT, dataU);
MessageManager.Instance.SendMessage(message);
}
public bool AddListener(MESSAGE_TYPE msgType, MessageHandleDelegate handle)
{
if (!m_DelegateLists.ContainsKey(msgType))
{
m_DelegateLists.Add(msgType, new List <MessageHandleDelegate>());
}
List <MessageHandleDelegate> handleList = m_DelegateLists[msgType];
if (handleList.Contains(handle))
{
return(false);
}
handleList.Add(handle);
return(true);
}
public static string GetHeader(this MESSAGE_TYPE type)
{
switch (type)
{
case MESSAGE_TYPE.SUCCESS: return("Success");
case MESSAGE_TYPE.WARN: return("Warning");
case MESSAGE_TYPE.ERROR: return("Error");
case MESSAGE_TYPE.FATAL: return("Fatal");
default: return("");
}
}
public static Message Parse(string text)
{
try
{
XElement tree = XElement.Parse(text);
string type_value = tree.Attribute("type").Value;
MESSAGE_TYPE t = (MESSAGE_TYPE)Enum.Parse(typeof(MESSAGE_TYPE), type_value);
Message m = new Message(t, tree.Value);
return(m);
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Schreibt die Nachricht ins Log
/// </summary>
public void WriteMessage(string cLogMessage, MESSAGE_TYPE eTyp)
{
FileStream oFileStream = null;
StackFrame oStackFrame;
try
{
lock (m_oLockFileWrite)
{
oStackFrame = new StackTrace().GetFrame(1);
// Datei öffnen, gegebenenfalls erstellen
if (!File.Exists(CURRENT_LOG_FILE))
{
oFileStream = File.Create(CURRENT_LOG_FILE);
oFileStream.Close();
oFileStream.Dispose();
}
using (StreamWriter oLogWriter = new StreamWriter(CURRENT_LOG_FILE, true, Encoding.UTF8))
{
oLogWriter.WriteLine(string.Format(
"[{0:T}] => {1} <{2}>.<{3}>: {4}",
DateTime.Now,
eTyp.ToString().ToUpper(),
oStackFrame.GetMethod().ReflectedType.Name,
oStackFrame.GetMethod().Name,
cLogMessage
));
oLogWriter.Close();
}
}
}
catch (Exception oEx)
{
throw oEx;
}
finally
{
if (oFileStream != null)
{
oFileStream.Close();
oFileStream.Dispose();
}
}
}
public void CreateMessageLocal( string _message, MESSAGE_TYPE _messageType, int? _receiverID = null )
{
DebugConsole.Log( "Creating message \"" + _message + "\"" );
_message = _message.Replace( ">", "\\>" ).Replace( "<", "\\<" );
if ( Network.peerType != NetworkPeerType.Disconnected )
{
if ( _messageType == MESSAGE_TYPE.PRIVATE )
{
if ( _receiverID == null )
{
throw new Exception( "Receiver ID required for private messages." );
}
DebugConsole.Log( "Sending private message to " + _receiverID.Value );
GamePlayer receiver = GamePlayerManager.instance.GetPlayerWithID( _receiverID.Value );
BaseNetworkManager.baseInstance.SendLobbyMessage( _message, receiver.networkPlayer, _messageType );
}
else if ( _messageType == MESSAGE_TYPE.TO_ALL || _messageType == MESSAGE_TYPE.TO_TEAM )
{
foreach ( KeyValuePair<int, GamePlayer> pair in GamePlayerManager.instance.playerMap )
{
if ( pair.Value == GamePlayerManager.instance.myPlayer )
{
continue;
}
if ( !pair.Value.sendMessagesTo )
{
DebugConsole.Log( "Ignoring player on ignore list " + pair.Key );
continue;
}
if ( _messageType == MESSAGE_TYPE.TO_TEAM
&& pair.Value.team != GamePlayerManager.instance.myPlayer.team )
{
DebugConsole.Log( "Ignoring player on opposing team " + pair.Key );
continue;
}
DebugConsole.Log( "Sending to " + pair.Key );
BaseNetworkManager.baseInstance.SendLobbyMessage( _message, pair.Value.networkPlayer, _messageType );
}
}
}
// Send to myself
this.CreateMessageNetworked( Common.MyNetworkID(), _message, _messageType );
}
/// <summary>
/// show message box according different type.
/// </summary>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <returns>Dialog Result</returns>
private static DialogResult doShow(string message, MESSAGE_TYPE messageType)
{
DialogResult dialogResult = DialogResult.None;
switch (messageType)
{
case MESSAGE_TYPE.SUCCESS:
dialogResult = MessageBox.Show(message, "PROMPT", MessageBoxButtons.OK, MessageBoxIcon.Information);
break;
case MESSAGE_TYPE.FAILURE:
dialogResult = MessageBox.Show(message, "PROMPT", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
case MESSAGE_TYPE.ADVISORY:
dialogResult = MessageBox.Show(message, "PROMPT", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
break;
}
return(dialogResult);
}
/// <summary>
/// Sets the error messages based on the supplied type
/// </summary>
/// <param name="type">Type of message that should be shown to the user</param>
public static void SetMessage(MESSAGE_TYPE type)
{
switch (type)
{
case MESSAGE_TYPE.INVALID_DIGIT:
ErrorMessage = "You can only use digits 1-9";
break;
case MESSAGE_TYPE.BREAKS_SUDOKU_RULES:
ErrorMessage = "You can not repeat the same digit in a row, column or block";
break;
case MESSAGE_TYPE.NO_ERROR:
ErrorMessage = "";
break;
default:
break;
}
}
public static void SendDebugString(MESSAGE_TYPE mt, string msg)
{
// ask permission to report this message.
var rc = MessageBox.Show("Please help improve this program and report this error. The information to be sent is this: " + Environment.NewLine + Environment.NewLine + msg, "An error has been detected, will you supply permission to report?", MessageBoxButtons.YesNo);
if (rc != DialogResult.Yes)
{
return;
}
UdpClient newsock = new UdpClient();
byte[] data = new byte[10000];
Encoding.ASCII.GetBytes("Eddie", 0, 5, data, 0);
// encode the message
data[5] = (byte)mt;
string mdetails = Application.ProductName + " " + version + " ";
int length = Encoding.ASCII.GetBytes(mdetails + msg, 0, mdetails.Length + msg.Length, data, 6);
data[6 + length] = 0;
try
{
// ekhtodo - sometimes these messages get long.... use TCP?
newsock.Send(data, Math.Min(1200, length + 7), "debug01cloudrouter.dyndns.org", 502);
}
catch (SocketException)
{
// possibly not even connected - ignore
}
catch
{
// Socket send fails if not connected to the internet...
// todo, at least log this exception to file, ready for email.
}
}
public static string GetString <T>(T _obj, Model.Header _head, MESSAGE_TYPE _type, string _eqpID)
{
try
{
switch (_type)
{
case MESSAGE_TYPE.REQUEST:
return(requestObject(_obj, _head));
case MESSAGE_TYPE.RESPONSE:
return(reponseMessage(_head, _eqpID));
}
return(string.Empty);
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
}
public override void ADD_MESSAGE_LOG(
String _Message_Text
, MESSAGE_TYPE _Messaage_Type
, MESSAGE_RESULT_TYPE _Message_Result_Type = MESSAGE_RESULT_TYPE.Succeed)
{
List <SqlParameter> sqlParaList = new List <SqlParameter>();
SqlParameter message_type = new SqlParameter("@message_type", SqlDbType.NVarChar);
message_type.Value = _Messaage_Type.ToString();
sqlParaList.Add(message_type);
SqlParameter message_result = new SqlParameter("@message_result", SqlDbType.NVarChar);
message_result.Value = _Message_Result_Type.ToString();
sqlParaList.Add(message_result);
SqlParameter message_description = new SqlParameter("@message_description", SqlDbType.NVarChar);
message_description.Value = _Message_Text;
sqlParaList.Add(message_description);
SqlParameter[] parameters = sqlParaList.ToArray();
EXECUTE_PROCEDURE_WITH_PARAMETERS(this, "sp_ssas_automation_deploy_log_details", parameters);
}
public void givePlayerFeedBack(Heros currentHero, String text, MESSAGE_TYPE messageType)
{
Console.WriteLine(text);
displayInfo(Program.DebugMode, text, messageType.ToString());
}
public CommunicationType(MESSAGE_TYPE MsgType, string Msg, List <string> param)
{
MessageType = MsgType;
Message = Msg;
Parameters = param;
}
private void OnStatus(object sender, MESSAGE_TYPE staus, byte[] msg)
{
string smsg = null;
switch (staus)
{
case MESSAGE_TYPE.MT_CONNECT_READY:
push.Subscribe(push.UserTopic);
smsg = encoding.GetString(msg);
AddInfo("CONNECT_READY:" + String.Format("{0} UserNo:{1}", smsg, push.UserNo));
SetBtnStatus(true);
break;
case MESSAGE_TYPE.MT_CONNECT_FAIL:
smsg = encoding.GetString(msg);
AddInfo("CONNECT_FAIL:" + String.Format("{0}", smsg));
break;
case MESSAGE_TYPE.MT_DISCONNECTED:
smsg = encoding.GetString(msg);
AddInfo("DISCONNECTED:" + String.Format("{0}", smsg));
SetBtnStatus(false);
break;
case MESSAGE_TYPE.MT_SUBSCRIBE:
smsg = encoding.GetString(msg);
AddInfo("SUBSCRIBE:" + String.Format("{0}", smsg));
break;
case MESSAGE_TYPE.MT_UNSUBSCRIBE:
smsg = encoding.GetString(msg);
AddInfo("UNSUBSCRIBE:" + String.Format("{0}", smsg));
break;
case MESSAGE_TYPE.MT_ACK_REQUESTID:
long RequestId = BitConverter.ToInt64(msg, 0);
AddInfo("Request Id BACK: " + RequestId);
break;
case MESSAGE_TYPE.MT_RECOVER_DATA:
smsg = encoding.GetString(msg, 1, msg.Length - 1);
if (msg[0] == 0)
{
AddInfo(String.Format("Begin Recover Topic:{0}", smsg));
}
if (msg[0] == 1)
{
AddInfo(String.Format("End Recover Topic:{0}", smsg));
}
break;
case MESSAGE_TYPE.MT_HEART_BEAT:
long UTC = ((PushClient)sender).ServerTime();
double totsec = (double)UTC / (double)1000000000;
DateTime st = (new DateTime(1970, 1, 1, 0, 0, 0)).AddHours(8).AddSeconds(totsec);
AddInfo(String.Format("{0:yyyy/MM/dd hh:mm:ss.fff}", st));
AddInfo(String.Format("{0:yyyy/MM/dd hh:mm:ss.fff}", DateTime.Now));
// TimeSpan toNow = new TimeSpan(UTC * 10);
// AddInfo(String.Format("{0:yyyy/MM/dd hh:mm:ss.fff}", gtm.Add(toNow)));
break;
}
}
public void SendLobbyMessage( string _message, NetworkPlayer _receiver, MESSAGE_TYPE _messageType )
{
this.GetComponent<NetworkView>().RPC( "OnSendLobbyMessageRPC", _receiver, Common.MyNetworkID(), _message, (int)_messageType );
}
public CustomException(string message, MESSAGE_TYPE type, object data)
: base(message)
{
this.type = type;
this.data = data;
}
public Message(MESSAGE_TYPE type, string header, string msg)
{
Type = type;
Header = header;
Msg = msg;
}
public void SetMessage(string message, MESSAGE_TYPE type)
{
Session["MESSAGE"] = new CustomException(message, type);
}
public void CreateMessageNetworked( int _senderID, string _message, MESSAGE_TYPE _messageType )
{
DebugConsole.Log( "Received message \"" + _senderID + "\" from " + _senderID );
GamePlayer sender = GamePlayerManager.instance.GetPlayerWithID( _senderID );
if ( !sender.receiveMessagesFrom )
{
DebugConsole.Log( "Ignoring message" );
return;
}
Message msg = new Message();
msg.senderID = _senderID;
msg.message = _message;
msg.timeReceived = DateTime.Now;
msg.messageType = _messageType;
this.messages.Add( msg );
if ( _senderID != Common.MyNetworkID() )
{
this.newMessages = true;
}
}
public CustomException(string message, MESSAGE_TYPE type)
: base(message)
{
this.type = type;
}
public void SetMessageType(MESSAGE_TYPE type)
{
this.PutByte((byte)type, 4);
}
public Message(MESSAGE_TYPE type, string msg)
{
Type = type;
Header = type.GetHeader();
Msg = msg;
}
/// <summary>
/// Schreibt die Nachricht ins Log
/// </summary>
public void WriteMessage(string cLogMessage, MESSAGE_TYPE eTyp)
{
FileStream oFileStream = null;
StackFrame oStackFrame;
try
{
lock (m_oLockFileWrite)
{
oStackFrame = new StackTrace().GetFrame(1);
// Datei öffnen, gegebenenfalls erstellen
if(!File.Exists(CURRENT_LOG_FILE))
{
oFileStream = File.Create(CURRENT_LOG_FILE);
oFileStream.Close();
oFileStream.Dispose();
}
using(StreamWriter oLogWriter = new StreamWriter(CURRENT_LOG_FILE, true, Encoding.UTF8))
{
oLogWriter.WriteLine(string.Format(
"[{0:T}] => {1} <{2}>.<{3}>: {4}",
DateTime.Now,
eTyp.ToString().ToUpper(),
oStackFrame.GetMethod().ReflectedType.Name,
oStackFrame.GetMethod().Name,
cLogMessage
));
oLogWriter.Close();
}
}
}
catch (Exception oEx)
{
throw oEx;
}
finally
{
if (oFileStream != null)
{
oFileStream.Close();
oFileStream.Dispose();
}
}
}
