이병무 - Brian Lee > Brian Lee - Town > Study Room | 공부방 http://www.bmlee.com/bbs/board.php?bo_table=study 테스트 버전 0.2 (2004-04-26) ko Javascript Function to Check or Uncheck all Checkboxes http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=25 Javascript-x Function to Check or Uncheck all Checkboxes

This Javascript-x function will check or uncheck all the checkboxes in an HTML form.

This function is specially designed for dynamic pages with varying numbers of checkboxes. Unlike other functions out there, it will work without error even if there are no checkboxes or there is only one checkbox. It is also significantly faster for long lists, because it saves the length of the checkbox in a variable, instead of recalculating it in the loop. Finally, the function is granted to the public domain--use it as you wish.

Instructions

Provide the form name and the field name of the checkbox as the parameters to the function. Then specify true or false as the CheckValue, depending on if you want to check or uncheck all the checkboxes, respectively. The function simply returns without doing anything if the checkboxes do not exist, so make sure you enter the correct FormName and FieldName. Remember, unlike HTML, Javascript-x form and field names are case-sensitive!

JavaScript-x Source Code


function SetAllCheckBoxes(FormName, FieldName, CheckValue)
{
	if(!document.forms[FormName])
		return;
	var objCheckBoxes = document.forms[FormName].elements[FieldName];
	if(!objCheckBoxes)
		return;
	var countCheckBoxes = objCheckBoxes.length;
	if(!countCheckBoxes)
		objCheckBoxes.checked = CheckValue;
	else
		// set the check value for all check boxes
		for(var i = 0; i < countCheckBoxes; i++)
			objCheckBoxes[i].checked = CheckValue;
}
]]> 평상심 Thu, 08 Feb 2007 16:47:04 -0700 Permanent Redirect with HTTP 301 http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=24 Permanent Redirect with HTTP 301

This article describes how to properly redirect a web page using an HTTP 301 status code and Location header. The 301 status code is used to indicate that a page has permanently moved. Multiple techniques are presented with recommendations.

In order to redirect an out-of-print web page to another location, return the HTTP 301 status code and a location header in the HTTP response of the deprecated web page. The HTTP 301 response code will tell user-agents that the location has permanently moved. This is particularly useful for search engines like Google, which will carry over page rank to the new page if this status code is seen. If you do not need to indicate permanent displacement, you can accomplish redirection by setting a Location header in PHP or using Response.Redirect in ASP. The location header does the actual redirection to the new location, and can be used by itself.
HTTP headers are sent for every web page. If you want to see what HTTP headers look like for a particular page, visit Rex Swain's HTTP Viewer. For advanced users, I would recommend you download the Firefox web browser and install Chris Pederick's Web Developer Extensions. Then, use the Information->View Response Headers function. In script-xs, HTTP headers must be sent before sending any page content, including white space, or else an error will result.

HTTP 301 Redirect in ASP-VBScript-x

<%@ Language=VBScript-x %>
<%
' Permanent redirection
Response.Status = "301 Moved Permanently"
Response.AddHeader "Location", "http://www.bmlee.com/"
Response.End
%>
In Active Server Pages (ASP), Response.Redirect does not work the same as the code shown in the example. Response.Redirect will set the location header as shown, but it will set the status code to HTTP/1.1 302 Object moved instead. When you set the Location header with Response.AddHeader, the status code must be manually defined, otherwise it stays 200 OK.
If you send any page content prior to the headers, you will get an error like, "Response object error 'ASP 0156 : 80004005'; Header Error; The HTTP headers are already written to the client browser. Any HTTP header modifications must be made before writing page content.". Normally, you do not see this error even if there is content prior to the redirect, because page buffering is enabled by default in IIS. If you want to be sure there is no content being sent before the redirect, call Response.Flush just before it, disable page buffering with Response.Buffer = False, or configure IIS to disable page buffering. (Disabling buffering reduces performance.)

HTTP 301 Redirect in PHP

<?php
// Permanent redirection
header("HTTP/1.1 301 Moved Permanently");
header("Location: http://www.bmlee.com/");
exit();
?>
If you set the Location header by itself, PHP automatically sets the status code to HTTP/1.1 302 Found.
Note, if you attempt to send headers after content has been sent, you will get a warning like, "Warning: Cannot modify header information - headers already sent by ...". Watch out for empty lines and spaces between PHP open and close tags. ASP ignores these, but PHP does not.

HTTP 301 Redirect in ColdFusion

<CFHEADER statuscode="301" statustext="Moved Permanently">
<CFHEADER name="Location" value="http://www.bmlee.com/">
Do not use a CFFLUSH command before the above tags, or in Application.cfm. This Coldfusion code was provided by Toll Free Forwarding.com.

HTTP 301 Redirect in Perl

#!/usr/bin/perl      -w
use strict;
print "Status: 301 Moved Permanantly\n";
print "Location: http://somewhere/page.htm\n\n";
exit;
As in PHP, if you do not supply the 301 code explicitly, Apache will send a "302 Found" status code. Note the subtle difference as compared to PHP. This example prints a "Status" header rather than an HTTP status code line. This is because you can not set the HTTP status code directly as you typically can in PHP. If you do, the server will return a 500 Internal Server Error, and the error log will show: 
malformed header from script-x. Bad header=HTTP/1.1 301 Moved Permanently: /cgi/test.pl
The "Status" header is an alternative way of setting the HTTP status code. This is not passed to the browser directly, but the web server (Apache) converts it into a suitable HTTP status code. (The CGI specification does not allow directly setting the HTTP status code. Perl typically runs as a CGI, whereas PHP does not. For more information, see this PHP header FAQ or the PHP header function documentation.)
You must supply the carraige returns as specified above. Two carriage returns (\n\n) are needed after the last header, since they signify the end of the HTTP header and the beginning of content.
As in PHP, it is good practice to exit the script-x explicitly, otherwise, the Perl script-x continues executing. There should not be any print "Content-type: text/html\n\n"; or other output before printing these headers, or the headers will be printed as part of the content visible in the browser.

Redirection with mod_rewrite

The Apache module, mod_rewrite, is typically used to transform URLs from one form to another. It can also be used for permanent redirection. The rewriting rules can be placed in httpd.conf (for server-wide rules), or in .htaccess files (for directory-specific rules). Consider the following example that is in the .htaccess file of this website: 
rewriteEngine on
rewriteRule ^contact\.php$ http://www.bmlee.com/p2.php [R=permanent,L]
The first line tells Apache to turn the mod_rewrite engine on. The second line tells mod_rewrite to match requests where the URI is exactly contact.php. The ^ and $ match the beginning and end of the expression, respectively, and the \ is used to escape the period, which otherwise would match any character. After the match pattern is a space, and then the substitution. In this case, I want the server to substitute contact.php with http://www.bmlee.com/p2.php.
In brackets are the comma-separated rule flags. The R=permanent flag tells Apache to issue a permanent redirect 301 response, with the location as the substituted URL. The L flag tells mod_rewrite that no other subsequent rules should be processed.
Note that I specified the full destination URL in the substitution, because otherwise mod_rewrite uses the short form of my hostname bmlee.com. To avoid Google indexing issues, I've redirected all non-www traffic to the www prefixed host. I also redirect the default, index pages to the root directory. The rules to achieve this are as follows: 
# redirect all non-www traffic
RewriteCond %{HTTP_HOST} ^bmlee\.com$
RewriteRule ^.*$ http://www.bmlee.com%{REQUEST_URI} [R=permanent,L]

