Dotnet Rocks

Formatting the Date by using String.Format() Method

2010-08-16T23:34:00.000-07:00

custom format specifiers

y (year), M (month), d (day), h (hour 12), H (hour 24), m (minute), s (second), f (second fraction), F (second fraction, trailing zeroes are trimmed), t (P.M or A.M) and z (time zone).

// create date time 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);

String.Format("{0:y yy yyy yyyy}", dt);            // "8 08 008 2008" year
String.Format("{0:M MM MMM MMMM}", dt); // "3 03 Mar March" month
String.Format("{0:d dd ddd dddd}", dt);            // "9 09 Sun Sunday" day
String.Format("{0:h hh H HH}", dt);                 // "4 04 16 16" hour 12/24
String.Format("{0:m mm}", dt);                       // "5 05" minute
String.Format("{0:s ss}", dt);                          // "7 07" second
String.Format("{0:f ff fff ffff}", dt);                      // "1 12 123 1230" sec.fraction
String.Format("{0:F FF FFF FFFF}", dt);         // "1 12 123 123" without zeroes
String.Format("{0:t tt}", dt);                            // "P PM" A.M. or P.M.
String.Format("{0:z zz zzz}", dt);                   // "-6 -06 -06:00" time zone

String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - english (en-US)

examples of custom date and time formatting:

// month/day numbers without/with leading zeroes
String.Format("{0:M/d/yyyy}", dt); // "3/9/2008"
String.Format("{0:MM/dd/yyyy}", dt); // "03/09/2008"

// day/month names
String.Format("{0:ddd, MMM d, yyyy}", dt); // "Sun, Mar 9, 2008"
String.Format("{0:dddd, MMMM d, yyyy}", dt); // "Sunday, March 9, 2008"

// two/four digit year
String.Format("{0:MM/dd/yy}", dt); // "03/09/08"
String.Format("{0:MM/dd/yyyy}", dt); // "03/09/2008"

Standard DateTime Formatting

Specifier	DateTimeFormatInfo property	Pattern value (for en-US culture)
t	ShortTimePattern	h:mm tt
d	ShortDatePattern	M/d/yyyy
T	LongTimePattern	h:mm:ss tt
D	LongDatePattern	dddd, MMMM dd, yyyy
f	(combination of D and t)	dddd, MMMM dd, yyyy h:mm tt
F	FullDateTimePattern	dddd, MMMM dd, yyyy h:mm:ss tt
g	(combination of d and t)	M/d/yyyy h:mm tt
G	(combination of d and T)	M/d/yyyy h:mm:ss tt
m, M	MonthDayPattern	MMMM dd
y, Y	YearMonthPattern	MMMM, yyyy
r, R	RFC1123Pattern	ddd, dd MMM yyyy HH':'mm':'ss 'GMT' ()*
s	SortableDateTimePattern	yyyy'-'MM'-'dd'T'HH':'mm':'ss ()*
u	UniversalSortableDateTimePattern	yyyy'-'MM'-'dd HH':'mm':'ss'Z' ()*
		() = culture independent*

Examples:

String.Format("{0:d}", dt); // "3/9/2008" ShortDate
String.Format("{0:T}", dt); // "4:05:07 PM" LongTime
String.Format("{0:D}", dt); // "Sunday, March 09, 2008" LongDate
String.Format("{0:f}", dt); // "Sunday, March 09, 2008 4:05 PM" LongDate+ShortTime
String.Format("{0:F}", dt); // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt); // "3/9/2008 4:05 PM" ShortDate+ShortTime
String.Format("{0:G}", dt); // "3/9/2008 4:05:07 PM" ShortDate+LongTime
String.Format("{0:m}", dt); // "March 09" MonthDay
String.Format("{0:y}", dt); // "March, 2008" YearMonth
String.Format("{0:r}", dt); // "Sun, 09 Mar 2008 16:05:07 GMT" RFC1123
String.Format("{0:s}", dt); // "2008-03-09T16:05:07" SortableDateTime
String.Format("{0:u}", dt); // "2008-03-09 16:05:07Z" UniversalSortableDateTime

Copy Constructor

2010-03-18T22:57:00.001-07:00

C# does not provide a copy constructor by itself. But, You can create a new object and want to copy the values from an existing object to a newly created object,

