Category Archives: C# Programming

PersonListXMLWriter

PersonListXMLWriter – Person 클래스에 XML Serialization을 사용하는 대신
XmlDocument 클래스를 사용하여 xml file 열기와 저장하기9520712777.zip
    class PersonListManager
    {
        private List<Person> pList = null;
        public string FileName
        {
            get;
            set;
        }

        public PersonListManager(ref List<Person> pList)
        {
            this.pList = pList;
        }

        public void Load()
        {
            if (pList == null) return;

            if (File.Exists(FileName))
            {
                pList.Clear();

                // create filestream and xmlDoc loading
                FileStream stream = File.Open(FileName, FileMode.OpenOrCreate, FileAccess.Read);
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.Load(stream);

                XmlNode nodePersonList;
                nodePersonList = xmlDoc.FirstChild;
                foreach (XmlNode nodePerson in nodePersonList)
                {
                    Person p = new Person();
                    p.Name = nodePerson.FirstChild.InnerText;
                    p.ID = Int32.Parse(nodePerson.FirstChild.NextSibling.InnerText);
                    p.Phone = nodePerson.FirstChild.NextSibling.NextSibling.InnerText;
                    p.Address = nodePerson.LastChild.InnerText;
                    pList.Add(p);
                }
                stream.Close();

                pList.Sort(Person.IDComparison);
            }
        }

        public void Save()
        {
            if (pList == null) return;

            File.Delete(FileName); // delete the saved file
            FileStream stream = File.Open(FileName, FileMode.OpenOrCreate);

            // xmlDoc writing
            XmlDocument xmlDoc = new XmlDocument();
            XmlNode nodePersonList = xmlDoc.CreateNode(“element”, “PersonList”, “”);
            foreach (Person p in pList)
            {
                XmlNode nodePerson = xmlDoc.CreateNode(“element”, “Person”, “”);

                XmlNode nodeName = xmlDoc.CreateNode(“element”, “Name”, “”);
                nodeName.InnerText = Convert.ToString(p.Name);
                XmlNode nodeID = xmlDoc.CreateNode(“element”, “ID”, “”);
                nodeID.InnerText = Convert.ToString(p.ID);
                XmlNode nodePhone = xmlDoc.CreateNode(“element”, “Phone”, “”);
                nodePhone.InnerText = Convert.ToString(p.Phone);
                XmlNode nodeAddress = xmlDoc.CreateNode(“element”, “Address”, “”);
                nodeAddress.InnerText = Convert.ToString(p.Address);

                nodePerson.AppendChild(nodeName);
                nodePerson.AppendChild(nodeID);
                nodePerson.AppendChild(nodePhone);
                nodePerson.AppendChild(nodeAddress);

                nodePersonList.AppendChild(nodePerson);
            }
            xmlDoc.AppendChild(nodePersonList);

            xmlDoc.Save(stream);
            stream.Close();
        }

        public void Add(Person p)
        {
            pList.Add(p);
            pList.Sort(Person.IDComparison);
            Save();
        }
    }

    public class Person : IComparable<Person>, IEquatable<Person>
    {
        // member field
        protected string name;
        protected int id;
        protected string phone;
        protected string address;

        // delegate
        public static Comparison<Person> NameComparison = delegate(Person p, Person q)
        {
            return p.Name.CompareTo(q.Name);
        };

        public static Comparison<Person> IDComparison = delegate(Person p, Person q)
        {
            return p.ID.CompareTo(q.ID);
        };

        public static Comparison<Person> PhoneComparison = delegate(Person p, Person q)
        {
            return p.Phone.CompareTo(q.Phone);
        };

        public static Comparison<Person> AddressComparison = delegate(Person p, Person q)
        {
            return p.Address.CompareTo(q.Address);
        };

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

        public int ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }

        public string Phone
        {
            get
            {
                return phone;
            }
            set
            {
                phone = value;
            }
        }

        public string Address
        {
            get
            {
                return address;
            }
            set
            {
                address = value;
            }
        }

        // constructor
        public Person() : this(“”, 0, “”, “”)
        {
        }

        public Person(string name, int id, string phone, string address)
        {
            this.name = name;
            this.id = id;
            this.phone = phone;
            this.address = address;
        }

        public Person(Person p)
        {
            this.name = p.name;
            this.id = p.id;
            this.phone = p.phone;
            this.address = p.address;
        }

        // method
        public virtual void Print()
        {
            Console.WriteLine(“이름: {0} ID: {1} 전화번호: {2} 주소: {3}”, this.name, this.id, this.phone, this.address);
        }

        // needed for sort
        #region IComparable<Person> Members
        public int CompareTo(Person other)
        {
            return Name.CompareTo(other.Name);
        }
        #endregion

        // needed for search
        #region IEquatable<Person> Members
        public bool Equals(Person other)
        {
            return Name.Equals(other.Name) && ID.Equals(other.ID) && Phone.Equals(other.Phone) && Address.Equals(other.Address);
        }
        #endregion

        // System.Object.ToString method override
        public override string ToString()
        {
            return string.Format(“{0},{1},{2},{3}”, Name, ID, Phone, Address); // csv file format으로 출력
        }

        // needed for ListView
        #region ListViewItem
        public ListViewItem ToListViewItem()
        {
            ListViewItem item = new ListViewItem(this.name);
            item.SubItems.Add(new ListViewItem.ListViewSubItem(item, this.id.ToString()));
            item.SubItems.Add(new ListViewItem.ListViewSubItem(item, this.phone));
            item.SubItems.Add(new ListViewItem.ListViewSubItem(item, this.address));
            return item;
        }
        #endregion
    }