# Redirect aliases of home page to the root website
rewriteRule ^index\.(php|html|htm) http://www.bmlee.com/ [R=permanent,L]
I leave it up to the reader to understand this example by reading the mod_rewrite documentation. The mod_rewrite module offers a very powerful and effective way to perform redirection. It is preferable to use mod_rewrite over a server-side script-x. The drawback is the steep learning curve, requiring you to learn both its syntax and the syntax of regular expressions.

Redirection with Javascript-x or META tags

If you don't have server-side script-xing or mod_rewrite on your web server, you can still do redirection, but not as elegantly. The Javascript-x/META method will redirect after both the headers and the page have loaded. By contrast, the HTTP header method described above redirects immediately after the headers have loaded. While both methods require two requests to the web server, the Javascript-x/META method causes the user's browser to flicker or refresh as the old page is loading. Redirection with HTTP headers is seamless, and saves time.
You can not send a 301 status code via Javascript-x or META tags. Since the HTTP status code of the page will remain 200 OK, most search engines will continue to think the location is valid. Any page rank of the old location will not be transferred to the new location.
Another disadvantage is that some browsers disable Javascript-x or META refresh. Therefore, one must include a link to the destination page in the body of the page. One can also add a delay between when the page is displayed, and when it redirects. However, I would strongly discourage this and will not even describe it here.
Unfortunately, it is very common to see delayed META/Javascript-x refresh used when a site or page has moved. The page typically shows a message saying, "This site has moved to ... Your browser will be automatically forwarded in X seconds. Click here if your browser does not automatically forward you." Some website, particularly government and legal websites, add such an intermediate page whenever you click a link to an external site.
Not only is this search-engine unfriendly, but it has the additional drawback of wasting the visitor's precious time while they read wholly unneccessary information and wait for the redirect. The first rule of web design (and writing) is to treat your reader's time with respect. All visitors except the most novice can tell when they are leaving your site for another, and that your site has no authority over the external site, so there is no need to waste everyone else's time.

Redirection with Javascript-x

<html>
<head>
<script-x type="text/javascript-x">
window.location.href='http://www.bmlee.com/';
</script-x>
</head>
<body>
This page has moved to <a href="http://bmlee.com/">http://bmlee.com/</a>

</body>
</html>
Note that they syntax document.location=''; has been deprecated. Use the above code, or alternately, document.URL='';.

Redirection with META Refresh

<html>
<head>
<meta http-equiv="refresh" content="0;url=http://www.bmlee.com/">
</head>
<body>
This page has moved to <a href="http://bmlee.com/">http://bmlee.com/</a>
</body>
</html>
As I've pointed out, the META refresh tag should be avoided as a method of redirection. There are other times when it is more useful. A common situation is on a page where information is constantly changing, like news or stock tickers. For example, most major news websites include META refresh tags in their home pages. CNN sets the refresh interval to 1800 seconds, while Google sets it to 900 and Yahoo, to 300. If the user switches to another application for awhile, when they return, they are presented with the most up to date information.
Another situation is in the status page for the execution of a long-running server-side task. A good site design principle is that every web page load within a fraction of a second. For longer tasks, queue and run them on the server, and simply show a status page via the web. The three states of the status page would be queued, running, and completed. The refresh tag would be printed in the queued and running states, with an appropriate refresh interval like 15 or 30 seconds. You should always put a link to manually refresh the status page, in case the user disabled this META tag in their browser.

HTTP/1.1 301 Status Code Definition

From the HTTP/1.1 Status Code Definitions section of the Hypertext Transfer Protocol -- HTTP/1.1 RFC 2616, Fielding, et al. See the RFC for all the possible redirection status codes, which include 300-Multiple Choices, 301-Moved Permanently, 302-Found, 303-See Other, 304-Not Modified, 305-Use Proxy, and 307-Temporary Redirect. Using the appropriate status code is worthwhile for public websites, but you can probably leave it unspecified when redirecting in a private or intranet application.
The requested resource has been assigned a new permanent URI and any future references to this resource SHOULD use one of the returned URIs. Clients with link editing capabilities ought to automatically re-link references to the Request-URI to one or more of the new references returned by the server, where possible. This response is cacheable unless indicated otherwise.
The new permanent URI SHOULD be given by the Location field in the response. Unless the request method was HEAD, the entity of the response SHOULD contain a short hypertext note with a hyperlink to the new URI(s).
If the 301 status code is received in response to a request other than GET or HEAD, the user agent MUST NOT automatically redirect the request unless it can be confirmed by the user, since this might change the conditions under which the request was issued.
Note: When automatically redirecting a POST request after receiving a 301 status code, some existing HTTP/1.0 user agents will erroneously change it into a GET request.
]]> 평상심 Thu, 08 Feb 2007 16:38:33 -0700 무조건 알아야 할 PHP 속도 테스트 14 가지 http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=21

PHP로 코딩 함에 있어서 알아야 할 속도 테스트 입니다.
조금더 빠른 PHP 속도를 유지 하기 위한 것이죠 ^^

작은 것이 모여서, 대따 오랜 시간이 걸릴 수 가 있는 것 입니다. !!
되도록이면 속도가 빠른 것을 사용하시는 것이 좋습니다.

물론 함수 마다 기능 마다 장단이 있지만요....^^


다른 비교가 있으면 알려주셍 ^^ 답변 달아 주세용 ^^

계속 적으로 업글 됩니다. 현재 14가지 !!!!


==========================================================================
★ mysql 총 게시물 수 세기

$numresults=mysql_query("select code from $board");
$numrows=mysql_num_rows($numresults);
2초 이상 ...게시물 10만개

VS

$numresults=mysql_query("select count(code) as code from $board");
$row_num=mysql_fetch_array($numresults);
$numrows=$row_num[code];
0.2  ...게시물 10만개

아래것이 훠얼씬 빠름다..
도대체 mysql_num_row() 는 왜 만들어 놓은 것일까용???


==========================================================================
★ mysql_fetch_row  > mysql_fetch_array >>> mysql_result


입니다.

row 가 array 보다 약간 빠르고, result 보다는 훠얼씬 빠름당 ^^

row 는 불편한게 숫자로 칼럼을 불러와서 불편합니다.
array 가 약간 느리지만, 문자 칼럼을 불러 올 수 있으니 array 쓰는 것도 양호 ^^

