|
You can't have the "'" in Guardian's Name. What database are you using?
|
|
|
|
|
Member 10564850 wrote: My query can't executed successfully please help ??
As Griff mentioned on Saturday:
Just remember in future - the better the info you give us, the quicker we can give you a solution!
Once again, you've posted your code, but not the error message, which leaves us to play another game of "guess the error".
Assuming the problem is with the column names containing special characters, the quick fix is to wrap the affected column names in square brackets. You'll also need to fix the parameter names:
string s = "INSERT INTO [Students Records] (Name, Age, Class, Gender, [Guardian's Name], [Contact.No], Address, [Email-Address]) VALUES(@Name, @Age, @Class, @Gender, @GuardiansName, @ContactNo, @Address, @EmailAddress)";
A better solution is to change your database structure so that the table and column names do not contain anything other than letters and numbers - no spaces, no punctuation, and no extended characters.
The same restrictions apply to parameter names.
If that doesn't solve the problem, then you'll need to provide the details of the exception being thrown when you try to execute the query.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
Whoops! Already moved. Sorry! 
|
|
|
|
|
Answered here[^].
..and now you know "why" it is not done.
Bastard Programmer from Hell 
If you can't read my code, try converting it here[^]
|
|
|
|
|
|
Again, you're putting spaces and special characters in the parameter names.
DO NOT USE SPACES AND SPECIAL CHARACTERS IN TABLE NAMES, FIELD NAMES AND PARAMETER NAMES!
Your field names should be something like this:
Name, Age, Class, Gender, GuardianName, ContactPhone, Address, EmailAddress
By making the code more "eyeball friendly" to read, you are giving yourself headaches debugging the resulting code. "Eyeball friendly" is NOT "compiler friendly"!
|
|
|
|
|
Clean-up crew needed, grammar spill... - Nagy Vilmos
|
|
|
|
|
Hi,
I am using MySQL database in my C# .NET application and saving all dates in the database as UTC_TIMESTAMP
I want to know to display it for the user in his own local time according to his Microsoft Windows?
Thanks,
Jassim
Technology News @ www.JassimRahma.com
|
|
|
|
|
Try reading the documentation on the DateTime structure, here[^].
Dim databaseUtcTime = dateTimeFromDatabase
databaseUtcTime = databaseUtcTime.SpecifyKind(DateTimeKind.Utc)
Debug.WriteLine(String.Format("UtcTime: {0}", databaseUtcTime.ToString()))
Debug.WriteLine(String.Format("LocalTime: {0}", databaseUtcTime.ToLocalTime().ToString()))
|
|
|
|
|
Alright, this is not exactly a programming question, but I also doubt that it would fit into the Lounge.
Situation: I am currently implementing the Syslog Protocol in .Net, starting with the Base classes (Message, Header, Struct. Data). The Header contains a timestamp which's formatting is exactly defined.
A timestamp may look as follows:
2014-2-4T14:22:56.235Z+1
2014-2-4T14:22:56.235Z-1.5
2014-2-4T14:22:56.235123Z+1
What I have done so far is that I consider System.DateTime being unuseable as timestamp, even with a wrapper around it it would be highly difficult since setting a single field (e.g. Day, Year, Month and so on) is only possible by parsing an entire time string, or adding a Time span.
Now to avoid these circumstances, I have implemented the following class SyslogTimestamp:
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace Springlog.Com.Messaging
{
public class SyslogTimestamp
{
#region Properties
static short GetDayMaxDaysOfMonth(int month, int year)
{
if (month != 2)
{
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
{
return 31;
}
else
{
return 30;
}
}
else
{
if (IsLeapYear(year))
{
return 29;
}
return 28;
}
}
private static bool IsLeapYear(int year)
{
if (year % 4 == 0)
{
if (year % 100 == 0)
{
if (year % 400 == 0)
{
return true;
}
return false;
}
return true;
}
return false;
}
int year;
public int Year
{
get { return year; }
}
int month;
public int Month
{
get { return month; }
}
int dayOfMonth;
public int DayOfMonth
{
get { return dayOfMonth; }
}
int hours;
public int Hours
{
get { return hours; }
}
int minutes;
public int Minutes
{
get { return minutes; }
}
int seconds;
public int Seconds
{
get { return seconds; }
}
int miliseconds;
public int Miliseconds
{
get { return miliseconds; }
}
double utcOffset;
public double UtcOffset
{
get { return utcOffset; }
set { utcOffset = value; }
}
#endregion
public SyslogTimestamp()
{
Reset();
}
public SyslogTimestamp(string timestamp)
{
Reset();
FromString(timestamp);
}
public SyslogTimestamp(DateTime timestamp)
{
Reset();
FromDateTime(timestamp);
}
private void Reset()
{
miliseconds = 0;
seconds = 0;
minutes = 0;
hours = 0;
dayOfMonth = 0;
month = 1;
year = 1;
utcOffset = 0;
}
public bool FromString(string dateTime)
{
Regex splitRegex = new Regex("([0-9]{4})-([1-9]|[1][0-2])-([0-2]?[0-9]|[3][0-1])[T]([0-1]?[0-9]|[2][0-3])[:]([0-5]?[0-9])[:]([0-5]?[0-9])?.?([0-9]{1,6})[Z]([+-][0-9]|[+-]?[0][1][0-2])", RegexOptions.IgnoreCase);
Match timestamp = splitRegex.Match(dateTime);
if (timestamp.Groups.Count == 9)
{
AddYears(Int32.Parse(timestamp.Groups[1].Value));
AddMonths(Int32.Parse(timestamp.Groups[2].Value));
AddDays(Int32.Parse(timestamp.Groups[3].Value));
AddHours(Int32.Parse(timestamp.Groups[4].Value));
AddMinutes(Int32.Parse(timestamp.Groups[5].Value));
AddSeconds(Int32.Parse(timestamp.Groups[6].Value));
AddMilliseconds(Int32.Parse(timestamp.Groups[7].Value));
utcOffset = Int32.Parse(timestamp.Groups[8].Value);
return true;
}
else
{
return false;
}
}
public string ToFormattedString()
{
string timezonPreSign = "+";
if (utcOffset < 0)
{
timezonPreSign = "";
}
return string.Format("{0}-{1}-{2}T{3}:{4}:{5}.{6}Z{7}{8}", year, month, dayOfMonth, hours, minutes, seconds, miliseconds, timezonPreSign, utcOffset);
}
public override string ToString()
{
return this.ToFormattedString();
}
public void FromDateTime(DateTime timestamp, bool convertToUtc = true)
{
TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(timestamp);
if (convertToUtc)
{
timestamp.Add(utcOffset);
this.utcOffset = 0;
}
else
{
this.utcOffset = utcOffset.Hours + (utcOffset.Minutes / 100);
}
AddMilliseconds(timestamp.Millisecond);
AddSeconds(timestamp.Second);
AddMinutes(timestamp.Minute);
AddHours(timestamp.Hour);
AddDays(timestamp.Day);
AddMonths(timestamp.Month);
AddYears(timestamp.Year);
}
public void Add(TimeSpan timeSpan)
{
AddMilliseconds(timeSpan.Milliseconds);
AddSeconds(timeSpan.Seconds);
AddMinutes(timeSpan.Minutes);
AddHours(timeSpan.Hours);
AddDays(timeSpan.Days);
}
public void AddMilliseconds(int val)
{
if (val + miliseconds >= 1000)
{
AddSeconds( val / 1000);
miliseconds = (val % 1000);
}
else
{
miliseconds += val;
}
}
private void AddSeconds(int val)
{
if (seconds + val >= 60)
{
AddMinutes(val / 60);
seconds = (val % 60);
}
else
{
seconds += val;
}
}
private void AddMinutes(int val)
{
if (minutes + val >= 60)
{
AddMinutes(val / 60);
minutes = (val % 60);
}
else
{
minutes += val;
}
}
private void AddHours(int val)
{
if (minutes + val >= 24)
{
AddDays (val / 24);
minutes = (val % 24);
}
else
{
minutes += val;
}
}
private void AddDays(int val)
{
short dayCount = GetDayMaxDaysOfMonth(month, year);
if (dayOfMonth + val > dayCount)
{
AddMonths(val / dayCount);
dayOfMonth = (val % dayCount);
}
else
{
dayOfMonth += val;
}
}
private void AddMonths(int val)
{
if (month + val > 12)
{
AddYears(val / 12);
month = (val % 12);
}
else
{
month += val;
}
}
private void AddYears(int val)
{
year += val;
}
public override bool Equals(object o)
{
if (o is SyslogTimestamp)
{
return DoMatch((SyslogTimestamp)o, this);
}
else
{
return false;
}
}
public static bool DoMatch(SyslogTimestamp a, SyslogTimestamp b)
{
bool doMatch = (a.year == b.Year)
&& (a.month == b.Month)
&& (a.dayOfMonth == b.DayOfMonth)
&& (a.hours == b.Hours)
&& (a.minutes == b.Minutes)
&& (a.seconds == b.Seconds)
&& (a.miliseconds == b.Miliseconds)
&& (a.utcOffset == b.UtcOffset);
return doMatch;
}
public static bool operator ==(SyslogTimestamp a, SyslogTimestamp b)
{
if (System.Object.ReferenceEquals(a, b))
{
return true;
}
if (((object)a == null) || ((object)b == null))
{
return false;
}
return DoMatch(a, b);
}
public static bool operator !=(SyslogTimestamp a, SyslogTimestamp b)
{
return !(a == b);
}
public static bool operator <(SyslogTimestamp a, SyslogTimestamp b)
{
if (a.Year < b.Year) { return true; }
if (a.Year > b.Year) { return false; }
if (a.Month < b.Month) { return true; }
if (a.Month > b.Month) { return false; }
if (a.DayOfMonth < b.DayOfMonth) { return true; }
if (a.DayOfMonth > b.DayOfMonth) { return false; }
if ((a.Hours + a.UtcOffset) < (b.Hours + b.UtcOffset)) { return true; }
if ((a.Hours + a.UtcOffset) > (b.Hours + b.UtcOffset)) { return false; }
if (a.Minutes < b.Minutes) { return true; }
if (a.Minutes > b.Minutes) { return false; }
if (a.Seconds < b.Seconds) { return true; }
if (a.Seconds > b.Seconds) { return false; }
if (a.Miliseconds < b.Miliseconds) { return true; }
if (a.Miliseconds > b.Miliseconds) { return false; }
return false;
}
public static bool operator >(SyslogTimestamp a, SyslogTimestamp b)
{
if (a.Year > b.Year) { return true; }
if (a.Year < b.Year) { return false; }
if (a.Month > b.Month) { return true; }
if (a.Month < b.Month) { return false; }
if (a.DayOfMonth > b.DayOfMonth) { return true; }
if (a.DayOfMonth < b.DayOfMonth) { return false; }
if ((a.Hours + a.UtcOffset) > (b.Hours + b.UtcOffset)) { return true; }
if ((a.Hours + a.UtcOffset) < (b.Hours + b.UtcOffset)) { return false; }
if (a.Minutes > b.Minutes) { return true; }
if (a.Minutes < b.Minutes) { return false; }
if (a.Seconds > b.Seconds) { return true; }
if (a.Seconds < b.Seconds) { return false; }
if (a.Miliseconds > b.Miliseconds) { return true; }
if (a.Miliseconds < b.Miliseconds) { return false; }
return false;
}
public static bool operator >=(SyslogTimestamp a, SyslogTimestamp b)
{
return (a > b) || DoMatch(a, b);
}
public static bool operator <=(SyslogTimestamp a, SyslogTimestamp b)
{
return (a < b) || DoMatch(a, b);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
}
Of course I have Unit Tests to check the integrity of the data handling within that class:
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Springlog.Com.Messaging;
namespace Springlog.Com.Messaging.UnitTests
{
[TestClass]
public class SyslogTimestampUnitTest
{
[TestMethod]
public void SyslogTimestampComparisonIntegrity()
{
SyslogTimestamp timestamp1 = new SyslogTimestamp();
SyslogTimestamp timestamp2 = new SyslogTimestamp();
SyslogTimestamp timestamp3 = new SyslogTimestamp();
SyslogTimestamp timestamp4 = new SyslogTimestamp();
timestamp1.FromDateTime(DateTime.Now);
timestamp2.FromDateTime(DateTime.Now.AddDays(-1));
timestamp3 = timestamp1;
timestamp4.FromDateTime(DateTime.Now.AddMinutes(2));
Assert.AreEqual(true, (timestamp1 > timestamp2));
Assert.AreEqual(true, (timestamp4 > timestamp1));
Assert.AreEqual(false, (timestamp1 < timestamp2));
Assert.AreEqual(true, (timestamp1 >= timestamp2));
Assert.AreEqual(false, (timestamp1 <= timestamp2));
Assert.AreEqual(true, (timestamp1 == timestamp3));
Assert.AreEqual(false, (timestamp1 != timestamp3));
Assert.AreEqual(false, (timestamp1 == timestamp4));
Assert.AreEqual(false, (timestamp1 == timestamp2));
}
[TestMethod]
public void SyslogTimestampStringConversionIntegrity()
{
DateTime now = DateTime.Now;
SyslogTimestamp timestamp = new SyslogTimestamp();
SyslogTimestamp timestamp2 = new SyslogTimestamp();
timestamp.FromDateTime(now);
timestamp.UtcOffset = 1;
Assert.AreEqual(true, timestamp2.FromString(timestamp.ToFormattedString()));
Assert.AreEqual(true, (timestamp2 == timestamp));
}
}
}
Now my question is: Can I achieve the same with System.DateTime?
I seriously doubt that, since System.DateTime's ParseExact method tends to have problems dealing with a variable amount of microseconds, and does not provide any field to store the UTC Offset.
Edit: I provided the new class implementation, since I have added various improvements.
Clean-up crew needed, grammar spill... - Nagy Vilmos
modified 5-Feb-14 8:52am.
|
|
|
|
|
personally I would never re-write it. I once tried and though it was more than a reasonable effort, the amount of rules and things to think of becomes very large and does not outwheigh the disadvantages of being stuck with the standard DateTime.
([SMALL RANT]And I'm now working with Java's GregorianCalendar, how I wish I had a DateTime object  [/SMALL RANT])
Marco Bertschi wrote: since System.DateTime's ParseExact method tends to have problems dealing with a variable amount of microseconds, and does not provide any field to store the UTC Offset.
Variable microseconds can be handled with a few lines of business logic I think and for the UTC Offset you could create a new DateTime Object that inherits from the DateTime class? (just a quick thought)
good luck.
|
|
|
|
|
V. wrote: Variable microseconds can be handled with a few lines of business logic I think
The big deal is that the Syslog Timestamp has special characters in it, in order to make it better parseable. ParseExact can't handle them properly, somehow.
V. wrote: for the UTC Offset you could create a new DateTime Object that inherits from the DateTime class? (just a quick thought)
And then I'd end up with what I already have, since the UTC Offset must be recognized when comparing two types of the new datetime class.
In the end I'd say that it is a reasonable amount of work, especially since Date/Time stuff isn't going to change too soon, and if it has proven itself worth the work it will last longer than both of us will ever live.
Clean-up crew needed, grammar spill... - Nagy Vilmos
|
|
|
|
|
DateTime is a sealed class, so you can't inherit from it.
“But I don't want to go among mad people,” Alice remarked.
“Oh, you can't help that,” said the Cat: “we're all mad here. I'm mad. You're mad.”
“How do you know I'm mad?” said Alice.
“You must be," said the Cat, or you wouldn't have come here.” Lewis Carroll
|
|
|
|
|
[Edit]
Crap. I saw "Timestamp" read it "Timespan".
Actually, I was right. DateTime structure[^]. I'll get the right eventually!
|
|
|
|
|
Marco Bertschi wrote: Can I achieve the same with System.DateTime?
Based on the observation that all of your Properties, except milliseconds, are 'get only, I would say "yes," if you were willing to accept the limitations of inheriting from a data-structure like a Tuple<T1,T2,T3> ... given the fact that Tuple instances are immutable.
I don't claim to have thought through your use scenario here in any great depth, or to fully understand your goals here, but here's a quick sketch:
using System;
namespace Feb4_2014_InheritFromTupleT1T2T3
{
public class DateTimeEx: Tuple<DateTime, long, Int32>
{
private const string msPrefix = ":Z";
private const string tzPlus = "+";
private string tzPre;
public DateTime dateTime { set; get; }
public long milliSeconds { set; get; }
public Int32 utcOffset { set; get; }
public DateTimeEx(DateTime datetime, long millisec, Int32 utcoff) : base(datetime, millisec, utcoff)
{
dateTime = datetime;
milliSeconds = millisec;
utcOffset = utcoff;
}
public override string ToString()
{
tzPre = (milliSeconds < 0) ? "" : tzPlus;
return string.Format("{0}-{1}-{2}T{3}:{4}:{5}.{6}Z{7}{8}", Item1.Year, Item1.Month, Item1.Day, Item1.Hour, Item1.Minute, Item1.Second, milliSeconds, tzPre, utcOffset);
}
}
}Here's the results of a simple test:
DateTime rightNow = DateTime.Now;
DateTimeEx dEx1 = new DateTimeEx(rightNow, 0, 7);
DateTimeEx dEx2 = new DateTimeEx(rightNow, 0, 7);
DateTimeEx dEx3 = new DateTimeEx(rightNow, 230, 4);
Console.WriteLine(dEx1);
Console.WriteLine(dEx3);
Console.WriteLine(dEx1.Equals(dEx2));
Console.WriteLine(dEx1.Equals(dEx3)); I would hope what you would get from this is being able to use Parse, and ParseExact on the DateTime component, and, hopefully, save you from writing some of the overloads. But, whether you could use in the context of whatever your doing with SysLog: I ain't got a clue.
Hope this is helpful.
“But I don't want to go among mad people,” Alice remarked.
“Oh, you can't help that,” said the Cat: “we're all mad here. I'm mad. You're mad.”
“How do you know I'm mad?” said Alice.
“You must be," said the Cat, or you wouldn't have come here.” Lewis Carroll
|
|
|
|
|
BillWoodruff wrote: Based on the observation that all of your Properties, except milliseconds, are 'get only, I would say "yes," if you were willing to accept the limitations of inheriting from a data-structure like a Tuple<T1,T2,T3> ... given the fact that Tuple instances are immutable.
The read-only behavior will change soon, I only have to implement the value validation first.
BillWoodruff wrote: would hope what you would get from this is being able to use Parse, and ParseExact on the DateTime component,
I will almost certainly not be able to, since the UTC-Offset at the end (after the "Z") can't be handled by these functions. An overload may make sense, but will eventually end up in a big mess with the comparison operators.
I did some thinking myself in the meantime, and I consider an overloading of DateTime bein highly unusable, especially since DateTime has to present a Date/Time pair which may change, and a Timestamp has to represent a single Date/Time/UTC-Offset pair which is not going to change after its initialization (Apart from the problems of inheriting a struct which you already have mentioned).
Clean-up crew needed, grammar spill... - Nagy Vilmos
|
|
|
|
|
Marco Bertschi wrote: What I have done so far is that I consider System.DateTime being unuseable as timestamp,
You have effectively two 'layers' which needs a 'translation' layer in between.
That doesn't require a new timestamp class. What it requires is that you create functionality that parses (and formats if needed) and that goes in your translation layer. On the C# (application side) the input/output is a DateTime. On the syslog interface side it is a string.
|
|
|
|
|
jschell wrote: On the C# (application side) the input/output is a DateTime.
Yes, that's why the new class has a "FromDateTime(DateTime dateTime)"-Method.
jschell wrote: On the syslog interface side it is a string.
I am the one who provides the classes to serialize/deserialze the Syslog message, therefore a class might be useful, especially afterwards when showing the messages in the Logviewer (Ordering them by a timestamp type has almost certainly advantages over ordering them by a string which represents a timestamp).
I might be wrong in some point here (or I may not). I'll just go ahead and see what I'll learn. It's a side project which I do in my free time, so I am allowed to spend time making errors (and learning from them).
Clean-up crew needed, grammar spill... - Nagy Vilmos
|
|
|
|
|
Marco,
In your lounge post[^] you say that you imposing RFC5424[^] as the criteria. Based on the following format that I found online, you will not be able to properly store a RFC5424 timestamp in a DateTime structure due to the possibility of the TIME-SECFRAC being allowed to have up six digits. The DateTime structure can only accommodate milliseconds (3 digits).
Quote: TIMESTAMP = NILVALUE / FULL-DATE "T" FULL-TIME
FULL-DATE = DATE-FULLYEAR "-" DATE-MONTH "-" DATE-MDAY
DATE-FULLYEAR = 4DIGIT
DATE-MONTH = 2DIGIT ; 01-12
DATE-MDAY = 2DIGIT ; 01-28, 01-29, 01-30, 01-31 based on
; month/year
FULL-TIME = PARTIAL-TIME TIME-OFFSET
PARTIAL-TIME = TIME-HOUR ":" TIME-MINUTE ":" TIME-SECOND
[TIME-SECFRAC]
TIME-HOUR = 2DIGIT ; 00-23
TIME-MINUTE = 2DIGIT ; 00-59
TIME-SECOND = 2DIGIT ; 00-59
TIME-SECFRAC = "." 1*6DIGIT
TIME-OFFSET = "Z" / TIME-NUMOFFSET
TIME-NUMOFFSET = ("+" / "-") TIME-HOUR ":" TIME-MINUTE
You also have shown TimeStamp examples[^] that you say are valid. However these have decimal TIME-NUMOFFSET values instead of "Hours:Minutes"; again this conflicts with the specification. Is it your intent to allow these deviations?
Just courious, is there a reason that you have implemented your own GetDayMaxDaysOfMonth and Is LeapYear versus using those from the DateTimeStructure (DateTime.DaysInMonth[^], DateTime.IsLeapYear[^])?
|
|
|
|
|
TnTinMn wrote: In your lounge post[^] you say that you imposing RFC5424[^] as the criteria. Based on the following format that I found online, you will not be able to properly store a RFC5424 timestamp in a DateTime structure due to the possibility of the TIME-SECFRAC being allowed to have up six digits. The DateTime structure can only accommodate milliseconds (3 digits).
Thank you 
TnTinMn wrote: You also have shown TimeStamp examples[^] that you say are valid. However these have decimal TIME-NUMOFFSET values instead of "Hours:Minutes"; again this conflicts with the specification. Is it your intent to allow these deviations?
 I know that these are not valid examples, brain was off while typing
TnTinMn wrote: Just courious, is there a reason that you have implemented your own GetDayMaxDaysOfMonth and Is LeapYear versus using those from the DateTimeStructure (DateTime.DaysInMonth[^], DateTime.IsLeapYear[^])?
Pssst - I simply forgot about those
On the other hand side I didn't really bothered to check for something existing, since I had to learn the leap year rules anyways.
Clean-up crew needed, grammar spill... - Nagy Vilmos
|
|
|
|
|
Marco,
My statement "The DateTime structure can only accommodate milliseconds (3 digits)" was incorrect.  Sorry about that.
You can access higher resolution through the usage of the Ticks property that has a 100 nanosecond resolution[^].
You could use DateTime.TryParseExact with this format string: "yyyy-MM-dd\THH:mm:ss"
If that succeeds then, then you would need to extract the fractional second component (if it exists) as microseconds (upto 6 digits) and convert the microseconds to Ticks. Then you you can use the DateTime.AddTicks method on the DateTime value returned from the TryParseExact method.
I have put together a class to parse a TimeStamp string using this methodolgy and can make a copy of the code available if you are interested in it.
Yeah, its cold and I saw this as an interesting exercise. 
|
|
|
|
|
TnTinMn wrote: You could use DateTime.TryParseExact with this format string: "yyyy-MM-dd\THH:mm:ss"
If that succeeds then, then you would need to extract the fractional second component (if it exists) as microseconds (upto 6 digits) and convert the microseconds to Ticks. Then you you can use the DateTime.AddTicks method on the DateTime value returned from the TryParseExact method.
Which is very difficult.
The biggest problem starts when you try to parse the Miliseconds directly, as in DateTime.TryParseExact(yyyy-MM-dd\THH:mm:ss.fff) where fff defines the miliseconds. DateTime can't handle any conversion if the amount of 'f' is not equal to the amount of the miliseconds, e.g.
parsing 2014-02-13\15:33:12.12 with DateTime.TryParseExact(yyyy-MM-dd\HH:mm:ss.fff) would return false, which is a crucial problem in my case since the amount of miliseconds may differ between 0 and 100000.
Of course I could populate them prior to the conversion, but then I am better of with my own class where I have full control over the conversion.
TnTinMn wrote: I have put together a class to parse a TimeStamp string using this methodolgy and can make a copy of the code available if you are interested in it.
If you have it I'd love to see it. I have developed my own timestamp class a little further, here it is in case you are interested in it:
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace Springlog.Com.Messaging
{
public class SyslogTimestamp
{
#region Properties
static short GetDayMaxDaysOfMonth(int month, int year)
{
if (month != 2)
{
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
{
return 31;
}
else
{
return 30;
}
}
else
{
if (IsLeapYear(year))
{
return 29;
}
return 28;
}
}
private static bool IsLeapYear(int year)
{
if (year % 4 == 0)
{
if (year % 100 == 0)
{
if (year % 400 == 0)
{
return true;
}
return false;
}
return true;
}
return false;
}
int year;
public int Year
{
get { return year; }
}
int month;
public int Month
{
get { return month; }
}
int dayOfMonth;
public int DayOfMonth
{
get { return dayOfMonth; }
}
int hours;
public int Hours
{
get { return hours; }
}
int minutes;
public int Minutes
{
get { return minutes; }
}
int seconds;
public int Seconds
{
get { return seconds; }
}
int miliseconds;
public int Miliseconds
{
get { return miliseconds; }
}
double utcOffset;
public double UtcOffset
{
get { return utcOffset; }
set { utcOffset = value; }
}
#endregion
public SyslogTimestamp()
{
Reset();
}
public SyslogTimestamp(string timestamp)
{
Reset();
FromString(timestamp);
}
public SyslogTimestamp(DateTime timestamp)
{
Reset();
FromDateTime(timestamp);
}
private void Reset()
{
miliseconds = 0;
seconds = 0;
minutes = 0;
hours = 0;
dayOfMonth = 0;
month = 0;
year = 0;
utcOffset = 0;
}
public bool FromString(string dateTime)
{
Reset();
Regex splitRegex = new Regex(@"(\d{4})-(0?[1-9]|1[0-2])-([0-2]?\d|3[0-1])T?([0-1]?\d|2[0-3]):([0-5]?\d):([0-5]?\d)\.?(\d{0,6})?Z?([+-]?\d\.?\d?|\d{2}?|[0]?1[0-2]\.?\d?|\d{2}?)?", RegexOptions.IgnoreCase);
Match timestamp = splitRegex.Match(dateTime);
if (timestamp.Groups.Count == 9)
{
AddYears(Int32.Parse(timestamp.Groups[1].Value));
AddMonths(Int32.Parse(timestamp.Groups[2].Value));
AddDays(Int32.Parse(timestamp.Groups[3].Value));
AddHours(Int32.Parse(timestamp.Groups[4].Value));
AddMinutes(Int32.Parse(timestamp.Groups[5].Value));
AddSeconds(Int32.Parse(timestamp.Groups[6].Value));
if (!string.IsNullOrWhiteSpace(timestamp.Groups[7].Value))
{
AddMilliseconds(Int32.Parse(timestamp.Groups[7].Value));
}
if (!string.IsNullOrWhiteSpace(timestamp.Groups[8].Value))
{
utcOffset = Double.Parse(timestamp.Groups[8].Value, CultureInfo.InvariantCulture);
}
return true;
}
else
{
return false;
}
}
public string ToFormattedString()
{
string timezonePreSign = "Z";
if (utcOffset < 0)
{
timezonePreSign = "";
}
return string.Format("{0}-{1}-{2}T{3}:{4}:{5}.{6}{7}{8}", year, month, dayOfMonth, hours, minutes, seconds, miliseconds, timezonePreSign, utcOffset.ToString().Replace(',','.'));
}
public DateTime ToDateTime()
{
DateTimeKind dateTimeKind;
if(utcOffset == 0)
{
dateTimeKind = DateTimeKind.Utc;
}
else
{
dateTimeKind = DateTimeKind.Local;
}
return new DateTime(year, month, dayOfMonth, hours, minutes, seconds, miliseconds, dateTimeKind);
}
public override string ToString()
{
return this.ToFormattedString();
}
public void FromDateTime(DateTime timestamp)
{
TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(timestamp);
this.utcOffset = utcOffset.Hours + (utcOffset.Minutes / 100);
AddMilliseconds(timestamp.Millisecond);
AddSeconds(timestamp.Second);
AddMinutes(timestamp.Minute);
AddHours(timestamp.Hour);
AddDays(timestamp.Day);
AddMonths(timestamp.Month);
AddYears(timestamp.Year);
}
public void Add(TimeSpan timeSpan)
{
AddMilliseconds(timeSpan.Milliseconds);
AddSeconds(timeSpan.Seconds);
AddMinutes(timeSpan.Minutes);
AddHours(timeSpan.Hours);
AddDays(timeSpan.Days);
}
public void AddMilliseconds(int val)
{
if (val + miliseconds >= 1000)
{
AddSeconds( val / 1000);
miliseconds = (val % 1000);
}
else
{
miliseconds += val;
}
}
private void AddSeconds(int val)
{
if (seconds + val >= 60)
{
AddMinutes(val / 60);
seconds = (val % 60);
}
else
{
seconds += val;
}
}
private void AddMinutes(int val)
{
if (minutes + val >= 60)
{
AddMinutes(val / 60);
minutes = (val % 60);
}
else
{
minutes += val;
}
}
private void AddHours(int val)
{
if (hours + val >= 24)
{
AddDays (val / 24);
hours = (val % 24);
}
else
{
hours += val;
}
}
private void AddDays(int val)
{
short dayCount = GetDayMaxDaysOfMonth(month, year);
if (dayOfMonth + val > dayCount)
{
AddMonths(val / dayCount);
dayOfMonth = (val % dayCount);
}
else
{
dayOfMonth += val;
}
}
private void AddMonths(int val)
{
if (month + val > 12)
{
AddYears(val / 12);
month = (val % 12);
}
else
{
month += val;
}
}
private void AddYears(int val)
{
year += val;
}
public override bool Equals(object o)
{
if (o is SyslogTimestamp)
{
return DoMatch((SyslogTimestamp)o, this);
}
else
{
return false;
}
}
public static bool DoMatch(SyslogTimestamp a, SyslogTimestamp b)
{
bool doMatch = (a.year == b.Year)
&& (a.month == b.Month)
&& (a.dayOfMonth == b.DayOfMonth)
&& (a.hours == b.Hours)
&& (a.minutes == b.Minutes)
&& (a.seconds == b.Seconds)
&& (a.miliseconds == b.Miliseconds)
&& (a.utcOffset == b.UtcOffset);
return doMatch;
}
public static bool operator ==(SyslogTimestamp a, SyslogTimestamp b)
{
if (System.Object.ReferenceEquals(a, b))
{
return true;
}
if (((object)a == null) || ((object)b == null))
{
return false;
}
return DoMatch(a, b);
}
public static bool operator !=(SyslogTimestamp a, SyslogTimestamp b)
{
return !(a == b);
}
public static bool operator <(SyslogTimestamp a, SyslogTimestamp b)
{
if (a.Year < b.Year) { return true; }
if (a.Year > b.Year) { return false; }
if (a.Month < b.Month) { return true; }
if (a.Month > b.Month) { return false; }
if (a.DayOfMonth < b.DayOfMonth) { return true; }
if (a.DayOfMonth > b.DayOfMonth) { return false; }
if ((a.Hours + a.UtcOffset) < (b.Hours + b.UtcOffset)) { return true; }
if ((a.Hours + a.UtcOffset) > (b.Hours + b.UtcOffset)) { return false; }
if (a.Minutes < b.Minutes) { return true; }
if (a.Minutes > b.Minutes) { return false; }
if (a.Seconds < b.Seconds) { return true; }
if (a.Seconds > b.Seconds) { return false; }
if (a.Miliseconds < b.Miliseconds) { return true; }
if (a.Miliseconds > b.Miliseconds) { return false; }
return false;
}
public static bool operator >(SyslogTimestamp a, SyslogTimestamp b)
{
if (a.Year > b.Year) { return true; }
if (a.Year < b.Year) { return false; }
if (a.Month > b.Month) { return true; }
if (a.Month < b.Month) { return false; }
if (a.DayOfMonth > b.DayOfMonth) { return true; }
if (a.DayOfMonth < b.DayOfMonth) { return false; }
if ((a.Hours + a.UtcOffset) > (b.Hours + b.UtcOffset)) { return true; }
if ((a.Hours + a.UtcOffset) < (b.Hours + b.UtcOffset)) { return false; }
if (a.Minutes > b.Minutes) { return true; }
if (a.Minutes < b.Minutes) { return false; }
if (a.Seconds > b.Seconds) { return true; }
if (a.Seconds < b.Seconds) { return false; }
if (a.Miliseconds > b.Miliseconds) { return true; }
if (a.Miliseconds < b.Miliseconds) { return false; }
return false;
}
public static bool operator >=(SyslogTimestamp a, SyslogTimestamp b)
{
return (a > b) || DoMatch(a, b);
}
public static bool operator <=(SyslogTimestamp a, SyslogTimestamp b)
{
return (a < b) || DoMatch(a, b);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
}
Clean-up crew needed, grammar spill... - Nagy Vilmos
|
|
|
|
|
This is real simple now especially after I noticed the other overload on TryParseExact that takes an array of formats to test.
string[] formats = { "yyyy-MM-dd\\THH:mm:ss\\Z",
"yyyy-MM-dd\\THH:mm:ss.f\\Z",
"yyyy-MM-dd\\THH:mm:ss.ff\\Z",
"yyyy-MM-dd\\THH:mm:ss.fff\\Z",
"yyyy-MM-dd\\THH:mm:ss.ffff\\Z",
"yyyy-MM-dd\\THH:mm:ss.fffff\\Z",
"yyyy-MM-dd\\THH:mm:ss.ffffff\\Z",
"yyyy-MM-dd\\THH:mm:sszzz",
"yyyy-MM-dd\\THH:mm:ss.fzzz",
"yyyy-MM-dd\\THH:mm:ss.ffzzz",
"yyyy-MM-dd\\THH:mm:ss.fffzzz",
"yyyy-MM-dd\\THH:mm:ss.ffffzzz",
"yyyy-MM-dd\\THH:mm:ss.fffffzzz",
"yyyy-MM-dd\\THH:mm:ss.ffffffzzz"
};
DateTime dt1 = default(DateTime);
bool res1 = System.DateTime.TryParseExact("1985-04-12T20:20:59.100000-00:15",
formats, System.Globalization.CultureInfo.InvariantCulture,
System.Globalization.DateTimeStyles.AdjustToUniversal,
out dt1);
DateTime dt2 = default(DateTime);
bool res2 = System.DateTime.TryParseExact("1985-04-12T20:20:59.100001-00:15",
formats, System.Globalization.CultureInfo.InvariantCulture,
System.Globalization.DateTimeStyles.AdjustToUniversal,
out dt2);
Console.WriteLine(dt1.Kind.ToString());
Console.WriteLine(dt1.ToString("u"));
Console.WriteLine((dt1 < dt2).ToString());
This code works, but has the drawback of loosing the original offsets as everything gets adjusted to UTC.
You can maintain the original offset date by using the DateTimeOffset [^]structure (this structure has all the functionality that I so foolishly recreated by custom parsing).  Oh, well it was fun to see if I could do it.
DateTimeOffset dto1 = new DateTimeOffset();
bool res1b = System.DateTimeOffset.TryParseExact("1985-04-12T20:20:59.100000-00:15",
formats,
System.Globalization.CultureInfo.InvariantCulture,
System.Globalization.DateTimeStyles.AssumeLocal,
out dto1);Notice the change to AssumeLocal. The DateTime and Offset properties can then be used to recreate the original string.
|
|
|
|
|
I have a file in which each line has a fixed length 1600 char
but each line has its there are different columns
Line 1 will be like this
RA01XYZ--------------------------------------------------------------------201401231
RA is Record Type
01 is Version
XYZ------------------ is client name
201401231 is date
now 2 line
SR0123456789-------------------------011234567890-
SR is record type
0123456789------------------------- is some number
You see that each line will have its own set of defined columns and it cannot be fixed width
So my question is, is it possible/advisable to apply SSIS on this or create a simple win form application using REGEX to extract and process the data.
|
|
|
|
|
Regex? No, Substring(start, length).
Read a whole line, determine the "line type", and then get its data into appropriate objects which you then insert into the db.
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