<?xml version=”1.0″?>
-<PersonList>
   -<Person> 
       <Name>
Park </Name>
       <ID>
1207</ID>        
       <Phone>
010-</Phone>        
       <Address>
단국대학교</Address>
    </Person>
    -<Person>  
       <Name>박똑똑</Name>  
       <ID>5205</ID>

      <Phone>10</Phone>  
       <Address>단국대</Address>
    </Person>
     -<Person>  
        <Name>아무개</Name>  
        <ID>1202</ID>  
        <Phone>041-550-3418</Phone>
         <Address>충남 천안시</Address>
     </Person>
   -<Person>  
       <Name>홍군</Name>  
       <ID>1204</ID>
      
<Phone> 041-550-3490</Phone>
       <Address>충남 천안시</Address>
    </Person>
    -<Person>
       <Name>김씨</Name>
       <ID>5204</ID>
       <Phone>11</Phone>
       <Address>단국대</Address>
    </Person>
</PersonList>

XMLElement & Attribute

    public class Phone
    {
        [XmlAttribute(AttributeName = “WorkPhone”)]
        public string WorkPhone
        {
            get;
            set;
        }

        [XmlAttribute(AttributeName = “HomePhone”)]
        public string HomePhone
        {
            get;
            set;
        }

        [XmlAttribute(AttributeName = “CellPhone”)]
        public string CellPhone
        {
            get;
            set;
        }
    }

    [XmlRoot(“Person”)]
    public class Person : IComparable<Person>, IEquatable<Person>
    {
        [XmlElement(ElementName=”Name”, Order=1)]
        public string Name
        {
            get;
            set;
        }

        [XmlElement(ElementName=”ID”, DataType=”int”, Order=2)]
        public int ID
        {
            get;
            set;
        }

        [XmlElement(ElementName=”Phone”, Order=3)]
        public Phone Phone = new Phone();

        [XmlElement(ElementName=”Address”, Order=4)]
        public string Address
        {
            get;
            set;
        }

        public Person() : this(“”, 0, “”, “”, “”,””)
        {
        }

        // 중간생략
}




<?xml version=”1.0″ ?>


<ArrayOfPerson xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance xmlns:xsd=”http://www.w3.org/2001/XMLSchema>



<Person>



       <Name>Park Kyoung Shin</Name>


       <ID>1207</ID>
<Phone WorkPhone=”041-550 HomePhone=”02-379 CellPhone=”010 />




    <Address>서울시</Address>

</Person>


  <Person>



    <Name>박똑똑</Name>


    <ID>5205</ID>


    <Phone WorkPhone=”10 HomePhone=”10 CellPhone=”10 />


    <Address>단국대</Address>

</Person>


<Person>



    <Name>아무개</Name>


    <ID>1202</ID>


      <Phone WorkPhone=”11 HomePhone=”11 CellPhone=”11 /> 
<Address>충남 천안시</Address> 
 </Person>


</ArrayOfPerson>