아직도 mysql_result() 를 사용하시나요?

==========================================================================
★print , echo ,printf 함수 속도 비교
HTML 출력 >> echo > print >> printf


print 와 printf 함수는 복잡한곳에 적격이고, 약간 느리다.

echo 는 단순한곳에 적격이고...빠르다.
printf 는 형식화된 출력을 해주므로 그래도 좋죠 ^^

==========================================================================
★  인라인

 a.php
<?
$aa="sdsdsdsd";
echo ("<table>
 <td> $aa </td>
</table>");
?>

 위 랑..

 b.php
<? $aa="sdsdsdsd"; ?>
<table>
<td><? echo $aa; ?></td>
</table>

 랑 도대체 어케 코딩 하느냐죠 ?

솔직히 코딩은 a.php 가 편합니다.
<? ?> 를 한번 만 쓰니까 효율적일 수 있습니당..

그러나 아무리 아무리 PHP가 빠르다고 해도 HTML 이 더 빠릅니당.. !!!

쿠쿠쿠

b.php 처럼 코딩 하는 습관을 가지세용 ^^

==========================================================================
★ zend cache , APC ,Bware 캐쉬 비교
Zend cache > APC > Bware

zend cache 는 캐쉬 입니다. 울나라에서 포탈에서도 몇군데 사용하죠.
PHP 프로그램 변환 없이 속도를 빠르게 해 줍니다. ^^

zend cache 를 살 돈이 없으시다구용?
그러면 APC 나 zend optimizer 를 반드쉬 설치 하세용 !!

■ 그런디 Zend Cache 만한 무료 캐쉬가 나왔다고 합니당...^^
http://www.php -accelerator.co.uk/index.php ;


==========================================================================
★ ereg_replace , preg_replace 정규표현식
ereg_replace () 가 장난 아니게 느림다.
40개 정도 변환 하는데 1초나 걸려요.preg_replace 는 0.3초 정도요.

되도록이면 preg_replace() 를 사용하세요 !!!

www.php.net/preg_replace


==========================================================================
★ foreach , list 함수 속도 차이 35%

foreach($string as $a);  >>>  while(list(,$a) = each($string));

foreach() 를 사용하는 것이 35% 정도 빠릅니다...!!


==========================================================================
★mysql_connect Vs mysql_pconnect

서로 장단이 있다 합니다.

mysql_pconnect 가 더 빠르다고 합니다.
persistant

메뉴얼에 영구적인 이렇게 되어 있으니까요..
일정시간 동안 mysql 을 열어 놓기 때문에, 다시 열 필요가 없어서 빠르다고 합니다.

단점은 계속 열기 때문에 메모리를 많이 잡아 먹슴당...^^
mysql_pconnect 경우는 최소 메모리가 1G 이상 되어야 사용하시는 것이 좋습니다.

==========================================================================
★ 큰따옴표(") , 작은 따옴표(')

큰따옴표는 PHP가 파싱을 합니다. 그러나 작은 따옴표는 파싱을 하지 않습니다.
작은 따옴표를 사용하시는 것이 빠릅니다.

코딩시 echo ' test '.$aaa.' tood ';
요런식으로 하시는 게 가장 빠름당 !!

==========================================================================
★ mysql 데이터 저장 공간 크기 ?


id int(11) unsigned NOT NULL auto_increment,
  bbs smallint(5) unsigned NOT NULL,
  lens mediumint(8) unsigned NOT NULL,
 

int 도 무자게 많슴당..
각각의 크기에 맞게 하는 것이 속도가 빨라 집니당 ^^

not null 를 주는 것도 속도가 빨라 집니당..

작은 사이트 조회수 경우 1만을 넘기도 힘듭니다. 그럴 경우 smallint 를 사용하시면 됩니다.

==========================================================================
★ where 절에 모든 것은 인덱스를 걸어라 !!!
mysql 에서 쿼리시에 where 절에 사용되는 비교의 칼럼은 반드쉬 인덱스를 거세용 !!!

mysql 인덱스 가 여러 분들의 게시판 속도를 업 시켜 줍니당 !!


==========================================================================
★메인페이지에서 속도를 빠르게 하려면, .htm 으로 만드는 것이 좋습니다.

그러니까..제 사이트 페이지 오른쪽 에는 모두 최신 게시물로 디비를 불러오는 부분
입니다.

디비 연결은 부하를 줄 수 있습니다.

그러니까..이예는 사이트가 상당히 활성화된 사이트일 경우 입니다.

하루에 2번 정도 .htm 으로 만들어 페이지를 업시키는 것이 좋습니다.
아무리 PHP가 빨라도 HTML 보다는 빠르지 않습니다.. !!!

그러기 위해서는 ★cron 를 알아야 합니다 PHP강좌 게시판에서 cron 으로 검색하세용 !!
윈도우 사용자는 멀 쓰는지 잘 모르겠슴당...아시면 답글 부탁  ^^


==========================================================================
★ 초보자 Vs 전문가

www.zend.com 에서 제가 2000년 5월에 퍼온건데용 ^^ 
함 주석을 붙일까 해서용^^


Beginner vs Experienced 
Author:  Boaz Yahav 
Date  23/05/2000 

Beginner : echo "$var"; 
Experienced : echo $var; 


Beginner:echo "<a href=\" http://www.php.net\">PHP</a>";  ;
Experienced : ?><a href=" http://www.php.net">PHP</a><?  ... ?>  ;

◆ "(따옴표) 가 굉장히 중요한것이라는 한 대목이죵 ^^
전 보통의 경우 php 변수 값이 들어갈 경우는 초보자 처럼 쓰구요 ^^ 안들어 갈 경우 는 전문가 처럼 씀다.

Beginner : $a[0]=1; $a[1]=2; $a[2]=3; 
Experienced : $a = array(1,2,3, 1); 
둘다 사용하는 데요. 전문가 쪽이 편함다. ^^

Beginner : if($a>1) { $b=2; } else { $b=3; } 
Experienced : $b = ($a>1) ? 2:3; 
요건 완존히 소스 어렵게 짜는 넘이 최고 라는 소리 같네용 ^^
전문가 쪽것은 C 언어 에서 배웠는데도 역시 전 if 씀다. ^^

Beginner : $result=mysql_query(...); 
Experienced: $result=mysql_query(...) OR die 
        (mysql_error()); 

요즘 들어 새삼 전문가 쪽으로 씀다.^^
보통의 경우

$result=mysql_query(...) 
if (!$result)
{
 echo error()."<P>";
 echo errno();
}
이렇게 사용함다. ^^

or 이 설명이고 no 가 에러 번호 일 검다. ^^

==========================================================================
★MySQL,ADODB,PHPLib,PEAR 벤치마킹 

ADODB > PHPlib > PEAR
 
MySQL    1.14      -
ADODB    1.45    27%
PHPLib    1.60    40%
PEAR    2.87    152% (fetchInto)

MySQL,ADODB,PHPLib,PEAR  는 모두 데이터베이스 인가요? 당근 아닙니다.
MySQL만 데이터베이스 구요.
ADODB,PHPLib,PEAR 는 PHP 프로그램 입니다.

3개 다 MySQL연결을 편하게 하는 클래스 프로그램 입니다.
그런디 벤치 마킹 결과 MySQL 에서 직접 쿼리하는 것 다음으로 ADODB 가 뽑혔슴당 ^^

PEAR 가 굉장히 늦군요. PEAR DB 나 ADODB 를 사용해 보았는데, 움..역시나 ADODB 가 좋군요.
오라클, mysql , ms sql 연결시 1개의 API 만 사용할 수 있는 프로그램 들 이 PEAR 과 ADODB 입니당 ^^
==========================================================================
★ 속도 테스트는 어케 하는가 ? microtime() 사용하면 됩니다.


<?

function pageTime($page) {
 $mstart = explode(" ", $m);
 $mend = explode(" ", microtime());
 $mtime = ($mend[1] - $mstart[1]) + ($mend[0] - $mstart[0]);

 echo " $m[1]  $mend[1]<P>";
 echo " $m[0]  $mend[0]<P>";

 print("tood.net 페이지 로딩 시간 : " . $mtime . " microseconds");
}
pageTime(basename($PHP_SELF));
?>
 
==========================================================================
★

==========================================================================

참고 사이트
http://www.tood.net
http://www.zend.com
http://www.php.net
http://www.php.lt/benchmark/phpbench.php
http://www.phpbuilder.com
http://www.phpbuilder.com/columns/piergiorgio20010321.php3?print_mode=1]]> 평상심 Tue, 30 Jan 2007 09:04:57 -0700 Ajax 마스터하기 http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=20
난이도 : 초급

Brett McLaughlin, Author and Editor, O'Reilly Media Inc.


2006 년 5 월 29 일
2006 년 12 월 12 일 수정

1~8까지 한글 번역되어 있습니다.]]> 평상심 Tue, 30 Jan 2007 08:49:53 -0700 simple database class http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=19 // db connection class class MySql { var $dbHost; // dbHost var $dbUser; // db user var $dbPass; // db password var $dbName; // db name var $dbConn; // db connection var $dbConnErr; // db connection error // constructor function MySql($dbHost, $dbUser, $dbPass, $dbName) { $this->dbHost = $dbHost; $this->dbUser = $dbUser; $this->dbPass = $dbPass; $this->dbName = $dbName; $this->connectToDb(); } // establish db connection function connectToDb() { // make connection to mysql server if (!$this->dbConn = @mysql_connect($this->dbHost, $this->dbUser, $this->dbPass)) { trigger_error("Could not connect to server."); $this->dbConnErr = true; } else if (!@mysql_select_db($this->dbName, $this->dbConn)) { trigger_error("Could not select db."); $this->dbConnErr = true; } } // query function that returns an MySqlResult object function &query($sql) { if (!$queryResource = mysql_query($sql, $this->dbConn)) { trigger_error("Query failed: ".mysql_error($this->dbConn)."
SQL: ".$sql); } return new MySqlResult($this, $queryResource); } // checks db errors function isError() { if ($this->dbConnErr) { return true; } $error = mysql_error($this->dbConn); if (empty($error)) { return false; } else { return true; } } } // query result class class MySqlResult { var $mysql; // instance of db connection var $result; // query result // constructor function MySqlResult(&$mysql, $result) // object $mysql { $this->mysql = &$mysql; $this->result = $result; } // fetches a row from result (without MYSQL_ASSOC) function fetch() { if ($row = mysql_fetch_array($this->result)) { return $row; } else if ($this->numRows() > 0) { mysql_data_seek($this->result, 0); return false; } else { return false; } } // fetches a row from result (with MYSQL_ASSOC) function fetchA() { if ($row = mysql_fetch_array($this->result, MYSQL_ASSOC)) { return $row; } else if ($this->numRows() > 0) { mysql_data_seek($this->result, 0); return false; } else { return false; } } // count rows function numRows() { return mysql_num_rows($this->result); } // get ID of the last row inserted function insertId() { return mysql_insert_id($this->mysql->dbConn); } // get number of affected rows function affectedRows() { return mysql_affected_rows($this->mysql->dbConn); } // checks db errors function isError() { return $this->mysql->isError(); } } ]]> 평상심 Fri, 19 Jan 2007 09:43:10 -0700 MySQL Sub Queries http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=17
If we move on to a more complicated (and arguably more useful) example, we'll start to see the power of subqueries. Let's find out what the highest number of official languages in any country is:

  /* 1 */
  SELECT MAX(tbl.nr) AS nr
  FROM
    (
      /* 2 */
      SELECT countrycode, COUNT(*) AS nr
      FROM CountryLanguage
      WHERE isofficial='T'
      GROUP BY countrycode
    ) AS tbl;

  +---------+
  | MAX(nr) |
  +---------+
  |      4 |
  +---------+
