C#

jschell wrote:

On the C# (application side) the input/output is a DateTime.

jschell wrote:

On the syslog interface side it is a string.

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

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).

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?

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[^])?

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.

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.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Springlog.Com.Messaging
{
    /// <summary>
    /// Represents the Timestamp of a <see cref="SyslogMessageHeader"/>
    /// Author: Marco Bertschi, (C) 2014 Marco Bertschi
    /// </summary>
    public class SyslogTimestamp
    {
        #region Properties
        /// <summary>
        /// Returns the count of the days for a specific month in a specific year.
        /// </summary>
        /// <param name="month">month  </param>
        /// <param name="year">year</param>
        /// <returns></returns>
        static short GetDayMaxDaysOfMonth(int month, int year)
        {
            if (month != 2)
            {
                //  January       March         May           July          August        October        December
                if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
                {
                    return 31;
                }
                else // April, June, September, November
                {
                    return 30;
                }
            }
            else //February
            {
                if (IsLeapYear(year))
                {
                    return 29;
                }
                return 28;
            }
        }
        /// <summary>
        /// Returns true if the argument is a leap year
        /// </summary>
        /// <param name="year">The year number to check</param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// The part of the Timestamp which represents the year.
        /// </summary>
        int year;
        /// <summary>
        /// Gets the year part of the Timestamp.
        /// </summary>
        public int Year
        {
            get { return year; }
        }
        /// <summary>
        /// The part of the Timestamp which represents the month.
        /// </summary>
        int month;
        /// <summary>
        /// Gets the month part of the Timestamp.
        /// </summary>
        public int Month
        {
            get { return month; }
        }
        /// <summary>
        /// The part of the Timestamp which represents the day of the month.
        /// </summary>
        int dayOfMonth;
        /// <summary>
        /// Gets the days part of the Timestamp.
        /// </summary>
        public int DayOfMonth
        {
            get { return dayOfMonth; }
        }
        /// <summary>
        /// The part of the Timestamp which represents the hours.
        /// </summary>
        int hours;
        /// <summary>
        /// Gets the hours part of the Timestamp.
        /// </summary>
        public int Hours
        {
            get { return hours; }
        }
        /// <summary>
        /// The part of the Timestamp which represents the minutes.
        /// </summary>
        int minutes;
        /// <summary>
        /// Gets the minutes part of the Timestamp.
        /// </summary>
        public int Minutes
        {
            get { return minutes; }
        }
        /// <summary>
        /// The part of the Timestamp which represents the seconds.
        /// </summary>
        int seconds;
        /// <summary>
        /// Gets the seconds part of the Timestamp.
        /// </summary>
        public int Seconds
        {
            get { return seconds; }
        }
        /// <summary>
        /// The part of the Timestamp which represents the year.
        /// </summary>
        int miliseconds;
        /// <summary>
        /// Gets the milliseconds part of the Timestamp.
        /// </summary>
        public int Miliseconds
        {
            get { return miliseconds; }
        }
        /// <summary>
        /// The offset from the UTC timezone
        /// </summary>
        double utcOffset;
        /// <summary>
        /// Gets or sets the offset from the UTC timezone.
        /// </summary>
        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);
        }

        /// <summary>
        /// Resets all fields to their default values;
        /// </summary>
        private void Reset()
        {
            miliseconds = 0;
            seconds = 0;
            minutes = 0;
            hours = 0;
            dayOfMonth = 0;
            month = 0;
            year = 0;
            utcOffset = 0;
        }

        /// <summary>
        /// Parses a string into a Syslog timestamp.
        /// </summary>
        /// <param name="dateTime">string which is going to be parsed</param>
        /// <returns>true = success | false = invalid string</returns>
        public bool FromString(string dateTime)
        {
            Reset();// All fields must be resetted - Otherwise the parsing will give a wrong value!
            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;
            }
        }
        /// <summary>
        /// Returns a fully formatted Syslog timestamp, as string.
        /// </summary>
        /// <returns>Syslog timestamp, as string</returns>
        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);
        }

        /// <summary>
        /// Overriden ToString() method - Displays the same as ToFormattedString().
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return this.ToFormattedString();
        }
        /// <summary>
        /// Parses a <see cref="System.DateTime"/> type to a <see cref="SyslogTimestamp"/>. It is assumed that the
        /// DateTime type must be converted to UTC if the second argument is left out.
        /// </summary>
        /// <remarks>
        /// The FromDateTime method recognizes only the current daylight saving time adjustment rule for the local time zone.
        /// As a result, it is guaranteed to accurately return the UTC offset of a local time only during the period in which the
        /// latest adjustment rule is in effect. It may return inaccurate results if time is a historic date and time value
        /// that was subject to a previous adjustment rule.
        /// </remarks>
        /// <param name="timestamp">The <see cref="System.DateTime"/> type which will be parsed</param>
        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);
        }

        /// <summary>
        /// Adds a <see cref="System.TimeSpan"/> to the timestamp
        /// </summary>
        /// <param name="timeSpan">The time span which is added to the Timestamp</param>
        public void Add(TimeSpan timeSpan)
        {
            AddMilliseconds(timeSpan.Milliseconds);
            AddSeconds(timeSpan.Seconds);
            AddMinutes(timeSpan.Minutes);
            AddHours(timeSpan.Hours);
            AddDays(timeSpan.Days);
        }
        /// <summary>
        /// Adds the passed millisecond value to the timestamp
        /// </summary>
        /// <param name="val">Added milliseconds</param>
        public void AddMilliseconds(int val)
        {
            if (val + miliseconds >= 1000)
            {
                AddSeconds( val / 1000);
                miliseconds = (val % 1000);
            }
            else
            {
                miliseconds += val;
            }
        }
        /// <summary>
        /// Adds the passed second value to the timestamp
        /// </summary>
        /// <param name="val">Added seconds</param>
        private void AddSeconds(int val)
        {
            if (seconds + val >= 60)
            {
                AddMinutes(val / 60);
                seconds = (val % 60);
            }
            else
            {
                seconds += val;
            }
        }
        /// <summary>
        /// Adds the passed minute value to the timestamp
        /// </summary>
        /// <param name="val">Added minutes</param>
        private void AddMinutes(int val)
        {
            if (minutes + val >= 60)
            {
                AddMinutes(val / 60);
                minutes = (val % 60);
            }
            else
            {
                minutes += val;
            }
        }
        /// <summary>
        /// Adds the passed hour value to the timestamp
        /// </summary>
        /// <param name="val">Added hours</param>
        private void AddHours(int val)
        {
            if (hours + val >= 24)
            {
                AddDays (val / 24);
                hours = (val % 24);
            }
            else
            {
                hours += val;
            }
        }
        /// <summary>
        /// Adds the passed days value to the timestamp
        /// </summary>
        /// <param name="val">Added days</param>
        private void AddDays(int val)
        {
            short dayCount = GetDayMaxDaysOfMonth(month, year);
            if (dayOfMonth + val > dayCount)
            {
                AddMonths(val / dayCount);
                dayOfMonth = (val % dayCount);
            }
            else
            {
                dayOfMonth += val;
            }
        }
        /// <summary>
        /// Adds the passed month value to the timestamp
        /// </summary>
        /// <param name="val">Added months</param>
        private void AddMonths(int val)
        {
            if (month + val > 12)
            {
                AddYears(val / 12);
                month = (val % 12);
            }
            else
            {
                month += val;
            }
        }
        /// <summary>
        /// Adds the passed value to the year part of the time stamp
        /// </summary>
        /// <param name="val">Years to be added</param>
        private void AddYears(int val)
        {
            year += val;
        }

        /// <summary>
        /// Returns true if the the parameter matches this instance.
        /// </summary>
        /// <remarks>
        /// See <see cref="DoMatch"/>
        /// </remarks>
        /// <param name="other">The parameter to compare</param>
        /// <returns>true|false</returns>
        public override bool Equals(object o)
        {
            if (o is SyslogTimestamp)
            {
                return DoMatch((SyslogTimestamp)o, this);
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Returns true if a & b match, else false.
        /// </summary>
        /// <remarks>
        /// Match criteria:
        /// (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);
        /// </remarks>
        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;
        }
        /// <summary>
        /// The overloaded == operator
        /// </summary>
        /// <remarks>
        /// see http://msdn.microsoft.com/en-us/library/ms173147(v=vs.80).aspx
        /// </remarks>
        public static bool operator ==(SyslogTimestamp a, SyslogTimestamp b)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(a, b))
            {
                return true;
            }

            // If one is null, but not both, return false.
            if (((object)a == null) || ((object)b == null))
            {
                return false;
            }

            return DoMatch(a, b);
        }
        /// <summary>
        /// The overloaded != operator.
        /// </summary>
        /// <remarks>
        /// see http://msdn.microsoft.com/en-us/library/ms173147(v=vs.80).aspx
        /// </remarks>
        public static bool operator !=(SyslogTimestamp a, SyslogTimestamp b)
        {
            return !(a == b);
        }
        /// <summary>
        /// The smaller than Operator
        /// compares every date|time related field with
        /// the other and returns true if the left hand side of
        /// the assignement is smaller than the right hand side
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// The greater than Operator
        /// compares every date|time related field with
        /// the other and returns true if the left hand side of
        /// the assignement is greater than the right hand side
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// greater or equal Operator
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns>(a > b) || DoMatch(a, b)</returns>
        public static bool operator >=(SyslogTimestamp a, SyslogTimestamp b)
        {
            return (a > b) || DoMatch(a, b);
        }
        /// <summary>
        /// smaller or equal Operator
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns><code>(a { b) || DoMatch(a, b)</code></returns>
        public static bool operator <=(SyslogTimestamp a, SyslogTimestamp b)
        {
            return (a < b) || DoMatch(a, b);
        }

        /// <summary>
        /// Returns the Hash code of the object
        /// </summary>
        /// <returns>Hash code</returns>
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}

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()); // yep UTC
Console.WriteLine(dt1.ToString("u"));
Console.WriteLine((dt1 < dt2).ToString()); // 1 µsec less

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);