XMLElement & Attribute

    public class Phone
    {
        [XmlElement(ElementName = “WorkPhone”)]
        public string WorkPhone
        {
            get;
            set;
        }

        [XmlElement(ElementName = “HomePhone”)]
        public string HomePhone
        {
            get;
            set;
        }

        [XmlElement(ElementName = “CellPhone”)]
        public string CellPhone
        {
            get;
            set;
        }
    }

    [XmlRoot(“Person”)]
    public class Person : IComparable<Person>, IEquatable<Person>
    {
        [XmlElement(ElementName=”Name”, Order=1)]
        public string Name
        {
            get;
            set;
        }

        [XmlElement(ElementName=”ID”, DataType=”int”, Order=2)]
        public int ID
        {
            get;
            set;
        }

        [XmlElement(ElementName=”Phone”, Order=3)]
        public Phone Phone = new Phone();

        [XmlElement(ElementName=”Address”, Order=4)]
        public string Address
        {
            get;
            set;
        }

        public Person() : this(“”, 0, “”, “”, “”,””)
        {
        }

        // 중간생략
}




<?xml version=”1.0″ ?>


<ArrayOfPerson xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance xmlns:xsd=”http://www.w3.org/2001/XMLSchema>



<Person>



    <Name>Park Kyoung Shin</Name>


    <ID>1207</ID>


   <Phone>



     <WorkPhone>041-550</WorkPhone>


     <HomePhone>02-379</HomePhone>


     <CellPhone>010</CellPhone>

 </Phone>


   <Address>서울시</Address>

</Person>


  <Person>



    <Name>박똑똑</Name>


    <ID>5205</ID>


   <Phone>



      <WorkPhone>10</WorkPhone>


      <HomePhone>10</HomePhone>


      <CellPhone>10</CellPhone>

 </Phone>


    <Address>단국대</Address>

</Person>


<Person>



  <Name>아무개</Name>


  <ID>1202</ID>


<Phone>



  <WorkPhone>041-550-3418</WorkPhone>


  <HomePhone>11</HomePhone>


  <CellPhone>11</CellPhone>

  </Phone>


    <Address>단국대</Address>

</Person>


</ArrayOfPerson>

XMLElement

    public class Person : IComparable<Person>, IEquatable<Person>
    {
        [XmlElement(“Name”)]
        public string Name
        {
            get;
            set;
        }


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


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


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


        public Person() : this(“”, 0, “”, “”)
        {
        }


        public Person(string name, int id, string phone, string address)
        {
            this.Name = name;
            this.ID = id;
            this.Phone = phone;
            this.Address = address;
        }


        public Person(Person p)
        {
            this.Name = p.Name;
            this.ID = p.ID;
            this.Phone = p.Phone;
            this.Address = p.Address;
        }


        public virtual void Print()
        {
            Console.WriteLine(“이름: {0} ID: {1} 전화번호: {2} 주소: {3}”, this.Name, this.ID, this.Phone, this.Address);
        }


        // System.Object.ToString method override
        public override string ToString()
        {
            // csv file format으로 출력
            return string.Format(“{0},{1},{2},{3}”, Name, ID, Phone, Address);
        }

        // 중간생략…
}


<?xml version=”1.0″?>
<ArrayOfPerson xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance
xmlns:xsd=”http://www.w3.org/2001/XMLSchema“>
  <Person>
   <Name>Park </Name>
    <ID>
1207</ID>
    <Phone>
010-</Phone>
    <Address>
단국대학교</Address>
  </Person>
  <Person>
    <Name>박똑똑</Name>
    <ID>5205</ID>
    <Phone>10</Phone>
    <Address>단국대</Address>
  </Person>
  <Person>
    <Name>아무개</Name>
    <ID>1202</ID>
    <Phone>041-550-3418</Phone>
    <Address>충남 천안시</Address>
  </Person>
 <Person>
    <Name>홍군</Name>
    <ID>1204</ID>
    <Phone> 041-550-3490</Phone>
    <Address>충남 천안시</Address>
  </Person>
  <Person>
    <Name>김씨</Name>
    <ID>5204</ID>
    <Phone>11</Phone>
    <Address>단국대</Address>
  </Person>
</ArrayOfPerson>