Again, those of you who are MySQL experts might note that the same answer could be found with an ORDER BY and LIMIT. Again, I have to alias the subquery part to something, and I chose AS tbl. Let's do something that couldn't be done easily without subqueries: Let's get the information for those countries with the the highest number of official languages:

  /* 1 */
  SELECT name, population, headofstate, top.nr
  FROM
    Country,
    (
      /* 2 */
      SELECT countrycode, COUNT(*) AS nr
      FROM CountryLanguage
      WHERE isofficial='T'
      GROUP BY countrycode
      HAVING nr=(
        /* 3 */
        SELECT MAX(summary.nr_official_languages)
        FROM
          (
            /* 4 */
            SELECT countrycode, COUNT(*) AS nr_official_languages
            FROM CountryLanguage
            WHERE isofficial='T'
            GROUP BY countrycode
          ) AS summary
        )
    ) as top
  WHERE Country.code=top.countrycode

  +--------------+------------+-------------+----+
  | name        | population | headofstate | nr |
  +--------------+------------+-------------+----+
  | Switzerland  |    7160400 | Adolf Ogi  |  4 |
  | South Africa |  40377000 | Thabo Mbeki |  4 |
  +--------------+------------+-------------+----+
This query is not so simple. It nests four SELECT statements one inside the other, to accomplish a somewhat complex result. I have added comments to the statement of the form /* 1 */ to mark each statement, so that we can break the query down logically. If we look at each of the individual queries, by number, and in reverse order, which I find easiest (and is also the order in which MySQL must solve the query):

4. This SELECT finds all countries and the number of official languages for each. We're interested in what the maximum number is, and there may be more than one with the same maximum. 
3. This SELECT finds the maximum of nr_official_languages from SELECT #4. There isn't an SQL-standard way of getting the countrycode column for the max at the same time, since there may be more than one. 
2. In this SELECT we match up the country codes based on the number of official languages. 
1. Finally, we can JOIN the result against the Country table to find the country information about the matching countries. 