Example,

class Student
{
private string name;

       /// Instance constructor

       public Student(string name)
       {
           this.name = name;`
       }

       /// Copy constructor.

        public Student(Student student)
        {
            this.name = student.name;
        }

        public string Name
        {
            get
           {
              return name;
           }
            set
           {
               name = value;
           }
       }
}

class Final
{
static void Main()
{

/// Create a new object of Student Class
Student student = new Student ("A");

/// Create a new object , and then copy the class “Student” to “NewStudent”
Student NewStudent = new Student (student);

        student.Name = "B";
        System.Console.WriteLine("The new student's name is {0}", NewStudent.Name);
      }
}

Serialization

2010-03-09T19:35:00.001-08:00

When we write an application the data is stored in the memory. Think you want that data to be stored elsewhere or transport it from one process into another process or to some other location. You could transfer or store the data as binary data / xml / and some proprietary format.

Serialization is the process of converting an object /many objects into a stream of bytes.

De-serialization is the process of converting a stream of bytes back into its “live” objects in memory. But, it’s a difficult process than serialization. Since the structure of the object is not known to the user.

Serialization and De - Serialization are typically used to:

1. Transmit objects across a network or application boundary.

2. Store representations of objects within a file or database.

.net provides rich support for serialization and De-serialization.

Here are some of the examples: -

1. An application state can easily be saved in a disk file or database and then restored the next time the application is run.

2. A set of objects can easily be copied to the system’s clipboard and then pasted into the same or another application.

3. A set of objects can be cloned and set aside as a backup while a user manipulates the main set of objects.

4. A set of objects can easily be sent over the network to a process running on another machine.

5. When an object is serialized, it is quite easy to process the data in many useful ways like Compressing and encrypting the data.

Serialization Vs Persistence

1. Terms aren’t identical in .NET

a. Serialization refers to transforming an object or group of objects into a stream of bytes that can be saved or moved.

i. No specific storage implied by Serialization.

b. Persistence refers to saving data to permanent storage (Disk Storage/Database).

2. We can serialize an object to a memory stream.

a. And then persist the MemoryStream to a disk file.

.Net Framework and Serialization

.net framework includes support for serializing all the base types, which also include data structures.

Introduction to formatter objects
Formatters are mainly used to convert objects into different format of data.

1. Formatters accept object / objects and serialize to a stream of bytes (implement IFormatter).

2. Different formatters provide different results.

3. There are two built-in formatters:

a. BinaryFormatter: takes the input and emits all bytes of object(s) in a continuous stream.

b. SoapFormatter: serializes data into human readable XML format, using SOAP specification.

i. This is slightly slower and certainly results in larger output. I.e. for each byte of information the process results in many bytes of data.

c. To use this SoapFormatter, we need to add reference to “Serialization.Formatters.SOAP.dll”.

d. To serialize a object :

i. Create a new IFormatter object (i.e. Binary/ soap formatter).

ii. Call IFormatter objects serialize method, which takes a reference to a stream object, and the object to be serialized.

iii. Stream object can be anything that derives from System.IO.Stream (Memory, File, Network and any other).

iv. The formatter will return the stream of bytes as of data of any format.

e. .Net formatters can

i. Handle nested and circular references (i.e. first object containing references to second objects and the second object have references to the first object).

ii. Handle public and private member of classes.

iii. Also can handle multiple references to a single object. Complex objects that as multiple references to a single object. It doesn’t send out serialized output. but multiple copies it sends out multiple references/pointers to that single object.

Use const and readonly

2010-03-05T12:29:00.001-08:00

Both const and readonly are used to define data that does not change.

Differences :

const must be defined at declaration and the value cannot be changed once it is assigned, it implies that they belong to the type as static fields.

readonly fields can be set at declaration or in the constructor and nowhere else.

Example :

public class Test
{
private const string Name = “Test”;
private readonly int ver;

       public Test()
       {
             ver = 10;//Ok
       }

       public void Function()
       {
              ver = 13;//Error!
       }
}

First Post

2010-02-23T01:22:00.000-08:00

Hai Every one.

I am Basically a .Net developer.

This is my first post.

From now on i will be posting my view towards Microsoft Technologies.

Any Feedbacks feel free to mail me.

ENJOY READING