XMLAttribute

    public class Person : IComparable<Person>, IEquatable<Person>
    {
        [XmlAttribute(AttributeName=”Name”)]
        public string Name
        {
            get;
            set;
        }


        [XmlAttribute(AttributeName = “ID”)]
        public int ID
        {
            get;
            set;
        }


        [XmlAttribute(AttributeName = “Phone”)]
        public string Phone
        {
            get;
            set;
        }


        [XmlAttribute(AttributeName = “Address”)]
        public string Address
        {
            get;
            set;
        }


        public Person() : this(“”, 0, “”, “”)
        {
        }


        public Person(string name, int id, string phone, string address)
        {
            this.Name = name;
            this.ID = id;
            this.Phone = phone;
            this.Address = address;
        }


        public Person(Person p)
        {
            this.Name = p.Name;
            this.ID = p.ID;
            this.Phone = p.Phone;
            this.Address = p.Address;
        }


        public virtual void Print()
        {
            Console.WriteLine(“이름: {0} ID: {1} 전화번호: {2} 주소: {3}”, this.Name, this.ID, this.Phone, this.Address);
        }


        // System.Object.ToString method override
        public override string ToString()
        {
            // csv file format으로 출력
            return string.Format(“{0},{1},{2},{3}”, Name, ID, Phone, Address);        
        }
        // 중간생략..
}


<?xml version=”1.0″?>
<ArrayOfPerson xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance
xmlns:xsd=”http://www.w3.org/2001/XMLSchema“>
  <Person Name=”Park” ID=”1207Phone=”010Address=”단국대” />
  <Person Name=”박똑똑” ID=”5205Phone=”10″ Address=”단국대” />
  <Person Name=”아무개” ID=”1202” Phone=” 041-550-3418” Address=”충남 천안시” />
  <Person Name=”홍군” ID=”1204” Phone=” 041-550-3490” Address=”충남 천안시” />
  <Person Name=”김씨” ID=”5204” Phone=”11” Address=”단국대” />
</ArrayOfPerson>

C# Collection, Interface, Delegate

1. Collection
서로 밀접하게 관련된 데이터를 그룹화하여 좀 더 효율적으로 처리할 수 있게 한 특수한 클래스 혹은 구조체이다.


2. Collection과 Interface
모든 닷넷 컬렉션은 ICollection<T> 인터페이스는 구현한다.
IList<T> 인터페이스는 인덱스를 사용하여 요소에 개별적으로 접근할 수 있는 컬렉션을 정의한다.
-T this [int index] { get; set; } //지정한 인덱스에 있는 요소를 가져오거나 설정
-int IndexOf(T item)              //IList에서 특정 항목의 인덱스를 확인
-void Insert(int index, T item)   //항목을 IList의 지정한 인덱스에 삽입
-void RemoveAt(int index)         //지정한 인덱스에서 IList 항목을 제거


3. Collection과 Method와 Delegate
// Person 클래스
public class Person
{
     private readonly string _name;


     public string Name
     {
         get { return _name; }
     }


     private readonly int _age;


     public int Age
     {
         get { return _age; }
     }


     public Person(string name, int age)
     {
         _name = name;
         _age = age;
     }


     public override string ToString()
     {
         return string.Format(“이름 : {0}\t나이 : {1}”, _name, _age);
     }
}


// List<T> 컬렉션에 Person 객체를 담는다
private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));
}


// aList에 포함된 세 사람이 모두 10세 이상인지를 확인한다 => 둘리와 고길동만 만족함
private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));


     bool result = true;
     foreach (Person p in aList)
     {
         if (p.Age < 10)
         {
             result = false;
             break;
         }
     }
}


// aList에 포함된 세 사람이 모두 이름이 두 글자인지를 확인한다 => 둘리만 만족함
private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));


     bool result = true;
     foreach (Person p in aList)
     {
         if (p.Name.Length != 2)
         {
             result = false;
             break;
         }
     }
}


// 위의 두 코드가 나이가 10세이상인지 또는 이름이 두 글자인지 조건을 만족하는지를 확인하는 부분이 반복
// List<T> 컬렉션의 TrueForAll 메소드는 조건을 만족하는 메소드가 존재한다면 true반환
public delegate bool Predicate<T>(T item);


public class List<T> : …
{
     …


    public bool TrueForAll(Predicate<T> match)
    {
        bool result = true;
        foreach (T item in this)
        {
            if (match(item) == false)
            {
                result = false;
                break;
            }
        }
    }
}