I hope you've learned something, and will do some of your own reading about subqueries. In the next article of the series, we'll discuss Correlation, ANY, and EXISTS.

]]> 평상심 Wed, 15 Nov 2006 10:22:49 -0700 N-Tier(Three-Tier) Computing http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=16 N-Tier Computing (Three-Tier Computing) In computing, Three-tier is a client-server architecture in which the user interface, functional process logic ("business rules"), data storage and data access are developed and maintained as independent modules, most often on separate platforms. The term "three-tier" or "three-layer", as well as the concept of multitier architectures, seems to have originated within Rational Software. The three-tier model is considered to be a software architecture and a software design pattern. Apart from the usual advantages of modular software with well defined interfaces, the three-tier architecture is intended to allow any of the three tiers to be upgraded or replaced independently as requirements or technology change. For example, a change of operating system from Microsoft Windows to Unix would only affect the user interface code. Typically, the user interface runs on a desktop PC or workstation and uses a standard graphical user interface, functional process logic may consist of one or more separate modules running on a workstation or application server, and an RDBMS on a database server or mainframe contains the data storage logic. The middle tier may be multi-tiered itself (in which case the overall architecture is called an "n-tier architecture"). It seems similar, although defined in slightly different terms, to the Model-view-controller concept and the pipes and filters concept. Web services usage In the Web service field, three-tier is used to refer to Websites, often Electronic commerce websites, which are built using three tiers: 1. A front end Web server serving static content 2. A middle dynamic content processing and generation level Application server, for example Java EE platform. 3. A back end Database, comprising both data sets and the Database management system or RDBMS software that manages and provides access to the data. ]]> 평상심 Tue, 02 May 2006 17:08:12 -0700 10 Tips for Writing High-Performance Web Applications http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=15 Performance on the Data Tier When it comes to performance-tuning an application, there is a single litmus test you can use to prioritize work: does the code access the database? If so, how often? Note that the same test could be applied for code that uses Web services or remoting, too, but I'm not covering those in this article. If you have a database request required in a particular code path and you see other areas such as string manipulations that you want to optimize first, stop and perform your litmus test. Unless you have an egregious performance problem, your time would be better utilized trying to optimize the time spent in and connected to the database, the amount of data returned, and how often you make round-trips to and from the database. With that general information established, let's look at ten tips that can help your application perform better. I'll begin with the changes that can make the biggest difference. Tip 1—Return Multiple Resultsets Review your database code to see if you have request paths that go to the database more than once. Each of those round-trips decreases the number of requests per second your application can serve. By returning multiple resultsets in a single database request, you can cut the total time spent communicating with the database. You'll be making your system more scalable, too, as you'll cut down on the work the database server is doing managing requests. While you can return multiple resultsets using dynamic SQL, I prefer to use stored procedures. It's arguable whether business logic should reside in a stored procedure, but I think that if logic in a stored procedure can constrain the data returned (reduce the size of the dataset, time spent on the network, and not having to filter the data in the logic tier), it's a good thing. Using a SqlCommand instance and its ExecuteReader method to populate strongly typed business classes, you can move the resultset pointer forward by calling NextResult. Figure 1 shows a sample conversation populating several ArrayLists with typed classes. Returning only the data you need from the database will additionally decrease memory allocations on your server. Tip 2—Paged Data Access The ASP.NET DataGrid exposes a wonderful capability: data paging support. When paging is enabled in the DataGrid, a fixed number of records is shown at a time. Additionally, paging UI is also shown at the bottom of the DataGrid for navigating through the records. The paging UI allows you to navigate backwards and forwards through displayed data, displaying a fixed number of records at a time. There's one slight wrinkle. Paging with the DataGrid requires all of the data to be bound to the grid. For example, your data layer will need to return all of the data and then the DataGrid will filter all the displayed records based on the current page. If 100,000 records are returned when you're paging through the DataGrid, 99,975 records would be discarded on each request (assuming a page size of 25). As the number of records grows, the performance of the application will suffer as more and more data must be sent on each request. One good approach to writing better paging code is to use stored procedures. Figure 2 shows a sample stored procedure that pages through the Orders table in the Northwind database. In a nutshell, all you're doing here is passing in the page index and the page size. The appropriate resultset is calculated and then returned. In Community Server, we wrote a paging server control to do all the data paging. You'll see that I am using the ideas discussed in Tip 1, returning two resultsets from one stored procedure: the total number of records and the requested data. The total number of records returned can vary depending on the query being executed. For example, a WHERE clause can be used to constrain the data returned. The total number of records to be returned must be known in order to calculate the total pages to be displayed in the paging UI. For example, if there are 1,000,000 total records and a WHERE clause is used that filters this to 1,000 records, the paging logic needs to be aware of the total number of records to properly render the paging UI. Tip 3—Connection Pooling Setting up the TCP connection between your Web application and SQL Server™ can be an expensive operation. Developers at Microsoft have been able to take advantage of connection pooling for some time now, allowing them to reuse connections to the database. Rather than setting up a new TCP connection on each request, a new connection is set up only when one is not available in the connection pool. When the connection is closed, it is returned to the pool where it remains connected to the database, as opposed to completely tearing down that TCP connection. Of course you need to watch out for leaking connections. Always close your connections when you're finished with them. I repeat: no matter what anyone says about garbage collection within the Microsoft? .NET Framework, always call Close or Dispose explicitly on your connection when you are finished with it. Do not trust the common language runtime (CLR) to clean up and close your connection for you at a predetermined time. The CLR will eventually destroy the class and force the connection closed, but you have no guarantee when the garbage collection on the object will actually happen. To use connection pooling optimally, there are a couple of rules to live by. First, open the connection, do the work, and then close the connection. It's okay to open and close the connection multiple times on each request if you have to (optimally you apply Tip 1) rather than keeping the connection open and passing it around through different methods. Second, use the same connection string (and the same thread identity if you're using integrated authentication). If you don't use the same connection string, for example customizing the connection string based on the logged-in user, you won't get the same optimization value provided by connection pooling. And if you use integrated authentication while impersonating a large set of users, your pooling will also be much less effective. The .NET CLR data performance counters can be very useful when attempting to track down any performance issues that are related to connection pooling. Whenever your application is connecting to a resource, such as a database, running in another process, you should optimize by focusing on the time spent connecting to the resource, the time spent sending or retrieving data, and the number of round-trips. Optimizing any kind of process hop in your application is the first place to start to achieve better performance. The application tier contains the logic that connects to your data layer and transforms data into meaningful class instances and business processes. For example, in Community Server, this is where you populate a Forums or Threads collection, and apply business rules such as permissions; most importantly it is where the Caching logic is performed. Tip 4—ASP.NET Cache API One of the very first things you should do before writing a line of application code is architect the application tier to maximize and exploit the ASP.NET Cache feature. If your components are running within an ASP.NET application, you simply need to include a reference to System.Web.dll in your application project. When you need access to the Cache, use the HttpRuntime.Cache property (the same object is also accessible through Page.Cache and HttpContext.Cache). There are several rules for caching data. First, if data can be used more than once it's a good candidate for caching. Second, if data is general rather than specific to a given request or user, it's a great candidate for the cache. If the data is user- or request-specific, but is long lived, it can still be cached, but may not be used as frequently. Third, an often overlooked rule is that sometimes you can cache too much. Generally on an x86 machine, you want to run a process with no higher than 800MB of private bytes in order to reduce the chance of an out-of-memory error. Therefore, caching should be bounded. In other words, you may be able to reuse a result of a computation, but if that computation takes 10 parameters, you might attempt to cache on 10 permutations, which will likely get you into trouble. One of the most common support calls for ASP.NET is out-of-memory errors caused by overcaching, especially of large datasets. Figure 3 ASP.NET Cache There are a several great features of the Cache that you need to know. The first is that the Cache implements a least-recently-used algorithm, allowing ASP.NET to force a Cache purge—automatically removing unused items from the Cache—if memory is running low. Secondly, the Cache supports expiration dependencies that can force invalidation. These include time, key, and file. Time is often used, but with ASP.NET 2.0 a new and more powerful invalidation type is being introduced: database cache invalidation. This refers to the automatic removal of entries in the cache when data in the database changes. For more information on database cache invalidation, see Dino Esposito's Cutting Edge column in the July 2004 issue of MSDN?Magazine. For a look at the architecture of the cache, see Figure 3. Tip 5—Per-Request Caching Earlier in the article, I mentioned that small improvements to frequently traversed code paths can lead to big, overall performance gains. One of my absolute favorites of these is something I've termed per-request caching. Whereas the Cache API is designed to cache data for a long period or until some condition is met, per-request caching simply means caching the data for the duration of the request. A particular code path is accessed frequently on each request but the data only needs to be fetched, applied, modified, or updated once. This sounds fairly theoretical, so let's consider a concrete example. In the Forums application of Community Server, each server control used on a page requires personalization data to determine which skin to use, the style sheet to use, as well as other personalization data. Some of this data can be cached for a long period of time, but some data, such as the skin to use for the controls, is fetched once on each request and reused multiple times during the execution of the request. To accomplish per-request caching, use the ASP.NET HttpContext. An instance of HttpContext is created with every request and is accessible anywhere during that request from the HttpContext.Current property. The HttpContext class has a special Items collection property; objects and data added to this Items collection are cached only for the duration of the request. Just as you can use the Cache to store frequently accessed data, you can use HttpContext.Items to store data that you'll use only on a per-request basis. The logic behind this is simple: data is added to the HttpContext.Items collection when it doesn't exist, and on subsequent lookups the data found in HttpContext.Items is simply returned. Tip 6—Background Processing The path through your code should be as fast as possible, right? There may be times when you find yourself performing expensive tasks on each request or once every n requests. Sending out e-mails or parsing and validation of incoming data are just a few examples. When tearing apart ASP.NET Forums 1.0 and rebuilding what became Community Server, we found that the code path for adding a new post was pretty slow. Each time a post was added, the application first needed to ensure that there were no duplicate posts, then it had to parse the post using a "badword" filter, parse the post for emoticons, tokenize and index the post, add the post to the moderation queue when required, validate attachments, and finally, once posted, send e-mail notifications out to any subscribers. Clearly, that's a lot of work. It turns out that most of the time was spent in the indexing logic and sending e-mails. Indexing a post was a time-consuming operation, and it turned out that the built-in System.Web.Mail functionality would connect to an SMTP server and send the e-mails serially. As the number of subscribers to a particular post or topic area increased, it would take longer and longer to perform the AddPost function. Indexing e-mail didn't need to happen on each request. Ideally, we wanted to batch this work together and index 25 posts at a time or send all the e-mails every five minutes. We decided to use the same code I had used to prototype database cache invalidation for what eventually got baked into Visual Studio? 2005. The Timer class, found in the System.Threading namespace, is a wonderfully useful, but less well-known class in the .NET Framework, at least for Web developers. Once created, the Timer will invoke the specified callback on a thread from the ThreadPool at a configurable interval. This means you can set up code to execute without an incoming request to your ASP.NET application, an ideal situation for background processing. You can do work such as indexing or sending e-mail in this background process too. There are a couple of problems with this technique, though. If your application domain unloads, the timer instance will stop firing its events. In addition, since the CLR has a hard gate on the number of threads per process, you can get into a situation on a heavily loaded server where timers may not have threads to complete on and can be somewhat delayed. ASP.NET tries to minimize the chances of this happening by reserving a certain number of free threads in the process and only using a portion of the total threads for request processing. However, if you have lots of asynchronous work, this can be an issue. There is not enough room to go into the code here, but you can download a digestible sample at www.rob-howard.net. Just grab the slides and demos from the Blackbelt TechEd 2004 presentation. Tip 7—Page Output Caching and Proxy Servers ASP.NET is your presentation layer (or should be); it consists of pages, user controls, server controls (HttpHandlers and HttpModules), and the content that they generate. If you have an ASP.NET page that generates output, whether HTML, XML, images, or any other data, and you run this code on each request and it generates the same output, you have a great candidate for page output caching. By simply adding this line to the top of your page <%@ Page OutputCache VaryByParams="none" Duration="60" %> you can effectively generate the output for this page once and reuse it multiple times for up to 60 seconds, at which point the page will re-execute and the output will once be again added to the ASP.NET Cache. This behavior can also be accomplished using some lower-level programmatic APIs, too. There are several configurable settings for output caching, such as the VaryByParams attribute just described. VaryByParams just happens to be required, but allows you to specify the HTTP GET or HTTP POST parameters to vary the cache entries. For example, default.aspx?Report=1 or default.aspx?Report=2 could be output-cached by simply setting VaryByParam="Report". Additional parameters can be named by specifying a semicolon-separated list. Many people don't realize that when the Output Cache is used, the ASP.NET page also generates a set of HTTP headers that downstream caching servers, such as those used by the Microsoft Internet Security and Acceleration Server or by Akamai. When HTTP Cache headers are set, the documents can be cached on these network resources, and client requests can be satisfied without having to go back to the origin server. Using page output caching, then, does not make your application more efficient, but it can potentially reduce the load on your server as downstream caching technology caches documents. Of course, this can only be anonymous content; once it's downstream, you won't see the requests anymore and can't perform authentication to prevent access to it. Tip 8—Run IIS 6.0 (If Only for Kernel Caching) If you're not running IIS 6.0 (Windows Server™ 2003), you're missing out on some great performance enhancements in the Microsoft Web server. In Tip 7, I talked about output caching. In IIS 5.0, a request comes through IIS and then to ASP.NET. When caching is involved, an HttpModule in ASP.NET receives the request, and returns the contents from the Cache. If you're using IIS 6.0, there is a nice little feature called kernel caching that doesn't require any code changes to ASP.NET. When a request is output-cached by ASP.NET, the IIS kernel cache receives a copy of the cached data. When a request comes from the network driver, a kernel-level driver (no context switch to user mode) receives the request, and if cached, flushes the cached data to the response, and completes execution. This means that when you use kernel-mode caching with IIS and ASP.NET output caching, you'll see unbelievable performance results. At one point during the Visual Studio 2005 development of ASP.NET, I was the program manager responsible for ASP.NET performance. The developers did the magic, but I saw all the reports on a daily basis. The kernel mode caching results were always the most interesting. The common characteristic was network saturation by requests/responses and IIS running at about five percent CPU utilization. It was amazing! There are certainly other reasons for using IIS 6.0, but kernel mode caching is an obvious one. Tip 9—Use Gzip Compression While not necessarily a server performance tip (since you might see CPU utilization go up), using gzip compression can decrease the number of bytes sent by your server. This gives the perception of faster pages and also cuts down on bandwidth usage. Depending on the data sent, how well it can be compressed, and whether the client browsers support it (IIS will only send gzip compressed content to clients that support gzip compression, such as Internet Explorer 6.0 and Firefox), your server can serve more requests per second. In fact, just about any time you can decrease the amount of data returned, you will increase requests per second. The good news is that gzip compression is built into IIS 6.0 and is much better than the gzip compression used in IIS 5.0. Unfortunately, when attempting to turn on gzip compression in IIS 6.0, you may not be able to locate the setting on the properties dialog in IIS. The IIS team built awesome gzip capabilities into the server, but neglected to include an administrative UI for enabling it. To enable gzip compression, you have to spelunk into the innards of the XML configuration settings of IIS 6.0 (which isn't for the faint of heart). By the way, the credit goes to Scott Forsyth of OrcsWeb who helped me figure this out for the www.asp.net severs hosted by OrcsWeb. Rather than include the procedure in this article, just read the article by Brad Wilson at IIS6 Compression. There's also a Knowledge Base article on enabling compression for ASPX, available at Enable ASPX Compression in IIS. It should be noted, however, that dynamic compression and kernel caching are mutually exclusive on IIS 6.0 due to some implementation details. Tip 10—Server Control View State View state is a fancy name for ASP.NET storing some state data in a hidden input field inside the generated page. When the page is posted back to the server, the server can parse, validate, and apply this view state data back to the page's tree of controls. View state is a very powerful capability since it allows state to be persisted with the client and it requires no cookies or server memory to save this state. Many ASP.NET server controls use view state to persist settings made during interactions with elements on the page, for example, saving the current page that is being displayed when paging through data. There are a number of drawbacks to the use of view state, however. First of all, it increases the total payload of the page both when served and when requested. There is also an additional overhead incurred when serializing or deserializing view state data that is posted back to the server. Lastly, view state increases the memory allocations on the server. Several server controls, the most well known of which is the DataGrid, tend to make excessive use of view state, even in cases where it is not needed. The default behavior of the ViewState property is enabled, but if you don't need it, you can turn it off at the control or page level. Within a control, you simply set the EnableViewState property to false, or you can set it globally within the page using this setting: <%@ Page EnableViewState="false" %> If you are not doing postbacks in a page or are always regenerating the controls on a page on each request, you should disable view state at the page level. Conclusion I've offered you some tips that I've found useful for writing high-performance ASP.NET applications. As I mentioned at the beginning of this article, this is more a preliminary guide than the last word on ASP.NET performance. (More information on improving the performance of ASP.NET apps can be found at Improving ASP.NET Performance.) Only through your own experience can you find the best way to solve your unique performance problems. However, during your journey, these tips should provide you with good guidance. In software development, there are very few absolutes; every application is unique.]]> 평상심 Tue, 02 May 2006 17:04:45 -0700 [ASP.NET] Another Server.Tranfer problem http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=14 using System.Threading;]]> 평상심 Sun, 23 Apr 2006 13:53:35 -0700 [ASP.NET] Server.Transfer vs Response.Redirect http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=13
A common misconception is the difference between Server.Transfer and Response.Redirect in ASP.NET applications. Redirect and Transfer both cause a new page to be processed, but the interaction between the client (web browser) and server (ASP.NET) is different in each situation.