Bernhard Hiller wrote:

get its data into appropriate objects

Source[^]

Northwind Database is a sample database that is shipped along with Microsoft Access application. Basically, the database is about a company named "Northwind Traders". The database captures all the sales transactions that occurs between the company i.e. Northwind traders and its customers as well as the purchase transactions between Northwind and its suppliers.

public enum Suit
    {
    Spades = 0,
    Diamonds = 1,
    Clubs = 2,
    Hearts = 3,
    }
public class Card
    {
    private int _Value;
    public Suit Suit { get { return (Suit)(_Value / 13); } }
    public int Value { get { return _Value % 13; } }
    public Card(int value)
        {
        if (value < 0 || value >= 52)
            {
            throw new ArgumentException("Invalid Card : " + value);
            }
        _Value = value;
        }
    }

private List<Card> deck = new List<Card>();
private Random rand = new Random();
private Card GetNextCard(List<Card> deck)
    {
    if (deck.Count <= 0)
        {
        Enumerable.Range(0, 52).Select(c => new Card(c)).ToList();
        deck = Shuffle(deck);
        }
    Card card = deck[0];
    deck.RemoveAt(0);
    //deck.Add(card); //Uncomment this line to return cards to the bottom of the deck.
    return card;
    }
private List<Card> Shuffle(List<Card> deck)
    {
    List<Card> shuffled = new List<Card>();
    int cards = deck.Count;
    for (int i = 0; i < cards; i++)
        {
        int index = rand.Next(deck.Count);
        shuffled.Add(deck[index]);
        deck.RemoveAt(index);
        }
    return shuffled;
    }