private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));


    // 10살 이상인지를 검사
    bool result1 = aList.TrueForAll(IsGreaterThanTen);


    // 무명 대리자를 사용하여 이름이 두 글자인지 검사
    bool result2 = aList.TrueForAll(delegate(Person p)
                                    { return p.Name.Length == 2; });
}


private static bool IsGreaterThanTen(Person p)
{
    return p.Age >= 10;
}

4. List<T> 컬랙션 클래스의 메소드와 헬퍼 대리자


public List<TOutput> ConvertAll<TOutput> (Converter<T, TOutput> converter)
-리스트 객체의 각 원소를 TOutput 형으로 변환하여 리스트로 반환


public bool Exists(Predicate<T> match)
-리스트에 있는 모든 원소 중 match 조건을 만족하는 원소가 있는지 여부를 반환


public T Find(Predicate<T> match)
-리스트에 있는 모든 원소 중 match 조건을 만족하는 첫번째 원소를 반환


public List<T> FindAll(Predicate<T> match)
-리스트에 있는 모든 원소 중 match 조건을 만족하는 모든 원소를 리스트로 반환


public int FindIndex(Predicate<T> match)
-리스트에 있는 모든 원소 중 match 조건을 만족하는 첫번째 원소의 인덱스를 반환


public int FindLastIndex(Predicate<T> match)
-리스트에 있는 모든 원소 중 match 조건을 만족하는 마지막 원소의 인덱스를 반환


public void ForEach(Action<T> action)
-리스트에 있는 모든 원소에 대해 action을 수행


public bool TrueForAll(Predicate<T> match)
-리스트에 있는 모든 원소가 match 조건을 만족하는 지 여부를 반환


<<대리자(Delegate)>>


public delegate void Action<T>(T object)
-T 형의 매개변수를 하나 받고 반환값이 없는 메소드


public delegate TOutput Converter<TInput, TOutput>(TInput input)
-TInput 형의 매개변수를 받고 이를 TOutput 형으로 변환하여 반환하는 메소드


public delegate bool Predicate<T>(T object)
-T 형의 매개변수를 받아 그것이 특정 조건을 만족하는지를 반환하는 메소드


public delegate int Comparison<T>(T x, T y)
-x, y 두 객체를 비교하는 메소드로 x가 y보다 작으면 음수, 같으면 0, 크면 양수를 반환하는 메소드


5. List<T>의 Sort 메소드
public void Sort()
public void Sort(Comparison<T> comparison)
public void Sort(IComparer<T> comparer)
public void Sort(int index, int count, IComparer<T> comparer)


-public void Sort()
즉, 매개변수가 없는 Sort 메서드(void Sort())는 List<T>의 원소인 객체와 계약을 맺었는데,
그 계약의 내용은 List<T>의 원소인 객체는 int CompareTo(T other)와 같은 메서드를 가지고 있다는 것입니다.
따라서 실제 List<T>의 원소의 객체가 무엇이든지 간에 Sort 메서드는 그 객체의 CompareTo 메서드를 호출하면 정렬을 수행할 수 있다.
List<T>의 원소인 객체는 int CompareTo(T other)를 구현하여야 한다.
즉, Person이 int CompareTo(Person other) 메소드에 이름 순으로 구현하여야 계약이 성립한다.


public class Person : IComparable<Person>
{
    ….

     // Sort
     public int CompareTo(Person other)
    {
        return this.Name.CompareTo(other.Name);
    }
}


private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));


    // 이름순으로 정렬
    aList.Sort();
}

-public void Sort(Comparison<T> comparison)
이번에는 이름이 아니라 나이 순으로 정렬을 하는 경우,
int CompareTo(Person other) 내부 구현을 이름이 아니라 나이를 기준으로 정렬하도록 수정한다.
이 경우 동적으로 Sort를 다르게 할수없는 문제가 있으므로,
List<T>의 원소를 비교 가능한 객체라고 전제 하는 것이 아니라,
Sort 메서드의 매개 변수로 아예 List<T>의 원소들을 비교하는 메서드를 전달하는 것입니다.

public delegate int Comparison<T>(T x, T y)
Comparison 대리자의 의미는 x가 y보다 작으면 음수, 같으면 0, 크면 양수를 반환한다는 것이다.

public static int ComparePersonByName(Person x, Person y)
{
    return x.Name.CompareTo(y.Name);
}

public static int ComparePersonByAge(Person x, Person y)
{
    return x.Age.CompareTo(y.Age);
}