Redirect: A redirect is just a suggestion – it’s like saying to the client “Hey, you might want to look at this”. All you tell the client is the new URL to look at, and if they comply, they do a second request for the new URL.

If you want to pass state from the source page to the new page, you have to pass it either on the URL (such as a database key, or message string), or you can store it in the Session object (caveat: there may be more than one browser window, and they’ll all use the same session object).

e.g. Redirect to the new.aspx page, passing an ID on the query string. "true" stops processing the current page:


Response.Redirect("new.aspx?id=34", true);
 



Transfer: A transfer happens without the client knowing – it’s the equivalent of a client requesting one page, but being given another. As far as the client knows, they are still visiting the original URL.

Sharing state between pages is much easier using Server.Transfer – you can put values into the Context.Items dictionary, which is similar to Session and Application, except that it lasts only for the current request. (search for HttpContext in MSDN). The page receiving postback can process data, store values in the Context, and then Transfer to a page that uses the values.

e.g. Store a message in the context dictionary, and transfer to the default.aspx page (which can then display the message):


Context.Items["Message"] = "Your password was changed successfully";
Server.Transfer("default.aspx");
 



Caveats:


Response.Redirect is more user-friendly, as the site visitor can bookmark the page that they are redirected to.
Transferred pages appear to the client as a different url than they really are. This means that things like relative links / image paths may not work if you transfer to a page from a different directory.
Server.Transfer has an optional parameter to pass the form data to the new page.
Since the release version, this no longer works, because the Viewstate now has more security by default (The EnableViewStateMac defaults to true), so the new page isn’t able to access the form data. You can still access the values of the original page in the new page, by requesting the original handler:


