Extension method vb.net vs c#

Leave a comment

c#
////////////////

public static class Extensions
{
    public static string GetFirstThreeCharacters(this String str)
    {
        if(str.Length < 3)
        {
            return str;
        }
        else
        {
            return str.Substring(0,3);
        }
    }
}

vb.net

<System.Runtime.CompilerServices.Extension> _
Public Function GetFirstThreeCharacters(Byval str As String) As String
If str.Length < 3 Then
	Return str
Else
	Return str.Substring(0, 3)
End If
End Function

oop features in vb6
//////////////////////
http://cs.iupui.edu/~aharris/avb/avb4/oop.html

https://books.google.co.th/books?id=kVqB5hjNsScC&pg=PA345&lpg=PA345&dq=visual+basic+6+oop&source=bl&ots=19WwyyRM-D&sig=sC5sSwF-kfDbTW5NIKu8oAd3mHI&hl=en&sa=X&ved=0ahUKEwjtqrHMp5HKAhXECo4KHbkIB4cQ6AEIVTAJ#v=onepage&q=visual%20basic%206%20oop&f=false

Advertisements

dataset vs collection

Leave a comment

  • DataTable and DataSet are heavy weight comparitively using List Collection.
  • List<Emp> enables you to maintain the safe type. So You no need to do typecasting anytime.
  • It’s prefarable not to use DataSet and DataTable while your data is flowing between the layers as I mentioned in point1
  • Java(any other than .NET languages) can not understand DataSet and DataTable while throwing from WebService or WCF. so it’s easy to convert the List<Emp> to Emp Array and throw it to Java. Java can understand simple clases and arrays.

Best practice – Dispose

Leave a comment

Use built-in keyword in C# as a shortcut for this particular pattern of using
an IDisposable object and calling Dispose when it goes out of scope: the using
keyword


// Example use
using (MyClass data = new MyClass())
                {
                    this.Store1.DataSource = data.getData();
                    this.Store1.DataBind();
                }

public class MyClass : IDisposable
    {
        private object resource1; // pointer for a resource
        private object resource2; // other resource you use
        private bool disposed = false;

        // implements IDisposable
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                // if this is a dispose call dispose on all state you
                // hold, and take yourself off the Finalization queue.
                if (disposing)
                {
                    if (resource1 != null)
                    {
                        ((IDisposable)resource1).Dispose();
                        resource1 = null;
                    }

                    if (resource2 != null)
                    {
                        ((IDisposable)resource2).Dispose();
                        resource2 = null;
                    }
                }
                this.disposed = true;
            }
        }

        // finalizer simply calls Dispose(false)
        ~MyClass()
        {
            Dispose(false);
        }

JSon Serialize Deserialize

Leave a comment

public class JsonHelper
    {   
        /// <summary>
        /// JSON Serialization
        /// </summary>
        public static string JsonSerializer<T>(T t)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            MemoryStream ms = new MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            return jsonString;
        }
        /// <summary>
        /// JSON Deserialization
        /// </summary>
        public static T JsonDeserialize<T>(string jsonString)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            T obj = (T)ser.ReadObject(ms);
            return obj;
        }
    }

// usage
// collection
            IList<Person> pList = new List<Person>(){
                new Person(){ firstName="chutchai.kp", email="chutchai.kp@gmail.com", grade=13},
                new Person(){ firstName="chutchai", email="chutchai.kp@gmail.com", grade=13},
                new Person(){ firstName="kp", email="chutchai.kp@gmail.com", grade=13}
            };

            // to string
            string jsonString = JsonHelper.JsonSerializer<IList<Person>>(pList);             
            Console.WriteLine(jsonString); // output ***

            // to object
            var obj = JsonHelper.JsonDeserialize<IList<Person>>(jsonString);

            Console.Read();

Serialize Deserialize

Leave a comment

ปกติแล้ว Object ที่เราสร้างขึ้นจะเก็บไว้ใน memory เพราะฉะนั้น ช่วงชีวิตมากที่สุดของมันก็จะอยู่จนกว่าโปรแกรมมันจะหยุดทำงาน คิดดูหากว่า เราสามารถเก็บ state ของมัน ไปใช้ได้ต่อ เมื่อโปรแกรมกลับมาทำงานใหม่ หรือสามารถส่ง Object เหล่านั้นไปที่อื่นได้