private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));


    // 이름순으로 정렬
    aList.Sort(ComparePersonByName);
    // 나이순으로 정렬
    aList.Sort(ComparePersonByAge);
}

-public void Sort(IComparer<T> comparer)
Sort가 IComparer<T> 인터페이스를 매개변수로 받아 처리할 수 있다.
int Compare(T x, T y)

public class PersonNameComparer : IComparer<Person>
{
    public int Compare(Person x, Person y)
    {
        return x.Name.CompareTo(y.Name);
    }
}


public class PersonAgeComparer : IComparer<Person>
{
    public int Compare(Person x, Person y)
    {
        return x.Age.CompareTo(y.Age);
    }
}


private static void Main(string[] args)
{
    List<Person> aList = new List<Person>();
    aList.Add(new Person(“둘리”, 1000));
    aList.Add(new Person(“희동이”, 3));
    aList.Add(new Person(“고길동”, 40));


    // 이름순으로 정렬
    aList.Sort(new PersonNameComparer());
    // 나이순으로 정렬
    aList.Sort(new PersonAgeComparer());


    foreach(Person p in aList)
        Console.WriteLine(p); // Person의 ToString 호출
}

C# Serialization

Person Serialization (Using BinaryFormatter or SoapFormatter)
http://dis.dankook.ac.kr/lectures/hci09/entry/Simple-Serialization

Person XML Serialization (Using XML Serializer or Soap XML Serializer)
http://dis.dankook.ac.kr/lectures/hci09/entry/XML-Serialization

Person Using ISerialable Interface
http://dis.dankook.ac.kr/lectures/hci09/entry/ISerialable

PersonList Serialization (Using BinaryFormatter or SoapFormatter)
http://dis.dankook.ac.kr/lectures/hci09/entry/PersonList-Serialization

Draw Shapes to Bitmap in Memory

도형그리기를 비트맵이미지로 그리기1273706404.zip
private void Form1_Paint(object sender, PaintEventArgs e)
{
            Graphics g = e.Graphics;


            // Create a Bitmap image in memory and set its CompositingMode
            Bitmap bmp = new Bitmap(this.Size.Width, this.Size.Height,
                                                              PixelFormat.Format32bppArgb);
            Graphics gBmp = Graphics.FromImage(bmp);
            gBmp.CompositingMode = CompositingMode.SourceCopy;


            // Pen으로 대각선과 사각형 그리기 (to bitmap in memory)
            Pen p = new Pen(Color.Black, 3);
            Rectangle r = new Rectangle(10, 10, this.Size.Width/2, this.Size.Height/2);
            gBmp.DrawLine(p, 10, 10, this.Size.Width / 2 + 10, this.Size.Height / 2 + 10);
            gBmp.DrawLine(p, this.Size.Width / 2 + 10, 10, 10, this.Size.Height / 2 + 10);
            gBmp.DrawRectangle(p, r);


            // Brush로 파란사각형 그리기 (to bitmap in memory)
            Brush b = new SolidBrush(Color.Blue);
            Rectangle r2 = new Rectangle(this.Size.Width / 2 + 10, this.Size.Height / 2 + 10,
                                                                    this.Size.Width / 2 – 10, this.Size.Height / 2 – 10);
            gBmp.FillRectangle(b, r2);


            // Brush로 빨간삼각형 그리기 (to bitmap in memory)
            Brush b2 = new SolidBrush(Color.Red);
            Point[] pt = new Point[3];
            pt[0].X = 400; pt[0].Y = 10;
            pt[1].X = 300; pt[1].Y = 210;
            pt[2].X = 500; pt[2].Y = 210;
            gBmp.FillPolygon(b2, pt);


            // HatchBrush로 타원 그리기 (to bitmap in memory)
            HatchBrush hb = new HatchBrush(HatchStyle.DiagonalCross,
                                                                           Color.Yellow, Color.Brown);
            gBmp.FillEllipse(hb, 10, 220, 200, 100);


            // DrawArc 메소드 사용하여 호 그리기 (to bitmap in memory)
            Pen p2 = new Pen(Color.Green, 3);
            Rectangle r3 = new Rectangle(220, 220, 200, 100);
            gBmp.DrawArc(p2, r3, 0, 180);


            // draw the bitmap on our window
            g.DrawImage(bmp, 0, 0, bmp.Width, bmp.Height);
            bmp.Dispose();
            gBmp.Dispose();
    }