Page originalPage = (Page)Context.Handler;

TextBox textBox1 = (TextBox)originalPage.FindControl("textBox1"); ]]> 평상심 Sun, 23 Apr 2006 13:41:31 -0700 [ASP.NET] printing property information http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=12
using System.Reflection; // must have for 'PropertyInfo[]'

public class WebForm1 : System.Web.UI.Page
        {
                private void Page_Load(object sender, System.EventArgs e)
                {
                        WriteProperties(Context);
                        WriteProperties(Response);
                        WriteProperties(Request);
                        WriteProperties(Session);
                        WriteProperties(Server);
                        WriteProperties(Application);
                }

                public void WriteProperties(object intrinsic)
                {
                        Type t = intrinsic.GetType();
                        PropertyInfo[] info = t.GetProperties();
                        Response.Write("<table border=1 style='font-size:12;font-family:tahoma;' cellpadding=0 cellspacing=0>");
                        Response.Write("<tr style='background-color:black;color:white;font-weight:bold;'><td colspan=4>" + t.ToString() + "</td></tr>");
                        Response.Write("<tr style='background-color:black;color:white;font-weight:bold;'><td>Property</td><td>Type</td><td>Get/Set</td><td>Value</td></tr>");

                        for (int i = 0; i < info.Length; i++)
                        {
                                Response.Write("<tr>");
                                Response.Write("<td style='background-color:white'>" + info[i].Name + "</td>");
                                Response.Write("<td style='background-color:white'>" + info[i].PropertyType + "</td>");
                                if(!info[i].CanWrite)
                                {
                                        Response.Write("<td style='background-color:white'>get</td>");
                                }
                                else
                                {
                                        Response.Write("<td style='background-color:white'>get/set</td>");
                                }

                                try
                                {
                                        object obj= info[i].GetValue(intrinsic, BindingFlags.GetProperty, null, null, null);
                                        if (obj == null)
                                        {
                                                Response.Write("<td style='background-color:white'> </td>");
                                        }
                                        else
                                        {
                                                Response.Write("<td style='background-color:white'>" + obj + "</td>");
                                        }
                                }
                                catch
                                {
                                        Response.Write("<td style='background-color:white'>error</td>");
                                }
                                Response.Write("</tr>");
                        }
                        Response.Write("</table>");
                        Response.Write("<p>");
                }
      }]]> 평상심 Mon, 03 Apr 2006 10:23:21 -0700 [Console] Simple Read and Write XML in C# http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=11 using System.IO;