Card c1 = GetNextCard(deck);
Card c2 = GetNextCard(deck);
Card c3 = GetNextCard(deck);
Card c4 = GetNextCard(deck);

using System;

namespace Draw4
{
    class Program
    {
        static int[] ranData = new int[4];
        static Random ran = new Random();
        static int[] KS = new int[4];

        static int GenerateRandomNum()
        {
            int cleanRanNum;
            cleanRanNum = ran.Next(1, 53);
            
            // Prevent cards from repeating

            return cleanRanNum;
        }
        static void Main(string[] args)
        {
            int idx, ranNum;
            int[] cdv = new int[4]; // 1-13
            int[] cds = new int[4]; // 1-4
            for (idx = 0; idx < 4; idx++) KS[idx] = 0;
            // loop 10,000 times
            //for (int lp = 0; lp < 10000; lp++)
            {
                // Draw 4 cards

                Console.Write("Random numbers: \t");
                for (idx = 0; idx < cdv.Length; idx++)
                {
                    ranNum = GenerateRandomNum();

                    Console.Write(ranNum + ",\t");
                    cdv[idx] = ranNum % 13;
                    if (cdv[idx] == 0)
                    {
                        cds[idx] = ranNum / 13;
                        cdv[idx] = 13;
                    }
                    else
                        cds[idx] = ranNum / 13 + 1;

                }
                Array.Sort(cdv);
                Console.Write("\nThe suits:\t\t");
                PrintingSuits(cds);
                Console.Write("\nThe values:\t\t");

                foreach (int val in cdv) Console.Write(val + ",\t");
                CountSuits(cds);
            }
            Console.Read();
        }
        static void CountSuits(int[] cds)
        {
            Array.Sort(cds);
            int howManySuits = 0;
            for (int j = 0; j < 3; j++)
                if (cds[j] != cds[j + 1]) howManySuits++;
            Console.WriteLine("\nThis hand has {0} suits", howManySuits + 1);
            return;

        }
        static void PrintingSuits(int[] suit)
        {
            string s = " ";
            foreach (int su in suit)
            {

                switch (su)
                {
                    case 1: s = "H"; break;
                    case 2: s = "S"; break;
                    case 3: s = "D"; break;
                    case 4: s = "C"; break;
                }

                Console.Write(s + ",\t");
            }
        }
    }
}

for (idx = 0; idx < cdv.Length; idx++)
{
    cdv[idx] = GetNext(deck);
    Console.WriteLine(cdv[idx]);
}