ปัญหามันจะเกิดก็ต่อเมื่อเราพยายามจะส่ง Object ข้ามเครื่องกัน ซึ่งเครื่องแต่ละเครื่องก็สถาปัตยกรรม แตกต่างกัน การจัดการ byte ก็แตกต่างกัน ซึ่งถ้าไม่มี Serializable แล้ว เราจะต้องมาจัดการกันเอาเอง ซึ่งคงเป็นเรื่องน่าปวดหัวมาก

Serializable จึงเข้ามาช่วยจัดการตรงนี้ให้ ทำให้เราสามารถโฟกัสไปที่ bussiness ของเรา ไม่ต้องมาปวดหัวเป็นห่วงเรื่อง conflict ที่อาจจะเกิดขึ้น

Serializable เป็นแค่ marker interface เพราะฉะนั้นเราไม่ต้อง implement method อะไรเพิ่ม class ที่สำคัญส่วนใหญ่ก็จะ implement Serializable ไว้หมดแล้ว เช่น String เป็นต้น

// collection
            IList<Person> pList = new List<Person>(){
                new Person(){ firstName="chutchai.kp", email="chutchai.kp@gmail.com", grade=13},
                new Person(){ firstName="chutchai", email="chutchai.kp@gmail.com", grade=13},
                new Person(){ firstName="kp", email="chutchai.kp@gmail.com", grade=13}
            };

            // to string
            XmlSerializer x = new XmlSerializer(pList.GetType());
            TextWriter tw = new StringWriter();
            x.Serialize(tw, pList); // tw is output
            //Console.WriteLine(tw.ToString()); // output ***

            // to object (collection)
            TextReader re = new StringReader(tw.ToString());
            var obj = x.Deserialize(re);

            Console.Read();

Generic fast search and sort by delegate, anonymous method, or lamda expression

Leave a comment

// Search
///////////////////////////////////
List<Student> student1 = this.StudentList.FindAll(delegate(Student s) { return s.name.Contains("xxx"); });
// or
List<Student> student2 = this.StudentList.FindAll(o => o.name.Contains("xxx"));
// Sort
                ///////////////////////////////////
                student2.Sort(
                            delegate(Student s1, Student s2)
                            {
                                return s1.name.CompareTo(s2.name);
                            });

                // or
                student2.Sort((x, y) => string.Compare(x.name, y.name));
                // student2.Sort((x, y) => x.name.CompareTo(y.score));

                // or
                student2.OrderBy( x => x.name); 
                student2.OrderByDescending(x => x.name);

.net xml string to object, object to xml string

Leave a comment

// 1. ———————————————————————-
[XmlRoot(“Person”)]
public class Person
{
[XmlElement(“Name”)]
public string Name { get; set; }

[XmlElement(“LastName”)]
public string LastName { get; set; }

[XmlElement(“Age”)]
public int Age { get; set; }

public string GetSerializedXml()
{
string xmlString = String.Empty;
using (StringWriter outStream = new StringWriter())
{
XmlSerializer s = new XmlSerializer(typeof(Person));
s.Serialize(outStream, this);
xmlString = outStream.ToString();
}
return xmlString;
}
}
// 2. ———————————————————————-

public string xmlString { get; set; }
public static Person p = null;

protected void Button1_Click(object sender, EventArgs e)
{
p = new Person();
p.Name = “my name”;
p.LastName = “my lastname”;
p.Age = 20;
xmlString = p.GetSerializedXml();
}

protected void Button2_Click(object sender, EventArgs e)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
DeserializeFromXML(p.GetSerializedXml(), xmlSerializer);
}

private Person DeserializeFromXML(string xmlString, XmlSerializer xmlSerializer)
{
StringReader stringReader;
stringReader = new StringReader(xmlString);
XmlTextReader xmlReader;
Person fatique = null;
xmlReader = new XmlTextReader(stringReader);
fatique = (Person)xmlSerializer.Deserialize(xmlReader);
xmlReader.Close();
stringReader.Close();
return fatique;
}

Older Entries