using System.Xml;
using System.Xml.XPath;

namespace xmlConsoleTest
{
        /// <summary>
        /// Summary description for Class1.
        /// </summary>
        class Class1
        {
                /// <summary>
                /// The main entry point for the application.
                /// </summary>
                [STAThread]
                public static void Main()
                {
                        /*
                        // for read and write - use ReadandWrite(..) method
                        XmlTextReader rdr = new XmlTextReader(@"c:testemployees.xml");
                        ReadandWrite(rdr);
                        */

                        /*
                        // just to write
                        XmlTextWriter writer = null;
                        writer = new XmlTextWriter(Console.Out);

                        // for easy reading, take 4 spaces
                        writer.Formatting = Formatting.Indented;
                        writer.Indentation = 4;

                        writer.WriteStartElement("book");

                        writer.WriteStartElement("title");
                        writer.WriteString("About C#");
                        writer.WriteEndElement();

                        writer.WriteStartElement("author");
                        writer.WriteStartElement("name");
                        writer.WriteString("David");
                        writer.WriteEndElement();
                        writer.WriteStartElement("age");
                        writer.WriteString("26");
                        writer.WriteEndElement();
                        writer.WriteEndElement();

                        writer.WriteStartElement("price");
                        writer.WriteString("50.00");
                        writer.WriteEndElement();

                        writer.WriteEndElement();
                        writer.Close();
                        */

                        try
                        {
                                XPathDocument doc = new XPathDocument("c:testemployees.xml");
                                XPathNavigator nav = ((IXPathNavigable)doc).CreateNavigator();
                                XPathNodeIterator iterator = nav.Select("/bookstore/book[2]");

                                while (iterator.MoveNext())
                                {
                                        Console.WriteLine(iterator.Current.Name + ": " + iterator.Current.Value);
                                }
                        }
                        catch (Exception ex)
                        {
                                Console.WriteLine(ex.Message);
                        }
                }

                public static void ReadandWrite(XmlReader rdr)
                {
                        while (rdr.Read())
                        {
                                switch (rdr.NodeType)
                                {
                                        case XmlNodeType.Element:
                                                Console.Write("<" + rdr.Name);
                                                while (rdr.MoveToNextAttribute())
                                                {
                                                        Console.Write(" " + rdr.Name + "='" + rdr.Value + "'");
                                                }
                                                Console.Write(">");

                                                if(rdr.IsEmptyElement == true)
                                                {
                                                        Console.Write("#empty element");
                                                }
                                                else
                                                {
                                                        Console.Write("#begin element");
                                                }
                                                break;
                                        case XmlNodeType.Text:
                                                Console.Write(rdr.Value);
                                                Console.Write("#Text");
                                                break;
                                        case XmlNodeType.CDATA:
                                                Console.Write(rdr.Value);
                                                break;
                                        case XmlNodeType.ProcessingInstruction:
                                                Console.WriteLine("<?" + rdr.Name + " " + rdr.Value + "?>");
                                                break;
                                        case XmlNodeType.Comment:
                                                Console.Write("<!--" + rdr.Value + "-->");
                                                break;
                                        case XmlNodeType.Document:
                                                Console.Write("<?xml version='1.0'?>");
                                                break;
                                        case XmlNodeType.Whitespace:
                                                Console.Write(rdr.Value);
                                                break;
                                        case XmlNodeType.EndElement:
                                                Console.Write("</" + rdr.Name + ">");
                                                Console.Write("#End Element");
                                                break;
                                }
                        }
                }
        }
}]]> 평상심 Mon, 03 Apr 2006 10:19:45 -0700 [General] Abstract Class in C# http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=10 평상심 Mon, 03 Apr 2006 07:46:18 -0700 [General] Use of Garbage Collector http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=9 System.GC.Collect();
System.GC.WaitForPendingFinalizers();
위의 두가지를 함께 실행시킨다.


class Class1
{
        static void Main(string[] args)
        {
                SourceFile src = new SourceFile();

                src = null;

                System.GC.Collect();
                System.GC.WaitForPendingFinalizers();

                Console.WriteLine("hello");
        }
}

public class SourceFile
{
        ~SourceFile()
        {
                Console.WriteLine("destructor");
        }
}

Output with GC forced :
destructor
hello

Output without GC forced :
hello
destructor]]> 평상심 Tue, 14 Mar 2006 07:40:49 -0700 [General] Class and Struct in C# http://www.bmlee.com/bbs/board.php?bo_table=study&wr_id=8 1. value type (reference type)
2. can't initialize value (able to initialize value)
3. no default constructor (default constructor)
4. and yet, constructor is needed in Struct, use overloading

    struct StructData
    {
        public int a;
        public int b;
        public StructData(int a, int b)
        {
            this.a = a;
            this.b = b;
        }
    }
    StructData sd = new StructData(2, 3);


- In Class, if you want creating object is to be blocked, use private constructor.
Public Math
{
    Public static double Cos(double x){...}
    Private Math() {...}
}


- Main() 보다 Static Constructor가 먼저 실행됨.
그중에서도 static variable -> static constructor]]> 평상심 Sun, 12 Mar 2006 08:15:38 -0700